← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa/quantal

« back to all changes in this revision

Viewing changes to src/glu/mini/glu.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2007-02-21 12:44:07 UTC
  • mfrom: (1.2.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 22.
  • Revision ID: james.westby@ubuntu.com-20070221124407-rgcacs32mycrtadl
Import upstream version 6.5.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/glu/mini/glu.c
1
 
/* $Id: glu.c,v 1.2 2003-08-22 20:11:43 brianp Exp $ */
2
 
 
3
 
/*
4
 
 * Mesa 3-D graphics library
5
 
 * Version:  3.5
6
 
 * Copyright (C) 1995-2001  Brian Paul
7
 
 *
8
 
 * This library is free software; you can redistribute it and/or
9
 
 * modify it under the terms of the GNU Library General Public
10
 
 * License as published by the Free Software Foundation; either
11
 
 * version 2 of the License, or (at your option) any later version.
12
 
 *
13
 
 * This library is distributed in the hope that it will be useful,
14
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 
 * Library General Public License for more details.
17
 
 *
18
 
 * You should have received a copy of the GNU Library General Public
19
 
 * License along with this library; if not, write to the Free
20
 
 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21
 
 */
22
 
 
23
 
 
24
 
#ifdef PC_HEADER
25
 
#include "all.h"
26
 
#else
27
 
#include <assert.h>
28
 
#include <math.h>
29
 
#include <stdio.h>
30
 
#include <stdlib.h>
31
 
#include <string.h>
32
 
#include "gluP.h"
33
 
#endif
34
 
 
35
 
 
36
 
/*
37
 
 * Miscellaneous utility functions
38
 
 */
39
 
 
40
 
 
41
 
#ifndef M_PI
42
 
#define M_PI 3.1415926536
43
 
#endif
44
 
#define EPS 0.00001
45
 
 
46
 
#ifndef GLU_INCOMPATIBLE_GL_VERSION
47
 
#define GLU_INCOMPATIBLE_GL_VERSION     100903
48
 
#endif
49
 
 
50
 
 
51
 
void GLAPIENTRY
52
 
gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez,
53
 
          GLdouble centerx, GLdouble centery, GLdouble centerz,
54
 
          GLdouble upx, GLdouble upy, GLdouble upz)
55
 
{
56
 
   GLfloat m[16];
57
 
   GLfloat x[3], y[3], z[3];
58
 
   GLfloat mag;
59
 
 
60
 
   /* Make rotation matrix */
61
 
 
62
 
   /* Z vector */
63
 
   z[0] = eyex - centerx;
64
 
   z[1] = eyey - centery;
65
 
   z[2] = eyez - centerz;
66
 
   mag = sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]);
67
 
   if (mag) {                   /* mpichler, 19950515 */
68
 
      z[0] /= mag;
69
 
      z[1] /= mag;
70
 
      z[2] /= mag;
71
 
   }
72
 
 
73
 
   /* Y vector */
74
 
   y[0] = upx;
75
 
   y[1] = upy;
76
 
   y[2] = upz;
77
 
 
78
 
   /* X vector = Y cross Z */
79
 
   x[0] = y[1] * z[2] - y[2] * z[1];
80
 
   x[1] = -y[0] * z[2] + y[2] * z[0];
81
 
   x[2] = y[0] * z[1] - y[1] * z[0];
82
 
 
83
 
   /* Recompute Y = Z cross X */
84
 
   y[0] = z[1] * x[2] - z[2] * x[1];
85
 
   y[1] = -z[0] * x[2] + z[2] * x[0];
86
 
   y[2] = z[0] * x[1] - z[1] * x[0];
87
 
 
88
 
   /* mpichler, 19950515 */
89
 
   /* cross product gives area of parallelogram, which is < 1.0 for
90
 
    * non-perpendicular unit-length vectors; so normalize x, y here
91
 
    */
92
 
 
93
 
   mag = sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);
94
 
   if (mag) {
95
 
      x[0] /= mag;
96
 
      x[1] /= mag;
97
 
      x[2] /= mag;
98
 
   }
99
 
 
100
 
   mag = sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]);
101
 
   if (mag) {
102
 
      y[0] /= mag;
103
 
      y[1] /= mag;
104
 
      y[2] /= mag;
105
 
   }
106
 
 
107
 
#define M(row,col)  m[col*4+row]
108
 
   M(0, 0) = x[0];
