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

#ifndef __MATERIAL_H__
#define __MATERIAL_H__

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

	Material

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

#include "RendererEnums.h"
#include "../framework/declManager.h"

using namespace sdUtility;

class idImage;
class sdUserInterface;
class idMegaTexture;
class sdDeclRenderBinding;
class sdDeclRenderProgram;
class idSoundEmitter;

typedef struct decalInfo_s {
	int		stayTime;		// msec for no change
	int		fadeTime;		// msec to fade vertex colors over
	idVec4	start;		// vertex color at spawn (possibly out of 0.0 - 1.0 range, will clamp after calc)
	idVec4	end;		// vertex color at fade-out (possibly out of 0.0 - 1.0 range, will clamp after calc)
} decalInfo_t;

typedef enum {
	DFRM_NONE,
	DFRM_SPRITE,
	DFRM_TUBE,
	DFRM_FLARE,
	DFRM_FLARE_VCOL,
	DFRM_EXPAND,
	DFRM_MOVE,
	DFRM_EYEBALL,
	DFRM_PARTICLE,
	DFRM_PARTICLE2,
	DFRM_TURB,
	DFRM_GLOW,
} deform_t;

typedef enum {
	DI_STATIC,
	DI_SCRATCH,		// video, screen wipe, etc
	DI_CUBE_RENDER,
	DI_MIRROR_RENDER,
	DI_REMOTE_RENDER,
	DI_REFRACT_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,
	OP_TYPE_LOAD
} 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,
	EXP_REG_NUMLIGHTS,
	EXP_REG_NUM_PREDEFINED
} expRegister_t;

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

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

// deprecated
typedef struct {
	idImage *			image;
	//texgen_t			texgen;
	//effectsVertexProgram_t	program;
	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;

struct arbProgramBinding_t {};
// end deprecated


// Subview allows you to set some parameters when the shader has mirrored views rendered
// these mainly limit the amount of objects rendered in the reflection
typedef struct {
	float		boxExpand;			// Expand the surace's bounding box by this amount, only render objects in this box in the subview (-1 for everything)
	float		farPlane;			// Add a far culling plane to the subview camera at the given distance (-1 for none)
	idImage*	backgroundImage;	// Render this cubemap in the background (because so much stuff was culled to avoid H.O.M.)
} subviewInfo_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_MODULATE_ALPHA,
	SVC_INVERSE_MODULATE
} stageVertexColor_t;

struct stageVector_t {
	int							registers[4];
	const sdDeclRenderBinding*	renderBinding;
};
const int MAX_STAGE_VECTORS = 32;

struct stageTexture_t {
	idImage*					image;
	const sdDeclRenderBinding*	renderBinding;
};
const int MAX_STAGE_TEXTURES = 16;

struct stageTextureMatrix_t {
	int							matrix[2][3];
	const sdDeclRenderBinding*	renderBinding_s;
	const sdDeclRenderBinding*	renderBinding_t;
};
const int MAX_STAGE_TEXTUREMATRICES = 3;

struct stageParseData_t {
							stageParseData_t() :
								numVectors( 0 ),
								numTextures( 0 ),
								numTextureMatrices( 0 ) {
								memset( vectors, 0, sizeof( vectors ) );
								memset( textures, 0, sizeof( textures ) );
								memset( textureMatrices, 0, sizeof( textureMatrices ) );
							}

	int						numVectors;
	stageVector_t			vectors[MAX_STAGE_VECTORS];
	int						numTextures;
	stageTexture_t			textures[MAX_STAGE_TEXTURES];
	int						numTextureMatrices;
	stageTextureMatrix_t	textureMatrices[MAX_STAGE_TEXTUREMATRICES];
};

struct materialStage_t {
	int					conditionRegister;	// if registers[conditionRegister] == 0, skip stage
//	stageLighting_t		lighting;			// determines which passes interact with lights
	int					drawStateBits;
//	colorStage_t		color;
	bool				hasAlphaTest;
	int					alphaTestRegister;
	int					specularPowerRegister;
//	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

//	bool				forceDepthFuncEqual;

