// Copyright (C) 2004 Id Software, Inc.
//

#ifndef __MATERIAL_H__
#define __MATERIAL_H__

/*
===============================================================================

	Material

===============================================================================
*/

class idImage;
class idCinematic;
class idUserInterface;
class idMegaTexture;
// RAVEN BEGIN
// rjohnson: new shader stage system
class rvNewShaderStage;
class rvGLSLShaderStage;
// RAVEN END

// moved from image.h for default parm
typedef enum {
	TR_REPEAT,
	TR_CLAMP,
	TR_CLAMP_TO_BORDER,		// this should replace TR_CLAMP_TO_ZERO and TR_CLAMP_TO_ZERO_ALPHA,
							// but I don't want to risk changing it right now
	TR_CLAMP_TO_ZERO,		// guarantee 0,0,0,255 edge for projected textures,
	// set AFTER image format selection
	TR_CLAMP_TO_ZERO_ALPHA,	// guarantee 0 alpha edge for projected textures,
	// set AFTER image format selection
	TR_MIRRORED_REPEAT,
} textureRepeat_t;

typedef struct {
	int		stayTime;		// msec for no change
	float	maxAngle;		// maximum dot product to reject projection angles
} decalInfo_t;

typedef enum {
	DFRM_NONE,
	DFRM_SPRITE,
	DFRM_TUBE,
	DFRM_FLARE,
	DFRM_EXPAND,
	DFRM_MOVE,
	DFRM_EYEBALL,
// ddynerman: rectangular sprites
	DFRM_RECTSPRITE,
// RAVEN END
	DFRM_TURB
} deform_t;

typedef enum {
	DI_STATIC,
	DI_SCRATCH,		// video, screen wipe, etc
	DI_CUBE_RENDER,
	DI_MIRROR_RENDER,
// RAVEN BEGIN
// AReis: Used for water reflection/refraction.
	DI_REFLECTION_RENDER,
	DI_REFRACTION_RENDER,
// RAVEN END
	DI_REMOTE_RENDER
} dynamicidImage_t;

// note: keep opNames[] in sync with changes
typedef enum {
	OP_TYPE_ADD,
	OP_TYPE_SUBTRACT,
	OP_TYPE_MULTIPLY,
	OP_TYPE_DIVIDE,
	OP_TYPE_MOD,
	OP_TYPE_TABLE,
	OP_TYPE_GT,
	OP_TYPE_GE,
	OP_TYPE_LT,
	OP_TYPE_LE,
	OP_TYPE_EQ,
	OP_TYPE_NE,
	OP_TYPE_AND,
	OP_TYPE_OR,
	OP_TYPE_SOUND
// RAVEN BEGIN
// rjohnson: new shader stage system
	,
	OP_TYPE_GLSL_ENABLED,
	OP_TYPE_POT_X,
	OP_TYPE_POT_Y,
// RAVEN END
} expOpType_t;

typedef enum {
	EXP_REG_TIME,

	EXP_REG_PARM0,
	EXP_REG_PARM1,
	EXP_REG_PARM2,
	EXP_REG_PARM3,
	EXP_REG_PARM4,
	EXP_REG_PARM5,
	EXP_REG_PARM6,
	EXP_REG_PARM7,
	EXP_REG_PARM8,
	EXP_REG_PARM9,
	EXP_REG_PARM10,
	EXP_REG_PARM11,

	EXP_REG_GLOBAL0,
	EXP_REG_GLOBAL1,
	EXP_REG_GLOBAL2,
	EXP_REG_GLOBAL3,
	EXP_REG_GLOBAL4,
	EXP_REG_GLOBAL5,
	EXP_REG_GLOBAL6,
	EXP_REG_GLOBAL7,

// RAVEN BEGIN
// rjohnson: added vertex randomizing
	EXP_REG_VERTEX_RANDOMIZER,
// RAVEN END

	EXP_REG_NUM_PREDEFINED
} expRegister_t;

// RAVEN BEGIN
// rjohnson: added new decal support

// decal registers
#define EXP_REG_DECAL_LIFE		EXP_REG_PARM4
#define	REG_DECAL_LIFE			4
#define EXP_REG_DECAL_SPAWN		EXP_REG_PARM5
#define	REG_DECAL_SPAWN			5
// RAVEN END

typedef struct {
	expOpType_t		opType;	
	int				a, b, c;
} expOp_t;

typedef struct {
	int				registers[4];
} colorStage_t;