109
 
   M(0, 1) = x[1];
110
 
   M(0, 2) = x[2];
111
 
   M(0, 3) = 0.0;
112
 
   M(1, 0) = y[0];
113
 
   M(1, 1) = y[1];
114
 
   M(1, 2) = y[2];
115
 
   M(1, 3) = 0.0;
116
 
   M(2, 0) = z[0];
117
 
   M(2, 1) = z[1];
118
 
   M(2, 2) = z[2];
119
 
   M(2, 3) = 0.0;
120
 
   M(3, 0) = 0.0;
121
 
   M(3, 1) = 0.0;
122
 
   M(3, 2) = 0.0;
123
 
   M(3, 3) = 1.0;
124
 
#undef M
125
 
   glMultMatrixf(m);
126
 
 
127
 
   /* Translate Eye to Origin */
128
 
   glTranslatef(-eyex, -eyey, -eyez);
129
 
 
130
 
}
131
 
 
132
 
 
133
 
 
134
 
void GLAPIENTRY
135
 
gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top)
136
 
{
137
 
   glOrtho(left, right, bottom, top, -1.0, 1.0);
138
 
}
139
 
 
140
 
 
141
 
 
142
 
static void
143
 
frustum(GLfloat left, GLfloat right,
144
 
        GLfloat bottom, GLfloat top, 
145
 
        GLfloat nearval, GLfloat farval)
146
 
{
147
 
   GLfloat x, y, a, b, c, d;
148
 
   GLfloat m[16];
149
 
 
150
 
   x = (2.0 * nearval) / (right - left);
151
 
   y = (2.0 * nearval) / (top - bottom);
152
 
   a = (right + left) / (right - left);
153
 
   b = (top + bottom) / (top - bottom);
154
 
   c = -(farval + nearval) / ( farval - nearval);
155
 
   d = -(2.0 * farval * nearval) / (farval - nearval);
156
 
 
157
 
#define M(row,col)  m[col*4+row]
158
 
   M(0,0) = x;     M(0,1) = 0.0F;  M(0,2) = a;      M(0,3) = 0.0F;
159
 
   M(1,0) = 0.0F;  M(1,1) = y;     M(1,2) = b;      M(1,3) = 0.0F;
160
 
   M(2,0) = 0.0F;  M(2,1) = 0.0F;  M(2,2) = c;      M(2,3) = d;
161
 
   M(3,0) = 0.0F;  M(3,1) = 0.0F;  M(3,2) = -1.0F;  M(3,3) = 0.0F;
162
 
#undef M
163
 
 
164
 
   glMultMatrixf(m);
165
 
}
166
 
 
167
 
 
168
 
void GLAPIENTRY
169
 
gluPerspective(GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar)
170
 
{
171
 
   GLfloat xmin, xmax, ymin, ymax;
172
 
 
173
 
   ymax = zNear * tan(fovy * M_PI / 360.0);
174
 
   ymin = -ymax;
175
 
   xmin = ymin * aspect;
176
 
   xmax = ymax * aspect;
177
 
 
178
 
   /* don't call glFrustum() because of error semantics (covglu) */
179
 
   frustum(xmin, xmax, ymin, ymax, zNear, zFar);
180
 
}
181
 
 
182
 
 
183
 
 
184
 
void GLAPIENTRY
185
 
gluPickMatrix(GLdouble x, GLdouble y,
186
 
              GLdouble width, GLdouble height, GLint viewport[4])
187
 
{
188
 
   GLfloat m[16];
189
 
   GLfloat sx, sy;
190
 
   GLfloat tx, ty;
191
 
 
192
 
   sx = viewport[2] / width;
193
 
   sy = viewport[3] / height;
194
 
   tx = (viewport[2] + 2.0 * (viewport[0] - x)) / width;
195
 
   ty = (viewport[3] + 2.0 * (viewport[1] - y)) / height;
196
 
 
197
 
#define M(row,col)  m[col*4+row]
198
 
   M(0, 0) = sx;
199
 
   M(0, 1) = 0.0;
200
 
   M(0, 2) = 0.0;
201
 
   M(0, 3) = tx;
202
 
   M(1, 0) = 0.0;
203
 
   M(1, 1) = sy;
204
 
   M(1, 2) = 0.0;
205
 
   M(1, 3) = ty;
206
 
   M(2, 0) = 0.0;
207
 
   M(2, 1) = 0.0;
208
 
   M(2, 2) = 1.0;
209
 
   M(2, 3) = 0.0;
210
 
   M(3, 0) = 0.0;
211
 
   M(3, 1) = 0.0;
212
 
   M(3, 2) = 0.0;
213
 
   M(3, 3) = 1.0;
214
 
#undef M
215
 
 
216
 
   glMultMatrixf(m);
217
 
}
218
 
 
219
 
 
220
 
 
221
 