	cullType_t			cullType;
	float				lineWidth;
	bool				breakpoint;			// There is a breakpoint on the drawing of this stage
//	bool				forceDepth;			// Force z-writing on certain transparent stages
	bool				hasExplicitDepthFunc; // don't autodetect depthfuncs 
	bool				hasExplicitDepthMask; // don't autodetect depthfuncs 

	const sdDeclRenderProgram*	renderProgram;

	int							numVectors;
	stageVector_t*				vectors;
	int							numTextures;
	stageTexture_t*				textures;
	int							numTextureMatrices;
	stageTextureMatrix_t*		textureMatrices;

	// look these up post-parse, the backend needs to know about these in certain cases
	stageVector_t*				colorVector;
	stageTextureMatrix_t*		diffuseTextureMatrix;

	class sdImageSequence*		imgSequence;
	idMegaTexture*				megaTexture;

	bool						updateCurrentRender;
	bool						depthStage;
	int							destinationBuffer; //-1 for normal rendering
};

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_SUBVIEW = -3,	// mirrors, viewscreens, etc
	SS_BAD = -1,
	SS_OPAQUEFIRST,		// opaque
	SS_OPAQUE,			// opaque
	SS_OPAQUENEARER,	// used for materials with expensive shaders, such as the megaTexture
	SS_OPAQUENEAREST,	// used for materials that definitely should be rendered 'last'
	SS_DECAL,			// scorch marks, etc.

	SS_GUI,		// guis

	SS_REFRACTABLE,			// Translucent, but drawn before refraction surfaces
	SS_REFRACTION,			// Stage using refraction screen copy to texture

	SS_FAR_PRE_ATMOS,		// Translucent materials drawn before the atmosphere, this is usally not what we want
	SS_MEDIUM_PRE_ATMOS,	// as translucent mats don't fill the z-buffer and thus get fogged like what's behind them
	SS_CLOSE_PRE_ATMOS,		// instead of for their own depth.

	//
	//	Anything whith the following sort orders will need to be fogged "manually" (i.e. by setting up the shader properly)
	//
	SS_ATMOSPHERE,			// Not really used; just as a new phase
	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_LAST					// needs to be last
} materialSort_t;

typedef enum {
	LS_AMBIENTOCCLUSION = -3,	// Drawn just after ambient light
	LS_REFRACTABLE = -2,		// Drawn before refraction and non-refracting non-light dependent stages 
	LS_BAD = -1,				// For compatibility with normal sorts
	LS_NORMAL,					// Normal interaction stages
	LS_EFFECT,					// Drawn after interaction lights
	LS_LAST
} lightSort_t;

// these don't effect per-material storage, so they can be very large
const int MAX_SHADER_STAGES			= 256;
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
	MF_NOAMBIENT					= BIT(7),	// No cubemap ambient light on this shader
	MF_NOATMOSPHERE					= BIT(7),	// No extinction/inscattering on this shader
	MF_FORCETANGENTS				= BIT(8),	// Force tangents and normal calculation
	MF_CLUSTERTRANSFORM				= BIT(9),	// the vertex shader will do the final offseting for the cluster model
	MF_FORCEATMOSPHERE				= BIT(10),	// No extinction/inscattering on this shader
	MF_FLIPBACKSIDENORMALS			= BIT(11),	// hack to make foliage light better, for twosided materials give one side flipped normals
	MF_FULLSCREENPOSTPROCESS		= BIT(12),	// Don't modify depth and always pass the depth test for post processing materials (using SS_POSTPROCESS sort)
	MF_NOHWSKINNING					= BIT(13),	// Don't use hardware skinning, use the SIMD code instead
	MF_OCCLUSION_OCCLUDE			= BIT(14),
	MF_OCCLUSION_QUERY				= BIT(15),
	MF_NOSURFACEMERGE				= BIT(16),	// Don't merge MD5 mesh surface which have this set
	MF_SHADOWMAPPED					= BIT(17),	// This light uses shadow maps
	MF_VERTEXPOSITIONONLY			= BIT(18),	// Ignore UV, color, etc data from source models when loaded
	MF_ONLYATMOSPHEREINTERACTION	= BIT(19),
	MF_NOATMOSPHEREINTERACTION		= BIT(20),
	MF_ADVERT						= BIT(21),
	MF_FORCESOURCENORMALS			= BIT(22),
	MF_BAKEDINATMOSLIGHTCOL			= BIT(23),
	MF_TRANSLUCENTINTERACTION		= BIT(24),
	MF_RECEIVESLIGHTINGONBACKSIDES	= BIT(25),
	MF_LOWRANGEUVCOMPRESS			= BIT(26),
	MF_UPDATECURRENTRENDER			= BIT(27),
	MF_SHADOWSCASTONLYFROMSTATICOBJECTS = BIT(28),
	MF_HASMEGA						= BIT(29),
	MF_NOIMPLICITSTAGES				= BIT(30),
} materialFlags_t;

