shadershadowdx8.cpp

hl2 source code. Do not use it illegal.

{
	m_ShadowState.m_ZBias = bEnable;
}


//-----------------------------------------------------------------------------
// Color write state
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableColorWrites( bool bEnable )
{
	if (bEnable)
	{
		m_ShadowState.m_ColorWriteEnable |= D3DCOLORWRITEENABLE_BLUE |
							D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED;
	}
	else
	{
		m_ShadowState.m_ColorWriteEnable &= ~( D3DCOLORWRITEENABLE_BLUE |
							D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_RED );
	}
}

void CShaderShadowDX8::EnableAlphaWrites( bool bEnable )
{
	if (bEnable)
	{
		m_ShadowState.m_ColorWriteEnable |= D3DCOLORWRITEENABLE_ALPHA;
	}
	else
	{
		m_ShadowState.m_ColorWriteEnable &= ~D3DCOLORWRITEENABLE_ALPHA;
	}
}


//-----------------------------------------------------------------------------
// Alpha blending states
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableBlending( bool bEnable )
{
	m_ShadowState.m_AlphaBlendEnable = bEnable;
}

// GR - separate alpha
void CShaderShadowDX8::EnableBlendingSeparateAlpha( bool bEnable )
{
	m_ShadowState.m_SeparateAlphaBlendEnable = bEnable;
}

void CShaderShadowDX8::EnableAlphaTest( bool bEnable )
{
	m_ShadowState.m_AlphaTestEnable = bEnable;
}

void CShaderShadowDX8::AlphaFunc( ShaderAlphaFunc_t alphaFunc, float alphaRef /* [0-1] */ )
{
	D3DCMPFUNC d3dCmpFunc;

	switch( alphaFunc )
	{
	case SHADER_ALPHAFUNC_NEVER:
		d3dCmpFunc = D3DCMP_NEVER;
		break;
	case SHADER_ALPHAFUNC_LESS:
		d3dCmpFunc = D3DCMP_LESS;
		break;
	case SHADER_ALPHAFUNC_EQUAL:
		d3dCmpFunc = D3DCMP_EQUAL;
		break;
	case SHADER_ALPHAFUNC_LEQUAL:
		d3dCmpFunc = D3DCMP_LESSEQUAL;
		break;
	case SHADER_ALPHAFUNC_GREATER:
		d3dCmpFunc = D3DCMP_GREATER;
		break;
	case SHADER_ALPHAFUNC_NOTEQUAL:
		d3dCmpFunc = D3DCMP_NOTEQUAL;
		break;
	case SHADER_ALPHAFUNC_GEQUAL:
		d3dCmpFunc = D3DCMP_GREATEREQUAL;
		break;
	case SHADER_ALPHAFUNC_ALWAYS:
		d3dCmpFunc = D3DCMP_ALWAYS;
		break;
	default:
		Warning( "AlphaFunc: invalid param\n" );
		return;
	}

	m_AlphaFunc = d3dCmpFunc;
	m_AlphaRef = (int)(alphaRef * 255);
}

D3DBLEND CShaderShadowDX8::BlendFuncValue( ShaderBlendFactor_t factor ) const
{
	switch( factor )
	{
	case SHADER_BLEND_ZERO:
		return D3DBLEND_ZERO;

	case SHADER_BLEND_ONE:
		return D3DBLEND_ONE;

	case SHADER_BLEND_DST_COLOR:
		return D3DBLEND_DESTCOLOR;

	case SHADER_BLEND_ONE_MINUS_DST_COLOR:
		return D3DBLEND_INVDESTCOLOR;

	case SHADER_BLEND_SRC_ALPHA:
		return D3DBLEND_SRCALPHA;

	case SHADER_BLEND_ONE_MINUS_SRC_ALPHA:
		return D3DBLEND_INVSRCALPHA;

	case SHADER_BLEND_DST_ALPHA:
		return D3DBLEND_DESTALPHA;

	case SHADER_BLEND_ONE_MINUS_DST_ALPHA:
		return D3DBLEND_INVDESTALPHA;

	case SHADER_BLEND_SRC_ALPHA_SATURATE:
		return D3DBLEND_SRCALPHASAT;

	case SHADER_BLEND_SRC_COLOR:
		return D3DBLEND_SRCCOLOR;

	case SHADER_BLEND_ONE_MINUS_SRC_COLOR:
		return D3DBLEND_INVSRCCOLOR;
	}

	Warning( "BlendFunc: invalid factor\n" );
	return D3DBLEND_ONE;
}

void CShaderShadowDX8::BlendFunc( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor )
{
	D3DBLEND d3dSrcFactor = BlendFuncValue( srcFactor );
	D3DBLEND d3dDstFactor = BlendFuncValue( dstFactor );
	m_SrcBlend = d3dSrcFactor;
	m_DestBlend = d3dDstFactor;
}

