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