typedef enum {
	TG_EXPLICIT,
	TG_DIFFUSE_CUBE,
	TG_REFLECT_CUBE,
	TG_SKYBOX_CUBE,
	TG_WOBBLESKY_CUBE,
	TG_SCREEN			// screen aligned, for mirrorRenders and screen space temporaries
} texgen_t;

typedef struct {
	idCinematic *		cinematic;
	idImage *			image;
	texgen_t			texgen;
	bool				hasMatrix;
	int					matrix[2][3];	// we only allow a subset of the full projection matrix

	// dynamic image variables
	dynamicidImage_t	dynamic;
	int					width, height;
	int					dynamicFrameCount;
} textureStage_t;

// the order BUMP / DIFFUSE / SPECULAR is necessary for interactions to draw correctly on low end cards
typedef enum {
	SL_AMBIENT,						// execute after lighting
	SL_BUMP,
	SL_DIFFUSE,
	SL_SPECULAR
} stageLighting_t;

// cross-blended terrain textures need to modulate the color by
// the vertex color to smoothly blend between two textures
typedef enum {
	SVC_IGNORE,
	SVC_MODULATE,
	SVC_INVERSE_MODULATE
} stageVertexColor_t;

static const int	MAX_FRAGMENT_IMAGES = 8;
// RAVEN BEGIN
// AReis: Increased MAX_VERTEX_PARMS from 4 to 16 and added MAX_FRAGMENT_PARMS.
static const int	MAX_VERTEX_PARMS = 16;
static const int	MAX_FRAGMENT_PARMS = 8;
// RAVEN END

typedef struct {
	int					vertexProgram;

// RAVEN BEGIN
// dluetscher: added support for specifying MD5R specfic vertex programs
// Q4SDK: maintain compatible structure padding
#if defined( _MD5R_SUPPORT ) || defined( Q4SDK_MD5R )
	int					md5rVertexProgram;
#endif
// RAVEN END

	int					numVertexParms;
	int					vertexParms[MAX_VERTEX_PARMS][4];	// evaluated register indexes

// RAVEN BEGIN
// AReis: New Fragment Parm stuff.
	int					numFragmentParms;
	int					fragmentParms[MAX_FRAGMENT_PARMS][4];	// evaluated register indexes
// RAVEN END

	int					fragmentProgram;
	int					numFragmentProgramImages;
	idImage *			fragmentProgramImages[MAX_FRAGMENT_IMAGES];

// RAVEN BEGIN
// AReis: Custom Bindings. These override existing parm values.
	bool				vertexParmsBindings[MAX_VERTEX_PARMS];
	bool				fragmentParmsBindings[MAX_FRAGMENT_PARMS];

// AReis: So fragment images can be bound to program specified binding, this
// list keeps track of which image to use (if any, 0 if use specified image).
	int					fragmentProgramBindings[MAX_FRAGMENT_IMAGES];
// RAVEN END

	idMegaTexture		*megaTexture;		// handles all the binding and parameter setting 
} newShaderStage_t;

typedef struct {
	int					conditionRegister;	// if registers[conditionRegister] == 0, skip stage
	stageLighting_t		lighting;			// determines which passes interact with lights
	int					drawStateBits;
	colorStage_t		color;
	bool				hasAlphaTest;
// RAVEN BEGIN
	bool				hasAlphaFunc;
	int					alphaTestMode;
// RAVEN END
	int					alphaTestRegister;
	textureStage_t		texture;
	stageVertexColor_t	vertexColor;
	bool				ignoreAlphaTest;	// this stage should act as translucent, even
											// if the surface is alpha tested
	float				privatePolygonOffset;	// a per-stage polygon offset

	newShaderStage_t	*newStage;			// vertex / fragment program based stage

// RAVEN BEGIN
// rjohnson: new shader stage system
	rvNewShaderStage	*newShaderStage;

// rjohnson: added new decal support
	int					mStageRegisterStart;
	int					mNumStageRegisters;
	int					mStageOpsStart;
	int					mNumStageOps;
// RAVEN END
} shaderStage_t;

typedef enum {
	MC_BAD,
	MC_OPAQUE,			// completely fills the triangle, will have black drawn on fillDepthBuffer
	MC_PERFORATED,		// may have alpha tested holes
	MC_TRANSLUCENT		// blended with background
} materialCoverage_t;