// GR - separate alpha blend
void CShaderShadowDX8::BlendFuncSeparateAlpha( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor )
{
	D3DBLEND d3dSrcFactor = BlendFuncValue( srcFactor );
	D3DBLEND d3dDstFactor = BlendFuncValue( dstFactor );
	m_SrcBlendAlpha = d3dSrcFactor;
	m_DestBlendAlpha = d3dDstFactor;
}


//-----------------------------------------------------------------------------
// Polygon fill mode states
//-----------------------------------------------------------------------------
void CShaderShadowDX8::PolyMode( ShaderPolyModeFace_t face, ShaderPolyMode_t polyMode )
{
	// DX8 can't handle different modes on front and back faces
// FIXME:	Assert( face == SHADER_POLYMODEFACE_FRONT_AND_BACK );
	if (face == SHADER_POLYMODEFACE_BACK)
		return;
	
	D3DFILLMODE fillMode;
	switch( polyMode )
	{
	case SHADER_POLYMODE_POINT:
		fillMode = D3DFILL_POINT;
		break;
	case SHADER_POLYMODE_LINE:
		fillMode =  D3DFILL_WIREFRAME;
		break;
	case SHADER_POLYMODE_FILL:
		fillMode =  D3DFILL_SOLID;
		break;
	default:
		Warning( "PolyMode: invalid poly mode\n" );
		return;
	}

	m_ShadowState.m_FillMode = fillMode;
}


//-----------------------------------------------------------------------------
// Backface cull states
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableCulling( bool bEnable )
{
	m_ShadowState.m_CullEnable = bEnable;
}


//-----------------------------------------------------------------------------
// Indicates we've got a constant color specified
//-----------------------------------------------------------------------------
bool CShaderShadowDX8::HasConstantColor() const
{
	return m_HasConstantColor;
}

void CShaderShadowDX8::EnableConstantColor( bool bEnable ) 
{
	m_HasConstantColor = bEnable;
}


//-----------------------------------------------------------------------------
// A simpler method of dealing with alpha modulation
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableAlphaPipe( bool bEnable )
{
	m_AlphaPipe = bEnable;
}

void CShaderShadowDX8::EnableConstantAlpha( bool bEnable )
{
	m_HasConstantAlpha = bEnable;
}

void CShaderShadowDX8::EnableVertexAlpha( bool bEnable )
{
	m_HasVertexAlpha = bEnable;
}

void CShaderShadowDX8::EnableTextureAlpha( TextureStage_t stage, bool bEnable )
{
	if (stage < m_pHardwareConfig->GetNumTextureUnits())
	{
		m_TextureStage[stage].m_TextureAlphaEnable = bEnable;
	}
}


//-----------------------------------------------------------------------------
// Indicates we're going to light the model
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableLighting( bool bEnable )
{
	m_ShadowState.m_Lighting = bEnable;
}


//-----------------------------------------------------------------------------
// Enables specular lighting (lighting has also got to be enabled)
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableSpecular( bool bEnable )
{
	m_ShadowState.m_SpecularEnable = bEnable;
}

//-----------------------------------------------------------------------------
// Enables auto-conversion from linear to gamma space on write to framebuffer.
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableSRGBWrite( bool bEnable )
{
	m_ShadowState.m_SRGBWriteEnable = bEnable;
}

//-----------------------------------------------------------------------------
// Indicates we're going to be using the ambient cube
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableAmbientLightCubeOnStage0( bool bEnable )
{
	// FIXME: This is only used to optimize model rendering to help us know
	// when we don't have to set the texture transform to identity during reset
	m_ShadowState.m_AmbientCubeOnStage0 = bEnable;

	m_AmbientCubeEnabled = bEnable;
	RecomputeTexCoordIndex( SHADER_TEXTURE_STAGE0 );
}


//-----------------------------------------------------------------------------
// Activate/deactivate skinning
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableVertexBlend( bool bEnable )
{
	// Activate/deactivate skinning. Indexed blending is automatically
	// enabled if it's available for this hardware. When blending is enabled,
	// we allocate enough room for 3 weights (max allowed)
	if ((m_pHardwareConfig->MaxBlendMatrices() > 0) || (!bEnable))
	{
		m_ShadowState.m_VertexBlendEnable = bEnable;
	}
}

				 
//-----------------------------------------------------------------------------
// Texturemapping state
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableTexture( TextureStage_t stage, bool bEnable )
{
	if (stage < m_pHardwareConfig->GetNumTextureUnits())
	{
		m_TextureStage[stage].m_TextureEnable = bEnable;
	}
	else
	{
		Warning("Attempting to bind a texture to an invalid stage (%d)!\n", stage);
	}
}


