/*
 * Copyright (c) 1993-1995 Argonaut Technologies Limited. All rights reserved.
 *
 * $Id: state.c 1.2 1997/08/11 14:26:08 jon Exp JON $
 * $Locker: JON $
 *
 * Default state and access templates
 */
#include <stddef.h>
#include <string.h>

#include "drv.h"
#include "brassert.h"

BR_RCS_ID("$Id: state.c 1.2 1997/08/11 14:26:08 jon Exp JON $");

/*
 * Shortcuts for template flags
 */
#define S BRTV_SET
#define Q BRTV_QUERY
#define A BRTV_ALL

#if BASED_FIXED
#define AX BRTV_ALL
#else 
#define AX 0
#endif

#if BASED_FLOAT
#define AF BRTV_ALL
#else 
#define AF 0
#endif

/*
 * Bits used for template masks to indicate actions when a template entry is triggered
 */
#define TM_PART				0x00001		/* set timestamp for whole part								*/
#define TM_INDEX			0x00002		/* set timestamp for indexed part							*/
#define TM_V2S_HINT			0x00004		/* set timestamp for matrix.view_to_screen_hint				*/
#define TM_M2V				0x00008		/* set timestamp for matrix.model_to_view					*/
#define TM_V2S				0x00010		/* set timestamp for matrix.view_to_screen					*/
#define TM_COPY_CACHE		0x00020		/* set timestamp for anything that affects the copied cache	*/
#define TM_CACHE			0x00040		/* set timestamp for anything that affects the static cache	*/

#define TM_CLEAR_M2V_HINT	0x00080		/* set M2V_HINT to NONE										*/
#define TM_CLEAR_V2S_HINT	0x00100		/* set V2S_HINT to NONE										*/


#define TM_INVALID_PS		0x01000		/* set Update Per Scene										*/
#define TM_INVALID_PM		0x02000		/* set Update Per Model										*/
#define TM_INVALID_V2M		0x04000		/* set Update View To Model									*/
#define TM_INVALID_M2S		0x08000		/* set Update Model To Screen								*/
#define TM_INVALID_CC		0x10000		/* set Update Copied Cache									*/

/**************************************************************************
 ** Culling
 **/

#define F(f) offsetof(struct state_all,f)
#define P(f) ((br_int_32)(&(f)))

static const br_tv_template_entry partCullTemplateEntries[] = {
	{BRT(TYPE_T),			F(cull.type),			Q | S | A,	BRTV_CONV_COPY,				0,TM_PART|TM_INVALID_CC},
	{BRT(SPACE_T),			F(cull.space),			Q | S | A,	BRTV_CONV_COPY,				0,TM_PART|TM_INVALID_CC},
};

/**************************************************************************
 ** Surface
 **/

