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

//

// Purpose:

//

// $NoKeywords: $

//

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

#ifndef ISHADERDYNAMIC_H

#define ISHADERDYNAMIC_H

#ifdef _WIN32

#pragma once

#endif

#include "shaderapi/shareddefs.h"

#include "materialsystem/imaterial.h"

#include "materialsystem/imaterialsystem.h"

#include "tier0/basetypes.h"

typedef int ShaderAPITextureHandle_t;

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

// forward declarations

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

class CMeshBuilder;

class IMaterialVar;

struct LightDesc_t;

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

// State from ShaderAPI used to select proper vertex and pixel shader combos

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

struct LightState_t

};

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

// Color correction info

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

struct ShaderColorCorrectionInfo_t

};

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

// the 3D shader API interface

// This interface is all that shaders see.

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

enum StandardTextureId_t

};

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

// Viewport structure

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

#define SHADER_VIEWPORT_VERSION 1

struct ShaderViewport_t

};

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

// The Shader interface versions

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

#define SHADERDYNAMIC_INTERFACE_VERSION "ShaderDynamic001"

abstract_class IShaderDynamicAPI

{

public:

virtual void SetViewports( int nCount, const ShaderViewport_t* pViewports ) = 0;

virtual int GetViewports( ShaderViewport_t* pViewports, int nMax ) const = 0;

// returns the current time in seconds....

virtual double CurrentTime() const = 0;

// Gets the lightmap dimensions

virtual void GetLightmapDimensions( int *w, int *h ) = 0;

// Scene fog state.

// This is used by the shaders for picking the proper vertex shader for fogging based on dynamic state.

virtual MaterialFogMode_t GetSceneFogMode( ) = 0;

virtual void GetSceneFogColor( unsigned char *rgb ) = 0;

// stuff related to matrix stacks

virtual void MatrixMode( MaterialMatrixMode_t matrixMode ) = 0;

virtual void PushMatrix() = 0;

virtual void PopMatrix() = 0;

virtual void LoadMatrix( float *m ) = 0;

virtual void MultMatrix( float *m ) = 0;

virtual void MultMatrixLocal( float *m ) = 0;

virtual void GetMatrix( MaterialMatrixMode_t matrixMode, float *dst ) = 0;

virtual void LoadIdentity( void ) = 0;

virtual void LoadCameraToWorld( void ) = 0;

virtual void Ortho( double left, double right, double bottom, double top, double zNear, double zFar ) = 0;

virtual void PerspectiveX( double fovx, double aspect, double zNear, double zFar ) = 0;

virtual void PickMatrix( int x, int y, int width, int height ) = 0;

virtual void Rotate( float angle, float x, float y, float z ) = 0;

virtual void Translate( float x, float y, float z ) = 0;

virtual void Scale( float x, float y, float z ) = 0;

virtual void ScaleXY( float x, float y ) = 0;

// Sets the color to modulate by

virtual void Color3f( float r, float g, float b ) = 0;

virtual void Color3fv( float const* pColor ) = 0;

virtual void Color4f( float r, float g, float b, float a ) = 0;

virtual void Color4fv( float const* pColor ) = 0;

virtual void Color3ub( unsigned char r, unsigned char g, unsigned char b ) = 0;

virtual void Color3ubv( unsigned char const* pColor ) = 0;

virtual void Color4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a ) = 0;

virtual void Color4ubv( unsigned char const* pColor ) = 0;

// Sets the constant register for vertex and pixel shaders

virtual void SetVertexShaderConstant( int var, float const* pVec, int numConst = 1, bool bForce = false ) = 0;

virtual void SetPixelShaderConstant( int var, float const* pVec, int numConst = 1, bool bForce = false ) = 0;

// Sets the default *dynamic* state

virtual void SetDefaultState() = 0;

// Get the current camera position in world space.

virtual void GetWorldSpaceCameraPosition( float* pPos ) const = 0;

virtual int GetCurrentNumBones( void ) const = 0;

virtual int GetCurrentLightCombo( void ) const = 0;

virtual MaterialFogMode_t GetCurrentFogType( void ) const = 0;

// fixme: move this to shadow state

virtual void SetTextureTransformDimension( TextureStage_t textureStage, int dimension, bool projected ) = 0;

virtual void DisableTextureTransform( TextureStage_t textureStage ) = 0;

virtual void SetBumpEnvMatrix( TextureStage_t textureStage, float m00, float m01, float m10, float m11 ) = 0;

// Sets the vertex and pixel shaders

virtual void SetVertexShaderIndex( int vshIndex = -1 ) = 0;

virtual void SetPixelShaderIndex( int pshIndex = 0 ) = 0;

// Get the dimensions of the back buffer.

virtual void GetBackBufferDimensions( int& width, int& height ) const = 0;

// FIXME: The following 6 methods used to live in IShaderAPI

// and were moved for stdshader_dx8. Let's try to move them back!

// Get the lights

virtual int GetMaxLights( void ) const = 0;

virtual const LightDesc_t& GetLight( int lightNum ) const = 0;

virtual void SetPixelShaderFogParams( int reg ) = 0;

// Render state for the ambient light cube

virtual void SetVertexShaderStateAmbientLightCube() = 0;

virtual void SetPixelShaderStateAmbientLightCube( int pshReg, bool bForceToBlack = false ) = 0;

virtual void CommitPixelShaderLighting( int pshReg ) = 0;

// Use this to get the mesh builder that allows us to modify vertex data

virtual CMeshBuilder* GetVertexModifyBuilder() = 0;

