← Back to branch summary

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

« back to all changes in this revision

Viewing changes to progs/glsl/trirast.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/trirast.c
1
 
/**
2
 
 * Demonstration of doing triangle rasterization with a fragment program.
3
 
 * Basic idea:
4
 
 *   1. Draw screen-aligned quad / bounding box around the triangle verts.
5
 
 *   2. For each pixel in the quad, determine if pixel is inside/outside
6
 
 *      the triangle edges.
7
 
 *
8
 
 * Brian Paul
9
 
 * 1 Aug 2007
10
 
 */
11
 
 
12
 
 
13
 
#include <assert.h>
14
 
#include <string.h>
15
 
#include <stdio.h>
16
 
#include <stdlib.h>
17
 
#include <math.h>
18
 
#include <GL/glew.h>
19
 
#include <GL/glut.h>
20
 
#include "shaderutil.h"
21
 
 
22
 
 
23
 
static GLint WinWidth = 300, WinHeight = 300;
24
 
static char *FragProgFile = NULL;
25
 
static char *VertProgFile = NULL;
26
 
static GLuint fragShader;
27
 
static GLuint vertShader;
28
 
static GLuint program;
29
 
static GLint win = 0;
30
 
static GLboolean anim = GL_TRUE;
31
 
static GLfloat Zrot = 0.0f;
32
 
static GLint uv0, uv1, uv2;
33
 
 
34
 
 
35
 
static const GLfloat TriVerts[3][2] = {
36
 
   { 50,  50 },
37
 
   { 250, 50 },
38
 
   { 150, 250 }
39
 
};
40
 
 
41
 
 
42
 
static void
43
 
RotateVerts(GLfloat a,
44
 
            GLuint n, const GLfloat vertsIn[][2], GLfloat vertsOut[][2])
45
 
{
46
 
   GLuint i;
47
 
   GLfloat cx = WinWidth / 2, cy = WinHeight / 2;
48
 
   for (i = 0; i < n; i++) {
49
 
      float x = vertsIn[i][0] - cx;
50
 
      float y = vertsIn[i][1] - cy;
51
 
      
52
 
      vertsOut[i][0] =  x * cos(a) + y * sin(a)  + cx;
53
 
      vertsOut[i][1] = -x * sin(a) + y * cos(a)  + cy;
54
 
   }
55
 
}
56
 
 
57
 
static void
58
 
ComputeBounds(GLuint n, GLfloat vertsIn[][2],
59
 
              GLfloat *xmin, GLfloat *ymin,
60
 
              GLfloat *xmax, GLfloat *ymax)
61
 
{
62
 
   GLuint i;
63
 
   *xmin = *xmax = vertsIn[0][0];
64
 
   *ymin = *ymax = vertsIn[0][1];
65
 
   for (i = 1; i < n; i++) {
66
 
      if (vertsIn[i][0] < *xmin)
67
 
         *xmin = vertsIn[i][0];
68
 
      else if (vertsIn[i][0] > *xmax)
69
 
         *xmax = vertsIn[i][0];
70
 
      if (vertsIn[i][1] < *ymin)
71
 
         *ymin = vertsIn[i][1];
72
 
      else if (vertsIn[i][1] > *ymax)
73
 
         *ymax = vertsIn[i][1];
74
 
   }
75
 
}
76
 
 
77
 
 
78
 
static void
79
 
Redisplay(void)
80
 
{
81
 
   GLfloat v[3][2], xmin, ymin, xmax, ymax;
82
 
 
83
 
   RotateVerts(Zrot, 3, TriVerts, v);
84
 
   ComputeBounds(3, v, &xmin, &ymin, &xmax, &ymax);
85
 
 
86
 
   glUniform2fv(uv0, 1, v[0]);
87
 
   glUniform2fv(uv1, 1, v[1]);
88
 
   glUniform2fv(uv2, 1, v[2]);
89
 
 
90
 
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
91
 
 
92
 
   glPushMatrix();
93
 
   glBegin(GL_POLYGON);
94
 
   glVertex2f(xmin, ymin);
95
 
   glVertex2f(xmax, ymin);
96
 
   glVertex2f(xmax, ymax);
97
 
   glVertex2f(xmin, ymax);
98
 
   glEnd();
99
 
   glPopMatrix();
100
 
 
101
 
   glutSwapBuffers();
102
 
}
103
 
 
104
 
 
105
 
static void
106
 
Idle(void)
107
 
{
108
 
   if (anim) {
109
 
      Zrot = glutGet(GLUT_ELAPSED_TIME) * 0.0005;
110
 
      glutPostRedisplay();
111
 
   }
112
 
   else
113
 
      abort();
114
 
}
115
 
 
116
 
 
117
 
static void
118
 
Reshape(int width, int height)
119
 