typedef enum {
	SS_MIN = -10000,
// RAVEN BEGIN
	SS_SUBVIEW = -4,	// mirrors, viewscreens, etc
	SS_PREGUI = -3,		// guis
// RAVEN END
	SS_GUI = -2,		// guis
	SS_BAD = -1,
	SS_OPAQUE,			// opaque

	SS_PORTAL_SKY,

	SS_DECAL,			// scorch marks, etc.

	SS_FAR,
	SS_MEDIUM,			// normal translucent
	SS_CLOSE,

	SS_ALMOST_NEAREST,	// gun smoke puffs

	SS_NEAREST,			// screen blood blobs

	SS_POST_PROCESS = 100,	// after a screen copy to texture
	SS_MAX = 10000
} materialSort_t;

typedef enum {
	CT_FRONT_SIDED,
	CT_BACK_SIDED,
	CT_TWO_SIDED
} cullType_t;

// these don't effect per-material storage, so they can be very large
const int MAX_SHADER_STAGES			= 256;

const int MAX_TEXGEN_REGISTERS		= 4;

const int MAX_ENTITY_SHADER_PARMS	= 12;

// material flags
typedef enum {
	MF_DEFAULTED				= BIT(0),
	MF_POLYGONOFFSET			= BIT(1),
	MF_NOSHADOWS				= BIT(2),
	MF_FORCESHADOWS				= BIT(3),
	MF_NOSELFSHADOW				= BIT(4),
	MF_NOPORTALFOG				= BIT(5),	// this fog volume won't ever consider a portal fogged out
	MF_EDITOR_VISIBLE			= BIT(6)	// in use (visible) per editor
// RAVEN BEGIN
// jscott: for portal skies
	, 
	MF_SKY						= BIT(7),
	MF_NEED_CURRENT_RENDER		= BIT(8)	// for hud guis that need sort order preseved but need back end too
// RAVEN END
} materialFlags_t;

// contents flags, NOTE: make sure to keep the defines in doom_defs.script up to date with these!
typedef enum {
	CONTENTS_SOLID				= BIT(0),	// an eye is never valid in a solid
	CONTENTS_OPAQUE				= BIT(1),	// blocks visibility (for ai)
	CONTENTS_WATER				= BIT(2),	// used for water
	CONTENTS_PLAYERCLIP			= BIT(3),	// solid to players
	CONTENTS_MONSTERCLIP		= BIT(4),	// solid to monsters
	CONTENTS_MOVEABLECLIP		= BIT(5),	// solid to moveable entities
	CONTENTS_IKCLIP				= BIT(6),	// solid to IK
	CONTENTS_BLOOD				= BIT(7),	// used to detect blood decals
	CONTENTS_BODY				= BIT(8),	// used for actors
	CONTENTS_PROJECTILE			= BIT(9),	// used for projectiles
	CONTENTS_CORPSE				= BIT(10),	// used for dead bodies
	CONTENTS_RENDERMODEL		= BIT(11),	// used for render models for collision detection
	CONTENTS_TRIGGER			= BIT(12),	// used for triggers
	CONTENTS_AAS_SOLID			= BIT(13),	// solid for AAS
	CONTENTS_AAS_OBSTACLE		= BIT(14),	// used to compile an obstacle into AAS that can be enabled/disabled
	CONTENTS_FLASHLIGHT_TRIGGER	= BIT(15),	// used for triggers that are activated by the flashlight
// RAVEN BEGIN
// bdube: new clip that blocks monster visibility
	CONTENTS_SIGHTCLIP			= BIT(16),	// used for blocking sight for actors and cameras
	CONTENTS_LARGESHOTCLIP		= BIT(17),	// used to block large shots (fence that allows bullets through but not rockets for example)
// cdr: AASTactical
	CONTENTS_NOTACTICALFEATURES	= BIT(18),	// don't place tactical features here
	CONTENTS_VEHICLECLIP		= BIT(19),	// solid to vehicles

	// contents used by utils
	CONTENTS_AREAPORTAL			= BIT(20),	// portal separating renderer areas
	CONTENTS_NOCSG				= BIT(21),	// don't cut this brush with CSG operations in the editor
	CONTENTS_FLYCLIP			= BIT(22),	// solid to vehicles

// mekberg: added
	CONTENTS_ITEMCLIP			= BIT(23),	// so items can collide
	CONTENTS_PROJECTILECLIP		= BIT(24),  // unlike contents_projectile, projectiles only NOT hitscans
// RAVEN END

	CONTENTS_REMOVE_UTIL		= ~(CONTENTS_AREAPORTAL|CONTENTS_NOCSG)
} contentsFlags_t;

