Subversion Repositories shark

Rev

Rev 55 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
55 pj 1
/* $Id: matrix.c,v 1.1 2003-02-28 11:42:03 pj Exp $ */
2
 
3
/*
4
 * Mesa 3-D graphics library
5
 * Version:  4.1
6
 *
7
 * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
8
 *
9
 * Permission is hereby granted, free of charge, to any person obtaining a
10
 * copy of this software and associated documentation files (the "Software"),
11
 * to deal in the Software without restriction, including without limitation
12
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13
 * and/or sell copies of the Software, and to permit persons to whom the
14
 * Software is furnished to do so, subject to the following conditions:
15
 *
16
 * The above copyright notice and this permission notice shall be included
17
 * in all copies or substantial portions of the Software.
18
 *
19
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
22
 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23
 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25
 */
26
 
27
 
28
/*
29
 * Matrix operations
30
 *
31
 * NOTES:
32
 * 1. 4x4 transformation matrices are stored in memory in column major order.
33
 * 2. Points/vertices are to be thought of as column vectors.
34
 * 3. Transformation of a point p by a matrix M is: p' = M * p
35
 */
36
 
37
 
38
#include "glheader.h"
39
#include "imports.h"
40
#include "buffers.h"
41
#include "context.h"
42
#include "enums.h"
43
#include "macros.h"
44
#include "matrix.h"
45
#include "mmath.h"
46
#include "mtypes.h"
47
#include "math/m_matrix.h"
48
 
49
 
50
 
51
void
52
_mesa_Frustum( GLdouble left, GLdouble right,
53
               GLdouble bottom, GLdouble top,
54
               GLdouble nearval, GLdouble farval )
55
{
56
   GET_CURRENT_CONTEXT(ctx);
57
   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
58
 
59
   if (nearval <= 0.0 ||
60
       farval <= 0.0 ||
61
       nearval == farval ||
62
       left == right ||
63
       top == bottom)
64
   {
65
      _mesa_error( ctx,  GL_INVALID_VALUE, "glFrustum" );
66
      return;
67
   }
68
 
69
   _math_matrix_frustum( ctx->CurrentStack->Top,
70
                         (GLfloat) left, (GLfloat) right,
71
                         (GLfloat) bottom, (GLfloat) top,
72
                         (GLfloat) nearval, (GLfloat) farval );
73
   ctx->NewState |= ctx->CurrentStack->DirtyFlag;
74
}
75
 
76
 
77
void
78
_mesa_Ortho( GLdouble left, GLdouble right,
79
             GLdouble bottom, GLdouble top,
80
             GLdouble nearval, GLdouble farval )
81
{
82
   GET_CURRENT_CONTEXT(ctx);
83
   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
84
 
85
   if (MESA_VERBOSE & VERBOSE_API)
86
      _mesa_debug(ctx, "glFrustum(%f, %f, %f, %f, %f, %f)\n",
87
                  left, right, bottom, top, nearval, farval);
88
 
89
   if (left == right ||
90
       bottom == top ||
91
       nearval == farval)
92
   {
93
      _mesa_error( ctx,  GL_INVALID_VALUE, "glOrtho" );
94
      return;
95
   }
96
 
97
   _math_matrix_ortho( ctx->CurrentStack->Top,
98
                       (GLfloat) left, (GLfloat) right,
99
                       (GLfloat) bottom, (GLfloat) top,
100
                       (GLfloat) nearval, (GLfloat) farval );
101
   ctx->NewState |= ctx->CurrentStack->DirtyFlag;
102
}
103
 
104
 
105
void
106
_mesa_MatrixMode( GLenum mode )
107
{
108
   GET_CURRENT_CONTEXT(ctx);
109
   ASSERT_OUTSIDE_BEGIN_END(ctx);
110
 
111
   if (ctx->Transform.MatrixMode == mode && mode != GL_TEXTURE)
112
      return;
113
   FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
114
 
115
   switch (mode) {
116
   case GL_MODELVIEW:
117
      ctx->CurrentStack = &ctx->ModelviewMatrixStack;
118
      break;
119
   case GL_PROJECTION:
120
      ctx->CurrentStack = &ctx->ProjectionMatrixStack;
121
      break;
122
   case GL_TEXTURE:
123
      ctx->CurrentStack = &ctx->TextureMatrixStack[ctx->Texture.CurrentUnit];
124
      break;
125
   case GL_COLOR:
126
      ctx->CurrentStack = &ctx->ColorMatrixStack;
127
      break;
128
   case GL_MATRIX0_NV:
129
   case GL_MATRIX1_NV:
130
   case GL_MATRIX2_NV:
131
   case GL_MATRIX3_NV:
132
   case GL_MATRIX4_NV:
133
   case GL_MATRIX5_NV:
134
   case GL_MATRIX6_NV:
135
   case GL_MATRIX7_NV:
136
      if (!ctx->Extensions.NV_vertex_program) {
137
         _mesa_error( ctx,  GL_INVALID_ENUM, "glMatrixMode" );
138
         return;
139
      }
140
      ctx->CurrentStack = &ctx->ProgramMatrixStack[mode - GL_MATRIX0_NV];
141
      break;
142
   default:
143
      _mesa_error( ctx,  GL_INVALID_ENUM, "glMatrixMode" );
144
      return;
145
   }
146
 
147
   ctx->Transform.MatrixMode = mode;
148
}
149
 