typedef enum {
	BP_DEPTHFILL				= BIT(0),
	BP_AMBIENT					= BIT(1),
	BP_ATMOSPHERE				= BIT(2),
	BP_INTERACTION				= BIT(3),
	BP_SHADOWBUFFER				= BIT(4),
} breakpointFlags_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_WALKERCLIP			= BIT(4),	// solid to walkers
	CONTENTS_MOVEABLECLIP		= BIT(5),	// solid to moveable entities
	CONTENTS_IKCLIP				= BIT(6),	// solid to IK
	CONTENTS_SLIDEMOVER			= BIT(7),	// contains players & vehicles that move like players (with a SlideMove)
	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_VEHICLECLIP		= BIT(13),	// solid to vehicles
	CONTENTS_EXPLOSIONSOLID		= BIT(14),	// used for selection traces
	CONTENTS_MONSTER			= BIT(15),	// monster physics
	CONTENTS_FORCEFIELD			= BIT(16),	// these can be hit by projectiles but other things can move through them
	CONTENTS_SHADOWCOLLISION	= BIT(17),
	CONTENTS_CROSSHAIRSOLID		= BIT(18),
	CONTENTS_FLYERHIVECLIP		= BIT(19),	// flyer hive only

	// AAS
	CONTENTS_AAS_SOLID_PLAYER	= BIT(24),	//
	CONTENTS_AAS_SOLID_VEHICLE	= BIT(25),	//
	CONTENTS_AAS_CLUSTER_PORTAL	= BIT(26),	//
	CONTENTS_AAS_OBSTACLE		= BIT(27),	//

	// contents used by utils
	CONTENTS_AREAPORTAL			= BIT(28),	// portal separating renderer areas
	CONTENTS_NOCSG				= BIT(29),	// don't cut this brush with CSG operations in the editor
	CONTENTS_OCCLUDER			= BIT(30),	// occluder brushes for outdoor occlusion
} contentsFlags_t;

// surface flags
typedef enum {
	SURF_NODAMAGE				= BIT(0),	// never give falling damage
	SURF_SLICK					= BIT(1),	// affects game physics
	SURF_COLLISION				= BIT(2),	// collision surface
	SURF_LADDER					= BIT(3),	// player can climb up this surface
	SURF_NOIMPACT				= BIT(4),	// don't make missile explosions
	SURF_NOSTEPS				= BIT(5),	// no footstep sounds
	SURF_DISCRETE				= BIT(6),	// not clipped or merged by utilities
	SURF_NOFRAGMENT				= BIT(7),	// dmap won't cut surface at each bsp boundary
	SURF_NULLNORMAL				= BIT(8),	// renderbump will draw this surface as 0x80 0x80 0x80, which
											// won't collect light from any angle
	SURF_NONSOLID				= BIT(9),
	SURF_NOPLANT				= BIT(10),	// can't plant landmines, HE charges etc here
	SURF_NOAREAS				= BIT(11),	// don't create AAS areas on this surface
	
	SURF_SHADOWCOLLISION		= BIT(12),	// shadow collision surface, used only when CONTENTS_SHADOWCOLLISION is specified
} surfaceFlags_t;

// portal flags
typedef enum {
	PORTAL_VIS,						// block visibility, splits surfaces
	PORTAL_OUTSIDE,					// defines a border between an outside and an inside area
	PORTAL_BLOCKAMBIENT,			// defines ambient light sectors
	PORTAL_AUDIO,					// defines sound sectors
	PORTAL_PLAYZONE,				// defines playzone areas
	PORTAL_OCCTEST,					// enables occlusion testing on portal
	NUM_PORTAL_FLAGS
} portalFlags_t;