// surface types
const int NUM_SURFACE_BITS		= 4;
const int MAX_SURFACE_TYPES		= 1 << NUM_SURFACE_BITS;

typedef enum {
	SURFTYPE_NONE,					// default type
    SURFTYPE_METAL,
	SURFTYPE_STONE,
	SURFTYPE_FLESH,
	SURFTYPE_WOOD,
	SURFTYPE_CARDBOARD,
	SURFTYPE_LIQUID,
	SURFTYPE_GLASS,
	SURFTYPE_PLASTIC,
	SURFTYPE_RICOCHET,
	SURFTYPE_10,
	SURFTYPE_11,
	SURFTYPE_12,
	SURFTYPE_13,
	SURFTYPE_14,
	SURFTYPE_15
} surfTypes_t;

// surface flags
typedef enum {
	SURF_TYPE_BIT0				= BIT(0),	// encodes the material type (metal, flesh, concrete, etc.)
	SURF_TYPE_BIT1				= BIT(1),	// "
	SURF_TYPE_BIT2				= BIT(2),	// "
	SURF_TYPE_BIT3				= BIT(3),	// "
	SURF_TYPE_MASK				= ( 1 << NUM_SURFACE_BITS ) - 1,

	SURF_NODAMAGE				= BIT(4),	// never give falling damage
	SURF_SLICK					= BIT(5),	// effects game physics
	SURF_COLLISION				= BIT(6),	// collision surface
	SURF_LADDER					= BIT(7),	// player can climb up this surface
	SURF_NOIMPACT				= BIT(8),	// don't make missile explosions
	SURF_NOSTEPS				= BIT(9),	// no footstep sounds
	SURF_DISCRETE				= BIT(10),	// not clipped or merged by utilities
	SURF_NOFRAGMENT				= BIT(11),	// dmap won't cut surface at each bsp boundary
	SURF_NULLNORMAL				= BIT(12),	// renderbump will draw this surface as 0x80 0x80 0x80, which
											// won't collect light from any angle
// RAVEN BEGIN
// bdube: added bounce
	SURF_BOUNCE					= BIT(13),	// projectiles should bounce off this surface

// dluetscher: added no T fix
	SURF_NO_T_FIX				= BIT(14),	// merge surfaces (like decals), but does not try to T-fix them

// RAVEN END
} surfaceFlags_t;

class idSoundEmitter;

// RAVEN BEGIN
// jsinger: added to allow support for serialization/deserialization of binary decls
#ifdef RV_BINARYDECLS
class idMaterial : public idDecl, public Serializable<'IMAT'> {
public:
// jsinger:
	virtual void		Write( SerialOutputStream &stream ) const;
	virtual void		AddReferences() const;
						idMaterial( SerialInputStream &stream );
#else
class idMaterial : public idDecl {
#endif
// rjohnson: new shader stage system
	friend class rvNewShaderStage;
	friend class rvGLSLShaderStage;
// RAVEN END

public:
						idMaterial();
	virtual				~idMaterial();

	virtual size_t		Size( void ) const;
	virtual bool		SetDefaultText( void );
	virtual const char *DefaultDefinition( void ) const;
	virtual bool		Parse( const char *text, const int textLength, bool noCaching );
	virtual void		FreeData( void );
	virtual void		Print( void ) const;

						// returns the internal image name for stage 0, which can be used
						// for the renderer CaptureRenderToImage() call
						// I'm not really sure why this needs to be virtual...
	virtual const char	*ImageName( void ) const;

	void				ReloadImages( bool force ) const;
// RAVEN BEGIN
// mwhitlock: Xenon texture streaming
#if defined(_XENON)
	int					streamCount;
	int					streamTimeStamp;
	static int			masterStreamTimeStamp;
	bool				StreamImages( bool inBackground );
	void				UnstreamImages( void );
	void				UpdateImage( int stage, const byte *data, int width, int height );
#endif
// RAVEN END
						// returns number of stages this material contains
	const int			GetNumStages( void ) const { return numStages; }

						// get a specific stage
	const shaderStage_t *GetStage( const int index ) const { assert(index >= 0 && index < numStages); return &stages[index]; }

						// get the first bump map stage, or NULL if not present.
						// used for bumpy-specular
	const shaderStage_t *GetBumpStage( void ) const;

