home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.3 Development Libraries / SGI IRIX 6.3 Development Libraries.iso / dist6.3 / gl_dev.idb / usr / share / src / OpenGL / teach / pixel / convolve.c.z / convolve.c
Encoding:
C/C++ Source or Header  |  1996-12-06  |  47.1 KB  |  1,827 lines
  1. #include <GL/glx.h>
  2. #include <GL/gl.h>
  3.  
  4. #include <gl/image.h>
  5.  
  6. #include <stdio.h>
  7.  
  8. #include <Xm/MainW.h>
  9. #include <Xm/Form.h>
  10. #include <Xm/Frame.h>
  11. #include <Xm/Label.h>
  12. #include <Xm/ToggleB.h>
  13. #include <Xm/PushB.h>
  14. #include <Xm/RowColumn.h>
  15. #include <Xm/Scale.h>
  16. #include <Xm/FileSB.h>
  17. #include <Xm/SelectioB.h>
  18. #include <Xm/MessageB.h>
  19.  
  20. #include <GL/GLwMDrawA.h>
  21.  
  22.  
  23. #include <math.h>
  24.  
  25. /* size of squares in test image */
  26. #define GRID 16
  27.  
  28. /* To compile: cc -o convolve convolve.c -lGL -lX11 -limage */
  29.  
  30. /* Motif Stuff */
  31.  
  32. static String fallbackResources[] = {
  33.     "*sgiMode: true",
  34.     "*useSchemes: all",
  35.     "*title: Convolution Demo Program",
  36.     "*glxarea*width: 256",
  37.     "*glxarea*height: 256",
  38.     NULL
  39. };
  40.  
  41. XtWorkProcId workId = 0;
  42. Widget       toplevel, mainw, frame, glxarea, form;
  43. Widget       control, fwidth, fheight;
  44. Widget       actions, load, readit, copy, draw, makeconv2d, makesep2d, texmap;
  45. Widget       makeconv1d;
  46. Widget       enables, enable1d, enable2d, enableSep2d;
  47. Widget       enabletex1d, enabletex2d;
  48. Widget       filter_format, filter_type, filter_contents, filters;
  49. Widget       image_format, image_type, image_contents;
  50. Widget       pzoom, xzoom, yzoom;
  51. Widget       getconv1dfilter, getconv2dfilter, getsepfilter;
  52. Widget       copyfilter1d, copyfilter2d;
  53. Widget       newlist, endlist, calllist;
  54. Arg          args[1];
  55.  
  56.  
  57. /*
  58. ** Generate a pop-up if an OpenGL error is detected. Keep popping up until
  59. ** all errors are shown.
  60. */
  61. void check_error(char *string)
  62. {
  63.     Widget glerror;
  64.     char message_string[1000];
  65.     XmString error_message;
  66.     GLenum error;
  67.     while((error = glGetError()) != GL_NO_ERROR) {
  68.     glerror = XmCreateErrorDialog(toplevel, "gl Error", NULL, 0);
  69.     sprintf(message_string, "%s: %s", 
  70.         string,
  71.         (char *)gluErrorString(error)); 
  72.     error_message = XmStringCreateLocalized(message_string);
  73.     XtVaSetValues(glerror, XmNmessageString, error_message, NULL);
  74.     XtManageChild(glerror);
  75.     XmStringFree(error_message);
  76.     }    
  77. }
  78.  
  79. /*
  80. ** The following two structures are used for bookkeeping details about
  81. ** the current image and the current filter.
  82. ** The create function is called to create or resize a filter or image.
  83. ** the function is called with a pointer to the appropriate structure,
  84. ** with the desired information filled in. If the creation function can't
  85. ** meet all the criteria described in the data, it changes the value to
  86. ** on it can meet. 
  87. **
  88. ** For example, if a filter of a certain size is desired, but the filter
  89. ** is defined to be a fixed size, the width and height information are
  90. ** changed to match the fixed size filter created. The calling routine
  91. ** must check for changed values.
  92. */
  93.  
  94.  
  95. /*
  96. ** Current filter
  97. */
  98.  
  99. typedef enum {BOX, SOBEL, LAPLACE} FilterContents;
  100.  
  101. typedef struct filter_info {
  102.     /* used as arguments to OpenGL calls */
  103.     GLsizei width;
  104.     GLsizei height;
  105.     GLenum internalformat;
  106.     GLenum format;
  107.     GLenum type;
  108.     /* Destination format and type for glGet*Filter() calls */
  109.     GLenum get_target;
  110.     GLenum get_format;
  111.     GLenum get_type;
  112.     /* Internal filter information */
  113.     void (*create)(struct filter_info *filt);
  114.     FilterContents contents;
  115.     unsigned char *filter;
  116.     unsigned char *row; /* if filter is separable */
  117.     unsigned char *col; /* if filter is separable */
  118. } Filter;
  119.  
  120.  
  121. /*
  122. ** Current Image
  123. */
  124.  
  125. typedef enum {SQUARES, CHECKERBOARD, FILES} ImageContents;
  126.  
  127. typedef struct image_info {
  128.     /* used as arguments to OpenGL calls */
  129.     GLenum format;
  130.     GLenum type;
  131.     GLint x;
  132.     GLint y;
  133.     GLsizei width;
  134.     GLsizei height;
  135.     GLfloat rasterposx;
  136.     GLfloat rasterposy;
  137.     /* Internal image information */
  138.     void (*create)(struct image_info *image);
  139.     char filename[100]; /* filename of file read to make image */
  140.     ImageContents contents;
  141.     unsigned int wid; /* actual dimensions and size of filter */
  142.     unsigned int ht;
  143.     unsigned char *image;
  144. } Image;
  145.  
  146.  
  147. /*
  148. ** Global filter and image
  149. */
  150.  
  151. Image image;
  152. Filter filter;
  153.  
  154.  
  155.  
  156. int format_size(GLenum format)
  157. {
  158.     switch(format) {
  159.     case GL_RGB:
  160.     return 3;
  161.     case GL_LUMINANCE_ALPHA:
  162.         return 2;
  163.     case GL_RGBA:
  164.     case GL_ABGR_EXT:
  165.         return 4;
  166.     default:
  167.         return 1;
  168.     }
  169. }
  170.  
  171. int type_size(GLenum type)
  172. {
  173.    switch(type) {
  174.       case GL_UNSIGNED_SHORT:
  175.       case GL_SHORT:
  176.         return 2;
  177.       case GL_UNSIGNED_BYTE:
  178.       case GL_BYTE:
  179.         return 1;
  180.       case GL_INT:
  181.       case GL_UNSIGNED_INT:
  182.       case GL_FLOAT:
  183.       default:
  184.         return 4;
  185.     }
  186. }
  187.  
  188.  
  189. /*
  190. ** Convert an element from a float to the destination type
  191. */
  192. void write_type(float *source, unsigned char *dest, GLenum type)
  193. {
  194.     switch(type) {
  195.     case GL_UNSIGNED_BYTE:
  196.     *(GLubyte *)dest = (GLubyte)(*source * 255.);
  197.     break;
  198.     case GL_BYTE:
  199.     *(GLbyte *)dest = (GLbyte)(*source * 128.);
  200.     break;
  201.     case GL_UNSIGNED_SHORT:
  202.     *(GLushort *)dest = (GLushort)(*source * 65535.);
  203.     break;
  204.     case GL_SHORT:
  205.     *(GLshort *)dest = (GLshort)(*source * 32767.);
  206.     break;
  207.     case GL_UNSIGNED_INT:
  208.     *(GLuint *)dest = (GLuint)(*source * 4292965000);
  209.     break;
  210.     case GL_INT:
  211.     *(GLint *)dest = (GLint)(*source * 2147482000);
  212.     break;
  213.     case GL_FLOAT:
  214.     *(GLfloat *)dest = *source;
  215.     break;
  216.     default:
  217.     fprintf(stderr, "write_type: error, invalid type: %d\n", (int)type);
  218.     break;
  219.     }
  220. }
  221.  
  222. /*
  223. ** Copy an element from an array of float RGBA elements in the proper
  224. ** format and type of the destination void * array
  225. */
  226. void write_element(float *source, unsigned char **dest, 
  227.            GLenum format, GLenum type)
  228. {
  229.  
  230.     float *src = source;
  231.     float tmp; /* for luminance, luminance_alpha, intensity */
  232.  
  233.     switch(format) {
  234.     case GL_RGBA:
  235.     write_type(src, *dest, type);
  236.     src++;
  237.     *dest += type_size(type);
  238.     write_type(src, *dest, type);
  239.     src++;
  240.     *dest += type_size(type);
  241.     write_type(src, *dest, type);
  242.     src++;
  243.     *dest += type_size(type);
  244.     write_type(src, *dest, type);
  245.     src++;
  246.     *dest += type_size(type);
  247.     break;
  248.     case GL_ABGR_EXT:
  249.     write_type(src + 3, *dest, type);
  250.     *dest += type_size(type);
  251.     write_type(src + 2, *dest, type);
  252.     *dest += type_size(type);
  253.     write_type(src + 1, *dest, type);
  254.     *dest += type_size(type);
  255.     write_type(src, *dest, type);
  256.     *dest += type_size(type);
  257.     break;
  258.     case GL_RGB:
  259.     write_type(src, *dest, type);
  260.     src++;
  261.     *dest += type_size(type);
  262.     write_type(src, *dest, type);
  263.     src++;
  264.     *dest += type_size(type);
  265.     write_type(src, *dest, type);
  266.     src++;
  267.     *dest += type_size(type);
  268.     break;
  269.     case GL_LUMINANCE_ALPHA:
  270.     tmp = src[0] + src[1] + src[2];
  271.     write_type(&tmp, *dest, type);
  272.     *dest += type_size(type);
  273.     write_type(src + 3, *dest, type);
  274.     *dest += type_size(type);
  275.     break;
  276.     case GL_LUMINANCE:
  277.     tmp = src[0] + src[1] + src[2];
  278.     if(tmp > 1.0) tmp = 1.0;
  279.     write_type(&tmp, *dest, type);
  280.     *dest += type_size(type);
  281.     break;
  282.     case GL_INTENSITY_EXT:
  283.     tmp = src[0] + src[1] + src[2] + src[3];
  284.     if(tmp > 1.0) tmp = 1.0;
  285.     write_type(&tmp, *dest, type);
  286.     *dest += type_size(type);
  287.     break;
  288.     }
  289. }
  290.  
  291.  
  292. void create_sobel(Filter *filter_info)
  293. {
  294.     static float sbl[] = {-1.,-1.,-1., 1., 0., 0., 0., 1.,1., 1., 1., 1.,
  295.               -2.,-2.,-2., 1., 0., 0., 0., 1.,2., 2., 2., 1.,
  296.               -1.,-1.,-1., 1., 0., 0., 0., 1.,1., 1., 1., 1.};
  297.  
  298.     static float sbl_row[] = {-1.,-1.,-1., 1., 0., 0., 0., 1., 1., 1., 1., 1.};
  299.     static float sbl_col[] = { 1., 1., 1., 1., 2., 2., 2., 1., 1., 1., 1., 1.};
  300.     int i, j;    
  301.     unsigned char *f;
  302.     float *s;
  303.  
  304.     filter_info->create = create_sobel; /* for resizing */
  305.     filter_info->contents = SOBEL;
  306.  
  307.     filter_info->width = 3;
  308.     filter_info->height = 3;
  309.  
  310.     if(filter_info->filter) free(filter_info->filter);
  311.     if(filter_info->row) free(filter_info->row);
  312.     if(filter_info->col) free(filter_info->col);
  313.  
  314.     filter_info->filter = (unsigned char *)malloc(filter_info->width *
  315.                           filter_info->height *
  316.                           format_size(filter_info->format) *
  317.                           type_size(filter_info->type));
  318.  
  319.     filter_info->row = (unsigned char *)malloc(filter_info->width *
  320.                      format_size(filter_info->format) *
  321.                      type_size(filter_info->type));
  322.  
  323.     filter_info->col = (unsigned char *)malloc(filter_info->height *
  324.                      format_size(filter_info->format) *
  325.                      type_size(filter_info->type));
  326.  
  327.     
  328.     s = sbl;
  329.     f = filter_info->filter;
  330.     for(j = 0;j < 3;j++) {
  331.     for(i = 0;i < 3;i++) {
  332.         write_element(s, &f, filter_info->format, filter_info->type);
  333.         s += 4;
  334.     }
  335.     }
  336.  
  337.     s = sbl_row;
  338.     f = filter_info->row;
  339.     for(i = 0;i < 3;i++) {
  340.     write_element(s, &f, filter_info->format, filter_info->type);
  341.     s += 4;
  342.     }
  343.  
  344.     s = sbl_col;
  345.     f = filter_info->col;
  346.     for(j = 0;j < 3;j++) {
  347.     write_element(s, &f, filter_info->format, filter_info->type);
  348.     s += 4;
  349.     }
  350. }
  351.  
  352.  
  353. /*
  354. ** Create a laplacian filter
  355. */
  356. void create_laplace(Filter *filter_info)
  357. {
  358.     float lp[] = { 0., 0., 0., 1.,   1., 1., 1., 1.,  0., 0., 0., 1.,
  359.            1., 1., 1., 1.,  -4.,-4.,-4., 1.,  1., 1., 1., 1.,
  360.            0., 0., 0., 1.,   1., 1., 1., 1.,  0., 0., 0., 1.};
  361.  
  362.     int i, j;    
  363.     unsigned char *f;
  364.     float *s;
  365.  
  366.     filter_info->create = create_laplace; /* for resizing */
  367.     filter_info->contents = LAPLACE;
  368.  
  369.     filter_info->width = 3;
  370.     filter_info->height = 3;
  371.  
  372.     if(filter_info->filter) free(filter_info->filter);
  373.     if(filter_info->row) free(filter_info->row);
  374.     if(filter_info->col) free(filter_info->col);
  375.  
  376.     filter_info->filter = (unsigned char *)malloc(filter_info->width *
  377.                            filter_info->height *
  378.                           format_size(filter_info->format) *
  379.                           type_size(filter_info->type));
  380.  
  381.     filter_info->row = NULL;
  382.     filter_info->col = NULL;
  383.     
  384.     s = lp;
  385.     f = filter_info->filter;
  386.     for(j = 0;j < 3;j++) {
  387.     for(i = 0;i < 3;i++) {
  388.         write_element(s, &f, filter_info->format, filter_info->type);
  389.         s += 4;
  390.     }
  391.     }
  392. }
  393.  
  394. /*
  395. ** Create a Box filter
  396. */
  397. void create_box(Filter *filter_info)
  398. {
  399.     int i;
  400.     float value[4];
  401.     unsigned char *f;
  402.  
  403.     filter_info->create = create_box; /* for resizing */
  404.     filter_info->contents = BOX;
  405.  
  406.     /* TODO: check for maximum filter width, height? */
  407.  
  408.     if(filter_info->filter) free(filter_info->filter);
  409.     if(filter_info->row) free(filter_info->row);
  410.     if(filter_info->col) free(filter_info->col);
  411.  
  412.     filter_info->filter = (unsigned char *)malloc(filter_info->width *
  413.                           filter_info->height *
  414.                           format_size(filter_info->format) *
  415.                           type_size(filter_info->type));
  416.  
  417.     filter_info->row = (unsigned char *)malloc(filter_info->width *
  418.                      format_size(filter_info->format) *
  419.                      type_size(filter_info->type));
  420.  
  421.     filter_info->col = (unsigned char *)malloc(filter_info->height *
  422.                      format_size(filter_info->format) *
  423.                      type_size(filter_info->type));
  424.  
  425.  
  426.     value[0] = value[1] = value[2] = 1.0/(GLfloat)(filter_info->width * 
  427.                            filter_info->height);
  428.     value[3] = 1.0;
  429.  
  430.     f = filter_info->filter;
  431.     for(i = 0; i < filter_info->width * filter_info->height; i++) {
  432.     write_element(value, &f, filter_info->format, filter_info->type);
  433.     }
  434.  
  435.     value[0] = value[1] = value[2] = 1.0/(GLfloat)filter_info->width;
  436.     value[3] = 1.0;
  437.     f = filter_info->row;
  438.     for(i = 0; i < filter_info->width; i++) {
  439.     write_element(value, &f, filter_info->format, filter_info->type);
  440.     }
  441.  
  442.     value[0] = value[1] = value[2] = 1.0/(GLfloat)filter_info->height;
  443.     value[3] = 1.0;
  444.     f = filter_info->col;
  445.     for(i = 0; i < filter_info->height; i++) {
  446.     write_element(value, &f, filter_info->format, filter_info->type);
  447.     }
  448. }
  449.  
  450.  
  451. /*
  452. ** Create an image of white squares on a black background
  453. */
  454. void create_squares(Image *image_info)
  455. {
  456.     unsigned int x, y;
  457.     float zero[4], one[4];
  458.     unsigned char *i;
  459.  
  460.     zero[0] = 0.; zero[1] = 0.; zero[2] = 0.; zero[3] = 1.;
  461.     one[0] = 1.; one[1] = 1.; one[2] = 1.; one[3] = 1.;
  462.  
  463.     image_info->create = create_squares; /* for resizing */
  464.  
  465.     if(image_info->image) free(image_info->image);
  466.  
  467.     image_info->image = (unsigned char *)malloc(image_info->wid *
  468.                           image_info->ht *
  469.                           format_size(image_info->format) *
  470.                           type_size(image_info->type));
  471.  
  472.     i = image_info->image;
  473.     for(y = 0; y < image_info->ht; y++) {
  474.     for(x = 0; x < image_info->wid; x++) {
  475.         if(!(x/GRID & 0x1) & 
  476.            !(y/GRID & 0x1)) {
  477.         write_element(one, &i, image_info->format, image_info->type);
  478.         } else {
  479.         write_element(zero, &i, image_info->format, image_info->type);
  480.         }
  481.     }
  482.     }
  483. }
  484.  
  485. /*
  486. ** Create a checkerboard image
  487. */
  488.  
  489. void create_checkerboard(Image *image_info)
  490. {
  491.     unsigned int x, y;
  492.     float zero[4], one[4];
  493.     unsigned char *i;
  494.  
  495.     zero[0] = 0.; zero[1] = 0.; zero[2] = 0.; zero[3] = 1.;
  496.     one[0] = 1.; one[1] = 1.; one[2] = 1.; one[3] = 1.;
  497.  
  498.     image_info->create = create_checkerboard; /* for resizing */
  499.  
  500.     if(image_info->image) free(image_info->image);
  501.  
  502.     image_info->image = (unsigned char *)malloc(image_info->wid *
  503.                           image_info->ht *
  504.                           format_size(image_info->format) *
  505.                           type_size(image_info->type));
  506.  
  507.     i = image_info->image;
  508.     for(y = 0; y < image_info->ht; y++) {
  509.     for(x = 0; x < image_info->wid; x++) {
  510.         if((x/GRID & 0x1) ^ 
  511.            (y/GRID & 0x1)) {
  512.         write_element(one, &i, image_info->format, image_info->type);
  513.         } else {
  514.         write_element(zero, &i, image_info->format, image_info->type);
  515.         }
  516.     }
  517.     }
  518. }
  519.  
  520. void create_from_file(Image *image_info)
  521. {
  522.     IMAGE *fileimage;
  523.     GLubyte *img, *pixel;
  524.     unsigned short *rbuf, *gbuf, *bbuf;
  525.     int i,j;
  526.  
  527.  
  528.     image_info->create = create_from_file; /* for resizing */
  529.  
  530.     fileimage = iopen(image_info->filename, "r");
  531.     if(!fileimage) { /* open failed */
  532.     fprintf(stderr, "Unable to read rgb image file %s\n", 
  533.         image_info->filename);
  534.     return;
  535.     }    
  536.     
  537.     free(image_info->image);
  538.  
  539.     /* TODO: fix so format, type can be changed */
  540.     image_info->width = image_info->wid = fileimage->xsize; 
  541.     image_info->height = image_info->ht = fileimage->ysize; 
  542.     
  543.     image_info->type = GL_UNSIGNED_BYTE;
  544.     image_info->format = GL_RGB;
  545.     img = (GLubyte *)malloc(fileimage->xsize * 
  546.                 fileimage->ysize * 
  547.                 3 * 
  548.                 sizeof(GLushort));
  549.     image_info->image = (unsigned char *)img;
  550.  
  551.     rbuf = (unsigned short *) malloc(fileimage->xsize * sizeof(unsigned short));
  552.     gbuf = (unsigned short *) malloc(fileimage->xsize * sizeof(unsigned short));
  553.     bbuf = (unsigned short *) malloc(fileimage->xsize * sizeof(unsigned short));
  554.  
  555.  
  556.     for(j = 0; j < fileimage->ysize; j++) {
  557.     getrow(fileimage, rbuf, j, 0);
  558.     getrow(fileimage, gbuf, j, 1);
  559.     getrow(fileimage, bbuf, j, 2);
  560.     pixel = img + j * fileimage->xsize * 3; /* row pointer */
  561.     for(i = 0; i < fileimage->xsize;i++) {
  562.         pixel[0] = rbuf[i];
  563.         pixel[1] = gbuf[i];
  564.         pixel[2] = bbuf[i];
  565.         pixel += 3; /* next pixel */
  566.     }
  567.     }
  568.  
  569.     iclose(fileimage);
  570.     free(rbuf);
  571.     free(gbuf);
  572.     free(bbuf);
  573.  
  574. /* TODO: update option menus
  575.     XtVaSetValues(filter_format, XmNmenuHistory, button_1, NULL);
  576.     XtVaSetValues(filter_type, XmNmenuHistory, button_3, NULL);
  577. */
  578. }
  579.  
  580. void make_image(Image *image_info)
  581. { 
  582.  
  583.     switch(image_info->contents) { 
  584.     case SQUARES: /* generate squares on a background */
  585.     create_squares(image_info);
  586.     break;
  587.     case CHECKERBOARD: /* generate a checkerboard pattern */
  588.     create_checkerboard(image_info);
  589.     break;
  590.     case FILES: /* image read in from a file */
  591.     create_from_file(image_info);
  592.     break;
  593.     }
  594. }
  595.  
  596. void make_filter(Filter *filter_info)
  597. {
  598.     switch(filter_info->contents) {
  599.     case BOX:
  600.     create_box(filter_info);
  601.     break;
  602.     case SOBEL:
  603.     create_sobel(filter_info);
  604.     break;
  605.     case LAPLACE:
  606.     create_laplace(filter_info);
  607.     break;
  608.     }
  609. }
  610.  
  611. GLfloat pyramid[3 * (3 + 2) * 4]; /* 4 3d Triangles w/ 2d textures */
  612. void make_pyramid()
  613. {
  614.     int i, j, k;
  615.     float angle;
  616.  
  617.     angle = 120. * M_PI * 2.0 / 360. ;
  618.  
  619.     k = 0; /* index for loading array */
  620.     for(j = 0; j < 3; j++) { /* number of triangles */
  621.     for(i = j; i < j + 2; i++) { /* finding x & y coordinates */
  622.         if(i == j) {
  623.         pyramid[k++] = 0.0; /* texture coord */
  624.         pyramid[k++] = 0.0;
  625.         } else {
  626.         pyramid[k++] = 1.0; /* texture coord */
  627.         pyramid[k++] = 0.0;
  628.         }
  629.         pyramid[k++] = fcos(i * angle);
  630.         pyramid[k++] = fsin(i * angle);
  631.         pyramid[k++] = -1.0;
  632.     }
  633.     pyramid[k++] = 0.5; /* texture coord */
  634.     pyramid[k++] = 1.0;
  635.  
  636.     pyramid[k++] = 0.;
  637.     pyramid[k++] = 0.;
  638.     pyramid[k++] = 0.;
  639.     } 
  640.     /* now; last triangle */
  641.     for(i = 0; i < 3; i++) { /* finding x & y coordinates */
  642.     switch(i) {
  643.     case 0:
  644.         pyramid[k++] = 0.0; /* texture coord */
  645.         pyramid[k++] = 0.0;
  646.         break;
  647.     case 1:
  648.         pyramid[k++] = 1.0; /* texture coord */
  649.         pyramid[k++] = 0.0;
  650.         break;
  651.     case 2:
  652.         pyramid[k++] = 0.5; /* texture coord */
  653.         pyramid[k++] = 1.0;
  654.         break;
  655.     }
  656.     pyramid[k++] = fcos(i * angle);
  657.     pyramid[k++] = fsin(i * angle);
  658.     pyramid[k++] = -1.0;
  659.     }
  660. }
  661.  
  662. void clear_screen(Widget w, XtPointer data, XtPointer callData)
  663. {
  664.     glClear(GL_COLOR_BUFFER_BIT);
  665. }
  666.  
  667.  
  668. void draw_tex(Widget w, XtPointer data, XtPointer callData)
  669. {
  670.     GLint zoomx, zoomy;
  671.     int i;
  672.  
  673.     XmScaleGetValue(xzoom, &zoomx);
  674.     XmScaleGetValue(yzoom, &zoomy);
  675.     
  676.     glPixelZoom(zoomx/100., zoomy/100.);
  677.  
  678.     if(glIsEnabled(GL_TEXTURE_1D))
  679.     gluBuild1DMipmaps(GL_TEXTURE_1D, 4, image.wid,
  680.               image.format, image.type, image.image);
  681.     if(glIsEnabled(GL_TEXTURE_2D))
  682.     gluBuild2DMipmaps(GL_TEXTURE_2D, 4, image.wid, image.ht,
  683.               image.format, image.type, image.image);
  684.  
  685.     glBegin(GL_TRIANGLES);
  686.     glTexCoord2f(0.,0.);
  687.     glVertex3f(-1.,-1.,0.);
  688.     glTexCoord2f(1.,0.);
  689.     glVertex3f(1.,-1.,0.);
  690.     glTexCoord2f(.5,1.);
  691.     glVertex3f(0.,1.,0.);
  692.     glEnd();
  693.  
  694. }
  695.  
  696.  
  697. void load_image(Widget w, XtPointer data, XtPointer callData)
  698. {
  699.     make_image(&image);
  700. }
  701.  
  702. void draw_pix(Widget w, XtPointer data, XtPointer callData)
  703. {
  704.     GLint zoomx, zoomy;
  705.  
  706.     XmScaleGetValue(xzoom, &zoomx);
  707.     XmScaleGetValue(yzoom, &zoomy);
  708.     
  709.     glPixelZoom(zoomx/100., zoomy/100.);
  710.  
  711.     glRasterPos3f(-1.0, -1.0, 0.0);
  712.  
  713.     glDrawPixels(image.wid, image.ht, image.format, image.type,
  714.          image.image);
  715. }
  716.  
  717. void read_pix(Widget w, XtPointer data, XtPointer callData)
  718. {
  719.     GLint zoomx, zoomy;
  720.  
  721.     XmScaleGetValue(xzoom, &zoomx);
  722.     XmScaleGetValue(yzoom, &zoomy);
  723.     
  724.     glPixelZoom(zoomx/100., zoomy/100.);
  725.  
  726.     glReadPixels(0, 0, image.wid, image.ht, image.format, image.type,
  727.          image.image);
  728. }
  729.  
  730. void copy_pix(Widget w, XtPointer data, XtPointer callData)
  731. {
  732.     GLint zoomx, zoomy;
  733.  
  734.     XmScaleGetValue(xzoom, &zoomx);
  735.     XmScaleGetValue(yzoom, &zoomy);
  736.     
  737.     glPixelZoom(zoomx/100., zoomy/100.);
  738.  
  739.     glRasterPos2f(image.rasterposx, image.rasterposy);
  740.     glCopyPixels(image.x, image.y, image.width, image.height, GL_COLOR);
  741.     glRasterPos2f(-1.0, -1.0); /* restore raster position */
  742. }
  743.  
  744. void enable_1d(Widget w, XtPointer data, XtPointer call_data)
  745. {
  746.     if(((XmToggleButtonCallbackStruct *)call_data)->set)
  747.     glEnable(GL_CONVOLUTION_1D_EXT);
  748.     else
  749.     glDisable(GL_CONVOLUTION_1D_EXT);
  750. }
  751.  
  752. void enable_2d(Widget w, XtPointer data, XtPointer call_data)
  753. {
  754.     if(((XmToggleButtonCallbackStruct *)call_data)->set)
  755.     glEnable(GL_CONVOLUTION_2D_EXT);
  756.     else
  757.     glDisable(GL_CONVOLUTION_2D_EXT);
  758. }
  759.  
  760. void enable_tex_1d(Widget w, XtPointer data, XtPointer call_data)
  761. {
  762.     if(((XmToggleButtonCallbackStruct *)call_data)->set)
  763.     glEnable(GL_TEXTURE_1D);
  764.     else
  765.     glDisable(GL_TEXTURE_1D);
  766. }
  767.  
  768. void enable_tex_2d(Widget w, XtPointer data, XtPointer call_data)
  769. {
  770.     if(((XmToggleButtonCallbackStruct *)call_data)->set)
  771.     glEnable(GL_TEXTURE_2D);
  772.     else
  773.     glDisable(GL_TEXTURE_2D);
  774. }
  775.  
  776. void enable_sep_2d(Widget w, XtPointer data, XtPointer call_data)
  777. {
  778.     if(((XmToggleButtonCallbackStruct *)call_data)->set)
  779.     glEnable(GL_SEPARABLE_2D_EXT);
  780.     else
  781.     glDisable(GL_SEPARABLE_2D_EXT);
  782. }
  783.  
  784. void make_conv_1d(Widget w, XtPointer data, XtPointer callData)
  785. {
  786.     int wid, ht;
  787.  
  788.     XmScaleGetValue(fwidth, &wid);
  789.     XmScaleGetValue(fheight, &ht);
  790.     filter.width = wid;
  791.     filter.height = ht;
  792.     (*filter.create)(&filter);
  793.  
  794.     /* load filter */
  795.     glConvolutionFilter1DEXT(GL_CONVOLUTION_1D_EXT, 
  796.                  filter.internalformat,
  797.                  filter.width,
  798.                  filter.format,
  799.                  filter.type,
  800.                  filter.row);
  801.     check_error("glConvolutionFilter1DEXT");
  802. }
  803.  
  804. void make_conv_2d(Widget w, XtPointer data, XtPointer callData)
  805. {
  806.     int wid, ht;
  807.  
  808.     XmScaleGetValue(fwidth, &wid);
  809.     XmScaleGetValue(fheight, &ht);
  810.     filter.width = wid;
  811.     filter.height = ht;
  812.     (*filter.create)(&filter);
  813.  
  814.     /* load filter */
  815.     glConvolutionFilter2DEXT(GL_CONVOLUTION_2D_EXT, 
  816.                  filter.internalformat,
  817.                  filter.width, filter.height,
  818.                  filter.format,
  819.                  filter.type,
  820.                  filter.filter);
  821.     check_error("glConvolutionFilter2DEXT");
  822. }
  823.  
  824. void make_sep_2d(Widget w, XtPointer data, XtPointer callData)
  825. {
  826.     int wid, ht;
  827.  
  828.     XmScaleGetValue(fwidth, &wid);
  829.     XmScaleGetValue(fheight, &ht);
  830.     filter.width = wid;
  831.     filter.height = ht;
  832.     (*filter.create)(&filter);
  833.  
  834.     /* load filter */
  835.     glSeparableFilter2DEXT(GL_SEPARABLE_2D_EXT, 
  836.                filter.internalformat,
  837.                filter.width, filter.height,
  838.                filter.format,
  839.                filter.type,
  840.                filter.row,
  841.                filter.col);
  842.     check_error("glSeparableFilter2DEXT");
  843. }
  844.  
  845. void new_list(Widget w, XtPointer data, XtPointer callData)
  846. {
  847.     if(glIsList(1)) {
  848.     check_error("glIsList");
  849.     glDeleteLists(1,1);
  850.     check_error("glDeleteLists");
  851.     }
  852.     glNewList(1, GL_COMPILE);
  853.     check_error("glNewList");
  854. }
  855.  
  856. void end_list(Widget w, XtPointer data, XtPointer callData)
  857. {
  858.     glEndList();
  859.     check_error("glEndList");
  860. }
  861.  
  862. void call_list(Widget w, XtPointer data, XtPointer callData)
  863. {
  864.     glCallList(1);
  865.     check_error("glCallList");
  866. }
  867.  
  868.  
  869. /*
  870. ** Return number of characters needed to print a given type
  871. */
  872. int print_type_size(GLenum type)
  873. {
  874.     return(4); /* hardwired for GL_FLOAT (X.XX or %.2f) */
  875. }
  876. /*
  877. ** Return number of characters needed to print a given format & type
  878. */
  879. int print_format_size(GLenum format, GLenum type)
  880. {
  881.    return (print_type_size(type) + 2) * 4 + 1; /* hardwired for RGBA */
  882. }
  883.  
  884. void get_conv_1d_filter(Widget w, XtPointer data, XtPointer callData)
  885. {
  886.     GLfloat *filter_image, *f;
  887.     Widget filter_output;
  888.     XmString filter_elements;
  889.     char *filter_text, *ft;
  890.     GLint wid, ht;
  891.     int i, j;
  892.  
  893.     glGetConvolutionParameterivEXT(GL_CONVOLUTION_1D_EXT,
  894.                   GL_CONVOLUTION_WIDTH_EXT,
  895.                   &wid);
  896.     check_error("glGetConvolutionParameterivEXT");
  897.  
  898.     ht = 1;
  899.     filter_image = (GLfloat *)malloc(4 * sizeof(GLfloat) * wid);
  900.  
  901.     glGetConvolutionFilterEXT(GL_CONVOLUTION_1D_EXT,
  902.                   filter.get_format,
  903.                   filter.get_type,
  904.                   filter_image);
  905.     check_error("glGetConvolutionFilterEXT");
  906.  
  907.     
  908. /*
  909. **     TODO: make so format and type can vary.
  910. **     4 components/element, 6 chars/component, 1 comma + 3 space/element,
  911. **     2 newline/line
  912. */
  913.     filter_text = (char *)malloc(26 * wid + 3);
  914.  
  915.     ft = filter_text;
  916.     for(f = filter_image, i = 0; i < wid; i++) {
  917.     ft += sprintf(ft, "%.2f  ",  *f++);
  918.     ft += sprintf(ft, "%.2f  ",  *f++);
  919.     ft += sprintf(ft, "%.2f  ",  *f++);
  920.     ft += sprintf(ft, "%.2f,   ", *f++);
  921.     }
  922.  
  923.     filter_output = XmCreateMessageDialog(toplevel, "FilterContents", NULL, 0);
  924.     XtUnmanageChild(XmMessageBoxGetChild(filter_output, 
  925.                      XmDIALOG_CANCEL_BUTTON));
  926.     XtUnmanageChild(XmMessageBoxGetChild(filter_output, 
  927.                      XmDIALOG_HELP_BUTTON));
  928.     filter_elements = XmStringCreateLtoR(filter_text,
  929.                      XmFONTLIST_DEFAULT_TAG);
  930.     XtVaSetValues(filter_output, XmNmessageString, filter_elements, NULL);
  931.     XmStringFree(filter_elements);
  932.     XtManageChild(filter_output);
  933.     free(filter_text);
  934.     free(filter_image);
  935. }
  936.  
  937. void get_conv_2d_filter(Widget w, XtPointer data, XtPointer callData)
  938. {
  939.     GLfloat *filter_image, *f;
  940.     Widget filter_output;
  941.     XmString filter_elements;
  942.     char *filter_text, *ft;
  943.     GLint wid, ht;
  944.     int i, j;
  945.  
  946.     glGetConvolutionParameterivEXT(GL_CONVOLUTION_2D_EXT,
  947.                   GL_CONVOLUTION_WIDTH_EXT,
  948.                   &wid);
  949.     check_error("glGetConvolutionParameterivEXT");
  950.  
  951.     glGetConvolutionParameterivEXT(filter.get_target,
  952.                    GL_CONVOLUTION_HEIGHT_EXT,
  953.                    &ht);
  954.     check_error("glGetConvolutionParameterivEXT");
  955.  
  956.     filter_image = (GLfloat *)malloc(4 * sizeof(GLfloat) * wid * ht);
  957.  
  958.     glGetConvolutionFilterEXT(GL_CONVOLUTION_2D_EXT,
  959.                   filter.get_format,
  960.                   filter.get_type,
  961.                   filter_image);
  962.     check_error("glGetConvolutionFilterEXT");
  963.  
  964.     
  965. /*
  966. **     TODO: make so format and type can vary.
  967. **     4 components/element, 6 chars/component, 1 comma + 3 space/element,
  968. **     2 newline/line
  969. */
  970.     filter_text = (char *)malloc((26 * wid + 2) * ht + 1);
  971.  
  972.     ft = filter_text;
  973.     for(j = 0; j < ht; j++) { /* assuming output is RGBA */
  974.     for(f = filter_image, i = 0; i < wid; i++) {
  975.         ft += sprintf(ft, "%.2f  ",  *f++);
  976.         ft += sprintf(ft, "%.2f  ",  *f++);
  977.         ft += sprintf(ft, "%.2f  ",  *f++);
  978.         ft += sprintf(ft, "%.2f,   ", *f++);
  979.     }
  980.     if(j < ht - 1)
  981.         ft += sprintf(ft, "\n\n");
  982.     }
  983.  
  984.     filter_output = XmCreateMessageDialog(toplevel, "FilterContents", NULL, 0);
  985.     XtUnmanageChild(XmMessageBoxGetChild(filter_output, 
  986.                      XmDIALOG_CANCEL_BUTTON));
  987.     XtUnmanageChild(XmMessageBoxGetChild(filter_output, 
  988.                      XmDIALOG_HELP_BUTTON));
  989.     filter_elements = XmStringCreateLtoR(filter_text,
  990.                      XmFONTLIST_DEFAULT_TAG);
  991.     XtVaSetValues(filter_output, XmNmessageString, filter_elements, NULL);
  992.     XmStringFree(filter_elements);
  993.     XtManageChild(filter_output);
  994.     free(filter_text);
  995.     free(filter_image);
  996. }
  997.  
  998. void get_sep_filter(Widget w, XtPointer data, XtPointer callData)
  999. {
  1000.     GLfloat *row, *col, *dummy, *f;
  1001.     Widget filter_output;
  1002.     XmString filter_elements;
  1003.     char *filter_text, *ft;
  1004.     GLint wid, ht;
  1005.     int i;
  1006.  
  1007.     /* which convolution filter are we using? */
  1008.  
  1009.     glGetConvolutionParameterivEXT(GL_SEPARABLE_2D_EXT,
  1010.                   GL_CONVOLUTION_WIDTH_EXT,
  1011.                   &wid);
  1012.     check_error("glGetConvolutionParameterivEXT");
  1013.     glGetConvolutionParameterivEXT(GL_SEPARABLE_2D_EXT,
  1014.                   GL_CONVOLUTION_HEIGHT_EXT,
  1015.                   &ht);
  1016.     check_error("glGetConvolutionParameterivEXT");
  1017.  
  1018.     row = (GLfloat *)malloc(4 * sizeof(GLfloat) * wid);
  1019.     col = (GLfloat *)malloc(4 * sizeof(GLfloat) * ht);
  1020.  
  1021.     glGetSeparableFilterEXT(GL_SEPARABLE_2D_EXT,
  1022.                 filter.get_format,
  1023.                 filter.get_type,
  1024.                 row,
  1025.                 col,
  1026.                 dummy);
  1027.     check_error("glGetSeparableFilterEXT");
  1028.  
  1029.  
  1030. /*
  1031. **     TODO: make so format and type can vary.
  1032. **     4 components/element, 6 chars/component, 1 comma + 3 space/element,
  1033. **     2 newline/line
  1034. */
  1035.     filter_text = (char *)malloc(26 * wid + 26 * ht + 15);
  1036.  
  1037.     ft = filter_text;
  1038.     ft += sprintf(ft, "Row:  ");
  1039.     for(f = row, i = 0; i < wid; i++) { /* assuming output is RGBA */
  1040.     ft += sprintf(ft, "%.2f  ",  *f++);
  1041.     ft += sprintf(ft, "%.2f  ",  *f++);
  1042.     ft += sprintf(ft, "%.2f  ",  *f++);
  1043.     ft += sprintf(ft, "%.2f,   ", *f++);
  1044.     }
  1045.  
  1046.     ft += sprintf(ft, "\n\n Col:  ");
  1047.     for(f = col, i = 0; i < ht; i++) { /* assuming output is RGBA */
  1048.     ft += sprintf(ft, "%.2f  ",  *f++);
  1049.     ft += sprintf(ft, "%.2f  ",  *f++);
  1050.     ft += sprintf(ft, "%.2f  ",  *f++);
  1051.     ft += sprintf(ft, "%.2f,   ", *f++);
  1052.     }
  1053.  
  1054.     filter_output = XmCreateMessageDialog(toplevel, "FilterContents", NULL, 0);
  1055.     XtUnmanageChild(XmMessageBoxGetChild(filter_output, 
  1056.                      XmDIALOG_CANCEL_BUTTON));
  1057.     XtUnmanageChild(XmMessageBoxGetChild(filter_output, 
  1058.                      XmDIALOG_HELP_BUTTON));
  1059.     filter_elements = XmStringCreateLtoR(filter_text,
  1060.                      XmFONTLIST_DEFAULT_TAG);
  1061.     XtVaSetValues(filter_output, XmNmessageString, filter_elements, NULL);
  1062.     XmStringFree(filter_elements);
  1063.     XtManageChild(filter_output);
  1064.     free(filter_text);
  1065.     free(row);
  1066.     free(col);
  1067. }
  1068.  
  1069. void copy_filter_1d(Widget w, XtPointer data, XtPointer callData)
  1070. {
  1071.     glCopyConvolutionFilter1DEXT(GL_CONVOLUTION_1D_EXT, GL_RGB, 
  1072.                  image.x, image.y, 
  1073.                  image.width);
  1074.     check_error("glCopyConvolutionFilter1DEXT");
  1075.  
  1076.     XmScaleSetValue(fwidth, image.width);
  1077. }
  1078.  
  1079. void copy_filter_2d(Widget w, XtPointer data, XtPointer callData)
  1080. {
  1081.     glCopyConvolutionFilter2DEXT(GL_CONVOLUTION_2D_EXT, GL_RGB, 
  1082.                  image.x, image.y, 
  1083.                  image.width, image.height);
  1084.     check_error("glCopyConvolutionFilter2DEXT");
  1085.     XmScaleSetValue(fwidth, image.width);
  1086.     XmScaleSetValue(fheight, image.height);
  1087. }
  1088.  
  1089.  
  1090. GLboolean made_current = GL_FALSE;
  1091.  
  1092. void resize(Widget w, XtPointer data, XtPointer callData)
  1093. {
  1094.     Dimension wid, ht;
  1095.  
  1096.     if(made_current) {
  1097.     XtVaGetValues(w, XmNwidth, &wid, XmNheight, &ht, NULL);
  1098.     glViewport(0,0, (GLint) wid, (GLint) ht);
  1099.     check_error("glViewport");
  1100.     image.wid = wid;
  1101.     image.ht = ht;
  1102.     make_image(&image);
  1103.     }
  1104. }
  1105.  
  1106. void map_state_changed(Widget w, XtPointer data, XEvent *event, Boolean *cont)
  1107. {
  1108.     switch(event->type) {
  1109.     case MapNotify:
  1110.     break;
  1111.     case UnmapNotify:
  1112.     break;
  1113.     }
  1114. }
  1115.  
  1116. void get_filename(Widget w, XtPointer data, XtPointer callData)
  1117. {
  1118.     char *filename;
  1119.  
  1120.     XmFileSelectionBoxCallbackStruct *cbs =
  1121.     (XmFileSelectionBoxCallbackStruct *) callData;
  1122.  
  1123.     if(cbs->reason == XmCR_OK) {
  1124.     if(!XmStringGetLtoR(cbs->value, XmFONTLIST_DEFAULT_TAG, &filename))
  1125.         return; /* internal error */
  1126.  
  1127.     strcpy(image.filename, filename);
  1128.     XtFree(filename);
  1129.     create_from_file(&image);
  1130.     }
  1131.     XtPopdown(XtParent(w));
  1132. }
  1133.  
  1134. void cancel_file(Widget w, XtPointer data, XtPointer callData)
  1135. {
  1136.     XtPopdown(XtParent(w));
  1137.     return;
  1138. }
  1139.  
  1140. /*
  1141. ** Set the type of image to work on
  1142. */
  1143. void set_image_contents(Widget w, XtPointer data, XtPointer callData)
  1144. {
  1145.     Widget dialog;
  1146.     XmString dir;
  1147.  
  1148.     image.contents = (ImageContents)data;
  1149.  
  1150.     switch((ImageContents)data) {
  1151.     case SQUARES:
  1152.     create_squares(&image);
  1153.     break;
  1154.     case CHECKERBOARD:
  1155.     create_checkerboard(&image);
  1156.     break;
  1157.     case FILES:
  1158.     dir = XmStringCreateLocalized("/usr/demos/data/images/*.rgb"); /**/
  1159.     dialog = XmCreateFileSelectionDialog(toplevel, "imagefile", NULL, 0);
  1160.     XtAddCallback(dialog, XmNokCallback, get_filename, NULL);
  1161.     XtAddCallback(dialog, XmNcancelCallback, get_filename, NULL);
  1162.     XtSetSensitive(XmSelectionBoxGetChild(dialog, XmDIALOG_HELP_BUTTON),
  1163.                False);
  1164.     XmFileSelectionDoSearch(dialog, dir);
  1165.     XtManageChild(dialog);
  1166.     XmStringFree(dir);
  1167.     break;
  1168.     }
  1169. }
  1170.  
  1171. void set_image_format(Widget w, XtPointer data, XtPointer callData)
  1172. {
  1173.     switch((int)data) {
  1174.     case 0: /* RGBA */
  1175.     image.format = GL_RGBA;
  1176.     break;
  1177.     case 1: /* RGB */
  1178.     image.format = GL_RGB;
  1179.     break;
  1180.     case 2: /* Luminance */
  1181.     image.format = GL_LUMINANCE;
  1182.     break;
  1183.     case 3: /* Luminance-Alpha */
  1184.     image.format = GL_LUMINANCE_ALPHA;
  1185.     break;
  1186.     case 4: /* Intensity */
  1187.     image.format = GL_INTENSITY_EXT;
  1188.     break;
  1189.     }
  1190.     make_image(&image);
  1191. }
  1192.  
  1193. void set_image_type(Widget w, XtPointer data, XtPointer callData)
  1194. {
  1195.     switch((int)data) {
  1196.     case 0: 
  1197.     image.type = GL_BYTE;
  1198.     break;
  1199.     case 1: 
  1200.     image.type = GL_UNSIGNED_BYTE;
  1201.     break;
  1202.     case 2: 
  1203.     image.type = GL_SHORT;
  1204.     break;
  1205.     case 3: 
  1206.     image.type = GL_UNSIGNED_SHORT;
  1207.     break;
  1208.     case 4: 
  1209.     image.type = GL_INT;
  1210.     break;
  1211.     case 5: 
  1212.     image.type = GL_UNSIGNED_INT;
  1213.     break;
  1214.     case 6: 
  1215.     image.type = GL_FLOAT;
  1216.     break;
  1217.     }
  1218.     make_image(&image);
  1219. }
  1220.  
  1221.  
  1222. void set_filter_format(Widget w, XtPointer data, XtPointer callData)
  1223. {
  1224.     switch((int)data) {
  1225.     case 0: /* RGBA */
  1226.     filter.format = GL_RGBA;
  1227.     break;
  1228.     case 1: /* RGB */
  1229.     filter.format = GL_RGB;
  1230.     break;
  1231.     case 2: /* Luminance */
  1232.     filter.format = GL_LUMINANCE;
  1233.     break;
  1234.     case 3: /* Luminance-Alpha */
  1235.     filter.format = GL_LUMINANCE_ALPHA;
  1236.     break;
  1237.     case 4: /* Intensity */
  1238.     filter.format = GL_INTENSITY_EXT;
  1239.     break;
  1240.     }
  1241.     make_filter(&filter);
  1242. }
  1243.  
  1244. void set_filter_type(Widget w, XtPointer data, XtPointer callData)
  1245. {
  1246.     switch((int)data) {
  1247.     case 0: 
  1248.     filter.type = GL_BYTE;
  1249.     break;
  1250.     case 1: 
  1251.     filter.type = GL_UNSIGNED_BYTE;
  1252.     break;
  1253.     case 2: 
  1254.     filter.type = GL_SHORT;
  1255.     break;
  1256.     case 3: 
  1257.     filter.type = GL_UNSIGNED_SHORT;
  1258.     break;
  1259.     case 4: 
  1260.     filter.type = GL_INT;
  1261.     break;
  1262.     case 5: 
  1263.     filter.type = GL_UNSIGNED_INT;
  1264.     break;
  1265.     case 6: 
  1266.     filter.type = GL_FLOAT;
  1267.     break;
  1268.     }
  1269.     make_filter(&filter);
  1270. }
  1271.  
  1272. void set_filter_contents(Widget w, XtPointer data, XtPointer callData)
  1273. {
  1274.     switch((int)data) {
  1275.     case 0: /* Box Filter */
  1276.     create_box(&filter);
  1277.     break;
  1278.     case 1: /* Laplace Filter */
  1279.     create_laplace(&filter);
  1280.     break;
  1281.     case 2: /* Sobel Filter */
  1282.     create_sobel(&filter);
  1283.     break;
  1284.     default:
  1285.     break;
  1286.     }
  1287. }
  1288.  
  1289. /*
  1290. ** Read mouse (or any other) input events to the drawing window.
  1291. ** for now, it is used to specify the source and dest of copy pixels
  1292. */
  1293. void mouse_input(Widget w, XtPointer client_data, XtPointer call_data)
  1294. {
  1295.     GLint x,y;
  1296.     static int push_state = 0; /* 0 source, 1 dest */
  1297.     XmDrawingAreaCallbackStruct *cbs = (XmDrawingAreaCallbackStruct *)call_data;
  1298.     XEvent *event = cbs->event;
  1299.     GLfloat sx, sy;
  1300.  
  1301.     
  1302.     sx = 2.0/(GLfloat)image.wid;
  1303.     sy = 2.0/(GLfloat)image.ht;
  1304.  
  1305. /*    glBlendEquationEXT(GL_LOGIC_OP); 
  1306.  
  1307.     glEnable(GL_BLEND);
  1308. */
  1309.     if(cbs->reason == XmCR_INPUT) {
  1310.     if(event->xany.type == ButtonPress) {
  1311.         if(push_state) { /* lower left corner of dest */
  1312.         x = event->xbutton.x - (GLint)image.wid / 2;
  1313.         y =(GLint)image.ht - 1 - event->xbutton.y - (GLint)image.ht / 2;
  1314.         image.rasterposx =  2 * x / (GLfloat)image.wid;
  1315.         image.rasterposy =  2 * y / (GLfloat)image.ht;
  1316.         glBegin(GL_LINES);
  1317.         glVertex2f(x * sx - .1, y * sy);
  1318.         glVertex2f(x * sx + .1, y * sy);
  1319.         glVertex2f(x * sx, y * sy - .1);
  1320.         glVertex2f(x * sx, y * sy + .1);
  1321.         glEnd();
  1322.         check_error("glBegin/glEnd");
  1323.         } else { /* lower left corner of source */
  1324.         image.x = event->xbutton.x;
  1325.         image.y = (image.height - 1) - event->xbutton.y;
  1326.         }
  1327.     } else if (event->xany.type == ButtonRelease) {
  1328.         if(push_state) { /* ignore */
  1329.         push_state = ~push_state;
  1330.         } else { /* upper right corner of source */
  1331.         image.width = event->xbutton.x - image.x;
  1332.         image.height = image.ht - 1 - event->xbutton.y - image.y;
  1333.         push_state = ~push_state;
  1334.         }
  1335.     }
  1336.     }
  1337. /*
  1338.     glDisable(GL_BLEND);
  1339. */    
  1340. }
  1341.  
  1342.  
  1343. Display     *dpy;
  1344. XtAppContext app;
  1345. GLXContext   ctx;
  1346.  
  1347. main(int argc, char *argv[])
  1348. {
  1349.     XVisualInfo *vis;
  1350.     XmString rgba, rgb, l, la, intens;
  1351.     XmString fubyt, fbyt, fusht, fsht, fuinteg, finteg, fflt;
  1352.     XmString iubyt, ibyt, iusht, isht, iuinteg, iinteg, iflt;
  1353.     XmString fformat, ftype, fcont; 
  1354.     XmString iformat, itype, icont;
  1355.     XmString box, laplace, sobel;
  1356.     XmString squares, checks, files;
  1357.     static int vattribs[] = { GLX_RGBA, 0};
  1358.     int screen;
  1359.  
  1360.     XtSetLanguageProc(NULL, NULL, NULL);
  1361.  
  1362.     toplevel = XtAppInitialize(&app, "SampleCode", 
  1363.                    NULL, 0, 
  1364.                    &argc, argv,
  1365.                    fallbackResources, NULL, 
  1366.                    0);
  1367.  
  1368.     dpy = XtDisplay(toplevel);
  1369.     screen = DefaultScreen(dpy);
  1370.  
  1371.    if (!(vis = glXChooseVisual(dpy, screen, vattribs)))  {
  1372.        XtAppError(app, "desired visual can't be found");
  1373.    }
  1374.  
  1375.    /* get context */
  1376.    if (!(ctx = glXCreateContext(dpy, vis, 0, GL_TRUE))) {
  1377.        XtAppError(app, "couldn't create context");
  1378.    }
  1379.  
  1380.     XtAddEventHandler(toplevel, StructureNotifyMask, False,
  1381.               map_state_changed, NULL);
  1382.  
  1383.  
  1384.     form = XtVaCreateManagedWidget("form", 
  1385.                    xmFormWidgetClass, toplevel,
  1386.                    NULL);
  1387.  
  1388.     frame = XtVaCreateManagedWidget("frame",
  1389.                     xmFrameWidgetClass, form,
  1390.                     XmNtopAttachment, XmATTACH_FORM,
  1391.                     XmNleftAttachment, XmATTACH_FORM,
  1392.                     XmNrightAttachment, XmATTACH_FORM,
  1393.                     NULL);
  1394.  
  1395.     glxarea = XtVaCreateManagedWidget("glxarea", 
  1396.                       glwMDrawingAreaWidgetClass, frame, 
  1397.                       GLwNvisualInfo, vis, 
  1398.                       NULL);
  1399.     XtAddCallback(glxarea, XmNexposeCallback, clear_screen, NULL);
  1400.     XtAddCallback(glxarea, XmNresizeCallback, resize, NULL);
  1401.     XtAddCallback(glxarea, XmNinputCallback, mouse_input, NULL);
  1402.  
  1403.     control = XtVaCreateManagedWidget("ControlPanel",
  1404.                       xmFormWidgetClass, form,
  1405.                       XmNtopAttachment, XmATTACH_WIDGET,
  1406.                       XmNtopWidget, frame,
  1407.                       XmNleftAttachment, XmATTACH_FORM,
  1408.                       XmNrightAttachment, XmATTACH_FORM,
  1409.                       XmNbottomAttachment, XmATTACH_FORM,
  1410.                       NULL);
  1411.  
  1412.     enables = XtVaCreateManagedWidget("Enables",
  1413.                       xmRowColumnWidgetClass, control,
  1414.                       XmNtopAttachment, XmATTACH_FORM,
  1415.                       XmNleftAttachment, XmATTACH_FORM,
  1416.                       NULL);
  1417.  
  1418.     
  1419.     (void)XtVaCreateManagedWidget("title",
  1420.                   xmLabelWidgetClass, enables,
  1421.                   XtVaTypedArg, XmNlabelString, XmRString,
  1422.                   "Enables", sizeof("Enables"),
  1423.                   NULL);
  1424.  
  1425.  
  1426.     enabletex1d  = XtVaCreateManagedWidget("Tex1d",
  1427.                       xmToggleButtonWidgetClass, enables,
  1428.                       NULL);
  1429.     XtAddCallback(enabletex1d, XmNvalueChangedCallback, enable_tex_1d, NULL);
  1430.  
  1431.     enabletex2d  = XtVaCreateManagedWidget("Tex2d",
  1432.                       xmToggleButtonWidgetClass, enables,
  1433.                       NULL);
  1434.     XtAddCallback(enabletex2d, XmNvalueChangedCallback, enable_tex_2d, NULL);
  1435.  
  1436.  
  1437.     enable1d  = XtVaCreateManagedWidget("Conv1d",
  1438.                       xmToggleButtonWidgetClass, enables,
  1439.                       NULL);
  1440.     XtAddCallback(enable1d, XmNvalueChangedCallback, enable_1d, NULL);
  1441.  
  1442.     enable2d  = XtVaCreateManagedWidget("Conv2d",
  1443.                       xmToggleButtonWidgetClass, enables,
  1444.                       NULL);
  1445.     XtAddCallback(enable2d, XmNvalueChangedCallback, enable_2d, NULL);
  1446.  
  1447.     enableSep2d  = XtVaCreateManagedWidget("Sep2d",
  1448.                       xmToggleButtonWidgetClass, enables,
  1449.                       NULL);
  1450.     XtAddCallback(enableSep2d, XmNvalueChangedCallback, enable_sep_2d, NULL);
  1451.  
  1452.  
  1453.     actions = XtVaCreateManagedWidget("Actions",
  1454.                       xmRowColumnWidgetClass, control,
  1455.                       XmNtopAttachment, XmATTACH_FORM,
  1456.                       XmNrightAttachment, XmATTACH_FORM,
  1457.                       XmNleftWidget, enables,
  1458.                       NULL);
  1459.  
  1460.     draw = XtVaCreateManagedWidget("DrawPixels",
  1461.                       xmPushButtonWidgetClass, actions,
  1462.                       NULL);
  1463.     XtAddCallback(draw, XmNactivateCallback, draw_pix, NULL);
  1464.  
  1465.     readit = XtVaCreateManagedWidget("ReadPixels",
  1466.                     xmPushButtonWidgetClass, actions,
  1467.                     NULL);
  1468.     XtAddCallback(readit, XmNactivateCallback, read_pix, NULL);
  1469.  
  1470.     copy = XtVaCreateManagedWidget("CopyPixels",
  1471.                     xmPushButtonWidgetClass, actions,
  1472.                     NULL);
  1473.     XtAddCallback(copy, XmNactivateCallback, copy_pix, NULL);
  1474.  
  1475.     texmap = XtVaCreateManagedWidget("TexureMap",
  1476.                       xmPushButtonWidgetClass, actions,
  1477.                       NULL);
  1478.     XtAddCallback(texmap, XmNactivateCallback, draw_tex, NULL);
  1479.  
  1480.  
  1481.     load = XtVaCreateManagedWidget("New Image",
  1482.                     xmPushButtonWidgetClass, actions,
  1483.                     NULL);
  1484.     XtAddCallback(load, XmNactivateCallback, load_image, NULL);
  1485.  
  1486.  
  1487.     makeconv1d = XtVaCreateManagedWidget("Conv 1d",
  1488.                       xmPushButtonWidgetClass, actions,
  1489.                       NULL);
  1490.     XtAddCallback(makeconv1d, XmNactivateCallback, make_conv_1d, NULL);
  1491.  
  1492.     makeconv2d = XtVaCreateManagedWidget("Conv 2d",
  1493.                       xmPushButtonWidgetClass, actions,
  1494.                       NULL);
  1495.     XtAddCallback(makeconv2d, XmNactivateCallback, make_conv_2d, NULL);
  1496.  
  1497.     makesep2d  = XtVaCreateManagedWidget("Sep 2d",
  1498.                       xmPushButtonWidgetClass, actions,
  1499.                       NULL);
  1500.     XtAddCallback(makesep2d, XmNactivateCallback, make_sep_2d, NULL);
  1501.  
  1502.  
  1503.     getconv1dfilter  = XtVaCreateManagedWidget("Get Conv 1d",
  1504.                          xmPushButtonWidgetClass, actions,
  1505.                          NULL);
  1506.     XtAddCallback(getconv1dfilter, XmNactivateCallback, 
  1507.           get_conv_1d_filter, NULL);
  1508.  
  1509.     getconv2dfilter  = XtVaCreateManagedWidget("Get Conv 2d",
  1510.                          xmPushButtonWidgetClass, actions,
  1511.                          NULL);
  1512.     XtAddCallback(getconv2dfilter, XmNactivateCallback, 
  1513.           get_conv_2d_filter, NULL);
  1514.  
  1515.  
  1516.     getsepfilter  = XtVaCreateManagedWidget("Get Sep 2d",
  1517.                          xmPushButtonWidgetClass, actions,
  1518.                          NULL);
  1519.     XtAddCallback(getsepfilter, XmNactivateCallback, get_sep_filter, NULL);
  1520.  
  1521.     copyfilter1d  = XtVaCreateManagedWidget("Copy 1d",
  1522.                          xmPushButtonWidgetClass, actions,
  1523.                          NULL);
  1524.     XtAddCallback(copyfilter1d, XmNactivateCallback, copy_filter_1d, NULL);
  1525.  
  1526.     copyfilter2d  = XtVaCreateManagedWidget("Copy 2d",
  1527.                          xmPushButtonWidgetClass, actions,
  1528.                          NULL);
  1529.     XtAddCallback(copyfilter2d, XmNactivateCallback, copy_filter_2d, NULL);
  1530.  
  1531.     newlist  = XtVaCreateManagedWidget("glNewList",
  1532.                          xmPushButtonWidgetClass, actions,
  1533.                          NULL);
  1534.     XtAddCallback(newlist, XmNactivateCallback, new_list, NULL);
  1535.  
  1536.     endlist  = XtVaCreateManagedWidget("glEndList",
  1537.                          xmPushButtonWidgetClass, actions,
  1538.                          NULL);
  1539.     XtAddCallback(endlist, XmNactivateCallback, end_list, NULL);
  1540.  
  1541.     calllist  = XtVaCreateManagedWidget("glCallList",
  1542.                          xmPushButtonWidgetClass, actions,
  1543.                          NULL);
  1544.     XtAddCallback(calllist, XmNactivateCallback, call_list, NULL);
  1545.  
  1546.  
  1547.  
  1548.     filters = XtVaCreateManagedWidget("Filters",
  1549.                       xmRowColumnWidgetClass, control,
  1550.                       XmNtopAttachment, XmATTACH_WIDGET,
  1551.                       XmNleftAttachment, XmATTACH_FORM,
  1552.                       XmNtopWidget, enables,
  1553.                       NULL);
  1554.  
  1555.     (void)XtVaCreateManagedWidget("title",
  1556.                   xmLabelWidgetClass, filters,
  1557.                   XtVaTypedArg, XmNlabelString, XmRString,
  1558.                   "Filter", sizeof("Filter"),
  1559.                   NULL);
  1560.  
  1561.  
  1562.  
  1563.     fwidth = XtVaCreateManagedWidget("Width",
  1564.                      xmScaleWidgetClass, filters,
  1565.                      XtVaTypedArg, XmNtitleString, XmRString,
  1566.                      "Width", sizeof("Width"),
  1567.                      XmNmaximum, 11,
  1568.                      XmNminimum, 1,
  1569.                      XmNvalue, 3,
  1570.                      XmNshowValue, True,
  1571.                      XmNorientation, XmHORIZONTAL,
  1572.                      NULL);
  1573.  
  1574.     fheight = XtVaCreateManagedWidget("Height",
  1575.                      xmScaleWidgetClass, filters,
  1576.                      XtVaTypedArg, XmNtitleString, XmRString,
  1577.                      "Height", sizeof("Height"),
  1578.                      XmNmaximum, 11,
  1579.                      XmNminimum, 1,
  1580.                      XmNvalue, 3,
  1581.                      XmNshowValue, True,
  1582.                      XmNorientation, XmHORIZONTAL,
  1583.                      NULL);
  1584.  
  1585.  
  1586.     pzoom = XtVaCreateManagedWidget("Zoom",
  1587.                       xmRowColumnWidgetClass, control,
  1588.                       XmNtopAttachment, XmATTACH_WIDGET,
  1589.                       XmNrightAttachment, XmATTACH_FORM,
  1590.                       XmNtopWidget, actions,
  1591.                       NULL);
  1592.  
  1593.  
  1594.     (void)XtVaCreateManagedWidget("title",
  1595.                   xmLabelWidgetClass, pzoom,
  1596.                   XtVaTypedArg, XmNlabelString, XmRString,
  1597.                   "Zoom", sizeof("Zoom"),
  1598.                   NULL);
  1599.  
  1600.  
  1601.     xzoom = XtVaCreateManagedWidget("XZoom",
  1602.                     xmScaleWidgetClass, pzoom,
  1603.                     XtVaTypedArg, XmNtitleString, XmRString,
  1604.                     "ZoomX", sizeof("ZoomX"),
  1605.                     XmNdecimalPoints, 2,
  1606.                     XmNmaximum, 400,
  1607.                     XmNminimum, -200,
  1608.                     XmNvalue, 100,
  1609.                     XmNshowValue, True,
  1610.                     XmNorientation, XmHORIZONTAL,
  1611.                     NULL);
  1612.  
  1613.     yzoom = XtVaCreateManagedWidget("YZoom",
  1614.                     xmScaleWidgetClass, pzoom,
  1615.                     XtVaTypedArg, XmNtitleString, XmRString,
  1616.                     "ZoomY", sizeof("ZoomY"),
  1617.                     XmNdecimalPoints, 2,
  1618.                     XmNmaximum, 400,
  1619.                     XmNminimum, -200,
  1620.                     XmNvalue, 100,
  1621.                     XmNshowValue, True,
  1622.                     XmNorientation, XmHORIZONTAL,
  1623.                     NULL);
  1624.  
  1625.  
  1626.     fformat = XmStringCreateLocalized("FFormat");
  1627.     rgba = XmStringCreateLocalized("RGBA");
  1628.     rgb = XmStringCreateLocalized("RGB");
  1629.     l = XmStringCreateLocalized("L");
  1630.     la = XmStringCreateLocalized("LA");
  1631.     intens = XmStringCreateLocalized("I");
  1632.  
  1633.     filter_format = 
  1634.     XmVaCreateSimpleOptionMenu(filters, "FilterFormat",
  1635.                    fformat, 'F', 1, set_filter_format, 
  1636.                    XmVaPUSHBUTTON, rgba, 'R', NULL, NULL,
  1637.                    XmVaPUSHBUTTON, rgb, 'B', NULL, NULL,
  1638.                    XmVaPUSHBUTTON, l, 'L', NULL, NULL,
  1639.                    XmVaPUSHBUTTON, la, 'A', NULL, NULL,
  1640.                    XmVaPUSHBUTTON, intens, 'I', NULL, NULL,
  1641.                    NULL);
  1642.  
  1643.     XmStringFree(fformat);
  1644.     XmStringFree(rgba);
  1645.     XmStringFree(rgb);
  1646.     XmStringFree(l);
  1647.     XmStringFree(la);
  1648.     XmStringFree(intens);
  1649.  
  1650.     XtManageChild(filter_format);
  1651.  
  1652.  
  1653.     ftype = XmStringCreateLocalized("FType");
  1654.     fubyt = XmStringCreateLocalized("UBYTE");
  1655.     fbyt = XmStringCreateLocalized("BYTE");
  1656.     fusht = XmStringCreateLocalized("USHORT");
  1657.     fsht = XmStringCreateLocalized("SHORT");
  1658.     fuinteg = XmStringCreateLocalized("UINT");
  1659.     finteg = XmStringCreateLocalized("INT");
  1660.     fflt = XmStringCreateLocalized("FLOAT");
  1661.  
  1662.     filter_type = 
  1663.     XmVaCreateSimpleOptionMenu(filters, "FilterType",
  1664.                    ftype, 'T', 6, set_filter_type, 
  1665.                    XmVaPUSHBUTTON, fbyt, 'b', NULL, NULL,
  1666.                    XmVaPUSHBUTTON, fubyt, 'B', NULL, NULL,
  1667.                    XmVaPUSHBUTTON, fsht, 's', NULL, NULL,
  1668.                    XmVaPUSHBUTTON, fusht, 'S', NULL, NULL,
  1669.                    XmVaPUSHBUTTON, finteg, 'i', NULL, NULL,
  1670.                    XmVaPUSHBUTTON, fuinteg, 'I', NULL, NULL,
  1671.                    XmVaPUSHBUTTON, fflt, 'F', NULL, NULL,
  1672.                    NULL);
  1673.  
  1674.     XmStringFree(ftype);
  1675.     XmStringFree(fubyt);
  1676.     XmStringFree(fbyt);
  1677.     XmStringFree(fusht);
  1678.     XmStringFree(fsht);
  1679.     XmStringFree(fuinteg);
  1680.     XmStringFree(finteg);
  1681.     XmStringFree(fflt);
  1682.  
  1683.     XtManageChild(filter_type);
  1684.  
  1685.  
  1686.  
  1687.     fcont = XmStringCreateLocalized("FContents");
  1688.     box = XmStringCreateLocalized("Box");
  1689.     laplace = XmStringCreateLocalized("LaPlace");
  1690.     sobel = XmStringCreateLocalized("Sobel");
  1691.  
  1692.     filter_contents = 
  1693.     XmVaCreateSimpleOptionMenu(filters, "FilterContents",
  1694.                    fcont, 'F', 0, set_filter_contents, 
  1695.                    XmVaPUSHBUTTON, box, 'B', NULL, NULL,
  1696.                    XmVaPUSHBUTTON, laplace, 'L', NULL, NULL,
  1697.                    XmVaPUSHBUTTON, sobel, 'S', NULL, NULL,
  1698.                    NULL);
  1699.  
  1700.     XmStringFree(fcont);
  1701.     XmStringFree(laplace);
  1702.     XmStringFree(sobel);
  1703.     XmStringFree(box);
  1704.  
  1705.     XtManageChild(filter_contents);
  1706.  
  1707.     icont = XmStringCreateLocalized("IContents");
  1708.     squares = XmStringCreateLocalized("Squares");
  1709.     checks = XmStringCreateLocalized("CheckerBoard");
  1710.     files = XmStringCreateLocalized("File...");
  1711.  
  1712.     image_contents = 
  1713.     XmVaCreateSimpleOptionMenu(filters, "ImageContents",
  1714.                    icont, 'I', 0, set_image_contents, 
  1715.                    XmVaPUSHBUTTON, squares, 'S', NULL, NULL,
  1716.                    XmVaPUSHBUTTON, checks, 'C', NULL, NULL,
  1717.                    XmVaPUSHBUTTON, files, 'F', NULL, NULL,
  1718.                    NULL);
  1719.  
  1720.     XmStringFree(icont);
  1721.     XmStringFree(checks);
  1722.     XmStringFree(squares);
  1723.     XmStringFree(files);
  1724.  
  1725.     XtManageChild(image_contents);
  1726.  
  1727.     itype = XmStringCreateLocalized("IType");
  1728.     iubyt = XmStringCreateLocalized("UBYTE");
  1729.     ibyt = XmStringCreateLocalized("BYTE");
  1730.     iusht = XmStringCreateLocalized("USHORT");
  1731.     isht = XmStringCreateLocalized("SHORT");
  1732.     iuinteg = XmStringCreateLocalized("UINT");
  1733.     iinteg = XmStringCreateLocalized("INT");
  1734.     iflt = XmStringCreateLocalized("FLOAT");
  1735.  
  1736.     image_type = 
  1737.     XmVaCreateSimpleOptionMenu(filters, "ImageType",
  1738.                    itype, 'I', 6, set_image_type, 
  1739.                    XmVaPUSHBUTTON, ibyt, 'b', NULL, NULL,
  1740.                    XmVaPUSHBUTTON, iubyt, 'B', NULL, NULL,
  1741.                    XmVaPUSHBUTTON, isht, 's', NULL, NULL,
  1742.                    XmVaPUSHBUTTON, iusht, 'S', NULL, NULL,
  1743.                    XmVaPUSHBUTTON, iinteg, 'i', NULL, NULL,
  1744.                    XmVaPUSHBUTTON, iuinteg, 'I', NULL, NULL,
  1745.                    XmVaPUSHBUTTON, iflt, 'F', NULL, NULL,
  1746.                    NULL);
  1747.  
  1748.     XmStringFree(itype);
  1749.     XmStringFree(iubyt);
  1750.     XmStringFree(ibyt);
  1751.     XmStringFree(iusht);
  1752.     XmStringFree(isht);
  1753.     XmStringFree(iuinteg);
  1754.     XmStringFree(iinteg);
  1755.     XmStringFree(iflt);
  1756.  
  1757.     XtManageChild(image_type);
  1758.  
  1759.     
  1760.     iformat = XmStringCreateLocalized("IFormat");
  1761.     rgba = XmStringCreateLocalized("RGBA");
  1762.     rgb = XmStringCreateLocalized("RGB");
  1763.     l = XmStringCreateLocalized("L");
  1764.     la = XmStringCreateLocalized("LA");
  1765.     intens = XmStringCreateLocalized("I");
  1766.  
  1767.     image_format = 
  1768.     XmVaCreateSimpleOptionMenu(filters, "ImageFormat",
  1769.                    iformat, 'I', 1, set_image_format, 
  1770.                    XmVaPUSHBUTTON, rgba, 'R', NULL, NULL,
  1771.                    XmVaPUSHBUTTON, rgb, 'B', NULL, NULL,
  1772.                    XmVaPUSHBUTTON, l, 'L', NULL, NULL,
  1773.                    XmVaPUSHBUTTON, la, 'A', NULL, NULL,
  1774.                    XmVaPUSHBUTTON, intens, 'I', NULL, NULL,
  1775.                    NULL);
  1776.  
  1777.     XmStringFree(iformat);
  1778.     XmStringFree(rgba);
  1779.     XmStringFree(rgb);
  1780.     XmStringFree(l);
  1781.     XmStringFree(la);
  1782.     XmStringFree(intens);
  1783.  
  1784.     XtManageChild(image_format);
  1785.  
  1786.  
  1787.  
  1788.     XtRealizeWidget(toplevel);
  1789.  
  1790.     glXMakeCurrent(dpy, XtWindow(glxarea), ctx);
  1791.     made_current = GL_TRUE;
  1792.     
  1793.     glDisable(GL_DITHER);
  1794.  
  1795.     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
  1796.  
  1797.    /* Default Enables */
  1798.  
  1799.     check_error("Clear Errors");
  1800.  
  1801.     image.wid = 256;
  1802.     image.ht = 256;
  1803.     image.x = 0;
  1804.     image.y = 0;
  1805.     image.width = 128;
  1806.     image.height = 128;
  1807.     image.rasterposx = 0.0;
  1808.     image.rasterposy = 0.0;
  1809.     image.contents = SQUARES;
  1810.     image.type = GL_FLOAT;
  1811.     image.format = GL_RGB;
  1812.     make_image(&image);
  1813.  
  1814.     filter.width = 3;
  1815.     filter.height = 3;
  1816.     filter.format = GL_RGB;
  1817.     filter.type = GL_FLOAT;
  1818.     filter.internalformat = GL_RGB;
  1819.     filter.get_target = GL_CONVOLUTION_2D_EXT;
  1820.     filter.get_format = GL_RGBA;
  1821.     filter.get_type = GL_FLOAT;
  1822.     filter.contents = BOX;
  1823.     make_filter(&filter);
  1824.  
  1825.     XtAppMainLoop(app);
  1826. }
  1827.