Attachment 37605 Details for Bug 29226 – a simplified version of shadowtex

a simplified version of shadowtex

shader.c (text/x-csrc), 13.99 KB, created by Michal Suchanek on 2010-08-05 17:24:35 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Michal Suchanek

Created: 2010-08-05 17:24:35 UTC

Size: 13.99 KB

patch

obsolete

>/*
> * Shadow demo using the GL_ARB_depth_texture, GL_ARB_shadow and
> * GL_ARB_shadow_ambient extensions.
> *
> * Brian Paul
> * 19 Feb 2001
> *
> * Added GL_EXT_shadow_funcs support on 23 March 2002
> * Added GL_EXT_packed_depth_stencil support on 15 March 2006.
> * Added GL_EXT_framebuffer_object support on 27 March 2006.
> * Removed old SGIX extension support on 5 April 2006.
> * Added vertex / fragment program support on 7 June 2007 (Ian Romanick).
> *
> * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
> *
> * Permission is hereby granted, free of charge, to any person obtaining a
> * copy of this software and associated documentation files (the "Software"),
> * to deal in the Software without restriction, including without limitation
> * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> * and/or sell copies of the Software, and to permit persons to whom the
> * Software is furnished to do so, subject to the following conditions:
> *
> * The above copyright notice and this permission notice shall be included
> * in all copies or substantial portions of the Software.
> *
> * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
> * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
> * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
> * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
> */
>
>#include <assert.h>
>#include <stdio.h>
>#include <stdlib.h>
>#include <string.h>
>#include <math.h>
>#include <GL/glew.h>
>#include <GL/glut.h>
>
>#define DEG_TO_RAD (3.14159 / 180.0)
>
>static GLint WindowWidth = 450, WindowHeight = 300;
>static GLfloat Xrot = 15, Yrot = -60, Zrot = 0;
>
>static GLfloat Red[4] = {1, 0, 0, 1};
>static GLfloat Green[4] = {0, 1, 0, 1};
>static GLfloat Blue[4] = {0, 0, 1, 1};
>static GLfloat Yellow[4] = {1, 1, 0, 1};
>
>static GLfloat LightDist = 10;
>static GLfloat LightLatitude = 45.0;
>static GLfloat LightLongitude = 45.0;
>static GLfloat LightPos[4];
>static GLfloat SpotDir[3];
>
>static GLboolean Anim = GL_FALSE;
>
>static GLuint vert_prog;
>static GLuint frag_progs[3];
>static GLuint curr_frag = 0;
>static GLuint max_frag = 1;
>
>#define NUM_FRAG_MODES 3
>static const char *FragProgNames[] = {
>   "fixed-function",
>   "program without \"OPTION ARB_fragment_program_shadow\"",
>   "program with \"OPTION ARB_fragment_program_shadow\"",
>};
>
>static GLboolean HaveShadow = GL_FALSE;
>static GLboolean HaveVP = GL_FALSE;
>static GLboolean HaveFP = GL_FALSE;
>static GLboolean HaveFP_Shadow = GL_FALSE;
>static GLboolean UseVP = GL_FALSE;
>static GLboolean HaveShadowAmbient = GL_FALSE;
>
>
>
>
>#define MAT4_MUL(dest_vec, src_mat, src_vec) \
>    "DP4	" dest_vec ".x, " src_mat "[0], " src_vec ";\n" \
>    "DP4	" dest_vec ".y, " src_mat "[1], " src_vec ";\n" \
>    "DP4	" dest_vec ".z, " src_mat "[2], " src_vec ";\n" \
>    "DP4	" dest_vec ".w, " src_mat "[3], " src_vec ";\n"
>
>#define MAT3_MUL(dest_vec, src_mat, src_vec) \
>    "DP3	" dest_vec ".x, " src_mat "[0], " src_vec ";\n" \
>    "DP3	" dest_vec ".y, " src_mat "[1], " src_vec ";\n" \
>    "DP3	" dest_vec ".z, " src_mat "[2], " src_vec ";\n"
>
>#define NORMALIZE(dest, src) \
>    "DP3	" dest ".w, " src ", " src ";\n" \
>    "RSQ	" dest ".w, " dest ".w;\n" \
>    "MUL	" dest ", " src ", " dest ".w;\n"
>   
>/**
> * Vertex program for shadow mapping.
> */
>static const char vert_code[] =
>    "!!ARBvp1.0\n"
>    "ATTRIB iPos        = vertex.position;\n"
>    "ATTRIB iNorm       = vertex.normal;\n"
>
>    "PARAM  mvinv[4]    = { state.matrix.modelview.invtrans };\n"
>    "PARAM  mvp[4]      = { state.matrix.mvp };\n"
>    "PARAM  mv[4]       = { state.matrix.modelview };\n"
>    "PARAM  texmat[4]   = { state.matrix.texture[0] };\n"
>    "PARAM  lightPos    = state.light[0].position;\n"
>    "PARAM  ambientCol  = state.lightprod[0].ambient;\n"
>    "PARAM  diffuseCol  = state.lightprod[0].diffuse;\n"
>
>    "TEMP   n, lightVec;\n"
>    "ALIAS  V = lightVec;\n"
>    "ALIAS  NdotL = n;\n"
>
>    "OUTPUT oPos = result.position;\n"
>    "OUTPUT oColor = result.color;\n"
>    "OUTPUT oTex = result.texcoord[0];\n"
>
>    /* Transform the vertex to clip coordinates. */
>    MAT4_MUL("oPos", "mvp",    "iPos")
>
>    /* Transform the vertex to eye coordinates. */
>    MAT4_MUL("V",    "mv",     "iPos")
>
>    /* Transform the vertex to projected light coordinates. */
>    MAT4_MUL("oTex", "texmat", "iPos")
>
>    /* Transform the normal to eye coordinates. */
>    MAT3_MUL("n",    "mvinv",  "iNorm")
>
>    /* Calculate the vector from the vertex to the light in eye
>     * coordinates.
>     */
>    "SUB	lightVec, lightPos, V;\n"
>    NORMALIZE("lightVec", "lightVec")
>
>    /* Compute diffuse lighting coefficient.
>     */
>    "DP3	NdotL.x, n, lightVec;\n"
>    "MAX	NdotL.x, NdotL.x, {0.0};\n"
>    "MIN	NdotL.x, NdotL.x, {1.0};\n"
>
>    /* Accumulate color contributions.
>     */
>    "MOV	oColor, diffuseCol;\n"
>    "MAD	oColor.xyz, NdotL.x, diffuseCol, ambientCol;\n"
>    "END\n"
>    ;
>
>static const char frag_code[] =
>    "!!ARBfp1.0\n"
>
>    "TEMP   shadow, temp;\n"
>
>    "TXP	shadow, fragment.texcoord[0], texture[0], 2D;\n"
>    "RCP	temp.x, fragment.texcoord[0].w;\n"
>    "MUL	temp.x, temp.x, fragment.texcoord[0].z;\n"
>    "SGE	shadow, shadow.x, temp.x;\n"
>    "MUL	result.color.rgb, fragment.color, shadow.x;\n"
>    "MOV	result.color.a, fragment.color;\n"
>    "END\n"
>    ;
>
>static const char frag_shadow_code[] =
>    "!!ARBfp1.0\n"
>    "OPTION ARB_fragment_program_shadow;\n"
>
>    "TEMP   shadow;\n"
>
>    "TXP	shadow, fragment.texcoord[0], texture[0], SHADOW2D;\n"
>    "MUL	result.color.rgb, fragment.color, shadow.x;\n"
>    "MOV	result.color.a, fragment.color.a;\n"
>    "END\n"
>    ;
>
>static void
>DrawScene(void)
>{
>   GLfloat k = 6;
>
>   /* sphere */
>   glPushMatrix();
>   glTranslatef(1.6, 2.2, 2.7);
>   glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Green);
>   glColor4fv(Green);
>   glutSolidSphere(1.5, 15, 15);
>   glPopMatrix();
>   /* dodecahedron */
>   glPushMatrix();
>   glTranslatef(-2.0, 1.2, 2.1);
>   glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Red);
>   glColor4fv(Red);
>   glutSolidDodecahedron();
>   glPopMatrix();
>   /* icosahedron */
>   glPushMatrix();
>   glTranslatef(-0.6, 1.3, -0.5);
>   glScalef(1.5, 1.5, 1.5);
>   glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Yellow);
>   glColor4fv(Red);
>   glutSolidIcosahedron();
>   glPopMatrix();
>   /* a plane */
>   glPushMatrix();
>   glTranslatef(0, -1.1, 0);
>   glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Blue);
>   glColor4fv(Blue);
>   glNormal3f(0, 1, 0);
>   glBegin(GL_POLYGON);
>   glVertex3f(-k, 0, -k);
>   glVertex3f( k, 0, -k);
>   glVertex3f( k, 0,  k);
>   glVertex3f(-k, 0,  k);
>   glEnd();
>   glPopMatrix();
>}
>
>
>
>
>
>
>static void
>ComputeLightPos(GLfloat dist, GLfloat latitude, GLfloat longitude,
>                GLfloat pos[4], GLfloat dir[3])
>{
>
>   pos[0] = dist * sin(longitude * DEG_TO_RAD);
>   pos[1] = dist * sin(latitude * DEG_TO_RAD);
>   pos[2] = dist * cos(latitude * DEG_TO_RAD) * cos(longitude * DEG_TO_RAD);
>   pos[3] = 1;
>   dir[0] = -pos[0];
>   dir[1] = -pos[1];
>   dir[2] = -pos[2];
>}
>
>
>
>
>/**
> * Redraw window image
> */
>static void
>Display(void)
>{
>   GLenum error;
>
>   ComputeLightPos(LightDist, LightLatitude, LightLongitude,
>                   LightPos, SpotDir);
>
>   glViewport(0, 0, WindowWidth, WindowHeight);
>   {
>      /* prepare to draw scene from camera's view */
>      const GLfloat ar = (GLfloat) WindowWidth / (GLfloat) WindowHeight;
>
>      glMatrixMode(GL_PROJECTION);
>      glLoadIdentity();
>      glFrustum(-ar, ar, -1.0, 1.0, 4.0, 50.0);
>
>      glMatrixMode(GL_MODELVIEW);
>      glLoadIdentity();
>      glTranslatef(0.0, 0.0, -22.0);
>      glRotatef(Xrot, 1, 0, 0);
>      glRotatef(Yrot, 0, 1, 0);
>      glRotatef(Zrot, 0, 0, 1);
>
>      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
>
>      glLightfv(GL_LIGHT0, GL_POSITION, LightPos);
>
>      {
>
>         if (curr_frag > 0) {
>            glEnable(GL_FRAGMENT_PROGRAM_ARB);
>         }
>         else {
>            glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
>         }
>
>         if (UseVP) {
>            glEnable(GL_VERTEX_PROGRAM_ARB);
>         }
>         else {
>            glEnable(GL_LIGHTING);
>         }
>      }
>
>      DrawScene();
>
>      if (UseVP) {
>         glDisable(GL_VERTEX_PROGRAM_ARB);
>      }
>      else {
>         glDisable(GL_LIGHTING);
>      }
>
>      if (curr_frag > 0) {
>         glDisable(GL_FRAGMENT_PROGRAM_ARB);
>      }
>
>   }
>
>   glutSwapBuffers();
>
>   error = glGetError();
>   if (error) {
>      printf("GL Error: %s\n", (char *) gluErrorString(error));
>   }
>}
>
>
>static void
>Reshape(int width, int height)
>{
>   WindowWidth = width;
>   WindowHeight = height;
>}
>
>
>static void
>Idle(void)
>{
>   static double t0 = -1.;
>   double dt, t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
>   if (t0 < 0.0)
>      t0 = t;
>   dt = t - t0;
>   t0 = t;
>   Yrot += 75.0 * dt;
>   /*LightLongitude -= 5.0;*/
>   glutPostRedisplay();
>}
>
>
>static void
>Key(unsigned char key, int x, int y)
>{
>   const GLfloat step = 3.0;
>   (void) x;
>   (void) y;
>   switch (key) {
>      case 'a':
>         Anim = !Anim;
>         if (Anim)
>            glutIdleFunc(Idle);
>         else
>            glutIdleFunc(NULL);
>         break;
>      case 'M':
>         curr_frag = (1 + curr_frag) % max_frag;
>         if (!HaveShadow && (curr_frag == 0)) {
>            curr_frag = 1;
>         }
>
>         printf("Using fragment %s\n", FragProgNames[curr_frag]);
>
>         if (HaveFP) {
>            glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, frag_progs[curr_frag]);
>         }
>         break;
>      case 'n':
>      case 's':
>      case ' ':
>         break;
>      case 'v':
>         UseVP = !UseVP && HaveVP;
>         printf("Using vertex %s mode.\n",
>                UseVP ? "program" : "fixed-function");
>         break;
>      case 'z':
>         Zrot -= step;
>         break;
>      case 'Z':
>         Zrot += step;
>         break;
>      case 27:
>         exit(0);
>         break;
>   }
>   fflush(stdout);
>   glutPostRedisplay();
>}
>
>
>static void
>SpecialKey(int key, int x, int y)
>{
>   const GLfloat step = 3.0;
>   const int mod = glutGetModifiers();
>   (void) x;
>   (void) y;
>   switch (key) {
>      case GLUT_KEY_UP:
>         if (mod)
>            LightLatitude += step;
>         else
>            Xrot += step;
>         break;
>      case GLUT_KEY_DOWN:
>         if (mod)
>            LightLatitude -= step;
>         else
>            Xrot -= step;
>         break;
>      case GLUT_KEY_LEFT:
>         if (mod)
>            LightLongitude += step;
>         else
>            Yrot += step;
>         break;
>      case GLUT_KEY_RIGHT:
>         if (mod)
>            LightLongitude -= step;
>         else
>            Yrot -= step;
>         break;
>   }
>
>   glutPostRedisplay();
>}
>
>
>/* A helper for finding errors in program strings */
>static int FindLine( const char *program, int position )
>{
>   int i, line = 1;
>   for (i = 0; i < position; i++) {
>      if (program[i] == '\n')
>         line++;
>   }
>   return line;
>}
>
>
>static GLuint
>compile_program(GLenum target, const char *code)
>{
>   GLuint p;
>   GLint errorPos;
>
>
>   glGenProgramsARB(1, & p);
>
>   glBindProgramARB(target, p);
>   glProgramStringARB(target, GL_PROGRAM_FORMAT_ASCII_ARB,
>                      strlen(code), code);
>   glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorPos);
>   if (glGetError() != GL_NO_ERROR || errorPos != -1) {
>      int l = FindLine(code, errorPos);
>      printf("Fragment Program Error (pos=%d line=%d): %s\n", errorPos, l,
>             (char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB));
>      exit(0);
>   }
>
>   glBindProgramARB(target, 0);
>   return p;
>}
>
>static void
>Init(void)
>{
>
>   if (!glutExtensionSupported("GL_ARB_depth_texture")) {
>      printf("Sorry, this demo requires the GL_ARB_depth_texture extension\n");
>      exit(1);
>   }
>
>   HaveShadow = glutExtensionSupported("GL_ARB_shadow");
>   HaveVP = glutExtensionSupported("GL_ARB_vertex_program");
>   HaveFP = glutExtensionSupported("GL_ARB_fragment_program");
>   HaveFP_Shadow = glutExtensionSupported("GL_ARB_fragment_program_shadow");
>
>   if (!HaveShadow && !HaveFP) {
>      printf("Sorry, this demo requires either the GL_ARB_shadow extension "
>	     "or the GL_ARB_fragment_program extension\n");
>      exit(1);
>   }
>
>   printf("Using GL_ARB_depth_texture\n");
>   if (HaveShadow) {
>      printf("and GL_ARB_shadow\n");
>   }
>
>   if (HaveFP) {
>      printf("and GL_ARB_fragment_program\n");
>   }
>
>   HaveShadowAmbient = glutExtensionSupported("GL_ARB_shadow_ambient");
>   if (HaveShadowAmbient) {
>      printf("and GL_ARB_shadow_ambient\n");
>   }
>
>
>   /*
>    * Set up the 2D shadow map texture
>    */
>
>   /*
>    * Setup 1-D grayscale texture image for SHOW_DISTANCE mode
>    */
>
>   if (HaveVP) {
>      vert_prog = compile_program(GL_VERTEX_PROGRAM_ARB, vert_code);
>      glBindProgramARB(GL_VERTEX_PROGRAM_ARB, vert_prog);
>   }
>
>   max_frag = 1;
>   frag_progs[0] = 0;
>
>   if (HaveFP) {
>      frag_progs[1] = compile_program(GL_FRAGMENT_PROGRAM_ARB, frag_code);
>      max_frag = 2;
>   }
>   
>   if (HaveFP && HaveFP_Shadow) {
>      frag_progs[2] = compile_program(GL_FRAGMENT_PROGRAM_ARB, 
>                                      frag_shadow_code);
>      max_frag = 3;
>   }
>
>   if (!HaveShadow) {
>      curr_frag = 1;
>      glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, frag_progs[curr_frag]);
>   }
>
>   glEnable(GL_DEPTH_TEST);
>   glEnable(GL_LIGHTING);
>   glEnable(GL_LIGHT0);
>}
>
>
>static void
>PrintHelp(void)
>{
>   printf("Keys:\n");
>   printf("  a = toggle animation\n");
>   printf("  b/B = decrease/increase shadow map Z bias\n");
>   printf("  M = cycle through fragment program modes\n");
>   printf("  v = toggle vertex program modes\n");
>   printf("  cursor keys = rotate scene\n");
>   printf("  <shift> + cursor keys = rotate light source\n");
>   fflush(stdout);
>}
>
>
>int
>main(int argc, char *argv[])
>{
>   glutInitWindowSize(WindowWidth, WindowHeight);
>   glutInit(&argc, argv);
>   glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL);
>   glutCreateWindow(argv[0]);
>   glewInit();
>   glutReshapeFunc(Reshape);
>   glutKeyboardFunc(Key);
>   glutSpecialFunc(SpecialKey);
>   glutDisplayFunc(Display);
>   if (Anim)
>      glutIdleFunc(Idle);
>   Init();
>   PrintHelp();
>   glutMainLoop();
>   return 0;
>}

Actions: View

Attachments on bug 29226: 37334 | 37335 | 37585 | 37596 | 37597 | 37605

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.