blendo
/
quadrilateralcowboy
mirror of https://github.com/blendogames/quadrilateralcowboy.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
quadrilateralcowboy/renderer/Material.h

692 lines
25 KiB
C++
Raw Blame History

/*
===========================================================================
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__ */
Reference in New Issue View Git Blame Copy Permalink