						// returns true if the material will draw anything at all.  Triggers, portals,
						// etc, will not have anything to draw.  A not drawn surface can still castShadow,
						// which can be used to make a simplified shadow hull for a complex object set
						// as noShadow
	bool				IsDrawn( void ) const { return ( numStages > 0 || entityGui != 0 || gui != NULL ); }

						// returns true if the material will draw any non light interaction stages
	bool				HasAmbient( void ) const { return ( numAmbientStages > 0 ); }

						// returns true if material has a gui
	bool				HasGui( void ) const { return ( entityGui != 0 || gui != NULL ); }

						// returns true if the material will generate another view, either as
						// a mirror or dynamic rendered image
	bool				HasSubview( void ) const { return hasSubview; }

						// returns true if the material will generate shadows, not making a
						// distinction between global and no-self shadows
	bool				SurfaceCastsShadow( void ) const { return TestMaterialFlag( MF_FORCESHADOWS ) || !TestMaterialFlag( MF_NOSHADOWS ); }

						// returns true if the material will generate interactions with fog/blend lights
						// All non-translucent surfaces receive fog unless they are explicitly noFog
	bool				ReceivesFog( void ) const { return ( IsDrawn() && !noFog && coverage != MC_TRANSLUCENT ); }

						// returns true if the material will generate interactions with normal lights
						// Many special effect surfaces don't have any bump/diffuse/specular
						// stages, and don't interact with lights at all
	bool				ReceivesLighting( void ) const { return numAmbientStages != numStages; }

						// returns true if the material should generate interactions on sides facing away
						// from light centers, as with noshadow and noselfshadow options
	bool				ReceivesLightingOnBackSides( void ) const { return ( materialFlags & (MF_NOSELFSHADOW|MF_NOSHADOWS) ) != 0; }

						// Standard two-sided triangle rendering won't work with bump map lighting, because
						// the normal and tangent vectors won't be correct for the back sides.  When two
						// sided lighting is desired. typically for alpha tested surfaces, this is
						// addressed by having CleanupModelSurfaces() create duplicates of all the triangles
						// with apropriate order reversal.
	bool				ShouldCreateBackSides( void ) const { return shouldCreateBackSides; }

						// characters and models that are created by a complete renderbump can use a faster
						// method of tangent and normal vector generation than surfaces which have a flat
						// renderbump wrapped over them.
	bool				UseUnsmoothedTangents( void ) const { return unsmoothedTangents; }

						// by default, monsters can have blood overlays placed on them, but this can
						// be overrided on a per-material basis with the "noOverlays" material command.
						// This will always return false for translucent surfaces
	bool				AllowOverlays( void ) const { return allowOverlays; }

						// MC_OPAQUE, MC_PERFORATED, or MC_TRANSLUCENT, for interaction list linking and
						// dmap flood filling
						// The depth buffer will not be filled for MC_TRANSLUCENT surfaces
						// FIXME: what do nodraw surfaces return?
	materialCoverage_t	Coverage( void ) const { return coverage; }

						// returns true if this material takes precedence over other in coplanar cases
	bool				HasHigherDmapPriority( const idMaterial &other ) const { return ( IsDrawn() && !other.IsDrawn() ) ||
																						( Coverage() < other.Coverage() ); }

						// returns a idUserInterface if it has a global gui, or NULL if no gui
	idUserInterface	*	GlobalGui( void ) const { return gui; }

						// a discrete surface will never be merged with other surfaces by dmap, which is
						// necessary to prevent mutliple gui surfaces, mirrors, autosprites, and some other
						// special effects from being combined into a single surface
						// guis, merging sprites or other effects, mirrors and remote views are always discrete
	bool				IsDiscrete( void ) const { return ( entityGui || gui || deform != DFRM_NONE || sort == SS_SUBVIEW ||
												( surfaceFlags & SURF_DISCRETE ) != 0 ); }

						// Normally, dmap chops each surface by every BSP boundary, then reoptimizes.
						// For gigantic polygons like sky boxes, this can cause a huge number of planar
						// triangles that make the optimizer take forever to turn back into a single
						// triangle.  The "noFragment" option causes dmap to only break the polygons at
						// area boundaries, instead of every BSP boundary.  This has the negative effect
						// of not automatically fixing up interpenetrations, so when this is used, you
						// should manually make the edges of your sky box exactly meet, instead of poking
						// into each other.
	bool				NoFragment( void ) const { return ( surfaceFlags & SURF_NOFRAGMENT ) != 0; }

// RAVEN BEGIN
// dluetscher: added SURF_NO_T_FIX to merge surfaces (like decals), but skipping any T-junction fixing
	bool				NoTFix( void ) const { return ( surfaceFlags & SURF_NO_T_FIX ) != 0; }
// RAVEN END

