1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
|
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//===========================================================================//
#ifndef SHADERDEVICEDX10_H
#define SHADERDEVICEDX10_H
#ifdef _WIN32
#pragma once
#endif
#include "shaderdevicebase.h"
#include "tier1/utlvector.h"
#include "tier1/utlrbtree.h"
#include "tier1/utllinkedlist.h"
//-----------------------------------------------------------------------------
// Forward declaration
//-----------------------------------------------------------------------------
struct IDXGIFactory;
struct IDXGIAdapter;
struct IDXGIOutput;
struct IDXGISwapChain;
struct ID3D10Device;
struct ID3D10RenderTargetView;
struct ID3D10VertexShader;
struct ID3D10PixelShader;
struct ID3D10GeometryShader;
struct ID3D10InputLayout;
struct ID3D10ShaderReflection;
//-----------------------------------------------------------------------------
// The Base implementation of the shader device
//-----------------------------------------------------------------------------
class CShaderDeviceMgrDx10 : public CShaderDeviceMgrBase
{
typedef CShaderDeviceMgrBase BaseClass;
public:
// constructor, destructor
CShaderDeviceMgrDx10();
virtual ~CShaderDeviceMgrDx10();
// Methods of IAppSystem
virtual bool Connect( CreateInterfaceFn factory );
virtual void Disconnect();
virtual InitReturnVal_t Init();
virtual void Shutdown();
// Methods of IShaderDeviceMgr
virtual int GetAdapterCount() const;
virtual void GetAdapterInfo( int adapter, MaterialAdapterInfo_t& info ) const;
virtual int GetModeCount( int nAdapter ) const;
virtual void GetModeInfo( ShaderDisplayMode_t* pInfo, int nAdapter, int mode ) const;
virtual void GetCurrentModeInfo( ShaderDisplayMode_t* pInfo, int nAdapter ) const;
virtual bool SetAdapter( int nAdapter, int nFlags );
virtual CreateInterfaceFn SetMode( void *hWnd, int nAdapter, const ShaderDeviceInfo_t& mode );
private:
// Initialize adapter information
void InitAdapterInfo();
// Determines hardware caps from D3D
bool ComputeCapsFromD3D( HardwareCaps_t *pCaps, IDXGIAdapter *pAdapter, IDXGIOutput *pOutput );
// Returns the amount of video memory in bytes for a particular adapter
virtual int GetVidMemBytes( int nAdapter ) const;
// Returns the appropriate adapter output to use
IDXGIOutput* GetAdapterOutput( int nAdapter ) const;
// Returns the adapter interface for a particular adapter
IDXGIAdapter* GetAdapter( int nAdapter ) const;
// Used to enumerate adapters, attach to windows
IDXGIFactory *m_pDXGIFactory;
bool m_bObeyDxCommandlineOverride: 1;
friend class CShaderDeviceDx10;
};
//-----------------------------------------------------------------------------
// The Dx10 implementation of the shader device
//-----------------------------------------------------------------------------
class CShaderDeviceDx10 : public CShaderDeviceBase
{
public:
// constructor, destructor
CShaderDeviceDx10();
virtual ~CShaderDeviceDx10();
public:
// Methods of IShaderDevice
virtual bool IsUsingGraphics() const;
virtual int GetCurrentAdapter() const;
virtual ImageFormat GetBackBufferFormat() const;
virtual void GetBackBufferDimensions( int& width, int& height ) const;
virtual void SpewDriverInfo() const;
virtual void Present();
virtual IShaderBuffer* CompileShader( const char *pProgram, size_t nBufLen, const char *pShaderVersion );
virtual VertexShaderHandle_t CreateVertexShader( IShaderBuffer *pShader );
virtual void DestroyVertexShader( VertexShaderHandle_t hShader );
virtual GeometryShaderHandle_t CreateGeometryShader( IShaderBuffer* pShaderBuffer );
virtual void DestroyGeometryShader( GeometryShaderHandle_t hShader );
virtual PixelShaderHandle_t CreatePixelShader( IShaderBuffer* pShaderBuffer );
virtual void DestroyPixelShader( PixelShaderHandle_t hShader );
virtual void ReleaseResources() {}
virtual void ReacquireResources() {}
virtual IMesh* CreateStaticMesh( VertexFormat_t format, const char *pTextureBudgetGroup, IMaterial * pMaterial );
virtual void DestroyStaticMesh( IMesh* mesh );
virtual IVertexBuffer *CreateVertexBuffer( ShaderBufferType_t type, VertexFormat_t fmt, int nVertexCount, const char *pTextureBudgetGroup );
virtual void DestroyVertexBuffer( IVertexBuffer *pVertexBuffer );
virtual IIndexBuffer *CreateIndexBuffer( ShaderBufferType_t type, MaterialIndexFormat_t fmt, int nIndexCount, const char *pTextureBudgetGroup );
virtual void DestroyIndexBuffer( IIndexBuffer *pIndexBuffer );
virtual IVertexBuffer *GetDynamicVertexBuffer( int nStreamID, VertexFormat_t vertexFormat, bool bBuffered = true );
virtual IIndexBuffer *GetDynamicIndexBuffer( MaterialIndexFormat_t fmt, bool bBuffered = true );
virtual void SetHardwareGammaRamp( float fGamma, float fGammaTVRangeMin, float fGammaTVRangeMax, float fGammaTVExponent, bool bTVEnabled );
// A special path used to tick the front buffer while loading on the 360
virtual void EnableNonInteractiveMode( MaterialNonInteractiveMode_t mode, ShaderNonInteractiveInfo_t *pInfo ) {}
virtual void RefreshFrontBufferNonInteractive( ) {}
virtual void HandleThreadEvent( uint32 threadEvent ) {}
public:
// Methods of CShaderDeviceBase
virtual bool InitDevice( void *hWnd, int nAdapter, const ShaderDeviceInfo_t& mode );
virtual void ShutdownDevice();
virtual bool IsDeactivated() const { return false; }
// Other public methods
ID3D10VertexShader* GetVertexShader( VertexShaderHandle_t hShader ) const;
ID3D10GeometryShader* GetGeometryShader( GeometryShaderHandle_t hShader ) const;
ID3D10PixelShader* GetPixelShader( PixelShaderHandle_t hShader ) const;
ID3D10InputLayout* GetInputLayout( VertexShaderHandle_t hShader, VertexFormat_t format );
private:
struct InputLayout_t
{
ID3D10InputLayout *m_pInputLayout;
VertexFormat_t m_VertexFormat;
};
typedef CUtlRBTree< InputLayout_t, unsigned short > InputLayoutDict_t;
static bool InputLayoutLessFunc( const InputLayout_t &lhs, const InputLayout_t &rhs )
{
return ( lhs.m_VertexFormat < rhs.m_VertexFormat );
}
struct VertexShader_t
{
ID3D10VertexShader *m_pShader;
ID3D10ShaderReflection *m_pInfo;
void *m_pByteCode;
size_t m_nByteCodeLen;
InputLayoutDict_t m_InputLayouts;
VertexShader_t() : m_InputLayouts( 0, 0, InputLayoutLessFunc ) {}
};
struct GeometryShader_t
{
ID3D10GeometryShader *m_pShader;
ID3D10ShaderReflection *m_pInfo;
};
struct PixelShader_t
{
ID3D10PixelShader *m_pShader;
ID3D10ShaderReflection *m_pInfo;
};
typedef CUtlFixedLinkedList< VertexShader_t >::IndexType_t VertexShaderIndex_t;
typedef CUtlFixedLinkedList< GeometryShader_t >::IndexType_t GeometryShaderIndex_t;
typedef CUtlFixedLinkedList< PixelShader_t >::IndexType_t PixelShaderIndex_t;
void SetupHardwareCaps();
void ReleaseInputLayouts( VertexShaderIndex_t nIndex );
IDXGIOutput *m_pOutput;
ID3D10Device *m_pDevice;
IDXGISwapChain *m_pSwapChain;
ID3D10RenderTargetView *m_pRenderTargetView;
CUtlFixedLinkedList< VertexShader_t > m_VertexShaderDict;
CUtlFixedLinkedList< GeometryShader_t > m_GeometryShaderDict;
CUtlFixedLinkedList< PixelShader_t > m_PixelShaderDict;
friend ID3D10Device *D3D10Device();
friend IDXGISwapChain *D3D10SwapChain();
friend ID3D10RenderTargetView *D3D10RenderTargetView();
};
//-----------------------------------------------------------------------------
// Inline methods of CShaderDeviceDx10
//-----------------------------------------------------------------------------
inline ID3D10VertexShader* CShaderDeviceDx10::GetVertexShader( VertexShaderHandle_t hShader ) const
{
if ( hShader != VERTEX_SHADER_HANDLE_INVALID )
return m_VertexShaderDict[ (VertexShaderIndex_t)hShader ].m_pShader;
return NULL;
}
inline ID3D10GeometryShader* CShaderDeviceDx10::GetGeometryShader( GeometryShaderHandle_t hShader ) const
{
if ( hShader != GEOMETRY_SHADER_HANDLE_INVALID )
return m_GeometryShaderDict[ (GeometryShaderIndex_t)hShader ].m_pShader;
return NULL;
}
inline ID3D10PixelShader* CShaderDeviceDx10::GetPixelShader( PixelShaderHandle_t hShader ) const
{
if ( hShader != PIXEL_SHADER_HANDLE_INVALID )
return m_PixelShaderDict[ (PixelShaderIndex_t)hShader ].m_pShader;
return NULL;
}
//-----------------------------------------------------------------------------
// Singleton
//-----------------------------------------------------------------------------
extern CShaderDeviceDx10* g_pShaderDeviceDx10;
//-----------------------------------------------------------------------------
// Utility methods
//-----------------------------------------------------------------------------
inline ID3D10Device *D3D10Device()
{
return g_pShaderDeviceDx10->m_pDevice;
}
inline IDXGISwapChain *D3D10SwapChain()
{
return g_pShaderDeviceDx10->m_pSwapChain;
}
inline ID3D10RenderTargetView *D3D10RenderTargetView()
{
return g_pShaderDeviceDx10->m_pRenderTargetView;
}
#endif // SHADERDEVICEDX10_H
|