150
 
151
 
152
void
153
_mesa_PushMatrix( void )
154
{
155
   GET_CURRENT_CONTEXT(ctx);
156
   struct matrix_stack *stack = ctx->CurrentStack;
157
   ASSERT_OUTSIDE_BEGIN_END(ctx);
158
 
159
   if (MESA_VERBOSE&VERBOSE_API)
160
      _mesa_debug(ctx, "glPushMatrix %s\n",
161
                  _mesa_lookup_enum_by_nr(ctx->Transform.MatrixMode));
162
 
163
   if (stack->Depth + 1 >= stack->MaxDepth) {
164
      _mesa_error( ctx,  GL_STACK_OVERFLOW, "glPushMatrix" );
165
      return;
166
   }
167
   _math_matrix_copy( &stack->Stack[stack->Depth + 1],
168
                      &stack->Stack[stack->Depth] );
169
   stack->Depth++;
170
   stack->Top = &(stack->Stack[stack->Depth]);
171
   ctx->NewState |= stack->DirtyFlag;
172
}
173
 
174
 
175
 
176
void
177
_mesa_PopMatrix( void )
178
{
179
   GET_CURRENT_CONTEXT(ctx);
180
   struct matrix_stack *stack = ctx->CurrentStack;
181
   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
182
 
183
   if (MESA_VERBOSE&VERBOSE_API)
184
      _mesa_debug(ctx, "glPopMatrix %s\n",
185
                  _mesa_lookup_enum_by_nr(ctx->Transform.MatrixMode));
186
 
187
   if (stack->Depth == 0) {
188
      _mesa_error( ctx,  GL_STACK_UNDERFLOW, "glPopMatrix" );
189
      return;
190
   }
191
   stack->Depth--;
192
   stack->Top = &(stack->Stack[stack->Depth]);
193
   ctx->NewState |= stack->DirtyFlag;
194
}
195
 
196
 
197
 
198
void
199
_mesa_LoadIdentity( void )
200
{
201
   GET_CURRENT_CONTEXT(ctx);
202
   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
203
 
204
   if (MESA_VERBOSE & VERBOSE_API)
205
      _mesa_debug(ctx, "glLoadIdentity()");
206
 
207
   _math_matrix_set_identity( ctx->CurrentStack->Top );
208
   ctx->NewState |= ctx->CurrentStack->DirtyFlag;
209
}
210
 
211
 
212
void
213
_mesa_LoadMatrixf( const GLfloat *m )
214
{
215
   GET_CURRENT_CONTEXT(ctx);
216
   if (!m) return;
217
   if (MESA_VERBOSE & VERBOSE_API)
218
      _mesa_debug(ctx,
219
          "glLoadMatrix(%f %f %f %f, %f %f %f %f, %f %f %f %f, %f %f %f %f\n",
220
          m[0], m[4], m[8], m[12],
221
          m[1], m[5], m[9], m[13],
222
          m[2], m[6], m[10], m[14],
223
          m[3], m[7], m[11], m[15]);
224
 
225
   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
226
   _math_matrix_loadf( ctx->CurrentStack->Top, m );
227
   ctx->NewState |= ctx->CurrentStack->DirtyFlag;
228
}
229
 
230
 
231
void
232
_mesa_LoadMatrixd( const GLdouble *m )
233
{
234
   GLint i;
235
   GLfloat f[16];
236
   if (!m) return;
237
   for (i = 0; i < 16; i++)
238
      f[i] = (GLfloat) m[i];
239
   _mesa_LoadMatrixf(f);
240
}
241
 
242
 
243
 
244
/*
245
 * Multiply the active matrix by an arbitary matrix.
246
 */
