home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / newopg.zip / STRETCH.C < prev    next >
Text File  |  1995-03-04  |  8KB  |  344 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <sys/types.h>
  5. #include <sys/stat.h>
  6. #include <malloc.h>
  7. #include <fcntl.h>
  8. //#include <unistd.h>
  9. #include <math.h>
  10. #include "tk.h"
  11.  
  12.  
  13. #define STEPCOUNT 40
  14. #define FALSE 0
  15. #define TRUE 1
  16. #define MAX(a, b) (((a) > (b)) ? (a) : (b))
  17. #define MIN(a, b) (((a) < (b)) ? (a) : (b))
  18.  
  19.  
  20. enum {
  21.     OP_NOOP = 0,
  22.     OP_STRETCH,
  23.     OP_DRAWPOINT,
  24.     OP_DRAWIMAGE
  25. };
  26.  
  27.  
  28. typedef struct _cRec {
  29.     float x, y;
  30. } cRec;
  31.  
  32. typedef struct _vertexRec {
  33.     float x, y;
  34.     float dX, dY;
  35.     float tX, tY;
  36. } vertexRec;
  37.  
  38.  
  39. GLenum doubleBuffer, directRender;
  40. int imageSizeX, imageSizeY;
  41. char *fileName = 0;
  42. TK_RGBImageRec *image;
  43. cRec cList[50];
  44. vertexRec vList[5];
  45. int cCount, cIndex[2], cStep;
  46. GLenum op = OP_NOOP;
  47.  
  48.  
  49. void DrawImage(void)
  50. {
  51.  
  52.     glRasterPos2i(0, 0);
  53.     glDrawPixels(image->sizeX, image->sizeY, GL_RGB, GL_UNSIGNED_BYTE,
  54.          image->data);
  55.  
  56.     glFlush();
  57.     if (doubleBuffer) {
  58.     tkSwapBuffers();
  59.     }
  60.  
  61.     glRasterPos2i(0, 0);
  62.     glDrawPixels(image->sizeX, image->sizeY, GL_RGB, GL_UNSIGNED_BYTE,
  63.          image->data);
  64. }
  65.  
  66. void DrawPoint(void)
  67. {
  68.     int i;
  69.  
  70.     glColor3f(1.0, 0.0, 1.0);
  71.     glPointSize(3.0);
  72.     glBegin(GL_POINTS);
  73.     for (i = 0; i < cCount; i++) {
  74.         glVertex2f(cList[i].x, cList[i].y);
  75.     }
  76.     glEnd();
  77.  
  78.     glFlush();
  79.     if (doubleBuffer) {
  80.     tkSwapBuffers();
  81.     }
  82. }
  83.  
  84. void InitVList(void)
  85. {
  86.  
  87.     vList[0].x = 0.0;
  88.     vList[0].y = 0.0;
  89.     vList[0].dX = 0.0;
  90.     vList[0].dY = 0.0;
  91.     vList[0].tX = 0.0;
  92.     vList[0].tY = 0.0;
  93.  
  94.     vList[1].x = (float)imageSizeX;
  95.     vList[1].y = 0.0;
  96.     vList[1].dX = 0.0;
  97.     vList[1].dY = 0.0;
  98.     vList[1].tX = 1.0;
  99.     vList[1].tY = 0.0;
  100.  
  101.     vList[2].x = (float)imageSizeX;
  102.     vList[2].y = (float)imageSizeY;
  103.     vList[2].dX = 0.0;
  104.     vList[2].dY = 0.0;
  105.     vList[2].tX = 1.0;
  106.     vList[2].tY = 1.0;
  107.  
  108.     vList[3].x = 0.0;
  109.     vList[3].y = (float)imageSizeY;
  110.     vList[3].dX = 0.0;
  111.     vList[3].dY = 0.0;
  112.     vList[3].tX = 0.0;
  113.     vList[3].tY = 1.0;
  114.  
  115.     vList[4].x = cList[0].x;
  116.     vList[4].y = cList[0].y;
  117.     vList[4].dX = (cList[1].x - cList[0].x) / STEPCOUNT;
  118.     vList[4].dY = (cList[1].y - cList[0].y) / STEPCOUNT;
  119.     vList[4].tX = cList[0].x / (float)imageSizeX;
  120.     vList[4].tY = cList[0].y / (float)imageSizeY;
  121. }
  122.  
  123. void ScaleImage(int sizeX, int sizeY)
  124. {
  125.     GLubyte *buf;
  126.  
  127.     buf = (GLubyte *)malloc(3*sizeX*sizeY);
  128.     gluScaleImage(GL_RGB, image->sizeX, image->sizeY, GL_UNSIGNED_BYTE,
  129.                   image->data, sizeX, sizeY, GL_UNSIGNED_BYTE, buf);
  130.     free(image->data);
  131.     image->data = buf;
  132.     image->sizeX = sizeX;
  133.     image->sizeY = sizeY;
  134. }
  135.  
  136. void SetPoint(int x, int y)
  137. {
  138.  
  139.     cList[cCount].x = (float)x;
  140.     cList[cCount].y = (float)y;
  141.     cCount++;
  142. }
  143.  
  144. void Stretch(void)
  145. {
  146.  
  147.     glBegin(GL_TRIANGLES);
  148.     glTexCoord2f(vList[0].tX, vList[0].tY);
  149.     glVertex2f(vList[0].x, vList[0].y);
  150.     glTexCoord2f(vList[1].tX, vList[1].tY);
  151.     glVertex2f(vList[1].x, vList[1].y);
  152.     glTexCoord2f(vList[4].tX, vList[4].tY);
  153.     glVertex2f(vList[4].x, vList[4].y);
  154.     glEnd();
  155.  
  156.     glBegin(GL_TRIANGLES);
  157.     glTexCoord2f(vList[1].tX, vList[1].tY);
  158.     glVertex2f(vList[1].x, vList[1].y);
  159.     glTexCoord2f(vList[2].tX, vList[2].tY);
  160.     glVertex2f(vList[2].x, vList[2].y);
  161.     glTexCoord2f(vList[4].tX, vList[4].tY);
  162.     glVertex2f(vList[4].x, vList[4].y);
  163.     glEnd();
  164.  
  165.     glBegin(GL_TRIANGLES);
  166.     glTexCoord2f(vList[2].tX, vList[2].tY);
  167.     glVertex2f(vList[2].x, vList[2].y);
  168.     glTexCoord2f(vList[3].tX, vList[3].tY);
  169.     glVertex2f(vList[3].x, vList[3].y);
  170.     glTexCoord2f(vList[4].tX, vList[4].tY);
  171.     glVertex2f(vList[4].x, vList[4].y);
  172.     glEnd();
  173.  
  174.     glBegin(GL_TRIANGLES);
  175.     glTexCoord2f(vList[3].tX, vList[3].tY);
  176.     glVertex2f(vList[3].x, vList[3].y);
  177.     glTexCoord2f(vList[0].tX, vList[0].tY);
  178.     glVertex2f(vList[0].x, vList[0].y);
  179.     glTexCoord2f(vList[4].tX, vList[4].tY);
  180.     glVertex2f(vList[4].x, vList[4].y);
  181.     glEnd();
  182.  
  183.     glFlush();
  184.     if (doubleBuffer) {
  185.     tkSwapBuffers();
  186.     }
  187.  
  188.     if (++cStep < STEPCOUNT) {
  189.     vList[4].x += vList[4].dX;
  190.     vList[4].y += vList[4].dY;
  191.     } else {
  192.     cIndex[0] = cIndex[1];
  193.     cIndex[1] = cIndex[1] + 1;
  194.     if (cIndex[1] == cCount) {
  195.         cIndex[1] = 0;
  196.     }
  197.     vList[4].dX = (cList[cIndex[1]].x - cList[cIndex[0]].x) / STEPCOUNT;
  198.     vList[4].dY = (cList[cIndex[1]].y - cList[cIndex[0]].y) / STEPCOUNT;
  199.     cStep = 0;
  200.     }
  201. }
  202.  
  203. GLenum Key(int key, GLenum mask)
  204. {
  205.  
  206.     switch (key) {
  207.       case TK_ESCAPE:
  208.     free(image->data);
  209.         tkQuit();
  210.       case TK_SPACE:
  211.     if (cCount > 1) {
  212.         InitVList();
  213.         cIndex[0] = 0;
  214.         cIndex[1] = 1;
  215.         cStep = 0;
  216.         glEnable(GL_TEXTURE_2D);
  217.         op = OP_STRETCH;
  218.     }
  219.     break;
  220.       default:
  221.     return GL_FALSE;
  222.     }
  223.     return GL_TRUE;
  224. }
  225.  
  226. GLenum Mouse(int mouseX, int mouseY, GLenum button)
  227. {
  228.  
  229.     if (op == OP_STRETCH) {
  230.     glDisable(GL_TEXTURE_2D);
  231.     cCount = 0;
  232.     op = OP_DRAWIMAGE;
  233.     } else {
  234.     SetPoint(mouseX, imageSizeY-mouseY);
  235.     op = OP_DRAWPOINT;
  236.     }
  237.     return GL_TRUE;
  238. }
  239.  
  240. void Animate(void)
  241. {
  242.  
  243.     switch (op) {
  244.       case OP_STRETCH:
  245.     Stretch();
  246.     break;
  247.       case OP_DRAWPOINT:
  248.     DrawPoint();
  249.     break;
  250.       case OP_DRAWIMAGE:
  251.     DrawImage();
  252.     break;
  253.     }
  254. }
  255.  
  256. static GLenum Args(int argc, char **argv)
  257. {
  258.     GLint i;
  259.  
  260.     doubleBuffer = GL_FALSE;
  261.     directRender = GL_TRUE;
  262.  
  263.     for (i = 1; i < argc; i++) {
  264.     if (strcmp(argv[i], "-sb") == 0) {
  265.         doubleBuffer = GL_FALSE;
  266.     } else if (strcmp(argv[i], "-db") == 0) {
  267.         doubleBuffer = GL_TRUE;
  268.     } else if (strcmp(argv[i], "-dr") == 0) {
  269.         directRender = GL_TRUE;
  270.     } else if (strcmp(argv[i], "-ir") == 0) {
  271.         directRender = GL_FALSE;
  272.     } else if (strcmp(argv[i], "-f") == 0) {
  273.         if (i+1 >= argc || argv[i+1][0] == '-') {
  274.         printf("-f (No file name).\n");
  275.         return GL_FALSE;
  276.         } else {
  277.         fileName = argv[++i];
  278.         }
  279.     } else {
  280.         printf("%s (Bad option).\n", argv[i]);
  281.         return GL_FALSE;
  282.     }
  283.     }
  284.     return GL_TRUE;
  285. }
  286.  
  287. void main(int argc, char **argv)
  288. {
  289.     GLenum type;
  290.  
  291.     if (Args(argc, argv) == GL_FALSE) {
  292.     tkQuit();
  293.     }
  294.  
  295.     if (fileName == 0) {
  296.     printf("No image file.\n");
  297.     tkQuit();
  298.     }
  299.  
  300.     image = tkRGBImageLoad(fileName);
  301.  
  302.     imageSizeX = (int)pow(2.0, (float)((int)(log(image->sizeX)/log(2.0))));
  303.     imageSizeY = (int)pow(2.0, (float)((int)(log(image->sizeY)/log(2.0))));
  304.  
  305.     tkInitPosition(0, 0, imageSizeX, imageSizeY);
  306.  
  307.     type = TK_RGB;
  308.     type |= (doubleBuffer) ? TK_DOUBLE : TK_SINGLE;
  309.     type |= (directRender) ? TK_DIRECT : TK_INDIRECT;
  310.     tkInitDisplayMode(type);
  311.  
  312.     if (tkInitWindow("Stretch") == GL_FALSE) {
  313.         tkQuit();
  314.     }
  315.  
  316.     glViewport(0, 0, imageSizeX, imageSizeY);
  317.     gluOrtho2D(0, imageSizeX, 0, imageSizeY);
  318.     glClearColor(0.0, 0.0, 0.0, 0.0);
  319.  
  320.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  321.     glPixelStorei(GL_PACK_ALIGNMENT, 1);
  322.  
  323.     ScaleImage(imageSizeX, imageSizeY);
  324.  
  325.     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
  326.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
  327.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
  328.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  329.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  330.     glTexImage2D(GL_TEXTURE_2D, 0, 3, image->sizeX, image->sizeY, 0,
  331.                  GL_RGB, GL_UNSIGNED_BYTE, (unsigned char *)image->data);
  332.  
  333.     cCount = 0;
  334.     cIndex[0] = 0;
  335.     cIndex[1] = 0;
  336.     cStep = 0;
  337.     op = OP_DRAWIMAGE;
  338.  
  339.     tkKeyDownFunc(Key);
  340.     tkMouseDownFunc(Mouse);
  341.     tkIdleFunc(Animate);
  342.     tkExec();
  343. }
  344.