← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to progs/glsl/shadow_sampler.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
progs/glsl/shadow_sampler.c
1
 
/**
2
 
 * Test shadow2DRectProj() and shadow2D() functions.
3
 
 * Brian Paul
4
 
 * 11 April 2007
5
 
 */
6
 
 
7
 
#define GL_GLEXT_PROTOTYPES
8
 
#include <assert.h>
9
 
#include <string.h>
10
 
#include <stdio.h>
11
 
#include <stdlib.h>
12
 
#include <math.h>
13
 
#include <GL/glew.h>
14
 
#include <GL/glut.h>
15
 
 
16
 
 
17
 
/** Use GL_RECTANGLE texture (with projective texcoords)? */
18
 
#define USE_RECT 01
19
 
 
20
 
#define TEXSIZE 16
21
 
 
22
 
 
23
 
static char *FragProgFile = NULL;
24
 
static char *VertProgFile = NULL;
25
 
 
26
 
static GLuint fragShader;
27
 
static GLuint vertShader;
28
 
static GLuint program;
29
 
 
30
 
static GLint uTexture2D;
31
 
static GLint uTextureRect;
32
 
 
33
 
static GLint win = 0;
34
 
 
35
 
static GLenum Filter = GL_LINEAR;
36
 
 
37
 
static void
38
 
CheckError(int line)
39
 
{
40
 
   GLenum err = glGetError();
41
 
   if (err) {
42
 
      printf("GL Error %s (0x%x) at line %d\n",
43
 
             gluErrorString(err), (int) err, line);
44
 
   }
45
 
}
46
 
 
47
 
 
48
 
static void
49
 
PrintString(const char *s)
50
 
{
51
 
   while (*s) {
52
 
      glutBitmapCharacter(GLUT_BITMAP_8_BY_13, (int) *s);
53
 
      s++;
54
 
   }
55
 
}
56
 
 
57
 
 
58
 
static void
59
 
Redisplay(void)
60
 
{
61
 
   CheckError(__LINE__);
62
 
   glClear(GL_COLOR_BUFFER_BIT);
63
 
 
64
 
   glPushMatrix();
65
 
 
66
 
   CheckError(__LINE__);
67
 
   glUseProgram(program);
68
 
   CheckError(__LINE__);
69
 
 
70
 
   glBegin(GL_POLYGON);
71
 
#if USE_RECT
72
 
   /* scale coords by two to test projection */
73
 
   glTexCoord4f(        0,         0,   0, 2.0);  glVertex2f(-1, -1);
74
 
   glTexCoord4f(2*TEXSIZE,         0, 2*1, 2.0);  glVertex2f( 1, -1);
75
 
   glTexCoord4f(2*TEXSIZE, 2*TEXSIZE, 2*1, 2.0);  glVertex2f( 1,  1);
76
 
   glTexCoord4f(        0, 2*TEXSIZE,   0, 2.0);  glVertex2f(-1,  1);
77
 
#else
78
 
   glTexCoord3f(0, 0, 0);  glVertex2f(-1, -1);
79
 
   glTexCoord3f(1, 0, 1);  glVertex2f( 1, -1);
80
 
   glTexCoord3f(1, 1, 1);  glVertex2f( 1,  1);
81
 
   glTexCoord3f(0, 1, 0);  glVertex2f(-1,  1);
82
 
#endif
83
 
   glEnd();
84
 
 
85
 
   glPopMatrix();
86
 
 
87
 
   glUseProgram(0);
88
 
   glWindowPos2iARB(80, 20);
89
 
   PrintString("white   black   white   black");
90
 
 
91
 
   glutSwapBuffers();
92
 
}
93
 
 
94
 
 
95
 
static void
96
 
Reshape(int width, int height)
97
 
{
98
 
   glViewport(0, 0, width, height);
99
 
   glMatrixMode(GL_PROJECTION);
100
 
   glLoadIdentity();
101
 
   glFrustum(-1.0, 1.0, -1.0, 1.0, 5.0, 25.0);
102
 
   glMatrixMode(GL_MODELVIEW);
103
 
   glLoadIdentity();
104
 
   glTranslatef(0.0f, 0.0f, -8.0f);
105
 
}
106
 
 
107
 
 
108
 
static void
109
 
CleanUp(void)
110
 