static const br_tv_template_entry partSurfaceTemplateEntries[] = {
	{BRT(COLOUR_RGB),		F(surface.colour),			Q|S|AX,	BRTV_CONV_COPY,				0,TM_PART},

	{BRT(OPACITY_X),		F(surface.opacity),			Q|S|AX,	BRTV_CONV_FIXED_SCALAR,		0,TM_PART},
	{BRT(OPACITY_F),		F(surface.opacity),			Q|S|AF,	BRTV_CONV_FLOAT_SCALAR,		0,TM_PART},
	{BRT(AMBIENT_X),		F(surface.ka),				Q|S|AX,	BRTV_CONV_FIXED_SCALAR,		0,TM_PART},
	{BRT(AMBIENT_F),		F(surface.ka),				Q|S|AF,	BRTV_CONV_FLOAT_SCALAR,		0,TM_PART},
	{BRT(DIFFUSE_X),		F(surface.kd),				Q|S|AX,	BRTV_CONV_FIXED_SCALAR,		0,TM_PART},
	{BRT(DIFFUSE_F),		F(surface.kd),				Q|S|AF,	BRTV_CONV_FLOAT_SCALAR,		0,TM_PART},
	{BRT(SPECULAR_X),		F(surface.ks),				Q|S|AX,	BRTV_CONV_FIXED_SCALAR,		0,TM_PART},
	{BRT(SPECULAR_F),		F(surface.ks),				Q|S|AF,	BRTV_CONV_FLOAT_SCALAR,		0,TM_PART},
	{BRT(SPECULAR_POWER_X),	F(surface.power),			Q|S|AX,	BRTV_CONV_FIXED_SCALAR,		0,TM_PART},
	{BRT(SPECULAR_POWER_F),	F(surface.power),			Q|S|AF,	BRTV_CONV_FLOAT_SCALAR,		0,TM_PART},

	{BRT(LIGHTING_B),		F(surface.lighting),		Q|S|A,	BRTV_CONV_COPY,				0,TM_PART|TM_INVALID_CC},
	{BRT(FORCE_FRONT_B),	F(surface.force_front),		Q|S|A,	BRTV_CONV_COPY,				0,TM_PART|TM_INVALID_CC},
	{BRT(FORCE_BACK_B),		F(surface.force_back),		Q|S|A,	BRTV_CONV_COPY,				0,TM_PART|TM_INVALID_CC},

	{BRT(COLOUR_SOURCE_T),	F(surface.colour_source),	Q|S|A,	BRTV_CONV_COPY,				0,TM_PART|TM_INVALID_CC},
	{BRT(MAPPING_SOURCE_T),	F(surface.mapping_source),	Q|S|A,	BRTV_CONV_COPY,				0,TM_PART|TM_INVALID_CC},

	{BRT(MAP_MATRIX_M23_X),	F(surface.map_transform),	Q|S|AX,	BRTV_CONV_M23_FIXED_SCALAR,	0,TM_PART|TM_INVALID_CC},
	{BRT(MAP_MATRIX_M23_F),	F(surface.map_transform),	Q|S|AF,	BRTV_CONV_M23_FLOAT_SCALAR,	0,TM_PART|TM_INVALID_CC},
};

/**************************************************************************
 ** Light
 **/

static const br_tv_template_entry partLightTemplateEntries[] = {
	{BRT(TYPE_T),			F(light[0].type),			Q|S|A,	BRTV_CONV_COPY,				0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(SPACE_T),			F(light[0].lighting_space),	Q|S|A,	BRTV_CONV_COPY,				0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(POSITION_V3_X),	F(light[0].position),		Q|S|AX,	BRTV_CONV_V3_FIXED_SCALAR,	0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(POSITION_V3_F),	F(light[0].position),		Q|S|AF,	BRTV_CONV_V3_FLOAT_SCALAR,	0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(DIRECTION_V3_X),	F(light[0].direction),		Q|S|AX,	BRTV_CONV_V3_FIXED_SCALAR,	0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(DIRECTION_V3_F),	F(light[0].direction),		Q|S|AF,	BRTV_CONV_V3_FLOAT_SCALAR,	0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(SPOT_INNER_X),		F(light[0].spot_inner),		Q|S|AX,	BRTV_CONV_FIXED_SCALAR,		0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(SPOT_INNER_F),		F(light[0].spot_inner),		Q|S|AF,	BRTV_CONV_FLOAT_SCALAR,		0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(SPOT_OUTER_X),		F(light[0].spot_outer),		Q|S|AX,	BRTV_CONV_FIXED_SCALAR,		0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(SPOT_OUTER_F),		F(light[0].spot_outer),		Q|S|AF,	BRTV_CONV_FLOAT_SCALAR,		0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},

	{BRT(COLOUR_RGB),		F(light[0].colour),			Q|S|AF,	BRTV_CONV_COPY,				0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},

	{BRT(ATTENUATION_C_F),	F(light[0].attenuation_c),	Q|S|AF,	BRTV_CONV_FLOAT_SCALAR,		0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(ATTENUATION_C_X),	F(light[0].attenuation_c),	Q|S|AF,	BRTV_CONV_FIXED_SCALAR,		0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(ATTENUATION_L_F),	F(light[0].attenuation_l),	Q|S|AF,	BRTV_CONV_FLOAT_SCALAR,		0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(ATTENUATION_L_X),	F(light[0].attenuation_l),	Q|S|AF,	BRTV_CONV_FIXED_SCALAR,		0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(ATTENUATION_Q_F),	F(light[0].attenuation_q),	Q|S|AF,	BRTV_CONV_FLOAT_SCALAR,		0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(ATTENUATION_Q_X),	F(light[0].attenuation_q),	Q|S|AF,	BRTV_CONV_FIXED_SCALAR,		0,TM_PART | TM_INDEX|TM_INVALID_PS|TM_INVALID_PM},
};

