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