const GLubyte *GLAPIENTRY
222
 
gluErrorString(GLenum errorCode)
223
 
{
224
 
   static char *tess_error[] = {
225
 
      "missing gluBeginPolygon",
226
 
      "missing gluBeginContour",
227
 
      "missing gluEndPolygon",
228
 
      "missing gluEndContour",
229
 
      "misoriented or self-intersecting loops",
230
 
      "coincident vertices",
231
 
      "colinear vertices",
232
 
      "FIST recovery process fatal error"
233
 
   };
234
 
   static char *nurbs_error[] = {
235
 
      "spline order un-supported",
236
 
      "too few knots",
237
 
      "valid knot range is empty",
238
 
      "decreasing knot sequence knot",
239
 
      "knot multiplicity greater than order of spline",
240
 
      "endcurve() must follow bgncurve()",
241
 
      "bgncurve() must precede endcurve()",
242
 
      "missing or extra geometric data",
243
 
      "can't draw pwlcurves",
244
 
      "missing bgncurve()",
245
 
      "missing bgnsurface()",
246
 
      "endtrim() must precede endsurface()",
247
 
      "bgnsurface() must precede endsurface()",
248
 
      "curve of improper type passed as trim curve",
249
 
      "bgnsurface() must precede bgntrim()",
250
 
      "endtrim() must follow bgntrim()",
251
 
      "bgntrim() must precede endtrim()",
252
 
      "invalid or missing trim curve",
253
 
      "bgntrim() must precede pwlcurve()",
254
 
      "pwlcurve referenced twice",
255
 
      "pwlcurve and nurbscurve mixed",
256
 
      "improper usage of trim data type",
257
 
      "nurbscurve referenced twice",
258
 
      "nurbscurve and pwlcurve mixed",
259
 
      "nurbssurface referenced twice",
260
 
      "invalid property",
261
 
      "endsurface() must follow bgnsurface()",
262
 
      "misoriented trim curves",
263
 
      "intersecting trim curves",
264
 
      "UNUSED",
265
 
      "unconnected trim curves",
266
 
      "unknown knot error",
267
 
      "negative vertex count encountered",
268
 
      "negative byte-stride encountered",
269
 
      "unknown type descriptor",
270
 
      "null control array or knot vector",
271
 
      "duplicate point on pwlcurve"
272
 
   };
273
 
 
274
 
   /* GL Errors */
275
 
   if (errorCode == GL_NO_ERROR) {
276
 
      return (GLubyte *) "no error";
277
 
   }
278
 
   else if (errorCode == GL_INVALID_VALUE) {
279
 
      return (GLubyte *) "invalid value";
280
 
   }
281
 
   else if (errorCode == GL_INVALID_ENUM) {
282
 
      return (GLubyte *) "invalid enum";
283
 
   }
284
 
   else if (errorCode == GL_INVALID_OPERATION) {
285
 
      return (GLubyte *) "invalid operation";
286
 
   }
287
 
   else if (errorCode == GL_STACK_OVERFLOW) {
288
 
      return (GLubyte *) "stack overflow";
289
 
   }
290
 
   else if (errorCode == GL_STACK_UNDERFLOW) {
291
 
      return (GLubyte *) "stack underflow";
292
 
   }
293
 
   else if (errorCode == GL_OUT_OF_MEMORY) {
294
 
      return (GLubyte *) "out of memory";
295
 
   }
296
 
   /* GLU Errors */
297
 
   else if (errorCode == GLU_NO_ERROR) {
298
 
      return (GLubyte *) "no error";
299
 
   }
300
 
   else if (errorCode == GLU_INVALID_ENUM) {
301
 
      return (GLubyte *) "invalid enum";
302
 
   }
303
 
   else if (errorCode == GLU_INVALID_VALUE) {
304
 
      return (GLubyte *) "invalid value";
305
 
   }
306
 
   else if (errorCode == GLU_OUT_OF_MEMORY) {
307
 
      return (GLubyte *) "out of memory";
308
 
   }
309
 
   else if (errorCode == GLU_INCOMPATIBLE_GL_VERSION) {
310
 
      return (GLubyte *) "incompatible GL version";
311
 
   }
312
 
   else if (errorCode >= GLU_TESS_ERROR1 && errorCode <= GLU_TESS_ERROR8) {
313
 
      return (GLubyte *) tess_error[errorCode - GLU_TESS_ERROR1];
314
 
   }
315
 
   else if (errorCode >= GLU_NURBS_ERROR1 && errorCode <= GLU_NURBS_ERROR37) {
316
 
      return (GLubyte *) nurbs_error[errorCode - GLU_NURBS_ERROR1];
317
 
   }
318
 
   else {
319
 
      return NULL;
320
 
   }
321
 
}
322
 
 
323
 
 
324
 
 
325
 