/**************************************************************************
 ** Clip
 **/

static const br_tv_template_entry partClipTemplateEntries[] = {
	{BRT(TYPE_T),		F(clip[0].type), 	Q|S|A, 	BRTV_CONV_COPY,				0,TM_PART|TM_INVALID_PS},
	{BRT(PLANE_V4_X),	F(clip[0].plane),	Q|S|AX,	BRTV_CONV_V4_FIXED_SCALAR,	0,TM_PART|TM_INVALID_PS},
	{BRT(PLANE_V4_F),	F(clip[0].plane),	Q|S|AF,	BRTV_CONV_V4_FLOAT_SCALAR,	0,TM_PART|TM_INVALID_PS},
};


/**************************************************************************
 ** Matrix
 **/

static const br_tv_template_entry partMatrixTemplateEntries[] = {
	{BRT(MODEL_TO_VIEW_M34_X),		F(matrix.model_to_view),		Q | S | AX,	BRTV_CONV_M34_FIXED_SCALAR,	0,TM_PART | TM_M2V | TM_CLEAR_M2V_HINT|TM_INVALID_PM|TM_INVALID_V2M|TM_INVALID_M2S},
	{BRT(MODEL_TO_VIEW_M34_F),		F(matrix.model_to_view),		Q | S | AF,	BRTV_CONV_M34_FLOAT_SCALAR,	0,TM_PART | TM_M2V | TM_CLEAR_M2V_HINT|TM_INVALID_PM|TM_INVALID_V2M|TM_INVALID_M2S},
	{BRT(VIEW_TO_ENVIRONMENT_M34_X),F(matrix.view_to_environment),	Q | S | AX,	BRTV_CONV_M34_FIXED_SCALAR,	0,TM_PART|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(VIEW_TO_ENVIRONMENT_M34_F),F(matrix.view_to_environment),	Q | S | AF,	BRTV_CONV_M34_FLOAT_SCALAR,	0,TM_PART|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(VIEW_TO_SCREEN_M4_X),		F(matrix.view_to_screen),		Q | S | AX,	BRTV_CONV_M4_FIXED_SCALAR,	0,TM_PART | TM_V2S | TM_CLEAR_V2S_HINT | TM_V2S_HINT|TM_INVALID_PS|TM_INVALID_PM|TM_INVALID_M2S},
	{BRT(VIEW_TO_SCREEN_M4_F),		F(matrix.view_to_screen),		Q | S | AF,	BRTV_CONV_M4_FLOAT_SCALAR,	0,TM_PART | TM_V2S | TM_CLEAR_V2S_HINT | TM_V2S_HINT|TM_INVALID_PS|TM_INVALID_PM|TM_INVALID_M2S},
	{BRT(MODEL_TO_VIEW_HINT_T),		F(matrix.model_to_view_hint),	Q | S | A,	BRTV_CONV_COPY,				0,TM_PART|TM_INVALID_PM|TM_INVALID_V2M},
	{BRT(VIEW_TO_SCREEN_HINT_T),	F(matrix.view_to_screen_hint),	Q | S | A,	BRTV_CONV_COPY,				0,TM_PART | TM_V2S_HINT|TM_INVALID_PS|TM_INVALID_PM|TM_INVALID_M2S},
	{BRT(VIEW_TO_ENVIRONMENT_HINT_T),F(matrix.view_to_environment_hint),Q | S | A,	BRTV_CONV_COPY,			0,TM_PART | TM_INVALID_PS|TM_INVALID_PM},
	{BRT(HITHER_Z_X),				F(matrix.hither_z),				Q | S | A,	BRTV_CONV_FIXED_SCALAR,		0,TM_PART},
	{BRT(HITHER_Z_F),				F(matrix.hither_z),				Q | S | A,	BRTV_CONV_FLOAT_SCALAR,		0,TM_PART},
	{BRT(YON_Z_X),					F(matrix.yon_z),				Q | S | A,	BRTV_CONV_FIXED_SCALAR,		0,TM_PART},
	{BRT(YON_Z_F),					F(matrix.yon_z),				Q | S | A,	BRTV_CONV_FLOAT_SCALAR,		0,TM_PART},
};

/**************************************************************************
 ** Enable
 **/

