home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 5 / MA_Cover_5.iso / ppc / mesa / demos / stex3d.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  14.2 KB  |  560 lines
  1. /*----------------------------- 
  2.  * stex3d.c GL example of the mesa 3d-texture extention to simulate procedural
  3.  *            texturing, it uses a perlin noise and turbulence functions.
  4.  * 
  5.  * Author:   Daniel Barrero
  6.  *           barrero@irit.fr
  7.  *           dbarrero@pegasus.uniandes.edu.co
  8.  *      
  9.  * cc stex3d.c -o stex3d -lMesaGLU -lMesaGL -lMesatk -lX11 -lXext -lm 
  10.  *
  11.  *---------------------------- */
  12.  
  13. #include <string.h>
  14. #include <stdio.h>
  15. #include <stdlib.h>
  16. #include <math.h>
  17. #include <GL/gl.h>
  18. /*#include "gltkmesa.h"*/
  19. #include "gltk.h"
  20. /* function declarations */
  21. #ifndef M_PI
  22. #define M_PI            3.14159265358979323846
  23. #endif
  24.  
  25. void init(void),
  26.      printHelp(void),
  27.      create3Dtexture(void),
  28.      setDefaults(void),
  29.      drawScene(void),
  30.      resize(int w, int h),
  31.      buildFigure(void),
  32.      initNoise(void);
  33. float turbulence(float point[3], float lofreq, float hifreq);
  34.  
  35. int isExtSupported(char *ext);
  36. GLenum keyHandler(int key, GLenum mask),
  37.        parseCmdLine(int argc, char **argv);
  38. float noise3(float vec[3]);
  39.       
  40. /* global variables */
  41. GLenum rgb, doubleBuffer, directRender, windType; /* visualization state*/
  42. float tex_width,tex_height,tex_depth;        /* texture volume dimensions  */
  43. unsigned char *voxels;                       /* texture data ptr */
  44. int angx,angy,angz;
  45. GLuint figure;
  46.  
  47. /*function definitions */
  48. void main(int argc, char **argv)
  49. {
  50.  
  51.  if (parseCmdLine(argc, argv) == GL_FALSE) {
  52.     tkQuit();
  53.  }
  54.  
  55.  tkInitPosition(0, 0, 400, 400);
  56.  windType = (rgb) ? TK_RGB : TK_INDEX;
  57.  windType |= (doubleBuffer) ? TK_DOUBLE : TK_SINGLE;
  58.  windType |= (directRender) ? TK_DIRECT : TK_INDIRECT;
  59.  windType |= TK_DEPTH;
  60.  tkInitDisplayMode(windType);
  61.  
  62.  if (tkInitWindow("stex3d") == GL_FALSE) {
  63.      tkQuit();
  64.  }
  65.  /* init all */
  66.  init();
  67.  
  68.  tkExposeFunc(resize);
  69.  tkReshapeFunc(resize);
  70.  tkKeyDownFunc(keyHandler);
  71.  tkDisplayFunc(drawScene);
  72.  tkExec();
  73. }
  74.  
  75. void init()
  76. { 
  77.  /* init light */
  78.  GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
  79.  GLfloat mat_shininess[] = { 25.0 };
  80.  GLfloat gray[] = { 0.6, 0.6, 0.6, 0.0 };
  81.  GLfloat white[] = { 1.0, 1.0, 1.0, 0.0 };
  82.  GLfloat light_position[] = { 0.0, 1.0, 1.0, 0.0 };
  83.  
  84.  glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  85.  glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
  86.  glLightfv(GL_LIGHT1, GL_POSITION, light_position);
  87.  glLightfv(GL_LIGHT1, GL_AMBIENT, gray);
  88.  glLightfv(GL_LIGHT1, GL_DIFFUSE, white);
  89.  glLightfv(GL_LIGHT1, GL_SPECULAR, white);
  90.  glColorMaterial(GL_FRONT, GL_DIFFUSE);
  91.  glEnable(GL_COLOR_MATERIAL);
  92.  glEnable(GL_LIGHTING);
  93.  glEnable(GL_LIGHT1);
  94.  
  95.  /* create torus for texturing */
  96.  figure=glGenLists(1); 
  97.  buildFigure();
  98. /* tkSolidTorus(figure,0.3,1.2);*/
  99.  
  100.  /* start the noise function variables */
  101.  initNoise();
  102.  
  103.  /* see if the texture 3d extention is supported */
  104.  if (!isExtSupported("GL_EXT_texture3D")) {
  105.    printf("Sorry this GL implementation (%s) does not support 3d texture extentions\n",
  106.     (char *)(glGetString(GL_RENDERER)));
  107. /*   tkQuit();*/
  108.  }
  109.  
  110.  /* if texture is supported then generate the texture */
  111.  create3Dtexture(); 
  112.  
  113.  glEnable(GL_TEXTURE_3D_EXT); 
  114.  /*
  115.  glBlendFunc(GL_SRC_COLOR, GL_SRC_ALPHA);
  116.  glEnable(GL_BLEND); 
  117.  */
  118.  glEnable(GL_DEPTH_TEST);
  119.  
  120.  glShadeModel(GL_FLAT);
  121.  glColor3f(0.6,0.7,0.8);
  122. }
  123.  
  124. void buildFigure(void)
  125. {   GLint i, j;
  126.     float theta1, phi1, theta2, phi2, rings, sides;
  127.     float v0[03], v1[3], v2[3], v3[3];
  128.     float t0[03], t1[3], t2[3], t3[3];
  129.     float n0[3], n1[3], n2[3], n3[3];
  130.     float innerRadius=0.4;
  131.     float outerRadius=0.8;
  132.     float scalFac;
  133.  
  134.     rings = 8;
  135.     sides = 10;
  136.     scalFac=1/(outerRadius*2);
  137.  
  138.     glNewList(figure, GL_COMPILE);
  139.     for (i = 0; i < rings; i++) {
  140.     theta1 = (float)i * 2.0 * M_PI / rings;
  141.     theta2 = (float)(i + 1) * 2.0 * M_PI / rings;
  142.     for (j = 0; j < sides; j++) {
  143.         phi1 = (float)j * 2.0 * M_PI / sides;
  144.         phi2 = (float)(j + 1) * 2.0 * M_PI / sides;
  145.  
  146.         v0[0] = cos(theta1) * (outerRadius + innerRadius * cos(phi1));
  147.         v0[1] = -sin(theta1) * (outerRadius + innerRadius * cos(phi1));
  148.         v0[2] = innerRadius * sin(phi1);
  149.  
  150.         v1[0] = cos(theta2) * (outerRadius + innerRadius * cos(phi1));
  151.         v1[1] = -sin(theta2) * (outerRadius + innerRadius * cos(phi1));
  152.         v1[2] = innerRadius * sin(phi1);
  153.         v2[0] = cos(theta2) * (outerRadius + innerRadius * cos(phi2));
  154.         v2[1] = -sin(theta2) * (outerRadius + innerRadius * cos(phi2));
  155.         v2[2] = innerRadius * sin(phi2);
  156.  
  157.         v3[0] = cos(theta1) * (outerRadius + innerRadius * cos(phi2));
  158.         v3[1] = -sin(theta1) * (outerRadius + innerRadius * cos(phi2));
  159.         v3[2] = innerRadius * sin(phi2);
  160.  
  161.         n0[0] = cos(theta1) * (cos(phi1));
  162.         n0[1] = -sin(theta1) * (cos(phi1));
  163.         n0[2] = sin(phi1);
  164.  
  165.         n1[0] = cos(theta2) * (cos(phi1));
  166.         n1[1] = -sin(theta2) * (cos(phi1));
  167.         n1[2] = sin(phi1);
  168.  
  169.         n2[0] = cos(theta2) * (cos(phi2));
  170.         n2[1] = -sin(theta2) * (cos(phi2));
  171.         n2[2] = sin(phi2);
  172.  
  173.         n3[0] = cos(theta1) * (cos(phi2));
  174.         n3[1] = -sin(theta1) * (cos(phi2));
  175.         n3[2] = sin(phi2);
  176.  
  177.         t0[0] = v0[0]*scalFac + 0.5;
  178.         t0[1] = v0[1]*scalFac + 0.5;
  179.         t0[2] = v0[2]*scalFac + 0.5;
  180.  
  181.         t1[0] = v1[0]*scalFac + 0.5;
  182.         t1[1] = v1[1]*scalFac + 0.5;
  183.         t1[2] = v1[2]*scalFac + 0.5;
  184.  
  185.         t2[0] = v2[0]*scalFac + 0.5;
  186.         t2[1] = v2[1]*scalFac + 0.5;
  187.         t2[2] = v2[2]*scalFac + 0.5;
  188.  
  189.         t3[0] = v3[0]*scalFac + 0.5;
  190.         t3[1] = v3[1]*scalFac + 0.5;
  191.         t3[2] = v3[2]*scalFac + 0.5;
  192.  
  193.         glBegin(GL_POLYGON);
  194.         glNormal3fv(n3); glTexCoord3fv(t3); glVertex3fv(v3);
  195.         glNormal3fv(n2); glTexCoord3fv(t2); glVertex3fv(v2);
  196.         glNormal3fv(n1); glTexCoord3fv(t1); glVertex3fv(v1);
  197.         glNormal3fv(n0); glTexCoord3fv(t0); glVertex3fv(v0);
  198.         glEnd();
  199.     }
  200.     }
  201.     glEndList();
  202. }
  203.  
  204. void create3Dtexture()
  205. {
  206.  int i,j,k;
  207.  unsigned char *vp;
  208.  float vec[3];
  209.  int tmp;
  210.  
  211.  printf("creating 3d textures...\n");
  212.  voxels = (unsigned char  *) malloc((4*tex_width*tex_height*tex_depth));
  213.  vp=voxels;
  214.  for (i=0;i<tex_width;i++){
  215.     vec[0]=i;
  216.     for (j=0;j<tex_height;j++) {
  217.       vec[1]=j;
  218.        for (k=0;k<tex_depth;k++) {
  219.        vec[2]=k;
  220.        tmp=(sin(k*i*j+turbulence(vec,0.01,1))+1)*127.5; 
  221.        *vp++=0;
  222.        *vp++=0;
  223.        *vp++=tmp; 
  224.        *vp++=tmp+128; 
  225.        }
  226.      }
  227.  }
  228.  
  229.  printf("setting up 3d texture...\n");
  230.  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  231.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  232.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  233.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_S,     GL_REPEAT);
  234.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_T,     GL_REPEAT);
  235.  glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_R_EXT, GL_REPEAT);
  236.  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, (GLfloat)(GLint)GL_DECAL);
  237.  
  238.  glTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, GL_RGBA,
  239.             tex_width, tex_height, tex_depth,
  240.             0, GL_RGBA, GL_UNSIGNED_BYTE, voxels);
  241.  
  242.  printf("finished setting up 3d texture image...\n");
  243. }
  244.  
  245. int isExtSupported(char *ext)
  246. {
  247.     /* routine to find whether a specified OpenGL extension is supported */
  248.  
  249.     char *c;
  250.     int len;
  251.     char *allext = (char *)(glGetString(GL_EXTENSIONS));
  252.  
  253.     len = strlen(ext);
  254.     if (len <= 0) return 0;
  255.  
  256.     c = allext;
  257.     while (c) {
  258.     if (!strncmp(c,ext,len)) return 1;
  259.     c = strchr(c+1,'G');
  260.     }
  261.     return 0;
  262. }
  263.  
  264. void printHelp()
  265. {
  266.   printf("\nUsage: stex3d  <cmd line options>\n"); 
  267.   printf(" cmd line options:\n");
  268.   printf("      -help   print this help!\n");
  269.   printf("      -rgb     RGBA mode. (Default)\n");
  270.   printf("      -ci     Color index mode.\n");
  271.   printf("      -sb     Single buffer mode. (Default)\n");
  272.   printf("      -db     Double buffer mode. \n");
  273.   printf("      -dr     Direct render mode.\n");
  274.   printf("      -ir     Indirect render mode. (Default)\n");
  275.   printf("      -wxxx   Width of the texture (Default=64)\n");
  276.   printf("      -hxxx   Height of the texture (Default=64)\n");
  277.   printf("      -dxxx   Depth of the texture (Default=64)\n");
  278.   printf(" Keyboard Options:\n");
  279.   printf("       1      Object Texture coordinates (Default)\n");
  280.   printf("       2      Eye Texture coordinates \n");
  281.   printf("       x      rotate around x clockwise\n");
  282.   printf("       X      rotate around x counter clockwise\n");
  283.   printf("       y      rotate around y clockwise\n");
  284.   printf("       Y      rotate around y counter clockwise\n");
  285.   printf("       z      rotate around z clockwise\n");
  286.   printf("       Z      rotate around z counter clockwise\n");
  287.   printf("       t      enable 3-D texuring (Default)\n");
  288.   printf("       T      disable 3-D texuring\n");
  289.   printf("       s      smooth shading \n");
  290.   printf("       S      flat shading (Default)\n");
  291. }
  292.  
  293. void setDefaults()
  294. {
  295.  /* visualization defaults */
  296.   rgb = GL_TRUE;
  297.   doubleBuffer = GL_FALSE;
  298.   directRender = GL_TRUE;
  299.   angx=130;
  300.   angy=30;
  301.   angz=0; 
  302.  /* texture values */
  303.  tex_width=64;
  304.  tex_height=64;
  305.  tex_depth=64;
  306. }
  307.  
  308. GLenum parseCmdLine(int argc, char **argv)
  309. {
  310.   GLint i;
  311.  
  312.   setDefaults();
  313.  
  314.   for (i = 1; i < argc; i++) {
  315.       if (strcmp(argv[i], "-ci") == 0) {
  316.       rgb = GL_FALSE;
  317.       } else if (strcmp(argv[i], "-rgb") == 0) {
  318.       rgb = GL_TRUE;
  319.       } else if (strcmp(argv[i], "-sb") == 0) {
  320.       doubleBuffer = GL_FALSE;
  321.       } else if (strcmp(argv[i], "-db") == 0) {
  322.       doubleBuffer = GL_TRUE;
  323.       } else if (strcmp(argv[i], "-dr") == 0) {
  324.       directRender = GL_TRUE;
  325.       } else if (strcmp(argv[i], "-ir") == 0) {
  326.       directRender = GL_FALSE;
  327.       } else if (strstr(argv[i], "-w") == 0) {
  328.       tex_width=atoi((argv[i])+2);
  329.       } else if (strstr(argv[i], "-h") == 0) {
  330.       tex_height=atoi((argv[i])+2);
  331.       } else if (strstr(argv[i], "-d") == 0) {
  332.       tex_depth=atoi((argv[i])+2);
  333.       } else if (strcmp(argv[i], "-help") == 0) {
  334.       printHelp();
  335.       return GL_FALSE;
  336.       } else {
  337.       printf("%s (Bad option).\n", argv[i]);
  338.       printHelp();
  339.       return GL_FALSE;
  340.       }
  341.   }
  342.  if(tex_width==0 || tex_height==0 || tex_depth==0) {
  343.    printf("%s (Bad option).\n", "size parameters can't be 0");
  344.    printHelp();
  345.    return GL_FALSE;
  346.  }
  347.   return GL_TRUE;
  348. }
  349.  
  350. void drawScene()
  351. {
  352.  /* clear background, z buffer etc */
  353.  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  354.  glPushMatrix();
  355.  glRotatef(angx,1.0,0.0,0.0);
  356.  glRotatef(angy,0.0,1.0,0.0);
  357.  glRotatef(angz,0.0,0.0,1.0);
  358.  
  359.  glCallList(figure);     
  360.  glPopMatrix();
  361.  glFlush();
  362.  if(doubleBuffer)
  363.    tkSwapBuffers();
  364.  ;
  365. }
  366.  
  367. void resize(int w, int h)
  368. { 
  369.  glViewport(0, 0, (GLint)w, (GLint)h);
  370.  glMatrixMode(GL_PROJECTION);
  371.  glLoadIdentity();
  372.  glOrtho(-2,2,-2,2,-5,10);
  373.  glMatrixMode(GL_MODELVIEW);
  374.  glLoadIdentity();
  375.  glTranslatef(0,0,-5);
  376. }
  377.  
  378. void cleanEverything(void)
  379. {
  380. /*  free(voxels); */
  381. }
  382.  
  383. GLenum keyHandler(int key, GLenum mask)
  384. {
  385.  switch(key) {
  386.       case TK_ESCAPE:
  387.    case TK_q:
  388.    case TK_Q: /* quit game. */
  389.       cleanEverything();
  390.        tkQuit();
  391.        break;
  392.    case TK_x:
  393.        angx+=10;
  394.        break;
  395.    case TK_X: 
  396.        angx-=10; 
  397.        break;
  398.    case TK_y:
  399.        angy+=10;
  400.        break;
  401.    case TK_Y: 
  402.        angy-=10; 
  403.        break;
  404.    case TK_z:
  405.        angz+=10;
  406.        break;
  407.    case TK_Z: 
  408.        angz-=10; 
  409.        break;
  410.    case TK_t:
  411.        glEnable(GL_TEXTURE_3D_EXT); 
  412.        break;
  413.    case TK_T:
  414.        glDisable(GL_TEXTURE_3D_EXT);
  415.        break;
  416.    case TK_s:
  417.        glShadeModel(GL_SMOOTH);
  418.        break;
  419.    case TK_S:
  420.        glShadeModel(GL_FLAT);
  421.        break;
  422.    case TK_1:
  423.        glDisable(GL_TEXTURE_GEN_S);
  424.        glDisable(GL_TEXTURE_GEN_T);
  425.        glDisable(GL_TEXTURE_GEN_R);
  426.        break;
  427.    case TK_2:
  428.        glEnable(GL_TEXTURE_GEN_S);
  429.        glEnable(GL_TEXTURE_GEN_T);
  430.        glEnable(GL_TEXTURE_GEN_R);
  431.        break;
  432.    default:
  433.      break;
  434.  }
  435.  return GL_TRUE;
  436. }
  437.  
  438. /*--------------------------------------------------------------------
  439.  noise function over R3 - implemented by a pseudorandom tricubic spline 
  440.           EXCERPTED FROM SIGGRAPH 92, COURSE 23
  441.             PROCEDURAL MODELING
  442.                  Ken Perlin
  443.                New York University
  444. ----------------------------------------------------------------------*/
  445.  
  446.  
  447. #define DOT(a,b) (a[0] * b[0] + a[1] * b[1] + a[2] * b[2])
  448. #define B 256
  449. static int p[B + B + 2];
  450. static float g[B + B + 2][3];
  451. #define setup(i,b0,b1,r0,r1) \
  452.     t = vec[i] + 10000.; \
  453.     b0 = ((int)t) & (B-1); \
  454.     b1 = (b0+1) & (B-1); \
  455.     r0 = t - (int)t; \
  456.     r1 = r0 - 1.;
  457.  
  458. float noise3(float vec[3])
  459. {
  460.     int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
  461.     float rx0, rx1, ry0, ry1, rz0, rz1, *q, sx, sy, sz, a, b, c, d, t, u, v;
  462.     register int i, j;
  463.  
  464.     setup(0, bx0,bx1, rx0,rx1);
  465.     setup(1, by0,by1, ry0,ry1);
  466.     setup(2, bz0,bz1, rz0,rz1);
  467.  
  468.     i = p[ bx0 ];
  469.     j = p[ bx1 ];
  470.  
  471.     b00 = p[ i + by0 ];
  472.     b10 = p[ j + by0 ];
  473.     b01 = p[ i + by1 ];
  474.     b11 = p[ j + by1 ];
  475.  
  476. #define at(rx,ry,rz) ( rx * q[0] + ry * q[1] + rz * q[2] )
  477. #define surve(t) ( t * t * (3. - 2. * t) )
  478. #define lerp(t, a, b) ( a + t * (b - a) )
  479.  
  480.     sx = surve(rx0);
  481.     sy = surve(ry0);
  482.     sz = surve(rz0);
  483.  
  484.     q = g[ b00 + bz0 ] ; u = at(rx0,ry0,rz0);
  485.     q = g[ b10 + bz0 ] ; v = at(rx1,ry0,rz0);
  486.     a = lerp(sx, u, v);
  487.  
  488.     q = g[ b01 + bz0 ] ; u = at(rx0,ry1,rz0);
  489.     q = g[ b11 + bz0 ] ; v = at(rx1,ry1,rz0);
  490.     b = lerp(sx, u, v);
  491.  
  492.     c = lerp(sy, a, b);          /* interpolate in y at lo x */
  493.  
  494.     q = g[ b00 + bz1 ] ; u = at(rx0,ry0,rz1);
  495.     q = g[ b10 + bz1 ] ; v = at(rx1,ry0,rz1);
  496.     a = lerp(sx, u, v);
  497.  
  498.     q = g[ b01 + bz1 ] ; u = at(rx0,ry1,rz1);
  499.     q = g[ b11 + bz1 ] ; v = at(rx1,ry1,rz1);
  500.     b = lerp(sx, u, v);
  501.  
  502.     d = lerp(sy, a, b);          /* interpolate in y at hi x */
  503.  
  504.     return 1.5 * lerp(sz, c, d); /* interpolate in z */
  505. }
  506.  
  507. void initNoise()
  508. {
  509.     /*long random();*/
  510.     int i, j, k;
  511.     float v[3], s;
  512.  
  513. /* Create an array of random gradient vectors uniformly on the unit sphere */
  514.     /*srandom(1);*/
  515.     srand(1);
  516.     for (i = 0 ; i < B ; i++) {
  517.         do {                            /* Choose uniformly in a cube */                        for (j=0 ; j<3 ; j++)
  518.                 v[j] = (float)((rand() % (B + B)) - B) / B;
  519.             s = DOT(v,v);
  520.         } while (s > 1.0);              /* If not in sphere try again */                s = sqrt(s);
  521.         for (j = 0 ; j < 3 ; j++)       /* Else normalize */
  522.             g[i][j] = v[j] / s;
  523.     }
  524.  
  525. /* Create a pseudorandom permutation of [1..B] */
  526.     for (i = 0 ; i < B ; i++)
  527.         p[i] = i;
  528.     for (i = B ; i > 0 ; i -= 2) {
  529.         k = p[i];
  530.         p[i] = p[j = rand() % B];
  531.         p[j] = k;
  532.     }
  533.  
  534. /* Extend g and p arrays to allow for faster indexing */
  535.     for (i = 0 ; i < B + 2 ; i++) {
  536.         p[B + i] = p[i];
  537.         for (j = 0 ; j < 3 ; j++)
  538.             g[B + i][j] = g[i][j];
  539.     }
  540. }
  541.  
  542. float turbulence(float point[3], float lofreq, float hifreq)
  543. {
  544.     float freq, t, p[3];
  545.  
  546.     p[0] = point[0] + 123.456;
  547.     p[1] = point[1];
  548.     p[2] = point[2];
  549.  
  550.     t = 0;
  551.     for (freq = lofreq ; freq < hifreq ; freq *= 2.) {
  552.         t += fabs(noise3(p)) / freq;
  553.         p[0] *= 2.;
  554.         p[1] *= 2.;
  555.         p[2] *= 2.;
  556.     }
  557.     return t - 0.3; /* readjust to make mean value = 0.0 */
  558. }
  559.  
  560.