/*
326
 
 * New in GLU 1.1
327
 
 */
328
 
 
329
 
const GLubyte *GLAPIENTRY
330
 
gluGetString(GLenum name)
331
 
{
332
 
   static char *extensions = "GL_EXT_abgr";
333
 
   static char *version = "1.1 Mesa 3.5";
334
 
 
335
 
   switch (name) {
336
 
   case GLU_EXTENSIONS:
337
 
      return (GLubyte *) extensions;
338
 
   case GLU_VERSION:
339
 
      return (GLubyte *) version;
340
 
   default:
341
 
      return NULL;
342
 
   }
343
 
}
344
 
 
345
 
 
346
 
 
347
 
#if 0                           /* gluGetProcAddressEXT not finalized yet! */
348
 
 
349
 
#ifdef __cplusplus
350
 
   /* for BeOS R4.5 */
351
 
void GLAPIENTRY(*gluGetProcAddressEXT(const GLubyte * procName)) (...)
352
 
#else
353
 
void (GLAPIENTRY * gluGetProcAddressEXT(const GLubyte * procName)) ()
354
 
#endif
355
 
{
356
 
   struct proc
357
 
   {
358
 
      const char *name;
359
 
      void *address;
360
 
   };
361
 
   static struct proc procTable[] = {
362
 
      {"gluGetProcAddressEXT", (void *) gluGetProcAddressEXT},  /* me! */
363
 
 
364
 
      /* new 1.1 functions */
365
 
      {"gluGetString", (void *) gluGetString},
366
 
 
367
 
      /* new 1.2 functions */
368
 
      {"gluTessBeginPolygon", (void *) gluTessBeginPolygon},
369
 
      {"gluTessBeginContour", (void *) gluTessBeginContour},
370
 
      {"gluTessEndContour", (void *) gluTessEndContour},
371
 
      {"gluTessEndPolygon", (void *) gluTessEndPolygon},
372
 
      {"gluGetTessProperty", (void *) gluGetTessProperty},
373
 
 
374
 
      /* new 1.3 functions */
375
 
 
376
 
      {NULL, NULL}
377
 
   };
378
 
   GLuint i;
379
 
 
380
 
   for (i = 0; procTable[i].address; i++) {
381
 
      if (strcmp((const char *) procName, procTable[i].name) == 0)
382
 
         return (void (GLAPIENTRY *) ()) procTable[i].address;
383
 
   }
384
 
 
385
 
   return NULL;
386
 
}
387
 
 
388
 
#endif
389
 
 
390
 
 
391
 
 
392
 
/*
393
 
 * New in GLU 1.3
394
 
 */
395
 
#ifdef GLU_VERSION_1_3
396
 
GLboolean GLAPIENTRY
397
 
gluCheckExtension(const GLubyte *extName, const GLubyte * extString)
398
 
{
399
 
   assert(extName);
400
 
   assert(extString);
401
 
   {
402
 
      const int len = strlen((const char *) extName);
403
 
      const char *start = (const char *) extString;
404
 
 
405
 
      while (1) {
406
 
         const char *c = strstr(start, (const char *) extName);
407
 
         if (!c)
408
 
            return GL_FALSE;
409
 
 
410
 
         if ((c == start || c[-1] == ' ') && (c[len] == ' ' || c[len] == 0))
411
 
            return GL_TRUE;
412
 
 
413
 
         start = c + len;
414
 
      }
415
 
   }
416
 
}
417
 
#endif