{
120
 
   glViewport(0, 0, width, height);
121
 
   glMatrixMode(GL_PROJECTION);
122
 
   glLoadIdentity();
123
 
   glOrtho(0, width, 0, height, -1, 1);
124
 
 
125
 
   glMatrixMode(GL_MODELVIEW);
126
 
   glLoadIdentity();
127
 
}
128
 
 
129
 
 
130
 
static void
131
 
CleanUp(void)
132
 
{
133
 
   glDeleteShader(fragShader);
134
 
   glDeleteShader(vertShader);
135
 
   glDeleteProgram(program);
136
 
   glutDestroyWindow(win);
137
 
}
138
 
 
139
 
 
140
 
static void
141
 
Key(unsigned char key, int x, int y)
142
 
{
143
 
  (void) x;
144
 
  (void) y;
145
 
 
146
 
   switch(key) {
147
 
   case ' ':
148
 
   case 'a':
149
 
      anim = !anim;
150
 
      if (anim)
151
 
         glutIdleFunc(Idle);
152
 
      else
153
 
         glutIdleFunc(NULL);
154
 
      break;
155
 
   case 'z':
156
 
      Zrot = 0;
157
 
      break;
158
 
   case 's':
159
 
      Zrot += 0.05;
160
 
      break;
161
 
   case 27:
162
 
      CleanUp();
163
 
      exit(0);
164
 
      break;
165
 
   }
166
 
   glutPostRedisplay();
167
 
}
168
 
 
169
 
 
170
 
static void
171
 
Init(void)
172
 
{
173
 
   static const char *fragShaderText =
174
 
      "uniform vec2 v0, v1, v2; \n"
175
 
      "float crs(const vec2 u, const vec2 v) \n"
176
 
      "{ \n"
177
 
      "   return u.x * v.y - u.y * v.x; \n"
178
 
      "} \n"
179
 
      "\n"
180
 
      "void main() {\n"
181
 
      "   vec2 p = gl_FragCoord.xy; \n"
182
 
      "   if (crs(v1 - v0, p - v0) >= 0.0 && \n"
183
 
      "       crs(v2 - v1, p - v1) >= 0.0 && \n"
184
 
      "       crs(v0 - v2, p - v2) >= 0.0) \n"
185
 
      "      gl_FragColor = vec4(1.0); \n"
186
 
      "   else \n"
187
 
      "      gl_FragColor = vec4(0.5); \n"
188
 
      "}\n";
189
 
   static const char *vertShaderText =
190
 
      "void main() {\n"
191
 
      "   gl_Position = ftransform(); \n"
192
 
      "}\n";
193
 
 
194
 
   if (!ShadersSupported())
195
 
      exit(1);
196
 
 
197
 
   vertShader = CompileShaderText(GL_VERTEX_SHADER, vertShaderText);
198
 
   fragShader = CompileShaderText(GL_FRAGMENT_SHADER, fragShaderText);
199
 
   program = LinkShaders(vertShader, fragShader);
200
 
 
201
 
   glUseProgram(program);
202
 
 
203
 
   uv0 = glGetUniformLocation(program, "v0");
204
 
   uv1 = glGetUniformLocation(program, "v1");
205
 
   uv2 = glGetUniformLocation(program, "v2");
206
 
   printf("Uniforms: %d %d %d\n", uv0, uv1, uv2);
207
 
 
208
 
   /*assert(glGetError() == 0);*/
209
 
 
210
 
   glClearColor(0.3f, 0.3f, 0.3f, 0.0f);
211
 
   glEnable(GL_DEPTH_TEST);
212
 
 
213
 
   printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
214
 
 
215
 
   assert(glIsProgram(program));
216
 
   assert(glIsShader(fragShader));
217
 
   assert(glIsShader(vertShader));
218
 
 
219
 
   glColor3f(1, 0, 0);
220
 
}
221
 
 
222
 
 
223
 
static void
224
 
ParseOptions(int argc, char *argv[])
225
 
{
226
 
   int i;
227
 
   for (i = 1; i < argc; i++) {
228
 
      if (strcmp(argv[i], "-fs") == 0) {
229
 
         FragProgFile = argv[i+1];
230
 
      }
231
 
      else if (strcmp(argv[i], "-vs") == 0) {
232
 
         VertProgFile = argv[i+1];
233
 
      }
234
 
   }
235
 
}
236
 
 
237
 
 
238
 
int
239
 
main(int argc, char *argv[])
240
 
{
241
 
   glutInit(&argc, argv);
242
 
   glutInitWindowSize(WinWidth, WinHeight);
243
 
   glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
244
 
   win = glutCreateWindow(argv[0]);
245
 
   glewInit();
246
 
   glutReshapeFunc(Reshape);
247
 
   glutKeyboardFunc(Key);
248
 
   glutDisplayFunc(Redisplay);
249
 
   if (anim)
250
 
      glutIdleFunc(Idle);
251
 
   ParseOptions(argc, argv);
252
 
   Init();
253
 
   glutMainLoop();
254
 
   return 0;
255
 
}