Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

2373 lines
63 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=====================================================================================//
#include "materialsystem/imesh.h"
#include "materialsystem/imaterialsystemhardwareconfig.h"
#include "materialsystem/imorph.h"
#include "materialsystem/imaterialsystemstub.h"
#include "materialsystem/imaterial.h"
#include "materialsystem/itexture.h"
#include "materialsystem/imaterialvar.h"
#include "bitmap/imageformat.h"
#include "mathlib/vmatrix.h"
#include "utlvector.h"
// GR
#include "imaterialinternal.h"
#include "materialsystem/materialsystem_config.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// ---------------------------------------------------------------------------------------- //
// IMaterialSystem and IMesh stub classes.
// ---------------------------------------------------------------------------------------- //
static unsigned short g_DummyIndices[6];
class CDummyMesh : public IMesh
{
public:
// Locks/ unlocks the mesh, providing space for nVertexCount and nIndexCount.
// nIndexCount of -1 means don't lock the index buffer...
virtual void LockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc )
{
Lock( nVertexCount, false, *static_cast< VertexDesc_t* >( &desc ) );
Lock( nIndexCount, false, *static_cast< IndexDesc_t* >( &desc ) );
}
virtual void UnlockMesh( int nVertexCount, int nIndexCount, MeshDesc_t& desc )
{
}
virtual void ModifyBeginEx( bool bReadOnly, int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc )
{
ModifyBegin( bReadOnly, nFirstIndex, nIndexCount, *static_cast< IndexDesc_t* >( &desc ) );
}
virtual void ModifyBegin( int nFirstVertex, int nVertexCount, int nFirstIndex, int nIndexCount, MeshDesc_t& desc )
{
ModifyBegin( false, nFirstIndex, nIndexCount, *static_cast< IndexDesc_t* >( &desc ) );
}
virtual void ModifyEnd( MeshDesc_t &desc )
{
}
// FIXME: Make this work! Unsupported methods of IIndexBuffer
virtual bool Lock( int nMaxIndexCount, bool bAppend, IndexDesc_t& desc )
{
desc.m_pIndices = g_DummyIndices;
desc.m_nIndexSize = 0;
desc.m_nFirstIndex = 0;
desc.m_nOffset = 0;
return true;
}
virtual void Unlock( int nWrittenIndexCount, IndexDesc_t& desc ) {}
virtual void ModifyBegin( bool bReadOnly, int nFirstIndex, int nIndexCount, IndexDesc_t& desc )
{
desc.m_pIndices = g_DummyIndices;
desc.m_nIndexSize = 0;
desc.m_nFirstIndex = 0;
desc.m_nOffset = 0;
}
virtual void ModifyEnd( IndexDesc_t &desc ) {}
virtual void Spew( int nIndexCount, const IndexDesc_t & desc ) {}
virtual void ValidateData( int nIndexCount, const IndexDesc_t &desc ) {}
virtual bool IsDynamic() const
{
return false;
}
virtual void BeginCastBuffer( MaterialIndexFormat_t format ) {}
virtual void BeginCastBuffer( VertexFormat_t format ) {}
virtual void EndCastBuffer( ) {}
// Returns the number of vertices that can still be written into the buffer
virtual int GetRoomRemaining() const { return 0; }
virtual int IndexCount() const
{
return 0;
}
// returns the # of vertices (static meshes only)
virtual int VertexCount() const
{
return 0;
}
// returns the vertex format
virtual bool Lock( int nVertexCount, bool bAppend, VertexDesc_t &desc )
{
static float dummyFloat[32];
static unsigned char dummyChar[32];
memset( &desc, 0, sizeof( desc ) );
// Pointers to our current vertex data
desc.m_pPosition = dummyFloat;
desc.m_pBoneWeight = dummyFloat;
#ifdef NEW_SKINNING
desc.m_pBoneMatrixIndex = dummyFloat;
#else
desc.m_pBoneMatrixIndex = dummyChar;
#endif
desc.m_pNormal = dummyFloat;
desc.m_pColor = dummyChar;
desc.m_pSpecular = dummyChar;
for( int i = 0; i < VERTEX_MAX_TEXTURE_COORDINATES; i++ )
{
desc.m_pTexCoord[i] = dummyFloat;
}
desc.m_pTangentS = dummyFloat;
desc.m_pTangentT = dummyFloat;
desc.m_pWrinkle = dummyFloat;
// user data
desc.m_pUserData = dummyFloat;
desc.m_nFirstVertex = 0;
desc.m_nOffset = 0;
return true;
}
virtual void Unlock( int nVertexCount, VertexDesc_t &desc ) {}
virtual void Spew( int nVertexCount, const VertexDesc_t &desc ) {}
virtual void ValidateData( int nVertexCount, const VertexDesc_t & desc ) {}
// Sets/gets the primitive type
virtual void SetPrimitiveType( MaterialPrimitiveType_t type )
{
}
// Draws the mesh
virtual void Draw( int nFirstIndex = -1, int nIndexCount = 0 )
{
}
virtual void SetColorMesh( IMesh *pColorMesh, int nVertexOffset )
{
}
virtual void SetFlexMesh( IMesh *pMesh, int nVertexOffset )
{
}
virtual void DisableFlexMesh( )
{
}
// Draw a list of (lists of) primitives. Batching your lists together that use
// the same lightmap, material, vertex and index buffers with multipass shaders
// can drastically reduce state-switching overhead.
// NOTE: this only works with STATIC meshes.
virtual void Draw( CPrimList *pLists, int nLists )
{
}
// Copy verts and/or indices to a mesh builder. This only works for temp meshes!
virtual void CopyToMeshBuilder(
int iStartVert, // Which vertices to copy.
int nVerts,
int iStartIndex, // Which indices to copy.
int nIndices,
int indexOffset, // This is added to each index.
CMeshBuilder &builder )
{
}
// Spews the mesh data
virtual void Spew( int nVertexCount, int nIndexCount, const MeshDesc_t& desc )
{
}
// Call this in debug mode to make sure our data is good.
virtual void ValidateData( int nVertexCount, int nIndexCount, const MeshDesc_t& desc )
{
}
virtual void MarkAsDrawn() {}
virtual unsigned ComputeMemoryUsed() { return 0; }
virtual VertexFormat_t GetVertexFormat() const
{
return VERTEX_POSITION;
}
virtual MaterialIndexFormat_t IndexFormat() const
{
return MATERIAL_INDEX_FORMAT_16BIT;
}
virtual IMesh *GetMesh()
{
return this;
}
};
// We allocate this dynamically because it uses a bunch of memory and we don't want to
// waste the memory unless we need to.
CDummyMesh *g_pDummyMesh = NULL;
CDummyMesh* GetDummyMesh()
{
if ( !g_pDummyMesh )
{
g_pDummyMesh = new CDummyMesh;
}
return g_pDummyMesh;
}
// ---------------------------------------------------------------------------------------- //
// ITexture dummy implementation.
// ---------------------------------------------------------------------------------------- //
class CDummyTexture : public ITexture
{
public:
// Various texture polling methods
virtual const char *GetName( void ) const { return "DummyTexture"; }
virtual int GetMappingWidth() const { return 512; }
virtual int GetMappingHeight() const { return 512; }
virtual int GetActualWidth() const { return 512; }
virtual int GetActualHeight() const { return 512; }
virtual int GetNumAnimationFrames() const { return 0; }
virtual bool IsTranslucent() const { return false; }
virtual bool IsMipmapped() const { return false; }
virtual void GetLowResColorSample( float s, float t, float *color ) const {}
// Gets texture resource data of the specified type.
// Params:
// eDataType type of resource to retrieve.
// pnumBytes on return is the number of bytes available in the read-only data buffer or is undefined
// Returns:
// pointer to the resource data, or NULL
virtual void *GetResourceData( uint32 eDataType, size_t *pNumBytes ) const
{
return NULL;
}
// Methods associated with reference count
virtual void IncrementReferenceCount( void ) {}
virtual void DecrementReferenceCount( void ) {}
// Used to modify the texture bits (procedural textures only)
virtual void SetTextureRegenerator( ITextureRegenerator *pTextureRegen ) {}
// Reconstruct the texture bits in HW memory
// If rect is not specified, reconstruct all bits, otherwise just
// reconstruct a subrect.
virtual void Download( Rect_t *pRect = 0, int nAdditionalCreationFlags = 0 ) {}
// Uses for stats. . .get the approximate size of the texture in it's current format.
virtual int GetApproximateVidMemBytes( void ) const { return 64; }
virtual bool IsError() const { return false; }
virtual ITexture *GetEmbeddedTexture( int nIndex ) { return NULL; }
// For volume textures
virtual bool IsVolumeTexture() const { return false; }
virtual int GetMappingDepth() const { return 1; }
virtual int GetActualDepth() const { return 1; }
virtual ImageFormat GetImageFormat() const { return IMAGE_FORMAT_RGBA8888; }
virtual NormalDecodeMode_t GetNormalDecodeMode() const { return NORMAL_DECODE_NONE; }
// Various information about the texture
virtual bool IsRenderTarget() const { return false; }
virtual bool IsCubeMap() const { return false; }
virtual bool IsNormalMap() const { return false; }
virtual bool IsProcedural() const { return false; }
virtual void DeleteIfUnreferenced() {}
virtual void SwapContents( ITexture *pOther ) {}
virtual unsigned int GetFlags( void ) const { return 0; }
virtual void ForceLODOverride( int iNumLodsOverrideUpOrDown ) { NULL; }
#if defined( _X360 )
virtual bool ClearTexture( int r, int g, int b, int a ) { return true; }
virtual bool CreateRenderTargetSurface( int width, int height, ImageFormat format, bool bSameAsTexture ) { return true; }
#endif
// Save texture to a file.
virtual bool SaveToFile( const char *fileName ) { return false; }
void CopyToStagingTexture( ITexture* pDstTex ) {}
virtual void SetErrorTexture( bool bIsErrorTexture ) { }
};
CDummyTexture g_DummyTexture;
// ---------------------------------------------------------------------------------------- //
// Dummy implementation of IMaterialVar.
// ---------------------------------------------------------------------------------------- //
static VMatrix g_DummyMatrix( 1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1 );
class CDummyMaterialVar : public IMaterialVar
{
public:
virtual char const * GetName( void ) const { return "DummyMaterialVar"; }
virtual MaterialVarSym_t GetNameAsSymbol() const { return 0; }
virtual void SetFloatValue( float val ) {}
virtual float GetFloatValueInternal( void ) const { return 1; }
virtual void SetIntValue( int val ) {}
virtual int GetIntValueInternal( void ) const { return 1; }
virtual void SetStringValue( char const *val ) {}
virtual char const * GetStringValue( void ) const { return ""; }
// Use FourCC values to pass app-defined data structures between
// the proxy and the shader. The shader should ignore the data if
// its FourCC type not correct.
virtual void SetFourCCValue( FourCC type, void *pData ) {}
virtual void GetFourCCValue( FourCC *type, void **ppData ) {}
// Vec (dim 2-4)
virtual void SetVecValue( float const* val, int numcomps ) {}
virtual void SetVecValue( float x, float y ) {}
virtual void SetVecValue( float x, float y, float z ) {}
virtual void SetVecValue( float x, float y, float z, float w ) {}
virtual void SetVecComponentValue( float fVal, int nComponent ) {}
virtual void GetVecValueInternal( float *val, int numcomps ) const
{
for ( int i=0; i < numcomps; i++ )
val[i] = 1;
}
virtual void GetLinearVecValue( float *val, int numcomps ) const
{
for ( int i=0; i < numcomps; i++ )
val[i] = 1;
}
virtual float const* GetVecValueInternal( ) const
{
static float val[4] = {1,1,1,1};
return val;
}
virtual int VectorSizeInternal() const
{
return 3;
}
// revisit: is this a good interface for textures?
virtual ITexture * GetTextureValue( void )
{
return &g_DummyTexture;
}
virtual void SetTextureValue( ITexture * ) {}
virtual operator ITexture*()
{
return GetTextureValue();
}
virtual IMaterial * GetMaterialValue( void )
{
extern IMaterial *g_pDummyMaterial;
return g_pDummyMaterial;
}
virtual void SetMaterialValue( IMaterial * ) {}
virtual MaterialVarType_t GetType() const { return MATERIAL_VAR_TYPE_INT; }
virtual bool IsDefined() const { return true; }
virtual void SetUndefined() {}
// Matrix
virtual void SetMatrixValue( VMatrix const& matrix ) {}
virtual const VMatrix &GetMatrixValue( )
{
return g_DummyMatrix;
}
virtual bool MatrixIsIdentity() const
{
return false;
}
// Copy....
virtual void CopyFrom( IMaterialVar *pMaterialVar ) {}
virtual void SetValueAutodetectType( char const *val ) {}
virtual IMaterial * GetOwningMaterial()
{
extern IMaterial *g_pDummyMaterial;
return g_pDummyMaterial;
}
};
CDummyMaterialVar g_DummyMaterialVar;
// ---------------------------------------------------------------------------------------- //
// Dummy implementation of IMaterialSystemHardwareConfig
// ---------------------------------------------------------------------------------------- //
class CDummyHardwareConfig : public IMaterialSystemHardwareConfig
{
public:
virtual bool HasDestAlphaBuffer() const { return false; }
virtual bool HasStencilBuffer() const { return false; }
virtual int StencilBufferBits() const { return 0; }
virtual int GetFrameBufferColorDepth() const { return 0; }
virtual int GetSamplerCount() const { return 0; }
virtual bool HasSetDeviceGammaRamp() const { return false; }
virtual bool SupportsCompressedTextures() const { return false; }
virtual VertexCompressionType_t SupportsCompressedVertices() const { return VERTEX_COMPRESSION_NONE; }
virtual bool SupportsVertexAndPixelShaders() const { return false; }
virtual bool SupportsPixelShaders_1_4() const { return false; }
virtual bool SupportsPixelShaders_2_0() const { return false; }
virtual bool SupportsPixelShaders_2_b() const { return false; }
virtual bool ActuallySupportsPixelShaders_2_b() const { return false; }
virtual bool SupportsStaticControlFlow() const { return false; }
virtual bool SupportsVertexShaders_2_0() const { return false; }
virtual bool SupportsShaderModel_3_0() const { return false; }
virtual int MaximumAnisotropicLevel() const { return 1; }
virtual int MaxTextureWidth() const { return 0; }
virtual int MaxTextureHeight() const { return 0; }
virtual int MaxTextureDepth() const { return 0; }
virtual int TextureMemorySize() const { return 0; }
virtual bool SupportsOverbright() const { return false; }
virtual bool SupportsCubeMaps() const { return false; }
virtual bool SupportsMipmappedCubemaps() const { return false; }
virtual bool SupportsNonPow2Textures() const { return false; }
// The number of texture stages represents the number of computations
// we can do in the pixel pipeline, it is *not* related to the
// simultaneous number of textures we can use
virtual int GetTextureStageCount() const { return 0; }
virtual int NumVertexShaderConstants() const { return 0; }
virtual int NumBooleanVertexShaderConstants() const { return 0; }
virtual int NumIntegerVertexShaderConstants() const { return 0; }
virtual int NumPixelShaderConstants() const { return 0; }
virtual int MaxNumLights() const { return 0; }
virtual bool SupportsHardwareLighting() const { return false; }
virtual int MaxBlendMatrices() const { return 0; }
virtual int MaxBlendMatrixIndices() const { return 0; }
virtual int MaxTextureAspectRatio() const { return 0; }
virtual int MaxVertexShaderBlendMatrices() const { return 0; }
virtual int MaxUserClipPlanes() const { return 0; }
virtual bool UseFastClipping() const { return false; }
virtual bool UseFastZReject() const { return false; }
virtual bool PreferReducedFillrate() const { return false; }
// This here should be the major item looked at when checking for compat
// from anywhere other than the material system shaders
virtual int GetDXSupportLevel() const { return 90; }
virtual const char *GetShaderDLLName() const { return NULL; }
virtual bool ReadPixelsFromFrontBuffer() const { return false; }
// Are dx dynamic textures preferred?
virtual bool PreferDynamicTextures() const { return false; }
virtual bool SupportsHDR() const { return false; }
virtual HDRType_t GetHDRType() const { return HDR_TYPE_NONE; }
virtual HDRType_t GetHardwareHDRType() const { return HDR_TYPE_NONE; }
virtual bool HasProjectedBumpEnv() const { return false; }
virtual bool SupportsSpheremapping() const { return false; }
virtual bool NeedsAAClamp() const { return false; }
virtual bool HasFastZReject() const { return false; }
virtual bool NeedsATICentroidHack() const { return false; }
virtual bool SupportsColorOnSecondStream() const{ return false; }
virtual bool SupportsStaticPlusDynamicLighting() const{ return false; }
virtual bool SupportsStreamOffset() const { return false; }
virtual int GetMaxDXSupportLevel() const { return 90; }
virtual bool SpecifiesFogColorInLinearSpace() const { return false; }
virtual bool SupportsSRGB() const { return false; }
virtual bool FakeSRGBWrite() const { return false; }
virtual bool CanDoSRGBReadFromRTs() const { return true; }
virtual bool SupportsGLMixedSizeTargets() const { return false; }
virtual bool IsAAEnabled() const { return false; }
virtual int GetVertexTextureCount() const { return 0; }
virtual int GetMaxVertexTextureDimension() const { return 0; }
virtual int MaxViewports() const { return 1; }
virtual void OverrideStreamOffsetSupport( bool bOverrideEnabled, bool bEnableSupport ) {}
virtual int GetShadowFilterMode() const { return 0; }
virtual int NeedsShaderSRGBConversion() const { return 0; }
bool UsesSRGBCorrectBlending() const { return false; }
virtual bool HasFastVertexTextures() const { return false; }
virtual int MaxHWMorphBatchCount() const { return 0; }
virtual bool SupportsHDRMode( HDRType_t nMode ) const { return 0; }
virtual bool IsDX10Card() const { return 0; }
virtual bool GetHDREnabled( void ) const { return true; }
virtual void SetHDREnabled( bool bEnable ) {}
virtual bool SupportsBorderColor( void ) const { return true; }
virtual bool SupportsFetch4( void ) const { return false; }
virtual bool CanStretchRectFromTextures() const { return false; }
};
CDummyHardwareConfig g_DummyHardwareConfig;
// ---------------------------------------------------------------------------------------- //
// CDummyMaterial.
// ---------------------------------------------------------------------------------------- //
class CDummyMaterial : public IMaterial
{
public:
virtual const char * GetName() const { return "dummy material"; }
virtual const char * GetTextureGroupName() const { return "dummy group"; }
virtual PreviewImageRetVal_t GetPreviewImageProperties( int *width, int *height,
ImageFormat *imageFormat, bool* isTranslucent ) const
{
if ( width )
*width = 4;
if ( height )
*height = 4;
if ( imageFormat )
*imageFormat = IMAGE_FORMAT_RGBA8888;
if ( isTranslucent )
*isTranslucent = false;
return MATERIAL_PREVIEW_IMAGE_OK;
}
virtual PreviewImageRetVal_t GetPreviewImage( unsigned char *data,
int width, int height,
ImageFormat imageFormat ) const
{
return MATERIAL_PREVIEW_IMAGE_OK;
}
//
virtual int GetMappingWidth( )
{
return 512;
}
virtual int GetMappingHeight( )
{
return 512;
}
virtual int GetNumAnimationFrames( )
{
return 0;
}
virtual bool InMaterialPage( void )
{
return false;
}
virtual void GetMaterialOffset( float *pOffset )
{
pOffset[0] = 0.0f;
pOffset[1] = 0.0f;
}
virtual void GetMaterialScale( float *pScale )
{
pScale[0] = 1.0f;
pScale[1] = 1.0f;
}
virtual IMaterial *GetMaterialPage( void )
{
return NULL;
}
virtual IMaterialVar * FindVar( const char *varName, bool *found, bool complain = true )
{
if ( found )
*found = true;
return &g_DummyMaterialVar;
}
virtual IMaterialVar * FindVarFast( const char *varName, unsigned int *pToken )
{
return NULL;
}
virtual void IncrementReferenceCount( void )
{
}
virtual void DecrementReferenceCount( void )
{
}
virtual int GetEnumerationID( void ) const
{
return 0;
}
virtual void GetLowResColorSample( float s, float t, float *color ) const
{
}
virtual void RecomputeStateSnapshots()
{
}
// Are we translucent?
virtual bool IsTranslucent()
{
return false;
}
// Are we alphatested?
virtual bool IsAlphaTested()
{
return false;
}
// Are we vertex lit?
virtual bool IsVertexLit()
{
return false;
}
// Gets the vertex format
virtual VertexFormat_t GetVertexFormat() const
{
return 0;
}
// returns true if this material uses a material proxy
virtual bool HasProxy( void ) const
{
return false;
}
virtual void CallBindProxy( void* ) {}
virtual IMaterial *CheckProxyReplacement( void *proxyData )
{
return this;
}
virtual bool UsesEnvCubemap( void )
{
return false;
}
virtual bool NeedsTangentSpace( void )
{
return false;
}
virtual bool NeedsPowerOfTwoFrameBufferTexture( bool bCheckSpecificToThisFrame )
{
return false;
}
virtual bool NeedsFullFrameBufferTexture( bool bCheckSpecificToThisFrame )
{
return false;
}
virtual bool NeedsSoftwareSkinning( void )
{
return false;
}
// Apply constant color or alpha modulation
virtual void AlphaModulate( float alpha )
{
}
virtual void ColorModulate( float r, float g, float b )
{
}
float GetAlphaModulation( )
{
return 1;
}
void GetColorModulation( float *r, float *g, float *b )
{
*r = *g = *b = 1;
}
// Material Var flags...
virtual void SetMaterialVarFlag( MaterialVarFlags_t flag, bool on )
{
}
virtual bool GetMaterialVarFlag( MaterialVarFlags_t flag ) const
{
return true;
}
// Gets material reflectivity
virtual void GetReflectivity( Vector& reflect )
{
reflect.Init(1,0,0);
}
// Gets material property flags
virtual bool GetPropertyFlag( MaterialPropertyTypes_t type )
{
return true;
}
// Is the material visible from both sides?
virtual bool IsTwoSided()
{
return false;
}
// Sets the shader associated with the material
virtual void SetShader( const char *pShaderName )
{
}
// Can't be const because the material might have to precache itself.
virtual int GetNumPasses( void )
{
return 1;
}
// Can't be const because the material might have to precache itself.
virtual int GetTextureMemoryBytes( void )
{
return 64;
}
// Meant to be used with materials created using CreateMaterial
// It updates the materials to reflect the current values stored in the material vars
virtual void Refresh()
{
}
// GR - returns true is material uses lightmap alpha for blending
virtual bool NeedsLightmapBlendAlpha( void )
{
return false;
}
// returns true if the shader doesn't do lighting itself and requires
// the data that is sent to it to be prelighted
virtual bool NeedsSoftwareLighting( void )
{
return false;
}
// Gets at the shader parameters
virtual int ShaderParamCount() const
{
return 0;
}
virtual IMaterialVar **GetShaderParams( void )
{
return 0;
}
virtual bool IsErrorMaterial() const
{
return false;
}
virtual void SetUseFixedFunctionBakedLighting( bool bEnable )
{
}
virtual MorphFormat_t GetMorphFormat() const
{
return 0;
}
virtual void SetShaderAndParams( KeyValues *pKeyValues )
{
}
virtual const char *GetShaderName() const { return "Wireframe"; }
virtual void DeleteIfUnreferenced() {}
virtual bool IsSpriteCard() { return false; }
virtual void RefreshPreservingMaterialVars() {};
virtual bool WasReloadedFromWhitelist() {return false;}
virtual bool IsPrecached() const {return true;}
};
CDummyMaterial g_DummyMaterial;
IMaterial *g_pDummyMaterial = &g_DummyMaterial;
void* DummyMaterialSystemFactory( const char *pName, int *pReturnCode )
{
if ( stricmp( pName, MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION ) == 0 )
return &g_DummyHardwareConfig;
else
return NULL;
}
// ---------------------------------------------------------------------------------------- //
// Dummy morph
// ---------------------------------------------------------------------------------------- //
class CDummyMorph : public IMorph
{
public:
virtual void Lock( float flFloatToFixedScale ) {}
virtual void AddMorph( const MorphVertexInfo_t &info ) {}
virtual void Unlock( ) {}
virtual void AccumulateMorph( int nWeightCount, const MorphWeight_t* pWeights ) {}
};
// ---------------------------------------------------------------------------------------- //
// CDummyMaterialSystem.
// ---------------------------------------------------------------------------------------- //
class CDummyMaterialSystem : public IMaterialSystemStub, public CRefCounted1<IMatRenderContext, CRefCountServiceNull>
{
private:
IMaterialSystem *m_pRealMaterialSystem;
public:
CDummyMaterialSystem()
{
m_pRealMaterialSystem = 0;
}
virtual void SetRealMaterialSystem( IMaterialSystem *pSys )
{
m_pRealMaterialSystem = pSys;
}
// Call this to initialize the material system
// returns a method to create interfaces in the shader dll
virtual CreateInterfaceFn Init( char const* pShaderDLL,
IMaterialProxyFactory *pMaterialProxyFactory,
CreateInterfaceFn fileSystemFactory,
CreateInterfaceFn cvarFactory )
{
return DummyMaterialSystemFactory;
}
virtual void Shutdown( )
{
}
virtual IMaterialSystemHardwareConfig *GetHardwareConfig( const char *pVersion, int *returnCode )
{
if ( returnCode )
*returnCode = 1;
return &g_DummyHardwareConfig;
}
// Gets the number of adapters...
virtual int GetDisplayAdapterCount() const
{
return 0;
}
// Returns info about each adapter
virtual void GetDisplayAdapterInfo( int adapter, MaterialAdapterInfo_t& info ) const
{
}
// Returns the number of modes
virtual int GetModeCount( int adapter ) const
{
return 0;
}
// Returns mode information..
virtual void GetModeInfo( int adapter, int mode, MaterialVideoMode_t& info ) const
{
}
// Returns the mode info for the current display device
virtual void GetDisplayMode( MaterialVideoMode_t& mode ) const
{
}
// Sets the mode...
virtual bool SetMode( void* hwnd, const MaterialSystem_Config_t &config )
{
return true;
}
// Creates/ destroys a child window
virtual bool AddView( void* hwnd )
{
return false;
}
virtual void RemoveView( void* hwnd )
{
}
// Sets the view
virtual void SetView( void* hwnd )
{
}
// return true if lightmaps need to be redownloaded
// Call this before rendering each frame with the current config
// for the material system.
// Will do whatever is necessary to get the material system into the correct state
// upon configuration change. .doesn't much else otherwise.
virtual bool UpdateConfig( bool forceUpdate )
{
return false;
}
virtual bool OverrideConfig( const MaterialSystem_Config_t &config, bool bForceUpdate )
{
return false;
}
// This is the interface for knowing what materials are available
// is to use the following functions to get a list of materials. The
// material names will have the full path to the material, and that is the
// only way that the directory structure of the materials will be seen through this
// interface.
// NOTE: This is mostly for worldcraft to get a list of materials to put
// in the "texture" browser.in Worldcraft
virtual MaterialHandle_t FirstMaterial() const
{
return 0;
}
// returns InvalidMaterial if there isn't another material.
// WARNING: you must call GetNextMaterial until it returns NULL,
// otherwise there will be a memory leak.
virtual MaterialHandle_t NextMaterial( MaterialHandle_t h ) const
{
return 0;
}
// This is the invalid material
virtual MaterialHandle_t InvalidMaterial() const
{
if ( m_pRealMaterialSystem )
return m_pRealMaterialSystem->InvalidMaterial();
else
return 0;
}
// Returns a particular material
virtual IMaterial* GetMaterial( MaterialHandle_t h ) const
{
if ( m_pRealMaterialSystem )
return m_pRealMaterialSystem->GetMaterial( h );
else
return &g_DummyMaterial;
}
// Find a material by name.
// The name of a material is a full path to
// the vmt file starting from "hl2/materials" (or equivalent) without
// a file extension.
// eg. "dev/dev_bumptest" refers to somethign similar to:
// "d:/hl2/hl2/materials/dev/dev_bumptest.vmt"
virtual IMaterial *FindMaterial( char const* pMaterialName, const char *pTextureGroupName, bool complain = true, const char *pComplainPrefix = NULL )
{
if ( m_pRealMaterialSystem )
return m_pRealMaterialSystem->FindMaterial( pMaterialName, pTextureGroupName, complain, pComplainPrefix );
return &g_DummyMaterial;
}
virtual bool IsMaterialLoaded( char const* pMaterialName )
{
if ( m_pRealMaterialSystem )
return m_pRealMaterialSystem->IsMaterialLoaded( pMaterialName );
return true;
}
virtual IMaterial *FindMaterialEx( char const* pMaterialName, const char *pTextureGroupName, int nContext, bool complain = true, const char *pComplainPrefix = NULL )
{
if ( m_pRealMaterialSystem )
return m_pRealMaterialSystem->FindMaterialEx( pMaterialName, pTextureGroupName, nContext, complain, pComplainPrefix );
return &g_DummyMaterial;
}
virtual IMaterial *FindProceduralMaterial( const char *pMaterialName, const char *pTextureGroupName, KeyValues *pVMTKeyValues )
{
if ( m_pRealMaterialSystem )
return m_pRealMaterialSystem->FindProceduralMaterial( pMaterialName, pTextureGroupName, pVMTKeyValues );
return &g_DummyMaterial;
}
virtual ITexture *FindTexture( char const* pTextureName, const char *pTextureGroupName, bool complain = true, int nAdditionalCreationFlags = 0)
{
if ( m_pRealMaterialSystem )
return m_pRealMaterialSystem->FindTexture( pTextureName, pTextureGroupName, complain, nAdditionalCreationFlags );
return &g_DummyTexture;
}
virtual void SetAsyncTextureLoadCache( FileCacheHandle_t hFileCache )
{
}
virtual void BindLocalCubemap( ITexture *pTexture )
{
}
virtual ITexture *GetLocalCubemap( )
{
return &g_DummyTexture;
}
// pass in an ITexture (that is build with "rendertarget" "1") or
// pass in NULL for the regular backbuffer.
virtual void SetRenderTarget( ITexture *pTexture )
{
}
virtual ITexture * GetRenderTarget( void )
{
return &g_DummyTexture;
}
virtual void SetRenderTargetEx( int nRenderTargetID, ITexture *pTexture )
{
}
virtual ITexture * GetRenderTargetEx( int nRenderTargetID )
{
return &g_DummyTexture;
}
virtual void GetRenderTargetDimensions( int &width, int &height) const
{
width = 256;
height = 256;
}
// Get the total number of materials in the system. These aren't just the used
// materials, but the complete collection.
virtual int GetNumMaterials( ) const
{
return m_pRealMaterialSystem->GetNumMaterials();
}
// Remove any materials from memory that aren't in use as determined
// by the IMaterial's reference count.
virtual void UncacheUnusedMaterials( bool bRecomputeStateSnapshots )
{
if ( m_pRealMaterialSystem )
{
m_pRealMaterialSystem->UncacheUnusedMaterials( bRecomputeStateSnapshots );
}
}
virtual void SuspendTextureStreaming( )
{
if ( m_pRealMaterialSystem )
m_pRealMaterialSystem->SuspendTextureStreaming();
}
virtual void ResumeTextureStreaming( )
{
if ( m_pRealMaterialSystem )
m_pRealMaterialSystem->ResumeTextureStreaming();
}
// uncache all materials. . good for forcing reload of materials.
virtual void UncacheAllMaterials( )
{
if ( m_pRealMaterialSystem )
m_pRealMaterialSystem->UncacheAllMaterials();
}
// Load any materials into memory that are to be used as determined
// by the IMaterial's reference count.
virtual void CacheUsedMaterials( )
{
if ( m_pRealMaterialSystem )
m_pRealMaterialSystem->CacheUsedMaterials( );
}
// Force all textures to be reloaded from disk.
virtual void ReloadTextures( )
{
}
// Allows us to override the depth buffer setting of a material
virtual void OverrideDepthEnable( bool bEnable, bool bEnableValue )
{
}
virtual void OverrideAlphaWriteEnable( bool bOverrideEnable, bool bAlphaWriteEnable )
{
}
virtual void OverrideColorWriteEnable( bool bOverrideEnable, bool bColorWriteEnable )
{
}
//
// lightmap allocation stuff
//
// To allocate lightmaps, sort the whole world by material twice.
// The first time through, call AllocateLightmap for every surface.
// that has a lightmap.
// The second time through, call AllocateWhiteLightmap for every
// surface that expects to use shaders that expect lightmaps.
virtual void BeginLightmapAllocation( )
{
}
// returns the sorting id for this surface
virtual int AllocateLightmap( int width, int height,
int offsetIntoLightmapPage[2],
IMaterial *pMaterial )
{
return 0;
}
// returns a lightmap page ID for this allocation, -1 if none available
virtual int AllocateDynamicLightmap( int lightmapSize[2], int *pOutOffsetIntoPage, int frameID )
{
return -1;
}
// returns the sorting id for this surface
virtual int AllocateWhiteLightmap( IMaterial *pMaterial )
{
return 0;
}
virtual void EndLightmapAllocation( )
{
}
// lightmaps are in linear color space
// lightmapPageID is returned by GetLightmapPageIDForSortID
// lightmapSize and offsetIntoLightmapPage are returned by AllocateLightmap.
// You should never call UpdateLightmap for a lightmap allocated through
// AllocateWhiteLightmap.
virtual void UpdateLightmap( int lightmapPageID, int lightmapSize[2],
int offsetIntoLightmapPage[2],
float *pFloatImage, float *pFloatImageBump1,
float *pFloatImageBump2, float *pFloatImageBump3 )
{
}
// Force the lightmaps updated with UpdateLightmap to be sent to the hardware.
virtual void FlushLightmaps( )
{
}
// fixme: could just be an array of ints for lightmapPageIDs since the material
// for a surface is already known.
virtual int GetNumSortIDs( )
{
return 10;
}
// virtual int GetLightmapPageIDForSortID( int sortID ) = 0;
virtual void GetSortInfo( MaterialSystem_SortInfo_t *pSortInfoArray )
{
}
virtual void BeginFrame( float )
{
}
virtual void EndFrame( )
{
}
virtual bool IsInFrame() const { return false; }
// Bind a material is current for rendering.
virtual void Bind( IMaterial *material, void *proxyData = 0 )
{
}
// Bind a lightmap page current for rendering. You only have to
// do this for materials that require lightmaps.
virtual void BindLightmapPage( int lightmapPageID )
{
}
// inputs are between 0 and 1
virtual void DepthRange( float zNear, float zFar )
{
}
virtual void ClearBuffers( bool bClearColor, bool bClearDepth, bool bClearStencil )
{
}
virtual void ClearBuffersObeyStencil( bool bClearColor, bool bClearDepth )
{
}
virtual void ClearBuffersObeyStencilEx( bool bClearColor, bool bClearAlpha, bool bClearDepth )
{
}
virtual void PerformFullScreenStencilOperation( void )
{
}
// read to a unsigned char rgb image.
virtual void ReadPixels( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat )
{
}
// Read w/ stretch to a host-memory buffer
virtual void ReadPixelsAndStretch( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *pBuffer, ImageFormat dstFormat, int nDstStride )
{
}
// Sets lighting
virtual void SetAmbientLight( float r, float g, float b )
{
}
virtual void SetLight( int lightNum, const LightDesc_t& desc )
{
}
virtual void SetLightingOrigin( Vector vLightingOrigin )
{
}
// The faces of the cube are specified in the same order as cubemap textures
virtual void SetAmbientLightCube( Vector4D cube[6] )
{
}
// Blit the backbuffer to the framebuffer texture
virtual void CopyRenderTargetToTexture( ITexture * )
{
}
virtual void SetFrameBufferCopyTexture( ITexture *pTexture, int textureIndex )
{
}
virtual ITexture * GetFrameBufferCopyTexture( int textureIndex )
{
return &g_DummyTexture;
}
// do we need this?
virtual void Flush( bool flushHardware = false )
{
}
//
// end vertex array api
//
//
// Debugging tools
//
virtual void DebugPrintUsedMaterials( const char *pSearchSubString, bool bVerbose )
{
}
virtual void DebugPrintUsedTextures( void )
{
}
virtual void ToggleSuppressMaterial( char const* pMaterialName )
{
}
virtual void ToggleDebugMaterial( char const* pMaterialName )
{
}
// matrix api
virtual void MatrixMode( MaterialMatrixMode_t matrixMode )
{
}
virtual void PushMatrix( void )
{
}
virtual void PopMatrix( void )
{
}
/*
virtual void LoadMatrix( float * )
{
}
*/
// Methods that use VMatrix
virtual void LoadMatrix( const VMatrix& matrix )
{
}
virtual void LoadMatrix( const matrix3x4_t& matrix )
{
}
virtual void LoadBoneMatrix( int boneIndex, const matrix3x4_t& matrix )
{
}
virtual void MultMatrix( const VMatrix& matrix )
{
}
virtual void MultMatrix( const matrix3x4_t& matrix )
{
}
virtual void MultMatrixLocal( const VMatrix& matrix )
{
}
virtual void MultMatrixLocal( const matrix3x4_t& matrix )
{
}
virtual void GetMatrix( MaterialMatrixMode_t matrixMode, VMatrix *pMatrix )
{
pMatrix->Identity();
}
virtual void GetMatrix( MaterialMatrixMode_t matrixMode, matrix3x4_t *pMatrix )
{
SetIdentityMatrix( *pMatrix );
}
virtual void LoadIdentity( void )
{
}
virtual void Ortho( double left, double top, double right, double bottom, double zNear, double zFar )
{
}
virtual void PerspectiveX( double fovx, double aspect, double zNear, double zFar )
{
}
virtual void PickMatrix( int x, int y, int width, int height )
{
}
virtual void Rotate( float angle, float x, float y, float z )
{
}
virtual void Translate( float x, float y, float z )
{
}
virtual void Scale( float x, float y, float z )
{
}
// end matrix api
// Sets/gets the viewport
virtual void Viewport( int x, int y, int width, int height )
{
}
virtual void GetViewport( int& x, int& y, int& width, int& height ) const
{
x = y = 0;
width = height = 640;
}
// The cull mode
virtual void CullMode( MaterialCullMode_t cullMode )
{
}
// end matrix api
// Force writes only when z matches. . . useful for stenciling things out
// by rendering the desired Z values ahead of time.
// virtual void ForceDepthFuncEquals( bool bEnable ) = 0;
// virtual void RenderZOnlyWithHeightClip( bool bEnable ) = 0;
// This could easily be extended to a general user clip plane
virtual void SetHeightClipMode( MaterialHeightClipMode_t nClipMode )
{
}
virtual MaterialHeightClipMode_t GetHeightClipMode( )
{
return MATERIAL_HEIGHTCLIPMODE_DISABLE;
}
// garymcthack : fog z is always used for heightclipz for now.
virtual void SetHeightClipZ( float z )
{
}
// Fog methods...
virtual void FogMode( MaterialFogMode_t fogMode )
{
}
MaterialFogMode_t GetFogMode( void )
{
return MATERIAL_FOG_NONE;
}
virtual void FogStart( float fStart )
{
}
virtual void FogEnd( float fEnd )
{
}
virtual void FogMaxDensity( float flMaxDensity )
{
}
virtual void SetFogZ( float fogZ )
{
}
virtual void GetFogDistances( float *fStart, float *fEnd, float *fFogZ )
{
}
virtual void FogColor3f( float r, float g, float b )
{
}
virtual void FogColor3fv( float const* rgb )
{
}
virtual void FogColor3ub( unsigned char r, unsigned char g, unsigned char b )
{
}
virtual void FogColor3ubv( unsigned char const* rgb )
{
}
virtual void GetFogColor( unsigned char *rgb )
{
}
// Sets the number of bones for skinning
virtual void SetNumBoneWeights( int numBones )
{
}
virtual IMaterialProxyFactory *GetMaterialProxyFactory()
{
return NULL;
}
virtual void SetMaterialProxyFactory( IMaterialProxyFactory* pFactory )
{
}
// Read the page size of an existing lightmap by sort id (returned from AllocateLightmap())
virtual void GetLightmapPageSize( int lightmap, int *width, int *height ) const
{
if ( m_pRealMaterialSystem )
m_pRealMaterialSystem->GetLightmapPageSize( lightmap, width, height );
else
*width = *height = 32;
}
/// FIXME: This stuff needs to be cleaned up and abstracted.
// Stuff that gets exported to the launcher through the engine
virtual void SwapBuffers( )
{
}
// Use this to spew information about the 3D layer
virtual void SpewDriverInfo() const
{
}
// Creates/destroys Mesh
virtual IMesh* CreateStaticMesh( VertexFormat_t fmt, const char *pTextureBudgetGroup, IMaterial * pMaterial )
{
return GetDummyMesh();
}
virtual void DestroyStaticMesh( IMesh* mesh )
{
}
// Gets the dynamic mesh associated with the currently bound material
// note that you've got to render the mesh before calling this function
// a second time. Clients should *not* call DestroyStaticMesh on the mesh
// returned by this call.
// Use buffered = false if you want to not have the mesh be buffered,
// but use it instead in the following pattern:
// meshBuilder.Begin
// meshBuilder.End
// Draw partial
// Draw partial
// Draw partial
// meshBuilder.Begin
// meshBuilder.End
// etc
// Use Vertex or Index Override to supply a static vertex or index buffer
// to use in place of the dynamic buffers.
//
// If you pass in a material in pAutoBind, it will automatically bind the
// material. This can be helpful since you must bind the material you're
// going to use BEFORE calling GetDynamicMesh.
virtual IMesh* GetDynamicMesh( bool bBuffered = true, IMesh* pVertexOverride = 0,
IMesh* pIndexOverride = 0, IMaterial *pAutoBind = 0 )
{
return GetDummyMesh();
}
virtual IMesh* GetDynamicMeshEx( VertexFormat_t vertexFormat, bool bBuffered = true,
IMesh* pVertexOverride = 0, IMesh* pIndexOverride = 0, IMaterial *pAutoBind = 0 )
{
return GetDummyMesh();
}
virtual IMesh *GetFlexMesh()
{
return GetDummyMesh();
}
// Selection mode methods
virtual int SelectionMode( bool selectionMode )
{
return 0;
}
virtual void SelectionBuffer( unsigned int* pBuffer, int size )
{
}
virtual void ClearSelectionNames( )
{
}
virtual void LoadSelectionName( int name )
{
}
virtual void PushSelectionName( int name )
{
}
virtual void PopSelectionName()
{
}
// Installs a function to be called when we need to release vertex buffers + textures
virtual void AddReleaseFunc( MaterialBufferReleaseFunc_t func )
{
}
virtual void RemoveReleaseFunc( MaterialBufferReleaseFunc_t func )
{
}
// Installs a function to be called when we need to restore vertex buffers
virtual void AddRestoreFunc( MaterialBufferRestoreFunc_t func )
{
}
virtual void RemoveRestoreFunc( MaterialBufferRestoreFunc_t func )
{
}
// Stuff for probing properties of shaders.
virtual int GetNumShaders( void ) const
{
return 0;
}
virtual const char * GetShaderName( int shaderID ) const
{
return NULL;
}
virtual int GetNumShaderParams( int shaderID ) const
{
return 0;
}
virtual const char * GetShaderParamName( int shaderID, int paramID ) const
{
return NULL;
}
virtual const char * GetShaderParamHelp( int shaderID, int paramID ) const
{
return NULL;
}
virtual ShaderParamType_t GetShaderParamType( int shaderID, int paramID ) const
{
return ( enum ShaderParamType_t )0;
}
virtual const char * GetShaderParamDefault( int shaderID, int paramID ) const
{
return NULL;
}
// Reloads materials
virtual void ReloadMaterials( const char *pSubString = NULL )
{
}
virtual void ResetMaterialLightmapPageInfo()
{
}
virtual ITexture* CreateRenderTargetTexture(
int w,
int h,
RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and regenerated on video mode change).
ImageFormat format,
MaterialRenderTargetDepth_t depth )
{
return &g_DummyTexture;
}
virtual ITexture *CreateProceduralTexture(
const char *pTextureName,
const char *pTextureGroupName,
int w,
int h,
ImageFormat fmt,
int nFlags )
{
return &g_DummyTexture;
}
// Sets the Clear Color for ClearBuffer....
virtual void ClearColor3ub( unsigned char r, unsigned char g, unsigned char b )
{
}
virtual void ClearColor4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a )
{
}
virtual void SetInStubMode( bool b )
{
}
// Create new materials
virtual IMaterial *CreateMaterial( const char *pMaterialName, KeyValues *pVMTKeyValues )
{
return &g_DummyMaterial;
}
void GetBackBufferDimensions( int &w, int &h ) const
{
w = 1024;
h = 768;
}
ImageFormat GetBackBufferFormat( void ) const
{
return IMAGE_FORMAT_RGBA8888;
}
// FIXME: This is a hack required for NVidia/XBox, can they fix in drivers?
virtual void DrawScreenSpaceQuad( IMaterial* pMaterial ) {}
// FIXME: Test interface
virtual bool Connect( CreateInterfaceFn factory ) { return true; }
virtual void Disconnect() {}
virtual void *QueryInterface( const char *pInterfaceName ) { return NULL; }
virtual InitReturnVal_t Init() { return INIT_OK; }
virtual void SetShaderAPI( const char *pShaderAPIDLL ) {}
virtual void SetAdapter( int nAdapter, int nFlags ) {}
// Release temporary HW memory...
virtual void ResetTempHWMemory( bool bExitingLevel ) {}
virtual ITexture* CreateNamedRenderTargetTextureEx(
const char *pRTName, // Pass in NULL here for an unnamed render target.
int w,
int h,
RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and regenerated on video mode change).
ImageFormat format,
MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED,
unsigned int textureFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT,
unsigned int renderTargetFlags = 0
)
{
return &g_DummyTexture;
}
virtual ITexture* CreateNamedRenderTargetTexture(
const char *pRTName,
int w,
int h,
RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and regenerated on video mode change).
ImageFormat format,
MaterialRenderTargetDepth_t depth,
bool bClampTexCoords,
bool bAutoMipMap
)
{
return &g_DummyTexture;
}
virtual void SyncToken( const char *pToken ) {}
virtual float ComputePixelWidthOfSphere( const Vector& origin, float flRadius )
{
return 1.0f;
}
virtual float ComputePixelDiameterOfSphere( const Vector& origin, float flRadius )
{
return 1.0f;
}
OcclusionQueryObjectHandle_t CreateOcclusionQueryObject( void )
{
return INVALID_OCCLUSION_QUERY_OBJECT_HANDLE;
}
void DestroyOcclusionQueryObject( OcclusionQueryObjectHandle_t handle )
{
}
void ResetOcclusionQueryObject( OcclusionQueryObjectHandle_t hOcclusionQuery ) {}
void BeginOcclusionQueryDrawing( OcclusionQueryObjectHandle_t handle )
{
}
void EndOcclusionQueryDrawing( OcclusionQueryObjectHandle_t handle )
{
}
int OcclusionQuery_GetNumPixelsRendered( OcclusionQueryObjectHandle_t handle )
{
return 0;
}
virtual void SetFlashlightMode( bool )
{
}
virtual bool GetFlashlightMode( void ) const
{
return false;
}
virtual bool InFlashlightMode( void ) const
{
return false;
}
virtual void SetFlashlightState( const FlashlightState_t &state, const VMatrix &worldToTexture )
{
}
virtual void SetFlashlightStateEx( const FlashlightState_t &state, const VMatrix &worldToTexture, ITexture *pFlashlightDepthTexture )
{
}
virtual void SetScissorRect( const int nLeft, const int nTop, const int nRight, const int nBottom, const bool bEnableScissor )
{
}
virtual void PushDeformation( DeformationBase_t const *Deformation )
{
}
virtual void PopDeformation( )
{
}
virtual int GetNumActiveDeformations() const
{
return 0;
}
// Get the current config for this video card (as last set by control panel or the default if not)
virtual const MaterialSystem_Config_t &GetCurrentConfigForVideoCard() const
{
static MaterialSystem_Config_t dummy;
return dummy;
}
// Get video card identitier
virtual const MaterialSystemHardwareIdentifier_t &GetVideoCardIdentifier( void ) const
{
static MaterialSystemHardwareIdentifier_t dummy;
return dummy;
}
virtual void AddModeChangeCallBack( ModeChangeCallbackFunc_t func )
{
}
virtual void RemoveModeChangeCallBack( ModeChangeCallbackFunc_t func )
{
}
virtual bool GetRecommendedConfigurationInfo( int nDxLevel, KeyValues *pKeyValues )
{
return false;
}
virtual void EnableUserClipTransformOverride( bool bEnable )
{
}
virtual void UserClipTransform( const VMatrix &worldToProjection )
{
}
// Used to iterate over all shaders for editing purposes
virtual int ShaderCount() const
{
return 0;
}
virtual int GetShaders( int nFirstShader, int nCount, IShader **ppShaderList ) const
{
return 0;
}
// Used to enable editor materials. Must be called before Init.
virtual void EnableEditorMaterials()
{
}
// Used to enable editor materials. Must be called before Init.
virtual int GetCurrentAdapter() const
{
return 0;
}
virtual char *GetDisplayDeviceName() const OVERRIDE
{
return "";
}
// Creates/destroys morph data associated w/ a particular material
IMorph *CreateMorph( MorphFormat_t, const char *pDebugName )
{
static CDummyMorph s_DummyMorph;
return &s_DummyMorph;
}
void DestroyMorph( IMorph *pMorph )
{
}
void BindMorph( IMorph *pMorph )
{
}
// Sets morph target factors
virtual void SetMorphTargetFactors( int nTargetId, float *pValue, int nCount )
{
}
virtual void SetToneMappingScaleLinear( const Vector &scale )
{
}
virtual void EvictManagedResources()
{
}
// Gets the window size
virtual void GetWindowSize( int &width, int &height ) const
{
width = height = 0;
if ( m_pRealMaterialSystem )
{
CMatRenderContextPtr pRenderContext( m_pRealMaterialSystem );
pRenderContext->GetWindowSize(width, height);
}
}
// For dealing with device lost in cases where SwapBuffers isn't called all the time (Hammer)
virtual void HandleDeviceLost()
{
}
virtual void AppUsesRenderTargets()
{
}
virtual void DrawScreenSpaceRectangle(
IMaterial *pMaterial,
int destx, int desty,
int width, int height,
float src_texture_x0, float src_texture_y0,
float src_texture_x1, float src_texture_y1,
int src_texture_width, int src_texture_height,
void *pClientRenderable = NULL,
int nXDice = 1,
int nYDice = 1 )
{
}
virtual void BeginRenderTargetAllocation()
{
}
// Simulate an Alt-Tab in here, which causes a release/restore of all resources
virtual void EndRenderTargetAllocation()
{
}
ITexture *CreateNamedRenderTargetTextureEx2(
const char *pRTName, // Pass in NULL here for an unnamed render target.
int w,
int h,
RenderTargetSizeMode_t sizeMode, // Controls how size is generated (and regenerated on video mode change).
ImageFormat format,
MaterialRenderTargetDepth_t depth = MATERIAL_RT_DEPTH_SHARED,
unsigned int textureFlags = TEXTUREFLAGS_CLAMPS | TEXTUREFLAGS_CLAMPT,
unsigned int renderTargetFlags = 0
)
{
return NULL;
};
void PushRenderTargetAndViewport( )
{
}
void PushRenderTargetAndViewport( ITexture *pTexture )
{
}
void PushRenderTargetAndViewport( ITexture *pTexture, int nViewX, int nViewY, int nViewW, int nViewH )
{
}
void PushRenderTargetAndViewport( ITexture *pTexture, ITexture *pDepthTexture, int nViewX, int nViewY, int nViewW, int nViewH )
{
}
void PopRenderTargetAndViewport( void )
{
}
virtual int ShaderFlagCount() const
{
return 0;
}
virtual const char *ShaderFlagName( int nIndex ) const
{
return "";
}
virtual void BindLightmapTexture( ITexture *pLightmapTexture )
{
}
// Returns the currently active shader fallback for a particular shader
virtual void GetShaderFallback( const char *pShaderName, char *pFallbackShader, int nFallbackLength )
{
pFallbackShader[0] = 0;
}
#ifdef DX_TO_GL_ABSTRACTION
virtual void DoStartupShaderPreloading( void )
{
}
#endif
// Blit a subrect of the current render target to another texture
virtual void CopyRenderTargetToTextureEx( ITexture *pTexture, int nRenderTargetID, Rect_t *pSrcRect, Rect_t *pDstRect = NULL )
{
}
virtual void CopyTextureToRenderTargetEx( int nRenderTargetID, ITexture *pTexture, Rect_t *pSrcRect, Rect_t *pDstRect = NULL )
{
}
bool IsTextureLoaded( char const* pTextureName ) const
{
return false;
}
void PerspectiveOffCenterX( double fovx, double aspect, double zNear, double zFar, double bottom, double top, double left, double right )
{
}
void SetFloatRenderingParameter(int parm_number, float value)
{
}
void SetIntRenderingParameter(int parm_number, int value)
{
}
void SetVectorRenderingParameter(int parm_number, Vector const &value)
{
}
float GetFloatRenderingParameter(int parm_number) const
{
return 0;
}
int GetIntRenderingParameter(int parm_number) const
{
return 0;
}
Vector GetVectorRenderingParameter(int parm_number) const
{
return Vector(0,0,0);
}
void ReleaseResources(void)
{
}
void ReacquireResources(void)
{
}
Vector GetToneMappingScaleLinear( void )
{
return Vector(1,1,1);
}
virtual void GetMaxToRender( IMesh *pMesh, bool bMaxUntilFlush, int *pMaxVerts, int *pMaxIndices )
{
*pMaxVerts = 32768;
*pMaxIndices = 32768;
}
// Returns the max possible vertices + indices to render in a single draw call
virtual int GetMaxVerticesToRender( IMaterial *pMaterial )
{
return 32768;
}
virtual int GetMaxIndicesToRender( )
{
return 32768;
}
// stencil buffer operations.
virtual void SetStencilEnable(bool onoff)
{
}
virtual void SetStencilFailOperation(StencilOperation_t op)
{
}
virtual void SetStencilZFailOperation(StencilOperation_t op)
{
}
virtual void SetStencilPassOperation(StencilOperation_t op)
{
}
virtual void SetStencilCompareFunction(StencilComparisonFunction_t cmpfn)
{
}
virtual void SetStencilReferenceValue(int ref)
{
}
virtual void SetStencilTestMask(uint32 msk)
{
}
virtual void SetStencilWriteMask(uint32 msk)
{
}
virtual void ClearStencilBufferRectangle(int xmin, int ymin, int xmax, int ymax, int value)
{
}
virtual void ModInit()
{
}
virtual void ModShutdown()
{
}
virtual void EnableColorCorrection( bool bEnable ) {}
virtual ColorCorrectionHandle_t AddLookup( const char *pName ) { return 0; }
virtual bool RemoveLookup( ColorCorrectionHandle_t handle ) { return true; }
virtual void LockLookup( ColorCorrectionHandle_t handle ) {}
virtual void LoadLookup( ColorCorrectionHandle_t handle, const char *pLookupName ) {}
virtual void UnlockLookup( ColorCorrectionHandle_t handle ) {}
virtual void SetLookupWeight( ColorCorrectionHandle_t handle, float flWeight ) {}
virtual void ResetLookupWeights( ) {}
virtual void SetResetable( ColorCorrectionHandle_t handle, bool bResetable ) {}
virtual void PushCustomClipPlane( const float *pPlane )
{
}
virtual void PopCustomClipPlane( void )
{
}
virtual bool EnableClipping( bool bEnable )
{
return true;
}
virtual void PushHeightClipPlane( void )
{
}
void ResetToneMappingScale( float sc)
{
}
void TurnOnToneMapping()
{
}
virtual void GetDXLevelDefaults(uint &max_dxlevel,uint &recommended_dxlevel)
{
max_dxlevel=recommended_dxlevel=90;
}
virtual bool UsingFastClipping( void )
{
return true; //true for "crappier" hardware, so true is safer than false
}
virtual int StencilBufferBits( void )
{
return 0;
}
virtual void DisableAllLocalLights() {}
virtual int CompareMaterialCombos( IMaterial *pMaterial1, IMaterial *pMaterial2, int lightmapID1, int lightmapID2 ) { return 0; }
virtual bool SupportsMSAAMode( int nMSAAMode ) { return false; }
virtual bool SupportsCSAAMode( int nNumSamples, int nQualityLevel ) { return false; }
virtual bool SupportsHDRMode( HDRType_t nHDRModede ) { return false; }
virtual bool IsDX10Card() { return false; }
// Hooks for firing PIX events from outside the Material System...
virtual void BeginPIXEvent( unsigned long color, const char *szName ) {};
virtual void EndPIXEvent() {};
virtual void SetPIXMarker( unsigned long color, const char *szName ) {};
virtual IMatRenderContext *GetRenderContext() { return this; }
void BeginRender() {}
void BeginRender( float ) {}
void EndRender() {}
virtual void SetThreadMode( MaterialThreadMode_t, int ) {}
virtual MaterialThreadMode_t GetThreadMode( ) { return MATERIAL_SINGLE_THREADED; }
virtual bool IsRenderThreadSafe( ) { return true; }
virtual bool AllowThreading( bool bAllow, int nServiceThread ) { return false; }
virtual void ExecuteQueued() {}
virtual void BeginBatch( IMesh* pIndices ) {}
virtual void BindBatch( IMesh* pVertices, IMaterial *pAutoBind = NULL ) {}
virtual void DrawBatch(int nFirstIndex, int nIndexCount ) {}
virtual void EndBatch() {}
virtual void SetGoalToneMappingScale(float) {}
virtual bool SupportsShadowDepthTextures( void ) { return false; }
virtual bool SupportsFetch4( void ) { return false; }
virtual void SetShadowDepthBiasFactors( float fShadowSlopeScaleDepthBias, float fShadowDepthBias ) {}
virtual ICallQueue *GetCallQueue() { return NULL; }
virtual void GetWorldSpaceCameraPosition( Vector *pCameraPos )
{
pCameraPos->Init();
}
virtual void GetWorldSpaceCameraVectors( Vector *pVecForward, Vector *pVecRight, Vector *pVecUp )
{
if ( pVecForward )
{
pVecForward->Init( 1, 0, 0 );
}
if ( pVecRight )
{
pVecRight->Init( 0, -1, 0 );
}
if ( pVecUp )
{
pVecUp->Init( 0, 0, 1 );
}
}
virtual void BeginUpdateLightmaps() {}
virtual void EndUpdateLightmaps() {}
virtual MaterialLock_t Lock() { return NULL; }
virtual void Unlock( MaterialLock_t ) {}
virtual ImageFormat GetShadowDepthTextureFormat() { return IMAGE_FORMAT_UNKNOWN; }
virtual IMatRenderContext *CreateRenderContext( MaterialContextType_t type )
{
return RetAddRef( (IMatRenderContext *)this );
}
virtual IMatRenderContext *SetRenderContext( IMatRenderContext *pContext )
{
SafeRelease( pContext );
return RetAddRef( this );
}
virtual IVertexBuffer * GetDynamicVertexBuffer( /*VertexFormat_t vertexFormat, */bool buffered = true )
{
Assert( 0 );
return NULL;
// return GetDummyMesh();
}
virtual IIndexBuffer * GetDynamicIndexBuffer( /*MaterialIndexFormat_t fmt, */bool buffered = true )
{
Assert( 0 );
return NULL;
// return GetDummyMesh();
}
// ------------ New Vertex/Index Buffer interface ----------------------------
virtual IVertexBuffer *CreateStaticVertexBuffer( VertexFormat_t fmt, int nVertexCount, const char *pBudgetGroup )
{
Assert( 0 );
return NULL;
}
virtual IIndexBuffer *CreateStaticIndexBuffer( MaterialIndexFormat_t fmt, int nIndexCount, const char *pBudgetGroup )
{
Assert( 0 );
return NULL;
}
virtual void DestroyVertexBuffer( IVertexBuffer * )
{
}
virtual void DestroyIndexBuffer( IIndexBuffer * )
{
}
// Do we need to specify the stream here in the case of locking multiple dynamic VBs on different streams?
virtual IVertexBuffer *GetDynamicVertexBuffer( int streamID, VertexFormat_t vertexFormat, bool bBuffered = true )
{
Assert( 0 );
return NULL;
}
virtual IIndexBuffer *GetDynamicIndexBuffer( MaterialIndexFormat_t fmt, bool bBuffered = true )
{
Assert( 0 );
return NULL;
}
virtual void BindVertexBuffer( int streamID, IVertexBuffer *pVertexBuffer, int nOffsetInBytes, int nFirstVertex, int nVertexCount, VertexFormat_t fmt, int nRepetitions = 1 )
{
}
virtual void BindIndexBuffer( IIndexBuffer *pIndexBuffer, int nOffsetInBytes )
{
}
virtual void Draw( MaterialPrimitiveType_t primitiveType, int nFirstIndex, int nIndexCount )
{
}
virtual void BeginMorphAccumulation()
{
}
virtual void EndMorphAccumulation()
{
}
virtual void AccumulateMorph( IMorph* pMorph, int nMorphCount, const MorphWeight_t* pWeights )
{
}
virtual bool GetMorphAccumulatorTexCoord( Vector2D *pTexCoord, IMorph *pMorph, int nVertex )
{
pTexCoord->Init();
return false;
}
// ------------ End ----------------------------
virtual ImageFormat GetNullTextureFormat() { return IMAGE_FORMAT_UNKNOWN; }
virtual void AddTextureAlias( const char *pAlias, const char *pRealName ) {}
virtual void RemoveTextureAlias( const char *pAlias ) {}
virtual void SetExcludedTextures( const char *pScriptName ) {}
virtual void UpdateExcludedTextures( void ) {}
virtual void SetFlexWeights( int nFirstWeight, int nCount, const MorphWeight_t* pWeights ) {}
virtual bool SupportsBorderColor() { return false; }
virtual IMaterial *GetCurrentMaterial() { return NULL; }
virtual int GetCurrentNumBones() const { return 0; }
virtual void *GetCurrentProxy() { return NULL; }
virtual void SetFullScreenDepthTextureValidityFlag( bool bIsValid ) {}
// A special path used to tick the front buffer while loading on the 360
virtual void SetNonInteractivePacifierTexture( ITexture *pTexture, float flNormalizedX, float flNormalizedY, float flNormalizedSize ) {}
virtual void SetNonInteractiveTempFullscreenBuffer( ITexture *pTexture, MaterialNonInteractiveMode_t mode ) {}
virtual void EnableNonInteractiveMode( MaterialNonInteractiveMode_t mode ) {}
virtual void RefreshFrontBufferNonInteractive() {}
virtual void * LockRenderData( int nSizeInBytes ) { return NULL; }
virtual void UnlockRenderData( void *pData ) {}
virtual bool IsRenderData( const void *pData ) const { return false; }
virtual void AddRefRenderData() {}
virtual void ReleaseRenderData() {}
#if defined( _X360 )
virtual void ListUsedMaterials( void ) {}
virtual HXUIFONT OpenTrueTypeFont( const char *pFontname, int tall, int style )
{
return (HXUIFONT)0;
}
virtual void CloseTrueTypeFont( HXUIFONT hFont ) {}
virtual bool GetTrueTypeFontMetrics( HXUIFONT hFont, XUIFontMetrics *pFontMetrics, XUICharMetrics charMetrics[256] )
{
pFontMetrics->fLineHeight = 0.0f;
pFontMetrics->fMaxAscent = 0.0f;
pFontMetrics->fMaxDescent = 0.0f;
pFontMetrics->fMaxWidth = 0.0f;
pFontMetrics->fMaxHeight = 0.0f;
pFontMetrics->fMaxAdvance = 0.0f;
return true;
}
virtual bool GetTrueTypeGlyphs( HXUIFONT hFont, int numChars, wchar_t *pWch, int *pOffsetX, int *pOffsetY, int *pWidth, int *pHeight, unsigned char *pRGBA, int *pRGBAOffset )
{
return false;
}
virtual void PersistDisplay() {}
virtual void *GetD3DDevice() { return NULL; }
virtual void PushVertexShaderGPRAllocation( int iVertexShaderCount = 64 ) { };
virtual void PopVertexShaderGPRAllocation( void ) { };
virtual bool OwnGPUResources( bool bEnable ) { return false; }
#endif
virtual void CompactMemory() {}
// For sv_pure mode. The filesystem figures out which files the client needs to reload to be "pure" ala the server's preferences.
virtual void ReloadFilesInList( IFileList *pFilesToReload )
{
}
virtual void PrintfVA( char *fmt, va_list vargs ) {}
virtual void Printf( const char *fmt, ... ) {}
virtual float Knob( char *knobname, float *setvalue=NULL ) { return 0.0f; }
virtual void SetRenderTargetFrameBufferSizeOverrides( int nWidth, int nHeight ) OVERRIDE
{
// Nope.
}
virtual void GetRenderTargetFrameBufferDimensions( int & nWidth, int & nHeight ) OVERRIDE
{
GetBackBufferDimensions( nWidth, nHeight );
}
virtual ITexture* CreateTextureFromBits(int w, int h, int mips, ImageFormat fmt, int srcBufferSize, byte* srcBits)
{
return NULL;
}
virtual void OverrideRenderTargetAllocation( bool )
{
// anda
}
virtual ITextureCompositor* NewTextureCompositor( int w, int h, const char* pCompositeName, int nTeamNum, uint64 randomSeed, KeyValues* stageDesc, uint texCompositeCreateFlags ) OVERRIDE
{
return NULL;
}
virtual void AsyncFindTexture( const char* pFilename, const char *pTextureGroupName, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs, bool bComplain = true, int nAdditionalCreationFlags = 0 )
{
}
virtual void AsyncCreateTextureFromRenderTarget( ITexture* pSrcRt, const char* pDstName, ImageFormat dstFmt, bool bGenMips, int nAdditionalCreationFlags, IAsyncTextureOperationReceiver* pRecipient, void* pExtraArgs )
{
}
virtual ITexture* CreateNamedTextureFromBitsEx( const char* pName, const char *pTextureGroupName, int w, int h, int mips, ImageFormat fmt, int srcBufferSize, byte* srcBits, int nFlags )
{
return NULL;
}
virtual bool AddTextureCompositorTemplate( const char* pName, KeyValues* pTmplDesc, int nTexCompositeTemplateFlags ) OVERRIDE
{
return false;
}
virtual bool VerifyTextureCompositorTemplates() OVERRIDE
{
return false;
}
};
static CDummyMaterialSystem g_DummyMaterialSystem;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CDummyMaterialSystem, IMaterialSystemStub,
MATERIAL_SYSTEM_STUB_INTERFACE_VERSION, g_DummyMaterialSystem );