static const br_tv_template_entry partEnableTemplateEntries[] = {
	{BRT(CULL_B),	  	F(enable.flags),	Q|S|A,	BRTV_CONV_BIT,	ENBL_CULL,		TM_PART|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(TRANSFORM_B),	F(enable.flags),	Q|S|A,	BRTV_CONV_BIT,	ENBL_TRANSFORM,	TM_PART|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(SURFACE_B),  	F(enable.flags),	Q|S|A,	BRTV_CONV_BIT,	ENBL_SURFACE,	TM_PART|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(CLIPPING_B),	F(enable.flags),	Q|S|A,	BRTV_CONV_BIT,	ENBL_CLIPPING,	TM_PART|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(BOUNDS_B),		F(enable.flags),	Q|S|A,	BRTV_CONV_BIT,	ENBL_BOUNDS,	TM_PART|TM_INVALID_PS|TM_INVALID_PM},
	{BRT(RENDER_B),		F(enable.flags),	Q|S|A,	BRTV_CONV_BIT,	ENBL_RENDER,	TM_PART|TM_INVALID_PS|TM_INVALID_PM},
};

/**************************************************************************
 ** Hidden Surface
 **/
static const br_tv_template_entry partHiddenSurfaceTemplateEntries[] = {
	{BRT(TYPE_T),				F(hidden.type), 	  	Q|S|A, 	BRTV_CONV_COPY,	0,TM_PART|TM_INVALID_PS|TM_INVALID_PM},

	{BRT(V1ORDER_TABLE_P),		F(hidden.order_table),	Q|S|A, 	BRTV_CONV_COPY,	0,TM_PART},
	{BRT(V1PRIMITIVE_HEAP_P),	F(hidden.heap), 		Q|S|A, 	BRTV_CONV_COPY,	0,TM_PART|TM_INVALID_PS|TM_INVALID_PM},

	{BRT(V1INSERT_FUNCTION_P),	F(hidden.insert_fn),	Q|S|A, 	BRTV_CONV_COPY,	0,TM_PART},
	{BRT(V1INSERT_ARG1_P),		F(hidden.insert_arg1),	Q|S|A, 	BRTV_CONV_COPY,	0,TM_PART},
	{BRT(V1INSERT_ARG2_P),		F(hidden.insert_arg2),	Q|S|A, 	BRTV_CONV_COPY,	0,TM_PART},
	{BRT(V1INSERT_ARG3_P),		F(hidden.insert_arg3),	Q|S|A, 	BRTV_CONV_COPY,	0,TM_PART},
};

/**************************************************************************
 ** Bounds
 **/

static const br_tv_template_entry partBoundsTemplateEntries[] = {
	{BRT(MIN_V2_X),	F(bounds.min),		Q|S|AX,	BRTV_CONV_V2_FIXED_SCALAR,	0},
	{BRT(MIN_V2_F),	F(bounds.min),		Q|S|AF,	BRTV_CONV_V2_FLOAT_SCALAR,	0},
	{BRT(MAX_V2_X),	F(bounds.max),		Q|S|AX,	BRTV_CONV_V2_FIXED_SCALAR,	0},
	{BRT(MAX_V2_F),	F(bounds.max),		Q|S|AF,	BRTV_CONV_V2_FLOAT_SCALAR,	0},
};

