home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / software / sviluppo / mesa-tk / samples.tk / texture.c < prev    next >
C/C++ Source or Header  |  1998-05-13  |  8KB  |  497 lines
  1. /*
  2.  * Copyright (c) 1991, 1992, 1993 Silicon Graphics, Inc.
  3.  *
  4.  * Permission to use, copy, modify, distribute, and sell this software and
  5.  * its documentation for any purpose is hereby granted without fee, provided
  6.  * that (i) the above copyright notices and this permission notice appear in
  7.  * all copies of the software and related documentation, and (ii) the name of
  8.  * Silicon Graphics may not be used in any advertising or
  9.  * publicity relating to the software without the specific, prior written
  10.  * permission of Silicon Graphics.
  11.  *
  12.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF
  13.  * ANY KIND,
  14.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  15.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  16.  *
  17.  * IN NO EVENT SHALL SILICON GRAPHICS BE LIABLE FOR
  18.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  19.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  20.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  21.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  22.  * OF THIS SOFTWARE.
  23.  */
  24.  
  25. #include <stdio.h>
  26. #include <string.h>
  27. #include <sys/types.h>
  28. #include <sys/stat.h>
  29. #include <fcntl.h>
  30. #include <unistd.h>
  31. #include <math.h>
  32. #include <stdlib.h>
  33. #include "gltk.h"
  34.  
  35. GLenum doubleBuffer, directRender;
  36.  
  37. char *texFileName = 0;
  38. TK_RGBImageRec *image;
  39.  
  40. float *minFilter, *magFilter, *sWrapMode, *tWrapMode;
  41. float decal[] =
  42. {GL_DECAL};
  43. float modulate[] =
  44. {GL_MODULATE};
  45. float repeat[] =
  46. {GL_REPEAT};
  47. float clamp[] =
  48. {GL_CLAMP};
  49. float nr[] =
  50. {GL_NEAREST};
  51. float ln[] =
  52. {GL_LINEAR};
  53. float nr_mipmap_nr[] =
  54. {GL_NEAREST_MIPMAP_NEAREST};
  55. float nr_mipmap_ln[] =
  56. {GL_NEAREST_MIPMAP_LINEAR};
  57. float ln_mipmap_nr[] =
  58. {GL_LINEAR_MIPMAP_NEAREST};
  59. float ln_mipmap_ln[] =
  60. {GL_LINEAR_MIPMAP_LINEAR};
  61. GLint sphereMap[] =
  62. {GL_SPHERE_MAP};
  63.  
  64. GLenum doSphere = GL_FALSE;
  65. float xRotation = 0.0, yRotation = 0.0, zTranslate = -3.125;
  66.  
  67. GLint cube;
  68. float c[6][4][3] =
  69. {
  70.   {
  71.     {
  72.       1.0, 1.0, -1.0
  73.     },
  74.     {
  75.       -1.0, 1.0, -1.0
  76.     },
  77.     {
  78.       -1.0, -1.0, -1.0
  79.     },
  80.     {
  81.       1.0, -1.0, -1.0
  82.     }
  83.   },
  84.   {
  85.     {
  86.       1.0, 1.0, 1.0
  87.     },
  88.     {
  89.       1.0, 1.0, -1.0
  90.     },
  91.     {
  92.       1.0, -1.0, -1.0
  93.     },
  94.     {
  95.       1.0, -1.0, 1.0
  96.     }
  97.   },
  98.   {
  99.     {
  100.       -1.0, 1.0, 1.0
  101.     },
  102.     {
  103.       1.0, 1.0, 1.0
  104.     },
  105.     {
  106.       1.0, -1.0, 1.0
  107.     },
  108.     {
  109.       -1.0, -1.0, 1.0
  110.     }
  111.   },
  112.   {
  113.     {
  114.       -1.0, 1.0, -1.0
  115.     },
  116.     {
  117.       -1.0, 1.0, 1.0
  118.     },
  119.     {
  120.       -1.0, -1.0, 1.0
  121.     },
  122.     {
  123.       -1.0, -1.0, -1.0
  124.     }
  125.   },
  126.   {
  127.     {
  128.       -1.0, 1.0, 1.0
  129.     },
  130.     {
  131.       -1.0, 1.0, -1.0
  132.     },
  133.     {
  134.       1.0, 1.0, -1.0
  135.     },
  136.     {
  137.       1.0, 1.0, 1.0
  138.     }
  139.   },
  140.   {
  141.     {
  142.       -1.0, -1.0, -1.0
  143.     },
  144.     {
  145.       -1.0, -1.0, 1.0
  146.     },
  147.     {
  148.       1.0, -1.0, 1.0
  149.     },
  150.     {
  151.       1.0, -1.0, -1.0
  152.     }
  153.   }
  154. };
  155. static float n[6][3] =
  156. {
  157.   {
  158.     0.0, 0.0, -1.0
  159.   },
  160.   {
  161.     1.0, 0.0, 0.0
  162.   },
  163.   {
  164.     0.0, 0.0, 1.0
  165.   },
  166.   {
  167.     -1.0, 0.0, 0.0
  168.   },
  169.   {
  170.     0.0, 1.0, 0.0
  171.   },
  172.   {
  173.     0.0, -1.0, 0.0
  174.   }
  175. };
  176. static float t[6][4][2] =
  177. {
  178.   {
  179.     {
  180.       1.1, 1.1
  181.     },
  182.     {
  183.       -0.1, 1.1
  184.     },
  185.     {
  186.       -0.1, -0.1
  187.     },
  188.     {
  189.       1.1, -0.1
  190.     }
  191.   },
  192.   {
  193.     {
  194.       1.1, 1.1
  195.     },
  196.     {
  197.       -0.1, 1.1
  198.     },
  199.     {
  200.       -0.1, -0.1
  201.     },
  202.     {
  203.       1.1, -0.1
  204.     }
  205.   },
  206.   {
  207.     {
  208.       -0.1, 1.1
  209.     },
  210.     {
  211.       1.1, 1.1
  212.     },
  213.     {
  214.       1.1, -0.1
  215.     },
  216.     {
  217.       -0.1, -0.1
  218.     }
  219.   },
  220.   {
  221.     {
  222.       1.1, 1.1
  223.     },
  224.     {
  225.       -0.1, 1.1
  226.     },
  227.     {
  228.       -0.1, -0.1
  229.     },
  230.     {
  231.       1.1, -0.1
  232.     }
  233.   },
  234.   {
  235.     {
  236.       1.1, 1.1
  237.     },
  238.     {
  239.       -0.1, 1.1
  240.     },
  241.     {
  242.       -0.1, -0.1
  243.     },
  244.     {
  245.       1.1, -0.1
  246.     }
  247.   },
  248.   {
  249.     {
  250.       1.1, 1.1
  251.     },
  252.     {
  253.       -0.1, 1.1
  254.     },
  255.     {
  256.       -0.1, -0.1
  257.     },
  258.     {
  259.       1.1, -0.1
  260.     }
  261.   },
  262. };
  263.  
  264. static void BuildCube(void)
  265. {
  266.   GLint i;
  267.  
  268.   glNewList(cube, GL_COMPILE);
  269.   for (i = 0; i < 6; i++) {
  270.     glBegin(GL_POLYGON);
  271.     glNormal3fv(n[i]);
  272.     glTexCoord2fv(t[i][0]);
  273.     glVertex3fv(c[i][0]);
  274.     glNormal3fv(n[i]);
  275.     glTexCoord2fv(t[i][1]);
  276.     glVertex3fv(c[i][1]);
  277.     glNormal3fv(n[i]);
  278.     glTexCoord2fv(t[i][2]);
  279.     glVertex3fv(c[i][2]);
  280.     glNormal3fv(n[i]);
  281.     glTexCoord2fv(t[i][3]);
  282.     glVertex3fv(c[i][3]);
  283.     glEnd();
  284.   }
  285.   glEndList();
  286. }
  287.  
  288. static void BuildLists(void)
  289. {
  290.  
  291.   cube = glGenLists(1);
  292.   BuildCube();
  293. }
  294.  
  295. static void Init(void)
  296. {
  297.  
  298.   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  299.   gluBuild2DMipmaps(GL_TEXTURE_2D, 3, image->sizeX, image->sizeY,
  300.             GL_RGB, GL_UNSIGNED_BYTE, image->data);
  301.   glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, decal);
  302.   glEnable(GL_TEXTURE_2D);
  303.  
  304.   glFrontFace(GL_CCW);
  305.   glCullFace(GL_FRONT);
  306.   glEnable(GL_CULL_FACE);
  307.  
  308.   BuildLists();
  309.  
  310.   glClearColor(0.0, 0.0, 0.0, 0.0);
  311.  
  312.   magFilter = nr;
  313.   minFilter = nr;
  314.   sWrapMode = repeat;
  315.   tWrapMode = repeat;
  316. }
  317.  
  318. static void Reshape(int width, int height)
  319. {
  320.  
  321.   glViewport(0, 0, (GLint) width, (GLint) height);
  322.  
  323.   glMatrixMode(GL_PROJECTION);
  324.   glLoadIdentity();
  325.   gluPerspective(145.0, 1.0, 0.01, 1000);
  326.   glMatrixMode(GL_MODELVIEW);
  327. }
  328.  
  329. static GLenum Key(int key, GLenum mask)
  330. {
  331.  
  332.   switch (key) {
  333.     case TK_ESCAPE:
  334.       tkQuit();
  335.  
  336.     case TK_LEFT:
  337.       yRotation -= 0.5;
  338.       break;
  339.     case TK_RIGHT:
  340.       yRotation += 0.5;
  341.       break;
  342.     case TK_UP:
  343.       xRotation -= 0.5;
  344.       break;
  345.     case TK_DOWN:
  346.       xRotation += 0.5;
  347.       break;
  348.     case TK_T:
  349.       zTranslate += 0.25;
  350.       break;
  351.     case TK_t:
  352.       zTranslate -= 0.25;
  353.       break;
  354.  
  355.     case TK_s:
  356.       doSphere = !doSphere;
  357.       if (doSphere) {
  358.     glTexGeniv(GL_S, GL_TEXTURE_GEN_MODE, sphereMap);
  359.     glTexGeniv(GL_T, GL_TEXTURE_GEN_MODE, sphereMap);
  360.     glEnable(GL_TEXTURE_GEN_S);
  361.     glEnable(GL_TEXTURE_GEN_T);
  362.       }
  363.       else {
  364.     glDisable(GL_TEXTURE_GEN_S);
  365.     glDisable(GL_TEXTURE_GEN_T);
  366.       }
  367.       break;
  368.  
  369.     case TK_0:
  370.       magFilter = nr;
  371.       break;
  372.     case TK_1:
  373.       magFilter = ln;
  374.       break;
  375.     case TK_2:
  376.       minFilter = nr;
  377.       break;
  378.     case TK_3:
  379.       minFilter = ln;
  380.       break;
  381.     case TK_4:
  382.       minFilter = nr_mipmap_nr;
  383.       break;
  384.     case TK_5:
  385.       minFilter = nr_mipmap_ln;
  386.       break;
  387.     case TK_6:
  388.       minFilter = ln_mipmap_nr;
  389.       break;
  390.     case TK_7:
  391.       minFilter = ln_mipmap_ln;
  392.       break;
  393.  
  394.     default:
  395.       return GL_FALSE;
  396.   }
  397.   return GL_TRUE;
  398. }
  399.  
  400. static void Draw(void)
  401. {
  402.  
  403.   glClear(GL_COLOR_BUFFER_BIT);
  404.  
  405.   glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, sWrapMode);
  406.   glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, tWrapMode);
  407.   glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
  408.   glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
  409.  
  410.   glPushMatrix();
  411.  
  412.   glTranslatef(0.0, 0.0, zTranslate);
  413.   glRotatef(xRotation, 1, 0, 0);
  414.   glRotatef(yRotation, 0, 1, 0);
  415.   glCallList(cube);
  416.  
  417.   glPopMatrix();
  418.  
  419.   glFlush();
  420.  
  421.   if (doubleBuffer) {
  422.     tkSwapBuffers();
  423.   }
  424. }
  425.  
  426. static GLenum Args(int argc, char **argv)
  427. {
  428.   GLint i;
  429.  
  430.   doubleBuffer = GL_FALSE;
  431.   directRender = GL_TRUE;
  432.  
  433.   for (i = 1; i < argc; i++) {
  434.     if (strcmp(argv[i], "-sb") == 0) {
  435.       doubleBuffer = GL_FALSE;
  436.     }
  437.     else if (strcmp(argv[i], "-db") == 0) {
  438.       doubleBuffer = GL_TRUE;
  439.     }
  440.     else if (strcmp(argv[i], "-dr") == 0) {
  441.       directRender = GL_TRUE;
  442.     }
  443.     else if (strcmp(argv[i], "-ir") == 0) {
  444.       directRender = GL_FALSE;
  445.     }
  446.     else if (strcmp(argv[i], "-f") == 0) {
  447.       if (i + 1 >= argc || argv[i + 1][0] == '-') {
  448.     printf("-f (No file name).\n");
  449.     return GL_FALSE;
  450.       }
  451.       else {
  452.     texFileName = argv[++i];
  453.       }
  454.     }
  455.     else {
  456.       printf("%s (Bad option).\n", argv[i]);
  457.       return GL_FALSE;
  458.     }
  459.   }
  460.   return GL_TRUE;
  461. }
  462.  
  463. void main(int argc, char **argv)
  464. {
  465.   GLenum type;
  466.  
  467.   if (Args(argc, argv) == GL_FALSE) {
  468.     tkQuit();
  469.   }
  470.  
  471.   if (texFileName == 0) {
  472.     printf("No image file.\n");
  473.     tkQuit();
  474.   }
  475.  
  476.   image = tkRGBImageLoad(texFileName);
  477.  
  478.   tkInitPosition(0, 0, 300, 300);
  479.  
  480.   type = TK_RGB;
  481.   type |= (doubleBuffer) ? TK_DOUBLE : TK_SINGLE;
  482.   type |= (directRender) ? TK_DIRECT : TK_INDIRECT;
  483.   tkInitDisplayMode(type);
  484.  
  485.   if (tkInitWindow("Texture Test") == GL_FALSE) {
  486.     tkQuit();
  487.   }
  488.  
  489.   Init();
  490.  
  491.   tkExposeFunc(Reshape);
  492.   tkReshapeFunc(Reshape);
  493.   tkKeyDownFunc(Key);
  494.   tkDisplayFunc(Draw);
  495.   tkExec();
  496. }
  497.