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
|
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//===========================================================================//
#include "shadershadowdx10.h"
#include "utlvector.h"
#include "materialsystem/imaterialsystem.h"
#include "IHardwareConfigInternal.h"
#include "shadersystem.h"
#include "shaderapi/ishaderutil.h"
#include "materialsystem/imesh.h"
#include "tier0/dbg.h"
#include "materialsystem/idebugtextureinfo.h"
//-----------------------------------------------------------------------------
// Class Factory
//-----------------------------------------------------------------------------
static CShaderShadowDx10 s_ShaderShadow;
CShaderShadowDx10 *g_pShaderShadowDx10 = &s_ShaderShadow;
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderShadowDx10, IShaderShadow,
SHADERSHADOW_INTERFACE_VERSION, s_ShaderShadow )
//-----------------------------------------------------------------------------
// The shader shadow interface
//-----------------------------------------------------------------------------
CShaderShadowDx10::CShaderShadowDx10()
{
m_IsTranslucent = false;
m_IsAlphaTested = false;
m_bIsDepthWriteEnabled = true;
m_bUsesVertexAndPixelShaders = false;
}
CShaderShadowDx10::~CShaderShadowDx10()
{
}
// Sets the default *shadow* state
void CShaderShadowDx10::SetDefaultState()
{
m_IsTranslucent = false;
m_IsAlphaTested = false;
m_bIsDepthWriteEnabled = true;
m_bUsesVertexAndPixelShaders = false;
}
// Methods related to depth buffering
void CShaderShadowDx10::DepthFunc( ShaderDepthFunc_t depthFunc )
{
}
void CShaderShadowDx10::EnableDepthWrites( bool bEnable )
{
m_bIsDepthWriteEnabled = bEnable;
}
void CShaderShadowDx10::EnableDepthTest( bool bEnable )
{
}
void CShaderShadowDx10::EnablePolyOffset( PolygonOffsetMode_t nOffsetMode )
{
}
// Suppresses/activates color writing
void CShaderShadowDx10::EnableColorWrites( bool bEnable )
{
}
// Suppresses/activates alpha writing
void CShaderShadowDx10::EnableAlphaWrites( bool bEnable )
{
}
// Methods related to alpha blending
void CShaderShadowDx10::EnableBlending( bool bEnable )
{
m_IsTranslucent = bEnable;
}
void CShaderShadowDx10::BlendFunc( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor )
{
}
void CShaderShadowDx10::BlendOp( ShaderBlendOp_t blendOp )
{
}
void CShaderShadowDx10::BlendOpSeparateAlpha( ShaderBlendOp_t blendOp )
{
}
// A simpler method of dealing with alpha modulation
void CShaderShadowDx10::EnableAlphaPipe( bool bEnable )
{
}
void CShaderShadowDx10::EnableConstantAlpha( bool bEnable )
{
}
void CShaderShadowDx10::EnableVertexAlpha( bool bEnable )
{
}
void CShaderShadowDx10::EnableTextureAlpha( TextureStage_t stage, bool bEnable )
{
}
void CShaderShadowDx10::SetShadowDepthFiltering( Sampler_t stage )
{
}
// Alpha testing
void CShaderShadowDx10::EnableAlphaTest( bool bEnable )
{
m_IsAlphaTested = bEnable;
}
void CShaderShadowDx10::AlphaFunc( ShaderAlphaFunc_t alphaFunc, float alphaRef /* [0-1] */ )
{
}
// Wireframe/filled polygons
void CShaderShadowDx10::PolyMode( ShaderPolyModeFace_t face, ShaderPolyMode_t polyMode )
{
}
// Back face culling
void CShaderShadowDx10::EnableCulling( bool bEnable )
{
}
// Alpha to coverage
void CShaderShadowDx10::EnableAlphaToCoverage( bool bEnable )
{
}
// constant color + transparency
void CShaderShadowDx10::EnableConstantColor( bool bEnable )
{
}
// Indicates the vertex format for use with a vertex shader
// The flags to pass in here come from the VertexFormatFlags_t enum
// If pTexCoordDimensions is *not* specified, we assume all coordinates
// are 2-dimensional
void CShaderShadowDx10::VertexShaderVertexFormat( unsigned int flags,
int numTexCoords, int* pTexCoordDimensions,
int userDataSize )
{
}
// Indicates we're going to light the model
void CShaderShadowDx10::EnableLighting( bool bEnable )
{
}
void CShaderShadowDx10::EnableSpecular( bool bEnable )
{
}
// Activate/deactivate skinning
void CShaderShadowDx10::EnableVertexBlend( bool bEnable )
{
}
// per texture unit stuff
void CShaderShadowDx10::OverbrightValue( TextureStage_t stage, float value )
{
}
void CShaderShadowDx10::EnableTexture( Sampler_t stage, bool bEnable )
{
}
void CShaderShadowDx10::EnableCustomPixelPipe( bool bEnable )
{
}
void CShaderShadowDx10::CustomTextureStages( int stageCount )
{
}
void CShaderShadowDx10::CustomTextureOperation( TextureStage_t stage, ShaderTexChannel_t channel,
ShaderTexOp_t op, ShaderTexArg_t arg1, ShaderTexArg_t arg2 )
{
}
void CShaderShadowDx10::EnableTexGen( TextureStage_t stage, bool bEnable )
{
}
void CShaderShadowDx10::TexGen( TextureStage_t stage, ShaderTexGenParam_t param )
{
}
// Sets the vertex and pixel shaders
void CShaderShadowDx10::SetVertexShader( const char *pShaderName, int vshIndex )
{
m_bUsesVertexAndPixelShaders = ( pShaderName != NULL );
}
void CShaderShadowDx10::EnableBlendingSeparateAlpha( bool bEnable )
{
}
void CShaderShadowDx10::SetPixelShader( const char *pShaderName, int pshIndex )
{
m_bUsesVertexAndPixelShaders = ( pShaderName != NULL );
}
void CShaderShadowDx10::BlendFuncSeparateAlpha( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor )
{
}
// indicates what per-vertex data we're providing
void CShaderShadowDx10::DrawFlags( unsigned int drawFlags )
{
}
|