	//------------------------------------------------------------------

// RAVEN BEGIN
// jscott: added accessor
	const rvDeclMatType *		GetMaterialType( void ) const { return( materialType ); }
	const rvDeclMatType *		GetMaterialType( idVec2 &tc ) const;
	byte *						GetMaterialTypeArray( void ) const { return( materialTypeArray ); }
	const char *				GetMaterialTypeArrayName( void ) const { return( materialTypeArrayName.c_str() ); }

// jscott: for profiling
	int							GetTexelCount( void ) const;

// jscott: for error checking
	bool						HasDefaultedImage( void ) const;

// jscott: for Radiant
	idImage *					GetDiffuseImage( void ) const;

// AReis: New portal distance culling stuff.
	float						GetPortalNear( void ) const { return( portalDistanceNear ); }
	float						GetPortalFar( void ) const { return( portalDistanceFar ); }
	const idImage *				GetPortalImage( void ) const { return( portalImage ); }

// jscott: to prevent a recursive crash
	virtual	bool				RebuildTextSource( void ) { return( false ); }
// scork: for detailed error-reporting
	virtual bool				Validate( const char *psText, int iTextLength, idStr &strReportTo ) const;
// RAVEN END

	//==================================================================
	// light shader specific functions, only called for light entities

						// lightshader option to fill with fog from viewer instead of light from center
	bool				IsFogLight() const { return fogLight; }

						// perform simple blending of the projection, instead of interacting with bumps and textures
	bool				IsBlendLight() const { return blendLight; }

						// an ambient light has non-directional bump mapping and no specular
	bool				IsAmbientLight() const { return ambientLight; }

						// implicitly no-shadows lights (ambients, fogs, etc) will never cast shadows
						// but individual light entities can also override this value
	bool				LightCastsShadows() const { return TestMaterialFlag( MF_FORCESHADOWS ) ||
								( !fogLight && !ambientLight && !blendLight && !TestMaterialFlag( MF_NOSHADOWS ) ); }

						// fog lights, blend lights, ambient lights, etc will all have to have interaction
						// triangles generated for sides facing away from the light as well as those
						// facing towards the light.  It is debatable if noshadow lights should effect back
						// sides, making everything "noSelfShadow", but that would make noshadow lights
						// potentially slower than normal lights, which detracts from their optimization
						// ability, so they currently do not.
	bool				LightEffectsBackSides() const { return fogLight || ambientLight || blendLight; }

						// NULL unless an image is explicitly specified in the shader with "lightFalloffShader <image>"
	idImage	*			LightFalloffImage() const { return lightFalloffImage; }

	//------------------------------------------------------------------

						// returns the renderbump command line for this shader, or an empty string if not present
	const char *		GetRenderBump() const { return renderBump; };

						// set specific material flag(s)
	void				SetMaterialFlag( const int flag ) const { materialFlags |= flag; }

						// clear specific material flag(s)
	void				ClearMaterialFlag( const int flag ) const { materialFlags &= ~flag; }

						// test for existance of specific material flag(s)
	bool				TestMaterialFlag( const int flag ) const { return ( materialFlags & flag ) != 0; }

						// get content flags
	const int			GetContentFlags( void ) const { return contentFlags; }

						// get surface flags
	const int			GetSurfaceFlags( void ) const { return surfaceFlags; }

						// gets name for surface type (stone, metal, flesh, etc.)
	const surfTypes_t	GetSurfaceType( void ) const { return static_cast<surfTypes_t>( surfaceFlags & SURF_TYPE_MASK ); }

						// get material description
	const char *		GetDescription( void ) const { return desc; }

						// get sort order
	const float			GetSort( void ) const { return sort; }
						// this is only used by the gui system to force sorting order
						// on images referenced from tga's instead of materials. 
						// this is done this way as there are 2000 tgas the guis use
	void				SetSort( float s ) const { sort = s; };

						// DFRM_NONE, DFRM_SPRITE, etc
	deform_t			Deform( void ) const { return deform; }

						// flare size, expansion size, etc
	const int			GetDeformRegister( int index ) const { return deformRegisters[index]; }