static br_tv_template_entry partPrimitiveTemplateEntries[] = {
	{BRT(FORCE_FRONT_B),	F(prim.flags),			Q | S | A,	BRTV_CONV_BIT,	PRIMF_FORCE_FRONT,			1},
	{BRT(SMOOTH_B),			F(prim.flags),			Q | S | A,	BRTV_CONV_BIT,	PRIMF_SMOOTH,				1},
	{BRT(DECAL_B),			F(prim.flags),			Q | S | A,	BRTV_CONV_BIT,	PRIMF_DECAL,				1},
	{BRT(DITHER_COLOUR_B),	F(prim.flags),			Q | S | A,	BRTV_CONV_BIT,	PRIMF_DITHER_COLOUR,		1},
	{BRT(DITHER_MAP_B),		F(prim.flags),			Q | S | A,	BRTV_CONV_BIT,	PRIMF_DITHER_MAP,			1},
	{BRT(DEPTH_WRITE_B),	F(prim.flags),			Q | S | A,	BRTV_CONV_BIT,	PRIMF_DEPTH_WRITE,			1},
	{BRT(COLOUR_WRITE_B),	F(prim.flags),			Q | S | A,	BRTV_CONV_BIT,	PRIMF_COLOUR_WRITE,			1},
	{BRT(BLEND_B),			F(prim.flags),			Q | S | A,	BRTV_CONV_BIT,	PRIMF_BLEND,				1},
	{BRT(MODULATE_B),		F(prim.flags),			Q | S | A,	BRTV_CONV_BIT,	PRIMF_MODULATE,				1},
	{BRT(FOG_T),			F(prim.fog_type),		Q | S | A,	BRTV_CONV_COPY},

	{BRT(COLOUR_T),			F(prim.colour_type),	Q | S | A,	BRTV_CONV_COPY,0,							1},
	{BRT(COLOUR_B),			F(prim.colour_type),	S,			BRTV_CONV_BOOL_TOKEN,BRT_DEFAULT,			1},

	{BRT(INDEX_BASE_I32),	F(prim.index_base),		Q | S | A,	BRTV_CONV_COPY,0,							1},
	{BRT(INDEX_RANGE_I32),	F(prim.index_range),	Q | S | A,	BRTV_CONV_COPY,0,							1},

  	{BRT(PERSPECTIVE_T),	F(prim.perspective_type),Q | S | A,	BRTV_CONV_COPY,0,							1},
  	{BRT(PERSPECTIVE_B),	F(prim.perspective_type),S,			BRTV_CONV_BOOL_TOKEN,BRT_DEFAULT,			1},

	{BRT(SUBDIVIDE_TOLERANCE_I32),	F(prim.subdivide_tolerance),Q | S | A,	BRTV_CONV_COPY,0,				1},

	{BRT(COLOUR_MAP_O),		F(prim.colour_map),		Q | S | A,	BRTV_CONV_COPY},
	{BRT(TEXTURE_O),		F(prim.colour_map),		Q | S,		BRTV_CONV_COPY},
	{BRT(INDEX_SHADE_O),	F(prim.index_shade),	Q | S | A,	BRTV_CONV_COPY},
	{BRT(INDEX_BLEND_O),	F(prim.index_blend),	Q | S | A,	BRTV_CONV_COPY},
	{BRT(SCREEN_DOOR_O),	F(prim.screendoor),		Q | S | A,	BRTV_CONV_COPY},
	{BRT(INDEX_LIGHT_O),	F(prim.lighting),		Q | S | A,	BRTV_CONV_COPY},
	{BRT(BUMP_O),			F(prim.bump),			Q | S | A,	BRTV_CONV_COPY},
	{BRT(INDEX_FOG_O),		F(prim.index_fog),		Q | S | A,	BRTV_CONV_COPY},
};

static br_tv_template_entry partOutputTemplateEntries[] = {
	{BRT(COLOUR_BUFFER_O),	F(out.colour),			Q | S | A,		BRTV_CONV_COPY},
	{BRT(DEPTH_BUFFER_O),	F(out.depth), 			Q | S | A,		BRTV_CONV_COPY},
};

#undef P
#undef F

/**************************************************************************
 ** Default values
 **/
static const struct state_cull partCullDefault = {
	BRT_NONE,
	BRT_MODEL,
};

static const struct state_surface partSurfaceDefault = {
	BR_COLOUR_RGB(255,255,255),				/* colour			*/
	BR_SCALAR(1.0),							/* opacity			*/
	BR_SCALAR(0.0),							/* ka				*/
	BR_SCALAR(0.75),						/* kd				*/
	BR_SCALAR(0.0),							/* ks				*/
	BR_SCALAR(20.0),						/* power			*/

	BR_FALSE,								/* lighting			*/
	BR_FALSE,								/* force_front		*/
	BR_FALSE,								/* force_back		*/
	BRT_SURFACE,							/* colour_source	*/
	BRT_GEOMETRY_MAP,						/* mapping_source	*/

	{{
		BR_VECTOR2(1,0),					/* map_transform	*/
		BR_VECTOR2(0,1),
		BR_VECTOR2(0,0),
	}},
};


static const struct state_light partLightDefault = {
	BRT_NONE,				/* type				*/
	BRT_MODEL,				/* lighting_space	*/
	BR_VECTOR3(0,0,0),		/* position			*/
	BR_VECTOR3(0,0,0),		/* direction		*/
	BR_ANGLE_DEG(30.0),		/* spot_outer		*/
	BR_ANGLE_DEG(20.0),		/* spot_inner		*/
};

