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
81 #include "accum.h"
82 #include "api_exec.h"
83 #include "arrayobj.h"
84 #include "attrib.h"
85 #include "bbox.h"
86 #include "blend.h"
87 #include "buffers.h"
88 #include "bufferobj.h"
89 #include "conservativeraster.h"
90 #include "context.h"
91 #include "cpuinfo.h"
92 #include "debug.h"
93 #include "debug_output.h"
94 #include "depth.h"
95 #include "dlist.h"
96 #include "eval.h"
97 #include "extensions.h"
98 #include "fbobject.h"
99 #include "feedback.h"
100 #include "fog.h"
101 #include "formats.h"
102 #include "framebuffer.h"
103 #include "glthread.h"
104 #include "hint.h"
105 #include "hash.h"
106 #include "light.h"
107 #include "lines.h"
108 #include "macros.h"
109 #include "matrix.h"
110 #include "multisample.h"
111 #include "performance_monitor.h"
112 #include "performance_query.h"
113 #include "pipelineobj.h"
114 #include "pixel.h"
115 #include "pixelstore.h"
116 #include "points.h"
117 #include "polygon.h"
118 #include "queryobj.h"
119 #include "syncobj.h"
120 #include "rastpos.h"
121 #include "remap.h"
122 #include "scissor.h"
123 #include "shared.h"
124 #include "shaderobj.h"
125 #include "shaderimage.h"
126 #include "state.h"
127 #include "util/debug.h"
128 #include "util/disk_cache.h"
129 #include "util/strtod.h"
130 #include "stencil.h"
131 #include "shaderimage.h"
132 #include "texcompress_s3tc.h"
133 #include "texstate.h"
134 #include "transformfeedback.h"
135 #include "mtypes.h"
136 #include "varray.h"
137 #include "version.h"
138 #include "viewport.h"
139 #include "texturebindless.h"
140 #include "program/program.h"
141 #include "math/m_matrix.h"
142 #include "main/dispatch.h" /* for _gloffset_COUNT */
143 #include "macros.h"
144 #include "git_sha1.h"
145
146 #ifdef USE_SPARC_ASM
147 #include "sparc/sparc.h"
148 #endif
149
150 #include "compiler/glsl_types.h"
151 #include "compiler/glsl/builtin_functions.h"
152 #include "compiler/glsl/glsl_parser_extras.h"
153 #include <stdbool.h>
154 #include "util/u_memory.h"
155
156
157 #ifndef MESA_VERBOSE
158 int MESA_VERBOSE = 0;
159 #endif
160
161 #ifndef MESA_DEBUG_FLAGS
162 int MESA_DEBUG_FLAGS = 0;
163 #endif
164
165
166 /* ubyte -> float conversion */
167 GLfloat _mesa_ubyte_to_float_color_tab[256];
168
169
170
171 /**
172 * Swap buffers notification callback.
173 *
174 * \param ctx GL context.
175 *
176 * Called by window system just before swapping buffers.
177 * We have to finish any pending rendering.
178 */
179 void
_mesa_notifySwapBuffers(struct gl_context * ctx)180 _mesa_notifySwapBuffers(struct gl_context *ctx)
181 {
182 if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)
183 _mesa_debug(ctx, "SwapBuffers\n");
184 FLUSH_VERTICES(ctx, 0);
185 if (ctx->Driver.Flush) {
186 ctx->Driver.Flush(ctx);
187 }
188 }
189
190
191 /**********************************************************************/
192 /** \name GL Visual allocation/destruction */
193 /**********************************************************************/
194 /*@{*/
195
196 /**
197 * Allocates a struct gl_config structure and initializes it via
198 * _mesa_initialize_visual().
199 *
200 * \param dbFlag double buffering
201 * \param stereoFlag stereo buffer
202 * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
203 * is acceptable but the actual depth type will be GLushort or GLuint as
204 * needed.
205 * \param stencilBits requested minimum bits per stencil buffer value
206 * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number
207 * of bits per color component in accum buffer.
208 * \param redBits number of bits per color component in frame buffer for RGB(A)
209 * mode. We always use 8 in core Mesa though.
210 * \param greenBits same as above.
211 * \param blueBits same as above.
212 * \param alphaBits same as above.
213 * \param numSamples not really used.
214 *
215 * \return pointer to new struct gl_config or NULL if requested parameters
216 * can't be met.
217 *
218 * \note Need to add params for level and numAuxBuffers (at least)
219 */
220 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,GLuint numSamples)221 _mesa_create_visual( GLboolean dbFlag,
222 GLboolean stereoFlag,
223 GLint redBits,
224 GLint greenBits,
225 GLint blueBits,
226 GLint alphaBits,
227 GLint depthBits,
228 GLint stencilBits,
229 GLint accumRedBits,
230 GLint accumGreenBits,
231 GLint accumBlueBits,
232 GLint accumAlphaBits,
233 GLuint numSamples )
234 {
235 struct gl_config *vis = CALLOC_STRUCT(gl_config);
236 if (vis) {
237 if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,
238 redBits, greenBits, blueBits, alphaBits,
239 depthBits, stencilBits,
240 accumRedBits, accumGreenBits,
241 accumBlueBits, accumAlphaBits,
242 numSamples)) {
243 free(vis);
244 return NULL;
245 }
246 }
247 return vis;
248 }
249
250
251 /**
252 * Makes some sanity checks and fills in the fields of the struct
253 * gl_config object with the given parameters. If the caller needs to
254 * set additional fields, he should just probably init the whole
255 * gl_config object himself.
256 *
257 * \return GL_TRUE on success, or GL_FALSE on failure.
258 *
259 * \sa _mesa_create_visual() above for the parameter description.
260 */
261 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,GLuint numSamples)262 _mesa_initialize_visual( struct gl_config *vis,
263 GLboolean dbFlag,
264 GLboolean stereoFlag,
265 GLint redBits,
266 GLint greenBits,
267 GLint blueBits,
268 GLint alphaBits,
269 GLint depthBits,
270 GLint stencilBits,
271 GLint accumRedBits,
272 GLint accumGreenBits,
273 GLint accumBlueBits,
274 GLint accumAlphaBits,
275 GLuint numSamples )
276 {
277 assert(vis);
278
279 if (depthBits < 0 || depthBits > 32) {
280 return GL_FALSE;
281 }
282 if (stencilBits < 0 || stencilBits > 8) {
283 return GL_FALSE;
284 }
285 assert(accumRedBits >= 0);
286 assert(accumGreenBits >= 0);
287 assert(accumBlueBits >= 0);
288 assert(accumAlphaBits >= 0);
289
290 vis->doubleBufferMode = dbFlag;
291 vis->stereoMode = stereoFlag;
292
293 vis->redBits = redBits;
294 vis->greenBits = greenBits;
295 vis->blueBits = blueBits;
296 vis->alphaBits = alphaBits;
297 vis->rgbBits = redBits + greenBits + blueBits;
298
299 vis->depthBits = depthBits;
300 vis->stencilBits = stencilBits;
301
302 vis->accumRedBits = accumRedBits;
303 vis->accumGreenBits = accumGreenBits;
304 vis->accumBlueBits = accumBlueBits;
305 vis->accumAlphaBits = accumAlphaBits;
306
307 vis->numAuxBuffers = 0;
308 vis->level = 0;
309 vis->sampleBuffers = numSamples > 0 ? 1 : 0;
310 vis->samples = numSamples;
311
312 return GL_TRUE;
313 }
314
315
316 /**
317 * Destroy a visual and free its memory.
318 *
319 * \param vis visual.
320 *
321 * Frees the visual structure.
322 */
323 void
_mesa_destroy_visual(struct gl_config * vis)324 _mesa_destroy_visual( struct gl_config *vis )
325 {
326 free(vis);
327 }
328
329 /*@}*/
330
331
332 /**********************************************************************/
333 /** \name Context allocation, initialization, destroying
334 *
335 * The purpose of the most initialization functions here is to provide the
336 * default state values according to the OpenGL specification.
337 */
338 /**********************************************************************/
339 /*@{*/
340
341
342 /**
343 * Calls all the various one-time-fini functions in Mesa
344 */
345
346 static void
one_time_fini(void)347 one_time_fini(void)
348 {
349 glsl_type_singleton_decref();
350 _mesa_locale_fini();
351 }
352
353 /**
354 * Calls all the various one-time-init functions in Mesa
355 */
356
357 static void
one_time_init(void)358 one_time_init(void)
359 {
360 GLuint i;
361
362 STATIC_ASSERT(sizeof(GLbyte) == 1);
363 STATIC_ASSERT(sizeof(GLubyte) == 1);
364 STATIC_ASSERT(sizeof(GLshort) == 2);
365 STATIC_ASSERT(sizeof(GLushort) == 2);
366 STATIC_ASSERT(sizeof(GLint) == 4);
367 STATIC_ASSERT(sizeof(GLuint) == 4);
368
369 _mesa_locale_init();
370
371 _mesa_one_time_init_extension_overrides();
372
373 _mesa_get_cpu_features();
374
375 for (i = 0; i < 256; i++) {
376 _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
377 }
378
379 atexit(one_time_fini);
380
381 #if defined(DEBUG)
382 if (MESA_VERBOSE != 0) {
383 _mesa_debug(NULL, "Mesa " PACKAGE_VERSION " DEBUG build" MESA_GIT_SHA1 "\n");
384 }
385 #endif
386
387 /* Take a glsl type reference for the duration of libGL's life to avoid
388 * unecessary creation/destruction of glsl types.
389 */
390 glsl_type_singleton_init_or_ref();
391
392 _mesa_init_remap_table();
393 }
394
395 /**
396 * One-time initialization flag
397 *
398 * \sa Used by _mesa_initialize().
399 */
400 static once_flag init_once = ONCE_FLAG_INIT;
401
402
403 /**
404 * Calls all the various one-time-init functions in Mesa.
405 *
406 * While holding a global mutex lock, calls several initialization functions,
407 * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
408 * defined.
409 *
410 * \sa _math_init().
411 */
412 void
_mesa_initialize(void)413 _mesa_initialize(void)
414 {
415 call_once(&init_once, one_time_init);
416 }
417
418
419 /**
420 * Initialize fields of gl_current_attrib (aka ctx->Current.*)
421 */
422 static void
_mesa_init_current(struct gl_context * ctx)423 _mesa_init_current(struct gl_context *ctx)
424 {
425 GLuint i;
426
427 /* Init all to (0,0,0,1) */
428 for (i = 0; i < ARRAY_SIZE(ctx->Current.Attrib); i++) {
429 ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
430 }
431
432 /* redo special cases: */
433 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
434 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
435 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
436 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
437 ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
438 }
439
440
441 /**
442 * Init vertex/fragment/geometry program limits.
443 * Important: drivers should override these with actual limits.
444 */
445 static void
init_program_limits(struct gl_constants * consts,gl_shader_stage stage,struct gl_program_constants * prog)446 init_program_limits(struct gl_constants *consts, gl_shader_stage stage,
447 struct gl_program_constants *prog)
448 {
449 prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
450 prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
451 prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
452 prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
453 prog->MaxTemps = MAX_PROGRAM_TEMPS;
454 prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
455 prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
456 prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS;
457
458 switch (stage) {
459 case MESA_SHADER_VERTEX:
460 prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
461 prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;
462 prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
463 prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
464 prog->MaxInputComponents = 0; /* value not used */
465 prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */
466 break;
467 case MESA_SHADER_FRAGMENT:
468 prog->MaxParameters = MAX_FRAGMENT_PROGRAM_PARAMS;
469 prog->MaxAttribs = MAX_FRAGMENT_PROGRAM_INPUTS;
470 prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
471 prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
472 prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */
473 prog->MaxOutputComponents = 0; /* value not used */
474 break;
475 case MESA_SHADER_TESS_CTRL:
476 case MESA_SHADER_TESS_EVAL:
477 case MESA_SHADER_GEOMETRY:
478 prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
479 prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;
480 prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
481 prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
482 prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */
483 prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */
484 break;
485 case MESA_SHADER_COMPUTE:
486 prog->MaxParameters = 0; /* not meaningful for compute shaders */
487 prog->MaxAttribs = 0; /* not meaningful for compute shaders */
488 prog->MaxAddressRegs = 0; /* not meaningful for compute shaders */
489 prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
490 prog->MaxInputComponents = 0; /* not meaningful for compute shaders */
491 prog->MaxOutputComponents = 0; /* not meaningful for compute shaders */
492 break;
493 default:
494 assert(0 && "Bad shader stage in init_program_limits()");
495 }
496
497 /* Set the native limits to zero. This implies that there is no native
498 * support for shaders. Let the drivers fill in the actual values.
499 */
500 prog->MaxNativeInstructions = 0;
501 prog->MaxNativeAluInstructions = 0;
502 prog->MaxNativeTexInstructions = 0;
503 prog->MaxNativeTexIndirections = 0;
504 prog->MaxNativeAttribs = 0;
505 prog->MaxNativeTemps = 0;
506 prog->MaxNativeAddressRegs = 0;
507 prog->MaxNativeParameters = 0;
508
509 /* Set GLSL datatype range/precision info assuming IEEE float values.
510 * Drivers should override these defaults as needed.
511 */
512 prog->MediumFloat.RangeMin = 127;
513 prog->MediumFloat.RangeMax = 127;
514 prog->MediumFloat.Precision = 23;
515 prog->LowFloat = prog->HighFloat = prog->MediumFloat;
516
517 /* Assume ints are stored as floats for now, since this is the least-common
518 * denominator. The OpenGL ES spec implies (page 132) that the precision
519 * of integer types should be 0. Practically speaking, IEEE
520 * single-precision floating point values can only store integers in the
521 * range [-0x01000000, 0x01000000] without loss of precision.
522 */
523 prog->MediumInt.RangeMin = 24;
524 prog->MediumInt.RangeMax = 24;
525 prog->MediumInt.Precision = 0;
526 prog->LowInt = prog->HighInt = prog->MediumInt;
527
528 prog->MaxUniformBlocks = 12;
529 prog->MaxCombinedUniformComponents = (prog->MaxUniformComponents +
530 consts->MaxUniformBlockSize / 4 *
531 prog->MaxUniformBlocks);
532
533 prog->MaxAtomicBuffers = 0;
534 prog->MaxAtomicCounters = 0;
535
536 prog->MaxShaderStorageBlocks = 8;
537 }
538
539
540 /**
541 * Initialize fields of gl_constants (aka ctx->Const.*).
542 * Use defaults from config.h. The device drivers will often override
543 * some of these values (such as number of texture units).
544 */
545 void
_mesa_init_constants(struct gl_constants * consts,gl_api api)546 _mesa_init_constants(struct gl_constants *consts, gl_api api)
547 {
548 int i;
549 assert(consts);
550
551 /* Constants, may be overriden (usually only reduced) by device drivers */
552 consts->MaxTextureMbytes = MAX_TEXTURE_MBYTES;
553 consts->MaxTextureSize = 1 << (MAX_TEXTURE_LEVELS - 1);
554 consts->Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
555 consts->MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
556 consts->MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
557 consts->MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
558 consts->MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
559 consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
560 consts->MaxTextureUnits = MIN2(consts->MaxTextureCoordUnits,
561 consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
562 consts->MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
563 consts->MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
564 consts->MaxTextureBufferSize = 65536;
565 consts->TextureBufferOffsetAlignment = 1;
566 consts->MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
567 consts->SubPixelBits = SUB_PIXEL_BITS;
568 consts->MinPointSize = MIN_POINT_SIZE;
569 consts->MaxPointSize = MAX_POINT_SIZE;
570 consts->MinPointSizeAA = MIN_POINT_SIZE;
571 consts->MaxPointSizeAA = MAX_POINT_SIZE;
572 consts->PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
573 consts->MinLineWidth = MIN_LINE_WIDTH;
574 consts->MaxLineWidth = MAX_LINE_WIDTH;
575 consts->MinLineWidthAA = MIN_LINE_WIDTH;
576 consts->MaxLineWidthAA = MAX_LINE_WIDTH;
577 consts->LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
578 consts->MaxClipPlanes = 6;
579 consts->MaxLights = MAX_LIGHTS;
580 consts->MaxShininess = 128.0;
581 consts->MaxSpotExponent = 128.0;
582 consts->MaxViewportWidth = 16384;
583 consts->MaxViewportHeight = 16384;
584 consts->MinMapBufferAlignment = 64;
585
586 /* Driver must override these values if ARB_viewport_array is supported. */
587 consts->MaxViewports = 1;
588 consts->ViewportSubpixelBits = 0;
589 consts->ViewportBounds.Min = 0;
590 consts->ViewportBounds.Max = 0;
591
592 /** GL_ARB_uniform_buffer_object */
593 consts->MaxCombinedUniformBlocks = 36;
594 consts->MaxUniformBufferBindings = 36;
595 consts->MaxUniformBlockSize = 16384;
596 consts->UniformBufferOffsetAlignment = 1;
597
598 /** GL_ARB_shader_storage_buffer_object */
599 consts->MaxCombinedShaderStorageBlocks = 8;
600 consts->MaxShaderStorageBufferBindings = 8;
601 consts->MaxShaderStorageBlockSize = 128 * 1024 * 1024; /* 2^27 */
602 consts->ShaderStorageBufferOffsetAlignment = 256;
603
604 /* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */
605 consts->MaxUserAssignableUniformLocations =
606 4 * MESA_SHADER_STAGES * MAX_UNIFORMS;
607
608 for (i = 0; i < MESA_SHADER_STAGES; i++)
609 init_program_limits(consts, i, &consts->Program[i]);
610
611 consts->MaxProgramMatrices = MAX_PROGRAM_MATRICES;
612 consts->MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
613
614 /* Set the absolute minimum possible GLSL version. API_OPENGL_CORE can
615 * mean an OpenGL 3.0 forward-compatible context, so that implies a minimum
616 * possible version of 1.30. Otherwise, the minimum possible version 1.20.
617 * Since Mesa unconditionally advertises GL_ARB_shading_language_100 and
618 * GL_ARB_shader_objects, every driver has GLSL 1.20... even if they don't
619 * advertise any extensions to enable any shader stages (e.g.,
620 * GL_ARB_vertex_shader).
621 */
622 consts->GLSLVersion = api == API_OPENGL_CORE ? 130 : 120;
623 consts->GLSLVersionCompat = consts->GLSLVersion;
624
625 consts->GLSLLowerConstArrays = true;
626
627 /* Assume that if GLSL 1.30+ (or GLSL ES 3.00+) is supported that
628 * gl_VertexID is implemented using a native hardware register with OpenGL
629 * semantics.
630 */
631 consts->VertexID_is_zero_based = false;
632
633 /* GL_ARB_draw_buffers */
634 consts->MaxDrawBuffers = MAX_DRAW_BUFFERS;
635
636 consts->MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
637 consts->MaxRenderbufferSize = MAX_RENDERBUFFER_SIZE;
638
639 consts->Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
640 consts->MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
641 consts->MaxVarying = 16; /* old limit not to break tnl and swrast */
642 consts->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
643 consts->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;
644 consts->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;
645 consts->MaxGeometryShaderInvocations = MAX_GEOMETRY_SHADER_INVOCATIONS;
646
647 #ifdef DEBUG
648 consts->GenerateTemporaryNames = true;
649 #else
650 consts->GenerateTemporaryNames = false;
651 #endif
652
653 /* GL_ARB_framebuffer_object */
654 consts->MaxSamples = 0;
655
656 /* GLSL default if NativeIntegers == FALSE */
657 consts->UniformBooleanTrue = FLOAT_AS_UNION(1.0f).u;
658
659 /* GL_ARB_sync */
660 consts->MaxServerWaitTimeout = 0x7fffffff7fffffffULL;
661
662 /* GL_EXT_provoking_vertex */
663 consts->QuadsFollowProvokingVertexConvention = GL_TRUE;
664
665 /** GL_ARB_viewport_array */
666 consts->LayerAndVPIndexProvokingVertex = GL_UNDEFINED_VERTEX;
667
668 /* GL_EXT_transform_feedback */
669 consts->MaxTransformFeedbackBuffers = MAX_FEEDBACK_BUFFERS;
670 consts->MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;
671 consts->MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;
672 consts->MaxVertexStreams = 1;
673
674 /* GL 3.2 */
675 consts->ProfileMask = api == API_OPENGL_CORE
676 ? GL_CONTEXT_CORE_PROFILE_BIT
677 : GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
678
679 /* GL 4.4 */
680 consts->MaxVertexAttribStride = 2048;
681
682 /** GL_EXT_gpu_shader4 */
683 consts->MinProgramTexelOffset = -8;
684 consts->MaxProgramTexelOffset = 7;
685
686 /* GL_ARB_texture_gather */
687 consts->MinProgramTextureGatherOffset = -8;
688 consts->MaxProgramTextureGatherOffset = 7;
689
690 /* GL_ARB_robustness */
691 consts->ResetStrategy = GL_NO_RESET_NOTIFICATION_ARB;
692
693 /* GL_KHR_robustness */
694 consts->RobustAccess = GL_FALSE;
695
696 /* ES 3.0 or ARB_ES3_compatibility */
697 consts->MaxElementIndex = 0xffffffffu;
698
699 /* GL_ARB_texture_multisample */
700 consts->MaxColorTextureSamples = 1;
701 consts->MaxDepthTextureSamples = 1;
702 consts->MaxIntegerSamples = 1;
703
704 /* GL_ARB_shader_atomic_counters */
705 consts->MaxAtomicBufferBindings = MAX_COMBINED_ATOMIC_BUFFERS;
706 consts->MaxAtomicBufferSize = MAX_ATOMIC_COUNTERS * ATOMIC_COUNTER_SIZE;
707 consts->MaxCombinedAtomicBuffers = MAX_COMBINED_ATOMIC_BUFFERS;
708 consts->MaxCombinedAtomicCounters = MAX_ATOMIC_COUNTERS;
709
710 /* GL_ARB_vertex_attrib_binding */
711 consts->MaxVertexAttribRelativeOffset = 2047;
712 consts->MaxVertexAttribBindings = MAX_VERTEX_GENERIC_ATTRIBS;
713
714 /* GL_ARB_compute_shader */
715 consts->MaxComputeWorkGroupCount[0] = 65535;
716 consts->MaxComputeWorkGroupCount[1] = 65535;
717 consts->MaxComputeWorkGroupCount[2] = 65535;
718 consts->MaxComputeWorkGroupSize[0] = 1024;
719 consts->MaxComputeWorkGroupSize[1] = 1024;
720 consts->MaxComputeWorkGroupSize[2] = 64;
721 /* Enables compute support for GLES 3.1 if >= 128 */
722 consts->MaxComputeWorkGroupInvocations = 0;
723
724 /** GL_ARB_gpu_shader5 */
725 consts->MinFragmentInterpolationOffset = MIN_FRAGMENT_INTERPOLATION_OFFSET;
726 consts->MaxFragmentInterpolationOffset = MAX_FRAGMENT_INTERPOLATION_OFFSET;
727
728 /** GL_KHR_context_flush_control */
729 consts->ContextReleaseBehavior = GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH;
730
731 /** GL_ARB_tessellation_shader */
732 consts->MaxTessGenLevel = MAX_TESS_GEN_LEVEL;
733 consts->MaxPatchVertices = MAX_PATCH_VERTICES;
734 consts->Program[MESA_SHADER_TESS_CTRL].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
735 consts->Program[MESA_SHADER_TESS_EVAL].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
736 consts->MaxTessPatchComponents = MAX_TESS_PATCH_COMPONENTS;
737 consts->MaxTessControlTotalOutputComponents = MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS;
738 consts->PrimitiveRestartForPatches = false;
739
740 /** GL_ARB_compute_variable_group_size */
741 consts->MaxComputeVariableGroupSize[0] = 512;
742 consts->MaxComputeVariableGroupSize[1] = 512;
743 consts->MaxComputeVariableGroupSize[2] = 64;
744 consts->MaxComputeVariableGroupInvocations = 512;
745
746 /** GL_NV_conservative_raster */
747 consts->MaxSubpixelPrecisionBiasBits = 0;
748
749 /** GL_NV_conservative_raster_dilate */
750 consts->ConservativeRasterDilateRange[0] = 0.0;
751 consts->ConservativeRasterDilateRange[1] = 0.0;
752 consts->ConservativeRasterDilateGranularity = 0.0;
753
754 consts->glBeginEndBufferSize = 512 * 1024;
755 }
756
757
758 /**
759 * Do some sanity checks on the limits/constants for the given context.
760 * Only called the first time a context is bound.
761 */
762 static void
check_context_limits(struct gl_context * ctx)763 check_context_limits(struct gl_context *ctx)
764 {
765 (void) ctx;
766
767 /* check that we don't exceed the size of various bitfields */
768 assert(VARYING_SLOT_MAX <=
769 (8 * sizeof(ctx->VertexProgram._Current->info.outputs_written)));
770 assert(VARYING_SLOT_MAX <=
771 (8 * sizeof(ctx->FragmentProgram._Current->info.inputs_read)));
772
773 /* shader-related checks */
774 assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
775 assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
776
777 /* Texture unit checks */
778 assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits > 0);
779 assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
780 assert(ctx->Const.MaxTextureCoordUnits > 0);
781 assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
782 assert(ctx->Const.MaxTextureUnits > 0);
783 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
784 assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
785 assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits,
786 ctx->Const.MaxTextureCoordUnits));
787 assert(ctx->Const.MaxCombinedTextureImageUnits > 0);
788 assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
789 assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
790 /* number of coord units cannot be greater than number of image units */
791 assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
792
793
794 /* Texture size checks */
795 assert(ctx->Const.MaxTextureSize <= (1 << (MAX_TEXTURE_LEVELS - 1)));
796 assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
797 assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
798 assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
799
800 /* Texture level checks */
801 assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
802 assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
803
804 /* Max texture size should be <= max viewport size (render to texture) */
805 assert(ctx->Const.MaxTextureSize <= ctx->Const.MaxViewportWidth);
806 assert(ctx->Const.MaxTextureSize <= ctx->Const.MaxViewportHeight);
807
808 assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
809
810 /* if this fails, add more enum values to gl_buffer_index */
811 assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);
812
813 /* XXX probably add more tests */
814 }
815
816
817 /**
818 * Initialize the attribute groups in a GL context.
819 *
820 * \param ctx GL context.
821 *
822 * Initializes all the attributes, calling the respective <tt>init*</tt>
823 * functions for the more complex data structures.
824 */
825 static GLboolean
init_attrib_groups(struct gl_context * ctx)826 init_attrib_groups(struct gl_context *ctx)
827 {
828 assert(ctx);
829
830 /* Constants */
831 _mesa_init_constants(&ctx->Const, ctx->API);
832
833 /* Extensions */
834 _mesa_init_extensions(&ctx->Extensions);
835
836 /* Attribute Groups */
837 _mesa_init_accum( ctx );
838 _mesa_init_attrib( ctx );
839 _mesa_init_bbox( ctx );
840 _mesa_init_buffer_objects( ctx );
841 _mesa_init_color( ctx );
842 _mesa_init_conservative_raster( ctx );
843 _mesa_init_current( ctx );
844 _mesa_init_depth( ctx );
845 _mesa_init_debug( ctx );
846 _mesa_init_debug_output( ctx );
847 _mesa_init_display_list( ctx );
848 _mesa_init_eval( ctx );
849 _mesa_init_fbobjects( ctx );
850 _mesa_init_feedback( ctx );
851 _mesa_init_fog( ctx );
852 _mesa_init_hint( ctx );
853 _mesa_init_image_units( ctx );
854 _mesa_init_line( ctx );
855 _mesa_init_lighting( ctx );
856 _mesa_init_matrix( ctx );
857 _mesa_init_multisample( ctx );
858 _mesa_init_performance_monitors( ctx );
859 _mesa_init_performance_queries( ctx );
860 _mesa_init_pipeline( ctx );
861 _mesa_init_pixel( ctx );
862 _mesa_init_pixelstore( ctx );
863 _mesa_init_point( ctx );
864 _mesa_init_polygon( ctx );
865 _mesa_init_program( ctx );
866 _mesa_init_queryobj( ctx );
867 _mesa_init_sync( ctx );
868 _mesa_init_rastpos( ctx );
869 _mesa_init_scissor( ctx );
870 _mesa_init_shader_state( ctx );
871 _mesa_init_stencil( ctx );
872 _mesa_init_transform( ctx );
873 _mesa_init_transform_feedback( ctx );
874 _mesa_init_varray( ctx );
875 _mesa_init_viewport( ctx );
876 _mesa_init_resident_handles( ctx );
877
878 if (!_mesa_init_texture( ctx ))
879 return GL_FALSE;
880
881 /* Miscellaneous */
882 ctx->TileRasterOrderIncreasingX = GL_TRUE;
883 ctx->TileRasterOrderIncreasingY = GL_TRUE;
884 ctx->NewState = _NEW_ALL;
885 ctx->NewDriverState = ~0;
886 ctx->ErrorValue = GL_NO_ERROR;
887 ctx->ShareGroupReset = false;
888 ctx->varying_vp_inputs = VERT_BIT_ALL;
889
890 return GL_TRUE;
891 }
892
893
894 /**
895 * Update default objects in a GL context with respect to shared state.
896 *
897 * \param ctx GL context.
898 *
899 * Removes references to old default objects, (texture objects, program
900 * objects, etc.) and changes to reference those from the current shared
901 * state.
902 */
903 static GLboolean
update_default_objects(struct gl_context * ctx)904 update_default_objects(struct gl_context *ctx)
905 {
906 assert(ctx);
907
908 _mesa_update_default_objects_program(ctx);
909 _mesa_update_default_objects_texture(ctx);
910 _mesa_update_default_objects_buffer_objects(ctx);
911
912 return GL_TRUE;
913 }
914
915
916 /* XXX this is temporary and should be removed at some point in the
917 * future when there's a reasonable expectation that the libGL library
918 * contains the _glapi_new_nop_table() and _glapi_set_nop_handler()
919 * functions which were added in Mesa 10.6.
920 */
921 #if !defined(_WIN32)
922 /* Avoid libGL / driver ABI break */
923 #define USE_GLAPI_NOP_FEATURES 0
924 #else
925 #define USE_GLAPI_NOP_FEATURES 1
926 #endif
927
928
929 /**
930 * This function is called by the glapi no-op functions. For each OpenGL
931 * function/entrypoint there's a simple no-op function. These "no-op"
932 * functions call this function.
933 *
934 * If there's a current OpenGL context for the calling thread, we record a
935 * GL_INVALID_OPERATION error. This can happen either because the app's
936 * calling an unsupported extension function, or calling an illegal function
937 * (such as glClear between glBegin/glEnd).
938 *
939 * If there's no current OpenGL context for the calling thread, we can
940 * print a message to stderr.
941 *
942 * \param name the name of the OpenGL function
943 */
944 #if USE_GLAPI_NOP_FEATURES
945 static void
nop_handler(const char * name)946 nop_handler(const char *name)
947 {
948 GET_CURRENT_CONTEXT(ctx);
949 if (ctx) {
950 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(invalid call)", name);
951 }
952 #ifndef NDEBUG
953 else if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG")) {
954 fprintf(stderr,
955 "GL User Error: gl%s called without a rendering context\n",
956 name);
957 fflush(stderr);
958 }
959 #endif
960 }
961 #endif
962
963
964 /**
965 * Special no-op glFlush, see below.
966 */
967 #if defined(_WIN32)
968 static void GLAPIENTRY
nop_glFlush(void)969 nop_glFlush(void)
970 {
971 /* don't record an error like we do in nop_handler() */
972 }
973 #endif
974
975
976 #if !USE_GLAPI_NOP_FEATURES
977 static int
generic_nop(void)978 generic_nop(void)
979 {
980 GET_CURRENT_CONTEXT(ctx);
981 _mesa_error(ctx, GL_INVALID_OPERATION,
982 "unsupported function called "
983 "(unsupported extension or deprecated function?)");
984 return 0;
985 }
986 #endif
987
988
989 /**
990 * Create a new API dispatch table in which all entries point to the
991 * generic_nop() function. This will not work on Windows because of
992 * the __stdcall convention which requires the callee to clean up the
993 * call stack. That's impossible with one generic no-op function.
994 */
995 struct _glapi_table *
_mesa_new_nop_table(unsigned numEntries)996 _mesa_new_nop_table(unsigned numEntries)
997 {
998 struct _glapi_table *table;
999
1000 #if !USE_GLAPI_NOP_FEATURES
1001 table = malloc(numEntries * sizeof(_glapi_proc));
1002 if (table) {
1003 _glapi_proc *entry = (_glapi_proc *) table;
1004 unsigned i;
1005 for (i = 0; i < numEntries; i++) {
1006 entry[i] = (_glapi_proc) generic_nop;
1007 }
1008 }
1009 #else
1010 table = _glapi_new_nop_table(numEntries);
1011 #endif
1012 return table;
1013 }
1014
1015
1016 /**
1017 * Allocate and initialize a new dispatch table. The table will be
1018 * populated with pointers to "no-op" functions. In turn, the no-op
1019 * functions will call nop_handler() above.
1020 */
1021 struct _glapi_table *
_mesa_alloc_dispatch_table(void)1022 _mesa_alloc_dispatch_table(void)
1023 {
1024 /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1025 * In practice, this'll be the same for stand-alone Mesa. But for DRI
1026 * Mesa we do this to accommodate different versions of libGL and various
1027 * DRI drivers.
1028 */
1029 int numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);
1030
1031 struct _glapi_table *table = _mesa_new_nop_table(numEntries);
1032
1033 #if defined(_WIN32)
1034 if (table) {
1035 /* This is a special case for Windows in the event that
1036 * wglGetProcAddress is called between glBegin/End().
1037 *
1038 * The MS opengl32.dll library apparently calls glFlush from
1039 * wglGetProcAddress(). If we're inside glBegin/End(), glFlush
1040 * will dispatch to _mesa_generic_nop() and we'll generate a
1041 * GL_INVALID_OPERATION error.
1042 *
1043 * The specific case which hits this is piglit's primitive-restart
1044 * test which calls glPrimitiveRestartNV() inside glBegin/End. The
1045 * first time we call glPrimitiveRestartNV() Piglit's API dispatch
1046 * code will try to resolve the function by calling wglGetProcAddress.
1047 * This raises GL_INVALID_OPERATION and an assert(glGetError()==0)
1048 * will fail causing the test to fail. By suppressing the error, the
1049 * assertion passes and the test continues.
1050 */
1051 SET_Flush(table, nop_glFlush);
1052 }
1053 #endif
1054
1055 #if USE_GLAPI_NOP_FEATURES
1056 _glapi_set_nop_handler(nop_handler);
1057 #endif
1058
1059 return table;
1060 }
1061
1062 /**
1063 * Creates a minimal dispatch table for use within glBegin()/glEnd().
1064 *
1065 * This ensures that we generate GL_INVALID_OPERATION errors from most
1066 * functions, since the set of functions that are valid within Begin/End is
1067 * very small.
1068 *
1069 * From the GL 1.0 specification section 2.6.3, "GL Commands within
1070 * Begin/End"
1071 *
1072 * "The only GL commands that are allowed within any Begin/End pairs are
1073 * the commands for specifying vertex coordinates, vertex color, normal
1074 * coordinates, and texture coordinates (Vertex, Color, Index, Normal,
1075 * TexCoord), EvalCoord and EvalPoint commands (see section 5.1),
1076 * commands for specifying lighting material parameters (Material
1077 * commands see section 2.12.2), display list invocation commands
1078 * (CallList and CallLists see section 5.4), and the EdgeFlag
1079 * command. Executing Begin after Begin has already been executed but
1080 * before an End is issued generates the INVALID OPERATION error, as does
1081 * executing End without a previous corresponding Begin. Executing any
1082 * other GL command within Begin/End results in the error INVALID
1083 * OPERATION."
1084 *
1085 * The table entries for specifying vertex attributes are set up by
1086 * install_vtxfmt(), and End() and dlists
1087 * are set by install_vtxfmt() as well.
1088 */
1089 static struct _glapi_table *
create_beginend_table(const struct gl_context * ctx)1090 create_beginend_table(const struct gl_context *ctx)
1091 {
1092 struct _glapi_table *table;
1093
1094 table = _mesa_alloc_dispatch_table();
1095 if (!table)
1096 return NULL;
1097
1098 /* Fill in functions which return a value, since they should return some
1099 * specific value even if they emit a GL_INVALID_OPERATION error from them
1100 * being called within glBegin()/glEnd().
1101 */
1102 #define COPY_DISPATCH(func) SET_##func(table, GET_##func(ctx->Exec))
1103
1104 COPY_DISPATCH(GenLists);
1105 COPY_DISPATCH(IsProgram);
1106 COPY_DISPATCH(IsVertexArray);
1107 COPY_DISPATCH(IsBuffer);
1108 COPY_DISPATCH(IsEnabled);
1109 COPY_DISPATCH(IsEnabledi);
1110 COPY_DISPATCH(IsRenderbuffer);
1111 COPY_DISPATCH(IsFramebuffer);
1112 COPY_DISPATCH(CheckFramebufferStatus);
1113 COPY_DISPATCH(RenderMode);
1114 COPY_DISPATCH(GetString);
1115 COPY_DISPATCH(GetStringi);
1116 COPY_DISPATCH(GetPointerv);
1117 COPY_DISPATCH(IsQuery);
1118 COPY_DISPATCH(IsSampler);
1119 COPY_DISPATCH(IsSync);
1120 COPY_DISPATCH(IsTexture);
1121 COPY_DISPATCH(IsTransformFeedback);
1122 COPY_DISPATCH(DeleteQueries);
1123 COPY_DISPATCH(AreTexturesResident);
1124 COPY_DISPATCH(FenceSync);
1125 COPY_DISPATCH(ClientWaitSync);
1126 COPY_DISPATCH(MapBuffer);
1127 COPY_DISPATCH(UnmapBuffer);
1128 COPY_DISPATCH(MapBufferRange);
1129 COPY_DISPATCH(ObjectPurgeableAPPLE);
1130 COPY_DISPATCH(ObjectUnpurgeableAPPLE);
1131
1132 return table;
1133 }
1134
1135 void
_mesa_initialize_dispatch_tables(struct gl_context * ctx)1136 _mesa_initialize_dispatch_tables(struct gl_context *ctx)
1137 {
1138 /* Do the code-generated setup of the exec table in api_exec.c. */
1139 _mesa_initialize_exec_table(ctx);
1140
1141 if (ctx->Save)
1142 _mesa_initialize_save_table(ctx);
1143 }
1144
1145 /**
1146 * Initialize a struct gl_context struct (rendering context).
1147 *
1148 * This includes allocating all the other structs and arrays which hang off of
1149 * the context by pointers.
1150 * Note that the driver needs to pass in its dd_function_table here since
1151 * we need to at least call driverFunctions->NewTextureObject to create the
1152 * default texture objects.
1153 *
1154 * Called by _mesa_create_context().
1155 *
1156 * Performs the imports and exports callback tables initialization, and
1157 * miscellaneous one-time initializations. If no shared context is supplied one
1158 * is allocated, and increase its reference count. Setups the GL API dispatch
1159 * tables. Initialize the TNL module. Sets the maximum Z buffer depth.
1160 * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1161 * for debug flags.
1162 *
1163 * \param ctx the context to initialize
1164 * \param api the GL API type to create the context for
1165 * \param visual describes the visual attributes for this context or NULL to
1166 * create a configless context
1167 * \param share_list points to context to share textures, display lists,
1168 * etc with, or NULL
1169 * \param driverFunctions table of device driver functions for this context
1170 * to use
1171 */
1172 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)1173 _mesa_initialize_context(struct gl_context *ctx,
1174 gl_api api,
1175 const struct gl_config *visual,
1176 struct gl_context *share_list,
1177 const struct dd_function_table *driverFunctions)
1178 {
1179 struct gl_shared_state *shared;
1180 int i;
1181
1182 assert(driverFunctions->NewTextureObject);
1183 assert(driverFunctions->FreeTextureImageBuffer);
1184
1185 ctx->API = api;
1186 ctx->DrawBuffer = NULL;
1187 ctx->ReadBuffer = NULL;
1188 ctx->WinSysDrawBuffer = NULL;
1189 ctx->WinSysReadBuffer = NULL;
1190
1191 if (visual) {
1192 ctx->Visual = *visual;
1193 ctx->HasConfig = GL_TRUE;
1194 }
1195 else {
1196 memset(&ctx->Visual, 0, sizeof ctx->Visual);
1197 ctx->HasConfig = GL_FALSE;
1198 }
1199
1200 _mesa_override_gl_version(ctx);
1201
1202 /* misc one-time initializations */
1203 _mesa_initialize();
1204
1205 /* Plug in driver functions and context pointer here.
1206 * This is important because when we call alloc_shared_state() below
1207 * we'll call ctx->Driver.NewTextureObject() to create the default
1208 * textures.
1209 */
1210 ctx->Driver = *driverFunctions;
1211
1212 if (share_list) {
1213 /* share state with another context */
1214 shared = share_list->Shared;
1215 }
1216 else {
1217 /* allocate new, unshared state */
1218 shared = _mesa_alloc_shared_state(ctx);
1219 if (!shared)
1220 return GL_FALSE;
1221 }
1222
1223 _mesa_reference_shared_state(ctx, &ctx->Shared, shared);
1224
1225 if (!init_attrib_groups( ctx ))
1226 goto fail;
1227
1228 /* KHR_no_error is likely to crash, overflow memory, etc if an application
1229 * has errors so don't enable it for setuid processes.
1230 */
1231 if (env_var_as_boolean("MESA_NO_ERROR", false)) {
1232 #if !defined(_WIN32)
1233 if (geteuid() == getuid())
1234 #endif
1235 ctx->Const.ContextFlags |= GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR;
1236 }
1237
1238 /* setup the API dispatch tables with all nop functions */
1239 ctx->OutsideBeginEnd = _mesa_alloc_dispatch_table();
1240 if (!ctx->OutsideBeginEnd)
1241 goto fail;
1242 ctx->Exec = ctx->OutsideBeginEnd;
1243 ctx->CurrentClientDispatch = ctx->CurrentServerDispatch = ctx->OutsideBeginEnd;
1244
1245 ctx->FragmentProgram._MaintainTexEnvProgram
1246 = (getenv("MESA_TEX_PROG") != NULL);
1247
1248 ctx->VertexProgram._MaintainTnlProgram
1249 = (getenv("MESA_TNL_PROG") != NULL);
1250 if (ctx->VertexProgram._MaintainTnlProgram) {
1251 /* this is required... */
1252 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1253 }
1254
1255 /* Mesa core handles all the formats that mesa core knows about.
1256 * Drivers will want to override this list with just the formats
1257 * they can handle, and confirm that appropriate fallbacks exist in
1258 * _mesa_choose_tex_format().
1259 */
1260 memset(&ctx->TextureFormatSupported, GL_TRUE,
1261 sizeof(ctx->TextureFormatSupported));
1262
1263 switch (ctx->API) {
1264 case API_OPENGL_COMPAT:
1265 ctx->BeginEnd = create_beginend_table(ctx);
1266 ctx->Save = _mesa_alloc_dispatch_table();
1267 if (!ctx->BeginEnd || !ctx->Save)
1268 goto fail;
1269
1270 /* fall-through */
1271 case API_OPENGL_CORE:
1272 break;
1273 case API_OPENGLES:
1274 /**
1275 * GL_OES_texture_cube_map says
1276 * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
1277 */
1278 for (i = 0; i < ARRAY_SIZE(ctx->Texture.FixedFuncUnit); i++) {
1279 struct gl_fixedfunc_texture_unit *texUnit =
1280 &ctx->Texture.FixedFuncUnit[i];
1281
1282 texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
1283 texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
1284 texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
1285 texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1286 texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1287 texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
1288 }
1289 break;
1290 case API_OPENGLES2:
1291 ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1292 ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
1293 break;
1294 }
1295
1296 ctx->FirstTimeCurrent = GL_TRUE;
1297
1298 return GL_TRUE;
1299
1300 fail:
1301 _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1302 free(ctx->BeginEnd);
1303 free(ctx->OutsideBeginEnd);
1304 free(ctx->Save);
1305 return GL_FALSE;
1306 }
1307
1308
1309 /**
1310 * Free the data associated with the given context.
1311 *
1312 * But doesn't free the struct gl_context struct itself.
1313 *
1314 * \sa _mesa_initialize_context() and init_attrib_groups().
1315 */
1316 void
_mesa_free_context_data(struct gl_context * ctx,bool destroy_debug_output)1317 _mesa_free_context_data(struct gl_context *ctx, bool destroy_debug_output)
1318 {
1319 if (!_mesa_get_current_context()){
1320 /* No current context, but we may need one in order to delete
1321 * texture objs, etc. So temporarily bind the context now.
1322 */
1323 _mesa_make_current(ctx, NULL, NULL);
1324 }
1325
1326 /* unreference WinSysDraw/Read buffers */
1327 _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
1328 _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
1329 _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
1330 _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
1331
1332 _mesa_reference_program(ctx, &ctx->VertexProgram.Current, NULL);
1333 _mesa_reference_program(ctx, &ctx->VertexProgram._Current, NULL);
1334 _mesa_reference_program(ctx, &ctx->VertexProgram._TnlProgram, NULL);
1335
1336 _mesa_reference_program(ctx, &ctx->TessCtrlProgram._Current, NULL);
1337 _mesa_reference_program(ctx, &ctx->TessEvalProgram._Current, NULL);
1338 _mesa_reference_program(ctx, &ctx->GeometryProgram._Current, NULL);
1339
1340 _mesa_reference_program(ctx, &ctx->FragmentProgram.Current, NULL);
1341 _mesa_reference_program(ctx, &ctx->FragmentProgram._Current, NULL);
1342 _mesa_reference_program(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
1343
1344 _mesa_reference_program(ctx, &ctx->ComputeProgram._Current, NULL);
1345
1346 _mesa_reference_vao(ctx, &ctx->Array.VAO, NULL);
1347 _mesa_reference_vao(ctx, &ctx->Array.DefaultVAO, NULL);
1348 _mesa_reference_vao(ctx, &ctx->Array._EmptyVAO, NULL);
1349 _mesa_reference_vao(ctx, &ctx->Array._DrawVAO, NULL);
1350
1351 _mesa_free_attrib_data(ctx);
1352 _mesa_free_buffer_objects(ctx);
1353 _mesa_free_eval_data( ctx );
1354 _mesa_free_texture_data( ctx );
1355 _mesa_free_image_textures(ctx);
1356 _mesa_free_matrix_data( ctx );
1357 _mesa_free_pipeline_data(ctx);
1358 _mesa_free_program_data(ctx);
1359 _mesa_free_shader_state(ctx);
1360 _mesa_free_queryobj_data(ctx);
1361 _mesa_free_sync_data(ctx);
1362 _mesa_free_varray_data(ctx);
1363 _mesa_free_transform_feedback(ctx);
1364 _mesa_free_performance_monitors(ctx);
1365 _mesa_free_performance_queries(ctx);
1366 _mesa_free_resident_handles(ctx);
1367
1368 _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
1369 _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
1370 _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
1371 _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
1372
1373 /* free dispatch tables */
1374 free(ctx->BeginEnd);
1375 free(ctx->OutsideBeginEnd);
1376 free(ctx->Save);
1377 free(ctx->ContextLost);
1378 free(ctx->MarshalExec);
1379
1380 /* Shared context state (display lists, textures, etc) */
1381 _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
1382
1383 /* needs to be after freeing shared state */
1384 _mesa_free_display_list_data(ctx);
1385
1386 if (destroy_debug_output)
1387 _mesa_destroy_debug_output(ctx);
1388
1389 free((void *)ctx->Extensions.String);
1390
1391 free(ctx->VersionString);
1392
1393 ralloc_free(ctx->SoftFP64);
1394
1395 /* unbind the context if it's currently bound */
1396 if (ctx == _mesa_get_current_context()) {
1397 _mesa_make_current(NULL, NULL, NULL);
1398 }
1399
1400 /* Do this after unbinding context to ensure any thread is finished. */
1401 if (ctx->shader_builtin_ref) {
1402 _mesa_glsl_builtin_functions_decref();
1403 ctx->shader_builtin_ref = false;
1404 }
1405
1406 free(ctx->Const.SpirVExtensions);
1407 }
1408
1409
1410 /**
1411 * Destroy a struct gl_context structure.
1412 *
1413 * \param ctx GL context.
1414 *
1415 * Calls _mesa_free_context_data() and frees the gl_context object itself.
1416 */
1417 void
_mesa_destroy_context(struct gl_context * ctx)1418 _mesa_destroy_context( struct gl_context *ctx )
1419 {
1420 if (ctx) {
1421 _mesa_free_context_data(ctx, true);
1422 free( (void *) ctx );
1423 }
1424 }
1425
1426
1427 /**
1428 * Copy attribute groups from one context to another.
1429 *
1430 * \param src source context
1431 * \param dst destination context
1432 * \param mask bitwise OR of GL_*_BIT flags
1433 *
1434 * According to the bits specified in \p mask, copies the corresponding
1435 * attributes from \p src into \p dst. For many of the attributes a simple \c
1436 * memcpy is not enough due to the existence of internal pointers in their data
1437 * structures.
1438 */
1439 void
_mesa_copy_context(const struct gl_context * src,struct gl_context * dst,GLuint mask)1440 _mesa_copy_context( const struct gl_context *src, struct gl_context *dst,
1441 GLuint mask )
1442 {
1443 if (mask & GL_ACCUM_BUFFER_BIT) {
1444 /* OK to memcpy */
1445 dst->Accum = src->Accum;
1446 }
1447 if (mask & GL_COLOR_BUFFER_BIT) {
1448 /* OK to memcpy */
1449 dst->Color = src->Color;
1450 }
1451 if (mask & GL_CURRENT_BIT) {
1452 /* OK to memcpy */
1453 dst->Current = src->Current;
1454 }
1455 if (mask & GL_DEPTH_BUFFER_BIT) {
1456 /* OK to memcpy */
1457 dst->Depth = src->Depth;
1458 }
1459 if (mask & GL_ENABLE_BIT) {
1460 /* no op */
1461 }
1462 if (mask & GL_EVAL_BIT) {
1463 /* OK to memcpy */
1464 dst->Eval = src->Eval;
1465 }
1466 if (mask & GL_FOG_BIT) {
1467 /* OK to memcpy */
1468 dst->Fog = src->Fog;
1469 }
1470 if (mask & GL_HINT_BIT) {
1471 /* OK to memcpy */
1472 dst->Hint = src->Hint;
1473 }
1474 if (mask & GL_LIGHTING_BIT) {
1475 /* OK to memcpy */
1476 dst->Light = src->Light;
1477 }
1478 if (mask & GL_LINE_BIT) {
1479 /* OK to memcpy */
1480 dst->Line = src->Line;
1481 }
1482 if (mask & GL_LIST_BIT) {
1483 /* OK to memcpy */
1484 dst->List = src->List;
1485 }
1486 if (mask & GL_PIXEL_MODE_BIT) {
1487 /* OK to memcpy */
1488 dst->Pixel = src->Pixel;
1489 }
1490 if (mask & GL_POINT_BIT) {
1491 /* OK to memcpy */
1492 dst->Point = src->Point;
1493 }
1494 if (mask & GL_POLYGON_BIT) {
1495 /* OK to memcpy */
1496 dst->Polygon = src->Polygon;
1497 }
1498 if (mask & GL_POLYGON_STIPPLE_BIT) {
1499 /* Use loop instead of memcpy due to problem with Portland Group's
1500 * C compiler. Reported by John Stone.
1501 */
1502 GLuint i;
1503 for (i = 0; i < 32; i++) {
1504 dst->PolygonStipple[i] = src->PolygonStipple[i];
1505 }
1506 }
1507 if (mask & GL_SCISSOR_BIT) {
1508 /* OK to memcpy */
1509 dst->Scissor = src->Scissor;
1510 }
1511 if (mask & GL_STENCIL_BUFFER_BIT) {
1512 /* OK to memcpy */
1513 dst->Stencil = src->Stencil;
1514 }
1515 if (mask & GL_TEXTURE_BIT) {
1516 /* Cannot memcpy because of pointers */
1517 _mesa_copy_texture_state(src, dst);
1518 }
1519 if (mask & GL_TRANSFORM_BIT) {
1520 /* OK to memcpy */
1521 dst->Transform = src->Transform;
1522 }
1523 if (mask & GL_VIEWPORT_BIT) {
1524 unsigned i;
1525 for (i = 0; i < src->Const.MaxViewports; i++) {
1526 /* OK to memcpy */
1527 dst->ViewportArray[i] = src->ViewportArray[i];
1528 }
1529 }
1530
1531 /* XXX FIXME: Call callbacks?
1532 */
1533 dst->NewState = _NEW_ALL;
1534 dst->NewDriverState = ~0;
1535 }
1536
1537
1538 /**
1539 * Check if the given context can render into the given framebuffer
1540 * by checking visual attributes.
1541 *
1542 * \return GL_TRUE if compatible, GL_FALSE otherwise.
1543 */
1544 static GLboolean
check_compatible(const struct gl_context * ctx,const struct gl_framebuffer * buffer)1545 check_compatible(const struct gl_context *ctx,
1546 const struct gl_framebuffer *buffer)
1547 {
1548 const struct gl_config *ctxvis = &ctx->Visual;
1549 const struct gl_config *bufvis = &buffer->Visual;
1550
1551 if (buffer == _mesa_get_incomplete_framebuffer())
1552 return GL_TRUE;
1553
1554 #define check_component(foo) \
1555 if (ctxvis->foo && bufvis->foo && \
1556 ctxvis->foo != bufvis->foo) \
1557 return GL_FALSE
1558
1559 check_component(redShift);
1560 check_component(greenShift);
1561 check_component(blueShift);
1562 check_component(redBits);
1563 check_component(greenBits);
1564 check_component(blueBits);
1565 check_component(depthBits);
1566 check_component(stencilBits);
1567
1568 #undef check_component
1569
1570 return GL_TRUE;
1571 }
1572
1573
1574 /**
1575 * Check if the viewport/scissor size has not yet been initialized.
1576 * Initialize the size if the given width and height are non-zero.
1577 */
1578 static void
check_init_viewport(struct gl_context * ctx,GLuint width,GLuint height)1579 check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
1580 {
1581 if (!ctx->ViewportInitialized && width > 0 && height > 0) {
1582 unsigned i;
1583
1584 /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
1585 * potential infinite recursion.
1586 */
1587 ctx->ViewportInitialized = GL_TRUE;
1588
1589 /* Note: ctx->Const.MaxViewports may not have been set by the driver
1590 * yet, so just initialize all of them.
1591 */
1592 for (i = 0; i < MAX_VIEWPORTS; i++) {
1593 _mesa_set_viewport(ctx, i, 0, 0, width, height);
1594 _mesa_set_scissor(ctx, i, 0, 0, width, height);
1595 }
1596 }
1597 }
1598
1599
1600 static void
handle_first_current(struct gl_context * ctx)1601 handle_first_current(struct gl_context *ctx)
1602 {
1603 if (ctx->Version == 0 || !ctx->DrawBuffer) {
1604 /* probably in the process of tearing down the context */
1605 return;
1606 }
1607
1608 check_context_limits(ctx);
1609
1610 _mesa_update_vertex_processing_mode(ctx);
1611
1612 /* According to GL_MESA_configless_context the default value of
1613 * glDrawBuffers depends on the config of the first surface it is bound to.
1614 * For GLES it is always GL_BACK which has a magic interpretation.
1615 */
1616 if (!ctx->HasConfig && _mesa_is_desktop_gl(ctx)) {
1617 if (ctx->DrawBuffer != _mesa_get_incomplete_framebuffer()) {
1618 GLenum16 buffer;
1619
1620 if (ctx->DrawBuffer->Visual.doubleBufferMode)
1621 buffer = GL_BACK;
1622 else
1623 buffer = GL_FRONT;
1624
1625 _mesa_drawbuffers(ctx, ctx->DrawBuffer, 1, &buffer,
1626 NULL /* destMask */);
1627 }
1628
1629 if (ctx->ReadBuffer != _mesa_get_incomplete_framebuffer()) {
1630 gl_buffer_index bufferIndex;
1631 GLenum buffer;
1632
1633 if (ctx->ReadBuffer->Visual.doubleBufferMode) {
1634 buffer = GL_BACK;
1635 bufferIndex = BUFFER_BACK_LEFT;
1636 }
1637 else {
1638 buffer = GL_FRONT;
1639 bufferIndex = BUFFER_FRONT_LEFT;
1640 }
1641
1642 _mesa_readbuffer(ctx, ctx->ReadBuffer, buffer, bufferIndex);
1643 }
1644 }
1645
1646 /* Determine if generic vertex attribute 0 aliases the conventional
1647 * glVertex position.
1648 */
1649 {
1650 const bool is_forward_compatible_context =
1651 ctx->Const.ContextFlags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT;
1652
1653 /* In OpenGL 3.1 attribute 0 becomes non-magic, just like in OpenGL ES
1654 * 2.0. Note that we cannot just check for API_OPENGL_COMPAT here because
1655 * that will erroneously allow this usage in a 3.0 forward-compatible
1656 * context too.
1657 */
1658 ctx->_AttribZeroAliasesVertex = (ctx->API == API_OPENGLES
1659 || (ctx->API == API_OPENGL_COMPAT
1660 && !is_forward_compatible_context));
1661 }
1662
1663 /* We can use this to help debug user's problems. Tell them to set
1664 * the MESA_INFO env variable before running their app. Then the
1665 * first time each context is made current we'll print some useful
1666 * information.
1667 */
1668 if (getenv("MESA_INFO")) {
1669 _mesa_print_info(ctx);
1670 }
1671 }
1672
1673 /**
1674 * Bind the given context to the given drawBuffer and readBuffer and
1675 * make it the current context for the calling thread.
1676 * We'll render into the drawBuffer and read pixels from the
1677 * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1678 *
1679 * We check that the context's and framebuffer's visuals are compatible
1680 * and return immediately if they're not.
1681 *
1682 * \param newCtx the new GL context. If NULL then there will be no current GL
1683 * context.
1684 * \param drawBuffer the drawing framebuffer
1685 * \param readBuffer the reading framebuffer
1686 */
1687 GLboolean
_mesa_make_current(struct gl_context * newCtx,struct gl_framebuffer * drawBuffer,struct gl_framebuffer * readBuffer)1688 _mesa_make_current( struct gl_context *newCtx,
1689 struct gl_framebuffer *drawBuffer,
1690 struct gl_framebuffer *readBuffer )
1691 {
1692 GET_CURRENT_CONTEXT(curCtx);
1693
1694 if (MESA_VERBOSE & VERBOSE_API)
1695 _mesa_debug(newCtx, "_mesa_make_current()\n");
1696
1697 /* Check that the context's and framebuffer's visuals are compatible.
1698 */
1699 if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1700 if (!check_compatible(newCtx, drawBuffer)) {
1701 _mesa_warning(newCtx,
1702 "MakeCurrent: incompatible visuals for context and drawbuffer");
1703 return GL_FALSE;
1704 }
1705 }
1706 if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1707 if (!check_compatible(newCtx, readBuffer)) {
1708 _mesa_warning(newCtx,
1709 "MakeCurrent: incompatible visuals for context and readbuffer");
1710 return GL_FALSE;
1711 }
1712 }
1713
1714 if (curCtx &&
1715 (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) &&
1716 /* make sure this context is valid for flushing */
1717 curCtx != newCtx &&
1718 curCtx->Const.ContextReleaseBehavior ==
1719 GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH) {
1720 _mesa_flush(curCtx);
1721 }
1722
1723 /* Call this periodically to detect when the user has begun using
1724 * GL rendering from multiple threads.
1725 */
1726 _glapi_check_multithread();
1727
1728 if (!newCtx) {
1729 _glapi_set_dispatch(NULL); /* none current */
1730 /* We need old ctx to correctly release Draw/ReadBuffer
1731 * and avoid a surface leak in st_renderbuffer_delete.
1732 * Therefore, first drop buffers then set new ctx to NULL.
1733 */
1734 if (curCtx) {
1735 _mesa_reference_framebuffer(&curCtx->WinSysDrawBuffer, NULL);
1736 _mesa_reference_framebuffer(&curCtx->WinSysReadBuffer, NULL);
1737 }
1738 _glapi_set_context(NULL);
1739 assert(_mesa_get_current_context() == NULL);
1740 }
1741 else {
1742 _glapi_set_context((void *) newCtx);
1743 assert(_mesa_get_current_context() == newCtx);
1744 _glapi_set_dispatch(newCtx->CurrentClientDispatch);
1745
1746 if (drawBuffer && readBuffer) {
1747 assert(_mesa_is_winsys_fbo(drawBuffer));
1748 assert(_mesa_is_winsys_fbo(readBuffer));
1749 _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1750 _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1751
1752 /*
1753 * Only set the context's Draw/ReadBuffer fields if they're NULL
1754 * or not bound to a user-created FBO.
1755 */
1756 if (!newCtx->DrawBuffer || _mesa_is_winsys_fbo(newCtx->DrawBuffer)) {
1757 _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1758 /* Update the FBO's list of drawbuffers/renderbuffers.
1759 * For winsys FBOs this comes from the GL state (which may have
1760 * changed since the last time this FBO was bound).
1761 */
1762 _mesa_update_draw_buffers(newCtx);
1763 _mesa_update_allow_draw_out_of_order(newCtx);
1764 }
1765 if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) {
1766 _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1767 /* In _mesa_initialize_window_framebuffer, for single-buffered
1768 * visuals, the ColorReadBuffer is set to be GL_FRONT, even with
1769 * GLES contexts. When calling read_buffer, we verify we are reading
1770 * from GL_BACK in is_legal_es3_readbuffer_enum. But the default is
1771 * incorrect, and certain dEQP tests check this. So fix it here.
1772 */
1773 if (_mesa_is_gles(newCtx) &&
1774 !newCtx->ReadBuffer->Visual.doubleBufferMode)
1775 if (newCtx->ReadBuffer->ColorReadBuffer == GL_FRONT)
1776 newCtx->ReadBuffer->ColorReadBuffer = GL_BACK;
1777 }
1778
1779 /* XXX only set this flag if we're really changing the draw/read
1780 * framebuffer bindings.
1781 */
1782 newCtx->NewState |= _NEW_BUFFERS;
1783
1784 check_init_viewport(newCtx, drawBuffer->Width, drawBuffer->Height);
1785 }
1786
1787 if (newCtx->FirstTimeCurrent) {
1788 handle_first_current(newCtx);
1789 newCtx->FirstTimeCurrent = GL_FALSE;
1790 }
1791 }
1792
1793 return GL_TRUE;
1794 }
1795
1796
1797 /**
1798 * Make context 'ctx' share the display lists, textures and programs
1799 * that are associated with 'ctxToShare'.
1800 * Any display lists, textures or programs associated with 'ctx' will
1801 * be deleted if nobody else is sharing them.
1802 */
1803 GLboolean
_mesa_share_state(struct gl_context * ctx,struct gl_context * ctxToShare)1804 _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
1805 {
1806 if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1807 struct gl_shared_state *oldShared = NULL;
1808
1809 /* save ref to old state to prevent it from being deleted immediately */
1810 _mesa_reference_shared_state(ctx, &oldShared, ctx->Shared);
1811
1812 /* update ctx's Shared pointer */
1813 _mesa_reference_shared_state(ctx, &ctx->Shared, ctxToShare->Shared);
1814
1815 update_default_objects(ctx);
1816
1817 /* release the old shared state */
1818 _mesa_reference_shared_state(ctx, &oldShared, NULL);
1819
1820 return GL_TRUE;
1821 }
1822 else {
1823 return GL_FALSE;
1824 }
1825 }
1826
1827
1828
1829 /**
1830 * \return pointer to the current GL context for this thread.
1831 *
1832 * Calls _glapi_get_context(). This isn't the fastest way to get the current
1833 * context. If you need speed, see the #GET_CURRENT_CONTEXT macro in
1834 * context.h.
1835 */
1836 struct gl_context *
_mesa_get_current_context(void)1837 _mesa_get_current_context( void )
1838 {
1839 return (struct gl_context *) _glapi_get_context();
1840 }
1841
1842
1843 /**
1844 * Get context's current API dispatch table.
1845 *
1846 * It'll either be the immediate-mode execute dispatcher, the display list
1847 * compile dispatcher, or the thread marshalling dispatcher.
1848 *
1849 * \param ctx GL context.
1850 *
1851 * \return pointer to dispatch_table.
1852 *
1853 * Simply returns __struct gl_contextRec::CurrentClientDispatch.
1854 */
1855 struct _glapi_table *
_mesa_get_dispatch(struct gl_context * ctx)1856 _mesa_get_dispatch(struct gl_context *ctx)
1857 {
1858 return ctx->CurrentClientDispatch;
1859 }
1860
1861 /*@}*/
1862
1863
1864 /**********************************************************************/
1865 /** \name Miscellaneous functions */
1866 /**********************************************************************/
1867 /*@{*/
1868 /**
1869 * Flush commands.
1870 */
1871 void
_mesa_flush(struct gl_context * ctx)1872 _mesa_flush(struct gl_context *ctx)
1873 {
1874 FLUSH_VERTICES( ctx, 0 );
1875 if (ctx->Driver.Flush) {
1876 ctx->Driver.Flush(ctx);
1877 }
1878 }
1879
1880
1881
1882 /**
1883 * Flush commands and wait for completion.
1884 *
1885 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1886 * dd_function_table::Finish driver callback, if not NULL.
1887 */
1888 void GLAPIENTRY
_mesa_Finish(void)1889 _mesa_Finish(void)
1890 {
1891 GET_CURRENT_CONTEXT(ctx);
1892 ASSERT_OUTSIDE_BEGIN_END(ctx);
1893
1894 FLUSH_VERTICES(ctx, 0);
1895
1896 if (ctx->Driver.Finish) {
1897 ctx->Driver.Finish(ctx);
1898 }
1899 }
1900
1901
1902 /**
1903 * Execute glFlush().
1904 *
1905 * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1906 * dd_function_table::Flush driver callback, if not NULL.
1907 */
1908 void GLAPIENTRY
_mesa_Flush(void)1909 _mesa_Flush(void)
1910 {
1911 GET_CURRENT_CONTEXT(ctx);
1912 ASSERT_OUTSIDE_BEGIN_END(ctx);
1913 _mesa_flush(ctx);
1914 }
1915
1916
1917 /*@}*/
1918