You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
851 lines
37 KiB
851 lines
37 KiB
//========== Copyright (c) 2005, Valve Corporation, All rights reserved. ========
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef CMATERIALRENDERSTATE_H
|
|
#define CMATERIALRENDERSTATE_H
|
|
|
|
#if defined( _WIN32 )
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "tier1/delegates.h"
|
|
#include "tier1/utlstack.h"
|
|
#include "bitvec.h"
|
|
#include "materialsystem_global.h"
|
|
#include "materialsystem/imaterialsystem.h"
|
|
#include "materialsystem/ishaderapi.h"
|
|
#include "imaterialinternal.h"
|
|
#include "shadersystem.h"
|
|
#include "imorphinternal.h"
|
|
#include "isubdinternal.h"
|
|
#include "imatrendercontextinternal.h"
|
|
#include "occlusionquerymgr.h"
|
|
#include "materialsystem/MaterialSystemUtil.h"
|
|
#include "tier1/memstack.h"
|
|
|
|
#ifndef MATSYS_INTERNAL
|
|
#error "This file is private to the implementation of IMaterialSystem/IMaterialSystemInternal"
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
class ITextureInternal;
|
|
class CMaterialSystem;
|
|
class CMatLightmaps;
|
|
class CMatPaintmaps;
|
|
typedef intp ShaderAPITextureHandle_t;
|
|
class IMorphMgrRenderContext;
|
|
class CMatCallQueue;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Render targets
|
|
//-----------------------------------------------------------------------------
|
|
#if !defined( _X360 ) && !defined( _PS3 )
|
|
#define MAX_RENDER_TARGETS 4
|
|
#else
|
|
#define MAX_RENDER_TARGETS 1
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CMatRenderContextBase : public CRefCounted1<IMatRenderContextInternal>
|
|
{
|
|
public:
|
|
virtual void InitializeFrom( CMatRenderContextBase *pInitialState );
|
|
|
|
InitReturnVal_t Init();
|
|
void Shutdown();
|
|
void CompactMemory();
|
|
|
|
void SetFrameTime( float frameTime ) { m_FrameTime = frameTime; }
|
|
|
|
ICallQueue * GetCallQueue() { return NULL; }
|
|
CMatCallQueue * GetCallQueueInternal() { return NULL; }
|
|
|
|
ITexture * GetRenderTarget( void );
|
|
ITexture * GetRenderTargetEx( int nRenderTargetID );
|
|
|
|
IMaterialInternal* GetCurrentMaterialInternal() const { return m_pCurrentMaterial; }
|
|
virtual void SetCurrentMaterialInternal(IMaterialInternal* pCurrentMaterial) {
|
|
m_pCurrentMaterial = pCurrentMaterial;
|
|
Assert( (m_pCurrentMaterial == NULL) || ((IMaterialInternal *)m_pCurrentMaterial)->IsRealTimeVersion() );
|
|
}
|
|
IMaterial * GetCurrentMaterial() { return GetCurrentMaterialInternal(); }
|
|
virtual void * GetCurrentProxy() { return m_pCurrentProxyData; }
|
|
virtual void SetCurrentProxy( void *pProxyData ) { m_pCurrentProxyData = pProxyData; }
|
|
|
|
void Bind( IMaterial *material, void *proxyData = NULL );
|
|
void BindLightmapPage( int lightmapPageID );
|
|
void BindLocalCubemap( ITexture *pTexture );
|
|
|
|
// matrix api
|
|
void MatrixMode( MaterialMatrixMode_t);
|
|
void PushMatrix();
|
|
void PopMatrix();
|
|
void LoadMatrix( const VMatrix& matrix );
|
|
void LoadMatrix( const matrix3x4_t& matrix );
|
|
void MultMatrix( const VMatrix& matrix );
|
|
void MultMatrixLocal( const VMatrix& matrix );
|
|
void MultMatrix( const matrix3x4_t& matrix );
|
|
void MultMatrixLocal( const matrix3x4_t& matrix );
|
|
void GetMatrix( MaterialMatrixMode_t matrixMode, VMatrix *pMatrix );
|
|
void GetMatrix( MaterialMatrixMode_t matrixMode, matrix3x4_t *pMatrix );
|
|
void LoadIdentity();
|
|
void Ortho( double, double, double, double, double, double);
|
|
void PerspectiveX( double, double, double, double);
|
|
void PerspectiveOffCenterX( double, double, double, double, double, double, double, double );
|
|
void PickMatrix( int, int, int, int);
|
|
void Rotate( float, float, float, float);
|
|
void Translate( float, float, float);
|
|
void Scale( float, float, float);
|
|
// end matrix api
|
|
|
|
// Set the current texture that is a copy of the framebuffer.
|
|
void SetFrameBufferCopyTexture( ITexture *pTexture, int textureIndex );
|
|
ITexture * GetFrameBufferCopyTexture( int textureIndex );
|
|
|
|
void SetHeightClipMode( MaterialHeightClipMode_t mode );
|
|
MaterialHeightClipMode_t GetHeightClipMode( void );
|
|
void SetHeightClipZ( float z );
|
|
|
|
bool EnableClipping( bool bEnable );
|
|
|
|
void SetRenderTarget( ITexture *pTexture );
|
|
void SetRenderTargetEx( int nRenderTargetID, ITexture *pTexture );
|
|
|
|
void Viewport( int x, int y, int width, int height );
|
|
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 );
|
|
|
|
void SyncMatrices();
|
|
void SyncMatrix( MaterialMatrixMode_t );
|
|
const VMatrix & AccessCurrentMatrix() const { return m_pCurMatrixItem->matrix; }
|
|
ShaderAPITextureHandle_t GetLightmapTexture( int nLightmapPage );
|
|
ShaderAPITextureHandle_t GetPaintmapTexture( int nLightmapPage );
|
|
|
|
virtual void UpdateHeightClipUserClipPlane( void ) {}
|
|
virtual void ApplyCustomClipPlanes( void ) {}
|
|
|
|
float ComputePixelDiameterOfSphere( const Vector& origin, float flRadius );
|
|
float ComputePixelWidthOfSphere( const Vector& origin, float flRadius ); // FIXME: REMOVE THIS FUNCTION!
|
|
|
|
virtual void GetWorldSpaceCameraPosition( Vector *pCameraPos );
|
|
virtual void GetWorldSpaceCameraVectors( Vector *pVecForward, Vector *pVecRight, Vector *pVecUp );
|
|
|
|
Vector GetToneMappingScaleLinear();
|
|
|
|
// Inherited from IMaterialSystemInternal
|
|
int GetLightmapPage( void );
|
|
|
|
virtual void * LockRenderData( int nSizeInBytes );
|
|
virtual void UnlockRenderData( void *pData );
|
|
virtual void AddRefRenderData();
|
|
virtual void ReleaseRenderData();
|
|
virtual bool IsRenderData( const void *pData ) const;
|
|
void MarkRenderDataUnused( bool bFrameEnd );
|
|
int RenderDataSizeUsed() const;
|
|
|
|
// debugging
|
|
virtual void PrintfVA( char *fmt, va_list vargs );
|
|
virtual void Printf( char *fmt, ... );
|
|
virtual float Knob( char *knobname, float *setvalue = NULL );
|
|
|
|
protected:
|
|
enum MatrixStackFlags_t
|
|
{
|
|
MSF_DIRTY = ( 1 << 0 ),
|
|
MSF_IDENTITY = ( 1 << 1 ),
|
|
};
|
|
|
|
struct MatrixStackItem_t
|
|
{
|
|
VMatrix matrix;
|
|
unsigned flags;
|
|
};
|
|
|
|
struct RenderTargetStackElement_t
|
|
{
|
|
// The render target
|
|
ITexture *m_pRenderTargets[MAX_RENDER_TARGETS];
|
|
|
|
// Optional depth texture (used for shadow mapping)
|
|
ITexture *m_pDepthTexture;
|
|
|
|
// Viewport dimensions
|
|
int m_nViewX;
|
|
int m_nViewY;
|
|
int m_nViewW;
|
|
int m_nViewH;
|
|
};
|
|
|
|
struct ScissorRectStackElement_t
|
|
{
|
|
int nLeft;
|
|
int nTop;
|
|
int nRight;
|
|
int nBottom;
|
|
};
|
|
|
|
struct PlaneStackElement
|
|
{
|
|
float fValues[4];
|
|
bool bHack_IsHeightClipPlane; //used to hack in compatibility between the user clip planes and the existing height clip plane code
|
|
//I'm doing the hack this way to retain modder's flexibility to mess with clip plane ordering so that they can make special hacks on their side if necessary
|
|
PlaneStackElement( void ) : bHack_IsHeightClipPlane( false ) { };
|
|
};
|
|
|
|
protected:
|
|
CMatRenderContextBase( );
|
|
virtual void CommitRenderTargetAndViewport( void ) {}
|
|
void RecomputeViewState();
|
|
void RecomputeViewProjState();
|
|
void CurrentMatrixChanged();
|
|
virtual void OnRenderDataUnreferenced() {}
|
|
|
|
protected:
|
|
IMaterialInternal * m_pCurrentMaterial;
|
|
void* m_pCurrentProxyData;
|
|
|
|
// The lightmap page
|
|
int m_lightmapPageID;
|
|
ITextureInternal * m_pUserDefinedLightmap;
|
|
|
|
ITexture * m_pLocalCubemapTexture;
|
|
|
|
ITexture * m_pCurrentFrameBufferCopyTexture[MAX_FB_TEXTURES];
|
|
|
|
MaterialHeightClipMode_t m_HeightClipMode;
|
|
float m_HeightClipZ;
|
|
// The currently bound morph target
|
|
IMorphInternal * m_pBoundMorph;
|
|
IMorphMgrRenderContext *m_pMorphRenderContext;
|
|
|
|
// Intially a stack of 32 elements allocated, growing by 16 on overflows
|
|
CUtlStack< RenderTargetStackElement_t > m_RenderTargetStack;
|
|
|
|
// Intially a stack of 32 elements allocated, growing by 16 on overflows
|
|
CUtlStack< ScissorRectStackElement_t > m_ScissorRectStack;
|
|
|
|
MaterialMatrixMode_t m_MatrixMode;
|
|
MatrixStackItem_t * m_pCurMatrixItem;
|
|
CUtlStack<MatrixStackItem_t> m_MatrixStacks[NUM_MATRIX_MODES];
|
|
|
|
// View state
|
|
VMatrix m_viewProjMatrix;
|
|
Vector m_vecViewOrigin;
|
|
Vector m_vecViewForward;
|
|
Vector m_vecViewUp;
|
|
Vector m_vecViewRight;
|
|
|
|
float m_FrameTime;
|
|
|
|
Vector m_LastSetToneMapScale;
|
|
ShaderViewport_t m_Viewport;
|
|
CMaterialSystem * m_pMaterialSystem;
|
|
|
|
static CMemoryStack sm_RenderData[2];
|
|
static int sm_nRenderLockCount;
|
|
static int sm_nRenderStack;
|
|
static MemoryStackMark_t sm_nRenderCurrentAllocPoint;
|
|
static int sm_nInitializeCount;
|
|
|
|
bool m_bFlashlightEnable : 1;
|
|
bool m_bDirtyViewState : 1;
|
|
bool m_bDirtyViewProjState : 1;
|
|
bool m_bEnableClipping : 1;
|
|
bool m_bFullFrameDepthIsValid : 1;
|
|
bool m_bRenderingPaint : 1;
|
|
bool m_bCullingEnabledForSinglePassFlashlight : 1;
|
|
bool m_bSinglePassFlashlightMode : 1;
|
|
bool m_bCascadedShadowMappingEnabled : 1;
|
|
|
|
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
#if defined( _PS3 ) || defined( _OSX )
|
|
#define g_pShaderAPI ShaderAPI()
|
|
#endif
|
|
|
|
class CMatRenderContext : public CMatRenderContextBase
|
|
{
|
|
typedef CMatRenderContextBase BaseClass;
|
|
|
|
public:
|
|
CMatRenderContext();
|
|
|
|
InitReturnVal_t Init( CMaterialSystem *pMaterialSystem );
|
|
void Shutdown();
|
|
|
|
void BeginRender();
|
|
void EndRender();
|
|
|
|
void Flush( bool flushHardware = false );
|
|
|
|
void SwapBuffers();
|
|
|
|
void OnReleaseShaderObjects();
|
|
|
|
DELEGATE_TO_OBJECT_0V( EvictManagedResources, g_pShaderAPI );
|
|
|
|
// Set the current texture that is a copy of the framebuffer.
|
|
void SetFrameBufferCopyTexture( ITexture *pTexture, int textureIndex );
|
|
|
|
IMesh * CreateStaticMesh( VertexFormat_t vertexFormat, const char *pTextureBudgetGroup, IMaterial * pMaterial = NULL, VertexStreamSpec_t *pStreamSpec = NULL );
|
|
DELEGATE_TO_OBJECT_1V( DestroyStaticMesh, IMesh *, g_pShaderDevice );
|
|
IMesh * GetDynamicMesh( bool buffered, IMesh* pVertexOverride = 0, IMesh* pIndexOverride = 0, IMaterial *pAutoBind = 0 );
|
|
virtual IMesh* GetDynamicMeshEx( VertexFormat_t vertexFormat, bool bBuffered = true, IMesh* pVertexOverride = 0, IMesh* pIndexOverride = 0, IMaterial *pAutoBind = 0 );
|
|
DELEGATE_TO_OBJECT_0( IMesh *, GetFlexMesh, g_pShaderAPI );
|
|
|
|
// ------------ New Vertex/Index Buffer interface ----------------------------
|
|
IVertexBuffer *CreateStaticVertexBuffer( VertexFormat_t fmt, int nVertexCount, const char *pBudgetGroup )
|
|
{
|
|
return g_pShaderDevice->CreateVertexBuffer( SHADER_BUFFER_TYPE_STATIC, fmt, nVertexCount, pBudgetGroup );
|
|
}
|
|
|
|
IIndexBuffer *CreateStaticIndexBuffer( MaterialIndexFormat_t fmt, int nIndexCount, const char *pBudgetGroup )
|
|
{
|
|
return g_pShaderDevice->CreateIndexBuffer( SHADER_BUFFER_TYPE_STATIC, fmt, nIndexCount, pBudgetGroup );
|
|
}
|
|
|
|
DELEGATE_TO_OBJECT_1V( DestroyVertexBuffer, IVertexBuffer *, g_pShaderDevice );
|
|
DELEGATE_TO_OBJECT_1V( DestroyIndexBuffer, IIndexBuffer *, g_pShaderDevice );
|
|
DELEGATE_TO_OBJECT_3( IVertexBuffer *, GetDynamicVertexBuffer, int, VertexFormat_t, bool, g_pShaderDevice );
|
|
DELEGATE_TO_OBJECT_0( IIndexBuffer *, GetDynamicIndexBuffer, g_pShaderDevice );
|
|
DELEGATE_TO_OBJECT_7V( BindVertexBuffer, int, IVertexBuffer *, int, int, int, VertexFormat_t, int, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_2V( BindIndexBuffer, IIndexBuffer *, int, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_3V( Draw, MaterialPrimitiveType_t, int, int, g_pShaderAPI );
|
|
// ------------ End ----------------------------
|
|
|
|
void BindLocalCubemap( ITexture *pTexture );
|
|
ITexture * GetLocalCubemap( void );
|
|
void SetRenderTargetEx( int nRenderTargetID, ITexture *pTexture );
|
|
void GetRenderTargetDimensions( int &width, int &height) const;
|
|
|
|
// matrix api
|
|
void MatrixMode( MaterialMatrixMode_t);
|
|
void PushMatrix();
|
|
void PopMatrix();
|
|
void LoadMatrix( const VMatrix& matrix );
|
|
void LoadMatrix( const matrix3x4_t& matrix );
|
|
void MultMatrix( const VMatrix& matrix );
|
|
void MultMatrixLocal( const VMatrix& matrix );
|
|
void MultMatrix( const matrix3x4_t& matrix );
|
|
void MultMatrixLocal( const matrix3x4_t& matrix );
|
|
void GetMatrix( MaterialMatrixMode_t matrixMode, VMatrix *pMatrix );
|
|
void GetMatrix( MaterialMatrixMode_t matrixMode, matrix3x4_t *pMatrix );
|
|
void LoadIdentity();
|
|
void Ortho( double, double, double, double, double, double);
|
|
void PerspectiveX( double, double, double, double);
|
|
void PerspectiveOffCenterX( double, double, double, double, double, double, double, double );
|
|
void PickMatrix( int, int, int, int);
|
|
void Rotate( float, float, float, float);
|
|
void Translate( float, float, float);
|
|
void Scale( float, float, float);
|
|
// end matrix api
|
|
|
|
void SyncMatrices();
|
|
void SyncMatrix( MaterialMatrixMode_t );
|
|
bool TestMatrixSync( MaterialMatrixMode_t );
|
|
void ForceSyncMatrix( MaterialMatrixMode_t );
|
|
ShaderAPITextureHandle_t GetLightmapTexture( int nLightmapPage );
|
|
ShaderAPITextureHandle_t GetPaintmapTexture( int nLightmapPage );
|
|
|
|
// Allows us to override the depth buffer setting of a material
|
|
DELEGATE_TO_OBJECT_3V( OverrideDepthEnable, bool, bool, bool, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_2V( OverrideAlphaWriteEnable, bool, bool, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_2V( OverrideColorWriteEnable, bool, bool, g_pShaderAPI );
|
|
|
|
// FIXME: This is a hack required for NVidia/XBox, can they fix in drivers?
|
|
void DrawScreenSpaceQuad( IMaterial* pMaterial );
|
|
|
|
int CompareMaterialCombos( IMaterial *pMaterial1, IMaterial *pMaterial2, int lightMapID1, int lightMapID2 );
|
|
|
|
void Bind( IMaterial *material, void *proxyData = NULL );
|
|
void BindLightmapPage( int lightmapPageID );
|
|
void BindPaintTexture( ITexture *pTexture );
|
|
|
|
DELEGATE_TO_OBJECT_2V( SetLights, int, const LightDesc_t *, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1V( SetLightingOrigin, Vector, g_pShaderAPI );
|
|
|
|
DELEGATE_TO_OBJECT_1V( SetAmbientLightCube, LightCube_t, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( DisableAllLocalLights, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1V( SetLightingState, const MaterialLightingState_t&, g_pShaderAPI );
|
|
|
|
void CopyRenderTargetToTexture( ITexture *pTexture );
|
|
|
|
void ClearBuffers( bool bClearColor, bool bClearDepth, bool bClearStencil );
|
|
DELEGATE_TO_OBJECT_3V( ClearColor3ub, unsigned char, unsigned char, unsigned char, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_4V( ClearColor4ub, unsigned char, unsigned char, unsigned char, unsigned char, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_2V( ClearBuffersObeyStencil, bool, bool, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_3V( ClearBuffersObeyStencilEx, bool, bool, bool, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( PerformFullScreenStencilOperation, g_pShaderAPI );
|
|
|
|
// read to a unsigned char rgb image.
|
|
DELEGATE_TO_OBJECT_6V( ReadPixels, int, int, int, int, unsigned char *, ImageFormat, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_7V( ReadPixels, int, int, int, int, unsigned char *, ImageFormat, ITexture *, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_6V( ReadPixelsAsync, int, int, int, int, unsigned char *, ImageFormat, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_7V( ReadPixelsAsync, int, int, int, int, unsigned char *, ImageFormat, ITexture *, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_8V( ReadPixelsAsync, int, int, int, int, unsigned char *, ImageFormat, ITexture *, CThreadEvent *, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_6V( ReadPixelsAsyncGetResult, int, int, int, int, unsigned char *, ImageFormat, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_7V( ReadPixelsAsyncGetResult, int, int, int, int, unsigned char *, ImageFormat, CThreadEvent *, g_pShaderAPI );
|
|
void ReadPixelsAndStretch( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *pBuffer, ImageFormat dstFormat, int nDstStride ) { g_pShaderAPI->ReadPixels( pSrcRect, pDstRect, pBuffer, dstFormat, nDstStride ); }
|
|
|
|
// Gets/sets viewport
|
|
void Viewport( int x, int y, int width, int height );
|
|
void GetViewport( int& x, int& y, int& width, int& height ) const;
|
|
virtual void DepthRange( float zNear, float zFar );
|
|
|
|
// Selection mode methods
|
|
DELEGATE_TO_OBJECT_1( int, SelectionMode, bool, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_2V( SelectionBuffer, unsigned int *, int, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( ClearSelectionNames, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1V( LoadSelectionName, int, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1V( PushSelectionName, int, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( PopSelectionName, g_pShaderAPI );
|
|
|
|
// Sets the cull mode
|
|
DELEGATE_TO_OBJECT_1V( CullMode, MaterialCullMode_t, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( FlipCullMode, g_pShaderAPI );
|
|
|
|
DELEGATE_TO_OBJECT_0V( BeginGeneratingCSMs, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( EndGeneratingCSMs, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_3V( PerpareForCascadeDraw, int, float, float, g_pShaderAPI );
|
|
|
|
// Sets the number of bones for skinning
|
|
DELEGATE_TO_OBJECT_1V( SetNumBoneWeights, int, g_pShaderAPI );
|
|
|
|
void LoadBoneMatrix( int boneIndex, const matrix3x4_t& matrix );
|
|
DELEGATE_TO_OBJECT_3V( SetFlexWeights, int, int, const MorphWeight_t*, g_pShaderAPI );
|
|
|
|
// Fog-related methods
|
|
void FogMode( MaterialFogMode_t fogMode ) { g_pShaderAPI->SceneFogMode( fogMode ); }
|
|
DELEGATE_TO_OBJECT_1V( FogStart, float, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1V( FogEnd, float, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1V( SetFogZ, float, g_pShaderAPI );
|
|
void FogColor3f( float r, float g, float b );
|
|
void FogColor3fv( const float* rgb );
|
|
void FogColor3ub( unsigned char r, unsigned char g, unsigned char b ) { g_pShaderAPI->SceneFogColor3ub( r, g, b ); }
|
|
void FogColor3ubv( unsigned char const* rgb );
|
|
void FogMaxDensity( float flMaxDensity );
|
|
|
|
MaterialFogMode_t GetFogMode( void ) { return g_pShaderAPI->GetSceneFogMode(); }
|
|
void GetFogColor( unsigned char *rgb ) { g_pShaderAPI->GetSceneFogColor( rgb ); }
|
|
DELEGATE_TO_OBJECT_3V( GetFogDistances, float *, float *, float *, g_pShaderAPI );
|
|
int GetCurrentNumBones( ) const { return g_pShaderAPI->GetCurrentNumBones(); }
|
|
|
|
// Bind standard textures
|
|
void BindStandardTexture( Sampler_t sampler, TextureBindFlags_t nBindFlags, StandardTextureId_t id );
|
|
ShaderAPITextureHandle_t GetStandardTexture( StandardTextureId_t id );
|
|
|
|
virtual void BindStandardVertexTexture( VertexTextureSampler_t sampler, StandardTextureId_t id );
|
|
virtual void GetStandardTextureDimensions( int *pWidth, int *pHeight, StandardTextureId_t id );
|
|
|
|
virtual float GetSubDHeight();
|
|
|
|
// By default, the material system applies the VIEW and PROJECTION matrices to the user clip
|
|
// planes (which are specified in world space) to generate projection-space user clip planes
|
|
// Occasionally (for the particle system in hl2, for example), we want to override that
|
|
// behavior and explictly specify a ViewProj transform for user clip planes
|
|
DELEGATE_TO_OBJECT_1V( EnableUserClipTransformOverride, bool, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1V( UserClipTransform, const VMatrix &, g_pShaderAPI );
|
|
|
|
// Gets the window size
|
|
DELEGATE_TO_OBJECT_2VC( GetWindowSize, int &, int &, g_pShaderDevice );
|
|
|
|
// Methods related to occlusion query
|
|
OcclusionQueryObjectHandle_t CreateOcclusionQueryObject();
|
|
DELEGATE_TO_OBJECT_1V( DestroyOcclusionQueryObject, OcclusionQueryObjectHandle_t, g_pOcclusionQueryMgr );
|
|
DELEGATE_TO_OBJECT_1V( BeginOcclusionQueryDrawing, OcclusionQueryObjectHandle_t, g_pOcclusionQueryMgr );
|
|
DELEGATE_TO_OBJECT_1V( EndOcclusionQueryDrawing, OcclusionQueryObjectHandle_t, g_pOcclusionQueryMgr );
|
|
DELEGATE_TO_OBJECT_1V( ResetOcclusionQueryObject, OcclusionQueryObjectHandle_t, g_pOcclusionQueryMgr );
|
|
int OcclusionQuery_GetNumPixelsRendered( OcclusionQueryObjectHandle_t h );
|
|
|
|
bool InFlashlightMode() const;
|
|
bool IsRenderingPaint() const;
|
|
virtual void SetFlashlightMode( bool bEnable );
|
|
virtual void SetRenderingPaint( bool bEnable );
|
|
bool GetFlashlightMode( ) const;
|
|
|
|
virtual bool IsCascadedShadowMapping() const;
|
|
virtual void SetCascadedShadowMapping( bool bEnable );
|
|
virtual void SetCascadedShadowMappingState( const CascadedShadowMappingState_t &state, ITexture *pDepthTextureAtlas );
|
|
|
|
virtual bool IsCullingEnabledForSinglePassFlashlight() const;
|
|
virtual void EnableCullingForSinglePassFlashlight( bool bEnable );
|
|
|
|
void SetFlashlightState( const FlashlightState_t &state, const VMatrix &worldToTexture );
|
|
void SetFlashlightStateEx( const FlashlightState_t &state, const VMatrix &worldToTexture, ITexture *pFlashlightDepthTexture );
|
|
|
|
void PushScissorRect( const int nLeft, const int nTop, const int nRight, const int nBottom );
|
|
void PopScissorRect();
|
|
|
|
#if defined( _GAMECONSOLE )
|
|
void BeginConsoleZPass( const WorldListIndicesInfo_t &indicesInfo ){ BeginConsoleZPass2( indicesInfo.m_nTotalIndices ); }
|
|
#endif
|
|
|
|
// Creates/destroys morph data associated w/ a particular material
|
|
IMorph * CreateMorph( MorphFormat_t format, const char *pDebugName );
|
|
void DestroyMorph( IMorph *pMorph );
|
|
void BindMorph( IMorph *pMorph );
|
|
// Gets the bound morph's vertex format; returns 0 if no morph is bound
|
|
MorphFormat_t GetBoundMorphFormat();
|
|
|
|
void DrawScreenSpaceRectangle( IMaterial *pMaterial,
|
|
int destx, int desty,
|
|
int width, int height,
|
|
float src_texture_x0, float src_texture_y0, // which texel you want to appear at
|
|
// destx/y
|
|
float src_texture_x1, float src_texture_y1, // which texel you want to appear at
|
|
// destx+width-1, desty+height-1
|
|
int src_texture_width, int src_texture_height, // needed for fixup
|
|
void *pClientRenderable = NULL,
|
|
int nXDice = 1,
|
|
int nYDice = 1 );
|
|
|
|
// custom clip planes, beware that only the most recently pushed plane will actually be used in some hardware configurations
|
|
void PushCustomClipPlane( const float *fPlane );
|
|
void PopCustomClipPlane( void );
|
|
void ApplyCustomClipPlanes( void ); //updates the clip planes based on how many are supported by the hardware using the top of the stack first, at the end of the stack, the height clip plane will be evaluated
|
|
|
|
// Force writes only when z matches. . . useful for stenciling things out
|
|
// by rendering the desired Z values ahead of time.
|
|
DELEGATE_TO_OBJECT_1V( ForceDepthFuncEquals, bool, g_pShaderAPI );
|
|
|
|
// Two methods of building lightmap bits from floating point src data
|
|
|
|
// What are the lightmap dimensions?
|
|
void GetLightmapDimensions( int *w, int *h );
|
|
|
|
void DrawClearBufferQuad( unsigned char r, unsigned char g, unsigned char b, unsigned char a, bool bClearColor, bool bClearAlpha, bool bClearDepth );
|
|
#ifdef _PS3
|
|
void DrawReloadZcullQuad();
|
|
#endif // _PS3
|
|
|
|
void UpdateHeightClipUserClipPlane( void );
|
|
|
|
// Private routine called by render target stack push and pop routines to commit new top of stack to the device
|
|
void CommitRenderTargetAndViewport( void );
|
|
|
|
void SyncToken( const char *pToken );
|
|
|
|
void BindLightmapTexture( ITexture *pLightmapTexture );
|
|
void CopyRenderTargetToTextureEx( ITexture *pTexture, int nRenderTargetID, Rect_t *pSrcRect, Rect_t *pDstRect = NULL );
|
|
void CopyTextureToRenderTargetEx( int nRenderTargetID, ITexture *pTexture, Rect_t *pSrcRect, Rect_t *pDstRect = NULL );
|
|
|
|
DELEGATE_TO_OBJECT_2V( SetFloatRenderingParameter, int, float, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_2V( SetIntRenderingParameter, int, int, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_2V( SetTextureRenderingParameter, int, ITexture *, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_2V( SetVectorRenderingParameter, int, const Vector &, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1C( float, GetFloatRenderingParameter, int, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1C( int, GetIntRenderingParameter, int, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1C( ITexture *, GetTextureRenderingParameter, int, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1C( Vector, GetVectorRenderingParameter, int, g_pShaderAPI );
|
|
|
|
DELEGATE_TO_OBJECT_4V( GetMaxToRender, IMesh *, bool, int *, int *, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1( int, GetMaxVerticesToRender, IMaterial *, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0( int, GetMaxIndicesToRender, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_1V( SetStencilState, const ShaderStencilState_t &, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_5V( ClearStencilBufferRectangle, int, int, int, int, int, g_pShaderAPI );
|
|
|
|
// PIX support
|
|
DELEGATE_TO_OBJECT_2V( BeginPIXEvent, unsigned long, const char *, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( EndPIXEvent, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_2V( SetPIXMarker, unsigned long, const char *, g_pShaderAPI );
|
|
|
|
DELEGATE_TO_OBJECT_2V( SetShadowDepthBiasFactors, float, float, g_pShaderAPI );
|
|
|
|
void BeginBatch( IMesh* pIndices );
|
|
void BindBatch( IMesh* pVertices, IMaterial *pAutoBind = NULL );
|
|
void DrawBatch( MaterialPrimitiveType_t primType, int firstIndex, int numIndices );
|
|
void EndBatch();
|
|
|
|
void SetToneMappingScaleLinear( const Vector &scale );
|
|
|
|
bool OnDrawMesh( IMesh *pMesh, int firstIndex, int numIndices );
|
|
bool OnDrawMesh( IMesh *pMesh, CPrimList *pLists, int nLists );
|
|
bool OnDrawMeshModulated( IMesh *pMesh, const Vector4D &diffuseModulation, int firstIndex, int numIndices );
|
|
bool OnSetFlexMesh( IMesh *pStaticMesh, IMesh *pMesh, int nVertexOffsetInBytes ) { return true; }
|
|
bool OnSetColorMesh( IMesh *pStaticMesh, IMesh *pMesh, int nVertexOffsetInBytes ) { return true; }
|
|
bool OnSetPrimitiveType( IMesh *pMesh, MaterialPrimitiveType_t type ) { return true; }
|
|
|
|
CMaterialSystem *GetMaterialSystem() const;
|
|
|
|
DELEGATE_TO_OBJECT_0V( ForceHardwareSync, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( BeginFrame, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( EndFrame, g_pShaderAPI );
|
|
|
|
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 );
|
|
|
|
// Subdivision surface interface
|
|
virtual int GetSubDBufferWidth();
|
|
virtual float *LockSubDBuffer( int nNumRows );
|
|
virtual void UnlockSubDBuffer();
|
|
|
|
DELEGATE_TO_OBJECT_1V( PushDeformation, const DeformationBase_t *, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( PopDeformation, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0C( int, GetNumActiveDeformations, g_pShaderAPI );
|
|
|
|
// Color correction related methods..
|
|
DELEGATE_TO_OBJECT_1V( EnableColorCorrection, bool, g_pColorCorrectionSystem );
|
|
DELEGATE_TO_OBJECT_1( ColorCorrectionHandle_t, AddLookup, const char *, g_pColorCorrectionSystem );
|
|
DELEGATE_TO_OBJECT_1( bool, RemoveLookup, ColorCorrectionHandle_t, g_pColorCorrectionSystem );
|
|
DELEGATE_TO_OBJECT_1V( LockLookup, ColorCorrectionHandle_t, g_pColorCorrectionSystem );
|
|
DELEGATE_TO_OBJECT_2V( LoadLookup, ColorCorrectionHandle_t, const char *, g_pColorCorrectionSystem );
|
|
DELEGATE_TO_OBJECT_1V( UnlockLookup, ColorCorrectionHandle_t, g_pColorCorrectionSystem );
|
|
DELEGATE_TO_OBJECT_2V( SetLookupWeight, ColorCorrectionHandle_t, float, g_pColorCorrectionSystem );
|
|
DELEGATE_TO_OBJECT_0V( ResetLookupWeights, g_pColorCorrectionSystem );
|
|
DELEGATE_TO_OBJECT_2V( SetResetable, ColorCorrectionHandle_t, bool, g_pColorCorrectionSystem );
|
|
|
|
virtual void SetFullScreenDepthTextureValidityFlag( bool bIsValid );
|
|
|
|
#if defined( _X360 )
|
|
DELEGATE_TO_OBJECT_1V( PushVertexShaderGPRAllocation, int, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( PopVertexShaderGPRAllocation, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( FlushHiStencil, g_pShaderAPI );
|
|
#endif
|
|
|
|
#if defined( _GAMECONSOLE )
|
|
DELEGATE_TO_OBJECT_1V( BeginConsoleZPass2, int, g_pShaderAPI );
|
|
DELEGATE_TO_OBJECT_0V( EndConsoleZPass, g_pShaderAPI );
|
|
#endif
|
|
|
|
#if defined( _PS3 )
|
|
DELEGATE_TO_OBJECT_0V( FlushTextureCache, g_pShaderAPI );
|
|
#endif
|
|
DELEGATE_TO_OBJECT_1V( AntiAliasingHint, int, g_pShaderAPI );
|
|
|
|
// A special path used to tick the front buffer while loading on the 360
|
|
virtual void SetNonInteractiveLogoTexture( ITexture *pTexture, float flNormalizedX, float flNormalizedY, float flNormalizedW, float flNormalizedH );
|
|
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();
|
|
|
|
DELEGATE_TO_OBJECT_1V( FlipCulling, bool, g_pShaderAPI );
|
|
|
|
// DELEGATE_TO_OBJECT_1V( EnableSinglePassFlashlightMode, bool, g_pShaderAPI );
|
|
virtual void EnableSinglePassFlashlightMode( bool bEnable );
|
|
virtual bool SinglePassFlashlightModeEnabled() const;
|
|
|
|
DELEGATE_TO_OBJECT_2V( DrawInstances, int, const MeshInstanceData_t *, g_pShaderAPI );
|
|
|
|
DELEGATE_TO_OBJECT_1V( UpdateGameTime, float, g_pShaderAPI );
|
|
|
|
//--------------------------------------------------------
|
|
// debug logging - no-op in queued context
|
|
//--------------------------------------------------------
|
|
virtual void Printf( char *fmt, ... );
|
|
virtual void PrintfVA( char *fmt, va_list vargs );;
|
|
virtual float Knob( char *knobname, float *setvalue=NULL );
|
|
|
|
#if defined( DX_TO_GL_ABSTRACTION ) && !defined( _GAMECONSOLE )
|
|
void DoStartupShaderPreloading( void );
|
|
#endif
|
|
|
|
|
|
//---------------------------------------------------------
|
|
|
|
#if defined( INCLUDE_SCALEFORM )
|
|
//--------------------------------------------------------
|
|
// scaleform interaction
|
|
//--------------------------------------------------------
|
|
|
|
void SetScaleformSlotViewport( int slot, int x, int y, int w, int h ) { ScaleformUI()->SetSlotViewport( slot, x, y, w, h ); }
|
|
void RenderScaleformSlot( int slot ) { ScaleformUI()->RenderSlot( slot ); }
|
|
void ForkRenderScaleformSlot( int slot ) { ScaleformUI()->ForkRenderSlot( slot ); }
|
|
void JoinRenderScaleformSlot( int slot ) { ScaleformUI()->JoinRenderSlot( slot ); }
|
|
|
|
void SetScaleformCursorViewport( int x, int y, int w, int h ) { ScaleformUI()->SetCursorViewport( x, y, w, h ); }
|
|
void RenderScaleformCursor( void ) { ScaleformUI()->RenderCursor(); }
|
|
|
|
void AdvanceAndRenderScaleformSlot( int slot ) { ScaleformUI()->AdvanceSlot( slot ); ScaleformUI()->RenderSlot( slot ); }
|
|
void AdvanceAndRenderScaleformCursor() { ScaleformUI()->AdvanceCursor(); ScaleformUI()->RenderCursor(); }
|
|
|
|
#endif // INCLUDE_SCALEFORM
|
|
|
|
DELEGATE_TO_OBJECT_1( ColorCorrectionHandle_t, FindLookup, const char *, g_pColorCorrectionSystem );
|
|
|
|
//---------------------------------------------------------
|
|
protected:
|
|
|
|
IMaterialInternal *GetMaterialInternal( MaterialHandle_t ) const;
|
|
IMaterialInternal *GetDrawFlatMaterial();
|
|
IMaterialInternal *GetRenderTargetBlitMaterial();
|
|
IMaterialInternal *GetBufferClearObeyStencil( int i );
|
|
IMaterialInternal *GetReloadZcullMaterial();
|
|
|
|
ShaderAPITextureHandle_t GetFullbrightLightmapTextureHandle() const;
|
|
ShaderAPITextureHandle_t GetFullbrightBumpedLightmapTextureHandle() const;
|
|
ShaderAPITextureHandle_t GetBlackTextureHandle() const;
|
|
ShaderAPITextureHandle_t GetBlackAlphaZeroTextureHandle() const;
|
|
ShaderAPITextureHandle_t GetFlatNormalTextureHandle() const;
|
|
ShaderAPITextureHandle_t GetFlatSSBumpTextureHandle() const;
|
|
ShaderAPITextureHandle_t GetGreyTextureHandle() const;
|
|
ShaderAPITextureHandle_t GetGreyAlphaZeroTextureHandle() const;
|
|
ShaderAPITextureHandle_t GetWhiteTextureHandle() const;
|
|
ShaderAPITextureHandle_t GetFrameBufferTextureHandle() const;
|
|
ShaderAPITextureHandle_t GetMaxDepthTextureHandle() const;
|
|
|
|
// Helper methods
|
|
void BindLightmap( Sampler_t stage, TextureBindFlags_t nBindFlags );
|
|
void BindBumpLightmap( Sampler_t stage, TextureBindFlags_t nBindFlags );
|
|
void BindFullbrightLightmap( Sampler_t stage, TextureBindFlags_t nBindFlags );
|
|
void BindBumpedFullbrightLightmap( Sampler_t stage, TextureBindFlags_t nBindFlags );
|
|
void BindPaintTexture( Sampler_t stage, TextureBindFlags_t nBindFlags );
|
|
|
|
virtual void OnRenderDataUnreferenced();
|
|
|
|
const CMatLightmaps *GetLightmaps() const;
|
|
CMatLightmaps *GetLightmaps();
|
|
|
|
const CMatPaintmaps *GetPaintmaps() const;
|
|
CMatPaintmaps *GetPaintmaps();
|
|
|
|
CUtlVector<PlaneStackElement> m_CustomClipPlanes; //implemented as a vector so we can remove in special ways
|
|
|
|
IMesh *m_pBatchIndices;
|
|
IMesh *m_pBatchMesh;
|
|
IIndexBuffer *m_pCurrentIndexBuffer;
|
|
|
|
CTextureReference m_pNonInteractiveTempFullscreenBuffer[MATERIAL_NON_INTERACTIVE_MODE_COUNT];
|
|
CTextureReference m_pNonInteractivePacifier;
|
|
CTextureReference m_pNonInteractiveLogo;
|
|
|
|
MaterialNonInteractiveMode_t m_NonInteractiveMode;
|
|
|
|
float m_flNormalizedX;
|
|
float m_flNormalizedY;
|
|
float m_flNormalizedSize;
|
|
|
|
float m_flLogoNormalizedX;
|
|
float m_flLogoNormalizedY;
|
|
float m_flLogoNormalizedW;
|
|
float m_flLogoNormalizedH;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline void CMatRenderContext::LoadBoneMatrix( int boneIndex, const matrix3x4_t& matrix )
|
|
{
|
|
g_pShaderAPI->LoadBoneMatrix( boneIndex, matrix.Base() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
inline bool CMatRenderContext::InFlashlightMode() const
|
|
{
|
|
return m_bFlashlightEnable;
|
|
}
|
|
|
|
inline bool CMatRenderContext::IsRenderingPaint() const
|
|
{
|
|
return m_bRenderingPaint;
|
|
}
|
|
|
|
inline void CMatRenderContext::SetFlashlightState( const FlashlightState_t &state, const VMatrix &worldToTexture )
|
|
{
|
|
SetFlashlightStateEx( state, worldToTexture, NULL );
|
|
}
|
|
|
|
inline bool CMatRenderContext::IsCascadedShadowMapping() const
|
|
{
|
|
return m_bCascadedShadowMappingEnabled;
|
|
}
|
|
|
|
inline void CMatRenderContext::SetCascadedShadowMapping( bool bEnable )
|
|
{
|
|
m_bCascadedShadowMappingEnabled = bEnable;
|
|
}
|
|
|
|
inline float CMatRenderContextBase::ComputePixelWidthOfSphere( const Vector& vecOrigin, float flRadius )
|
|
{
|
|
return ComputePixelDiameterOfSphere( vecOrigin, flRadius ) * 2.0f;
|
|
}
|
|
|
|
inline void CMatRenderContext::FogColor3ubv( unsigned char const* rgb )
|
|
{
|
|
g_pShaderAPI->SceneFogColor3ub( rgb[0], rgb[1], rgb[2] );
|
|
}
|
|
|
|
inline void CMatRenderContext::FogMaxDensity( float flMaxDensity )
|
|
{
|
|
g_pShaderAPI->FogMaxDensity( flMaxDensity );
|
|
}
|
|
|
|
inline ITexture *CMatRenderContext::GetLocalCubemap( void )
|
|
{
|
|
return m_pLocalCubemapTexture;
|
|
}
|
|
|
|
inline void CMatRenderContextBase::SetRenderTarget( ITexture *pTexture_ )
|
|
{
|
|
SetRenderTargetEx( 0, pTexture_ );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets the bound morph's vertex format; returns 0 if no morph is bound
|
|
//-----------------------------------------------------------------------------
|
|
inline MorphFormat_t CMatRenderContext::GetBoundMorphFormat()
|
|
{
|
|
return m_pBoundMorph ? m_pBoundMorph->GetMorphFormat() : 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Use this to create static vertex and index buffers
|
|
//-----------------------------------------------------------------------------
|
|
inline IMesh* CMatRenderContext::CreateStaticMesh( VertexFormat_t vertexFormat, const char *pTextureBudgetGroup, IMaterial * pMaterial, VertexStreamSpec_t *pStreamSpec )
|
|
{
|
|
return g_pShaderDevice->CreateStaticMesh( vertexFormat, pTextureBudgetGroup, pMaterial, pStreamSpec );
|
|
}
|
|
|
|
inline void CMatRenderContext::SyncToken( const char *pToken )
|
|
{
|
|
#if !defined( _PS3 ) && !defined( _OSX )
|
|
if ( g_pShaderAPI )
|
|
#endif
|
|
{
|
|
g_pShaderAPI->SyncToken( pToken );
|
|
}
|
|
}
|
|
|
|
inline enum MaterialHeightClipMode_t CMatRenderContextBase::GetHeightClipMode( void )
|
|
{
|
|
return m_HeightClipMode;
|
|
}
|
|
|
|
inline int CMatRenderContextBase::GetLightmapPage( void )
|
|
{
|
|
return m_lightmapPageID;
|
|
}
|
|
|
|
inline CMaterialSystem *CMatRenderContext::GetMaterialSystem() const
|
|
{
|
|
return m_pMaterialSystem;
|
|
}
|
|
|
|
#if defined( _PS3 ) || defined( _OSX )
|
|
#undef g_pShaderAPI
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#endif // CMATERIALRENDERSTATE_H
|