static const struct state_clip partClipDefault = {
	BRT_NONE,				/* type */
	BR_VECTOR4(0,0,-1,0),	/* plane */
};

static const struct state_matrix partMatrixDefault = {
	{{
		BR_VECTOR3(1,0,0),		/* model_to_view */
		BR_VECTOR3(0,1,0),
		BR_VECTOR3(0,0,1),
		BR_VECTOR3(0,0,0)
	}},
	
	{{
		BR_VECTOR4(1,0,0,0),	/* view_to_screen */
		BR_VECTOR4(0,1,0,0),
		BR_VECTOR4(0,0,1,0),
		BR_VECTOR4(0,0,0,1)
	}},

	{{
		BR_VECTOR3(1,0,0),		/* view_to_environment */
		BR_VECTOR3(0,1,0),
		BR_VECTOR3(0,0,1),
		BR_VECTOR3(0,0,0)
	}},

	BRT_LENGTH_PRESERVING,		/* model_to_view_hint */
	BRT_PARALLEL,				/* view_to_screen_hint */
};

static const struct state_enable partEnableDefault = {
	ENBL_TRANSFORM | ENBL_CLIPPING | ENBL_RENDER,		/* flags			*/
};

static const struct state_hidden partHiddenSurfaceDefault = {
	BRT_NONE,
	NULL,
	NULL,
	NULL,
	NULL,
};

static const struct state_bounds partBoundsDefault = {
	{BR_SCALAR_MAX, BR_SCALAR_MAX},	
	{BR_SCALAR_MIN, BR_SCALAR_MIN},	
};

/*
 * Sets up an initial state and asociated templates
 */
br_error StateInitialise(struct state_all *state)
{
	int i;

	/*
	 * Some of state can just be copied from static initialisers
	 */
	state->surface = partSurfaceDefault;

	for(i=0; i < MAX_STATE_LIGHTS; i++)
		state->light[i] = partLightDefault;

	for(i=0; i < MAX_STATE_CLIP_PLANES; i++)
		state->clip[i] = partClipDefault;

	state->matrix = partMatrixDefault;
	state->enable = partEnableDefault;
	state->hidden = partHiddenSurfaceDefault;

	state->bounds = partBoundsDefault;
	state->cull = partCullDefault;

	/*
	 * This isn't really correct - surface, primitive, output and cache are not valid
	 */
	state->valid = MASK_STATE_LOCAL | MASK_STATE_CACHE;

	return BRE_OK;
}

/*
 * Common action for all state operations, finds an appropriate template, given part & index
 *
 * Will adjust the state pointer to line up with indexed parts
 */
struct br_tv_template * FindStateTemplate(struct br_renderer *self, struct state_all **state, br_token part, br_int_32 index)
{
    struct br_tv_template_entry *entries;
    struct br_tv_template **tpp;
    int n_entries;

