← Back to branch summary

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

« back to all changes in this revision

Viewing changes to progs/glsl/multinoise.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/multinoise.c
1
 
/**
2
 
 * Another test for noise() functions (noise1 to noise4 tested independently).
3
 
 * 13 Dec 2008
4
 
 */
5
 
 
6
 
#include <assert.h>
7
 
#include <string.h>
8
 
#include <stdio.h>
9
 
#include <stdlib.h>
10
 
#include <math.h>
11
 
#include <GL/glew.h>
12
 
#include <GL/glut.h>
13
 
 
14
 
static const char *VertShaderText =
15
 
   "void main() {\n"
16
 
   "   gl_TexCoord[0].xyz = gl_Vertex.xyz;\n"
17
 
   "   gl_TexCoord[0].w = gl_MultiTexCoord1.x;\n"
18
 
   "   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
19
 
   "}\n";
20
 
 
21
 
static const char *FragShaderText[ 4 ] = {
22
 
   "void main()\n"
23
 
   "{\n"
24
 
   "   gl_FragColor.rgb = noise3( gl_TexCoord[ 0 ].w ) * 0.5 + 0.5;\n"
25
 
   "   gl_FragColor.a = 1.0;\n"
26
 
   "}\n",
27
 
   "void main()\n"
28
 
   "{\n"
29
 
   "   gl_FragColor.rgb = noise3( gl_TexCoord[ 0 ].xw ) * 0.5 + 0.5;\n"
30
 
   "   gl_FragColor.a = 1.0;\n"
31
 
   "}\n",
32
 
   "void main()\n"
33
 
   "{\n"
34
 
   "   gl_FragColor.rgb = noise3( gl_TexCoord[ 0 ].xyw ) * 0.5 + 0.5;\n"
35
 
   "   gl_FragColor.a = 1.0;\n"
36
 
   "}\n",
37
 
   "void main()\n"
38
 
   "{\n"
39
 
   "   gl_FragColor.rgb = noise3( gl_TexCoord[ 0 ].xyzw ) * 0.5 + 0.5;\n"
40
 
   "   gl_FragColor.a = 1.0;\n"
41
 
   "}\n"
42
 
};
43
 
    
44
 
struct uniform_info {
45
 
   const char *name;
46
 
   GLuint size;
47
 
   GLint location;
48
 
   GLfloat value[4];
49
 
};
50
 
 
51
 
/* program/shader objects */
52
 
static GLuint fragShader[ 4 ];
53
 
static GLuint vertShader;
54
 
static GLuint program[ 4 ];
55
 
 
56
 
static GLint win = 0;
57
 
static GLfloat xRot = 0.0f, yRot = 0.0f, zRot = 0.0f;
58
 
static GLfloat Slice = 0.0;
59
 
static GLboolean Anim = GL_FALSE;
60
 
 
61
 
 
62
 
static void
63
 
Idle(void)
64
 
{
65
 
   Slice += 0.01;
66
 
   glutPostRedisplay();
67
 
}
68
 
 
69
 
 
70
 
static void
71
 
Redisplay(void)
72
 
{
73
 
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
74
 
 
75
 
   glMultiTexCoord1f( GL_TEXTURE1, Slice );
76
 
   
77
 
   glPushMatrix();
78
 
   glRotatef(xRot, 1.0f, 0.0f, 0.0f);
79
 
   glRotatef(yRot, 0.0f, 1.0f, 0.0f);
80
 
   glRotatef(zRot, 0.0f, 0.0f, 1.0f);
81
 
 
82
 
   glutSolidTeapot( 1.0 );
83
 
 
84
 
   glPopMatrix();
85
 
 
86
 
   glutSwapBuffers();
87
 
}
88
 
 
89
 
 
90
 
static void
91
 
Reshape(int width, int height)
92
 
{
93
 
   glViewport(0, 0, width, height);
94
 
   glMatrixMode(GL_PROJECTION);
95
 
   glLoadIdentity();
96
 
   glFrustum(-1.0, 1.0, -1.0, 1.0, 5.0, 25.0);
97
 
   glMatrixMode(GL_MODELVIEW);
98
 
   glLoadIdentity();
99
 
   glTranslatef(0.0f, 0.0f, -15.0f);
100
 
}
101
 
 
102
 
 
103
 
static void
104
 
CleanUp(void)
105
 
{
106
 
   GLint i;
107
 
 
108
 
   glDeleteShader(vertShader);
109
 
   for( i = 0; i < 4; i++ ) {
110
 
      glDeleteShader(fragShader[ i ]);
111
 
      glDeleteProgram(program[ i ]);
112
 
   }
113
 
   glutDestroyWindow(win);
114
 
}
115
 
 
116
 
 
117
 
static void
118
 
Key(unsigned char key, int x, int y)
119
 
