Fix crash when debug output is enabled and sarea is notset in r200Clear
[mesa.git] / src / mesa / main / context.c
1 /*
2 * Mesa 3-D graphics library
3 * Version: 7.3
4 *
5 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
6 * Copyright (C) 2008 VMware, Inc. All Rights Reserved.
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 */
25
26 /**
27 * \file context.c
28 * Mesa context/visual/framebuffer management functions.
29 * \author Brian Paul
30 */
31
32 /**
33 * \mainpage Mesa Main Module
34 *
35 * \section MainIntroduction Introduction
36 *
37 * The Mesa Main module consists of all the files in the main/ directory.
38 * Among the features of this module are:
39 * <UL>
40 * <LI> Structures to represent most GL state </LI>
41 * <LI> State set/get functions </LI>
42 * <LI> Display lists </LI>
43 * <LI> Texture unit, object and image handling </LI>
44 * <LI> Matrix and attribute stacks </LI>
45 * </UL>
46 *
47 * Other modules are responsible for API dispatch, vertex transformation,
48 * point/line/triangle setup, rasterization, vertex array caching,
49 * vertex/fragment programs/shaders, etc.
50 *
51 *
52 * \section AboutDoxygen About Doxygen
53 *
54 * If you're viewing this information as Doxygen-generated HTML you'll
55 * see the documentation index at the top of this page.
56 *
57 * The first line lists the Mesa source code modules.
58 * The second line lists the indexes available for viewing the documentation
59 * for each module.
60 *
61 * Selecting the <b>Main page</b> link will display a summary of the module
62 * (this page).
63 *
64 * Selecting <b>Data Structures</b> will list all C structures.
65 *
66 * Selecting the <b>File List</b> link will list all the source files in
67 * the module.
68 * Selecting a filename will show a list of all functions defined in that file.
69 *
70 * Selecting the <b>Data Fields</b> link will display a list of all
71 * documented structure members.
72 *
73 * Selecting the <b>Globals</b> link will display a list
74 * of all functions, structures, global variables and macros in the module.
75 *
76 */
77
78
79 #include "glheader.h"
80 #include "mfeatures.h"
81 #include "imports.h"
82 #if FEATURE_accum
83 #include "accum.h"
84 #endif
85 #include "api_exec.h"
86 #include "arrayobj.h"
87 #if FEATURE_attrib_stack
88 #include "attrib.h"
89 #endif
90 #include "blend.h"
91 #include "buffers.h"
92 #include "bufferobj.h"
93 #if FEATURE_colortable
94 #include "colortab.h"
95 #endif
96 #include "context.h"
97 #include "cpuinfo.h"
98 #include "debug.h"
99 #include "depth.h"
100 #if FEATURE_dlist
101 #include "dlist.h"
102 #endif
103 #if FEATURE_evaluators
104 #include "eval.h"
105 #endif
106 #include "enums.h"
107 #include "extensions.h"
108 #include "fbobject.h"
109 #if FEATURE_feedback
110 #include "feedback.h"
111 #endif
112 #include "fog.h"
113 #include "framebuffer.h"
114 #include "get.h"
115 #if FEATURE_histogram
116 #include "histogram.h"
117 #endif
118 #include "hint.h"
119 #include "hash.h"
120 #include "light.h"
121 #include "lines.h"
122 #include "macros.h"
123 #include "matrix.h"
124 #include "multisample.h"
125 #include "pixel.h"
126 #include "pixelstore.h"
127 #include "points.h"
128 #include "polygon.h"
129 #if FEATURE_ARB_occlusion_query
130 #include "queryobj.h"
131 #endif
132 #if FEATURE_drawpix
133 #include "rastpos.h"
134 #endif
135 #include "scissor.h"
136 #include "shared.h"
137 #include "simple_list.h"
138 #include "state.h"
139 #include "stencil.h"
140 #include "texcompress.h"
141 #include "teximage.h"
142 #include "texobj.h"
143 #include "texstate.h"
144 #include "mtypes.h"
145 #include "varray.h"
146 #include "version.h"
147 #include "viewport.h"
148 #include "vtxfmt.h"
149 #include "glapi/glthread.h"
150 #include "glapi/glapioffsets.h"
151 #include "glapi/glapitable.h"
152 #include "shader/program.h"
153 #include "shader/shader_api.h"
154 #if FEATURE_ATI_fragment_shader
155 #include "shader/atifragshader.h"
156 #endif
157 #if _HAVE_FULL_GL
158 #include "math/m_matrix.h"
159 #endif
160
161 #ifdef USE_SPARC_ASM
162 #include "sparc/sparc.h"
163 #endif
164
165 #ifndef MESA_VERBOSE
166 int MESA_VERBOSE = 0;
167 #endif
168
169 #ifndef MESA_DEBUG_FLAGS
170 int MESA_DEBUG_FLAGS = 0;
171 #endif
172
173
174 /* ubyte -> float conversion */
175 GLfloat _mesa_ubyte_to_float_color_tab[256];
176
177
178
179 /**
180 * Swap buffers notification callback.
181 *
182 * \param ctx GL context.
183 *
184 * Called by window system just before swapping buffers.
185 * We have to finish any pending rendering.
186 */
187 void
188 _mesa_notifySwapBuffers(__GLcontext *ctx)
189 {
190 FLUSH_CURRENT( ctx, 0 );
191 if (ctx->Driver.Flush) {
192 ctx->Driver.Flush(ctx);
193 }
194 }
195
196
197 /**********************************************************************/
198 /** \name GL Visual allocation/destruction */
199 /**********************************************************************/
200 /*@{*/
201
202 /**
203 * Allocates a GLvisual structure and initializes it via
204 * _mesa_initialize_visual().
205 *
206 * \param rgbFlag GL_TRUE for RGB(A) mode, GL_FALSE for Color Index mode.
207 * \param dbFlag double buffering
208 * \param stereoFlag stereo buffer
209 * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
210 * is acceptable but the actual depth type will be GLushort or GLuint as
211 * needed.
212 * \param stencilBits requested minimum bits per stencil buffer value
213 * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.
214 * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
215 * \param redBits number of bits per color component in frame buffer for RGB(A)
216 * mode. We always use 8 in core Mesa though.
217 * \param greenBits same as above.
218 * \param blueBits same as above.
219 * \param alphaBits same as above.
220 * \param numSamples not really used.
221 *
222 * \return pointer to new GLvisual or NULL if requested parameters can't be
223 * met.
224 *
225 * \note Need to add params for level and numAuxBuffers (at least)
226 */
227 GLvisual *
228 _mesa_create_visual( GLboolean rgbFlag,
229 GLboolean dbFlag,
230 GLboolean stereoFlag,
231 GLint redBits,
232 GLint greenBits,
233 GLint blueBits,
234 GLint alphaBits,
235 GLint indexBits,
236 GLint depthBits,
237 GLint stencilBits,
238 GLint accumRedBits,
239 GLint accumGreenBits,
240 GLint accumBlueBits,
241 GLint accumAlphaBits,
242 GLint numSamples )
243 {
244 GLvisual *vis = (GLvisual *) _mesa_calloc(sizeof(GLvisual));
245 if (vis) {
246 if (!_mesa_initialize_visual(vis, rgbFlag, dbFlag, stereoFlag,
247 redBits, greenBits, blueBits, alphaBits,
248 indexBits, depthBits, stencilBits,
249 accumRedBits, accumGreenBits,
250 accumBlueBits, accumAlphaBits,
251 numSamples)) {
252 _mesa_free(vis);
253 return NULL;
254 }
255 }
256 return vis;
257 }
258
259 /**
260 * Makes some sanity checks and fills in the fields of the
261 * GLvisual object with the given parameters. If the caller needs
262 * to set additional fields, he should just probably init the whole GLvisual
263 * object himself.
264 * \return GL_TRUE on success, or GL_FALSE on failure.
265 *
266 * \sa _mesa_create_visual() above for the parameter description.
267 */
268 GLboolean
269 _mesa_initialize_visual( GLvisual *vis,
270 GLboolean rgbFlag,
271 GLboolean dbFlag,
272 GLboolean stereoFlag,
273 GLint redBits,
274 GLint greenBits,
275 GLint blueBits,
276 GLint alphaBits,
277 GLint indexBits,
278 GLint depthBits,
279 GLint stencilBits,
280 GLint accumRedBits,
281 GLint accumGreenBits,
282 GLint accumBlueBits,
283 GLint accumAlphaBits,
284 GLint numSamples )
285 {
286 assert(vis);
287
288 if (depthBits < 0 || depthBits > 32) {
289 return GL_FALSE;
290 }
291 if (stencilBits < 0 || stencilBits > STENCIL_BITS) {
292 return GL_FALSE;
293 }
294 assert(accumRedBits >= 0);
295 assert(accumGreenBits >= 0);
296 assert(accumBlueBits >= 0);
297 assert(accumAlphaBits >= 0);
298
299 vis->rgbMode = rgbFlag;
300 vis->doubleBufferMode = dbFlag;
301 vis->stereoMode = stereoFlag;
302
303 vis->redBits = redBits;
304 vis->greenBits = greenBits;
305 vis->blueBits = blueBits;
306 vis->alphaBits = alphaBits;
307 vis->rgbBits = redBits + greenBits + blueBits;
308
309 vis->indexBits = indexBits;
310 vis->depthBits = depthBits;
311 vis->stencilBits = stencilBits;
312
313 vis->accumRedBits = accumRedBits;
314 vis->accumGreenBits = accumGreenBits;
315 vis->accumBlueBits = accumBlueBits;
316 vis->accumAlphaBits = accumAlphaBits;
317
318 vis->haveAccumBuffer = accumRedBits > 0;
319 vis->haveDepthBuffer = depthBits > 0;
320 vis->haveStencilBuffer = stencilBits > 0;
321
322 vis->numAuxBuffers = 0;
323 vis->level = 0;
324 vis->pixmapMode = 0;
325 vis->sampleBuffers = numSamples > 0 ? 1 : 0;
326 vis->samples = numSamples;
327
328 return GL_TRUE;
329 }
330
331
332 /**
333 * Destroy a visual and free its memory.
334 *
335 * \param vis visual.
336 *
337 * Frees the visual structure.
338 */
339 void
340 _mesa_destroy_visual( GLvisual *vis )
341 {
342 _mesa_free(vis);
343 }
344
345 /*@}*/
346
347
348 /**********************************************************************/
349 /** \name Context allocation, initialization, destroying
350 *
351 * The purpose of the most initialization functions here is to provide the
352 * default state values according to the OpenGL specification.
353 */
354 /**********************************************************************/
355 /*@{*/
356
357
358 /**
359 * This is lame. gdb only seems to recognize enum types that are
360 * actually used somewhere. We want to be able to print/use enum
361 * values such as TEXTURE_2D_INDEX in gdb. But we don't actually use
362 * the gl_texture_index type anywhere. Thus, this lame function.
363 */
364 static void
365 dummy_enum_func(void)
366 {
367 gl_buffer_index bi;
368 gl_colortable_index ci;
369 gl_face_index fi;
370 gl_frag_attrib fa;
371 gl_frag_result fr;
372 gl_texture_index ti;
373 gl_vert_attrib va;
374 gl_vert_result vr;
375
376 (void) bi;
377 (void) ci;
378 (void) fi;
379 (void) fa;
380 (void) fr;
381 (void) ti;
382 (void) va;
383 (void) vr;
384 }
385
386
387 /**
388 * One-time initialization mutex lock.
389 *
390 * \sa Used by one_time_init().
391 */
392 _glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
393
394 /**
395 * Calls all the various one-time-init functions in Mesa.
396 *
397 * While holding a global mutex lock, calls several initialization functions,
398 * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
399 * defined.
400 *
401 * \sa _math_init().
402 */
403 static void
404 one_time_init( GLcontext *ctx )
405 {
406 static GLboolean alreadyCalled = GL_FALSE;
407 (void) ctx;
408 _glthread_LOCK_MUTEX(OneTimeLock);
409 if (!alreadyCalled) {
410 GLuint i;
411
412 /* do some implementation tests */
413 assert( sizeof(GLbyte) == 1 );
414 assert( sizeof(GLubyte) == 1 );
415 assert( sizeof(GLshort) == 2 );
416 assert( sizeof(GLushort) == 2 );
417 assert( sizeof(GLint) == 4 );
418 assert( sizeof(GLuint) == 4 );
419
420 _mesa_get_cpu_features();
421
422 _mesa_init_sqrt_table();
423
424 for (i = 0; i < 256; i++) {
425 _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
426 }
427
428 if (_mesa_getenv("MESA_DEBUG")) {
429 _glapi_noop_enable_warnings(GL_TRUE);
430 _glapi_set_warning_func( (_glapi_warning_func) _mesa_warning );
431 }
432 else {
433 _glapi_noop_enable_warnings(GL_FALSE);
434 }
435
436 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
437 _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
438 MESA_VERSION_STRING, __DATE__, __TIME__);
439 #endif
440
441 alreadyCalled = GL_TRUE;
442 }
443 _glthread_UNLOCK_MUTEX(OneTimeLock);
444
445 dummy_enum_func();
446 }
447
448
449 /**
450 * Initialize fields of gl_current_attrib (aka ctx->Current.*)
451 */
452 static void
453 _mesa_init_current(GLcontext *ctx)
454 {
455 GLuint i;
456
457 /* Init all to (0,0,0,1) */
458 for (i = 0; i < Elements(ctx->Current.Attrib); i++) {
459 ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
460 }
461
462 /* redo special cases: */
463 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );
464 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
465 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
466 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
467 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
468 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
469 }
470
471
472 /**
473 * Init vertex/fragment program limits.
474 * Important: drivers should override these with actual limits.
475 */
476 static void
477 init_program_limits(GLenum type, struct gl_program_constants *prog)
478 {
479 prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
480 prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
481 prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
482 prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
483 prog->MaxTemps = MAX_PROGRAM_TEMPS;
484 prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
485 prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
486 prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
487
488 if (type == GL_VERTEX_PROGRAM_ARB) {
489 prog->MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
490 prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
491 prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
492 }
493 else {
494 prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
495 prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
496 prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
497 }
498
499 /* copy the above limits to init native limits */
500 prog->MaxNativeInstructions = prog->MaxInstructions;
501 prog->MaxNativeAluInstructions = prog->MaxAluInstructions;
502 prog->MaxNativeTexInstructions = prog->MaxTexInstructions;
503 prog->MaxNativeTexIndirections = prog->MaxTexIndirections;
504 prog->MaxNativeAttribs = prog->MaxAttribs;
505 prog->MaxNativeTemps = prog->MaxTemps;
506 prog->MaxNativeAddressRegs = prog->MaxAddressRegs;
507 prog->MaxNativeParameters = prog->MaxParameters;
508 }
509
510
511 /**
512 * Initialize fields of gl_constants (aka ctx->Const.*).
513 * Use defaults from config.h. The device drivers will often override
514 * some of these values (such as number of texture units).
515 */
516 static void
517 _mesa_init_constants(GLcontext *ctx)
518 {
519 assert(ctx);
520
521 assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
522 assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
523
524 /* Max texture size should be <= max viewport size (render to texture) */
525 assert((1 << (MAX_TEXTURE_LEVELS - 1)) <= MAX_WIDTH);
526
527 /* Constants, may be overriden (usually only reduced) by device drivers */
528 ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
529 ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
530 ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
531 ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
532 ctx->Const.MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
533 ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
534 ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
535 ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,
536 ctx->Const.MaxTextureImageUnits);
537 ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
538 ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
539 ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
540 ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
541 ctx->Const.MinPointSize = MIN_POINT_SIZE;
542 ctx->Const.MaxPointSize = MAX_POINT_SIZE;
543 ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
544 ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
545 ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
546 ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
547 ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
548 ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
549 ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
550 ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
551 ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
552 ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
553 ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
554 ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
555 ctx->Const.MaxLights = MAX_LIGHTS;
556 ctx->Const.MaxShininess = 128.0;
557 ctx->Const.MaxSpotExponent = 128.0;
558 ctx->Const.MaxViewportWidth = MAX_WIDTH;
559 ctx->Const.MaxViewportHeight = MAX_HEIGHT;
560 #if FEATURE_ARB_vertex_program
561 init_program_limits(GL_VERTEX_PROGRAM_ARB, &ctx->Const.VertexProgram);
562 #endif
563 #if FEATURE_ARB_fragment_program
564 init_program_limits(GL_FRAGMENT_PROGRAM_ARB, &ctx->Const.FragmentProgram);
565 #endif
566 ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
567 ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
568
569 /* CheckArrayBounds is overriden by drivers/x11 for X server */
570 ctx->Const.CheckArrayBounds = GL_FALSE;
571
572 /* GL_ARB_draw_buffers */
573 ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
574
575 /* GL_OES_read_format */
576 ctx->Const.ColorReadFormat = GL_RGBA;
577 ctx->Const.ColorReadType = GL_UNSIGNED_BYTE;
578
579 #if FEATURE_EXT_framebuffer_object
580 ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
581 ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
582 #endif
583
584 #if FEATURE_ARB_vertex_shader
585 ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
586 ctx->Const.MaxVarying = MAX_VARYING;
587 #endif
588
589 /* GL_ARB_framebuffer_object */
590 ctx->Const.MaxSamples = 0;
591
592 /* GL_ATI_envmap_bumpmap */
593 ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS;
594
595 /* GL_EXT_provoking_vertex */
596 ctx->Const.QuadsFollowProvokingVertexConvention = GL_TRUE;
597
598 /* sanity checks */
599 ASSERT(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,
600 ctx->Const.MaxTextureCoordUnits));
601 ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
602 ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
603
604 ASSERT(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
605 ASSERT(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
606 ASSERT(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);
607 ASSERT(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);
608
609 /* check that we don't exceed various 32-bit bitfields */
610 ASSERT(VERT_RESULT_MAX <= 32);
611 ASSERT(FRAG_ATTRIB_MAX <= 32);
612 }
613
614
615 /**
616 * Do some sanity checks on the limits/constants for the given context.
617 * Only called the first time a context is bound.
618 */
619 static void
620 check_context_limits(GLcontext *ctx)
621 {
622 /* Many context limits/constants are limited by the size of
623 * internal arrays.
624 */
625 assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
626 assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
627 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
628 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
629
630 /* number of coord units cannot be greater than number of image units */
631 assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits);
632
633 assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
634 assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
635 assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
636 assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
637
638 /* make sure largest texture image is <= MAX_WIDTH in size */
639 assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= MAX_WIDTH);
640 assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= MAX_WIDTH);
641 assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= MAX_WIDTH);
642
643 assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);
644 assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);
645
646 assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
647
648 /* XXX probably add more tests */
649 }
650
651
652 /**
653 * Initialize the attribute groups in a GL context.
654 *
655 * \param ctx GL context.
656 *
657 * Initializes all the attributes, calling the respective <tt>init*</tt>
658 * functions for the more complex data structures.
659 */
660 static GLboolean
661 init_attrib_groups(GLcontext *ctx)
662 {
663 assert(ctx);
664
665 /* Constants */
666 _mesa_init_constants( ctx );
667
668 /* Extensions */
669 _mesa_init_extensions( ctx );
670
671 /* Attribute Groups */
672 #if FEATURE_accum
673 _mesa_init_accum( ctx );
674 #endif
675 #if FEATURE_attrib_stack
676 _mesa_init_attrib( ctx );
677 #endif
678 _mesa_init_buffer_objects( ctx );
679 _mesa_init_color( ctx );
680 #if FEATURE_colortable
681 _mesa_init_colortables( ctx );
682 #endif
683 _mesa_init_current( ctx );
684 _mesa_init_depth( ctx );
685 _mesa_init_debug( ctx );
686 #if FEATURE_dlist
687 _mesa_init_display_list( ctx );
688 #endif
689 #if FEATURE_evaluators
690 _mesa_init_eval( ctx );
691 #endif
692 _mesa_init_fbobjects( ctx );
693 #if FEATURE_feedback
694 _mesa_init_feedback( ctx );
695 #else
696 ctx->RenderMode = GL_RENDER;
697 #endif
698 _mesa_init_fog( ctx );
699 #if FEATURE_histogram
700 _mesa_init_histogram( ctx );
701 #endif
702 _mesa_init_hint( ctx );
703 _mesa_init_line( ctx );
704 _mesa_init_lighting( ctx );
705 _mesa_init_matrix( ctx );
706 _mesa_init_multisample( ctx );
707 _mesa_init_pixel( ctx );
708 _mesa_init_pixelstore( ctx );
709 _mesa_init_point( ctx );
710 _mesa_init_polygon( ctx );
711 _mesa_init_program( ctx );
712 #if FEATURE_ARB_occlusion_query
713 _mesa_init_query( ctx );
714 #endif
715 #if FEATURE_drawpix
716 _mesa_init_rastpos( ctx );
717 #endif
718 _mesa_init_scissor( ctx );
719 _mesa_init_shader_state( ctx );
720 _mesa_init_stencil( ctx );
721 _mesa_init_transform( ctx );
722 _mesa_init_varray( ctx );
723 _mesa_init_viewport( ctx );
724
725 if (!_mesa_init_texture( ctx ))
726 return GL_FALSE;
727
728 #if FEATURE_texture_s3tc
729 _mesa_init_texture_s3tc( ctx );
730 #endif
731 #if FEATURE_texture_fxt1
732 _mesa_init_texture_fxt1( ctx );
733 #endif
734
735 /* Miscellaneous */
736 ctx->NewState = _NEW_ALL;
737 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
738 ctx->varying_vp_inputs = ~0;
739
740 return GL_TRUE;
741 }
742
743
744 /**
745 * Update default objects in a GL context with respect to shared state.
746 *
747 * \param ctx GL context.
748 *
749 * Removes references to old default objects, (texture objects, program
750 * objects, etc.) and changes to reference those from the current shared
751 * state.
752 */
753 static GLboolean
754 update_default_objects(GLcontext *ctx)
755 {
756 assert(ctx);
757
758 _mesa_update_default_objects_program(ctx);
759 _mesa_update_default_objects_texture(ctx);
760 _mesa_update_default_objects_buffer_objects(ctx);
761
762 return GL_TRUE;
763 }
764
765
766 /**
767 * This is the default function we plug into all dispatch table slots
768 * This helps prevents a segfault when someone calls a GL function without
769 * first checking if the extension's supported.
770 */
771 static int
772 generic_nop(void)
773 {
774 _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)");
775 return 0;
776 }
777
778
779 /**
780 * Allocate and initialize a new dispatch table.
781 */
782 static struct _glapi_table *
783 alloc_dispatch_table(void)
784 {
785 /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
786 * In practice, this'll be the same for stand-alone Mesa. But for DRI
787 * Mesa we do this to accomodate different versions of libGL and various
788 * DRI drivers.
789 */
790 GLint numEntries = MAX2(_glapi_get_dispatch_table_size(),
791 sizeof(struct _glapi_table) / sizeof(_glapi_proc));
792 struct _glapi_table *table =
793 (struct _glapi_table *) _mesa_malloc(numEntries * sizeof(_glapi_proc));
794 if (table) {
795 _glapi_proc *entry = (_glapi_proc *) table;
796 GLint i;
797 for (i = 0; i < numEntries; i++) {
798 entry[i] = (_glapi_proc) generic_nop;
799 }
800 }
801 return table;
802 }
803
804
805 /**
806 * Initialize a GLcontext struct (rendering context).
807 *
808 * This includes allocating all the other structs and arrays which hang off of
809 * the context by pointers.
810 * Note that the driver needs to pass in its dd_function_table here since
811 * we need to at least call driverFunctions->NewTextureObject to create the
812 * default texture objects.
813 *
814 * Called by _mesa_create_context().
815 *
816 * Performs the imports and exports callback tables initialization, and
817 * miscellaneous one-time initializations. If no shared context is supplied one
818 * is allocated, and increase its reference count. Setups the GL API dispatch
819 * tables. Initialize the TNL module. Sets the maximum Z buffer depth.
820 * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
821 * for debug flags.
822 *
823 * \param ctx the context to initialize
824 * \param visual describes the visual attributes for this context
825 * \param share_list points to context to share textures, display lists,
826 * etc with, or NULL
827 * \param driverFunctions table of device driver functions for this context
828 * to use
829 * \param driverContext pointer to driver-specific context data
830 */
831 GLboolean
832 _mesa_initialize_context(GLcontext *ctx,
833 const GLvisual *visual,
834 GLcontext *share_list,
835 const struct dd_function_table *driverFunctions,
836 void *driverContext)
837 {
838 struct gl_shared_state *shared;
839
840 /*ASSERT(driverContext);*/
841 assert(driverFunctions->NewTextureObject);
842 assert(driverFunctions->FreeTexImageData);
843
844 /* misc one-time initializations */
845 one_time_init(ctx);
846
847 ctx->Visual = *visual;
848 ctx->DrawBuffer = NULL;
849 ctx->ReadBuffer = NULL;
850 ctx->WinSysDrawBuffer = NULL;
851 ctx->WinSysReadBuffer = NULL;
852
853 /* Plug in driver functions and context pointer here.
854 * This is important because when we call alloc_shared_state() below
855 * we'll call ctx->Driver.NewTextureObject() to create the default
856 * textures.
857 */
858 ctx->Driver = *driverFunctions;
859 ctx->DriverCtx = driverContext;
860
861 if (share_list) {
862 /* share state with another context */
863 shared = share_list->Shared;
864 }
865 else {
866 /* allocate new, unshared state */
867 shared = _mesa_alloc_shared_state(ctx);
868 if (!shared)
869 return GL_FALSE;
870 }
871
872 _glthread_LOCK_MUTEX(shared->Mutex);
873 ctx->Shared = shared;
874 shared->RefCount++;
875 _glthread_UNLOCK_MUTEX(shared->Mutex);
876
877 if (!init_attrib_groups( ctx )) {
878 _mesa_free_shared_state(ctx, ctx->Shared);
879 return GL_FALSE;
880 }
881
882 /* setup the API dispatch tables */
883 ctx->Exec = alloc_dispatch_table();
884 ctx->Save = alloc_dispatch_table();
885 if (!ctx->Exec || !ctx->Save) {
886 _mesa_free_shared_state(ctx, ctx->Shared);
887 if (ctx->Exec)
888 _mesa_free(ctx->Exec);
889 }
890 #if FEATURE_dispatch
891 _mesa_init_exec_table(ctx->Exec);
892 #endif
893 ctx->CurrentDispatch = ctx->Exec;
894 #if FEATURE_dlist
895 _mesa_init_dlist_table(ctx->Save);
896 _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
897 #endif
898 /* Neutral tnl module stuff */
899 _mesa_init_exec_vtxfmt( ctx );
900 ctx->TnlModule.Current = NULL;
901 ctx->TnlModule.SwapCount = 0;
902
903 ctx->FragmentProgram._MaintainTexEnvProgram
904 = (_mesa_getenv("MESA_TEX_PROG") != NULL);
905
906 ctx->VertexProgram._MaintainTnlProgram
907 = (_mesa_getenv("MESA_TNL_PROG") != NULL);
908 if (ctx->VertexProgram._MaintainTnlProgram) {
909 /* this is required... */
910 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
911 }
912
913 #ifdef FEATURE_extra_context_init
914 _mesa_initialize_context_extra(ctx);
915 #endif
916
917 ctx->FirstTimeCurrent = GL_TRUE;
918
919 return GL_TRUE;
920 }
921
922
923 /**
924 * Allocate and initialize a GLcontext structure.
925 * Note that the driver needs to pass in its dd_function_table here since
926 * we need to at least call driverFunctions->NewTextureObject to initialize
927 * the rendering context.
928 *
929 * \param visual a GLvisual pointer (we copy the struct contents)
930 * \param share_list another context to share display lists with or NULL
931 * \param driverFunctions points to the dd_function_table into which the
932 * driver has plugged in all its special functions.
933 * \param driverContext points to the device driver's private context state
934 *
935 * \return pointer to a new __GLcontextRec or NULL if error.
936 */
937 GLcontext *
938 _mesa_create_context(const GLvisual *visual,
939 GLcontext *share_list,
940 const struct dd_function_table *driverFunctions,
941 void *driverContext)
942 {
943 GLcontext *ctx;
944
945 ASSERT(visual);
946 /*ASSERT(driverContext);*/
947
948 ctx = (GLcontext *) _mesa_calloc(sizeof(GLcontext));
949 if (!ctx)
950 return NULL;
951
952 if (_mesa_initialize_context(ctx, visual, share_list,
953 driverFunctions, driverContext)) {
954 return ctx;
955 }
956 else {
957 _mesa_free(ctx);
958 return NULL;
959 }
960 }
961
962
963 /**
964 * Free the data associated with the given context.
965 *
966 * But doesn't free the GLcontext struct itself.
967 *
968 * \sa _mesa_initialize_context() and init_attrib_groups().
969 */
970 void
971 _mesa_free_context_data( GLcontext *ctx )
972 {
973 GLint RefCount;
974
975 if (!_mesa_get_current_context()){
976 /* No current context, but we may need one in order to delete
977 * texture objs, etc. So temporarily bind the context now.
978 */
979 _mesa_make_current(ctx, NULL, NULL);
980 }
981
982 /* unreference WinSysDraw/Read buffers */
983 _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
984 _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
985 _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
986 _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
987
988 _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
989 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
990 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL);
991
992 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
993 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
994 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
995
996 #if FEATURE_attrib_stack
997 _mesa_free_attrib_data(ctx);
998 #endif
999 _mesa_free_lighting_data( ctx );
1000 #if FEATURE_evaluators
1001 _mesa_free_eval_data( ctx );
1002 #endif
1003 _mesa_free_texture_data( ctx );
1004 _mesa_free_matrix_data( ctx );
1005 _mesa_free_viewport_data( ctx );
1006 #if FEATURE_colortable
1007 _mesa_free_colortables_data( ctx );
1008 #endif
1009 _mesa_free_program_data(ctx);
1010 _mesa_free_shader_state(ctx);
1011 #if FEATURE_ARB_occlusion_query
1012 _mesa_free_query_data(ctx);
1013 #endif
1014
1015 _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);
1016
1017 #if FEATURE_ARB_pixel_buffer_object
1018 _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
1019 _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
1020 #endif
1021
1022 #if FEATURE_ARB_vertex_buffer_object
1023 _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
1024 _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);
1025 #endif
1026
1027 /* free dispatch tables */
1028 _mesa_free(ctx->Exec);
1029 _mesa_free(ctx->Save);
1030
1031 /* Shared context state (display lists, textures, etc) */
1032 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1033 RefCount = --ctx->Shared->RefCount;
1034 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1035 assert(RefCount >= 0);
1036 if (RefCount == 0) {
1037 /* free shared state */
1038 _mesa_free_shared_state( ctx, ctx->Shared );
1039 }
1040
1041 if (ctx->Extensions.String)
1042 _mesa_free((void *) ctx->Extensions.String);
1043
1044 /* unbind the context if it's currently bound */
1045 if (ctx == _mesa_get_current_context()) {
1046 _mesa_make_current(NULL, NULL, NULL);
1047 }
1048 }
1049
1050
1051 /**
1052 * Destroy a GLcontext structure.
1053 *
1054 * \param ctx GL context.
1055 *
1056 * Calls _mesa_free_context_data() and frees the GLcontext structure itself.
1057 */
1058 void
1059 _mesa_destroy_context( GLcontext *ctx )
1060 {
1061 if (ctx) {
1062 _mesa_free_context_data(ctx);
1063 _mesa_free( (void *) ctx );
1064 }
1065 }
1066
1067
1068 #if _HAVE_FULL_GL
1069 /**
1070 * Copy attribute groups from one context to another.
1071 *
1072 * \param src source context
1073 * \param dst destination context
1074 * \param mask bitwise OR of GL_*_BIT flags
1075 *
1076 * According to the bits specified in \p mask, copies the corresponding
1077 * attributes from \p src into \p dst. For many of the attributes a simple \c
1078 * memcpy is not enough due to the existence of internal pointers in their data
1079 * structures.
1080 */
1081 void
1082 _mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1083 {
1084 if (mask & GL_ACCUM_BUFFER_BIT) {
1085 /* OK to memcpy */
1086 dst->Accum = src->Accum;
1087 }
1088 if (mask & GL_COLOR_BUFFER_BIT) {
1089 /* OK to memcpy */
1090 dst->Color = src->Color;
1091 }
1092 if (mask & GL_CURRENT_BIT) {
1093 /* OK to memcpy */
1094 dst->Current = src->Current;
1095 }
1096 if (mask & GL_DEPTH_BUFFER_BIT) {
1097 /* OK to memcpy */
1098 dst->Depth = src->Depth;
1099 }
1100 if (mask & GL_ENABLE_BIT) {
1101 /* no op */
1102 }
1103 if (mask & GL_EVAL_BIT) {
1104 /* OK to memcpy */
1105 dst->Eval = src->Eval;
1106 }
1107 if (mask & GL_FOG_BIT) {
1108 /* OK to memcpy */
1109 dst->Fog = src->Fog;
1110 }
1111 if (mask & GL_HINT_BIT) {
1112 /* OK to memcpy */
1113 dst->Hint = src->Hint;
1114 }
1115 if (mask & GL_LIGHTING_BIT) {
1116 GLuint i;
1117 /* begin with memcpy */
1118 dst->Light = src->Light;
1119 /* fixup linked lists to prevent pointer insanity */
1120 make_empty_list( &(dst->Light.EnabledList) );
1121 for (i = 0; i < MAX_LIGHTS; i++) {
1122 if (dst->Light.Light[i].Enabled) {
1123 insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
1124 }
1125 }
1126 }
1127 if (mask & GL_LINE_BIT) {
1128 /* OK to memcpy */
1129 dst->Line = src->Line;
1130 }
1131 if (mask & GL_LIST_BIT) {
1132 /* OK to memcpy */
1133 dst->List = src->List;
1134 }
1135 if (mask & GL_PIXEL_MODE_BIT) {
1136 /* OK to memcpy */
1137 dst->Pixel = src->Pixel;
1138 }
1139 if (mask & GL_POINT_BIT) {
1140 /* OK to memcpy */
1141 dst->Point = src->Point;
1142 }
1143 if (mask & GL_POLYGON_BIT) {
1144 /* OK to memcpy */
1145 dst->Polygon = src->Polygon;
1146 }
1147 if (mask & GL_POLYGON_STIPPLE_BIT) {
1148 /* Use loop instead of MEMCPY due to problem with Portland Group's
1149 * C compiler. Reported by John Stone.
1150 */
1151 GLuint i;
1152 for (i = 0; i < 32; i++) {
1153 dst->PolygonStipple[i] = src->PolygonStipple[i];
1154 }
1155 }
1156 if (mask & GL_SCISSOR_BIT) {
1157 /* OK to memcpy */
1158 dst->Scissor = src->Scissor;
1159 }
1160 if (mask & GL_STENCIL_BUFFER_BIT) {
1161 /* OK to memcpy */
1162 dst->Stencil = src->Stencil;
1163 }
1164 if (mask & GL_TEXTURE_BIT) {
1165 /* Cannot memcpy because of pointers */
1166 _mesa_copy_texture_state(src, dst);
1167 }
1168 if (mask & GL_TRANSFORM_BIT) {
1169 /* OK to memcpy */
1170 dst->Transform = src->Transform;
1171 }
1172 if (mask & GL_VIEWPORT_BIT) {
1173 /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
1174 dst->Viewport.X = src->Viewport.X;
1175 dst->Viewport.Y = src->Viewport.Y;
1176 dst->Viewport.Width = src->Viewport.Width;
1177 dst->Viewport.Height = src->Viewport.Height;
1178 dst->Viewport.Near = src->Viewport.Near;
1179 dst->Viewport.Far = src->Viewport.Far;
1180 _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
1181 }
1182
1183 /* XXX FIXME: Call callbacks?
1184 */
1185 dst->NewState = _NEW_ALL;
1186 }
1187 #endif
1188
1189
1190 /**
1191 * Check if the given context can render into the given framebuffer
1192 * by checking visual attributes.
1193 *
1194 * Most of these tests could go away because Mesa is now pretty flexible
1195 * in terms of mixing rendering contexts with framebuffers. As long
1196 * as RGB vs. CI mode agree, we're probably good.
1197 *
1198 * \return GL_TRUE if compatible, GL_FALSE otherwise.
1199 */
1200 static GLboolean
1201 check_compatible(const GLcontext *ctx, const GLframebuffer *buffer)
1202 {
1203 const GLvisual *ctxvis = &ctx->Visual;
1204 const GLvisual *bufvis = &buffer->Visual;
1205
1206 if (ctxvis == bufvis)
1207 return GL_TRUE;
1208
1209 if (ctxvis->rgbMode != bufvis->rgbMode)
1210 return GL_FALSE;
1211 #if 0
1212 /* disabling this fixes the fgl_glxgears pbuffer demo */
1213 if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
1214 return GL_FALSE;
1215 #endif
1216 if (ctxvis->stereoMode && !bufvis->stereoMode)
1217 return GL_FALSE;
1218 if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
1219 return GL_FALSE;
1220 if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
1221 return GL_FALSE;
1222 if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
1223 return GL_FALSE;
1224 if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
1225 return GL_FALSE;
1226 if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
1227 return GL_FALSE;
1228 if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
1229 return GL_FALSE;
1230 #if 0
1231 /* disabled (see bug 11161) */
1232 if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
1233 return GL_FALSE;
1234 #endif
1235 if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
1236 return GL_FALSE;
1237
1238 return GL_TRUE;
1239 }
1240
1241
1242 /**
1243 * Do one-time initialization for the given framebuffer. Specifically,
1244 * ask the driver for the window's current size and update the framebuffer
1245 * object to match.
1246 * Really, the device driver should totally take care of this.
1247 */
1248 static void
1249 initialize_framebuffer_size(GLcontext *ctx, GLframebuffer *fb)
1250 {
1251 GLuint width, height;
1252 if (ctx->Driver.GetBufferSize) {
1253 ctx->Driver.GetBufferSize(fb, &width, &height);
1254 if (ctx->Driver.ResizeBuffers)
1255 ctx->Driver.ResizeBuffers(ctx, fb, width, height);
1256 fb->Initialized = GL_TRUE;
1257 }
1258 }
1259
1260
1261 /**
1262 * Bind the given context to the given drawBuffer and readBuffer and
1263 * make it the current context for the calling thread.
1264 * We'll render into the drawBuffer and read pixels from the
1265 * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1266 *
1267 * We check that the context's and framebuffer's visuals are compatible
1268 * and return immediately if they're not.
1269 *
1270 * \param newCtx the new GL context. If NULL then there will be no current GL
1271 * context.
1272 * \param drawBuffer the drawing framebuffer
1273 * \param readBuffer the reading framebuffer
1274 */
1275 GLboolean
1276 _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
1277 GLframebuffer *readBuffer )
1278 {
1279 if (MESA_VERBOSE & VERBOSE_API)
1280 _mesa_debug(newCtx, "_mesa_make_current()\n");
1281
1282 /* Check that the context's and framebuffer's visuals are compatible.
1283 */
1284 if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1285 if (!check_compatible(newCtx, drawBuffer)) {
1286 _mesa_warning(newCtx,
1287 "MakeCurrent: incompatible visuals for context and drawbuffer");
1288 return GL_FALSE;
1289 }
1290 }
1291 if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1292 if (!check_compatible(newCtx, readBuffer)) {
1293 _mesa_warning(newCtx,
1294 "MakeCurrent: incompatible visuals for context and readbuffer");
1295 return GL_FALSE;
1296 }
1297 }
1298
1299 /* We used to call _glapi_check_multithread() here. Now do it in drivers */
1300 _glapi_set_context((void *) newCtx);
1301 ASSERT(_mesa_get_current_context() == newCtx);
1302
1303 if (!newCtx) {
1304 _glapi_set_dispatch(NULL); /* none current */
1305 }
1306 else {
1307 _glapi_set_dispatch(newCtx->CurrentDispatch);
1308
1309 if (drawBuffer && readBuffer) {
1310 /* TODO: check if newCtx and buffer's visual match??? */
1311
1312 ASSERT(drawBuffer->Name == 0);
1313 ASSERT(readBuffer->Name == 0);
1314 _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1315 _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1316
1317 /*
1318 * Only set the context's Draw/ReadBuffer fields if they're NULL
1319 * or not bound to a user-created FBO.
1320 */
1321 if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
1322 /* KW: merge conflict here, revisit.
1323 */
1324 /* fix up the fb fields - these will end up wrong otherwise
1325 * if the DRIdrawable changes, and everything relies on them.
1326 * This is a bit messy (same as needed in _mesa_BindFramebufferEXT)
1327 */
1328 unsigned int i;
1329 GLenum buffers[MAX_DRAW_BUFFERS];
1330
1331 _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1332
1333 for(i = 0; i < newCtx->Const.MaxDrawBuffers; i++) {
1334 buffers[i] = newCtx->Color.DrawBuffer[i];
1335 }
1336
1337 _mesa_drawbuffers(newCtx, newCtx->Const.MaxDrawBuffers, buffers, NULL);
1338 }
1339 if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {
1340 _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1341 }
1342
1343 /* XXX only set this flag if we're really changing the draw/read
1344 * framebuffer bindings.
1345 */
1346 newCtx->NewState |= _NEW_BUFFERS;
1347
1348 #if 1
1349 /* We want to get rid of these lines: */
1350
1351 #if _HAVE_FULL_GL
1352 if (!drawBuffer->Initialized) {
1353 initialize_framebuffer_size(newCtx, drawBuffer);
1354 }
1355 if (readBuffer != drawBuffer && !readBuffer->Initialized) {
1356 initialize_framebuffer_size(newCtx, readBuffer);
1357 }
1358
1359 _mesa_resizebuffers(newCtx);
1360 #endif
1361
1362 #else
1363 /* We want the drawBuffer and readBuffer to be initialized by
1364 * the driver.
1365 * This generally means the Width and Height match the actual
1366 * window size and the renderbuffers (both hardware and software
1367 * based) are allocated to match. The later can generally be
1368 * done with a call to _mesa_resize_framebuffer().
1369 *
1370 * It's theoretically possible for a buffer to have zero width
1371 * or height, but for now, assert check that the driver did what's
1372 * expected of it.
1373 */
1374 ASSERT(drawBuffer->Width > 0);
1375 ASSERT(drawBuffer->Height > 0);
1376 #endif
1377
1378 if (newCtx->FirstTimeCurrent) {
1379 /* set initial viewport and scissor size now */
1380 _mesa_set_viewport(newCtx, 0, 0,
1381 drawBuffer->Width, drawBuffer->Height);
1382 _mesa_set_scissor(newCtx, 0, 0,
1383 drawBuffer->Width, drawBuffer->Height );
1384 check_context_limits(newCtx);
1385 }
1386 }
1387
1388 /* We can use this to help debug user's problems. Tell them to set
1389 * the MESA_INFO env variable before running their app. Then the
1390 * first time each context is made current we'll print some useful
1391 * information.
1392 */
1393 if (newCtx->FirstTimeCurrent) {
1394 if (_mesa_getenv("MESA_INFO")) {
1395 _mesa_print_info();
1396 }
1397 newCtx->FirstTimeCurrent = GL_FALSE;
1398 }
1399 }
1400
1401 return GL_TRUE;
1402 }
1403
1404
1405 /**
1406 * Make context 'ctx' share the display lists, textures and programs
1407 * that are associated with 'ctxToShare'.
1408 * Any display lists, textures or programs associated with 'ctx' will
1409 * be deleted if nobody else is sharing them.
1410 */
1411 GLboolean
1412 _mesa_share_state(GLcontext *ctx, GLcontext *ctxToShare)
1413 {
1414 if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1415 struct gl_shared_state *oldSharedState = ctx->Shared;
1416 GLint RefCount;
1417
1418 ctx->Shared = ctxToShare->Shared;
1419
1420 _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1421 ctx->Shared->RefCount++;
1422 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1423
1424 update_default_objects(ctx);
1425
1426 _glthread_LOCK_MUTEX(oldSharedState->Mutex);
1427 RefCount = --oldSharedState->RefCount;
1428 _glthread_UNLOCK_MUTEX(oldSharedState->Mutex);
1429
1430 if (RefCount == 0) {
1431 _mesa_free_shared_state(ctx, oldSharedState);
1432 }
1433
1434 return GL_TRUE;
1435 }
1436 else {
1437 return GL_FALSE;
1438 }
1439 }
1440
1441
1442
1443 /**
1444 * \return pointer to the current GL context for this thread.
1445 *
1446 * Calls _glapi_get_context(). This isn't the fastest way to get the current
1447 * context. If you need speed, see the #GET_CURRENT_CONTEXT macro in
1448 * context.h.
1449 */
1450 GLcontext *
1451 _mesa_get_current_context( void )
1452 {
1453 return (GLcontext *) _glapi_get_context();
1454 }
1455
1456
1457 /**
1458 * Get context's current API dispatch table.
1459 *
1460 * It'll either be the immediate-mode execute dispatcher or the display list
1461 * compile dispatcher.
1462 *
1463 * \param ctx GL context.
1464 *
1465 * \return pointer to dispatch_table.
1466 *
1467 * Simply returns __GLcontextRec::CurrentDispatch.
1468 */
1469 struct _glapi_table *
1470 _mesa_get_dispatch(GLcontext *ctx)
1471 {
1472 return ctx->CurrentDispatch;
1473 }
1474
1475 /*@}*/
1476
1477
1478 /**********************************************************************/
1479 /** \name Miscellaneous functions */
1480 /**********************************************************************/
1481 /*@{*/
1482
1483 /**
1484 * Record an error.
1485 *
1486 * \param ctx GL context.
1487 * \param error error code.
1488 *
1489 * Records the given error code and call the driver's dd_function_table::Error
1490 * function if defined.
1491 *
1492 * \sa
1493 * This is called via _mesa_error().
1494 */
1495 void
1496 _mesa_record_error(GLcontext *ctx, GLenum error)
1497 {
1498 if (!ctx)
1499 return;
1500
1501 if (ctx->ErrorValue == GL_NO_ERROR) {
1502 ctx->ErrorValue = error;
1503 }
1504
1505 /* Call device driver's error handler, if any. This is used on the Mac. */
1506 if (ctx->Driver.Error) {
1507 ctx->Driver.Error(ctx);
1508 }
1509 }
1510
1511
1512 /**
1513 * Execute glFinish().
1514 *
1515 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1516 * dd_function_table::Finish driver callback, if not NULL.
1517 */
1518 void GLAPIENTRY
1519 _mesa_Finish(void)
1520 {
1521 GET_CURRENT_CONTEXT(ctx);
1522 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1523 FLUSH_CURRENT( ctx, 0 );
1524 if (ctx->Driver.Finish) {
1525 ctx->Driver.Finish(ctx);
1526 }
1527 }
1528
1529
1530 /**
1531 * Execute glFlush().
1532 *
1533 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1534 * dd_function_table::Flush driver callback, if not NULL.
1535 */
1536 void GLAPIENTRY
1537 _mesa_Flush(void)
1538 {
1539 GET_CURRENT_CONTEXT(ctx);
1540 ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1541 FLUSH_CURRENT( ctx, 0 );
1542 if (ctx->Driver.Flush) {
1543 ctx->Driver.Flush(ctx);
1544 }
1545 }
1546
1547
1548 /**
1549 * Set mvp_with_dp4 flag. If a driver has a preference for DP4 over
1550 * MUL/MAD, or vice versa, call this function to register that.
1551 * Otherwise we default to MUL/MAD.
1552 */
1553 void
1554 _mesa_set_mvp_with_dp4( GLcontext *ctx,
1555 GLboolean flag )
1556 {
1557 ctx->mvp_with_dp4 = flag;
1558 }
1559
1560
1561 /*@}*/