typedef struct {
	idStr		name;						// String can contain any ascii text (more like a description or whatever)
	enum { T_FLOAT, T_COLOR } parmType;
	union {
		struct {
			float		defaultVal;			// Default value
			float		min;				// Minimum value
			float		max;				// Maximum value
		} floatParm;
		struct {
			float		defaultVal[3];
		} colorParm;
	};
} sdParameterInfo;

class sdDeclSurfaceType;
class sdDeclSurfaceTypeMap;
class sdSurfaceTypeMap;

//TODO: Move this into decllib
class idMaterial : public idDecl {
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 );
	virtual void		FreeData( void );
	virtual void		Print( void ) const;

	static void			CacheFromDict( const idDict& dict );

	void				ReloadImages( bool force ) const;

						// returns number of stages this material contains
	const int			GetNumStages( void ) const { return numStages; }

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

						// 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 ); }

						// 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 ); }

						// 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 ); }

	bool				ShadowsCastOnlyFromStaticObjects( void ) const { return TestMaterialFlag( MF_SHADOWSCASTONLYFROMSTATICOBJECTS ); }

						// 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|MF_RECEIVESLIGHTINGONBACKSIDES) ) != 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; }

						// This surface has a different material on the backside
	const idMaterial *	GetBackSideMaterial( void ) const { return backSideMaterial; }

#if SD_SUPPORT_UNSMOOTHEDTANGENTS
						// 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; }
#endif // SD_SUPPORT_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() ); }

						// 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 || 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; }

						// Some materials don't receive lighting, but still require full normals (and sometimes tangents)
						// to be calculated for per vertex/fragment effects. This flag makes sure that the normals and
						// tangents are generated at all times.
	bool				ForceTangentsCalculation( void ) const { return ( materialFlags & (MF_FORCETANGENTS) ) != 0; }

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

						// lightMaterial 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; }

						// 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 && !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 || blendLight; }

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

	// returns true if the material should use static occlusion (i.e. it occludes other objects and is never occlusion culled itself)
	bool				IsOccluder( void ) const { return TestMaterialFlag( MF_OCCLUSION_OCCLUDE ); }
	bool				UseOcclusionQuery( void ) const { return TestMaterialFlag( MF_OCCLUSION_QUERY ); }

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

						// 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; }

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

						// get sort order
	const float			GetSort( void ) const { return sort; }

						// 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; }

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

	float				GetEditorAlpha( void ) const { return editorAlpha; }

	int					GetEntityGui( void ) const { return entityGui; }

						// get portal flags
	const int			GetPortalFlags() const { return portalFlags; }

	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; }

	void				SetPolygonOffset( float po ) { polygonOffset = po; }

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

	const class sdDeclSurfaceType*		GetSurfaceType( void ) const { return surfaceTypeDecl; }
	const class sdDeclSurfaceTypeMap*	GetSurfaceTypeMapDecl( void ) const { return surfaceTypeMapDecl; }
	const class sdSurfaceTypeMap*		GetSurfaceTypeMap( void ) const { return surfaceTypeMap; }
	const idVec3&		GetSurfaceColor( void ) const { return surfaceColor; }

	ID_INLINE int		GetGpuSpec( void ) const { return gpuSpec; }

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

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

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

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

						// 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, idSoundEmitter *soundEmitter = NULL, int numManualLights = 0 ) const;

						// 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 float shaderParms[MAX_ENTITY_SHADER_PARMS], const struct viewDef_s *view ) const;
	void					SetLodDistance( float distance ) const;
	const subviewInfo_t&	GetSubviewInfo() const { return subviewInfo; }
	const sdParameterInfo&	GetParameterInfo( int index ) const { return parameterInfo[index]; } //For visual shader tweaking tools	
	unsigned int			GetBreakpoints() const { return breakpointFlags; }

	const float			GetSlopTexCoordMod() const { return slopTexCoordMod; }

						// evaluates and sets render bindings
	static void			SetRenderBindings( const materialStage_t* stage, const float* materialRegisters, float texCoordScale );

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

						// Purges any partial loadable images
	void				PurgePartialLoadableImages( void );

						// Schedules loading of any partial loadable images
	void				LoadPartialLoadableImages( bool blocking = false );

	bool				IsFinishedPartialLoading( void ) const;

