//========= Copyright Valve Corporation, All rights reserved. ============//

//

// Purpose:

//

// $NoKeywords: $

//

//===========================================================================//

#ifndef ISHADERSHADOW_H

#define ISHADERSHADOW_H

#ifdef _WIN32

#pragma once

#endif

#include "shaderapi/shareddefs.h"

#include <materialsystem/imaterial.h>

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

// forward declarations

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

class CMeshBuilder;

class IMaterialVar;

struct LightDesc_t;

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

// important enumerations

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

enum ShaderDepthFunc_t

};

enum ShaderBlendFactor_t

};

enum ShaderBlendOp_t

};

enum ShaderAlphaFunc_t

};

enum ShaderStencilFunc_t

};

enum ShaderStencilOp_t

};

enum ShaderTexChannel_t

};

enum ShaderPolyModeFace_t

};

enum ShaderPolyMode_t

};

enum ShaderTexArg_t

};

enum ShaderTexOp_t

};

enum ShaderTexGenParam_t

};

enum ShaderDrawBitField_t

};

enum ShaderFogMode_t

};

enum ShaderMaterialSource_t

};

// m_ZBias has only two bits in ShadowState_t, so be careful extending this enum

enum PolygonOffsetMode_t

};

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

// The Shader interface versions

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

#define SHADERSHADOW_INTERFACE_VERSION "ShaderShadow010"

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

// the shader API interface (methods called from shaders)

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

abstract_class IShaderShadow

{

public:

// Sets the default *shadow* state

virtual void SetDefaultState() = 0;

// Methods related to depth buffering

virtual void DepthFunc( ShaderDepthFunc_t depthFunc ) = 0;

virtual void EnableDepthWrites( bool bEnable ) = 0;

virtual void EnableDepthTest( bool bEnable ) = 0;

virtual void EnablePolyOffset( PolygonOffsetMode_t nOffsetMode ) = 0;

// These methods for controlling stencil are obsolete and stubbed to do nothing. Stencil

// control is via the shaderapi/material system now, not part of the shadow state.

// Methods related to stencil

virtual void EnableStencil( bool bEnable ) = 0;

virtual void StencilFunc( ShaderStencilFunc_t stencilFunc ) = 0;

virtual void StencilPassOp( ShaderStencilOp_t stencilOp ) = 0;

virtual void StencilFailOp( ShaderStencilOp_t stencilOp ) = 0;

virtual void StencilDepthFailOp( ShaderStencilOp_t stencilOp ) = 0;

virtual void StencilReference( int nReference ) = 0;

virtual void StencilMask( int nMask ) = 0;

virtual void StencilWriteMask( int nMask ) = 0;

// Suppresses/activates color writing

virtual void EnableColorWrites( bool bEnable ) = 0;

virtual void EnableAlphaWrites( bool bEnable ) = 0;

// Methods related to alpha blending

virtual void EnableBlending( bool bEnable ) = 0;

virtual void BlendFunc( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor ) = 0;

// More below...

// Alpha testing

virtual void EnableAlphaTest( bool bEnable ) = 0;

virtual void AlphaFunc( ShaderAlphaFunc_t alphaFunc, float alphaRef /* [0-1] */ ) = 0;

// Wireframe/filled polygons

virtual void PolyMode( ShaderPolyModeFace_t face, ShaderPolyMode_t polyMode ) = 0;

// Back face culling

virtual void EnableCulling( bool bEnable ) = 0;

// constant color + transparency

virtual void EnableConstantColor( bool bEnable ) = 0;

// 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

virtual void VertexShaderVertexFormat( unsigned int nFlags,

int nTexCoordCount, int* pTexCoordDimensions, int nUserDataSize ) = 0;

// Pixel and vertex shader methods

virtual void SetVertexShader( const char* pFileName, int nStaticVshIndex ) = 0;

virtual void SetPixelShader( const char* pFileName, int nStaticPshIndex = 0 ) = 0;

// Indicates we're going to light the model

virtual void EnableLighting( bool bEnable ) = 0;

// Enables specular lighting (lighting has also got to be enabled)

virtual void EnableSpecular( bool bEnable ) = 0;

// Convert from linear to gamma color space on writes to frame buffer.

virtual void EnableSRGBWrite( bool bEnable ) = 0;

// Convert from gamma to linear on texture fetch.

virtual void EnableSRGBRead( Sampler_t sampler, bool bEnable ) = 0;

// 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)

virtual void EnableVertexBlend( bool bEnable ) = 0;

// per texture unit stuff

virtual void OverbrightValue( TextureStage_t stage, float value ) = 0;

virtual void EnableTexture( Sampler_t sampler, bool bEnable ) = 0;

virtual void EnableTexGen( TextureStage_t stage, bool bEnable ) = 0;

virtual void TexGen( TextureStage_t stage, ShaderTexGenParam_t param ) = 0;

// alternate method of specifying per-texture unit stuff, more flexible and more complicated

// Can be used to specify different operation per channel (alpha/color)...

virtual void EnableCustomPixelPipe( bool bEnable ) = 0;

virtual void CustomTextureStages( int stageCount ) = 0;

virtual void CustomTextureOperation( TextureStage_t stage, ShaderTexChannel_t channel,

ShaderTexOp_t op, ShaderTexArg_t arg1, ShaderTexArg_t arg2 ) = 0;

// indicates what per-vertex data we're providing

virtual void DrawFlags( unsigned int drawFlags ) = 0;

// A simpler method of dealing with alpha modulation

virtual void EnableAlphaPipe( bool bEnable ) = 0;

virtual void EnableConstantAlpha( bool bEnable ) = 0;

virtual void EnableVertexAlpha( bool bEnable ) = 0;

virtual void EnableTextureAlpha( TextureStage_t stage, bool bEnable ) = 0;

// GR - Separate alpha blending

virtual void EnableBlendingSeparateAlpha( bool bEnable ) = 0;

virtual void BlendFuncSeparateAlpha( ShaderBlendFactor_t srcFactor, ShaderBlendFactor_t dstFactor ) = 0;

virtual void FogMode( ShaderFogMode_t fogMode ) = 0;

virtual void SetDiffuseMaterialSource( ShaderMaterialSource_t materialSource ) = 0;

// Indicates the morph format for use with a vertex shader

// The flags to pass in here come from the MorphFormatFlags_t enum

virtual void SetMorphFormat( MorphFormat_t flags ) = 0;

virtual void DisableFogGammaCorrection( bool bDisable ) = 0; //some blending modes won't work properly with corrected fog

// Alpha to coverage

virtual void EnableAlphaToCoverage( bool bEnable ) = 0;

// Shadow map filtering

virtual void SetShadowDepthFiltering( Sampler_t stage ) = 0;

// More alpha blending state

virtual void BlendOp( ShaderBlendOp_t blendOp ) = 0;

virtual void BlendOpSeparateAlpha( ShaderBlendOp_t blendOp ) = 0;

};

// end class IShaderShadow

#endif // ISHADERSHADOW_H