//========= 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 { 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 );