WebSVN - shark - Blame - Rev 1618 - /shark/branches/xen/ports/mesa/src/context.c

Rev	Author	Line No.	Line
72	giacomo	1	/* $Id: context.c,v 1.2 2003-03-13 12:20:28 giacomo Exp $ */
55	pj	2
		3	/*
		4	* Mesa 3-D graphics library
		5	* Version: 4.1
		6	*
		7	* Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
		8	*
		9	* Permission is hereby granted, free of charge, to any person obtaining a
		10	* copy of this software and associated documentation files (the "Software"),
		11	* to deal in the Software without restriction, including without limitation
		12	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		13	* and/or sell copies of the Software, and to permit persons to whom the
		14	* Software is furnished to do so, subject to the following conditions:
		15	*
		16	* The above copyright notice and this permission notice shall be included
		17	* in all copies or substantial portions of the Software.
		18	*
		19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
		20	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		22	* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
		23	* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
		24	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		25	*/
		26
		27
		28	#include "glheader.h"
		29	#include "imports.h"
		30	#include "buffers.h"
		31	#include "clip.h"
		32	#include "colortab.h"
		33	#include "context.h"
		34	#include "dlist.h"
		35	#include "eval.h"
		36	#include "enums.h"
		37	#include "extensions.h"
		38	#include "fog.h"
		39	#include "get.h"
		40	#include "glthread.h"
		41	#include "hash.h"
		42	#include "light.h"
		43	#include "macros.h"
		44	#include "mmath.h"
		45	#include "simple_list.h"
		46	#include "state.h"
		47	#include "teximage.h"
		48	#include "texobj.h"
		49	#include "texstate.h"
		50	#include "mtypes.h"
		51	#include "varray.h"
		52	#include "vpstate.h"
		53	#include "vtxfmt.h"
		54	#include "math/m_translate.h"
		55	#include "math/m_matrix.h"
		56	#include "math/m_xform.h"
		57	#include "math/mathmod.h"
		58
		59
		60	#if defined(MESA_TRACE)
72	giacomo	61	#include "trace/tr_context.h"
		62	#include "trace/tr_wrapper.h"
55	pj	63	#endif
		64
		65	#ifdef USE_SPARC_ASM
		66	#include "SPARC/sparc.h"
		67	#endif
		68
		69	#ifndef MESA_VERBOSE
