2374 lines
63 KiB
C++
2374 lines
63 KiB
C++
//========= 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 );
|
|
|
|
|