247
void
248
_mesa_MultMatrixf( const GLfloat *m )
249
{
250
   GET_CURRENT_CONTEXT(ctx);
251
   if (!m) return;
252
   if (MESA_VERBOSE & VERBOSE_API)
253
      _mesa_debug(ctx,
254
          "glMultMatrix(%f %f %f %f, %f %f %f %f, %f %f %f %f, %f %f %f %f\n",
255
          m[0], m[4], m[8], m[12],
256
          m[1], m[5], m[9], m[13],
257
          m[2], m[6], m[10], m[14],
258
          m[3], m[7], m[11], m[15]);
259
   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
260
   _math_matrix_mul_floats( ctx->CurrentStack->Top, m );
261
   ctx->NewState |= ctx->CurrentStack->DirtyFlag;
262
}
263
 
264
 
265
/*
266
 * Multiply the active matrix by an arbitary matrix.
267
 */
268
void
269
_mesa_MultMatrixd( const GLdouble *m )
270
{
271
   GLint i;
272
   GLfloat f[16];
273
   if (!m) return;
274
   for (i = 0; i < 16; i++)
275
      f[i] = (GLfloat) m[i];
276
   _mesa_MultMatrixf( f );
277
}
278
 
279
 
280
 
281
 
282
/*
283
 * Execute a glRotate call
284
 */
285
void
286
_mesa_Rotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
287
{
288
   GET_CURRENT_CONTEXT(ctx);
289
   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
290
   if (angle != 0.0F) {
291
      _math_matrix_rotate( ctx->CurrentStack->Top, angle, x, y, z);
292
      ctx->NewState |= ctx->CurrentStack->DirtyFlag;
293
   }
294
}
295
 
296
void
297
_mesa_Rotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
298
{
299
   _mesa_Rotatef((GLfloat) angle, (GLfloat) x, (GLfloat) y, (GLfloat) z);
300
}
301
 
302
 
303
/*
304
 * Execute a glScale call
305
 */
306
void
307
_mesa_Scalef( GLfloat x, GLfloat y, GLfloat z )
308
{
309
   GET_CURRENT_CONTEXT(ctx);
310
   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
311
   _math_matrix_scale( ctx->CurrentStack->Top, x, y, z);
312
   ctx->NewState |= ctx->CurrentStack->DirtyFlag;
313
}
314
 
315
 
316
void
317
_mesa_Scaled( GLdouble x, GLdouble y, GLdouble z )
318
{
319
   _mesa_Scalef((GLfloat) x, (GLfloat) y, (GLfloat) z);
320
}
321
 
322
 
323
/*
324
 * Execute a glTranslate call
325
 */
326
void
327
_mesa_Translatef( GLfloat x, GLfloat y, GLfloat z )
328
{
329
   GET_CURRENT_CONTEXT(ctx);
330
   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
331
   _math_matrix_translate( ctx->CurrentStack->Top, x, y, z);
332
   ctx->NewState |= ctx->CurrentStack->DirtyFlag;
333
}
334
 
335
 
336
void
337
_mesa_Translated( GLdouble x, GLdouble y, GLdouble z )
338
{
339
   _mesa_Translatef((GLfloat) x, (GLfloat) y, (GLfloat) z);
340
}
341
 
342
 
343
void
344
_mesa_LoadTransposeMatrixfARB( const GLfloat *m )
345
{
346
   GLfloat tm[16];
347
   if (!m) return;
348
   _math_transposef(tm, m);
349
   _mesa_LoadMatrixf(tm);
350
}
351
 
352
 
353
void
354
_mesa_LoadTransposeMatrixdARB( const GLdouble *m )
355
{
356
   GLfloat tm[16];
357
   if (!m) return;
358
   _math_transposefd(tm, m);
359
   _mesa_LoadMatrixf(tm);
360
}
361
 
362
 
363
void
364
_mesa_MultTransposeMatrixfARB( const GLfloat *m )
365
{
366
   GLfloat tm[16];
367
   if (!m) return;
368
   _math_transposef(tm, m);
369
   _mesa_MultMatrixf(tm);
370
}
371
 
372
 
373
void
374
_mesa_MultTransposeMatrixdARB( const GLdouble *m )
375
{
376
   GLfloat tm[16];
377
   if (!m) return;
378
   _math_transposefd(tm, m);
379
   _mesa_MultMatrixf(tm);
380
}
381
 
382
 
383
/*
384
 * Called via glViewport or display list execution.
385
 */