72	giacomo	70	int MESA_VERBOSE = 1;
55	pj	71	#endif
		72
		73	#ifndef MESA_DEBUG_FLAGS
		74	int MESA_DEBUG_FLAGS = 0;
		75	#endif
		76
		77
		78	static void
		79	free_shared_state( GLcontext ctx, struct gl_shared_state ss );
		80
		81
		82	/**********************************************************************/
		83	/*** OpenGL SI-style interface (new in Mesa 3.5) ***/
		84	/**********************************************************************/
		85
		86	/* Called by window system/device driver (via gc->exports.destroyCurrent())
		87	* when the rendering context is to be destroyed.
		88	*/
		89	GLboolean
		90	_mesa_destroyContext(__GLcontext *gc)
		91	{
		92	if (gc) {
		93	_mesa_free_context_data(gc);
		94	_mesa_free(gc);
		95	}
		96	return GL_TRUE;
		97	}
		98
		99	/* Called by window system/device driver (via gc->exports.loseCurrent())
		100	* when the rendering context is made non-current.
		101	*/
		102	GLboolean
		103	_mesa_loseCurrent(__GLcontext *gc)
		104	{
		105	/* XXX unbind context from thread */
		106	return GL_TRUE;
		107	}
		108
		109	/* Called by window system/device driver (via gc->exports.makeCurrent())
		110	* when the rendering context is made current.
		111	*/
		112	GLboolean
		113	_mesa_makeCurrent(__GLcontext *gc)
		114	{
		115	/* XXX bind context to thread */
		116	return GL_TRUE;
		117	}
		118
		119	/* Called by window system/device driver - yadda, yadda, yadda.
		120	* See above comments.
		121	*/
		122	GLboolean
		123	_mesa_shareContext(__GLcontext gc, __GLcontext gcShare)
		124	{
		125	if (gc && gcShare && gc->Shared && gcShare->Shared) {
		126	gc->Shared->RefCount--;
		127	if (gc->Shared->RefCount == 0) {
		128	free_shared_state(gc, gc->Shared);
		129	}
		130	gc->Shared = gcShare->Shared;
		131	gc->Shared->RefCount++;
		132	return GL_TRUE;
		133	}
		134	else {
		135	return GL_FALSE;
		136	}
		137	}
		138
		139	GLboolean
		140	_mesa_copyContext(__GLcontext dst, const __GLcontext src, GLuint mask)
		141	{
		142	if (dst && src) {
		143	_mesa_copy_context( src, dst, mask );
		144	return GL_TRUE;
		145	}
		146	else {
		147	return GL_FALSE;
		148	}
		149	}
		150
		151	GLboolean
		152	_mesa_forceCurrent(__GLcontext *gc)
		153	{
		154	return GL_TRUE;
		155	}
		156
		157	GLboolean
		158	_mesa_notifyResize(__GLcontext *gc)
		159	{
		160	GLint x, y;
		161	GLuint width, height;
		162	__GLdrawablePrivate *d = gc->imports.getDrawablePrivate(gc);
		163	if (!d \|\| !d->getDrawableSize)
		164	return GL_FALSE;
		165	d->getDrawableSize( d, &x, &y, &width, &height );
		166	/* update viewport, resize software buffers, etc. */
		167	return GL_TRUE;
		168	}
		169
		170	void
		171	_mesa_notifyDestroy(__GLcontext *gc)
		172	{
		173	/* Called when the context's window/buffer is going to be destroyed. */
		174	/* Unbind from it. */
		175	}
		176
		177	/* Called by window system just before swapping buffers.
		178	* We have to finish any pending rendering.
		179	*/
		180	void
		181	_mesa_notifySwapBuffers(__GLcontext *gc)
		182	{
		183	FLUSH_VERTICES( gc, 0 );
		184	}
		185
		186	struct __GLdispatchStateRec *
		187	_mesa_dispatchExec(__GLcontext *gc)
		188	{
		189	return NULL;
		190	}
		191
		192	void
		193	_mesa_beginDispatchOverride(__GLcontext *gc)
		194	{
		195	}
		196
		197	void
		198	_mesa_endDispatchOverride(__GLcontext *gc)
		199	{
		200	}
		201
		202	/* Setup the exports. The window system will call these functions
		203	* when it needs Mesa to do something.
		204	* NOTE: Device drivers should override these functions! For example,
		205	* the Xlib driver should plug in the XMesa*-style functions into this
		206	* structure. The XMesa-style functions should then call the _mesa_*
		207	* version of these functions. This is an approximation to OO design
		208	* (inheritance and virtual functions).
		209	*/
		210	static void
		211	_mesa_init_default_exports(__GLexports *exports)
		212	{
		213	exports->destroyContext = _mesa_destroyContext;
		214	exports->loseCurrent = _mesa_loseCurrent;
		215	exports->makeCurrent = _mesa_makeCurrent;
		216	exports->shareContext = _mesa_shareContext;
		217	exports->copyContext = _mesa_copyContext;
		218	exports->forceCurrent = _mesa_forceCurrent;
		219	exports->notifyResize = _mesa_notifyResize;
		220	exports->notifyDestroy = _mesa_notifyDestroy;
		221	exports->notifySwapBuffers = _mesa_notifySwapBuffers;
		222	exports->dispatchExec = _mesa_dispatchExec;
		223	exports->beginDispatchOverride = _mesa_beginDispatchOverride;
		224	exports->endDispatchOverride = _mesa_endDispatchOverride;
		225	}
		226
		227
		228
		229	/* exported OpenGL SI interface */
		230	__GLcontext *
		231	__glCoreCreateContext(__GLimports imports, __GLcontextModes modes)
		232	{
		233	GLcontext *ctx;
		234
		235	ctx = (GLcontext ) (imports->calloc)(NULL, 1, sizeof(GLcontext));
		236	if (ctx == NULL) {
		237	return NULL;
		238	}
		239
		240	_mesa_initialize_context(ctx, modes, NULL, imports, GL_FALSE);
		241	ctx->imports = *imports;
		242
		243	return ctx;
		244	}
		245
		246
		247	/* exported OpenGL SI interface */
		248	void
		249	__glCoreNopDispatch(void)
		250	{
		251	#if 0
		252	/* SI */
		253	__gl_dispatch = __glNopDispatchState;
		254	#else
		255	/* Mesa */
		256	_glapi_set_dispatch(NULL);
		257	#endif
		258	}
		259
		260
		261	/**********************************************************************/
		262	/*** GL Visual allocation/destruction ***/
		263	/**********************************************************************/
		264
		265
		266	/*
		267	* Allocate a new GLvisual object.
		268	* Input: rgbFlag - GL_TRUE=RGB(A) mode, GL_FALSE=Color Index mode
		269	* dbFlag - double buffering?
		270	* stereoFlag - stereo buffer?
		271	* depthBits - requested bits per depth buffer value
		272	* Any value in [0, 32] is acceptable but the actual
		273	* depth type will be GLushort or GLuint as needed.
		274	* stencilBits - requested minimum bits per stencil buffer value
		275	* accumBits - requested minimum bits per accum buffer component
		276	* indexBits - number of bits per pixel if rgbFlag==GL_FALSE
		277	* red/green/blue/alphaBits - number of bits per color component
		278	* in frame buffer for RGB(A) mode.
		279	* We always use 8 in core Mesa though.
		280	* Return: pointer to new GLvisual or NULL if requested parameters can't
		281	* be met.
		282	*/
		283	GLvisual *
		284	_mesa_create_visual( GLboolean rgbFlag,
		285	GLboolean dbFlag,
		286	GLboolean stereoFlag,
		287	GLint redBits,
		288	GLint greenBits,
		289	GLint blueBits,
		290	GLint alphaBits,
		291	GLint indexBits,
		292	GLint depthBits,
		293	GLint stencilBits,
		294	GLint accumRedBits,
		295	GLint accumGreenBits,
		296	GLint accumBlueBits,
		297	GLint accumAlphaBits,
		298	GLint numSamples )
		299	{
		300	GLvisual vis = (GLvisual ) CALLOC( sizeof(GLvisual) );
		301	if (vis) {
		302	if (!_mesa_initialize_visual(vis, rgbFlag, dbFlag, stereoFlag,
		303	redBits, greenBits, blueBits, alphaBits,
		304	indexBits, depthBits, stencilBits,
		305	accumRedBits, accumGreenBits,
		306	accumBlueBits, accumAlphaBits,
		307	numSamples)) {
		308	FREE(vis);
		309	return NULL;
		310	}
		311	}
		312	return vis;
		313	}
		314
		315
		316	/*
		317	* Initialize the fields of the given GLvisual.
		318	* Input: see _mesa_create_visual() above.
		319	* Return: GL_TRUE = success
		320	* GL_FALSE = failure.
		321	*/
		322	GLboolean
		323	_mesa_initialize_visual( GLvisual *vis,
		324	GLboolean rgbFlag,
		325	GLboolean dbFlag,
		326	GLboolean stereoFlag,
		327	GLint redBits,
		328	GLint greenBits,
		329	GLint blueBits,
		330	GLint alphaBits,
		331	GLint indexBits,
		332	GLint depthBits,
		333	GLint stencilBits,
		334	GLint accumRedBits,
		335	GLint accumGreenBits,
		336	GLint accumBlueBits,
		337	GLint accumAlphaBits,
		338	GLint numSamples )
		339	{
		340	(void) numSamples;
		341
		342	assert(vis);
		343
		344	/* This is to catch bad values from device drivers not updated for
		345	* Mesa 3.3. Some device drivers just passed 1. That's a REALLY
		346	* bad value now (a 1-bit depth buffer!?!).
		347	*/
		348	assert(depthBits == 0 \|\| depthBits > 1);
		349
		350	if (depthBits < 0 \|\| depthBits > 32) {
		351	return GL_FALSE;
		352	}
		353	if (stencilBits < 0 \|\| stencilBits > (GLint) (8 * sizeof(GLstencil))) {
		354	return GL_FALSE;
		355	}
		356	if (accumRedBits < 0 \|\| accumRedBits > (GLint) (8 * sizeof(GLaccum))) {
		357	return GL_FALSE;
		358	}
		359	if (accumGreenBits < 0 \|\| accumGreenBits > (GLint) (8 * sizeof(GLaccum))) {
		360	return GL_FALSE;
		361	}
		362	if (accumBlueBits < 0 \|\| accumBlueBits > (GLint) (8 * sizeof(GLaccum))) {
		363	return GL_FALSE;
		364	}
		365	if (accumAlphaBits < 0 \|\| accumAlphaBits > (GLint) (8 * sizeof(GLaccum))) {
		366	return GL_FALSE;
		367	}
		368
		369	vis->rgbMode = rgbFlag;
		370	vis->doubleBufferMode = dbFlag;
		371	vis->stereoMode = stereoFlag;
		372
		373	vis->redBits = redBits;
		374	vis->greenBits = greenBits;
		375	vis->blueBits = blueBits;
		376	vis->alphaBits = alphaBits;
		377
		378	vis->indexBits = indexBits;
		379	vis->depthBits = depthBits;
		380	vis->accumRedBits = (accumRedBits > 0) ? (8 * sizeof(GLaccum)) : 0;
		381	vis->accumGreenBits = (accumGreenBits > 0) ? (8 * sizeof(GLaccum)) : 0;
		382	vis->accumBlueBits = (accumBlueBits > 0) ? (8 * sizeof(GLaccum)) : 0;
		383	vis->accumAlphaBits = (accumAlphaBits > 0) ? (8 * sizeof(GLaccum)) : 0;
		384	vis->stencilBits = (stencilBits > 0) ? (8 * sizeof(GLstencil)) : 0;
		385
		386	vis->haveAccumBuffer = accumRedBits > 0;
		387	vis->haveDepthBuffer = depthBits > 0;
		388	vis->haveStencilBuffer = stencilBits > 0;
		389
		390	vis->numAuxBuffers = 0;
		391	vis->level = 0;
		392	vis->pixmapMode = 0;
		393
		394	return GL_TRUE;
		395	}
		396
		397
		398	void
		399	_mesa_destroy_visual( GLvisual *vis )
		400	{
		401	FREE(vis);
		402	}
		403
		404
		405	/**********************************************************************/
		406	/*** GL Framebuffer allocation/destruction ***/
		407	/**********************************************************************/
		408
		409
		410	/*
		411	* Create a new framebuffer. A GLframebuffer is a struct which
		412	* encapsulates the depth, stencil and accum buffers and related
		413	* parameters.
		414	* Input: visual - a GLvisual pointer (we copy the struct contents)
		415	* softwareDepth - create/use a software depth buffer?
		416	* softwareStencil - create/use a software stencil buffer?
		417	* softwareAccum - create/use a software accum buffer?
		418	* softwareAlpha - create/use a software alpha buffer?
		419	* Return: pointer to new GLframebuffer struct or NULL if error.
		420	*/
		421	GLframebuffer *
		422	_mesa_create_framebuffer( const GLvisual *visual,
		423	GLboolean softwareDepth,
		424	GLboolean softwareStencil,
		425	GLboolean softwareAccum,
		426	GLboolean softwareAlpha )
		427	{
		428	GLframebuffer *buffer = CALLOC_STRUCT(gl_frame_buffer);
		429	assert(visual);
		430	if (buffer) {
		431	_mesa_initialize_framebuffer(buffer, visual,
		432	softwareDepth, softwareStencil,
		433	softwareAccum, softwareAlpha );
		434	}
		435	return buffer;
		436	}
		437
		438
		439	/*
		440	* Initialize a GLframebuffer object.
		441	* Input: See _mesa_create_framebuffer() above.
		442	*/
		443	void
		444	_mesa_initialize_framebuffer( GLframebuffer *buffer,
		445	const GLvisual *visual,
		446	GLboolean softwareDepth,
		447	GLboolean softwareStencil,
		448	GLboolean softwareAccum,
		449	GLboolean softwareAlpha )
		450	{
		451	assert(buffer);
		452	assert(visual);
		453
		454	_mesa_bzero(buffer, sizeof(GLframebuffer));
		455
		456	/* sanity checks */
		457	if (softwareDepth ) {
		458	assert(visual->depthBits > 0);
		459	}
		460	if (softwareStencil) {
		461	assert(visual->stencilBits > 0);
		462	}
		463	if (softwareAccum) {
		464	assert(visual->rgbMode);
		465	assert(visual->accumRedBits > 0);
		466	assert(visual->accumGreenBits > 0);
		467	assert(visual->accumBlueBits > 0);
		468	}
		469	if (softwareAlpha) {
		470	assert(visual->rgbMode);
		471	assert(visual->alphaBits > 0);
		472	}
		473
		474	buffer->Visual = *visual;
		475	buffer->UseSoftwareDepthBuffer = softwareDepth;
		476	buffer->UseSoftwareStencilBuffer = softwareStencil;
		477	buffer->UseSoftwareAccumBuffer = softwareAccum;
		478	buffer->UseSoftwareAlphaBuffers = softwareAlpha;
		479	}
		480
		481
		482	/*
		483	* Free a framebuffer struct and its buffers.
		484	*/
		485	void
		486	_mesa_destroy_framebuffer( GLframebuffer *buffer )
		487	{
		488	if (buffer) {
		489	_mesa_free_framebuffer_data(buffer);
		490	FREE(buffer);
		491	}
		492	}
		493
		494
		495	/*
		496	* Free the data hanging off of <buffer>, but not <buffer> itself.
		497	*/
		498	void
		499	_mesa_free_framebuffer_data( GLframebuffer *buffer )
		500	{
		501	if (!buffer)
		502	return;
		503
		504	if (buffer->DepthBuffer) {
		505	MESA_PBUFFER_FREE( buffer->DepthBuffer );
		506	buffer->DepthBuffer = NULL;
		507	}
		508	if (buffer->Accum) {
		509	MESA_PBUFFER_FREE( buffer->Accum );
		510	buffer->Accum = NULL;
		511	}
		512	if (buffer->Stencil) {
		513	MESA_PBUFFER_FREE( buffer->Stencil );
		514	buffer->Stencil = NULL;
		515	}
		516	if (buffer->FrontLeftAlpha) {
		517	MESA_PBUFFER_FREE( buffer->FrontLeftAlpha );
		518	buffer->FrontLeftAlpha = NULL;
		519	}
		520	if (buffer->BackLeftAlpha) {
		521	MESA_PBUFFER_FREE( buffer->BackLeftAlpha );
		522	buffer->BackLeftAlpha = NULL;
		523	}
		524	if (buffer->FrontRightAlpha) {
		525	MESA_PBUFFER_FREE( buffer->FrontRightAlpha );
		526	buffer->FrontRightAlpha = NULL;
		527	}
		528	if (buffer->BackRightAlpha) {
		529	MESA_PBUFFER_FREE( buffer->BackRightAlpha );
		530	buffer->BackRightAlpha = NULL;
		531	}
		532	}
		533
		534
		535
		536	/**********************************************************************/
		537	/*** Context allocation, initialization, destroying ***/
		538	/**********************************************************************/
		539
		540
		541	_glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
		542
		543
		544	/*
		545	* This function just calls all the various one-time-init functions in Mesa.
		546	*/
		547	static void
		548	one_time_init( GLcontext *ctx )
		549	{
		550	static GLboolean alreadyCalled = GL_FALSE;
		551	_glthread_LOCK_MUTEX(OneTimeLock);
		552	if (!alreadyCalled) {
		553	/* do some implementation tests */
		554	assert( sizeof(GLbyte) == 1 );
		555	assert( sizeof(GLshort) >= 2 );
		556	assert( sizeof(GLint) >= 4 );
		557	assert( sizeof(GLubyte) == 1 );
		558	assert( sizeof(GLushort) >= 2 );
		559	assert( sizeof(GLuint) >= 4 );
		560
		561	_mesa_init_lists();
		562
		563	_math_init();
		564	_mesa_init_math();
		565
		566	#ifdef USE_SPARC_ASM
		567	_mesa_init_sparc_glapi_relocs();
		568	#endif
		569	if (_mesa_getenv("MESA_DEBUG")) {
		570	_glapi_noop_enable_warnings(GL_TRUE);
		571	#ifndef GLX_DIRECT_RENDERING
		572	/* libGL from before 2002/06/28 don't have this function. Someday,
		573	* when newer libGL libs are common, remove the #ifdef test. This
		574	* only serves to print warnings when calling undefined GL functions.
		575	*/
		576	_glapi_set_warning_func( (_glapi_warning_func) _mesa_warning );
		577	#endif
		578	}
		579	else {
		580	_glapi_noop_enable_warnings(GL_FALSE);
		581	}
		582
		583	#if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
		584	_mesa_debug(ctx, "Mesa DEBUG build %s %s\n", __DATE__, __TIME__);
		585	#endif
		586
		587	alreadyCalled = GL_TRUE;
		588	}
		589	_glthread_UNLOCK_MUTEX(OneTimeLock);
		590	}
		591
		592
		593	static void
		594	init_matrix_stack( struct matrix_stack *stack,
		595	GLuint maxDepth, GLuint dirtyFlag )
		596	{
		597	GLuint i;
		598
		599	stack->Depth = 0;
		600	stack->MaxDepth = maxDepth;
		601	stack->DirtyFlag = dirtyFlag;
		602	/* The stack */
		603	stack->Stack = (GLmatrix ) CALLOC(maxDepth sizeof(GLmatrix));
		604	for (i = 0; i < maxDepth; i++) {
		605	_math_matrix_ctr(&stack->Stack[i]);
		606	_math_matrix_alloc_inv(&stack->Stack[i]);
		607	}
		608	stack->Top = stack->Stack;
		609	}
		610
		611
		612	static void
		613	free_matrix_stack( struct matrix_stack *stack )
		614	{
		615	GLuint i;
		616	for (i = 0; i < stack->MaxDepth; i++) {
		617	_math_matrix_dtr(&stack->Stack[i]);
		618	}
		619	FREE(stack->Stack);
		620	stack->Stack = stack->Top = NULL;
		621	}
		622
		623
		624	/*
		625	* Allocate and initialize a shared context state structure.
		626	*/
		627	static struct gl_shared_state *
		628	alloc_shared_state( void )
		629	{
		630	struct gl_shared_state *ss;
		631	GLboolean outOfMemory;
		632
		633	ss = CALLOC_STRUCT(gl_shared_state);
		634	if (!ss)
		635	return NULL;
		636
		637	_glthread_INIT_MUTEX(ss->Mutex);
		638
		639	ss->DisplayList = _mesa_NewHashTable();
		640	ss->TexObjects = _mesa_NewHashTable();
		641	#if FEATURE_NV_vertex_program
		642	ss->VertexPrograms = _mesa_NewHashTable();
		643	#endif
		644
		645	/* Default Texture objects */
		646	outOfMemory = GL_FALSE;
		647
		648	ss->Default1D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_1D);
		649	if (!ss->Default1D) {
		650	outOfMemory = GL_TRUE;
		651	}
		652
		653	ss->Default2D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_2D);
		654	if (!ss->Default2D) {
		655	outOfMemory = GL_TRUE;
		656	}
		657
		658	ss->Default3D = _mesa_alloc_texture_object(ss, 0, GL_TEXTURE_3D);
		659	if (!ss->Default3D) {
		660	outOfMemory = GL_TRUE;
		661	}
		662
		663	ss->DefaultCubeMap = _mesa_alloc_texture_object(ss, 0,
		664	GL_TEXTURE_CUBE_MAP_ARB);
		665	if (!ss->DefaultCubeMap) {
		666	outOfMemory = GL_TRUE;
		667	}
		668
		669	ss->DefaultRect = _mesa_alloc_texture_object(ss, 0,
		670	GL_TEXTURE_RECTANGLE_NV);
		671	if (!ss->DefaultRect) {
		672	outOfMemory = GL_TRUE;
		673	}
		674
		675	if (!ss->DisplayList \|\| !ss->TexObjects
		676	#if FEATURE_NV_vertex_program
		677	\|\| !ss->VertexPrograms
		678	#endif
		679	\|\| outOfMemory) {
		680	/* Ran out of memory at some point. Free everything and return NULL */
		681	if (ss->DisplayList)
		682	_mesa_DeleteHashTable(ss->DisplayList);
		683	if (ss->TexObjects)
		684	_mesa_DeleteHashTable(ss->TexObjects);
		685	if (ss->VertexPrograms)
		686	_mesa_DeleteHashTable(ss->VertexPrograms);
		687	if (ss->Default1D)
		688	_mesa_free_texture_object(ss, ss->Default1D);
		689	if (ss->Default2D)
		690	_mesa_free_texture_object(ss, ss->Default2D);
		691	if (ss->Default3D)
		692	_mesa_free_texture_object(ss, ss->Default3D);
		693	if (ss->DefaultCubeMap)
		694	_mesa_free_texture_object(ss, ss->DefaultCubeMap);
		695	if (ss->DefaultRect)
		696	_mesa_free_texture_object(ss, ss->DefaultRect);
		697	FREE(ss);
		698	return NULL;
		699	}
		700	else {
		701	return ss;
		702	}
		703	}
		704
		705
		706	/*
		707	* Deallocate a shared state context and all children structures.
		708	*/
		709	static void
		710	free_shared_state( GLcontext ctx, struct gl_shared_state ss )
		711	{
		712	/* Free display lists */
		713	while (1) {
		714	GLuint list = _mesa_HashFirstEntry(ss->DisplayList);
		715	if (list) {
		716	_mesa_destroy_list(ctx, list);
		717	}
		718	else {
		719	break;
		720	}
		721	}
		722	_mesa_DeleteHashTable(ss->DisplayList);
		723
		724	/* Free texture objects */
		725	while (ss->TexObjectList) {
		726	if (ctx->Driver.DeleteTexture)
		727	(*ctx->Driver.DeleteTexture)( ctx, ss->TexObjectList );
		728	/* this function removes from linked list too! */
		729	_mesa_free_texture_object(ss, ss->TexObjectList);
		730	}
		731	_mesa_DeleteHashTable(ss->TexObjects);
		732
		733	#if FEATURE_NV_vertex_program
		734	/* Free vertex programs */
		735	while (1) {
		736	GLuint prog = _mesa_HashFirstEntry(ss->VertexPrograms);
		737	if (prog) {
		738	_mesa_delete_program(ctx, prog);
		739	}
		740	else {
		741	break;
		742	}
		743	}
		744	_mesa_DeleteHashTable(ss->VertexPrograms);
		745	#endif
		746
		747	FREE(ss);
		748	}
		749
		750
		751
		752	/*
		753	* Initialize the nth light. Note that the defaults for light 0 are
		754	* different than the other lights.
		755	*/
		756	static void
		757	init_light( struct gl_light *l, GLuint n )
		758	{
		759	make_empty_list( l );
		760
		761	ASSIGN_4V( l->Ambient, 0.0, 0.0, 0.0, 1.0 );
		762	if (n==0) {
		763	ASSIGN_4V( l->Diffuse, 1.0, 1.0, 1.0, 1.0 );
		764	ASSIGN_4V( l->Specular, 1.0, 1.0, 1.0, 1.0 );
		765	}
		766	else {
		767	ASSIGN_4V( l->Diffuse, 0.0, 0.0, 0.0, 1.0 );
		768	ASSIGN_4V( l->Specular, 0.0, 0.0, 0.0, 1.0 );
		769	}
		770	ASSIGN_4V( l->EyePosition, 0.0, 0.0, 1.0, 0.0 );
		771	ASSIGN_3V( l->EyeDirection, 0.0, 0.0, -1.0 );
		772	l->SpotExponent = 0.0;
		773	_mesa_invalidate_spot_exp_table( l );
		774	l->SpotCutoff = 180.0;
		775	l->_CosCutoff = 0.0; /* KW: -ve values not admitted */
		776	l->ConstantAttenuation = 1.0;
		777	l->LinearAttenuation = 0.0;
		778	l->QuadraticAttenuation = 0.0;
		779	l->Enabled = GL_FALSE;
		780	}
		781
		782
		783
		784	static void
		785	init_lightmodel( struct gl_lightmodel *lm )
		786	{
		787	ASSIGN_4V( lm->Ambient, 0.2F, 0.2F, 0.2F, 1.0F );
		788	lm->LocalViewer = GL_FALSE;
		789	lm->TwoSide = GL_FALSE;
		790	lm->ColorControl = GL_SINGLE_COLOR;
		791	}
		792
		793
		794	static void
		795	init_material( struct gl_material *m )
		796	{
		797	ASSIGN_4V( m->Ambient, 0.2F, 0.2F, 0.2F, 1.0F );
		798	ASSIGN_4V( m->Diffuse, 0.8F, 0.8F, 0.8F, 1.0F );
		799	ASSIGN_4V( m->Specular, 0.0F, 0.0F, 0.0F, 1.0F );
		800	ASSIGN_4V( m->Emission, 0.0F, 0.0F, 0.0F, 1.0F );
		801	m->Shininess = 0.0;
		802	m->AmbientIndex = 0;
		803	m->DiffuseIndex = 1;
		804	m->SpecularIndex = 1;
		805	}
		806
		807
		808
		809	static void
		810	init_texture_unit( GLcontext *ctx, GLuint unit )
		811	{
		812	struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
		813
		814	texUnit->EnvMode = GL_MODULATE;
		815	texUnit->CombineModeRGB = GL_MODULATE;
		816	texUnit->CombineModeA = GL_MODULATE;
		817	texUnit->CombineSourceRGB[0] = GL_TEXTURE;
		818	texUnit->CombineSourceRGB[1] = GL_PREVIOUS_EXT;
		819	texUnit->CombineSourceRGB[2] = GL_CONSTANT_EXT;
		820	texUnit->CombineSourceA[0] = GL_TEXTURE;
		821	texUnit->CombineSourceA[1] = GL_PREVIOUS_EXT;
		822	texUnit->CombineSourceA[2] = GL_CONSTANT_EXT;
		823	texUnit->CombineOperandRGB[0] = GL_SRC_COLOR;
		824	texUnit->CombineOperandRGB[1] = GL_SRC_COLOR;
		825	texUnit->CombineOperandRGB[2] = GL_SRC_ALPHA;
		826	texUnit->CombineOperandA[0] = GL_SRC_ALPHA;
		827	texUnit->CombineOperandA[1] = GL_SRC_ALPHA;
		828	texUnit->CombineOperandA[2] = GL_SRC_ALPHA;
		829	texUnit->CombineScaleShiftRGB = 0;
		830	texUnit->CombineScaleShiftA = 0;
		831
		832	ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
		833	texUnit->TexGenEnabled = 0;
		834	texUnit->GenModeS = GL_EYE_LINEAR;
		835	texUnit->GenModeT = GL_EYE_LINEAR;
		836	texUnit->GenModeR = GL_EYE_LINEAR;
		837	texUnit->GenModeQ = GL_EYE_LINEAR;
		838	texUnit->_GenBitS = TEXGEN_EYE_LINEAR;
		839	texUnit->_GenBitT = TEXGEN_EYE_LINEAR;
		840	texUnit->_GenBitR = TEXGEN_EYE_LINEAR;
		841	texUnit->_GenBitQ = TEXGEN_EYE_LINEAR;
		842
		843	/* Yes, these plane coefficients are correct! */
		844	ASSIGN_4V( texUnit->ObjectPlaneS, 1.0, 0.0, 0.0, 0.0 );
		845	ASSIGN_4V( texUnit->ObjectPlaneT, 0.0, 1.0, 0.0, 0.0 );
		846	ASSIGN_4V( texUnit->ObjectPlaneR, 0.0, 0.0, 0.0, 0.0 );
		847	ASSIGN_4V( texUnit->ObjectPlaneQ, 0.0, 0.0, 0.0, 0.0 );
		848	ASSIGN_4V( texUnit->EyePlaneS, 1.0, 0.0, 0.0, 0.0 );
		849	ASSIGN_4V( texUnit->EyePlaneT, 0.0, 1.0, 0.0, 0.0 );
		850	ASSIGN_4V( texUnit->EyePlaneR, 0.0, 0.0, 0.0, 0.0 );
		851	ASSIGN_4V( texUnit->EyePlaneQ, 0.0, 0.0, 0.0, 0.0 );
		852
		853	texUnit->Current1D = ctx->Shared->Default1D;
		854	texUnit->Current2D = ctx->Shared->Default2D;
		855	texUnit->Current3D = ctx->Shared->Default3D;
		856	texUnit->CurrentCubeMap = ctx->Shared->DefaultCubeMap;
		857	texUnit->CurrentRect = ctx->Shared->DefaultRect;
		858	}
		859
		860
		861
		862
		863	/* Initialize a 1-D evaluator map */
		864	static void
		865	init_1d_map( struct gl_1d_map map, int n, const float initial )
		866	{
		867	map->Order = 1;
		868	map->u1 = 0.0;
		869	map->u2 = 1.0;
		870	map->Points = (GLfloat ) MALLOC(n sizeof(GLfloat));
		871	if (map->Points) {
		872	GLint i;
		873	for (i=0;i<n;i++)
		874	map->Points[i] = initial[i];
		875	}
		876	}
		877
		878
		879	/* Initialize a 2-D evaluator map */
		880	static void
		881	init_2d_map( struct gl_2d_map map, int n, const float initial )
		882	{
		883	map->Uorder = 1;
		884	map->Vorder = 1;
		885	map->u1 = 0.0;
		886	map->u2 = 1.0;
		887	map->v1 = 0.0;
		888	map->v2 = 1.0;
		889	map->Points = (GLfloat ) MALLOC(n sizeof(GLfloat));
		890	if (map->Points) {
		891	GLint i;
		892	for (i=0;i<n;i++)
		893	map->Points[i] = initial[i];
		894	}
		895	}
		896
		897
		898	/*
		899	* Initialize the attribute groups in a GLcontext.
		900	*/
		901	static void
		902	init_attrib_groups( GLcontext *ctx )
		903	{
		904	GLuint i;
		905
		906	assert(ctx);
		907
		908	assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
		909	assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
		910
		911	/* Constants, may be overriden by device drivers */
		912	ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
		913	ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
		914	ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
		915	ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
		916	ctx->Const.MaxTextureUnits = MAX_TEXTURE_UNITS;
		917	ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
		918	ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
		919	ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
		920	ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
		921	ctx->Const.MinPointSize = MIN_POINT_SIZE;
		922	ctx->Const.MaxPointSize = MAX_POINT_SIZE;
		923	ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
		924	ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
		925	ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
		926	ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
		927	ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
		928	ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
		929	ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
		930	ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
		931	ctx->Const.NumAuxBuffers = NUM_AUX_BUFFERS;
		932	ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
		933	ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
		934	ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
		935	ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
		936	ctx->Const.MaxLights = MAX_LIGHTS;
		937
		938	/* Initialize matrix stacks */
		939	init_matrix_stack(&ctx->ModelviewMatrixStack, MAX_MODELVIEW_STACK_DEPTH,
		940	_NEW_MODELVIEW);
		941	init_matrix_stack(&ctx->ProjectionMatrixStack, MAX_PROJECTION_STACK_DEPTH,
		942	_NEW_PROJECTION);
		943	init_matrix_stack(&ctx->ColorMatrixStack, MAX_COLOR_STACK_DEPTH,
		944	_NEW_COLOR_MATRIX);
		945	for (i = 0; i < MAX_TEXTURE_UNITS; i++)
		946	init_matrix_stack(&ctx->TextureMatrixStack[i], MAX_TEXTURE_STACK_DEPTH,
		947	_NEW_TEXTURE_MATRIX);
		948	for (i = 0; i < MAX_PROGRAM_MATRICES; i++)
		949	init_matrix_stack(&ctx->ProgramMatrixStack[i], MAX_PROGRAM_STACK_DEPTH,
		950	_NEW_TRACK_MATRIX);
		951	ctx->CurrentStack = &ctx->ModelviewMatrixStack;
		952
		953	/* Init combined ModelviewProjection matrix /
		954	_math_matrix_ctr( &ctx->_ModelProjectMatrix );
		955
		956	/* Accumulate buffer group */
		957	ASSIGN_4V( ctx->Accum.ClearColor, 0.0, 0.0, 0.0, 0.0 );
		958
		959	/* Color buffer group */
		960	ctx->Color.IndexMask = 0xffffffff;
		961	ctx->Color.ColorMask[0] = 0xff;
		962	ctx->Color.ColorMask[1] = 0xff;
		963	ctx->Color.ColorMask[2] = 0xff;
		964	ctx->Color.ColorMask[3] = 0xff;
		965	ctx->Color.ClearIndex = 0;
		966	ASSIGN_4V( ctx->Color.ClearColor, 0, 0, 0, 0 );
		967	ctx->Color.DrawBuffer = GL_FRONT;
		968	ctx->Color.AlphaEnabled = GL_FALSE;
		969	ctx->Color.AlphaFunc = GL_ALWAYS;
		970	ctx->Color.AlphaRef = 0;
		971	ctx->Color.BlendEnabled = GL_FALSE;
		972	ctx->Color.BlendSrcRGB = GL_ONE;
		973	ctx->Color.BlendDstRGB = GL_ZERO;
		974	ctx->Color.BlendSrcA = GL_ONE;
		975	ctx->Color.BlendDstA = GL_ZERO;
		976	ctx->Color.BlendEquation = GL_FUNC_ADD_EXT;
		977	ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );
		978	ctx->Color.IndexLogicOpEnabled = GL_FALSE;
		979	ctx->Color.ColorLogicOpEnabled = GL_FALSE;
		980	ctx->Color.LogicOp = GL_COPY;
		981	ctx->Color.DitherFlag = GL_TRUE;
		982
		983	/* Current group */
		984	ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 0.0, 0.0, 0.0, 0.0 );
		985	ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 0.0 );
		986	ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
		987	ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 0.0 );
		988	ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_FOG], 0.0, 0.0, 0.0, 0.0 );
		989	for (i = 0; i < MAX_TEXTURE_UNITS; i++)
		990	ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_TEX0 + i], 0.0, 0.0, 0.0, 1.0 );
		991	ctx->Current.Index = 1;
		992	ctx->Current.EdgeFlag = GL_TRUE;
		993
		994	ASSIGN_4V( ctx->Current.RasterPos, 0.0, 0.0, 0.0, 1.0 );
		995	ctx->Current.RasterDistance = 0.0;
		996	ASSIGN_4V( ctx->Current.RasterColor, 1.0, 1.0, 1.0, 1.0 );
		997	ctx->Current.RasterIndex = 1;
		998	for (i=0; i<MAX_TEXTURE_UNITS; i++)
		999	ASSIGN_4V( ctx->Current.RasterTexCoords[i], 0.0, 0.0, 0.0, 1.0 );
		1000	ctx->Current.RasterPosValid = GL_TRUE;
		1001
		1002
		1003	/* Depth buffer group */
		1004	ctx->Depth.Test = GL_FALSE;
		1005	ctx->Depth.Clear = 1.0;
		1006	ctx->Depth.Func = GL_LESS;
		1007	ctx->Depth.Mask = GL_TRUE;
		1008	ctx->Depth.OcclusionTest = GL_FALSE;
		1009
		1010	/* Evaluators group */
		1011	ctx->Eval.Map1Color4 = GL_FALSE;
		1012	ctx->Eval.Map1Index = GL_FALSE;
		1013	ctx->Eval.Map1Normal = GL_FALSE;
		1014	ctx->Eval.Map1TextureCoord1 = GL_FALSE;
		1015	ctx->Eval.Map1TextureCoord2 = GL_FALSE;
		1016	ctx->Eval.Map1TextureCoord3 = GL_FALSE;
		1017	ctx->Eval.Map1TextureCoord4 = GL_FALSE;
		1018	ctx->Eval.Map1Vertex3 = GL_FALSE;
		1019	ctx->Eval.Map1Vertex4 = GL_FALSE;
		1020	MEMSET(ctx->Eval.Map1Attrib, 0, sizeof(ctx->Eval.Map1Attrib));
		1021	ctx->Eval.Map2Color4 = GL_FALSE;
		1022	ctx->Eval.Map2Index = GL_FALSE;
		1023	ctx->Eval.Map2Normal = GL_FALSE;
		1024	ctx->Eval.Map2TextureCoord1 = GL_FALSE;
		1025	ctx->Eval.Map2TextureCoord2 = GL_FALSE;
		1026	ctx->Eval.Map2TextureCoord3 = GL_FALSE;
		1027	ctx->Eval.Map2TextureCoord4 = GL_FALSE;
		1028	ctx->Eval.Map2Vertex3 = GL_FALSE;
		1029	ctx->Eval.Map2Vertex4 = GL_FALSE;
		1030	MEMSET(ctx->Eval.Map2Attrib, 0, sizeof(ctx->Eval.Map2Attrib));
		1031	ctx->Eval.AutoNormal = GL_FALSE;
		1032	ctx->Eval.MapGrid1un = 1;
		1033	ctx->Eval.MapGrid1u1 = 0.0;
		1034	ctx->Eval.MapGrid1u2 = 1.0;
		1035	ctx->Eval.MapGrid2un = 1;
		1036	ctx->Eval.MapGrid2vn = 1;
		1037	ctx->Eval.MapGrid2u1 = 0.0;
		1038	ctx->Eval.MapGrid2u2 = 1.0;
		1039	ctx->Eval.MapGrid2v1 = 0.0;
		1040	ctx->Eval.MapGrid2v2 = 1.0;
		1041
		1042	/* Evaluator data */
		1043	{
		1044	static GLfloat vertex[4] = { 0.0, 0.0, 0.0, 1.0 };
		1045	static GLfloat normal[3] = { 0.0, 0.0, 1.0 };
		1046	static GLfloat index[1] = { 1.0 };
		1047	static GLfloat color[4] = { 1.0, 1.0, 1.0, 1.0 };
		1048	static GLfloat texcoord[4] = { 0.0, 0.0, 0.0, 1.0 };
		1049	static GLfloat attrib[4] = { 0.0, 0.0, 0.0, 1.0 };
		1050
		1051	init_1d_map( &ctx->EvalMap.Map1Vertex3, 3, vertex );
		1052	init_1d_map( &ctx->EvalMap.Map1Vertex4, 4, vertex );
		1053	init_1d_map( &ctx->EvalMap.Map1Index, 1, index );
		1054	init_1d_map( &ctx->EvalMap.Map1Color4, 4, color );
		1055	init_1d_map( &ctx->EvalMap.Map1Normal, 3, normal );
		1056	init_1d_map( &ctx->EvalMap.Map1Texture1, 1, texcoord );
		1057	init_1d_map( &ctx->EvalMap.Map1Texture2, 2, texcoord );
		1058	init_1d_map( &ctx->EvalMap.Map1Texture3, 3, texcoord );
		1059	init_1d_map( &ctx->EvalMap.Map1Texture4, 4, texcoord );
		1060	for (i = 0; i < 16; i++)
		1061	init_1d_map( ctx->EvalMap.Map1Attrib + i, 4, attrib );
		1062
		1063	init_2d_map( &ctx->EvalMap.Map2Vertex3, 3, vertex );
		1064	init_2d_map( &ctx->EvalMap.Map2Vertex4, 4, vertex );
		1065	init_2d_map( &ctx->EvalMap.Map2Index, 1, index );
		1066	init_2d_map( &ctx->EvalMap.Map2Color4, 4, color );
		1067	init_2d_map( &ctx->EvalMap.Map2Normal, 3, normal );
		1068	init_2d_map( &ctx->EvalMap.Map2Texture1, 1, texcoord );
		1069	init_2d_map( &ctx->EvalMap.Map2Texture2, 2, texcoord );
		1070	init_2d_map( &ctx->EvalMap.Map2Texture3, 3, texcoord );
		1071	init_2d_map( &ctx->EvalMap.Map2Texture4, 4, texcoord );
		1072	for (i = 0; i < 16; i++)
		1073	init_2d_map( ctx->EvalMap.Map2Attrib + i, 4, attrib );
		1074	}
		1075
		1076	/* Fog group */
		1077	ctx->Fog.Enabled = GL_FALSE;
		1078	ctx->Fog.Mode = GL_EXP;
		1079	ASSIGN_4V( ctx->Fog.Color, 0.0, 0.0, 0.0, 0.0 );
		1080	ctx->Fog.Index = 0.0;
		1081	ctx->Fog.Density = 1.0;
		1082	ctx->Fog.Start = 0.0;
		1083	ctx->Fog.End = 1.0;
		1084	ctx->Fog.ColorSumEnabled = GL_FALSE;
		1085	ctx->Fog.FogCoordinateSource = GL_FRAGMENT_DEPTH_EXT;
		1086
		1087	/* Hint group */
		1088	ctx->Hint.PerspectiveCorrection = GL_DONT_CARE;
		1089	ctx->Hint.PointSmooth = GL_DONT_CARE;
		1090	ctx->Hint.LineSmooth = GL_DONT_CARE;
		1091	ctx->Hint.PolygonSmooth = GL_DONT_CARE;
		1092	ctx->Hint.Fog = GL_DONT_CARE;
		1093	ctx->Hint.ClipVolumeClipping = GL_DONT_CARE;
		1094	ctx->Hint.TextureCompression = GL_DONT_CARE;
		1095	ctx->Hint.GenerateMipmap = GL_DONT_CARE;
		1096
		1097	/* Histogram group */
		1098	ctx->Histogram.Width = 0;
		1099	ctx->Histogram.Format = GL_RGBA;
		1100	ctx->Histogram.Sink = GL_FALSE;
		1101	ctx->Histogram.RedSize = 0;
		1102	ctx->Histogram.GreenSize = 0;
		1103	ctx->Histogram.BlueSize = 0;
		1104	ctx->Histogram.AlphaSize = 0;
		1105	ctx->Histogram.LuminanceSize = 0;
		1106	for (i = 0; i < HISTOGRAM_TABLE_SIZE; i++) {
		1107	ctx->Histogram.Count[i][0] = 0;
		1108	ctx->Histogram.Count[i][1] = 0;
		1109	ctx->Histogram.Count[i][2] = 0;
		1110	ctx->Histogram.Count[i][3] = 0;
		1111	}
		1112
		1113	/* Min/Max group */
		1114	ctx->MinMax.Format = GL_RGBA;
		1115	ctx->MinMax.Sink = GL_FALSE;
		1116	ctx->MinMax.Min[RCOMP] = 1000; ctx->MinMax.Max[RCOMP] = -1000;
		1117	ctx->MinMax.Min[GCOMP] = 1000; ctx->MinMax.Max[GCOMP] = -1000;
		1118	ctx->MinMax.Min[BCOMP] = 1000; ctx->MinMax.Max[BCOMP] = -1000;
		1119	ctx->MinMax.Min[ACOMP] = 1000; ctx->MinMax.Max[ACOMP] = -1000;
		1120
		1121	/* Extensions */
		1122	_mesa_extensions_ctr( ctx );
		1123
		1124	/* Lighting group */
		1125	for (i=0;i<MAX_LIGHTS;i++) {
		1126	init_light( &ctx->Light.Light[i], i );
		1127	}
		1128	make_empty_list( &ctx->Light.EnabledList );
		1129
		1130	init_lightmodel( &ctx->Light.Model );
		1131	init_material( &ctx->Light.Material[0] );
		1132	init_material( &ctx->Light.Material[1] );
		1133	ctx->Light.ShadeModel = GL_SMOOTH;
		1134	ctx->Light.Enabled = GL_FALSE;
		1135	ctx->Light.ColorMaterialFace = GL_FRONT_AND_BACK;
		1136	ctx->Light.ColorMaterialMode = GL_AMBIENT_AND_DIFFUSE;
		1137	ctx->Light.ColorMaterialBitmask = _mesa_material_bitmask( ctx,
		1138	GL_FRONT_AND_BACK,
		1139	GL_AMBIENT_AND_DIFFUSE, ~0, 0 );
		1140
		1141	ctx->Light.ColorMaterialEnabled = GL_FALSE;
		1142
		1143	/* Lighting miscellaneous */
		1144	ctx->_ShineTabList = MALLOC_STRUCT( gl_shine_tab );
		1145	make_empty_list( ctx->_ShineTabList );
		1146	for (i = 0 ; i < 10 ; i++) {
		1147	struct gl_shine_tab *s = MALLOC_STRUCT( gl_shine_tab );
		1148	s->shininess = -1;
		1149	s->refcount = 0;
		1150	insert_at_tail( ctx->_ShineTabList, s );
		1151	}
		1152
		1153
		1154	/* Line group */
		1155	ctx->Line.SmoothFlag = GL_FALSE;
		1156	ctx->Line.StippleFlag = GL_FALSE;
		1157	ctx->Line.Width = 1.0;
		1158	ctx->Line._Width = 1.0;
		1159	ctx->Line.StipplePattern = 0xffff;
		1160	ctx->Line.StippleFactor = 1;
		1161
		1162	/* Display List group */
		1163	ctx->List.ListBase = 0;
		1164
		1165	/* Multisample */
		1166	ctx->Multisample.Enabled = GL_FALSE;
		1167	ctx->Multisample.SampleAlphaToCoverage = GL_FALSE;
		1168	ctx->Multisample.SampleAlphaToOne = GL_FALSE;
		1169	ctx->Multisample.SampleCoverage = GL_FALSE;
		1170	ctx->Multisample.SampleCoverageValue = 1.0;
		1171	ctx->Multisample.SampleCoverageInvert = GL_FALSE;
		1172
		1173	/* Pixel group */
		1174	ctx->Pixel.RedBias = 0.0;
		1175	ctx->Pixel.RedScale = 1.0;
		1176	ctx->Pixel.GreenBias = 0.0;
		1177	ctx->Pixel.GreenScale = 1.0;
		1178	ctx->Pixel.BlueBias = 0.0;
		1179	ctx->Pixel.BlueScale = 1.0;
		1180	ctx->Pixel.AlphaBias = 0.0;
		1181	ctx->Pixel.AlphaScale = 1.0;
		1182	ctx->Pixel.DepthBias = 0.0;
		1183	ctx->Pixel.DepthScale = 1.0;
		1184	ctx->Pixel.IndexOffset = 0;
		1185	ctx->Pixel.IndexShift = 0;
		1186	ctx->Pixel.ZoomX = 1.0;
		1187	ctx->Pixel.ZoomY = 1.0;
		1188	ctx->Pixel.MapColorFlag = GL_FALSE;
		1189	ctx->Pixel.MapStencilFlag = GL_FALSE;
		1190	ctx->Pixel.MapStoSsize = 1;
		1191	ctx->Pixel.MapItoIsize = 1;
		1192	ctx->Pixel.MapItoRsize = 1;
		1193	ctx->Pixel.MapItoGsize = 1;
		1194	ctx->Pixel.MapItoBsize = 1;
		1195	ctx->Pixel.MapItoAsize = 1;
		1196	ctx->Pixel.MapRtoRsize = 1;
		1197	ctx->Pixel.MapGtoGsize = 1;
		1198	ctx->Pixel.MapBtoBsize = 1;
		1199	ctx->Pixel.MapAtoAsize = 1;
		1200	ctx->Pixel.MapStoS[0] = 0;
		1201	ctx->Pixel.MapItoI[0] = 0;
		1202	ctx->Pixel.MapItoR[0] = 0.0;
		1203	ctx->Pixel.MapItoG[0] = 0.0;
		1204	ctx->Pixel.MapItoB[0] = 0.0;
		1205	ctx->Pixel.MapItoA[0] = 0.0;
		1206	ctx->Pixel.MapItoR8[0] = 0;
		1207	ctx->Pixel.MapItoG8[0] = 0;
		1208	ctx->Pixel.MapItoB8[0] = 0;
		1209	ctx->Pixel.MapItoA8[0] = 0;
		1210	ctx->Pixel.MapRtoR[0] = 0.0;
		1211	ctx->Pixel.MapGtoG[0] = 0.0;
		1212	ctx->Pixel.MapBtoB[0] = 0.0;
		1213	ctx->Pixel.MapAtoA[0] = 0.0;
		1214	ctx->Pixel.HistogramEnabled = GL_FALSE;
		1215	ctx->Pixel.MinMaxEnabled = GL_FALSE;
		1216	ctx->Pixel.PixelTextureEnabled = GL_FALSE;
		1217	ctx->Pixel.FragmentRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
		1218	ctx->Pixel.FragmentAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
		1219	ASSIGN_4V(ctx->Pixel.PostColorMatrixScale, 1.0, 1.0, 1.0, 1.0);
		1220	ASSIGN_4V(ctx->Pixel.PostColorMatrixBias, 0.0, 0.0, 0.0, 0.0);
		1221	ASSIGN_4V(ctx->Pixel.ColorTableScale, 1.0, 1.0, 1.0, 1.0);
		1222	ASSIGN_4V(ctx->Pixel.ColorTableBias, 0.0, 0.0, 0.0, 0.0);
		1223	ASSIGN_4V(ctx->Pixel.PCCTscale, 1.0, 1.0, 1.0, 1.0);
		1224	ASSIGN_4V(ctx->Pixel.PCCTbias, 0.0, 0.0, 0.0, 0.0);
		1225	ASSIGN_4V(ctx->Pixel.PCMCTscale, 1.0, 1.0, 1.0, 1.0);
		1226	ASSIGN_4V(ctx->Pixel.PCMCTbias, 0.0, 0.0, 0.0, 0.0);
		1227	ctx->Pixel.ColorTableEnabled = GL_FALSE;
		1228	ctx->Pixel.PostConvolutionColorTableEnabled = GL_FALSE;
		1229	ctx->Pixel.PostColorMatrixColorTableEnabled = GL_FALSE;
		1230	ctx->Pixel.Convolution1DEnabled = GL_FALSE;
		1231	ctx->Pixel.Convolution2DEnabled = GL_FALSE;
		1232	ctx->Pixel.Separable2DEnabled = GL_FALSE;
		1233	for (i = 0; i < 3; i++) {
		1234	ASSIGN_4V(ctx->Pixel.ConvolutionBorderColor[i], 0.0, 0.0, 0.0, 0.0);
		1235	ctx->Pixel.ConvolutionBorderMode[i] = GL_REDUCE;
		1236	ASSIGN_4V(ctx->Pixel.ConvolutionFilterScale[i], 1.0, 1.0, 1.0, 1.0);
		1237	ASSIGN_4V(ctx->Pixel.ConvolutionFilterBias[i], 0.0, 0.0, 0.0, 0.0);
		1238	}
		1239	for (i = 0; i < MAX_CONVOLUTION_WIDTH * MAX_CONVOLUTION_WIDTH * 4; i++) {
		1240	ctx->Convolution1D.Filter[i] = 0.0;
		1241	ctx->Convolution2D.Filter[i] = 0.0;
		1242	ctx->Separable2D.Filter[i] = 0.0;
		1243	}
		1244	ASSIGN_4V(ctx->Pixel.PostConvolutionScale, 1.0, 1.0, 1.0, 1.0);
		1245	ASSIGN_4V(ctx->Pixel.PostConvolutionBias, 0.0, 0.0, 0.0, 0.0);
		1246
		1247	/* Point group */
		1248	ctx->Point.SmoothFlag = GL_FALSE;
		1249	ctx->Point.Size = 1.0;
		1250	ctx->Point._Size = 1.0;
		1251	ctx->Point.Params[0] = 1.0;
		1252	ctx->Point.Params[1] = 0.0;
		1253	ctx->Point.Params[2] = 0.0;
		1254	ctx->Point._Attenuated = GL_FALSE;
		1255	ctx->Point.MinSize = 0.0;
		1256	ctx->Point.MaxSize = ctx->Const.MaxPointSize;
		1257	ctx->Point.Threshold = 1.0;
		1258	ctx->Point.PointSprite = GL_FALSE; /* GL_NV_point_sprite */
		1259	ctx->Point.SpriteRMode = GL_ZERO; /* GL_NV_point_sprite */
		1260	for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
		1261	ctx->Point.CoordReplace[i] = GL_FALSE; /* GL_NV_point_sprite */
		1262	}
		1263
		1264	/* Polygon group */
		1265	ctx->Polygon.CullFlag = GL_FALSE;
		1266	ctx->Polygon.CullFaceMode = GL_BACK;
		1267	ctx->Polygon.FrontFace = GL_CCW;
		1268	ctx->Polygon._FrontBit = 0;
		1269	ctx->Polygon.FrontMode = GL_FILL;
		1270	ctx->Polygon.BackMode = GL_FILL;
		1271	ctx->Polygon.SmoothFlag = GL_FALSE;
		1272	ctx->Polygon.StippleFlag = GL_FALSE;
		1273	ctx->Polygon.OffsetFactor = 0.0F;
		1274	ctx->Polygon.OffsetUnits = 0.0F;
		1275	ctx->Polygon.OffsetPoint = GL_FALSE;
		1276	ctx->Polygon.OffsetLine = GL_FALSE;
		1277	ctx->Polygon.OffsetFill = GL_FALSE;
		1278
		1279	/* Polygon Stipple group */
		1280	MEMSET( ctx->PolygonStipple, 0xff, 32*sizeof(GLuint) );
		1281
		1282	/* Scissor group */
		1283	ctx->Scissor.Enabled = GL_FALSE;
		1284	ctx->Scissor.X = 0;
		1285	ctx->Scissor.Y = 0;
		1286	ctx->Scissor.Width = 0;
		1287	ctx->Scissor.Height = 0;
		1288
		1289	/* Stencil group */
		1290	ctx->Stencil.Enabled = GL_FALSE;
		1291	ctx->Stencil.TestTwoSide = GL_FALSE;
		1292	ctx->Stencil.ActiveFace = 0; /* 0 = GL_FRONT, 1 = GL_BACK */
		1293	ctx->Stencil.Function[0] = GL_ALWAYS;
		1294	ctx->Stencil.Function[1] = GL_ALWAYS;
		1295	ctx->Stencil.FailFunc[0] = GL_KEEP;
		1296	ctx->Stencil.FailFunc[1] = GL_KEEP;
		1297	ctx->Stencil.ZPassFunc[0] = GL_KEEP;
		1298	ctx->Stencil.ZPassFunc[1] = GL_KEEP;
		1299	ctx->Stencil.ZFailFunc[0] = GL_KEEP;
		1300	ctx->Stencil.ZFailFunc[1] = GL_KEEP;
		1301	ctx->Stencil.Ref[0] = 0;
		1302	ctx->Stencil.Ref[1] = 0;
		1303	ctx->Stencil.ValueMask[0] = STENCIL_MAX;
		1304	ctx->Stencil.ValueMask[1] = STENCIL_MAX;
		1305	ctx->Stencil.WriteMask[0] = STENCIL_MAX;
		1306	ctx->Stencil.WriteMask[1] = STENCIL_MAX;
		1307	ctx->Stencil.Clear = 0;
		1308
		1309	/* Texture group */
		1310	ctx->Texture.CurrentUnit = 0; /* multitexture */
		1311	ctx->Texture._EnabledUnits = 0;
		1312	for (i=0; i<MAX_TEXTURE_UNITS; i++)
		1313	init_texture_unit( ctx, i );
		1314	ctx->Texture.SharedPalette = GL_FALSE;
		1315	_mesa_init_colortable(&ctx->Texture.Palette);
		1316
		1317	/* Transformation group */
		1318	ctx->Transform.MatrixMode = GL_MODELVIEW;
		1319	ctx->Transform.Normalize = GL_FALSE;
		1320	ctx->Transform.RescaleNormals = GL_FALSE;
		1321	ctx->Transform.RasterPositionUnclipped = GL_FALSE;
		1322	for (i=0;i<MAX_CLIP_PLANES;i++) {
		1323	ASSIGN_4V( ctx->Transform.EyeUserPlane[i], 0.0, 0.0, 0.0, 0.0 );
		1324	}
		1325	ctx->Transform.ClipPlanesEnabled = 0;
		1326
		1327	/* Viewport group */
		1328	ctx->Viewport.X = 0;
		1329	ctx->Viewport.Y = 0;
		1330	ctx->Viewport.Width = 0;
		1331	ctx->Viewport.Height = 0;
		1332	ctx->Viewport.Near = 0.0;
		1333	ctx->Viewport.Far = 1.0;
		1334	_math_matrix_ctr(&ctx->Viewport._WindowMap);
		1335
		1336	#define Sz 10
		1337	#define Tz 14
		1338	ctx->Viewport._WindowMap.m[Sz] = 0.5F * ctx->DepthMaxF;
		1339	ctx->Viewport._WindowMap.m[Tz] = 0.5F * ctx->DepthMaxF;
		1340	#undef Sz
		1341	#undef Tz
		1342
		1343	ctx->Viewport._WindowMap.flags = MAT_FLAG_GENERAL_SCALE\|MAT_FLAG_TRANSLATION;
		1344	ctx->Viewport._WindowMap.type = MATRIX_3D_NO_ROT;
		1345
		1346	/* Vertex arrays */
		1347	ctx->Array.Vertex.Size = 4;
		1348	ctx->Array.Vertex.Type = GL_FLOAT;
		1349	ctx->Array.Vertex.Stride = 0;
		1350	ctx->Array.Vertex.StrideB = 0;
		1351	ctx->Array.Vertex.Ptr = NULL;
		1352	ctx->Array.Vertex.Enabled = GL_FALSE;
		1353	ctx->Array.Vertex.Flags = CA_CLIENT_DATA;
		1354	ctx->Array.Normal.Type = GL_FLOAT;
		1355	ctx->Array.Normal.Stride = 0;
		1356	ctx->Array.Normal.StrideB = 0;
		1357	ctx->Array.Normal.Ptr = NULL;
		1358	ctx->Array.Normal.Enabled = GL_FALSE;
		1359	ctx->Array.Normal.Flags = CA_CLIENT_DATA;
		1360	ctx->Array.Color.Size = 4;
		1361	ctx->Array.Color.Type = GL_FLOAT;
		1362	ctx->Array.Color.Stride = 0;
		1363	ctx->Array.Color.StrideB = 0;
		1364	ctx->Array.Color.Ptr = NULL;
		1365	ctx->Array.Color.Enabled = GL_FALSE;
		1366	ctx->Array.Color.Flags = CA_CLIENT_DATA;
		1367	ctx->Array.SecondaryColor.Size = 4;
		1368	ctx->Array.SecondaryColor.Type = GL_FLOAT;
		1369	ctx->Array.SecondaryColor.Stride = 0;
		1370	ctx->Array.SecondaryColor.StrideB = 0;
		1371	ctx->Array.SecondaryColor.Ptr = NULL;
		1372	ctx->Array.SecondaryColor.Enabled = GL_FALSE;
		1373	ctx->Array.SecondaryColor.Flags = CA_CLIENT_DATA;
		1374	ctx->Array.FogCoord.Size = 1;
		1375	ctx->Array.FogCoord.Type = GL_FLOAT;
		1376	ctx->Array.FogCoord.Stride = 0;
		1377	ctx->Array.FogCoord.StrideB = 0;
		1378	ctx->Array.FogCoord.Ptr = NULL;
		1379	ctx->Array.FogCoord.Enabled = GL_FALSE;
		1380	ctx->Array.FogCoord.Flags = CA_CLIENT_DATA;
		1381	ctx->Array.Index.Type = GL_FLOAT;
		1382	ctx->Array.Index.Stride = 0;
		1383	ctx->Array.Index.StrideB = 0;
		1384	ctx->Array.Index.Ptr = NULL;
		1385	ctx->Array.Index.Enabled = GL_FALSE;
		1386	ctx->Array.Index.Flags = CA_CLIENT_DATA;
		1387	for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
		1388	ctx->Array.TexCoord[i].Size = 4;
		1389	ctx->Array.TexCoord[i].Type = GL_FLOAT;
		1390	ctx->Array.TexCoord[i].Stride = 0;
		1391	ctx->Array.TexCoord[i].StrideB = 0;
		1392	ctx->Array.TexCoord[i].Ptr = NULL;
		1393	ctx->Array.TexCoord[i].Enabled = GL_FALSE;
		1394	ctx->Array.TexCoord[i].Flags = CA_CLIENT_DATA;
		1395	}
		1396	ctx->Array.TexCoordInterleaveFactor = 1;
		1397	ctx->Array.EdgeFlag.Stride = 0;
		1398	ctx->Array.EdgeFlag.StrideB = 0;
		1399	ctx->Array.EdgeFlag.Ptr = NULL;
		1400	ctx->Array.EdgeFlag.Enabled = GL_FALSE;
		1401	ctx->Array.EdgeFlag.Flags = CA_CLIENT_DATA;
		1402	ctx->Array.ActiveTexture = 0; /* GL_ARB_multitexture */
		1403
		1404	/* Pixel transfer */
		1405	ctx->Pack.Alignment = 4;
		1406	ctx->Pack.RowLength = 0;
		1407	ctx->Pack.ImageHeight = 0;
		1408	ctx->Pack.SkipPixels = 0;
		1409	ctx->Pack.SkipRows = 0;
		1410	ctx->Pack.SkipImages = 0;
		1411	ctx->Pack.SwapBytes = GL_FALSE;
		1412	ctx->Pack.LsbFirst = GL_FALSE;
		1413	ctx->Unpack.Alignment = 4;
		1414	ctx->Unpack.RowLength = 0;
		1415	ctx->Unpack.ImageHeight = 0;
		1416	ctx->Unpack.SkipPixels = 0;
		1417	ctx->Unpack.SkipRows = 0;
		1418	ctx->Unpack.SkipImages = 0;
		1419	ctx->Unpack.SwapBytes = GL_FALSE;
		1420	ctx->Unpack.LsbFirst = GL_FALSE;
		1421
		1422	/* Feedback */
		1423	ctx->Feedback.Type = GL_2D; /* TODO: verify */
		1424	ctx->Feedback.Buffer = NULL;
		1425	ctx->Feedback.BufferSize = 0;
		1426	ctx->Feedback.Count = 0;
		1427
		1428	/* Selection/picking */
		1429	ctx->Select.Buffer = NULL;
		1430	ctx->Select.BufferSize = 0;
		1431	ctx->Select.BufferCount = 0;
		1432	ctx->Select.Hits = 0;
		1433	ctx->Select.NameStackDepth = 0;
		1434
		1435	/* Renderer and client attribute stacks */
		1436	ctx->AttribStackDepth = 0;
		1437	ctx->ClientAttribStackDepth = 0;
		1438
		1439	/* Display list */
		1440	ctx->CallDepth = 0;
		1441	ctx->ExecuteFlag = GL_TRUE;
		1442	ctx->CompileFlag = GL_FALSE;
		1443	ctx->CurrentListPtr = NULL;
		1444	ctx->CurrentBlock = NULL;
		1445	ctx->CurrentListNum = 0;
		1446	ctx->CurrentPos = 0;
		1447
		1448	/* Color tables */
		1449	_mesa_init_colortable(&ctx->ColorTable);
		1450	_mesa_init_colortable(&ctx->ProxyColorTable);
		1451	_mesa_init_colortable(&ctx->PostConvolutionColorTable);
		1452	_mesa_init_colortable(&ctx->ProxyPostConvolutionColorTable);
		1453	_mesa_init_colortable(&ctx->PostColorMatrixColorTable);
		1454	_mesa_init_colortable(&ctx->ProxyPostColorMatrixColorTable);
		1455
		1456	/* GL_NV_vertex_program */
		1457	ctx->VertexProgram.Enabled = GL_FALSE;
		1458	ctx->VertexProgram.PointSizeEnabled = GL_FALSE;
		1459	ctx->VertexProgram.TwoSideEnabled = GL_FALSE;
		1460	ctx->VertexProgram.CurrentID = 0;
		1461	ctx->VertexProgram.ErrorPos = -1;
		1462	ctx->VertexProgram.Current = NULL;
		1463	for (i = 0; i < VP_NUM_PROG_REGS / 4; i++) {
		1464	ctx->VertexProgram.TrackMatrix[i] = GL_NONE;
		1465	ctx->VertexProgram.TrackMatrixTransform[i] = GL_IDENTITY_NV;
		1466	}
		1467
		1468	/* Miscellaneous */
		1469	ctx->NewState = _NEW_ALL;
		1470	ctx->RenderMode = GL_RENDER;
		1471	ctx->_ImageTransferState = 0;
		1472
		1473	ctx->_NeedNormals = 0;
		1474	ctx->_NeedEyeCoords = 0;
		1475	ctx->_ModelViewInvScale = 1.0;
		1476
		1477	ctx->ErrorValue = (GLenum) GL_NO_ERROR;
		1478
		1479	ctx->CatchSignals = GL_TRUE;
		1480	ctx->OcclusionResult = GL_FALSE;
		1481	ctx->OcclusionResultSaved = GL_FALSE;
		1482	ctx->_Facing = 0;
		1483
		1484	/* For debug/development only */
		1485	ctx->NoRaster = _mesa_getenv("MESA_NO_RASTER") ? GL_TRUE : GL_FALSE;
		1486	ctx->FirstTimeCurrent = GL_TRUE;
		1487
		1488	/* Dither disable */
		1489	ctx->NoDither = _mesa_getenv("MESA_NO_DITHER") ? GL_TRUE : GL_FALSE;
		1490	if (ctx->NoDither) {
		1491	if (_mesa_getenv("MESA_DEBUG")) {
		1492	_mesa_debug(ctx, "MESA_NO_DITHER set - dithering disabled\n");
		1493	}
		1494	ctx->Color.DitherFlag = GL_FALSE;
		1495	}
		1496	}
		1497
		1498
		1499
		1500
		1501	/*
		1502	* Allocate the proxy textures. If we run out of memory part way through
		1503	* the allocations clean up and return GL_FALSE.
		1504	* Return: GL_TRUE=success, GL_FALSE=failure
		1505	*/
		1506	static GLboolean
		1507	alloc_proxy_textures( GLcontext *ctx )
		1508	{
		1509	GLboolean out_of_memory;
		1510	GLint i;
		1511
		1512	ctx->Texture.Proxy1D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_1D);
		1513	if (!ctx->Texture.Proxy1D) {
		1514	return GL_FALSE;
		1515	}
		1516
		1517	ctx->Texture.Proxy2D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_2D);
		1518	if (!ctx->Texture.Proxy2D) {
		1519	_mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
		1520	return GL_FALSE;
		1521	}
		1522
		1523	ctx->Texture.Proxy3D = _mesa_alloc_texture_object(NULL, 0, GL_TEXTURE_3D);
		1524	if (!ctx->Texture.Proxy3D) {
		1525	_mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
		1526	_mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
		1527	return GL_FALSE;
		1528	}
		1529
		1530	ctx->Texture.ProxyCubeMap = _mesa_alloc_texture_object(NULL, 0,
		1531	GL_TEXTURE_CUBE_MAP_ARB);
		1532	if (!ctx->Texture.ProxyCubeMap) {
		1533	_mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
		1534	_mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
		1535	_mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
		1536	return GL_FALSE;
		1537	}
		1538
		1539	ctx->Texture.ProxyRect = _mesa_alloc_texture_object(NULL, 0,
		1540	GL_TEXTURE_RECTANGLE_NV);
		1541	if (!ctx->Texture.ProxyRect) {
		1542	_mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
		1543	_mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
		1544	_mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
		1545	_mesa_free_texture_object(NULL, ctx->Texture.ProxyCubeMap);
		1546	return GL_FALSE;
		1547	}
		1548
		1549	out_of_memory = GL_FALSE;
		1550	for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
		1551	ctx->Texture.Proxy1D->Image[i] = _mesa_alloc_texture_image();
		1552	ctx->Texture.Proxy2D->Image[i] = _mesa_alloc_texture_image();
		1553	ctx->Texture.Proxy3D->Image[i] = _mesa_alloc_texture_image();
		1554	ctx->Texture.ProxyCubeMap->Image[i] = _mesa_alloc_texture_image();
		1555	if (!ctx->Texture.Proxy1D->Image[i]
		1556	\|\| !ctx->Texture.Proxy2D->Image[i]
		1557	\|\| !ctx->Texture.Proxy3D->Image[i]
		1558	\|\| !ctx->Texture.ProxyCubeMap->Image[i]) {
		1559	out_of_memory = GL_TRUE;
		1560	}
		1561	}
		1562	ctx->Texture.ProxyRect->Image[0] = _mesa_alloc_texture_image();
		1563	if (!ctx->Texture.ProxyRect->Image[0])
		1564	out_of_memory = GL_TRUE;
		1565
		1566	if (out_of_memory) {
		1567	for (i=0;i<MAX_TEXTURE_LEVELS;i++) {
		1568	if (ctx->Texture.Proxy1D->Image[i]) {
		1569	_mesa_free_texture_image(ctx->Texture.Proxy1D->Image[i]);
		1570	}
		1571	if (ctx->Texture.Proxy2D->Image[i]) {
		1572	_mesa_free_texture_image(ctx->Texture.Proxy2D->Image[i]);
		1573	}
		1574	if (ctx->Texture.Proxy3D->Image[i]) {
		1575	_mesa_free_texture_image(ctx->Texture.Proxy3D->Image[i]);
		1576	}
		1577	if (ctx->Texture.ProxyCubeMap->Image[i]) {
		1578	_mesa_free_texture_image(ctx->Texture.ProxyCubeMap->Image[i]);
		1579	}
		1580	}
		1581	if (ctx->Texture.ProxyRect->Image[0]) {
		1582	_mesa_free_texture_image(ctx->Texture.ProxyRect->Image[0]);
		1583	}
		1584	_mesa_free_texture_object(NULL, ctx->Texture.Proxy1D);
		1585	_mesa_free_texture_object(NULL, ctx->Texture.Proxy2D);
		1586	_mesa_free_texture_object(NULL, ctx->Texture.Proxy3D);
		1587	_mesa_free_texture_object(NULL, ctx->Texture.ProxyCubeMap);
		1588	_mesa_free_texture_object(NULL, ctx->Texture.ProxyRect);
		1589	return GL_FALSE;
		1590	}
		1591	else {
		1592	return GL_TRUE;
		1593	}
		1594	}
		1595
		1596
		1597	static void add_debug_flags( const char *debug )
		1598	{
		1599	#ifdef MESA_DEBUG
		1600	if (_mesa_strstr(debug, "varray"))
		1601	MESA_VERBOSE \|= VERBOSE_VARRAY;
		1602
		1603	if (_mesa_strstr(debug, "tex"))
		1604	MESA_VERBOSE \|= VERBOSE_TEXTURE;
		1605
		1606	if (_mesa_strstr(debug, "imm"))
		1607	MESA_VERBOSE \|= VERBOSE_IMMEDIATE;
		1608
		1609	if (_mesa_strstr(debug, "pipe"))
		1610	MESA_VERBOSE \|= VERBOSE_PIPELINE;
		1611
		1612	if (_mesa_strstr(debug, "driver"))
		1613	MESA_VERBOSE \|= VERBOSE_DRIVER;
		1614
		1615	if (_mesa_strstr(debug, "state"))
		1616	MESA_VERBOSE \|= VERBOSE_STATE;
		1617
		1618	if (_mesa_strstr(debug, "api"))
		1619	MESA_VERBOSE \|= VERBOSE_API;
		1620
		1621	if (_mesa_strstr(debug, "list"))
		1622	MESA_VERBOSE \|= VERBOSE_DISPLAY_LIST;
		1623
		1624	if (_mesa_strstr(debug, "lighting"))
		1625	MESA_VERBOSE \|= VERBOSE_LIGHTING;
		1626
		1627	/* Debug flag:
		1628	*/
		1629	if (_mesa_strstr(debug, "flush"))
		1630	MESA_DEBUG_FLAGS \|= DEBUG_ALWAYS_FLUSH;
		1631	#endif
		1632	}
		1633
		1634
		1635	/*
		1636	* Initialize a GLcontext struct. This includes allocating all the
		1637	* other structs and arrays which hang off of the context by pointers.
		1638	*/
		1639	GLboolean
		1640	_mesa_initialize_context( GLcontext *ctx,
		1641	const GLvisual *visual,
		1642	GLcontext *share_list,
		1643	void *driver_ctx,
		1644	GLboolean direct )
		1645	{
		1646	GLuint dispatchSize;
		1647	const char *c;
		1648
		1649	ASSERT(driver_ctx);
		1650
		1651	/* If the driver wants core Mesa to use special imports, it'll have to
		1652	* override these defaults.
		1653	*/
		1654	_mesa_init_default_imports( &(ctx->imports), driver_ctx );
		1655
		1656	/* initialize the exports (Mesa functions called by the window system) */
		1657	_mesa_init_default_exports( &(ctx->exports) );
		1658
		1659	/* misc one-time initializations */
		1660	one_time_init(ctx);
		1661
		1662	ctx->DriverCtx = driver_ctx;
		1663	ctx->Visual = *visual;
		1664	ctx->DrawBuffer = NULL;
		1665	ctx->ReadBuffer = NULL;
		1666
		1667	if (share_list) {
		1668	/* share state with another context */
		1669	ctx->Shared = share_list->Shared;
		1670	}
		1671	else {
		1672	/* allocate new, unshared state */
		1673	ctx->Shared = alloc_shared_state();
		1674	if (!ctx->Shared) {
		1675	return GL_FALSE;
		1676	}
		1677	}
		1678	_glthread_LOCK_MUTEX(ctx->Shared->Mutex);
		1679	ctx->Shared->RefCount++;
		1680	_glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
		1681
		1682	/* Effectively bind the default textures to all texture units */
		1683	ctx->Shared->Default1D->RefCount += MAX_TEXTURE_UNITS;
		1684	ctx->Shared->Default2D->RefCount += MAX_TEXTURE_UNITS;
		1685	ctx->Shared->Default3D->RefCount += MAX_TEXTURE_UNITS;
		1686	ctx->Shared->DefaultCubeMap->RefCount += MAX_TEXTURE_UNITS;
		1687	ctx->Shared->DefaultRect->RefCount += MAX_TEXTURE_UNITS;
		1688
		1689	init_attrib_groups( ctx );
		1690
		1691	if (visual->doubleBufferMode) {
		1692	ctx->Color.DrawBuffer = GL_BACK;
		1693	ctx->Color._DrawDestMask = BACK_LEFT_BIT;
		1694	ctx->Pixel.ReadBuffer = GL_BACK;
		1695	ctx->Pixel._ReadSrcMask = BACK_LEFT_BIT;
		1696	}
		1697	else {
		1698	ctx->Color.DrawBuffer = GL_FRONT;
		1699	ctx->Color._DrawDestMask = FRONT_LEFT_BIT;
		1700	ctx->Pixel.ReadBuffer = GL_FRONT;
		1701	ctx->Pixel._ReadSrcMask = FRONT_LEFT_BIT;
		1702	}
		1703
		1704	if (!alloc_proxy_textures(ctx)) {
		1705	free_shared_state(ctx, ctx->Shared);
		1706	return GL_FALSE;
		1707	}
		1708
		1709	/*
		1710	* For XFree86/DRI: tell libGL to add these functions to the dispatcher.
		1711	* Basically, we should add all extension functions above offset 577.
		1712	* This enables older libGL libraries to work with newer drivers that
		1713	* have newer extensions.
		1714	*/
		1715	/* GL_ARB_window_pos aliases with GL_MESA_window_pos */
		1716	_glapi_add_entrypoint("glWindowPos2dARB", 513);
		1717	_glapi_add_entrypoint("glWindowPos2dvARB", 514);
		1718	_glapi_add_entrypoint("glWindowPos2fARB", 515);
		1719	_glapi_add_entrypoint("glWindowPos2fvARB", 516);
		1720	_glapi_add_entrypoint("glWindowPos2iARB", 517);
		1721	_glapi_add_entrypoint("glWindowPos2ivARB", 518);
		1722	_glapi_add_entrypoint("glWindowPos2sARB", 519);
		1723	_glapi_add_entrypoint("glWindowPos2svARB", 520);
		1724	_glapi_add_entrypoint("glWindowPos3dARB", 521);
		1725	_glapi_add_entrypoint("glWindowPos3dvARB", 522);
		1726	_glapi_add_entrypoint("glWindowPos3fARB", 523);
		1727	_glapi_add_entrypoint("glWindowPos3fvARB", 524);
		1728	_glapi_add_entrypoint("glWindowPos3iARB", 525);
		1729	_glapi_add_entrypoint("glWindowPos3ivARB", 526);
		1730	_glapi_add_entrypoint("glWindowPos3sARB", 527);
		1731	_glapi_add_entrypoint("glWindowPos3svARB", 528);
		1732	/* new extension functions */
		1733	_glapi_add_entrypoint("glAreProgramsResidentNV", 578);
		1734	_glapi_add_entrypoint("glBindProgramNV", 579);
		1735	_glapi_add_entrypoint("glDeleteProgramsNV", 580);
		1736	_glapi_add_entrypoint("glExecuteProgramNV", 581);
		1737	_glapi_add_entrypoint("glGenProgramsNV", 582);
		1738	_glapi_add_entrypoint("glGetProgramParameterdvNV", 583);
		1739	_glapi_add_entrypoint("glGetProgramParameterfvNV", 584);
		1740	_glapi_add_entrypoint("glGetProgramivNV", 585);
		1741	_glapi_add_entrypoint("glGetProgramStringNV", 586);
		1742	_glapi_add_entrypoint("glGetTrackMatrixivNV", 587);
		1743	_glapi_add_entrypoint("glGetVertexAttribdvNV", 588);
		1744	_glapi_add_entrypoint("glGetVertexAttribfvNV", 589);
		1745	_glapi_add_entrypoint("glGetVertexAttribivNV", 590);
		1746	_glapi_add_entrypoint("glGetVertexAttribPointervNV", 591);
		1747	_glapi_add_entrypoint("glIsProgramNV", 592);
		1748	_glapi_add_entrypoint("glLoadProgramNV", 593);
		1749	_glapi_add_entrypoint("glProgramParameter4dNV", 594);
		1750	_glapi_add_entrypoint("glProgramParameter4dvNV", 595);
		1751	_glapi_add_entrypoint("glProgramParameter4fNV", 596);
		1752	_glapi_add_entrypoint("glProgramParameter4fvNV", 597);
		1753	_glapi_add_entrypoint("glProgramParameters4dvNV", 598);
		1754	_glapi_add_entrypoint("glProgramParameters4fvNV", 599);
		1755	_glapi_add_entrypoint("glRequestResidentProgramsNV", 600);
		1756	_glapi_add_entrypoint("glTrackMatrixNV", 601);
		1757	_glapi_add_entrypoint("glVertexAttribPointerNV", 602);
		1758	_glapi_add_entrypoint("glVertexAttrib1dNV", 603);
		1759	_glapi_add_entrypoint("glVertexAttrib1dvNV", 604);
		1760	_glapi_add_entrypoint("glVertexAttrib1fNV", 605);
		1761	_glapi_add_entrypoint("glVertexAttrib1fvNV", 606);
		1762	_glapi_add_entrypoint("glVertexAttrib1sNV", 607);
		1763	_glapi_add_entrypoint("glVertexAttrib1svNV", 608);
		1764	_glapi_add_entrypoint("glVertexAttrib2dNV", 609);
		1765	_glapi_add_entrypoint("glVertexAttrib2dvNV", 610);
		1766	_glapi_add_entrypoint("glVertexAttrib2fNV", 611);
		1767	_glapi_add_entrypoint("glVertexAttrib2fvNV", 612);
		1768	_glapi_add_entrypoint("glVertexAttrib2sNV", 613);
		1769	_glapi_add_entrypoint("glVertexAttrib2svNV", 614);
		1770	_glapi_add_entrypoint("glVertexAttrib3dNV", 615);
		1771	_glapi_add_entrypoint("glVertexAttrib3dvNV", 616);
		1772	_glapi_add_entrypoint("glVertexAttrib3fNV", 617);
		1773	_glapi_add_entrypoint("glVertexAttrib3fvNV", 618);
		1774	_glapi_add_entrypoint("glVertexAttrib3sNV", 619);
		1775	_glapi_add_entrypoint("glVertexAttrib3svNV", 620);
		1776	_glapi_add_entrypoint("glVertexAttrib4dNV", 621);
		1777	_glapi_add_entrypoint("glVertexAttrib4dvNV", 622);
		1778	_glapi_add_entrypoint("glVertexAttrib4fNV", 623);
		1779	_glapi_add_entrypoint("glVertexAttrib4fvNV", 624);
		1780	_glapi_add_entrypoint("glVertexAttrib4sNV", 625);
		1781	_glapi_add_entrypoint("glVertexAttrib4svNV", 626);
		1782	_glapi_add_entrypoint("glVertexAttrib4ubNV", 627);
		1783	_glapi_add_entrypoint("glVertexAttrib4ubvNV", 628);
		1784	_glapi_add_entrypoint("glVertexAttribs1dvNV", 629);
		1785	_glapi_add_entrypoint("glVertexAttribs1fvNV", 630);
		1786	_glapi_add_entrypoint("glVertexAttribs1svNV", 631);
		1787	_glapi_add_entrypoint("glVertexAttribs2dvNV", 632);
		1788	_glapi_add_entrypoint("glVertexAttribs2fvNV", 633);
		1789	_glapi_add_entrypoint("glVertexAttribs2svNV", 634);
		1790	_glapi_add_entrypoint("glVertexAttribs3dvNV", 635);
		1791	_glapi_add_entrypoint("glVertexAttribs3fvNV", 636);
		1792	_glapi_add_entrypoint("glVertexAttribs3svNV", 637);
		1793	_glapi_add_entrypoint("glVertexAttribs4dvNV", 638);
		1794	_glapi_add_entrypoint("glVertexAttribs4fvNV", 639);
		1795	_glapi_add_entrypoint("glVertexAttribs4svNV", 640);
		1796	_glapi_add_entrypoint("glVertexAttribs4ubvNV", 641);
		1797	_glapi_add_entrypoint("glPointParameteriNV", 642);
		1798	_glapi_add_entrypoint("glPointParameterivNV", 643);
		1799	_glapi_add_entrypoint("glMultiDrawArraysEXT", 644);
		1800	_glapi_add_entrypoint("glMultiDrawElementsEXT", 645);
		1801	_glapi_add_entrypoint("glActiveStencilFaceEXT", 646);
		1802	_glapi_add_entrypoint("glDeleteFencesNV", 647);
		1803	_glapi_add_entrypoint("glGenFencesNV", 648);
		1804	_glapi_add_entrypoint("glIsFenceNV", 649);
		1805	_glapi_add_entrypoint("glTestFenceNV", 650);
		1806	_glapi_add_entrypoint("glGetFenceivNV", 651);
		1807	_glapi_add_entrypoint("glFinishFenceNV", 652);
		1808	_glapi_add_entrypoint("glSetFenceNV", 653);
		1809
		1810	/* Find the larger of Mesa's dispatch table and libGL's dispatch table.
		1811	* In practice, this'll be the same for stand-alone Mesa. But for DRI
		1812	* Mesa we do this to accomodate different versions of libGL and various
		1813	* DRI drivers.
		1814	*/
		1815	dispatchSize = MAX2(_glapi_get_dispatch_table_size(),
		1816	sizeof(struct _glapi_table) / sizeof(void *));
		1817
		1818	/* setup API dispatch tables */
		1819	ctx->Exec = (struct _glapi_table ) CALLOC(dispatchSize sizeof(void*));
		1820	ctx->Save = (struct _glapi_table ) CALLOC(dispatchSize sizeof(void*));
		1821	if (!ctx->Exec \|\| !ctx->Save) {
		1822	free_shared_state(ctx, ctx->Shared);
		1823	if (ctx->Exec)
		1824	FREE( ctx->Exec );
		1825	}
		1826	_mesa_init_exec_table(ctx->Exec, dispatchSize);
		1827	_mesa_init_dlist_table(ctx->Save, dispatchSize);
		1828	ctx->CurrentDispatch = ctx->Exec;
		1829
		1830	ctx->ExecPrefersFloat = GL_FALSE;
		1831	ctx->SavePrefersFloat = GL_FALSE;
		1832
		1833	/* Neutral tnl module stuff */
		1834	_mesa_init_exec_vtxfmt( ctx );
		1835	ctx->TnlModule.Current = NULL;
		1836	ctx->TnlModule.SwapCount = 0;
		1837
		1838	/* Z buffer stuff */
		1839	if (ctx->Visual.depthBits == 0) {
		1840	/* Special case. Even if we don't have a depth buffer we need
		1841	* good values for DepthMax for Z vertex transformation purposes
		1842	* and for per-fragment fog computation.
		1843	*/
		1844	ctx->DepthMax = 1 << 16;
		1845	ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
		1846	}
		1847	else if (ctx->Visual.depthBits < 32) {
		1848	ctx->DepthMax = (1 << ctx->Visual.depthBits) - 1;
		1849	ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
		1850	}
		1851	else {
		1852	/* Special case since shift values greater than or equal to the
		1853	* number of bits in the left hand expression's type are undefined.
		1854	*/
		1855	ctx->DepthMax = 0xffffffff;
		1856	ctx->DepthMaxF = (GLfloat) ctx->DepthMax;
		1857	}
		1858	ctx->MRD = 1.0; /* Minimum resolvable depth value, for polygon offset */
		1859
		1860	c = _mesa_getenv("MESA_DEBUG");
		1861	if (c)
		1862	add_debug_flags(c);
		1863
		1864	c = _mesa_getenv("MESA_VERBOSE");
		1865	if (c)
		1866	add_debug_flags(c);
		1867
		1868	return GL_TRUE;
		1869	}
		1870
		1871
		1872
		1873	/*
		1874	* Allocate and initialize a GLcontext structure.
		1875	* Input: visual - a GLvisual pointer (we copy the struct contents)
		1876	* sharelist - another context to share display lists with or NULL
		1877	* driver_ctx - pointer to device driver's context state struct
		1878	* direct - direct rendering?
		1879	* Return: pointer to a new __GLcontextRec or NULL if error.
		1880	*/
		1881	GLcontext *
		1882	_mesa_create_context( const GLvisual *visual,
		1883	GLcontext *share_list,
		1884	void *driver_ctx,
		1885	GLboolean direct )
		1886
		1887	{
		1888	GLcontext *ctx;
		1889
		1890	ASSERT(visual);
		1891	ASSERT(driver_ctx);
		1892
		1893	ctx = (GLcontext *) _mesa_calloc(sizeof(GLcontext));
		1894	if (!ctx)
		1895	return NULL;
		1896
		1897	if (_mesa_initialize_context(ctx, visual, share_list, driver_ctx, direct)) {
		1898	return ctx;
		1899	}
		1900	else {
		1901	_mesa_free(ctx);
		1902	return NULL;
		1903	}
		1904	}
		1905
		1906
		1907
		1908	/*
		1909	* Free the data associated with the given context.
		1910	* But don't free() the GLcontext struct itself!
		1911	*/
		1912	void
		1913	_mesa_free_context_data( GLcontext *ctx )
		1914	{
		1915	struct gl_shine_tab s, tmps;
		1916	GLuint i;
		1917
		1918	/* if we're destroying the current context, unbind it first */
		1919	if (ctx == _mesa_get_current_context()) {
		1920	_mesa_make_current(NULL, NULL);
		1921	}
		1922
		1923	/*
		1924	* Free transformation matrix stacks
		1925	*/
		1926	free_matrix_stack(&ctx->ModelviewMatrixStack);
		1927	free_matrix_stack(&ctx->ProjectionMatrixStack);
		1928	free_matrix_stack(&ctx->ColorMatrixStack);
		1929	for (i = 0; i < MAX_TEXTURE_UNITS; i++)
		1930	free_matrix_stack(&ctx->TextureMatrixStack[i]);
		1931	for (i = 0; i < MAX_PROGRAM_MATRICES; i++)
		1932	free_matrix_stack(&ctx->ProgramMatrixStack[i]);
		1933	/* combined ModelviewProjection matrix /
		1934	_math_matrix_dtr( &ctx->_ModelProjectMatrix );
		1935
		1936
		1937	#if FEATURE_NV_vertex_program
		1938	if (ctx->VertexProgram.Current) {
		1939	ctx->VertexProgram.Current->RefCount--;
		1940	if (ctx->VertexProgram.Current->RefCount <= 0)
		1941	_mesa_delete_program(ctx, ctx->VertexProgram.CurrentID);
		1942	}
		1943	#endif
		1944
		1945	/* Shared context state (display lists, textures, etc) */
		1946	_glthread_LOCK_MUTEX(ctx->Shared->Mutex);
		1947	ctx->Shared->RefCount--;
		1948	assert(ctx->Shared->RefCount >= 0);
		1949	_glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
		1950	if (ctx->Shared->RefCount == 0) {
		1951	/* free shared state */
		1952	free_shared_state( ctx, ctx->Shared );
		1953	}
		1954
		1955	/* Free lighting shininess exponentiation table */
		1956	foreach_s( s, tmps, ctx->_ShineTabList ) {
		1957	FREE( s );
		1958	}
		1959	FREE( ctx->_ShineTabList );
		1960
		1961	/* Free proxy texture objects */
		1962	_mesa_free_texture_object( NULL, ctx->Texture.Proxy1D );
		1963	_mesa_free_texture_object( NULL, ctx->Texture.Proxy2D );
		1964	_mesa_free_texture_object( NULL, ctx->Texture.Proxy3D );
		1965	_mesa_free_texture_object( NULL, ctx->Texture.ProxyCubeMap );
		1966	_mesa_free_texture_object( NULL, ctx->Texture.ProxyRect );
		1967
		1968	/* Free evaluator data */
		1969	if (ctx->EvalMap.Map1Vertex3.Points)
		1970	FREE( ctx->EvalMap.Map1Vertex3.Points );
		1971	if (ctx->EvalMap.Map1Vertex4.Points)
		1972	FREE( ctx->EvalMap.Map1Vertex4.Points );
		1973	if (ctx->EvalMap.Map1Index.Points)
		1974	FREE( ctx->EvalMap.Map1Index.Points );
		1975	if (ctx->EvalMap.Map1Color4.Points)
		1976	FREE( ctx->EvalMap.Map1Color4.Points );
		1977	if (ctx->EvalMap.Map1Normal.Points)
		1978	FREE( ctx->EvalMap.Map1Normal.Points );
		1979	if (ctx->EvalMap.Map1Texture1.Points)
		1980	FREE( ctx->EvalMap.Map1Texture1.Points );
		1981	if (ctx->EvalMap.Map1Texture2.Points)
		1982	FREE( ctx->EvalMap.Map1Texture2.Points );
		1983	if (ctx->EvalMap.Map1Texture3.Points)
		1984	FREE( ctx->EvalMap.Map1Texture3.Points );
		1985	if (ctx->EvalMap.Map1Texture4.Points)
		1986	FREE( ctx->EvalMap.Map1Texture4.Points );
		1987	for (i = 0; i < 16; i++)
		1988	FREE((ctx->EvalMap.Map1Attrib[i].Points));
		1989
		1990	if (ctx->EvalMap.Map2Vertex3.Points)
		1991	FREE( ctx->EvalMap.Map2Vertex3.Points );
		1992	if (ctx->EvalMap.Map2Vertex4.Points)
		1993	FREE( ctx->EvalMap.Map2Vertex4.Points );
		1994	if (ctx->EvalMap.Map2Index.Points)
		1995	FREE( ctx->EvalMap.Map2Index.Points );
		1996	if (ctx->EvalMap.Map2Color4.Points)
		1997	FREE( ctx->EvalMap.Map2Color4.Points );
		1998	if (ctx->EvalMap.Map2Normal.Points)
		1999	FREE( ctx->EvalMap.Map2Normal.Points );
		2000	if (ctx->EvalMap.Map2Texture1.Points)
		2001	FREE( ctx->EvalMap.Map2Texture1.Points );
		2002	if (ctx->EvalMap.Map2Texture2.Points)
		2003	FREE( ctx->EvalMap.Map2Texture2.Points );
		2004	if (ctx->EvalMap.Map2Texture3.Points)
		2005	FREE( ctx->EvalMap.Map2Texture3.Points );
		2006	if (ctx->EvalMap.Map2Texture4.Points)
		2007	FREE( ctx->EvalMap.Map2Texture4.Points );
		2008	for (i = 0; i < 16; i++)
		2009	FREE((ctx->EvalMap.Map2Attrib[i].Points));
		2010
		2011	_mesa_free_colortable_data( &ctx->ColorTable );
		2012	_mesa_free_colortable_data( &ctx->PostConvolutionColorTable );
		2013	_mesa_free_colortable_data( &ctx->PostColorMatrixColorTable );
		2014	_mesa_free_colortable_data( &ctx->Texture.Palette );
		2015
		2016	_math_matrix_dtr(&ctx->Viewport._WindowMap);
		2017
		2018	_mesa_extensions_dtr(ctx);
		2019
		2020	FREE(ctx->Exec);
		2021	FREE(ctx->Save);
		2022	}
		2023
		2024
		2025
		2026	/*
		2027	* Destroy a GLcontext structure.
		2028	*/
		2029	void
		2030	_mesa_destroy_context( GLcontext *ctx )
		2031	{
		2032	if (ctx) {
		2033	_mesa_free_context_data(ctx);
		2034	FREE( (void *) ctx );
		2035	}
		2036	}
		2037
		2038
		2039
		2040	/*
		2041	* Copy attribute groups from one context to another.
		2042	* Input: src - source context
		2043	* dst - destination context
		2044	* mask - bitwise OR of GL_*_BIT flags
		2045	*/
		2046	void
		2047	_mesa_copy_context( const GLcontext src, GLcontext dst, GLuint mask )
		2048	{
		2049	if (mask & GL_ACCUM_BUFFER_BIT) {
		2050	/* OK to memcpy */
		2051	dst->Accum = src->Accum;
		2052	}
		2053	if (mask & GL_COLOR_BUFFER_BIT) {
		2054	/* OK to memcpy */
		2055	dst->Color = src->Color;
		2056	}
		2057	if (mask & GL_CURRENT_BIT) {
		2058	/* OK to memcpy */
		2059	dst->Current = src->Current;
		2060	}
		2061	if (mask & GL_DEPTH_BUFFER_BIT) {
		2062	/* OK to memcpy */
		2063	dst->Depth = src->Depth;
		2064	}
		2065	if (mask & GL_ENABLE_BIT) {
		2066	/* no op */
		2067	}
		2068	if (mask & GL_EVAL_BIT) {
		2069	/* OK to memcpy */
		2070	dst->Eval = src->Eval;
		2071	}
		2072	if (mask & GL_FOG_BIT) {
		2073	/* OK to memcpy */
		2074	dst->Fog = src->Fog;
		2075	}
		2076	if (mask & GL_HINT_BIT) {
		2077	/* OK to memcpy */
		2078	dst->Hint = src->Hint;
		2079	}
		2080	if (mask & GL_LIGHTING_BIT) {
		2081	GLuint i;
		2082	/* begin with memcpy */
		2083	MEMCPY( &dst->Light, &src->Light, sizeof(struct gl_light) );
		2084	/* fixup linked lists to prevent pointer insanity */
		2085	make_empty_list( &(dst->Light.EnabledList) );
		2086	for (i = 0; i < MAX_LIGHTS; i++) {
		2087	if (dst->Light.Light[i].Enabled) {
		2088	insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
		2089	}
		2090	}
		2091	}
		2092	if (mask & GL_LINE_BIT) {
		2093	/* OK to memcpy */
		2094	dst->Line = src->Line;
		2095	}
		2096	if (mask & GL_LIST_BIT) {
		2097	/* OK to memcpy */
		2098	dst->List = src->List;
		2099	}
		2100	if (mask & GL_PIXEL_MODE_BIT) {
		2101	/* OK to memcpy */
		2102	dst->Pixel = src->Pixel;
		2103	}
		2104	if (mask & GL_POINT_BIT) {
		2105	/* OK to memcpy */
		2106	dst->Point = src->Point;
		2107	}
		2108	if (mask & GL_POLYGON_BIT) {
		2109	/* OK to memcpy */
		2110	dst->Polygon = src->Polygon;
		2111	}
		2112	if (mask & GL_POLYGON_STIPPLE_BIT) {
		2113	/* Use loop instead of MEMCPY due to problem with Portland Group's
		2114	* C compiler. Reported by John Stone.
		2115	*/
		2116	GLuint i;
		2117	for (i = 0; i < 32; i++) {
		2118	dst->PolygonStipple[i] = src->PolygonStipple[i];
		2119	}
		2120	}
		2121	if (mask & GL_SCISSOR_BIT) {
		2122	/* OK to memcpy */
		2123	dst->Scissor = src->Scissor;
		2124	}
		2125	if (mask & GL_STENCIL_BUFFER_BIT) {
		2126	/* OK to memcpy */
		2127	dst->Stencil = src->Stencil;
		2128	}
		2129	if (mask & GL_TEXTURE_BIT) {
		2130	/* Cannot memcpy because of pointers */
		2131	_mesa_copy_texture_state(src, dst);
		2132	}
		2133	if (mask & GL_TRANSFORM_BIT) {
		2134	/* OK to memcpy */
		2135	dst->Transform = src->Transform;
		2136	}
		2137	if (mask & GL_VIEWPORT_BIT) {
		2138	/* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
		2139	dst->Viewport.X = src->Viewport.X;
		2140	dst->Viewport.Y = src->Viewport.Y;
		2141	dst->Viewport.Width = src->Viewport.Width;
		2142	dst->Viewport.Height = src->Viewport.Height;
		2143	dst->Viewport.Near = src->Viewport.Near;
		2144	dst->Viewport.Far = src->Viewport.Far;
		2145	_math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
		2146	}
		2147
		2148	/* XXX FIXME: Call callbacks?
		2149	*/
		2150	dst->NewState = _NEW_ALL;
		2151	}
		2152
		2153
		2154
		2155	static void print_info( void )
		2156	{
		2157	_mesa_debug(NULL, "Mesa GL_VERSION = %s\n",
		2158	(char *) _mesa_GetString(GL_VERSION));
		2159	_mesa_debug(NULL, "Mesa GL_RENDERER = %s\n",
		2160	(char *) _mesa_GetString(GL_RENDERER));
		2161	_mesa_debug(NULL, "Mesa GL_VENDOR = %s\n",
		2162	(char *) _mesa_GetString(GL_VENDOR));
		2163	_mesa_debug(NULL, "Mesa GL_EXTENSIONS = %s\n",
		2164	(char *) _mesa_GetString(GL_EXTENSIONS));
		2165	#if defined(THREADS)
		2166	_mesa_debug(NULL, "Mesa thread-safe: YES\n");
		2167	#else
		2168	_mesa_debug(NULL, "Mesa thread-safe: NO\n");
		2169	#endif
		2170	#if defined(USE_X86_ASM)
		2171	_mesa_debug(NULL, "Mesa x86-optimized: YES\n");
		2172	#else
		2173	_mesa_debug(NULL, "Mesa x86-optimized: NO\n");
		2174	#endif
		2175	#if defined(USE_SPARC_ASM)
		2176	_mesa_debug(NULL, "Mesa sparc-optimized: YES\n");
		2177	#else
		2178	_mesa_debug(NULL, "Mesa sparc-optimized: NO\n");
		2179	#endif
		2180	}
		2181
		2182
		2183	/*
		2184	* Set the current context, binding the given frame buffer to the context.
		2185	*/
		2186	void
		2187	_mesa_make_current( GLcontext newCtx, GLframebuffer buffer )
		2188	{
		2189	_mesa_make_current2( newCtx, buffer, buffer );
		2190	}
		2191
		2192
		2193	/*
		2194	* Bind the given context to the given draw-buffer and read-buffer
		2195	* and make it the current context for this thread.
		2196	*/
		2197	void
		2198	_mesa_make_current2( GLcontext newCtx, GLframebuffer drawBuffer,
		2199	GLframebuffer *readBuffer )
		2200	{
		2201	if (MESA_VERBOSE)
		2202	_mesa_debug(newCtx, "_mesa_make_current2()\n");
		2203
		2204	/* Check that the context's and framebuffer's visuals are compatible.
		2205	* We could do a lot more checking here but this'll catch obvious
		2206	* problems.
		2207	*/
		2208	if (newCtx && drawBuffer && readBuffer) {
		2209	if (newCtx->Visual.rgbMode != drawBuffer->Visual.rgbMode \|\|
		2210	newCtx->Visual.redBits != drawBuffer->Visual.redBits \|\|
		2211	newCtx->Visual.depthBits != drawBuffer->Visual.depthBits \|\|
		2212	newCtx->Visual.stencilBits != drawBuffer->Visual.stencilBits \|\|
		2213	newCtx->Visual.accumRedBits != drawBuffer->Visual.accumRedBits) {
		2214	return; /* incompatible */
		2215	}
		2216	}
		2217
		2218	/* We call this function periodically (just here for now) in
		2219	* order to detect when multithreading has begun.
		2220	*/
		2221	_glapi_check_multithread();
		2222
		2223	_glapi_set_context((void *) newCtx);
		2224	ASSERT(_mesa_get_current_context() == newCtx);
		2225
		2226
		2227	if (!newCtx) {
		2228	_glapi_set_dispatch(NULL); /* none current */
		2229	}
		2230	else {
		2231	_glapi_set_dispatch(newCtx->CurrentDispatch);
		2232
		2233	if (drawBuffer && readBuffer) {
		2234	/* TODO: check if newCtx and buffer's visual match??? */
		2235	newCtx->DrawBuffer = drawBuffer;
		2236	newCtx->ReadBuffer = readBuffer;
		2237	newCtx->NewState \|= _NEW_BUFFERS;
		2238
		2239	if (drawBuffer->Width == 0 && drawBuffer->Height == 0) {
		2240	/* get initial window size */
		2241	GLuint bufWidth, bufHeight;
		2242
		2243	/* ask device driver for size of output buffer */
		2244	(*newCtx->Driver.GetBufferSize)( drawBuffer, &bufWidth, &bufHeight );
		2245
		2246	if (drawBuffer->Width == bufWidth && drawBuffer->Height == bufHeight)
		2247	return; /* size is as expected */
		2248
		2249	drawBuffer->Width = bufWidth;
		2250	drawBuffer->Height = bufHeight;
		2251
		2252	newCtx->Driver.ResizeBuffers( drawBuffer );
		2253	}
		2254
		2255	if (readBuffer != drawBuffer &&
		2256	readBuffer->Width == 0 && readBuffer->Height == 0) {
		2257	/* get initial window size */
		2258	GLuint bufWidth, bufHeight;
		2259
		2260	/* ask device driver for size of output buffer */
		2261	(*newCtx->Driver.GetBufferSize)( readBuffer, &bufWidth, &bufHeight );
		2262
		2263	if (readBuffer->Width == bufWidth && readBuffer->Height == bufHeight)
		2264	return; /* size is as expected */
		2265
		2266	readBuffer->Width = bufWidth;
		2267	readBuffer->Height = bufHeight;
		2268
		2269	newCtx->Driver.ResizeBuffers( readBuffer );
		2270	}
		2271	}
		2272
		2273	/* This is only for T&L - a bit out of place, or misnamed (BP) */
		2274	if (newCtx->Driver.MakeCurrent)
		2275	newCtx->Driver.MakeCurrent( newCtx, drawBuffer, readBuffer );
		2276
		2277	/* We can use this to help debug user's problems. Tell them to set
		2278	* the MESA_INFO env variable before running their app. Then the
		2279	* first time each context is made current we'll print some useful
		2280	* information.
		2281	*/
		2282	if (newCtx->FirstTimeCurrent) {
		2283	if (_mesa_getenv("MESA_INFO")) {
		2284	print_info();
		2285	}
		2286	newCtx->FirstTimeCurrent = GL_FALSE;
		2287	}
		2288	}
		2289	}
		2290
		2291
		2292
		2293	/*
		2294	* Return current context handle for the calling thread.
		2295	* This isn't the fastest way to get the current context.
		2296	* If you need speed, see the GET_CURRENT_CONTEXT() macro in context.h
		2297	*/
		2298	GLcontext *
		2299	_mesa_get_current_context( void )
		2300	{
		2301	return (GLcontext *) _glapi_get_context();
		2302	}
		2303
		2304
		2305	/*
		2306	* Return pointer to this context's current API dispatch table.
		2307	* It'll either be the immediate-mode execute dispatcher or the
		2308	* display list compile dispatcher.
		2309	*/
		2310	struct _glapi_table *
		2311	_mesa_get_dispatch(GLcontext *ctx)
		2312	{
		2313	return ctx->CurrentDispatch;
		2314	}
		2315
		2316
		2317
		2318	/**********************************************************************/
		2319	/*** Miscellaneous functions ***/
		2320	/**********************************************************************/
		2321
		2322
		2323	/*
		2324	* Record the given error code and call the driver's Error function if defined.
		2325	* This is called via _mesa_error().
		2326	*/
		2327	void
		2328	_mesa_record_error( GLcontext *ctx, GLenum error )
		2329	{
		2330	if (!ctx)
		2331	return;
		2332
		2333	if (ctx->ErrorValue == GL_NO_ERROR) {
		2334	ctx->ErrorValue = error;
		2335	}
		2336
		2337	/* Call device driver's error handler, if any. This is used on the Mac. */
		2338	if (ctx->Driver.Error) {
		2339	(*ctx->Driver.Error)( ctx );
		2340	}
		2341	}
		2342
		2343
		2344	void
		2345	_mesa_Finish( void )
		2346	{
		2347	GET_CURRENT_CONTEXT(ctx);
		2348	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2349	if (ctx->Driver.Finish) {
		2350	(*ctx->Driver.Finish)( ctx );
		2351	}
		2352	}
		2353
		2354
		2355
		2356	void
		2357	_mesa_Flush( void )
		2358	{
		2359	GET_CURRENT_CONTEXT(ctx);
		2360	ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
		2361	if (ctx->Driver.Flush) {
		2362	(*ctx->Driver.Flush)( ctx );
		2363	}
		2364	}
		2365
		2366
		2367
		2368	const char *_mesa_prim_name[GL_POLYGON+4] = {
		2369	"GL_POINTS",
		2370	"GL_LINES",
		2371	"GL_LINE_LOOP",
		2372	"GL_LINE_STRIP",
		2373	"GL_TRIANGLES",
		2374	"GL_TRIANGLE_STRIP",
		2375	"GL_TRIANGLE_FAN",
		2376	"GL_QUADS",
		2377	"GL_QUAD_STRIP",
		2378	"GL_POLYGON",
		2379	"outside begin/end",
		2380	"inside unkown primitive",
		2381	"unknown state"
		2382	};

Subversion Repositories shark

(root)/shark/branches/xen/ports/mesa/src/context.c - Rev 1618