glsl: Add a lowering pass for gl_VertexID
[mesa.git] / src / mesa / main / context.c
1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
5 * Copyright (C) 2008 VMware, Inc. All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 * 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 "imports.h"
81 #include "accum.h"
82 #include "api_exec.h"
83 #include "api_loopback.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 "performance_monitor.h"
109 #include "pipelineobj.h"
110 #include "pixel.h"
111 #include "pixelstore.h"
112 #include "points.h"
113 #include "polygon.h"
114 #include "queryobj.h"
115 #include "syncobj.h"
116 #include "rastpos.h"
117 #include "remap.h"
118 #include "scissor.h"
119 #include "shared.h"
120 #include "shaderobj.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 "transformfeedback.h"
127 #include "mtypes.h"
128 #include "varray.h"
129 #include "version.h"
130 #include "viewport.h"
131 #include "vtxfmt.h"
132 #include "program/program.h"
133 #include "program/prog_print.h"
134 #include "math/m_matrix.h"
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
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 *
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
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
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
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_result fr = FRAG_RESULT_DEPTH;
349 gl_texture_index ti = TEXTURE_2D_ARRAY_INDEX;
350 gl_vert_attrib va = VERT_ATTRIB_POS;
351 gl_varying_slot vs = VARYING_SLOT_POS;
352
353 (void) bi;
354 (void) fi;
355 (void) fr;
356 (void) ti;
357 (void) va;
358 (void) vs;
359 }
360
361
362 /**
363 * One-time initialization mutex lock.
364 *
365 * \sa Used by one_time_init().
366 */
367 mtx_t OneTimeLock = _MTX_INITIALIZER_NP;
368
369
370
371 /**
372 * Calls all the various one-time-init functions in Mesa.
373 *
374 * While holding a global mutex lock, calls several initialization functions,
375 * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
376 * defined.
377 *
378 * \sa _math_init().
379 */
380 static void
381 one_time_init( struct gl_context *ctx )
382 {
383 static GLbitfield api_init_mask = 0x0;
384
385 mtx_lock(&OneTimeLock);
386
387 /* truly one-time init */
388 if (!api_init_mask) {
389 GLuint i;
390
391 /* do some implementation tests */
392 assert( sizeof(GLbyte) == 1 );
393 assert( sizeof(GLubyte) == 1 );
394 assert( sizeof(GLshort) == 2 );
395 assert( sizeof(GLushort) == 2 );
396 assert( sizeof(GLint) == 4 );
397 assert( sizeof(GLuint) == 4 );
398
399 _mesa_one_time_init_extension_overrides();
400
401 _mesa_get_cpu_features();
402
403 for (i = 0; i < 256; i++) {
404 _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
405 }
406
407 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
408 if (MESA_VERBOSE != 0) {
409 _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
410 PACKAGE_VERSION, __DATE__, __TIME__);
411 }
412 #endif
413
414 #ifdef DEBUG
415 _mesa_test_formats();
416 #endif
417 }
418
419 /* per-API one-time init */
420 if (!(api_init_mask & (1 << ctx->API))) {
421 _mesa_init_get_hash(ctx);
422
423 _mesa_init_remap_table();
424 }
425
426 api_init_mask |= 1 << ctx->API;
427
428 mtx_unlock(&OneTimeLock);
429
430 /* Hopefully atexit() is widely available. If not, we may need some
431 * #ifdef tests here.
432 */
433 atexit(_mesa_destroy_shader_compiler);
434
435 dummy_enum_func();
436 }
437
438
439 /**
440 * Initialize fields of gl_current_attrib (aka ctx->Current.*)
441 */
442 static void
443 _mesa_init_current(struct gl_context *ctx)
444 {
445 GLuint i;
446
447 /* Init all to (0,0,0,1) */
448 for (i = 0; i < Elements(ctx->Current.Attrib); i++) {
449 ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
450 }
451
452 /* redo special cases: */
453 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );
454 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
455 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
456 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
457 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
458 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
459 }
460
461
462 /**
463 * Init vertex/fragment/geometry program limits.
464 * Important: drivers should override these with actual limits.
465 */
466 static void
467 init_program_limits(struct gl_constants *consts, gl_shader_stage stage,
468 struct gl_program_constants *prog)
469 {
470 prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
471 prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
472 prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
473 prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
474 prog->MaxTemps = MAX_PROGRAM_TEMPS;
475 prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
476 prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
477 prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS;
478
479 switch (stage) {
480 case MESA_SHADER_VERTEX:
481 prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
482 prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;
483 prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
484 prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
485 prog->MaxInputComponents = 0; /* value not used */
486 prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */
487 break;
488 case MESA_SHADER_FRAGMENT:
489 prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
490 prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
491 prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
492 prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
493 prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */
494 prog->MaxOutputComponents = 0; /* value not used */
495 break;
496 case MESA_SHADER_GEOMETRY:
497 prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
498 prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;
499 prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
500 prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
501 prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */
502 prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */
503 break;
504 case MESA_SHADER_COMPUTE:
505 prog->MaxParameters = 0; /* not meaningful for compute shaders */
506 prog->MaxAttribs = 0; /* not meaningful for compute shaders */
507 prog->MaxAddressRegs = 0; /* not meaningful for compute shaders */
508 prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
509 prog->MaxInputComponents = 0; /* not meaningful for compute shaders */
510 prog->MaxOutputComponents = 0; /* not meaningful for compute shaders */
511 break;
512 default:
513 assert(0 && "Bad shader stage in init_program_limits()");
514 }
515
516 /* Set the native limits to zero. This implies that there is no native
517 * support for shaders. Let the drivers fill in the actual values.
518 */
519 prog->MaxNativeInstructions = 0;
520 prog->MaxNativeAluInstructions = 0;
521 prog->MaxNativeTexInstructions = 0;
522 prog->MaxNativeTexIndirections = 0;
523 prog->MaxNativeAttribs = 0;
524 prog->MaxNativeTemps = 0;
525 prog->MaxNativeAddressRegs = 0;
526 prog->MaxNativeParameters = 0;
527
528 /* Set GLSL datatype range/precision info assuming IEEE float values.
529 * Drivers should override these defaults as needed.
530 */
531 prog->MediumFloat.RangeMin = 127;
532 prog->MediumFloat.RangeMax = 127;
533 prog->MediumFloat.Precision = 23;
534 prog->LowFloat = prog->HighFloat = prog->MediumFloat;
535
536 /* Assume ints are stored as floats for now, since this is the least-common
537 * denominator. The OpenGL ES spec implies (page 132) that the precision
538 * of integer types should be 0. Practically speaking, IEEE
539 * single-precision floating point values can only store integers in the
540 * range [-0x01000000, 0x01000000] without loss of precision.
541 */
542 prog->MediumInt.RangeMin = 24;
543 prog->MediumInt.RangeMax = 24;
544 prog->MediumInt.Precision = 0;
545 prog->LowInt = prog->HighInt = prog->MediumInt;
546
547 prog->MaxUniformBlocks = 12;
548 prog->MaxCombinedUniformComponents = (prog->MaxUniformComponents +
549 consts->MaxUniformBlockSize / 4 *
550 prog->MaxUniformBlocks);
551
552 prog->MaxAtomicBuffers = 0;
553 prog->MaxAtomicCounters = 0;
554 }
555
556
557 /**
558 * Initialize fields of gl_constants (aka ctx->Const.*).
559 * Use defaults from config.h. The device drivers will often override
560 * some of these values (such as number of texture units).
561 */
562 void
563 _mesa_init_constants(struct gl_constants *consts, gl_api api)
564 {
565 int i;
566 assert(consts);
567
568 /* Constants, may be overriden (usually only reduced) by device drivers */
569 consts->MaxTextureMbytes = MAX_TEXTURE_MBYTES;
570 consts->MaxTextureLevels = MAX_TEXTURE_LEVELS;
571 consts->Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
572 consts->MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
573 consts->MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
574 consts->MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
575 consts->MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
576 consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
577 consts->MaxTextureUnits = MIN2(consts->MaxTextureCoordUnits,
578 consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
579 consts->MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
580 consts->MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
581 consts->MaxTextureBufferSize = 65536;
582 consts->TextureBufferOffsetAlignment = 1;
583 consts->MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
584 consts->SubPixelBits = SUB_PIXEL_BITS;
585 consts->MinPointSize = MIN_POINT_SIZE;
586 consts->MaxPointSize = MAX_POINT_SIZE;
587 consts->MinPointSizeAA = MIN_POINT_SIZE;
588 consts->MaxPointSizeAA = MAX_POINT_SIZE;
589 consts->PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
590 consts->MinLineWidth = MIN_LINE_WIDTH;
591 consts->MaxLineWidth = MAX_LINE_WIDTH;
592 consts->MinLineWidthAA = MIN_LINE_WIDTH;
593 consts->MaxLineWidthAA = MAX_LINE_WIDTH;
594 consts->LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
595 consts->MaxClipPlanes = 6;
596 consts->MaxLights = MAX_LIGHTS;
597 consts->MaxShininess = 128.0;
598 consts->MaxSpotExponent = 128.0;
599 consts->MaxViewportWidth = MAX_VIEWPORT_WIDTH;
600 consts->MaxViewportHeight = MAX_VIEWPORT_HEIGHT;
601 consts->MinMapBufferAlignment = 64;
602
603 /* Driver must override these values if ARB_viewport_array is supported. */
604 consts->MaxViewports = 1;
605 consts->ViewportSubpixelBits = 0;
606 consts->ViewportBounds.Min = 0;
607 consts->ViewportBounds.Max = 0;
608
609 /** GL_ARB_uniform_buffer_object */
610 consts->MaxCombinedUniformBlocks = 36;
611 consts->MaxUniformBufferBindings = 36;
612 consts->MaxUniformBlockSize = 16384;
613 consts->UniformBufferOffsetAlignment = 1;
614
615 /* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */
616 consts->MaxUserAssignableUniformLocations =
617 4 * MESA_SHADER_STAGES * MAX_UNIFORMS;
618
619 for (i = 0; i < MESA_SHADER_STAGES; i++)
620 init_program_limits(consts, i, &consts->Program[i]);
621
622 consts->MaxProgramMatrices = MAX_PROGRAM_MATRICES;
623 consts->MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
624
625 /* Assume that if GLSL 1.30+ (or GLSL ES 3.00+) is supported that
626 * gl_VertexID is implemented using a native hardware register with OpenGL
627 * semantics.
628 */
629 consts->VertexID_is_zero_based = false;
630
631 /* CheckArrayBounds is overriden by drivers/x11 for X server */
632 consts->CheckArrayBounds = GL_FALSE;
633
634 /* GL_ARB_draw_buffers */
635 consts->MaxDrawBuffers = MAX_DRAW_BUFFERS;
636
637 consts->MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
638 consts->MaxRenderbufferSize = MAX_RENDERBUFFER_SIZE;
639
640 consts->Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
641 consts->MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
642 consts->MaxVarying = 16; /* old limit not to break tnl and swrast */
643 consts->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
644 consts->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;
645 consts->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;
646
647 /* Shading language version */
648 if (api == API_OPENGL_COMPAT || api == API_OPENGL_CORE) {
649 consts->GLSLVersion = 120;
650 _mesa_override_glsl_version(consts);
651 }
652 else if (api == API_OPENGLES2) {
653 consts->GLSLVersion = 100;
654 }
655 else if (api == API_OPENGLES) {
656 consts->GLSLVersion = 0; /* GLSL not supported */
657 }
658
659 /* GL_ARB_framebuffer_object */
660 consts->MaxSamples = 0;
661
662 /* GLSL default if NativeIntegers == FALSE */
663 consts->UniformBooleanTrue = FLT_AS_UINT(1.0f);
664
665 /* GL_ARB_sync */
666 consts->MaxServerWaitTimeout = 0x1fff7fffffffULL;
667
668 /* GL_EXT_provoking_vertex */
669 consts->QuadsFollowProvokingVertexConvention = GL_TRUE;
670
671 /* GL_EXT_transform_feedback */
672 consts->MaxTransformFeedbackBuffers = MAX_FEEDBACK_BUFFERS;
673 consts->MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;
674 consts->MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;
675 consts->MaxVertexStreams = 1;
676
677 /* GL 3.2 */
678 consts->ProfileMask = api == API_OPENGL_CORE
679 ? GL_CONTEXT_CORE_PROFILE_BIT
680 : GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
681
682 /* GL 4.4 */
683 consts->MaxVertexAttribStride = 2048;
684
685 /** GL_EXT_gpu_shader4 */
686 consts->MinProgramTexelOffset = -8;
687 consts->MaxProgramTexelOffset = 7;
688
689 /* GL_ARB_texture_gather */
690 consts->MinProgramTextureGatherOffset = -8;
691 consts->MaxProgramTextureGatherOffset = 7;
692
693 /* GL_ARB_robustness */
694 consts->ResetStrategy = GL_NO_RESET_NOTIFICATION_ARB;
695
696 /* PrimitiveRestart */
697 consts->PrimitiveRestartInSoftware = GL_FALSE;
698
699 /* ES 3.0 or ARB_ES3_compatibility */
700 consts->MaxElementIndex = 0xffffffffu;
701
702 /* GL_ARB_texture_multisample */
703 consts->MaxColorTextureSamples = 1;
704 consts->MaxDepthTextureSamples = 1;
705 consts->MaxIntegerSamples = 1;
706
707 /* GL_ARB_shader_atomic_counters */
708 consts->MaxAtomicBufferBindings = MAX_COMBINED_ATOMIC_BUFFERS;
709 consts->MaxAtomicBufferSize = MAX_ATOMIC_COUNTERS * ATOMIC_COUNTER_SIZE;
710 consts->MaxCombinedAtomicBuffers = MAX_COMBINED_ATOMIC_BUFFERS;
711 consts->MaxCombinedAtomicCounters = MAX_ATOMIC_COUNTERS;
712
713 /* GL_ARB_vertex_attrib_binding */
714 consts->MaxVertexAttribRelativeOffset = 2047;
715 consts->MaxVertexAttribBindings = MAX_VERTEX_GENERIC_ATTRIBS;
716
717 /* GL_ARB_compute_shader */
718 consts->MaxComputeWorkGroupCount[0] = 65535;
719 consts->MaxComputeWorkGroupCount[1] = 65535;
720 consts->MaxComputeWorkGroupCount[2] = 65535;
721 consts->MaxComputeWorkGroupSize[0] = 1024;
722 consts->MaxComputeWorkGroupSize[1] = 1024;
723 consts->MaxComputeWorkGroupSize[2] = 64;
724 consts->MaxComputeWorkGroupInvocations = 1024;
725
726 /** GL_ARB_gpu_shader5 */
727 consts->MinFragmentInterpolationOffset = MIN_FRAGMENT_INTERPOLATION_OFFSET;
728 consts->MaxFragmentInterpolationOffset = MAX_FRAGMENT_INTERPOLATION_OFFSET;
729 }
730
731
732 /**
733 * Do some sanity checks on the limits/constants for the given context.
734 * Only called the first time a context is bound.
735 */
736 static void
737 check_context_limits(struct gl_context *ctx)
738 {
739 /* check that we don't exceed the size of various bitfields */
740 assert(VARYING_SLOT_MAX <=
741 (8 * sizeof(ctx->VertexProgram._Current->Base.OutputsWritten)));
742 assert(VARYING_SLOT_MAX <=
743 (8 * sizeof(ctx->FragmentProgram._Current->Base.InputsRead)));
744
745 /* shader-related checks */
746 assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
747 assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
748
749 /* Texture unit checks */
750 assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits > 0);
751 assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
752 assert(ctx->Const.MaxTextureCoordUnits > 0);
753 assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
754 assert(ctx->Const.MaxTextureUnits > 0);
755 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
756 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
757 assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits,
758 ctx->Const.MaxTextureCoordUnits));
759 assert(ctx->Const.MaxCombinedTextureImageUnits > 0);
760 assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
761 assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
762 /* number of coord units cannot be greater than number of image units */
763 assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
764
765
766 /* Texture size checks */
767 assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
768 assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
769 assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
770 assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
771
772 /* Texture level checks */
773 assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
774 assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
775
776 /* Max texture size should be <= max viewport size (render to texture) */
777 assert((1U << (ctx->Const.MaxTextureLevels - 1))
778 <= ctx->Const.MaxViewportWidth);
779 assert((1U << (ctx->Const.MaxTextureLevels - 1))
780 <= ctx->Const.MaxViewportHeight);
781
782 assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
783
784 /* if this fails, add more enum values to gl_buffer_index */
785 assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);
786
787 /* XXX probably add more tests */
788 }
789
790
791 /**
792 * Initialize the attribute groups in a GL context.
793 *
794 * \param ctx GL context.
795 *
796 * Initializes all the attributes, calling the respective <tt>init*</tt>
797 * functions for the more complex data structures.
798 */
799 static GLboolean
800 init_attrib_groups(struct gl_context *ctx)
801 {
802 assert(ctx);
803
804 /* Constants */
805 _mesa_init_constants(&ctx->Const, ctx->API);
806
807 /* Extensions */
808 _mesa_init_extensions(&ctx->Extensions);
809
810 /* Attribute Groups */
811 _mesa_init_accum( ctx );
812 _mesa_init_attrib( ctx );
813 _mesa_init_buffer_objects( ctx );
814 _mesa_init_color( ctx );
815 _mesa_init_current( ctx );
816 _mesa_init_depth( ctx );
817 _mesa_init_debug( ctx );
818 _mesa_init_display_list( ctx );
819 _mesa_init_errors( ctx );
820 _mesa_init_eval( ctx );
821 _mesa_init_fbobjects( ctx );
822 _mesa_init_feedback( ctx );
823 _mesa_init_fog( ctx );
824 _mesa_init_hint( ctx );
825 _mesa_init_line( ctx );
826 _mesa_init_lighting( ctx );
827 _mesa_init_matrix( ctx );
828 _mesa_init_multisample( ctx );
829 _mesa_init_performance_monitors( ctx );
830 _mesa_init_pipeline( ctx );
831 _mesa_init_pixel( ctx );
832 _mesa_init_pixelstore( ctx );
833 _mesa_init_point( ctx );
834 _mesa_init_polygon( ctx );
835 _mesa_init_program( ctx );
836 _mesa_init_queryobj( ctx );
837 _mesa_init_sync( ctx );
838 _mesa_init_rastpos( ctx );
839 _mesa_init_scissor( ctx );
840 _mesa_init_shader_state( ctx );
841 _mesa_init_stencil( ctx );
842 _mesa_init_transform( ctx );
843 _mesa_init_transform_feedback( ctx );
844 _mesa_init_varray( ctx );
845 _mesa_init_viewport( ctx );
846
847 if (!_mesa_init_texture( ctx ))
848 return GL_FALSE;
849
850 _mesa_init_texture_s3tc( ctx );
851
852 /* Miscellaneous */
853 ctx->NewState = _NEW_ALL;
854 ctx->NewDriverState = ~0;
855 ctx->ErrorValue = GL_NO_ERROR;
856 ctx->ShareGroupReset = false;
857 ctx->varying_vp_inputs = VERT_BIT_ALL;
858
859 return GL_TRUE;
860 }
861
862
863 /**
864 * Update default objects in a GL context with respect to shared state.
865 *
866 * \param ctx GL context.
867 *
868 * Removes references to old default objects, (texture objects, program
869 * objects, etc.) and changes to reference those from the current shared
870 * state.
871 */
872 static GLboolean
873 update_default_objects(struct gl_context *ctx)
874 {
875 assert(ctx);
876
877 _mesa_update_default_objects_program(ctx);
878 _mesa_update_default_objects_texture(ctx);
879 _mesa_update_default_objects_buffer_objects(ctx);
880
881 return GL_TRUE;
882 }
883
884
885 /**
886 * This is the default function we plug into all dispatch table slots
887 * This helps prevents a segfault when someone calls a GL function without
888 * first checking if the extension's supported.
889 */
890 int
891 _mesa_generic_nop(void)
892 {
893 GET_CURRENT_CONTEXT(ctx);
894 _mesa_error(ctx, GL_INVALID_OPERATION,
895 "unsupported function called "
896 "(unsupported extension or deprecated function?)");
897 return 0;
898 }
899
900
901 /**
902 * Allocate and initialize a new dispatch table.
903 */
904 struct _glapi_table *
905 _mesa_alloc_dispatch_table()
906 {
907 /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
908 * In practice, this'll be the same for stand-alone Mesa. But for DRI
909 * Mesa we do this to accomodate different versions of libGL and various
910 * DRI drivers.
911 */
912 GLint numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);
913 struct _glapi_table *table;
914
915 table = malloc(numEntries * sizeof(_glapi_proc));
916 if (table) {
917 _glapi_proc *entry = (_glapi_proc *) table;
918 GLint i;
919 for (i = 0; i < numEntries; i++) {
920 entry[i] = (_glapi_proc) _mesa_generic_nop;
921 }
922 }
923 return table;
924 }
925
926 /**
927 * Creates a minimal dispatch table for use within glBegin()/glEnd().
928 *
929 * This ensures that we generate GL_INVALID_OPERATION errors from most
930 * functions, since the set of functions that are valid within Begin/End is
931 * very small.
932 *
933 * From the GL 1.0 specification section 2.6.3, "GL Commands within
934 * Begin/End"
935 *
936 * "The only GL commands that are allowed within any Begin/End pairs are
937 * the commands for specifying vertex coordinates, vertex color, normal
938 * coordinates, and texture coordinates (Vertex, Color, Index, Normal,
939 * TexCoord), EvalCoord and EvalPoint commands (see section 5.1),
940 * commands for specifying lighting material parameters (Material
941 * commands see section 2.12.2), display list invocation commands
942 * (CallList and CallLists see section 5.4), and the EdgeFlag
943 * command. Executing Begin after Begin has already been executed but
944 * before an End is issued generates the INVALID OPERATION error, as does
945 * executing End without a previous corresponding Begin. Executing any
946 * other GL command within Begin/End results in the error INVALID
947 * OPERATION."
948 *
949 * The table entries for specifying vertex attributes are set up by
950 * install_vtxfmt() and _mesa_loopback_init_api_table(), and End() and dlists
951 * are set by install_vtxfmt() as well.
952 */
953 static struct _glapi_table *
954 create_beginend_table(const struct gl_context *ctx)
955 {
956 struct _glapi_table *table;
957
958 table = _mesa_alloc_dispatch_table();
959 if (!table)
960 return NULL;
961
962 /* Fill in functions which return a value, since they should return some
963 * specific value even if they emit a GL_INVALID_OPERATION error from them
964 * being called within glBegin()/glEnd().
965 */
966 #define COPY_DISPATCH(func) SET_##func(table, GET_##func(ctx->Exec))
967
968 COPY_DISPATCH(GenLists);
969 COPY_DISPATCH(IsProgram);
970 COPY_DISPATCH(IsVertexArray);
971 COPY_DISPATCH(IsBuffer);
972 COPY_DISPATCH(IsEnabled);
973 COPY_DISPATCH(IsEnabledi);
974 COPY_DISPATCH(IsRenderbuffer);
975 COPY_DISPATCH(IsFramebuffer);
976 COPY_DISPATCH(CheckFramebufferStatus);
977 COPY_DISPATCH(RenderMode);
978 COPY_DISPATCH(GetString);
979 COPY_DISPATCH(GetStringi);
980 COPY_DISPATCH(GetPointerv);
981 COPY_DISPATCH(IsQuery);
982 COPY_DISPATCH(IsSampler);
983 COPY_DISPATCH(IsSync);
984 COPY_DISPATCH(IsTexture);
985 COPY_DISPATCH(IsTransformFeedback);
986 COPY_DISPATCH(DeleteQueries);
987 COPY_DISPATCH(AreTexturesResident);
988 COPY_DISPATCH(FenceSync);
989 COPY_DISPATCH(ClientWaitSync);
990 COPY_DISPATCH(MapBuffer);
991 COPY_DISPATCH(UnmapBuffer);
992 COPY_DISPATCH(MapBufferRange);
993 COPY_DISPATCH(ObjectPurgeableAPPLE);
994 COPY_DISPATCH(ObjectUnpurgeableAPPLE);
995
996 _mesa_loopback_init_api_table(ctx, table);
997
998 return table;
999 }
1000
1001 void
1002 _mesa_initialize_dispatch_tables(struct gl_context *ctx)
1003 {
1004 /* Do the code-generated setup of the exec table in api_exec.c. */
1005 _mesa_initialize_exec_table(ctx);
1006
1007 if (ctx->Save)
1008 _mesa_initialize_save_table(ctx);
1009 }
1010
1011 /**
1012 * Initialize a struct gl_context struct (rendering context).
1013 *
1014 * This includes allocating all the other structs and arrays which hang off of
1015 * the context by pointers.
1016 * Note that the driver needs to pass in its dd_function_table here since
1017 * we need to at least call driverFunctions->NewTextureObject to create the
1018 * default texture objects.
1019 *
1020 * Called by _mesa_create_context().
1021 *
1022 * Performs the imports and exports callback tables initialization, and
1023 * miscellaneous one-time initializations. If no shared context is supplied one
1024 * is allocated, and increase its reference count. Setups the GL API dispatch
1025 * tables. Initialize the TNL module. Sets the maximum Z buffer depth.
1026 * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1027 * for debug flags.
1028 *
1029 * \param ctx the context to initialize
1030 * \param api the GL API type to create the context for
1031 * \param visual describes the visual attributes for this context or NULL to
1032 * create a configless context
1033 * \param share_list points to context to share textures, display lists,
1034 * etc with, or NULL
1035 * \param driverFunctions table of device driver functions for this context
1036 * to use
1037 */
1038 GLboolean
1039 _mesa_initialize_context(struct gl_context *ctx,
1040 gl_api api,
1041 const struct gl_config *visual,
1042 struct gl_context *share_list,
1043 const struct dd_function_table *driverFunctions)
1044 {
1045 struct gl_shared_state *shared;
1046 int i;
1047
1048 assert(driverFunctions->NewTextureObject);
1049 assert(driverFunctions->FreeTextureImageBuffer);
1050
1051 ctx->API = api;
1052 ctx->DrawBuffer = NULL;
1053 ctx->ReadBuffer = NULL;
1054 ctx->WinSysDrawBuffer = NULL;
1055 ctx->WinSysReadBuffer = NULL;
1056
1057 if (visual) {
1058 ctx->Visual = *visual;
1059 ctx->HasConfig = GL_TRUE;
1060 }
1061 else {
1062 memset(&ctx->Visual, 0, sizeof ctx->Visual);
1063 ctx->HasConfig = GL_FALSE;
1064 }
1065
1066 if (_mesa_is_desktop_gl(ctx)) {
1067 _mesa_override_gl_version(ctx);
1068 }
1069
1070 /* misc one-time initializations */
1071 one_time_init(ctx);
1072
1073 /* Plug in driver functions and context pointer here.
1074 * This is important because when we call alloc_shared_state() below
1075 * we'll call ctx->Driver.NewTextureObject() to create the default
1076 * textures.
1077 */
1078 ctx->Driver = *driverFunctions;
1079
1080 if (share_list) {
1081 /* share state with another context */
1082 shared = share_list->Shared;
1083 }
1084 else {
1085 /* allocate new, unshared state */
1086 shared = _mesa_alloc_shared_state(ctx);
1087 if (!shared)
1088 return GL_FALSE;
1089 }
1090
1091 _mesa_reference_shared_state(ctx, &ctx->Shared, shared);
1092
1093 if (!init_attrib_groups( ctx ))
1094 goto fail;
1095
1096 /* setup the API dispatch tables with all nop functions */
1097 ctx->OutsideBeginEnd = _mesa_alloc_dispatch_table();
1098 if (!ctx->OutsideBeginEnd)
1099 goto fail;
1100 ctx->Exec = ctx->OutsideBeginEnd;
1101 ctx->CurrentDispatch = ctx->OutsideBeginEnd;
1102
1103 ctx->FragmentProgram._MaintainTexEnvProgram
1104 = (_mesa_getenv("MESA_TEX_PROG") != NULL);
1105
1106 ctx->VertexProgram._MaintainTnlProgram
1107 = (_mesa_getenv("MESA_TNL_PROG") != NULL);
1108 if (ctx->VertexProgram._MaintainTnlProgram) {
1109 /* this is required... */
1110 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1111 }
1112
1113 /* Mesa core handles all the formats that mesa core knows about.
1114 * Drivers will want to override this list with just the formats
1115 * they can handle, and confirm that appropriate fallbacks exist in
1116 * _mesa_choose_tex_format().
1117 */
1118 memset(&ctx->TextureFormatSupported, GL_TRUE,
1119 sizeof(ctx->TextureFormatSupported));
1120
1121 switch (ctx->API) {
1122 case API_OPENGL_COMPAT:
1123 ctx->BeginEnd = create_beginend_table(ctx);
1124 ctx->Save = _mesa_alloc_dispatch_table();
1125 if (!ctx->BeginEnd || !ctx->Save)
1126 goto fail;
1127
1128 /* fall-through */
1129 case API_OPENGL_CORE:
1130 break;
1131 case API_OPENGLES:
1132 /**
1133 * GL_OES_texture_cube_map says
1134 * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
1135 */
1136 for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
1137 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
1138 texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
1139 texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
1140 texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
1141 texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1142 texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1143 texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1144 }
1145 break;
1146 case API_OPENGLES2:
1147 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1148 ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
1149 break;
1150 }
1151
1152 ctx->FirstTimeCurrent = GL_TRUE;
1153
1154 return GL_TRUE;
1155
1156 fail:
1157 _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1158 free(ctx->BeginEnd);
1159 free(ctx->OutsideBeginEnd);
1160 free(ctx->Save);
1161 return GL_FALSE;
1162 }
1163
1164
1165 /**
1166 * Allocate and initialize a struct gl_context structure.
1167 * Note that the driver needs to pass in its dd_function_table here since
1168 * we need to at least call driverFunctions->NewTextureObject to initialize
1169 * the rendering context.
1170 *
1171 * \param api the GL API type to create the context for
1172 * \param visual a struct gl_config pointer (we copy the struct contents) or
1173 * NULL to create a configless context
1174 * \param share_list another context to share display lists with or NULL
1175 * \param driverFunctions points to the dd_function_table into which the
1176 * driver has plugged in all its special functions.
1177 *
1178 * \return pointer to a new __struct gl_contextRec or NULL if error.
1179 */
1180 struct gl_context *
1181 _mesa_create_context(gl_api api,
1182 const struct gl_config *visual,
1183 struct gl_context *share_list,
1184 const struct dd_function_table *driverFunctions)
1185 {
1186 struct gl_context *ctx;
1187
1188 ctx = calloc(1, sizeof(struct gl_context));
1189 if (!ctx)
1190 return NULL;
1191
1192 if (_mesa_initialize_context(ctx, api, visual, share_list,
1193 driverFunctions)) {
1194 return ctx;
1195 }
1196 else {
1197 free(ctx);
1198 return NULL;
1199 }
1200 }
1201
1202
1203 /**
1204 * Free the data associated with the given context.
1205 *
1206 * But doesn't free the struct gl_context struct itself.
1207 *
1208 * \sa _mesa_initialize_context() and init_attrib_groups().
1209 */
1210 void
1211 _mesa_free_context_data( struct gl_context *ctx )
1212 {
1213 if (!_mesa_get_current_context()){
1214 /* No current context, but we may need one in order to delete
1215 * texture objs, etc. So temporarily bind the context now.
1216 */
1217 _mesa_make_current(ctx, NULL, NULL);
1218 }
1219
1220 /* unreference WinSysDraw/Read buffers */
1221 _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
1222 _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
1223 _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
1224 _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
1225
1226 _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
1227 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
1228 _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL);
1229
1230 _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current, NULL);
1231 _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current, NULL);
1232
1233 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
1234 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
1235 _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
1236
1237 _mesa_reference_vao(ctx, &ctx->Array.VAO, NULL);
1238 _mesa_reference_vao(ctx, &ctx->Array.DefaultVAO, NULL);
1239
1240 _mesa_free_attrib_data(ctx);
1241 _mesa_free_buffer_objects(ctx);
1242 _mesa_free_lighting_data( ctx );
1243 _mesa_free_eval_data( ctx );
1244 _mesa_free_texture_data( ctx );
1245 _mesa_free_matrix_data( ctx );
1246 _mesa_free_viewport_data( ctx );
1247 _mesa_free_pipeline_data(ctx);
1248 _mesa_free_program_data(ctx);
1249 _mesa_free_shader_state(ctx);
1250 _mesa_free_queryobj_data(ctx);
1251 _mesa_free_sync_data(ctx);
1252 _mesa_free_varray_data(ctx);
1253 _mesa_free_transform_feedback(ctx);
1254 _mesa_free_performance_monitors(ctx);
1255
1256 _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
1257 _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
1258 _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
1259 _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
1260
1261 /* free dispatch tables */
1262 free(ctx->BeginEnd);
1263 free(ctx->OutsideBeginEnd);
1264 free(ctx->Save);
1265
1266 /* Shared context state (display lists, textures, etc) */
1267 _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1268
1269 /* needs to be after freeing shared state */
1270 _mesa_free_display_list_data(ctx);
1271
1272 _mesa_free_errors_data(ctx);
1273
1274 free((void *)ctx->Extensions.String);
1275
1276 free(ctx->VersionString);
1277
1278 /* unbind the context if it's currently bound */
1279 if (ctx == _mesa_get_current_context()) {
1280 _mesa_make_current(NULL, NULL, NULL);
1281 }
1282 }
1283
1284
1285 /**
1286 * Destroy a struct gl_context structure.
1287 *
1288 * \param ctx GL context.
1289 *
1290 * Calls _mesa_free_context_data() and frees the gl_context object itself.
1291 */
1292 void
1293 _mesa_destroy_context( struct gl_context *ctx )
1294 {
1295 if (ctx) {
1296 _mesa_free_context_data(ctx);
1297 free( (void *) ctx );
1298 }
1299 }
1300
1301
1302 /**
1303 * Copy attribute groups from one context to another.
1304 *
1305 * \param src source context
1306 * \param dst destination context
1307 * \param mask bitwise OR of GL_*_BIT flags
1308 *
1309 * According to the bits specified in \p mask, copies the corresponding
1310 * attributes from \p src into \p dst. For many of the attributes a simple \c
1311 * memcpy is not enough due to the existence of internal pointers in their data
1312 * structures.
1313 */
1314 void
1315 _mesa_copy_context( const struct gl_context *src, struct gl_context *dst,
1316 GLuint mask )
1317 {
1318 if (mask & GL_ACCUM_BUFFER_BIT) {
1319 /* OK to memcpy */
1320 dst->Accum = src->Accum;
1321 }
1322 if (mask & GL_COLOR_BUFFER_BIT) {
1323 /* OK to memcpy */
1324 dst->Color = src->Color;
1325 }
1326 if (mask & GL_CURRENT_BIT) {
1327 /* OK to memcpy */
1328 dst->Current = src->Current;
1329 }
1330 if (mask & GL_DEPTH_BUFFER_BIT) {
1331 /* OK to memcpy */
1332 dst->Depth = src->Depth;
1333 }
1334 if (mask & GL_ENABLE_BIT) {
1335 /* no op */
1336 }
1337 if (mask & GL_EVAL_BIT) {
1338 /* OK to memcpy */
1339 dst->Eval = src->Eval;
1340 }
1341 if (mask & GL_FOG_BIT) {
1342 /* OK to memcpy */
1343 dst->Fog = src->Fog;
1344 }
1345 if (mask & GL_HINT_BIT) {
1346 /* OK to memcpy */
1347 dst->Hint = src->Hint;
1348 }
1349 if (mask & GL_LIGHTING_BIT) {
1350 GLuint i;
1351 /* begin with memcpy */
1352 dst->Light = src->Light;
1353 /* fixup linked lists to prevent pointer insanity */
1354 make_empty_list( &(dst->Light.EnabledList) );
1355 for (i = 0; i < MAX_LIGHTS; i++) {
1356 if (dst->Light.Light[i].Enabled) {
1357 insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
1358 }
1359 }
1360 }
1361 if (mask & GL_LINE_BIT) {
1362 /* OK to memcpy */
1363 dst->Line = src->Line;
1364 }
1365 if (mask & GL_LIST_BIT) {
1366 /* OK to memcpy */
1367 dst->List = src->List;
1368 }
1369 if (mask & GL_PIXEL_MODE_BIT) {
1370 /* OK to memcpy */
1371 dst->Pixel = src->Pixel;
1372 }
1373 if (mask & GL_POINT_BIT) {
1374 /* OK to memcpy */
1375 dst->Point = src->Point;
1376 }
1377 if (mask & GL_POLYGON_BIT) {
1378 /* OK to memcpy */
1379 dst->Polygon = src->Polygon;
1380 }
1381 if (mask & GL_POLYGON_STIPPLE_BIT) {
1382 /* Use loop instead of memcpy due to problem with Portland Group's
1383 * C compiler. Reported by John Stone.
1384 */
1385 GLuint i;
1386 for (i = 0; i < 32; i++) {
1387 dst->PolygonStipple[i] = src->PolygonStipple[i];
1388 }
1389 }
1390 if (mask & GL_SCISSOR_BIT) {
1391 /* OK to memcpy */
1392 dst->Scissor = src->Scissor;
1393 }
1394 if (mask & GL_STENCIL_BUFFER_BIT) {
1395 /* OK to memcpy */
1396 dst->Stencil = src->Stencil;
1397 }
1398 if (mask & GL_TEXTURE_BIT) {
1399 /* Cannot memcpy because of pointers */
1400 _mesa_copy_texture_state(src, dst);
1401 }
1402 if (mask & GL_TRANSFORM_BIT) {
1403 /* OK to memcpy */
1404 dst->Transform = src->Transform;
1405 }
1406 if (mask & GL_VIEWPORT_BIT) {
1407 /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
1408 unsigned i;
1409 for (i = 0; i < src->Const.MaxViewports; i++) {
1410 dst->ViewportArray[i].X = src->ViewportArray[i].X;
1411 dst->ViewportArray[i].Y = src->ViewportArray[i].Y;
1412 dst->ViewportArray[i].Width = src->ViewportArray[i].Width;
1413 dst->ViewportArray[i].Height = src->ViewportArray[i].Height;
1414 dst->ViewportArray[i].Near = src->ViewportArray[i].Near;
1415 dst->ViewportArray[i].Far = src->ViewportArray[i].Far;
1416 _math_matrix_copy(&dst->ViewportArray[i]._WindowMap,
1417 &src->ViewportArray[i]._WindowMap);
1418 }
1419 }
1420
1421 /* XXX FIXME: Call callbacks?
1422 */
1423 dst->NewState = _NEW_ALL;
1424 dst->NewDriverState = ~0;
1425 }
1426
1427
1428 /**
1429 * Check if the given context can render into the given framebuffer
1430 * by checking visual attributes.
1431 *
1432 * Most of these tests could go away because Mesa is now pretty flexible
1433 * in terms of mixing rendering contexts with framebuffers. As long
1434 * as RGB vs. CI mode agree, we're probably good.
1435 *
1436 * \return GL_TRUE if compatible, GL_FALSE otherwise.
1437 */
1438 static GLboolean
1439 check_compatible(const struct gl_context *ctx,
1440 const struct gl_framebuffer *buffer)
1441 {
1442 const struct gl_config *ctxvis = &ctx->Visual;
1443 const struct gl_config *bufvis = &buffer->Visual;
1444
1445 if (buffer == _mesa_get_incomplete_framebuffer())
1446 return GL_TRUE;
1447
1448 #if 0
1449 /* disabling this fixes the fgl_glxgears pbuffer demo */
1450 if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
1451 return GL_FALSE;
1452 #endif
1453 if (ctxvis->stereoMode && !bufvis->stereoMode)
1454 return GL_FALSE;
1455 if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
1456 return GL_FALSE;
1457 if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
1458 return GL_FALSE;
1459 if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
1460 return GL_FALSE;
1461 if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
1462 return GL_FALSE;
1463 if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
1464 return GL_FALSE;
1465 if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
1466 return GL_FALSE;
1467 #if 0
1468 /* disabled (see bug 11161) */
1469 if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
1470 return GL_FALSE;
1471 #endif
1472 if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
1473 return GL_FALSE;
1474
1475 return GL_TRUE;
1476 }
1477
1478
1479 /**
1480 * Check if the viewport/scissor size has not yet been initialized.
1481 * Initialize the size if the given width and height are non-zero.
1482 */
1483 void
1484 _mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
1485 {
1486 if (!ctx->ViewportInitialized && width > 0 && height > 0) {
1487 unsigned i;
1488
1489 /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
1490 * potential infinite recursion.
1491 */
1492 ctx->ViewportInitialized = GL_TRUE;
1493
1494 /* Note: ctx->Const.MaxViewports may not have been set by the driver
1495 * yet, so just initialize all of them.
1496 */
1497 for (i = 0; i < MAX_VIEWPORTS; i++) {
1498 _mesa_set_viewport(ctx, i, 0, 0, width, height);
1499 _mesa_set_scissor(ctx, i, 0, 0, width, height);
1500 }
1501 }
1502 }
1503
1504 static void
1505 handle_first_current(struct gl_context *ctx)
1506 {
1507 GLenum buffer;
1508 GLint bufferIndex;
1509
1510 assert(ctx->Version > 0);
1511
1512 ctx->Extensions.String = _mesa_make_extension_string(ctx);
1513
1514 check_context_limits(ctx);
1515
1516 /* According to GL_MESA_configless_context the default value of
1517 * glDrawBuffers depends on the config of the first surface it is bound to.
1518 * For GLES it is always GL_BACK which has a magic interpretation */
1519 if (!ctx->HasConfig && _mesa_is_desktop_gl(ctx)) {
1520 if (ctx->DrawBuffer != _mesa_get_incomplete_framebuffer()) {
1521 if (ctx->DrawBuffer->Visual.doubleBufferMode)
1522 buffer = GL_BACK;
1523 else
1524 buffer = GL_FRONT;
1525
1526 _mesa_drawbuffers(ctx, 1, &buffer, NULL /* destMask */);
1527 }
1528
1529 if (ctx->ReadBuffer != _mesa_get_incomplete_framebuffer()) {
1530 if (ctx->ReadBuffer->Visual.doubleBufferMode) {
1531 buffer = GL_BACK;
1532 bufferIndex = BUFFER_BACK_LEFT;
1533 }
1534 else {
1535 buffer = GL_FRONT;
1536 bufferIndex = BUFFER_FRONT_LEFT;
1537 }
1538
1539 _mesa_readbuffer(ctx, buffer, bufferIndex);
1540 }
1541 }
1542
1543 /* We can use this to help debug user's problems. Tell them to set
1544 * the MESA_INFO env variable before running their app. Then the
1545 * first time each context is made current we'll print some useful
1546 * information.
1547 */
1548 if (_mesa_getenv("MESA_INFO")) {
1549 _mesa_print_info(ctx);
1550 }
1551 }
1552
1553 /**
1554 * Bind the given context to the given drawBuffer and readBuffer and
1555 * make it the current context for the calling thread.
1556 * We'll render into the drawBuffer and read pixels from the
1557 * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1558 *
1559 * We check that the context's and framebuffer's visuals are compatible
1560 * and return immediately if they're not.
1561 *
1562 * \param newCtx the new GL context. If NULL then there will be no current GL
1563 * context.
1564 * \param drawBuffer the drawing framebuffer
1565 * \param readBuffer the reading framebuffer
1566 */
1567 GLboolean
1568 _mesa_make_current( struct gl_context *newCtx,
1569 struct gl_framebuffer *drawBuffer,
1570 struct gl_framebuffer *readBuffer )
1571 {
1572 GET_CURRENT_CONTEXT(curCtx);
1573
1574 if (MESA_VERBOSE & VERBOSE_API)
1575 _mesa_debug(newCtx, "_mesa_make_current()\n");
1576
1577 /* Check that the context's and framebuffer's visuals are compatible.
1578 */
1579 if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1580 if (!check_compatible(newCtx, drawBuffer)) {
1581 _mesa_warning(newCtx,
1582 "MakeCurrent: incompatible visuals for context and drawbuffer");
1583 return GL_FALSE;
1584 }
1585 }
1586 if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1587 if (!check_compatible(newCtx, readBuffer)) {
1588 _mesa_warning(newCtx,
1589 "MakeCurrent: incompatible visuals for context and readbuffer");
1590 return GL_FALSE;
1591 }
1592 }
1593
1594 if (curCtx &&
1595 (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) &&
1596 /* make sure this context is valid for flushing */
1597 curCtx != newCtx)
1598 _mesa_flush(curCtx);
1599
1600 /* We used to call _glapi_check_multithread() here. Now do it in drivers */
1601 _glapi_set_context((void *) newCtx);
1602 ASSERT(_mesa_get_current_context() == newCtx);
1603
1604 if (!newCtx) {
1605 _glapi_set_dispatch(NULL); /* none current */
1606 }
1607 else {
1608 _glapi_set_dispatch(newCtx->CurrentDispatch);
1609
1610 if (drawBuffer && readBuffer) {
1611 ASSERT(_mesa_is_winsys_fbo(drawBuffer));
1612 ASSERT(_mesa_is_winsys_fbo(readBuffer));
1613 _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1614 _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1615
1616 /*
1617 * Only set the context's Draw/ReadBuffer fields if they're NULL
1618 * or not bound to a user-created FBO.
1619 */
1620 if (!newCtx->DrawBuffer || _mesa_is_winsys_fbo(newCtx->DrawBuffer)) {
1621 _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1622 /* Update the FBO's list of drawbuffers/renderbuffers.
1623 * For winsys FBOs this comes from the GL state (which may have
1624 * changed since the last time this FBO was bound).
1625 */
1626 _mesa_update_draw_buffers(newCtx);
1627 }
1628 if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) {
1629 _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1630 }
1631
1632 /* XXX only set this flag if we're really changing the draw/read
1633 * framebuffer bindings.
1634 */
1635 newCtx->NewState |= _NEW_BUFFERS;
1636
1637 if (drawBuffer) {
1638 _mesa_check_init_viewport(newCtx,
1639 drawBuffer->Width, drawBuffer->Height);
1640 }
1641 }
1642
1643 if (newCtx->FirstTimeCurrent) {
1644 handle_first_current(newCtx);
1645 newCtx->FirstTimeCurrent = GL_FALSE;
1646 }
1647 }
1648
1649 return GL_TRUE;
1650 }
1651
1652
1653 /**
1654 * Make context 'ctx' share the display lists, textures and programs
1655 * that are associated with 'ctxToShare'.
1656 * Any display lists, textures or programs associated with 'ctx' will
1657 * be deleted if nobody else is sharing them.
1658 */
1659 GLboolean
1660 _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
1661 {
1662 if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1663 struct gl_shared_state *oldShared = NULL;
1664
1665 /* save ref to old state to prevent it from being deleted immediately */
1666 _mesa_reference_shared_state(ctx, &oldShared, ctx->Shared);
1667
1668 /* update ctx's Shared pointer */
1669 _mesa_reference_shared_state(ctx, &ctx->Shared, ctxToShare->Shared);
1670
1671 update_default_objects(ctx);
1672
1673 /* release the old shared state */
1674 _mesa_reference_shared_state(ctx, &oldShared, NULL);
1675
1676 return GL_TRUE;
1677 }
1678 else {
1679 return GL_FALSE;
1680 }
1681 }
1682
1683
1684
1685 /**
1686 * \return pointer to the current GL context for this thread.
1687 *
1688 * Calls _glapi_get_context(). This isn't the fastest way to get the current
1689 * context. If you need speed, see the #GET_CURRENT_CONTEXT macro in
1690 * context.h.
1691 */
1692 struct gl_context *
1693 _mesa_get_current_context( void )
1694 {
1695 return (struct gl_context *) _glapi_get_context();
1696 }
1697
1698
1699 /**
1700 * Get context's current API dispatch table.
1701 *
1702 * It'll either be the immediate-mode execute dispatcher or the display list
1703 * compile dispatcher.
1704 *
1705 * \param ctx GL context.
1706 *
1707 * \return pointer to dispatch_table.
1708 *
1709 * Simply returns __struct gl_contextRec::CurrentDispatch.
1710 */
1711 struct _glapi_table *
1712 _mesa_get_dispatch(struct gl_context *ctx)
1713 {
1714 return ctx->CurrentDispatch;
1715 }
1716
1717 /*@}*/
1718
1719
1720 /**********************************************************************/
1721 /** \name Miscellaneous functions */
1722 /**********************************************************************/
1723 /*@{*/
1724
1725 /**
1726 * Record an error.
1727 *
1728 * \param ctx GL context.
1729 * \param error error code.
1730 *
1731 * Records the given error code and call the driver's dd_function_table::Error
1732 * function if defined.
1733 *
1734 * \sa
1735 * This is called via _mesa_error().
1736 */
1737 void
1738 _mesa_record_error(struct gl_context *ctx, GLenum error)
1739 {
1740 if (!ctx)
1741 return;
1742
1743 if (ctx->ErrorValue == GL_NO_ERROR) {
1744 ctx->ErrorValue = error;
1745 }
1746 }
1747
1748
1749 /**
1750 * Flush commands and wait for completion.
1751 */
1752 void
1753 _mesa_finish(struct gl_context *ctx)
1754 {
1755 FLUSH_VERTICES( ctx, 0 );
1756 FLUSH_CURRENT( ctx, 0 );
1757 if (ctx->Driver.Finish) {
1758 ctx->Driver.Finish(ctx);
1759 }
1760 }
1761
1762
1763 /**
1764 * Flush commands.
1765 */
1766 void
1767 _mesa_flush(struct gl_context *ctx)
1768 {
1769 FLUSH_VERTICES( ctx, 0 );
1770 FLUSH_CURRENT( ctx, 0 );
1771 if (ctx->Driver.Flush) {
1772 ctx->Driver.Flush(ctx);
1773 }
1774 }
1775
1776
1777
1778 /**
1779 * Execute glFinish().
1780 *
1781 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1782 * dd_function_table::Finish driver callback, if not NULL.
1783 */
1784 void GLAPIENTRY
1785 _mesa_Finish(void)
1786 {
1787 GET_CURRENT_CONTEXT(ctx);
1788 ASSERT_OUTSIDE_BEGIN_END(ctx);
1789 _mesa_finish(ctx);
1790 }
1791
1792
1793 /**
1794 * Execute glFlush().
1795 *
1796 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1797 * dd_function_table::Flush driver callback, if not NULL.
1798 */
1799 void GLAPIENTRY
1800 _mesa_Flush(void)
1801 {
1802 GET_CURRENT_CONTEXT(ctx);
1803 ASSERT_OUTSIDE_BEGIN_END(ctx);
1804 _mesa_flush(ctx);
1805 }
1806
1807
1808 /*
1809 * ARB_blend_func_extended - ERRORS section
1810 * "The error INVALID_OPERATION is generated by Begin or any procedure that
1811 * implicitly calls Begin if any draw buffer has a blend function requiring the
1812 * second color input (SRC1_COLOR, ONE_MINUS_SRC1_COLOR, SRC1_ALPHA or
1813 * ONE_MINUS_SRC1_ALPHA), and a framebuffer is bound that has more than
1814 * the value of MAX_DUAL_SOURCE_DRAW_BUFFERS-1 active color attachements."
1815 */
1816 static GLboolean
1817 _mesa_check_blend_func_error(struct gl_context *ctx)
1818 {
1819 GLuint i;
1820 for (i = ctx->Const.MaxDualSourceDrawBuffers;
1821 i < ctx->DrawBuffer->_NumColorDrawBuffers;
1822 i++) {
1823 if (ctx->Color.Blend[i]._UsesDualSrc) {
1824 _mesa_error(ctx, GL_INVALID_OPERATION,
1825 "dual source blend on illegal attachment");
1826 return GL_FALSE;
1827 }
1828 }
1829 return GL_TRUE;
1830 }
1831
1832 static bool
1833 shader_linked_or_absent(struct gl_context *ctx,
1834 const struct gl_shader_program *shProg,
1835 bool *shader_present, const char *where)
1836 {
1837 if (shProg) {
1838 *shader_present = true;
1839
1840 if (!shProg->LinkStatus) {
1841 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(shader not linked)", where);
1842 return false;
1843 }
1844 #if 0 /* not normally enabled */
1845 {
1846 char errMsg[100];
1847 if (!_mesa_validate_shader_program(ctx, shProg, errMsg)) {
1848 _mesa_warning(ctx, "Shader program %u is invalid: %s",
1849 shProg->Name, errMsg);
1850 }
1851 }
1852 #endif
1853 }
1854
1855 return true;
1856 }
1857
1858 /**
1859 * Prior to drawing anything with glBegin, glDrawArrays, etc. this function
1860 * is called to see if it's valid to render. This involves checking that
1861 * the current shader is valid and the framebuffer is complete.
1862 * It also check the current pipeline object is valid if any.
1863 * If an error is detected it'll be recorded here.
1864 * \return GL_TRUE if OK to render, GL_FALSE if not
1865 */
1866 GLboolean
1867 _mesa_valid_to_render(struct gl_context *ctx, const char *where)
1868 {
1869 bool from_glsl_shader[MESA_SHADER_COMPUTE] = { false };
1870 unsigned i;
1871
1872 /* This depends on having up to date derived state (shaders) */
1873 if (ctx->NewState)
1874 _mesa_update_state(ctx);
1875
1876 for (i = 0; i < MESA_SHADER_COMPUTE; i++) {
1877 if (!shader_linked_or_absent(ctx, ctx->_Shader->CurrentProgram[i],
1878 &from_glsl_shader[i], where))
1879 return GL_FALSE;
1880 }
1881
1882 /* Any shader stages that are not supplied by the GLSL shader and have
1883 * assembly shaders enabled must now be validated.
1884 */
1885 if (!from_glsl_shader[MESA_SHADER_VERTEX]
1886 && ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) {
1887 _mesa_error(ctx, GL_INVALID_OPERATION,
1888 "%s(vertex program not valid)", where);
1889 return GL_FALSE;
1890 }
1891
1892 /* FINISHME: If GL_NV_geometry_program4 is ever supported, the current
1893 * FINISHME: geometry program should validated here.
1894 */
1895 (void) from_glsl_shader[MESA_SHADER_GEOMETRY];
1896
1897 if (!from_glsl_shader[MESA_SHADER_FRAGMENT]) {
1898 if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
1899 _mesa_error(ctx, GL_INVALID_OPERATION,
1900 "%s(fragment program not valid)", where);
1901 return GL_FALSE;
1902 }
1903
1904 /* If drawing to integer-valued color buffers, there must be an
1905 * active fragment shader (GL_EXT_texture_integer).
1906 */
1907 if (ctx->DrawBuffer && ctx->DrawBuffer->_IntegerColor) {
1908 _mesa_error(ctx, GL_INVALID_OPERATION,
1909 "%s(integer format but no fragment shader)", where);
1910 return GL_FALSE;
1911 }
1912 }
1913
1914 /* A pipeline object is bound */
1915 if (ctx->_Shader->Name && !ctx->_Shader->Validated) {
1916 /* Error message will be printed inside _mesa_validate_program_pipeline.
1917 */
1918 if (!_mesa_validate_program_pipeline(ctx, ctx->_Shader, GL_TRUE)) {
1919 return GL_FALSE;
1920 }
1921 }
1922
1923 if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
1924 _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
1925 "%s(incomplete framebuffer)", where);
1926 return GL_FALSE;
1927 }
1928
1929 if (_mesa_check_blend_func_error(ctx) == GL_FALSE) {
1930 return GL_FALSE;
1931 }
1932
1933 #ifdef DEBUG
1934 if (ctx->_Shader->Flags & GLSL_LOG) {
1935 struct gl_shader_program **shProg = ctx->_Shader->CurrentProgram;
1936 gl_shader_stage i;
1937
1938 for (i = 0; i < MESA_SHADER_STAGES; i++) {
1939 if (shProg[i] == NULL || shProg[i]->_Used
1940 || shProg[i]->_LinkedShaders[i] == NULL)
1941 continue;
1942
1943 /* This is the first time this shader is being used.
1944 * Append shader's constants/uniforms to log file.
1945 *
1946 * Only log data for the program target that matches the shader
1947 * target. It's possible to have a program bound to the vertex
1948 * shader target that also supplied a fragment shader. If that
1949 * program isn't also bound to the fragment shader target we don't
1950 * want to log its fragment data.
1951 */
1952 _mesa_append_uniforms_to_file(shProg[i]->_LinkedShaders[i]);
1953 }
1954
1955 for (i = 0; i < MESA_SHADER_STAGES; i++) {
1956 if (shProg[i] != NULL)
1957 shProg[i]->_Used = GL_TRUE;
1958 }
1959 }
1960 #endif
1961
1962 return GL_TRUE;
1963 }
1964
1965
1966 /*@}*/