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