//-----------------------------------------------------------------------------
// Binds texture coordinates to a particular stage...
//-----------------------------------------------------------------------------
void CShaderShadowDX8::TextureCoordinate( TextureStage_t stage, int useTexCoord )
{
	if (stage < m_pHardwareConfig->GetNumTextureUnits())
	{
		m_TextureStage[stage].m_TexCoordinate = useTexCoord;

		// Need to recompute the texCoordIndex, since that's affected by this
		RecomputeTexCoordIndex(stage);
	}
}


//-----------------------------------------------------------------------------
// Returns true if we're generating spheremap coordinates
//-----------------------------------------------------------------------------
bool CShaderShadowDX8::IsGeneratingSpheremapCoords( TextureStage_t stage ) const
{
	return m_TextureStage[stage].m_GenerateSphericalCoords &&
		m_TextureStage[stage].m_TexGenEnable;
}


//-----------------------------------------------------------------------------
// Automatic texture coordinate generation
//-----------------------------------------------------------------------------
void CShaderShadowDX8::RecomputeTexCoordIndex( TextureStage_t stage )
{
	if ((stage == 0) && (m_AmbientCubeEnabled))
	{
		m_ShadowState.m_TextureStage[0].m_TexCoordIndex = D3DTSS_TCI_CAMERASPACENORMAL;
		m_ShadowState.m_TextureStage[0].m_GenerateSphericalCoords = false;
		return;
	}

	int texCoordIndex = m_TextureStage[stage].m_TexCoordinate;
	if (m_TextureStage[stage].m_TexGenEnable)
		texCoordIndex |= m_TextureStage[stage].m_TexCoordIndex;
	m_ShadowState.m_TextureStage[stage].m_TexCoordIndex = texCoordIndex;
	m_ShadowState.m_TextureStage[stage].m_GenerateSphericalCoords = 
		IsGeneratingSpheremapCoords( stage );
}


//-----------------------------------------------------------------------------
// Automatic texture coordinate generation
//-----------------------------------------------------------------------------
void CShaderShadowDX8::EnableTexGen( TextureStage_t stage, bool bEnable )
{
	if (stage >= m_pHardwareConfig->GetNumTextureUnits())
	{
		Assert( 0 );
		return;
	}

	m_TextureStage[stage].m_TexGenEnable = bEnable;
	RecomputeTexCoordIndex(stage);
}

//-----------------------------------------------------------------------------
// Automatic texture coordinate generation
//-----------------------------------------------------------------------------
void CShaderShadowDX8::TexGen( TextureStage_t stage, ShaderTexGenParam_t param )
{
	if (stage >= m_pHardwareConfig->GetNumTextureUnits())
		return;

	m_TextureStage[stage].m_GenerateSphericalCoords = false;
	switch( param )
	{
	case SHADER_TEXGENPARAM_OBJECT_LINEAR:
		m_TextureStage[stage].m_TexCoordIndex = 0;	
		break;	
	case SHADER_TEXGENPARAM_EYE_LINEAR:
		m_TextureStage[stage].m_TexCoordIndex = D3DTSS_TCI_CAMERASPACEPOSITION;
		break;
	case SHADER_TEXGENPARAM_SPHERE_MAP:
		if ( m_pHardwareConfig->SupportsSpheremapping() )
		{
			m_TextureStage[stage].m_TexCoordIndex = D3DTSS_TCI_SPHEREMAP;
		}
		else
		{
			m_TextureStage[stage].m_TexCoordIndex = D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR;

			// We may need to use this if spheremapping isn't supported
			// This is a correct way, but perf sucks hard
			//m_TextureStage[stage].m_TexCoordIndex = 0; 
			//m_TextureStage[stage].m_GenerateSphericalCoords = true;
		}

		break;
	case SHADER_TEXGENPARAM_CAMERASPACEREFLECTIONVECTOR:
		m_TextureStage[stage].m_TexCoordIndex = D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR;
		break;
	case SHADER_TEXGENPARAM_CAMERASPACENORMAL:
		m_TextureStage[stage].m_TexCoordIndex = D3DTSS_TCI_CAMERASPACENORMAL;
		break;
	}

	// Set the board state...
	RecomputeTexCoordIndex(stage);
}


//-----------------------------------------------------------------------------
// Overbrighting
//-----------------------------------------------------------------------------
void CShaderShadowDX8::OverbrightValue( TextureStage_t stage, float value )
{
	if (m_pHardwareConfig->SupportsOverbright() && 
		(stage < m_pHardwareConfig->GetNumTextureUnits()) )
	{
		m_TextureStage[stage].m_OverbrightVal = value;
	}
}


//-----------------------------------------------------------------------------