hello world

neo/renderer/Material.h

@@ -0,0 +1,691 @@
+/*
+===========================================================================
+
+Doom 3 GPL Source Code
+Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company. 
+
+This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).  
+
+Doom 3 Source Code is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Doom 3 Source Code is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with Doom 3 Source Code.  If not, see <http://www.gnu.org/licenses/>.
+
+In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code.  If not, please request a copy in writing from id Software at the address below.
+
+If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
+
+===========================================================================
+*/
+
+#ifndef __MATERIAL_H__
+#define __MATERIAL_H__
+
+/*
+===============================================================================
+
+	Material
+
+===============================================================================
+*/
+
+class idImage;
+class idCinematic;
+class idUserInterface;
+class idMegaTexture;
+
+// moved from image.h for default parm
+typedef enum {
+	TF_LINEAR,
+	TF_NEAREST,
+	TF_DEFAULT				// use the user-specified r_textureFilter
+} textureFilter_t;
+
+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
+} textureRepeat_t;
+
+typedef struct {
+	int		stayTime;		// msec for no change
+	int		fadeTime;		// msec to fade vertex colors over
+	float	start[4];		// vertex color at spawn (possibly out of 0.0 - 1.0 range, will clamp after calc)
+	float	end[4];			// 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_EXPAND,
+	DFRM_MOVE,
+	DFRM_EYEBALL,
+	DFRM_PARTICLE,
+	DFRM_PARTICLE2,
+	DFRM_TURB
+} deform_t;
+
+typedef enum {
+	DI_STATIC,
+	DI_SCRATCH,		// video, screen wipe, etc
+	DI_CUBE_RENDER,
+	DI_MIRROR_RENDER,
+	DI_XRAY_RENDER,
+	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
+} 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_NUM_PREDEFINED
+} expRegister_t;
+
+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
+	TG_SCREEN2,
+	TG_GLASSWARP
+} 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;
+static const int	MAX_VERTEX_PARMS = 4;
+
+typedef struct {
+	int					vertexProgram;
+	int					numVertexParms;
+	int					vertexParms[MAX_VERTEX_PARMS][4];	// evaluated register indexes
+
+	int					fragmentProgram;
+	int					numFragmentProgramImages;
+	idImage *			fragmentProgramImages[MAX_FRAGMENT_IMAGES];
+
+	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;
+	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
+} 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_SUBVIEW = -3,	// mirrors, viewscreens, etc
+	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
+} 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
+} 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
+
+	// 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_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
+} surfaceFlags_t;
+
+class idSoundEmitter;
+
+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;
+
+	//BSM Nerve: Added for material editor
+	bool				Save( const char *fileName = NULL );
+
+						// 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;
+
+						// 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; }
+
+	//------------------------------------------------------------------
+	// 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; }
+
+						// 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 ) 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;
+
+	bool				SuppressInSubview() const				{ return suppressInSubview; };
+	bool				IsPortalSky() const						{ return portalSky; };
+	void				AddReference();
+
+private:
+	// parse the entire material
+	void				CommonInit();
+	void				ParseMaterial( idLexer &src );
+	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 );
+	void				ParseFragmentMap( idLexer &src, newShaderStage_t *newStage );
+	void				ParseStage( idLexer &src, const textureRepeat_t trpDefault = TR_REPEAT );
+	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();
+	void				AddImplicitStages( const textureRepeat_t trpDefault = TR_REPEAT );
+	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
+
+	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;
+
+#endif /* !__MATERIAL_H__ */