						// particle system to emit from surface and table for turbulent
	const idDecl		*GetDeformDecl( void ) const { return deformDecl; }

						// currently a surface can only have one unique texgen for all the stages
	texgen_t			Texgen() const;

						// wobble sky parms
	const int *			GetTexGenRegisters( void ) const { return texGenRegisters; }

						// get cull type
	const cullType_t	GetCullType( void ) const { return cullType; }

	float				GetEditorAlpha( void ) const { return editorAlpha; }

	int					GetEntityGui( void ) const { return entityGui; }

	decalInfo_t			GetDecalInfo( void ) const { return decalInfo; }

						// spectrums are used for "invisible writing" that can only be
						// illuminated by a light of matching spectrum
	int					Spectrum( void ) const { return spectrum; }

	float				GetPolygonOffset( void ) const { return polygonOffset; }

	float				GetSurfaceArea( void ) const { return surfaceArea; }
	void				AddToSurfaceArea( float area ) { surfaceArea += area; }

	//------------------------------------------------------------------

						// returns the length, in milliseconds, of the videoMap on this material,
						// or zero if it doesn't have one
	int					CinematicLength( void ) const;

	void				CloseCinematic( void ) const;

	void				ResetCinematicTime( int time ) const;

	void				UpdateCinematic( int time ) const;

	//------------------------------------------------------------------

						// gets an image for the editor to use
	idImage *			GetEditorImage( void ) const;
	int					GetImageWidth( void ) const;
	int					GetImageHeight( void ) const;

	void				SetGui( const char *_gui ) const;

						// just for resource tracking
	void				SetImageClassifications( int tag ) const;

	//------------------------------------------------------------------

						// returns number of registers this material contains
	const int			GetNumRegisters() const { return numRegisters; }

// RAVEN BEGIN
// rjohnson: added vertex randomizing
						// regs should point to a float array large enough to hold GetNumRegisters() floats
	void				EvaluateRegisters( float *regs, const float entityParms[MAX_ENTITY_SHADER_PARMS], 
											const struct viewDef_s *view, int soundEmitter = 0, idVec3 *randomizer = NULL ) const;
// RAVEN END

// RAVEN BEGIN
// rjohnson: added new decal support
	void				EvaluateStageRegisters( int StageIndex, float *registers, const float shaderParms[MAX_ENTITY_SHADER_PARMS], float FloatTime) const;

// rjohnson: started tracking image/material usage
	void				ClearUseCount( void ) { useCount = 0; }
	void				IncreaseUseCount( void ) { useCount++; globalUseCount++; }
	int					GetUseCount( void ) { return useCount; }
	int					GetGlobalUseCount( void ) const { return globalUseCount; }
	void				ResolveUse( void );
// RAVEN END

						// if a material only uses constants (no entityParm or globalparm references), this
						// will return a pointer to an internal table, and EvaluateRegisters will not need
						// to be called.  If NULL is returned, EvaluateRegisters must be used.
	const float *		ConstantRegisters() const;

	bool				SuppressInSubview() const				{ return suppressInSubview; };
	bool				IsPortalSky() const						{ return portalSky; };
	void				AddReference();

private:
	// parse the entire material
	void				CommonInit();
// RAVEN BEGIN
// scork: now returns false (WHEN VALIDATING) under circumstances which would cause a common->FatalError normally, caller should bail ASAP on return.
	bool				ParseMaterial( idLexer &src );
// RAVEN END
	bool				MatchToken( idLexer &src, const char *match );
	void				ParseSort( idLexer &src );
	void				ParseBlend( idLexer &src, shaderStage_t *stage );
	void				ParseVertexParm( idLexer &src, newShaderStage_t *newStage );
// RAVEN BEGIN
// AReis: New fragment parm stuff.
	void				ParseFragmentParm( idLexer &src, newShaderStage_t *newStage );
// RAVEN END
	void				ParseFragmentMap( idLexer &src, newShaderStage_t *newStage );

// RAVEN BEGIN
// scork: now returns false (WHEN VALIDATING) under circumstances which would cause a common->FatalError normally, caller should bail ASAP on return.
	bool				ParseStage( idLexer &src, const textureRepeat_t trpDefault = TR_REPEAT );
// RAVEN END
	void				ParseDeform( idLexer &src );
	void				ParseDecalInfo( idLexer &src );
	bool				CheckSurfaceParm( idToken *token );
	int					GetExpressionConstant( float f );
	int					GetExpressionTemporary( void );
	expOp_t	*			GetExpressionOp( void );
	int					EmitOp( int a, int b, expOpType_t opType );
	int					ParseEmitOp( idLexer &src, int a, expOpType_t opType, int priority );
	int					ParseTerm( idLexer &src );
	int					ParseExpressionPriority( idLexer &src, int priority );
	int					ParseExpression( idLexer &src );
	void				ClearStage( shaderStage_t *ss );
	int					NameToSrcBlendMode( const idStr &name );
	int					NameToDstBlendMode( const idStr &name );
	void				MultiplyTextureMatrix( textureStage_t *ts, int registers[2][3] );	// FIXME: for some reason the const is bad for gcc and Mac
	void				SortInteractionStages();
// RAVEN BEGIN
// scork: now returns false (WHEN VALIDATING) under circumstances which would cause a common->FatalError normally, caller should bail ASAP on return.
	bool				AddImplicitStages( const textureRepeat_t trpDefault = TR_REPEAT );
// RAVEN END
	void				CheckForConstantRegisters();

private:
	idStr				desc;				// description
	idStr				renderBump;			// renderbump command options, without the "renderbump" at the start