private:
	// parse the entire material
	void				CommonInit();
	void				ParseMaterial( idParser &src );
	bool				MatchToken( idParser &src, const char *match );
	void				ParseSort( idParser &src );
	void				ParseBlend( idParser &src, materialStage_t *stage );
	void				ParseFillMode( idParser &src, materialStage_t *stage );
	void				ParseCullFace( idParser &src, materialStage_t *stage );
	void				ParseStage( idParser &src );
	void				ParseDeform( idParser &src );
	void				ParseDecalInfo( idParser &src );
	bool				CheckSurfaceParm( idToken *token );
	bool				CheckPortalParm( idToken *token );
	int					GetExpressionConstant( float f );
	int					GetExpressionTemporary( void );
	expOp_t	*			GetExpressionOp( void );
	int					EmitOp( int a, int b, expOpType_t opType );
	int					ParseEmitOp( idParser &src, int a, expOpType_t opType, int priority );
	int					ParseTerm( idParser &src );
	int					ParseExpressionPriority( idParser &src, int priority );
	int					ParseExpression( idParser &src );
	bool				ParseConstantCVarExpression( idParser& src, bool& result );
	void				ClearStage( materialStage_t* ms );
	int					NameToSrcBlendMode( const idStr &name );
	int					NameToDstBlendMode( const idStr &name );
	void				MultiplyTextureMatrix( stageTextureMatrix_t* stm, int registers[2][3], const sdDeclRenderBinding* matrix_s, const sdDeclRenderBinding* matrix_t );	// FIXME: for some reason the const is bad for gcc and Mac
	bool				ParseTextureMatrixKey( idToken& key, idParser& src, stageTextureMatrix_t& stm, const sdDeclRenderBinding* matrix_s, const sdDeclRenderBinding* matrix_t );
	bool				AddImplicitStages();
	void				CheckForConstantRegisters();

	void				CompleteStage( materialStage_t* ms, stageParseData_t& spd, const sdDeclRenderBinding** defaults, const int numDefaults );
	void				CompleteInterationStage( materialStage_t* ms, stageParseData_t& spd );
	void				FinishStage( materialStage_t* ms, stageParseData_t& spd );

	static void			SetTextureMatrix( const stageTextureMatrix_t* textureMatrix, const float* materialRegisters, idVec4 matrix[2] );

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

	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
	int					portalFlags;		// portal flags
	mutable int			materialFlags;		// material flags

	const sdDeclSurfaceType*	surfaceTypeDecl;
	const sdDeclSurfaceTypeMap*	surfaceTypeMapDecl;
	const sdSurfaceTypeMap*		surfaceTypeMap;
	idVec3				surfaceColor;

	decalInfo_t			decalInfo;


	int					gpuSpec;
	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

	materialCoverage_t	coverage;
	cullType_t			cullType;			// CT_FRONT_SIDED, CT_BACK_SIDED, or CT_TWO_SIDED
	bool				shouldCreateBackSides;

	bool				fogLight;
	bool				blendLight;
#if SD_SUPPORT_UNSMOOTHEDTANGENTS
	bool				unsmoothedTangents;
#endif // SD_SUPPORT_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
	mutable float		lastFloatTime;
	mutable int			atmosphereFrame;
	bool				timeBasedRegisters;

	int					numStages;
	int					numAmbientStages;

	materialStage_t *	stages;

	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				doLodDistance;		// images will be distance lodded on this shader			
	subviewInfo_t		subviewInfo;
	sdParameterInfo		parameterInfo[MAX_ENTITY_SHADER_PARMS];		// Names of the shader params for visual tweaking tools
	unsigned int		breakpointFlags;

	float				slopTexCoordMod;

	const idMaterial	*backSideMaterial;

	struct mtrParsingData_s	*pd;			// only used during parsing

public:
	static int			currentAtmosphereFrame;

};

typedef idList<const idMaterial *> idMatList;

#endif /* !__MATERIAL_H__ */