WebSVN - shark - Blame - Rev 56 - /shark/trunk/ports/mesa/src/tnl/t_imm

Rev	Author	Line No.	Line
56	pj	1	/* $Id: t_imm_api.c,v 1.1 2003-02-28 11:48:06 pj Exp $ */
		2
		3	/*
		4	* Mesa 3-D graphics library
		5	* Version: 4.1
		6	*
		7	* Copyright (C) 1999-2001 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	* Authors:
		27	* Keith Whitwell <keith@tungstengraphics.com>
		28	*/
		29
		30
		31
		32	#include "glheader.h"
		33	#include "context.h"
		34	#include "dlist.h"
		35	#include "enums.h"
		36	#include "light.h"
		37	#include "imports.h"
		38	#include "state.h"
		39	#include "colormac.h"
		40	#include "macros.h"
		41	#include "vtxfmt.h"
		42
		43	#include "t_context.h"
		44	#include "t_imm_api.h"
		45	#include "t_imm_elt.h"
		46	#include "t_imm_exec.h"
		47	#include "t_imm_dlist.h"
		48
		49
		50	/* A cassette is full or flushed on a statechange.
		51	*/
		52	void _tnl_flush_immediate( GLcontext ctx, struct immediate IM )
		53	{
		54	if (!ctx) {
		55	/* We were called by glVertex, glEvalCoord, glArrayElement, etc.
		56	* The current context is corresponds to the IM structure.
		57	*/
		58	GET_CURRENT_CONTEXT(context);
		59	ctx = context;
		60	}
		61
		62	if (MESA_VERBOSE & VERBOSE_IMMEDIATE)
		63	_mesa_debug(ctx, "_tnl_flush_immediate IM: %d compiling: %d\n",
		64	IM->id, ctx->CompileFlag);
		65
		66	if (IM->FlushElt == FLUSH_ELT_EAGER) {
		67	_tnl_translate_array_elts( ctx, IM, IM->LastPrimitive, IM->Count );
		68	}
		69
		70	/* Mark the last primitive:
		71	*/
		72	IM->PrimitiveLength[IM->LastPrimitive] = IM->Count - IM->LastPrimitive;
		73	IM->Primitive[IM->LastPrimitive] \|= PRIM_LAST;
		74
		75	if (ctx->CompileFlag)
		76	_tnl_compile_cassette( ctx, IM );
		77	else
		78	_tnl_execute_cassette( ctx, IM );
		79	}
		80
		81
		82	/* Hook for ctx->Driver.FlushVertices:
		83	*/
		84	void _tnl_flush_vertices( GLcontext *ctx, GLuint flags )
		85	{
		86	struct immediate *IM = TNL_CURRENT_IM(ctx);
		87
		88	if (MESA_VERBOSE & VERBOSE_IMMEDIATE)
		89	_mesa_debug(ctx,
		90	"_tnl_flush_vertices flags %x IM(%d) %d..%d Flag[%d]: %x\n",
		91	flags, IM->id, IM->Start, IM->Count, IM->Start,
		92	IM->Flag[IM->Start]);
		93
		94	if (IM->Flag[IM->Start]) {
		95	if ((flags & FLUSH_UPDATE_CURRENT) \|\|
		96	IM->Count > IM->Start \|\|
		97	(IM->Flag[IM->Start] & (VERT_BIT_BEGIN \| VERT_BIT_END))) {
		98	_tnl_flush_immediate( ctx, IM );
		99	}
		100	}
		101	}
		102
		103
		104	void
		105	_tnl_save_Begin( GLenum mode )
		106	{
		107	GET_CURRENT_CONTEXT(ctx);
		108	struct immediate *IM = TNL_CURRENT_IM(ctx);
		109	GLuint inflags, state;
		110
		111	/* _mesa_debug(ctx, "%s: before: %x\n", __FUNCTION__, IM->BeginState); */
		112
		113	if (mode > GL_POLYGON) {
		114	_mesa_compile_error( ctx, GL_INVALID_ENUM, "_tnl_Begin" );
		115	return;
		116	}
		117
		118	if (ctx->NewState)
		119	_mesa_update_state(ctx);
		120
		121	#if 000
		122	/* if only a very few slots left, might as well flush now
		123	*/
		124	if (IM->Count > IMM_MAXDATA-8) {
		125	_tnl_flush_immediate( ctx, IM );
		126	IM = TNL_CURRENT_IM(ctx);
		127	}
		128	#endif
		129
		130	/* Check for and flush buffered vertices from internal operations.
		131	*/
		132	if (IM->SavedBeginState) {
		133	_tnl_flush_immediate( ctx, IM );
		134	IM = TNL_CURRENT_IM(ctx);
		135	IM->BeginState = IM->SavedBeginState;
		136	IM->SavedBeginState = 0;
		137	}
		138
		139	state = IM->BeginState;
		140	inflags = state & (VERT_BEGIN_0\|VERT_BEGIN_1);
		141	state \|= inflags << 2; /* set error conditions */
		142
		143	if (inflags != (VERT_BEGIN_0\|VERT_BEGIN_1))
		144	{
		145	GLuint count = IM->Count;
		146	GLuint last = IM->LastPrimitive;
		147
		148	state \|= (VERT_BEGIN_0\|VERT_BEGIN_1);
		149	IM->Flag[count] \|= VERT_BIT_BEGIN;
		150	IM->Primitive[count] = mode \| PRIM_BEGIN;
		151	IM->PrimitiveLength[IM->LastPrimitive] = count - IM->LastPrimitive;
		152	IM->LastPrimitive = count;
		153
		154	/* Not quite right. Need to use the fallback '_aa_ArrayElement'
		155	* when not known to be inside begin/end and arrays are
		156	* unlocked.
		157	*/
		158	if (IM->FlushElt == FLUSH_ELT_EAGER) {
		159	_tnl_translate_array_elts( ctx, IM, last, count );
		160	}
		161	}
		162
		163	ctx->Driver.NeedFlush \|= FLUSH_STORED_VERTICES;
		164	IM->BeginState = state;
		165
		166	/* Update save_primitive now. Don't touch ExecPrimitive as this is
		167	* updated in the replay of this cassette if we are in
		168	* COMPILE_AND_EXECUTE mode.
		169	*/
		170	if (ctx->Driver.CurrentSavePrimitive == PRIM_UNKNOWN)
		171	ctx->Driver.CurrentSavePrimitive = PRIM_INSIDE_UNKNOWN_PRIM;
		172	else if (ctx->Driver.CurrentSavePrimitive == PRIM_OUTSIDE_BEGIN_END)
		173	ctx->Driver.CurrentSavePrimitive = mode;
		174	}
		175
		176
		177	void
		178	_tnl_Begin( GLenum mode )
		179	{
		180	GET_CURRENT_CONTEXT(ctx);
		181	TNLcontext *tnl = TNL_CONTEXT(ctx);
		182	ASSERT (!ctx->CompileFlag);
		183
		184	if (mode > GL_POLYGON) {
		185	_mesa_error( ctx, GL_INVALID_ENUM, "_tnl_Begin(0x%x)", mode );
		186	return;
		187	}
		188
		189	if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) {
		190	_mesa_error( ctx, GL_INVALID_OPERATION, "_tnl_Begin" );
		191	return;
		192	}
		193
		194	if (ctx->NewState)
		195	_mesa_update_state(ctx);
		196
		197	{
		198	struct immediate *IM = TNL_CURRENT_IM(ctx);
		199	GLuint count = IM->Count;
		200	GLuint last = IM->LastPrimitive;
		201
		202	if (IM->Start == IM->Count &&
		203	tnl->Driver.NotifyBegin &&
		204	tnl->Driver.NotifyBegin( ctx, mode )) {
		205	return;
		206	}
		207
		208	assert( IM->SavedBeginState == 0 );
		209	assert( IM->BeginState == 0 );
		210
		211	/* Not quite right. Need to use the fallback '_aa_ArrayElement'
		212	* when not known to be inside begin/end and arrays are
		213	* unlocked.
		214	*/
		215	if (IM->FlushElt == FLUSH_ELT_EAGER) {
		216	_tnl_translate_array_elts( ctx, IM, last, count );
		217	}
		218
		219	IM->Flag[count] \|= VERT_BIT_BEGIN;
		220	IM->Primitive[count] = mode \| PRIM_BEGIN;
		221	IM->PrimitiveLength[last] = count - last;
		222	IM->LastPrimitive = count;
		223	IM->BeginState = (VERT_BEGIN_0\|VERT_BEGIN_1);
		224
		225	/* _mesa_debug(ctx, "%s: %x\n", __FUNCTION__, IM->BeginState); */
		226
		227	ctx->Driver.NeedFlush \|= FLUSH_STORED_VERTICES;
		228	ctx->Driver.CurrentExecPrimitive = mode;
		229	}
		230	}
		231
		232
		233	/* Function which allows operations like 'glRectf' to decompose to a
		234	* begin/end object and vertices without worrying about what happens
		235	* with display lists.
		236	*/
		237	GLboolean
		238	_tnl_hard_begin( GLcontext *ctx, GLenum p )
		239	{
		240	/* _mesa_debug(ctx, "%s\n", __FUNCTION__); */
		241
		242	if (!ctx->CompileFlag) {
		243	/* If not compiling, treat as a normal begin().
		244	*/
		245	/* _mesa_debug(ctx, "%s: treating as glBegin\n", __FUNCTION__); */
		246	glBegin( p );
		247	return GL_TRUE;
		248	}
		249	else {
		250	/* Otherwise, need to do special processing to preserve the
		251	* condition that these vertices will only be replayed outside
		252	* future begin/end objects.
		253	*/
		254	struct immediate *IM = TNL_CURRENT_IM(ctx);
		255
		256	if (ctx->NewState)
		257	_mesa_update_state(ctx);
		258
		259	if (IM->Count > IMM_MAXDATA-8) {
		260	_tnl_flush_immediate( ctx, IM );
		261	IM = TNL_CURRENT_IM(ctx);
		262	}
		263
		264	/* A lot depends on the degree to which the display list has
		265	* constrained the possible begin/end states at this point:
		266	*/
		267	switch (IM->BeginState & (VERT_BEGIN_0\|VERT_BEGIN_1)) {
		268	case VERT_BEGIN_0\|VERT_BEGIN_1:
		269	/* This is an immediate known to be inside a begin/end object.
		270	*/
		271	ASSERT(ctx->Driver.CurrentSavePrimitive <= GL_POLYGON);
		272	IM->BeginState \|= (VERT_ERROR_1\|VERT_ERROR_0);
		273	return GL_FALSE;
		274
		275	case VERT_BEGIN_0:
		276	case VERT_BEGIN_1:
		277	/* This is a display-list immediate in an unknown begin/end
		278	* state. Assert it is empty and convert it to a 'hard' one.
		279	*/
		280	ASSERT(IM->SavedBeginState == 0);
		281	ASSERT(ctx->Driver.CurrentSavePrimitive == PRIM_UNKNOWN);
		282
		283	/* Push current beginstate, to be restored later. Don't worry
		284	* about raising errors.
		285	*/
		286	IM->SavedBeginState = IM->BeginState;
		287
		288	/* FALLTHROUGH */
		289
		290	case 0:
		291	/* Unless we have fallen through, this is an immediate known to
		292	* be outside begin/end objects.
		293	*/
		294	ASSERT(ctx->Driver.CurrentSavePrimitive == PRIM_UNKNOWN \|\|
		295	ctx->Driver.CurrentSavePrimitive == PRIM_OUTSIDE_BEGIN_END);
		296	ASSERT (IM->FlushElt != FLUSH_ELT_EAGER);
		297
		298	IM->BeginState \|= VERT_BEGIN_0\|VERT_BEGIN_1;
		299	IM->Flag[IM->Count] \|= VERT_BIT_BEGIN;
		300	IM->Primitive[IM->Count] = p \| PRIM_BEGIN;
		301	IM->PrimitiveLength[IM->LastPrimitive] = IM->Count - IM->LastPrimitive;
		302	IM->LastPrimitive = IM->Count;
		303
		304	/* This is necessary as this immediate will not be flushed in
		305	* _tnl_end() -- we leave it active, hoping to pick up more
		306	* vertices before the next state change.
		307	*/
		308	ctx->Driver.NeedFlush \|= FLUSH_STORED_VERTICES;
		309	return GL_TRUE;
		310
		311	default:
		312	assert (0);
		313	return GL_TRUE;
		314	}
		315	}
		316	}
		317
		318
		319
		320
		321
		322
		323	/* Both streams now outside begin/end.
		324	*
		325	* Leave SavedBeginState untouched -- attempt to gather several
		326	* rects/arrays together in a single immediate struct.
		327	*/
		328	void
		329	_tnl_end( GLcontext *ctx )
		330	{
		331	struct immediate *IM = TNL_CURRENT_IM(ctx);
		332	GLuint state = IM->BeginState;
		333	GLuint inflags = (~state) & (VERT_BEGIN_0\|VERT_BEGIN_1);
		334
		335	assert( ctx->Driver.NeedFlush & FLUSH_STORED_VERTICES );
		336
		337	state \|= inflags << 2; /* errors */
		338
		339	if (inflags != (VERT_BEGIN_0\|VERT_BEGIN_1))
		340	{
		341	GLuint count = IM->Count;
		342	GLuint last = IM->LastPrimitive;
		343
		344	state &= ~(VERT_BEGIN_0\|VERT_BEGIN_1); /* update state */
		345	IM->Flag[count] \|= VERT_BIT_END;
		346	IM->Primitive[last] \|= PRIM_END;
		347	IM->PrimitiveLength[last] = count - last;
		348	IM->Primitive[count] = PRIM_OUTSIDE_BEGIN_END; /* removes PRIM_BEGIN
		349	* flag if length == 0
		350	*/
		351	IM->LastPrimitive = count;
		352
		353	if (IM->FlushElt == FLUSH_ELT_EAGER) {
		354	_tnl_translate_array_elts( ctx, IM, last, count );
		355	}
		356	}
		357
		358	IM->BeginState = state;
		359
		360	if (!ctx->CompileFlag) {
		361	if (ctx->Driver.CurrentExecPrimitive == PRIM_OUTSIDE_BEGIN_END)
		362	_mesa_error( ctx, GL_INVALID_OPERATION, "_tnl_End" );
		363	else
		364	ctx->Driver.CurrentExecPrimitive = PRIM_OUTSIDE_BEGIN_END;
		365	}
		366
		367	/* You can set this flag to get the old 'flush_vb on glEnd()'
		368	* behaviour.
		369	*/
		370	if (MESA_DEBUG_FLAGS & DEBUG_ALWAYS_FLUSH)
		371	_tnl_flush_immediate( ctx, IM );
		372	}
		373
		374	void
		375	_tnl_End(void)
		376	{
		377	GET_CURRENT_CONTEXT(ctx);
		378
		379	_tnl_end( ctx );
		380
		381	/* Need to keep save primitive uptodate in COMPILE and
		382	* COMPILE_AND_EXEC modes, need to keep exec primitive uptodate
		383	* otherwise.
		384	*/
		385	if (ctx->CompileFlag)
		386	ctx->Driver.CurrentSavePrimitive = PRIM_OUTSIDE_BEGIN_END;
		387	}
		388
		389
		390	#define COLOR( r, g, b, a ) \
		391	{ \
		392	GET_IMMEDIATE; \
		393	GLuint count = IM->Count; \
		394	GLfloat *color = IM->Attrib[VERT_ATTRIB_COLOR0][count]; \
		395	IM->Flag[count] \|= VERT_BIT_COLOR0; \
		396	color[0] = r; \
		397	color[1] = g; \
		398	color[2] = b; \
		399	color[3] = a; \
		400	}
		401
		402	static void
		403	_tnl_Color3f( GLfloat red, GLfloat green, GLfloat blue )
		404	{
		405	COLOR( red, green, blue, 1.0 );
		406	}
		407
		408	static void
		409	_tnl_Color3ub( GLubyte red, GLubyte green, GLubyte blue )
		410	{
		411	COLOR(UBYTE_TO_FLOAT(red),
		412	UBYTE_TO_FLOAT(green),
		413	UBYTE_TO_FLOAT(blue),
		414	1.0);
		415	}
		416
		417	static void
		418	_tnl_Color4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
		419	{
		420	COLOR( red, green, blue, alpha );
		421	}
		422
		423	static void
		424	_tnl_Color4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
		425	{
		426	COLOR(UBYTE_TO_FLOAT(red),
		427	UBYTE_TO_FLOAT(green),
		428	UBYTE_TO_FLOAT(blue),
		429	UBYTE_TO_FLOAT(alpha));
		430	}
		431
		432	static void
		433	_tnl_Color3fv( const GLfloat *v )
		434	{
		435	COLOR( v[0], v[1], v[2], 1.0 );
		436	}
		437
		438	static void
		439	_tnl_Color3ubv( const GLubyte *v )
		440	{
		441	COLOR(UBYTE_TO_FLOAT(v[0]),
		442	UBYTE_TO_FLOAT(v[1]),
		443	UBYTE_TO_FLOAT(v[2]),
		444	1.0 );
		445	}
		446
		447	static void
		448	_tnl_Color4fv( const GLfloat *v )
		449	{
		450	COLOR( v[0], v[1], v[2], v[3] );
		451	}
		452
		453	static void
		454	_tnl_Color4ubv( const GLubyte *v)
		455	{
		456	COLOR(UBYTE_TO_FLOAT(v[0]),
		457	UBYTE_TO_FLOAT(v[1]),
		458	UBYTE_TO_FLOAT(v[2]),
		459	UBYTE_TO_FLOAT(v[3]));
		460	}
		461
		462
		463
		464
		465	#define SECONDARY_COLOR( r, g, b ) \
		466	{ \
		467	GLuint count; \
		468	GET_IMMEDIATE; \
		469	count = IM->Count; \
		470	IM->Flag[count] \|= VERT_BIT_COLOR1; \
		471	IM->Attrib[VERT_ATTRIB_COLOR1][count][0] = r; \
		472	IM->Attrib[VERT_ATTRIB_COLOR1][count][1] = g; \
		473	IM->Attrib[VERT_ATTRIB_COLOR1][count][2] = b; \
		474	}
		475
		476	static void
		477	_tnl_SecondaryColor3fEXT( GLfloat red, GLfloat green, GLfloat blue )
		478	{
		479	SECONDARY_COLOR( red, green, blue );
		480	}
		481
		482	static void
		483	_tnl_SecondaryColor3ubEXT( GLubyte red, GLubyte green, GLubyte blue )
		484	{
		485	SECONDARY_COLOR(UBYTE_TO_FLOAT(red),
		486	UBYTE_TO_FLOAT(green),
		487	UBYTE_TO_FLOAT(blue));
		488	}
		489
		490	static void
		491	_tnl_SecondaryColor3fvEXT( const GLfloat *v )
		492	{
		493	SECONDARY_COLOR( v[0], v[1], v[2] );
		494	}
		495
		496	static void
		497	_tnl_SecondaryColor3ubvEXT( const GLubyte *v )
		498	{
		499	SECONDARY_COLOR(UBYTE_TO_FLOAT(v[0]),
		500	UBYTE_TO_FLOAT(v[1]),
		501	UBYTE_TO_FLOAT(v[2]));
		502	}
		503
		504
		505	static void
		506	_tnl_EdgeFlag( GLboolean flag )
		507	{
		508	GLuint count;
		509	GET_IMMEDIATE;
		510	count = IM->Count;
		511	IM->EdgeFlag[count] = flag;
		512	IM->Flag[count] \|= VERT_BIT_EDGEFLAG;
		513	}
		514
		515
		516	static void
		517	_tnl_EdgeFlagv( const GLboolean *flag )
		518	{
		519	GLuint count;
		520	GET_IMMEDIATE;
		521	count = IM->Count;
		522	IM->EdgeFlag[count] = *flag;
		523	IM->Flag[count] \|= VERT_BIT_EDGEFLAG;
		524	}
		525
		526
		527	static void
		528	_tnl_FogCoordfEXT( GLfloat f )
		529	{
		530	GLuint count;
		531	GET_IMMEDIATE;
		532	count = IM->Count;
		533	IM->Attrib[VERT_ATTRIB_FOG][count][0] = f; /FogCoord[count] = f;/
		534	IM->Flag[count] \|= VERT_BIT_FOG;
		535	}
		536
		537	static void
		538	_tnl_FogCoordfvEXT( const GLfloat *v )
		539	{
		540	GLuint count;
		541	GET_IMMEDIATE;
		542	count = IM->Count;
		543	IM->Attrib[VERT_ATTRIB_FOG][count][0] = v[0]; /FogCoord[count] = v[0];/
		544	IM->Flag[count] \|= VERT_BIT_FOG;
		545	}
		546
		547
		548	static void
		549	_tnl_Indexi( GLint c )
		550	{
		551	GLuint count;
		552	GET_IMMEDIATE;
		553	count = IM->Count;
		554	IM->Index[count] = c;
		555	IM->Flag[count] \|= VERT_BIT_INDEX;
		556	}
		557
		558
		559	static void
		560	_tnl_Indexiv( const GLint *c )
		561	{
		562	GLuint count;
		563	GET_IMMEDIATE;
		564	count = IM->Count;
		565	IM->Index[count] = *c;
		566	IM->Flag[count] \|= VERT_BIT_INDEX;
		567	}
		568
		569
		570	#define NORMAL( x, y, z ) \
		571	{ \
		572	GLuint count; \
		573	GLfloat *normal; \
		574	GET_IMMEDIATE; \
		575	count = IM->Count; \
		576	IM->Flag[count] \|= VERT_BIT_NORMAL; \
		577	normal = IM->Attrib[VERT_ATTRIB_NORMAL][count]; \
		578	ASSIGN_3V(normal, x,y,z); \
		579	}
		580
		581	#if defined(USE_IEEE)
		582	#define NORMALF( x, y, z ) \
		583	{ \
		584	GLuint count; \
		585	fi_type *normal; \
		586	GET_IMMEDIATE; \
		587	count = IM->Count; \
		588	IM->Flag[count] \|= VERT_BIT_NORMAL; \
		589	normal = (fi_type *)IM->Attrib[VERT_ATTRIB_NORMAL][count]; \
		590	normal[0].i = ((fi_type *)&(x))->i; \
		591	normal[1].i = ((fi_type *)&(y))->i; \
		592	normal[2].i = ((fi_type *)&(z))->i; \
		593	}
		594	#else
		595	#define NORMALF NORMAL
		596	#endif
		597
		598	static void
		599	_tnl_Normal3f( GLfloat nx, GLfloat ny, GLfloat nz )
		600	{
		601	NORMALF(nx, ny, nz);
		602	}
		603
		604
		605	static void
		606	_tnl_Normal3fv( const GLfloat *v )
		607	{
		608	NORMALF( v[0], v[1], v[2] );
		609	/* struct immediate IM = (struct immediate )(((GLcontext ) _glapi_Context)->swtnl_im); /
		610	/* IM->Flag[IM->Count] = VERT_NORM; */
		611	}
		612
		613
		614
		615	#define TEXCOORD1(s) \
		616	{ \
		617	GLuint count; \
		618	GLfloat *tc; \
		619	GET_IMMEDIATE; \
		620	count = IM->Count; \
		621	IM->Flag[count] \|= VERT_BIT_TEX0; \
		622	tc = IM->Attrib[VERT_ATTRIB_TEX0][count]; \
		623	ASSIGN_4V(tc,s,0,0,1); \
		624	}
		625
		626	#define TEXCOORD2(s, t) \
		627	{ \
		628	GLuint count; \
		629	GLfloat *tc; \
		630	GET_IMMEDIATE; \
		631	count = IM->Count; \
		632	IM->Flag[count] \|= VERT_BIT_TEX0; \
		633	tc = IM->Attrib[VERT_ATTRIB_TEX0][count]; \
		634	ASSIGN_4V(tc, s, t, 0, 1); \
		635	}
		636
		637	#define TEXCOORD3(s, t, u) \
		638	{ \
		639	GLuint count; \
		640	GLfloat *tc; \
		641	GET_IMMEDIATE; \
		642	count = IM->Count; \
		643	IM->Flag[count] \|= VERT_BIT_TEX0; \
		644	IM->TexSize \|= TEX_0_SIZE_3; \
		645	tc = IM->Attrib[VERT_ATTRIB_TEX0][count]; \
		646	ASSIGN_4V(tc, s, t, u, 1); \
		647	}
		648
		649	#define TEXCOORD4(s, t, u, v) \
		650	{ \
		651	GLuint count; \
		652	GLfloat *tc; \
		653	GET_IMMEDIATE; \
		654	count = IM->Count; \
		655	IM->Flag[count] \|= VERT_BIT_TEX0; \
		656	IM->TexSize \|= TEX_0_SIZE_4; \
		657	tc = IM->Attrib[VERT_ATTRIB_TEX0][count]; \
		658	ASSIGN_4V(tc, s, t, u, v); \
		659	}
		660
		661	#if defined(USE_IEEE)
		662	#define TEXCOORD2F(s, t) \
		663	{ \
		664	GLuint count; \
		665	fi_type *tc; \
		666	GET_IMMEDIATE; \
		667	count = IM->Count; \
		668	IM->Flag[count] \|= VERT_BIT_TEX0; \
		669	tc = (fi_type *)IM->Attrib[VERT_ATTRIB_TEX0][count]; \
		670	tc[0].i = ((fi_type *)&(s))->i; \
		671	tc[1].i = ((fi_type *)&(t))->i; \
		672	tc[2].i = 0; \
		673	tc[3].i = IEEE_ONE; \
		674	}
		675	#else
		676	#define TEXCOORD2F TEXCOORD2
		677	#endif
		678
		679	static void
		680	_tnl_TexCoord1f( GLfloat s )
		681	{
		682	TEXCOORD1(s);
		683	}
		684
		685
		686	static void
		687	_tnl_TexCoord2f( GLfloat s, GLfloat t )
		688	{
		689	TEXCOORD2F(s, t);
		690	}
		691
		692
		693	static void
		694	_tnl_TexCoord3f( GLfloat s, GLfloat t, GLfloat r )
		695	{
		696	TEXCOORD3(s, t, r);
		697	}
		698
		699	static void
		700	_tnl_TexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
		701	{
		702	TEXCOORD4(s, t, r, q)
		703	}
		704
		705	static void
		706	_tnl_TexCoord1fv( const GLfloat *v )
		707	{
		708	TEXCOORD1(v[0]);
		709	}
		710
		711	static void
		712	_tnl_TexCoord2fv( const GLfloat *v )
		713	{
		714	TEXCOORD2F(v[0], v[1]);
		715	}
		716
		717	static void
		718	_tnl_TexCoord3fv( const GLfloat *v )
		719	{
		720	TEXCOORD3(v[0], v[1], v[2]);
		721	}
		722
		723	static void
		724	_tnl_TexCoord4fv( const GLfloat *v )
		725	{
		726	TEXCOORD4(v[0], v[1], v[2], v[3]);
		727	}
		728
		729
		730
		731	/* KW: Run into bad problems in vertex copying if we don't fully pad
		732	* the incoming vertices.
		733	*/
		734	#define VERTEX2(IM, x,y) \
		735	{ \
		736	GLuint count = IM->Count++; \
		737	GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
		738	IM->Flag[count] \|= VERT_BIT_POS; \
		739	ASSIGN_4V(dest, x, y, 0, 1); \
		740	/* ASSERT(IM->Flag[IM->Count]==0); */ \
		741	if (count == IMM_MAXDATA - 1) \
		742	_tnl_flush_immediate( NULL, IM ); \
		743	}
		744
		745	#define VERTEX3(IM,x,y,z) \
		746	{ \
		747	GLuint count = IM->Count++; \
		748	GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
		749	IM->Flag[count] \|= VERT_BITS_OBJ_23; \
		750	ASSIGN_4V(dest, x, y, z, 1); \
		751	/* ASSERT(IM->Flag[IM->Count]==0); */ \
		752	if (count == IMM_MAXDATA - 1) \
		753	_tnl_flush_immediate( NULL, IM ); \
		754	}
		755
		756	#define VERTEX4(IM, x,y,z,w) \
		757	{ \
		758	GLuint count = IM->Count++; \
		759	GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
		760	IM->Flag[count] \|= VERT_BITS_OBJ_234; \
		761	ASSIGN_4V(dest, x, y, z, w); \
		762	if (count == IMM_MAXDATA - 1) \
		763	_tnl_flush_immediate( NULL, IM ); \
		764	}
		765
		766	#if defined(USE_IEEE)
		767	#define VERTEX2F(IM, x, y) \
		768	{ \
		769	GLuint count = IM->Count++; \
		770	fi_type dest = (fi_type )IM->Attrib[VERT_ATTRIB_POS][count]; \
		771	IM->Flag[count] \|= VERT_BIT_POS; \
		772	dest[0].i = ((fi_type *)&(x))->i; \
		773	dest[1].i = ((fi_type *)&(y))->i; \
		774	dest[2].i = 0; \
		775	dest[3].i = IEEE_ONE; \
		776	/* ASSERT(IM->Flag[IM->Count]==0); */ \
		777	if (count == IMM_MAXDATA - 1) \
		778	_tnl_flush_immediate( NULL, IM ); \
		779	}
		780	#else
		781	#define VERTEX2F VERTEX2
		782	#endif
		783
		784	#if defined(USE_IEEE)
		785	#define VERTEX3F(IM, x, y, z) \
		786	{ \
		787	GLuint count = IM->Count++; \
		788	fi_type dest = (fi_type )IM->Attrib[VERT_ATTRIB_POS][count]; \
		789	IM->Flag[count] \|= VERT_BITS_OBJ_23; \
		790	dest[0].i = ((fi_type *)&(x))->i; \
		791	dest[1].i = ((fi_type *)&(y))->i; \
		792	dest[2].i = ((fi_type *)&(z))->i; \
		793	dest[3].i = IEEE_ONE; \
		794	/* ASSERT(IM->Flag[IM->Count]==0); */ \
		795	if (count == IMM_MAXDATA - 1) \
		796	_tnl_flush_immediate( NULL, IM ); \
		797	}
		798	#else
		799	#define VERTEX3F VERTEX3
		800	#endif
		801
		802	#if defined(USE_IEEE)
		803	#define VERTEX4F(IM, x, y, z, w) \
		804	{ \
		805	GLuint count = IM->Count++; \
		806	fi_type dest = (fi_type )IM->Attrib[VERT_ATTRIB_POS][count]; \
		807	IM->Flag[count] \|= VERT_BITS_OBJ_234; \
		808	dest[0].i = ((fi_type *)&(x))->i; \
		809	dest[1].i = ((fi_type *)&(y))->i; \
		810	dest[2].i = ((fi_type *)&(z))->i; \
		811	dest[3].i = ((fi_type *)&(w))->i; \
		812	if (count == IMM_MAXDATA - 1) \
		813	_tnl_flush_immediate( NULL, IM ); \
		814	}
		815	#else
		816	#define VERTEX4F VERTEX4
		817	#endif
		818
		819
		820
		821	static void
		822	_tnl_Vertex2f( GLfloat x, GLfloat y )
		823	{
		824	GET_IMMEDIATE;
		825	VERTEX2F( IM, x, y );
		826	}
		827
		828	static void
		829	_tnl_Vertex3f( GLfloat x, GLfloat y, GLfloat z )
		830	{
		831	GET_IMMEDIATE;
		832	VERTEX3F( IM, x, y, z );
		833	}
		834	static void
		835	_tnl_Vertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
		836	{
		837	GET_IMMEDIATE;
		838	VERTEX4F( IM, x, y, z, w );
		839	}
		840
		841	static void
		842	_tnl_Vertex2fv( const GLfloat *v )
		843	{
		844	GET_IMMEDIATE;
		845	VERTEX2F( IM, v[0], v[1] );
		846	}
		847
		848	static void
		849	_tnl_Vertex3fv( const GLfloat *v )
		850	{
		851	GET_IMMEDIATE;
		852	VERTEX3F( IM, v[0], v[1], v[2] );
		853	}
		854
		855	static void
		856	_tnl_Vertex4fv( const GLfloat *v )
		857	{
		858	GET_IMMEDIATE;
		859	VERTEX4F( IM, v[0], v[1], v[2], v[3] );
		860	}
		861
		862
		863
		864
		865	/*
		866	* GL_ARB_multitexture
		867	*
		868	* Note: the multitexture spec says that specifying an invalid target
		869	* has undefined results and does not have to generate an error. Just
		870	* don't crash. We no-op on invalid targets.
		871	*/
		872
		873	#define MAX_TARGET (GL_TEXTURE0_ARB + MAX_TEXTURE_UNITS)
		874
		875	#define MULTI_TEXCOORD1(target, s) \
		876	{ \
		877	GET_IMMEDIATE; \
		878	GLuint texunit = target - GL_TEXTURE0_ARB; \
		879	if (texunit < IM->MaxTextureUnits) { \
		880	GLuint count = IM->Count; \
		881	GLfloat *tc = IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
		882	ASSIGN_4V(tc, s, 0.0F, 0.0F, 1.0F); \
		883	IM->Flag[count] \|= VERT_BIT_TEX(texunit); \
		884	} \
		885	}
		886
		887	#define MULTI_TEXCOORD2(target, s, t) \
		888	{ \
		889	GET_IMMEDIATE; \
		890	GLuint texunit = target - GL_TEXTURE0_ARB; \
		891	if (texunit < IM->MaxTextureUnits) { \
		892	GLuint count = IM->Count; \
		893	GLfloat *tc = IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
		894	ASSIGN_4V(tc, s, t, 0.0F, 1.0F); \
		895	IM->Flag[count] \|= VERT_BIT_TEX(texunit); \
		896	} \
		897	}
		898
		899	#define MULTI_TEXCOORD3(target, s, t, u) \
		900	{ \
		901	GET_IMMEDIATE; \
		902	GLuint texunit = target - GL_TEXTURE0_ARB; \
		903	if (texunit < IM->MaxTextureUnits) { \
		904	GLuint count = IM->Count; \
		905	GLfloat *tc = IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
		906	ASSIGN_4V(tc, s, t, u, 1.0F); \
		907	IM->Flag[count] \|= VERT_BIT_TEX(texunit); \
		908	IM->TexSize \|= TEX_SIZE_3(texunit); \
		909	} \
		910	}
		911
		912	#define MULTI_TEXCOORD4(target, s, t, u, v) \
		913	{ \
		914	GET_IMMEDIATE; \
		915	GLuint texunit = target - GL_TEXTURE0_ARB; \
		916	if (texunit < IM->MaxTextureUnits) { \
		917	GLuint count = IM->Count; \
		918	GLfloat *tc = IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count]; \
		919	ASSIGN_4V(tc, s, t, u, v); \
		920	IM->Flag[count] \|= VERT_BIT_TEX(texunit); \
		921	IM->TexSize \|= TEX_SIZE_4(texunit); \
		922	} \
		923	}
		924
		925	#if defined(USE_IEEE)
		926	#define MULTI_TEXCOORD2F(target, s, t) \
		927	{ \
		928	GET_IMMEDIATE; \
		929	GLuint texunit = target - GL_TEXTURE0_ARB; \
		930	if (texunit < IM->MaxTextureUnits) { \
		931	GLuint count = IM->Count; \
		932	fi_type tc = (fi_type )IM->Attrib[VERT_ATTRIB_TEX0 + texunit][count];\
		933	IM->Flag[count] \|= VERT_BIT_TEX(texunit); \
		934	tc[0].i = ((fi_type *)&(s))->i; \
		935	tc[1].i = ((fi_type *)&(t))->i; \
		936	tc[2].i = 0; \
		937	tc[3].i = IEEE_ONE; \
		938	} \
		939	}
		940	#else
		941	#define MULTI_TEXCOORD2F MULTI_TEXCOORD2
		942	#endif
		943
		944	static void
		945	_tnl_MultiTexCoord1fARB(GLenum target, GLfloat s)
		946	{
		947	MULTI_TEXCOORD1( target, s );
		948	}
		949
		950	static void
		951	_tnl_MultiTexCoord1fvARB(GLenum target, const GLfloat *v)
		952	{
		953	MULTI_TEXCOORD1( target, v[0] );
		954	}
		955
		956	static void
		957	_tnl_MultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
		958	{
		959	MULTI_TEXCOORD2F( target, s, t );
		960	}
		961
		962	static void
		963	_tnl_MultiTexCoord2fvARB(GLenum target, const GLfloat *v)
		964	{
		965	MULTI_TEXCOORD2F( target, v[0], v[1] );
		966	}
		967
		968	static void
		969	_tnl_MultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
		970	{
		971	MULTI_TEXCOORD3( target, s, t, r );
		972	}
		973
		974	static void
		975	_tnl_MultiTexCoord3fvARB(GLenum target, const GLfloat *v)
		976	{
		977	MULTI_TEXCOORD3( target, v[0], v[1], v[2] );
		978	}
		979
		980	static void
		981	_tnl_MultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
		982	{
		983	MULTI_TEXCOORD4( target, s, t, r, q );
		984	}
		985
		986	static void
		987	_tnl_MultiTexCoord4fvARB(GLenum target, const GLfloat *v)
		988	{
		989	MULTI_TEXCOORD4( target, v[0], v[1], v[2], v[3] );
		990	}
		991
		992
		993
		994	/* KW: Because the eval values don't become 'current', fixup will flow
		995	* through these vertices, and then evaluation will write on top
		996	* of the fixup results.
		997	*
		998	* Note: using Obj to hold eval coord data.
		999	*/
		1000	#define EVALCOORD1(IM, x) \
		1001	{ \
		1002	GLuint count = IM->Count++; \
		1003	GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
		1004	IM->Flag[count] \|= VERT_BIT_EVAL_C1; \
		1005	ASSIGN_4V(dest, x, 0, 0, 1); \
		1006	if (count == IMM_MAXDATA-1) \
		1007	_tnl_flush_immediate( NULL, IM ); \
		1008	}
		1009
		1010	#define EVALCOORD2(IM, x, y) \
		1011	{ \
		1012	GLuint count = IM->Count++; \
		1013	GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
		1014	IM->Flag[count] \|= VERT_BIT_EVAL_C2; \
		1015	ASSIGN_4V(dest, x, y, 0, 1); \
		1016	if (count == IMM_MAXDATA-1) \
		1017	_tnl_flush_immediate( NULL, IM ); \
		1018	}
		1019
		1020	#define EVALPOINT1(IM, x) \
		1021	{ \
		1022	GLuint count = IM->Count++; \
		1023	GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
		1024	IM->Flag[count] \|= VERT_BIT_EVAL_P1; \
		1025	ASSIGN_4V(dest, x, 0, 0, 1); \
		1026	if (count == IMM_MAXDATA-1) \
		1027	_tnl_flush_immediate( NULL, IM ); \
		1028	}
		1029
		1030	#define EVALPOINT2(IM, x, y) \
		1031	{ \
		1032	GLuint count = IM->Count++; \
		1033	GLfloat *dest = IM->Attrib[VERT_ATTRIB_POS][count]; \
		1034	IM->Flag[count] \|= VERT_BIT_EVAL_P2; \
		1035	ASSIGN_4V(dest, x, y, 0, 1); \
		1036	if (count == IMM_MAXDATA-1) \
		1037	_tnl_flush_immediate( NULL, IM ); \
		1038	}
		1039
		1040	static void
		1041	_tnl_EvalCoord1f( GLfloat u )
		1042	{
		1043	GET_IMMEDIATE;
		1044	EVALCOORD1( IM, u );
		1045	}
		1046
		1047	static void
		1048	_tnl_EvalCoord1fv( const GLfloat *u )
		1049	{
		1050	GET_IMMEDIATE;
		1051	EVALCOORD1( IM, (GLfloat) *u );
		1052	}
		1053
		1054	static void
		1055	_tnl_EvalCoord2f( GLfloat u, GLfloat v )
		1056	{
		1057	GET_IMMEDIATE;
		1058	EVALCOORD2( IM, u, v );
		1059	}
		1060
		1061	static void
		1062	_tnl_EvalCoord2fv( const GLfloat *u )
		1063	{
		1064	GET_IMMEDIATE;
		1065	EVALCOORD2( IM, u[0], u[1] );
		1066	}
		1067
		1068
		1069	static void
		1070	_tnl_EvalPoint1( GLint i )
		1071	{
		1072	GET_IMMEDIATE;
		1073	EVALPOINT1( IM, (GLfloat) i );
		1074	}
		1075
		1076
		1077	static void
		1078	_tnl_EvalPoint2( GLint i, GLint j )
		1079	{
		1080	GET_IMMEDIATE;
		1081	EVALPOINT2( IM, (GLfloat) i, (GLfloat) j );
		1082	}
		1083
		1084
		1085	/* Need to use the default array-elt outside begin/end for strict
		1086	* conformance.
		1087	*/
		1088	#define ARRAY_ELT( IM, i ) \
		1089	{ \
		1090	GLuint count = IM->Count; \
		1091	IM->Elt[count] = i; \
		1092	IM->Flag[count] &= IM->ArrayEltFlags; \
		1093	IM->Flag[count] \|= VERT_BIT_ELT; \
		1094	IM->FlushElt = IM->ArrayEltFlush; \
		1095	IM->Count += IM->ArrayEltIncr; \
		1096	if (IM->Count == IMM_MAXDATA) \
		1097	_tnl_flush_immediate( NULL, IM ); \
		1098	}
		1099
		1100
		1101	static void
		1102	_tnl_ArrayElement( GLint i )
		1103	{
		1104	GET_IMMEDIATE;
		1105	ARRAY_ELT( IM, i );
		1106	}
		1107
		1108
		1109	/* Internal functions. These are safe to use providing either:
		1110	*
		1111	* - It is determined that a display list is not being compiled, or
		1112	* if so that these commands won't be compiled into the list (see
		1113	* t_eval.c for an example).
		1114	*
		1115	* - _tnl_hard_begin() is used instead of _tnl_[bB]egin, and tested
		1116	* for a GL_TRUE return value. See _tnl_Rectf, below.
		1117	*/
		1118	void
		1119	_tnl_eval_coord1f( GLcontext *CC, GLfloat u )
		1120	{
		1121	struct immediate *i = TNL_CURRENT_IM(CC);
		1122	EVALCOORD1( i, u );
		1123	}
		1124
		1125	void
		1126	_tnl_eval_coord2f( GLcontext *CC, GLfloat u, GLfloat v )
		1127	{
		1128	struct immediate *i = TNL_CURRENT_IM(CC);
		1129	EVALCOORD2( i, u, v );
		1130	}
		1131
		1132
		1133
		1134
		1135	/*
		1136	* NV_vertex_program
		1137	*/
		1138
		1139	static void
		1140	_tnl_VertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
		1141	{
		1142	if (index < 16) {
		1143	GET_IMMEDIATE;
		1144	const GLuint count = IM->Count;
		1145	GLfloat *attrib = IM->Attrib[index][count];
		1146	ASSIGN_4V(attrib, x, y, z, w);
		1147	IM->Flag[count] \|= (1 << index);
		1148	if (index == 0) {
		1149	IM->Count++;
		1150	if (count == IMM_MAXDATA - 1)
		1151	_tnl_flush_immediate( NULL, IM );
		1152	}
		1153	}
		1154	else {
		1155	GET_CURRENT_CONTEXT(ctx);
		1156	_mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribNV(index > 15)");
		1157	}
		1158	}
		1159
		1160	static void
		1161	_tnl_VertexAttrib4fvNV( GLuint index, const GLfloat *v )
		1162	{
		1163	if (index < 16) {
		1164	GET_IMMEDIATE;
		1165	const GLuint count = IM->Count;
		1166	GLfloat *attrib = IM->Attrib[index][count];
		1167	COPY_4V(attrib, v);
		1168	IM->Flag[count] \|= (1 << index);
		1169	if (index == 0) {
		1170	IM->Count++;
		1171	if (count == IMM_MAXDATA - 1)
		1172	_tnl_flush_immediate( NULL, IM );
		1173	}
		1174	}
		1175	else {
		1176	GET_CURRENT_CONTEXT(ctx);
		1177	_mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribNV(index > 15)");
		1178	}
		1179	}
		1180
		1181
		1182	/* Execute a glRectf() function. _tnl_hard_begin() ensures the check
		1183	* on outside_begin_end is executed even in compiled lists. These
		1184	* vertices can now participate in the same immediate as regular ones,
		1185	* even in most display lists.
		1186	*/
		1187	static void
		1188	_tnl_Rectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
		1189	{
		1190	GET_CURRENT_CONTEXT(ctx);
		1191
		1192	if (_tnl_hard_begin( ctx, GL_QUADS )) {
		1193	glVertex2f( x1, y1 );
		1194	glVertex2f( x2, y1 );
		1195	glVertex2f( x2, y2 );
		1196	glVertex2f( x1, y2 );
		1197	glEnd();
		1198	}
		1199	}
		1200
		1201	static void
		1202	_tnl_Materialfv( GLenum face, GLenum pname, const GLfloat *params )
		1203	{
		1204	GET_CURRENT_CONTEXT(ctx);
		1205	TNLcontext *tnl = TNL_CONTEXT(ctx);
		1206	struct immediate *IM = TNL_CURRENT_IM(ctx);
		1207	GLuint count = IM->Count;
		1208	struct gl_material *mat;
		1209	GLuint bitmask = _mesa_material_bitmask(ctx, face, pname, ~0, "Materialfv");
		1210
		1211	if (bitmask == 0)
		1212	return;
		1213
		1214	if (MESA_VERBOSE & VERBOSE_API)
		1215	_mesa_debug(ctx, "_tnl_Materialfv\n");
		1216
		1217	if (tnl->IsolateMaterials &&
		1218	!(IM->BeginState & VERT_BEGIN_1)) /* heuristic */
		1219	{
		1220	_tnl_flush_immediate( ctx, IM );
		1221	IM = TNL_CURRENT_IM(ctx);
		1222	count = IM->Count;
		1223	}
		1224
		1225	if (!(IM->Flag[count] & VERT_BIT_MATERIAL)) {
		1226	if (!IM->Material) {
		1227	IM->Material = (struct gl_material (*)[2])
		1228	MALLOC( sizeof(struct gl_material) * IMM_SIZE * 2 );
		1229	IM->MaterialMask = (GLuint ) MALLOC( sizeof(GLuint) IMM_SIZE );
		1230	IM->MaterialMask[IM->LastMaterial] = 0;
		1231	}
		1232	else if (IM->MaterialOrMask & ~bitmask) {
		1233	_mesa_copy_material_pairs( IM->Material[count],
		1234	IM->Material[IM->LastMaterial],
		1235	IM->MaterialOrMask & ~bitmask );
		1236	}
		1237
		1238	IM->Flag[count] \|= VERT_BIT_MATERIAL;
		1239	IM->MaterialMask[count] = 0;
		1240	IM->MaterialAndMask &= IM->MaterialMask[IM->LastMaterial];
		1241	IM->LastMaterial = count;
		1242	}
		1243
		1244	IM->MaterialOrMask \|= bitmask;
		1245	IM->MaterialMask[count] \|= bitmask;
		1246	mat = IM->Material[count];
		1247
		1248	if (bitmask & FRONT_AMBIENT_BIT) {
		1249	COPY_4FV( mat[0].Ambient, params );
		1250	}
		1251	if (bitmask & BACK_AMBIENT_BIT) {
		1252	COPY_4FV( mat[1].Ambient, params );
		1253	}
		1254	if (bitmask & FRONT_DIFFUSE_BIT) {
		1255	COPY_4FV( mat[0].Diffuse, params );
		1256	}
		1257	if (bitmask & BACK_DIFFUSE_BIT) {
		1258	COPY_4FV( mat[1].Diffuse, params );
		1259	}
		1260	if (bitmask & FRONT_SPECULAR_BIT) {
		1261	COPY_4FV( mat[0].Specular, params );
		1262	}
		1263	if (bitmask & BACK_SPECULAR_BIT) {
		1264	COPY_4FV( mat[1].Specular, params );
		1265	}
		1266	if (bitmask & FRONT_EMISSION_BIT) {
		1267	COPY_4FV( mat[0].Emission, params );
		1268	}
		1269	if (bitmask & BACK_EMISSION_BIT) {
		1270	COPY_4FV( mat[1].Emission, params );
		1271	}
		1272	if (bitmask & FRONT_SHININESS_BIT) {
		1273	GLfloat shininess = CLAMP( params[0], 0.0F, 128.0F );
		1274	mat[0].Shininess = shininess;
		1275	}
		1276	if (bitmask & BACK_SHININESS_BIT) {
		1277	GLfloat shininess = CLAMP( params[0], 0.0F, 128.0F );
		1278	mat[1].Shininess = shininess;
		1279	}
		1280	if (bitmask & FRONT_INDEXES_BIT) {
		1281	mat[0].AmbientIndex = params[0];
		1282	mat[0].DiffuseIndex = params[1];
		1283	mat[0].SpecularIndex = params[2];
		1284	}
		1285	if (bitmask & BACK_INDEXES_BIT) {
		1286	mat[1].AmbientIndex = params[0];
		1287	mat[1].DiffuseIndex = params[1];
		1288	mat[1].SpecularIndex = params[2];
		1289	}
		1290
		1291	if (tnl->IsolateMaterials &&
		1292	!(IM->BeginState & VERT_BEGIN_1)) /* heuristic */
		1293	{
		1294	_tnl_flush_immediate( ctx, IM );
		1295	}
		1296	}
		1297
		1298	void _tnl_imm_vtxfmt_init( GLcontext *ctx )
		1299	{
		1300	GLvertexformat *vfmt = &(TNL_CONTEXT(ctx)->vtxfmt);
		1301
		1302	/* All begin/end operations are handled by this vertex format:
		1303	*/
		1304	vfmt->ArrayElement = _tnl_ArrayElement;
		1305	vfmt->Begin = _tnl_Begin;
		1306	vfmt->Color3f = _tnl_Color3f;
		1307	vfmt->Color3fv = _tnl_Color3fv;
		1308	vfmt->Color3ub = _tnl_Color3ub;
		1309	vfmt->Color3ubv = _tnl_Color3ubv;
		1310	vfmt->Color4f = _tnl_Color4f;
		1311	vfmt->Color4fv = _tnl_Color4fv;
		1312	vfmt->Color4ub = _tnl_Color4ub;
		1313	vfmt->Color4ubv = _tnl_Color4ubv;
		1314	vfmt->EdgeFlag = _tnl_EdgeFlag;
		1315	vfmt->EdgeFlagv = _tnl_EdgeFlagv;
		1316	vfmt->End = _tnl_End;
		1317	vfmt->EvalCoord1f = _tnl_EvalCoord1f;
		1318	vfmt->EvalCoord1fv = _tnl_EvalCoord1fv;
		1319	vfmt->EvalCoord2f = _tnl_EvalCoord2f;
		1320	vfmt->EvalCoord2fv = _tnl_EvalCoord2fv;
		1321	vfmt->EvalPoint1 = _tnl_EvalPoint1;
		1322	vfmt->EvalPoint2 = _tnl_EvalPoint2;
		1323	vfmt->FogCoordfEXT = _tnl_FogCoordfEXT;
		1324	vfmt->FogCoordfvEXT = _tnl_FogCoordfvEXT;
		1325	vfmt->Indexi = _tnl_Indexi;
		1326	vfmt->Indexiv = _tnl_Indexiv;
		1327	vfmt->Materialfv = _tnl_Materialfv;
		1328	vfmt->MultiTexCoord1fARB = _tnl_MultiTexCoord1fARB;
		1329	vfmt->MultiTexCoord1fvARB = _tnl_MultiTexCoord1fvARB;
		1330	vfmt->MultiTexCoord2fARB = _tnl_MultiTexCoord2fARB;
		1331	vfmt->MultiTexCoord2fvARB = _tnl_MultiTexCoord2fvARB;
		1332	vfmt->MultiTexCoord3fARB = _tnl_MultiTexCoord3fARB;
		1333	vfmt->MultiTexCoord3fvARB = _tnl_MultiTexCoord3fvARB;
		1334	vfmt->MultiTexCoord4fARB = _tnl_MultiTexCoord4fARB;
		1335	vfmt->MultiTexCoord4fvARB = _tnl_MultiTexCoord4fvARB;
		1336	vfmt->Normal3f = _tnl_Normal3f;
		1337	vfmt->Normal3fv = _tnl_Normal3fv;
		1338	vfmt->SecondaryColor3fEXT = _tnl_SecondaryColor3fEXT;
		1339	vfmt->SecondaryColor3fvEXT = _tnl_SecondaryColor3fvEXT;
		1340	vfmt->SecondaryColor3ubEXT = _tnl_SecondaryColor3ubEXT;
		1341	vfmt->SecondaryColor3ubvEXT = _tnl_SecondaryColor3ubvEXT;
		1342	vfmt->TexCoord1f = _tnl_TexCoord1f;
		1343	vfmt->TexCoord1fv = _tnl_TexCoord1fv;
		1344	vfmt->TexCoord2f = _tnl_TexCoord2f;
		1345	vfmt->TexCoord2fv = _tnl_TexCoord2fv;
		1346	vfmt->TexCoord3f = _tnl_TexCoord3f;
		1347	vfmt->TexCoord3fv = _tnl_TexCoord3fv;
		1348	vfmt->TexCoord4f = _tnl_TexCoord4f;
		1349	vfmt->TexCoord4fv = _tnl_TexCoord4fv;
		1350	vfmt->Vertex2f = _tnl_Vertex2f;
		1351	vfmt->Vertex2fv = _tnl_Vertex2fv;
		1352	vfmt->Vertex3f = _tnl_Vertex3f;
		1353	vfmt->Vertex3fv = _tnl_Vertex3fv;
		1354	vfmt->Vertex4f = _tnl_Vertex4f;
		1355	vfmt->Vertex4fv = _tnl_Vertex4fv;
		1356	vfmt->VertexAttrib4fNV = _tnl_VertexAttrib4fNV;
		1357	vfmt->VertexAttrib4fvNV = _tnl_VertexAttrib4fvNV;
		1358
		1359	/* Outside begin/end functions (from t_varray.c, t_eval.c, ...):
		1360	*/
		1361	vfmt->Rectf = _tnl_Rectf;
		1362
		1363	/* Just use the core function:
		1364	*/
		1365	vfmt->CallList = _mesa_CallList;
		1366
		1367	vfmt->prefer_float_colors = GL_FALSE;
		1368	}

Subversion Repositories shark

(root)/shark/trunk/ports/mesa/src/tnl/t_imm_api.c - Rev 56