virtual bool InFlashlightMode() const = 0;

virtual const FlashlightState_t &GetFlashlightState( VMatrix &worldToTexture ) const = 0;

virtual bool InEditorMode() const = 0;

// Gets the bound morph's vertex format; returns 0 if no morph is bound

virtual MorphFormat_t GetBoundMorphFormat() = 0;

// Binds a standard texture

virtual void BindStandardTexture( Sampler_t sampler, StandardTextureId_t id ) = 0;

virtual ITexture *GetRenderTargetEx( int nRenderTargetID ) = 0;

virtual void SetToneMappingScaleLinear( const Vector &scale ) = 0;

virtual const Vector &GetToneMappingScaleLinear( void ) const = 0;

virtual float GetLightMapScaleFactor( void ) const = 0;

virtual void LoadBoneMatrix( int boneIndex, const float *m ) = 0;

virtual void PerspectiveOffCenterX( double fovx, double aspect, double zNear, double zFar, double bottom, double top, double left, double right ) = 0;

virtual void SetFloatRenderingParameter(int parm_number, float value) = 0;

virtual void SetIntRenderingParameter(int parm_number, int value) = 0 ;

virtual void SetVectorRenderingParameter(int parm_number, Vector const &value) = 0 ;

virtual float GetFloatRenderingParameter(int parm_number) const = 0 ;

virtual int GetIntRenderingParameter(int parm_number) const = 0 ;

virtual Vector GetVectorRenderingParameter(int parm_number) const = 0 ;

// stencil buffer operations.

virtual void SetStencilEnable(bool onoff) = 0;

virtual void SetStencilFailOperation(StencilOperation_t op) = 0;

virtual void SetStencilZFailOperation(StencilOperation_t op) = 0;

virtual void SetStencilPassOperation(StencilOperation_t op) = 0;

virtual void SetStencilCompareFunction(StencilComparisonFunction_t cmpfn) = 0;

virtual void SetStencilReferenceValue(int ref) = 0;

virtual void SetStencilTestMask(uint32 msk) = 0;

virtual void SetStencilWriteMask(uint32 msk) = 0;

virtual void ClearStencilBufferRectangle( int xmin, int ymin, int xmax, int ymax,int value) = 0;

virtual void GetDXLevelDefaults(uint &max_dxlevel,uint &recommended_dxlevel) = 0;

virtual const FlashlightState_t &GetFlashlightStateEx( VMatrix &worldToTexture, ITexture **pFlashlightDepthTexture ) const = 0;

virtual float GetAmbientLightCubeLuminance() = 0;

virtual void GetDX9LightState( LightState_t *state ) const = 0;

virtual int GetPixelFogCombo( ) = 0; //0 is either range fog, or no fog simulated with rigged range fog values. 1 is height fog

virtual void BindStandardVertexTexture( VertexTextureSampler_t sampler, StandardTextureId_t id ) = 0;

// Is hardware morphing enabled?

virtual bool IsHWMorphingEnabled( ) const = 0;

virtual void GetStandardTextureDimensions( int *pWidth, int *pHeight, StandardTextureId_t id ) = 0;

virtual void SetBooleanVertexShaderConstant( int var, BOOL const* pVec, int numBools = 1, bool bForce = false ) = 0;

virtual void SetIntegerVertexShaderConstant( int var, int const* pVec, int numIntVecs = 1, bool bForce = false ) = 0;

virtual void SetBooleanPixelShaderConstant( int var, BOOL const* pVec, int numBools = 1, bool bForce = false ) = 0;

virtual void SetIntegerPixelShaderConstant( int var, int const* pVec, int numIntVecs = 1, bool bForce = false ) = 0;

//Are we in a configuration that needs access to depth data through the alpha channel later?

virtual bool ShouldWriteDepthToDestAlpha( void ) const = 0;

// deformations

virtual void PushDeformation( DeformationBase_t const *Deformation ) = 0;

virtual void PopDeformation( ) = 0;

virtual int GetNumActiveDeformations() const =0;

// for shaders to set vertex shader constants. returns a packed state which can be used to set

// the dynamic combo. returns # of active deformations

virtual int GetPackedDeformationInformation( int nMaskOfUnderstoodDeformations,

float *pConstantValuesOut,

int nBufferSize,

int nMaximumDeformations,

int *pNumDefsOut ) const = 0;

// This lets the lower level system that certain vertex fields requested

// in the shadow state aren't actually being read given particular state

// known only at dynamic state time. It's here only to silence warnings.

virtual void MarkUnusedVertexFields( unsigned int nFlags, int nTexCoordCount, bool *pUnusedTexCoords ) = 0;

virtual void ExecuteCommandBuffer( uint8 *pCmdBuffer ) =0;

// interface for mat system to tell shaderapi about standard texture handles

virtual void SetStandardTextureHandle( StandardTextureId_t nId, ShaderAPITextureHandle_t nHandle ) =0;

// Interface for mat system to tell shaderapi about color correction

virtual void GetCurrentColorCorrection( ShaderColorCorrectionInfo_t* pInfo ) = 0;

virtual void SetPSNearAndFarZ( int pshReg ) = 0;

virtual void SetDepthFeatheringPixelShaderConstant( int iConstant, float fDepthBlendScale ) = 0;

};

// end class IShaderDynamicAPI

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

// Software vertex shaders

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

typedef void (*SoftwareVertexShader_t)( CMeshBuilder& meshBuilder, IMaterialVar **params, IShaderDynamicAPI *pShaderAPI );

#endif // ISHADERDYNAMIC_H