{
120
 
   const GLfloat step = 0.01;
121
 
  (void) x;
122
 
  (void) y;
123
 
 
124
 
   switch(key) {
125
 
   case 'a':
126
 
      Anim = !Anim;
127
 
      glutIdleFunc(Anim ? Idle : NULL);
128
 
      break;
129
 
   case 's':
130
 
      Slice -= step;
131
 
      break;
132
 
   case 'S':
133
 
      Slice += step;
134
 
      break;
135
 
   case 'z':
136
 
      zRot -= 1.0;
137
 
      break;
138
 
   case 'Z':
139
 
      zRot += 1.0;
140
 
      break;
141
 
   case '1':
142
 
   case '2':
143
 
   case '3':
144
 
   case '4':
145
 
      glUseProgram(program[ key - '1' ]);
146
 
      break;
147
 
   case 27:
148
 
      CleanUp();
149
 
      exit(0);
150
 
      break;
151
 
   }
152
 
   glutPostRedisplay();
153
 
}
154
 
 
155
 
 
156
 
static void
157
 
SpecialKey(int key, int x, int y)
158
 
{
159
 
   const GLfloat step = 3.0f;
160
 
 
161
 
  (void) x;
162
 
  (void) y;
163
 
 
164
 
   switch(key) {
165
 
   case GLUT_KEY_UP:
166
 
      xRot -= step;
167
 
      break;
168
 
   case GLUT_KEY_DOWN:
169
 
      xRot += step;
170
 
      break;
171
 
   case GLUT_KEY_LEFT:
172
 
      yRot -= step;
173
 
      break;
174
 
   case GLUT_KEY_RIGHT:
175
 
      yRot += step;
176
 
      break;
177
 
   }
178
 
   glutPostRedisplay();
179
 
}
180
 
 
181
 
 
182
 
 
183
 
static void
184
 
LoadAndCompileShader(GLuint shader, const char *text)
185
 
{
186
 
   GLint stat;
187
 
 
188
 
   glShaderSource(shader, 1, (const GLchar **) &text, NULL);
189
 
 
190
 
   glCompileShader(shader);
191
 
 
192
 
   glGetShaderiv(shader, GL_COMPILE_STATUS, &stat);
193
 
   if (!stat) {
194
 
      GLchar log[1000];
195
 
      GLsizei len;
196
 
      glGetShaderInfoLog(shader, 1000, &len, log);
197
 
      fprintf(stderr, "multinoise: problem compiling shader: %s\n", log);
198
 
      exit(1);
199
 
   }
200
 
   else {
201
 
      printf("Shader compiled OK\n");
202
 
   }
203
 
}
204
 
 
205
 
 
206
 
static void
207
 
CheckLink(GLuint prog)
208
 
{
209
 
   GLint stat;
210
 
   glGetProgramiv(prog, GL_LINK_STATUS, &stat);
211
 
   if (!stat) {
212
 
      GLchar log[1000];
213
 
      GLsizei len;
214
 
      glGetProgramInfoLog(prog, 1000, &len, log);
215
 
      fprintf(stderr, "Linker error:\n%s\n", log);
216
 
   }
217
 
   else {
218
 
      fprintf(stderr, "Link success!\n");
219
 
   }
220
 
}
221
 
 
222
 
 
223
 
static void
224
 
Init(void)
225
 
{
226
 
   const char *version;
227
 
   GLint i;
228
 
 
229
 
   version = (const char *) glGetString(GL_VERSION);
230
 
   if (version[0] != '2' || version[1] != '.') {
231
 
      printf("Warning: this program expects OpenGL 2.0\n");
232
 
      /*exit(1);*/
233
 
   }
234
 
 
235
 
   vertShader = glCreateShader(GL_VERTEX_SHADER);
236
 
   LoadAndCompileShader(vertShader, VertShaderText);
237
 
 
238
 
   for( i = 0; i < 4; i++ ) {
239
 
      fragShader[ i ] = glCreateShader(GL_FRAGMENT_SHADER);
240
 
      LoadAndCompileShader(fragShader[ i ], FragShaderText[ i ]);
241
 
      program[ i ] = glCreateProgram();
242
 
      glAttachShader(program[ i ], fragShader[ i ]);
243
 
      glAttachShader(program[ i ], vertShader);
244
 
      glLinkProgram(program[ i ]);
245
 
      CheckLink(program[ i ]);
246
 
   }
247
 
   
248
 
   glUseProgram(program[ 0 ]);
249
 
 
250
 
   assert(glGetError() == 0);
251
 
 
252
 
   glClearColor(0.4f, 0.4f, 0.8f, 0.0f);
253
 
 
254
 
   glColor3f(1, 0, 0);
255
 
 
256
 
   glFrontFace( GL_CW );
257
 
   glEnable( GL_CULL_FACE );
258
 
   glEnable( GL_DEPTH_TEST );
259
 
}
260
 
 
261
 
 
262
 
int
263
 
main(int argc, char *argv[])
264
 
{
265
 
   glutInit(&argc, argv);
266
 
   glutInitWindowSize(400, 400);
267
 
   glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
268
 
   win = glutCreateWindow(argv[0]);
269
 
   glewInit();
270
 
   glutReshapeFunc(Reshape);
271
 
   glutKeyboardFunc(Key);
272
 
   glutSpecialFunc(SpecialKey);
273
 
   glutDisplayFunc(Redisplay);
274
 
   Init();
275
 
   glutMainLoop();
276
 
   return 0;
277
 
}
278