	switch(part) {

	case BRT_CULL:
    
        entries = (struct br_tv_template_entry *)partCullTemplateEntries;
        n_entries = BR_ASIZE(partCullTemplateEntries);
        tpp = &self->device->templates.partCullTemplate;
        break;

	case BRT_SURFACE:
        
        entries = (struct br_tv_template_entry *)partSurfaceTemplateEntries;
        n_entries = BR_ASIZE(partSurfaceTemplateEntries);
        tpp = &self->device->templates.partSurfaceTemplate;
        break;

	case BRT_MATRIX:
        
        entries = (struct br_tv_template_entry *)partMatrixTemplateEntries;
        n_entries = BR_ASIZE(partMatrixTemplateEntries);
        tpp = &self->device->templates.partMatrixTemplate;
        break;

	case BRT_ENABLE:
        
        entries = (struct br_tv_template_entry *)partEnableTemplateEntries;
        n_entries = BR_ASIZE(partEnableTemplateEntries);
        tpp = &self->device->templates.partEnableTemplate;
        break;

	case BRT_HIDDEN_SURFACE:
        
        entries = (struct br_tv_template_entry *)partHiddenSurfaceTemplateEntries;
        n_entries = BR_ASIZE(partHiddenSurfaceTemplateEntries);
        tpp = &self->device->templates.partHiddenSurfaceTemplate;
        break;

	case BRT_BOUNDS:
        
        entries = (struct br_tv_template_entry *)partBoundsTemplateEntries;
        n_entries = BR_ASIZE(partBoundsTemplateEntries);
        tpp = &self->device->templates.partBoundsTemplate;
        break;

	case BRT_LIGHT:
		
		if (index >= BR_ASIZE((*state)->light))
			return NULL;

		*state = (struct state_all *)((char *)(*state) + index * sizeof((*state)->light[0]));

        entries = (struct br_tv_template_entry *)partLightTemplateEntries;
        n_entries = BR_ASIZE(partLightTemplateEntries);
        tpp = &self->device->templates.partLightTemplate;
        break;

	case BRT_CLIP:
		
		if (index >= BR_ASIZE((*state)->clip))
			return NULL;

		*state = (struct state_all *)((char *)(*state) + index * sizeof((*state)->clip[0]));

        entries = (struct br_tv_template_entry *)partClipTemplateEntries;
        n_entries = BR_ASIZE(partClipTemplateEntries);
        tpp = &self->device->templates.partClipTemplate;
        break;

	case BRT_PRIMITIVE:
        
		entries = (struct br_tv_template_entry *)partPrimitiveTemplateEntries;
		n_entries = BR_ASIZE(partPrimitiveTemplateEntries);
		tpp = &self->device->templates.partPrimitiveTemplate;
		break;

	case BRT_OUTPUT:
        
		entries = (struct br_tv_template_entry *)partOutputTemplateEntries;
		n_entries = BR_ASIZE(partOutputTemplateEntries);
		tpp = &self->device->templates.partOutputTemplate;
		break;

	default:
		return NULL;
	}

	if (*tpp == NULL)
		*tpp = BrTVTemplateAllocate(self->device,  entries, n_entries);

    return *tpp;
}

/*
 * Given the mask returned by a template set, perform the indicated actions
 */
void TemplateActions(struct state_all *state, br_token part, br_int_32 index, br_uint_32 mask)
{
#if 0
	if(mask & TM_PART) {
		switch(part) {
		case BRT_CULL:
			state->cull.timestamp = Timestamp();
			break;

		case BRT_SURFACE:
			state->surface.timestamp = Timestamp();
			break;

		case BRT_MATRIX:
			state->matrix.timestamp = Timestamp();
			break;

		case BRT_ENABLE:
			state->enable.timestamp = Timestamp();
			break;

		case BRT_HIDDEN_SURFACE:
			state->hidden.timestamp = Timestamp();
			break;

		case BRT_LIGHT:
			state->timestamp_lights = Timestamp();
			break;

		case BRT_CLIP:
			state->timestamp_clips = Timestamp();
			break;
		}
	}

	if(mask & TM_INDEX) {
		if(part == BRT_LIGHT)
			state->light[index].timestamp = Timestamp();
	}

	if(mask & TM_V2S_HINT)
		state->matrix.timestamp_v2s_hint = Timestamp();

	if(mask & TM_M2V)
		state->matrix.timestamp_m2v = Timestamp();

	if(mask & TM_V2S)
		state->matrix.timestamp_v2s = Timestamp();

	if(mask & TM_COPY_CACHE)
		state->timestamp_copy_cache = Timestamp();

	if(mask & TM_CACHE)
		state->timestamp_cache = Timestamp();
#endif

	if(mask & TM_CLEAR_M2V_HINT)
		state->matrix.model_to_view_hint = BRT_NONE;

	if(mask & TM_CLEAR_V2S_HINT)
		state->matrix.view_to_screen_hint = BRT_NONE;

	if(mask & TM_INVALID_PS)
		scache.valid_per_scene = BR_FALSE;

	if(mask & TM_INVALID_PM)
		scache.valid_per_model = BR_FALSE;

	if(mask & TM_INVALID_V2M)
		scache.valid_v2m = BR_FALSE;

	if(mask & TM_INVALID_M2S)
		scache.valid_m2s = BR_FALSE;

	if(mask & TM_INVALID_CC)
		state->cache.valid = BR_FALSE;

}

/*
 * Called when something has touch the model_to_view matrix
 */
void TouchModelToView(br_renderer *self)
{
	scache.valid_v2m = BR_FALSE;
	scache.valid_m2s = BR_FALSE;
	scache.valid_per_model = BR_FALSE;
}