386
void
387
_mesa_Viewport( GLint x, GLint y, GLsizei width, GLsizei height )
388
{
389
   GET_CURRENT_CONTEXT(ctx);
390
   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
391
   _mesa_set_viewport(ctx, x, y, width, height);
392
}
393
 
394
 
395
/*
396
 * Define a new viewport and reallocate auxillary buffers if the size of
397
 * the window (color buffer) has changed.
398
 */
399
void
400
_mesa_set_viewport( GLcontext *ctx, GLint x, GLint y,
401
                    GLsizei width, GLsizei height )
402
{
403
   const GLfloat n = ctx->Viewport.Near;
404
   const GLfloat f = ctx->Viewport.Far;
405
 
406
   if (MESA_VERBOSE & VERBOSE_API)
407
      _mesa_debug(ctx, "glViewport %d %d %d %d\n", x, y, width, height);
408
 
409
   if (width < 0 || height < 0) {
410
      _mesa_error( ctx,  GL_INVALID_VALUE,
411
                   "glViewport(%d, %d, %d, %d)", x, y, width, height );
412
      return;
413
   }
414
 
415
   /* clamp width, and height to implementation dependent range */
416
   width  = CLAMP( width,  1, MAX_WIDTH );
417
   height = CLAMP( height, 1, MAX_HEIGHT );
418
 
419
   /* Save viewport */
420
   ctx->Viewport.X = x;
421
   ctx->Viewport.Width = width;
422
   ctx->Viewport.Y = y;
423
   ctx->Viewport.Height = height;
424
 
425
   /* compute scale and bias values :: This is really driver-specific
426
    * and should be maintained elsewhere if at all.
427
    */
428
   ctx->Viewport._WindowMap.m[MAT_SX] = (GLfloat) width / 2.0F;
429
   ctx->Viewport._WindowMap.m[MAT_TX] = ctx->Viewport._WindowMap.m[MAT_SX] + x;
430
   ctx->Viewport._WindowMap.m[MAT_SY] = (GLfloat) height / 2.0F;
431
   ctx->Viewport._WindowMap.m[MAT_TY] = ctx->Viewport._WindowMap.m[MAT_SY] + y;
432
   ctx->Viewport._WindowMap.m[MAT_SZ] = ctx->DepthMaxF * ((f - n) / 2.0F);
433
   ctx->Viewport._WindowMap.m[MAT_TZ] = ctx->DepthMaxF * ((f - n) / 2.0F + n);
434
   ctx->Viewport._WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
435
   ctx->Viewport._WindowMap.type = MATRIX_3D_NO_ROT;
436
   ctx->NewState |= _NEW_VIEWPORT;
437
 
438
   /* Check if window/buffer has been resized and if so, reallocate the
439
    * ancillary buffers.
440
    */
441
   _mesa_ResizeBuffersMESA();
442
 
443
   if (ctx->Driver.Viewport) {
444
      (*ctx->Driver.Viewport)( ctx, x, y, width, height );
445
   }
446
}
447
 
448
 
449
 
450
void
451
_mesa_DepthRange( GLclampd nearval, GLclampd farval )
452
{
453
   /*
454
    * nearval - specifies mapping of the near clipping plane to window
455
    *   coordinates, default is 0
456
    * farval - specifies mapping of the far clipping plane to window
457
    *   coordinates, default is 1
458
    *
459
    * After clipping and div by w, z coords are in -1.0 to 1.0,
460
    * corresponding to near and far clipping planes.  glDepthRange
461
    * specifies a linear mapping of the normalized z coords in
462
    * this range to window z coords.
463
    */
464
   GLfloat n, f;
465
   GET_CURRENT_CONTEXT(ctx);
466
   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
467
 
468
   if (MESA_VERBOSE&VERBOSE_API)
469
      _mesa_debug(ctx, "glDepthRange %f %f\n", nearval, farval);
470
 
471
   n = (GLfloat) CLAMP( nearval, 0.0, 1.0 );
472
   f = (GLfloat) CLAMP( farval, 0.0, 1.0 );
473
 
474
   ctx->Viewport.Near = n;
475
   ctx->Viewport.Far = f;
476
   ctx->Viewport._WindowMap.m[MAT_SZ] = ctx->DepthMaxF * ((f - n) / 2.0F);
477
   ctx->Viewport._WindowMap.m[MAT_TZ] = ctx->DepthMaxF * ((f - n) / 2.0F + n);
478
   ctx->NewState |= _NEW_VIEWPORT;
479
 
480
   if (ctx->Driver.DepthRange) {
481
      (*ctx->Driver.DepthRange)( ctx, nearval, farval );
482
   }
483
}