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.
1461 lines
38 KiB
1461 lines
38 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// |
|
// Purpose: |
|
// |
|
// $NoKeywords: $ |
|
// |
|
//===========================================================================// |
|
|
|
#include "shaderapidx10.h" |
|
#include "shaderapibase.h" |
|
#include "shaderapi/ishaderutil.h" |
|
#include "materialsystem/idebugtextureinfo.h" |
|
#include "materialsystem/materialsystem_config.h" |
|
#include "meshdx10.h" |
|
#include "shadershadowdx10.h" |
|
#include "shaderdevicedx10.h" |
|
#include "shaderapidx10_global.h" |
|
#include "imaterialinternal.h" |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Methods related to queuing functions to be called prior to rendering |
|
//----------------------------------------------------------------------------- |
|
CFunctionCommit::CFunctionCommit() |
|
{ |
|
m_pCommitFlags = NULL; |
|
m_nCommitBufferSize = 0; |
|
} |
|
|
|
CFunctionCommit::~CFunctionCommit() |
|
{ |
|
if ( m_pCommitFlags ) |
|
{ |
|
delete[] m_pCommitFlags; |
|
m_pCommitFlags = NULL; |
|
} |
|
} |
|
|
|
void CFunctionCommit::Init( int nFunctionCount ) |
|
{ |
|
m_nCommitBufferSize = ( nFunctionCount + 7 ) >> 3; |
|
Assert( !m_pCommitFlags ); |
|
m_pCommitFlags = new unsigned char[ m_nCommitBufferSize ]; |
|
memset( m_pCommitFlags, 0, m_nCommitBufferSize ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Methods related to queuing functions to be called per-(pMesh->Draw call) or per-pass |
|
//----------------------------------------------------------------------------- |
|
inline bool CFunctionCommit::IsCommitFuncInUse( int nFunc ) const |
|
{ |
|
Assert( nFunc >> 3 < m_nCommitBufferSize ); |
|
return ( m_pCommitFlags[ nFunc >> 3 ] & ( 1 << ( nFunc & 0x7 ) ) ) != 0; |
|
} |
|
|
|
inline void CFunctionCommit::MarkCommitFuncInUse( int nFunc ) |
|
{ |
|
Assert( nFunc >> 3 < m_nCommitBufferSize ); |
|
m_pCommitFlags[ nFunc >> 3 ] |= 1 << ( nFunc & 0x7 ); |
|
} |
|
|
|
inline void CFunctionCommit::AddCommitFunc( StateCommitFunc_t f ) |
|
{ |
|
m_CommitFuncs.AddToTail( f ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Clears all commit functions |
|
//----------------------------------------------------------------------------- |
|
inline void CFunctionCommit::ClearAllCommitFuncs( ) |
|
{ |
|
memset( m_pCommitFlags, 0, m_nCommitBufferSize ); |
|
m_CommitFuncs.RemoveAll(); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Calls all commit functions in a particular list |
|
//----------------------------------------------------------------------------- |
|
void CFunctionCommit::CallCommitFuncs( ID3D10Device *pDevice, const ShaderStateDx10_t &desiredState, ShaderStateDx10_t ¤tState, bool bForce ) |
|
{ |
|
int nCount = m_CommitFuncs.Count(); |
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
m_CommitFuncs[i]( pDevice, desiredState, currentState, bForce ); |
|
} |
|
|
|
ClearAllCommitFuncs( ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Helpers for commit functions |
|
//----------------------------------------------------------------------------- |
|
#define ADD_COMMIT_FUNC( _func_name ) \ |
|
if ( !m_Commit.IsCommitFuncInUse( COMMIT_FUNC_ ## _func_name ) ) \ |
|
{ \ |
|
m_Commit.AddCommitFunc( _func_name ); \ |
|
m_Commit.MarkCommitFuncInUse( COMMIT_FUNC_ ## _func_name ); \ |
|
} |
|
|
|
#define ADD_RENDERSTATE_FUNC( _func_name, _state, _val ) \ |
|
if ( m_bResettingRenderState || ( m_DesiredState. ## _state != _val ) ) \ |
|
{ \ |
|
m_DesiredState. ## _state = _val; \ |
|
ADD_COMMIT_FUNC( _func_name ) \ |
|
} |
|
|
|
#define IMPLEMENT_RENDERSTATE_FUNC( _func_name, _state, _d3dFunc ) \ |
|
static void _func_name( ID3D10Device *pDevice, const ShaderStateDx10_t &desiredState, ShaderStateDx10_t ¤tState, bool bForce ) \ |
|
{ \ |
|
if ( bForce || ( desiredState. ## _state != currentState. ## _state ) ) \ |
|
{ \ |
|
pDevice->_d3dFunc( desiredState. ## _state ); \ |
|
currentState. ## _state = desiredState. ## _state; \ |
|
} \ |
|
} |
|
|
|
//----------------------------------------------------------------------------- |
|
// D3D state setting methods |
|
//----------------------------------------------------------------------------- |
|
|
|
// NOTE: For each commit func you create, add to this enumeration. |
|
enum CommitFunc_t |
|
{ |
|
COMMIT_FUNC_CommitSetViewports = 0, |
|
COMMIT_FUNC_CommitSetVertexShader, |
|
COMMIT_FUNC_CommitSetGeometryShader, |
|
COMMIT_FUNC_CommitSetPixelShader, |
|
COMMIT_FUNC_CommitSetVertexBuffer, |
|
COMMIT_FUNC_CommitSetIndexBuffer, |
|
COMMIT_FUNC_CommitSetInputLayout, |
|
COMMIT_FUNC_CommitSetTopology, |
|
COMMIT_FUNC_CommitSetRasterState, |
|
|
|
COMMIT_FUNC_COUNT, |
|
}; |
|
|
|
IMPLEMENT_RENDERSTATE_FUNC( CommitSetTopology, m_Topology, IASetPrimitiveTopology ) |
|
IMPLEMENT_RENDERSTATE_FUNC( CommitSetVertexShader, m_pVertexShader, VSSetShader ) |
|
IMPLEMENT_RENDERSTATE_FUNC( CommitSetGeometryShader, m_pGeometryShader, GSSetShader ) |
|
IMPLEMENT_RENDERSTATE_FUNC( CommitSetPixelShader, m_pPixelShader, PSSetShader ) |
|
|
|
static void CommitSetInputLayout( ID3D10Device *pDevice, const ShaderStateDx10_t &desiredState, ShaderStateDx10_t ¤tState, bool bForce ) |
|
{ |
|
const ShaderInputLayoutStateDx10_t& newState = desiredState.m_InputLayout; |
|
if ( bForce || memcmp( &newState, ¤tState.m_InputLayout, sizeof(ShaderInputLayoutStateDx10_t) ) ) |
|
{ |
|
// FIXME: Deal with multiple streams |
|
ID3D10InputLayout *pInputLayout = g_pShaderDeviceDx10->GetInputLayout( |
|
newState.m_hVertexShader, newState.m_pVertexDecl[0] ); |
|
pDevice->IASetInputLayout( pInputLayout ); |
|
|
|
currentState.m_InputLayout = newState; |
|
} |
|
} |
|
|
|
static void CommitSetViewports( ID3D10Device *pDevice, const ShaderStateDx10_t &desiredState, ShaderStateDx10_t ¤tState, bool bForce ) |
|
{ |
|
bool bChanged = bForce || ( desiredState.m_nViewportCount != currentState.m_nViewportCount ); |
|
if ( !bChanged && desiredState.m_nViewportCount > 0 ) |
|
{ |
|
bChanged = memcmp( desiredState.m_pViewports, currentState.m_pViewports, |
|
desiredState.m_nViewportCount * sizeof( D3D10_VIEWPORT ) ) != 0; |
|
} |
|
|
|
if ( !bChanged ) |
|
return; |
|
|
|
pDevice->RSSetViewports( desiredState.m_nViewportCount, desiredState.m_pViewports ); |
|
currentState.m_nViewportCount = desiredState.m_nViewportCount; |
|
|
|
#ifdef _DEBUG |
|
memset( currentState.m_pViewports, 0xDD, sizeof( currentState.m_pViewports ) ); |
|
#endif |
|
|
|
memcpy( currentState.m_pViewports, desiredState.m_pViewports, |
|
desiredState.m_nViewportCount * sizeof( D3D10_VIEWPORT ) ); |
|
} |
|
|
|
static void CommitSetIndexBuffer( ID3D10Device *pDevice, const ShaderStateDx10_t &desiredState, ShaderStateDx10_t ¤tState, bool bForce ) |
|
{ |
|
const ShaderIndexBufferStateDx10_t &newState = desiredState.m_IndexBuffer; |
|
bool bChanged = bForce || memcmp( &newState, ¤tState.m_IndexBuffer, sizeof(ShaderIndexBufferStateDx10_t) ); |
|
if ( !bChanged ) |
|
return; |
|
|
|
pDevice->IASetIndexBuffer( newState.m_pBuffer, newState.m_Format, newState.m_nOffset ); |
|
memcpy( ¤tState.m_IndexBuffer, &newState, sizeof( ShaderIndexBufferStateDx10_t ) ); |
|
} |
|
|
|
static void CommitSetVertexBuffer( ID3D10Device *pDevice, const ShaderStateDx10_t &desiredState, ShaderStateDx10_t ¤tState, bool bForce ) |
|
{ |
|
ID3D10Buffer *ppVertexBuffers[ MAX_DX10_STREAMS ]; |
|
UINT pStrides[ MAX_DX10_STREAMS ]; |
|
UINT pOffsets[ MAX_DX10_STREAMS ]; |
|
|
|
UINT nFirstBuffer = 0; |
|
UINT nBufferCount = 0; |
|
bool bInMatch = true; |
|
for ( int i = 0; i < MAX_DX10_STREAMS; ++i ) |
|
{ |
|
const ShaderVertexBufferStateDx10_t &newState = desiredState.m_pVertexBuffer[i]; |
|
bool bMatch = !bForce && !memcmp( &newState, ¤tState.m_pVertexBuffer[i], sizeof(ShaderVertexBufferStateDx10_t) ); |
|
if ( !bMatch ) |
|
{ |
|
ppVertexBuffers[i] = newState.m_pBuffer; |
|
pStrides[i] = newState.m_nStride; |
|
pOffsets[i] = newState.m_nOffset; |
|
++nBufferCount; |
|
memcpy( ¤tState.m_pVertexBuffer[i], &newState, sizeof( ShaderVertexBufferStateDx10_t ) ); |
|
} |
|
|
|
if ( bInMatch ) |
|
{ |
|
if ( !bMatch ) |
|
{ |
|
bInMatch = false; |
|
nFirstBuffer = i; |
|
} |
|
continue; |
|
} |
|
|
|
if ( bMatch ) |
|
{ |
|
bInMatch = true; |
|
pDevice->IASetVertexBuffers( nFirstBuffer, nBufferCount, |
|
&ppVertexBuffers[nFirstBuffer], &pStrides[nFirstBuffer], &pOffsets[nFirstBuffer] ); |
|
nBufferCount = 0; |
|
} |
|
} |
|
|
|
if ( !bInMatch ) |
|
{ |
|
pDevice->IASetVertexBuffers( nFirstBuffer, nBufferCount, |
|
&ppVertexBuffers[nFirstBuffer], &pStrides[nFirstBuffer], &pOffsets[nFirstBuffer] ); |
|
} |
|
} |
|
|
|
static void GenerateRasterizerDesc( D3D10_RASTERIZER_DESC* pDesc, const ShaderRasterState_t& state ) |
|
{ |
|
pDesc->FillMode = ( state.m_FillMode == SHADER_FILL_WIREFRAME ) ? D3D10_FILL_WIREFRAME : D3D10_FILL_SOLID; |
|
|
|
// Cull state |
|
if ( state.m_bCullEnable ) |
|
{ |
|
pDesc->CullMode = D3D10_CULL_NONE; |
|
} |
|
else |
|
{ |
|
pDesc->CullMode = ( state.m_CullMode == MATERIAL_CULLMODE_CW ) ? D3D10_CULL_BACK : D3D10_CULL_FRONT; |
|
} |
|
pDesc->FrontCounterClockwise = TRUE; |
|
|
|
// Depth bias state |
|
if ( !state.m_bDepthBias ) |
|
{ |
|
pDesc->DepthBias = 0; |
|
pDesc->DepthBiasClamp = 0.0f; |
|
pDesc->SlopeScaledDepthBias = 0.0f; |
|
pDesc->DepthClipEnable = FALSE; |
|
} |
|
else |
|
{ |
|
// FIXME: Implement! Read ConVars |
|
} |
|
|
|
pDesc->ScissorEnable = state.m_bScissorEnable ? TRUE : FALSE; |
|
pDesc->MultisampleEnable = state.m_bMultisampleEnable ? TRUE : FALSE; |
|
pDesc->AntialiasedLineEnable = FALSE; |
|
} |
|
|
|
static void CommitSetRasterState( ID3D10Device *pDevice, const ShaderStateDx10_t &desiredState, ShaderStateDx10_t ¤tState, bool bForce ) |
|
{ |
|
const ShaderRasterState_t& newState = desiredState.m_RasterState; |
|
if ( bForce || memcmp( &newState, ¤tState.m_RasterState, sizeof(ShaderRasterState_t) ) ) |
|
{ |
|
// Clear out the existing state |
|
if ( currentState.m_pRasterState ) |
|
{ |
|
currentState.m_pRasterState->Release(); |
|
} |
|
|
|
D3D10_RASTERIZER_DESC desc; |
|
GenerateRasterizerDesc( &desc, newState ); |
|
|
|
// NOTE: This does a search for existing matching state objects |
|
ID3D10RasterizerState *pState = NULL; |
|
HRESULT hr = pDevice->CreateRasterizerState( &desc, &pState ); |
|
if ( !FAILED(hr) ) |
|
{ |
|
Warning( "Unable to create rasterizer state object!\n" ); |
|
} |
|
|
|
pDevice->RSSetState( pState ); |
|
|
|
currentState.m_pRasterState = pState; |
|
memcpy( ¤tState.m_RasterState, &newState, sizeof( ShaderRasterState_t ) ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
// Shader API Dx10 |
|
// |
|
//----------------------------------------------------------------------------- |
|
|
|
//----------------------------------------------------------------------------- |
|
// Class Factory |
|
//----------------------------------------------------------------------------- |
|
static CShaderAPIDx10 s_ShaderAPIDx10; |
|
CShaderAPIDx10* g_pShaderAPIDx10 = &s_ShaderAPIDx10; |
|
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderAPIDx10, IShaderAPI, |
|
SHADERAPI_INTERFACE_VERSION, s_ShaderAPIDx10 ) |
|
|
|
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderAPIDx10, IDebugTextureInfo, |
|
DEBUG_TEXTURE_INFO_VERSION, s_ShaderAPIDx10 ) |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Constructor, destructor |
|
//----------------------------------------------------------------------------- |
|
CShaderAPIDx10::CShaderAPIDx10() |
|
{ |
|
m_bResettingRenderState = false; |
|
m_Commit.Init( COMMIT_FUNC_COUNT ); |
|
ClearShaderState( &m_DesiredState ); |
|
ClearShaderState( &m_CurrentState ); |
|
} |
|
|
|
CShaderAPIDx10::~CShaderAPIDx10() |
|
{ |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Clears the shader state to a well-defined value |
|
//----------------------------------------------------------------------------- |
|
void CShaderAPIDx10::ClearShaderState( ShaderStateDx10_t* pState ) |
|
{ |
|
memset( pState, 0, sizeof( ShaderStateDx10_t ) ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Resets the render state |
|
//----------------------------------------------------------------------------- |
|
void CShaderAPIDx10::ResetRenderState( bool bFullReset ) |
|
{ |
|
D3D10_RASTERIZER_DESC rDesc; |
|
memset( &rDesc, 0, sizeof(rDesc) ); |
|
rDesc.FillMode = D3D10_FILL_SOLID; |
|
rDesc.CullMode = D3D10_CULL_NONE; |
|
rDesc.FrontCounterClockwise = TRUE; // right-hand rule |
|
|
|
ID3D10RasterizerState *pRasterizerState; |
|
HRESULT hr = D3D10Device()->CreateRasterizerState( &rDesc, &pRasterizerState ); |
|
Assert( !FAILED(hr) ); |
|
D3D10Device()->RSSetState( pRasterizerState ); |
|
|
|
D3D10_DEPTH_STENCIL_DESC dsDesc; |
|
memset( &dsDesc, 0, sizeof(dsDesc) ); |
|
|
|
ID3D10DepthStencilState *pDepthStencilState; |
|
hr = D3D10Device()->CreateDepthStencilState( &dsDesc, &pDepthStencilState ); |
|
Assert( !FAILED(hr) ); |
|
D3D10Device()->OMSetDepthStencilState( pDepthStencilState, 0 ); |
|
|
|
D3D10_BLEND_DESC bDesc; |
|
memset( &bDesc, 0, sizeof(bDesc) ); |
|
bDesc.SrcBlend = D3D10_BLEND_ONE; |
|
bDesc.DestBlend = D3D10_BLEND_ZERO; |
|
bDesc.BlendOp = D3D10_BLEND_OP_ADD; |
|
bDesc.SrcBlendAlpha = D3D10_BLEND_ONE; |
|
bDesc.DestBlendAlpha = D3D10_BLEND_ZERO; |
|
bDesc.BlendOpAlpha = D3D10_BLEND_OP_ADD; |
|
bDesc.RenderTargetWriteMask[0] = D3D10_COLOR_WRITE_ENABLE_ALL; |
|
|
|
FLOAT pBlendFactor[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; |
|
ID3D10BlendState *pBlendState; |
|
hr = D3D10Device()->CreateBlendState( &bDesc, &pBlendState ); |
|
Assert( !FAILED(hr) ); |
|
D3D10Device()->OMSetBlendState( pBlendState, pBlendFactor, 0xFFFFFFFF ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Commits queued-up state change requests |
|
//----------------------------------------------------------------------------- |
|
void CShaderAPIDx10::CommitStateChanges( bool bForce ) |
|
{ |
|
// Don't bother committing anything if we're deactivated |
|
if ( g_pShaderDevice->IsDeactivated() ) |
|
return; |
|
|
|
m_Commit.CallCommitFuncs( D3D10Device(), m_DesiredState, m_CurrentState, bForce ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Methods of IShaderDynamicAPI |
|
//----------------------------------------------------------------------------- |
|
void CShaderAPIDx10::GetBackBufferDimensions( int& nWidth, int& nHeight ) const |
|
{ |
|
g_pShaderDeviceDx10->GetBackBufferDimensions( nWidth, nHeight ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Viewport-related methods |
|
//----------------------------------------------------------------------------- |
|
void CShaderAPIDx10::SetViewports( int nCount, const ShaderViewport_t* pViewports ) |
|
{ |
|
nCount = min( nCount, MAX_DX10_VIEWPORTS ); |
|
m_DesiredState.m_nViewportCount = nCount; |
|
|
|
for ( int i = 0; i < nCount; ++i ) |
|
{ |
|
Assert( pViewports[i].m_nVersion == SHADER_VIEWPORT_VERSION ); |
|
|
|
D3D10_VIEWPORT& viewport = m_DesiredState.m_pViewports[i]; |
|
viewport.TopLeftX = pViewports[i].m_nTopLeftX; |
|
viewport.TopLeftY = pViewports[i].m_nTopLeftY; |
|
viewport.Width = pViewports[i].m_nWidth; |
|
viewport.Height = pViewports[i].m_nHeight; |
|
viewport.MinDepth = pViewports[i].m_flMinZ; |
|
viewport.MaxDepth = pViewports[i].m_flMaxZ; |
|
} |
|
|
|
ADD_COMMIT_FUNC( CommitSetViewports ); |
|
} |
|
|
|
int CShaderAPIDx10::GetViewports( ShaderViewport_t* pViewports, int nMax ) const |
|
{ |
|
int nCount = m_DesiredState.m_nViewportCount; |
|
if ( pViewports && nMax ) |
|
{ |
|
nCount = min( nCount, nMax ); |
|
memcpy( pViewports, m_DesiredState.m_pViewports, nCount * sizeof( ShaderViewport_t ) ); |
|
} |
|
return nCount; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Methods related to state objects |
|
//----------------------------------------------------------------------------- |
|
void CShaderAPIDx10::SetRasterState( const ShaderRasterState_t& state ) |
|
{ |
|
if ( memcmp( &state, &m_DesiredState.m_RasterState, sizeof(ShaderRasterState_t) ) ) |
|
{ |
|
memcpy( &m_DesiredState.m_RasterState, &state, sizeof(ShaderRasterState_t) ); |
|
ADD_COMMIT_FUNC( CommitSetRasterState ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Methods related to clearing buffers |
|
//----------------------------------------------------------------------------- |
|
void CShaderAPIDx10::ClearColor3ub( unsigned char r, unsigned char g, unsigned char b ) |
|
{ |
|
m_DesiredState.m_ClearColor[0] = r / 255.0f; |
|
m_DesiredState.m_ClearColor[1] = g / 255.0f; |
|
m_DesiredState.m_ClearColor[2] = b / 255.0f; |
|
m_DesiredState.m_ClearColor[3] = 1.0f; |
|
} |
|
|
|
void CShaderAPIDx10::ClearColor4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a ) |
|
{ |
|
m_DesiredState.m_ClearColor[0] = r / 255.0f; |
|
m_DesiredState.m_ClearColor[1] = g / 255.0f; |
|
m_DesiredState.m_ClearColor[2] = b / 255.0f; |
|
m_DesiredState.m_ClearColor[3] = a / 255.0f; |
|
} |
|
|
|
void CShaderAPIDx10::ClearBuffers( bool bClearColor, bool bClearDepth, bool bClearStencil, int renderTargetWidth, int renderTargetHeight ) |
|
{ |
|
// NOTE: State change commit isn't necessary since clearing doesn't use state |
|
// CommitStateChanges(); |
|
|
|
// FIXME: This implementation is totally bust0red [doesn't guarantee exact color specified] |
|
if ( bClearColor ) |
|
{ |
|
D3D10Device()->ClearRenderTargetView( D3D10RenderTargetView(), m_DesiredState.m_ClearColor ); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Methods related to binding shaders |
|
//----------------------------------------------------------------------------- |
|
void CShaderAPIDx10::BindVertexShader( VertexShaderHandle_t hVertexShader ) |
|
{ |
|
ID3D10VertexShader *pVertexShader = g_pShaderDeviceDx10->GetVertexShader( hVertexShader ); |
|
ADD_RENDERSTATE_FUNC( CommitSetVertexShader, m_pVertexShader, pVertexShader ); |
|
|
|
if ( m_bResettingRenderState || ( m_DesiredState.m_InputLayout.m_hVertexShader != hVertexShader ) ) |
|
{ |
|
m_DesiredState.m_InputLayout.m_hVertexShader = hVertexShader; |
|
ADD_COMMIT_FUNC( CommitSetInputLayout ); |
|
} |
|
} |
|
|
|
void CShaderAPIDx10::BindGeometryShader( GeometryShaderHandle_t hGeometryShader ) |
|
{ |
|
ID3D10GeometryShader *pGeometryShader = g_pShaderDeviceDx10->GetGeometryShader( hGeometryShader ); |
|
ADD_RENDERSTATE_FUNC( CommitSetGeometryShader, m_pGeometryShader, pGeometryShader ); |
|
} |
|
|
|
void CShaderAPIDx10::BindPixelShader( PixelShaderHandle_t hPixelShader ) |
|
{ |
|
ID3D10PixelShader *pPixelShader = g_pShaderDeviceDx10->GetPixelShader( hPixelShader ); |
|
ADD_RENDERSTATE_FUNC( CommitSetPixelShader, m_pPixelShader, pPixelShader ); |
|
} |
|
|
|
void CShaderAPIDx10::BindVertexBuffer( int nStreamID, IVertexBuffer *pVertexBuffer, int nOffsetInBytes, int nFirstVertex, int nVertexCount, VertexFormat_t fmt, int nRepetitions ) |
|
{ |
|
// FIXME: What to do about repetitions? |
|
CVertexBufferDx10 *pVertexBufferDx10 = static_cast<CVertexBufferDx10 *>( pVertexBuffer ); |
|
|
|
ShaderVertexBufferStateDx10_t state; |
|
if ( pVertexBufferDx10 ) |
|
{ |
|
state.m_pBuffer = pVertexBufferDx10->GetDx10Buffer(); |
|
state.m_nStride = pVertexBufferDx10->VertexSize(); |
|
} |
|
else |
|
{ |
|
state.m_pBuffer = NULL; |
|
state.m_nStride = 0; |
|
} |
|
state.m_nOffset = nOffsetInBytes; |
|
|
|
if ( m_bResettingRenderState || memcmp( &m_DesiredState.m_pVertexBuffer[ nStreamID ], &state, sizeof( ShaderVertexBufferStateDx10_t ) ) ) |
|
{ |
|
m_DesiredState.m_pVertexBuffer[ nStreamID ] = state; |
|
ADD_COMMIT_FUNC( CommitSetVertexBuffer ); |
|
} |
|
|
|
if ( m_bResettingRenderState || ( m_DesiredState.m_InputLayout.m_pVertexDecl[ nStreamID ] != fmt ) ) |
|
{ |
|
m_DesiredState.m_InputLayout.m_pVertexDecl[ nStreamID ] = fmt; |
|
ADD_COMMIT_FUNC( CommitSetInputLayout ); |
|
} |
|
} |
|
|
|
void CShaderAPIDx10::BindIndexBuffer( IIndexBuffer *pIndexBuffer, int nOffsetInBytes ) |
|
{ |
|
CIndexBufferDx10 *pIndexBufferDx10 = static_cast<CIndexBufferDx10 *>( pIndexBuffer ); |
|
|
|
ShaderIndexBufferStateDx10_t state; |
|
if ( pIndexBufferDx10 ) |
|
{ |
|
state.m_pBuffer = pIndexBufferDx10->GetDx10Buffer(); |
|
state.m_Format = ( pIndexBufferDx10->GetIndexFormat() == MATERIAL_INDEX_FORMAT_16BIT ) ? |
|
DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT; |
|
} |
|
else |
|
{ |
|
state.m_pBuffer = NULL; |
|
state.m_Format = DXGI_FORMAT_R16_UINT; |
|
} |
|
state.m_nOffset = nOffsetInBytes; |
|
|
|
ADD_RENDERSTATE_FUNC( CommitSetIndexBuffer, m_IndexBuffer, state ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Unbinds resources because they are about to be deleted |
|
//----------------------------------------------------------------------------- |
|
void CShaderAPIDx10::Unbind( VertexShaderHandle_t hShader ) |
|
{ |
|
ID3D10VertexShader* pShader = g_pShaderDeviceDx10->GetVertexShader( hShader ); |
|
Assert ( pShader ); |
|
if ( m_DesiredState.m_pVertexShader == pShader ) |
|
{ |
|
BindVertexShader( VERTEX_SHADER_HANDLE_INVALID ); |
|
} |
|
if ( m_CurrentState.m_pVertexShader == pShader ) |
|
{ |
|
CommitStateChanges(); |
|
} |
|
} |
|
|
|
void CShaderAPIDx10::Unbind( GeometryShaderHandle_t hShader ) |
|
{ |
|
ID3D10GeometryShader* pShader = g_pShaderDeviceDx10->GetGeometryShader( hShader ); |
|
Assert ( pShader ); |
|
if ( m_DesiredState.m_pGeometryShader == pShader ) |
|
{ |
|
BindGeometryShader( GEOMETRY_SHADER_HANDLE_INVALID ); |
|
} |
|
if ( m_CurrentState.m_pGeometryShader == pShader ) |
|
{ |
|
CommitStateChanges(); |
|
} |
|
} |
|
|
|
void CShaderAPIDx10::Unbind( PixelShaderHandle_t hShader ) |
|
{ |
|
ID3D10PixelShader* pShader = g_pShaderDeviceDx10->GetPixelShader( hShader ); |
|
Assert ( pShader ); |
|
if ( m_DesiredState.m_pPixelShader == pShader ) |
|
{ |
|
BindPixelShader( PIXEL_SHADER_HANDLE_INVALID ); |
|
} |
|
if ( m_CurrentState.m_pPixelShader == pShader ) |
|
{ |
|
CommitStateChanges(); |
|
} |
|
} |
|
|
|
void CShaderAPIDx10::UnbindVertexBuffer( ID3D10Buffer *pBuffer ) |
|
{ |
|
Assert ( pBuffer ); |
|
|
|
for ( int i = 0; i < MAX_DX10_STREAMS; ++i ) |
|
{ |
|
if ( m_DesiredState.m_pVertexBuffer[i].m_pBuffer == pBuffer ) |
|
{ |
|
BindVertexBuffer( i, NULL, 0, 0, 0, VERTEX_POSITION, 0 ); |
|
} |
|
} |
|
for ( int i = 0; i < MAX_DX10_STREAMS; ++i ) |
|
{ |
|
if ( m_CurrentState.m_pVertexBuffer[i].m_pBuffer == pBuffer ) |
|
{ |
|
CommitStateChanges(); |
|
break; |
|
} |
|
} |
|
} |
|
|
|
void CShaderAPIDx10::UnbindIndexBuffer( ID3D10Buffer *pBuffer ) |
|
{ |
|
Assert ( pBuffer ); |
|
|
|
if ( m_DesiredState.m_IndexBuffer.m_pBuffer == pBuffer ) |
|
{ |
|
BindIndexBuffer( NULL, 0 ); |
|
} |
|
if ( m_CurrentState.m_IndexBuffer.m_pBuffer == pBuffer ) |
|
{ |
|
CommitStateChanges(); |
|
} |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Sets the topology state |
|
//----------------------------------------------------------------------------- |
|
void CShaderAPIDx10::SetTopology( MaterialPrimitiveType_t topology ) |
|
{ |
|
D3D10_PRIMITIVE_TOPOLOGY d3dTopology; |
|
switch( topology ) |
|
{ |
|
case MATERIAL_POINTS: |
|
d3dTopology = D3D10_PRIMITIVE_TOPOLOGY_POINTLIST; |
|
break; |
|
|
|
case MATERIAL_LINES: |
|
d3dTopology = D3D10_PRIMITIVE_TOPOLOGY_LINELIST; |
|
break; |
|
|
|
case MATERIAL_TRIANGLES: |
|
d3dTopology = D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST; |
|
break; |
|
|
|
case MATERIAL_TRIANGLE_STRIP: |
|
d3dTopology = D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; |
|
break; |
|
|
|
case MATERIAL_LINE_STRIP: |
|
d3dTopology = D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP; |
|
break; |
|
|
|
default: |
|
case MATERIAL_LINE_LOOP: |
|
case MATERIAL_POLYGON: |
|
case MATERIAL_QUADS: |
|
Assert( 0 ); |
|
d3dTopology = D3D10_PRIMITIVE_TOPOLOGY_UNDEFINED; |
|
break; |
|
} |
|
|
|
ADD_RENDERSTATE_FUNC( CommitSetTopology, m_Topology, d3dTopology ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Main entry point for rendering |
|
//----------------------------------------------------------------------------- |
|
void CShaderAPIDx10::Draw( MaterialPrimitiveType_t primitiveType, int nFirstIndex, int nIndexCount ) |
|
{ |
|
SetTopology( primitiveType ); |
|
|
|
CommitStateChanges(); |
|
|
|
// FIXME: How do I set the base vertex location!? |
|
D3D10Device()->DrawIndexed( (UINT)nIndexCount, (UINT)nFirstIndex, 0 ); |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// |
|
// Abandon all hope below this point |
|
// |
|
//----------------------------------------------------------------------------- |
|
|
|
bool CShaderAPIDx10::DoRenderTargetsNeedSeparateDepthBuffer() const |
|
{ |
|
return false; |
|
} |
|
|
|
// Can we download textures? |
|
bool CShaderAPIDx10::CanDownloadTextures() const |
|
{ |
|
return false; |
|
} |
|
|
|
// Used to clear the transition table when we know it's become invalid. |
|
void CShaderAPIDx10::ClearSnapshots() |
|
{ |
|
} |
|
|
|
// Sets the default *dynamic* state |
|
void CShaderAPIDx10::SetDefaultState() |
|
{ |
|
} |
|
|
|
|
|
// Returns the snapshot id for the shader state |
|
StateSnapshot_t CShaderAPIDx10::TakeSnapshot( ) |
|
{ |
|
StateSnapshot_t id = 0; |
|
if (g_pShaderShadowDx10->m_IsTranslucent) |
|
id |= TRANSLUCENT; |
|
if (g_pShaderShadowDx10->m_IsAlphaTested) |
|
id |= ALPHATESTED; |
|
if (g_pShaderShadowDx10->m_bUsesVertexAndPixelShaders) |
|
id |= VERTEX_AND_PIXEL_SHADERS; |
|
if (g_pShaderShadowDx10->m_bIsDepthWriteEnabled) |
|
id |= DEPTHWRITE; |
|
return id; |
|
} |
|
|
|
// Returns true if the state snapshot is transparent |
|
bool CShaderAPIDx10::IsTranslucent( StateSnapshot_t id ) const |
|
{ |
|
return (id & TRANSLUCENT) != 0; |
|
} |
|
|
|
bool CShaderAPIDx10::IsAlphaTested( StateSnapshot_t id ) const |
|
{ |
|
return (id & ALPHATESTED) != 0; |
|
} |
|
|
|
bool CShaderAPIDx10::IsDepthWriteEnabled( StateSnapshot_t id ) const |
|
{ |
|
return (id & DEPTHWRITE) != 0; |
|
} |
|
|
|
bool CShaderAPIDx10::UsesVertexAndPixelShaders( StateSnapshot_t id ) const |
|
{ |
|
return (id & VERTEX_AND_PIXEL_SHADERS) != 0; |
|
} |
|
|
|
// Gets the vertex format for a set of snapshot ids |
|
VertexFormat_t CShaderAPIDx10::ComputeVertexFormat( int numSnapshots, StateSnapshot_t* pIds ) const |
|
{ |
|
return 0; |
|
} |
|
|
|
// Gets the vertex format for a set of snapshot ids |
|
VertexFormat_t CShaderAPIDx10::ComputeVertexUsage( int numSnapshots, StateSnapshot_t* pIds ) const |
|
{ |
|
return 0; |
|
} |
|
|
|
// Uses a state snapshot |
|
void CShaderAPIDx10::UseSnapshot( StateSnapshot_t snapshot ) |
|
{ |
|
} |
|
|
|
// Sets the color to modulate by |
|
void CShaderAPIDx10::Color3f( float r, float g, float b ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::Color3fv( float const* pColor ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::Color4f( float r, float g, float b, float a ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::Color4fv( float const* pColor ) |
|
{ |
|
} |
|
|
|
// Faster versions of color |
|
void CShaderAPIDx10::Color3ub( unsigned char r, unsigned char g, unsigned char b ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::Color3ubv( unsigned char const* rgb ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::Color4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::Color4ubv( unsigned char const* rgba ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::GetStandardTextureDimensions( int *pWidth, int *pHeight, StandardTextureId_t id ) |
|
{ |
|
ShaderUtil()->GetStandardTextureDimensions( pWidth, pHeight, id ); |
|
} |
|
|
|
|
|
// The shade mode |
|
void CShaderAPIDx10::ShadeMode( ShaderShadeMode_t mode ) |
|
{ |
|
} |
|
|
|
// Binds a particular material to render with |
|
void CShaderAPIDx10::Bind( IMaterial* pMaterial ) |
|
{ |
|
} |
|
|
|
// Cull mode |
|
void CShaderAPIDx10::CullMode( MaterialCullMode_t cullMode ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::ForceDepthFuncEquals( bool bEnable ) |
|
{ |
|
} |
|
|
|
// Forces Z buffering on or off |
|
void CShaderAPIDx10::OverrideDepthEnable( bool bEnable, bool bDepthEnable ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::OverrideAlphaWriteEnable( bool bOverrideEnable, bool bAlphaWriteEnable ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::OverrideColorWriteEnable( bool bOverrideEnable, bool bColorWriteEnable ) |
|
{ |
|
} |
|
|
|
|
|
//legacy fast clipping linkage |
|
void CShaderAPIDx10::SetHeightClipZ( float z ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::SetHeightClipMode( enum MaterialHeightClipMode_t heightClipMode ) |
|
{ |
|
} |
|
|
|
|
|
// Sets the lights |
|
void CShaderAPIDx10::SetLight( int lightNum, const LightDesc_t& desc ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::SetAmbientLight( float r, float g, float b ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::SetAmbientLightCube( Vector4D cube[6] ) |
|
{ |
|
} |
|
|
|
// Get lights |
|
int CShaderAPIDx10::GetMaxLights( void ) const |
|
{ |
|
return 0; |
|
} |
|
|
|
const LightDesc_t& CShaderAPIDx10::GetLight( int lightNum ) const |
|
{ |
|
static LightDesc_t blah; |
|
return blah; |
|
} |
|
|
|
// Render state for the ambient light cube (vertex shaders) |
|
void CShaderAPIDx10::SetVertexShaderStateAmbientLightCube() |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::SetSkinningMatrices() |
|
{ |
|
} |
|
|
|
// Lightmap texture binding |
|
void CShaderAPIDx10::BindLightmap( TextureStage_t stage ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::BindBumpLightmap( TextureStage_t stage ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::BindFullbrightLightmap( TextureStage_t stage ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::BindWhite( TextureStage_t stage ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::BindBlack( TextureStage_t stage ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::BindGrey( TextureStage_t stage ) |
|
{ |
|
} |
|
|
|
// Gets the lightmap dimensions |
|
void CShaderAPIDx10::GetLightmapDimensions( int *w, int *h ) |
|
{ |
|
g_pShaderUtil->GetLightmapDimensions( w, h ); |
|
} |
|
|
|
// Special system flat normal map binding. |
|
void CShaderAPIDx10::BindFlatNormalMap( TextureStage_t stage ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::BindNormalizationCubeMap( TextureStage_t stage ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::BindSignedNormalizationCubeMap( TextureStage_t stage ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::BindFBTexture( TextureStage_t stage, int textureIndex ) |
|
{ |
|
} |
|
|
|
// Flushes any primitives that are buffered |
|
void CShaderAPIDx10::FlushBufferedPrimitives() |
|
{ |
|
} |
|
|
|
// Creates/destroys Mesh |
|
IMesh* CShaderAPIDx10::CreateStaticMesh( VertexFormat_t fmt, const char *pTextureBudgetGroup, IMaterial * pMaterial ) |
|
{ |
|
return &m_Mesh; |
|
} |
|
|
|
void CShaderAPIDx10::DestroyStaticMesh( IMesh* mesh ) |
|
{ |
|
} |
|
|
|
// Gets the dynamic mesh; 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. |
|
IMesh* CShaderAPIDx10::GetDynamicMesh( IMaterial* pMaterial, int nHWSkinBoneCount, bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride ) |
|
{ |
|
Assert( (pMaterial == NULL) || ((IMaterialInternal *)pMaterial)->IsRealTimeVersion() ); |
|
return &m_Mesh; |
|
} |
|
|
|
IMesh* CShaderAPIDx10::GetDynamicMeshEx( IMaterial* pMaterial, VertexFormat_t fmt, int nHWSkinBoneCount, bool buffered, IMesh* pVertexOverride, IMesh* pIndexOverride ) |
|
{ |
|
// UNDONE: support compressed dynamic meshes if needed (pro: less VB memory, con: time spent compressing) |
|
Assert( CompressionType( pVertexOverride->GetVertexFormat() ) != VERTEX_COMPRESSION_NONE ); |
|
Assert( (pMaterial == NULL) || ((IMaterialInternal *)pMaterial)->IsRealTimeVersion() ); |
|
return &m_Mesh; |
|
} |
|
|
|
IMesh* CShaderAPIDx10::GetFlexMesh() |
|
{ |
|
return &m_Mesh; |
|
} |
|
|
|
// Begins a rendering pass that uses a state snapshot |
|
void CShaderAPIDx10::BeginPass( StateSnapshot_t snapshot ) |
|
{ |
|
} |
|
|
|
// Renders a single pass of a material |
|
void CShaderAPIDx10::RenderPass( int nPass, int nPassCount ) |
|
{ |
|
} |
|
|
|
// stuff related to matrix stacks |
|
void CShaderAPIDx10::MatrixMode( MaterialMatrixMode_t matrixMode ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::PushMatrix() |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::PopMatrix() |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::LoadMatrix( float *m ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::MultMatrix( float *m ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::MultMatrixLocal( float *m ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::GetMatrix( MaterialMatrixMode_t matrixMode, float *dst ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::LoadIdentity( void ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::LoadCameraToWorld( void ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::Ortho( double left, double top, double right, double bottom, double zNear, double zFar ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::PerspectiveX( double fovx, double aspect, double zNear, double zFar ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::PerspectiveOffCenterX( double fovx, double aspect, double zNear, double zFar, double bottom, double top, double left, double right ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::PickMatrix( int x, int y, int width, int height ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::Rotate( float angle, float x, float y, float z ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::Translate( float x, float y, float z ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::Scale( float x, float y, float z ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::ScaleXY( float x, float y ) |
|
{ |
|
} |
|
|
|
// Fog methods... |
|
void CShaderAPIDx10::FogMode( MaterialFogMode_t fogMode ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::FogStart( float fStart ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::FogEnd( float fEnd ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::SetFogZ( float fogZ ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::FogMaxDensity( float flMaxDensity ) |
|
{ |
|
} |
|
|
|
|
|
void CShaderAPIDx10::GetFogDistances( float *fStart, float *fEnd, float *fFogZ ) |
|
{ |
|
} |
|
|
|
|
|
void CShaderAPIDx10::SceneFogColor3ub( unsigned char r, unsigned char g, unsigned char b ) |
|
{ |
|
} |
|
|
|
|
|
void CShaderAPIDx10::SceneFogMode( MaterialFogMode_t fogMode ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::GetSceneFogColor( unsigned char *rgb ) |
|
{ |
|
} |
|
|
|
MaterialFogMode_t CShaderAPIDx10::GetSceneFogMode( ) |
|
{ |
|
return MATERIAL_FOG_NONE; |
|
} |
|
|
|
int CShaderAPIDx10::GetPixelFogCombo( ) |
|
{ |
|
return 0; //FIXME |
|
} |
|
|
|
void CShaderAPIDx10::FogColor3f( float r, float g, float b ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::FogColor3fv( float const* rgb ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::FogColor3ub( unsigned char r, unsigned char g, unsigned char b ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::FogColor3ubv( unsigned char const* rgb ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::Viewport( int x, int y, int width, int height ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::GetViewport( int& x, int& y, int& width, int& height ) const |
|
{ |
|
} |
|
|
|
// Sets the vertex and pixel shaders |
|
void CShaderAPIDx10::SetVertexShaderIndex( int vshIndex ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::SetPixelShaderIndex( int pshIndex ) |
|
{ |
|
} |
|
|
|
// Sets the constant register for vertex and pixel shaders |
|
void CShaderAPIDx10::SetVertexShaderConstant( int var, float const* pVec, int numConst, bool bForce ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::SetPixelShaderConstant( int var, float const* pVec, int numConst, bool bForce ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::InvalidateDelayedShaderConstants( void ) |
|
{ |
|
} |
|
|
|
//Set's the linear->gamma conversion textures to use for this hardware for both srgb writes enabled and disabled(identity) |
|
void CShaderAPIDx10::SetLinearToGammaConversionTextures( ShaderAPITextureHandle_t hSRGBWriteEnabledTexture, ShaderAPITextureHandle_t hIdentityTexture ) |
|
{ |
|
} |
|
|
|
|
|
// Returns the nearest supported format |
|
ImageFormat CShaderAPIDx10::GetNearestSupportedFormat( ImageFormat fmt, bool bFilteringRequired /* = true */ ) const |
|
{ |
|
return fmt; |
|
} |
|
|
|
ImageFormat CShaderAPIDx10::GetNearestRenderTargetFormat( ImageFormat fmt ) const |
|
{ |
|
return fmt; |
|
} |
|
|
|
// Sets the texture state |
|
void CShaderAPIDx10::BindTexture( Sampler_t stage, ShaderAPITextureHandle_t textureHandle ) |
|
{ |
|
} |
|
|
|
// Indicates we're going to be modifying this texture |
|
// TexImage2D, TexSubImage2D, TexWrap, TexMinFilter, and TexMagFilter |
|
// all use the texture specified by this function. |
|
void CShaderAPIDx10::ModifyTexture( ShaderAPITextureHandle_t textureHandle ) |
|
{ |
|
} |
|
|
|
// Texture management methods |
|
void CShaderAPIDx10::TexImage2D( int level, int cubeFace, ImageFormat dstFormat, int zOffset, int width, int height, |
|
ImageFormat srcFormat, bool bSrcIsTiled, void *imageData ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::TexSubImage2D( int level, int cubeFace, int xOffset, int yOffset, int zOffset, int width, int height, |
|
ImageFormat srcFormat, int srcStride, bool bSrcIsTiled, void *imageData ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::TexImageFromVTF( IVTFTexture *pVTF, int iVTFFrame ) |
|
{ |
|
} |
|
|
|
bool CShaderAPIDx10::TexLock( int level, int cubeFaceID, int xOffset, int yOffset, |
|
int width, int height, CPixelWriter& writer ) |
|
{ |
|
return false; |
|
} |
|
|
|
void CShaderAPIDx10::TexUnlock( ) |
|
{ |
|
} |
|
|
|
|
|
// These are bound to the texture, not the texture environment |
|
void CShaderAPIDx10::TexMinFilter( ShaderTexFilterMode_t texFilterMode ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::TexMagFilter( ShaderTexFilterMode_t texFilterMode ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::TexWrap( ShaderTexCoordComponent_t coord, ShaderTexWrapMode_t wrapMode ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::TexSetPriority( int priority ) |
|
{ |
|
} |
|
|
|
ShaderAPITextureHandle_t CShaderAPIDx10::CreateTexture( |
|
int width, |
|
int height, |
|
int depth, |
|
ImageFormat dstImageFormat, |
|
int numMipLevels, |
|
int numCopies, |
|
int flags, |
|
const char *pDebugName, |
|
const char *pTextureGroupName ) |
|
{ |
|
ShaderAPITextureHandle_t handle; |
|
CreateTextures( &handle, 1, width, height, depth, dstImageFormat, numMipLevels, numCopies, flags, pDebugName, pTextureGroupName ); |
|
return handle; |
|
} |
|
|
|
void CShaderAPIDx10::CreateTextures( |
|
ShaderAPITextureHandle_t *pHandles, |
|
int count, |
|
int width, |
|
int height, |
|
int depth, |
|
ImageFormat dstImageFormat, |
|
int numMipLevels, |
|
int numCopies, |
|
int flags, |
|
const char *pDebugName, |
|
const char *pTextureGroupName ) |
|
{ |
|
for ( int k = 0; k < count; ++ k ) |
|
{ |
|
pHandles[ k ] = 0; |
|
} |
|
} |
|
|
|
ShaderAPITextureHandle_t CShaderAPIDx10::CreateDepthTexture( ImageFormat renderFormat, int width, int height, const char *pDebugName, bool bTexture ) |
|
{ |
|
return 0; |
|
} |
|
|
|
void CShaderAPIDx10::DeleteTexture( ShaderAPITextureHandle_t textureHandle ) |
|
{ |
|
} |
|
|
|
bool CShaderAPIDx10::IsTexture( ShaderAPITextureHandle_t textureHandle ) |
|
{ |
|
return true; |
|
} |
|
|
|
bool CShaderAPIDx10::IsTextureResident( ShaderAPITextureHandle_t textureHandle ) |
|
{ |
|
return false; |
|
} |
|
|
|
// stuff that isn't to be used from within a shader |
|
void CShaderAPIDx10::ClearBuffersObeyStencil( bool bClearColor, bool bClearDepth ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::ClearBuffersObeyStencilEx( bool bClearColor, bool bClearAlpha, bool bClearDepth ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::PerformFullScreenStencilOperation( void ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::ReadPixels( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::ReadPixels( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *data, ImageFormat dstFormat, int nDstStride ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::FlushHardware() |
|
{ |
|
} |
|
|
|
// Set the number of bone weights |
|
void CShaderAPIDx10::SetNumBoneWeights( int numBones ) |
|
{ |
|
} |
|
|
|
// Selection mode methods |
|
int CShaderAPIDx10::SelectionMode( bool selectionMode ) |
|
{ |
|
return 0; |
|
} |
|
|
|
void CShaderAPIDx10::SelectionBuffer( unsigned int* pBuffer, int size ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::ClearSelectionNames( ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::LoadSelectionName( int name ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::PushSelectionName( int name ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::PopSelectionName() |
|
{ |
|
} |
|
|
|
|
|
// Use this to get the mesh builder that allows us to modify vertex data |
|
CMeshBuilder* CShaderAPIDx10::GetVertexModifyBuilder() |
|
{ |
|
return 0; |
|
} |
|
|
|
// Board-independent calls, here to unify how shaders set state |
|
// Implementations should chain back to IShaderUtil->BindTexture(), etc. |
|
|
|
// Use this to begin and end the frame |
|
void CShaderAPIDx10::BeginFrame() |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::EndFrame() |
|
{ |
|
} |
|
|
|
// returns the current time in seconds.... |
|
double CShaderAPIDx10::CurrentTime() const |
|
{ |
|
return Sys_FloatTime(); |
|
} |
|
|
|
// Get the current camera position in world space. |
|
void CShaderAPIDx10::GetWorldSpaceCameraPosition( float * pPos ) const |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::ForceHardwareSync( void ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::SetClipPlane( int index, const float *pPlane ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::EnableClipPlane( int index, bool bEnable ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::SetFastClipPlane( const float *pPlane ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::EnableFastClip( bool bEnable ) |
|
{ |
|
} |
|
|
|
int CShaderAPIDx10::GetCurrentNumBones( void ) const |
|
{ |
|
return 0; |
|
} |
|
|
|
// Is hardware morphing enabled? |
|
bool CShaderAPIDx10::IsHWMorphingEnabled( ) const |
|
{ |
|
return false; |
|
} |
|
|
|
int CShaderAPIDx10::GetCurrentLightCombo( void ) const |
|
{ |
|
return 0; |
|
} |
|
|
|
int CShaderAPIDx10::MapLightComboToPSLightCombo( int nLightCombo ) const |
|
{ |
|
return 0; |
|
} |
|
|
|
MaterialFogMode_t CShaderAPIDx10::GetCurrentFogType( void ) const |
|
{ |
|
return MATERIAL_FOG_NONE; |
|
} |
|
|
|
void CShaderAPIDx10::RecordString( const char *pStr ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::DestroyVertexBuffers( bool bExitingLevel ) |
|
{ |
|
} |
|
|
|
int CShaderAPIDx10::GetCurrentDynamicVBSize( void ) |
|
{ |
|
return 0; |
|
} |
|
|
|
void CShaderAPIDx10::EvictManagedResources() |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::ReleaseShaderObjects() |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::RestoreShaderObjects() |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::SetTextureTransformDimension( TextureStage_t textureStage, int dimension, bool projected ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::SetBumpEnvMatrix( TextureStage_t textureStage, float m00, float m01, float m10, float m11 ) |
|
{ |
|
} |
|
|
|
void CShaderAPIDx10::SyncToken( const char *pToken ) |
|
{ |
|
}
|
|
|