	idImage	*			lightFalloffImage;

	int					entityGui;			// draw a gui with the idUserInterface from the renderEntity_t
											// non zero will draw gui, gui2, or gui3 from renderEnitty_t
	mutable idUserInterface	*gui;			// non-custom guis are shared by all users of a material

// RAVEN BEGIN
// jscott: for material types
	const rvDeclMatType *materialType;
	byte				*materialTypeArray;	// an array of material type indices generated from the hit image
	idStr				materialTypeArrayName;
	int					MTAWidth;
	int					MTAHeight;

// rjohnson: started tracking image/material usage
	int					useCount;
	int					globalUseCount;

// AReis: New portal distance culling stuff.
	float				portalDistanceNear;
	float				portalDistanceFar;
	idImage *			portalImage;
// RAVEN END

	bool				noFog;				// surface does not create fog interactions

	int					spectrum;			// for invisible writing, used for both lights and surfaces

	float				polygonOffset;

	int					contentFlags;		// content flags
	int					surfaceFlags;		// surface flags	
	mutable int			materialFlags;		// material flags
	
	decalInfo_t			decalInfo;


	mutable	float		sort;				// lower numbered shaders draw before higher numbered
	deform_t			deform;
	int					deformRegisters[4];		// numeric parameter for deforms
	const idDecl		*deformDecl;			// for surface emitted particle deforms and tables

	int					texGenRegisters[MAX_TEXGEN_REGISTERS];	// for wobbleSky

	materialCoverage_t	coverage;
	cullType_t			cullType;			// CT_FRONT_SIDED, CT_BACK_SIDED, or CT_TWO_SIDED
	bool				shouldCreateBackSides;
	
	bool				fogLight;
	bool				blendLight;
	bool				ambientLight;
	bool				unsmoothedTangents;
	bool				hasSubview;			// mirror, remote render, etc
	bool				allowOverlays;

	int					numOps;
	expOp_t *			ops;				// evaluate to make expressionRegisters
																										
	int					numRegisters;																			//
	float *				expressionRegisters;

	float *				constantRegisters;	// NULL if ops ever reference globalParms or entityParms

	int					numStages;
	int					numAmbientStages;
																										
	shaderStage_t *		stages;

	struct mtrParsingData_s	*pd;			// only used during parsing

	float				surfaceArea;		// only for listSurfaceAreas

	// we defer loading of the editor image until it is asked for, so the game doesn't load up
	// all the invisible and uncompressed images.
	// If editorImage is NULL, it will atempt to load editorImageName, and set editorImage to that or defaultImage
	idStr				editorImageName;
	mutable idImage *	editorImage;		// image used for non-shaded preview
	float				editorAlpha;

	bool				suppressInSubview;
	bool				portalSky;
	int					refCount;
};

typedef idList<const idMaterial *> idMatList;

// RAVEN BEGIN
class rvMaterialEdit
{
public:
	virtual ~rvMaterialEdit() {}
	virtual	void		SetGui( idMaterial *edit, const char *name ) = 0;
	virtual int			GetImageWidth( const idMaterial *edit ) const = 0;
	virtual int			GetImageHeight( const idMaterial *edit ) const = 0;
};

extern rvMaterialEdit	*materialEdit;
// RAVEN END

#endif /* !__MATERIAL_H__ */