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 "context.h"
90 #include "cpuinfo.h"
91 #include "debug.h"
92 #include "depth.h"
93 #include "dlist.h"
94 #include "eval.h"
95 #include "extensions.h"
96 #include "fbobject.h"
97 #include "feedback.h"
98 #include "fog.h"
99 #include "formats.h"
100 #include "framebuffer.h"
101 #include "hint.h"
102 #include "hash.h"
103 #include "light.h"
104 #include "lines.h"
105 #include "macros.h"
106 #include "matrix.h"
107 #include "multisample.h"
108 #include "pixel.h"
109 #include "pixelstore.h"
110 #include "points.h"
111 #include "polygon.h"
112 #include "queryobj.h"
113 #include "syncobj.h"
114 #include "rastpos.h"
115 #include "remap.h"
116 #include "scissor.h"
117 #include "shared.h"
118 #include "shaderobj.h"
119 #include "simple_list.h"
120 #include "state.h"
121 #include "stencil.h"
122 #include "texcompress_s3tc.h"
123 #include "texstate.h"
124 #include "transformfeedback.h"
125 #include "mtypes.h"
126 #include "varray.h"
127 #include "version.h"
128 #include "viewport.h"
129 #include "vtxfmt.h"
130 #include "program/program.h"
131 #include "program/prog_print.h"
132 #if _HAVE_FULL_GL
133 #include "math/m_matrix.h"
134 #endif
135 #include "main/dispatch.h" /* for _gloffset_COUNT */
136
137 #ifdef USE_SPARC_ASM
138 #include "sparc/sparc.h"
139 #endif
140
141 #include "glsl_parser_extras.h"
142 #include <stdbool.h>
143
144
145 #ifndef MESA_VERBOSE
146 int MESA_VERBOSE = 0;
147 #endif
148
149 #ifndef MESA_DEBUG_FLAGS
150 int MESA_DEBUG_FLAGS = 0;
151 #endif
152
153
154 /* ubyte -> float conversion */
155 GLfloat _mesa_ubyte_to_float_color_tab[256];
156
157
158
159 /**
160 * Swap buffers notification callback.
161 *
162 * \param ctx GL context.
163 *
164 * Called by window system just before swapping buffers.
165 * We have to finish any pending rendering.
166 */
167 void
_mesa_notifySwapBuffers(struct gl_context * ctx)168 _mesa_notifySwapBuffers(struct gl_context *ctx)
169 {
170 if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)
171 _mesa_debug(ctx, "SwapBuffers\n");
172 FLUSH_CURRENT( ctx, 0 );
173 if (ctx->Driver.Flush) {
174 ctx->Driver.Flush(ctx);
175 }
176 }
177
178
179 /**********************************************************************/
180 /** \name GL Visual allocation/destruction */
181 /**********************************************************************/
182 /*@{*/
183
184 /**
185 * Allocates a struct gl_config structure and initializes it via
186 * _mesa_initialize_visual().
187 *
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
195 * of bits per color component in accum buffer.
196 * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
197 * \param redBits number of bits per color component in frame buffer for RGB(A)
198 * mode. We always use 8 in core Mesa though.
199 * \param greenBits same as above.
200 * \param blueBits same as above.
201 * \param alphaBits same as above.
202 * \param numSamples not really used.
203 *
204 * \return pointer to new struct gl_config or NULL if requested parameters
205 * can't be met.
206 *
207 * \note Need to add params for level and numAuxBuffers (at least)
208 */
209 struct gl_config *
_mesa_create_visual(GLboolean dbFlag,GLboolean stereoFlag,GLint redBits,GLint greenBits,GLint blueBits,GLint alphaBits,GLint depthBits,GLint stencilBits,GLint accumRedBits,GLint accumGreenBits,GLint accumBlueBits,GLint accumAlphaBits,GLint numSamples)210 _mesa_create_visual( GLboolean dbFlag,
211 GLboolean stereoFlag,
212 GLint redBits,
213 GLint greenBits,
214 GLint blueBits,
215 GLint alphaBits,
216 GLint depthBits,
217 GLint stencilBits,
218 GLint accumRedBits,
219 GLint accumGreenBits,
220 GLint accumBlueBits,
221 GLint accumAlphaBits,
222 GLint numSamples )
223 {
224 struct gl_config *vis = CALLOC_STRUCT(gl_config);
225 if (vis) {
226 if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,
227 redBits, greenBits, blueBits, alphaBits,
228 depthBits, stencilBits,
229 accumRedBits, accumGreenBits,
230 accumBlueBits, accumAlphaBits,
231 numSamples)) {
232 free(vis);
233 return NULL;
234 }
235 }
236 return vis;
237 }
238
239
240 /**
241 * Makes some sanity checks and fills in the fields of the struct
242 * gl_config object with the given parameters. If the caller needs to
243 * set additional fields, he should just probably init the whole
244 * gl_config object himself.
245 *
246 * \return GL_TRUE on success, or GL_FALSE on failure.
247 *
248 * \sa _mesa_create_visual() above for the parameter description.
249 */
250 GLboolean
_mesa_initialize_visual(struct gl_config * vis,GLboolean dbFlag,GLboolean stereoFlag,GLint redBits,GLint greenBits,GLint blueBits,GLint alphaBits,GLint depthBits,GLint stencilBits,GLint accumRedBits,GLint accumGreenBits,GLint accumBlueBits,GLint accumAlphaBits,GLint numSamples)251 _mesa_initialize_visual( struct gl_config *vis,
252 GLboolean dbFlag,
253 GLboolean stereoFlag,
254 GLint redBits,
255 GLint greenBits,
256 GLint blueBits,
257 GLint alphaBits,
258 GLint depthBits,
259 GLint stencilBits,
260 GLint accumRedBits,
261 GLint accumGreenBits,
262 GLint accumBlueBits,
263 GLint accumAlphaBits,
264 GLint numSamples )
265 {
266 assert(vis);
267
268 if (depthBits < 0 || depthBits > 32) {
269 return GL_FALSE;
270 }
271 if (stencilBits < 0 || stencilBits > 8) {
272 return GL_FALSE;
273 }
274 assert(accumRedBits >= 0);
275 assert(accumGreenBits >= 0);
276 assert(accumBlueBits >= 0);
277 assert(accumAlphaBits >= 0);
278
279 vis->rgbMode = GL_TRUE;
280 vis->doubleBufferMode = dbFlag;
281 vis->stereoMode = stereoFlag;
282
283 vis->redBits = redBits;
284 vis->greenBits = greenBits;
285 vis->blueBits = blueBits;
286 vis->alphaBits = alphaBits;
287 vis->rgbBits = redBits + greenBits + blueBits;
288
289 vis->indexBits = 0;
290 vis->depthBits = depthBits;
291 vis->stencilBits = stencilBits;
292
293 vis->accumRedBits = accumRedBits;
294 vis->accumGreenBits = accumGreenBits;
295 vis->accumBlueBits = accumBlueBits;
296 vis->accumAlphaBits = accumAlphaBits;
297
298 vis->haveAccumBuffer = accumRedBits > 0;
299 vis->haveDepthBuffer = depthBits > 0;
300 vis->haveStencilBuffer = stencilBits > 0;
301
302 vis->numAuxBuffers = 0;
303 vis->level = 0;
304 vis->sampleBuffers = numSamples > 0 ? 1 : 0;
305 vis->samples = numSamples;
306
307 return GL_TRUE;
308 }
309
310
311 /**
312 * Destroy a visual and free its memory.
313 *
314 * \param vis visual.
315 *
316 * Frees the visual structure.
317 */
318 void
_mesa_destroy_visual(struct gl_config * vis)319 _mesa_destroy_visual( struct gl_config *vis )
320 {
321 free(vis);
322 }
323
324 /*@}*/
325
326
327 /**********************************************************************/
328 /** \name Context allocation, initialization, destroying
329 *
330 * The purpose of the most initialization functions here is to provide the
331 * default state values according to the OpenGL specification.
332 */
333 /**********************************************************************/
334 /*@{*/
335
336
337 /**
338 * This is lame. gdb only seems to recognize enum types that are
339 * actually used somewhere. We want to be able to print/use enum
340 * values such as TEXTURE_2D_INDEX in gdb. But we don't actually use
341 * the gl_texture_index type anywhere. Thus, this lame function.
342 */
343 static void
dummy_enum_func(void)344 dummy_enum_func(void)
345 {
346 gl_buffer_index bi = BUFFER_FRONT_LEFT;
347 gl_face_index fi = FACE_POS_X;
348 gl_frag_attrib fa = FRAG_ATTRIB_WPOS;
349 gl_frag_result fr = FRAG_RESULT_DEPTH;
350 gl_texture_index ti = TEXTURE_2D_ARRAY_INDEX;
351 gl_vert_attrib va = VERT_ATTRIB_POS;
352 gl_vert_result vr = VERT_RESULT_HPOS;
353 gl_geom_attrib ga = GEOM_ATTRIB_POSITION;
354 gl_geom_result gr = GEOM_RESULT_POS;
355
356 (void) bi;
357 (void) fi;
358 (void) fa;
359 (void) fr;
360 (void) ti;
361 (void) va;
362 (void) vr;
363 (void) ga;
364 (void) gr;
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
377 /**
378 * Calls all the various one-time-init functions in Mesa.
379 *
380 * While holding a global mutex lock, calls several initialization functions,
381 * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
382 * defined.
383 *
384 * \sa _math_init().
385 */
386 static void
one_time_init(struct gl_context * ctx)387 one_time_init( struct gl_context *ctx )
388 {
389 static GLbitfield api_init_mask = 0x0;
390
391 _glthread_LOCK_MUTEX(OneTimeLock);
392
393 /* truly one-time init */
394 if (!api_init_mask) {
395 GLuint i;
396
397 /* do some implementation tests */
398 assert( sizeof(GLbyte) == 1 );
399 assert( sizeof(GLubyte) == 1 );
400 assert( sizeof(GLshort) == 2 );
401 assert( sizeof(GLushort) == 2 );
402 assert( sizeof(GLint) == 4 );
403 assert( sizeof(GLuint) == 4 );
404
405 _mesa_get_cpu_features();
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 if (MESA_VERBOSE != 0) {
413 _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
414 MESA_VERSION_STRING, __DATE__, __TIME__);
415 }
416 #endif
417
418 #ifdef DEBUG
419 _mesa_test_formats();
420 #endif
421 }
422
423 /* per-API one-time init */
424 if (!(api_init_mask & (1 << ctx->API))) {
425 _mesa_init_get_hash(ctx);
426
427 /*
428 * This is fine as ES does not use the remap table, but it may not be
429 * future-proof. We cannot always initialize the remap table because
430 * when an app is linked to libGLES*, there are not enough dynamic
431 * entries.
432 */
433 if (_mesa_is_desktop_gl(ctx) || ctx->API == API_OPENGLES2)
434 _mesa_init_remap_table();
435 }
436
437 api_init_mask |= 1 << ctx->API;
438
439 _glthread_UNLOCK_MUTEX(OneTimeLock);
440
441 /* Hopefully atexit() is widely available. If not, we may need some
442 * #ifdef tests here.
443 */
444 atexit(_mesa_destroy_shader_compiler);
445
446 dummy_enum_func();
447 }
448
449
450 /**
451 * Initialize fields of gl_current_attrib (aka ctx->Current.*)
452 */
453 static void
_mesa_init_current(struct gl_context * ctx)454 _mesa_init_current(struct gl_context *ctx)
455 {
456 GLuint i;
457
458 /* Init all to (0,0,0,1) */
459 for (i = 0; i < Elements(ctx->Current.Attrib); i++) {
460 ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
461 }
462
463 /* redo special cases: */
464 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );
465 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
466 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
467 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
468 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
469 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
470 }
471
472
473 /**
474 * Init vertex/fragment/geometry program limits.
475 * Important: drivers should override these with actual limits.
476 */
477 static void
init_program_limits(struct gl_context * ctx,GLenum type,struct gl_program_constants * prog)478 init_program_limits(struct gl_context *ctx, GLenum type,
479 struct gl_program_constants *prog)
480 {
481 prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
482 prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
483 prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
484 prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
485 prog->MaxTemps = MAX_PROGRAM_TEMPS;
486 prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
487 prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
488 prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS;
489
490 switch (type) {
491 case GL_VERTEX_PROGRAM_ARB:
492 prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
493 prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
494 prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
495 prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
496 break;
497 case GL_FRAGMENT_PROGRAM_ARB:
498 prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
499 prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
500 prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
501 prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
502 break;
503 case MESA_GEOMETRY_PROGRAM:
504 prog->MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
505 prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
506 prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
507 prog->MaxUniformComponents = MAX_GEOMETRY_UNIFORM_COMPONENTS;
508 break;
509 default:
510 assert(0 && "Bad program type in init_program_limits()");
511 }
512
513 /* Set the native limits to zero. This implies that there is no native
514 * support for shaders. Let the drivers fill in the actual values.
515 */
516 prog->MaxNativeInstructions = 0;
517 prog->MaxNativeAluInstructions = 0;
518 prog->MaxNativeTexInstructions = 0;
519 prog->MaxNativeTexIndirections = 0;
520 prog->MaxNativeAttribs = 0;
521 prog->MaxNativeTemps = 0;
522 prog->MaxNativeAddressRegs = 0;
523 prog->MaxNativeParameters = 0;
524
525 /* Set GLSL datatype range/precision info assuming IEEE float values.
526 * Drivers should override these defaults as needed.
527 */
528 prog->MediumFloat.RangeMin = 127;
529 prog->MediumFloat.RangeMax = 127;
530 prog->MediumFloat.Precision = 23;
531 prog->LowFloat = prog->HighFloat = prog->MediumFloat;
532
533 /* Assume ints are stored as floats for now, since this is the least-common
534 * denominator. The OpenGL ES spec implies (page 132) that the precision
535 * of integer types should be 0. Practically speaking, IEEE
536 * single-precision floating point values can only store integers in the
537 * range [-0x01000000, 0x01000000] without loss of precision.
538 */
539 prog->MediumInt.RangeMin = 24;
540 prog->MediumInt.RangeMax = 24;
541 prog->MediumInt.Precision = 0;
542 prog->LowInt = prog->HighInt = prog->MediumInt;
543
544 prog->MaxUniformBlocks = 12;
545 prog->MaxCombinedUniformComponents = (prog->MaxUniformComponents +
546 ctx->Const.MaxUniformBlockSize / 4 *
547 prog->MaxUniformBlocks);
548 }
549
550
551 /**
552 * Initialize fields of gl_constants (aka ctx->Const.*).
553 * Use defaults from config.h. The device drivers will often override
554 * some of these values (such as number of texture units).
555 */
556 static void
_mesa_init_constants(struct gl_context * ctx)557 _mesa_init_constants(struct gl_context *ctx)
558 {
559 assert(ctx);
560
561 /* Constants, may be overriden (usually only reduced) by device drivers */
562 ctx->Const.MaxTextureMbytes = MAX_TEXTURE_MBYTES;
563 ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
564 ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
565 ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
566 ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
567 ctx->Const.MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
568 ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
569 ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
570 ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,
571 ctx->Const.MaxTextureImageUnits);
572 ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
573 ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
574 ctx->Const.MaxTextureBufferSize = 65536;
575 ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
576 ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
577 ctx->Const.MinPointSize = MIN_POINT_SIZE;
578 ctx->Const.MaxPointSize = MAX_POINT_SIZE;
579 ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
580 ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
581 ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
582 ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
583 ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
584 ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
585 ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
586 ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
587 ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
588 ctx->Const.MaxClipPlanes = 6;
589 ctx->Const.MaxLights = MAX_LIGHTS;
590 ctx->Const.MaxShininess = 128.0;
591 ctx->Const.MaxSpotExponent = 128.0;
592 ctx->Const.MaxViewportWidth = MAX_VIEWPORT_WIDTH;
593 ctx->Const.MaxViewportHeight = MAX_VIEWPORT_HEIGHT;
594
595 /** GL_ARB_uniform_buffer_object */
596 ctx->Const.MaxCombinedUniformBlocks = 36;
597 ctx->Const.MaxUniformBufferBindings = 36;
598 ctx->Const.MaxUniformBlockSize = 16384;
599 ctx->Const.UniformBufferOffsetAlignment = 1;
600
601 #if FEATURE_ARB_vertex_program
602 init_program_limits(ctx, GL_VERTEX_PROGRAM_ARB, &ctx->Const.VertexProgram);
603 #endif
604 #if FEATURE_ARB_fragment_program
605 init_program_limits(ctx, GL_FRAGMENT_PROGRAM_ARB, &ctx->Const.FragmentProgram);
606 #endif
607 #if FEATURE_ARB_geometry_shader4
608 init_program_limits(ctx, MESA_GEOMETRY_PROGRAM, &ctx->Const.GeometryProgram);
609 #endif
610 ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
611 ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
612
613 /* CheckArrayBounds is overriden by drivers/x11 for X server */
614 ctx->Const.CheckArrayBounds = GL_FALSE;
615
616 /* GL_ARB_draw_buffers */
617 ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
618
619 #if FEATURE_EXT_framebuffer_object
620 ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
621 ctx->Const.MaxRenderbufferSize = MAX_RENDERBUFFER_SIZE;
622 #endif
623
624 #if FEATURE_ARB_vertex_shader
625 ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
626 ctx->Const.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
627 ctx->Const.MaxVarying = 16; /* old limit not to break tnl and swrast */
628 #endif
629 #if FEATURE_ARB_geometry_shader4
630 ctx->Const.MaxGeometryTextureImageUnits = MAX_GEOMETRY_TEXTURE_IMAGE_UNITS;
631 ctx->Const.MaxVertexVaryingComponents = MAX_VERTEX_VARYING_COMPONENTS;
632 ctx->Const.MaxGeometryVaryingComponents = MAX_GEOMETRY_VARYING_COMPONENTS;
633 ctx->Const.MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;
634 ctx->Const.MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;
635 #endif
636
637 /* Shading language version */
638 if (_mesa_is_desktop_gl(ctx)) {
639 ctx->Const.GLSLVersion = 120;
640 _mesa_override_glsl_version(ctx);
641 }
642 else if (ctx->API == API_OPENGLES2) {
643 ctx->Const.GLSLVersion = 100;
644 }
645 else if (ctx->API == API_OPENGLES) {
646 ctx->Const.GLSLVersion = 0; /* GLSL not supported */
647 }
648
649 /* GL_ARB_framebuffer_object */
650 ctx->Const.MaxSamples = 0;
651
652 /* GL_ARB_sync */
653 ctx->Const.MaxServerWaitTimeout = (GLuint64) ~0;
654
655 /* GL_ATI_envmap_bumpmap */
656 ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS;
657
658 /* GL_EXT_provoking_vertex */
659 ctx->Const.QuadsFollowProvokingVertexConvention = GL_TRUE;
660
661 /* GL_EXT_transform_feedback */
662 ctx->Const.MaxTransformFeedbackBuffers = MAX_FEEDBACK_BUFFERS;
663 ctx->Const.MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;
664 ctx->Const.MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;
665 ctx->Const.MaxVertexStreams = 1;
666
667 /* GL 3.2: hard-coded for now: */
668 ctx->Const.ProfileMask = GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
669
670 /** GL_EXT_gpu_shader4 */
671 ctx->Const.MinProgramTexelOffset = -8;
672 ctx->Const.MaxProgramTexelOffset = 7;
673
674 /* GL_ARB_robustness */
675 ctx->Const.ResetStrategy = GL_NO_RESET_NOTIFICATION_ARB;
676
677 /* PrimitiveRestart */
678 ctx->Const.PrimitiveRestartInSoftware = GL_FALSE;
679 }
680
681
682 /**
683 * Do some sanity checks on the limits/constants for the given context.
684 * Only called the first time a context is bound.
685 */
686 static void
check_context_limits(struct gl_context * ctx)687 check_context_limits(struct gl_context *ctx)
688 {
689 /* check that we don't exceed the size of various bitfields */
690 assert(VERT_RESULT_MAX <=
691 (8 * sizeof(ctx->VertexProgram._Current->Base.OutputsWritten)));
692 assert(FRAG_ATTRIB_MAX <=
693 (8 * sizeof(ctx->FragmentProgram._Current->Base.InputsRead)));
694
695 assert(MAX_COMBINED_TEXTURE_IMAGE_UNITS <= 8 * sizeof(GLbitfield));
696
697 /* shader-related checks */
698 assert(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
699 assert(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
700
701 assert(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
702 assert(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
703 assert(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);
704 assert(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);
705
706 /* Texture unit checks */
707 assert(ctx->Const.MaxTextureImageUnits > 0);
708 assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
709 assert(ctx->Const.MaxTextureCoordUnits > 0);
710 assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
711 assert(ctx->Const.MaxTextureUnits > 0);
712 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
713 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
714 assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,
715 ctx->Const.MaxTextureCoordUnits));
716 assert(ctx->Const.MaxCombinedTextureImageUnits > 0);
717 assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
718 assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
719 /* number of coord units cannot be greater than number of image units */
720 assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits);
721
722
723 /* Texture size checks */
724 assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
725 assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
726 assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
727 assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
728
729 /* Texture level checks */
730 assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
731 assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
732
733 /* Max texture size should be <= max viewport size (render to texture) */
734 assert((1 << (ctx->Const.MaxTextureLevels - 1))
735 <= ctx->Const.MaxViewportWidth);
736 assert((1 << (ctx->Const.MaxTextureLevels - 1))
737 <= ctx->Const.MaxViewportHeight);
738
739 assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
740
741 /* if this fails, add more enum values to gl_buffer_index */
742 assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);
743
744 /* XXX probably add more tests */
745 }
746
747
748 /**
749 * Initialize the attribute groups in a GL context.
750 *
751 * \param ctx GL context.
752 *
753 * Initializes all the attributes, calling the respective <tt>init*</tt>
754 * functions for the more complex data structures.
755 */
756 static GLboolean
init_attrib_groups(struct gl_context * ctx)757 init_attrib_groups(struct gl_context *ctx)
758 {
759 assert(ctx);
760
761 /* Constants */
762 _mesa_init_constants( ctx );
763
764 /* Extensions */
765 _mesa_init_extensions( ctx );
766
767 /* Attribute Groups */
768 _mesa_init_accum( ctx );
769 _mesa_init_attrib( ctx );
770 _mesa_init_buffer_objects( ctx );
771 _mesa_init_color( ctx );
772 _mesa_init_current( ctx );
773 _mesa_init_depth( ctx );
774 _mesa_init_debug( ctx );
775 _mesa_init_display_list( ctx );
776 _mesa_init_errors( ctx );
777 _mesa_init_eval( ctx );
778 _mesa_init_fbobjects( ctx );
779 _mesa_init_feedback( ctx );
780 _mesa_init_fog( ctx );
781 _mesa_init_hint( ctx );
782 _mesa_init_line( ctx );
783 _mesa_init_lighting( ctx );
784 _mesa_init_matrix( ctx );
785 _mesa_init_multisample( ctx );
786 _mesa_init_pixel( ctx );
787 _mesa_init_pixelstore( ctx );
788 _mesa_init_point( ctx );
789 _mesa_init_polygon( ctx );
790 _mesa_init_program( ctx );
791 _mesa_init_queryobj( ctx );
792 _mesa_init_sync( ctx );
793 _mesa_init_rastpos( ctx );
794 _mesa_init_scissor( ctx );
795 _mesa_init_shader_state( ctx );
796 _mesa_init_stencil( ctx );
797 _mesa_init_transform( ctx );
798 _mesa_init_transform_feedback( ctx );
799 _mesa_init_varray( ctx );
800 _mesa_init_viewport( ctx );
801
802 if (!_mesa_init_texture( ctx ))
803 return GL_FALSE;
804
805 _mesa_init_texture_s3tc( ctx );
806
807 /* Miscellaneous */
808 ctx->NewState = _NEW_ALL;
809 ctx->NewDriverState = ~0;
810 ctx->ErrorValue = (GLenum) GL_NO_ERROR;
811 ctx->ResetStatus = (GLenum) GL_NO_ERROR;
812 ctx->varying_vp_inputs = VERT_BIT_ALL;
813
814 return GL_TRUE;
815 }
816
817
818 /**
819 * Update default objects in a GL context with respect to shared state.
820 *
821 * \param ctx GL context.
822 *
823 * Removes references to old default objects, (texture objects, program
824 * objects, etc.) and changes to reference those from the current shared
825 * state.
826 */
827 static GLboolean
update_default_objects(struct gl_context * ctx)828 update_default_objects(struct gl_context *ctx)
829 {
830 assert(ctx);
831
832 _mesa_update_default_objects_program(ctx);
833 _mesa_update_default_objects_texture(ctx);
834 _mesa_update_default_objects_buffer_objects(ctx);
835
836 return GL_TRUE;
837 }
838
839
840 /**
841 * This is the default function we plug into all dispatch table slots
842 * This helps prevents a segfault when someone calls a GL function without
843 * first checking if the extension's supported.
844 */
845 static int
generic_nop(void)846 generic_nop(void)
847 {
848 GET_CURRENT_CONTEXT(ctx);
849 _mesa_error(ctx, GL_INVALID_OPERATION,
850 "unsupported function called "
851 "(unsupported extension or deprecated function?)");
852 return 0;
853 }
854
855
856 /**
857 * Allocate and initialize a new dispatch table.
858 */
859 struct _glapi_table *
_mesa_alloc_dispatch_table(int size)860 _mesa_alloc_dispatch_table(int size)
861 {
862 /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
863 * In practice, this'll be the same for stand-alone Mesa. But for DRI
864 * Mesa we do this to accomodate different versions of libGL and various
865 * DRI drivers.
866 */
867 GLint numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);
868 struct _glapi_table *table;
869
870 /* should never happen, but just in case */
871 numEntries = MAX2(numEntries, size);
872
873 table = (struct _glapi_table *) malloc(numEntries * sizeof(_glapi_proc));
874 if (table) {
875 _glapi_proc *entry = (_glapi_proc *) table;
876 GLint i;
877 for (i = 0; i < numEntries; i++) {
878 entry[i] = (_glapi_proc) generic_nop;
879 }
880 }
881 return table;
882 }
883
884
885 /**
886 * Initialize a struct gl_context struct (rendering context).
887 *
888 * This includes allocating all the other structs and arrays which hang off of
889 * the context by pointers.
890 * Note that the driver needs to pass in its dd_function_table here since
891 * we need to at least call driverFunctions->NewTextureObject to create the
892 * default texture objects.
893 *
894 * Called by _mesa_create_context().
895 *
896 * Performs the imports and exports callback tables initialization, and
897 * miscellaneous one-time initializations. If no shared context is supplied one
898 * is allocated, and increase its reference count. Setups the GL API dispatch
899 * tables. Initialize the TNL module. Sets the maximum Z buffer depth.
900 * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
901 * for debug flags.
902 *
903 * \param ctx the context to initialize
904 * \param api the GL API type to create the context for
905 * \param visual describes the visual attributes for this context
906 * \param share_list points to context to share textures, display lists,
907 * etc with, or NULL
908 * \param driverFunctions table of device driver functions for this context
909 * to use
910 * \param driverContext pointer to driver-specific context data
911 */
912 GLboolean
_mesa_initialize_context(struct gl_context * ctx,gl_api api,const struct gl_config * visual,struct gl_context * share_list,const struct dd_function_table * driverFunctions,void * driverContext)913 _mesa_initialize_context(struct gl_context *ctx,
914 gl_api api,
915 const struct gl_config *visual,
916 struct gl_context *share_list,
917 const struct dd_function_table *driverFunctions,
918 void *driverContext)
919 {
920 struct gl_shared_state *shared;
921 int i;
922
923 /*ASSERT(driverContext);*/
924 assert(driverFunctions->NewTextureObject);
925 assert(driverFunctions->FreeTextureImageBuffer);
926
927 ctx->API = api;
928 ctx->Visual = *visual;
929 ctx->DrawBuffer = NULL;
930 ctx->ReadBuffer = NULL;
931 ctx->WinSysDrawBuffer = NULL;
932 ctx->WinSysReadBuffer = NULL;
933
934 /* misc one-time initializations */
935 one_time_init(ctx);
936
937 /* Plug in driver functions and context pointer here.
938 * This is important because when we call alloc_shared_state() below
939 * we'll call ctx->Driver.NewTextureObject() to create the default
940 * textures.
941 */
942 ctx->Driver = *driverFunctions;
943 ctx->DriverCtx = driverContext;
944
945 if (share_list) {
946 /* share state with another context */
947 shared = share_list->Shared;
948 }
949 else {
950 /* allocate new, unshared state */
951 shared = _mesa_alloc_shared_state(ctx);
952 if (!shared)
953 return GL_FALSE;
954 }
955
956 _mesa_reference_shared_state(ctx, &ctx->Shared, shared);
957
958 if (!init_attrib_groups( ctx )) {
959 _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
960 return GL_FALSE;
961 }
962
963 #if FEATURE_dispatch
964 /* setup the API dispatch tables */
965 switch (ctx->API) {
966 #if FEATURE_GL || FEATURE_ES2
967 case API_OPENGL:
968 case API_OPENGL_CORE:
969 case API_OPENGLES2:
970 ctx->Exec = _mesa_create_exec_table(ctx);
971 break;
972 #endif
973 #if FEATURE_ES1
974 case API_OPENGLES:
975 ctx->Exec = _mesa_create_exec_table_es1();
976 break;
977 #endif
978 default:
979 _mesa_problem(ctx, "unknown or unsupported API");
980 break;
981 }
982
983 if (!ctx->Exec) {
984 _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
985 return GL_FALSE;
986 }
987 #endif
988 ctx->CurrentDispatch = ctx->Exec;
989
990 ctx->FragmentProgram._MaintainTexEnvProgram
991 = (_mesa_getenv("MESA_TEX_PROG") != NULL);
992
993 ctx->VertexProgram._MaintainTnlProgram
994 = (_mesa_getenv("MESA_TNL_PROG") != NULL);
995 if (ctx->VertexProgram._MaintainTnlProgram) {
996 /* this is required... */
997 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
998 }
999
1000 /* Mesa core handles all the formats that mesa core knows about.
1001 * Drivers will want to override this list with just the formats
1002 * they can handle, and confirm that appropriate fallbacks exist in
1003 * _mesa_choose_tex_format().
1004 */
1005 memset(&ctx->TextureFormatSupported, GL_TRUE,
1006 sizeof(ctx->TextureFormatSupported));
1007
1008 switch (ctx->API) {
1009 case API_OPENGL:
1010 #if FEATURE_dlist
1011 ctx->Save = _mesa_create_save_table(ctx);
1012 if (!ctx->Save) {
1013 _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1014 free(ctx->Exec);
1015 return GL_FALSE;
1016 }
1017
1018 _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
1019 #endif
1020 case API_OPENGL_CORE:
1021 break;
1022 case API_OPENGLES:
1023 /**
1024 * GL_OES_texture_cube_map says
1025 * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
1026 */
1027 for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1028 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
1029 texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
1030 texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
1031 texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
1032 texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1033 texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1034 texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1035 }
1036 break;
1037 case API_OPENGLES2:
1038 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1039 ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
1040 ctx->Point.PointSprite = GL_TRUE; /* always on for ES 2.x */
1041 break;
1042 }
1043
1044 ctx->FirstTimeCurrent = GL_TRUE;
1045
1046 return GL_TRUE;
1047 }
1048
1049
1050 /**
1051 * Allocate and initialize a struct gl_context structure.
1052 * Note that the driver needs to pass in its dd_function_table here since
1053 * we need to at least call driverFunctions->NewTextureObject to initialize
1054 * the rendering context.
1055 *
1056 * \param api the GL API type to create the context for
1057 * \param visual a struct gl_config pointer (we copy the struct contents)
1058 * \param share_list another context to share display lists with or NULL
1059 * \param driverFunctions points to the dd_function_table into which the
1060 * driver has plugged in all its special functions.
1061 * \param driverContext points to the device driver's private context state
1062 *
1063 * \return pointer to a new __struct gl_contextRec or NULL if error.
1064 */
1065 struct gl_context *
_mesa_create_context(gl_api api,const struct gl_config * visual,struct gl_context * share_list,const struct dd_function_table * driverFunctions,void * driverContext)1066 _mesa_create_context(gl_api api,
1067 const struct gl_config *visual,
1068 struct gl_context *share_list,
1069 const struct dd_function_table *driverFunctions,
1070 void *driverContext)
1071 {
1072 struct gl_context *ctx;
1073
1074 ASSERT(visual);
1075 /*ASSERT(driverContext);*/
1076
1077 ctx = (struct gl_context *) calloc(1, sizeof(struct gl_context));
1078 if (!ctx)
1079 return NULL;
1080
1081 if (_mesa_initialize_context(ctx, api, visual, share_list,
1082 driverFunctions, driverContext)) {
1083 return ctx;
1084 }
1085 else {
1086 free(ctx);
1087 return NULL;
1088 }
1089 }
1090
1091
1092 /**
1093 * Free the data associated with the given context.
1094 *
1095 * But doesn't free the struct gl_context struct itself.
1096 *
1097 * \sa _mesa_initialize_context() and init_attrib_groups().
1098 */
1099 void
_mesa_free_context_data(struct gl_context * ctx)1100 _mesa_free_context_data( struct gl_context *ctx )
1101 {
1102 if (!_mesa_get_current_context()){
1103 /* No current context, but we may need one in order to delete
1104 * texture objs, etc. So temporarily bind the context now.
1105 */
1106 _mesa_make_current(ctx, NULL, NULL);
1107 }
1108
1109 /* unreference WinSysDraw/Read buffers */
1110 _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
1111 _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
1112 _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
1113 _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
1114
1115 _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
1116 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
1117 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL);
1118
1119 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
1120 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
1121 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
1122
1123 _mesa_reference_array_object(ctx, &ctx->Array.ArrayObj, NULL);
1124 _mesa_reference_array_object(ctx, &ctx->Array.DefaultArrayObj, NULL);
1125
1126 _mesa_free_attrib_data(ctx);
1127 _mesa_free_buffer_objects(ctx);
1128 _mesa_free_lighting_data( ctx );
1129 _mesa_free_eval_data( ctx );
1130 _mesa_free_texture_data( ctx );
1131 _mesa_free_matrix_data( ctx );
1132 _mesa_free_viewport_data( ctx );
1133 _mesa_free_program_data(ctx);
1134 _mesa_free_shader_state(ctx);
1135 _mesa_free_queryobj_data(ctx);
1136 _mesa_free_sync_data(ctx);
1137 _mesa_free_varray_data(ctx);
1138 _mesa_free_transform_feedback(ctx);
1139
1140 #if FEATURE_ARB_pixel_buffer_object
1141 _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
1142 _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
1143 _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
1144 #endif
1145
1146 _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
1147
1148 /* free dispatch tables */
1149 free(ctx->Exec);
1150 free(ctx->Save);
1151
1152 /* Shared context state (display lists, textures, etc) */
1153 _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1154
1155 /* needs to be after freeing shared state */
1156 _mesa_free_display_list_data(ctx);
1157
1158 _mesa_free_errors_data(ctx);
1159
1160 if (ctx->Extensions.String)
1161 free((void *) ctx->Extensions.String);
1162
1163 if (ctx->VersionString)
1164 free(ctx->VersionString);
1165
1166 /* unbind the context if it's currently bound */
1167 if (ctx == _mesa_get_current_context()) {
1168 _mesa_make_current(NULL, NULL, NULL);
1169 }
1170 }
1171
1172
1173 /**
1174 * Destroy a struct gl_context structure.
1175 *
1176 * \param ctx GL context.
1177 *
1178 * Calls _mesa_free_context_data() and frees the gl_context object itself.
1179 */
1180 void
_mesa_destroy_context(struct gl_context * ctx)1181 _mesa_destroy_context( struct gl_context *ctx )
1182 {
1183 if (ctx) {
1184 _mesa_free_context_data(ctx);
1185 free( (void *) ctx );
1186 }
1187 }
1188
1189
1190 #if _HAVE_FULL_GL
1191 /**
1192 * Copy attribute groups from one context to another.
1193 *
1194 * \param src source context
1195 * \param dst destination context
1196 * \param mask bitwise OR of GL_*_BIT flags
1197 *
1198 * According to the bits specified in \p mask, copies the corresponding
1199 * attributes from \p src into \p dst. For many of the attributes a simple \c
1200 * memcpy is not enough due to the existence of internal pointers in their data
1201 * structures.
1202 */
1203 void
_mesa_copy_context(const struct gl_context * src,struct gl_context * dst,GLuint mask)1204 _mesa_copy_context( const struct gl_context *src, struct gl_context *dst,
1205 GLuint mask )
1206 {
1207 if (mask & GL_ACCUM_BUFFER_BIT) {
1208 /* OK to memcpy */
1209 dst->Accum = src->Accum;
1210 }
1211 if (mask & GL_COLOR_BUFFER_BIT) {
1212 /* OK to memcpy */
1213 dst->Color = src->Color;
1214 }
1215 if (mask & GL_CURRENT_BIT) {
1216 /* OK to memcpy */
1217 dst->Current = src->Current;
1218 }
1219 if (mask & GL_DEPTH_BUFFER_BIT) {
1220 /* OK to memcpy */
1221 dst->Depth = src->Depth;
1222 }
1223 if (mask & GL_ENABLE_BIT) {
1224 /* no op */
1225 }
1226 if (mask & GL_EVAL_BIT) {
1227 /* OK to memcpy */
1228 dst->Eval = src->Eval;
1229 }
1230 if (mask & GL_FOG_BIT) {
1231 /* OK to memcpy */
1232 dst->Fog = src->Fog;
1233 }
1234 if (mask & GL_HINT_BIT) {
1235 /* OK to memcpy */
1236 dst->Hint = src->Hint;
1237 }
1238 if (mask & GL_LIGHTING_BIT) {
1239 GLuint i;
1240 /* begin with memcpy */
1241 dst->Light = src->Light;
1242 /* fixup linked lists to prevent pointer insanity */
1243 make_empty_list( &(dst->Light.EnabledList) );
1244 for (i = 0; i < MAX_LIGHTS; i++) {
1245 if (dst->Light.Light[i].Enabled) {
1246 insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
1247 }
1248 }
1249 }
1250 if (mask & GL_LINE_BIT) {
1251 /* OK to memcpy */
1252 dst->Line = src->Line;
1253 }
1254 if (mask & GL_LIST_BIT) {
1255 /* OK to memcpy */
1256 dst->List = src->List;
1257 }
1258 if (mask & GL_PIXEL_MODE_BIT) {
1259 /* OK to memcpy */
1260 dst->Pixel = src->Pixel;
1261 }
1262 if (mask & GL_POINT_BIT) {
1263 /* OK to memcpy */
1264 dst->Point = src->Point;
1265 }
1266 if (mask & GL_POLYGON_BIT) {
1267 /* OK to memcpy */
1268 dst->Polygon = src->Polygon;
1269 }
1270 if (mask & GL_POLYGON_STIPPLE_BIT) {
1271 /* Use loop instead of memcpy due to problem with Portland Group's
1272 * C compiler. Reported by John Stone.
1273 */
1274 GLuint i;
1275 for (i = 0; i < 32; i++) {
1276 dst->PolygonStipple[i] = src->PolygonStipple[i];
1277 }
1278 }
1279 if (mask & GL_SCISSOR_BIT) {
1280 /* OK to memcpy */
1281 dst->Scissor = src->Scissor;
1282 }
1283 if (mask & GL_STENCIL_BUFFER_BIT) {
1284 /* OK to memcpy */
1285 dst->Stencil = src->Stencil;
1286 }
1287 if (mask & GL_TEXTURE_BIT) {
1288 /* Cannot memcpy because of pointers */
1289 _mesa_copy_texture_state(src, dst);
1290 }
1291 if (mask & GL_TRANSFORM_BIT) {
1292 /* OK to memcpy */
1293 dst->Transform = src->Transform;
1294 }
1295 if (mask & GL_VIEWPORT_BIT) {
1296 /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
1297 dst->Viewport.X = src->Viewport.X;
1298 dst->Viewport.Y = src->Viewport.Y;
1299 dst->Viewport.Width = src->Viewport.Width;
1300 dst->Viewport.Height = src->Viewport.Height;
1301 dst->Viewport.Near = src->Viewport.Near;
1302 dst->Viewport.Far = src->Viewport.Far;
1303 _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
1304 }
1305
1306 /* XXX FIXME: Call callbacks?
1307 */
1308 dst->NewState = _NEW_ALL;
1309 dst->NewDriverState = ~0;
1310 }
1311 #endif
1312
1313
1314 /**
1315 * Check if the given context can render into the given framebuffer
1316 * by checking visual attributes.
1317 *
1318 * Most of these tests could go away because Mesa is now pretty flexible
1319 * in terms of mixing rendering contexts with framebuffers. As long
1320 * as RGB vs. CI mode agree, we're probably good.
1321 *
1322 * \return GL_TRUE if compatible, GL_FALSE otherwise.
1323 */
1324 static GLboolean
check_compatible(const struct gl_context * ctx,const struct gl_framebuffer * buffer)1325 check_compatible(const struct gl_context *ctx,
1326 const struct gl_framebuffer *buffer)
1327 {
1328 const struct gl_config *ctxvis = &ctx->Visual;
1329 const struct gl_config *bufvis = &buffer->Visual;
1330
1331 if (buffer == _mesa_get_incomplete_framebuffer())
1332 return GL_TRUE;
1333
1334 #if 0
1335 /* disabling this fixes the fgl_glxgears pbuffer demo */
1336 if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
1337 return GL_FALSE;
1338 #endif
1339 if (ctxvis->stereoMode && !bufvis->stereoMode)
1340 return GL_FALSE;
1341 if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
1342 return GL_FALSE;
1343 if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
1344 return GL_FALSE;
1345 if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
1346 return GL_FALSE;
1347 if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
1348 return GL_FALSE;
1349 if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
1350 return GL_FALSE;
1351 if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
1352 return GL_FALSE;
1353 #if 0
1354 /* disabled (see bug 11161) */
1355 if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
1356 return GL_FALSE;
1357 #endif
1358 if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
1359 return GL_FALSE;
1360
1361 return GL_TRUE;
1362 }
1363
1364
1365 /**
1366 * Do one-time initialization for the given framebuffer. Specifically,
1367 * ask the driver for the window's current size and update the framebuffer
1368 * object to match.
1369 * Really, the device driver should totally take care of this.
1370 */
1371 static void
initialize_framebuffer_size(struct gl_context * ctx,struct gl_framebuffer * fb)1372 initialize_framebuffer_size(struct gl_context *ctx, struct gl_framebuffer *fb)
1373 {
1374 GLuint width, height;
1375 if (ctx->Driver.GetBufferSize) {
1376 ctx->Driver.GetBufferSize(fb, &width, &height);
1377 if (ctx->Driver.ResizeBuffers)
1378 ctx->Driver.ResizeBuffers(ctx, fb, width, height);
1379 fb->Initialized = GL_TRUE;
1380 }
1381 }
1382
1383
1384 /**
1385 * Check if the viewport/scissor size has not yet been initialized.
1386 * Initialize the size if the given width and height are non-zero.
1387 */
1388 void
_mesa_check_init_viewport(struct gl_context * ctx,GLuint width,GLuint height)1389 _mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
1390 {
1391 if (!ctx->ViewportInitialized && width > 0 && height > 0) {
1392 /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
1393 * potential infinite recursion.
1394 */
1395 ctx->ViewportInitialized = GL_TRUE;
1396 _mesa_set_viewport(ctx, 0, 0, width, height);
1397 _mesa_set_scissor(ctx, 0, 0, width, height);
1398 }
1399 }
1400
1401
1402 /**
1403 * Bind the given context to the given drawBuffer and readBuffer and
1404 * make it the current context for the calling thread.
1405 * We'll render into the drawBuffer and read pixels from the
1406 * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1407 *
1408 * We check that the context's and framebuffer's visuals are compatible
1409 * and return immediately if they're not.
1410 *
1411 * \param newCtx the new GL context. If NULL then there will be no current GL
1412 * context.
1413 * \param drawBuffer the drawing framebuffer
1414 * \param readBuffer the reading framebuffer
1415 */
1416 GLboolean
_mesa_make_current(struct gl_context * newCtx,struct gl_framebuffer * drawBuffer,struct gl_framebuffer * readBuffer)1417 _mesa_make_current( struct gl_context *newCtx,
1418 struct gl_framebuffer *drawBuffer,
1419 struct gl_framebuffer *readBuffer )
1420 {
1421 GET_CURRENT_CONTEXT(curCtx);
1422
1423 if (MESA_VERBOSE & VERBOSE_API)
1424 _mesa_debug(newCtx, "_mesa_make_current()\n");
1425
1426 /* Check that the context's and framebuffer's visuals are compatible.
1427 */
1428 if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1429 if (!check_compatible(newCtx, drawBuffer)) {
1430 _mesa_warning(newCtx,
1431 "MakeCurrent: incompatible visuals for context and drawbuffer");
1432 return GL_FALSE;
1433 }
1434 }
1435 if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1436 if (!check_compatible(newCtx, readBuffer)) {
1437 _mesa_warning(newCtx,
1438 "MakeCurrent: incompatible visuals for context and readbuffer");
1439 return GL_FALSE;
1440 }
1441 }
1442
1443 if (curCtx &&
1444 (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) &&
1445 /* make sure this context is valid for flushing */
1446 curCtx != newCtx)
1447 _mesa_flush(curCtx);
1448
1449 /* We used to call _glapi_check_multithread() here. Now do it in drivers */
1450 _glapi_set_context((void *) newCtx);
1451 ASSERT(_mesa_get_current_context() == newCtx);
1452
1453 if (!newCtx) {
1454 _glapi_set_dispatch(NULL); /* none current */
1455 }
1456 else {
1457 _glapi_set_dispatch(newCtx->CurrentDispatch);
1458
1459 if (drawBuffer && readBuffer) {
1460 ASSERT(_mesa_is_winsys_fbo(drawBuffer));
1461 ASSERT(_mesa_is_winsys_fbo(readBuffer));
1462 _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1463 _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1464
1465 /*
1466 * Only set the context's Draw/ReadBuffer fields if they're NULL
1467 * or not bound to a user-created FBO.
1468 */
1469 if (!newCtx->DrawBuffer || _mesa_is_winsys_fbo(newCtx->DrawBuffer)) {
1470 _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1471 /* Update the FBO's list of drawbuffers/renderbuffers.
1472 * For winsys FBOs this comes from the GL state (which may have
1473 * changed since the last time this FBO was bound).
1474 */
1475 _mesa_update_draw_buffers(newCtx);
1476 }
1477 if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) {
1478 _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1479 }
1480
1481 /* XXX only set this flag if we're really changing the draw/read
1482 * framebuffer bindings.
1483 */
1484 newCtx->NewState |= _NEW_BUFFERS;
1485
1486 #if 1
1487 /* We want to get rid of these lines: */
1488
1489 #if _HAVE_FULL_GL
1490 if (!drawBuffer->Initialized) {
1491 initialize_framebuffer_size(newCtx, drawBuffer);
1492 }
1493 if (readBuffer != drawBuffer && !readBuffer->Initialized) {
1494 initialize_framebuffer_size(newCtx, readBuffer);
1495 }
1496
1497 _mesa_resizebuffers(newCtx);
1498 #endif
1499
1500 #else
1501 /* We want the drawBuffer and readBuffer to be initialized by
1502 * the driver.
1503 * This generally means the Width and Height match the actual
1504 * window size and the renderbuffers (both hardware and software
1505 * based) are allocated to match. The later can generally be
1506 * done with a call to _mesa_resize_framebuffer().
1507 *
1508 * It's theoretically possible for a buffer to have zero width
1509 * or height, but for now, assert check that the driver did what's
1510 * expected of it.
1511 */
1512 ASSERT(drawBuffer->Width > 0);
1513 ASSERT(drawBuffer->Height > 0);
1514 #endif
1515
1516 if (drawBuffer) {
1517 _mesa_check_init_viewport(newCtx,
1518 drawBuffer->Width, drawBuffer->Height);
1519 }
1520 }
1521
1522 if (newCtx->FirstTimeCurrent) {
1523 _mesa_compute_version(newCtx);
1524
1525 newCtx->Extensions.String = _mesa_make_extension_string(newCtx);
1526
1527 check_context_limits(newCtx);
1528
1529 /* We can use this to help debug user's problems. Tell them to set
1530 * the MESA_INFO env variable before running their app. Then the
1531 * first time each context is made current we'll print some useful
1532 * information.
1533 */
1534 if (_mesa_getenv("MESA_INFO")) {
1535 _mesa_print_info();
1536 }
1537
1538 newCtx->FirstTimeCurrent = GL_FALSE;
1539 }
1540 }
1541
1542 return GL_TRUE;
1543 }
1544
1545
1546 /**
1547 * Make context 'ctx' share the display lists, textures and programs
1548 * that are associated with 'ctxToShare'.
1549 * Any display lists, textures or programs associated with 'ctx' will
1550 * be deleted if nobody else is sharing them.
1551 */
1552 GLboolean
_mesa_share_state(struct gl_context * ctx,struct gl_context * ctxToShare)1553 _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
1554 {
1555 if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1556 struct gl_shared_state *oldShared = NULL;
1557
1558 /* save ref to old state to prevent it from being deleted immediately */
1559 _mesa_reference_shared_state(ctx, &oldShared, ctx->Shared);
1560
1561 /* update ctx's Shared pointer */
1562 _mesa_reference_shared_state(ctx, &ctx->Shared, ctxToShare->Shared);
1563
1564 update_default_objects(ctx);
1565
1566 /* release the old shared state */
1567 _mesa_reference_shared_state(ctx, &oldShared, NULL);
1568
1569 return GL_TRUE;
1570 }
1571 else {
1572 return GL_FALSE;
1573 }
1574 }
1575
1576
1577
1578 /**
1579 * \return pointer to the current GL context for this thread.
1580 *
1581 * Calls _glapi_get_context(). This isn't the fastest way to get the current
1582 * context. If you need speed, see the #GET_CURRENT_CONTEXT macro in
1583 * context.h.
1584 */
1585 struct gl_context *
_mesa_get_current_context(void)1586 _mesa_get_current_context( void )
1587 {
1588 return (struct gl_context *) _glapi_get_context();
1589 }
1590
1591
1592 /**
1593 * Get context's current API dispatch table.
1594 *
1595 * It'll either be the immediate-mode execute dispatcher or the display list
1596 * compile dispatcher.
1597 *
1598 * \param ctx GL context.
1599 *
1600 * \return pointer to dispatch_table.
1601 *
1602 * Simply returns __struct gl_contextRec::CurrentDispatch.
1603 */
1604 struct _glapi_table *
_mesa_get_dispatch(struct gl_context * ctx)1605 _mesa_get_dispatch(struct gl_context *ctx)
1606 {
1607 return ctx->CurrentDispatch;
1608 }
1609
1610 /*@}*/
1611
1612
1613 /**********************************************************************/
1614 /** \name Miscellaneous functions */
1615 /**********************************************************************/
1616 /*@{*/
1617
1618 /**
1619 * Record an error.
1620 *
1621 * \param ctx GL context.
1622 * \param error error code.
1623 *
1624 * Records the given error code and call the driver's dd_function_table::Error
1625 * function if defined.
1626 *
1627 * \sa
1628 * This is called via _mesa_error().
1629 */
1630 void
_mesa_record_error(struct gl_context * ctx,GLenum error)1631 _mesa_record_error(struct gl_context *ctx, GLenum error)
1632 {
1633 if (!ctx)
1634 return;
1635
1636 if (ctx->ErrorValue == GL_NO_ERROR) {
1637 ctx->ErrorValue = error;
1638 }
1639
1640 /* Call device driver's error handler, if any. This is used on the Mac. */
1641 if (ctx->Driver.Error) {
1642 ctx->Driver.Error(ctx);
1643 }
1644 }
1645
1646
1647 /**
1648 * Flush commands and wait for completion.
1649 */
1650 void
_mesa_finish(struct gl_context * ctx)1651 _mesa_finish(struct gl_context *ctx)
1652 {
1653 FLUSH_VERTICES( ctx, 0 );
1654 FLUSH_CURRENT( ctx, 0 );
1655 if (ctx->Driver.Finish) {
1656 ctx->Driver.Finish(ctx);
1657 }
1658 }
1659
1660
1661 /**
1662 * Flush commands.
1663 */
1664 void
_mesa_flush(struct gl_context * ctx)1665 _mesa_flush(struct gl_context *ctx)
1666 {
1667 FLUSH_VERTICES( ctx, 0 );
1668 FLUSH_CURRENT( ctx, 0 );
1669 if (ctx->Driver.Flush) {
1670 ctx->Driver.Flush(ctx);
1671 }
1672 }
1673
1674
1675
1676 /**
1677 * Execute glFinish().
1678 *
1679 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1680 * dd_function_table::Finish driver callback, if not NULL.
1681 */
1682 void GLAPIENTRY
_mesa_Finish(void)1683 _mesa_Finish(void)
1684 {
1685 GET_CURRENT_CONTEXT(ctx);
1686 ASSERT_OUTSIDE_BEGIN_END(ctx);
1687 _mesa_finish(ctx);
1688 }
1689
1690
1691 /**
1692 * Execute glFlush().
1693 *
1694 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1695 * dd_function_table::Flush driver callback, if not NULL.
1696 */
1697 void GLAPIENTRY
_mesa_Flush(void)1698 _mesa_Flush(void)
1699 {
1700 GET_CURRENT_CONTEXT(ctx);
1701 ASSERT_OUTSIDE_BEGIN_END(ctx);
1702 _mesa_flush(ctx);
1703 }
1704
1705
1706 /**
1707 * Set mvp_with_dp4 flag. If a driver has a preference for DP4 over
1708 * MUL/MAD, or vice versa, call this function to register that.
1709 * Otherwise we default to MUL/MAD.
1710 */
1711 void
_mesa_set_mvp_with_dp4(struct gl_context * ctx,GLboolean flag)1712 _mesa_set_mvp_with_dp4( struct gl_context *ctx,
1713 GLboolean flag )
1714 {
1715 ctx->mvp_with_dp4 = flag;
1716 }
1717
1718 /*
1719 * ARB_blend_func_extended - ERRORS section
1720 * "The error INVALID_OPERATION is generated by Begin or any procedure that
1721 * implicitly calls Begin if any draw buffer has a blend function requiring the
1722 * second color input (SRC1_COLOR, ONE_MINUS_SRC1_COLOR, SRC1_ALPHA or
1723 * ONE_MINUS_SRC1_ALPHA), and a framebuffer is bound that has more than
1724 * the value of MAX_DUAL_SOURCE_DRAW_BUFFERS-1 active color attachements."
1725 */
1726 static GLboolean
_mesa_check_blend_func_error(struct gl_context * ctx)1727 _mesa_check_blend_func_error(struct gl_context *ctx)
1728 {
1729 GLuint i;
1730 for (i = ctx->Const.MaxDualSourceDrawBuffers;
1731 i < ctx->DrawBuffer->_NumColorDrawBuffers;
1732 i++) {
1733 if (ctx->Color.Blend[i]._UsesDualSrc) {
1734 _mesa_error(ctx, GL_INVALID_OPERATION,
1735 "dual source blend on illegal attachment");
1736 return GL_FALSE;
1737 }
1738 }
1739 return GL_TRUE;
1740 }
1741
1742 /**
1743 * Prior to drawing anything with glBegin, glDrawArrays, etc. this function
1744 * is called to see if it's valid to render. This involves checking that
1745 * the current shader is valid and the framebuffer is complete.
1746 * If an error is detected it'll be recorded here.
1747 * \return GL_TRUE if OK to render, GL_FALSE if not
1748 */
1749 GLboolean
_mesa_valid_to_render(struct gl_context * ctx,const char * where)1750 _mesa_valid_to_render(struct gl_context *ctx, const char *where)
1751 {
1752 bool vert_from_glsl_shader = false;
1753 bool geom_from_glsl_shader = false;
1754 bool frag_from_glsl_shader = false;
1755
1756 /* This depends on having up to date derived state (shaders) */
1757 if (ctx->NewState)
1758 _mesa_update_state(ctx);
1759
1760 if (ctx->Shader.CurrentVertexProgram) {
1761 vert_from_glsl_shader = true;
1762
1763 if (!ctx->Shader.CurrentVertexProgram->LinkStatus) {
1764 _mesa_error(ctx, GL_INVALID_OPERATION,
1765 "%s(shader not linked)", where);
1766 return GL_FALSE;
1767 }
1768 #if 0 /* not normally enabled */
1769 {
1770 char errMsg[100];
1771 if (!_mesa_validate_shader_program(ctx,
1772 ctx->Shader.CurrentVertexProgram,
1773 errMsg)) {
1774 _mesa_warning(ctx, "Shader program %u is invalid: %s",
1775 ctx->Shader.CurrentVertexProgram->Name, errMsg);
1776 }
1777 }
1778 #endif
1779 }
1780
1781 if (ctx->Shader.CurrentGeometryProgram) {
1782 geom_from_glsl_shader = true;
1783
1784 if (!ctx->Shader.CurrentGeometryProgram->LinkStatus) {
1785 _mesa_error(ctx, GL_INVALID_OPERATION,
1786 "%s(shader not linked)", where);
1787 return GL_FALSE;
1788 }
1789 #if 0 /* not normally enabled */
1790 {
1791 char errMsg[100];
1792 if (!_mesa_validate_shader_program(ctx,
1793 ctx->Shader.CurrentGeometryProgram,
1794 errMsg)) {
1795 _mesa_warning(ctx, "Shader program %u is invalid: %s",
1796 ctx->Shader.CurrentGeometryProgram->Name, errMsg);
1797 }
1798 }
1799 #endif
1800 }
1801
1802 if (ctx->Shader.CurrentFragmentProgram) {
1803 frag_from_glsl_shader = true;
1804
1805 if (!ctx->Shader.CurrentFragmentProgram->LinkStatus) {
1806 _mesa_error(ctx, GL_INVALID_OPERATION,
1807 "%s(shader not linked)", where);
1808 return GL_FALSE;
1809 }
1810 #if 0 /* not normally enabled */
1811 {
1812 char errMsg[100];
1813 if (!_mesa_validate_shader_program(ctx,
1814 ctx->Shader.CurrentFragmentProgram,
1815 errMsg)) {
1816 _mesa_warning(ctx, "Shader program %u is invalid: %s",
1817 ctx->Shader.CurrentFragmentProgram->Name, errMsg);
1818 }
1819 }
1820 #endif
1821 }
1822
1823 /* Any shader stages that are not supplied by the GLSL shader and have
1824 * assembly shaders enabled must now be validated.
1825 */
1826 if (!vert_from_glsl_shader
1827 && ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) {
1828 _mesa_error(ctx, GL_INVALID_OPERATION,
1829 "%s(vertex program not valid)", where);
1830 return GL_FALSE;
1831 }
1832
1833 /* FINISHME: If GL_NV_geometry_program4 is ever supported, the current
1834 * FINISHME: geometry program should validated here.
1835 */
1836 (void) geom_from_glsl_shader;
1837
1838 if (!frag_from_glsl_shader) {
1839 if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
1840 _mesa_error(ctx, GL_INVALID_OPERATION,
1841 "%s(fragment program not valid)", where);
1842 return GL_FALSE;
1843 }
1844
1845 /* If drawing to integer-valued color buffers, there must be an
1846 * active fragment shader (GL_EXT_texture_integer).
1847 */
1848 if (ctx->DrawBuffer && ctx->DrawBuffer->_IntegerColor) {
1849 _mesa_error(ctx, GL_INVALID_OPERATION,
1850 "%s(integer format but no fragment shader)", where);
1851 return GL_FALSE;
1852 }
1853 }
1854
1855 if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
1856 _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
1857 "%s(incomplete framebuffer)", where);
1858 return GL_FALSE;
1859 }
1860
1861 if (_mesa_check_blend_func_error(ctx) == GL_FALSE) {
1862 return GL_FALSE;
1863 }
1864
1865 #ifdef DEBUG
1866 if (ctx->Shader.Flags & GLSL_LOG) {
1867 struct gl_shader_program *shProg[MESA_SHADER_TYPES];
1868 gl_shader_type i;
1869
1870 shProg[MESA_SHADER_VERTEX] = ctx->Shader.CurrentVertexProgram;
1871 shProg[MESA_SHADER_GEOMETRY] = ctx->Shader.CurrentGeometryProgram;
1872 shProg[MESA_SHADER_FRAGMENT] = ctx->Shader.CurrentFragmentProgram;
1873
1874 for (i = 0; i < MESA_SHADER_TYPES; i++) {
1875 if (shProg[i] == NULL || shProg[i]->_Used
1876 || shProg[i]->_LinkedShaders[i] == NULL)
1877 continue;
1878
1879 /* This is the first time this shader is being used.
1880 * Append shader's constants/uniforms to log file.
1881 *
1882 * Only log data for the program target that matches the shader
1883 * target. It's possible to have a program bound to the vertex
1884 * shader target that also supplied a fragment shader. If that
1885 * program isn't also bound to the fragment shader target we don't
1886 * want to log its fragment data.
1887 */
1888 _mesa_append_uniforms_to_file(shProg[i]->_LinkedShaders[i]);
1889 }
1890
1891 for (i = 0; i < MESA_SHADER_TYPES; i++) {
1892 if (shProg[i] != NULL)
1893 shProg[i]->_Used = GL_TRUE;
1894 }
1895 }
1896 #endif
1897
1898 return GL_TRUE;
1899 }
1900
1901
1902 /*@}*/
1903