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