projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
added memory macros
[mesa.git] / src / mesa / main / context.c
1 /* $Id: context.c,v 1.12 1999/10/10 12:39:16 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 3.1
6 *
7 * Copyright (C) 1999 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 /* $XFree86: xc/lib/GL/mesa/src/context.c,v 1.4 1999/04/04 00:20:21 dawes Exp $ */
29
30 /*
31 * If multi-threading is enabled (-DTHREADS) then each thread has it's
32 * own rendering context. A thread obtains the pointer to its GLcontext
33 * with the gl_get_thread_context() function. Otherwise, the global
34 * pointer, CC, points to the current context used by all threads in
35 * the address space.
36 */
37
38
39
40 #ifdef PC_HEADER
41 #include "all.h"
42 #else
43 #ifndef XFree86Server
44 #include <assert.h>
45 #include <math.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #else
50 #include "GL/xf86glx.h"
51 #endif
52 #include "accum.h"
53 #include "alphabuf.h"
54 #include "api.h"
55 #include "clip.h"
56 #include "context.h"
57 #include "cva.h"
58 #include "depth.h"
59 #include "dlist.h"
60 #include "eval.h"
61 #include "enums.h"
62 #include "extensions.h"
63 #include "fog.h"
64 #include "hash.h"
65 #include "light.h"
66 #include "lines.h"
67 #include "dlist.h"
68 #include "macros.h"
69 #include "matrix.h"
70 #include "mmath.h"
71 #include "pb.h"
72 #include "pipeline.h"
73 #include "points.h"
74 #include "pointers.h"
75 #include "quads.h"
76 #include "shade.h"
77 #include "simple_list.h"
78 #include "stencil.h"
79 #include "stages.h"
80 #include "triangle.h"
81 #include "translate.h"
82 #include "teximage.h"
83 #include "texobj.h"
84 #include "texstate.h"
85 #include "texture.h"
86 #include "types.h"
87 #include "varray.h"
88 #include "vb.h"
89 #include "vbcull.h"
90 #include "vbfill.h"
91 #include "vbrender.h"
92 #include "vbxform.h"
93 #include "vertices.h"
94 #include "xform.h"
95 #ifdef XFree86Server
96 #include "GL/xf86glx.h"
97 #endif
98 #endif
99
100
101 /*
102 * Memory allocation functions. Called via the GL_ALLOC, GL_CALLOC and
103 * GL_FREE macros when DEBUG symbol is defined.
104 * You might want to set breakpoints on these functions or plug in
105 * other memory allocation functions. The Mesa sources should only
106 * use the GL_ALLOC and GL_FREE macros (which could also be overriden).
107 *
108 * XXX these functions should probably go into a new glmemory.c file.
109 */
110
111 /*
112 * Allocate memory (uninitialized)
113 */
114 void *gl_alloc(size_t bytes)
115 {
116 return GL_ALLOC(bytes);
117 }
118
119 /*
120 * Allocate memory and initialize to zero.
121 */
122 void *gl_calloc(size_t bytes)
123 {
124 return calloc(1, bytes);
125 }
126
127 /*
128 * Free memory
129 */
130 void gl_free(void *ptr)
131 {
132 free(ptr);
133 }
134
135
136 /**********************************************************************/
137 /***** Context and Thread management *****/
138 /**********************************************************************/
139
140
141 #ifdef THREADS
142
143 #include "mthreads.h" /* Mesa platform independent threads interface */
144
145 static MesaTSD mesa_ctx_tsd;
146
147 static void mesa_ctx_thread_init() {
148 MesaInitTSD(&mesa_ctx_tsd);
149 }
150
151 GLcontext *gl_get_thread_context( void ) {
152 return (GLcontext *) MesaGetTSD(&mesa_ctx_tsd);
153 }
154
155 static void set_thread_context( GLcontext *ctx ) {
156 MesaSetTSD(&mesa_ctx_tsd, ctx, mesa_ctx_thread_init);
157 }
158
159
160 #else
161
162 /* One Current Context pointer for all threads in the address space */
163 GLcontext *CC = NULL;
164 struct immediate *CURRENT_INPUT = NULL;
165
166 #endif /*THREADS*/
167
168
169
170
171 /**********************************************************************/
172 /***** Profiling functions *****/
173 /**********************************************************************/
174
175 #ifdef PROFILE
176
177 #include <sys/times.h>
178 #include <sys/param.h>
179
180
181 /*
182 * Return system time in seconds.
183 * NOTE: this implementation may not be very portable!
184 */
185 GLdouble gl_time( void )
186 {
187 static GLdouble prev_time = 0.0;
188 static GLdouble time;
189 struct tms tm;
190 clock_t clk;
191
192 clk = times(&tm);
193
194 #ifdef CLK_TCK
195 time = (double)clk / (double)CLK_TCK;
196 #else
197 time = (double)clk / (double)HZ;
198 #endif
199
200 if (time>prev_time) {
201 prev_time = time;
202 return time;
203 }
204 else {
205 return prev_time;
206 }
207 }
208
209 /*
210 * Reset the timing/profiling counters
211 */
212 static void init_timings( GLcontext *ctx )
213 {
214 ctx->BeginEndCount = 0;
215 ctx->BeginEndTime = 0.0;
216 ctx->VertexCount = 0;
217 ctx->VertexTime = 0.0;
218 ctx->PointCount = 0;
219 ctx->PointTime = 0.0;
220 ctx->LineCount = 0;
221 ctx->LineTime = 0.0;
222 ctx->PolygonCount = 0;
223 ctx->PolygonTime = 0.0;
224 ctx->ClearCount = 0;
225 ctx->ClearTime = 0.0;
226 ctx->SwapCount = 0;
227 ctx->SwapTime = 0.0;
228 }
229
230
231 /*
232 * Print the accumulated timing/profiling data.
233 */
234 static void print_timings( GLcontext *ctx )
235 {
236 GLdouble beginendrate;
237 GLdouble vertexrate;
238 GLdouble pointrate;
239 GLdouble linerate;
240 GLdouble polygonrate;
241 GLdouble overhead;
242 GLdouble clearrate;
243 GLdouble swaprate;
244 GLdouble avgvertices;
245
246 if (ctx->BeginEndTime>0.0) {
247 beginendrate = ctx->BeginEndCount / ctx->BeginEndTime;
248 }
249 else {
250 beginendrate = 0.0;
251 }
252 if (ctx->VertexTime>0.0) {
253 vertexrate = ctx->VertexCount / ctx->VertexTime;
254 }
255 else {
256 vertexrate = 0.0;
257 }
258 if (ctx->PointTime>0.0) {
259 pointrate = ctx->PointCount / ctx->PointTime;
260 }
261 else {
262 pointrate = 0.0;
263 }
264 if (ctx->LineTime>0.0) {
265 linerate = ctx->LineCount / ctx->LineTime;
266 }
267 else {
268 linerate = 0.0;
269 }
270 if (ctx->PolygonTime>0.0) {
271 polygonrate = ctx->PolygonCount / ctx->PolygonTime;
272 }
273 else {
274 polygonrate = 0.0;
275 }
276 if (ctx->ClearTime>0.0) {
277 clearrate = ctx->ClearCount / ctx->ClearTime;
278 }
279 else {
280 clearrate = 0.0;
281 }
282 if (ctx->SwapTime>0.0) {
283 swaprate = ctx->SwapCount / ctx->SwapTime;
284 }
285 else {
286 swaprate = 0.0;
287 }
288
289 if (ctx->BeginEndCount>0) {
290 avgvertices = (GLdouble) ctx->VertexCount / (GLdouble) ctx->BeginEndCount;
291 }
292 else {
293 avgvertices = 0.0;
294 }
295
296 overhead = ctx->BeginEndTime - ctx->VertexTime - ctx->PointTime
297 - ctx->LineTime - ctx->PolygonTime;
298
299
300 printf(" Count Time (s) Rate (/s) \n");
301 printf("--------------------------------------------------------\n");
302 printf("glBegin/glEnd %7d %8.3f %10.3f\n",
303 ctx->BeginEndCount, ctx->BeginEndTime, beginendrate);
304 printf(" vertexes transformed %7d %8.3f %10.3f\n",
305 ctx->VertexCount, ctx->VertexTime, vertexrate );
306 printf(" points rasterized %7d %8.3f %10.3f\n",
307 ctx->PointCount, ctx->PointTime, pointrate );
308 printf(" lines rasterized %7d %8.3f %10.3f\n",
309 ctx->LineCount, ctx->LineTime, linerate );
310 printf(" polygons rasterized %7d %8.3f %10.3f\n",
311 ctx->PolygonCount, ctx->PolygonTime, polygonrate );
312 printf(" overhead %8.3f\n", overhead );
313 printf("glClear %7d %8.3f %10.3f\n",
314 ctx->ClearCount, ctx->ClearTime, clearrate );
315 printf("SwapBuffers %7d %8.3f %10.3f\n",
316 ctx->SwapCount, ctx->SwapTime, swaprate );
317 printf("\n");
318
319 printf("Average number of vertices per begin/end: %8.3f\n", avgvertices );
320 }
321 #endif
322
323
324
325
326
327 /**********************************************************************/
328 /***** Context allocation, initialization, destroying *****/
329 /**********************************************************************/
330
331
332 /*
333 * This function just calls all the various one-time-init functions in Mesa.
334 */
335 static void one_time_init( void )
336 {
337 static GLboolean alreadyCalled = GL_FALSE;
338 if (!alreadyCalled) {
339 gl_init_clip();
340 gl_init_eval();
341 gl_init_fog();
342 gl_init_math();
343 gl_init_lists();
344 gl_init_shade();
345 gl_init_texture();
346 gl_init_transformation();
347 gl_init_translate();
348 gl_init_vbrender();
349 gl_init_vbxform();
350 gl_init_vertices();
351 alreadyCalled = GL_TRUE;
352 }
353 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
354 fprintf(stderr, "Mesa DEBUG build %s %s\n", __DATE__, __TIME__);
355 #endif
356 }
357
358
359 /*
360 * Allocate and initialize a shared context state structure.
361 */
362 static struct gl_shared_state *alloc_shared_state( void )
363 {
364 GLuint d;
365 struct gl_shared_state *ss;
366 GLboolean outOfMemory;
367
368 ss = (struct gl_shared_state*) calloc( 1, sizeof(struct gl_shared_state) );
369 if (!ss)
370 return NULL;
371
372 ss->DisplayList = NewHashTable();
373
374 ss->TexObjects = NewHashTable();
375
376 /* Default Texture objects */
377 outOfMemory = GL_FALSE;
378 for (d = 1 ; d <= 3 ; d++) {
379 ss->DefaultD[d] = gl_alloc_texture_object(ss, 0, d);
380 if (!ss->DefaultD[d]) {
381 outOfMemory = GL_TRUE;
382 break;
383 }
384 ss->DefaultD[d]->RefCount++; /* don't free if not in use */
385 }
386
387 if (!ss->DisplayList || !ss->TexObjects || outOfMemory) {
388 /* Ran out of memory at some point. Free everything and return NULL */
389 if (ss->DisplayList)
390 DeleteHashTable(ss->DisplayList);
391 if (ss->TexObjects)
392 DeleteHashTable(ss->TexObjects);
393 if (ss->DefaultD[1])
394 gl_free_texture_object(ss, ss->DefaultD[1]);
395 if (ss->DefaultD[2])
396 gl_free_texture_object(ss, ss->DefaultD[2]);
397 if (ss->DefaultD[3])
398 gl_free_texture_object(ss, ss->DefaultD[3]);
399 GL_FREE(ss);
400 return NULL;
401 }
402 else {
403 return ss;
404 }
405 }
406
407
408 /*
409 * Deallocate a shared state context and all children structures.
410 */
411 static void free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
412 {
413 /* Free display lists */
414 while (1) {
415 GLuint list = HashFirstEntry(ss->DisplayList);
416 if (list) {
417 gl_destroy_list(ctx, list);
418 }
419 else {
420 break;
421 }
422 }
423 DeleteHashTable(ss->DisplayList);
424
425 /* Free texture objects */
426 while (ss->TexObjectList)
427 {
428 if (ctx->Driver.DeleteTexture)
429 (*ctx->Driver.DeleteTexture)( ctx, ss->TexObjectList );
430 /* this function removes from linked list too! */
431 gl_free_texture_object(ss, ss->TexObjectList);
432 }
433 DeleteHashTable(ss->TexObjects);
434
435 GL_FREE(ss);
436 }
437
438
439
440
441
442
443 /*
444 * Initialize the nth light. Note that the defaults for light 0 are
445 * different than the other lights.
446 */
447 static void init_light( struct gl_light *l, GLuint n )
448 {
449 make_empty_list( l );
450
451 ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 );
452 if (n==0) {
453 ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 );
454 ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 );
455 }
456 else {
457 ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 );
458 ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 );
459 }
460 ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 );
461 ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 );
462 l->SpotExponent = 0.0;
463 gl_compute_spot_exp_table( l );
464 l->SpotCutoff = 180.0;
465 l->CosCutoff = 0.0; /* KW: -ve values not admitted */
466 l->ConstantAttenuation = 1.0;
467 l->LinearAttenuation = 0.0;
468 l->QuadraticAttenuation = 0.0;
469 l->Enabled = GL_FALSE;
470 }
471
472
473
474 static void init_lightmodel( struct gl_lightmodel *lm )
475 {
476 ASSIGN_4V( lm->Ambient, 0.2, 0.2, 0.2, 1.0 );
477 lm->LocalViewer = GL_FALSE;
478 lm->TwoSide = GL_FALSE;
479 lm->ColorControl = GL_SINGLE_COLOR;
480 }
481
482
483 static void init_material( struct gl_material *m )
484 {
485 ASSIGN_4V( m->Ambient, 0.2, 0.2, 0.2, 1.0 );
486 ASSIGN_4V( m->Diffuse, 0.8, 0.8, 0.8, 1.0 );
487 ASSIGN_4V( m->Specular, 0.0, 0.0, 0.0, 1.0 );
488 ASSIGN_4V( m->Emission, 0.0, 0.0, 0.0, 1.0 );
489 m->Shininess = 0.0;
490 m->AmbientIndex = 0;
491 m->DiffuseIndex = 1;
492 m->SpecularIndex = 1;
493 }
494
495
496
497 static void init_texture_unit( GLcontext *ctx, GLuint unit )
498 {
499 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
500
501 texUnit->EnvMode = GL_MODULATE;
502 ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
503 texUnit->TexGenEnabled = 0;
504 texUnit->GenModeS = GL_EYE_LINEAR;
505 texUnit->GenModeT = GL_EYE_LINEAR;
506 texUnit->GenModeR = GL_EYE_LINEAR;
507 texUnit->GenModeQ = GL_EYE_LINEAR;
508 /* Yes, these plane coefficients are correct! */
509 ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 );
510 ASSIGN_4V( texUnit->ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 );
511 ASSIGN_4V( texUnit->ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 );
512 ASSIGN_4V( texUnit->ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 );
513 ASSIGN_4V( texUnit->EyePlaneS, 1.0, 0.0, 0.0, 0.0 );
514 ASSIGN_4V( texUnit->EyePlaneT, 0.0, 1.0, 0.0, 0.0 );
515 ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 );
516 ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 );
517
518 texUnit->CurrentD[1] = ctx->Shared->DefaultD[1];
519 texUnit->CurrentD[2] = ctx->Shared->DefaultD[2];
520 texUnit->CurrentD[3] = ctx->Shared->DefaultD[3];
521 }
522
523
524 static void init_fallback_arrays( GLcontext *ctx )
525 {
526 struct gl_client_array *cl;
527 GLuint i;
528
529 cl = &ctx->Fallback.Normal;
530 cl->Size = 3;
531 cl->Type = GL_FLOAT;
532 cl->Stride = 0;
533 cl->StrideB = 0;
534 cl->Ptr = (void *) ctx->Current.Normal;
535 cl->Enabled = 1;
536
537 cl = &ctx->Fallback.Color;
538 cl->Size = 4;
539 cl->Type = GL_UNSIGNED_BYTE;
540 cl->Stride = 0;
541 cl->StrideB = 0;
542 cl->Ptr = (void *) ctx->Current.ByteColor;
543 cl->Enabled = 1;
544
545 cl = &ctx->Fallback.Index;
546 cl->Size = 1;
547 cl->Type = GL_UNSIGNED_INT;
548 cl->Stride = 0;
549 cl->StrideB = 0;
550 cl->Ptr = (void *) &ctx->Current.Index;
551 cl->Enabled = 1;
552
553 for (i = 0 ; i < MAX_TEXTURE_UNITS ; i++) {
554 cl = &ctx->Fallback.TexCoord[i];
555 cl->Size = 4;
556 cl->Type = GL_FLOAT;
557 cl->Stride = 0;
558 cl->StrideB = 0;
559 cl->Ptr = (void *) ctx->Current.Texcoord[i];
560 cl->Enabled = 1;
561 }
562
563 cl = &ctx->Fallback.EdgeFlag;
564 cl->Size = 1;
565 cl->Type = GL_UNSIGNED_BYTE;
566 cl->Stride = 0;
567 cl->StrideB = 0;
568 cl->Ptr = (void *) &ctx->Current.EdgeFlag;
569 cl->Enabled = 1;
570 }
571
572 /* Initialize a 1-D evaluator map */
573 static void init_1d_map( struct gl_1d_map *map, int n, const float *initial )
574 {
575 map->Order = 1;
576 map->u1 = 0.0;
577 map->u2 = 1.0;
578 map->Points = (GLfloat *) GL_ALLOC(n * sizeof(GLfloat));
579 if (map->Points) {
580 GLint i;
581 for (i=0;i<n;i++)
582 map->Points[i] = initial[i];
583 }
584 map->Retain = GL_FALSE;
585 }
586
587
588 /* Initialize a 2-D evaluator map */
589 static void init_2d_map( struct gl_2d_map *map, int n, const float *initial )
590 {
591 map->Uorder = 1;
592 map->Vorder = 1;
593 map->u1 = 0.0;
594 map->u2 = 1.0;
595 map->v1 = 0.0;
596 map->v2 = 1.0;
597 map->Points = (GLfloat *) GL_ALLOC(n * sizeof(GLfloat));
598 if (map->Points) {
599 GLint i;
600 for (i=0;i<n;i++)
601 map->Points[i] = initial[i];
602 }
603 map->Retain = GL_FALSE;
604 }
605
606
607
608 /*
609 * Initialize a gl_context structure to default values.
610 */
611 static void initialize_context( GLcontext *ctx )
612 {
613 GLuint i, j;
614
615 if (ctx) {
616 /* Constants, may be overriden by device driver */
617 ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
618 ctx->Const.MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
619 ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
620 ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
621
622
623 /* Modelview matrix */
624 gl_matrix_ctr( &ctx->ModelView );
625 gl_matrix_alloc_inv( &ctx->ModelView );
626
627 ctx->ModelViewStackDepth = 0;
628 for (i = 0 ; i < MAX_MODELVIEW_STACK_DEPTH ; i++) {
629 gl_matrix_ctr( &ctx->ModelViewStack[i] );
630 gl_matrix_alloc_inv( &ctx->ModelViewStack[i] );
631 }
632
633 /* Projection matrix - need inv for user clipping in clip space*/
634 gl_matrix_ctr( &ctx->ProjectionMatrix );
635 gl_matrix_alloc_inv( &ctx->ProjectionMatrix );
636
637 gl_matrix_ctr( &ctx->ModelProjectMatrix );
638 gl_matrix_ctr( &ctx->ModelProjectWinMatrix );
639 ctx->ModelProjectWinMatrixUptodate = GL_FALSE;
640
641 ctx->ProjectionStackDepth = 0;
642 ctx->NearFarStack[0][0] = 1.0; /* These values seem weird by make */
643 ctx->NearFarStack[0][1] = 0.0; /* sense mathematically. */
644
645 for (i = 0 ; i < MAX_PROJECTION_STACK_DEPTH ; i++) {
646 gl_matrix_ctr( &ctx->ProjectionStack[i] );
647 gl_matrix_alloc_inv( &ctx->ProjectionStack[i] );
648 }
649
650 /* Texture matrix */
651 for (i=0; i<MAX_TEXTURE_UNITS; i++) {
652 gl_matrix_ctr( &ctx->TextureMatrix[i] );
653 ctx->TextureStackDepth[i] = 0;
654 for (j = 0 ; j < MAX_TEXTURE_STACK_DEPTH ; j++) {
655 ctx->TextureStack[i][j].inv = 0;
656 }
657 }
658
659 /* Accumulate buffer group */
660 ASSIGN_4V( ctx->Accum.ClearColor, 0.0, 0.0, 0.0, 0.0 );
661
662 /* Color buffer group */
663 ctx->Color.IndexMask = 0xffffffff;
664 ctx->Color.ColorMask[0] = 0xff;
665 ctx->Color.ColorMask[1] = 0xff;
666 ctx->Color.ColorMask[2] = 0xff;
667 ctx->Color.ColorMask[3] = 0xff;
668 ctx->Color.SWmasking = GL_FALSE;
669 ctx->Color.ClearIndex = 0;
670 ASSIGN_4V( ctx->Color.ClearColor, 0.0, 0.0, 0.0, 0.0 );
671 ctx->Color.DrawBuffer = GL_FRONT;
672 ctx->Color.AlphaEnabled = GL_FALSE;
673 ctx->Color.AlphaFunc = GL_ALWAYS;
674 ctx->Color.AlphaRef = 0;
675 ctx->Color.BlendEnabled = GL_FALSE;
676 ctx->Color.BlendSrcRGB = GL_ONE;
677 ctx->Color.BlendDstRGB = GL_ZERO;
678 ctx->Color.BlendSrcA = GL_ONE;
679 ctx->Color.BlendDstA = GL_ZERO;
680 ctx->Color.BlendEquation = GL_FUNC_ADD_EXT;
681 ctx->Color.BlendFunc = NULL; /* this pointer set only when needed */
682 ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );
683 ctx->Color.IndexLogicOpEnabled = GL_FALSE;
684 ctx->Color.ColorLogicOpEnabled = GL_FALSE;
685 ctx->Color.SWLogicOpEnabled = GL_FALSE;
686 ctx->Color.LogicOp = GL_COPY;
687 ctx->Color.DitherFlag = GL_TRUE;
688 ctx->Color.MultiDrawBuffer = GL_FALSE;
689
690 /* Current group */
691 ASSIGN_4V( ctx->Current.ByteColor, 255, 255, 255, 255);
692 ctx->Current.Index = 1;
693 for (i=0; i<MAX_TEXTURE_UNITS; i++)
694 ASSIGN_4V( ctx->Current.Texcoord[i], 0.0, 0.0, 0.0, 1.0 );
695 ASSIGN_4V( ctx->Current.RasterPos, 0.0, 0.0, 0.0, 1.0 );
696 ctx->Current.RasterDistance = 0.0;
697 ASSIGN_4V( ctx->Current.RasterColor, 1.0, 1.0, 1.0, 1.0 );
698 ctx->Current.RasterIndex = 1;
699 for (i=0; i<MAX_TEXTURE_UNITS; i++)
700 ASSIGN_4V( ctx->Current.RasterMultiTexCoord[i], 0.0, 0.0, 0.0, 1.0 );
701 ctx->Current.RasterTexCoord = ctx->Current.RasterMultiTexCoord[0];
702 ctx->Current.RasterPosValid = GL_TRUE;
703 ctx->Current.EdgeFlag = GL_TRUE;
704 ASSIGN_3V( ctx->Current.Normal, 0.0, 0.0, 1.0 );
705 ctx->Current.Primitive = (GLenum) (GL_POLYGON + 1);
706
707 ctx->Current.Flag = (VERT_NORM|VERT_INDEX|VERT_RGBA|VERT_EDGE|
708 VERT_TEX0_1|VERT_TEX1_1|VERT_MATERIAL);
709
710 init_fallback_arrays( ctx );
711
712 /* Depth buffer group */
713 ctx->Depth.Test = GL_FALSE;
714 ctx->Depth.Clear = 1.0;
715 ctx->Depth.Func = GL_LESS;
716 ctx->Depth.Mask = GL_TRUE;
717
718 /* Evaluators group */
719 ctx->Eval.Map1Color4 = GL_FALSE;
720 ctx->Eval.Map1Index = GL_FALSE;
721 ctx->Eval.Map1Normal = GL_FALSE;
722 ctx->Eval.Map1TextureCoord1 = GL_FALSE;
723 ctx->Eval.Map1TextureCoord2 = GL_FALSE;
724 ctx->Eval.Map1TextureCoord3 = GL_FALSE;
725 ctx->Eval.Map1TextureCoord4 = GL_FALSE;
726 ctx->Eval.Map1Vertex3 = GL_FALSE;
727 ctx->Eval.Map1Vertex4 = GL_FALSE;
728 ctx->Eval.Map2Color4 = GL_FALSE;
729 ctx->Eval.Map2Index = GL_FALSE;
730 ctx->Eval.Map2Normal = GL_FALSE;
731 ctx->Eval.Map2TextureCoord1 = GL_FALSE;
732 ctx->Eval.Map2TextureCoord2 = GL_FALSE;
733 ctx->Eval.Map2TextureCoord3 = GL_FALSE;
734 ctx->Eval.Map2TextureCoord4 = GL_FALSE;
735 ctx->Eval.Map2Vertex3 = GL_FALSE;
736 ctx->Eval.Map2Vertex4 = GL_FALSE;
737 ctx->Eval.AutoNormal = GL_FALSE;
738 ctx->Eval.MapGrid1un = 1;
739 ctx->Eval.MapGrid1u1 = 0.0;
740 ctx->Eval.MapGrid1u2 = 1.0;
741 ctx->Eval.MapGrid2un = 1;
742 ctx->Eval.MapGrid2vn = 1;
743 ctx->Eval.MapGrid2u1 = 0.0;
744 ctx->Eval.MapGrid2u2 = 1.0;
745 ctx->Eval.MapGrid2v1 = 0.0;
746 ctx->Eval.MapGrid2v2 = 1.0;
747
748 /* Evaluator data */
749 {
750 static GLfloat vertex[4] = { 0.0, 0.0, 0.0, 1.0 };
751 static GLfloat normal[3] = { 0.0, 0.0, 1.0 };
752 static GLfloat index[1] = { 1.0 };
753 static GLfloat color[4] = { 1.0, 1.0, 1.0, 1.0 };
754 static GLfloat texcoord[4] = { 0.0, 0.0, 0.0, 1.0 };
755
756 init_1d_map( &ctx->EvalMap.Map1Vertex3, 3, vertex );
757 init_1d_map( &ctx->EvalMap.Map1Vertex4, 4, vertex );
758 init_1d_map( &ctx->EvalMap.Map1Index, 1, index );
759 init_1d_map( &ctx->EvalMap.Map1Color4, 4, color );
760 init_1d_map( &ctx->EvalMap.Map1Normal, 3, normal );
761 init_1d_map( &ctx->EvalMap.Map1Texture1, 1, texcoord );
762 init_1d_map( &ctx->EvalMap.Map1Texture2, 2, texcoord );
763 init_1d_map( &ctx->EvalMap.Map1Texture3, 3, texcoord );
764 init_1d_map( &ctx->EvalMap.Map1Texture4, 4, texcoord );
765
766 init_2d_map( &ctx->EvalMap.Map2Vertex3, 3, vertex );
767 init_2d_map( &ctx->EvalMap.Map2Vertex4, 4, vertex );
768 init_2d_map( &ctx->EvalMap.Map2Index, 1, index );
769 init_2d_map( &ctx->EvalMap.Map2Color4, 4, color );
770 init_2d_map( &ctx->EvalMap.Map2Normal, 3, normal );
771 init_2d_map( &ctx->EvalMap.Map2Texture1, 1, texcoord );
772 init_2d_map( &ctx->EvalMap.Map2Texture2, 2, texcoord );
773 init_2d_map( &ctx->EvalMap.Map2Texture3, 3, texcoord );
774 init_2d_map( &ctx->EvalMap.Map2Texture4, 4, texcoord );
775 }
776
777 /* Fog group */
778 ctx->Fog.Enabled = GL_FALSE;
779 ctx->Fog.Mode = GL_EXP;
780 ASSIGN_4V( ctx->Fog.Color, 0.0, 0.0, 0.0, 0.0 );
781 ctx->Fog.Index = 0.0;
782 ctx->Fog.Density = 1.0;
783 ctx->Fog.Start = 0.0;
784 ctx->Fog.End = 1.0;
785
786 /* Hint group */
787 ctx->Hint.PerspectiveCorrection = GL_DONT_CARE;
788 ctx->Hint.PointSmooth = GL_DONT_CARE;
789 ctx->Hint.LineSmooth = GL_DONT_CARE;
790 ctx->Hint.PolygonSmooth = GL_DONT_CARE;
791 ctx->Hint.Fog = GL_DONT_CARE;
792
793 ctx->Hint.AllowDrawWin = GL_TRUE;
794 ctx->Hint.AllowDrawSpn = GL_TRUE;
795 ctx->Hint.AllowDrawMem = GL_TRUE;
796 ctx->Hint.StrictLighting = GL_TRUE;
797
798 /* Pipeline */
799 gl_pipeline_init( ctx );
800 gl_cva_init( ctx );
801
802 /* Extensions */
803 gl_extensions_ctr( ctx );
804
805 ctx->AllowVertexCull = CLIP_CULLED_BIT;
806
807 /* Lighting group */
808 for (i=0;i<MAX_LIGHTS;i++) {
809 init_light( &ctx->Light.Light[i], i );
810 }
811 make_empty_list( &ctx->Light.EnabledList );
812
813 init_lightmodel( &ctx->Light.Model );
814 init_material( &ctx->Light.Material[0] );
815 init_material( &ctx->Light.Material[1] );
816 ctx->Light.ShadeModel = GL_SMOOTH;
817 ctx->Light.Enabled = GL_FALSE;
818 ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK;
819 ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE;
820 ctx->Light.ColorMaterialBitmask
821 = gl_material_bitmask( ctx,
822 GL_FRONT_AND_BACK,
823 GL_AMBIENT_AND_DIFFUSE, ~0, 0 );
824
825 ctx->Light.ColorMaterialEnabled = GL_FALSE;
826
827 /* Line group */
828 ctx->Line.SmoothFlag = GL_FALSE;
829 ctx->Line.StippleFlag = GL_FALSE;
830 ctx->Line.Width = 1.0;
831 ctx->Line.StipplePattern = 0xffff;
832 ctx->Line.StippleFactor = 1;
833
834 /* Display List group */
835 ctx->List.ListBase = 0;
836
837 /* Pixel group */
838 ctx->Pixel.RedBias = 0.0;
839 ctx->Pixel.RedScale = 1.0;
840 ctx->Pixel.GreenBias = 0.0;
841 ctx->Pixel.GreenScale = 1.0;
842 ctx->Pixel.BlueBias = 0.0;
843 ctx->Pixel.BlueScale = 1.0;
844 ctx->Pixel.AlphaBias = 0.0;
845 ctx->Pixel.AlphaScale = 1.0;
846 ctx->Pixel.ScaleOrBiasRGBA = GL_FALSE;
847 ctx->Pixel.DepthBias = 0.0;
848 ctx->Pixel.DepthScale = 1.0;
849 ctx->Pixel.IndexOffset = 0;
850 ctx->Pixel.IndexShift = 0;
851 ctx->Pixel.ZoomX = 1.0;
852 ctx->Pixel.ZoomY = 1.0;
853 ctx->Pixel.MapColorFlag = GL_FALSE;
854 ctx->Pixel.MapStencilFlag = GL_FALSE;
855 ctx->Pixel.MapStoSsize = 1;
856 ctx->Pixel.MapItoIsize = 1;
857 ctx->Pixel.MapItoRsize = 1;
858 ctx->Pixel.MapItoGsize = 1;
859 ctx->Pixel.MapItoBsize = 1;
860 ctx->Pixel.MapItoAsize = 1;
861 ctx->Pixel.MapRtoRsize = 1;
862 ctx->Pixel.MapGtoGsize = 1;
863 ctx->Pixel.MapBtoBsize = 1;
864 ctx->Pixel.MapAtoAsize = 1;
865 ctx->Pixel.MapStoS[0] = 0;
866 ctx->Pixel.MapItoI[0] = 0;
867 ctx->Pixel.MapItoR[0] = 0.0;
868 ctx->Pixel.MapItoG[0] = 0.0;
869 ctx->Pixel.MapItoB[0] = 0.0;
870 ctx->Pixel.MapItoA[0] = 0.0;
871 ctx->Pixel.MapItoR8[0] = 0;
872 ctx->Pixel.MapItoG8[0] = 0;
873 ctx->Pixel.MapItoB8[0] = 0;
874 ctx->Pixel.MapItoA8[0] = 0;
875 ctx->Pixel.MapRtoR[0] = 0.0;
876 ctx->Pixel.MapGtoG[0] = 0.0;
877 ctx->Pixel.MapBtoB[0] = 0.0;
878 ctx->Pixel.MapAtoA[0] = 0.0;
879
880 /* Point group */
881 ctx->Point.SmoothFlag = GL_FALSE;
882 ctx->Point.Size = 1.0;
883 ctx->Point.Params[0] = 1.0;
884 ctx->Point.Params[1] = 0.0;
885 ctx->Point.Params[2] = 0.0;
886 ctx->Point.Attenuated = GL_FALSE;
887 ctx->Point.MinSize = 0.0;
888 ctx->Point.MaxSize = (GLfloat) MAX_POINT_SIZE;
889 ctx->Point.Threshold = 1.0;
890
891 /* Polygon group */
892 ctx->Polygon.CullFlag = GL_FALSE;
893 ctx->Polygon.CullFaceMode = GL_BACK;
894 ctx->Polygon.FrontFace = GL_CCW;
895 ctx->Polygon.FrontBit = 0;
896 ctx->Polygon.FrontMode = GL_FILL;
897 ctx->Polygon.BackMode = GL_FILL;
898 ctx->Polygon.Unfilled = GL_FALSE;
899 ctx->Polygon.SmoothFlag = GL_FALSE;
900 ctx->Polygon.StippleFlag = GL_FALSE;
901 ctx->Polygon.OffsetFactor = 0.0F;
902 ctx->Polygon.OffsetUnits = 0.0F;
903 ctx->Polygon.OffsetPoint = GL_FALSE;
904 ctx->Polygon.OffsetLine = GL_FALSE;
905 ctx->Polygon.OffsetFill = GL_FALSE;
906
907 /* Polygon Stipple group */
908 MEMSET( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) );
909
910 /* Scissor group */
911 ctx->Scissor.Enabled = GL_FALSE;
912 ctx->Scissor.X = 0;
913 ctx->Scissor.Y = 0;
914 ctx->Scissor.Width = 0;
915 ctx->Scissor.Height = 0;
916
917 /* Stencil group */
918 ctx->Stencil.Enabled = GL_FALSE;
919 ctx->Stencil.Function = GL_ALWAYS;
920 ctx->Stencil.FailFunc = GL_KEEP;
921 ctx->Stencil.ZPassFunc = GL_KEEP;
922 ctx->Stencil.ZFailFunc = GL_KEEP;
923 ctx->Stencil.Ref = 0;
924 ctx->Stencil.ValueMask = 0xff;
925 ctx->Stencil.Clear = 0;
926 ctx->Stencil.WriteMask = 0xff;
927
928 /* Texture group */
929 ctx->Texture.CurrentUnit = 0; /* multitexture */
930 ctx->Texture.CurrentTransformUnit = 0; /* multitexture */
931 ctx->Texture.Enabled = 0;
932
933 for (i=0; i<MAX_TEXTURE_UNITS; i++)
934 init_texture_unit( ctx, i );
935
936 ctx->Texture.SharedPalette = GL_FALSE;
937 ctx->Texture.Palette[0] = 255;
938 ctx->Texture.Palette[1] = 255;
939 ctx->Texture.Palette[2] = 255;
940 ctx->Texture.Palette[3] = 255;
941 ctx->Texture.PaletteSize = 1;
942 ctx->Texture.PaletteIntFormat = GL_RGBA;
943 ctx->Texture.PaletteFormat = GL_RGBA;
944
945 /* Transformation group */
946 ctx->Transform.MatrixMode = GL_MODELVIEW;
947 ctx->Transform.Normalize = GL_FALSE;
948 ctx->Transform.RescaleNormals = GL_FALSE;
949 for (i=0;i<MAX_CLIP_PLANES;i++) {
950 ctx->Transform.ClipEnabled[i] = GL_FALSE;
951 ASSIGN_4V( ctx->Transform.EyeUserPlane[i], 0.0, 0.0, 0.0, 0.0 );
952 }
953 ctx->Transform.AnyClip = GL_FALSE;
954
955 /* Viewport group */
956 ctx->Viewport.X = 0;
957 ctx->Viewport.Y = 0;
958 ctx->Viewport.Width = 0;
959 ctx->Viewport.Height = 0;
960 ctx->Viewport.Near = 0.0;
961 ctx->Viewport.Far = 1.0;
962 gl_matrix_ctr(&ctx->Viewport.WindowMap);
963
964 #define Sz 10
965 #define Tz 14
966 ctx->Viewport.WindowMap.m[Sz] = 0.5 * DEPTH_SCALE;
967 ctx->Viewport.WindowMap.m[Tz] = 0.5 * DEPTH_SCALE;
968 #undef Sz
969 #undef Tz
970
971 ctx->Viewport.WindowMap.flags = MAT_FLAG_GENERAL_SCALE|MAT_FLAG_TRANSLATION;
972 ctx->Viewport.WindowMap.type = MATRIX_3D_NO_ROT;
973
974 /* Vertex arrays */
975 ctx->Array.Vertex.Size = 4;
976 ctx->Array.Vertex.Type = GL_FLOAT;
977 ctx->Array.Vertex.Stride = 0;
978 ctx->Array.Vertex.StrideB = 0;
979 ctx->Array.Vertex.Ptr = NULL;
980 ctx->Array.Vertex.Enabled = GL_FALSE;
981 ctx->Array.Normal.Type = GL_FLOAT;
982 ctx->Array.Normal.Stride = 0;
983 ctx->Array.Normal.StrideB = 0;
984 ctx->Array.Normal.Ptr = NULL;
985 ctx->Array.Normal.Enabled = GL_FALSE;
986 ctx->Array.Color.Size = 4;
987 ctx->Array.Color.Type = GL_FLOAT;
988 ctx->Array.Color.Stride = 0;
989 ctx->Array.Color.StrideB = 0;
990 ctx->Array.Color.Ptr = NULL;
991 ctx->Array.Color.Enabled = GL_FALSE;
992 ctx->Array.Index.Type = GL_FLOAT;
993 ctx->Array.Index.Stride = 0;
994 ctx->Array.Index.StrideB = 0;
995 ctx->Array.Index.Ptr = NULL;
996 ctx->Array.Index.Enabled = GL_FALSE;
997 for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
998 ctx->Array.TexCoord[i].Size = 4;
999 ctx->Array.TexCoord[i].Type = GL_FLOAT;
1000 ctx->Array.TexCoord[i].Stride = 0;
1001 ctx->Array.TexCoord[i].StrideB = 0;
1002 ctx->Array.TexCoord[i].Ptr = NULL;
1003 ctx->Array.TexCoord[i].Enabled = GL_FALSE;
1004 }
1005 ctx->Array.TexCoordInterleaveFactor = 1;
1006 ctx->Array.EdgeFlag.Stride = 0;
1007 ctx->Array.EdgeFlag.StrideB = 0;
1008 ctx->Array.EdgeFlag.Ptr = NULL;
1009 ctx->Array.EdgeFlag.Enabled = GL_FALSE;
1010 ctx->Array.ActiveTexture = 0; /* GL_ARB_multitexture */
1011
1012 /* Pixel transfer */
1013 ctx->Pack.Alignment = 4;
1014 ctx->Pack.RowLength = 0;
1015 ctx->Pack.SkipPixels = 0;
1016 ctx->Pack.SkipRows = 0;
1017 ctx->Pack.SwapBytes = GL_FALSE;
1018 ctx->Pack.LsbFirst = GL_FALSE;
1019 ctx->Unpack.Alignment = 4;
1020 ctx->Unpack.RowLength = 0;
1021 ctx->Unpack.SkipPixels = 0;
1022 ctx->Unpack.SkipRows = 0;
1023 ctx->Unpack.SwapBytes = GL_FALSE;
1024 ctx->Unpack.LsbFirst = GL_FALSE;
1025
1026 /* Feedback */
1027 ctx->Feedback.Type = GL_2D; /* TODO: verify */
1028 ctx->Feedback.Buffer = NULL;
1029 ctx->Feedback.BufferSize = 0;
1030 ctx->Feedback.Count = 0;
1031
1032 /* Selection/picking */
1033 ctx->Select.Buffer = NULL;
1034 ctx->Select.BufferSize = 0;
1035 ctx->Select.BufferCount = 0;
1036 ctx->Select.Hits = 0;
1037 ctx->Select.NameStackDepth = 0;
1038
1039 /* Optimized Accum buffer */
1040 ctx->IntegerAccumMode = GL_TRUE;
1041 ctx->IntegerAccumScaler = 0.0;
1042
1043 /* Renderer and client attribute stacks */
1044 ctx->AttribStackDepth = 0;
1045 ctx->ClientAttribStackDepth = 0;
1046
1047 /*** Miscellaneous ***/
1048 ctx->NewState = NEW_ALL;
1049 ctx->RenderMode = GL_RENDER;
1050 ctx->StippleCounter = 0;
1051 ctx->NeedNormals = GL_FALSE;
1052 ctx->DoViewportMapping = GL_TRUE;
1053
1054 ctx->NeedEyeCoords = GL_FALSE;
1055 ctx->NeedEyeNormals = GL_FALSE;
1056 ctx->vb_proj_matrix = &ctx->ModelProjectMatrix;
1057
1058 /* Display list */
1059 ctx->CallDepth = 0;
1060 ctx->ExecuteFlag = GL_TRUE;
1061 ctx->CompileFlag = GL_FALSE;
1062 ctx->CurrentListPtr = NULL;
1063 ctx->CurrentBlock = NULL;
1064 ctx->CurrentListNum = 0;
1065 ctx->CurrentPos = 0;
1066
1067 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1068
1069 ctx->CatchSignals = GL_TRUE;
1070
1071 /* For debug/development only */
1072 ctx->NoRaster = getenv("MESA_NO_RASTER") ? GL_TRUE : GL_FALSE;
1073
1074 /* Dither disable */
1075 ctx->NoDither = getenv("MESA_NO_DITHER") ? GL_TRUE : GL_FALSE;
1076 if (ctx->NoDither) {
1077 if (getenv("MESA_DEBUG")) {
1078 fprintf(stderr, "MESA_NO_DITHER set - dithering disabled\n");
1079 }
1080 ctx->Color.DitherFlag = GL_FALSE;
1081 }
1082 }
1083 }
1084
1085
1086
1087 /*
1088 * Allocate a new GLvisual object.
1089 * Input: rgbFlag - GL_TRUE=RGB(A) mode, GL_FALSE=Color Index mode
1090 * alphaFlag - alloc software alpha buffers?
1091 * dbFlag - double buffering?
1092 * stereoFlag - stereo buffer?
1093 * depthFits - requested minimum bits per depth buffer value
1094 * stencilFits - requested minimum bits per stencil buffer value
1095 * accumFits - requested minimum bits per accum buffer component
1096 * indexFits - number of bits per pixel if rgbFlag==GL_FALSE
1097 * red/green/blue/alphaFits - number of bits per color component
1098 * in frame buffer for RGB(A) mode.
1099 * Return: pointer to new GLvisual or NULL if requested parameters can't
1100 * be met.
1101 */
1102 GLvisual *gl_create_visual( GLboolean rgbFlag,
1103 GLboolean alphaFlag,
1104 GLboolean dbFlag,
1105 GLboolean stereoFlag,
1106 GLint depthBits,
1107 GLint stencilBits,
1108 GLint accumBits,
1109 GLint indexBits,
1110 GLint redBits,
1111 GLint greenBits,
1112 GLint blueBits,
1113 GLint alphaBits )
1114 {
1115 GLvisual *vis;
1116
1117 if (depthBits > (GLint) (8*sizeof(GLdepth))) {
1118 /* can't meet depth buffer requirements */
1119 return NULL;
1120 }
1121 if (stencilBits > (GLint) (8*sizeof(GLstencil))) {
1122 /* can't meet stencil buffer requirements */
1123 return NULL;
1124 }
1125 if (accumBits > (GLint) (8*sizeof(GLaccum))) {
1126 /* can't meet accum buffer requirements */
1127 return NULL;
1128 }
1129
1130 vis = (GLvisual *) calloc( 1, sizeof(GLvisual) );
1131 if (!vis) {
1132 return NULL;
1133 }
1134
1135 vis->RGBAflag = rgbFlag;
1136 vis->DBflag = dbFlag;
1137 vis->StereoFlag = stereoFlag;
1138 vis->RedBits = redBits;
1139 vis->GreenBits = greenBits;
1140 vis->BlueBits = blueBits;
1141 vis->AlphaBits = alphaFlag ? 8*sizeof(GLubyte) : alphaBits;
1142
1143 vis->IndexBits = indexBits;
1144 vis->DepthBits = (depthBits>0) ? 8*sizeof(GLdepth) : 0;
1145 vis->AccumBits = (accumBits>0) ? 8*sizeof(GLaccum) : 0;
1146 vis->StencilBits = (stencilBits>0) ? 8*sizeof(GLstencil) : 0;
1147
1148 vis->SoftwareAlpha = alphaFlag;
1149
1150 return vis;
1151 }
1152
1153
1154
1155 void gl_destroy_visual( GLvisual *vis )
1156 {
1157 GL_FREE( vis );
1158 }
1159
1160
1161
1162 /*
1163 * Allocate the proxy textures. If we run out of memory part way through
1164 * the allocations clean up and return GL_FALSE.
1165 * Return: GL_TRUE=success, GL_FALSE=failure
1166 */
1167 static GLboolean alloc_proxy_textures( GLcontext *ctx )
1168 {
1169 GLboolean out_of_memory;
1170 GLint i;
1171
1172 ctx->Texture.Proxy1D = gl_alloc_texture_object(NULL, 0, 1);
1173 if (!ctx->Texture.Proxy1D) {
1174 return GL_FALSE;
1175 }
1176
1177 ctx->Texture.Proxy2D = gl_alloc_texture_object(NULL, 0, 2);
1178 if (!ctx->Texture.Proxy2D) {
1179 gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
1180 return GL_FALSE;
1181 }
1182
1183 ctx->Texture.Proxy3D = gl_alloc_texture_object(NULL, 0, 3);
1184 if (!ctx->Texture.Proxy3D) {
1185 gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
1186 gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
1187 return GL_FALSE;
1188 }
1189
1190 out_of_memory = GL_FALSE;
1191 for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1192 ctx->Texture.Proxy1D->Image[i] = gl_alloc_texture_image();
1193 ctx->Texture.Proxy2D->Image[i] = gl_alloc_texture_image();
1194 ctx->Texture.Proxy3D->Image[i] = gl_alloc_texture_image();
1195 if (!ctx->Texture.Proxy1D->Image[i]
1196 || !ctx->Texture.Proxy2D->Image[i]
1197 || !ctx->Texture.Proxy3D->Image[i]) {
1198 out_of_memory = GL_TRUE;
1199 }
1200 }
1201 if (out_of_memory) {
1202 for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
1203 if (ctx->Texture.Proxy1D->Image[i]) {
1204 gl_free_texture_image(ctx->Texture.Proxy1D->Image[i]);
1205 }
1206 if (ctx->Texture.Proxy2D->Image[i]) {
1207 gl_free_texture_image(ctx->Texture.Proxy2D->Image[i]);
1208 }
1209 if (ctx->Texture.Proxy3D->Image[i]) {
1210 gl_free_texture_image(ctx->Texture.Proxy3D->Image[i]);
1211 }
1212 }
1213 gl_free_texture_object(NULL, ctx->Texture.Proxy1D);
1214 gl_free_texture_object(NULL, ctx->Texture.Proxy2D);
1215 gl_free_texture_object(NULL, ctx->Texture.Proxy3D);
1216 return GL_FALSE;
1217 }
1218 else {
1219 return GL_TRUE;
1220 }
1221 }
1222
1223
1224
1225 /*
1226 * Allocate and initialize a GLcontext structure.
1227 * Input: visual - a GLvisual pointer
1228 * sharelist - another context to share display lists with or NULL
1229 * driver_ctx - pointer to device driver's context state struct
1230 * Return: pointer to a new gl_context struct or NULL if error.
1231 */
1232 GLcontext *gl_create_context( GLvisual *visual,
1233 GLcontext *share_list,
1234 void *driver_ctx,
1235 GLboolean direct )
1236 {
1237 GLcontext *ctx;
1238 GLuint i;
1239
1240 (void) direct; /* not used */
1241
1242 /* do some implementation tests */
1243 assert( sizeof(GLbyte) == 1 );
1244 assert( sizeof(GLshort) >= 2 );
1245 assert( sizeof(GLint) >= 4 );
1246 assert( sizeof(GLubyte) == 1 );
1247 assert( sizeof(GLushort) >= 2 );
1248 assert( sizeof(GLuint) >= 4 );
1249
1250 /* misc one-time initializations */
1251 one_time_init();
1252
1253 ctx = (GLcontext *) calloc( 1, sizeof(GLcontext) );
1254 if (!ctx) {
1255 return NULL;
1256 }
1257
1258 ctx->DriverCtx = driver_ctx;
1259 ctx->Visual = visual;
1260 ctx->Buffer = NULL;
1261
1262 ctx->VB = gl_vb_create_for_immediate( ctx );
1263 if (!ctx->VB) {
1264 GL_FREE( ctx );
1265 return NULL;
1266 }
1267 ctx->input = ctx->VB->IM;
1268
1269 ctx->PB = gl_alloc_pb();
1270 if (!ctx->PB) {
1271 GL_FREE( ctx->VB );
1272 GL_FREE( ctx );
1273 return NULL;
1274 }
1275
1276 if (share_list) {
1277 /* share the group of display lists of another context */
1278 ctx->Shared = share_list->Shared;
1279 }
1280 else {
1281 /* allocate new group of display lists */
1282 ctx->Shared = alloc_shared_state();
1283 if (!ctx->Shared) {
1284 GL_FREE(ctx->VB);
1285 GL_FREE(ctx->PB);
1286 GL_FREE(ctx);
1287 return NULL;
1288 }
1289 }
1290 ctx->Shared->RefCount++;
1291
1292 initialize_context( ctx );
1293 gl_reset_vb( ctx->VB );
1294 gl_reset_input( ctx );
1295
1296
1297 ctx->ShineTabList = GL_ALLOC_STRUCT( gl_shine_tab );
1298 make_empty_list( ctx->ShineTabList );
1299
1300 for (i = 0 ; i < 10 ; i++) {
1301 struct gl_shine_tab *s = GL_ALLOC_STRUCT( gl_shine_tab );
1302 s->shininess = -1;
1303 s->refcount = 0;
1304 insert_at_tail( ctx->ShineTabList, s );
1305 }
1306
1307 for (i = 0 ; i < 4 ; i++) {
1308 ctx->ShineTable[i] = ctx->ShineTabList->prev;
1309 ctx->ShineTable[i]->refcount++;
1310 }
1311
1312 if (visual->DBflag) {
1313 ctx->Color.DrawBuffer = GL_BACK;
1314 ctx->Color.DriverDrawBuffer = GL_BACK_LEFT;
1315 ctx->Color.DrawDestMask = BACK_LEFT_BIT;
1316 ctx->Pixel.ReadBuffer = GL_BACK;
1317 ctx->Pixel.DriverReadBuffer = GL_BACK_LEFT;
1318 }
1319 else {
1320 ctx->Color.DrawBuffer = GL_FRONT;
1321 ctx->Color.DriverDrawBuffer = GL_FRONT_LEFT;
1322 ctx->Color.DrawDestMask = FRONT_LEFT_BIT;
1323 ctx->Pixel.ReadBuffer = GL_FRONT;
1324 ctx->Pixel.DriverReadBuffer = GL_FRONT_LEFT;
1325 }
1326
1327
1328 /* Fill in some driver defaults now.
1329 */
1330 ctx->Driver.AllocDepthBuffer = gl_alloc_depth_buffer;
1331 ctx->Driver.ReadDepthSpanFloat = gl_read_depth_span_float;
1332 ctx->Driver.ReadDepthSpanInt = gl_read_depth_span_int;
1333
1334
1335
1336 #ifdef PROFILE
1337 init_timings( ctx );
1338 #endif
1339
1340 #ifdef GL_VERSION_1_1
1341 if (!alloc_proxy_textures(ctx)) {
1342 free_shared_state(ctx, ctx->Shared);
1343 GL_FREE(ctx->VB);
1344 GL_FREE(ctx->PB);
1345 GL_FREE(ctx);
1346 return NULL;
1347 }
1348 #endif
1349
1350 gl_init_api_function_pointers( ctx );
1351 ctx->API = ctx->Exec; /* GL_EXECUTE is default */
1352
1353 return ctx;
1354 }
1355
1356 /* Just reads the config files...
1357 */
1358 void gl_context_initialize( GLcontext *ctx )
1359 {
1360 gl_read_config_file( ctx );
1361 }
1362
1363
1364
1365
1366 /*
1367 * Destroy a gl_context structure.
1368 */
1369 void gl_destroy_context( GLcontext *ctx )
1370 {
1371 if (ctx) {
1372
1373 GLuint i;
1374 struct gl_shine_tab *s, *tmps;
1375
1376 #ifdef PROFILE
1377 if (getenv("MESA_PROFILE")) {
1378 print_timings( ctx );
1379 }
1380 #endif
1381
1382 gl_matrix_dtr( &ctx->ModelView );
1383 for (i = 0 ; i < MAX_MODELVIEW_STACK_DEPTH ; i++) {
1384 gl_matrix_dtr( &ctx->ModelViewStack[i] );
1385 }
1386 gl_matrix_dtr( &ctx->ProjectionMatrix );
1387 for (i = 0 ; i < MAX_PROJECTION_STACK_DEPTH ; i++) {
1388 gl_matrix_dtr( &ctx->ProjectionStack[i] );
1389 }
1390
1391 GL_FREE( ctx->PB );
1392
1393 if(ctx->input != ctx->VB->IM)
1394 gl_immediate_free( ctx->input );
1395
1396 gl_vb_free( ctx->VB );
1397
1398 ctx->Shared->RefCount--;
1399 assert(ctx->Shared->RefCount>=0);
1400 if (ctx->Shared->RefCount==0) {
1401 /* free shared state */
1402 free_shared_state( ctx, ctx->Shared );
1403 }
1404
1405 foreach_s( s, tmps, ctx->ShineTabList ) {
1406 GL_FREE( s );
1407 }
1408 GL_FREE( ctx->ShineTabList );
1409
1410 /* Free proxy texture objects */
1411 gl_free_texture_object( NULL, ctx->Texture.Proxy1D );
1412 gl_free_texture_object( NULL, ctx->Texture.Proxy2D );
1413 gl_free_texture_object( NULL, ctx->Texture.Proxy3D );
1414
1415 /* Free evaluator data */
1416 if (ctx->EvalMap.Map1Vertex3.Points)
1417 GL_FREE( ctx->EvalMap.Map1Vertex3.Points );
1418 if (ctx->EvalMap.Map1Vertex4.Points)
1419 GL_FREE( ctx->EvalMap.Map1Vertex4.Points );
1420 if (ctx->EvalMap.Map1Index.Points)
1421 GL_FREE( ctx->EvalMap.Map1Index.Points );
1422 if (ctx->EvalMap.Map1Color4.Points)
1423 GL_FREE( ctx->EvalMap.Map1Color4.Points );
1424 if (ctx->EvalMap.Map1Normal.Points)
1425 GL_FREE( ctx->EvalMap.Map1Normal.Points );
1426 if (ctx->EvalMap.Map1Texture1.Points)
1427 GL_FREE( ctx->EvalMap.Map1Texture1.Points );
1428 if (ctx->EvalMap.Map1Texture2.Points)
1429 GL_FREE( ctx->EvalMap.Map1Texture2.Points );
1430 if (ctx->EvalMap.Map1Texture3.Points)
1431 GL_FREE( ctx->EvalMap.Map1Texture3.Points );
1432 if (ctx->EvalMap.Map1Texture4.Points)
1433 GL_FREE( ctx->EvalMap.Map1Texture4.Points );
1434
1435 if (ctx->EvalMap.Map2Vertex3.Points)
1436 GL_FREE( ctx->EvalMap.Map2Vertex3.Points );
1437 if (ctx->EvalMap.Map2Vertex4.Points)
1438 GL_FREE( ctx->EvalMap.Map2Vertex4.Points );
1439 if (ctx->EvalMap.Map2Index.Points)
1440 GL_FREE( ctx->EvalMap.Map2Index.Points );
1441 if (ctx->EvalMap.Map2Color4.Points)
1442 GL_FREE( ctx->EvalMap.Map2Color4.Points );
1443 if (ctx->EvalMap.Map2Normal.Points)
1444 GL_FREE( ctx->EvalMap.Map2Normal.Points );
1445 if (ctx->EvalMap.Map2Texture1.Points)
1446 GL_FREE( ctx->EvalMap.Map2Texture1.Points );
1447 if (ctx->EvalMap.Map2Texture2.Points)
1448 GL_FREE( ctx->EvalMap.Map2Texture2.Points );
1449 if (ctx->EvalMap.Map2Texture3.Points)
1450 GL_FREE( ctx->EvalMap.Map2Texture3.Points );
1451 if (ctx->EvalMap.Map2Texture4.Points)
1452 GL_FREE( ctx->EvalMap.Map2Texture4.Points );
1453
1454 /* Free cache of immediate buffers. */
1455 while (ctx->nr_im_queued-- > 0) {
1456 struct immediate * next = ctx->freed_im_queue->next;
1457 GL_FREE( ctx->freed_im_queue );
1458 ctx->freed_im_queue = next;
1459 }
1460 gl_extensions_dtr(ctx);
1461
1462 GL_FREE( (void *) ctx );
1463
1464 #ifndef THREADS
1465 if (ctx==CC) {
1466 CC = NULL;
1467 CURRENT_INPUT = NULL;
1468 }
1469 #endif
1470
1471 }
1472 }
1473
1474
1475
1476 /*
1477 * Create a new framebuffer. A GLframebuffer is a struct which
1478 * encapsulates the depth, stencil and accum buffers and related
1479 * parameters.
1480 * Input: visual - a GLvisual pointer
1481 * Return: pointer to new GLframebuffer struct or NULL if error.
1482 */
1483 GLframebuffer *gl_create_framebuffer( GLvisual *visual )
1484 {
1485 GLframebuffer *buffer;
1486
1487 buffer = (GLframebuffer *) calloc( 1, sizeof(GLframebuffer) );
1488 if (!buffer) {
1489 return NULL;
1490 }
1491
1492 buffer->Visual = visual;
1493
1494 return buffer;
1495 }
1496
1497
1498
1499 /*
1500 * Free a framebuffer struct and its buffers.
1501 */
1502 void gl_destroy_framebuffer( GLframebuffer *buffer )
1503 {
1504 if (buffer) {
1505 if (buffer->Depth) {
1506 GL_FREE( buffer->Depth );
1507 }
1508 if (buffer->Accum) {
1509 GL_FREE( buffer->Accum );
1510 }
1511 if (buffer->Stencil) {
1512 GL_FREE( buffer->Stencil );
1513 }
1514 if (buffer->FrontLeftAlpha) {
1515 GL_FREE( buffer->FrontLeftAlpha );
1516 }
1517 if (buffer->BackLeftAlpha) {
1518 GL_FREE( buffer->BackLeftAlpha );
1519 }
1520 if (buffer->FrontRightAlpha) {
1521 GL_FREE( buffer->FrontRightAlpha );
1522 }
1523 if (buffer->BackRightAlpha) {
1524 GL_FREE( buffer->BackRightAlpha );
1525 }
1526 GL_FREE(buffer);
1527 }
1528 }
1529
1530
1531
1532 /*
1533 * Set the current context, binding the given frame buffer to the context.
1534 */
1535 void gl_make_current( GLcontext *ctx, GLframebuffer *buffer )
1536 {
1537 GET_CONTEXT;
1538
1539 /* Flush the old context
1540 */
1541 if (CC) {
1542 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(CC, "gl_make_current");
1543 }
1544
1545 #ifdef THREADS
1546 /* TODO: unbind old buffer from context? */
1547 set_thread_context( ctx );
1548 #else
1549 if (CC && CC->Buffer) {
1550 /* unbind frame buffer from context */
1551 CC->Buffer = NULL;
1552 }
1553 CC = ctx;
1554 if (ctx) {
1555 SET_IMMEDIATE(ctx, ctx->input);
1556 }
1557 #endif
1558
1559 if (MESA_VERBOSE) fprintf(stderr, "gl_make_current()\n");
1560
1561 if (ctx && buffer) {
1562 /* TODO: check if ctx and buffer's visual match??? */
1563 ctx->Buffer = buffer; /* Bind the frame buffer to the context */
1564 ctx->NewState = NEW_ALL; /* just to be safe */
1565 gl_update_state( ctx );
1566 }
1567 }
1568
1569
1570 /*
1571 * Return current context handle.
1572 */
1573 GLcontext *gl_get_current_context( void )
1574 {
1575 #ifdef THREADS
1576 return gl_get_thread_context();
1577 #else
1578 return CC;
1579 #endif
1580 }
1581
1582
1583
1584 /*
1585 * Copy attribute groups from one context to another.
1586 * Input: src - source context
1587 * dst - destination context
1588 * mask - bitwise OR of GL_*_BIT flags
1589 */
1590 void gl_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1591 {
1592 if (mask & GL_ACCUM_BUFFER_BIT) {
1593 MEMCPY( &dst->Accum, &src->Accum, sizeof(struct gl_accum_attrib) );
1594 }
1595 if (mask & GL_COLOR_BUFFER_BIT) {
1596 MEMCPY( &dst->Color, &src->Color, sizeof(struct gl_colorbuffer_attrib) );
1597 }
1598 if (mask & GL_CURRENT_BIT) {
1599 MEMCPY( &dst->Current, &src->Current, sizeof(struct gl_current_attrib) );
1600 }
1601 if (mask & GL_DEPTH_BUFFER_BIT) {
1602 MEMCPY( &dst->Depth, &src->Depth, sizeof(struct gl_depthbuffer_attrib) );
1603 }
1604 if (mask & GL_ENABLE_BIT) {
1605 /* no op */
1606 }
1607 if (mask & GL_EVAL_BIT) {
1608 MEMCPY( &dst->Eval, &src->Eval, sizeof(struct gl_eval_attrib) );
1609 }
1610 if (mask & GL_FOG_BIT) {
1611 MEMCPY( &dst->Fog, &src->Fog, sizeof(struct gl_fog_attrib) );
1612 }
1613 if (mask & GL_HINT_BIT) {
1614 MEMCPY( &dst->Hint, &src->Hint, sizeof(struct gl_hint_attrib) );
1615 }
1616 if (mask & GL_LIGHTING_BIT) {
1617 MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light_attrib) );
1618 /* gl_reinit_light_attrib( &dst->Light ); */
1619 }
1620 if (mask & GL_LINE_BIT) {
1621 MEMCPY( &dst->Line, &src->Line, sizeof(struct gl_line_attrib) );
1622 }
1623 if (mask & GL_LIST_BIT) {
1624 MEMCPY( &dst->List, &src->List, sizeof(struct gl_list_attrib) );
1625 }
1626 if (mask & GL_PIXEL_MODE_BIT) {
1627 MEMCPY( &dst->Pixel, &src->Pixel, sizeof(struct gl_pixel_attrib) );
1628 }
1629 if (mask & GL_POINT_BIT) {
1630 MEMCPY( &dst->Point, &src->Point, sizeof(struct gl_point_attrib) );
1631 }
1632 if (mask & GL_POLYGON_BIT) {
1633 MEMCPY( &dst->Polygon, &src->Polygon, sizeof(struct gl_polygon_attrib) );
1634 }
1635 if (mask & GL_POLYGON_STIPPLE_BIT) {
1636 /* Use loop instead of MEMCPY due to problem with Portland Group's
1637 * C compiler. Reported by John Stone.
1638 */
1639 int i;
1640 for (i=0;i<32;i++) {
1641 dst->PolygonStipple[i] = src->PolygonStipple[i];
1642 }
1643 }
1644 if (mask & GL_SCISSOR_BIT) {
1645 MEMCPY( &dst->Scissor, &src->Scissor, sizeof(struct gl_scissor_attrib) );
1646 }
1647 if (mask & GL_STENCIL_BUFFER_BIT) {
1648 MEMCPY( &dst->Stencil, &src->Stencil, sizeof(struct gl_stencil_attrib) );
1649 }
1650 if (mask & GL_TEXTURE_BIT) {
1651 MEMCPY( &dst->Texture, &src->Texture, sizeof(struct gl_texture_attrib) );
1652 }
1653 if (mask & GL_TRANSFORM_BIT) {
1654 MEMCPY( &dst->Transform, &src->Transform, sizeof(struct gl_transform_attrib) );
1655 }
1656 if (mask & GL_VIEWPORT_BIT) {
1657 MEMCPY( &dst->Viewport, &src->Viewport, sizeof(struct gl_viewport_attrib) );
1658 }
1659 }
1660
1661
1662
1663 /*
1664 * Someday a GLS library or OpenGL-like debugger may call this function
1665 * to register it's own set of API entry points.
1666 * Input: ctx - the context to set API pointers for
1667 * api - if NULL, restore original API pointers
1668 * else, set API function table to this table.
1669 */
1670 void gl_set_api_table( GLcontext *ctx, const struct gl_api_table *api )
1671 {
1672 if (api) {
1673 MEMCPY( &ctx->API, api, sizeof(struct gl_api_table) );
1674 }
1675 else {
1676 MEMCPY( &ctx->API, &ctx->Exec, sizeof(struct gl_api_table) );
1677 }
1678 }
1679
1680
1681
1682
1683 /**********************************************************************/
1684 /***** Miscellaneous functions *****/
1685 /**********************************************************************/
1686
1687
1688 /*
1689 * This function is called when the Mesa user has stumbled into a code
1690 * path which may not be implemented fully or correctly.
1691 */
1692 void gl_problem( const GLcontext *ctx, const char *s )
1693 {
1694 fprintf( stderr, "Mesa implementation error: %s\n", s );
1695 fprintf( stderr, "Report to mesa-bugs@mesa3d.org\n" );
1696 (void) ctx;
1697 }
1698
1699
1700
1701 /*
1702 * This is called to inform the user that he or she has tried to do
1703 * something illogical or if there's likely a bug in their program
1704 * (like enabled depth testing without a depth buffer).
1705 */
1706 void gl_warning( const GLcontext *ctx, const char *s )
1707 {
1708 GLboolean debug;
1709 #ifdef DEBUG
1710 debug = GL_TRUE;
1711 #else
1712 if (getenv("MESA_DEBUG")) {
1713 debug = GL_TRUE;
1714 }
1715 else {
1716 debug = GL_FALSE;
1717 }
1718 #endif
1719 if (debug) {
1720 fprintf( stderr, "Mesa warning: %s\n", s );
1721 }
1722 (void) ctx;
1723 }
1724
1725
1726
1727 void gl_compile_error( GLcontext *ctx, GLenum error, const char *s )
1728 {
1729 if (ctx->CompileFlag)
1730 gl_save_error( ctx, error, s );
1731
1732 if (ctx->ExecuteFlag)
1733 gl_error( ctx, error, s );
1734 }
1735
1736
1737 /*
1738 * This is Mesa's error handler. Normally, all that's done is the updating
1739 * of the current error value. If Mesa is compiled with -DDEBUG or if the
1740 * environment variable "MESA_DEBUG" is defined then a real error message
1741 * is printed to stderr.
1742 * Input: error - the error value
1743 * s - a diagnostic string
1744 */
1745 void gl_error( GLcontext *ctx, GLenum error, const char *s )
1746 {
1747 GLboolean debug;
1748
1749 #ifdef DEBUG
1750 debug = GL_TRUE;
1751 #else
1752 if (getenv("MESA_DEBUG")) {
1753 debug = GL_TRUE;
1754 }
1755 else {
1756 debug = GL_FALSE;
1757 }
1758 #endif
1759
1760 if (debug) {
1761 char errstr[1000];
1762
1763 switch (error) {
1764 case GL_NO_ERROR:
1765 strcpy( errstr, "GL_NO_ERROR" );
1766 break;
1767 case GL_INVALID_VALUE:
1768 strcpy( errstr, "GL_INVALID_VALUE" );
1769 break;
1770 case GL_INVALID_ENUM:
1771 strcpy( errstr, "GL_INVALID_ENUM" );
1772 break;
1773 case GL_INVALID_OPERATION:
1774 strcpy( errstr, "GL_INVALID_OPERATION" );
1775 break;
1776 case GL_STACK_OVERFLOW:
1777 strcpy( errstr, "GL_STACK_OVERFLOW" );
1778 break;
1779 case GL_STACK_UNDERFLOW:
1780 strcpy( errstr, "GL_STACK_UNDERFLOW" );
1781 break;
1782 case GL_OUT_OF_MEMORY:
1783 strcpy( errstr, "GL_OUT_OF_MEMORY" );
1784 break;
1785 default:
1786 strcpy( errstr, "unknown" );
1787 break;
1788 }
1789 fprintf( stderr, "Mesa user error: %s in %s\n", errstr, s );
1790 }
1791
1792 if (ctx->ErrorValue==GL_NO_ERROR) {
1793 ctx->ErrorValue = error;
1794 }
1795
1796 /* Call device driver's error handler, if any. This is used on the Mac. */
1797 if (ctx->Driver.Error) {
1798 (*ctx->Driver.Error)( ctx );
1799 }
1800 }
1801
1802
1803
1804 /*
1805 * Execute a glGetError command
1806 */
1807 GLenum gl_GetError( GLcontext *ctx )
1808 {
1809 GLenum e = ctx->ErrorValue;
1810
1811 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL( ctx, "glGetError", (GLenum) 0);
1812
1813 if (MESA_VERBOSE & VERBOSE_API)
1814 fprintf(stderr, "glGetError <-- %s\n", gl_lookup_enum_by_nr(e));
1815
1816 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1817 return e;
1818 }
1819
1820
1821
1822 void gl_ResizeBuffersMESA( GLcontext *ctx )
1823 {
1824 GLuint buf_width, buf_height;
1825
1826 if (MESA_VERBOSE & VERBOSE_API)
1827 fprintf(stderr, "glResizeBuffersMESA\n");
1828
1829 /* ask device driver for size of output buffer */
1830 (*ctx->Driver.GetBufferSize)( ctx, &buf_width, &buf_height );
1831
1832 /* see if size of device driver's color buffer (window) has changed */
1833 if (ctx->Buffer->Width == (GLint) buf_width &&
1834 ctx->Buffer->Height == (GLint) buf_height)
1835 return;
1836
1837 ctx->NewState |= NEW_RASTER_OPS; /* to update scissor / window bounds */
1838
1839 /* save buffer size */
1840 ctx->Buffer->Width = buf_width;
1841 ctx->Buffer->Height = buf_height;
1842
1843 /* Reallocate other buffers if needed. */
1844 if (ctx->Visual->DepthBits>0) {
1845 /* reallocate depth buffer */
1846 (*ctx->Driver.AllocDepthBuffer)( ctx );
1847 }
1848 if (ctx->Visual->StencilBits>0) {
1849 /* reallocate stencil buffer */
1850 gl_alloc_stencil_buffer( ctx );
1851 }
1852 if (ctx->Visual->AccumBits>0) {
1853 /* reallocate accum buffer */
1854 gl_alloc_accum_buffer( ctx );
1855 }
1856 if (ctx->Visual->SoftwareAlpha) {
1857 gl_alloc_alpha_buffers( ctx );
1858 }
1859 }
1860
1861
1862
1863
1864 /**********************************************************************/
1865 /***** State update logic *****/
1866 /**********************************************************************/
1867
1868
1869 /*
1870 * Since the device driver may or may not support pixel logic ops we
1871 * have to make some extensive tests to determine whether or not
1872 * software-implemented logic operations have to be used.
1873 */
1874 static void update_pixel_logic( GLcontext *ctx )
1875 {
1876 if (ctx->Visual->RGBAflag) {
1877 /* RGBA mode blending w/ Logic Op */
1878 if (ctx->Color.ColorLogicOpEnabled) {
1879 if (ctx->Driver.LogicOp
1880 && (*ctx->Driver.LogicOp)( ctx, ctx->Color.LogicOp )) {
1881 /* Device driver can do logic, don't have to do it in software */
1882 ctx->Color.SWLogicOpEnabled = GL_FALSE;
1883 }
1884 else {
1885 /* Device driver can't do logic op so we do it in software */
1886 ctx->Color.SWLogicOpEnabled = GL_TRUE;
1887 }
1888 }
1889 else {
1890 /* no logic op */
1891 if (ctx->Driver.LogicOp) {
1892 (void) (*ctx->Driver.LogicOp)( ctx, GL_COPY );
1893 }
1894 ctx->Color.SWLogicOpEnabled = GL_FALSE;
1895 }
1896 }
1897 else {
1898 /* CI mode Logic Op */
1899 if (ctx->Color.IndexLogicOpEnabled) {
1900 if (ctx->Driver.LogicOp
1901 && (*ctx->Driver.LogicOp)( ctx, ctx->Color.LogicOp )) {
1902 /* Device driver can do logic, don't have to do it in software */
1903 ctx->Color.SWLogicOpEnabled = GL_FALSE;
1904 }
1905 else {
1906 /* Device driver can't do logic op so we do it in software */
1907 ctx->Color.SWLogicOpEnabled = GL_TRUE;
1908 }
1909 }
1910 else {
1911 /* no logic op */
1912 if (ctx->Driver.LogicOp) {
1913 (void) (*ctx->Driver.LogicOp)( ctx, GL_COPY );
1914 }
1915 ctx->Color.SWLogicOpEnabled = GL_FALSE;
1916 }
1917 }
1918 }
1919
1920
1921
1922 /*
1923 * Check if software implemented RGBA or Color Index masking is needed.
1924 */
1925 static void update_pixel_masking( GLcontext *ctx )
1926 {
1927 if (ctx->Visual->RGBAflag) {
1928 GLuint *colorMask = (GLuint *) ctx->Color.ColorMask;
1929 if (*colorMask == 0xffffffff) {
1930 /* disable masking */
1931 if (ctx->Driver.ColorMask) {
1932 (void) (*ctx->Driver.ColorMask)( ctx, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
1933 }
1934 ctx->Color.SWmasking = GL_FALSE;
1935 }
1936 else {
1937 /* Ask driver to do color masking, if it can't then
1938 * do it in software
1939 */
1940 GLboolean red = ctx->Color.ColorMask[RCOMP] ? GL_TRUE : GL_FALSE;
1941 GLboolean green = ctx->Color.ColorMask[GCOMP] ? GL_TRUE : GL_FALSE;
1942 GLboolean blue = ctx->Color.ColorMask[BCOMP] ? GL_TRUE : GL_FALSE;
1943 GLboolean alpha = ctx->Color.ColorMask[ACOMP] ? GL_TRUE : GL_FALSE;
1944 if (ctx->Driver.ColorMask
1945 && (*ctx->Driver.ColorMask)( ctx, red, green, blue, alpha )) {
1946 ctx->Color.SWmasking = GL_FALSE;
1947 }
1948 else {
1949 ctx->Color.SWmasking = GL_TRUE;
1950 }
1951 }
1952 }
1953 else {
1954 if (ctx->Color.IndexMask==0xffffffff) {
1955 /* disable masking */
1956 if (ctx->Driver.IndexMask) {
1957 (void) (*ctx->Driver.IndexMask)( ctx, 0xffffffff );
1958 }
1959 ctx->Color.SWmasking = GL_FALSE;
1960 }
1961 else {
1962 /* Ask driver to do index masking, if it can't then
1963 * do it in software
1964 */
1965 if (ctx->Driver.IndexMask
1966 && (*ctx->Driver.IndexMask)( ctx, ctx->Color.IndexMask )) {
1967 ctx->Color.SWmasking = GL_FALSE;
1968 }
1969 else {
1970 ctx->Color.SWmasking = GL_TRUE;
1971 }
1972 }
1973 }
1974 }
1975
1976
1977 static void update_fog_mode( GLcontext *ctx )
1978 {
1979 int old_mode = ctx->FogMode;
1980
1981 if (ctx->Fog.Enabled) {
1982 if (ctx->Texture.Enabled)
1983 ctx->FogMode = FOG_FRAGMENT;
1984 else if (ctx->Hint.Fog == GL_NICEST)
1985 ctx->FogMode = FOG_FRAGMENT;
1986 else
1987 ctx->FogMode = FOG_VERTEX;
1988
1989 if (ctx->Driver.GetParameteri)
1990 if ((ctx->Driver.GetParameteri)( ctx, DD_HAVE_HARDWARE_FOG ))
1991 ctx->FogMode = FOG_FRAGMENT;
1992 }
1993 else {
1994 ctx->FogMode = FOG_NONE;
1995 }
1996
1997 if (old_mode != ctx->FogMode)
1998 ctx->NewState |= NEW_FOG;
1999 }
2000
2001
2002 /*
2003 * Recompute the value of ctx->RasterMask, etc. according to
2004 * the current context.
2005 */
2006 static void update_rasterflags( GLcontext *ctx )
2007 {
2008 ctx->RasterMask = 0;
2009
2010 if (ctx->Color.AlphaEnabled) ctx->RasterMask |= ALPHATEST_BIT;
2011 if (ctx->Color.BlendEnabled) ctx->RasterMask |= BLEND_BIT;
2012 if (ctx->Depth.Test) ctx->RasterMask |= DEPTH_BIT;
2013 if (ctx->FogMode==FOG_FRAGMENT) ctx->RasterMask |= FOG_BIT;
2014 if (ctx->Color.SWLogicOpEnabled) ctx->RasterMask |= LOGIC_OP_BIT;
2015 if (ctx->Scissor.Enabled) ctx->RasterMask |= SCISSOR_BIT;
2016 if (ctx->Stencil.Enabled) ctx->RasterMask |= STENCIL_BIT;
2017 if (ctx->Color.SWmasking) ctx->RasterMask |= MASKING_BIT;
2018
2019 if (ctx->Visual->SoftwareAlpha && ctx->Color.ColorMask[ACOMP]
2020 && ctx->Color.DrawBuffer != GL_NONE)
2021 ctx->RasterMask |= ALPHABUF_BIT;
2022
2023 if ( ctx->Viewport.X<0
2024 || ctx->Viewport.X + ctx->Viewport.Width > ctx->Buffer->Width
2025 || ctx->Viewport.Y<0
2026 || ctx->Viewport.Y + ctx->Viewport.Height > ctx->Buffer->Height) {
2027 ctx->RasterMask |= WINCLIP_BIT;
2028 }
2029
2030 /* If we're not drawing to exactly one color buffer set the
2031 * MULTI_DRAW_BIT flag. Also set it if we're drawing to no
2032 * buffers or the RGBA or CI mask disables all writes.
2033 */
2034
2035 ctx->TriangleCaps &= ~DD_MULTIDRAW;
2036
2037 if (ctx->Color.MultiDrawBuffer) {
2038 ctx->RasterMask |= MULTI_DRAW_BIT;
2039 ctx->TriangleCaps |= DD_MULTIDRAW;
2040 }
2041 else if (ctx->Color.DrawBuffer==GL_NONE) {
2042 ctx->RasterMask |= MULTI_DRAW_BIT;
2043 ctx->TriangleCaps |= DD_MULTIDRAW;
2044 }
2045 else if (ctx->Visual->RGBAflag && ctx->Color.ColorMask==0) {
2046 /* all RGBA channels disabled */
2047 ctx->RasterMask |= MULTI_DRAW_BIT;
2048 ctx->TriangleCaps |= DD_MULTIDRAW;
2049 ctx->Color.DrawDestMask = 0;
2050 }
2051 else if (!ctx->Visual->RGBAflag && ctx->Color.IndexMask==0) {
2052 /* all color index bits disabled */
2053 ctx->RasterMask |= MULTI_DRAW_BIT;
2054 ctx->TriangleCaps |= DD_MULTIDRAW;
2055 ctx->Color.DrawDestMask = 0;
2056 }
2057 }
2058
2059
2060 void gl_print_state( const char *msg, GLuint state )
2061 {
2062 fprintf(stderr,
2063 "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
2064 msg,
2065 state,
2066 (state & NEW_LIGHTING) ? "lighting, " : "",
2067 (state & NEW_RASTER_OPS) ? "raster-ops, " : "",
2068 (state & NEW_TEXTURING) ? "texturing, " : "",
2069 (state & NEW_POLYGON) ? "polygon, " : "",
2070 (state & NEW_DRVSTATE0) ? "driver-0, " : "",
2071 (state & NEW_DRVSTATE1) ? "driver-1, " : "",
2072 (state & NEW_DRVSTATE2) ? "driver-2, " : "",
2073 (state & NEW_DRVSTATE3) ? "driver-3, " : "",
2074 (state & NEW_MODELVIEW) ? "modelview, " : "",
2075 (state & NEW_PROJECTION) ? "projection, " : "",
2076 (state & NEW_TEXTURE_MATRIX) ? "texture-matrix, " : "",
2077 (state & NEW_USER_CLIP) ? "user-clip, " : "",
2078 (state & NEW_TEXTURE_ENV) ? "texture-env, " : "",
2079 (state & NEW_CLIENT_STATE) ? "client-state, " : "",
2080 (state & NEW_FOG) ? "fog, " : "",
2081 (state & NEW_NORMAL_TRANSFORM) ? "normal-transform, " : "",
2082 (state & NEW_VIEWPORT) ? "viewport, " : "",
2083 (state & NEW_TEXTURE_ENABLE) ? "texture-enable, " : "");
2084 }
2085
2086 void gl_print_enable_flags( const char *msg, GLuint flags )
2087 {
2088 fprintf(stderr,
2089 "%s: (0x%x) %s%s%s%s%s%s%s%s%s%s%s\n",
2090 msg,
2091 flags,
2092 (flags & ENABLE_TEX0) ? "tex-0, " : "",
2093 (flags & ENABLE_TEX1) ? "tex-1, " : "",
2094 (flags & ENABLE_LIGHT) ? "light, " : "",
2095 (flags & ENABLE_FOG) ? "fog, " : "",
2096 (flags & ENABLE_USERCLIP) ? "userclip, " : "",
2097 (flags & ENABLE_TEXGEN0) ? "tex-gen-0, " : "",
2098 (flags & ENABLE_TEXGEN1) ? "tex-gen-1, " : "",
2099 (flags & ENABLE_TEXMAT0) ? "tex-mat-0, " : "",
2100 (flags & ENABLE_TEXMAT1) ? "tex-mat-1, " : "",
2101 (flags & ENABLE_NORMALIZE) ? "normalize, " : "",
2102 (flags & ENABLE_RESCALE) ? "rescale, " : "");
2103 }
2104
2105
2106 /*
2107 * If ctx->NewState is non-zero then this function MUST be called before
2108 * rendering any primitive. Basically, function pointers and miscellaneous
2109 * flags are updated to reflect the current state of the state machine.
2110 */
2111 void gl_update_state( GLcontext *ctx )
2112 {
2113 GLuint i;
2114
2115 if (MESA_VERBOSE & VERBOSE_STATE)
2116 gl_print_state("", ctx->NewState);
2117
2118 if (ctx->NewState & NEW_CLIENT_STATE)
2119 gl_update_client_state( ctx );
2120
2121 if ((ctx->NewState & NEW_TEXTURE_ENABLE) &&
2122 (ctx->Enabled & ENABLE_TEX_ANY) != ctx->Texture.Enabled)
2123 ctx->NewState |= NEW_TEXTURING | NEW_RASTER_OPS;
2124
2125 if (ctx->NewState & NEW_TEXTURE_ENV) {
2126 if (ctx->Texture.Unit[0].EnvMode == ctx->Texture.Unit[0].LastEnvMode &&
2127 ctx->Texture.Unit[1].EnvMode == ctx->Texture.Unit[1].LastEnvMode)
2128 ctx->NewState &= ~NEW_TEXTURE_ENV;
2129 ctx->Texture.Unit[0].LastEnvMode = ctx->Texture.Unit[0].EnvMode;
2130 ctx->Texture.Unit[1].LastEnvMode = ctx->Texture.Unit[1].EnvMode;
2131 }
2132
2133 if ((ctx->NewState & ~(NEW_CLIENT_STATE|NEW_TEXTURE_ENABLE)) == 0) {
2134
2135 if (MESA_VERBOSE&VERBOSE_STATE)
2136 fprintf(stderr, "update_state: goto finished\n");
2137
2138 goto finished;
2139 }
2140
2141 if (ctx->NewState & NEW_TEXTURE_MATRIX) {
2142 ctx->Enabled &= ~(ENABLE_TEXMAT0|ENABLE_TEXMAT1);
2143
2144 for (i=0; i < MAX_TEXTURE_UNITS; i++) {
2145 if (ctx->TextureMatrix[i].flags & MAT_DIRTY_ALL_OVER)
2146 {
2147 gl_matrix_analyze( &ctx->TextureMatrix[i] );
2148 ctx->TextureMatrix[i].flags &= ~MAT_DIRTY_DEPENDENTS;
2149
2150 if (ctx->Texture.Unit[i].Enabled &&
2151 ctx->TextureMatrix[i].type != MATRIX_IDENTITY)
2152 ctx->Enabled |= ENABLE_TEXMAT0 << i;
2153 }
2154 }
2155 }
2156
2157 if (ctx->NewState & NEW_TEXTURING) {
2158 ctx->Texture.NeedNormals = GL_FALSE;
2159 gl_update_dirty_texobjs(ctx);
2160 ctx->Enabled &= ~(ENABLE_TEXGEN0|ENABLE_TEXGEN1);
2161 ctx->Texture.ReallyEnabled = 0;
2162
2163 for (i=0; i < MAX_TEXTURE_UNITS; i++) {
2164 if (ctx->Texture.Unit[i].Enabled) {
2165 gl_update_texture_unit( ctx, &ctx->Texture.Unit[i] );
2166
2167 ctx->Texture.ReallyEnabled |=
2168 ctx->Texture.Unit[i].ReallyEnabled<<(i*4);
2169
2170 if (ctx->Texture.Unit[i].GenFlags != 0) {
2171 ctx->Enabled |= ENABLE_TEXGEN0 << i;
2172
2173 if (ctx->Texture.Unit[i].GenFlags & TEXGEN_NEED_NORMALS)
2174 {
2175 ctx->Texture.NeedNormals = GL_TRUE;
2176 ctx->Texture.NeedEyeCoords = GL_TRUE;
2177 }
2178
2179 if (ctx->Texture.Unit[i].GenFlags & TEXGEN_NEED_EYE_COORD)
2180 {
2181 ctx->Texture.NeedEyeCoords = GL_TRUE;
2182 }
2183 }
2184 }
2185 }
2186
2187 ctx->Texture.Enabled = ctx->Enabled & ENABLE_TEX_ANY;
2188 ctx->NeedNormals = (ctx->Light.Enabled || ctx->Texture.NeedNormals);
2189 }
2190
2191 if (ctx->NewState & (NEW_RASTER_OPS | NEW_LIGHTING | NEW_FOG)) {
2192
2193
2194 if (ctx->NewState & NEW_RASTER_OPS) {
2195 update_pixel_logic(ctx);
2196 update_pixel_masking(ctx);
2197 update_fog_mode(ctx);
2198 update_rasterflags(ctx);
2199 if (ctx->Driver.Dither) {
2200 (*ctx->Driver.Dither)( ctx, ctx->Color.DitherFlag );
2201 }
2202
2203 /* Check if incoming colors can be modified during rasterization */
2204 if (ctx->Fog.Enabled ||
2205 ctx->Texture.Enabled ||
2206 ctx->Color.BlendEnabled ||
2207 ctx->Color.SWmasking ||
2208 ctx->Color.SWLogicOpEnabled) {
2209 ctx->MutablePixels = GL_TRUE;
2210 }
2211 else {
2212 ctx->MutablePixels = GL_FALSE;
2213 }
2214
2215 /* update scissor region */
2216
2217 ctx->Buffer->Xmin = 0;
2218 ctx->Buffer->Ymin = 0;
2219 ctx->Buffer->Xmax = ctx->Buffer->Width-1;
2220 ctx->Buffer->Ymax = ctx->Buffer->Height-1;
2221 if (ctx->Scissor.Enabled) {
2222 if (ctx->Scissor.X > ctx->Buffer->Xmin) {
2223 ctx->Buffer->Xmin = ctx->Scissor.X;
2224 }
2225 if (ctx->Scissor.Y > ctx->Buffer->Ymin) {
2226 ctx->Buffer->Ymin = ctx->Scissor.Y;
2227 }
2228 if (ctx->Scissor.X + ctx->Scissor.Width - 1 < ctx->Buffer->Xmax) {
2229 ctx->Buffer->Xmax = ctx->Scissor.X + ctx->Scissor.Width - 1;
2230 }
2231 if (ctx->Scissor.Y + ctx->Scissor.Height - 1 < ctx->Buffer->Ymax) {
2232 ctx->Buffer->Ymax = ctx->Scissor.Y + ctx->Scissor.Height - 1;
2233 }
2234 }
2235
2236 /* The driver isn't managing the depth buffer.
2237 */
2238 if (ctx->Driver.AllocDepthBuffer == gl_alloc_depth_buffer)
2239 {
2240 if (ctx->Depth.Mask) {
2241 switch (ctx->Depth.Func) {
2242 case GL_LESS:
2243 ctx->Driver.DepthTestSpan = gl_depth_test_span_less;
2244 ctx->Driver.DepthTestPixels = gl_depth_test_pixels_less;
2245 break;
2246 case GL_GREATER:
2247 ctx->Driver.DepthTestSpan = gl_depth_test_span_greater;
2248 ctx->Driver.DepthTestPixels = gl_depth_test_pixels_greater;
2249 break;
2250 default:
2251 ctx->Driver.DepthTestSpan = gl_depth_test_span_generic;
2252 ctx->Driver.DepthTestPixels = gl_depth_test_pixels_generic;
2253 }
2254 }
2255 else {
2256 ctx->Driver.DepthTestSpan = gl_depth_test_span_generic;
2257 ctx->Driver.DepthTestPixels = gl_depth_test_pixels_generic;
2258 }
2259 }
2260 }
2261
2262 if (ctx->NewState & NEW_LIGHTING) {
2263 ctx->TriangleCaps &= ~(DD_TRI_LIGHT_TWOSIDE|DD_LIGHTING_CULL);
2264 if (ctx->Light.Enabled) {
2265 if (ctx->Light.Model.TwoSide)
2266 ctx->TriangleCaps |= (DD_TRI_LIGHT_TWOSIDE|DD_LIGHTING_CULL);
2267 gl_update_lighting(ctx);
2268 }
2269 }
2270 }
2271
2272 if (ctx->NewState & (NEW_POLYGON | NEW_LIGHTING)) {
2273
2274 ctx->TriangleCaps &= ~DD_TRI_CULL_FRONT_BACK;
2275
2276 if (ctx->NewState & NEW_POLYGON) {
2277 /* Setup CullBits bitmask */
2278 if (ctx->Polygon.CullFlag) {
2279 ctx->backface_sign = 1;
2280 switch(ctx->Polygon.CullFaceMode) {
2281 case GL_BACK:
2282 if(ctx->Polygon.FrontFace==GL_CCW)
2283 ctx->backface_sign = -1;
2284 ctx->Polygon.CullBits = 1;
2285 break;
2286 case GL_FRONT:
2287 if(ctx->Polygon.FrontFace!=GL_CCW)
2288 ctx->backface_sign = -1;
2289 ctx->Polygon.CullBits = 2;
2290 break;
2291 default:
2292 case GL_FRONT_AND_BACK:
2293 ctx->backface_sign = 0;
2294 ctx->Polygon.CullBits = 0;
2295 ctx->TriangleCaps |= DD_TRI_CULL_FRONT_BACK;
2296 break;
2297 }
2298 }
2299 else {
2300 ctx->Polygon.CullBits = 3;
2301 ctx->backface_sign = 0;
2302 }
2303
2304 /* Any Polygon offsets enabled? */
2305 ctx->TriangleCaps &= ~DD_TRI_OFFSET;
2306
2307 if (ctx->Polygon.OffsetPoint ||
2308 ctx->Polygon.OffsetLine ||
2309 ctx->Polygon.OffsetFill)
2310 ctx->TriangleCaps |= DD_TRI_OFFSET;
2311
2312 /* reset Z offsets now */
2313 ctx->PointZoffset = 0.0;
2314 ctx->LineZoffset = 0.0;
2315 ctx->PolygonZoffset = 0.0;
2316 }
2317 }
2318
2319 if (ctx->NewState & ~(NEW_CLIENT_STATE|NEW_TEXTURE_ENABLE|
2320 NEW_DRIVER_STATE|NEW_USER_CLIP|
2321 NEW_POLYGON))
2322 gl_update_clipmask(ctx);
2323
2324 if (ctx->NewState & (NEW_LIGHTING|
2325 NEW_RASTER_OPS|
2326 NEW_TEXTURING|
2327 NEW_TEXTURE_ENV|
2328 NEW_POLYGON|
2329 NEW_DRVSTATE0|
2330 NEW_DRVSTATE1|
2331 NEW_DRVSTATE2|
2332 NEW_DRVSTATE3|
2333 NEW_USER_CLIP))
2334 {
2335 ctx->IndirectTriangles = ctx->TriangleCaps & ~ctx->Driver.TriangleCaps;
2336 ctx->IndirectTriangles |= DD_SW_RASTERIZE;
2337
2338 if (MESA_VERBOSE&VERBOSE_CULL)
2339 gl_print_tri_caps("initial indirect tris", ctx->IndirectTriangles);
2340
2341 ctx->Driver.PointsFunc = NULL;
2342 ctx->Driver.LineFunc = NULL;
2343 ctx->Driver.TriangleFunc = NULL;
2344 ctx->Driver.QuadFunc = NULL;
2345 ctx->Driver.RectFunc = NULL;
2346 ctx->Driver.RenderVBClippedTab = NULL;
2347 ctx->Driver.RenderVBCulledTab = NULL;
2348 ctx->Driver.RenderVBRawTab = NULL;
2349
2350 /*
2351 * Here the driver sets up all the ctx->Driver function pointers to
2352 * it's specific, private functions.
2353 */
2354 ctx->Driver.UpdateState(ctx);
2355
2356 if (MESA_VERBOSE&VERBOSE_CULL)
2357 gl_print_tri_caps("indirect tris", ctx->IndirectTriangles);
2358
2359 /*
2360 * In case the driver didn't hook in an optimized point, line or
2361 * triangle function we'll now select "core/fallback" point, line
2362 * and triangle functions.
2363 */
2364 if (ctx->IndirectTriangles & DD_SW_RASTERIZE) {
2365 gl_set_point_function(ctx);
2366 gl_set_line_function(ctx);
2367 gl_set_triangle_function(ctx);
2368 gl_set_quad_function(ctx);
2369
2370 if ((ctx->IndirectTriangles &
2371 (DD_TRI_SW_RASTERIZE|DD_QUAD_SW_RASTERIZE|DD_TRI_CULL)) ==
2372 (DD_TRI_SW_RASTERIZE|DD_QUAD_SW_RASTERIZE|DD_TRI_CULL))
2373 ctx->IndirectTriangles &= ~DD_TRI_CULL;
2374 }
2375
2376 if (MESA_VERBOSE&VERBOSE_CULL)
2377 gl_print_tri_caps("indirect tris 2", ctx->IndirectTriangles);
2378
2379 gl_set_render_vb_function(ctx);
2380 }
2381
2382 /* Should only be calc'd when !need_eye_coords and not culling.
2383 */
2384 if (ctx->NewState & (NEW_MODELVIEW|NEW_PROJECTION)) {
2385 if (ctx->NewState & NEW_MODELVIEW) {
2386 gl_matrix_analyze( &ctx->ModelView );
2387 ctx->ProjectionMatrix.flags &= ~MAT_DIRTY_DEPENDENTS;
2388 }
2389
2390 if (ctx->NewState & NEW_PROJECTION) {
2391 gl_matrix_analyze( &ctx->ProjectionMatrix );
2392 ctx->ProjectionMatrix.flags &= ~MAT_DIRTY_DEPENDENTS;
2393
2394 if (ctx->Transform.AnyClip) {
2395 gl_update_userclip( ctx );
2396 }
2397 }
2398
2399 gl_calculate_model_project_matrix( ctx );
2400 ctx->ModelProjectWinMatrixUptodate = 0;
2401 }
2402
2403 /* Figure out whether we can light in object space or not. If we
2404 * can, find the current positions of the lights in object space
2405 */
2406 if ((ctx->Enabled & (ENABLE_POINT_ATTEN | ENABLE_LIGHT | ENABLE_FOG |
2407 ENABLE_TEXGEN0 | ENABLE_TEXGEN1)) &&
2408 (ctx->NewState & (NEW_LIGHTING |
2409 NEW_FOG |
2410 NEW_MODELVIEW |
2411 NEW_PROJECTION |
2412 NEW_TEXTURING |
2413 NEW_RASTER_OPS |
2414 NEW_USER_CLIP)))
2415 {
2416 GLboolean oldcoord, oldnorm;
2417
2418 oldcoord = ctx->NeedEyeCoords;
2419 oldnorm = ctx->NeedEyeNormals;
2420
2421 ctx->NeedNormals = (ctx->Light.Enabled || ctx->Texture.NeedNormals);
2422 ctx->NeedEyeCoords = ((ctx->Fog.Enabled && ctx->Hint.Fog != GL_NICEST) ||
2423 ctx->Point.Attenuated);
2424 ctx->NeedEyeNormals = GL_FALSE;
2425
2426 if (ctx->Light.Enabled) {
2427 if (ctx->Light.Flags & LIGHT_POSITIONAL) {
2428 /* Need length for attenuation */
2429 if (!TEST_MAT_FLAGS( &ctx->ModelView, MAT_FLAGS_LENGTH_PRESERVING))
2430 ctx->NeedEyeCoords = GL_TRUE;
2431 } else if (ctx->Light.NeedVertices) {
2432 /* Need angle for spot calculations */
2433 if (!TEST_MAT_FLAGS( &ctx->ModelView, MAT_FLAGS_ANGLE_PRESERVING))
2434 ctx->NeedEyeCoords = GL_TRUE;
2435 }
2436 ctx->NeedEyeNormals = ctx->NeedEyeCoords;
2437 }
2438 if (ctx->Texture.Enabled || ctx->RenderMode==GL_FEEDBACK) {
2439 if (ctx->Texture.NeedEyeCoords) ctx->NeedEyeCoords = GL_TRUE;
2440 if (ctx->Texture.NeedNormals)
2441 ctx->NeedNormals = ctx->NeedEyeNormals = GL_TRUE;
2442 }
2443
2444 ctx->vb_proj_matrix = &ctx->ModelProjectMatrix;
2445
2446 if (ctx->NeedEyeCoords)
2447 ctx->vb_proj_matrix = &ctx->ProjectionMatrix;
2448
2449 if (ctx->Light.Enabled) {
2450 gl_update_lighting_function(ctx);
2451
2452 if ( (ctx->NewState & NEW_LIGHTING) ||
2453 ((ctx->NewState & (NEW_MODELVIEW| NEW_PROJECTION)) &&
2454 !ctx->NeedEyeCoords) ||
2455 oldcoord != ctx->NeedEyeCoords ||
2456 oldnorm != ctx->NeedEyeNormals) {
2457 gl_compute_light_positions(ctx);
2458 }
2459
2460 ctx->rescale_factor = 1.0F;
2461
2462 if (ctx->ModelView.flags & (MAT_FLAG_UNIFORM_SCALE |
2463 MAT_FLAG_GENERAL_SCALE |
2464 MAT_FLAG_GENERAL_3D |
2465 MAT_FLAG_GENERAL) )
2466
2467 {
2468 GLfloat *m = ctx->ModelView.inv;
2469 GLfloat f = m[2]*m[2] + m[6]*m[6] + m[10]*m[10];
2470 if (f > 1e-12 && (f-1)*(f-1) > 1e-12)
2471 ctx->rescale_factor = 1.0/GL_SQRT(f);
2472 }
2473 }
2474
2475 gl_update_normal_transform( ctx );
2476 }
2477
2478 finished:
2479 gl_update_pipelines(ctx);
2480 ctx->NewState = 0;
2481 }