{
111
 
   glDeleteShader(fragShader);
112
 
   glDeleteShader(vertShader);
113
 
   glDeleteProgram(program);
114
 
   glutDestroyWindow(win);
115
 
}
116
 
 
117
 
 
118
 
static void
119
 
Key(unsigned char key, int x, int y)
120
 
{
121
 
  (void) x;
122
 
  (void) y;
123
 
 
124
 
   switch(key) {
125
 
   case 27:
126
 
      CleanUp();
127
 
      exit(0);
128
 
      break;
129
 
   }
130
 
   glutPostRedisplay();
131
 
}
132
 
 
133
 
 
134
 
static void
135
 
MakeTexture(void)
136
 
{
137
 
   GLfloat image[TEXSIZE][TEXSIZE];
138
 
   GLuint i, j;
139
 
 
140
 
   for (i = 0; i < TEXSIZE; i++) {
141
 
      for (j = 0; j < TEXSIZE; j++) {
142
 
         if (j < (TEXSIZE / 2)) {
143
 
            image[i][j] = 0.25;
144
 
         }
145
 
         else {
146
 
            image[i][j] = 0.75;
147
 
         }
148
 
      }
149
 
   }
150
 
 
151
 
   glActiveTexture(GL_TEXTURE0); /* unit 0 */
152
 
   glBindTexture(GL_TEXTURE_2D, 42);
153
 
   glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, TEXSIZE, TEXSIZE, 0,
154
 
                GL_DEPTH_COMPONENT, GL_FLOAT, image);
155
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1);
156
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, Filter);
157
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, Filter);
158
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE_ARB,
159
 
                   GL_COMPARE_R_TO_TEXTURE_ARB);
160
 
   CheckError(__LINE__);
161
 
 
162
 
   glActiveTexture(GL_TEXTURE1); /* unit 1 */
163
 
   glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 43);
164
 
   glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_DEPTH_COMPONENT,
165
 
                TEXSIZE, 10, 0,/*16x10*/
166
 
                GL_DEPTH_COMPONENT, GL_FLOAT, image);
167
 
   glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, Filter);
168
 
   glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, Filter);
169
 
   glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_COMPARE_MODE_ARB,
170
 
                   GL_COMPARE_R_TO_TEXTURE_ARB);
171
 
   CheckError(__LINE__);
172
 
}
173
 
 
174
 
 
175
 
static void
176
 
LoadAndCompileShader(GLuint shader, const char *text)
177
 
{
178
 
   GLint stat;
179
 
   glShaderSource(shader, 1, (const GLchar **) &text, NULL);
180
 
   glCompileShader(shader);
181
 
   glGetShaderiv(shader, GL_COMPILE_STATUS, &stat);
182
 
   if (!stat) {
183
 
      GLchar log[1000];
184
 
      GLsizei len;
185
 
      glGetShaderInfoLog(shader, 1000, &len, log);
186
 
      fprintf(stderr, "fslight: problem compiling shader:\n%s\n", log);
187
 
      exit(1);
188
 
   }
189
 
}
190
 
 
191
 
 
192
 
/**
193
 
 * Read a shader from a file.
194
 
 */
195
 
static void
196
 
ReadShader(GLuint shader, const char *filename)
197
 
{
198
 
   const int max = 100*1000;
199
 
   int n;
200
 
   char *buffer = (char*) malloc(max);
201
 
   FILE *f = fopen(filename, "r");
202
 
   if (!f) {
203
 
      fprintf(stderr, "fslight: Unable to open shader file %s\n", filename);
204
 
      exit(1);
205
 
   }
206
 
 
207
 
   n = fread(buffer, 1, max, f);
208
 
   printf("fslight: read %d bytes from shader file %s\n", n, filename);
209
 
   if (n > 0) {
210
 
      buffer[n] = 0;
211
 
      LoadAndCompileShader(shader, buffer);
212
 
   }
213
 
 
214
 
   fclose(f);
215
 
   free(buffer);
216
 
}
217
 
 
218
 
 
219
 
static void
220
 
CheckLink(GLuint prog)
221
 
{
222
 
   GLint stat;
223
 
   glGetProgramiv(prog, GL_LINK_STATUS, &stat);
224
 
   if (!stat) {
225
 
      GLchar log[1000];
226
 
      GLsizei len;
227
 
      glGetProgramInfoLog(prog, 1000, &len, log);
228
 
      fprintf(stderr, "Linker error:\n%s\n", log);
229
 
   }
230
 
}
231
 
 
232
 
 
233
 
static void
234
 
Init(void)
235
 
{
236
 
   static const char *fragShaderText =
237
 
      "uniform sampler2DShadow shadowTex2D; \n"
238
 
      "uniform sampler2DRectShadow shadowTexRect; \n"
239
 
      "void main() {\n"
240
 
#if USE_RECT
241
 
      "   gl_FragColor = shadow2DRectProj(shadowTexRect, gl_TexCoord[0]); \n"
242
 
#else
243
 
      "   gl_FragColor = shadow2D(shadowTex2D, gl_TexCoord[0].xyz); \n"
244
 
#endif
245
 
      "}\n";
246
 
   static const char *vertShaderText =
247
 
      "void main() {\n"
248
 
      "   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
249
 
      "   gl_TexCoord[0] = gl_MultiTexCoord0; \n"
250
 
      "}\n";
251
 
   const char *version;
252
 
 
253
 
#if USE_RECT
254
 
   if (!glutExtensionSupported("GL_ARB_texture_rectangle")) {
255
 
      printf("This program requires GL_ARB_texture_rectangle\n");
256
 
      exit(1);
257
 
   }
258
 
#endif
259
 
 
260
 
   version = (const char *) glGetString(GL_VERSION);
261
 
   if (version[0] != '2' || version[1] != '.') {
262
 
      printf("This program requires OpenGL 2.x, found %s\n", version);
263
 
      exit(1);
264
 
   }
265
 
   printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
266
 
 
267
 
   fragShader = glCreateShader(GL_FRAGMENT_SHADER);
268
 
   if (FragProgFile)
269
 
      ReadShader(fragShader, FragProgFile);
270
 
   else
271
 
      LoadAndCompileShader(fragShader, fragShaderText);
272
 
 
273
 
   vertShader = glCreateShader(GL_VERTEX_SHADER);
274
 
   if (VertProgFile)
275
 
      ReadShader(vertShader, VertProgFile);
276
 
   else
277
 
      LoadAndCompileShader(vertShader, vertShaderText);
278
 
 
279
 
   program = glCreateProgram();
280
 
   glAttachShader(program, fragShader);
281
 
   glAttachShader(program, vertShader);
282
 
   glLinkProgram(program);
283
 
   CheckLink(program);
284
 
   glUseProgram(program);
285
 
 
286
 
   uTexture2D = glGetUniformLocation(program, "shadowTex2D");
287
 
   uTextureRect = glGetUniformLocation(program, "shadowTexRect");
288
 
   printf("uTexture2D %d  uTextureRect %d\n", uTexture2D, uTextureRect);
289
 
   if (uTexture2D >= 0) {
290
 
      glUniform1i(uTexture2D, 0);  /* use texture unit 0 */
291
 
   }
292
 
   if (uTextureRect >= 0) {
293
 
      glUniform1i(uTextureRect, 1);  /* use texture unit 0 */
294
 
   }
295
 
   CheckError(__LINE__);
296
 
 
297
 
   glClearColor(0.3f, 0.3f, 0.3f, 0.0f);
298
 
   glColor3f(1, 1, 1);
299
 
 
300
 
   MakeTexture();
301
 
   CheckError(__LINE__);
302
 
}
303
 
 
304
 
 
305
 
static void
306
 
ParseOptions(int argc, char *argv[])
307
 
{
308
 
   int i;
309
 
   for (i = 1; i < argc; i++) {
310
 
      if (strcmp(argv[i], "-fs") == 0) {
311
 
         FragProgFile = argv[i+1];
312
 
      }
313
 
      else if (strcmp(argv[i], "-vs") == 0) {
314
 
         VertProgFile = argv[i+1];
315
 
      }
316
 
   }
317
 
}
318
 
 
319
 
 
320
 
int
321
 
main(int argc, char *argv[])
322
 
{
323
 
   glutInit(&argc, argv);
324
 
   glutInitWindowSize(400, 300);
325
 
   glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
326
 
   win = glutCreateWindow(argv[0]);
327
 
   glewInit();
328
 
   glutReshapeFunc(Reshape);
329
 
   glutKeyboardFunc(Key);
330
 
   glutDisplayFunc(Redisplay);
331
 
   ParseOptions(argc, argv);
332
 
   Init();
333
 
   glutMainLoop();
334
 
   return 0;
335
 
}
336
 
 
337