expvintl/source-engine-2018-hl2_src
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
master
source-engine-2018-hl2_src/materialsystem/shaderapidx9/shaderapidx8.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

14355 lines
444 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//
// The dx8 implementation of the shader API
//===========================================================================//
/*
DX9 todo:
-make the transforms in the older shaders match the transforms in lightmappedgeneric
-fix polyoffset for hardware that doesn't support D3DRS_SLOPESCALEDEPTHBIAS and D3DRS_DEPTHBIAS
- code is there, I think matrix offset just needs tweaking
-fix forcehardwaresync - implement texture locking for hardware that doesn't support async query
-get the format for GetAdapterModeCount and EnumAdapterModes from somewhere (shaderapidx8.cpp, GetModeCount, GetModeInfo)
-record frame sync objects (allocframesyncobjects, free framesync objects, ForceHardwareSync)
-Need to fix ENVMAPMASKSCALE, BUMPOFFSET in lightmappedgeneric*.cpp and vertexlitgeneric*.cpp
fix this:
// FIXME: This also depends on the vertex format and whether or not we are static lit in dx9
#ifndef SHADERAPIDX9
if (m_DynamicState.m_VertexShader != shader) // garymcthack
#endif // !SHADERAPIDX9
unrelated to dx9:
mat_fullbright 1 doesn't work properly on alpha materials in testroom_standards
*/
#define DISABLE_PROTECTED_THINGS
#include "shaderapidx8.h"
#include "shaderapidx8_global.h"
#include "shadershadowdx8.h"
#include "locald3dtypes.h"
#include "utlvector.h"
#include "IHardwareConfigInternal.h"
#include "utlstack.h"
#include "shaderapi/ishaderutil.h"
#include "shaderapi/commandbuffer.h"
#include "shaderapidx8_global.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/itexture.h"
#include "imaterialinternal.h"
#include "imeshdx8.h"
#include "materialsystem/imorph.h"
#include "colorformatdx8.h"
#include "texturedx8.h"
#include "textureheap.h"
#include <malloc.h>
#include "interface.h"
#include "utlrbtree.h"
#include "utlsymbol.h"
#include "tier1/strtools.h"
#include "recording.h"
#ifndef _X360
#include <crtmemdebug.h>
#endif
#include "vertexshaderdx8.h"
#include "filesystem.h"
#include "mathlib/mathlib.h"
#include "materialsystem/materialsystem_config.h"
#include "worldsize.h"
#include "TransitionTable.h"
#include "tier0/vcrmode.h"
#include "tier0/vprof.h"
#include "tier1/tier1.h"
#include "tier1/utlbuffer.h"
#include "vertexdecl.h"
#include "tier0/icommandline.h"
#include "IShaderSystem.h"
#include "tier1/convar.h"
#include "tier1/KeyValues.h"
#include "Color.h"
#ifdef RECORDING
#include "materialsystem/IShader.h"
#endif
#include "../stdshaders/common_hlsl_cpp_consts.h" // hack hack hack!
#include "KeyValues.h"
#include "bitmap/imageformat.h"
#include "materialsystem/idebugtextureinfo.h"
#include "tier1/utllinkedlist.h"
#include "vtf/vtf.h"
#include "datacache/idatacache.h"
#include "renderparm.h"
#include "tier2/tier2.h"
#include "materialsystem/deformations.h"
#include "bitmap/tgawriter.h"
#include "tier0/icommandline.h"
#include "togl/rendermechanism.h" // provides GLMPRINTF/GLMPRINTSTR / GLMPRINTEXT macros which only activate if GLMDEBUG is nonzero and POSIX is defined.
#if defined( _X360 )
#include "xbox/xbox_console.h"
#include "xbox/xbox_win32stubs.h"
#include "xbox/xbox_launch.h"
#endif
#include "tier0/tslist.h"
#ifndef _X360
#include "wmi.h"
#endif
#include "filesystem/IQueuedLoader.h"
#include "shaderdevicedx8.h"
#include "togl/rendermechanism.h"
// Define this if you want to use a stubbed d3d.
//#define STUBD3D
#ifdef STUBD3D
#include "stubd3ddevice.h"
#endif
#include "winutils.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#if defined( OSX )
typedef unsigned int DWORD;
typedef DWORD* LPDWORD;
#endif
#ifdef _WIN32
#pragma warning (disable:4189)
#endif
ConVar mat_texture_limit( "mat_texture_limit", "-1", FCVAR_NEVER_AS_STRING,
"If this value is not -1, the material system will limit the amount of texture memory it uses in a frame."
" Useful for identifying performance cliffs. The value is in kilobytes." );
ConVar mat_frame_sync_enable( "mat_frame_sync_enable", "1", FCVAR_CHEAT );
ConVar mat_frame_sync_force_texture( "mat_frame_sync_force_texture", "0", FCVAR_CHEAT, "Force frame syncing to lock a managed texture." );
#if defined( _X360 )
ConVar mat_texturecachesize( "mat_texturecachesize", "176" );
ConVar mat_force_flush_texturecache( "mat_force_flush_texturecache", "0" );
#endif
extern ConVar mat_debugalttab;
#define ALLOW_SMP_ACCESS 0
#if ALLOW_SMP_ACCESS
static ConVar mat_use_smp( "mat_use_smp", "0" );
#endif
// Convars for driving PIX (not all hooked up yet...JasonM)
static ConVar r_pix_start( "r_pix_start", "0" );
static ConVar r_pix_recordframes( "r_pix_recordframes", "0" );
#define D3DDeviceWrapper IDirect3DDevice9
//-----------------------------------------------------------------------------
// Some important enumerations
//-----------------------------------------------------------------------------
enum
{
MAX_VERTEX_TEXTURE_COUNT = 4,
};
//-----------------------------------------------------------------------------
// These board states change with high frequency; are not shadowed
//-----------------------------------------------------------------------------
struct TextureStageState_t
{
D3DTEXTURETRANSFORMFLAGS m_TextureTransformFlags;
float m_BumpEnvMat00;
float m_BumpEnvMat01;
float m_BumpEnvMat10;
float m_BumpEnvMat11;
};
struct SamplerState_t
{
ShaderAPITextureHandle_t m_BoundTexture;
D3DTEXTUREADDRESS m_UTexWrap;
D3DTEXTUREADDRESS m_VTexWrap;
D3DTEXTUREADDRESS m_WTexWrap;
D3DTEXTUREFILTERTYPE m_MagFilter;
D3DTEXTUREFILTERTYPE m_MinFilter;
D3DTEXTUREFILTERTYPE m_MipFilter;
int m_FinestMipmapLevel;
float m_LodBias;
int m_nAnisotropicLevel;
bool m_TextureEnable;
bool m_SRGBReadEnable;
};
//-----------------------------------------------------------------------------
// State related to vertex textures
//-----------------------------------------------------------------------------
struct VertexTextureState_t
{
ShaderAPITextureHandle_t m_BoundTexture;
D3DTEXTUREADDRESS m_UTexWrap;
D3DTEXTUREADDRESS m_VTexWrap;
D3DTEXTUREFILTERTYPE m_MagFilter;
D3DTEXTUREFILTERTYPE m_MinFilter;
D3DTEXTUREFILTERTYPE m_MipFilter;
};
enum TransformType_t
{
TRANSFORM_IS_IDENTITY = 0,
TRANSFORM_IS_CAMERA_TO_WORLD,
TRANSFORM_IS_GENERAL,
};
enum TransformDirtyBits_t
{
STATE_CHANGED_VERTEX_SHADER = 0x1,
STATE_CHANGED_FIXED_FUNCTION = 0x2,
STATE_CHANGED = 0x3
};
enum
{
#if !defined( _X360 )
MAX_NUM_RENDERSTATES = ( D3DRS_BLENDOPALPHA+1 ),
#else
MAX_NUM_RENDERSTATES = D3DRS_MAX,
#endif
// MORPH_TARGET_FACTOR_COUNT = VERTEX_SHADER_MORPH_TARGET_FACTOR_COUNT * 4,
};
struct DynamicState_t
{
// Constant color
unsigned int m_ConstantColor;
// Normalize normals?
bool m_NormalizeNormals;
// Viewport state
D3DVIEWPORT9 m_Viewport;
// Transform state
D3DXMATRIX m_Transform[NUM_MATRIX_MODES];
unsigned char m_TransformType[NUM_MATRIX_MODES];
unsigned char m_TransformChanged[NUM_MATRIX_MODES];
// Ambient light color
D3DCOLOR m_Ambient;
D3DLIGHT m_Lights[MAX_NUM_LIGHTS];
LightDesc_t m_LightDescs[MAX_NUM_LIGHTS];
bool m_LightEnable[MAX_NUM_LIGHTS];
Vector4D m_AmbientLightCube[6];
unsigned char m_LightChanged[MAX_NUM_LIGHTS];
unsigned char m_LightEnableChanged[MAX_NUM_LIGHTS];
VertexShaderLightTypes_t m_LightType[MAX_NUM_LIGHTS];
Vector m_vLightingOrigin;
int m_NumLights;
// Shade mode
D3DSHADEMODE m_ShadeMode;
// Clear color
D3DCOLOR m_ClearColor;
// Fog
D3DCOLOR m_FogColor;
float m_PixelFogColor[4];
bool m_bFogGammaCorrectionDisabled;
bool m_FogEnable;
MaterialFogMode_t m_SceneFog;
D3DFOGMODE m_FogMode;
float m_FogStart;
float m_FogEnd;
float m_FogZ;
float m_FogMaxDensity;
float m_HeightClipZ;
MaterialHeightClipMode_t m_HeightClipMode;
// user clip planes
int m_UserClipPlaneEnabled;
int m_UserClipPlaneChanged;
D3DXPLANE m_UserClipPlaneWorld[MAXUSERCLIPPLANES];
D3DXPLANE m_UserClipPlaneProj[MAXUSERCLIPPLANES];
bool m_UserClipLastUpdatedUsingFixedFunction;
bool m_FastClipEnabled;
bool m_bFastClipPlaneChanged;
D3DXPLANE m_FastClipPlane;
// Used when overriding the user clip plane
bool m_bUserClipTransformOverride;
D3DXMATRIX m_UserClipTransform;
// Cull mode
D3DCULL m_DesiredCullMode;
D3DCULL m_CullMode;
bool m_bCullEnabled;
// Skinning
D3DVERTEXBLENDFLAGS m_VertexBlend;
int m_NumBones;
// Pixel and vertex shader constants...
Vector4D* m_pVectorVertexShaderConstant;
BOOL* m_pBooleanVertexShaderConstant;
IntVector4D* m_pIntegerVertexShaderConstant;
Vector4D* m_pVectorPixelShaderConstant;
BOOL* m_pBooleanPixelShaderConstant;
IntVector4D* m_pIntegerPixelShaderConstant;
// Texture stage state
TextureStageState_t m_TextureStage[MAX_TEXTURE_STAGES];
SamplerState_t m_SamplerState[MAX_SAMPLERS];
// Vertex texture stage state
VertexTextureState_t m_VertexTextureState[MAX_VERTEX_TEXTURE_COUNT];
DWORD m_RenderState[MAX_NUM_RENDERSTATES];
RECT m_ScissorRect;
IDirect3DVertexDeclaration9 *m_pVertexDecl;
bool m_bSRGBWritesEnabled;
bool m_bHWMorphingEnabled;
float m_DestAlphaDepthRange; //Dest alpha writes compress the depth to get better results. This holds the default setting that can be overriden with r_destalpharange
#if defined( _X360 )
int m_iVertexShaderGPRAllocation; //only need to track vertex shader
bool m_bBuffer2Frames;
#endif
DynamicState_t() {}
private:
DynamicState_t( DynamicState_t const& );
};
//-----------------------------------------------------------------------------
// Method to queue up dirty dynamic state change calls
//-----------------------------------------------------------------------------
typedef void (*StateCommitFunc_t)( IDirect3DDevice9 *pDevice, const DynamicState_t &desiredState, DynamicState_t &currentState, bool bForce );
static void CommitSetViewports( IDirect3DDevice9 *pDevice, const DynamicState_t &desiredState, DynamicState_t &currentState, bool bForce );
// NOTE: It's slightly memory inefficient, and definitely not typesafe,
// to put all commit funcs into the same table (vs, ff, per-draw, per-pass),
// but it makes the code a heck of a lot simpler and smaller.
enum CommitFunc_t
{
COMMIT_FUNC_CommitVertexTextures = 0,
COMMIT_FUNC_CommitFlexWeights,
COMMIT_FUNC_CommitSetScissorRect,
COMMIT_FUNC_CommitSetViewports,
#if defined( _X360 )
COMMIT_FUNC_CommitShaderGPRs,
#endif
COMMIT_FUNC_COUNT,
COMMIT_FUNC_BYTE_COUNT = ( COMMIT_FUNC_COUNT + 0x7 ) >> 3,
};
enum CommitFuncType_t
{
COMMIT_PER_DRAW = 0,
COMMIT_PER_PASS,
COMMIT_FUNC_TYPE_COUNT,
};
enum CommitShaderType_t
{
COMMIT_FIXED_FUNCTION = 0,
COMMIT_VERTEX_SHADER,
COMMIT_ALWAYS,
COMMIT_SHADER_TYPE_COUNT,
};
#define ADD_COMMIT_FUNC( _func, _shader, _func_name ) \
if ( !IsCommitFuncInUse( _func, _shader, COMMIT_FUNC_ ## _func_name ) ) \
{ \
AddCommitFunc( _func, _shader, _func_name ); \
MarkCommitFuncInUse( _func, _shader, COMMIT_FUNC_ ## _func_name ); \
}
#define ADD_RENDERSTATE_FUNC( _func, _shader, _func_name, _state, _val ) \
if ( m_bResettingRenderState || (m_DesiredState._state != _val) ) \
{ \
m_DesiredState._state = _val; \
ADD_COMMIT_FUNC( _func, _shader, _func_name ) \
}
#define ADD_VERTEX_TEXTURE_FUNC( _func, _shader, _func_name, _stage, _state, _val ) \
Assert( ( int )_stage < MAX_VERTEX_TEXTURE_COUNT ); \
if ( m_bResettingRenderState || (m_DesiredState.m_VertexTextureState[_stage]._state != _val) ) \
{ \
m_DesiredState.m_VertexTextureState[_stage]._state = _val; \
ADD_COMMIT_FUNC( _func, _shader, _func_name ) \
}
//-----------------------------------------------------------------------------
// Check render state support at compile time instead of runtime
//-----------------------------------------------------------------------------
#define SetSupportedRenderState( _state, _val ) \
{ \
if( _state != D3DRS_NOTSUPPORTED ) \
{ \
SetRenderState( _state, _val, false ); \
} \
}
#define SetSupportedRenderStateForce( _state, _val ) \
{ \
if( _state != D3DRS_NOTSUPPORTED ) \
{ \
SetRenderStateForce( _state, _val ); \
} \
}
//-----------------------------------------------------------------------------
// Allocated textures
//-----------------------------------------------------------------------------
struct Texture_t
{
Texture_t()
{
m_Flags = 0;
m_Count = 1;
m_CountIndex = 0;
m_nTimesBoundMax = 0;
m_nTimesBoundThisFrame = 0;
m_pTexture = NULL;
m_ppTexture = NULL;
m_ImageFormat = IMAGE_FORMAT_RGBA8888;
m_pTextureGroupCounterGlobal = NULL;
m_pTextureGroupCounterFrame = NULL;
m_FinestMipmapLevel = 0;
m_LodBias = 0.0f;
}
// FIXME: Compress this info
D3DTEXTUREADDRESS m_UTexWrap;
D3DTEXTUREADDRESS m_VTexWrap;
D3DTEXTUREADDRESS m_WTexWrap;
D3DTEXTUREFILTERTYPE m_MagFilter;
D3DTEXTUREFILTERTYPE m_MinFilter;
D3DTEXTUREFILTERTYPE m_MipFilter;
int m_FinestMipmapLevel;
float m_LodBias;
unsigned char m_NumLevels;
unsigned char m_SwitchNeeded; // Do we need to advance the current copy?
unsigned char m_NumCopies; // copies are used to optimize procedural textures
unsigned char m_CurrentCopy; // the current copy we're using...
int m_CreationFlags;
CUtlSymbol m_DebugName;
CUtlSymbol m_TextureGroupName;
int *m_pTextureGroupCounterGlobal; // Global counter for this texture's group.
int *m_pTextureGroupCounterFrame; // Per-frame global counter for this texture's group.
// stats stuff
int m_SizeBytes;
int m_SizeTexels;
int m_LastBoundFrame;
int m_nTimesBoundMax;
int m_nTimesBoundThisFrame;
enum Flags_t
{
IS_ALLOCATED = 0x0001,
IS_DEPTH_STENCIL = 0x0002,
IS_DEPTH_STENCIL_TEXTURE = 0x0004, // depth stencil texture, not surface
IS_RENDERABLE = ( IS_DEPTH_STENCIL | IS_ALLOCATED ),
IS_LOCKABLE = 0x0008,
IS_FINALIZED = 0x0010, // 360: completed async hi-res load
IS_FAILED = 0x0020, // 360: failed during load
CAN_CONVERT_FORMAT = 0x0040, // 360: allow format conversion
IS_LINEAR = 0x0080, // 360: unswizzled linear format
IS_RENDER_TARGET = 0x0100, // 360: marks a render target texture source
IS_RENDER_TARGET_SURFACE = 0x0200, // 360: marks a render target surface target
IS_VERTEX_TEXTURE = 0x0800,
};
short m_Width;
short m_Height;
short m_Depth;
unsigned short m_Flags;
typedef IDirect3DBaseTexture *IDirect3DBaseTexturePtr;
typedef IDirect3DBaseTexture **IDirect3DBaseTexturePtrPtr;
typedef IDirect3DSurface *IDirect3DSurfacePtr;
IDirect3DBaseTexturePtr GetTexture( void )
{
Assert( m_NumCopies == 1 );
Assert( !( m_Flags & IS_DEPTH_STENCIL ) );
return m_pTexture;
}
IDirect3DBaseTexturePtr GetTexture( int copy )
{
Assert( m_NumCopies > 1 );
Assert( !( m_Flags & IS_DEPTH_STENCIL ) );
return m_ppTexture[copy];
}
IDirect3DBaseTexturePtrPtr &GetTextureArray( void )
{
Assert( m_NumCopies > 1 );
Assert( !( m_Flags & IS_DEPTH_STENCIL ) );
return m_ppTexture;
}
IDirect3DSurfacePtr &GetDepthStencilSurface( void )
{
Assert( m_NumCopies == 1 );
Assert( (m_Flags & IS_DEPTH_STENCIL) );
return m_pDepthStencilSurface;
}
IDirect3DSurfacePtr &GetRenderTargetSurface( bool bSRGB )
{
Assert( m_NumCopies == 1 );
Assert( m_Flags & IS_RENDER_TARGET_SURFACE );
return m_pRenderTargetSurface[bSRGB];
}
void SetTexture( IDirect3DBaseTexturePtr pPtr )
{
m_pTexture = pPtr;
}
void SetTexture( int copy, IDirect3DBaseTexturePtr pPtr )
{
m_ppTexture[copy] = pPtr;
}
int GetMemUsage() const
{
return m_SizeBytes;
}
int GetWidth() const
{
return ( int )m_Width;
}
int GetHeight() const
{
return ( int )m_Height;
}
int GetDepth() const
{
return ( int )m_Depth;
}
int GetLodClamp() const
{
return m_FinestMipmapLevel;
}
void SetImageFormat( ImageFormat format )
{
m_ImageFormat = format;
}
ImageFormat GetImageFormat() const
{
return m_ImageFormat;
}
private:
union
{
IDirect3DBaseTexture *m_pTexture; // used when there's one copy
IDirect3DBaseTexture **m_ppTexture; // used when there are more than one copies
IDirect3DSurface *m_pDepthStencilSurface; // used when there's one depth stencil surface
IDirect3DSurface *m_pRenderTargetSurface[2];
};
ImageFormat m_ImageFormat;
public:
short m_Count;
short m_CountIndex;
short GetCount() const
{
return m_Count;
}
};
#define MAX_DEFORMATION_PARAMETERS 16
#define DEFORMATION_STACK_DEPTH 10
struct Deformation_t
{
int m_nDeformationType;
int m_nNumParameters;
float m_flDeformationParameters[MAX_DEFORMATION_PARAMETERS];
};
//-----------------------------------------------------------------------------
// The DX8 implementation of the shader API
//-----------------------------------------------------------------------------
class CShaderAPIDx8 : public CShaderDeviceDx8, public IShaderAPIDX8, public IDebugTextureInfo
{
typedef CShaderDeviceDx8 BaseClass;
public:
// constructor, destructor
CShaderAPIDx8( );
virtual ~CShaderAPIDx8();
// Methods of IShaderAPI
public:
virtual void SetViewports( int nCount, const ShaderViewport_t* pViewports );
virtual int GetViewports( ShaderViewport_t* pViewports, int nMax ) const;
virtual void ClearBuffers( bool bClearColor, bool bClearDepth, bool bClearStencil, int renderTargetWidth, int renderTargetHeight );
virtual void ClearColor3ub( unsigned char r, unsigned char g, unsigned char b );
virtual void ClearColor4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a );
virtual void BindVertexShader( VertexShaderHandle_t hVertexShader );
virtual void BindGeometryShader( GeometryShaderHandle_t hGeometryShader );
virtual void BindPixelShader( PixelShaderHandle_t hPixelShader );
virtual void SetRasterState( const ShaderRasterState_t& state );
virtual void SetFlexWeights( int nFirstWeight, int nCount, const MorphWeight_t* pWeights );
// Methods of IShaderDynamicAPI
public:
virtual void GetBackBufferDimensions( int &nWidth, int &nHeight ) const
{
// Chain to the device
BaseClass::GetBackBufferDimensions( nWidth, nHeight );
}
virtual void MarkUnusedVertexFields( unsigned int nFlags, int nTexCoordCount, bool *pUnusedTexCoords );
public:
// Methods of CShaderAPIBase
virtual bool OnDeviceInit();
virtual void OnDeviceShutdown();
virtual void ReleaseShaderObjects();
virtual void RestoreShaderObjects();
virtual void BeginPIXEvent( unsigned long color, const char *szName );
virtual void EndPIXEvent();
virtual void AdvancePIXFrame();
public:
// Methods of IShaderAPIDX8
virtual void QueueResetRenderState();
//
// Abandon all hope ye who pass below this line which hasn't been ported.
//
// Sets the mode...
bool SetMode( void* VD3DHWND, int nAdapter, const ShaderDeviceInfo_t &info );
// Change the video mode after it's already been set.
void ChangeVideoMode( const ShaderDeviceInfo_t &info );
// Sets the default render state
void SetDefaultState();
// Methods to ask about particular state snapshots
virtual bool IsTranslucent( StateSnapshot_t id ) const;
virtual bool IsAlphaTested( StateSnapshot_t id ) const;
virtual bool UsesVertexAndPixelShaders( StateSnapshot_t id ) const;
virtual int CompareSnapshots( StateSnapshot_t snapshot0, StateSnapshot_t snapshot1 );
// Computes the vertex format for a particular set of snapshot ids
VertexFormat_t ComputeVertexFormat( int num, StateSnapshot_t* pIds ) const;
VertexFormat_t ComputeVertexUsage( int num, StateSnapshot_t* pIds ) const;
// What fields in the morph do we actually use?
virtual MorphFormat_t ComputeMorphFormat( int numSnapshots, StateSnapshot_t* pIds ) const;
// Uses a state snapshot
void UseSnapshot( StateSnapshot_t snapshot );
// Color state
void Color3f( float r, float g, float b );
void Color4f( float r, float g, float b, float a );
void Color3fv( float const* c );
void Color4fv( float const* c );
void Color3ub( unsigned char r, unsigned char g, unsigned char b );
void Color3ubv( unsigned char const* pColor );
void Color4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a );
void Color4ubv( unsigned char const* pColor );
// Set the number of bone weights
virtual void SetNumBoneWeights( int numBones );
virtual void EnableHWMorphing( bool bEnable );
// Sets the vertex and pixel shaders
virtual void SetVertexShaderIndex( int vshIndex = -1 );
virtual void SetPixelShaderIndex( int pshIndex = 0 );
// Matrix state
void MatrixMode( MaterialMatrixMode_t matrixMode );
void PushMatrix();
void PopMatrix();
void LoadMatrix( float *m );
void LoadBoneMatrix( int boneIndex, const float *m );
void MultMatrix( float *m );
void MultMatrixLocal( float *m );
void GetMatrix( MaterialMatrixMode_t matrixMode, float *dst );
void LoadIdentity( void );
void LoadCameraToWorld( void );
void Ortho( double left, double top, double right, double bottom, double zNear, double zFar );
void PerspectiveX( double fovx, double aspect, double zNear, double zFar );
void PerspectiveOffCenterX( double fovx, double aspect, double zNear, double zFar, double bottom, double top, double left, double right );
void PickMatrix( int x, int y, int width, int height );
void Rotate( float angle, float x, float y, float z );
void Translate( float x, float y, float z );
void Scale( float x, float y, float z );
void ScaleXY( float x, float y );
// Binds a particular material to render with
void Bind( IMaterial* pMaterial );
IMaterialInternal* GetBoundMaterial();
// Level of anisotropic filtering
virtual void SetAnisotropicLevel( int nAnisotropyLevel );
virtual void SyncToken( const char *pToken );
// Cull mode
void CullMode( MaterialCullMode_t cullMode );
// Force writes only when z matches. . . useful for stenciling things out
// by rendering the desired Z values ahead of time.
void ForceDepthFuncEquals( bool bEnable );
// Turns off Z buffering
void OverrideDepthEnable( bool bEnable, bool bDepthEnable );
void OverrideAlphaWriteEnable( bool bOverrideEnable, bool bAlphaWriteEnable );
void OverrideColorWriteEnable( bool bOverrideEnable, bool bColorWriteEnable );
void SetHeightClipZ( float z );
void SetHeightClipMode( enum MaterialHeightClipMode_t heightClipMode );
void SetClipPlane( int index, const float *pPlane );
void EnableClipPlane( int index, bool bEnable );
void SetFastClipPlane(const float *pPlane);
void EnableFastClip(bool bEnable);
// The shade mode
void ShadeMode( ShaderShadeMode_t mode );
// Vertex blend state
void SetVertexBlendState( int numBones );
// Gets the dynamic mesh
IMesh* GetDynamicMesh( IMaterial* pMaterial, int nHWSkinBoneCount, bool buffered,
IMesh* pVertexOverride, IMesh* pIndexOverride );
IMesh* GetDynamicMeshEx( IMaterial* pMaterial, VertexFormat_t vertexFormat, int nHWSkinBoneCount,
bool bBuffered, IMesh* pVertexOverride, IMesh* pIndexOverride );
IMesh *GetFlexMesh();
// Returns the number of vertices we can render using the dynamic mesh
virtual void GetMaxToRender( IMesh *pMesh, bool bMaxUntilFlush, int *pMaxVerts, int *pMaxIndices );
virtual int GetMaxVerticesToRender( IMaterial *pMaterial );
virtual int GetMaxIndicesToRender( );
// Draws the mesh
void DrawMesh( CMeshBase* mesh );
// modifies the vertex data when necessary
void ModifyVertexData( );
// Draws
void BeginPass( StateSnapshot_t snapshot );
void RenderPass( int nPass, int nPassCount );
// We use smaller dynamic VBs during level transitions, to free up memory
virtual int GetCurrentDynamicVBSize( void );
virtual void DestroyVertexBuffers( bool bExitingLevel = false );
void SetVertexDecl( VertexFormat_t vertexFormat, bool bHasColorMesh, bool bUsingFlex, bool bUsingMorph );
// Sets the constant register for vertex and pixel shaders
FORCEINLINE void SetVertexShaderConstantInternal( int var, float const* pVec, int numVecs = 1, bool bForce = false );
void SetVertexShaderConstant( int var, float const* pVec, int numVecs = 1, bool bForce = false );
void SetBooleanVertexShaderConstant( int var, BOOL const* pVec, int numBools = 1, bool bForce = false );
void SetIntegerVertexShaderConstant( int var, int const* pVec, int numIntVecs = 1, bool bForce = false );
void SetPixelShaderConstant( int var, float const* pVec, int numVecs = 1, bool bForce = false );
FORCEINLINE void SetPixelShaderConstantInternal( int var, float const* pValues, int nNumConsts, bool bForce );
void SetBooleanPixelShaderConstant( int var, BOOL const* pVec, int numBools = 1, bool bForce = false );
void SetIntegerPixelShaderConstant( int var, int const* pVec, int numIntVecs = 1, bool bForce = false );
void InvalidateDelayedShaderConstants( void );
// Returns the nearest supported format
ImageFormat GetNearestSupportedFormat( ImageFormat fmt, bool bFilteringRequired = true ) const;
ImageFormat GetNearestRenderTargetFormat( ImageFormat format ) const;
virtual bool DoRenderTargetsNeedSeparateDepthBuffer() const;
// stuff that shouldn't be used from within a shader
void ModifyTexture( ShaderAPITextureHandle_t textureHandle );
void BindTexture( Sampler_t sampler, ShaderAPITextureHandle_t textureHandle );
virtual void BindVertexTexture( VertexTextureSampler_t nStage, ShaderAPITextureHandle_t textureHandle );
void DeleteTexture( ShaderAPITextureHandle_t textureHandle );
void WriteTextureToFile( ShaderAPITextureHandle_t hTexture, const char *szFileName );
bool IsTexture( ShaderAPITextureHandle_t textureHandle );
bool IsTextureResident( ShaderAPITextureHandle_t textureHandle );
FORCEINLINE bool TextureIsAllocated( ShaderAPITextureHandle_t hTexture )
{
return m_Textures.IsValidIndex( hTexture ) && ( GetTexture( hTexture ).m_Flags & Texture_t::IS_ALLOCATED );
}
FORCEINLINE void AssertValidTextureHandle( ShaderAPITextureHandle_t textureHandle )
{
#ifdef _DEBUG
Assert( TextureIsAllocated( textureHandle ) );
#endif
}
// Lets the shader know about the full-screen texture so it can
virtual void SetFullScreenTextureHandle( ShaderAPITextureHandle_t h );
virtual void SetLinearToGammaConversionTextures( ShaderAPITextureHandle_t hSRGBWriteEnabledTexture, ShaderAPITextureHandle_t hIdentityTexture );
// Set the render target to a texID.
// Set to SHADER_RENDERTARGET_BACKBUFFER if you want to use the regular framebuffer.
void SetRenderTarget( ShaderAPITextureHandle_t colorTextureHandle = SHADER_RENDERTARGET_BACKBUFFER,
ShaderAPITextureHandle_t depthTextureHandle = SHADER_RENDERTARGET_DEPTHBUFFER );
// Set the render target to a texID.
// Set to SHADER_RENDERTARGET_BACKBUFFER if you want to use the regular framebuffer.
void SetRenderTargetEx( int nRenderTargetID, ShaderAPITextureHandle_t colorTextureHandle = SHADER_RENDERTARGET_BACKBUFFER,
ShaderAPITextureHandle_t depthTextureHandle = SHADER_RENDERTARGET_DEPTHBUFFER );
// These are bound to the texture, not the texture environment
void TexMinFilter( ShaderTexFilterMode_t texFilterMode );
void TexMagFilter( ShaderTexFilterMode_t texFilterMode );
void TexWrap( ShaderTexCoordComponent_t coord, ShaderTexWrapMode_t wrapMode );
void TexSetPriority( int priority );
void TexLodClamp( int finest );
void TexLodBias( float bias );
ShaderAPITextureHandle_t CreateTextureHandle( void );
void CreateTextureHandles( ShaderAPITextureHandle_t *handles, int count );
ShaderAPITextureHandle_t CreateTexture(
int width,
int height,
int depth,
ImageFormat dstImageFormat,
int numMipLevels,
int numCopies,
int creationFlags,
const char *pDebugName,
const char *pTextureGroupName );
// Create a multi-frame texture (equivalent to calling "CreateTexture" multiple times, but more efficient)
void CreateTextures(
ShaderAPITextureHandle_t *pHandles,
int count,
int width,
int height,
int depth,
ImageFormat dstImageFormat,
int numMipLevels,
int numCopies,
int flags,
const char *pDebugName,
const char *pTextureGroupName );
ShaderAPITextureHandle_t CreateDepthTexture(
ImageFormat renderTargetFormat,
int width,
int height,
const char *pDebugName,
bool bTexture );
void TexImage2D(
int level,
int cubeFaceID,
ImageFormat dstFormat,
int zOffset,
int width,
int height,
ImageFormat srcFormat,
bool bSrcIsTiled,
void *imageData );
void TexSubImage2D(
int level,
int cubeFaceID,
int xOffset,
int yOffset,
int zOffset,
int width,
int height,
ImageFormat srcFormat,
int srcStride,
bool bSrcIsTiled,
void *imageData );
void TexImageFromVTF( IVTFTexture *pVTF, int iVTFFrame );
bool TexLock( int level, int cubeFaceID, int xOffset, int yOffset, int width, int height, CPixelWriter& writer );
void TexUnlock( );
// stuff that isn't to be used from within a shader
// what's the best way to hide this? subclassing?
virtual void ClearBuffersObeyStencil( bool bClearColor, bool bClearDepth );
virtual void ClearBuffersObeyStencilEx( bool bClearColor, bool bClearAlpha, bool bClearDepth );
virtual void PerformFullScreenStencilOperation( void );
void ReadPixels( int x, int y, int width, int height, unsigned char *data, ImageFormat dstFormat );
virtual void ReadPixels( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *data, ImageFormat dstFormat, int nDstStride );
// Gets the current buffered state... (debug only)
void GetBufferedState( BufferedState_t& state );
// Buffered primitives
void FlushBufferedPrimitives();
void FlushBufferedPrimitivesInternal( );
// Make sure we finish drawing everything that has been requested
void FlushHardware();
// Use this to begin and end the frame
void BeginFrame();
void EndFrame();
// Used to clear the transition table when we know it's become invalid.
void ClearSnapshots();
// Backward compat
virtual int GetActualTextureStageCount() const;
virtual int GetActualSamplerCount() const;
virtual int StencilBufferBits() const;
virtual bool IsAAEnabled() const; // Is antialiasing being used?
virtual bool OnAdapterSet( );
bool m_bAdapterSet;
void UpdateFastClipUserClipPlane( void );
bool ReadPixelsFromFrontBuffer() const;
// returns the current time in seconds....
double CurrentTime() const;
// Get the current camera position in world space.
void GetWorldSpaceCameraPosition( float* pPos ) const;
// Fog methods
void FogMode( MaterialFogMode_t fogMode );
void FogStart( float fStart );
void FogEnd( float fEnd );
void FogMaxDensity( float flMaxDensity );
void SetFogZ( float fogZ );
void GetFogDistances( float *fStart, float *fEnd, float *fFogZ );
void SceneFogMode( MaterialFogMode_t fogMode );
MaterialFogMode_t GetSceneFogMode( );
MaterialFogMode_t GetPixelFogMode( );
int GetPixelFogCombo( );//0 is either range fog, or no fog simulated with rigged range fog values. 1 is height fog
bool ShouldUsePixelFogForMode( MaterialFogMode_t fogMode );
void SceneFogColor3ub( unsigned char r, unsigned char g, unsigned char b );
void GetSceneFogColor( unsigned char *rgb );
void GetSceneFogColor( unsigned char *r, unsigned char *g, unsigned char *b );
// Selection mode methods
int SelectionMode( bool selectionMode );
void SelectionBuffer( unsigned int* pBuffer, int size );
void ClearSelectionNames( );
void LoadSelectionName( int name );
void PushSelectionName( int name );
void PopSelectionName();
bool IsInSelectionMode() const;
void RegisterSelectionHit( float minz, float maxz );
void WriteHitRecord();
// Binds a standard texture
virtual void BindStandardTexture( Sampler_t sampler, StandardTextureId_t id );
virtual void BindStandardVertexTexture( VertexTextureSampler_t sampler, StandardTextureId_t id );
virtual void GetStandardTextureDimensions( int *pWidth, int *pHeight, StandardTextureId_t id );
// Gets the lightmap dimensions
virtual void GetLightmapDimensions( int *w, int *h );
// Use this to get the mesh builder that allows us to modify vertex data
CMeshBuilder* GetVertexModifyBuilder();
virtual bool InFlashlightMode() const;
virtual bool InEditorMode() const;
// Gets the bound morph's vertex format; returns 0 if no morph is bound
virtual MorphFormat_t GetBoundMorphFormat();
// Helper to get at the texture state stage
TextureStageState_t& TextureStage( int stage ) { return m_DynamicState.m_TextureStage[stage]; }
const TextureStageState_t& TextureStage( int stage ) const { return m_DynamicState.m_TextureStage[stage]; }
SamplerState_t& SamplerState( int nSampler ) { return m_DynamicState.m_SamplerState[nSampler]; }
const SamplerState_t& SamplerState( int nSampler ) const { return m_DynamicState.m_SamplerState[nSampler]; }
void SetAmbientLight( float r, float g, float b );
void SetLight( int lightNum, const LightDesc_t& desc );
void SetLightingOrigin( Vector vLightingOrigin );
void DisableAllLocalLights();
void SetAmbientLightCube( Vector4D colors[6] );
float GetAmbientLightCubeLuminance( void );
int GetMaxLights( void ) const;
const LightDesc_t& GetLight( int lightNum ) const;
void SetVertexShaderStateAmbientLightCube();
void SetPixelShaderStateAmbientLightCube( int pshReg, bool bForceToBlack = false );
void CopyRenderTargetToTexture( ShaderAPITextureHandle_t textureHandle );
void CopyRenderTargetToTextureEx( ShaderAPITextureHandle_t textureHandle, int nRenderTargetID, Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL );
void CopyTextureToRenderTargetEx( int nRenderTargetID, ShaderAPITextureHandle_t textureHandle, Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL );
void CopyRenderTargetToScratchTexture( ShaderAPITextureHandle_t srcHandle, ShaderAPITextureHandle_t dstHandle, Rect_t *pSrcRect = NULL, Rect_t *pDstRect = NULL );
virtual void LockRect( void** pOutBits, int* pOutPitch, ShaderAPITextureHandle_t texHandle, int mipmap, int x, int y, int w, int h, bool bWrite, bool bRead );
virtual void UnlockRect( ShaderAPITextureHandle_t texHandle, int mipmap );
virtual void CopyTextureToTexture( ShaderAPITextureHandle_t srcTex, ShaderAPITextureHandle_t dstTex );
// Returns the cull mode (for fill rate computation)
D3DCULL GetCullMode() const;
void SetCullModeState( bool bEnable, D3DCULL nDesiredCullMode );
void ApplyCullEnable( bool bEnable );
// Alpha to coverage
void ApplyAlphaToCoverage( bool bEnable );
#if defined( _X360 )
void ApplySRGBReadState( int iTextureStage, bool bSRGBReadEnabled );
#endif
// Applies Z Bias
void ApplyZBias( const ShadowState_t& shaderState );
// Applies texture enable
void ApplyTextureEnable( const ShadowState_t& state, int stage );
void ApplyFogMode( ShaderFogMode_t fogMode, bool bSRGBWritesEnabled, bool bDisableFogGammaCorrection );
void UpdatePixelFogColorConstant( void );
void EnabledSRGBWrite( bool bEnabled );
// Gamma<->Linear conversions according to the video hardware we're running on
float GammaToLinear_HardwareSpecific( float fGamma ) const;
float LinearToGamma_HardwareSpecific( float fLinear ) const;
// Applies alpha blending
void ApplyAlphaBlend( bool bEnable, D3DBLEND srcBlend, D3DBLEND destBlend );
// Applies alpha texture op
void ApplyColorTextureStage( int stage, D3DTEXTUREOP op, int arg1, int arg2 );
void ApplyAlphaTextureStage( int stage, D3DTEXTUREOP op, int arg1, int arg2 );
// Sets texture stage stage + render stage state
void SetSamplerState( int stage, D3DSAMPLERSTATETYPE state, DWORD val );
void SetTextureStageState( int stage, D3DTEXTURESTAGESTATETYPE state, DWORD val);
void SetRenderStateForce( D3DRENDERSTATETYPE state, DWORD val );
void SetRenderState( D3DRENDERSTATETYPE state, DWORD val,
bool bFlushBufferedPrimitivesIfChanged = false);
// Scissor Rect
void SetScissorRect( const int nLeft, const int nTop, const int nRight, const int nBottom, const bool bEnableScissor );
// Can we download textures?
virtual bool CanDownloadTextures() const;
void ForceHardwareSync_WithManagedTexture();
void ForceHardwareSync( void );
void UpdateFrameSyncQuery( int queryIndex, bool bIssue );
void EvictManagedResources();
virtual void EvictManagedResourcesInternal();
// Gets at a particular transform
inline D3DXMATRIX& GetTransform( int i )
{
return *m_pMatrixStack[i]->GetTop();
}
int GetCurrentNumBones( void ) const;
bool IsHWMorphingEnabled( ) const;
int GetCurrentLightCombo( void ) const; // Used for DX8 only
void GetDX9LightState( LightState_t *state ) const; // Used for DX9 only
MaterialFogMode_t GetCurrentFogType( void ) const;
void RecordString( const char *pStr );
virtual bool IsRenderingMesh() const { return m_pRenderMesh != 0; }
void SetTextureTransformDimension( TextureStage_t textureStage, int dimension, bool projected );
void DisableTextureTransform( TextureStage_t textureMatrix );
void SetBumpEnvMatrix( TextureStage_t textureStage, float m00, float m01, float m10, float m11 );
int GetCurrentFrameCounter( void ) const
{
return m_CurrentFrame;
}
// Workaround hack for visualization of selection mode
virtual void SetupSelectionModeVisualizationState();
// Allocate and delete query objects.
virtual ShaderAPIOcclusionQuery_t CreateOcclusionQueryObject( void );
virtual void DestroyOcclusionQueryObject( ShaderAPIOcclusionQuery_t h );
// Bracket drawing with begin and end so that we can get counts next frame.
virtual void BeginOcclusionQueryDrawing( ShaderAPIOcclusionQuery_t h );
virtual void EndOcclusionQueryDrawing( ShaderAPIOcclusionQuery_t h );
// Get the number of pixels rendered between begin and end on an earlier frame.
// Calling this in the same frame is a huge perf hit!
virtual int OcclusionQuery_GetNumPixelsRendered( ShaderAPIOcclusionQuery_t h, bool bFlush );
void SetFlashlightState( const FlashlightState_t &state, const VMatrix &worldToTexture );
void SetFlashlightStateEx( const FlashlightState_t &state, const VMatrix &worldToTexture, ITexture *pFlashlightDepthTexture );
const FlashlightState_t &GetFlashlightState( VMatrix &worldToTexture ) const;
const FlashlightState_t &GetFlashlightStateEx( VMatrix &worldToTexture, ITexture **pFlashlightDepthTexture ) const;
// Gets at the shadow state for a particular state snapshot
virtual bool IsDepthWriteEnabled( StateSnapshot_t id ) const;
// IDebugTextureInfo implementation.
virtual bool IsDebugTextureListFresh( int numFramesAllowed = 1 );
virtual void EnableDebugTextureList( bool bEnable );
virtual bool SetDebugTextureRendering( bool bEnable );
virtual void EnableGetAllTextures( bool bEnable );
virtual KeyValues* GetDebugTextureList();
virtual int GetTextureMemoryUsed( TextureMemoryType eTextureMemory );
virtual void ClearVertexAndPixelShaderRefCounts();
virtual void PurgeUnusedVertexAndPixelShaders();
// Called when the dx support level has changed
virtual void DXSupportLevelChanged();
// User clip plane override
virtual void EnableUserClipTransformOverride( bool bEnable );
virtual void UserClipTransform( const VMatrix &worldToProjection );
bool UsingSoftwareVertexProcessing() const;
// Mark all user clip planes as being dirty
void MarkAllUserClipPlanesDirty();
// Converts a D3DXMatrix to a VMatrix and back
void D3DXMatrixToVMatrix( const D3DXMATRIX &in, VMatrix &out );
void VMatrixToD3DXMatrix( const VMatrix &in, D3DXMATRIX &out );
ITexture *GetRenderTargetEx( int nRenderTargetID );
virtual void SetToneMappingScaleLinear( const Vector &scale );
virtual const Vector &GetToneMappingScaleLinear( void ) const;
float GetLightMapScaleFactor( void ) const;
void SetFloatRenderingParameter(int parm_number, float value);
void SetIntRenderingParameter(int parm_number, int value);
void SetVectorRenderingParameter(int parm_number, Vector const &value);
float GetFloatRenderingParameter(int parm_number) const;
int GetIntRenderingParameter(int parm_number) const;
Vector GetVectorRenderingParameter(int parm_number) const;
// For dealing with device lost in cases where Present isn't called all the time (Hammer)
virtual void HandleDeviceLost();
virtual void EnableLinearColorSpaceFrameBuffer( bool bEnable );
virtual void SetPSNearAndFarZ( int pshReg );
// stencil methods
void SetStencilEnable(bool onoff);
void SetStencilFailOperation(StencilOperation_t op);
void SetStencilZFailOperation(StencilOperation_t op);
void SetStencilPassOperation(StencilOperation_t op);
void SetStencilCompareFunction(StencilComparisonFunction_t cmpfn);
void SetStencilReferenceValue(int ref);
void SetStencilTestMask(uint32 msk);
void SetStencilWriteMask(uint32 msk);
void ClearStencilBufferRectangle(int xmin, int ymin, int xmax, int ymax,int value);
virtual void GetDXLevelDefaults(uint &max_dxlevel,uint &recommended_dxlevel);
#if defined( _X360 )
HXUIFONT OpenTrueTypeFont( const char *pFontname, int tall, int style );
void CloseTrueTypeFont( HXUIFONT hFont );
bool GetTrueTypeFontMetrics( HXUIFONT hFont, XUIFontMetrics *pFontMetrics, XUICharMetrics charMetrics[256] );
// Render a sequence of characters and extract the data into a buffer
// For each character, provide the width+height of the font texture subrect,
// an offset to apply when rendering the glyph, and an offset into a buffer to receive the RGBA data
bool GetTrueTypeGlyphs( HXUIFONT hFont, int numChars, wchar_t *pWch, int *pOffsetX, int *pOffsetY, int *pWidth, int *pHeight, unsigned char *pRGBA, int *pRGBAOffset );
ShaderAPITextureHandle_t CreateRenderTargetSurface( int width, int height, ImageFormat format, const char *pDebugName, const char *pTextureGroupName );
void PersistDisplay();
bool PostQueuedTexture( const void *pData, int nSize, ShaderAPITextureHandle_t *pHandles, int nHandles, int nWidth, int nHeight, int nDepth, int nMips, int *pRefCount );
void *GetD3DDevice();
void PushVertexShaderGPRAllocation( int iVertexShaderCount = 64 );
void PopVertexShaderGPRAllocation( void );
void EnableVSync_360( bool bEnable );
#endif
virtual bool OwnGPUResources( bool bEnable );
// ------------ New Vertex/Index Buffer interface ----------------------------
void BindVertexBuffer( int streamID, IVertexBuffer *pVertexBuffer, int nOffsetInBytes, int nFirstVertex, int nVertexCount, VertexFormat_t fmt, int nRepetitions = 1 );
void BindIndexBuffer( IIndexBuffer *pIndexBuffer, int nOffsetInBytes );
void Draw( MaterialPrimitiveType_t primitiveType, int nFirstIndex, int nIndexCount );
// Draw the mesh with the currently bound vertex and index buffers.
void DrawWithVertexAndIndexBuffers( void );
// ------------ End ----------------------------
// deformations
virtual void PushDeformation( const DeformationBase_t *pDeformation );
virtual void PopDeformation( );
virtual int GetNumActiveDeformations( ) const ;
// for shaders to set vertex shader constants. returns a packed state which can be used to set the dynamic combo
virtual int GetPackedDeformationInformation( int nMaskOfUnderstoodDeformations,
float *pConstantValuesOut,
int nBufferSize,
int nMaximumDeformations,
int *pNumDefsOut ) const ;
inline Texture_t &GetTexture( ShaderAPITextureHandle_t hTexture )
{
return m_Textures[hTexture];
}
// Gets the texture
IDirect3DBaseTexture* GetD3DTexture( ShaderAPITextureHandle_t hTexture );
virtual bool ShouldWriteDepthToDestAlpha( void ) const;
virtual void AcquireThreadOwnership();
virtual void ReleaseThreadOwnership();
private:
enum
{
SMALL_BACK_BUFFER_SURFACE_WIDTH = 256,
SMALL_BACK_BUFFER_SURFACE_HEIGHT = 256,
};
bool m_bEnableDebugTextureList;
bool m_bDebugGetAllTextures;
bool m_bDebugTexturesRendering;
KeyValues *m_pDebugTextureList;
int m_nTextureMemoryUsedLastFrame, m_nTextureMemoryUsedTotal;
int m_nTextureMemoryUsedPicMip1, m_nTextureMemoryUsedPicMip2;
int m_nDebugDataExportFrame;
FlashlightState_t m_FlashlightState;
VMatrix m_FlashlightWorldToTexture;
ITexture *m_pFlashlightDepthTexture;
CShaderAPIDx8( CShaderAPIDx8 const& );
enum
{
INVALID_TRANSITION_OP = 0xFFFF
};
// State transition table for the device is as follows:
// Other app init causes transition from OK to OtherAppInit, during transition we must release resources
// !Other app init causes transition from OtherAppInit to OK, during transition we must restore resources
// Minimized or device lost or device not reset causes transition from OK to LOST_DEVICE, during transition we must release resources
// Minimized or device lost or device not reset causes transition from OtherAppInit to LOST_DEVICE
// !minimized AND !device lost causes transition from LOST_DEVICE to NEEDS_RESET
// minimized or device lost causes transition from NEEDS_RESET to LOST_DEVICE
// Successful TryDeviceReset and !Other app init causes transition from NEEDS_RESET to OK, during transition we must restore resources
// Successful TryDeviceReset and Other app init causes transition from NEEDS_RESET to OtherAppInit
void ExportTextureList();
void AddBufferToTextureList( const char *pName, D3DSURFACE_DESC &desc );
void SetupTextureGroup( ShaderAPITextureHandle_t hTexture, const char *pTextureGroupName );
// Creates the matrix stack
void CreateMatrixStacks();
// Initializes the render state
void InitRenderState( );
// Resets all dx renderstates to dx default so that our shadows are correct.
void ResetDXRenderState( );
// Resets the render state
void ResetRenderState( bool bFullReset = true );
// Setup standard vertex shader constants (that don't change)
void SetStandardVertexShaderConstants( float fOverbright );
// Initializes vertex and pixel shaders
void InitVertexAndPixelShaders();
// Discards the vertex and index buffers
void DiscardVertexBuffers();
// Computes the fill rate
void ComputeFillRate();
// Takes a snapshot
virtual StateSnapshot_t TakeSnapshot( );
// Converts the clear color to be appropriate for HDR
D3DCOLOR GetActualClearColor( D3DCOLOR clearColor );
// We lost the device
void OnDeviceLost();
// Gets the matrix stack from the matrix mode
int GetMatrixStack( MaterialMatrixMode_t mode ) const;
// Flushes the matrix state, returns false if we don't need to
// do any more work
bool MatrixIsChanging( TransformType_t transform = TRANSFORM_IS_GENERAL );
// Updates the matrix transform state
void UpdateMatrixTransform( TransformType_t transform = TRANSFORM_IS_GENERAL );
// Sets the vertex shader modelView state..
// NOTE: GetProjectionMatrix should only be called from the Commit functions!
const D3DXMATRIX &GetProjectionMatrix( void );
void SetVertexShaderViewProj();
void SetVertexShaderModelViewProjAndModelView();
void SetPixelShaderFogParams( int reg );
void SetPixelShaderFogParams( int reg, ShaderFogMode_t fogMode );
FORCEINLINE void UpdateVertexShaderFogParams( void )
{
if ( g_pHardwareConfig->Caps().m_SupportsPixelShaders )
{
float ooFogRange = 1.0f;
float fStart = m_VertexShaderFogParams[0];
float fEnd = m_VertexShaderFogParams[1];
// Check for divide by zero
if ( fEnd != fStart )
{
ooFogRange = 1.0f / ( fEnd - fStart );
}
float fogParams[4];
fogParams[0] = ooFogRange * fEnd;
fogParams[1] = 1.0f;
fogParams[2] = 1.0f - clamp( m_flFogMaxDensity, 0.0f, 1.0f ); // Max fog density
fogParams[3] = ooFogRange;
float vertexShaderCameraPos[4];
vertexShaderCameraPos[0] = m_WorldSpaceCameraPositon[0];
vertexShaderCameraPos[1] = m_WorldSpaceCameraPositon[1];
vertexShaderCameraPos[2] = m_WorldSpaceCameraPositon[2];
vertexShaderCameraPos[3] = m_DynamicState.m_FogZ; // waterheight
// cFogEndOverFogRange, cFogOne, unused, cOOFogRange
SetVertexShaderConstant( VERTEX_SHADER_FOG_PARAMS, fogParams, 1 );
// eyepos.x eyepos.y eyepos.z cWaterZ
SetVertexShaderConstant( VERTEX_SHADER_CAMERA_POS, vertexShaderCameraPos );
}
}
// Compute stats info for a texture
void ComputeStatsInfo( ShaderAPITextureHandle_t hTexture, bool isCubeMap, bool isVolumeTexture );
// For procedural textures
void AdvanceCurrentCopy( ShaderAPITextureHandle_t hTexture );
// Deletes a D3D texture
void DeleteD3DTexture( ShaderAPITextureHandle_t hTexture );
// Unbinds a texture
void UnbindTexture( ShaderAPITextureHandle_t hTexture );
// Releases all D3D textures
void ReleaseAllTextures();
// Deletes all textures
void DeleteAllTextures();
// Gets the currently modified texture handle
ShaderAPITextureHandle_t GetModifyTextureHandle() const;
// Gets the bind id
ShaderAPITextureHandle_t GetBoundTextureBindId( Sampler_t sampler ) const;
// If mat_texture_limit is enabled, then this tells us if binding the specified texture would
// take us over the limit.
bool WouldBeOverTextureLimit( ShaderAPITextureHandle_t hTexture );
// Sets the texture state
void SetTextureState( Sampler_t sampler, ShaderAPITextureHandle_t hTexture, bool force = false );
// Grab/release the internal render targets such as the back buffer and the save game thumbnail
void AcquireInternalRenderTargets();
void ReleaseInternalRenderTargets();
// create/release linear->gamma table texture lookups. Only used by hardware supporting pixel shader 2b and up
void AcquireLinearToGammaTableTextures();
void ReleaseLinearToGammaTableTextures();
// Gets the texture being modified
IDirect3DBaseTexture* GetModifyTexture();
void SetModifyTexture( IDirect3DBaseTexture *pTex );
// returns true if we're using texture coordinates at a given stage
bool IsUsingTextureCoordinates( int stage, int flags ) const;
// Returns true if the board thinks we're generating spheremap coordinates
bool IsSpheremapRenderStateActive( int stage ) const;
// Returns true if we're modulating constant color into the vertex color
bool IsModulatingVertexColor() const;
// Recomputes ambient light cube
void RecomputeAmbientLightCube( );
// Debugging spew
void SpewBoardState();
// Compute and save the world space camera position.
void CacheWorldSpaceCameraPosition();
// Compute and save the projection atrix with polyoffset built in if we need it.
void CachePolyOffsetProjectionMatrix();
// Vertex shader helper functions
int FindVertexShader( VertexFormat_t fmt, char const* pFileName ) const;
int FindPixelShader( char const* pFileName ) const;
// Returns copies of the front and back buffers
IDirect3DSurface* GetFrontBufferImage( ImageFormat& format );
IDirect3DSurface* GetBackBufferImage( Rect_t *pSrcRect, Rect_t *pDstRect, ImageFormat& format );
IDirect3DSurface* GetBackBufferImageHDR( Rect_t *pSrcRect, Rect_t *pDstRect, ImageFormat& format );
// Copy bits from a host-memory surface
void CopyBitsFromHostSurface( IDirect3DSurface* pSurfaceBits,
const Rect_t &dstRect, unsigned char *pData, ImageFormat srcFormat, ImageFormat dstFormat, int nDstStride );
FORCEINLINE void SetTransform( D3DTRANSFORMSTATETYPE State, CONST D3DXMATRIX *pMatrix )
{
#if !defined( _X360 )
Dx9Device()->SetTransform( State, pMatrix );
#endif
}
FORCEINLINE void SetLight( DWORD Index, CONST D3DLIGHT9 *pLight )
{
#if !defined( _X360 )
Dx9Device()->SetLight( Index, pLight );
#endif
}
FORCEINLINE void LightEnable( DWORD LightIndex, bool bEnable )
{
#if !defined( _X360 )
Dx9Device()->LightEnable( LightIndex, bEnable );
#endif
}
void ExecuteCommandBuffer( uint8 *pCmdBuffer );
void SetStandardTextureHandle( StandardTextureId_t nId, ShaderAPITextureHandle_t );
// Methods related to queuing functions to be called per-(pMesh->Draw call) or per-pass
void ClearAllCommitFuncs( CommitFuncType_t func, CommitShaderType_t shader );
void CallCommitFuncs( CommitFuncType_t func, CommitShaderType_t shader, bool bForce );
bool IsCommitFuncInUse( CommitFuncType_t func, CommitShaderType_t shader, int nFunc ) const;
void MarkCommitFuncInUse( CommitFuncType_t func, CommitShaderType_t shader, int nFunc );
void AddCommitFunc( CommitFuncType_t func, CommitShaderType_t shader, StateCommitFunc_t f );
void CallCommitFuncs( CommitFuncType_t func, bool bUsingFixedFunction, bool bForce = false );
// Commits transforms and lighting
void CommitStateChanges();
// Commits transforms that have to be dealt with on a per pass basis (ie. projection matrix for polyoffset)
void CommitPerPassStateChanges( StateSnapshot_t id );
// Need to handle fog mode on a per-pass basis
void CommitPerPassFogMode( bool bUsingVertexAndPixelShaders );
void CommitPerPassXboxFixups();
// Commits user clip planes
void CommitUserClipPlanes( bool bUsingFixedFunction );
// Gets the user clip transform (world->view)
D3DXMATRIX & GetUserClipTransform( );
// transform commit
bool VertexShaderTransformChanged( int i );
bool FixedFunctionTransformChanged( int i );
void UpdateVertexShaderMatrix( int iMatrix );
void SetVertexShaderStateSkinningMatrices();
void CommitVertexShaderTransforms();
void CommitPerPassVertexShaderTransforms();
void UpdateFixedFunctionMatrix( int iMatrix );
void SetFixedFunctionStateSkinningMatrices();
void CommitFixedFunctionTransforms();
void CommitPerPassFixedFunctionTransforms();
// Recomputes the fast-clip plane matrices based on the current fast-clip plane
void CommitFastClipPlane( );
// Computes a matrix which includes the poly offset given an initial projection matrix
void ComputePolyOffsetMatrix( const D3DXMATRIX& matProjection, D3DXMATRIX &matProjectionOffset );
void SetSkinningMatrices();
// lighting commit
bool VertexShaderLightingChanged( int i );
bool VertexShaderLightingEnableChanged( int i );
bool FixedFunctionLightingChanged( int i );
bool FixedFunctionLightingEnableChanged( int i );
VertexShaderLightTypes_t ComputeLightType( int i ) const;
void SortLights( int* index );
void CommitVertexShaderLighting();
void CommitPixelShaderLighting( int pshReg );
void CommitFixedFunctionLighting();
// Gets the surface associated with a texture (refcount of surface is increased)
IDirect3DSurface* GetTextureSurface( ShaderAPITextureHandle_t textureHandle );
IDirect3DSurface* GetDepthTextureSurface( ShaderAPITextureHandle_t textureHandle );
//
// Methods related to hardware config
//
void SetDefaultConfigValuesForDxLevel( int dxLevelFromCaps, ShaderDeviceInfo_t &info, unsigned int nFlagsUsed );
// Determines hardware capabilities
bool DetermineHardwareCaps( );
// Alpha To Coverage entrypoints and states - much of this involves vendor-dependent paths and states...
bool CheckVendorDependentAlphaToCoverage();
void EnableAlphaToCoverage();
void DisableAlphaToCoverage();
// Vendor-dependent shadow mapping detection
void CheckVendorDependentShadowMappingSupport( bool &bSupportsShadowDepthTextures, bool &bSupportsFetch4 );
// Override caps based on a requested dx level
void OverrideCaps( int nForcedDXLevel );
// Reports support for a given MSAA mode
bool SupportsMSAAMode( int nMSAAMode );
// Reports support for a given CSAA mode
bool SupportsCSAAMode( int nNumSamples, int nQualityLevel );
// Gamma correction of fog color, or not...
D3DCOLOR ComputeGammaCorrectedFogColor( unsigned char r, unsigned char g, unsigned char b, bool bSRGBWritesEnabled );
void SetDefaultMaterial();
bool RestorePersistedDisplay( bool bUseFrontBuffer );
void ClearStdTextureHandles( void );
// debug logging
void PrintfVA( char *fmt, va_list vargs );
void Printf( const char *fmt, ... );
float Knob( char *knobname, float *setvalue = NULL );
// "normal" back buffer and depth buffer. Need to keep this around so that we
// know what to set the render target to when we are done rendering to a texture.
IDirect3DSurface *m_pBackBufferSurface;
IDirect3DSurface *m_pBackBufferSurfaceSRGB;
IDirect3DSurface *m_pZBufferSurface;
// Optimization for screenshots
IDirect3DSurface *m_pSmallBackBufferFP16TempSurface;
ShaderAPITextureHandle_t m_hFullScreenTexture;
ShaderAPITextureHandle_t m_hLinearToGammaTableTexture;
ShaderAPITextureHandle_t m_hLinearToGammaTableIdentityTexture;
//
// State needed at the time of rendering (after snapshots have been applied)
//
// Interface for the D3DXMatrixStack
ID3DXMatrixStack* m_pMatrixStack[NUM_MATRIX_MODES];
matrix3x4_t m_boneMatrix[NUM_MODEL_TRANSFORMS];
int m_maxBoneLoaded;
// Current matrix mode
D3DTRANSFORMSTATETYPE m_MatrixMode;
int m_CurrStack;
// The current camera position in world space.
Vector4D m_WorldSpaceCameraPositon;
// The current projection matrix with polyoffset baked into it.
D3DXMATRIX m_CachedPolyOffsetProjectionMatrix;
D3DXMATRIX m_CachedFastClipProjectionMatrix;
D3DXMATRIX m_CachedFastClipPolyOffsetProjectionMatrix;
// The texture stage state that changes frequently
DynamicState_t m_DynamicState;
// The *desired* dynamic state. Most dynamic state is committed into actual hardware state
// at either per-pass or per-material time. This can also be used to force the hardware
// to match the desired state after returning from alt-tab.
DynamicState_t m_DesiredState;
// A list of state commit functions to run as per-draw call commit time
unsigned char m_pCommitFlags[COMMIT_FUNC_TYPE_COUNT][COMMIT_SHADER_TYPE_COUNT][ COMMIT_FUNC_BYTE_COUNT ];
CUtlVector< StateCommitFunc_t > m_CommitFuncs[COMMIT_FUNC_TYPE_COUNT][COMMIT_SHADER_TYPE_COUNT];
// Render data
CMeshBase *m_pRenderMesh;
int m_nDynamicVBSize;
IMaterialInternal *m_pMaterial;
// Shadow depth bias states
float m_fShadowSlopeScaleDepthBias;
float m_fShadowDepthBias;
bool m_bReadPixelsEnabled;
// Render-to-texture stuff...
bool m_UsingTextureRenderTarget;
int m_ViewportMaxWidth;
int m_ViewportMaxHeight;
ShaderAPITextureHandle_t m_hCachedRenderTarget;
bool m_bUsingSRGBRenderTarget;
// Ambient cube map ok?
int m_CachedAmbientLightCube;
// The current frame
int m_CurrentFrame;
// The texture we're currently modifying
ShaderAPITextureHandle_t m_ModifyTextureHandle;
char m_ModifyTextureLockedLevel;
unsigned char m_ModifyTextureLockedFace;
// Stores all textures
CUtlFixedLinkedList< Texture_t > m_Textures;
// Mesh builder used to modify vertex data
CMeshBuilder m_ModifyBuilder;
float m_VertexShaderFogParams[2];
float m_flFogMaxDensity;
// Shadow state transition table
CTransitionTable m_TransitionTable;
StateSnapshot_t m_nCurrentSnapshot;
// Depth test override...
bool m_bOverrideMaterialIgnoreZ;
bool m_bIgnoreZValue;
// Are we in the middle of resetting the render state?
bool m_bResettingRenderState;
// Can we buffer 2 frames ahead?
bool m_bBuffer2FramesAhead;
// Selection name stack
CUtlStack< int > m_SelectionNames;
bool m_InSelectionMode;
unsigned int* m_pSelectionBufferEnd;
unsigned int* m_pSelectionBuffer;
unsigned int* m_pCurrSelectionRecord;
float m_SelectionMinZ;
float m_SelectionMaxZ;
int m_NumHits;
// fog
unsigned char m_SceneFogColor[3];
MaterialFogMode_t m_SceneFogMode;
// Tone Mapping state ( w is gamma scale )
Vector4D m_ToneMappingScale;
Deformation_t m_DeformationStack[DEFORMATION_STACK_DEPTH];
Deformation_t *m_pDeformationStackPtr;
void WriteShaderConstantsToGPU();
// rendering parameter storage
int IntRenderingParameters[MAX_INT_RENDER_PARMS];
float FloatRenderingParameters[MAX_FLOAT_RENDER_PARMS];
Vector VectorRenderingParameters[MAX_VECTOR_RENDER_PARMS];
ShaderAPITextureHandle_t m_StdTextureHandles[TEXTURE_MAX_STD_TEXTURES];
// PIX instrumentation utlities...enable these with PIX_INSTRUMENTATION
void StartPIXInstrumentation();
void EndPIXInstrumentation();
void SetPIXMarker( unsigned long color, const char *szName );
void IncrementPIXError();
bool PIXError();
int m_nPIXErrorCount;
int m_nPixFrame;
bool m_bPixCapturing;
void ComputeVertexDescription( unsigned char* pBuffer, VertexFormat_t vertexFormat, MeshDesc_t& desc ) const
{
return MeshMgr()->ComputeVertexDescription( pBuffer, vertexFormat, desc );
}
// Reports support for shadow depth texturing
bool SupportsShadowDepthTextures( void );
bool SupportsFetch4( void );
void SetShadowDepthBiasFactors( float fShadowSlopeScaleDepthBias, float fShadowDepthBias );
// Vendor-dependent depth stencil texture format
ImageFormat GetShadowDepthTextureFormat( void );
bool SupportsBorderColor( void ) const;
bool SupportsFetch4( void ) const;
void EnableBuffer2FramesAhead( bool bEnable );
void SetDepthFeatheringPixelShaderConstant( int iConstant, float fDepthBlendScale );
void SetDisallowAccess( bool b )
{
g_bShaderAccessDisallowed = b;
}
void EnableShaderShaderMutex( bool b )
{
Assert( g_ShaderMutex.GetOwnerId() == 0 );
g_bUseShaderMutex = b;
}
void ShaderLock()
{
g_ShaderMutex.Lock();
}
void ShaderUnlock()
{
g_ShaderMutex.Unlock();
}
// Vendor-dependent slim texture format
ImageFormat GetNullTextureFormat( void );
//The idea behind a delayed constant is this.
// Some shaders set constants based on rendering states, and some rendering states aren't updated until after a shader's already called Draw().
// So, for some functions that are state based, we save the constant we set and if the state changes between when it's set in the shader setup code
// and when the shader is drawn, we update that constant.
struct DelayedConstants_t
{
int iPixelShaderFogParams;
void Invalidate( void )
{
iPixelShaderFogParams = -1;
}
DelayedConstants_t( void ) { this->Invalidate(); }
};
DelayedConstants_t m_DelayedShaderConstants;
bool SetRenderTargetInternalXbox( ShaderAPITextureHandle_t hTexture, bool bForce = false );
#if defined( _X360 )
CUtlStack<int> m_VertexShaderGPRAllocationStack;
#endif
int m_MaxVectorVertexShaderConstant;
int m_MaxBooleanVertexShaderConstant;
int m_MaxIntegerVertexShaderConstant;
int m_MaxVectorPixelShaderConstant;
int m_MaxBooleanPixelShaderConstant;
int m_MaxIntegerPixelShaderConstant;
bool m_bGPUOwned;
bool m_bResetRenderStateNeeded;
#ifdef ENABLE_NULLREF_DEVICE_SUPPORT
bool m_NullDevice;
#endif
};
//-----------------------------------------------------------------------------
// Class Factory
//-----------------------------------------------------------------------------
static CShaderAPIDx8 g_ShaderAPIDX8;
IShaderAPIDX8 *g_pShaderAPIDX8 = &g_ShaderAPIDX8;
CShaderDeviceDx8* g_pShaderDeviceDx8 = &g_ShaderAPIDX8;
// FIXME: Remove IShaderAPI + IShaderDevice; they change after SetMode
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderAPIDx8, IShaderAPI,
SHADERAPI_INTERFACE_VERSION, g_ShaderAPIDX8 )
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderAPIDx8, IShaderDevice,
SHADER_DEVICE_INTERFACE_VERSION, g_ShaderAPIDX8 )
EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CShaderAPIDx8, IDebugTextureInfo,
DEBUG_TEXTURE_INFO_VERSION, g_ShaderAPIDX8 )
//-----------------------------------------------------------------------------
// Accessors for major interfaces
//-----------------------------------------------------------------------------
// Pix wants a max of 32 characters
// We'll give it the right-most substrings separated by slashes
static char s_pPIXMaterialName[32];
void PIXifyName( char *pDst, int destSize, const char *pSrc )
{
char *pSrcWalk = (char *)pSrc;
while ( V_strlen( pSrcWalk ) > 31 ) // While we still have too many characters
{
char *pTok = strpbrk( pSrcWalk, "/\\" ); // Find next token
if ( pTok )
pSrcWalk = pTok + 1;
else
break;
}
V_strncpy( pDst, pSrcWalk, min( 32, destSize ) );
}
static int AdjustUpdateRange( float const* pVec, void const *pOut, int numVecs, int* pSkip )
{
int skip = 0;
uint32* pSrc = (uint32*)pVec;
uint32* pDst = (uint32*)pOut;
while( numVecs && !( ( pSrc[0] ^ pDst[0] ) | ( pSrc[1] ^ pDst[1] ) | ( pSrc[2] ^ pDst[2] ) | ( pSrc[3] ^ pDst[3] ) ) )
{
pSrc += 4;
pDst += 4;
numVecs--;
skip++;
}
*pSkip = skip;
if ( !numVecs )
return 0;
uint32* pSrcLast = pSrc + numVecs * 4 - 4;
uint32* pDstLast = pDst + numVecs * 4 - 4;
while( numVecs > 1 && !( ( pSrcLast[0] ^ pDstLast[0] ) | ( pSrcLast[1] ^ pDstLast[1] ) | ( pSrcLast[2] ^ pDstLast[2] ) | ( pSrcLast[3] ^ pDstLast[3] ) ) )
{
pSrcLast -= 4;
pDstLast -= 4;
numVecs--;
}
return numVecs;
}
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CShaderAPIDx8::CShaderAPIDx8() :
m_Textures( 32 ),
m_CurrStack( -1 ),
m_ModifyTextureHandle( INVALID_SHADERAPI_TEXTURE_HANDLE ),
m_pRenderMesh( 0 ),
m_nDynamicVBSize( DYNAMIC_VERTEX_BUFFER_MEMORY ),
m_pMaterial( NULL ),
m_CurrentFrame( 0 ),
m_CachedAmbientLightCube( STATE_CHANGED ),
m_InSelectionMode( false ),
m_SelectionMinZ( FLT_MAX ),
m_SelectionMaxZ( FLT_MIN ),
m_pSelectionBuffer( 0 ),
m_pSelectionBufferEnd( 0 ),
m_bResetRenderStateNeeded( false ),
m_ModifyTextureLockedLevel( -1 ),
m_nPixFrame(0),
m_bPixCapturing(false),
m_nPIXErrorCount(0),
m_pBackBufferSurface( 0 ),
m_pBackBufferSurfaceSRGB( 0 ),
m_pZBufferSurface( 0 ),
m_bResettingRenderState( false ),
m_bReadPixelsEnabled( false ),
m_ToneMappingScale( 1.0f, 1.0f, 1.0f, 1.0f ),
m_hFullScreenTexture( INVALID_SHADERAPI_TEXTURE_HANDLE ),
m_hLinearToGammaTableTexture( INVALID_SHADERAPI_TEXTURE_HANDLE ),
m_hLinearToGammaTableIdentityTexture( INVALID_SHADERAPI_TEXTURE_HANDLE ),
m_fShadowSlopeScaleDepthBias( 16.0f ),
m_fShadowDepthBias( 0.00008f ),
m_hCachedRenderTarget( INVALID_SHADERAPI_TEXTURE_HANDLE ),
m_bUsingSRGBRenderTarget( false )
{
// FIXME: Remove! Backward compat
m_bAdapterSet = false;
m_bBuffer2FramesAhead = false;
m_bReadPixelsEnabled = true;
memset( m_pMatrixStack, 0, sizeof(ID3DXMatrixStack*) * NUM_MATRIX_MODES );
memset( &m_DynamicState, 0, sizeof(m_DynamicState) );
//m_DynamicState.m_HeightClipMode = MATERIAL_HEIGHTCLIPMODE_DISABLE;
m_nWindowHeight = m_nWindowWidth = 0;
m_maxBoneLoaded = 0;
m_bEnableDebugTextureList = 0;
m_bDebugTexturesRendering = 0;
m_pDebugTextureList = NULL;
m_nTextureMemoryUsedLastFrame = 0;
m_nTextureMemoryUsedTotal = 0;
m_nTextureMemoryUsedPicMip1 = 0;
m_nTextureMemoryUsedPicMip2 = 0;
m_nDebugDataExportFrame = 0;
m_SceneFogColor[0] = 0;
m_SceneFogColor[1] = 0;
m_SceneFogColor[2] = 0;
m_SceneFogMode = MATERIAL_FOG_NONE;
// We haven't yet detected whether we support CreateQuery or not yet.
memset(IntRenderingParameters,0,sizeof(IntRenderingParameters));
memset(FloatRenderingParameters,0,sizeof(FloatRenderingParameters));
memset(VectorRenderingParameters,0,sizeof(VectorRenderingParameters));
m_pDeformationStackPtr = m_DeformationStack + DEFORMATION_STACK_DEPTH;
m_bGPUOwned = false;
m_MaxVectorVertexShaderConstant = 0;
m_MaxBooleanVertexShaderConstant = 0;
m_MaxIntegerVertexShaderConstant = 0;
m_MaxVectorPixelShaderConstant = 0;
m_MaxBooleanPixelShaderConstant = 0;
m_MaxIntegerPixelShaderConstant = 0;
ClearStdTextureHandles();
//Debugger();
#ifdef ENABLE_NULLREF_DEVICE_SUPPORT
m_NullDevice = !!CommandLine()->FindParm( "-nulldevice" );
#endif
}
CShaderAPIDx8::~CShaderAPIDx8()
{
if ( m_DynamicState.m_pVectorVertexShaderConstant )
{
delete[] m_DynamicState.m_pVectorVertexShaderConstant;
m_DynamicState.m_pVectorVertexShaderConstant = NULL;
}
if ( m_DynamicState.m_pBooleanVertexShaderConstant )
{
delete[] m_DynamicState.m_pBooleanVertexShaderConstant;
m_DynamicState.m_pBooleanVertexShaderConstant = NULL;
}
if ( m_DynamicState.m_pIntegerVertexShaderConstant )
{
delete[] m_DynamicState.m_pIntegerVertexShaderConstant;
m_DynamicState.m_pIntegerVertexShaderConstant = NULL;
}
if ( m_DynamicState.m_pVectorPixelShaderConstant )
{
delete[] m_DynamicState.m_pVectorPixelShaderConstant;
m_DynamicState.m_pVectorPixelShaderConstant = NULL;
}
if ( m_DynamicState.m_pBooleanPixelShaderConstant )
{
delete[] m_DynamicState.m_pBooleanPixelShaderConstant;
m_DynamicState.m_pBooleanPixelShaderConstant = NULL;
}
if ( m_DynamicState.m_pIntegerPixelShaderConstant )
{
delete[] m_DynamicState.m_pIntegerPixelShaderConstant;
m_DynamicState.m_pIntegerPixelShaderConstant = NULL;
}
if ( m_pDebugTextureList )
{
m_pDebugTextureList->deleteThis();
m_pDebugTextureList = NULL;
}
}
void CShaderAPIDx8::ClearStdTextureHandles( void )
{
for(int i = 0 ; i < ARRAYSIZE( m_StdTextureHandles ) ; i++ )
m_StdTextureHandles[i] = INVALID_SHADERAPI_TEXTURE_HANDLE;
}
//-----------------------------------------------------------------------------
// FIXME: Remove! Backward compat.
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::OnAdapterSet()
{
if ( !DetermineHardwareCaps( ) )
return false;
// Modify the caps based on requested DXlevels
int nForcedDXLevel = CommandLine()->ParmValue( "-dxlevel", 0 );
if ( nForcedDXLevel > 0 )
{
nForcedDXLevel = MAX( nForcedDXLevel, ABSOLUTE_MINIMUM_DXLEVEL );
}
// FIXME: Check g_pHardwareConfig->ActualCaps() for a preferred DX level
OverrideCaps( nForcedDXLevel );
m_bAdapterSet = true;
return true;
}
void CShaderAPIDx8::GetDXLevelDefaults(uint &max_dxlevel,uint &recommended_dxlevel)
{
max_dxlevel=g_pHardwareConfig->ActualCaps().m_nMaxDXSupportLevel;
recommended_dxlevel=g_pHardwareConfig->ActualCaps().m_nDXSupportLevel;
}
//-----------------------------------------------------------------------------
// Can we download textures?
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::CanDownloadTextures() const
{
if ( IsDeactivated() )
return false;
return IsActive();
}
//-----------------------------------------------------------------------------
// Grab the render targets
//-----------------------------------------------------------------------------
void CShaderAPIDx8::AcquireInternalRenderTargets()
{
GLMPRINTF(( ">-A- CShaderAPIDx8::AcquireInternalRenderTargets... "));
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: CShaderAPIDx8::AcquireInternalRenderTargets\n" );
}
if ( !m_pBackBufferSurface )
{
Dx9Device()->GetRenderTarget( 0, &m_pBackBufferSurface );
#ifdef ENABLE_NULLREF_DEVICE_SUPPORT
if( !m_NullDevice )
#endif
{
Assert( m_pBackBufferSurface );
}
}
#if defined( _X360 )
if ( !m_pBackBufferSurfaceSRGB )
{
// create a SRGB back buffer clone
int backWidth, backHeight;
ShaderAPI()->GetBackBufferDimensions( backWidth, backHeight );
D3DFORMAT backBufferFormat = ImageLoader::ImageFormatToD3DFormat( g_pShaderDevice->GetBackBufferFormat() );
m_pBackBufferSurfaceSRGB = g_TextureHeap.AllocRenderTargetSurface( backWidth, backHeight, (D3DFORMAT)MAKESRGBFMT( backBufferFormat ), true, 0 );
}
#endif
#ifdef ENABLE_NULLREF_DEVICE_SUPPORT
if ( !m_pZBufferSurface && !m_NullDevice )
#else
if ( !m_pZBufferSurface )
#endif
{
Dx9Device()->GetDepthStencilSurface( &m_pZBufferSurface );
Assert( m_pZBufferSurface );
}
GLMPRINTF(( "<-A- CShaderAPIDx8::AcquireInternalRenderTargets...complete "));
}
//-----------------------------------------------------------------------------
// Release the render targets
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ReleaseInternalRenderTargets( )
{
GLMPRINTF(( ">-A- CShaderAPIDx8::ReleaseInternalRenderTargets... "));
if( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: CShaderAPIDx8::ReleaseInternalRenderTargets\n" );
}
// Note: This function does not release renderable textures created elsewhere
// Those should be released separately via the texure manager
if ( m_pBackBufferSurface )
{
#if POSIX
// dxabstract's AddRef/Release have optional args to help track usage
int nRetVal = m_pBackBufferSurface->Release( 0, "-B CShaderAPIDx8::ReleaseInternalRenderTargets public release color buffer");
#else
int nRetVal = m_pBackBufferSurface->Release();
#endif
//Assert( nRetVal == 0 );
m_pBackBufferSurface = NULL;
}
if ( m_pZBufferSurface )
{
#if POSIX
// dxabstract's AddRef/Release have optional args to help track usage
int nRetVal = m_pZBufferSurface->Release( 0, "-B CShaderAPIDx8::ReleaseInternalRenderTargets public release zbuffer");
#else
int nRetVal = m_pZBufferSurface->Release();
#endif
//Assert( nRetVal == 0 ); //FIXME not sure why we're seeing a refcount of 3 here
m_pZBufferSurface = NULL;
}
GLMPRINTF(( "<-A- CShaderAPIDx8::ReleaseInternalRenderTargets... complete"));
}
//-----------------------------------------------------------------------------
// During init, places the persisted texture back into the back buffer.
// The initial 360 fixup present will then not flash. This routine has to be
// self contained, no other shader api systems are viable during init.
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::RestorePersistedDisplay( bool bUseFrontBuffer )
{
#if defined( _X360 )
if ( !( XboxLaunch()->GetLaunchFlags() & LF_INTERNALLAUNCH ) )
{
// there is no persisted screen
return false;
}
OwnGPUResources( false );
const char *strVertexShaderProgram =
" float4x4 matWVP : register(c0);"
" struct VS_IN"
" {"
" float4 ObjPos : POSITION;"
" float2 TexCoord : TEXCOORD;"
" };"
" struct VS_OUT"
" {"
" float4 ProjPos : POSITION;"
" float2 TexCoord : TEXCOORD;"
" };"
" VS_OUT main( VS_IN In )"
" {"
" VS_OUT Out; "
" Out.ProjPos = mul( matWVP, In.ObjPos );"
" Out.TexCoord = In.TexCoord;"
" return Out;"
" }";
const char *strPixelShaderProgram =
" struct PS_IN"
" {"
" float2 TexCoord : TEXCOORD;"
" };"
" sampler detail;"
" float4 main( PS_IN In ) : COLOR"
" {"
" return tex2D( detail, In.TexCoord );"
" }";
D3DVERTEXELEMENT9 VertexElements[3] =
{
{ 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },
{ 0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};
IDirect3DTexture *pTexture;
if ( bUseFrontBuffer )
{
Dx9Device()->GetFrontBuffer( &pTexture );
}
else
{
// 360 holds a persistent image across restarts
Dx9Device()->GetPersistedTexture( &pTexture );
}
ID3DXBuffer *pErrorMsg = NULL;
ID3DXBuffer *pShaderCode = NULL;
HRESULT hr = D3DXCompileShader( strVertexShaderProgram, (UINT)strlen( strVertexShaderProgram ), NULL, NULL, "main", "vs_2_0", 0, &pShaderCode, &pErrorMsg, NULL );
if ( FAILED( hr ) )
{
return false;
}
IDirect3DVertexShader9 *pVertexShader;
Dx9Device()->CreateVertexShader( (DWORD*)pShaderCode->GetBufferPointer(), &pVertexShader );
pShaderCode->Release();
pErrorMsg = NULL;
pShaderCode = NULL;
hr = D3DXCompileShader( strPixelShaderProgram, (UINT)strlen( strPixelShaderProgram ), NULL, NULL, "main", "ps_2_0", 0, &pShaderCode, &pErrorMsg, NULL );
if ( FAILED(hr) )
{
return false;
}
IDirect3DPixelShader9 *pPixelShader;
Dx9Device()->CreatePixelShader( (DWORD*)pShaderCode->GetBufferPointer(), &pPixelShader );
pShaderCode->Release();
int w, h;
GetBackBufferDimensions( w, h );
// Create a vertex declaration from the element descriptions.
IDirect3DVertexDeclaration9 *pVertexDecl;
Dx9Device()->CreateVertexDeclaration( VertexElements, &pVertexDecl );
XMMATRIX matWVP = XMMatrixOrthographicOffCenterLH( 0, (FLOAT)w, (FLOAT)h, 0, 0, 1 );
ConVarRef mat_monitorgamma( "mat_monitorgamma" );
ConVarRef mat_monitorgamma_tv_range_min( "mat_monitorgamma_tv_range_min" );
ConVarRef mat_monitorgamma_tv_range_max( "mat_monitorgamma_tv_range_max" );
ConVarRef mat_monitorgamma_tv_exp( "mat_monitorgamma_tv_exp" );
ConVarRef mat_monitorgamma_tv_enabled( "mat_monitorgamma_tv_enabled" );
g_pShaderDeviceDx8->SetHardwareGammaRamp( mat_monitorgamma.GetFloat(), mat_monitorgamma_tv_range_min.GetFloat(), mat_monitorgamma_tv_range_max.GetFloat(),
mat_monitorgamma_tv_exp.GetFloat(), mat_monitorgamma_tv_enabled.GetBool() );
// Structure to hold vertex data.
struct COLORVERTEX
{
FLOAT Position[3];
float TexCoord[2];
};
COLORVERTEX Vertices[4];
Vertices[0].Position[0] = 0;
Vertices[0].Position[1] = 0;
Vertices[0].Position[2] = 0;
Vertices[0].TexCoord[0] = 0;
Vertices[0].TexCoord[1] = 0;
Vertices[1].Position[0] = w-1;
Vertices[1].Position[1] = 0;
Vertices[1].Position[2] = 0;
Vertices[1].TexCoord[0] = 1;
Vertices[1].TexCoord[1] = 0;
Vertices[2].Position[0] = w-1;
Vertices[2].Position[1] = h-1;
Vertices[2].Position[2] = 0;
Vertices[2].TexCoord[0] = 1;
Vertices[2].TexCoord[1] = 1;
Vertices[3].Position[0] = 0;
Vertices[3].Position[1] = h-1;
Vertices[3].Position[2] = 0;
Vertices[3].TexCoord[0] = 0;
Vertices[3].TexCoord[1] = 1;
Dx9Device()->SetTexture( 0, pTexture );
Dx9Device()->SetVertexShader( pVertexShader );
Dx9Device()->SetPixelShader( pPixelShader );
Dx9Device()->SetVertexShaderConstantF( 0, (FLOAT*)&matWVP, 4 );
Dx9Device()->SetVertexDeclaration( pVertexDecl );
Dx9Device()->DrawPrimitiveUP( D3DPT_QUADLIST, 1, Vertices, sizeof( COLORVERTEX ) );
Dx9Device()->SetVertexShader( NULL );
Dx9Device()->SetPixelShader( NULL );
Dx9Device()->SetTexture( 0, NULL );
Dx9Device()->SetVertexDeclaration( NULL );
pVertexShader->Release();
pPixelShader->Release();
pVertexDecl->Release();
pTexture->Release();
OwnGPUResources( true );
return true;
#else
return false;
#endif
}
//-----------------------------------------------------------------------------
// Initialize, shutdown the Device....
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::OnDeviceInit()
{
AcquireInternalRenderTargets();
g_pHardwareConfig->CapsForEdit().m_TextureMemorySize = g_pShaderDeviceMgrDx8->GetVidMemBytes( m_nAdapter );
CreateMatrixStacks();
// Hide the cursor
RECORD_COMMAND( DX8_SHOW_CURSOR, 1 );
RECORD_INT( false );
#if !defined( _X360 )
Dx9Device()->ShowCursor( false );
#endif
// Initialize the shader manager
ShaderManager()->Init();
// Initialize the shader shadow
ShaderShadow()->Init();
// Initialize the mesh manager
MeshMgr()->Init();
bool bToolsMode = IsWindows() && ( CommandLine()->CheckParm( "-tools" ) != NULL );
// Use fat vertices when running in tools
MeshMgr()->UseFatVertices( bToolsMode );
// Initialize the transition table.
m_TransitionTable.Init();
// Initialize the render state
InitRenderState();
// Clear the z and color buffers
ClearBuffers( true, true, true, -1, -1 );
AllocFrameSyncObjects();
AllocNonInteractiveRefreshObjects();
RECORD_COMMAND( DX8_BEGIN_SCENE, 0 );
// Apply mandatory initialization HW fixups, GPU state will be left as expected
if ( IsX360() )
{
// place the possible persisted display into the back buffer, ready for present()
RestorePersistedDisplay( false );
// 360 MUST perform an initial swap to stabilize the state
// this ensures any states (e.g. gamma) are respected
// without this, the 360 resets to internal default state on the first swap
OwnGPUResources( false );
Dx9Device()->Present( 0, 0, 0, 0 );
// present corrupts the GPU state and back buffer (according to docs)
// re-clear the back buffer in order to re-establish the expected contents
ResetRenderState( false );
ClearBuffers( true, true, true, -1, -1 );
// place the front buffer image in the back buffer, later systems will detect and grab
// other systems will detect and grab
RestorePersistedDisplay( true );
}
Dx9Device()->BeginScene();
return true;
}
void CShaderAPIDx8::OnDeviceShutdown()
{
if ( !IsPC() || !IsActive() )
return;
// Deallocate all textures
DeleteAllTextures();
// Release render targets
ReleaseInternalRenderTargets();
// Free objects that are used for frame syncing.
FreeFrameSyncObjects();
FreeNonInteractiveRefreshObjects();
for (int i = 0; i < NUM_MATRIX_MODES; ++i)
{
if (m_pMatrixStack[i])
{
int ref = m_pMatrixStack[i]->Release();
Assert( ref == 0 );
}
}
// Shutdown the transition table.
m_TransitionTable.Shutdown();
MeshMgr()->Shutdown();
ShaderManager()->Shutdown();
ReleaseAllVertexDecl( );
}
//-----------------------------------------------------------------------------
// Sets the mode...
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::SetMode( void* VD3DHWND, int nAdapter, const ShaderDeviceInfo_t &info )
{
//
// FIXME: Note that this entire function is backward compat and will go soon
//
bool bRestoreNeeded = false;
if ( IsActive() )
{
ReleaseResources();
OnDeviceShutdown();
ShutdownDevice();
bRestoreNeeded = true;
}
LOCK_SHADERAPI();
Assert( D3D() );
Assert( nAdapter < g_pShaderDeviceMgr->GetAdapterCount() );
const HardwareCaps_t& actualCaps = g_pShaderDeviceMgr->GetHardwareCaps( nAdapter );
ShaderDeviceInfo_t actualInfo = info;
int nDXLevel = actualInfo.m_nDXLevel ? actualInfo.m_nDXLevel : actualCaps.m_nDXSupportLevel;
static bool bSetModeOnce = false;
if ( !bSetModeOnce )
{
nDXLevel = MAX( ABSOLUTE_MINIMUM_DXLEVEL, CommandLine()->ParmValue( "-dxlevel", nDXLevel ) );
bSetModeOnce = true;
}
if ( nDXLevel > actualCaps.m_nMaxDXSupportLevel )
{
nDXLevel = actualCaps.m_nMaxDXSupportLevel;
}
actualInfo.m_nDXLevel = g_pShaderDeviceMgr->GetClosestActualDXLevel( nDXLevel );
if ( !g_pShaderDeviceMgrDx8->ValidateMode( nAdapter, actualInfo ) )
return false;
g_pShaderAPI = this;
g_pShaderDevice = this;
g_pShaderShadow = ShaderShadow();
bool bOk = InitDevice( VD3DHWND, nAdapter, actualInfo );
if ( !bOk )
return false;
if ( !OnDeviceInit() )
return false;
if ( bRestoreNeeded && IsPC() )
{
ReacquireResources();
}
return true;
}
//-----------------------------------------------------------------------------
// Creates the matrix stack
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CreateMatrixStacks()
{
MEM_ALLOC_D3D_CREDIT();
for (int i = 0; i < NUM_MATRIX_MODES; ++i)
{
HRESULT hr = D3DXCreateMatrixStack( 0, &m_pMatrixStack[i] );
Assert( hr == D3D_OK );
}
}
//-----------------------------------------------------------------------------
// Vendor-dependent code to turn on alpha to coverage
//-----------------------------------------------------------------------------
void CShaderAPIDx8::EnableAlphaToCoverage( void )
{
if( !g_pHardwareConfig->ActualCaps().m_bSupportsAlphaToCoverage || !IsAAEnabled() )
return;
D3DRENDERSTATETYPE renderState = (D3DRENDERSTATETYPE)g_pHardwareConfig->Caps().m_AlphaToCoverageState;
SetRenderState( renderState, g_pHardwareConfig->Caps().m_AlphaToCoverageEnableValue ); // Vendor dependent state
}
//-----------------------------------------------------------------------------
// Vendor-dependent code to turn off alpha to coverage
//-----------------------------------------------------------------------------
void CShaderAPIDx8::DisableAlphaToCoverage()
{
if( !g_pHardwareConfig->ActualCaps().m_bSupportsAlphaToCoverage || !IsAAEnabled() )
return;
D3DRENDERSTATETYPE renderState = (D3DRENDERSTATETYPE)g_pHardwareConfig->Caps().m_AlphaToCoverageState;
SetRenderState( renderState, g_pHardwareConfig->Caps().m_AlphaToCoverageDisableValue ); // Vendor dependent state
}
//-----------------------------------------------------------------------------
// Determine capabilities
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::DetermineHardwareCaps( )
{
HardwareCaps_t& actualCaps = g_pHardwareConfig->ActualCapsForEdit();
if ( !g_pShaderDeviceMgrDx8->ComputeCapsFromD3D( &actualCaps, m_DisplayAdapter ) )
return false;
// See if the file tells us otherwise
g_pShaderDeviceMgrDx8->ReadDXSupportLevels( actualCaps );
// Read dxsupport.cfg which has config overrides for particular cards.
g_pShaderDeviceMgrDx8->ReadHardwareCaps( actualCaps, actualCaps.m_nMaxDXSupportLevel );
// What's in "-shader" overrides dxsupport.cfg
const char *pShaderParam = CommandLine()->ParmValue( "-shader" );
if ( pShaderParam )
{
Q_strncpy( actualCaps.m_pShaderDLL, pShaderParam, sizeof( actualCaps.m_pShaderDLL ) );
}
return true;
}
//-----------------------------------------------------------------------------
// Override caps based on a particular dx level
//-----------------------------------------------------------------------------
void CShaderAPIDx8::OverrideCaps( int nForcedDXLevel )
{
// Just use the actual caps if we can't use what was requested or if the default is requested
if ( nForcedDXLevel <= 0 )
{
nForcedDXLevel = g_pHardwareConfig->ActualCaps().m_nDXSupportLevel;
}
nForcedDXLevel = g_pShaderDeviceMgr->GetClosestActualDXLevel( nForcedDXLevel );
g_pHardwareConfig->SetupHardwareCaps( nForcedDXLevel, g_pHardwareConfig->ActualCaps() );
}
//-----------------------------------------------------------------------------
// Called when the dx support level has changed
//-----------------------------------------------------------------------------
void CShaderAPIDx8::DXSupportLevelChanged()
{
LOCK_SHADERAPI();
if ( IsPC() )
{
OverrideCaps( ShaderUtil()->GetConfig().dxSupportLevel );
}
else
{
Assert( 0 );
}
}
//-----------------------------------------------------------------------------
// FIXME: Remove! Backward compat only
//-----------------------------------------------------------------------------
int CShaderAPIDx8::GetActualTextureStageCount() const
{
return g_pHardwareConfig->GetActualTextureStageCount();
}
int CShaderAPIDx8::GetActualSamplerCount() const
{
return g_pHardwareConfig->GetActualSamplerCount();
}
int CShaderAPIDx8::StencilBufferBits() const
{
return m_bUsingStencil ? m_iStencilBufferBits : 0;
}
bool CShaderAPIDx8::IsAAEnabled() const
{
bool bAntialiasing = ( m_PresentParameters.MultiSampleType != D3DMULTISAMPLE_NONE );
return bAntialiasing;
}
//-----------------------------------------------------------------------------
// Methods related to queuing functions to be called per-(pMesh->Draw call) or per-pass
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::IsCommitFuncInUse( CommitFuncType_t func, CommitShaderType_t shader, int nFunc ) const
{
Assert( nFunc < COMMIT_FUNC_COUNT );
return ( m_pCommitFlags[func][shader][ nFunc >> 3 ] & ( 1 << ( nFunc & 0x7 ) ) ) != 0;
}
void CShaderAPIDx8::MarkCommitFuncInUse( CommitFuncType_t func, CommitShaderType_t shader, int nFunc )
{
m_pCommitFlags[func][shader][ nFunc >> 3 ] |= 1 << ( nFunc & 0x7 );
}
void CShaderAPIDx8::AddCommitFunc( CommitFuncType_t func, CommitShaderType_t shader, StateCommitFunc_t f )
{
m_CommitFuncs[func][shader].AddToTail( f );
}
//-----------------------------------------------------------------------------
// Clears all commit functions
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ClearAllCommitFuncs( CommitFuncType_t func, CommitShaderType_t shader )
{
memset( m_pCommitFlags[func][shader], 0, COMMIT_FUNC_BYTE_COUNT );
m_CommitFuncs[func][shader].RemoveAll();
}
//-----------------------------------------------------------------------------
// Calls all commit functions in a particular list
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CallCommitFuncs( CommitFuncType_t func, CommitShaderType_t shader, bool bForce )
{
// 360 does not have have a FF pipe
Assert ( IsPC() || ( IsX360() && shader != COMMIT_FIXED_FUNCTION ) );
// Don't bother committing anything if we're deactivated
if ( IsDeactivated() )
return;
CUtlVector< StateCommitFunc_t > &funcList = m_CommitFuncs[func][shader];
int nCount = funcList.Count();
if ( nCount == 0 )
return;
for ( int i = 0; i < nCount; ++i )
{
funcList[i]( Dx9Device(), m_DesiredState, m_DynamicState, bForce );
}
ClearAllCommitFuncs( func, shader );
}
//-----------------------------------------------------------------------------
// Calls all per-mesh draw commit functions
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CallCommitFuncs( CommitFuncType_t func, bool bUsingFixedFunction, bool bForce )
{
// Fixed-Function only funcs
if ( IsPC() && ( bUsingFixedFunction || bForce ) )
{
CallCommitFuncs( func, COMMIT_FIXED_FUNCTION, bForce );
}
// Vertex-shader only funcs
if ( !bUsingFixedFunction || bForce )
{
CallCommitFuncs( func, COMMIT_VERTEX_SHADER, bForce );
}
// State set in both FF + VS
CallCommitFuncs( func, COMMIT_ALWAYS, bForce );
}
//-----------------------------------------------------------------------------
// Sets the sampler state
//-----------------------------------------------------------------------------
static FORCEINLINE void SetSamplerState( IDirect3DDevice9 *pDevice, int stage, D3DSAMPLERSTATETYPE state, DWORD val )
{
RECORD_SAMPLER_STATE( stage, state, val );
#if defined( _X360 )
if ( state == D3DSAMP_NOTSUPPORTED )
return;
#endif
pDevice->SetSamplerState( stage, state, val );
}
inline void CShaderAPIDx8::SetSamplerState( int stage, D3DSAMPLERSTATETYPE state, DWORD val )
{
#ifndef DX_TO_GL_ABSTRACTION
if ( IsDeactivated() )
return;
#endif
::SetSamplerState( Dx9Device(), stage, state, val );
}
//-----------------------------------------------------------------------------
// Sets the texture stage state
//-----------------------------------------------------------------------------
inline void CShaderAPIDx8::SetTextureStageState( int stage, D3DTEXTURESTAGESTATETYPE state, DWORD val )
{
#if !defined( _X360 )
if ( IsDeactivated() )
return;
Dx9Device()->SetTextureStageState( stage, state, val );
#endif
}
inline void CShaderAPIDx8::SetRenderState( D3DRENDERSTATETYPE state, DWORD val, bool bFlushIfChanged )
{
#if ( !defined( _X360 ) && !defined( DX_TO_GL_ABSTRACTION ) )
{
if ( IsDeactivated() )
return;
}
#else
{
Assert( state != D3DRS_NOTSUPPORTED ); //Use SetSupportedRenderState() macro to avoid this at compile time
//if ( state == D3DRS_NOTSUPPORTED )
// return;
}
#endif
Assert( state >= 0 && ( int )state < MAX_NUM_RENDERSTATES );
if ( m_DynamicState.m_RenderState[state] != val )
{
if ( bFlushIfChanged )
{
FlushBufferedPrimitives();
}
#ifdef DX_TO_GL_ABSTRACTION
Dx9Device()->SetRenderStateInline( state, val );
#else
Dx9Device()->SetRenderState( state, val );
#endif
m_DynamicState.m_RenderState[state] = val;
}
}
#ifdef DX_TO_GL_ABSTRACTION
// Purposely always writing the new state (even if it's not changed), in case SetRenderStateConstInline() compiles away to nothing (it sometimes does)
#define SetRenderStateConstMacro(t, state, val ) \
do \
{ \
Assert( state >= 0 && ( int )state < MAX_NUM_RENDERSTATES ); \
if ( t->m_DynamicState.m_RenderState[state] != (DWORD)val ) \
{ \
Dx9Device()->SetRenderStateConstInline( state, val ); \
} \
t->m_DynamicState.m_RenderState[state] = val; \
} while(0)
#else
#define SetRenderStateConstMacro(t, state, val ) t->SetRenderState( state, val );
#endif
//-----------------------------------------------------------------------------
// Commits viewports
//-----------------------------------------------------------------------------
static void CommitSetScissorRect( IDirect3DDevice9 *pDevice, const DynamicState_t &desiredState, DynamicState_t &currentState, bool bForce )
{
// Set the enable/disable renderstate
bool bEnableChanged = desiredState.m_RenderState[D3DRS_SCISSORTESTENABLE] != currentState.m_RenderState[D3DRS_SCISSORTESTENABLE];
if ( bEnableChanged )
{
Dx9Device()->SetRenderState( D3DRS_SCISSORTESTENABLE, desiredState.m_RenderState[D3DRS_SCISSORTESTENABLE] );
currentState.m_RenderState[D3DRS_SCISSORTESTENABLE] = desiredState.m_RenderState[D3DRS_SCISSORTESTENABLE];
}
// Only bother with the rect if we're enabling
if ( desiredState.m_RenderState[D3DRS_SCISSORTESTENABLE] )
{
int nWidth, nHeight;
ITexture *pTexture = ShaderAPI()->GetRenderTargetEx( 0 );
if ( pTexture == NULL )
{
ShaderAPI()->GetBackBufferDimensions( nWidth, nHeight );
}
else
{
nWidth = pTexture->GetActualWidth();
nHeight = pTexture->GetActualHeight();
}
Assert( (desiredState.m_ScissorRect.left <= nWidth) && (desiredState.m_ScissorRect.bottom <= nHeight) &&
( desiredState.m_ScissorRect.top >= 0 ) && (desiredState.m_ScissorRect.left >= 0) );
clamp( desiredState.m_ScissorRect.right, 0, nWidth );
clamp( desiredState.m_ScissorRect.left, 0, nWidth );
clamp( desiredState.m_ScissorRect.top, 0, nHeight );
clamp( desiredState.m_ScissorRect.bottom, 0, nHeight );
Dx9Device()->SetScissorRect( &desiredState.m_ScissorRect );
currentState.m_ScissorRect = desiredState.m_ScissorRect;
}
}
// Routine for setting scissor rect
// If pScissorRect is NULL, disable scissoring by setting the render state
// If pScissorRect is non-NULL, set the RECT state in Direct3D AND set the renderstate
inline void CShaderAPIDx8::SetScissorRect( const int nLeft, const int nTop, const int nRight, const int nBottom, const bool bEnableScissor )
{
Assert( (nLeft <= nRight) && (nTop <= nBottom) ); //360 craps itself if this isn't true
if ( !g_pHardwareConfig->Caps().m_bScissorSupported )
return;
// If we're turning it on, check the validity of the rect
if ( bEnableScissor )
{
int nWidth, nHeight;
ITexture *pTexture = GetRenderTargetEx( 0 );
if ( pTexture == NULL )
{
GetBackBufferDimensions( nWidth, nHeight );
}
else
{
nWidth = pTexture->GetActualWidth();
nHeight = pTexture->GetActualHeight();
}
Assert( (nRight <= nWidth) && (nBottom <= nHeight) && ( nTop >= 0 ) && (nLeft >= 0) );
clamp( nRight, 0, nWidth );
clamp( nLeft, 0, nWidth );
clamp( nTop, 0, nHeight );
clamp( nBottom, 0, nHeight );
}
DWORD dwEnableScissor = bEnableScissor ? TRUE : FALSE;
RECT newScissorRect;
newScissorRect.left = nLeft;
newScissorRect.top = nTop;
newScissorRect.right = nRight;
newScissorRect.bottom = nBottom;
if ( !m_bResettingRenderState )
{
bool bEnableChanged = m_DesiredState.m_RenderState[D3DRS_SCISSORTESTENABLE] != dwEnableScissor;
bool bRectChanged = memcmp( &newScissorRect, &m_DesiredState.m_ScissorRect, sizeof(RECT) ) != 0;
if ( !bEnableChanged && !bRectChanged )
return;
}
if ( !IsDeactivated() )
{
// Do we need to do this always?
FlushBufferedPrimitives();
}
m_DesiredState.m_RenderState[D3DRS_SCISSORTESTENABLE] = dwEnableScissor;
memcpy( &m_DesiredState.m_ScissorRect, &newScissorRect, sizeof(RECT) );
ADD_COMMIT_FUNC( COMMIT_PER_DRAW, COMMIT_ALWAYS, CommitSetScissorRect );
}
inline void CShaderAPIDx8::SetRenderStateForce( D3DRENDERSTATETYPE state, DWORD val )
{
#if ( !defined( _X360 ) && !defined( DX_TO_GL_ABSTRACTION ) )
{
if ( IsDeactivated() )
return;
}
#else
{
Assert( state != D3DRS_NOTSUPPORTED ); //Use SetSupportedRenderStateForce() macro to avoid this at compile time
//if ( state == D3DRS_NOTSUPPORTED )
// return;
}
#endif
Dx9Device()->SetRenderState( state, val );
m_DynamicState.m_RenderState[state] = val;
}
//-----------------------------------------------------------------------------
// Set the values for pixel shader constants that don't change.
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetStandardVertexShaderConstants( float fOverbright )
{
LOCK_SHADERAPI();
if ( g_pHardwareConfig->GetDXSupportLevel() < 80 )
return;
// Set a couple standard constants....
Vector4D standardVertexShaderConstant( 0.0f, 1.0f, 2.0f, 0.5f );
SetVertexShaderConstant( VERTEX_SHADER_MATH_CONSTANTS0, standardVertexShaderConstant.Base(), 1 );
// [ gamma, overbright, 1/3, 1/overbright ]
standardVertexShaderConstant.Init( 1.0f/2.2f, fOverbright, 1.0f / 3.0f, 1.0f / fOverbright );
SetVertexShaderConstant( VERTEX_SHADER_MATH_CONSTANTS1, standardVertexShaderConstant.Base(), 1 );
int nModelIndex = g_pHardwareConfig->Caps().m_nDXSupportLevel < 90 ? VERTEX_SHADER_MODEL - 10 : VERTEX_SHADER_MODEL;
/*
if ( g_pHardwareConfig->Caps().m_SupportsVertexShaders_3_0 )
{
Vector4D factors[4];
factors[0].Init( 1, 0, 0, 0 );
factors[1].Init( 0, 1, 0, 0 );
factors[2].Init( 0, 0, 1, 0 );
factors[3].Init( 0, 0, 0, 1 );
SetVertexShaderConstant( VERTEX_SHADER_DOT_PRODUCT_FACTORS, factors[0].Base(), 4 );
}
*/
if ( g_pHardwareConfig->Caps().m_SupportsVertexShaders_2_0 )
{
float c[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
SetVertexShaderConstant( VERTEX_SHADER_FLEXSCALE, c, 1 );
}
else
{
// These point to the lighting and the transforms
standardVertexShaderConstant.Init(
VERTEX_SHADER_LIGHTS,
VERTEX_SHADER_LIGHTS + 5,
// Use COLOR instead of UBYTE4 since Geforce3 does not support it
// vConst.w should be 3, but due to about hack, mul by 255 and add epsilon
// 360 supports UBYTE4, so no fixup required
(IsPC() || !IsX360()) ? 765.01f : 3.0f,
nModelIndex ); // DX8 has different constant packing
SetVertexShaderConstant( VERTEX_SHADER_LIGHT_INDEX, standardVertexShaderConstant.Base(), 1 );
}
}
//-----------------------------------------------------------------------------
// Initialize vertex and pixel shaders
//-----------------------------------------------------------------------------
void CShaderAPIDx8::InitVertexAndPixelShaders()
{
// Allocate space for the pixel and vertex shader constants...
if ( g_pHardwareConfig->Caps().m_SupportsPixelShaders )
{
// pixel shaders
{
if (m_DynamicState.m_pVectorPixelShaderConstant)
{
delete[] m_DynamicState.m_pVectorPixelShaderConstant;
}
m_DynamicState.m_pVectorPixelShaderConstant = new Vector4D[g_pHardwareConfig->Caps().m_NumPixelShaderConstants];
if (m_DesiredState.m_pVectorPixelShaderConstant)
{
delete[] m_DesiredState.m_pVectorPixelShaderConstant;
}
m_DesiredState.m_pVectorPixelShaderConstant = new Vector4D[g_pHardwareConfig->Caps().m_NumPixelShaderConstants];
if (m_DynamicState.m_pBooleanPixelShaderConstant)
{
delete[] m_DynamicState.m_pBooleanPixelShaderConstant;
}
m_DynamicState.m_pBooleanPixelShaderConstant = new BOOL[g_pHardwareConfig->Caps().m_NumBooleanPixelShaderConstants];
if (m_DesiredState.m_pBooleanPixelShaderConstant)
{
delete[] m_DesiredState.m_pBooleanPixelShaderConstant;
}
m_DesiredState.m_pBooleanPixelShaderConstant = new BOOL[g_pHardwareConfig->Caps().m_NumBooleanPixelShaderConstants];
if (m_DynamicState.m_pIntegerPixelShaderConstant)
{
delete[] m_DynamicState.m_pIntegerPixelShaderConstant;
}
m_DynamicState.m_pIntegerPixelShaderConstant = new IntVector4D[g_pHardwareConfig->Caps().m_NumIntegerPixelShaderConstants];
if (m_DesiredState.m_pIntegerPixelShaderConstant)
{
delete[] m_DesiredState.m_pIntegerPixelShaderConstant;
}
m_DesiredState.m_pIntegerPixelShaderConstant = new IntVector4D[g_pHardwareConfig->Caps().m_NumIntegerPixelShaderConstants];
// force reset vector pixel constants
int i;
for ( i = 0; i < g_pHardwareConfig->Caps().m_NumPixelShaderConstants; ++i )
{
m_DesiredState.m_pVectorPixelShaderConstant[i].Init();
}
SetPixelShaderConstant( 0, m_DesiredState.m_pVectorPixelShaderConstant[0].Base(), g_pHardwareConfig->Caps().m_NumPixelShaderConstants, true );
// force reset boolean pixel constants
int nNumBooleanPixelShaderConstants = g_pHardwareConfig->Caps().m_NumBooleanPixelShaderConstants;
if ( nNumBooleanPixelShaderConstants )
{
for ( i = 0; i < nNumBooleanPixelShaderConstants; ++i )
{
m_DesiredState.m_pBooleanPixelShaderConstant[i] = 0;
}
SetBooleanPixelShaderConstant( 0, m_DesiredState.m_pBooleanPixelShaderConstant, nNumBooleanPixelShaderConstants, true );
}
// force reset integer pixel constants
int nNumIntegerPixelShaderConstants = g_pHardwareConfig->Caps().m_NumIntegerPixelShaderConstants;
if ( nNumIntegerPixelShaderConstants )
{
for ( i = 0; i < nNumIntegerPixelShaderConstants; ++i )
{
m_DesiredState.m_pIntegerPixelShaderConstant[i].Init();
}
SetIntegerPixelShaderConstant( 0, m_DesiredState.m_pIntegerPixelShaderConstant[0].Base(), nNumIntegerPixelShaderConstants, true );
}
}
// vertex shaders
{
if (m_DynamicState.m_pVectorVertexShaderConstant)
{
delete[] m_DynamicState.m_pVectorVertexShaderConstant;
}
m_DynamicState.m_pVectorVertexShaderConstant = new Vector4D[g_pHardwareConfig->Caps().m_NumVertexShaderConstants];
if (m_DesiredState.m_pVectorVertexShaderConstant)
{
delete[] m_DesiredState.m_pVectorVertexShaderConstant;
}
m_DesiredState.m_pVectorVertexShaderConstant = new Vector4D[g_pHardwareConfig->Caps().m_NumVertexShaderConstants];
if (m_DynamicState.m_pBooleanVertexShaderConstant)
{
delete[] m_DynamicState.m_pBooleanVertexShaderConstant;
}
m_DynamicState.m_pBooleanVertexShaderConstant = new BOOL[g_pHardwareConfig->Caps().m_NumBooleanVertexShaderConstants];
if (m_DesiredState.m_pBooleanVertexShaderConstant)
{
delete[] m_DesiredState.m_pBooleanVertexShaderConstant;
}
m_DesiredState.m_pBooleanVertexShaderConstant = new BOOL[g_pHardwareConfig->Caps().m_NumBooleanVertexShaderConstants];
if (m_DynamicState.m_pIntegerVertexShaderConstant)
{
delete[] m_DynamicState.m_pIntegerVertexShaderConstant;
}
m_DynamicState.m_pIntegerVertexShaderConstant = new IntVector4D[g_pHardwareConfig->Caps().m_NumIntegerVertexShaderConstants];
if (m_DesiredState.m_pIntegerVertexShaderConstant)
{
delete[] m_DesiredState.m_pIntegerVertexShaderConstant;
}
m_DesiredState.m_pIntegerVertexShaderConstant = new IntVector4D[g_pHardwareConfig->Caps().m_NumIntegerVertexShaderConstants];
// force reset vector vertex constants
int i;
for ( i = 0; i < g_pHardwareConfig->Caps().m_NumVertexShaderConstants; ++i )
{
m_DesiredState.m_pVectorVertexShaderConstant[i].Init();
}
SetVertexShaderConstant( 0, m_DesiredState.m_pVectorVertexShaderConstant[0].Base(), g_pHardwareConfig->Caps().m_NumVertexShaderConstants, true );
// force reset boolean vertex constants
for ( i = 0; i < g_pHardwareConfig->Caps().m_NumBooleanVertexShaderConstants; ++i )
{
m_DesiredState.m_pBooleanVertexShaderConstant[i] = 0;
}
SetBooleanVertexShaderConstant( 0, m_DesiredState.m_pBooleanVertexShaderConstant, g_pHardwareConfig->Caps().m_NumBooleanVertexShaderConstants, true );
// force reset integer vertex constants
for ( i = 0; i < g_pHardwareConfig->Caps().m_NumIntegerVertexShaderConstants; ++i )
{
m_DesiredState.m_pIntegerVertexShaderConstant[i].Init();
}
SetIntegerVertexShaderConstant( 0, m_DesiredState.m_pIntegerVertexShaderConstant[0].Base(), g_pHardwareConfig->Caps().m_NumIntegerVertexShaderConstants, true );
}
if ( IsX360() )
{
// to init/update all constants, must disable ownership
bool bPreviousState = OwnGPUResources( false );
WriteShaderConstantsToGPU();
OwnGPUResources( bPreviousState );
}
SetStandardVertexShaderConstants( OVERBRIGHT );
}
// Set up the vertex and pixel shader stuff
ShaderManager()->ResetShaderState();
}
//-----------------------------------------------------------------------------
// Initialize render state
//-----------------------------------------------------------------------------
void CShaderAPIDx8::InitRenderState()
{
// Set the default shadow state
g_pShaderShadowDx8->SetDefaultState();
// Grab a snapshot of this state; we'll be using it to set the board
// state to something well defined.
m_TransitionTable.TakeDefaultStateSnapshot();
if ( !IsDeactivated() )
{
ResetRenderState();
}
}
//-----------------------------------------------------------------------------
// Commits vertex textures
//-----------------------------------------------------------------------------
static void CommitVertexTextures( IDirect3DDevice9 *pDevice, const DynamicState_t &desiredState, DynamicState_t &currentState, bool bForce )
{
int nCount = g_pMaterialSystemHardwareConfig->GetVertexTextureCount();
for ( int i = 0; i < nCount; ++i )
{
VertexTextureState_t &currentVTState = currentState.m_VertexTextureState[i];
ShaderAPITextureHandle_t textureHandle = desiredState.m_VertexTextureState[i].m_BoundTexture;
Texture_t *pTexture = ( textureHandle != INVALID_SHADERAPI_TEXTURE_HANDLE ) ? &g_ShaderAPIDX8.GetTexture( textureHandle ) : NULL;
if ( pTexture && ( pTexture->m_Flags & Texture_t::IS_VERTEX_TEXTURE ) == 0 )
{
Warning( "Attempting to bind a vertex texture (%s) which was not created as a vertex texture!\n", pTexture->m_DebugName.String() );
}
if ( bForce || ( currentVTState.m_BoundTexture != textureHandle ) )
{
currentVTState.m_BoundTexture = textureHandle;
// RECORD_COMMAND( DX8_SET_VERTEXTEXTURE, 3 );
// RECORD_INT( D3DVERTEXTEXTURESAMPLER0 + nStage );
// RECORD_INT( pTexture ? pTexture->GetUniqueID() : 0xFFFF );
// RECORD_INT( 0 );
IDirect3DBaseTexture *pD3DTexture = ( textureHandle >= 0 ) ? g_ShaderAPIDX8.GetD3DTexture( textureHandle ) : NULL;
pDevice->SetTexture( D3DVERTEXTEXTURESAMPLER0 + i, pD3DTexture );
}
if ( !pTexture )
continue;
D3DTEXTUREADDRESS nNewUTexWrap = pTexture->m_UTexWrap;
if ( bForce || ( currentVTState.m_UTexWrap != nNewUTexWrap ) )
{
currentVTState.m_UTexWrap = nNewUTexWrap;
SetSamplerState( pDevice, D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_ADDRESSU, currentVTState.m_UTexWrap );
}
D3DTEXTUREADDRESS nNewVTexWrap = pTexture->m_VTexWrap;
if ( bForce || ( currentVTState.m_VTexWrap != nNewVTexWrap ) )
{
currentVTState.m_VTexWrap = nNewVTexWrap;
SetSamplerState( pDevice, D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_ADDRESSV, currentVTState.m_VTexWrap );
}
/*
D3DTEXTUREADDRESS nNewWTexWrap = pTexture->GetWTexWrap();
if ( bForce || ( currentVTState.m_WTexWrap != nNewWTexWrap ) )
{
currentVTState.m_WTexWrap = nNewWTexWrap;
SetSamplerState( pDevice, D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_ADDRESSW, currentVTState.m_WTexWrap );
}
*/
D3DTEXTUREFILTERTYPE nNewMinFilter = pTexture->m_MinFilter;
if ( bForce || ( currentVTState.m_MinFilter != nNewMinFilter ) )
{
currentVTState.m_MinFilter = nNewMinFilter;
SetSamplerState( pDevice, D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_MINFILTER, currentVTState.m_MinFilter );
}
D3DTEXTUREFILTERTYPE nNewMagFilter = pTexture->m_MagFilter;
if ( bForce || ( currentVTState.m_MagFilter != nNewMagFilter ) )
{
currentVTState.m_MagFilter = nNewMagFilter;
SetSamplerState( pDevice, D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_MAGFILTER, currentVTState.m_MagFilter );
}
D3DTEXTUREFILTERTYPE nNewMipFilter = pTexture->m_MipFilter;
if ( bForce || ( currentVTState.m_MipFilter != nNewMipFilter ) )
{
currentVTState.m_MipFilter = nNewMipFilter;
SetSamplerState( pDevice, D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_MIPFILTER, currentVTState.m_MipFilter );
}
}
}
//-----------------------------------------------------------------------------
// Returns true if the state snapshot is translucent
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::IsTranslucent( StateSnapshot_t id ) const
{
LOCK_SHADERAPI();
return m_TransitionTable.GetSnapshot(id).m_AlphaBlendEnable;
}
//-----------------------------------------------------------------------------
// Returns true if the state snapshot is alpha tested
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::IsAlphaTested( StateSnapshot_t id ) const
{
LOCK_SHADERAPI();
return m_TransitionTable.GetSnapshot(id).m_AlphaTestEnable;
}
//-----------------------------------------------------------------------------
// Gets at the shadow state for a particular state snapshot
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::IsDepthWriteEnabled( StateSnapshot_t id ) const
{
LOCK_SHADERAPI();
return m_TransitionTable.GetSnapshot(id).m_ZWriteEnable;
}
//-----------------------------------------------------------------------------
// Returns true if the state snapshot uses shaders
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::UsesVertexAndPixelShaders( StateSnapshot_t id ) const
{
LOCK_SHADERAPI();
return m_TransitionTable.GetSnapshotShader(id).m_VertexShader != INVALID_SHADER;
}
//-----------------------------------------------------------------------------
// Takes a snapshot
//-----------------------------------------------------------------------------
StateSnapshot_t CShaderAPIDx8::TakeSnapshot( )
{
LOCK_SHADERAPI();
return m_TransitionTable.TakeSnapshot();
}
void CShaderAPIDx8::ResetDXRenderState( void )
{
float zero = 0.0f;
float one = 1.0f;
DWORD dZero = *((DWORD*)(&zero));
DWORD dOne = *((DWORD*)(&one));
// Set default values for all dx render states.
// NOTE: this does not include states encapsulated by the transition table,
// which are reset in CTransitionTable::UseDefaultState
SetSupportedRenderStateForce( D3DRS_FILLMODE, D3DFILL_SOLID );
SetSupportedRenderStateForce( D3DRS_SHADEMODE, D3DSHADE_GOURAUD );
SetSupportedRenderStateForce( D3DRS_LASTPIXEL, TRUE );
SetSupportedRenderStateForce( D3DRS_CULLMODE, D3DCULL_CCW );
SetSupportedRenderStateForce( D3DRS_DITHERENABLE, FALSE );
SetSupportedRenderStateForce( D3DRS_FOGENABLE, FALSE );
SetSupportedRenderStateForce( D3DRS_SPECULARENABLE, FALSE );
SetSupportedRenderStateForce( D3DRS_FOGCOLOR, 0 );
SetSupportedRenderStateForce( D3DRS_FOGTABLEMODE, D3DFOG_NONE );
SetSupportedRenderStateForce( D3DRS_FOGSTART, dZero );
SetSupportedRenderStateForce( D3DRS_FOGEND, dOne );
SetSupportedRenderStateForce( D3DRS_FOGDENSITY, dZero );
SetSupportedRenderStateForce( D3DRS_RANGEFOGENABLE, FALSE );
SetSupportedRenderStateForce( D3DRS_STENCILENABLE, FALSE);
SetSupportedRenderStateForce( D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP );
SetSupportedRenderStateForce( D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP );
SetSupportedRenderStateForce( D3DRS_STENCILPASS, D3DSTENCILOP_KEEP );
SetSupportedRenderStateForce( D3DRS_STENCILFUNC, D3DCMP_ALWAYS );
SetSupportedRenderStateForce( D3DRS_STENCILREF, 0 );
SetSupportedRenderStateForce( D3DRS_STENCILMASK, 0xFFFFFFFF );
SetSupportedRenderStateForce( D3DRS_STENCILWRITEMASK, 0xFFFFFFFF );
SetSupportedRenderStateForce( D3DRS_TEXTUREFACTOR, 0xFFFFFFFF );
SetSupportedRenderStateForce( D3DRS_WRAP0, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP1, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP2, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP3, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP4, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP5, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP6, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP7, 0 );
SetSupportedRenderStateForce( D3DRS_CLIPPING, TRUE );
SetSupportedRenderStateForce( D3DRS_LIGHTING, TRUE );
SetSupportedRenderStateForce( D3DRS_AMBIENT, 0 );
SetSupportedRenderStateForce( D3DRS_FOGVERTEXMODE, D3DFOG_NONE);
SetSupportedRenderStateForce( D3DRS_COLORVERTEX, TRUE );
SetSupportedRenderStateForce( D3DRS_LOCALVIEWER, TRUE );
SetSupportedRenderStateForce( D3DRS_NORMALIZENORMALS, FALSE );
SetSupportedRenderStateForce( D3DRS_SPECULARMATERIALSOURCE, D3DMCS_COLOR2 );
SetSupportedRenderStateForce( D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_MATERIAL );
SetSupportedRenderStateForce( D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL );
SetSupportedRenderStateForce( D3DRS_VERTEXBLEND, D3DVBF_DISABLE );
SetSupportedRenderStateForce( D3DRS_CLIPPLANEENABLE, 0 );
// -disable_d3d9_hacks is for debugging. For example, the "CENT" driver hack thing causes the flashlight pass to appear much brighter on NVidia drivers.
if ( IsPC() && !IsOpenGL() && !CommandLine()->CheckParm( "-disable_d3d9_hacks" ) )
{
if ( g_pHardwareConfig->Caps().m_bNeedsATICentroidHack && ( g_pHardwareConfig->Caps().m_VendorID == VENDORID_ATI ) )
{
SetSupportedRenderStateForce( D3DRS_POINTSIZE, MAKEFOURCC( 'C', 'E', 'N', 'T' ) );
}
if( g_pHardwareConfig->Caps().m_bDisableShaderOptimizations )
{
SetSupportedRenderStateForce( D3DRS_ADAPTIVETESS_Y, MAKEFOURCC( 'C', 'O', 'P', 'M' ) );
}
}
SetSupportedRenderStateForce( D3DRS_POINTSIZE, dOne );
SetSupportedRenderStateForce( D3DRS_POINTSIZE_MIN, dOne );
SetSupportedRenderStateForce( D3DRS_POINTSPRITEENABLE, FALSE );
SetSupportedRenderStateForce( D3DRS_POINTSCALEENABLE, FALSE );
SetSupportedRenderStateForce( D3DRS_POINTSCALE_A, dOne );
SetSupportedRenderStateForce( D3DRS_POINTSCALE_B, dZero );
SetSupportedRenderStateForce( D3DRS_POINTSCALE_C, dZero );
SetSupportedRenderStateForce( D3DRS_MULTISAMPLEANTIALIAS, TRUE );
SetSupportedRenderStateForce( D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF );
SetSupportedRenderStateForce( D3DRS_PATCHEDGESTYLE, D3DPATCHEDGE_DISCRETE );
SetSupportedRenderStateForce( D3DRS_DEBUGMONITORTOKEN, D3DDMT_ENABLE );
float sixtyFour = 64.0f;
SetSupportedRenderStateForce( D3DRS_POINTSIZE_MAX, *((DWORD*)(&sixtyFour)));
SetSupportedRenderStateForce( D3DRS_INDEXEDVERTEXBLENDENABLE, FALSE );
SetSupportedRenderStateForce( D3DRS_TWEENFACTOR, dZero );
SetSupportedRenderStateForce( D3DRS_POSITIONDEGREE, D3DDEGREE_CUBIC );
SetSupportedRenderStateForce( D3DRS_NORMALDEGREE, D3DDEGREE_LINEAR );
SetSupportedRenderStateForce( D3DRS_SCISSORTESTENABLE, FALSE);
SetSupportedRenderStateForce( D3DRS_SLOPESCALEDEPTHBIAS, dZero );
SetSupportedRenderStateForce( D3DRS_ANTIALIASEDLINEENABLE, FALSE );
SetSupportedRenderStateForce( D3DRS_MINTESSELLATIONLEVEL, dOne );
SetSupportedRenderStateForce( D3DRS_MAXTESSELLATIONLEVEL, dOne );
SetSupportedRenderStateForce( D3DRS_ADAPTIVETESS_X, dZero );
SetSupportedRenderStateForce( D3DRS_ADAPTIVETESS_Y, dZero );
SetSupportedRenderStateForce( D3DRS_ADAPTIVETESS_Z, dOne );
SetSupportedRenderStateForce( D3DRS_ADAPTIVETESS_W, dZero );
SetSupportedRenderStateForce( D3DRS_ENABLEADAPTIVETESSELLATION, FALSE );
SetSupportedRenderStateForce( D3DRS_TWOSIDEDSTENCILMODE, FALSE );
SetSupportedRenderStateForce( D3DRS_CCW_STENCILFAIL, D3DSTENCILOP_KEEP );
SetSupportedRenderStateForce( D3DRS_CCW_STENCILZFAIL, D3DSTENCILOP_KEEP );
SetSupportedRenderStateForce( D3DRS_CCW_STENCILPASS, D3DSTENCILOP_KEEP );
SetSupportedRenderStateForce( D3DRS_CCW_STENCILFUNC, D3DCMP_ALWAYS );
SetSupportedRenderStateForce( D3DRS_COLORWRITEENABLE1, 0x0000000f );
SetSupportedRenderStateForce( D3DRS_COLORWRITEENABLE2, 0x0000000f );
SetSupportedRenderStateForce( D3DRS_COLORWRITEENABLE3, 0x0000000f );
SetSupportedRenderStateForce( D3DRS_BLENDFACTOR, 0xffffffff );
SetSupportedRenderStateForce( D3DRS_SRGBWRITEENABLE, 0);
SetSupportedRenderStateForce( D3DRS_DEPTHBIAS, dZero );
SetSupportedRenderStateForce( D3DRS_WRAP8, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP9, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP10, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP11, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP12, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP13, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP14, 0 );
SetSupportedRenderStateForce( D3DRS_WRAP15, 0 );
SetSupportedRenderStateForce( D3DRS_BLENDOP, D3DBLENDOP_ADD );
SetSupportedRenderStateForce( D3DRS_BLENDOPALPHA, D3DBLENDOP_ADD );
#if defined( _X360 )
SetSupportedRenderStateForce( D3DRS_HIZENABLE, D3DHIZ_AUTOMATIC );
SetSupportedRenderStateForce( D3DRS_HIZWRITEENABLE, D3DHIZ_AUTOMATIC );
SetSupportedRenderStateForce( D3DRS_HISTENCILENABLE, FALSE );
SetSupportedRenderStateForce( D3DRS_HISTENCILWRITEENABLE, FALSE );
SetSupportedRenderStateForce( D3DRS_HISTENCILFUNC, D3DHSCMP_EQUAL );
SetSupportedRenderStateForce( D3DRS_HISTENCILREF, 0 );
#endif
}
//-----------------------------------------------------------------------------
// Own GPU Resources. Return previous state.
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::OwnGPUResources( bool bEnable )
{
#if defined( _X360 )
if ( m_bGPUOwned == bEnable )
{
return m_bGPUOwned;
}
if ( !bEnable )
{
Dx9Device()->GpuDisownAll();
}
else
{
// owned GPU constants can be set very fast, and must be in blocks of 4
// there are 256, but the game only uses 217 (snapped to 220), leaving just enough room for shader literals
COMPILE_TIME_ASSERT( VERTEX_SHADER_MODEL + 3*NUM_MODEL_TRANSFORMS == 217 );
Dx9Device()->GpuOwnVertexShaderConstantF( 0, AlignValue( VERTEX_SHADER_MODEL + 3*NUM_MODEL_TRANSFORMS, 4 ) );
// there are 256, but the game only utilizes 32, leaving lots of room for shader literals
Dx9Device()->GpuOwnPixelShaderConstantF( 0, 32 );
}
bool bPrevious = m_bGPUOwned;
m_bGPUOwned = bEnable;
return bPrevious;
#else
return false;
#endif
}
//-----------------------------------------------------------------------------
// Reset render state (to its initial value)
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ResetRenderState( bool bFullReset )
{
LOCK_SHADERAPI();
RECORD_DEBUG_STRING( "BEGIN ResetRenderState" );
if ( !CanDownloadTextures() )
{
QueueResetRenderState();
return;
}
m_bResettingRenderState = true;
OwnGPUResources( true );
ResetDXRenderState();
// We're not currently rendering anything
m_nCurrentSnapshot = -1;
D3DXMatrixIdentity( &m_CachedPolyOffsetProjectionMatrix );
D3DXMatrixIdentity( &m_CachedFastClipProjectionMatrix );
D3DXMatrixIdentity( &m_CachedFastClipPolyOffsetProjectionMatrix );
m_UsingTextureRenderTarget = false;
m_SceneFogColor[0] = 0;
m_SceneFogColor[1] = 0;
m_SceneFogColor[2] = 0;
m_SceneFogMode = MATERIAL_FOG_NONE;
// This is state that isn't part of the snapshot per-se, because we
// don't need it when it's actually time to render. This just helps us
// to construct the shadow state.
m_DynamicState.m_ClearColor = D3DCOLOR_XRGB(0,0,0);
if ( bFullReset )
{
InitVertexAndPixelShaders();
}
else
{
// just need to dirty the dynamic state, desired state gets copied into below
Q_memset( m_DynamicState.m_pVectorPixelShaderConstant, 0, g_pHardwareConfig->Caps().m_NumPixelShaderConstants * sizeof( Vector4D ) );
Q_memset( m_DynamicState.m_pBooleanPixelShaderConstant, 0, g_pHardwareConfig->Caps().m_NumBooleanPixelShaderConstants * sizeof( BOOL ) );
Q_memset( m_DynamicState.m_pIntegerPixelShaderConstant, 0, g_pHardwareConfig->Caps().m_NumIntegerPixelShaderConstants * sizeof( IntVector4D ) );
Q_memset( m_DynamicState.m_pVectorVertexShaderConstant, 0, g_pHardwareConfig->Caps().m_NumVertexShaderConstants * sizeof( Vector4D ) );
Q_memset( m_DynamicState.m_pBooleanVertexShaderConstant, 0, g_pHardwareConfig->Caps().m_NumBooleanVertexShaderConstants * sizeof( BOOL ) );
Q_memset( m_DynamicState.m_pIntegerVertexShaderConstant, 0, g_pHardwareConfig->Caps().m_NumIntegerVertexShaderConstants * sizeof( IntVector4D ) );
SetStandardVertexShaderConstants( OVERBRIGHT );
}
//Set the default compressed depth range written to dest alpha. Only need to compress it for 8bit alpha to get a useful gradient.
m_DynamicState.m_DestAlphaDepthRange = (g_pHardwareConfig->GetHDRType() == HDR_TYPE_FLOAT) ? 8192.0f : 192.0f;
m_CachedAmbientLightCube = STATE_CHANGED;
// Set the constant color
m_DynamicState.m_ConstantColor = 0xFFFFFFFF;
Color4ub( 255, 255, 255, 255 );
// Ambient light color
m_DynamicState.m_Ambient = 0;
SetSupportedRenderState( D3DRS_AMBIENT, m_DynamicState.m_Ambient );
// Fog
m_VertexShaderFogParams[0] = m_VertexShaderFogParams[1] = 0.0f;
m_WorldSpaceCameraPositon.Init( 0, 0, 0.01f, 0 ); // Don't let z be zero, as some pixel shaders will divide by this
m_DynamicState.m_FogColor = 0xFFFFFFFF;
m_DynamicState.m_PixelFogColor[0] = m_DynamicState.m_PixelFogColor[1] =
m_DynamicState.m_PixelFogColor[2] = m_DynamicState.m_PixelFogColor[3] = 0.0f;
m_DynamicState.m_bFogGammaCorrectionDisabled = false;
m_DynamicState.m_FogEnable = false;
m_DynamicState.m_SceneFog = MATERIAL_FOG_NONE;
m_DynamicState.m_FogMode = D3DFOG_NONE;
m_DynamicState.m_FogStart = -1;
m_DynamicState.m_FogEnd = -1;
m_DynamicState.m_FogMaxDensity = -1.0f;
m_DynamicState.m_FogZ = 0.0f;
SetSupportedRenderState( D3DRS_FOGCOLOR, m_DynamicState.m_FogColor );
SetSupportedRenderState( D3DRS_FOGENABLE, m_DynamicState.m_FogEnable );
SetSupportedRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE );
SetSupportedRenderState( D3DRS_FOGVERTEXMODE, D3DFOG_NONE );
SetSupportedRenderState( D3DRS_RANGEFOGENABLE, false );
FogStart( 0 );
FogEnd( 0 );
FogMaxDensity( 1.0f );
m_DynamicState.m_bSRGBWritesEnabled = false;
// Set the cull mode
m_DynamicState.m_bCullEnabled = true;
m_DynamicState.m_CullMode = D3DCULL_CCW;
m_DynamicState.m_DesiredCullMode = D3DCULL_CCW;
SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW );
// No shade mode yet
m_DynamicState.m_ShadeMode = (D3DSHADEMODE)-1;
ShadeMode( SHADER_SMOOTH );
m_DynamicState.m_bHWMorphingEnabled = false;
// Skinning...
m_DynamicState.m_NumBones = 0;
m_DynamicState.m_VertexBlend = (D3DVERTEXBLENDFLAGS)-1;
SetSupportedRenderState( D3DRS_VERTEXBLEND, D3DVBF_DISABLE );
SetSupportedRenderState( D3DRS_INDEXEDVERTEXBLENDENABLE, FALSE );
// No normal normalization
m_DynamicState.m_NormalizeNormals = false;
SetSupportedRenderState( D3DRS_NORMALIZENORMALS, m_DynamicState.m_NormalizeNormals );
bool bAntialiasing = ( m_PresentParameters.MultiSampleType != D3DMULTISAMPLE_NONE );
if ( g_pHardwareConfig->GetHDRType() == HDR_TYPE_FLOAT )
{
bAntialiasing = false;
}
SetRenderState( D3DRS_MULTISAMPLEANTIALIAS, bAntialiasing );
// Anisotropic filtering is disabled by default
if ( bFullReset )
{
SetAnisotropicLevel( 1 );
}
int i;
for ( i = 0; i < g_pHardwareConfig->ActualCaps().m_NumTextureStages; ++i )
{
TextureStage(i).m_TextureTransformFlags = D3DTTFF_DISABLE;
TextureStage(i).m_BumpEnvMat00 = 1.0f;
TextureStage(i).m_BumpEnvMat01 = 0.0f;
TextureStage(i).m_BumpEnvMat10 = 0.0f;
TextureStage(i).m_BumpEnvMat11 = 1.0f;
SetTextureStageState( i, D3DTSS_TEXTURETRANSFORMFLAGS, TextureStage(i).m_TextureTransformFlags );
SetTextureStageState( i, D3DTSS_BUMPENVMAT00, *( ( LPDWORD ) (&TextureStage(i).m_BumpEnvMat00) ) );
SetTextureStageState( i, D3DTSS_BUMPENVMAT01, *( ( LPDWORD ) (&TextureStage(i).m_BumpEnvMat01) ) );
SetTextureStageState( i, D3DTSS_BUMPENVMAT10, *( ( LPDWORD ) (&TextureStage(i).m_BumpEnvMat10) ) );
SetTextureStageState( i, D3DTSS_BUMPENVMAT11, *( ( LPDWORD ) (&TextureStage(i).m_BumpEnvMat11) ) );
}
for ( i = 0; i < g_pHardwareConfig->ActualCaps().m_NumSamplers; ++i )
{
SamplerState(i).m_BoundTexture = INVALID_SHADERAPI_TEXTURE_HANDLE;
SamplerState(i).m_UTexWrap = D3DTADDRESS_WRAP;
SamplerState(i).m_VTexWrap = D3DTADDRESS_WRAP;
SamplerState(i).m_WTexWrap = D3DTADDRESS_WRAP;
SamplerState(i).m_MagFilter = D3DTEXF_POINT;
SamplerState(i).m_MinFilter = D3DTEXF_POINT;
SamplerState(i).m_MipFilter = D3DTEXF_NONE;
SamplerState(i).m_FinestMipmapLevel = 0;
SamplerState(i).m_LodBias = 0.0f;
SamplerState(i).m_TextureEnable = false;
SamplerState(i).m_SRGBReadEnable = false;
// Just some initial state...
Dx9Device()->SetTexture( i, 0 );
SetSamplerState( i, D3DSAMP_ADDRESSU, SamplerState(i).m_UTexWrap );
SetSamplerState( i, D3DSAMP_ADDRESSV, SamplerState(i).m_VTexWrap );
SetSamplerState( i, D3DSAMP_ADDRESSW, SamplerState(i).m_WTexWrap );
SetSamplerState( i, D3DSAMP_MINFILTER, SamplerState(i).m_MinFilter );
SetSamplerState( i, D3DSAMP_MAGFILTER, SamplerState(i).m_MagFilter );
SetSamplerState( i, D3DSAMP_MIPFILTER, SamplerState(i).m_MipFilter );
SetSamplerState( i, D3DSAMP_MAXMIPLEVEL, SamplerState(i).m_FinestMipmapLevel );
SetSamplerState( i, D3DSAMP_MIPMAPLODBIAS, SamplerState(i).m_LodBias );
SetSamplerState( i, D3DSAMP_BORDERCOLOR, RGB( 0,0,0 ) );
}
// FIXME!!!!! : This barfs with the debug runtime on 6800.
for( i = 0; i < g_pHardwareConfig->ActualCaps().m_nVertexTextureCount; i++ )
{
m_DynamicState.m_VertexTextureState[i].m_BoundTexture = INVALID_SHADERAPI_TEXTURE_HANDLE;
Dx9Device()->SetTexture( D3DVERTEXTEXTURESAMPLER0 + i, NULL );
m_DynamicState.m_VertexTextureState[i].m_UTexWrap = D3DTADDRESS_CLAMP;
m_DynamicState.m_VertexTextureState[i].m_VTexWrap = D3DTADDRESS_CLAMP;
// m_DynamicState.m_VertexTextureState[i].m_WTexWrap = D3DTADDRESS_CLAMP;
m_DynamicState.m_VertexTextureState[i].m_MinFilter = D3DTEXF_POINT;
m_DynamicState.m_VertexTextureState[i].m_MagFilter = D3DTEXF_POINT;
m_DynamicState.m_VertexTextureState[i].m_MipFilter = D3DTEXF_POINT;
SetSamplerState( D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_ADDRESSU, m_DynamicState.m_VertexTextureState[i].m_UTexWrap );
SetSamplerState( D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_ADDRESSV, m_DynamicState.m_VertexTextureState[i].m_VTexWrap );
// SetSamplerState( D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_ADDRESSW, m_DynamicState.m_VertexTextureState[i].m_WTexWrap );
SetSamplerState( D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_MINFILTER, m_DynamicState.m_VertexTextureState[i].m_MinFilter );
SetSamplerState( D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_MAGFILTER, m_DynamicState.m_VertexTextureState[i].m_MagFilter );
SetSamplerState( D3DVERTEXTEXTURESAMPLER0 + i, D3DSAMP_MIPFILTER, m_DynamicState.m_VertexTextureState[i].m_MipFilter );
}
m_DynamicState.m_NumLights = 0;
for ( i = 0; i < MAX_NUM_LIGHTS; ++i)
{
m_DynamicState.m_LightEnable[i] = false;
m_DynamicState.m_LightChanged[i] = STATE_CHANGED;
m_DynamicState.m_LightEnableChanged[i] = STATE_CHANGED;
}
for ( i = 0; i < NUM_MATRIX_MODES; ++i)
{
// By setting this to *not* be identity, we force an update...
m_DynamicState.m_TransformType[i] = TRANSFORM_IS_GENERAL;
m_DynamicState.m_TransformChanged[i] = STATE_CHANGED;
}
// set the board state to match the default state
m_TransitionTable.UseDefaultState();
// Set the default render state
SetDefaultState();
// Constant for all time
SetSupportedRenderState( D3DRS_CLIPPING, TRUE );
SetSupportedRenderState( D3DRS_LOCALVIEWER, TRUE );
SetSupportedRenderState( D3DRS_POINTSCALEENABLE, FALSE );
SetSupportedRenderState( D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL );
SetSupportedRenderState( D3DRS_SPECULARMATERIALSOURCE, D3DMCS_COLOR2 );
SetSupportedRenderState( D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_MATERIAL );
SetSupportedRenderState( D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL );
SetSupportedRenderState( D3DRS_COLORVERTEX, TRUE ); // This defaults to true anyways. . .
// Set a default identity material.
SetDefaultMaterial();
#if 0
float fBias = -1.0f;
SetTextureStageState( 0, D3DTSS_MIPMAPLODBIAS, *( ( LPDWORD ) (&fBias) ) );
SetTextureStageState( 1, D3DTSS_MIPMAPLODBIAS, *( ( LPDWORD ) (&fBias) ) );
SetTextureStageState( 2, D3DTSS_MIPMAPLODBIAS, *( ( LPDWORD ) (&fBias) ) );
SetTextureStageState( 3, D3DTSS_MIPMAPLODBIAS, *( ( LPDWORD ) (&fBias) ) );
#endif
if ( bFullReset )
{
// Set the modelview matrix to identity too
for ( i = 0; i < NUM_MODEL_TRANSFORMS; ++i )
{
SetIdentityMatrix( m_boneMatrix[i] );
}
MatrixMode( MATERIAL_VIEW );
LoadIdentity();
MatrixMode( MATERIAL_PROJECTION );
LoadIdentity();
}
#ifdef _X360
m_DynamicState.m_bBuffer2Frames = m_bBuffer2FramesAhead;
SetRenderState( D3DRS_BUFFER2FRAMES, m_DynamicState.m_bBuffer2Frames );
#endif
m_DynamicState.m_Viewport.X = m_DynamicState.m_Viewport.Y =
m_DynamicState.m_Viewport.Width = m_DynamicState.m_Viewport.Height = 0xFFFFFFFF;
m_DynamicState.m_Viewport.MinZ = m_DynamicState.m_Viewport.MaxZ = 0.0;
// Be sure scissoring is off
m_DynamicState.m_RenderState[D3DRS_SCISSORTESTENABLE] = FALSE;
SetRenderState( D3DRS_SCISSORTESTENABLE, FALSE );
m_DynamicState.m_ScissorRect.left = -1;
m_DynamicState.m_ScissorRect.top = -1;
m_DynamicState.m_ScissorRect.right = -1;
m_DynamicState.m_ScissorRect.bottom = -1;
//SetHeightClipMode( MATERIAL_HEIGHTCLIPMODE_DISABLE );
EnableFastClip( false );
float fFakePlane[4];
unsigned int iFakePlaneVal = 0xFFFFFFFF;
fFakePlane[0] = fFakePlane[1] = fFakePlane[2] = fFakePlane[3] = *((float *)&iFakePlaneVal);
SetFastClipPlane( fFakePlane ); //doing this to better wire up plane change detection
float zero[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
// Make sure that our state is dirty.
m_DynamicState.m_UserClipPlaneEnabled = 0;
m_DynamicState.m_UserClipPlaneChanged = 0;
m_DynamicState.m_UserClipLastUpdatedUsingFixedFunction = false;
for( i = 0; i < g_pHardwareConfig->MaxUserClipPlanes(); i++ )
{
// Make sure that our state is dirty.
m_DynamicState.m_UserClipPlaneWorld[i][0] = -1.0f;
m_DynamicState.m_UserClipPlaneProj[i][0] = -9999.0f;
m_DynamicState.m_UserClipPlaneEnabled |= ( 1 << i );
SetClipPlane( i, zero );
EnableClipPlane( i, false );
Assert( m_DynamicState.m_UserClipPlaneEnabled == 0 );
}
Assert( m_DynamicState.m_UserClipPlaneChanged == ((1 << g_pHardwareConfig->MaxUserClipPlanes()) - 1) );
m_DynamicState.m_FastClipEnabled = false;
m_DynamicState.m_bFastClipPlaneChanged = true;
// User clip override
m_DynamicState.m_bUserClipTransformOverride = false;
D3DXMatrixIdentity( &m_DynamicState.m_UserClipTransform );
// Viewport defaults to the window size
RECT windowRect;
#if !defined( DX_TO_GL_ABSTRACTION )
GetClientRect( (HWND)m_hWnd, &windowRect );
#else
toglGetClientRect( (VD3DHWND)m_hWnd, &windowRect );
#endif
ShaderViewport_t viewport;
viewport.Init( windowRect.left, windowRect.top,
windowRect.right - windowRect.left, windowRect.bottom - windowRect.top );
SetViewports( 1, &viewport );
// No render mesh
m_pRenderMesh = 0;
// Reset cached vertex decl
m_DynamicState.m_pVertexDecl = NULL;
// Reset the render target to be the normal backbuffer
if ( IsX360() )
{
m_hCachedRenderTarget = INVALID_SHADERAPI_TEXTURE_HANDLE;
m_bUsingSRGBRenderTarget = false;
}
AcquireInternalRenderTargets();
SetRenderTarget();
// Maintain vertex + pixel shader constant buffers
Vector4D *pVectorPixelShaderConstants = m_DesiredState.m_pVectorPixelShaderConstant;
int *pBooleanPixelShaderConstants = m_DesiredState.m_pBooleanPixelShaderConstant;
IntVector4D *pIntegerPixelShaderConstants = m_DesiredState.m_pIntegerPixelShaderConstant;
Vector4D *pVectorVertexShaderConstants = m_DesiredState.m_pVectorVertexShaderConstant;
int *pBooleanVertexShaderConstants = m_DesiredState.m_pBooleanVertexShaderConstant;
IntVector4D *pIntegerVertexShaderConstants = m_DesiredState.m_pIntegerVertexShaderConstant;
m_DesiredState = m_DynamicState;
m_DesiredState.m_pVectorPixelShaderConstant = pVectorPixelShaderConstants;
m_DesiredState.m_pBooleanPixelShaderConstant = pBooleanPixelShaderConstants;
m_DesiredState.m_pIntegerPixelShaderConstant = pIntegerPixelShaderConstants;
m_DesiredState.m_pVectorVertexShaderConstant = pVectorVertexShaderConstants;
m_DesiredState.m_pBooleanVertexShaderConstant = pBooleanVertexShaderConstants;
m_DesiredState.m_pIntegerVertexShaderConstant = pIntegerVertexShaderConstants;
if ( g_pHardwareConfig->Caps().m_SupportsPixelShaders )
{
if ( !bFullReset )
{
//Full resets init the values to defaults. Normal resets just leave them dirty.
if( g_pHardwareConfig->Caps().m_NumVertexShaderConstants != 0 )
SetVertexShaderConstant( 0, m_DesiredState.m_pVectorVertexShaderConstant[0].Base(), IsX360() ? 217 : g_pHardwareConfig->Caps().m_NumVertexShaderConstants, true ); //217 on X360 to play nice with fast blatting code
if( g_pHardwareConfig->Caps().m_NumIntegerVertexShaderConstants != 0 )
SetIntegerVertexShaderConstant( 0, (int *)m_DesiredState.m_pIntegerVertexShaderConstant, g_pHardwareConfig->Caps().m_NumIntegerVertexShaderConstants, true );
if( g_pHardwareConfig->Caps().m_NumBooleanVertexShaderConstants != 0 )
SetBooleanVertexShaderConstant( 0, m_DesiredState.m_pBooleanVertexShaderConstant, g_pHardwareConfig->Caps().m_NumBooleanVertexShaderConstants, true );
if( g_pHardwareConfig->Caps().m_NumPixelShaderConstants != 0 )
SetPixelShaderConstant( 0, m_DesiredState.m_pVectorPixelShaderConstant[0].Base(), g_pHardwareConfig->Caps().m_NumPixelShaderConstants, true );
if( g_pHardwareConfig->Caps().m_NumIntegerPixelShaderConstants != 0 )
SetIntegerPixelShaderConstant( 0, (int *)m_DesiredState.m_pIntegerPixelShaderConstant, g_pHardwareConfig->Caps().m_NumIntegerPixelShaderConstants, true );
if( g_pHardwareConfig->Caps().m_NumBooleanPixelShaderConstants != 0 )
SetBooleanPixelShaderConstant( 0, m_DesiredState.m_pBooleanPixelShaderConstant, g_pHardwareConfig->Caps().m_NumBooleanPixelShaderConstants, true );
}
}
RECORD_DEBUG_STRING( "END ResetRenderState" );
m_bResettingRenderState = false;
}
//-----------------------------------------------------------------------------
// Sets the default render state
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetDefaultState()
{
LOCK_SHADERAPI();
// NOTE: This used to be in the material system, but I want to avoid all the per pass/batch
// virtual function calls.
int numTextureStages = g_pHardwareConfig->GetTextureStageCount();
// FIXME: This is a brutal hack. We only need to load these transforms for fixed-function
// hardware. Cap the max here to 4.
if ( IsPC() )
{
numTextureStages = min( numTextureStages, 4 );
int i;
for( i = 0; i < numTextureStages; i++ )
{
CShaderAPIDx8::DisableTextureTransform( (TextureStage_t)i );
CShaderAPIDx8::MatrixMode( (MaterialMatrixMode_t)(MATERIAL_TEXTURE0 + i) );
CShaderAPIDx8::LoadIdentity( );
}
}
CShaderAPIDx8::MatrixMode( MATERIAL_MODEL );
CShaderAPIDx8::Color4ub( 255, 255, 255, 255 );
CShaderAPIDx8::ShadeMode( SHADER_SMOOTH );
CShaderAPIDx8::SetVertexShaderIndex( );
CShaderAPIDx8::SetPixelShaderIndex( );
MeshMgr()->MarkUnusedVertexFields( 0, 0, NULL );
}
//-----------------------------------------------------------------------------
//
// Methods related to vertex format
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Sets the vertex
//-----------------------------------------------------------------------------
inline void CShaderAPIDx8::SetVertexDecl( VertexFormat_t vertexFormat, bool bHasColorMesh, bool bUsingFlex, bool bUsingMorph )
{
VPROF("CShaderAPIDx8::SetVertexDecl");
IDirect3DVertexDeclaration9 *pDecl = FindOrCreateVertexDecl( vertexFormat, bHasColorMesh, bUsingFlex, bUsingMorph );
Assert( pDecl );
if ( ( pDecl != m_DynamicState.m_pVertexDecl ) && pDecl )
{
Dx9Device()->SetVertexDeclaration( pDecl );
m_DynamicState.m_pVertexDecl = pDecl;
}
}
//-----------------------------------------------------------------------------
//
// Methods related to vertex buffers
//
//-----------------------------------------------------------------------------
IMesh *CShaderAPIDx8::GetFlexMesh()
{
LOCK_SHADERAPI();
return MeshMgr()->GetFlexMesh();
}
//-----------------------------------------------------------------------------
// Gets the dynamic mesh
//-----------------------------------------------------------------------------
IMesh* CShaderAPIDx8::GetDynamicMesh( IMaterial* pMaterial, int nHWSkinBoneCount, bool buffered,
IMesh* pVertexOverride, IMesh* pIndexOverride )
{
Assert( (pMaterial == NULL) || ((IMaterialInternal *)pMaterial)->IsRealTimeVersion() );
LOCK_SHADERAPI();
return MeshMgr()->GetDynamicMesh( pMaterial, 0, nHWSkinBoneCount, buffered, pVertexOverride, pIndexOverride );
}
IMesh* CShaderAPIDx8::GetDynamicMeshEx( IMaterial* pMaterial, VertexFormat_t vertexFormat, int nHWSkinBoneCount,
bool bBuffered, IMesh* pVertexOverride, IMesh* pIndexOverride )
{
Assert( (pMaterial == NULL) || ((IMaterialInternal *)pMaterial)->IsRealTimeVersion() );
LOCK_SHADERAPI();
return MeshMgr()->GetDynamicMesh( pMaterial, vertexFormat, nHWSkinBoneCount, bBuffered, pVertexOverride, pIndexOverride );
}
//-----------------------------------------------------------------------------
// Returns the number of vertices we can render using the dynamic mesh
//-----------------------------------------------------------------------------
void CShaderAPIDx8::GetMaxToRender( IMesh *pMesh, bool bMaxUntilFlush, int *pMaxVerts, int *pMaxIndices )
{
LOCK_SHADERAPI();
MeshMgr()->GetMaxToRender( pMesh, bMaxUntilFlush, pMaxVerts, pMaxIndices );
}
int CShaderAPIDx8::GetMaxVerticesToRender( IMaterial *pMaterial )
{
pMaterial = ((IMaterialInternal *)pMaterial)->GetRealTimeVersion(); //always work with the realtime version internally
LOCK_SHADERAPI();
return MeshMgr()->GetMaxVerticesToRender( pMaterial );
}
int CShaderAPIDx8::GetMaxIndicesToRender( )
{
LOCK_SHADERAPI();
return MeshMgr()->GetMaxIndicesToRender( );
}
void CShaderAPIDx8::MarkUnusedVertexFields( unsigned int nFlags, int nTexCoordCount, bool *pUnusedTexCoords )
{
LOCK_SHADERAPI();
MeshMgr()->MarkUnusedVertexFields( nFlags, nTexCoordCount, pUnusedTexCoords );
}
//-----------------------------------------------------------------------------
// Draws the mesh
//-----------------------------------------------------------------------------
void CShaderAPIDx8::DrawMesh( CMeshBase *pMesh )
{
VPROF("CShaderAPIDx8::DrawMesh");
if ( ShaderUtil()->GetConfig().m_bSuppressRendering )
return;
#if defined( PIX_INSTRUMENTATION ) || defined( NVPERFHUD )
PIXifyName( s_pPIXMaterialName, sizeof( s_pPIXMaterialName ), m_pMaterial->GetName() );
BeginPIXEvent( PIX_VALVE_ORANGE, s_pPIXMaterialName );
#endif
m_pRenderMesh = pMesh;
VertexFormat_t vertexFormat = m_pRenderMesh->GetVertexFormat();
SetVertexDecl( vertexFormat, m_pRenderMesh->HasColorMesh(), m_pRenderMesh->HasFlexMesh(), m_pMaterial->IsUsingVertexID() );
CommitStateChanges();
Assert( m_pRenderMesh && m_pMaterial );
m_pMaterial->DrawMesh( CompressionType( vertexFormat ) );
m_pRenderMesh = NULL;
#if defined( PIX_INSTRUMENTATION ) || defined( NVPERFHUD )
EndPIXEvent();
#endif
}
void CShaderAPIDx8::DrawWithVertexAndIndexBuffers( void )
{
VPROF("CShaderAPIDx8::DrawWithVertexAndIndexBuffers");
if ( ShaderUtil()->GetConfig().m_bSuppressRendering )
return;
#if defined( PIX_INSTRUMENTATION ) || defined( NVPERFHUD )
PIXifyName( s_pPIXMaterialName, sizeof( s_pPIXMaterialName ), m_pMaterial->GetName());
BeginPIXEvent( PIX_VALVE_ORANGE, s_pPIXMaterialName );
#endif
// m_pRenderMesh = pMesh;
// FIXME: need to make this deal with multiple streams, etc.
VertexFormat_t vertexFormat = MeshMgr()->GetCurrentVertexFormat();
SetVertexDecl( vertexFormat, false /*m_pRenderMesh->HasColorMesh()*/,
false /*m_pRenderMesh->HasFlexMesh()*/, false /*m_pRenderMesh->IsUsingMorphData()*/ );
CommitStateChanges();
if ( m_pMaterial )
{
m_pMaterial->DrawMesh( CompressionType( vertexFormat ) );
}
else
{
MeshMgr()->RenderPassWithVertexAndIndexBuffers();
}
// m_pRenderMesh = NULL;
#if defined( PIX_INSTRUMENTATION ) || defined( NVPERFHUD )
EndPIXEvent();
#endif
}
//-----------------------------------------------------------------------------
// Discards the vertex buffers
//-----------------------------------------------------------------------------
void CShaderAPIDx8::DiscardVertexBuffers()
{
MeshMgr()->DiscardVertexBuffers();
}
void CShaderAPIDx8::ForceHardwareSync_WithManagedTexture()
{
if ( IsX360() || !m_pFrameSyncTexture )
return;
// Set the default state for everything so we don't get more than we ask for here!
SetDefaultState();
D3DLOCKED_RECT rect;
tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s", __FUNCTION__ );
HRESULT hr = m_pFrameSyncTexture->LockRect( 0, &rect, NULL, 0 );
if ( SUCCEEDED( hr ) )
{
// modify..
unsigned long *pData = (unsigned long*)rect.pBits;
(*pData)++;
m_pFrameSyncTexture->UnlockRect( 0 );
// Now draw something with this texture.
DWORD iStage = 0;
IDirect3DBaseTexture9 *pOldTexture;
hr = Dx9Device()->GetTexture( iStage, &pOldTexture );
if ( SUCCEEDED( hr ) )
{
Dx9Device()->SetTexture( iStage, m_pFrameSyncTexture );
// Remember the old FVF.
DWORD oldFVF;
hr = Dx9Device()->GetFVF( &oldFVF );
if ( SUCCEEDED( hr ) )
{
// Set the new FVF.
Dx9Device()->SetFVF( D3DFVF_XYZ );
// Now, draw the simplest primitive D3D has ever seen.
unsigned short indices[3] = { 0, 1, 2 };
Vector verts[3] = {vec3_origin, vec3_origin, vec3_origin};
tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "DrawIndexedPrimitiveUP" );
Dx9Device()->DrawIndexedPrimitiveUP(
D3DPT_TRIANGLELIST,
0, // Min vertex index
3, // Num vertices used
1, // # primitives
indices, // indices
D3DFMT_INDEX16, // index format
verts, // Vertices
sizeof( Vector )// Vertex stride
);
Dx9Device()->SetFVF( oldFVF );
}
Dx9Device()->SetTexture( iStage, pOldTexture );
}
}
// If this assert fails, then we failed somewhere above.
AssertOnce( SUCCEEDED( hr ) );
}
void CShaderAPIDx8::UpdateFrameSyncQuery( int queryIndex, bool bIssue )
{
Assert(queryIndex < NUM_FRAME_SYNC_QUERIES);
// wait if already issued
if ( m_bQueryIssued[queryIndex] )
{
tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s", __FUNCTION__ );
double flStartTime = Plat_FloatTime();
BOOL dummyData = 0;
HRESULT hr = S_OK;
// NOTE: This fix helps out motherboards that are a little freaky.
// On such boards, sometimes the driver has to reset itself (an event which takes several seconds)
// and when that happens, the frame sync query object gets lost
for (;;)
{
hr = m_pFrameSyncQueryObject[queryIndex]->GetData( &dummyData, sizeof( dummyData ), D3DGETDATA_FLUSH );
if ( hr != S_FALSE )
break;
double flCurrTime = Plat_FloatTime();
// don't wait more than 200ms (5fps) for these
if ( flCurrTime - flStartTime > 0.200f )
break;
// Avoid burning a full core while waiting for the query. Spinning can actually harm performance
// because there might be driver threads that are trying to do work that end up starved, and the
// power drawn by the CPU may take away from the power available to the integrated graphics chip.
// A sleep of one millisecond should never be long enough to affect performance, especially since
// this should only trigger when the CPU is already ahead of the GPU.
// On L4D2/TF2 in GL mode this spinning was causing slowdowns.
ThreadSleep( 1 );
}
m_bQueryIssued[queryIndex] = false;
Assert(hr == S_OK || hr == D3DERR_DEVICELOST);
if ( hr == D3DERR_DEVICELOST )
{
MarkDeviceLost( );
return;
}
}
if ( bIssue )
{
m_pFrameSyncQueryObject[queryIndex]->Issue( D3DISSUE_END );
m_bQueryIssued[queryIndex] = true;
}
}
void CShaderAPIDx8::ForceHardwareSync( void )
{
LOCK_SHADERAPI();
VPROF( "CShaderAPIDx8::ForceHardwareSync" );
#ifdef DX_TO_GL_ABSTRACTION
if ( true )
#else
if ( !mat_frame_sync_enable.GetInt() )
#endif
return;
// need to flush the dynamic buffer and make sure the entire image is there
FlushBufferedPrimitives();
RECORD_COMMAND( DX8_HARDWARE_SYNC, 0 );
#if !defined( _X360 )
// How do you query dx9 for how many frames behind the hardware is or, alternatively, how do you tell the hardware to never be more than N frames behind?
// 1) The old QueryPendingFrameCount design was removed. It was
// a simple transaction with the driver through the
// GetDriverState, trivial for the drivers to lie. We came up
// with a much better scheme for tracking pending frames where
// the driver can not lie without a possible performance loss:
// use the asynchronous query system with D3DQUERYTYPE_EVENT and
// data size 0. When GetData returns S_OK for the query, you
// know that frame has finished.
if ( mat_frame_sync_force_texture.GetBool() )
{
ForceHardwareSync_WithManagedTexture();
}
else if ( m_pFrameSyncQueryObject[0] )
{
// FIXME: Could install a callback into the materialsystem to do something while waiting for
// the frame to finish (update sound, etc.)
// Disable VCR mode here or else it'll screw up (and we don't really care if this part plays back in exactly the same amount of time).
VCRSetEnabled( false );
m_currentSyncQuery ++;
if ( m_currentSyncQuery >= ARRAYSIZE(m_pFrameSyncQueryObject) )
{
m_currentSyncQuery = 0;
}
double fStart = Plat_FloatTime();
int waitIndex = ((m_currentSyncQuery + NUM_FRAME_SYNC_QUERIES) - (NUM_FRAME_SYNC_FRAMES_LATENCY+1)) % NUM_FRAME_SYNC_QUERIES;
UpdateFrameSyncQuery( waitIndex, false );
UpdateFrameSyncQuery( m_currentSyncQuery, true );
VCRSetEnabled( true );
}
#else
DWORD hFence = Dx9Device()->InsertFence();
Dx9Device()->BlockOnFence( hFence );
#endif
}
//-----------------------------------------------------------------------------
// Needs render state
//-----------------------------------------------------------------------------
void CShaderAPIDx8::QueueResetRenderState()
{
m_bResetRenderStateNeeded = true;
}
//-----------------------------------------------------------------------------
// Use this to begin and end the frame
//-----------------------------------------------------------------------------
void CShaderAPIDx8::BeginFrame()
{
LOCK_SHADERAPI();
if ( m_bResetRenderStateNeeded )
{
ResetRenderState( false );
m_bResetRenderStateNeeded = false;
}
#if ALLOW_SMP_ACCESS
Dx9Device()->SetASyncMode( mat_use_smp.GetInt() != 0 );
#endif
++m_CurrentFrame;
m_nTextureMemoryUsedLastFrame = 0;
}
void CShaderAPIDx8::EndFrame()
{
LOCK_SHADERAPI();
#if !defined( _X360 )
MEMCHECK;
#endif
ExportTextureList();
}
void CShaderAPIDx8::AddBufferToTextureList( const char *pName, D3DSURFACE_DESC &desc )
{
// ImageFormat imageFormat;
// imageFormat = ImageLoader::D3DFormatToImageFormat( desc.Format );
// if( imageFormat < 0 )
// {
// Assert( 0 );
// return;
// }
KeyValues *pSubKey = m_pDebugTextureList->CreateNewKey();
pSubKey->SetString( "Name", pName );
pSubKey->SetString( "TexGroup", TEXTURE_GROUP_RENDER_TARGET );
pSubKey->SetInt( "Size",
// ImageLoader::SizeInBytes( imageFormat ) * desc.Width * desc.Height );
4 * desc.Width * desc.Height );
pSubKey->SetString( "Format", "32 bit buffer (hack)" );//ImageLoader::GetName( imageFormat ) );
pSubKey->SetInt( "Width", desc.Width );
pSubKey->SetInt( "Height", desc.Height );
pSubKey->SetInt( "BindsMax", 1 );
pSubKey->SetInt( "BindsFrame", 1 );
}
void CShaderAPIDx8::ExportTextureList()
{
if ( !m_bEnableDebugTextureList )
return;
if ( !m_pBackBufferSurface || !m_pZBufferSurface )
// Device vanished...
return;
m_nDebugDataExportFrame = m_CurrentFrame;
if ( IsPC() || !IsX360() )
{
if ( m_pDebugTextureList )
m_pDebugTextureList->deleteThis();
m_pDebugTextureList = new KeyValues( "TextureList" );
m_nTextureMemoryUsedTotal = 0;
m_nTextureMemoryUsedPicMip1 = 0;
m_nTextureMemoryUsedPicMip2 = 0;
for ( ShaderAPITextureHandle_t hTexture = m_Textures.Head() ; hTexture != m_Textures.InvalidIndex(); hTexture = m_Textures.Next( hTexture ) )
{
Texture_t &tex = m_Textures[hTexture];
if ( !( tex.m_Flags & Texture_t::IS_ALLOCATED ) )
continue;
// Compute total texture memory usage
m_nTextureMemoryUsedTotal += tex.GetMemUsage();
// Compute picmip memory usage
{
int numBytes = tex.GetMemUsage();
if ( tex.m_NumLevels > 1 )
{
if ( tex.GetWidth() > 4 || tex.GetHeight() > 4 || tex.GetDepth() > 4 )
{
int topmipsize = ImageLoader::GetMemRequired( tex.GetWidth(), tex.GetHeight(), tex.GetDepth(), tex.GetImageFormat(), false );
numBytes -= topmipsize;
m_nTextureMemoryUsedPicMip1 += numBytes;
if ( tex.GetWidth() > 8 || tex.GetHeight() > 8 || tex.GetDepth() > 8 )
{
int othermipsizeRatio = ( ( tex.GetWidth() > 8 ) ? 2 : 1 ) * ( ( tex.GetHeight() > 8 ) ? 2 : 1 ) * ( ( tex.GetDepth() > 8 ) ? 2 : 1 );
int othermipsize = topmipsize / othermipsizeRatio;
numBytes -= othermipsize;
}
m_nTextureMemoryUsedPicMip1 += numBytes;
}
else
{
m_nTextureMemoryUsedPicMip1 += numBytes;
m_nTextureMemoryUsedPicMip2 += numBytes;
}
}
else
{
m_nTextureMemoryUsedPicMip1 += numBytes;
m_nTextureMemoryUsedPicMip2 += numBytes;
}
}
if ( !m_bDebugGetAllTextures &&
tex.m_LastBoundFrame != m_CurrentFrame )
continue;
if ( tex.m_LastBoundFrame != m_CurrentFrame )
tex.m_nTimesBoundThisFrame = 0;
KeyValues *pSubKey = m_pDebugTextureList->CreateNewKey();
pSubKey->SetString( "Name", tex.m_DebugName.String() );
pSubKey->SetString( "TexGroup", tex.m_TextureGroupName.String() );
pSubKey->SetInt( "Size", tex.GetMemUsage() );
if ( tex.GetCount() > 1 )
pSubKey->SetInt( "Count", tex.GetCount() );
pSubKey->SetString( "Format", ImageLoader::GetName( tex.GetImageFormat() ) );
pSubKey->SetInt( "Width", tex.GetWidth() );
pSubKey->SetInt( "Height", tex.GetHeight() );
pSubKey->SetInt( "BindsMax", tex.m_nTimesBoundMax );
pSubKey->SetInt( "BindsFrame", tex.m_nTimesBoundThisFrame );
}
D3DSURFACE_DESC desc;
m_pBackBufferSurface->GetDesc( &desc );
AddBufferToTextureList( "BACKBUFFER", desc );
AddBufferToTextureList( "FRONTBUFFER", desc );
// ImageFormat imageFormat = ImageLoader::D3DFormatToImageFormat( desc.Format );
// if( imageFormat >= 0 )
{
VPROF_INCREMENT_GROUP_COUNTER( "TexGroup_frame_" TEXTURE_GROUP_RENDER_TARGET,
COUNTER_GROUP_TEXTURE_PER_FRAME,
// ImageLoader::SizeInBytes( imageFormat ) * desc.Width * desc.Height );
2 * 4 * desc.Width * desc.Height ); // hack (times 2 for front and back buffer)
}
m_pZBufferSurface->GetDesc( &desc );
AddBufferToTextureList( "DEPTHBUFFER", desc );
// imageFormat = ImageLoader::D3DFormatToImageFormat( desc.Format );
// if( imageFormat >= 0 )
{
VPROF_INCREMENT_GROUP_COUNTER( "TexGroup_frame_" TEXTURE_GROUP_RENDER_TARGET,
COUNTER_GROUP_TEXTURE_PER_FRAME,
// ImageLoader::SizeInBytes( imageFormat ) * desc.Width * desc.Height );
4 * desc.Width * desc.Height ); // hack
}
}
#if defined( _X360 )
// toggle to do one shot transmission
m_bEnableDebugTextureList = false;
int numTextures = m_Textures.Count() + 3;
xTextureList_t* pXTextureList = (xTextureList_t *)_alloca( numTextures * sizeof( xTextureList_t ) );
memset( pXTextureList, 0, numTextures * sizeof( xTextureList_t ) );
numTextures = 0;
for ( ShaderAPITextureHandle_t hTexture = m_Textures.Head() ; hTexture != m_Textures.InvalidIndex(); hTexture = m_Textures.Next( hTexture ) )
{
Texture_t &tex = m_Textures[hTexture];
if ( !m_bDebugGetAllTextures && tex.m_LastBoundFrame != m_CurrentFrame )
{
continue;
}
if ( !( tex.m_Flags & Texture_t::IS_ALLOCATED ) )
{
continue;
}
int refCount;
if ( tex.m_Flags & Texture_t::IS_DEPTH_STENCIL )
{
// interface forces us to ignore these
refCount = -1;
}
else
{
refCount = GetD3DTextureRefCount( CShaderAPIDx8::GetD3DTexture( hTexture ) );
}
pXTextureList[numTextures].pName = tex.m_DebugName.String();
pXTextureList[numTextures].size = tex.m_SizeBytes * tex.m_NumCopies;
pXTextureList[numTextures].pGroupName = tex.m_TextureGroupName.String();
pXTextureList[numTextures].pFormatName = D3DFormatName( ImageLoader::ImageFormatToD3DFormat( tex.GetImageFormat() ) );
pXTextureList[numTextures].width = tex.GetWidth();
pXTextureList[numTextures].height = tex.GetHeight();
pXTextureList[numTextures].depth = tex.GetDepth();
pXTextureList[numTextures].numLevels = tex.m_NumLevels;
pXTextureList[numTextures].binds = tex.m_nTimesBoundThisFrame;
pXTextureList[numTextures].refCount = refCount;
pXTextureList[numTextures].edram = ( tex.m_Flags & Texture_t::IS_RENDER_TARGET_SURFACE ) != 0;
pXTextureList[numTextures].procedural = tex.m_NumCopies > 1;
pXTextureList[numTextures].final = ( tex.m_Flags & Texture_t::IS_FINALIZED ) != 0;
pXTextureList[numTextures].failed = ( tex.m_Flags & Texture_t::IS_FAILED ) != 0;
numTextures++;
}
// build special entries for implicit surfaces/textures
D3DSURFACE_DESC desc;
m_pBackBufferSurface->GetDesc( &desc );
int size = ImageLoader::GetMemRequired(
desc.Width,
desc.Height,
0,
ImageLoader::D3DFormatToImageFormat( desc.Format ),
false );
pXTextureList[numTextures].pName = "_rt_BackBuffer";
pXTextureList[numTextures].size = size;
pXTextureList[numTextures].pGroupName = TEXTURE_GROUP_RENDER_TARGET_SURFACE;
pXTextureList[numTextures].pFormatName = D3DFormatName( desc.Format );
pXTextureList[numTextures].width = desc.Width;
pXTextureList[numTextures].height = desc.Height;
pXTextureList[numTextures].depth = 1;
pXTextureList[numTextures].binds = 1;
pXTextureList[numTextures].refCount = 1;
pXTextureList[numTextures].sRGB = IS_D3DFORMAT_SRGB( desc.Format );
pXTextureList[numTextures].edram = true;
numTextures++;
m_pZBufferSurface->GetDesc( &desc );
pXTextureList[numTextures].pName = "_rt_DepthBuffer";
pXTextureList[numTextures].size = size;
pXTextureList[numTextures].pGroupName = TEXTURE_GROUP_RENDER_TARGET_SURFACE;
pXTextureList[numTextures].pFormatName = D3DFormatName( desc.Format );
pXTextureList[numTextures].width = desc.Width;
pXTextureList[numTextures].height = desc.Height;
pXTextureList[numTextures].depth = 1;
pXTextureList[numTextures].binds = 1;
pXTextureList[numTextures].refCount = 1;
pXTextureList[numTextures].sRGB = IS_D3DFORMAT_SRGB( desc.Format );
pXTextureList[numTextures].edram = true;
numTextures++;
// front buffer resides in DDR
pXTextureList[numTextures].pName = "_rt_FrontBuffer";
pXTextureList[numTextures].size = size;
pXTextureList[numTextures].pGroupName = TEXTURE_GROUP_RENDER_TARGET;
pXTextureList[numTextures].pFormatName = D3DFormatName( desc.Format );
pXTextureList[numTextures].width = desc.Width;
pXTextureList[numTextures].height = desc.Height;
pXTextureList[numTextures].depth = 1;
pXTextureList[numTextures].binds = 1;
pXTextureList[numTextures].refCount = 1;
pXTextureList[numTextures].sRGB = IS_D3DFORMAT_SRGB( desc.Format );
numTextures++;
int totalMemory = 0;
for ( int i = 0; i < numTextures; i++ )
{
if ( pXTextureList[i].edram )
{
// skip edram based items
continue;
}
totalMemory += pXTextureList[i].size;
}
Msg( "Total D3D Texture Memory: %.2f MB\n", (float)totalMemory/( 1024.0f * 1024.0f ) );
// transmit to console
XBX_rTextureList( numTextures, pXTextureList );
#endif
}
//-----------------------------------------------------------------------------
// Releases/reloads resources when other apps want some memory
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ReleaseShaderObjects()
{
ReleaseInternalRenderTargets();
EvictManagedResourcesInternal();
// FIXME: Move into shaderdevice when textures move over.
#ifdef _DEBUG
// Helps to find the unreleased textures.
if ( TextureCount() > 0 )
{
ShaderAPITextureHandle_t hTexture;
for ( hTexture = m_Textures.Head(); hTexture != m_Textures.InvalidIndex(); hTexture = m_Textures.Next( hTexture ) )
{
if ( GetTexture( hTexture ).m_NumCopies == 1 )
{
if ( GetTexture( hTexture ).GetTexture() )
{
Warning( "Didn't correctly clean up texture 0x%8.8x (%s)\n", hTexture, GetTexture( hTexture ).m_DebugName.String() );
}
}
else
{
for ( int k = GetTexture( hTexture ).m_NumCopies; --k >= 0; )
{
if ( GetTexture( hTexture ).GetTexture( k ) != 0 )
{
Warning( "Didn't correctly clean up texture 0x%8.8x (%s)\n", hTexture, GetTexture( hTexture ).m_DebugName.String() );
break;
}
}
}
}
}
#endif
Assert( TextureCount() == 0 );
}
void CShaderAPIDx8::RestoreShaderObjects()
{
AcquireInternalRenderTargets();
SetRenderTarget();
}
//--------------------------------------------------------------------
// PIX instrumentation routines
// Windows only for now. Turn these on with PIX_INSTRUMENTATION above
//--------------------------------------------------------------------
#if 0 // hack versions for OSX to be able to PIX log even when not built debug...
void CShaderAPIDx8::BeginPIXEvent( unsigned long color, const char* szName )
{
LOCK_SHADERAPI();
GLMBeginPIXEvent( szName ); // direct call no macro
return;
}
void CShaderAPIDx8::EndPIXEvent( void )
{
LOCK_SHADERAPI();
GLMEndPIXEvent(); // direct call no macro
return;
}
#else
#if defined( PIX_INSTRUMENTATION ) || defined( NVPERFHUD )
ConVar pix_break_on_event( "pix_break_on_event", "" );
#endif
void CShaderAPIDx8::BeginPIXEvent( unsigned long color, const char* szName )
{
#if ( defined( PIX_INSTRUMENTATION ) || defined( NVPERFHUD ) )
//LOCK_SHADERAPI();
const char *p = pix_break_on_event.GetString();
if ( p && V_strlen( p ) )
{
if ( V_stristr( szName, p ) != NULL )
{
DebuggerBreak();
}
}
#if defined ( DX_TO_GL_ABSTRACTION )
GLMBeginPIXEvent( szName );
#if defined( _WIN32 )
// AMD PerfStudio integration: Call into D3D9.DLL's D3DPERF_BeginEvent() (this gets intercepted by PerfStudio even in GL mode).
if ( g_pShaderDeviceMgrDx8->m_pBeginEvent )
{
wchar_t wszName[128];
mbstowcs( wszName, szName, 128 );
g_pShaderDeviceMgrDx8->m_pBeginEvent( 0x2F2F2F2F, wszName );
}
#endif
#elif defined(_X360 )
#ifndef _DEBUG
char szPIXEventName[32];
PIXifyName( szPIXEventName, szName );
PIXBeginNamedEvent( color, szPIXEventName );
#endif
#else // PC
if ( PIXError() )
return;
wchar_t wszName[128];
mbstowcs( wszName, szName, 128 );
// Fire the PIX event, trapping for errors...
if ( D3DPERF_BeginEvent( color, wszName ) < 0 )
{
Warning( "PIX error Beginning %s event\n", szName );
IncrementPIXError();
}
#endif
#endif // #if defined( PIX_INSTRUMENTATION )
}
void CShaderAPIDx8::EndPIXEvent( void )
{
#if ( defined( PIX_INSTRUMENTATION ) || defined( NVPERFHUD ) )
//LOCK_SHADERAPI();
#if defined ( DX_TO_GL_ABSTRACTION )
GLMEndPIXEvent();
#if defined( _WIN32 )
// AMD PerfStudio integration: Call into D3D9.DLL's D3DPERF_EndEvent() (this gets intercepted by PerfStudio even in GL mode).
if ( g_pShaderDeviceMgrDx8->m_pEndEvent )
{
g_pShaderDeviceMgrDx8->m_pEndEvent();
}
#endif
#elif defined( _X360 )
#ifndef _DEBUG
PIXEndNamedEvent();
#endif
#else // PC
if ( PIXError() )
return;
#if !defined( NVPERFHUD )
// Fire the PIX event, trapping for errors...
if ( D3DPERF_EndEvent() < 0 )
{
Warning("PIX error ending event\n");
IncrementPIXError();
}
#endif
#endif
#endif // #if defined( PIX_INSTRUMENTATION )
}
#endif
void CShaderAPIDx8::AdvancePIXFrame()
{
#if defined( PIX_INSTRUMENTATION )
// Ping PIX when this bool goes from false to true
if ( r_pix_start.GetBool() && (!m_bPixCapturing) )
{
StartPIXInstrumentation();
m_bPixCapturing = true;
}
// If we want to record frames...
if ( r_pix_recordframes.GetInt() )
{
if ( m_nPixFrame == 0 ) // First frame to record
{
StartPIXInstrumentation();
m_nPixFrame++;
}
else if( m_nPixFrame == r_pix_recordframes.GetInt() ) // Last frame to record
{
EndPIXInstrumentation();
r_pix_recordframes.SetValue(0);
m_nPixFrame = 0;
}
else
{
m_nPixFrame++; // Recording frames...
}
}
#endif
}
// No begin-end for this...use this to put discrete markers in the PIX stream
void CShaderAPIDx8::SetPIXMarker( unsigned long color, const char* szName )
{
#if defined( PIX_INSTRUMENTATION )
LOCK_SHADERAPI();
#if defined( DX_TO_GL_ABSTRACTION )
if ( g_pShaderDeviceMgrDx8->m_pSetMarker )
{
wchar_t wszName[128];
mbstowcs(wszName, szName, 128 );
g_pShaderDeviceMgrDx8->m_pSetMarker( 0x2F2F2F2F, wszName );
}
#elif defined( _X360 )
#ifndef _DEBUG
char szPIXMarkerName[32];
PIXifyName( szPIXMarkerName, szName );
PIXSetMarker( color, szPIXMarkerName );
#endif
#else // PC
if ( PIXError() )
return;
wchar_t wszName[128];
mbstowcs(wszName, szName, 128 );
D3DPERF_SetMarker( color, wszName );
#endif
#endif // PIX_INSTRUMENTATION
}
void CShaderAPIDx8::StartPIXInstrumentation()
{
#if defined( PIX_INSTRUMENTATION )
SetPIXMarker( PIX_VALVE_ORANGE, "Valve_PIX_Capture_Start" );
#endif
}
void CShaderAPIDx8::EndPIXInstrumentation()
{
#if defined( PIX_INSTRUMENTATION )
SetPIXMarker( PIX_VALVE_ORANGE, "Valve_PIX_Capture_End" );
#endif
}
void CShaderAPIDx8::IncrementPIXError()
{
#if defined( PIX_INSTRUMENTATION ) && !defined( NVPERFHUD )
m_nPIXErrorCount++;
if ( m_nPIXErrorCount >= MAX_PIX_ERRORS )
{
Warning( "Source engine built with PIX instrumentation, but PIX doesn't seem to have been used to instantiate the game, which is necessary on PC.\n" );
}
#endif
}
// Have we already hit several PIX errors?
bool CShaderAPIDx8::PIXError()
{
#if defined( PIX_INSTRUMENTATION ) && !defined( NVPERFHUD )
return m_nPIXErrorCount >= MAX_PIX_ERRORS;
#else
return false;
#endif
}
//-----------------------------------------------------------------------------
// Check for device lost
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ChangeVideoMode( const ShaderDeviceInfo_t &info )
{
if ( IsX360() )
return;
LOCK_SHADERAPI();
m_PendingVideoModeChangeConfig = info;
m_bPendingVideoModeChange = true;
if ( info.m_DisplayMode.m_nWidth != 0 && info.m_DisplayMode.m_nHeight != 0 )
{
m_nWindowWidth = info.m_DisplayMode.m_nWidth;
m_nWindowHeight = info.m_DisplayMode.m_nHeight;
}
}
//-----------------------------------------------------------------------------
// Compute fill rate
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ComputeFillRate()
{
if ( IsX360() )
{
// not valid
return;
}
static unsigned char* pBuf = 0;
int width, height;
GetWindowSize( width, height );
// Snapshot; look at total # pixels drawn...
if ( !pBuf )
{
int memSize = ShaderUtil()->GetMemRequired(
width,
height,
1,
IMAGE_FORMAT_RGB888,
false ) + 4;
pBuf = (unsigned char*)malloc( memSize );
}
ReadPixels(
0,
0,
width,
height,
pBuf,
IMAGE_FORMAT_RGB888 );
int mask = 0xFF;
int count = 0;
unsigned char* pRead = pBuf;
for (int i = 0; i < height; ++i)
{
for (int j = 0; j < width; ++j)
{
int val = *(int*)pRead;
count += (val & mask);
pRead += 3;
}
}
}
//-----------------------------------------------------------------------------
// Use this to get the mesh builder that allows us to modify vertex data
//-----------------------------------------------------------------------------
CMeshBuilder* CShaderAPIDx8::GetVertexModifyBuilder()
{
return &m_ModifyBuilder;
}
bool CShaderAPIDx8::InFlashlightMode() const
{
return ShaderUtil()->InFlashlightMode();
}
bool CShaderAPIDx8::InEditorMode() const
{
return ShaderUtil()->InEditorMode();
}
//-----------------------------------------------------------------------------
// Gets the bound morph's vertex format; returns 0 if no morph is bound
//-----------------------------------------------------------------------------
MorphFormat_t CShaderAPIDx8::GetBoundMorphFormat()
{
return ShaderUtil()->GetBoundMorphFormat();
}
//-----------------------------------------------------------------------------
// returns the current time in seconds...
//-----------------------------------------------------------------------------
double CShaderAPIDx8::CurrentTime() const
{
// FIXME: Return game time instead of real time!
// Or eliminate this altogether and put it into a material var
// (this is used by vertex modifiers in shader code at the moment)
return Plat_FloatTime();
}
//-----------------------------------------------------------------------------
// Methods called by the transition table that use dynamic state...
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ApplyZBias( const ShadowState_t& shaderState )
{
MaterialSystem_Config_t &config = ShaderUtil()->GetConfig();
float a = (config.m_SlopeScaleDepthBias_Decal != 0.0f) ? 1.0f / config.m_SlopeScaleDepthBias_Decal : 0.0f;
float b = (config.m_SlopeScaleDepthBias_Normal != 0.0f) ? 1.0f / config.m_SlopeScaleDepthBias_Normal : 0.0f;
float c = (config.m_DepthBias_Decal != 0.0f) ? 1.0f / config.m_DepthBias_Decal : 0.0f;
float d = (config.m_DepthBias_Normal != 0.0f) ? 1.0f / config.m_DepthBias_Normal : 0.0f;
// FIXME: No longer necessary; may be necessary if you want to use cat 4.3 drivers?
// GR - hack for R200
bool bPS14Only = g_pHardwareConfig->Caps().m_SupportsPixelShaders_1_4 && !g_pHardwareConfig->Caps().m_SupportsPixelShaders_2_0;
if( ( g_pHardwareConfig->Caps().m_VendorID == 0x1002 ) && bPS14Only )
{
// Slam to m_SlopeScaleDepthBias_Decal = 0, m_DepthBias_Decal = -4096
// which empirically is what appears to look good on r200
// NOTE: Slamming to 0 instead of -1.0 / 4096 because on Cat 4.9, WinXP, 8500,
// this causes the z values to be more than 50 units away from the original z values
a = 0.0f;
c = -1.0/4096.0;
}
// bias = (s * D3DRS_SLOPESCALEDEPTHBIAS) + D3DRS_DEPTHBIAS, where s is the maximum depth slope of the triangle being rendered
if ( g_pHardwareConfig->Caps().m_ZBiasAndSlopeScaledDepthBiasSupported )
{
float fSlopeScaleDepthBias, fDepthBias;
if ( shaderState.m_ZBias == SHADER_POLYOFFSET_DECAL )
{
fSlopeScaleDepthBias = a;
fDepthBias = c;
}
else if ( shaderState.m_ZBias == SHADER_POLYOFFSET_SHADOW_BIAS )
{
fSlopeScaleDepthBias = m_fShadowSlopeScaleDepthBias;
fDepthBias = m_fShadowDepthBias;
}
else // assume SHADER_POLYOFFSET_DISABLE
{
fSlopeScaleDepthBias = b;
fDepthBias = d;
}
if( ReverseDepthOnX360() )
{
fSlopeScaleDepthBias = -fSlopeScaleDepthBias;
fDepthBias = -fDepthBias;
}
SetRenderStateConstMacro( this, D3DRS_SLOPESCALEDEPTHBIAS, *((DWORD*) (&fSlopeScaleDepthBias)) );
SetRenderStateConstMacro( this, D3DRS_DEPTHBIAS, *((DWORD*) (&fDepthBias)) );
}
else
{
MarkAllUserClipPlanesDirty();
m_DynamicState.m_TransformChanged[MATERIAL_PROJECTION] |=
STATE_CHANGED_VERTEX_SHADER | STATE_CHANGED_FIXED_FUNCTION;
}
}
void CShaderAPIDx8::ApplyTextureEnable( const ShadowState_t& state, int nSampler )
{
if ( state.m_SamplerState[nSampler].m_TextureEnable == SamplerState(nSampler).m_TextureEnable )
return;
if ( state.m_SamplerState[nSampler].m_TextureEnable )
{
SamplerState( nSampler ).m_TextureEnable = true;
// Should not be necessary/possible (SetTextureState() calls D3D9/DXAbstract, so the calling thread must already own the device.
//LOCK_SHADERAPI();
// Don't do this here!! It ends up giving us extra texture sets.
// We'll Assert in debug mode if you enable a texture stage
// but don't bind a texture.
// see CShaderAPIDx8::RenderPass() for this check.
// NOTE: We aren't doing this optimization quite yet. There are situations
// where you want a texture stage enabled for its texture coordinates, but
// you don't actually bind a texture (texmvspec for example.)
SetTextureState( (Sampler_t)nSampler, SamplerState(nSampler).m_BoundTexture, true );
}
else
{
SamplerState( nSampler ).m_TextureEnable = false;
SetTextureState( (Sampler_t)nSampler, INVALID_SHADERAPI_TEXTURE_HANDLE );
}
}
//-----------------------------------------------------------------------------
// Used to clear the transition table when we know it's become invalid.
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ClearSnapshots()
{
LOCK_SHADERAPI();
FlushBufferedPrimitives();
m_TransitionTable.Reset();
InitRenderState();
}
static void KillTranslation( D3DXMATRIX& mat )
{
mat[3] = 0.0f;
mat[7] = 0.0f;
mat[11] = 0.0f;
mat[12] = 0.0f;
mat[13] = 0.0f;
mat[14] = 0.0f;
mat[15] = 1.0f;
}
static void PrintMatrix( const char *name, const D3DXMATRIX& mat )
{
int row, col;
char buf[128];
Plat_DebugString( name );
Plat_DebugString( "\n" );
for( row = 0; row < 4; row++ )
{
Plat_DebugString( " " );
for( col = 0; col < 4; col++ )
{
sprintf( buf, "%f ", ( float )mat( row, col ) );
Plat_DebugString( buf );
}
Plat_DebugString( "\n" );
}
Plat_DebugString( "\n" );
}
//-----------------------------------------------------------------------------
// Gets the vertex format for a particular snapshot id
//-----------------------------------------------------------------------------
VertexFormat_t CShaderAPIDx8::ComputeVertexUsage( int num, StateSnapshot_t* pIds ) const
{
LOCK_SHADERAPI();
if (num == 0)
return 0;
// We don't have to all sorts of crazy stuff if there's only one snapshot
if ( num == 1 )
{
const ShadowShaderState_t& state = m_TransitionTable.GetSnapshotShader( pIds[0] );
return state.m_VertexUsage;
}
Assert( pIds );
// Aggregating vertex formats is a little tricky;
// For example, what do we do when two passes want user data?
// Can we assume they are the same? For now, I'm going to
// just print a warning in debug.
VertexCompressionType_t compression = VERTEX_COMPRESSION_INVALID;
int userDataSize = 0;
int numBones = 0;
int texCoordSize[VERTEX_MAX_TEXTURE_COORDINATES] = { 0, 0, 0, 0, 0, 0, 0, 0 };
int flags = 0;
for (int i = num; --i >= 0; )
{
const ShadowShaderState_t& state = m_TransitionTable.GetSnapshotShader( pIds[i] );
VertexFormat_t fmt = state.m_VertexUsage;
flags |= VertexFlags(fmt);
VertexCompressionType_t newCompression = CompressionType( fmt );
if ( ( compression != newCompression ) && ( compression != VERTEX_COMPRESSION_INVALID ) )
{
Warning("Encountered a material with two passes that specify different vertex compression types!\n");
compression = VERTEX_COMPRESSION_NONE; // Be safe, disable compression
}
int newNumBones = NumBoneWeights(fmt);
if ((numBones != newNumBones) && (newNumBones != 0))
{
if (numBones != 0)
{
Warning("Encountered a material with two passes that use different numbers of bones!\n");
}
numBones = newNumBones;
}
int newUserSize = UserDataSize(fmt);
if ((userDataSize != newUserSize) && (newUserSize != 0))
{
if (userDataSize != 0)
{
Warning("Encountered a material with two passes that use different user data sizes!\n");
}
userDataSize = newUserSize;
}
for ( int j = 0; j < VERTEX_MAX_TEXTURE_COORDINATES; ++j )
{
int newSize = TexCoordSize( (TextureStage_t)j, fmt );
if ( ( texCoordSize[j] != newSize ) && ( newSize != 0 ) )
{
if ( texCoordSize[j] != 0 )
{
Warning("Encountered a material with two passes that use different texture coord sizes!\n");
}
if ( texCoordSize[j] < newSize )
{
texCoordSize[j] = newSize;
}
}
}
}
return MeshMgr()->ComputeVertexFormat( flags, VERTEX_MAX_TEXTURE_COORDINATES,
texCoordSize, numBones, userDataSize );
}
VertexFormat_t CShaderAPIDx8::ComputeVertexFormat( int num, StateSnapshot_t* pIds ) const
{
LOCK_SHADERAPI();
VertexFormat_t fmt = ComputeVertexUsage( num, pIds );
return fmt;
}
//-----------------------------------------------------------------------------
// What fields in the morph do we actually use?
//-----------------------------------------------------------------------------
MorphFormat_t CShaderAPIDx8::ComputeMorphFormat( int numSnapshots, StateSnapshot_t* pIds ) const
{
LOCK_SHADERAPI();
MorphFormat_t format = 0;
for ( int i = 0; i < numSnapshots; ++i )
{
MorphFormat_t fmt = m_TransitionTable.GetSnapshotShader( pIds[i] ).m_MorphUsage;
format |= VertexFlags(fmt);
}
return format;
}
//-----------------------------------------------------------------------------
// Commits a range of vertex shader constants
//-----------------------------------------------------------------------------
static void CommitVertexShaderConstantRange( IDirect3DDevice9 *pDevice, const DynamicState_t &desiredState,
DynamicState_t &currentState, bool bForce, int nFirstConstant, int nCount )
{
if ( IsX360() )
{
// invalid code path for 360, not coded for 360 GPU contant awareness
Assert( 0 );
return;
}
int nFirstCommit = nFirstConstant;
int nCommitCount = 0;
for ( int i = 0; i < nCount; ++i )
{
int nVar = nFirstConstant + i;
bool bDifferentValue = bForce || ( desiredState.m_pVectorVertexShaderConstant[nVar] != currentState.m_pVectorVertexShaderConstant[nVar] );
if ( !bDifferentValue )
{
if ( nCommitCount != 0 )
{
// flush the prior range
pDevice->SetVertexShaderConstantF( nFirstCommit, desiredState.m_pVectorVertexShaderConstant[nFirstCommit].Base(), nCommitCount );
memcpy( &currentState.m_pVectorVertexShaderConstant[nFirstCommit],
&desiredState.m_pVectorVertexShaderConstant[nFirstCommit], nCommitCount * 4 * sizeof(float) );
}
// start of new range
nFirstCommit = nVar + 1;
nCommitCount = 0;
}
else
{
++nCommitCount;
}
}
if ( nCommitCount != 0 )
{
// flush range
pDevice->SetVertexShaderConstantF( nFirstCommit, desiredState.m_pVectorVertexShaderConstant[nFirstCommit].Base(), nCommitCount );
memcpy( &currentState.m_pVectorVertexShaderConstant[nFirstCommit],
&desiredState.m_pVectorVertexShaderConstant[nFirstCommit], nCommitCount * 4 * sizeof(float) );
}
}
//-----------------------------------------------------------------------------
// Gets the current buffered state... (debug only)
//-----------------------------------------------------------------------------
void CShaderAPIDx8::GetBufferedState( BufferedState_t& state )
{
memcpy( &state.m_Transform[0], &GetTransform(MATERIAL_MODEL), sizeof(D3DXMATRIX) );
memcpy( &state.m_Transform[1], &GetTransform(MATERIAL_VIEW), sizeof(D3DXMATRIX) );
memcpy( &state.m_Transform[2], &GetTransform(MATERIAL_PROJECTION), sizeof(D3DXMATRIX) );
memcpy( &state.m_Viewport, &m_DynamicState.m_Viewport, sizeof(state.m_Viewport) );
state.m_PixelShader = ShaderManager()->GetCurrentPixelShader();
state.m_VertexShader = ShaderManager()->GetCurrentVertexShader();
for (int i = 0; i < g_pHardwareConfig->GetSamplerCount(); ++i)
{
state.m_BoundTexture[i] = m_DynamicState.m_SamplerState[i].m_BoundTexture;
}
}
//-----------------------------------------------------------------------------
// constant color methods
//-----------------------------------------------------------------------------
void CShaderAPIDx8::Color3f( float r, float g, float b )
{
unsigned int color = D3DCOLOR_ARGB( 255, (int)(r * 255),
(int)(g * 255), (int)(b * 255) );
if (color != m_DynamicState.m_ConstantColor)
{
m_DynamicState.m_ConstantColor = color;
SetSupportedRenderState( D3DRS_TEXTUREFACTOR, color );
}
}
void CShaderAPIDx8::Color4f( float r, float g, float b, float a )
{
unsigned int color = D3DCOLOR_ARGB( (int)(a * 255), (int)(r * 255),
(int)(g * 255), (int)(b * 255) );
if (color != m_DynamicState.m_ConstantColor)
{
m_DynamicState.m_ConstantColor = color;
SetSupportedRenderState( D3DRS_TEXTUREFACTOR, color );
}
}
void CShaderAPIDx8::Color3fv( float const *c )
{
Assert( c );
unsigned int color = D3DCOLOR_ARGB( 255, (int)(c[0] * 255),
(int)(c[1] * 255), (int)(c[2] * 255) );
if (color != m_DynamicState.m_ConstantColor)
{
m_DynamicState.m_ConstantColor = color;
SetSupportedRenderState( D3DRS_TEXTUREFACTOR, color );
}
}
void CShaderAPIDx8::Color4fv( float const *c )
{
Assert( c );
unsigned int color = D3DCOLOR_ARGB( (int)(c[3] * 255), (int)(c[0] * 255),
(int)(c[1] * 255), (int)(c[2] * 255) );
if (color != m_DynamicState.m_ConstantColor)
{
m_DynamicState.m_ConstantColor = color;
SetSupportedRenderState( D3DRS_TEXTUREFACTOR, color );
}
}
void CShaderAPIDx8::Color3ub( unsigned char r, unsigned char g, unsigned char b )
{
unsigned int color = D3DCOLOR_ARGB( 255, r, g, b );
if (color != m_DynamicState.m_ConstantColor)
{
m_DynamicState.m_ConstantColor = color;
SetSupportedRenderState( D3DRS_TEXTUREFACTOR, color );
}
}
void CShaderAPIDx8::Color3ubv( unsigned char const* pColor )
{
Assert( pColor );
unsigned int color = D3DCOLOR_ARGB( 255, pColor[0], pColor[1], pColor[2] );
if (color != m_DynamicState.m_ConstantColor)
{
m_DynamicState.m_ConstantColor = color;
SetSupportedRenderState( D3DRS_TEXTUREFACTOR, color );
}
}
void CShaderAPIDx8::Color4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a )
{
unsigned int color = D3DCOLOR_ARGB( a, r, g, b );
if (color != m_DynamicState.m_ConstantColor)
{
m_DynamicState.m_ConstantColor = color;
SetSupportedRenderState( D3DRS_TEXTUREFACTOR, color );
}
}
void CShaderAPIDx8::Color4ubv( unsigned char const* pColor )
{
Assert( pColor );
unsigned int color = D3DCOLOR_ARGB( pColor[3], pColor[0], pColor[1], pColor[2] );
if (color != m_DynamicState.m_ConstantColor)
{
m_DynamicState.m_ConstantColor = color;
SetSupportedRenderState( D3DRS_TEXTUREFACTOR, color );
}
}
//-----------------------------------------------------------------------------
// The shade mode
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ShadeMode( ShaderShadeMode_t mode )
{
LOCK_SHADERAPI();
D3DSHADEMODE shadeMode = (mode == SHADER_FLAT) ? D3DSHADE_FLAT : D3DSHADE_GOURAUD;
if (m_DynamicState.m_ShadeMode != shadeMode)
{
m_DynamicState.m_ShadeMode = shadeMode;
SetRenderStateConstMacro( this, D3DRS_SHADEMODE, shadeMode );
}
}
//-----------------------------------------------------------------------------
// Buffering 2 frames ahead
//-----------------------------------------------------------------------------
void CShaderAPIDx8::EnableBuffer2FramesAhead( bool bEnable )
{
#ifdef _X360
m_bBuffer2FramesAhead = bEnable;
if ( bEnable != m_DynamicState.m_bBuffer2Frames )
{
SetRenderState( D3DRS_BUFFER2FRAMES, bEnable );
m_DynamicState.m_bBuffer2Frames = bEnable;
}
#endif
}
void CShaderAPIDx8::SetDepthFeatheringPixelShaderConstant( int iConstant, float fDepthBlendScale )
{
float fConstantValues[4];
if( IsX360() )
{
const D3DMATRIX &projMatrix = GetProjectionMatrix();
fConstantValues[0] = 50.0f / fDepthBlendScale;
fConstantValues[1] = 1.0f / projMatrix.m[2][2];
fConstantValues[2] = 1.0f / projMatrix.m[3][2];
fConstantValues[3] = projMatrix.m[2][2];
/*
D3DXMATRIX invProjMatrix;
D3DXMatrixInverse( &invProjMatrix, NULL, (D3DXMATRIX *)&projMatrix );
fConstantValues[1] = invProjMatrix.m[3][2];
fConstantValues[2] = invProjMatrix.m[3][3];
fConstantValues[3] = invProjMatrix.m[2][2];
*/
}
else
{
fConstantValues[0] = m_DynamicState.m_DestAlphaDepthRange / fDepthBlendScale;
fConstantValues[1] = fConstantValues[2] = fConstantValues[3] = 0.0f; //empty
}
SetPixelShaderConstant( iConstant, fConstantValues );
}
//-----------------------------------------------------------------------------
// Cull mode..
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetCullModeState( bool bEnable, D3DCULL nDesiredCullMode )
{
D3DCULL nCullMode = bEnable ? nDesiredCullMode : D3DCULL_NONE;
if ( nCullMode != m_DynamicState.m_CullMode )
{
SetRenderStateConstMacro( this, D3DRS_CULLMODE, nCullMode );
m_DynamicState.m_CullMode = nCullMode;
}
}
void CShaderAPIDx8::ApplyCullEnable( bool bEnable )
{
m_DynamicState.m_bCullEnabled = bEnable;
SetCullModeState( m_DynamicState.m_bCullEnabled, m_DynamicState.m_DesiredCullMode );
}
void CShaderAPIDx8::CullMode( MaterialCullMode_t nCullMode )
{
LOCK_SHADERAPI();
D3DCULL nNewCullMode;
switch( nCullMode )
{
case MATERIAL_CULLMODE_CCW:
// Culls backfacing polys (normal)
nNewCullMode = D3DCULL_CCW;
break;
case MATERIAL_CULLMODE_CW:
// Culls frontfacing polys
nNewCullMode = D3DCULL_CW;
break;
default:
Warning( "CullMode: invalid cullMode\n" );
return;
}
if (m_DynamicState.m_DesiredCullMode != nNewCullMode)
{
FlushBufferedPrimitives();
m_DynamicState.m_DesiredCullMode = nNewCullMode;
SetCullModeState( m_DynamicState.m_bCullEnabled, m_DynamicState.m_DesiredCullMode );
}
}
static ConVar mat_alphacoverage( "mat_alphacoverage", "1" );
void CShaderAPIDx8::ApplyAlphaToCoverage( bool bEnable )
{
if ( mat_alphacoverage.GetBool() )
{
if ( bEnable )
EnableAlphaToCoverage();
else
DisableAlphaToCoverage();
}
else
{
DisableAlphaToCoverage();
}
}
//-----------------------------------------------------------------------------
// Returns the current cull mode of the current material (for selection mode only)
//-----------------------------------------------------------------------------
D3DCULL CShaderAPIDx8::GetCullMode() const
{
Assert( m_pMaterial );
if ( m_pMaterial->GetMaterialVarFlag( MATERIAL_VAR_NOCULL ) )
return D3DCULL_NONE;
return m_DynamicState.m_DesiredCullMode;
}
void CShaderAPIDx8::SetRasterState( const ShaderRasterState_t& state )
{
// FIXME: Implement!
}
void CShaderAPIDx8::ForceDepthFuncEquals( bool bEnable )
{
LOCK_SHADERAPI();
if ( !g_pShaderDeviceDx8->IsDeactivated() )
{
m_TransitionTable.ForceDepthFuncEquals( bEnable );
}
}
void CShaderAPIDx8::OverrideDepthEnable( bool bEnable, bool bDepthEnable )
{
LOCK_SHADERAPI();
if ( !g_pShaderDeviceDx8->IsDeactivated() )
{
m_TransitionTable.OverrideDepthEnable( bEnable, bDepthEnable );
}
}
void CShaderAPIDx8::OverrideAlphaWriteEnable( bool bOverrideEnable, bool bAlphaWriteEnable )
{
LOCK_SHADERAPI();
if ( !g_pShaderDeviceDx8->IsDeactivated() )
{
m_TransitionTable.OverrideAlphaWriteEnable( bOverrideEnable, bAlphaWriteEnable );
}
}
void CShaderAPIDx8::OverrideColorWriteEnable( bool bOverrideEnable, bool bColorWriteEnable )
{
LOCK_SHADERAPI();
if ( !g_pShaderDeviceDx8->IsDeactivated() )
{
m_TransitionTable.OverrideColorWriteEnable( bOverrideEnable, bColorWriteEnable );
}
}
void CShaderAPIDx8::UpdateFastClipUserClipPlane( void )
{
float plane[4];
switch( m_DynamicState.m_HeightClipMode )
{
case MATERIAL_HEIGHTCLIPMODE_DISABLE:
EnableFastClip( false );
break;
case MATERIAL_HEIGHTCLIPMODE_RENDER_ABOVE_HEIGHT:
plane[0] = 0.0f;
plane[1] = 0.0f;
plane[2] = 1.0f;
plane[3] = m_DynamicState.m_HeightClipZ;
EnableFastClip( true );
SetFastClipPlane(plane);
break;
case MATERIAL_HEIGHTCLIPMODE_RENDER_BELOW_HEIGHT:
plane[0] = 0.0f;
plane[1] = 0.0f;
plane[2] = -1.0f;
plane[3] = -m_DynamicState.m_HeightClipZ;
EnableFastClip( true );
SetFastClipPlane(plane);
break;
}
}
void CShaderAPIDx8::SetHeightClipZ( float z )
{
LOCK_SHADERAPI();
if( z != m_DynamicState.m_HeightClipZ )
{
FlushBufferedPrimitives();
m_DynamicState.m_HeightClipZ = z;
UpdateVertexShaderFogParams();
UpdateFastClipUserClipPlane();
m_DynamicState.m_TransformChanged[MATERIAL_PROJECTION] |=
STATE_CHANGED_VERTEX_SHADER | STATE_CHANGED_FIXED_FUNCTION;
}
}
void CShaderAPIDx8::SetHeightClipMode( MaterialHeightClipMode_t heightClipMode )
{
LOCK_SHADERAPI();
if( heightClipMode != m_DynamicState.m_HeightClipMode )
{
FlushBufferedPrimitives();
m_DynamicState.m_HeightClipMode = heightClipMode;
UpdateVertexShaderFogParams();
UpdateFastClipUserClipPlane();
m_DynamicState.m_TransformChanged[MATERIAL_PROJECTION] |=
STATE_CHANGED_VERTEX_SHADER | STATE_CHANGED_FIXED_FUNCTION;
}
}
void CShaderAPIDx8::SetClipPlane( int index, const float *pPlane )
{
LOCK_SHADERAPI();
Assert( index < g_pHardwareConfig->MaxUserClipPlanes() && index >= 0 );
// NOTE: The plane here is specified in *world space*
// NOTE: This is done because they assume Ax+By+Cz+Dw = 0 (where w = 1 in real space)
// while we use Ax+By+Cz=D
D3DXPLANE plane;
plane.a = pPlane[0];
plane.b = pPlane[1];
plane.c = pPlane[2];
plane.d = -pPlane[3];
if ( plane != m_DynamicState.m_UserClipPlaneWorld[index] )
{
FlushBufferedPrimitives();
m_DynamicState.m_UserClipPlaneChanged |= ( 1 << index );
m_DynamicState.m_UserClipPlaneWorld[index] = plane;
}
}
//-----------------------------------------------------------------------------
// Converts a D3DXMatrix to a VMatrix and back
//-----------------------------------------------------------------------------
void CShaderAPIDx8::D3DXMatrixToVMatrix( const D3DXMATRIX &in, VMatrix &out )
{
MatrixTranspose( *(const VMatrix*)&in, out );
}
void CShaderAPIDx8::VMatrixToD3DXMatrix( const VMatrix &in, D3DXMATRIX &out )
{
MatrixTranspose( in, *(VMatrix*)&out );
}
//-----------------------------------------------------------------------------
// Mark all user clip planes as being dirty
//-----------------------------------------------------------------------------
void CShaderAPIDx8::MarkAllUserClipPlanesDirty()
{
m_DynamicState.m_UserClipPlaneChanged |= ( 1 << g_pHardwareConfig->MaxUserClipPlanes() ) - 1;
m_DynamicState.m_bFastClipPlaneChanged = true;
}
//-----------------------------------------------------------------------------
// User clip plane override
//-----------------------------------------------------------------------------
void CShaderAPIDx8::EnableUserClipTransformOverride( bool bEnable )
{
LOCK_SHADERAPI();
if ( m_DynamicState.m_bUserClipTransformOverride != bEnable )
{
FlushBufferedPrimitives();
m_DynamicState.m_bUserClipTransformOverride = bEnable;
MarkAllUserClipPlanesDirty();
}
}
//-----------------------------------------------------------------------------
// Specify user clip transform
//-----------------------------------------------------------------------------
void CShaderAPIDx8::UserClipTransform( const VMatrix &worldToProjection )
{
LOCK_SHADERAPI();
D3DXMATRIX dxWorldToProjection;
VMatrixToD3DXMatrix( worldToProjection, dxWorldToProjection );
if ( m_DynamicState.m_UserClipTransform != dxWorldToProjection )
{
m_DynamicState.m_UserClipTransform = dxWorldToProjection;
if ( m_DynamicState.m_bUserClipTransformOverride )
{
FlushBufferedPrimitives();
MarkAllUserClipPlanesDirty();
}
}
}
//-----------------------------------------------------------------------------
// Enables a user clip plane
//-----------------------------------------------------------------------------
void CShaderAPIDx8::EnableClipPlane( int index, bool bEnable )
{
LOCK_SHADERAPI();
Assert( index < g_pHardwareConfig->MaxUserClipPlanes() && index >= 0 );
if( ( m_DynamicState.m_UserClipPlaneEnabled & ( 1 << index ) ? true : false ) != bEnable )
{
FlushBufferedPrimitives();
if( bEnable )
{
m_DynamicState.m_UserClipPlaneEnabled |= ( 1 << index );
}
else
{
m_DynamicState.m_UserClipPlaneEnabled &= ~( 1 << index );
}
SetRenderStateConstMacro( this, D3DRS_CLIPPLANEENABLE, m_DynamicState.m_UserClipPlaneEnabled );
}
}
//-----------------------------------------------------------------------------
// Recomputes the fast-clip plane matrices based on the current fast-clip plane
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitFastClipPlane( )
{
// Don't bother recomputing if unchanged or disabled
if ( !m_DynamicState.m_bFastClipPlaneChanged || !m_DynamicState.m_FastClipEnabled )
return;
m_DynamicState.m_bFastClipPlaneChanged = false;
D3DXMatrixIdentity( &m_CachedFastClipProjectionMatrix );
// Compute worldToProjection - need inv. transpose for transforming plane.
D3DXMATRIX viewToProjInvTrans, viewToProjInv, viewToProj = GetTransform(MATERIAL_PROJECTION);
viewToProj._43 *= 0.5f; // pull in zNear because the shear in effect
// moves it out: clipping artifacts when looking down at water
// could occur if this multiply is not done
D3DXMATRIX worldToViewInvTrans, worldToViewInv, worldToView = GetUserClipTransform();
D3DXMatrixInverse( &worldToViewInv, NULL, &worldToView );
D3DXMatrixTranspose( &worldToViewInvTrans, &worldToViewInv );
D3DXMatrixInverse( &viewToProjInv, NULL, &viewToProj );
D3DXMatrixTranspose( &viewToProjInvTrans, &viewToProjInv );
D3DXPLANE plane;
D3DXPlaneNormalize( &plane, &m_DynamicState.m_FastClipPlane );
D3DXVECTOR4 clipPlane( plane.a, plane.b, plane.c, plane.d );
// transform clip plane into view space
D3DXVec4Transform( &clipPlane, &clipPlane, &worldToViewInvTrans );
// transform clip plane into projection space
D3DXVec4Transform( &clipPlane, &clipPlane, &viewToProjInvTrans );
#define ALLOW_FOR_FASTCLIPDUMPS 0
#if (ALLOW_FOR_FASTCLIPDUMPS == 1)
static ConVar shader_dumpfastclipprojectioncoords( "shader_dumpfastclipprojectioncoords", "0", 0, "dump fast clip projected matrix" );
if( shader_dumpfastclipprojectioncoords.GetBool() )
DevMsg( "Fast clip plane projected coordinates: %f %f %f %f", clipPlane.x, clipPlane.y, clipPlane.z, clipPlane.w );
#endif
if( (clipPlane.z * clipPlane.w) <= -0.4f ) // a plane with (z*w) > -0.4 at this point is behind the camera and will cause graphical glitches. Toss it. (0.4 found through experimentation)
{
#if (ALLOW_FOR_FASTCLIPDUMPS == 1)
if( shader_dumpfastclipprojectioncoords.GetBool() )
DevMsg( " %f %f %f %f\n", clipPlane.x, clipPlane.y, clipPlane.z, clipPlane.w );
#endif
D3DXVec4Normalize( &clipPlane, &clipPlane );
//if ((fabs(clipPlane.z) > 0.01) && (fabs(clipPlane.w) > 0.01f))
{
// put projection space clip plane in Z column
m_CachedFastClipProjectionMatrix._13 = clipPlane.x;
m_CachedFastClipProjectionMatrix._23 = clipPlane.y;
m_CachedFastClipProjectionMatrix._33 = clipPlane.z;
m_CachedFastClipProjectionMatrix._43 = clipPlane.w;
}
}
#if (ALLOW_FOR_FASTCLIPDUMPS == 1)
else
{
if( shader_dumpfastclipprojectioncoords.GetBool() )
DevMsg( "\n" ); //finish off the line above
}
#endif
m_CachedFastClipProjectionMatrix = viewToProj * m_CachedFastClipProjectionMatrix;
// Update the cached polyoffset matrix (with clip) too:
ComputePolyOffsetMatrix( m_CachedFastClipProjectionMatrix, m_CachedFastClipPolyOffsetProjectionMatrix );
}
//-----------------------------------------------------------------------------
// Sets the fast-clip plane; but doesn't update the matrices
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetFastClipPlane( const float *pPlane )
{
LOCK_SHADERAPI();
D3DXPLANE plane;
plane.a = pPlane[0];
plane.b = pPlane[1];
plane.c = pPlane[2];
plane.d = -pPlane[3];
if ( plane != m_DynamicState.m_FastClipPlane )
{
FlushBufferedPrimitives();
UpdateVertexShaderFogParams();
m_DynamicState.m_FastClipPlane = plane;
// Mark a dirty bit so when it comes time to commit view + projection transforms,
// we also update the fast clip matrices
m_DynamicState.m_bFastClipPlaneChanged = true;
m_DynamicState.m_TransformChanged[MATERIAL_PROJECTION] |=
STATE_CHANGED_VERTEX_SHADER | STATE_CHANGED_FIXED_FUNCTION;
}
}
//-----------------------------------------------------------------------------
// Enables/disables fast-clip mode
//-----------------------------------------------------------------------------
void CShaderAPIDx8::EnableFastClip( bool bEnable )
{
LOCK_SHADERAPI();
if( m_DynamicState.m_FastClipEnabled != bEnable )
{
FlushBufferedPrimitives();
UpdateVertexShaderFogParams();
m_DynamicState.m_FastClipEnabled = bEnable;
m_DynamicState.m_TransformChanged[MATERIAL_PROJECTION] |=
STATE_CHANGED_VERTEX_SHADER | STATE_CHANGED_FIXED_FUNCTION;
}
}
/*
// -----------------------------------------------------------------------------
// SetInvariantClipVolume - This routine takes six planes as input and sets the
// appropriate Direct3D user clip plane state
// What we mean by "invariant clipping" here is that certain devices implement
// user clip planes at the raster level, which means that multi-pass rendering
// where one pass is unclipped (such as base geometry) and another pass *IS*
// clipped (such as flashlight geometry), there is no z-fighting since the
// clipping is implemented at the raster level in an "invariant" way
// -----------------------------------------------------------------------------
void CShaderAPIDx8::SetInvariantClipVolume( Frustum_t *pFrustumPlanes )
{
// Only do this on modern nVidia hardware, which does invariant clipping
if ( m_VendorID == VENDORID_NVIDIA )
{
if ( pFrustumPlanes )
{
// if ()
// {
//
// }
for (int i=0; i<6; i++)
{
const cplane_t *pPlane = pFrustumPlanes->GetPlane(i);
SetClipPlane( i, (float *) &pPlane->normal );
EnableClipPlane( i, true );
// FRUSTUM_RIGHT = 0,
// FRUSTUM_LEFT = 1,
// FRUSTUM_TOP = 2,
// FRUSTUM_BOTTOM = 3,
// FRUSTUM_NEARZ = 4,
// FRUSTUM_FARZ = 5,
}
}
else // NULL disables the invariant clip volume...
{
for (int i=0; i<6; i++)
{
EnableClipPlane( i, false );
}
}
}
}
*/
//-----------------------------------------------------------------------------
// Vertex blending
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetVertexBlendState( int numBones )
{
if (numBones < 0)
{
numBones = m_DynamicState.m_NumBones;
}
// For fixed-function, the number of weights is actually one less than
// the number of bones
if (numBones > 0)
--numBones;
bool normalizeNormals = true;
D3DVERTEXBLENDFLAGS vertexBlend;
switch(numBones)
{
case 0:
vertexBlend = D3DVBF_DISABLE;
normalizeNormals = false;
break;
case 1:
vertexBlend = D3DVBF_1WEIGHTS;
break;
case 2:
vertexBlend = D3DVBF_2WEIGHTS;
break;
case 3:
vertexBlend = D3DVBF_3WEIGHTS;
break;
default:
vertexBlend = D3DVBF_DISABLE;
Assert(0);
break;
}
if (m_DynamicState.m_VertexBlend != vertexBlend)
{
m_DynamicState.m_VertexBlend = vertexBlend;
SetSupportedRenderState( D3DRS_VERTEXBLEND, vertexBlend );
}
// Activate normalize normals when skinning is on
if (m_DynamicState.m_NormalizeNormals != normalizeNormals)
{
m_DynamicState.m_NormalizeNormals = normalizeNormals;
SetSupportedRenderState( D3DRS_NORMALIZENORMALS, normalizeNormals );
}
}
//-----------------------------------------------------------------------------
// Vertex blending
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetNumBoneWeights( int numBones )
{
LOCK_SHADERAPI();
if (m_DynamicState.m_NumBones != numBones)
{
FlushBufferedPrimitives();
m_DynamicState.m_NumBones = numBones;
if ( m_TransitionTable.CurrentShadowState() )
{
SetVertexBlendState( m_TransitionTable.CurrentShadowState()->m_VertexBlendEnable ? -1 : 0 );
}
}
}
void CShaderAPIDx8::EnableHWMorphing( bool bEnable )
{
LOCK_SHADERAPI();
if ( m_DynamicState.m_bHWMorphingEnabled != bEnable )
{
FlushBufferedPrimitives();
m_DynamicState.m_bHWMorphingEnabled = bEnable;
}
}
void CShaderAPIDx8::EnabledSRGBWrite( bool bEnabled )
{
m_DynamicState.m_bSRGBWritesEnabled = bEnabled;
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
UpdatePixelFogColorConstant();
if ( bEnabled && g_pHardwareConfig->NeedsShaderSRGBConversion() )
BindTexture( SHADER_SAMPLER15, m_hLinearToGammaTableTexture );
else
BindTexture( SHADER_SAMPLER15, m_hLinearToGammaTableIdentityTexture );
}
}
#if defined( _X360 )
void CShaderAPIDx8::ApplySRGBReadState( int iTextureStage, bool bSRGBReadEnabled )
{
Sampler_t sampler = (Sampler_t)iTextureStage;
SamplerState_t &samplerState = SamplerState( sampler );
samplerState.m_SRGBReadEnable = bSRGBReadEnabled;
if ( ( samplerState.m_BoundTexture == INVALID_SHADERAPI_TEXTURE_HANDLE ) || !samplerState.m_TextureEnable )
{
return;
}
IDirect3DBaseTexture *pBindTexture = CShaderAPIDx8::GetD3DTexture( samplerState.m_BoundTexture );
if ( !pBindTexture )
{
return;
}
DWORD linearFormatBackup = pBindTexture->Format.dword[0]; //if we convert to srgb format, we need the original format for reverting. We only need the first DWORD of GPUTEXTURE_FETCH_CONSTANT.
if ( bSRGBReadEnabled )
{
pBindTexture->Format.SignX = pBindTexture->Format.SignY = pBindTexture->Format.SignZ = 3; //convert to srgb format for the bind. This effectively emulates the old srgb read sampler state
}
Dx9Device()->SetTexture( sampler, pBindTexture );
// copy back the format in case we changed it
pBindTexture->Format.dword[0] = linearFormatBackup;
}
#endif
//-----------------------------------------------------------------------------
// Fog methods...
//-----------------------------------------------------------------------------
void CShaderAPIDx8::UpdatePixelFogColorConstant( void )
{
Assert( HardwareConfig()->SupportsPixelShaders_2_b() );
float fogColor[4];
switch( GetPixelFogMode() )
{
case MATERIAL_FOG_NONE:
{
for( int i = 0; i != 3; ++i )
fogColor[i] = 0.0f;
}
break;
case MATERIAL_FOG_LINEAR:
{
//setup the fog for mixing linear fog in the pixel shader so that it emulates ff range fog
for( int i = 0; i != 3; ++i )
fogColor[i] = m_DynamicState.m_PixelFogColor[i];
if( m_DynamicState.m_bSRGBWritesEnabled )
{
//since the fog color will assuredly get converted from linear to gamma, we should probably convert it from gamma to linear
for( int i = 0; i != 3; ++i )
fogColor[i] = GammaToLinear_HardwareSpecific( fogColor[i] );
}
if( (!m_DynamicState.m_bFogGammaCorrectionDisabled) && (g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER) )
{
for( int i = 0; i != 3; ++i )
fogColor[i] *= m_ToneMappingScale.x; // Linear
}
}
break;
case MATERIAL_FOG_LINEAR_BELOW_FOG_Z:
{
//water fog has been around a while and has never tonemap scaled, and has always been in linear space
if( g_pHardwareConfig->NeedsShaderSRGBConversion() )
{
//srgb in ps2b uses the 2.2 curve
for( int i = 0; i != 3; ++i )
fogColor[i] = pow( m_DynamicState.m_PixelFogColor[i], 2.2f );
}
else
{
for( int i = 0; i != 3; ++i )
fogColor[i] = GammaToLinear_HardwareSpecific( m_DynamicState.m_PixelFogColor[i] ); //this is how water fog color has always been setup in the past
}
if( (!m_DynamicState.m_bFogGammaCorrectionDisabled) && (g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER) )
{
for( int i = 0; i != 3; ++i )
fogColor[i] *= m_ToneMappingScale.x; // Linear
}
}
break;
NO_DEFAULT;
};
fogColor[3] = 1.0f / m_DynamicState.m_DestAlphaDepthRange;
SetPixelShaderConstant( LINEAR_FOG_COLOR, fogColor );
}
void CShaderAPIDx8::ApplyFogMode( ShaderFogMode_t fogMode, bool bSRGBWritesEnabled, bool bDisableFogGammaCorrection )
{
HDRType_t hdrType = g_pHardwareConfig->GetHDRType();
if ( fogMode == SHADER_FOGMODE_DISABLED )
{
if( hdrType != HDR_TYPE_FLOAT )
{
FogMode( MATERIAL_FOG_NONE );
}
if( m_DelayedShaderConstants.iPixelShaderFogParams != -1 )
SetPixelShaderFogParams( m_DelayedShaderConstants.iPixelShaderFogParams, fogMode );
return;
}
bool bShouldGammaCorrect = true; // By default, we'll gamma correct.
unsigned char r = 0, g = 0, b = 0; // Black fog
if( hdrType != HDR_TYPE_FLOAT )
{
FogMode( m_SceneFogMode );
}
if( m_DelayedShaderConstants.iPixelShaderFogParams != -1 )
SetPixelShaderFogParams( m_DelayedShaderConstants.iPixelShaderFogParams, fogMode );
switch( fogMode )
{
case SHADER_FOGMODE_BLACK: // Additive decals
bShouldGammaCorrect = false;
break;
case SHADER_FOGMODE_OO_OVERBRIGHT:
case SHADER_FOGMODE_GREY: // Mod2x decals
r = g = b = 128;
break;
case SHADER_FOGMODE_WHITE: // Multiplicative decals
r = g = b = 255;
bShouldGammaCorrect = false;
break;
case SHADER_FOGMODE_FOGCOLOR:
GetSceneFogColor( &r, &g, &b ); // Scene fog color
break;
NO_DEFAULT
}
bShouldGammaCorrect &= !bDisableFogGammaCorrection;
m_DynamicState.m_bFogGammaCorrectionDisabled = !bShouldGammaCorrect;
D3DCOLOR color;
if ( bShouldGammaCorrect )
{
color = ComputeGammaCorrectedFogColor( r, g, b, bSRGBWritesEnabled );
}
else
{
color = D3DCOLOR_ARGB( 255, r, g, b );
}
const float fColorScale = 1.0f / 255.0f;
m_DynamicState.m_PixelFogColor[0] = (float)(r) * fColorScale;
m_DynamicState.m_PixelFogColor[1] = (float)(g) * fColorScale;
m_DynamicState.m_PixelFogColor[2] = (float)(b) * fColorScale;
if( g_pMaterialSystemHardwareConfig->SupportsPixelShaders_2_b() )
{
UpdatePixelFogColorConstant();
}
if ( color != m_DynamicState.m_FogColor )
{
if( hdrType != HDR_TYPE_FLOAT )
{
m_DynamicState.m_FogColor = color;
SetRenderStateConstMacro( this, D3DRS_FOGCOLOR, m_DynamicState.m_FogColor );
}
}
}
void CShaderAPIDx8::SceneFogMode( MaterialFogMode_t fogMode )
{
LOCK_SHADERAPI();
if( m_SceneFogMode != fogMode )
{
FlushBufferedPrimitives();
m_SceneFogMode = fogMode;
if ( m_TransitionTable.CurrentShadowState() )
{
// Get the shadow state in sync since it depends on SceneFogMode.
ApplyFogMode( m_TransitionTable.CurrentShadowState()->m_FogMode, m_TransitionTable.CurrentShadowState()->m_SRGBWriteEnable, m_TransitionTable.CurrentShadowState()->m_bDisableFogGammaCorrection );
}
}
}
MaterialFogMode_t CShaderAPIDx8::GetSceneFogMode()
{
return m_SceneFogMode;
}
MaterialFogMode_t CShaderAPIDx8::GetPixelFogMode()
{
if( ShouldUsePixelFogForMode( m_SceneFogMode ) )
return m_SceneFogMode;
else
return MATERIAL_FOG_NONE;
}
int CShaderAPIDx8::GetPixelFogCombo( void )
{
if( (m_SceneFogMode != MATERIAL_FOG_NONE) && ShouldUsePixelFogForMode( m_SceneFogMode ) )
return m_SceneFogMode - 1; //PIXELFOGTYPE dynamic combos are shifted down one. MATERIAL_FOG_NONE is simulated by range fog with rigged parameters. Gets rid of a dynamic combo across the ps2x set
else
return MATERIAL_FOG_NONE;
}
static ConVar r_pixelfog( "r_pixelfog", "1" );
bool CShaderAPIDx8::ShouldUsePixelFogForMode( MaterialFogMode_t fogMode )
{
if( fogMode == MATERIAL_FOG_NONE )
return false;
if( IsX360() || IsPosix() ) // Always use pixel fog on X360 and Posix
return true;
if( g_pHardwareConfig->Caps().m_nDXSupportLevel < 90 ) //pixel fog not available until at least ps2.0
return false;
switch( m_SceneFogMode )
{
case MATERIAL_FOG_LINEAR:
return (g_pHardwareConfig->SupportsPixelShaders_2_b() && //lightmappedgeneric_ps20.fxc can't handle the instruction count
r_pixelfog.GetBool()); //use pixel fog if preferred
case MATERIAL_FOG_LINEAR_BELOW_FOG_Z:
return true;
};
return false;
}
//-----------------------------------------------------------------------------
// Fog methods...
//-----------------------------------------------------------------------------
void CShaderAPIDx8::FogMode( MaterialFogMode_t fogMode )
{
bool bFogEnable;
if ( IsX360() )
{
// FF fog not applicable on 360
return;
}
m_DynamicState.m_SceneFog = fogMode;
switch( fogMode )
{
default:
Assert( 0 );
// fall through
case MATERIAL_FOG_NONE:
bFogEnable = false;
break;
case MATERIAL_FOG_LINEAR:
// use vertex fog to achieve linear range fog
bFogEnable = true;
break;
case MATERIAL_FOG_LINEAR_BELOW_FOG_Z:
// use pixel fog on 9.0 and greater for height fog
bFogEnable = g_pHardwareConfig->Caps().m_nDXSupportLevel < 90;
break;
}
if( ShouldUsePixelFogForMode( fogMode ) )
{
bFogEnable = false; //disable FF fog when doing fog in the pixel shader
}
#if 0
// HACK - do this to disable fog always
bFogEnable = false;
m_DynamicState.m_SceneFog = MATERIAL_FOG_NONE;
#endif
// These two are always set to this, so don't bother setting them.
// We are always using vertex fog.
// SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE );
// SetRenderState( D3DRS_RANGEFOGENABLE, false );
// Set fog enable if it's different than before.
if ( bFogEnable != m_DynamicState.m_FogEnable )
{
SetSupportedRenderState( D3DRS_FOGENABLE, bFogEnable );
m_DynamicState.m_FogEnable = bFogEnable;
}
}
void CShaderAPIDx8::FogStart( float fStart )
{
LOCK_SHADERAPI();
if (fStart != m_DynamicState.m_FogStart)
{
// need to flush the dynamic buffer
FlushBufferedPrimitives();
SetRenderStateConstMacro( this, D3DRS_FOGSTART, *((DWORD*)(&fStart)));
m_VertexShaderFogParams[0] = fStart;
UpdateVertexShaderFogParams();
m_DynamicState.m_FogStart = fStart;
}
}
void CShaderAPIDx8::FogEnd( float fEnd )
{
LOCK_SHADERAPI();
if (fEnd != m_DynamicState.m_FogEnd)
{
// need to flush the dynamic buffer
FlushBufferedPrimitives();
SetRenderStateConstMacro( this, D3DRS_FOGEND, *((DWORD*)(&fEnd)));
m_VertexShaderFogParams[1] = fEnd;
UpdateVertexShaderFogParams();
m_DynamicState.m_FogEnd = fEnd;
}
}
void CShaderAPIDx8::SetFogZ( float fogZ )
{
LOCK_SHADERAPI();
if (fogZ != m_DynamicState.m_FogZ)
{
// need to flush the dynamic buffer
FlushBufferedPrimitives();
m_DynamicState.m_FogZ = fogZ;
UpdateVertexShaderFogParams();
}
}
void CShaderAPIDx8::FogMaxDensity( float flMaxDensity )
{
LOCK_SHADERAPI();
if (flMaxDensity != m_DynamicState.m_FogMaxDensity)
{
// need to flush the dynamic buffer
FlushBufferedPrimitives();
// SetRenderState(D3DRS_FOGDENSITY, *((DWORD*)(&flMaxDensity))); // ??? do I need to to this ???
m_flFogMaxDensity = flMaxDensity;
UpdateVertexShaderFogParams();
m_DynamicState.m_FogMaxDensity = flMaxDensity;
}
}
void CShaderAPIDx8::GetFogDistances( float *fStart, float *fEnd, float *fFogZ )
{
LOCK_SHADERAPI();
if( fStart )
*fStart = m_DynamicState.m_FogStart;
if( fEnd )
*fEnd = m_DynamicState.m_FogEnd;
if( fFogZ )
*fFogZ = m_DynamicState.m_FogZ;
}
void CShaderAPIDx8::SceneFogColor3ub( unsigned char r, unsigned char g, unsigned char b )
{
LOCK_SHADERAPI();
if( m_SceneFogColor[0] != r || m_SceneFogColor[1] != g || m_SceneFogColor[2] != b )
{
FlushBufferedPrimitives();
m_SceneFogColor[0] = r;
m_SceneFogColor[1] = g;
m_SceneFogColor[2] = b;
if ( m_TransitionTable.CurrentShadowState() )
{
ApplyFogMode( m_TransitionTable.CurrentShadowState()->m_FogMode, m_TransitionTable.CurrentShadowState()->m_SRGBWriteEnable, m_TransitionTable.CurrentShadowState()->m_bDisableFogGammaCorrection );
}
}
}
void CShaderAPIDx8::GetSceneFogColor( unsigned char *rgb )
{
LOCK_SHADERAPI();
rgb[0] = m_SceneFogColor[0];
rgb[1] = m_SceneFogColor[1];
rgb[2] = m_SceneFogColor[2];
}
void CShaderAPIDx8::GetSceneFogColor( unsigned char *r, unsigned char *g, unsigned char *b )
{
*r = m_SceneFogColor[0];
*g = m_SceneFogColor[1];
*b = m_SceneFogColor[2];
}
//-----------------------------------------------------------------------------
// Gamma correction of fog color, or not...
//-----------------------------------------------------------------------------
D3DCOLOR CShaderAPIDx8::ComputeGammaCorrectedFogColor( unsigned char r, unsigned char g, unsigned char b, bool bSRGBWritesEnabled )
{
#ifdef _DEBUG
if( g_pHardwareConfig->GetHDRType() == HDR_TYPE_FLOAT && !bSRGBWritesEnabled )
{
// Assert( 0 );
}
#endif
bool bLinearSpace = g_pHardwareConfig->Caps().m_bFogColorAlwaysLinearSpace ||
( bSRGBWritesEnabled && ( g_pHardwareConfig->Caps().m_bFogColorSpecifiedInLinearSpace || g_pHardwareConfig->GetHDRType() == HDR_TYPE_FLOAT ) );
bool bScaleFogByToneMappingScale = g_pHardwareConfig->GetHDRType() == HDR_TYPE_INTEGER;
float fr = ( r / 255.0f );
float fg = ( g / 255.0f );
float fb = ( b / 255.0f );
if ( bLinearSpace )
{
fr = GammaToLinear( fr );
fg = GammaToLinear( fg );
fb = GammaToLinear( fb );
if ( bScaleFogByToneMappingScale )
{
fr *= m_ToneMappingScale.x; //
fg *= m_ToneMappingScale.x; // Linear
fb *= m_ToneMappingScale.x; //
}
}
else if ( bScaleFogByToneMappingScale )
{
fr *= m_ToneMappingScale.w; //
fg *= m_ToneMappingScale.w; // Gamma
fb *= m_ToneMappingScale.w; //
}
fr = min( fr, 1.0f );
fg = min( fg, 1.0f );
fb = min( fb, 1.0f );
r = (int)( fr * 255 );
g = (int)( fg * 255 );
b = (int)( fb * 255 );
return D3DCOLOR_ARGB( 255, r, g, b );
}
//-----------------------------------------------------------------------------
// Some methods chaining vertex + pixel shaders through to the shader manager
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetVertexShaderIndex( int vshIndex )
{
ShaderManager()->SetVertexShaderIndex( vshIndex );
}
void CShaderAPIDx8::SetPixelShaderIndex( int pshIndex )
{
ShaderManager()->SetPixelShaderIndex( pshIndex );
}
void CShaderAPIDx8::SyncToken( const char *pToken )
{
LOCK_SHADERAPI();
RECORD_COMMAND( DX8_SYNC_TOKEN, 1 );
RECORD_STRING( pToken );
}
//-----------------------------------------------------------------------------
// Deals with vertex buffers
//-----------------------------------------------------------------------------
void CShaderAPIDx8::DestroyVertexBuffers( bool bExitingLevel )
{
LOCK_SHADERAPI();
MeshMgr()->DestroyVertexBuffers( );
// After a map is shut down, we switch to using smaller dynamic VBs
// (VGUI shouldn't need much), so that we have more memory free during map loading
m_nDynamicVBSize = bExitingLevel ? DYNAMIC_VERTEX_BUFFER_MEMORY_SMALL : DYNAMIC_VERTEX_BUFFER_MEMORY;
}
int CShaderAPIDx8::GetCurrentDynamicVBSize( void )
{
return m_nDynamicVBSize;
}
FORCEINLINE void CShaderAPIDx8::SetVertexShaderConstantInternal( int var, float const* pVec, int numVecs, bool bForce )
{
Assert( pVec );
// DX8 asm shaders use a constant mapping which has transforms and vertex shader
// specific constants shifted down by 10 constants (two 5-constant light structures)
if ( IsPC() )
{
if ( (g_pHardwareConfig->Caps().m_nDXSupportLevel < 90) && (var >= VERTEX_SHADER_MODULATION_COLOR) )
{
var -= 10;
}
Assert( var + numVecs <= g_pHardwareConfig->NumVertexShaderConstants() );
if ( !bForce )
{
int skip = 0;
numVecs = AdjustUpdateRange( pVec, &m_DesiredState.m_pVectorVertexShaderConstant[var], numVecs, &skip );
if ( !numVecs )
return;
var += skip;
pVec += skip * 4;
}
Dx9Device()->SetVertexShaderConstantF( var, pVec, numVecs );
memcpy( &m_DynamicState.m_pVectorVertexShaderConstant[var], pVec, numVecs * 4 * sizeof(float) );
}
else
{
Assert( var + numVecs <= g_pHardwareConfig->NumVertexShaderConstants() );
}
memcpy( &m_DesiredState.m_pVectorVertexShaderConstant[var], pVec, numVecs * 4 * sizeof(float) );
if ( IsX360() )
{
m_MaxVectorVertexShaderConstant = max( m_MaxVectorVertexShaderConstant, var + numVecs );
}
}
//-----------------------------------------------------------------------------
// Sets the constant register for vertex and pixel shaders
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetVertexShaderConstant( int var, float const* pVec, int numVecs, bool bForce )
{
SetVertexShaderConstantInternal( var, pVec, numVecs, bForce );
}
//-----------------------------------------------------------------------------
// Sets the boolean registers for vertex shader control flow
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetBooleanVertexShaderConstant( int var, int const* pVec, int numBools, bool bForce )
{
Assert( pVec );
Assert( var + numBools <= g_pHardwareConfig->NumBooleanVertexShaderConstants() );
if ( IsPC() && g_pHardwareConfig->GetDXSupportLevel() < 90 )
{
return;
}
if ( IsPC() && !bForce && memcmp( pVec, &m_DesiredState.m_pBooleanVertexShaderConstant[var], numBools * sizeof( BOOL ) ) == 0 )
{
return;
}
if ( IsPC() )
{
Dx9Device()->SetVertexShaderConstantB( var, pVec, numBools );
memcpy( &m_DynamicState.m_pBooleanVertexShaderConstant[var], pVec, numBools * sizeof(BOOL) );
}
memcpy( &m_DesiredState.m_pBooleanVertexShaderConstant[var], pVec, numBools * sizeof(BOOL) );
if ( IsX360() && var + numBools > m_MaxBooleanVertexShaderConstant )
{
m_MaxBooleanVertexShaderConstant = var + numBools;
Assert( m_MaxBooleanVertexShaderConstant <= 16 );
}
}
//-----------------------------------------------------------------------------
// Sets the integer registers for vertex shader control flow
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetIntegerVertexShaderConstant( int var, int const* pVec, int numIntVecs, bool bForce )
{
Assert( pVec );
Assert( var + numIntVecs <= g_pHardwareConfig->NumIntegerVertexShaderConstants() );
if ( IsPC() && g_pHardwareConfig->GetDXSupportLevel() < 90 )
{
return;
}
if ( IsPC() && !bForce && memcmp( pVec, &m_DesiredState.m_pIntegerVertexShaderConstant[var], numIntVecs * sizeof( IntVector4D ) ) == 0 )
{
return;
}
if ( IsPC() )
{
Dx9Device()->SetVertexShaderConstantI( var, pVec, numIntVecs );
memcpy( &m_DynamicState.m_pIntegerVertexShaderConstant[var], pVec, numIntVecs * sizeof(IntVector4D) );
}
memcpy( &m_DesiredState.m_pIntegerVertexShaderConstant[var], pVec, numIntVecs * sizeof(IntVector4D) );
if ( IsX360() && var + numIntVecs > m_MaxIntegerVertexShaderConstant )
{
m_MaxIntegerVertexShaderConstant = var + numIntVecs;
Assert( m_MaxIntegerVertexShaderConstant <= 16 );
}
}
FORCEINLINE void CShaderAPIDx8::SetPixelShaderConstantInternal( int nStartConst, float const* pValues, int nNumConsts, bool bForce )
{
Assert( nStartConst + nNumConsts <= g_pHardwareConfig->NumPixelShaderConstants() );
if ( IsPC() )
{
if ( ! bForce )
{
int skip = 0;
nNumConsts = AdjustUpdateRange( pValues, &m_DesiredState.m_pVectorPixelShaderConstant[nStartConst], nNumConsts, &skip );
if ( !nNumConsts )
return;
nStartConst += skip;
pValues += skip * 4;
}
Dx9Device()->SetPixelShaderConstantF( nStartConst, pValues, nNumConsts );
memcpy( &m_DynamicState.m_pVectorPixelShaderConstant[nStartConst], pValues, nNumConsts * 4 * sizeof(float) );
}
memcpy( &m_DesiredState.m_pVectorPixelShaderConstant[nStartConst], pValues, nNumConsts * 4 * sizeof(float) );
if ( IsX360() )
{
m_MaxVectorPixelShaderConstant = max( m_MaxVectorPixelShaderConstant, nStartConst + nNumConsts );
Assert( m_MaxVectorPixelShaderConstant <= 32 );
}
}
void CShaderAPIDx8::SetPixelShaderConstant( int var, float const* pVec, int numVecs, bool bForce )
{
SetPixelShaderConstantInternal( var, pVec, numVecs, bForce );
}
template<class T> FORCEINLINE T GetData( uint8 const *pData )
{
return * ( reinterpret_cast< T const *>( pData ) );
}
void CShaderAPIDx8::SetStandardTextureHandle( StandardTextureId_t nId, ShaderAPITextureHandle_t nHandle )
{
Assert( nId < ARRAYSIZE( m_StdTextureHandles ) );
m_StdTextureHandles[nId] = nHandle;
}
void CShaderAPIDx8::ExecuteCommandBuffer( uint8 *pCmdBuf )
{
uint8 *pReturnStack[20];
uint8 **pSP = &pReturnStack[ARRAYSIZE(pReturnStack)];
uint8 *pLastCmd;
for(;;)
{
uint8 *pCmd=pCmdBuf;
int nCmd = GetData<int>( pCmdBuf );
switch( nCmd )
{
case CBCMD_END:
{
if ( pSP == &pReturnStack[ARRAYSIZE(pReturnStack)] )
return;
else
{
// pop pc
pCmdBuf = *( pSP ++ );
break;
}
}
case CBCMD_JUMP:
pCmdBuf = GetData<uint8 *>( pCmdBuf + sizeof( int ) );
break;
case CBCMD_JSR:
{
Assert( pSP > &(pReturnStack[0] ) );
// *(--pSP ) = pCmdBuf + sizeof( int ) + sizeof( uint8 *);
// pCmdBuf = GetData<uint8 *>( pCmdBuf + sizeof( int ) );
ExecuteCommandBuffer( GetData<uint8 *>( pCmdBuf + sizeof( int ) ) );
pCmdBuf = pCmdBuf + sizeof( int ) + sizeof( uint8 *);
break;
}
case CBCMD_SET_PIXEL_SHADER_FLOAT_CONST:
{
int nStartConst = GetData<int>( pCmdBuf + sizeof( int ) );
int nNumConsts = GetData<int>( pCmdBuf + 2 * sizeof( int ) );
float const *pValues = reinterpret_cast< float const *> ( pCmdBuf + 3 * sizeof( int ) );
pCmdBuf += nNumConsts * 4 * sizeof( float ) + 3 * sizeof( int );
SetPixelShaderConstantInternal( nStartConst, pValues, nNumConsts, false );
break;
}
case CBCMD_SETPIXELSHADERFOGPARAMS:
{
int nReg = GetData<int>( pCmdBuf + sizeof( int ) );
pCmdBuf += 2 * sizeof( int );
SetPixelShaderFogParams( nReg ); // !! speed fixme
break;
}
case CBCMD_STORE_EYE_POS_IN_PSCONST:
{
int nReg = GetData<int>( pCmdBuf + sizeof( int ) );
pCmdBuf += 2 * sizeof( int );
SetPixelShaderConstantInternal( nReg, m_WorldSpaceCameraPositon.Base(), 1, false );
break;
}
case CBCMD_COMMITPIXELSHADERLIGHTING:
{
int nReg = GetData<int>( pCmdBuf + sizeof( int ) );
pCmdBuf += 2 * sizeof( int );
CommitPixelShaderLighting( nReg );
break;
}
case CBCMD_SETPIXELSHADERSTATEAMBIENTLIGHTCUBE:
{
int nReg = GetData<int>( pCmdBuf + sizeof( int ) );
pCmdBuf += 2 * sizeof( int );
float *pCubeBase = m_DynamicState.m_AmbientLightCube[0].Base();
SetPixelShaderConstantInternal( nReg, pCubeBase, 6, false );
break;
}
case CBCMD_SETAMBIENTCUBEDYNAMICSTATEVERTEXSHADER:
{
pCmdBuf +=sizeof( int );
SetVertexShaderStateAmbientLightCube();
break;
}
case CBCMD_SET_DEPTH_FEATHERING_CONST:
{
int nConst = GetData<int>( pCmdBuf + sizeof( int ) );
float fDepthBlendScale = GetData<float>( pCmdBuf + 2 * sizeof( int ) );
pCmdBuf += 2 * sizeof( int ) + sizeof( float );
SetDepthFeatheringPixelShaderConstant( nConst, fDepthBlendScale );
break;
}
case CBCMD_SET_VERTEX_SHADER_FLOAT_CONST:
{
int nStartConst = GetData<int>( pCmdBuf + sizeof( int ) );
int nNumConsts = GetData<int>( pCmdBuf + 2 * sizeof( int ) );
float const *pValues = reinterpret_cast< float const *> ( pCmdBuf + 3 * sizeof( int ) );
pCmdBuf += nNumConsts * 4 * sizeof( float ) + 3 * sizeof( int );
SetVertexShaderConstantInternal( nStartConst, pValues, nNumConsts, false );
break;
}
case CBCMD_BIND_STANDARD_TEXTURE:
{
int nSampler = GetData<int>( pCmdBuf + sizeof( int ) );
int nTextureID = GetData<int>( pCmdBuf + 2 * sizeof( int ) );
pCmdBuf += 3 * sizeof( int );
if ( m_StdTextureHandles[nTextureID] != INVALID_SHADERAPI_TEXTURE_HANDLE )
{
BindTexture( (Sampler_t) nSampler, m_StdTextureHandles[nTextureID] );
}
else
{
ShaderUtil()->BindStandardTexture( (Sampler_t) nSampler, (StandardTextureId_t ) nTextureID );
}
break;
}
case CBCMD_BIND_SHADERAPI_TEXTURE_HANDLE:
{
int nSampler = GetData<int>( pCmdBuf + sizeof( int ) );
ShaderAPITextureHandle_t hTexture = GetData<ShaderAPITextureHandle_t>( pCmdBuf + 2 * sizeof( int ) );
Assert( hTexture != INVALID_SHADERAPI_TEXTURE_HANDLE );
pCmdBuf += 2 * sizeof( int ) + sizeof( ShaderAPITextureHandle_t );
BindTexture( (Sampler_t) nSampler, hTexture );
break;
}
case CBCMD_SET_PSHINDEX:
{
int nIdx = GetData<int>( pCmdBuf + sizeof( int ) );
ShaderManager()->SetPixelShaderIndex( nIdx );
pCmdBuf += 2 * sizeof( int );
break;
}
case CBCMD_SET_VSHINDEX:
{
int nIdx = GetData<int>( pCmdBuf + sizeof( int ) );
ShaderManager()->SetVertexShaderIndex( nIdx );
pCmdBuf += 2 * sizeof( int );
break;
}
#ifndef NDEBUG
default:
{
Assert(0);
}
#endif
}
pLastCmd = pCmd;
}
}
//-----------------------------------------------------------------------------
// Sets the boolean registers for pixel shader control flow
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetBooleanPixelShaderConstant( int var, int const* pVec, int numBools, bool bForce )
{
Assert( pVec );
Assert( var + numBools <= g_pHardwareConfig->NumBooleanPixelShaderConstants() );
if ( IsPC() && !bForce && memcmp( pVec, &m_DesiredState.m_pBooleanPixelShaderConstant[var], numBools * sizeof( BOOL ) ) == 0 )
{
return;
}
if ( IsPC() )
{
Dx9Device()->SetPixelShaderConstantB( var, pVec, numBools );
memcpy( &m_DynamicState.m_pBooleanPixelShaderConstant[var], pVec, numBools * sizeof(BOOL) );
}
memcpy( &m_DesiredState.m_pBooleanPixelShaderConstant[var], pVec, numBools * sizeof(BOOL) );
if ( IsX360() && var + numBools > m_MaxBooleanPixelShaderConstant )
{
m_MaxBooleanPixelShaderConstant = var + numBools;
Assert( m_MaxBooleanPixelShaderConstant <= 16 );
}
}
//-----------------------------------------------------------------------------
// Sets the integer registers for pixel shader control flow
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetIntegerPixelShaderConstant( int var, int const* pVec, int numIntVecs, bool bForce )
{
Assert( pVec );
Assert( var + numIntVecs <= g_pHardwareConfig->NumIntegerPixelShaderConstants() );
if ( IsPC() && !bForce && memcmp( pVec, &m_DesiredState.m_pIntegerPixelShaderConstant[var], numIntVecs * sizeof( IntVector4D ) ) == 0 )
{
return;
}
if ( IsPC() )
{
Dx9Device()->SetPixelShaderConstantI( var, pVec, numIntVecs );
memcpy( &m_DynamicState.m_pIntegerPixelShaderConstant[var], pVec, numIntVecs * sizeof(IntVector4D) );
}
memcpy( &m_DesiredState.m_pIntegerPixelShaderConstant[var], pVec, numIntVecs * sizeof(IntVector4D) );
if ( IsX360() && var + numIntVecs > m_MaxIntegerPixelShaderConstant )
{
m_MaxIntegerPixelShaderConstant = var + numIntVecs;
Assert( m_MaxBooleanPixelShaderConstant <= 16 );
}
}
void CShaderAPIDx8::InvalidateDelayedShaderConstants( void )
{
m_DelayedShaderConstants.Invalidate();
}
//-----------------------------------------------------------------------------
//
// Methods dealing with texture stage state
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Gets the texture associated with a texture state...
//-----------------------------------------------------------------------------
inline IDirect3DBaseTexture* CShaderAPIDx8::GetD3DTexture( ShaderAPITextureHandle_t hTexture )
{
if ( hTexture == INVALID_SHADERAPI_TEXTURE_HANDLE )
{
return NULL;
}
AssertValidTextureHandle( hTexture );
Texture_t& tex = GetTexture( hTexture );
if ( tex.m_NumCopies == 1 )
{
return tex.GetTexture();
}
else
{
return tex.GetTexture( tex.m_CurrentCopy );
}
}
//-----------------------------------------------------------------------------
// Inline methods
//-----------------------------------------------------------------------------
inline ShaderAPITextureHandle_t CShaderAPIDx8::GetModifyTextureHandle() const
{
return m_ModifyTextureHandle;
}
inline IDirect3DBaseTexture* CShaderAPIDx8::GetModifyTexture()
{
return CShaderAPIDx8::GetD3DTexture( m_ModifyTextureHandle );
}
void CShaderAPIDx8::SetModifyTexture( IDirect3DBaseTexture* pTex )
{
if ( m_ModifyTextureHandle == INVALID_SHADERAPI_TEXTURE_HANDLE )
return;
Texture_t& tex = GetTexture( m_ModifyTextureHandle );
if ( tex.m_NumCopies == 1 )
{
tex.SetTexture( pTex );
}
else
{
tex.SetTexture( tex.m_CurrentCopy, pTex );
}
}
inline ShaderAPITextureHandle_t CShaderAPIDx8::GetBoundTextureBindId( Sampler_t sampler ) const
{
return SamplerState( sampler ).m_BoundTexture;
}
inline bool CShaderAPIDx8::WouldBeOverTextureLimit( ShaderAPITextureHandle_t hTexture )
{
if ( IsPC() )
{
if ( mat_texture_limit.GetInt() < 0 )
return false;
Texture_t &tex = GetTexture( hTexture );
if ( tex.m_LastBoundFrame == m_CurrentFrame )
return false;
return m_nTextureMemoryUsedLastFrame + tex.GetMemUsage() > (mat_texture_limit.GetInt() * 1024);
}
return false;
}
#define SETSAMPLESTATEANDMIRROR( sampler, samplerState, state_type, mirror_field, value ) \
if ( samplerState.mirror_field != value ) \
{ \
samplerState.mirror_field = value; \
::SetSamplerState( g_pD3DDevice, sampler, state_type, value ); \
}
#define SETSAMPLESTATEANDMIRROR_FLOAT( sampler, samplerState, state_type, mirror_field, value ) \
if ( samplerState.mirror_field != value ) \
{ \
samplerState.mirror_field = value; \
::SetSamplerState( g_pD3DDevice, sampler, state_type, *(DWORD*)&value ); \
}
//-----------------------------------------------------------------------------
// Sets state on the board related to the texture state
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetTextureState( Sampler_t sampler, ShaderAPITextureHandle_t hTexture, bool force )
{
// Get the dynamic texture info
SamplerState_t &samplerState = SamplerState( sampler );
// Set the texture state, but only if it changes
if ( ( samplerState.m_BoundTexture == hTexture ) && !force )
return;
// Disabling texturing
if ( hTexture == INVALID_SHADERAPI_TEXTURE_HANDLE || WouldBeOverTextureLimit( hTexture ) )
{
Dx9Device()->SetTexture( sampler, 0 );
return;
}
samplerState.m_BoundTexture = hTexture;
// Don't set this if we're disabled
if ( !samplerState.m_TextureEnable )
return;
RECORD_COMMAND( DX8_SET_TEXTURE, 3 );
RECORD_INT( stage );
RECORD_INT( hTexture );
RECORD_INT( GetTexture( hTexture).m_CurrentCopy );
IDirect3DBaseTexture *pTexture = CShaderAPIDx8::GetD3DTexture( hTexture );
#if defined( _X360 )
DWORD linearFormatBackup = pTexture->Format.dword[0];
if ( samplerState.m_SRGBReadEnable )
{
// convert to srgb format for the bind. This effectively emulates the old srgb read sampler state
pTexture->Format.SignX =
pTexture->Format.SignY =
pTexture->Format.SignZ = 3;
}
#endif
Dx9Device()->SetTexture( sampler, pTexture );
#if defined( _X360 )
// put the format back in linear space
pTexture->Format.dword[0] = linearFormatBackup;
#endif
Texture_t &tex = GetTexture( hTexture );
if ( tex.m_LastBoundFrame != m_CurrentFrame )
{
tex.m_LastBoundFrame = m_CurrentFrame;
tex.m_nTimesBoundThisFrame = 0;
if ( tex.m_pTextureGroupCounterFrame )
{
// Update the per-frame texture group counter.
*tex.m_pTextureGroupCounterFrame += tex.GetMemUsage();
}
// Track memory usage.
m_nTextureMemoryUsedLastFrame += tex.GetMemUsage();
}
if ( !m_bDebugTexturesRendering )
++tex.m_nTimesBoundThisFrame;
tex.m_nTimesBoundMax = MAX( tex.m_nTimesBoundMax, tex.m_nTimesBoundThisFrame );
static MaterialSystem_Config_t &materialSystemConfig = ShaderUtil()->GetConfig();
D3DTEXTUREFILTERTYPE minFilter = tex.m_MinFilter;
D3DTEXTUREFILTERTYPE magFilter = tex.m_MagFilter;
D3DTEXTUREFILTERTYPE mipFilter = tex.m_MipFilter;
int finestMipmapLevel = tex.m_FinestMipmapLevel;
float lodBias = tex.m_LodBias;
if ( materialSystemConfig.bMipMapTextures == 0 )
{
mipFilter = D3DTEXF_NONE;
}
if ( materialSystemConfig.bFilterTextures == 0 && tex.m_NumLevels > 1 )
{
minFilter = D3DTEXF_NONE;
magFilter = D3DTEXF_NONE;
mipFilter = D3DTEXF_POINT;
}
D3DTEXTUREADDRESS uTexWrap = tex.m_UTexWrap;
D3DTEXTUREADDRESS vTexWrap = tex.m_VTexWrap;
D3DTEXTUREADDRESS wTexWrap = tex.m_WTexWrap;
// For now do this the old way on OSX since the dxabstract layer doesn't support SetSamplerStates
// ###OSX### punting on OSX for now
#if DX_TO_GL_ABSTRACTION && !OSX
if ( ( samplerState.m_MinFilter != minFilter ) || ( samplerState.m_MagFilter != magFilter ) || ( samplerState.m_MipFilter != mipFilter ) ||
( samplerState.m_UTexWrap != uTexWrap ) || ( samplerState.m_VTexWrap != vTexWrap ) || ( samplerState.m_WTexWrap != wTexWrap ) ||
( samplerState.m_FinestMipmapLevel != finestMipmapLevel ) || ( samplerState.m_LodBias != lodBias ) )
{
samplerState.m_UTexWrap = uTexWrap;
samplerState.m_VTexWrap = vTexWrap;
samplerState.m_WTexWrap = wTexWrap;
samplerState.m_MinFilter = minFilter;
samplerState.m_MagFilter = magFilter;
samplerState.m_MipFilter = mipFilter;
samplerState.m_FinestMipmapLevel = finestMipmapLevel;
samplerState.m_LodBias = lodBias;
Dx9Device()->SetSamplerStates( sampler, uTexWrap, vTexWrap, wTexWrap, minFilter, magFilter, mipFilter, finestMipmapLevel, lodBias );
}
#else
SETSAMPLESTATEANDMIRROR( sampler, samplerState, D3DSAMP_ADDRESSU, m_UTexWrap, uTexWrap );
SETSAMPLESTATEANDMIRROR( sampler, samplerState, D3DSAMP_ADDRESSV, m_VTexWrap, vTexWrap );
SETSAMPLESTATEANDMIRROR( sampler, samplerState, D3DSAMP_ADDRESSW, m_WTexWrap, wTexWrap );
SETSAMPLESTATEANDMIRROR( sampler, samplerState, D3DSAMP_MINFILTER, m_MinFilter, minFilter );
SETSAMPLESTATEANDMIRROR( sampler, samplerState, D3DSAMP_MAGFILTER, m_MagFilter, magFilter );
SETSAMPLESTATEANDMIRROR( sampler, samplerState, D3DSAMP_MIPFILTER, m_MipFilter, mipFilter );
SETSAMPLESTATEANDMIRROR( sampler, samplerState, D3DSAMP_MAXMIPLEVEL, m_FinestMipmapLevel, finestMipmapLevel );
SETSAMPLESTATEANDMIRROR_FLOAT( sampler, samplerState, D3DSAMP_MIPMAPLODBIAS, m_LodBias, lodBias );
#endif
}
void CShaderAPIDx8::BindTexture( Sampler_t sampler, ShaderAPITextureHandle_t textureHandle )
{
LOCK_SHADERAPI();
SetTextureState( sampler, textureHandle );
}
void CShaderAPIDx8::BindVertexTexture( VertexTextureSampler_t nStage, ShaderAPITextureHandle_t textureHandle )
{
Assert( g_pMaterialSystemHardwareConfig->GetVertexTextureCount() != 0 );
LOCK_SHADERAPI();
ADD_VERTEX_TEXTURE_FUNC( COMMIT_PER_PASS, COMMIT_VERTEX_SHADER,
CommitVertexTextures, nStage, m_BoundTexture, textureHandle );
}
//-----------------------------------------------------------------------------
// Texture allocation/deallocation
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Computes stats info for a texture
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ComputeStatsInfo( ShaderAPITextureHandle_t hTexture, bool isCubeMap, bool isVolumeTexture )
{
Texture_t &textureData = GetTexture( hTexture );
textureData.m_SizeBytes = 0;
textureData.m_SizeTexels = 0;
textureData.m_LastBoundFrame = -1;
if ( IsX360() )
{
textureData.m_nTimesBoundThisFrame = 0;
}
IDirect3DBaseTexture* pD3DTex = CShaderAPIDx8::GetD3DTexture( hTexture );
if ( IsPC() || !IsX360() )
{
if ( isCubeMap )
{
IDirect3DCubeTexture* pTex = static_cast<IDirect3DCubeTexture*>(pD3DTex);
if ( !pTex )
{
Assert( 0 );
return;
}
int numLevels = pTex->GetLevelCount();
for (int i = 0; i < numLevels; ++i)
{
D3DSURFACE_DESC desc;
HRESULT hr = pTex->GetLevelDesc( i, &desc );
Assert( !FAILED(hr) );
textureData.m_SizeBytes += 6 * ImageLoader::GetMemRequired( desc.Width, desc.Height, 1, textureData.GetImageFormat(), false );
textureData.m_SizeTexels += 6 * desc.Width * desc.Height;
}
}
else if ( isVolumeTexture )
{
IDirect3DVolumeTexture9* pTex = static_cast<IDirect3DVolumeTexture9*>(pD3DTex);
if ( !pTex )
{
Assert( 0 );
return;
}
int numLevels = pTex->GetLevelCount();
for (int i = 0; i < numLevels; ++i)
{
D3DVOLUME_DESC desc;
HRESULT hr = pTex->GetLevelDesc( i, &desc );
Assert( !FAILED( hr ) );
textureData.m_SizeBytes += ImageLoader::GetMemRequired( desc.Width, desc.Height, desc.Depth, textureData.GetImageFormat(), false );
textureData.m_SizeTexels += desc.Width * desc.Height;
}
}
else
{
IDirect3DTexture* pTex = static_cast<IDirect3DTexture*>(pD3DTex);
if ( !pTex )
{
Assert( 0 );
return;
}
int numLevels = pTex->GetLevelCount();
for (int i = 0; i < numLevels; ++i)
{
D3DSURFACE_DESC desc;
HRESULT hr = pTex->GetLevelDesc( i, &desc );
Assert( !FAILED( hr ) );
textureData.m_SizeBytes += ImageLoader::GetMemRequired( desc.Width, desc.Height, 1, textureData.GetImageFormat(), false );
textureData.m_SizeTexels += desc.Width * desc.Height;
}
}
}
#if defined( _X360 )
// 360 uses gpu storage size (which accounts for page alignment bloat), not format size
textureData.m_SizeBytes = g_TextureHeap.GetSize( pD3DTex );
#endif
}
static D3DFORMAT ComputeFormat( IDirect3DBaseTexture* pTexture, bool isCubeMap )
{
Assert( pTexture );
D3DSURFACE_DESC desc;
if (isCubeMap)
{
IDirect3DCubeTexture* pTex = static_cast<IDirect3DCubeTexture*>(pTexture);
HRESULT hr = pTex->GetLevelDesc( 0, &desc );
Assert( !FAILED(hr) );
}
else
{
IDirect3DTexture* pTex = static_cast<IDirect3DTexture*>(pTexture);
HRESULT hr = pTex->GetLevelDesc( 0, &desc );
Assert( !FAILED(hr) );
}
return desc.Format;
}
ShaderAPITextureHandle_t CShaderAPIDx8::CreateDepthTexture(
ImageFormat renderTargetFormat,
int width,
int height,
const char *pDebugName,
bool bTexture )
{
LOCK_SHADERAPI();
ShaderAPITextureHandle_t i = CreateTextureHandle();
Texture_t *pTexture = &GetTexture( i );
pTexture->m_Flags = Texture_t::IS_ALLOCATED;
if( bTexture )
{
pTexture->m_Flags |= Texture_t::IS_DEPTH_STENCIL_TEXTURE;
}
else
{
pTexture->m_Flags |= Texture_t::IS_DEPTH_STENCIL;
}
pTexture->m_DebugName = pDebugName;
pTexture->m_Width = width;
pTexture->m_Height = height;
pTexture->m_Depth = 1; // fake
pTexture->m_Count = 1; // created single texture
pTexture->m_CountIndex = 0; // created single texture
pTexture->m_CreationFlags = 0; // fake
pTexture->m_NumCopies = 1;
pTexture->m_CurrentCopy = 0;
ImageFormat renderFormat = FindNearestSupportedFormat( renderTargetFormat, false, true, false );
#if defined( _X360 )
D3DFORMAT nDepthFormat = ReverseDepthOnX360() ? D3DFMT_D24FS8 : D3DFMT_D24S8;
#else
D3DFORMAT nDepthFormat = m_bUsingStencil ? D3DFMT_D24S8 : D3DFMT_D24X8;
#endif
D3DFORMAT format = FindNearestSupportedDepthFormat( m_nAdapter, m_AdapterFormat, renderFormat, nDepthFormat );
D3DMULTISAMPLE_TYPE multisampleType = D3DMULTISAMPLE_NONE;
pTexture->m_NumLevels = 1;
pTexture->m_SizeTexels = width * height;
pTexture->m_SizeBytes = ImageLoader::GetMemRequired( width, height, 1, renderFormat, false );
RECORD_COMMAND( DX8_CREATE_DEPTH_TEXTURE, 5 );
RECORD_INT( i );
RECORD_INT( width );
RECORD_INT( height );
RECORD_INT( format );
RECORD_INT( multisampleType );
HRESULT hr;
if ( !bTexture )
{
#if defined( _X360 )
int backWidth, backHeight;
ShaderAPI()->GetBackBufferDimensions( backWidth, backHeight );
D3DFORMAT backBufferFormat = ImageLoader::ImageFormatToD3DFormat( g_pShaderDevice->GetBackBufferFormat() );
// immediately follows back buffer in EDRAM
D3DSURFACE_PARAMETERS surfParameters;
surfParameters.Base = 2*XGSurfaceSize( backWidth, backHeight, backBufferFormat, D3DMULTISAMPLE_NONE );
surfParameters.ColorExpBias = 0;
surfParameters.HierarchicalZBase = 0;
hr = Dx9Device()->CreateDepthStencilSurface(
width, height, format, multisampleType, 0, TRUE, &pTexture->GetDepthStencilSurface(), &surfParameters );
#else
hr = Dx9Device()->CreateDepthStencilSurface(
width, height, format, multisampleType, 0, TRUE, &pTexture->GetDepthStencilSurface(), NULL );
#endif
}
else
{
IDirect3DTexture9 *pTex;
hr = Dx9Device()->CreateTexture( width, height, 1, D3DUSAGE_DEPTHSTENCIL, format, D3DPOOL_DEFAULT, &pTex, NULL );
pTexture->SetTexture( pTex );
}
if ( FAILED( hr ) )
{
switch( hr )
{
case D3DERR_INVALIDCALL:
Warning( "ShaderAPIDX8::CreateDepthStencilSurface: D3DERR_INVALIDCALL\n" );
break;
case D3DERR_OUTOFVIDEOMEMORY:
Warning( "ShaderAPIDX8::CreateDepthStencilSurface: D3DERR_OUTOFVIDEOMEMORY\n" );
break;
default:
break;
}
Assert( 0 );
}
#ifdef _XBOX
D3DSURFACE_DESC desc;
hr = pTexture->GetDepthStencilSurface()->GetDesc( &desc );
Assert( !FAILED( hr ) );
pTexture->m_nTimesBoundThisFrame = 0;
pTexture->m_StaticSizeBytes = desc.Size;
pTexture->m_DynamicSizeBytes = 0;
pTexture->m_DebugName = pDebugName;
pTexture->m_TextureGroupName = TEXTURE_GROUP_RENDER_TARGET;
pTexture->SetImageFormat( IMAGE_FORMAT_UNKNOWN );
#endif
return i;
}
// FIXME!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// Could keep a free-list for this instead of linearly searching. We
// don't create textures all the time, so this is probably fine for now.
// FIXME!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
ShaderAPITextureHandle_t CShaderAPIDx8::CreateTextureHandle( void )
{
ShaderAPITextureHandle_t handle;
CreateTextureHandles( &handle, 1 );
return handle;
}
void CShaderAPIDx8::CreateTextureHandles( ShaderAPITextureHandle_t *handles, int count )
{
TM_ZONE_DEFAULT( TELEMETRY_LEVEL0 );
if ( count <= 0 )
return;
MEM_ALLOC_CREDIT();
int idxCreating = 0;
ShaderAPITextureHandle_t hTexture;
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Search", __FUNCTION__ );
for ( hTexture = m_Textures.Head(); hTexture != m_Textures.InvalidIndex(); hTexture = m_Textures.Next( hTexture ) )
{
if ( !( m_Textures[hTexture].m_Flags & Texture_t::IS_ALLOCATED ) )
{
handles[ idxCreating ++ ] = hTexture;
if ( idxCreating >= count )
return;
}
}
}
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Add", __FUNCTION__ );
while ( idxCreating < count )
handles[ idxCreating ++ ] = m_Textures.AddToTail();
}
//-----------------------------------------------------------------------------
// Creates a lovely texture
//-----------------------------------------------------------------------------
ShaderAPITextureHandle_t CShaderAPIDx8::CreateTexture(
int width,
int height,
int depth,
ImageFormat dstImageFormat,
int numMipLevels,
int numCopies,
int creationFlags,
const char *pDebugName,
const char *pTextureGroupName )
{
ShaderAPITextureHandle_t handle = 0;
CreateTextures( &handle, 1, width, height, depth, dstImageFormat, numMipLevels, numCopies, creationFlags, pDebugName, pTextureGroupName );
return handle;
}
void CShaderAPIDx8::CreateTextures(
ShaderAPITextureHandle_t *pHandles,
int count,
int width,
int height,
int depth,
ImageFormat dstImageFormat,
int numMipLevels,
int numCopies,
int creationFlags,
const char *pDebugName,
const char *pTextureGroupName )
{
TM_ZONE_DEFAULT( TELEMETRY_LEVEL0 );
LOCK_SHADERAPI();
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - PostLock", __FUNCTION__ );
Assert( this == g_pShaderAPI );
if ( depth == 0 )
{
depth = 1;
}
bool isCubeMap = (creationFlags & TEXTURE_CREATE_CUBEMAP) != 0;
bool isRenderTarget = (creationFlags & TEXTURE_CREATE_RENDERTARGET) != 0;
bool managed = (creationFlags & TEXTURE_CREATE_MANAGED) != 0;
bool isDepthBuffer = (creationFlags & TEXTURE_CREATE_DEPTHBUFFER) != 0;
bool isDynamic = (creationFlags & TEXTURE_CREATE_DYNAMIC) != 0;
bool isSRGB = (creationFlags & TEXTURE_CREATE_SRGB) != 0; // for Posix/GL only... not used here ?
#if defined(IS_WINDOWS_PC) && defined(SHADERAPIDX9)
extern bool g_ShaderDeviceUsingD3D9Ex;
if ( g_ShaderDeviceUsingD3D9Ex && managed )
{
// Managed textures aren't available under D3D9Ex, but we never lose
// texture data, so it's ok to use the default pool. Really. We can't
// lock default-pool textures like we normally would to upload, but we
// have special logic to blit full updates via D3DX helper functions
// in D3D9Ex mode (see texturedx8.cpp)
managed = false;
creationFlags &= ~TEXTURE_CREATE_MANAGED;
}
#endif
// Can't be both managed + dynamic. Dynamic is an optimization, but
// if it's not managed, then we gotta do special client-specific stuff
// So, managed wins out!
if ( managed )
{
creationFlags &= ~TEXTURE_CREATE_DYNAMIC;
isDynamic = false;
}
// Create a set of texture handles
CreateTextureHandles( pHandles, count );
Texture_t **arrTxp = ( Texture_t ** ) stackalloc( count * sizeof( Texture_t * ) );
unsigned short usSetFlags = 0;
usSetFlags |= ( IsPosix() || ( creationFlags & (TEXTURE_CREATE_DYNAMIC | TEXTURE_CREATE_MANAGED) ) ) ? Texture_t::IS_LOCKABLE : 0;
usSetFlags |= ( creationFlags & TEXTURE_CREATE_VERTEXTEXTURE) ? Texture_t::IS_VERTEX_TEXTURE : 0;
#if defined( _X360 )
usSetFlags |= ( creationFlags & TEXTURE_CREATE_RENDERTARGET ) ? Texture_t::IS_RENDER_TARGET : 0;
usSetFlags |= ( creationFlags & TEXTURE_CREATE_CANCONVERTFORMAT ) ? Texture_t::CAN_CONVERT_FORMAT : 0;
#endif
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - CreateFrames", __FUNCTION__ );
for ( int idxFrame = 0; idxFrame < count; ++ idxFrame )
{
arrTxp[ idxFrame ] = &GetTexture( pHandles[ idxFrame ] );
Texture_t *pTexture = arrTxp[ idxFrame ];
pTexture->m_Flags = Texture_t::IS_ALLOCATED;
pTexture->m_DebugName = pDebugName;
pTexture->m_Width = width;
pTexture->m_Height = height;
pTexture->m_Depth = depth;
pTexture->m_Count = count;
pTexture->m_CountIndex = idxFrame;
pTexture->m_CreationFlags = creationFlags;
pTexture->m_Flags |= usSetFlags;
RECORD_COMMAND( DX8_CREATE_TEXTURE, 12 );
RECORD_INT( textureHandle );
RECORD_INT( width );
RECORD_INT( height );
RECORD_INT( depth ); // depth for volume textures
RECORD_INT( ImageLoader::ImageFormatToD3DFormat( FindNearestSupportedFormat(dstImageFormat)) );
RECORD_INT( numMipLevels );
RECORD_INT( isCubeMap );
RECORD_INT( numCopies <= 1 ? 1 : numCopies );
RECORD_INT( isRenderTarget ? 1 : 0 );
RECORD_INT( managed );
RECORD_INT( isDepthBuffer ? 1 : 0 );
RECORD_INT( isDynamic ? 1 : 0 );
IDirect3DBaseTexture* pD3DTex;
// Set the initial texture state
if ( numCopies <= 1 )
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - CreateD3DTexture", __FUNCTION__ );
pTexture->m_NumCopies = 1;
pD3DTex = CreateD3DTexture( width, height, depth, dstImageFormat, numMipLevels, creationFlags, (char*)pDebugName );
pTexture->SetTexture( pD3DTex );
}
else
{
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - CreateD3DTexture", __FUNCTION__ );
pTexture->m_NumCopies = numCopies;
{
// X360TEMP
// MEM_ALLOC_CREDIT();
pTexture->GetTextureArray() = new IDirect3DBaseTexture* [numCopies];
}
for (int k = 0; k < numCopies; ++k)
{
pD3DTex = CreateD3DTexture( width, height, depth, dstImageFormat, numMipLevels, creationFlags, (char*)pDebugName );
pTexture->SetTexture( k, pD3DTex );
}
}
pTexture->m_CurrentCopy = 0;
pD3DTex = CShaderAPIDx8::GetD3DTexture( pHandles[ idxFrame ] );
#if defined( _X360 )
if ( pD3DTex )
{
D3DSURFACE_DESC desc;
HRESULT hr;
if ( creationFlags & TEXTURE_CREATE_CUBEMAP )
{
hr = ((IDirect3DCubeTexture *)pD3DTex)->GetLevelDesc( 0, &desc );
}
else
{
hr = ((IDirect3DTexture *)pD3DTex)->GetLevelDesc( 0, &desc );
}
Assert( !FAILED( hr ) );
// for proper info get the actual format because the input format may have been redirected
dstImageFormat = ImageLoader::D3DFormatToImageFormat( desc.Format );
Assert( dstImageFormat != IMAGE_FORMAT_UNKNOWN );
// track linear or tiled
if ( !XGIsTiledFormat( desc.Format ) )
{
pTexture->m_Flags |= Texture_t::IS_LINEAR;
}
}
#endif
pTexture->SetImageFormat( dstImageFormat );
pTexture->m_UTexWrap = D3DTADDRESS_CLAMP;
pTexture->m_VTexWrap = D3DTADDRESS_CLAMP;
pTexture->m_WTexWrap = D3DTADDRESS_CLAMP;
if ( isRenderTarget )
{
#if !defined( _X360 )
if ( ( dstImageFormat == IMAGE_FORMAT_NV_INTZ ) || ( dstImageFormat == IMAGE_FORMAT_NV_RAWZ ) ||
( dstImageFormat == IMAGE_FORMAT_ATI_DST16 ) || ( dstImageFormat == IMAGE_FORMAT_ATI_DST24 ) )
{
pTexture->m_MinFilter = pTexture->m_MagFilter = D3DTEXF_POINT;
}
else
#endif
{
pTexture->m_MinFilter = pTexture->m_MagFilter = D3DTEXF_LINEAR;
}
pTexture->m_NumLevels = 1;
pTexture->m_MipFilter = D3DTEXF_NONE;
}
else
{
pTexture->m_NumLevels = pD3DTex ? pD3DTex->GetLevelCount() : 1;
pTexture->m_MipFilter = (pTexture->m_NumLevels != 1) ? D3DTEXF_LINEAR : D3DTEXF_NONE;
pTexture->m_MinFilter = pTexture->m_MagFilter = D3DTEXF_LINEAR;
}
pTexture->m_SwitchNeeded = false;
ComputeStatsInfo( pHandles[idxFrame], isCubeMap, (depth > 1) );
SetupTextureGroup( pHandles[idxFrame], pTextureGroupName );
}
}
void CShaderAPIDx8::SetupTextureGroup( ShaderAPITextureHandle_t hTexture, const char *pTextureGroupName )
{
Texture_t *pTexture = &GetTexture( hTexture );
Assert( !pTexture->m_pTextureGroupCounterGlobal );
// Setup the texture group stuff.
if ( pTextureGroupName && pTextureGroupName[0] != 0 )
{
pTexture->m_TextureGroupName = pTextureGroupName;
}
else
{
pTexture->m_TextureGroupName = TEXTURE_GROUP_UNACCOUNTED;
}
// 360 cannot vprof due to multicore loading until vprof is reentrant and these counters are real.
#if defined( VPROF_ENABLED ) && !defined( _X360 )
char counterName[256];
Q_snprintf( counterName, sizeof( counterName ), "TexGroup_global_%s", pTexture->m_TextureGroupName.String() );
pTexture->m_pTextureGroupCounterGlobal = g_VProfCurrentProfile.FindOrCreateCounter( counterName, COUNTER_GROUP_TEXTURE_GLOBAL );
Q_snprintf( counterName, sizeof( counterName ), "TexGroup_frame_%s", pTexture->m_TextureGroupName.String() );
pTexture->m_pTextureGroupCounterFrame = g_VProfCurrentProfile.FindOrCreateCounter( counterName, COUNTER_GROUP_TEXTURE_PER_FRAME );
#else
pTexture->m_pTextureGroupCounterGlobal = NULL;
pTexture->m_pTextureGroupCounterFrame = NULL;
#endif
if ( pTexture->m_pTextureGroupCounterGlobal )
{
*pTexture->m_pTextureGroupCounterGlobal += pTexture->GetMemUsage();
}
}
//-----------------------------------------------------------------------------
// Deletes a texture...
//-----------------------------------------------------------------------------
void CShaderAPIDx8::DeleteD3DTexture( ShaderAPITextureHandle_t hTexture )
{
int numDeallocated = 0;
Texture_t &texture = GetTexture( hTexture );
if ( texture.m_Flags & Texture_t::IS_DEPTH_STENCIL )
{
// garymcthack - need to make sure that playback knows how to deal with these.
RECORD_COMMAND( DX8_DESTROY_DEPTH_TEXTURE, 1 );
RECORD_INT( hTexture );
if ( texture.GetDepthStencilSurface() )
{
int nRetVal = texture.GetDepthStencilSurface()->Release();
Assert( nRetVal == 0 );
texture.GetDepthStencilSurface() = 0;
numDeallocated = 1;
}
else
{
// FIXME: we hit this on shutdown of HLMV on some machines
Assert( 0 );
}
}
else if ( texture.m_NumCopies == 1 )
{
if ( texture.GetTexture() )
{
RECORD_COMMAND( DX8_DESTROY_TEXTURE, 1 );
RECORD_INT( hTexture );
DestroyD3DTexture( texture.GetTexture() );
texture.SetTexture( 0 );
numDeallocated = 1;
}
}
else
{
if ( texture.GetTextureArray() )
{
RECORD_COMMAND( DX8_DESTROY_TEXTURE, 1 );
RECORD_INT( hTexture );
// Multiple copy texture
for (int j = 0; j < texture.m_NumCopies; ++j)
{
if (texture.GetTexture( j ))
{
DestroyD3DTexture( texture.GetTexture( j ) );
texture.SetTexture( j, 0 );
++numDeallocated;
}
}
delete [] texture.GetTextureArray();
texture.GetTextureArray() = 0;
}
}
texture.m_NumCopies = 0;
// Remove this texture from its global texture group counter.
if ( texture.m_pTextureGroupCounterGlobal )
{
*texture.m_pTextureGroupCounterGlobal -= texture.GetMemUsage();
Assert( *texture.m_pTextureGroupCounterGlobal >= 0 );
texture.m_pTextureGroupCounterGlobal = NULL;
}
// remove this texture from std textures
for( int i=0 ; i < ARRAYSIZE( m_StdTextureHandles ) ; i++ )
{
if ( m_StdTextureHandles[i] == hTexture )
m_StdTextureHandles[i] = INVALID_SHADERAPI_TEXTURE_HANDLE;
}
}
//-----------------------------------------------------------------------------
// Unbinds a texture from all texture stages
//-----------------------------------------------------------------------------
void CShaderAPIDx8::UnbindTexture( ShaderAPITextureHandle_t hTexture )
{
// Make sure no texture units are currently bound to it...
for ( int unit = 0; unit < g_pHardwareConfig->GetSamplerCount(); ++unit )
{
if ( hTexture == SamplerState( unit ).m_BoundTexture )
{
// Gotta set this here because INVALID_SHADERAPI_TEXTURE_HANDLE means don't actually
// set bound texture (it's used for disabling texturemapping)
SamplerState( unit ).m_BoundTexture = INVALID_SHADERAPI_TEXTURE_HANDLE;
SetTextureState( (Sampler_t)unit, INVALID_SHADERAPI_TEXTURE_HANDLE );
}
}
int nVertexTextureCount = g_pHardwareConfig->GetVertexTextureCount();
for ( int nSampler = 0; nSampler < nVertexTextureCount; ++nSampler )
{
if ( hTexture == m_DynamicState.m_VertexTextureState[ nSampler ].m_BoundTexture )
{
// Gotta set this here because INVALID_SHADERAPI_TEXTURE_HANDLE means don't actually
// set bound texture (it's used for disabling texturemapping)
BindVertexTexture( (VertexTextureSampler_t)nSampler, INVALID_SHADERAPI_TEXTURE_HANDLE );
}
}
}
//-----------------------------------------------------------------------------
// Deletes a texture...
//-----------------------------------------------------------------------------
void CShaderAPIDx8::DeleteTexture( ShaderAPITextureHandle_t textureHandle )
{
LOCK_SHADERAPI();
AssertValidTextureHandle( textureHandle );
if ( !TextureIsAllocated( textureHandle ) )
{
// already deallocated
return;
}
// Unbind it!
UnbindTexture( textureHandle );
// Delete it baby
DeleteD3DTexture( textureHandle );
// Now remove the texture from the list
// Mark as deallocated so that it can be reused.
GetTexture( textureHandle ).m_Flags = 0;
}
void CShaderAPIDx8::WriteTextureToFile( ShaderAPITextureHandle_t hTexture, const char *szFileName )
{
Texture_t *pTexInt = &GetTexture( hTexture );
//Assert( pTexInt->IsCubeMap() == false );
//Assert( pTexInt->IsVolumeTexture() == false );
IDirect3DTexture *pD3DTexture = (IDirect3DTexture *)pTexInt->GetTexture();
// Get the level of the texture we want to read from
IDirect3DSurface* pTextureLevel;
HRESULT hr = pD3DTexture ->GetSurfaceLevel( 0, &pTextureLevel );
if ( FAILED( hr ) )
return;
D3DSURFACE_DESC surfaceDesc;
pD3DTexture->GetLevelDesc( 0, &surfaceDesc );
D3DLOCKED_RECT lockedRect;
//if( pTexInt->m_Flags & Texture_t::IS_RENDER_TARGET )
#if !defined( _X360 ) //TODO: x360 version
{
//render targets can't be locked, luckily we can copy the surface to system memory and lock that.
IDirect3DSurface *pSystemSurface;
Assert( !IsX360() );
hr = Dx9Device()->CreateOffscreenPlainSurface( surfaceDesc.Width, surfaceDesc.Height, surfaceDesc.Format, D3DPOOL_SYSTEMMEM, &pSystemSurface, NULL );
Assert( SUCCEEDED( hr ) );
pSystemSurface->GetDesc( &surfaceDesc );
hr = Dx9Device()->GetRenderTargetData( pTextureLevel, pSystemSurface );
Assert( SUCCEEDED( hr ) );
//pretend this is the texture level we originally grabbed with GetSurfaceLevel() and continue on
pTextureLevel->Release();
pTextureLevel = pSystemSurface;
}
#endif
// lock the region
if ( FAILED( pTextureLevel->LockRect( &lockedRect, NULL, D3DLOCK_READONLY ) ) )
{
Assert( 0 );
pTextureLevel->Release();
return;
}
TGAWriter::WriteTGAFile( szFileName, surfaceDesc.Width, surfaceDesc.Height, pTexInt->GetImageFormat(), (const uint8 *)lockedRect.pBits, lockedRect.Pitch );
if ( FAILED( pTextureLevel->UnlockRect() ) )
{
Assert( 0 );
pTextureLevel->Release();
return;
}
pTextureLevel->Release();
}
//-----------------------------------------------------------------------------
// Releases all textures
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ReleaseAllTextures()
{
ClearStdTextureHandles();
ShaderAPITextureHandle_t hTexture;
for ( hTexture = m_Textures.Head(); hTexture != m_Textures.InvalidIndex(); hTexture = m_Textures.Next( hTexture ) )
{
if ( TextureIsAllocated( hTexture ) )
{
// Delete it baby
DeleteD3DTexture( hTexture );
}
}
// Make sure all texture units are pointing to nothing
for (int unit = 0; unit < g_pHardwareConfig->GetSamplerCount(); ++unit )
{
SamplerState( unit ).m_BoundTexture = INVALID_SHADERAPI_TEXTURE_HANDLE;
SetTextureState( (Sampler_t)unit, INVALID_SHADERAPI_TEXTURE_HANDLE );
}
}
void CShaderAPIDx8::DeleteAllTextures()
{
ReleaseAllTextures();
m_Textures.Purge();
}
bool CShaderAPIDx8::IsTexture( ShaderAPITextureHandle_t textureHandle )
{
LOCK_SHADERAPI();
if ( !TextureIsAllocated( textureHandle ) )
{
return false;
}
#if !defined( _X360 )
if ( GetTexture( textureHandle ).m_Flags & Texture_t::IS_DEPTH_STENCIL )
{
return GetTexture( textureHandle ).GetDepthStencilSurface() != 0;
}
else if ( ( GetTexture( textureHandle ).m_NumCopies == 1 && GetTexture( textureHandle ).GetTexture() != 0 ) ||
( GetTexture( textureHandle ).m_NumCopies > 1 && GetTexture( textureHandle ).GetTexture( 0 ) != 0 ) )
{
return true;
}
else
{
return false;
}
#else
// query is about texture handle validity, not presence
// texture handle is allocated, texture may or may not be present
return true;
#endif
}
//-----------------------------------------------------------------------------
// Gets the surface associated with a texture (refcount of surface is increased)
//-----------------------------------------------------------------------------
IDirect3DSurface* CShaderAPIDx8::GetTextureSurface( ShaderAPITextureHandle_t textureHandle )
{
MEM_ALLOC_D3D_CREDIT();
IDirect3DSurface* pSurface;
// We'll be modifying this sucka
AssertValidTextureHandle( textureHandle );
Texture_t &tex = GetTexture( textureHandle );
if ( !( tex.m_Flags & Texture_t::IS_ALLOCATED ) )
{
return NULL;
}
if ( IsX360() && ( tex.m_Flags & Texture_t::IS_RENDER_TARGET_SURFACE ) )
{
pSurface = tex.GetRenderTargetSurface( false );
#if POSIX
// dxabstract's AddRef/Release have optional args to help track usage
pSurface->AddRef( 0, "CShaderAPIDx8::GetTextureSurface public addref");
#else
pSurface->AddRef();
#endif
return pSurface;
}
IDirect3DBaseTexture* pD3DTex = CShaderAPIDx8::GetD3DTexture( textureHandle );
IDirect3DTexture* pTex = static_cast<IDirect3DTexture*>( pD3DTex );
Assert( pTex );
if ( !pTex )
{
return NULL;
}
HRESULT hr = pTex->GetSurfaceLevel( 0, &pSurface );
Assert( hr == D3D_OK );
return pSurface;
}
//-----------------------------------------------------------------------------
// Gets the surface associated with a texture (refcount of surface is increased)
//-----------------------------------------------------------------------------
IDirect3DSurface* CShaderAPIDx8::GetDepthTextureSurface( ShaderAPITextureHandle_t textureHandle )
{
AssertValidTextureHandle( textureHandle );
if ( !TextureIsAllocated( textureHandle ) )
{
return NULL;
}
return GetTexture( textureHandle ).GetDepthStencilSurface();
}
//-----------------------------------------------------------------------------
// Changes the render target
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetRenderTargetEx( int nRenderTargetID, ShaderAPITextureHandle_t colorTextureHandle, ShaderAPITextureHandle_t depthTextureHandle )
{
LOCK_SHADERAPI();
if ( IsDeactivated( ) )
{
return;
}
// GR - need to flush batched geometry
FlushBufferedPrimitives();
#if defined( PIX_INSTRUMENTATION )
{
const char *pRT = "Backbuffer";
const char *pDS = "DefaultDepthStencil";
if ( colorTextureHandle == SHADER_RENDERTARGET_NONE )
{
pRT = "None";
}
else if ( colorTextureHandle != SHADER_RENDERTARGET_BACKBUFFER )
{
Texture_t &tex = GetTexture( colorTextureHandle );
pRT = tex.m_DebugName.String();
}
if ( depthTextureHandle == SHADER_RENDERTARGET_NONE )
{
pDS = "None";
}
else if ( depthTextureHandle != SHADER_RENDERTARGET_DEPTHBUFFER )
{
Texture_t &tex = GetTexture( depthTextureHandle );
pDS = tex.m_DebugName.String();
}
char buf[256];
sprintf( buf, "SRT:%s %s", pRT ? pRT : "?", pDS ? pDS : "?" );
BeginPIXEvent( 0xFFFFFFFF, buf );
EndPIXEvent();
}
#endif
#if !defined( _X360 )
RECORD_COMMAND( DX8_TEST_COOPERATIVE_LEVEL, 0 );
HRESULT hr = Dx9Device()->TestCooperativeLevel();
if ( hr != D3D_OK )
{
MarkDeviceLost();
return;
}
#endif
IDirect3DSurface* pColorSurface = NULL;
IDirect3DSurface* pZSurface = NULL;
RECORD_COMMAND( DX8_SET_RENDER_TARGET, 3 );
RECORD_INT( nRenderTargetID );
RECORD_INT( colorTextureHandle );
RECORD_INT( depthTextureHandle );
// The 0th render target defines which depth buffer we are using, so
// don't bother if we are another render target
if ( nRenderTargetID > 0 )
{
depthTextureHandle = SHADER_RENDERTARGET_NONE;
}
// NOTE!!!! If this code changes, also change Dx8SetRenderTarget in playback.cpp
bool usingTextureTarget = false;
if ( colorTextureHandle == SHADER_RENDERTARGET_BACKBUFFER )
{
pColorSurface = m_pBackBufferSurface;
#ifdef ENABLE_NULLREF_DEVICE_SUPPORT
if( pColorSurface )
#endif
{
// This is just to make the code a little simpler...
// (simplifies the release logic)
#if POSIX
// dxabstract's AddRef/Release have optional args to help track usage
pColorSurface->AddRef( 0, "+C CShaderAPIDx8::SetRenderTargetEx public addref 1");
#else
pColorSurface->AddRef();
#endif
}
}
else
{
// get the texture (Refcount increases)
UnbindTexture( colorTextureHandle );
pColorSurface = GetTextureSurface( colorTextureHandle );
if ( !pColorSurface )
{
return;
}
usingTextureTarget = true;
}
if ( depthTextureHandle == SHADER_RENDERTARGET_DEPTHBUFFER )
{
// using the default depth buffer
pZSurface = m_pZBufferSurface;
#ifdef ENABLE_NULLREF_DEVICE_SUPPORT
if( pZSurface )
#endif
{
// simplify the prologue logic
#if POSIX
// dxabstract's AddRef/Release have optional args to help track usage
pZSurface->AddRef( 0, "+D CShaderAPIDx8::SetRenderTargetEx public addref 1");
#else
pZSurface->AddRef();
#endif
}
}
else if ( depthTextureHandle == SHADER_RENDERTARGET_NONE )
{
// GR - disable depth buffer
pZSurface = NULL;
}
else
{
UnbindTexture( depthTextureHandle );
Texture_t &tex = GetTexture( depthTextureHandle );
//Cannot use a depth/stencil surface derived from a texture.
//Asserting helps get the whole call stack instead of letting the 360 report an error with a partial stack
Assert( !( IsX360() && (tex.m_Flags & Texture_t::IS_DEPTH_STENCIL_TEXTURE) ) );
if ( tex.m_Flags & Texture_t::IS_DEPTH_STENCIL )
{
pZSurface = GetDepthTextureSurface( depthTextureHandle );
if ( pZSurface )
{
#if POSIX
// dxabstract's AddRef/Release have optional args to help track usage
pZSurface->AddRef( 0, "+D CShaderAPIDx8::SetRenderTargetEx public addref 2");
#else
pZSurface->AddRef();
#endif
}
}
else
{
HRESULT hr = ((IDirect3DTexture9*)tex.GetTexture())->GetSurfaceLevel( 0, &pZSurface );
}
if ( !pZSurface )
{
// Refcount of color surface was increased above
#if POSIX
// dxabstract's AddRef/Release have optional args to help track usage
pColorSurface->Release( 0, "-C CShaderAPIDx8::SetRenderTargetEx public release 1" );
#else
pColorSurface->Release();
#endif
return;
}
usingTextureTarget = true;
}
#ifdef _DEBUG
if ( pZSurface )
{
D3DSURFACE_DESC zSurfaceDesc, colorSurfaceDesc;
pZSurface->GetDesc( &zSurfaceDesc );
pColorSurface->GetDesc( &colorSurfaceDesc );
if ( !HushAsserts() )
{
Assert( colorSurfaceDesc.Width <= zSurfaceDesc.Width );
Assert( colorSurfaceDesc.Height <= zSurfaceDesc.Height );
}
}
#endif
// we only set this flag for the 0th render target so that NULL
// render targets 1-3 don't mess with the viewport on the main RT
if( nRenderTargetID == 0 )
m_UsingTextureRenderTarget = usingTextureTarget;
// NOTE: The documentation says that SetRenderTarget increases the refcount
// but it doesn't appear to in practice. If this somehow changes (perhaps
// in a device-specific manner, we're in trouble).
if ( IsPC() || !IsX360() )
{
if ( pColorSurface == m_pBackBufferSurface && nRenderTargetID > 0 )
{
// SetRenderTargetEx is overloaded so that if you pass NULL in for anything that
// isn't the zeroth render target, you effectively disable that MRT index.
// (Passing in NULL for the zeroth render target means that you want to use the backbuffer
// as the render target.)
// hack hack hack!!!!! If the render target id > 0 and the user passed in NULL, disable the render target
Dx9Device()->SetRenderTarget( nRenderTargetID, NULL );
}
else
{
Dx9Device()->SetRenderTarget( nRenderTargetID, pColorSurface );
}
}
else
{
Assert( nRenderTargetID == 0 );
SetRenderTargetInternalXbox( colorTextureHandle );
}
// The 0th render target defines which depth buffer we are using, so
// don't bother if we are another render target
if ( nRenderTargetID == 0 )
{
Dx9Device()->SetDepthStencilSurface( pZSurface );
}
// The 0th render target defines the viewport, therefore it also defines
// the viewport limits.
if ( m_UsingTextureRenderTarget && nRenderTargetID == 0 )
{
D3DSURFACE_DESC desc;
HRESULT hr;
if ( !pZSurface )
{
hr = pColorSurface->GetDesc( &desc );
}
else
{
hr = pZSurface->GetDesc( &desc );
}
Assert( !FAILED(hr) );
m_ViewportMaxWidth = desc.Width;
m_ViewportMaxHeight = desc.Height;
}
static bool assert_on_refzero = false;
int ref;
if ( pZSurface )
{
#if POSIX
ref = pZSurface->Release( 0, "-D CShaderAPIDx8::SetRenderTargetEx public release (z surface)");
#else
ref = pZSurface->Release();
#endif
if(assert_on_refzero)
{
Assert( ref != 0 );
}
}
#ifdef ENABLE_NULLREF_DEVICE_SUPPORT
if( pColorSurface )
#endif
{
#if POSIX
ref = pColorSurface->Release( 0, "-C CShaderAPIDx8::SetRenderTargetEx public release (color surface)");
#else
ref = pColorSurface->Release();
#endif
if(assert_on_refzero)
{
Assert( ref != 0 );
}
}
// Changing the render target sets a default viewport. Force rewrite to preserve the current desired state.
m_DynamicState.m_Viewport.X = 0;
m_DynamicState.m_Viewport.Y = 0;
m_DynamicState.m_Viewport.Width = (DWORD)-1;
m_DynamicState.m_Viewport.Height = (DWORD)-1;
ADD_COMMIT_FUNC( COMMIT_PER_DRAW, COMMIT_ALWAYS, CommitSetViewports );
}
//-----------------------------------------------------------------------------
// Changes the render target
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetRenderTarget( ShaderAPITextureHandle_t colorTextureHandle, ShaderAPITextureHandle_t depthTextureHandle )
{
LOCK_SHADERAPI();
SetRenderTargetEx( 0, colorTextureHandle, depthTextureHandle );
}
//-----------------------------------------------------------------------------
// Returns the nearest supported format
//-----------------------------------------------------------------------------
ImageFormat CShaderAPIDx8::GetNearestSupportedFormat( ImageFormat fmt, bool bFilteringRequired /* = true */ ) const
{
return FindNearestSupportedFormat( fmt, false, false, bFilteringRequired );
}
ImageFormat CShaderAPIDx8::GetNearestRenderTargetFormat( ImageFormat fmt ) const
{
return FindNearestSupportedFormat( fmt, false, true, false );
}
bool CShaderAPIDx8::DoRenderTargetsNeedSeparateDepthBuffer() const
{
LOCK_SHADERAPI();
return m_PresentParameters.MultiSampleType != D3DMULTISAMPLE_NONE;
}
//-----------------------------------------------------------------------------
// Indicates we're modifying a texture
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ModifyTexture( ShaderAPITextureHandle_t textureHandle )
{
tmZone( TELEMETRY_LEVEL2, TMZF_NONE, "%s", __FUNCTION__ );
LOCK_SHADERAPI();
// Can't do this if we're locked!
Assert( m_ModifyTextureLockedLevel < 0 );
AssertValidTextureHandle( textureHandle );
m_ModifyTextureHandle = textureHandle;
// If we're got a multi-copy texture, we need to up the current copy count
Texture_t& tex = GetTexture( textureHandle );
if (tex.m_NumCopies > 1)
{
// Each time we modify a texture, we'll want to switch texture
// as soon as a TexImage2D call is made...
tex.m_SwitchNeeded = true;
}
}
//-----------------------------------------------------------------------------
// Advances the current copy of a texture...
//-----------------------------------------------------------------------------
void CShaderAPIDx8::AdvanceCurrentCopy( ShaderAPITextureHandle_t hTexture )
{
// May need to switch textures....
Texture_t& tex = GetTexture( hTexture );
if (tex.m_NumCopies > 1)
{
if (++tex.m_CurrentCopy >= tex.m_NumCopies)
tex.m_CurrentCopy = 0;
// When the current copy changes, we need to make sure this texture
// isn't bound to any stages any more; thereby guaranteeing the new
// copy will be re-bound.
UnbindTexture( hTexture );
}
}
//-----------------------------------------------------------------------------
// Locks, unlocks the current texture
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::TexLock( int level, int cubeFaceID, int xOffset, int yOffset,
int width, int height, CPixelWriter& writer )
{
tmZone( TELEMETRY_LEVEL2, TMZF_NONE, "%s", __FUNCTION__ );
LOCK_SHADERAPI();
Assert( m_ModifyTextureLockedLevel < 0 );
ShaderAPITextureHandle_t hTexture = GetModifyTextureHandle();
if ( !m_Textures.IsValidIndex( hTexture ) )
return false;
// Blow off mip levels if we don't support mipmapping
if ( !g_pHardwareConfig->SupportsMipmapping() && ( level > 0 ) )
return false;
// This test here just makes sure we don't try to download mipmap levels
// if we weren't able to create them in the first place
Texture_t& tex = GetTexture( hTexture );
if ( level >= tex.m_NumLevels )
{
return false;
}
// May need to switch textures....
if ( tex.m_SwitchNeeded )
{
AdvanceCurrentCopy( hTexture );
tex.m_SwitchNeeded = false;
}
IDirect3DBaseTexture *pTexture = GetModifyTexture();
#if defined( _X360 )
// 360 can't lock a bound texture
if ( pTexture->IsSet( Dx9Device() ) )
{
UnbindTexture( hTexture );
}
#endif
bool bOK = LockTexture( hTexture, tex.m_CurrentCopy, pTexture,
level, (D3DCUBEMAP_FACES)cubeFaceID, xOffset, yOffset, width, height, false, writer );
if ( bOK )
{
m_ModifyTextureLockedLevel = level;
m_ModifyTextureLockedFace = cubeFaceID;
}
return bOK;
}
void CShaderAPIDx8::TexUnlock( )
{
tmZone( TELEMETRY_LEVEL2, TMZF_NONE, "%s", __FUNCTION__ );
LOCK_SHADERAPI();
if ( m_ModifyTextureLockedLevel >= 0 )
{
Texture_t& tex = GetTexture( GetModifyTextureHandle() );
UnlockTexture( GetModifyTextureHandle(), tex.m_CurrentCopy, GetModifyTexture(),
m_ModifyTextureLockedLevel, (D3DCUBEMAP_FACES)m_ModifyTextureLockedFace );
m_ModifyTextureLockedLevel = -1;
}
}
//-----------------------------------------------------------------------------
// Texture image upload
//-----------------------------------------------------------------------------
void CShaderAPIDx8::TexImage2D(
int level,
int cubeFaceID,
ImageFormat dstFormat,
int z,
int width,
int height,
ImageFormat srcFormat,
bool bSrcIsTiled,
void *pSrcData )
{
LOCK_SHADERAPI();
Assert( pSrcData );
AssertValidTextureHandle( GetModifyTextureHandle() );
if ( !m_Textures.IsValidIndex( GetModifyTextureHandle() ) )
{
return;
}
Assert( (width <= g_pHardwareConfig->Caps().m_MaxTextureWidth) && (height <= g_pHardwareConfig->Caps().m_MaxTextureHeight) );
// Blow off mip levels if we don't support mipmapping
if ( !g_pHardwareConfig->SupportsMipmapping() && (level > 0))
{
return;
}
// This test here just makes sure we don't try to download mipmap levels
// if we weren't able to create them in the first place
Texture_t& tex = GetTexture( GetModifyTextureHandle() );
if ( level >= tex.m_NumLevels )
{
return;
}
// May need to switch textures....
if (tex.m_SwitchNeeded)
{
AdvanceCurrentCopy( GetModifyTextureHandle() );
tex.m_SwitchNeeded = false;
}
TextureLoadInfo_t info;
info.m_TextureHandle = GetModifyTextureHandle();
info.m_pTexture = GetModifyTexture();
info.m_nLevel = level;
info.m_nCopy = tex.m_CurrentCopy;
info.m_CubeFaceID = (D3DCUBEMAP_FACES)cubeFaceID;
info.m_nWidth = width;
info.m_nHeight = height;
info.m_nZOffset = z;
info.m_SrcFormat = srcFormat;
info.m_pSrcData = (unsigned char *)pSrcData;
#if defined( _X360 )
info.m_bSrcIsTiled = bSrcIsTiled;
info.m_bCanConvertFormat = ( tex.m_Flags & Texture_t::CAN_CONVERT_FORMAT ) != 0;
#else
info.m_bTextureIsLockable = ( tex.m_Flags & Texture_t::IS_LOCKABLE ) != 0;
#endif
LoadTexture( info );
SetModifyTexture( info.m_pTexture );
}
//-----------------------------------------------------------------------------
// Upload to a sub-piece of a texture
//-----------------------------------------------------------------------------
void CShaderAPIDx8::TexSubImage2D(
int level,
int cubeFaceID,
int xOffset,
int yOffset,
int zOffset,
int width,
int height,
ImageFormat srcFormat,
int srcStride,
bool bSrcIsTiled,
void *pSrcData )
{
LOCK_SHADERAPI();
Assert( pSrcData );
AssertValidTextureHandle( GetModifyTextureHandle() );
if ( !m_Textures.IsValidIndex( GetModifyTextureHandle() ) )
{
return;
}
// Blow off mip levels if we don't support mipmapping
if ( !g_pHardwareConfig->SupportsMipmapping() && ( level > 0 ) )
{
return;
}
// NOTE: This can only be done with procedural textures if this method is
// being used to download the entire texture, cause last frame's partial update
// may be in a completely different texture! Sadly, I don't have all of the
// information I need, but I can at least check a couple things....
#ifdef _DEBUG
if ( GetTexture( GetModifyTextureHandle() ).m_NumCopies > 1 )
{
Assert( (xOffset == 0) && (yOffset == 0) );
}
#endif
// This test here just makes sure we don't try to download mipmap levels
// if we weren't able to create them in the first place
Texture_t& tex = GetTexture( GetModifyTextureHandle() );
if ( level >= tex.m_NumLevels )
{
return;
}
// May need to switch textures....
if ( tex.m_SwitchNeeded )
{
AdvanceCurrentCopy( GetModifyTextureHandle() );
tex.m_SwitchNeeded = false;
}
TextureLoadInfo_t info;
info.m_TextureHandle = GetModifyTextureHandle();
info.m_pTexture = GetModifyTexture();
info.m_nLevel = level;
info.m_nCopy = tex.m_CurrentCopy;
info.m_CubeFaceID = (D3DCUBEMAP_FACES)cubeFaceID;
info.m_nWidth = width;
info.m_nHeight = height;
info.m_nZOffset = zOffset;
info.m_SrcFormat = srcFormat;
info.m_pSrcData = (unsigned char *)pSrcData;
#if defined( _X360 )
info.m_bSrcIsTiled = bSrcIsTiled;
info.m_bCanConvertFormat = ( tex.m_Flags & Texture_t::CAN_CONVERT_FORMAT ) != 0;
#else
info.m_bTextureIsLockable = ( tex.m_Flags & Texture_t::IS_LOCKABLE ) != 0;
#endif
LoadSubTexture( info, xOffset, yOffset, srcStride );
}
//-----------------------------------------------------------------------------
// Volume texture upload
//-----------------------------------------------------------------------------
void CShaderAPIDx8::TexImageFromVTF( IVTFTexture *pVTF, int iVTFFrame )
{
LOCK_SHADERAPI();
Assert( pVTF );
AssertValidTextureHandle( GetModifyTextureHandle() );
if ( !m_Textures.IsValidIndex( GetModifyTextureHandle() ) )
{
return;
}
Texture_t& tex = GetTexture( GetModifyTextureHandle() );
// May need to switch textures....
if (tex.m_SwitchNeeded)
{
AdvanceCurrentCopy( GetModifyTextureHandle() );
tex.m_SwitchNeeded = false;
}
TextureLoadInfo_t info;
info.m_TextureHandle = GetModifyTextureHandle();
info.m_pTexture = GetModifyTexture();
info.m_nLevel = 0;
info.m_nCopy = tex.m_CurrentCopy;
info.m_CubeFaceID = (D3DCUBEMAP_FACES)0;
info.m_nWidth = 0;
info.m_nHeight = 0;
info.m_nZOffset = 0;
info.m_SrcFormat = pVTF->Format();
info.m_pSrcData = NULL;
#if defined( _X360 )
info.m_bSrcIsTiled = pVTF->IsPreTiled();
info.m_bCanConvertFormat = ( tex.m_Flags & Texture_t::CAN_CONVERT_FORMAT ) != 0;
#else
info.m_bTextureIsLockable = ( tex.m_Flags & Texture_t::IS_LOCKABLE ) != 0;
#endif
if ( pVTF->Depth() > 1 )
{
LoadVolumeTextureFromVTF( info, pVTF, iVTFFrame );
}
else if ( pVTF->IsCubeMap() )
{
if ( HardwareConfig()->SupportsCubeMaps() )
{
LoadCubeTextureFromVTF( info, pVTF, iVTFFrame );
}
else
{
info.m_CubeFaceID = (D3DCUBEMAP_FACES)6;
LoadTextureFromVTF( info, pVTF, iVTFFrame );
}
}
else
{
LoadTextureFromVTF( info, pVTF, iVTFFrame );
}
SetModifyTexture( info.m_pTexture );
}
//-----------------------------------------------------------------------------
// Is the texture resident?
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::IsTextureResident( ShaderAPITextureHandle_t textureHandle )
{
return true;
}
//-----------------------------------------------------------------------------
// Level of anisotropic filtering
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetAnisotropicLevel( int nAnisotropyLevel )
{
LOCK_SHADERAPI();
// NOTE: This must be called before the rest of the code in this function so
// anisotropic can be set per-texture to force it on! This will also avoid
// a possible infinite loop that existed before.
g_pShaderUtil->NoteAnisotropicLevel( nAnisotropyLevel );
// Never set this to 1. In the case we want it set to 1, we will use this to override
// aniso per-texture, so set it to something reasonable
if ( nAnisotropyLevel > g_pHardwareConfig->Caps().m_nMaxAnisotropy || nAnisotropyLevel <= 1 )
{
// Set it to 1/4 the max but between 2-8
nAnisotropyLevel = max( 2, min( 8, ( g_pHardwareConfig->Caps().m_nMaxAnisotropy / 4 ) ) );
}
// Set the D3D max insotropy state for all samplers
for ( int i = 0; i < g_pHardwareConfig->Caps().m_NumSamplers; ++i)
{
SamplerState(i).m_nAnisotropicLevel = nAnisotropyLevel;
SetSamplerState( i, D3DSAMP_MAXANISOTROPY, SamplerState(i).m_nAnisotropicLevel );
}
}
//-----------------------------------------------------------------------------
// Sets the priority
//-----------------------------------------------------------------------------
void CShaderAPIDx8::TexSetPriority( int priority )
{
#if !defined( _X360 )
LOCK_SHADERAPI();
// A hint to the cacher...
ShaderAPITextureHandle_t hModifyTexture = GetModifyTextureHandle();
if ( hModifyTexture == INVALID_SHADERAPI_TEXTURE_HANDLE )
return;
Texture_t& tex = GetTexture( hModifyTexture );
if ( tex.m_NumCopies > 1 )
{
for (int i = 0; i < tex.m_NumCopies; ++i)
tex.GetTexture( i )->SetPriority( priority );
}
else
{
tex.GetTexture()->SetPriority( priority );
}
#endif
}
void CShaderAPIDx8::TexLodClamp( int finest )
{
LOCK_SHADERAPI();
ShaderAPITextureHandle_t hModifyTexture = GetModifyTextureHandle();
if ( hModifyTexture == INVALID_SHADERAPI_TEXTURE_HANDLE )
return;
Texture_t& tex = GetTexture( hModifyTexture );
tex.m_FinestMipmapLevel = finest;
}
void CShaderAPIDx8::TexLodBias( float bias )
{
LOCK_SHADERAPI();
ShaderAPITextureHandle_t hModifyTexture = GetModifyTextureHandle();
if ( hModifyTexture == INVALID_SHADERAPI_TEXTURE_HANDLE )
return;
Texture_t& tex = GetTexture( hModifyTexture );
tex.m_LodBias = bias;
}
//-----------------------------------------------------------------------------
// Texturemapping state
//-----------------------------------------------------------------------------
void CShaderAPIDx8::TexWrap( ShaderTexCoordComponent_t coord, ShaderTexWrapMode_t wrapMode )
{
LOCK_SHADERAPI();
ShaderAPITextureHandle_t hModifyTexture = GetModifyTextureHandle();
if ( hModifyTexture == INVALID_SHADERAPI_TEXTURE_HANDLE )
return;
D3DTEXTUREADDRESS address;
switch( wrapMode )
{
case SHADER_TEXWRAPMODE_CLAMP:
address = D3DTADDRESS_CLAMP;
break;
case SHADER_TEXWRAPMODE_REPEAT:
address = D3DTADDRESS_WRAP;
break;
case SHADER_TEXWRAPMODE_BORDER:
address = D3DTADDRESS_BORDER;
break;
default:
address = D3DTADDRESS_CLAMP;
Warning( "CShaderAPIDx8::TexWrap: unknown wrapMode\n" );
break;
}
switch( coord )
{
case SHADER_TEXCOORD_S:
GetTexture( hModifyTexture ).m_UTexWrap = address;
break;
case SHADER_TEXCOORD_T:
GetTexture( hModifyTexture ).m_VTexWrap = address;
break;
case SHADER_TEXCOORD_U:
GetTexture( hModifyTexture ).m_WTexWrap = address;
break;
default:
Warning( "CShaderAPIDx8::TexWrap: unknown coord\n" );
break;
}
}
void CShaderAPIDx8::TexMinFilter( ShaderTexFilterMode_t texFilterMode )
{
LOCK_SHADERAPI();
ShaderAPITextureHandle_t hModifyTexture = GetModifyTextureHandle();
if ( hModifyTexture == INVALID_SHADERAPI_TEXTURE_HANDLE )
return;
switch( texFilterMode )
{
case SHADER_TEXFILTERMODE_NEAREST:
GetTexture( hModifyTexture ).m_MinFilter = D3DTEXF_POINT;
GetTexture( hModifyTexture ).m_MipFilter = D3DTEXF_NONE;
break;
case SHADER_TEXFILTERMODE_LINEAR:
GetTexture( hModifyTexture ).m_MinFilter = D3DTEXF_LINEAR;
GetTexture( hModifyTexture ).m_MipFilter = D3DTEXF_NONE;
break;
case SHADER_TEXFILTERMODE_NEAREST_MIPMAP_NEAREST:
GetTexture( hModifyTexture ).m_MinFilter = D3DTEXF_POINT;
GetTexture( hModifyTexture ).m_MipFilter =
GetTexture( hModifyTexture ).m_NumLevels != 1 ? D3DTEXF_POINT : D3DTEXF_NONE;
break;
case SHADER_TEXFILTERMODE_LINEAR_MIPMAP_NEAREST:
GetTexture( hModifyTexture ).m_MinFilter = D3DTEXF_LINEAR;
GetTexture( hModifyTexture ).m_MipFilter =
GetTexture( hModifyTexture ).m_NumLevels != 1 ? D3DTEXF_POINT : D3DTEXF_NONE;
break;
case SHADER_TEXFILTERMODE_NEAREST_MIPMAP_LINEAR:
GetTexture( hModifyTexture ).m_MinFilter = D3DTEXF_POINT;
GetTexture( hModifyTexture ).m_MipFilter =
GetTexture( hModifyTexture ).m_NumLevels != 1 ? D3DTEXF_LINEAR : D3DTEXF_NONE;
break;
case SHADER_TEXFILTERMODE_LINEAR_MIPMAP_LINEAR:
GetTexture( hModifyTexture ).m_MinFilter = D3DTEXF_LINEAR;
GetTexture( hModifyTexture ).m_MipFilter =
GetTexture( hModifyTexture ).m_NumLevels != 1 ? D3DTEXF_LINEAR : D3DTEXF_NONE;
break;
case SHADER_TEXFILTERMODE_ANISOTROPIC:
GetTexture( hModifyTexture ).m_MinFilter = D3DTEXF_ANISOTROPIC;
GetTexture( hModifyTexture ).m_MipFilter =
GetTexture( hModifyTexture ).m_NumLevels != 1 ? D3DTEXF_LINEAR : D3DTEXF_NONE;
break;
default:
Warning( "CShaderAPIDx8::TexMinFilter: Unknown texFilterMode\n" );
break;
}
}
void CShaderAPIDx8::TexMagFilter( ShaderTexFilterMode_t texFilterMode )
{
LOCK_SHADERAPI();
ShaderAPITextureHandle_t hModifyTexture = GetModifyTextureHandle();
if ( hModifyTexture == INVALID_SHADERAPI_TEXTURE_HANDLE )
return;
switch( texFilterMode )
{
case SHADER_TEXFILTERMODE_NEAREST:
GetTexture( hModifyTexture ).m_MagFilter = D3DTEXF_POINT;
break;
case SHADER_TEXFILTERMODE_LINEAR:
GetTexture( hModifyTexture ).m_MagFilter = D3DTEXF_LINEAR;
break;
case SHADER_TEXFILTERMODE_NEAREST_MIPMAP_NEAREST:
Warning( "CShaderAPIDx8::TexMagFilter: SHADER_TEXFILTERMODE_NEAREST_MIPMAP_NEAREST is invalid\n" );
break;
case SHADER_TEXFILTERMODE_LINEAR_MIPMAP_NEAREST:
Warning( "CShaderAPIDx8::TexMagFilter: SHADER_TEXFILTERMODE_LINEAR_MIPMAP_NEAREST is invalid\n" );
break;
case SHADER_TEXFILTERMODE_NEAREST_MIPMAP_LINEAR:
Warning( "CShaderAPIDx8::TexMagFilter: SHADER_TEXFILTERMODE_NEAREST_MIPMAP_LINEAR is invalid\n" );
break;
case SHADER_TEXFILTERMODE_LINEAR_MIPMAP_LINEAR:
Warning( "CShaderAPIDx8::TexMagFilter: SHADER_TEXFILTERMODE_LINEAR_MIPMAP_LINEAR is invalid\n" );
break;
case SHADER_TEXFILTERMODE_ANISOTROPIC:
GetTexture( hModifyTexture ).m_MagFilter = g_pHardwareConfig->Caps().m_bSupportsMagAnisotropicFiltering ? D3DTEXF_ANISOTROPIC : D3DTEXF_LINEAR;
break;
default:
Warning( "CShaderAPIDx8::TexMAGFilter: Unknown texFilterMode\n" );
break;
}
}
//-----------------------------------------------------------------------------
// Gets the matrix stack from the matrix mode
//-----------------------------------------------------------------------------
int CShaderAPIDx8::GetMatrixStack( MaterialMatrixMode_t mode ) const
{
Assert( mode >= 0 && mode < NUM_MATRIX_MODES );
return mode;
}
//-----------------------------------------------------------------------------
// Returns true if we're modulating constant color into the vertex color
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::IsModulatingVertexColor() const
{
return m_TransitionTable.CurrentShadowShaderState()->m_ModulateConstantColor;
}
//-----------------------------------------------------------------------------
// Material property (used to deal with overbright for lights)
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetDefaultMaterial()
{
#if !defined( _X360 )
D3DMATERIAL mat;
mat.Diffuse.r = mat.Diffuse.g = mat.Diffuse.b = mat.Diffuse.a = 1.0f;
mat.Ambient.r = mat.Ambient.g = mat.Ambient.b = mat.Ambient.a = 0.0f;
mat.Specular.r = mat.Specular.g = mat.Specular.b = mat.Specular.a = 0.0f;
mat.Emissive.r = mat.Emissive.g = mat.Emissive.b = mat.Emissive.a = 0.0f;
mat.Power = 1.0f;
Dx9Device()->SetMaterial( &mat );
#endif
}
//-----------------------------------------------------------------------------
// lighting related methods
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetAmbientLight( float r, float g, float b )
{
LOCK_SHADERAPI();
unsigned int ambient = D3DCOLOR_ARGB( 255, (int)(r * 255),
(int)(g * 255), (int)(b * 255) );
if (ambient != m_DynamicState.m_Ambient)
{
m_DynamicState.m_Ambient = ambient;
SetSupportedRenderState( D3DRS_AMBIENT, ambient );
}
}
void CShaderAPIDx8::SetLightingOrigin( Vector vLightingOrigin )
{
if ( vLightingOrigin != m_DynamicState.m_vLightingOrigin )
{
FlushBufferedPrimitives();
m_DynamicState.m_vLightingOrigin = vLightingOrigin;
}
}
//#define NO_LOCAL_LIGHTS
void CShaderAPIDx8::SetLight( int lightNum, const LightDesc_t& desc_ )
{
LOCK_SHADERAPI();
#ifdef NO_LOCAL_LIGHTS
LightDesc_t desc = desc_;
desc.m_Type = MATERIAL_LIGHT_DISABLE;
#else
LightDesc_t &desc = const_cast<LightDesc_t &>(desc_); // to permit '&'
#endif
Assert( lightNum < g_pHardwareConfig->Caps().m_MaxNumLights && lightNum >= 0 );
if( lightNum >= g_pHardwareConfig->Caps().m_MaxNumLights || lightNum < 0 )
return;
m_DynamicState.m_LightDescs[lightNum] = desc;
FlushBufferedPrimitives();
if (desc.m_Type == MATERIAL_LIGHT_DISABLE)
{
if (m_DynamicState.m_LightEnable[lightNum])
{
m_DynamicState.m_LightEnableChanged[lightNum] = STATE_CHANGED;
m_DynamicState.m_LightEnable[lightNum] = false;
}
return;
}
if (!m_DynamicState.m_LightEnable[lightNum])
{
m_DynamicState.m_LightEnableChanged[lightNum] = STATE_CHANGED;
m_DynamicState.m_LightEnable[lightNum] = true;
}
D3DLIGHT light;
switch( desc.m_Type )
{
case MATERIAL_LIGHT_POINT:
light.Type = D3DLIGHT_POINT;
light.Range = desc.m_Range;
break;
case MATERIAL_LIGHT_DIRECTIONAL:
light.Type = D3DLIGHT_DIRECTIONAL;
light.Range = 1e12; // This is supposed to be ignored
break;
case MATERIAL_LIGHT_SPOT:
light.Type = D3DLIGHT_SPOT;
light.Range = desc.m_Range;
break;
default:
m_DynamicState.m_LightEnable[lightNum] = false;
return;
}
// This is a D3D limitation
Assert( (light.Range >= 0) && (light.Range <= sqrt(FLT_MAX)) );
memcpy( &light.Diffuse, &desc.m_Color[0], 3*sizeof(float) );
memcpy( &light.Specular, &desc.m_Color[0], 3*sizeof(float) );
light.Diffuse.a = 1.0f;
light.Specular.a = 1.0f;
light.Ambient.a = light.Ambient.b = light.Ambient.g = light.Ambient.r = 0;
memcpy( &light.Position, &desc.m_Position[0], 3 * sizeof(float) );
memcpy( &light.Direction, &desc.m_Direction[0], 3 * sizeof(float) );
light.Falloff = desc.m_Falloff;
light.Attenuation0 = desc.m_Attenuation0;
light.Attenuation1 = desc.m_Attenuation1;
light.Attenuation2 = desc.m_Attenuation2;
// normalize light color...
light.Theta = desc.m_Theta;
light.Phi = desc.m_Phi;
if (light.Phi > M_PI)
light.Phi = M_PI;
// This piece of crap line of code is because if theta gets too close to phi,
// we get no light at all.
if (light.Theta - light.Phi > -1e-3)
light.Theta = light.Phi - 1e-3;
m_DynamicState.m_LightChanged[lightNum] = STATE_CHANGED;
memcpy( &m_DynamicState.m_Lights[lightNum], &light, sizeof(light) );
}
void CShaderAPIDx8::DisableAllLocalLights()
{
LOCK_SHADERAPI();
bool bFlushed = false;
for ( int lightNum = 0; lightNum < MAX_NUM_LIGHTS; lightNum++ )
{
if (m_DynamicState.m_LightEnable[lightNum])
{
if ( !bFlushed )
{
FlushBufferedPrimitives();
bFlushed = true;
}
m_DynamicState.m_LightDescs[lightNum].m_Type = MATERIAL_LIGHT_DISABLE;
m_DynamicState.m_LightEnableChanged[lightNum] = STATE_CHANGED;
m_DynamicState.m_LightEnable[lightNum] = false;
}
}
}
int CShaderAPIDx8::GetMaxLights( void ) const
{
return g_pHardwareConfig->Caps().m_MaxNumLights;
}
const LightDesc_t& CShaderAPIDx8::GetLight( int lightNum ) const
{
Assert( lightNum < g_pHardwareConfig->Caps().m_MaxNumLights && lightNum >= 0 );
return m_DynamicState.m_LightDescs[lightNum];
}
//-----------------------------------------------------------------------------
// Ambient cube
//-----------------------------------------------------------------------------
//#define NO_AMBIENT_CUBE 1
void CShaderAPIDx8::SetAmbientLightCube( Vector4D cube[6] )
{
LOCK_SHADERAPI();
/*
int i;
for( i = 0; i < 6; i++ )
{
ColorClamp( cube[i].AsVector3D() );
// if( i == 0 )
// {
// Warning( "%d: %f %f %f\n", i, cube[i][0], cube[i][1], cube[i][2] );
// }
}
*/
if (memcmp(&m_DynamicState.m_AmbientLightCube[0][0], cube, 6 * sizeof(Vector4D)))
{
memcpy( &m_DynamicState.m_AmbientLightCube[0][0], cube, 6 * sizeof(Vector4D) );
#ifdef NO_AMBIENT_CUBE
memset( &m_DynamicState.m_AmbientLightCube[0][0], 0, 6 * sizeof(Vector4D) );
#endif
//#define DEBUG_AMBIENT_CUBE
#ifdef DEBUG_AMBIENT_CUBE
m_DynamicState.m_AmbientLightCube[0][0] = 1.0f;
m_DynamicState.m_AmbientLightCube[0][1] = 0.0f;
m_DynamicState.m_AmbientLightCube[0][2] = 0.0f;
m_DynamicState.m_AmbientLightCube[1][0] = 0.0f;
m_DynamicState.m_AmbientLightCube[1][1] = 1.0f;
m_DynamicState.m_AmbientLightCube[1][2] = 0.0f;
m_DynamicState.m_AmbientLightCube[2][0] = 0.0f;
m_DynamicState.m_AmbientLightCube[2][1] = 0.0f;
m_DynamicState.m_AmbientLightCube[2][2] = 1.0f;
m_DynamicState.m_AmbientLightCube[3][0] = 1.0f;
m_DynamicState.m_AmbientLightCube[3][1] = 0.0f;
m_DynamicState.m_AmbientLightCube[3][2] = 1.0f;
m_DynamicState.m_AmbientLightCube[4][0] = 1.0f;
m_DynamicState.m_AmbientLightCube[4][1] = 1.0f;
m_DynamicState.m_AmbientLightCube[4][2] = 0.0f;
m_DynamicState.m_AmbientLightCube[5][0] = 0.0f;
m_DynamicState.m_AmbientLightCube[5][1] = 1.0f;
m_DynamicState.m_AmbientLightCube[5][2] = 1.0f;
#endif
m_CachedAmbientLightCube = STATE_CHANGED;
}
}
void CShaderAPIDx8::SetVertexShaderStateAmbientLightCube()
{
if (m_CachedAmbientLightCube & STATE_CHANGED_VERTEX_SHADER)
{
SetVertexShaderConstant( VERTEX_SHADER_AMBIENT_LIGHT, m_DynamicState.m_AmbientLightCube[0].Base(), 6 );
m_CachedAmbientLightCube &= ~STATE_CHANGED_VERTEX_SHADER;
}
}
void CShaderAPIDx8::SetPixelShaderStateAmbientLightCube( int pshReg, bool bForceToBlack )
{
float *pCubeBase;
Vector4D tempCube[6];
if( bForceToBlack )
{
for ( int i=0; i<6 ; i++ )
tempCube[i].Init();
pCubeBase = tempCube[0].Base();
}
else
{
pCubeBase = m_DynamicState.m_AmbientLightCube[0].Base();
}
SetPixelShaderConstant( pshReg, pCubeBase, 6 );
}
float CShaderAPIDx8::GetAmbientLightCubeLuminance( void )
{
Vector4D vLuminance( 0.3f, 0.59f, 0.11f, 0.0f );
float fLuminance = 0.0f;
for (int i=0; i<6; i++)
{
fLuminance += vLuminance.Dot( m_DynamicState.m_AmbientLightCube[i] );
}
return fLuminance / 6.0f;
}
static inline RECT* RectToRECT( Rect_t *pSrcRect, RECT &dstRect )
{
if ( !pSrcRect )
return NULL;
dstRect.left = pSrcRect->x;
dstRect.top = pSrcRect->y;
dstRect.right = pSrcRect->x + pSrcRect->width;
dstRect.bottom = pSrcRect->y + pSrcRect->height;
return &dstRect;
}
void CShaderAPIDx8::CopyRenderTargetToTextureEx( ShaderAPITextureHandle_t textureHandle, int nRenderTargetID, Rect_t *pSrcRect, Rect_t *pDstRect )
{
LOCK_SHADERAPI();
VPROF_BUDGET( "CShaderAPIDx8::CopyRenderTargetToTexture", "Refraction overhead" );
if ( !TextureIsAllocated( textureHandle ) )
return;
#if defined( PIX_INSTRUMENTATION )
{
const char *pRT = ( nRenderTargetID < 0 ) ? "DS" : "RT";
if ( textureHandle == SHADER_RENDERTARGET_NONE )
{
pRT = "None";
}
else if ( textureHandle != SHADER_RENDERTARGET_BACKBUFFER )
{
Texture_t &tex = GetTexture( textureHandle );
pRT = tex.m_DebugName.String();
}
char buf[256];
sprintf( buf, "CopyRTToTexture:%s", pRT ? pRT : "?" );
BeginPIXEvent( 0xFFFFFFFF, buf );
EndPIXEvent();
}
#endif
// Don't flush here!! If you have to flush here, then there is a driver bug.
// FlushHardware( );
AssertValidTextureHandle( textureHandle );
Texture_t *pTexture = &GetTexture( textureHandle );
Assert( pTexture );
IDirect3DTexture *pD3DTexture = (IDirect3DTexture *)pTexture->GetTexture();
Assert( pD3DTexture );
#if !defined( _X360 )
IDirect3DSurface* pRenderTargetSurface;
HRESULT hr = Dx9Device()->GetRenderTarget( nRenderTargetID, &pRenderTargetSurface );
if ( FAILED( hr ) )
{
Assert( 0 );
return;
}
IDirect3DSurface *pDstSurf;
hr = pD3DTexture->GetSurfaceLevel( 0, &pDstSurf );
Assert( !FAILED( hr ) );
if ( FAILED( hr ) )
{
pRenderTargetSurface->Release();
return;
}
bool tryblit = true;
if ( tryblit )
{
RECORD_COMMAND( DX8_COPY_FRAMEBUFFER_TO_TEXTURE, 1 );
RECORD_INT( textureHandle );
RECT srcRect, dstRect;
hr = Dx9Device()->StretchRect( pRenderTargetSurface, RectToRECT( pSrcRect, srcRect ),
pDstSurf, RectToRECT( pDstRect, dstRect ), D3DTEXF_LINEAR );
Assert( !FAILED( hr ) );
}
pDstSurf->Release();
pRenderTargetSurface->Release();
#else
DWORD flags = 0;
switch( nRenderTargetID )
{
case -1:
flags = D3DRESOLVE_DEPTHSTENCIL | D3DRESOLVE_FRAGMENT0;
break;
case 0:
flags = D3DRESOLVE_RENDERTARGET0;
break;
case 1:
case 2:
case 3:
// not supporting MRT
Assert( 0 );
return;
NO_DEFAULT
};
// not prepared to handle mip mapping yet
Assert( pD3DTexture->GetLevelCount() == 1 );
D3DPOINT dstPoint = { 0 };
if ( pDstRect )
{
dstPoint.x = pDstRect->x;
dstPoint.y = pDstRect->y;
}
int destWidth, destHeight;
if( pDstRect )
{
destWidth = pDstRect->width;
destHeight = pDstRect->height;
Assert( (destWidth <= pTexture->GetWidth()) && (destHeight <= pTexture->GetHeight()) );
}
else
{
destWidth = pTexture->GetWidth();
destHeight = pTexture->GetHeight();
}
RECT srcRect;
RECT *pResolveRect = NULL;
int srcWidth, srcHeight;
if ( pSrcRect )
{
RectToRECT( pSrcRect, srcRect );
pResolveRect = &srcRect;
// resolve has no stretching ability, and we can only compensate when doing a resolve to a whole texture larger than the source
Assert( !pDstRect || ( pSrcRect->width <= pDstRect->width && pSrcRect->height <= pDstRect->height ) );
srcWidth = pSrcRect->width;
srcHeight = pSrcRect->height;
}
else
{
srcRect.left = srcRect.top = 0;
srcRect.right = m_DynamicState.m_Viewport.Width;
srcRect.bottom = m_DynamicState.m_Viewport.Height;
if( (srcRect.right < 0) || (srcRect.bottom < 0) )
{
if( m_UsingTextureRenderTarget )
{
srcRect.right = m_ViewportMaxWidth;
srcRect.bottom = m_ViewportMaxHeight;
}
else
{
int w,h;
GetBackBufferDimensions( w, h );
srcRect.right = w;
srcRect.bottom = h;
}
}
srcWidth = srcRect.right;
srcHeight = srcRect.bottom;
}
if( (srcWidth != destWidth) || (srcHeight != destHeight) )
{
//Not a 1:1 resolve, we should only have gotten this far if we can downsize the target texture to compensate
Assert( (destWidth > srcWidth) && (destHeight > srcHeight) && (dstPoint.x == 0) && (dstPoint.y == 0) );
//What we're doing is telling D3D that this texture is smaller than it is so the resolve is 1:1.
//We leave the texture in this state until it resolves from something bigger.
//All outside code still thinks this texture is it's original size. And it still owns enough memory to go back to it's original size.
pD3DTexture->Format.Size.TwoD.Width = srcWidth - 1;
pD3DTexture->Format.Size.TwoD.Height = srcHeight - 1; //no idea why they store it as size-1, but they do
pResolveRect = NULL;
}
else
{
//restore D3D texture to full size in case it was previously downsized
pD3DTexture->Format.Size.TwoD.Width = pTexture->GetWidth() - 1;
pD3DTexture->Format.Size.TwoD.Height = pTexture->GetHeight() - 1; //no idea why they store it as size-1, but they do
}
// if we convert to srgb format, we need the original format for reverting. We only need the first DWORD of GPUTEXTURE_FETCH_CONSTANT.
DWORD linearFormatBackup = pD3DTexture->Format.dword[0];
if ( !( flags & D3DRESOLVE_DEPTHSTENCIL ) && ( m_DynamicState.m_bSRGBWritesEnabled ) )
{
// we need a matched resolve regarding sRGB to get values transfered as-is
// when the surface is sRGB, use the corresponding sRGB texture
pD3DTexture->Format.SignX = pD3DTexture->Format.SignY = pD3DTexture->Format.SignZ = 3;
}
HRESULT hr = Dx9Device()->Resolve( flags, (D3DRECT*)pResolveRect, pD3DTexture, &dstPoint, 0, 0, NULL, 0, 0, NULL );
Assert( !FAILED( hr ) );
pD3DTexture->Format.dword[0] = linearFormatBackup;
#endif
}
void CShaderAPIDx8::CopyRenderTargetToScratchTexture( ShaderAPITextureHandle_t srcRt, ShaderAPITextureHandle_t dstTex, Rect_t *pSrcRect, Rect_t *pDstRect )
{
LOCK_SHADERAPI();
if ( !TextureIsAllocated( srcRt ) || !TextureIsAllocated( dstTex ) )
{
Assert( !"Fix that render target or dest texture aren't allocated." );
return;
}
HRESULT hr = D3D_OK;
IDirect3DSurface9* srcSurf = NULL;
AssertValidTextureHandle( srcRt );
Texture_t *pSrcRt = &GetTexture( srcRt );
Assert( pSrcRt );
IDirect3DTexture *pD3DSrcRt = ( IDirect3DTexture * ) pSrcRt->GetTexture();
Assert( pD3DSrcRt );
hr = pD3DSrcRt->GetSurfaceLevel( 0, &srcSurf );
Assert( SUCCEEDED( hr ) && srcSurf );
IDirect3DSurface9* dstSurf = NULL;
AssertValidTextureHandle( dstTex );
Texture_t *pDstTex = &GetTexture( dstTex );
Assert( pDstTex );
IDirect3DTexture *pD3DDstTex = ( IDirect3DTexture * ) pDstTex->GetTexture();
Assert( pD3DDstTex );
hr = pD3DDstTex->GetSurfaceLevel( 0, &dstSurf );
Assert( SUCCEEDED( hr ) && dstSurf );
// This does it.
hr = Dx9Device()->GetRenderTargetData( srcSurf, dstSurf );
Assert( SUCCEEDED( hr ) );
srcSurf->Release();
dstSurf->Release();
}
//-------------------------------------------------------------------------
// Allows locking and unlocking of very specific surface types. pOutBits and pOutPitch will not be touched if
// the lock fails.
//-------------------------------------------------------------------------
void CShaderAPIDx8::LockRect( void** pOutBits, int* pOutPitch, ShaderAPITextureHandle_t texHandle, int mipmap, int x, int y, int w, int h, bool bWrite, bool bRead )
{
LOCK_SHADERAPI();
Assert( pOutBits );
Assert( pOutPitch );
if ( !TextureIsAllocated( texHandle ) )
{
Assert( !"Fix that texture isn't allocated." );
return;
}
HRESULT hr = D3D_OK;
IDirect3DSurface9* surf = NULL;
AssertValidTextureHandle( texHandle );
Texture_t *pTex = &GetTexture( texHandle );
Assert( pTex );
IDirect3DTexture *pD3DTex = ( IDirect3DTexture * ) pTex->GetTexture();
Assert( pD3DTex );
hr = pD3DTex->GetSurfaceLevel( mipmap, &surf );
Assert( SUCCEEDED( hr ) && surf );
D3DLOCKED_RECT lockRect = { 0 };
RECT srcRect = { x, y, w, h };
DWORD flags = 0;
if ( !bRead && !bWrite )
{
Assert( !"Asking to neither read nor write? Probably a caller bug." );
goto cleanup;
}
if ( bRead && !bWrite )
flags = D3DLOCK_READONLY;
hr = surf->LockRect( &lockRect, &srcRect, flags );
if ( FAILED( hr ) )
{
Assert( !"Lock failed, look into why." );
goto cleanup;
}
(*pOutBits) = lockRect.pBits;
(*pOutPitch) = lockRect.Pitch;
cleanup:
surf->Release();
}
void CShaderAPIDx8::UnlockRect( ShaderAPITextureHandle_t texHandle, int mipmap )
{
LOCK_SHADERAPI();
if ( !TextureIsAllocated( texHandle ) )
{
Assert( !"Fix that texture isn't allocated." );
return;
}
HRESULT hr = D3D_OK;
IDirect3DSurface9* surf = NULL;
AssertValidTextureHandle( texHandle );
Texture_t *pTex = &GetTexture( texHandle );
Assert( pTex );
IDirect3DTexture *pD3DTex = ( IDirect3DTexture * ) pTex->GetTexture();
Assert( pD3DTex );
hr = pD3DTex->GetSurfaceLevel( mipmap, &surf );
Assert( SUCCEEDED( hr ) && surf );
hr = surf->UnlockRect();
Assert( SUCCEEDED( hr ) );
surf->Release();
}
static float GetAspectRatio( const Texture_t* pTex )
{
Assert( pTex );
if ( pTex->m_Height != 0 )
return float( pTex->m_Width ) / float( pTex->m_Height );
Assert( !"Height of texture is 0, that seems like a bug." );
return 0.0f;
}
struct TextureExtents_t
{
int width;
int height;
int depth;
int mipmaps;
int fine;
int coarse;
TextureExtents_t() : width( 0 ), height( 0 ), depth( 0 ), mipmaps( 0 ), fine( 0 ), coarse( 0 ) { }
};
// Returns positive integer on success, 0 or <0 on failure.
static int FindCommonMipmapRange( int *pOutSrcFine, int *pOutDstFine, Texture_t *pSrcTex, Texture_t *pDstTex )
{
Assert( pOutSrcFine && pOutDstFine );
Assert( pSrcTex && pDstTex );
if ( GetAspectRatio( pSrcTex ) != GetAspectRatio( pDstTex ) )
return 0;
TextureExtents_t src,
dst;
// LOD Clamp indicates that there's no actual data in the finer mipmap levels yet, so respect it when determining
// the source and destination levels that could have data.
const int srcLodClamp = pSrcTex->GetLodClamp();
src.width = Max( 1, pSrcTex->GetWidth() >> srcLodClamp );
src.height = Max( 1, pSrcTex->GetHeight() >> srcLodClamp );
src.depth = Max( 1, pSrcTex->GetDepth() >> srcLodClamp );
src.mipmaps = pSrcTex->m_NumLevels - srcLodClamp;
Assert( src.mipmaps >= 1 );
const int dstLodClamp = pDstTex->GetLodClamp();
dst.width = Max( 1, pDstTex->GetWidth() >> dstLodClamp );
dst.height = Max( 1, pDstTex->GetHeight() >> dstLodClamp );
dst.depth = Max( 1, pDstTex->GetDepth() >> dstLodClamp );
dst.mipmaps = pDstTex->m_NumLevels - dstLodClamp;
Assert( dst.mipmaps >= 1 );
TextureExtents_t *pLarger = NULL,
*pSmaller = NULL;
if ( src.width >= dst.width && src.height >= dst.height && src.depth >= dst.depth )
{
pLarger = &src;
pSmaller = &dst;
}
else
{
pLarger = &dst;
pSmaller = &src;
}
// Since we are same aspect ratio, only need to test one dimension
while ( ( pLarger->width >> pLarger->fine ) > pSmaller->width )
{
++pLarger->fine;
--pLarger->mipmaps;
}
( *pOutSrcFine ) = src.fine;
( *pOutDstFine ) = dst.fine;
return Min( src.mipmaps, dst.mipmaps );
}
void CShaderAPIDx8::CopyTextureToTexture( ShaderAPITextureHandle_t srcTex, ShaderAPITextureHandle_t dstTex )
{
LOCK_SHADERAPI();
AssertValidTextureHandle( srcTex );
AssertValidTextureHandle( dstTex );
Assert( TextureIsAllocated( srcTex ) && TextureIsAllocated( dstTex ) );
Texture_t *pSrcTex = &GetTexture( srcTex );
Texture_t *pDstTex = &GetTexture( dstTex );
Assert( pSrcTex && pDstTex );
// Must have same image format
Assert( pSrcTex->GetImageFormat() == pDstTex->GetImageFormat() );
int srcFine = 0,
dstFine = 0;
int mipmapCount = FindCommonMipmapRange( &srcFine, &dstFine, pSrcTex, pDstTex );
if ( mipmapCount <= 0 )
{
// This is legit for things that are streamed in that are very small (near the 32x32 cutoff we do at the
// tip of the mipmap pyramid). But leaving it here because it's useful if you're tracking a specific bug.
// Warning( "Attempted to copy textures that had non-overlapping mipmap pyramids. This has failed and no copy has taken place.\n" );
return;
}
IDirect3DTexture* pSrcD3DTex = ( IDirect3DTexture * ) pSrcTex->GetTexture();
IDirect3DTexture* pDstD3DTex = ( IDirect3DTexture * ) pDstTex->GetTexture();
HRESULT hr = S_OK;
for ( int i = 0; i < mipmapCount; ++i )
{
int srcMipmap = srcFine + i;
int dstMipmap = dstFine + i;
IDirect3DSurface9* pSrcSurf = NULL;
IDirect3DSurface9* pDstSurf = NULL;
hr = pSrcD3DTex->GetSurfaceLevel( srcMipmap, &pSrcSurf );
Assert( SUCCEEDED( hr ) && pSrcSurf );
hr = pDstD3DTex->GetSurfaceLevel( dstMipmap, &pDstSurf );
Assert( SUCCEEDED( hr ) && pDstSurf );
hr = g_pD3DDevice->StretchRect( pSrcSurf, NULL, pDstSurf, NULL, D3DTEXF_NONE );
Assert( SUCCEEDED( hr ) );
pSrcSurf->Release();
pDstSurf->Release();
}
}
void CShaderAPIDx8::CopyRenderTargetToTexture( ShaderAPITextureHandle_t textureHandle )
{
LOCK_SHADERAPI();
CopyRenderTargetToTextureEx( textureHandle, 0 );
}
void CShaderAPIDx8::CopyTextureToRenderTargetEx( int nRenderTargetID, ShaderAPITextureHandle_t textureHandle, Rect_t *pSrcRect, Rect_t *pDstRect )
{
LOCK_SHADERAPI();
VPROF( "CShaderAPIDx8::CopyRenderTargetToTexture" );
if ( !TextureIsAllocated( textureHandle ) )
return;
// Don't flush here!! If you have to flush here, then there is a driver bug.
// FlushHardware( );
AssertValidTextureHandle( textureHandle );
Texture_t *pTexture = &GetTexture( textureHandle );
Assert( pTexture );
IDirect3DTexture *pD3DTexture = (IDirect3DTexture *)pTexture->GetTexture();
Assert( pD3DTexture );
#if !defined( _X360 )
IDirect3DSurface* pRenderTargetSurface;
HRESULT hr = Dx9Device()->GetRenderTarget( nRenderTargetID, &pRenderTargetSurface );
if ( FAILED( hr ) )
{
Assert( 0 );
return;
}
IDirect3DSurface *pDstSurf;
hr = pD3DTexture->GetSurfaceLevel( 0, &pDstSurf );
Assert( !FAILED( hr ) );
if ( FAILED( hr ) )
{
pRenderTargetSurface->Release();
return;
}
bool tryblit = true;
if ( tryblit )
{
RECORD_COMMAND( DX8_COPY_FRAMEBUFFER_TO_TEXTURE, 1 );
RECORD_INT( textureHandle );
RECT srcRect, dstRect;
hr = Dx9Device()->StretchRect( pDstSurf, RectToRECT( pSrcRect, srcRect ),
pRenderTargetSurface, RectToRECT( pDstRect, dstRect ), D3DTEXF_LINEAR );
Assert( !FAILED( hr ) );
}
pDstSurf->Release();
pRenderTargetSurface->Release();
#else
Assert( 0 );
#endif
}
//-----------------------------------------------------------------------------
// modifies the vertex data when necessary
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ModifyVertexData( )
{
// this should be a dead code path
Assert( 0 );
#if 0
// We have to modulate the vertex color by the constant color sometimes
if (IsModulatingVertexColor())
{
m_ModifyBuilder.Reset();
float factor[4];
unsigned char* pColor = (unsigned char*)&m_DynamicState.m_ConstantColor;
factor[0] = pColor[0] / 255.0f;
factor[1] = pColor[1] / 255.0f;
factor[2] = pColor[2] / 255.0f;
factor[3] = pColor[3] / 255.0f;
for ( int i = 0; i < m_ModifyBuilder.VertexCount(); ++i )
{
unsigned int color = m_ModifyBuilder.Color();
unsigned char* pVertexColor = (unsigned char*)&color;
pVertexColor[0] = (unsigned char)((float)pVertexColor[0] * factor[0]);
pVertexColor[1] = (unsigned char)((float)pVertexColor[1] * factor[1]);
pVertexColor[2] = (unsigned char)((float)pVertexColor[2] * factor[2]);
pVertexColor[3] = (unsigned char)((float)pVertexColor[3] * factor[3]);
m_ModifyBuilder.Color4ubv( pVertexColor );
m_ModifyBuilder.AdvanceVertex();
}
}
#endif
}
static const char *TextureArgToString( int arg )
{
static char buf[128];
switch( arg & D3DTA_SELECTMASK )
{
case D3DTA_DIFFUSE:
strcpy( buf, "D3DTA_DIFFUSE" );
break;
case D3DTA_CURRENT:
strcpy( buf, "D3DTA_CURRENT" );
break;
case D3DTA_TEXTURE:
strcpy( buf, "D3DTA_TEXTURE" );
break;
case D3DTA_TFACTOR:
strcpy( buf, "D3DTA_TFACTOR" );
break;
case D3DTA_SPECULAR:
strcpy( buf, "D3DTA_SPECULAR" );
break;
case D3DTA_TEMP:
strcpy( buf, "D3DTA_TEMP" );
break;
default:
strcpy( buf, "<ERROR>" );
break;
}
if( arg & D3DTA_COMPLEMENT )
{
strcat( buf, "|D3DTA_COMPLEMENT" );
}
if( arg & D3DTA_ALPHAREPLICATE )
{
strcat( buf, "|D3DTA_ALPHAREPLICATE" );
}
return buf;
}
static const char *TextureOpToString( D3DTEXTUREOP op )
{
switch( op )
{
case D3DTOP_DISABLE:
return "D3DTOP_DISABLE";
case D3DTOP_SELECTARG1:
return "D3DTOP_SELECTARG1";
case D3DTOP_SELECTARG2:
return "D3DTOP_SELECTARG2";
case D3DTOP_MODULATE:
return "D3DTOP_MODULATE";
case D3DTOP_MODULATE2X:
return "D3DTOP_MODULATE2X";
case D3DTOP_MODULATE4X:
return "D3DTOP_MODULATE4X";
case D3DTOP_ADD:
return "D3DTOP_ADD";
case D3DTOP_ADDSIGNED:
return "D3DTOP_ADDSIGNED";
case D3DTOP_ADDSIGNED2X:
return "D3DTOP_ADDSIGNED2X";
case D3DTOP_SUBTRACT:
return "D3DTOP_SUBTRACT";
case D3DTOP_ADDSMOOTH:
return "D3DTOP_ADDSMOOTH";
case D3DTOP_BLENDDIFFUSEALPHA:
return "D3DTOP_BLENDDIFFUSEALPHA";
case D3DTOP_BLENDTEXTUREALPHA:
return "D3DTOP_BLENDTEXTUREALPHA";
case D3DTOP_BLENDFACTORALPHA:
return "D3DTOP_BLENDFACTORALPHA";
case D3DTOP_BLENDTEXTUREALPHAPM:
return "D3DTOP_BLENDTEXTUREALPHAPM";
case D3DTOP_BLENDCURRENTALPHA:
return "D3DTOP_BLENDCURRENTALPHA";
case D3DTOP_PREMODULATE:
return "D3DTOP_PREMODULATE";
case D3DTOP_MODULATEALPHA_ADDCOLOR:
return "D3DTOP_MODULATEALPHA_ADDCOLOR";
case D3DTOP_MODULATECOLOR_ADDALPHA:
return "D3DTOP_MODULATECOLOR_ADDALPHA";
case D3DTOP_MODULATEINVALPHA_ADDCOLOR:
return "D3DTOP_MODULATEINVALPHA_ADDCOLOR";
case D3DTOP_MODULATEINVCOLOR_ADDALPHA:
return "D3DTOP_MODULATEINVCOLOR_ADDALPHA";
case D3DTOP_BUMPENVMAP:
return "D3DTOP_BUMPENVMAP";
case D3DTOP_BUMPENVMAPLUMINANCE:
return "D3DTOP_BUMPENVMAPLUMINANCE";
case D3DTOP_DOTPRODUCT3:
return "D3DTOP_DOTPRODUCT3";
case D3DTOP_MULTIPLYADD:
return "D3DTOP_MULTIPLYADD";
case D3DTOP_LERP:
return "D3DTOP_LERP";
default:
return "<ERROR>";
}
}
static const char *BlendModeToString( int blendMode )
{
switch( blendMode )
{
case D3DBLEND_ZERO:
return "D3DBLEND_ZERO";
case D3DBLEND_ONE:
return "D3DBLEND_ONE";
case D3DBLEND_SRCCOLOR:
return "D3DBLEND_SRCCOLOR";
case D3DBLEND_INVSRCCOLOR:
return "D3DBLEND_INVSRCCOLOR";
case D3DBLEND_SRCALPHA:
return "D3DBLEND_SRCALPHA";
case D3DBLEND_INVSRCALPHA:
return "D3DBLEND_INVSRCALPHA";
case D3DBLEND_DESTALPHA:
return "D3DBLEND_DESTALPHA";
case D3DBLEND_INVDESTALPHA:
return "D3DBLEND_INVDESTALPHA";
case D3DBLEND_DESTCOLOR:
return "D3DBLEND_DESTCOLOR";
case D3DBLEND_INVDESTCOLOR:
return "D3DBLEND_INVDESTCOLOR";
case D3DBLEND_SRCALPHASAT:
return "D3DBLEND_SRCALPHASAT";
#if !defined( _X360 )
case D3DBLEND_BOTHSRCALPHA:
return "D3DBLEND_BOTHSRCALPHA";
case D3DBLEND_BOTHINVSRCALPHA:
return "D3DBLEND_BOTHINVSRCALPHA";
#endif
default:
return "<ERROR>";
}
}
//-----------------------------------------------------------------------------
// Spew Board State
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SpewBoardState()
{
// FIXME: This has regressed
return;
#ifdef DEBUG_BOARD_STATE
/*
{
static ID3DXFont* pFont = 0;
if (!pFont)
{
HFONT hFont = CreateFont( 0, 0, 0, 0, FW_DONTCARE, FALSE, FALSE, FALSE,
ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
DEFAULT_PITCH | FF_MODERN, 0 );
Assert( hFont != 0 );
HRESULT hr = D3DXCreateFont( Dx9Device(), hFont, &pFont );
}
static char buf[1024];
static RECT r = { 0, 0, 640, 480 };
if (m_DynamicState.m_VertexBlend == 0)
return;
#if 1
D3DXMATRIX* m = &GetTransform(MATERIAL_MODEL);
D3DXMATRIX* m2 = &GetTransform(MATERIAL_MODEL + 1);
sprintf(buf,"FVF %x\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n\n",
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n",
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n",
ShaderManager()->GetCurrentVertexShader(),
m->m[0][0], m->m[0][1], m->m[0][2], m->m[0][3],
m->m[1][0], m->m[1][1], m->m[1][2], m->m[1][3],
m->m[2][0], m->m[2][1], m->m[2][2], m->m[2][3],
m->m[3][0], m->m[3][1], m->m[3][2], m->m[3][3],
m2->m[0][0], m2->m[0][1], m2->m[0][2], m2->m[0][3],
m2->m[1][0], m2->m[1][1], m2->m[1][2], m2->m[1][3],
m2->m[2][0], m2->m[2][1], m2->m[2][2], m2->m[2][3],
m2->m[3][0], m2->m[3][1], m2->m[3][2], m2->m[3][3]
);
#else
Vector4D *pVec2 = &m_DynamicState.m_pVectorVertexShaderConstant[VERTEX_SHADER_MODELVIEWPROJ];
Vector4D *pVec3 = &m_DynamicState.m_pVectorVertexShaderConstant[VERTEX_SHADER_VIEWPROJ];
Vector4D *pVec4 = &m_DynamicState.m_pVectorVertexShaderConstant[VERTEX_SHADER_MODEL];
sprintf(buf,"\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n",
pVec1[0][0], pVec1[0][1], pVec1[0][2], pVec1[0][3],
pVec1[1][0], pVec1[1][1], pVec1[1][2], pVec1[1][3],
pVec1[2][0], pVec1[2][1], pVec1[2][2], pVec1[2][3],
pVec1[3][0], pVec1[3][1], pVec1[3][2], pVec1[3][3],
pVec2[0][0], pVec2[0][1], pVec2[0][2], pVec2[0][3],
pVec2[1][0], pVec2[1][1], pVec2[1][2], pVec2[1][3],
pVec2[2][0], pVec2[2][1], pVec2[2][2], pVec2[2][3],
pVec2[3][0], pVec2[3][1], pVec2[3][2], pVec2[3][3],
pVec3[0][0], pVec3[0][1], pVec3[0][2], pVec3[0][3],
pVec3[1][0], pVec3[1][1], pVec3[1][2], pVec3[1][3],
pVec3[2][0], pVec3[2][1], pVec3[2][2], pVec3[2][3],
pVec3[3][0], pVec3[3][1], pVec3[3][2], pVec3[3][3],
pVec4[0][0], pVec4[0][1], pVec4[0][2], pVec4[0][3],
pVec4[1][0], pVec4[1][1], pVec4[1][2], pVec4[1][3],
pVec4[2][0], pVec4[2][1], pVec4[2][2], pVec4[2][3],
0, 0, 0, 1
);
#endif
pFont->Begin();
pFont->DrawText( buf, -1, &r, DT_LEFT | DT_TOP,
D3DCOLOR_RGBA( 255, 255, 255, 255 ) );
pFont->End();
return;
}
#if 0
Vector4D *pVec2 = &m_DynamicState.m_pVectorVertexShaderConstant[VERTEX_SHADER_MODELVIEWPROJ];
Vector4D *pVec3 = &m_DynamicState.m_pVectorVertexShaderConstant[VERTEX_SHADER_VIEWPROJ];
Vector4D *pVec4 = &m_DynamicState.m_pVectorVertexShaderConstant[VERTEX_SHADER_MODEL];
static char buf2[1024];
sprintf(buf2,"\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n"
"[%6.3f %6.3f %6.3f %6.3f]\n[%6.3f %6.3f %6.3f %6.3f]\n",
pVec1[0][0], pVec1[0][1], pVec1[0][2], pVec1[0][3],
pVec1[1][0], pVec1[1][1], pVec1[1][2], pVec1[1][3],
pVec1[2][0], pVec1[2][1], pVec1[2][2], pVec1[2][3],
pVec1[3][0], pVec1[3][1], pVec1[3][2], pVec1[3][3],
pVec2[0][0], pVec2[0][1], pVec2[0][2], pVec2[0][3],
pVec2[1][0], pVec2[1][1], pVec2[1][2], pVec2[1][3],
pVec2[2][0], pVec2[2][1], pVec2[2][2], pVec2[2][3],
pVec2[3][0], pVec2[3][1], pVec2[3][2], pVec2[3][3],
pVec3[0][0], pVec3[0][1], pVec3[0][2], pVec3[0][3],
pVec3[1][0], pVec3[1][1], pVec3[1][2], pVec3[1][3],
pVec3[2][0], pVec3[2][1], pVec3[2][2], pVec3[2][3],
pVec3[3][0], pVec3[3][1], pVec3[3][2], pVec3[3][3],
pVec4[0][0], pVec4[0][1], pVec4[0][2], pVec4[0][3],
pVec4[1][0], pVec4[1][1], pVec4[1][2], pVec4[1][3],
pVec4[2][0], pVec4[2][1], pVec4[2][2], pVec4[2][3],
0, 0, 0, 1.0f
);
Plat_DebugString(buf2);
return;
#endif
*/
char buf[256];
sprintf(buf, "\nSnapshot id %d : \n", m_TransitionTable.CurrentSnapshot() );
Plat_DebugString(buf);
ShadowState_t &boardState = m_TransitionTable.BoardState();
ShadowShaderState_t &boardShaderState = m_TransitionTable.BoardShaderState();
sprintf(buf,"Depth States: ZFunc %d, ZWrite %d, ZEnable %d, ZBias %d\n",
boardState.m_ZFunc, boardState.m_ZWriteEnable,
boardState.m_ZEnable, boardState.m_ZBias );
Plat_DebugString(buf);
sprintf(buf,"Cull Enable %d Cull Mode %d Color Write %d Fill %d Const Color Mod %d sRGBWriteEnable %d\n",
boardState.m_CullEnable, m_DynamicState.m_CullMode, boardState.m_ColorWriteEnable,
boardState.m_FillMode, boardShaderState.m_ModulateConstantColor, boardState.m_SRGBWriteEnable );
Plat_DebugString(buf);
sprintf(buf,"Blend States: Blend Enable %d Test Enable %d Func %d SrcBlend %d (%s) DstBlend %d (%s)\n",
boardState.m_AlphaBlendEnable, boardState.m_AlphaTestEnable,
boardState.m_AlphaFunc, boardState.m_SrcBlend, BlendModeToString( boardState.m_SrcBlend ),
boardState.m_DestBlend, BlendModeToString( boardState.m_DestBlend ) );
Plat_DebugString(buf);
int len = sprintf(buf,"Alpha Ref %d, Lighting: %d, Ambient Color %x, LightsEnabled ",
boardState.m_AlphaRef, boardState.m_Lighting, m_DynamicState.m_Ambient);
int i;
for ( i = 0; i < g_pHardwareConfig->Caps().m_MaxNumLights; ++i)
{
len += sprintf(buf+len,"%d ", m_DynamicState.m_LightEnable[i] );
}
sprintf(buf+len,"\n");
Plat_DebugString(buf);
sprintf(buf,"Fixed Function: %d, VertexBlend %d\n",
boardState.m_UsingFixedFunction, m_DynamicState.m_VertexBlend );
Plat_DebugString(buf);
sprintf(buf,"Pass Vertex Usage: %llx Pixel Shader %p Vertex Shader %p\n",
boardShaderState.m_VertexUsage, ShaderManager()->GetCurrentPixelShader(),
ShaderManager()->GetCurrentVertexShader() );
Plat_DebugString(buf);
// REGRESSED!!!!
/*
D3DXMATRIX* m = &GetTransform(MATERIAL_MODEL);
sprintf(buf,"WorldMat [%4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f]\n",
m->m[0][0], m->m[0][1], m->m[0][2], m->m[0][3],
m->m[1][0], m->m[1][1], m->m[1][2], m->m[1][3],
m->m[2][0], m->m[2][1], m->m[2][2], m->m[2][3],
m->m[3][0], m->m[3][1], m->m[3][2], m->m[3][3] );
Plat_DebugString(buf);
m = &GetTransform(MATERIAL_MODEL + 1);
sprintf(buf,"WorldMat2 [%4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f]\n",
m->m[0][0], m->m[0][1], m->m[0][2], m->m[0][3],
m->m[1][0], m->m[1][1], m->m[1][2], m->m[1][3],
m->m[2][0], m->m[2][1], m->m[2][2], m->m[2][3],
m->m[3][0], m->m[3][1], m->m[3][2], m->m[3][3] );
Plat_DebugString(buf);
m = &GetTransform(MATERIAL_VIEW);
sprintf(buf,"ViewMat [%4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f]\n",
m->m[0][0], m->m[0][1], m->m[0][2],
m->m[1][0], m->m[1][1], m->m[1][2],
m->m[2][0], m->m[2][1], m->m[2][2],
m->m[3][0], m->m[3][1], m->m[3][2] );
Plat_DebugString(buf);
m = &GetTransform(MATERIAL_PROJECTION);
sprintf(buf,"ProjMat [%4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f]\n",
m->m[0][0], m->m[0][1], m->m[0][2],
m->m[1][0], m->m[1][1], m->m[1][2],
m->m[2][0], m->m[2][1], m->m[2][2],
m->m[3][0], m->m[3][1], m->m[3][2] );
Plat_DebugString(buf);
for (i = 0; i < GetTextureStageCount(); ++i)
{
m = &GetTransform(MATERIAL_TEXTURE0 + i);
sprintf(buf,"TexMat%d [%4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f %4.3f]\n",
i, m->m[0][0], m->m[0][1], m->m[0][2],
m->m[1][0], m->m[1][1], m->m[1][2],
m->m[2][0], m->m[2][1], m->m[2][2],
m->m[3][0], m->m[3][1], m->m[3][2] );
Plat_DebugString(buf);
}
*/
sprintf(buf,"Viewport (%d %d) [%d %d] %4.3f %4.3f\n",
m_DynamicState.m_Viewport.X, m_DynamicState.m_Viewport.Y,
m_DynamicState.m_Viewport.Width, m_DynamicState.m_Viewport.Height,
m_DynamicState.m_Viewport.MinZ, m_DynamicState.m_Viewport.MaxZ);
Plat_DebugString(buf);
for (i = 0; i < MAX_TEXTURE_STAGES; ++i)
{
sprintf(buf,"Stage %d :\n", i);
Plat_DebugString(buf);
sprintf(buf," Color Op: %d (%s) Color Arg1: %d (%s)",
boardState.m_TextureStage[i].m_ColorOp,
TextureOpToString( boardState.m_TextureStage[i].m_ColorOp ),
boardState.m_TextureStage[i].m_ColorArg1,
TextureArgToString( boardState.m_TextureStage[i].m_ColorArg1 ) );
Plat_DebugString(buf);
sprintf( buf, " Color Arg2: %d (%s)\n",
boardState.m_TextureStage[i].m_ColorArg2,
TextureArgToString( boardState.m_TextureStage[i].m_ColorArg2 ) );
Plat_DebugString(buf);
sprintf(buf," Alpha Op: %d (%s) Alpha Arg1: %d (%s)",
boardState.m_TextureStage[i].m_AlphaOp,
TextureOpToString( boardState.m_TextureStage[i].m_AlphaOp ),
boardState.m_TextureStage[i].m_AlphaArg1,
TextureArgToString( boardState.m_TextureStage[i].m_AlphaArg1 ) );
Plat_DebugString(buf);
sprintf(buf," Alpha Arg2: %d (%s)\n",
boardState.m_TextureStage[i].m_AlphaArg2,
TextureArgToString( boardState.m_TextureStage[i].m_AlphaArg2 ) );
Plat_DebugString(buf);
}
for ( int i = 0; i < MAX_SAMPLERS; ++i )
{
sprintf(buf," Texture Enabled: %d Bound Texture: %d UWrap: %d VWrap: %d\n",
SamplerState(i).m_TextureEnable, GetBoundTextureBindId( (Sampler_t)i ),
SamplerState(i).m_UTexWrap, SamplerState(i).m_VTexWrap );
Plat_DebugString(buf);
sprintf(buf," Mag Filter: %d Min Filter: %d Mip Filter: %d\n",
SamplerState(i).m_MagFilter, SamplerState(i).m_MinFilter,
SamplerState(i).m_MipFilter );
sprintf(buf," MaxMipLevel: %d\n", SamplerState(i).m_FinestMipmapLevel );
Plat_DebugString(buf);
}
#else
Plat_DebugString("::SpewBoardState() Not Implemented Yet");
#endif
}
//-----------------------------------------------------------------------------
// Begin a render pass
//-----------------------------------------------------------------------------
void CShaderAPIDx8::BeginPass( StateSnapshot_t snapshot )
{
LOCK_SHADERAPI();
VPROF("CShaderAPIDx8::BeginPass");
if (IsDeactivated())
return;
m_nCurrentSnapshot = snapshot;
// Assert( m_pRenderMesh );
// FIXME: This only does anything with temp meshes, so don't bother yet for the new code.
if( m_pRenderMesh )
{
m_pRenderMesh->BeginPass( );
}
}
//-----------------------------------------------------------------------------
// Render da polygon!
//-----------------------------------------------------------------------------
void CShaderAPIDx8::RenderPass( int nPass, int nPassCount )
{
if ( IsDeactivated() )
return;
Assert( m_nCurrentSnapshot != -1 );
// Assert( m_pRenderMesh ); MESHFIXME
m_TransitionTable.UseSnapshot( m_nCurrentSnapshot );
CommitPerPassStateChanges( m_nCurrentSnapshot );
// Make sure that we bound a texture for every stage that is enabled
// NOTE: not enabled/finished yet... see comment in CShaderAPIDx8::ApplyTextureEnable
// int nSampler;
// for ( nSampler = 0; nSampler < g_pHardwareConfig->GetSamplerCount(); nSampler++ )
// {
// if ( SamplerState( nSampler ).m_TextureEnable )
// {
// }
// }
#ifdef DEBUG_BOARD_STATE
// Spew out render state...
if ( m_pMaterial->PerformDebugTrace() )
{
SpewBoardState();
}
#endif
#ifdef TEST_CACHE_LOCKS
g_pDataCache->Flush();
#endif
// Assert( m_pRenderMesh ); MESHFIXME
if ( m_pRenderMesh )
{
m_pRenderMesh->RenderPass();
}
else
{
MeshMgr()->RenderPassWithVertexAndIndexBuffers();
}
m_nCurrentSnapshot = -1;
}
//-----------------------------------------------------------------------------
// Matrix mode
//-----------------------------------------------------------------------------
void CShaderAPIDx8::MatrixMode( MaterialMatrixMode_t matrixMode )
{
// NOTE!!!!!!
// The only time that m_MatrixMode is used is for texture matrices. Do not use
// it for anything else unless you change this code!
if ( matrixMode >= MATERIAL_TEXTURE0 && matrixMode <= MATERIAL_TEXTURE7 )
{
m_MatrixMode = ( D3DTRANSFORMSTATETYPE )( matrixMode - MATERIAL_TEXTURE0 + D3DTS_TEXTURE0 );
}
else
{
m_MatrixMode = (D3DTRANSFORMSTATETYPE)-1;
}
m_CurrStack = GetMatrixStack( matrixMode );
}
//-----------------------------------------------------------------------------
// the current camera position in world space.
//-----------------------------------------------------------------------------
void CShaderAPIDx8::GetWorldSpaceCameraPosition( float* pPos ) const
{
memcpy( pPos, m_WorldSpaceCameraPositon.Base(), sizeof( float[3] ) );
}
void CShaderAPIDx8::CacheWorldSpaceCameraPosition()
{
D3DXMATRIX& view = GetTransform(MATERIAL_VIEW);
m_WorldSpaceCameraPositon[0] =
-( view( 3, 0 ) * view( 0, 0 ) +
view( 3, 1 ) * view( 0, 1 ) +
view( 3, 2 ) * view( 0, 2 ) );
m_WorldSpaceCameraPositon[1] =
-( view( 3, 0 ) * view( 1, 0 ) +
view( 3, 1 ) * view( 1, 1 ) +
view( 3, 2 ) * view( 1, 2 ) );
m_WorldSpaceCameraPositon[2] =
-( view( 3, 0 ) * view( 2, 0 ) +
view( 3, 1 ) * view( 2, 1 ) +
view( 3, 2 ) * view( 2, 2 ) );
m_WorldSpaceCameraPositon[3] = 1.0f;
// Protect against zero, as some pixel shaders will divide by this in CalcWaterFogAlpha() in common_ps_fxc.h
if ( fabs( m_WorldSpaceCameraPositon[2] ) <= 0.00001f )
{
m_WorldSpaceCameraPositon[2] = 0.01f;
}
}
//-----------------------------------------------------------------------------
// Computes a matrix which includes the poly offset given an initial projection matrix
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ComputePolyOffsetMatrix( const D3DXMATRIX& matProjection, D3DXMATRIX &matProjectionOffset )
{
// We never need to do this on hardware that can handle zbias
if ( g_pHardwareConfig->Caps().m_ZBiasAndSlopeScaledDepthBiasSupported )
return;
float offsetVal =
-1.0f * (m_DesiredState.m_Viewport.MaxZ - m_DesiredState.m_Viewport.MinZ) /
16384.0f;
D3DXMATRIX offset;
D3DXMatrixTranslation( &offset, 0.0f, 0.0f, offsetVal );
D3DXMatrixMultiply( &matProjectionOffset, &matProjection, &offset );
}
//-----------------------------------------------------------------------------
// Caches off the poly-offset projection matrix
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CachePolyOffsetProjectionMatrix()
{
ComputePolyOffsetMatrix( GetTransform(MATERIAL_PROJECTION), m_CachedPolyOffsetProjectionMatrix );
}
//-----------------------------------------------------------------------------
// Performs a flush on the matrix state if necessary
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::MatrixIsChanging( TransformType_t type )
{
if ( IsDeactivated() )
{
return false;
}
// early out if the transform is already one of our standard types
if ((type != TRANSFORM_IS_GENERAL) && (type == m_DynamicState.m_TransformType[m_CurrStack]))
return false;
// Only flush state if we're changing something other than a texture transform
int textureMatrix = m_CurrStack - MATERIAL_TEXTURE0;
if (( textureMatrix < 0 ) || (textureMatrix >= NUM_TEXTURE_TRANSFORMS))
FlushBufferedPrimitivesInternal();
return true;
}
void CShaderAPIDx8::SetTextureTransformDimension( TextureStage_t textureMatrix, int dimension, bool projected )
{
D3DTEXTURETRANSFORMFLAGS textureTransformFlags = ( D3DTEXTURETRANSFORMFLAGS )dimension;
if( projected )
{
Assert( sizeof( int ) == sizeof( D3DTEXTURETRANSFORMFLAGS ) );
( *( int * )&textureTransformFlags ) |= D3DTTFF_PROJECTED;
}
if (TextureStage(textureMatrix).m_TextureTransformFlags != textureTransformFlags )
{
SetTextureStageState( textureMatrix, D3DTSS_TEXTURETRANSFORMFLAGS, textureTransformFlags );
TextureStage(textureMatrix).m_TextureTransformFlags = textureTransformFlags;
}
}
void CShaderAPIDx8::DisableTextureTransform( TextureStage_t textureMatrix )
{
if (TextureStage(textureMatrix).m_TextureTransformFlags != D3DTTFF_DISABLE )
{
SetTextureStageState( textureMatrix, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE );
TextureStage(textureMatrix).m_TextureTransformFlags = D3DTTFF_DISABLE;
}
}
void CShaderAPIDx8::SetBumpEnvMatrix( TextureStage_t textureStage, float m00, float m01, float m10, float m11 )
{
TextureStageState_t &textureStageState = TextureStage( textureStage );
if( textureStageState.m_BumpEnvMat00 != m00 ||
textureStageState.m_BumpEnvMat01 != m01 ||
textureStageState.m_BumpEnvMat10 != m10 ||
textureStageState.m_BumpEnvMat11 != m11 )
{
SetTextureStageState( textureStage, D3DTSS_BUMPENVMAT00, *( ( LPDWORD ) (&m00) ) );
SetTextureStageState( textureStage, D3DTSS_BUMPENVMAT01, *( ( LPDWORD ) (&m01) ) );
SetTextureStageState( textureStage, D3DTSS_BUMPENVMAT10, *( ( LPDWORD ) (&m10) ) );
SetTextureStageState( textureStage, D3DTSS_BUMPENVMAT11, *( ( LPDWORD ) (&m11) ) );
textureStageState.m_BumpEnvMat00 = m00;
textureStageState.m_BumpEnvMat01 = m01;
textureStageState.m_BumpEnvMat10 = m10;
textureStageState.m_BumpEnvMat11 = m11;
}
}
//-----------------------------------------------------------------------------
// Sets the actual matrix state
//-----------------------------------------------------------------------------
void CShaderAPIDx8::UpdateMatrixTransform( TransformType_t type )
{
int textureMatrix = m_CurrStack - MATERIAL_TEXTURE0;
if (( textureMatrix >= 0 ) && (textureMatrix < NUM_TEXTURE_TRANSFORMS))
{
// NOTE: Flush shouldn't happen here because we
// expect that texture transforms will be set within the shader
// FIXME: We only want to use D3DTTFF_COUNT3 for cubemaps
// D3DTFF_COUNT2 is used for non-cubemaps. Of course, if there's
// no performance penalty for COUNT3, we should just use that.
D3DTEXTURETRANSFORMFLAGS transformFlags;
transformFlags = (type == TRANSFORM_IS_IDENTITY) ? D3DTTFF_DISABLE : D3DTTFF_COUNT3;
if (TextureStage(textureMatrix).m_TextureTransformFlags != transformFlags )
{
SetTextureStageState( textureMatrix, D3DTSS_TEXTURETRANSFORMFLAGS, transformFlags );
TextureStage(textureMatrix).m_TextureTransformFlags = transformFlags;
}
}
m_DynamicState.m_TransformType[m_CurrStack] = type;
m_DynamicState.m_TransformChanged[m_CurrStack] = STATE_CHANGED;
#ifdef _DEBUG
// Store off the board state
D3DXMATRIX *pSrc = &GetTransform(m_CurrStack);
D3DXMATRIX *pDst = &m_DynamicState.m_Transform[m_CurrStack];
// Assert( *pSrc != *pDst );
memcpy( pDst, pSrc, sizeof(D3DXMATRIX) );
#endif
if ( m_CurrStack == MATERIAL_VIEW )
{
CacheWorldSpaceCameraPosition();
}
if ( !IsX360() && m_CurrStack == MATERIAL_PROJECTION )
{
CachePolyOffsetProjectionMatrix();
}
// Any time the view or projection matrix changes, the user clip planes need recomputing....
// Assuming we're not overriding the user clip transform
if ( ( m_CurrStack == MATERIAL_PROJECTION ) ||
( ( m_CurrStack == MATERIAL_VIEW ) && ( !m_DynamicState.m_bUserClipTransformOverride ) ) )
{
MarkAllUserClipPlanesDirty();
}
// Set the state if it's a texture transform
if ( (m_CurrStack >= MATERIAL_TEXTURE0) && (m_CurrStack <= MATERIAL_TEXTURE7) )
{
SetTransform( m_MatrixMode, &GetTransform(m_CurrStack) );
}
}
//--------------------------------------------------------------------------------
// deformations
//--------------------------------------------------------------------------------
void CShaderAPIDx8::PushDeformation( DeformationBase_t const *pDef )
{
Assert( m_pDeformationStackPtr > m_DeformationStack );
--m_pDeformationStackPtr;
m_pDeformationStackPtr->m_nDeformationType = pDef->m_eType;
switch( pDef->m_eType )
{
case DEFORMATION_CLAMP_TO_BOX_IN_WORLDSPACE:
{
BoxDeformation_t const *pBox = reinterpret_cast< const BoxDeformation_t *>( pDef );
m_pDeformationStackPtr->m_nNumParameters = 16;
memcpy( m_pDeformationStackPtr->m_flDeformationParameters, &( pBox->m_SourceMins.x ), 16 * sizeof( float ) );
break;
}
break;
default:
Assert( 0 );
}
}
void CShaderAPIDx8::PopDeformation( )
{
Assert( m_pDeformationStackPtr != m_DeformationStack + DEFORMATION_STACK_DEPTH );
++m_pDeformationStackPtr;
}
int CShaderAPIDx8::GetNumActiveDeformations( void ) const
{
return ( m_DeformationStack + DEFORMATION_STACK_DEPTH ) - m_pDeformationStackPtr;
}
// for shaders to set vertex shader constants. returns a packed state which can be used to set the dynamic combo
int CShaderAPIDx8::GetPackedDeformationInformation( int nMaskOfUnderstoodDeformations,
float *pConstantValuesOut,
int nBufferSize,
int nMaximumDeformations,
int *pDefCombosOut ) const
{
int nCombosFound = 0;
memset( pDefCombosOut, 0, sizeof( pDefCombosOut[0] ) * nMaximumDeformations );
size_t nRemainingBufferSize = nBufferSize;
for( const Deformation_t *i = m_DeformationStack + DEFORMATION_STACK_DEPTH -1; i >= m_pDeformationStackPtr; i-- )
{
int nFloatsOut = 4 * ( ( i->m_nNumParameters + 3 )>> 2 );
if (
( ( 1 << i->m_nDeformationType ) & nMaskOfUnderstoodDeformations ) &&
( nRemainingBufferSize >= ( nFloatsOut * sizeof( float ) ) ) )
{
memcpy( pConstantValuesOut, i->m_flDeformationParameters, nFloatsOut * sizeof( float ) );
pConstantValuesOut += nFloatsOut;
nRemainingBufferSize -= nFloatsOut * sizeof( float );
( *pDefCombosOut++ ) = i->m_nDeformationType;
nCombosFound++;
}
}
return nCombosFound;
}
//-----------------------------------------------------------------------------
// Matrix stack operations
//-----------------------------------------------------------------------------
void CShaderAPIDx8::PushMatrix()
{
// NOTE: No matrix transform update needed here.
m_pMatrixStack[m_CurrStack]->Push();
}
void CShaderAPIDx8::PopMatrix()
{
if (MatrixIsChanging())
{
m_pMatrixStack[m_CurrStack]->Pop();
UpdateMatrixTransform();
}
}
void CShaderAPIDx8::LoadIdentity( )
{
if (MatrixIsChanging(TRANSFORM_IS_IDENTITY))
{
m_pMatrixStack[m_CurrStack]->LoadIdentity( );
UpdateMatrixTransform( TRANSFORM_IS_IDENTITY );
}
}
void CShaderAPIDx8::LoadCameraToWorld( )
{
if (MatrixIsChanging(TRANSFORM_IS_CAMERA_TO_WORLD))
{
// could just use the transpose instead, if we know there's no scale
float det;
D3DXMATRIX inv;
D3DXMatrixInverse( &inv, &det, &GetTransform(MATERIAL_VIEW) );
// Kill translation
inv.m[3][0] = inv.m[3][1] = inv.m[3][2] = 0.0f;
m_pMatrixStack[m_CurrStack]->LoadMatrix( &inv );
UpdateMatrixTransform( TRANSFORM_IS_CAMERA_TO_WORLD );
}
}
void CShaderAPIDx8::LoadMatrix( float *m )
{
// Check for identity...
if ( (fabs(m[0] - 1.0f) < 1e-3) && (fabs(m[5] - 1.0f) < 1e-3) && (fabs(m[10] - 1.0f) < 1e-3) && (fabs(m[15] - 1.0f) < 1e-3) &&
(fabs(m[1]) < 1e-3) && (fabs(m[2]) < 1e-3) && (fabs(m[3]) < 1e-3) &&
(fabs(m[4]) < 1e-3) && (fabs(m[6]) < 1e-3) && (fabs(m[7]) < 1e-3) &&
(fabs(m[8]) < 1e-3) && (fabs(m[9]) < 1e-3) && (fabs(m[11]) < 1e-3) &&
(fabs(m[12]) < 1e-3) && (fabs(m[13]) < 1e-3) && (fabs(m[14]) < 1e-3) )
{
LoadIdentity();
return;
}
if (MatrixIsChanging())
{
m_pMatrixStack[m_CurrStack]->LoadMatrix( (D3DXMATRIX*)m );
UpdateMatrixTransform();
}
}
void CShaderAPIDx8::LoadBoneMatrix( int boneIndex, const float *m )
{
if ( IsDeactivated() )
return;
memcpy( m_boneMatrix[boneIndex].Base(), m, sizeof(float)*12 );
if ( boneIndex > m_maxBoneLoaded )
{
m_maxBoneLoaded = boneIndex;
}
if ( boneIndex == 0 )
{
MatrixMode( MATERIAL_MODEL );
VMatrix transposeMatrix;
transposeMatrix.Init( *(matrix3x4_t *)m );
MatrixTranspose( transposeMatrix, transposeMatrix );
LoadMatrix( (float*)transposeMatrix.m );
}
}
//-----------------------------------------------------------------------------
// Commits morph target factors
//-----------------------------------------------------------------------------
static void CommitFlexWeights( IDirect3DDevice9 *pDevice, const DynamicState_t &desiredState,
DynamicState_t &currentState, bool bForce )
{
if ( IsX360() )
{
// not supporting for 360
return;
}
CommitVertexShaderConstantRange( pDevice, desiredState, currentState, bForce,
VERTEX_SHADER_FLEX_WEIGHTS, VERTEX_SHADER_MAX_FLEX_WEIGHT_COUNT );
}
void CShaderAPIDx8::SetFlexWeights( int nFirstWeight, int nCount, const MorphWeight_t* pWeights )
{
if ( IsX360() )
{
// not supported for 360
return;
}
LOCK_SHADERAPI();
if ( g_pHardwareConfig->Caps().m_NumVertexShaderConstants < VERTEX_SHADER_FLEX_WEIGHTS + VERTEX_SHADER_MAX_FLEX_WEIGHT_COUNT )
return;
if ( nFirstWeight + nCount > VERTEX_SHADER_MAX_FLEX_WEIGHT_COUNT )
{
Warning( "Attempted to set too many flex weights! Max is %d\n", VERTEX_SHADER_MAX_FLEX_WEIGHT_COUNT );
nCount = VERTEX_SHADER_MAX_FLEX_WEIGHT_COUNT - nFirstWeight;
}
if ( nCount <= 0 )
return;
float *pDest = m_DesiredState.m_pVectorVertexShaderConstant[ VERTEX_SHADER_FLEX_WEIGHTS + nFirstWeight ].Base();
memcpy( pDest, pWeights, nCount * sizeof(MorphWeight_t) );
ADD_COMMIT_FUNC( COMMIT_PER_DRAW, COMMIT_VERTEX_SHADER, CommitFlexWeights );
}
void CShaderAPIDx8::MultMatrix( float *m )
{
if (MatrixIsChanging())
{
m_pMatrixStack[m_CurrStack]->MultMatrix( (D3DXMATRIX*)m );
UpdateMatrixTransform();
}
}
void CShaderAPIDx8::MultMatrixLocal( float *m )
{
if (MatrixIsChanging())
{
m_pMatrixStack[m_CurrStack]->MultMatrixLocal( (D3DXMATRIX*)m );
UpdateMatrixTransform();
}
}
void CShaderAPIDx8::Rotate( float angle, float x, float y, float z )
{
if (MatrixIsChanging())
{
D3DXVECTOR3 axis( x, y, z );
m_pMatrixStack[m_CurrStack]->RotateAxisLocal( &axis, M_PI * angle / 180.0f );
UpdateMatrixTransform();
}
}
void CShaderAPIDx8::Translate( float x, float y, float z )
{
if (MatrixIsChanging())
{
m_pMatrixStack[m_CurrStack]->TranslateLocal( x, y, z );
UpdateMatrixTransform();
}
}
void CShaderAPIDx8::Scale( float x, float y, float z )
{
if (MatrixIsChanging())
{
m_pMatrixStack[m_CurrStack]->ScaleLocal( x, y, z );
UpdateMatrixTransform();
}
}
void CShaderAPIDx8::ScaleXY( float x, float y )
{
if (MatrixIsChanging())
{
m_pMatrixStack[m_CurrStack]->ScaleLocal( x, y, 1.0f );
UpdateMatrixTransform();
}
}
void CShaderAPIDx8::Ortho( double left, double top, double right, double bottom, double zNear, double zFar )
{
if (MatrixIsChanging())
{
D3DXMATRIX matrix;
// FIXME: This is being used incorrectly! Should read:
// D3DXMatrixOrthoOffCenterRH( &matrix, left, right, bottom, top, zNear, zFar );
// Which is certainly why we need these extra -1 scales in y. Bleah
// NOTE: The camera can be imagined as the following diagram:
// /z
// /
// /____ x Z is going into the screen
// |
// |
// |y
//
// (0,0,z) represents the upper-left corner of the screen.
// Our projection transform needs to transform from this space to a LH coordinate
// system that looks thusly:
//
// y| /z
// | /
// |/____ x Z is going into the screen
//
// Where x,y lies between -1 and 1, and z lies from 0 to 1
// This is because the viewport transformation from projection space to pixels
// introduces a -1 scale in the y coordinates
// D3DXMatrixOrthoOffCenterLH( &matrix, left, right, bottom, top, zNear, zFar );
D3DXMatrixOrthoOffCenterRH( &matrix, left, right, top, bottom, zNear, zFar );
m_pMatrixStack[m_CurrStack]->MultMatrixLocal(&matrix);
Assert( m_CurrStack == MATERIAL_PROJECTION );
UpdateMatrixTransform();
}
}
void CShaderAPIDx8::PerspectiveX( double fovx, double aspect, double zNear, double zFar )
{
if (MatrixIsChanging())
{
float width = 2 * zNear * tan( fovx * M_PI / 360.0 );
float height = width / aspect;
Assert( m_CurrStack == MATERIAL_PROJECTION );
D3DXMATRIX rh;
D3DXMatrixPerspectiveRH( &rh, width, height, zNear, zFar );
m_pMatrixStack[m_CurrStack]->MultMatrixLocal(&rh);
UpdateMatrixTransform();
}
}
void CShaderAPIDx8::PerspectiveOffCenterX( double fovx, double aspect, double zNear, double zFar, double bottom, double top, double left, double right )
{
if (MatrixIsChanging())
{
float width = 2 * zNear * tan( fovx * M_PI / 360.0 );
float height = width / aspect;
// bottom, top, left, right are 0..1 so convert to -1..1
float flFrontPlaneLeft = -(width/2.0f) * (1.0f - left) + left * (width/2.0f);
float flFrontPlaneRight = -(width/2.0f) * (1.0f - right) + right * (width/2.0f);
float flFrontPlaneBottom = -(height/2.0f) * (1.0f - bottom) + bottom * (height/2.0f);
float flFrontPlaneTop = -(height/2.0f) * (1.0f - top) + top * (height/2.0f);
Assert( m_CurrStack == MATERIAL_PROJECTION );
D3DXMATRIX rh;
D3DXMatrixPerspectiveOffCenterRH( &rh, flFrontPlaneLeft, flFrontPlaneRight, flFrontPlaneBottom, flFrontPlaneTop, zNear, zFar );
m_pMatrixStack[m_CurrStack]->MultMatrixLocal(&rh);
UpdateMatrixTransform();
}
}
void CShaderAPIDx8::PickMatrix( int x, int y, int width, int height )
{
if (MatrixIsChanging())
{
Assert( m_CurrStack == MATERIAL_PROJECTION );
// This is going to create a matrix to append to the standard projection.
// Projection space goes from -1 to 1 in x and y. This matrix we append
// will transform the pick region to -1 to 1 in projection space
ShaderViewport_t viewport;
GetViewports( &viewport, 1 );
int vx = viewport.m_nTopLeftX;
int vy = viewport.m_nTopLeftX;
int vwidth = viewport.m_nWidth;
int vheight = viewport.m_nHeight;
// Compute the location of the pick region in projection space...
float px = 2.0 * (float)(x - vx) / (float)vwidth - 1;
float py = 2.0 * (float)(y - vy)/ (float)vheight - 1;
float pw = 2.0 * (float)width / (float)vwidth;
float ph = 2.0 * (float)height / (float)vheight;
// we need to translate (px, py) to the origin
// and scale so (pw,ph) -> (2, 2)
D3DXMATRIX matrix;
D3DXMatrixIdentity( &matrix );
matrix.m[0][0] = 2.0 / pw;
matrix.m[1][1] = 2.0 / ph;
matrix.m[3][0] = -2.0 * px / pw;
matrix.m[3][1] = -2.0 * py / ph;
m_pMatrixStack[m_CurrStack]->MultMatrixLocal(&matrix);
UpdateMatrixTransform();
}
}
void CShaderAPIDx8::GetMatrix( MaterialMatrixMode_t matrixMode, float *dst )
{
memcpy( dst, (void*)(FLOAT*)GetTransform(matrixMode), sizeof(D3DXMATRIX) );
}
//-----------------------------------------------------------------------------
// Did a transform change?
//-----------------------------------------------------------------------------
inline bool CShaderAPIDx8::VertexShaderTransformChanged( int i )
{
return (m_DynamicState.m_TransformChanged[i] & STATE_CHANGED_VERTEX_SHADER) != 0;
}
inline bool CShaderAPIDx8::FixedFunctionTransformChanged( int i )
{
return (m_DynamicState.m_TransformChanged[i] & STATE_CHANGED_FIXED_FUNCTION) != 0;
}
const D3DXMATRIX &CShaderAPIDx8::GetProjectionMatrix( void )
{
bool bUsingZBiasProjectionMatrix =
!g_pHardwareConfig->Caps().m_ZBiasAndSlopeScaledDepthBiasSupported &&
( m_TransitionTable.CurrentSnapshot() != -1 ) &&
m_TransitionTable.CurrentShadowState() &&
m_TransitionTable.CurrentShadowState()->m_ZBias;
if ( !m_DynamicState.m_FastClipEnabled )
{
if ( bUsingZBiasProjectionMatrix )
return m_CachedPolyOffsetProjectionMatrix;
return GetTransform( MATERIAL_PROJECTION );
}
if ( bUsingZBiasProjectionMatrix )
return m_CachedFastClipPolyOffsetProjectionMatrix;
return m_CachedFastClipProjectionMatrix;
}
//-----------------------------------------------------------------------------
// Workaround hack for visualization of selection mode
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetupSelectionModeVisualizationState()
{
Dx9Device()->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
D3DXMATRIX ident;
D3DXMatrixIdentity( &ident );
SetTransform( D3DTS_WORLD, &ident );
SetTransform( D3DTS_VIEW, &ident );
SetTransform( D3DTS_PROJECTION, &ident );
if ( g_pHardwareConfig->Caps().m_SupportsPixelShaders )
{
SetVertexShaderConstant( VERTEX_SHADER_VIEWPROJ, ident, 4 );
SetVertexShaderConstant( VERTEX_SHADER_MODELVIEWPROJ, ident, 4 );
float *pRowTwo = (float *)ident + 8;
SetVertexShaderConstant( VERTEX_SHADER_MODELVIEWPROJ_THIRD_ROW, pRowTwo, 1 ); // Row two of an identity matrix
SetVertexShaderConstant( VERTEX_SHADER_MODEL, ident, 3 * NUM_MODEL_TRANSFORMS );
}
}
//-----------------------------------------------------------------------------
// Set view transforms
//-----------------------------------------------------------------------------
static void printmat4x4( char *label, float *m00 )
{
// print label..
// fetch 4 from row, print as a row
// fetch 4 from column, print as a row
#ifdef DX_TO_GL_ABSTRACTION
float row[4];
float col[4];
GLMPRINTF(("-M- -- %s --", label ));
for( int n=0; n<4; n++ )
{
// extract row and column floats
for( int i=0; i<4;i++)
{
row[i] = m00[(n*4)+i];
col[i] = m00[(i*4)+n];
}
GLMPRINTF(( "-M- [ %7.4f %7.4f %7.4f %7.4f ] T=> [ %7.4f %7.4f %7.4f %7.4f ]",
row[0],row[1],row[2],row[3],
col[0],col[1],col[2],col[3]
));
}
GLMPRINTF(("-M-"));
#endif
}
void CShaderAPIDx8::SetVertexShaderViewProj()
{
//GLM_FUNC;
//GLMPRINTF(( ">-M- SetVertexShaderViewProj" ));
if (g_pHardwareConfig->Caps().m_SupportsPixelShaders)
{
D3DXMATRIX transpose;
if(0)
{
transpose = GetTransform(MATERIAL_VIEW) * GetProjectionMatrix();
D3DXMatrixTranspose( &transpose, &transpose );
}
else
{
// show work
D3DXMATRIX matView,matProj;
matView = GetTransform(MATERIAL_VIEW);
matProj = GetProjectionMatrix();
transpose = matView * matProj;
//printmat4x4( "matView", (float*)&matView );
//printmat4x4( "matProj", (float*)&matProj );
//printmat4x4( "result (view * proj) pre-transpose", (float*)&transpose );
D3DXMatrixTranspose( &transpose, &transpose );
#if 0 // turned off while we try to do fixup-Y in shader translate
if (IsPosix()) // flip all shader projection matrices for Y on GL since you can't have an upside-down viewport specification
{
// flip Y
transpose._21 *= -1.0f;
transpose._22 *= -1.0f;
transpose._23 *= -1.0f;
transpose._24 *= -1.0f;
}
#endif
//printmat4x4( "result (view * proj) post-transpose", (float*)&transpose );
}
SetVertexShaderConstant( VERTEX_SHADER_VIEWPROJ, transpose, 4 );
// If we're doing FastClip, the above viewproj matrix won't work well for
// vertex shaders which compute projPos.z, hence we'll compute a more useful
// viewproj and put the third row of it in another constant
transpose = GetTransform( MATERIAL_VIEW ) * GetTransform( MATERIAL_PROJECTION ); // Get the non-FastClip projection matrix
D3DXMatrixTranspose( &transpose, &transpose );
float *pRowTwo = (float *)transpose + 8;
SetVertexShaderConstant( VERTEX_SHADER_VIEWPROJ_THIRD_ROW, pRowTwo, 1 );
}
//GLMPRINTF(( "<-M- SetVertexShaderViewProj" ));
}
void CShaderAPIDx8::SetVertexShaderModelViewProjAndModelView( void )
{
//GLM_FUNC;
//GLMPRINTF(( ">-M- SetVertexShaderModelViewProjAndModelView" ));
if (g_pHardwareConfig->Caps().m_SupportsPixelShaders)
{
D3DXMATRIX modelView, transpose;
if (0)
{
D3DXMatrixMultiply( &modelView, &GetTransform(MATERIAL_MODEL), &GetTransform(MATERIAL_VIEW) );
D3DXMatrixMultiply( &transpose, &modelView, &GetProjectionMatrix() );
}
else
{
// show work
D3DXMATRIX matView,matProj,matModel;
matModel = GetTransform(MATERIAL_MODEL);
matView = GetTransform(MATERIAL_VIEW);
matProj = GetProjectionMatrix();
D3DXMatrixMultiply( &modelView, &matModel, &matView );
D3DXMatrixMultiply( &transpose, &modelView, &matProj );
//printmat4x4( "matModel", (float*)&matModel );
//printmat4x4( "matView", (float*)&matView );
//printmat4x4( "matProj", (float*)&matProj );
//printmat4x4( "result (model * view * proj) pre-transpose", (float*)&transpose );
}
D3DXMatrixTranspose( &transpose, &transpose );
#if 0 // turned off while we try to do fixup-Y in shader translate
if (IsPosix()) // flip all shader projection matrices for Y on GL since you can't have an upside-down viewport specification
{
// flip Y
transpose._21 *= -1.0f;
transpose._22 *= -1.0f;
transpose._23 *= -1.0f;
transpose._24 *= -1.0f;
}
#endif
SetVertexShaderConstant( VERTEX_SHADER_MODELVIEWPROJ, transpose, 4 );
// If we're doing FastClip, the above modelviewproj matrix won't work well for
// vertex shaders which compute projPos.z, hence we'll compute a more useful
// modelviewproj and put the third row of it in another constant
D3DXMatrixMultiply( &transpose, &modelView, &GetTransform( MATERIAL_PROJECTION ) ); // Get the non-FastClip projection matrix
D3DXMatrixTranspose( &transpose, &transpose );
float *pRowTwo = (float *)transpose + 8;
SetVertexShaderConstant( VERTEX_SHADER_MODELVIEWPROJ_THIRD_ROW, pRowTwo, 1 );
}
//GLMPRINTF(( "<-M- SetVertexShaderModelViewProjAndModelView" ));
}
void CShaderAPIDx8::UpdateVertexShaderMatrix( int iMatrix )
{
//GLM_FUNC;
if ( iMatrix == 0 )
{
int matrix = MATERIAL_MODEL;
if (VertexShaderTransformChanged(matrix))
{
int vertexShaderConstant = VERTEX_SHADER_MODEL + iMatrix * 3;
// Put the transform into the vertex shader constants...
D3DXMATRIX transpose;
D3DXMatrixTranspose( &transpose, &GetTransform(matrix) );
SetVertexShaderConstant( vertexShaderConstant, transpose, 3 );
// clear the change flag
m_DynamicState.m_TransformChanged[matrix] &= ~STATE_CHANGED_VERTEX_SHADER;
}
}
else
{
SetVertexShaderConstant( VERTEX_SHADER_MODEL + iMatrix, m_boneMatrix[iMatrix].Base(), 3 );
}
}
void CShaderAPIDx8::SetVertexShaderStateSkinningMatrices()
{
//GLM_FUNC;
// casting from 4x3 matrices to a 4x4 D3DXMATRIX, need 4 floats of overflow
float results[12+4];
// get the first one from the MATERIAL_MODEL matrix stack
D3DXMatrixTranspose( (D3DXMATRIX *)&results[0], &GetTransform( MATERIAL_MODEL ) );
memcpy( m_boneMatrix[0].Base(), results, 12 * sizeof(float) );
m_maxBoneLoaded++;
int matricesLoaded = max( 1, m_maxBoneLoaded );
m_maxBoneLoaded = 0;
m_DynamicState.m_TransformChanged[MATERIAL_MODEL] &= ~STATE_CHANGED_VERTEX_SHADER;
SetVertexShaderConstant( VERTEX_SHADER_MODEL, m_boneMatrix[0].Base(), matricesLoaded * 3, true );
// ###OSX### punting on OSX for now
#if defined( DX_TO_GL_ABSTRACTION ) && !defined( OSX )
Dx9Device()->SetMaxUsedVertexShaderConstantsHint( VERTEX_SHADER_MODEL + ( matricesLoaded * 3 ) );
#endif
}
//-----------------------------------------------------------------------------
// Commits vertex shader transforms that can change on a per pass basis
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitPerPassVertexShaderTransforms()
{
//GLMPRINTF(( ">-M- CommitPerPassVertexShaderTransforms" ));
Assert( g_pHardwareConfig->Caps().m_SupportsPixelShaders );
bool projChanged = VertexShaderTransformChanged( MATERIAL_PROJECTION );
//projChanged = true; //only for debug
if ( projChanged )
{
//GLMPRINTF(( "-M- projChanged=true in CommitPerPassVertexShaderTransforms" ));
SetVertexShaderViewProj();
SetVertexShaderModelViewProjAndModelView();
// Clear change flags
m_DynamicState.m_TransformChanged[MATERIAL_PROJECTION] &= ~STATE_CHANGED_VERTEX_SHADER;
}
else
{
//GLMPRINTF(( "-M- projChanged=false in CommitPerPassVertexShaderTransforms" ));
}
//GLMPRINTF(( "<-M- CommitPerPassVertexShaderTransforms" ));
}
//-----------------------------------------------------------------------------
// Commits vertex shader transforms
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitVertexShaderTransforms()
{
//GLMPRINTF(( ">-M- CommitVertexShaderTransforms" ));
Assert( g_pHardwareConfig->Caps().m_SupportsPixelShaders );
bool viewChanged = VertexShaderTransformChanged(MATERIAL_VIEW);
bool projChanged = VertexShaderTransformChanged(MATERIAL_PROJECTION);
bool modelChanged = VertexShaderTransformChanged(MATERIAL_MODEL) && (m_DynamicState.m_NumBones < 1);
//GLMPRINTF(( "-M- viewChanged=%s projChanged=%s modelChanged = %s in CommitVertexShaderTransforms", viewChanged?"Y":"N",projChanged?"Y":"N",modelChanged?"Y":"N" ));
if (viewChanged)
{
//GLMPRINTF(( "-M- viewChanged --> UpdateVertexShaderFogParams" ));
UpdateVertexShaderFogParams();
}
if( viewChanged || projChanged )
{
// NOTE: We have to deal with fast-clip *before*
//GLMPRINTF(( "-M- viewChanged||projChanged --> SetVertexShaderViewProj" ));
SetVertexShaderViewProj();
}
if( viewChanged || modelChanged || projChanged )
{
//GLMPRINTF(( "-M- viewChanged||projChanged||modelChanged --> SetVertexShaderModelViewProjAndModelView" ));
SetVertexShaderModelViewProjAndModelView();
}
if( modelChanged && m_DynamicState.m_NumBones < 1 )
{
UpdateVertexShaderMatrix( 0 );
}
// Clear change flags
m_DynamicState.m_TransformChanged[MATERIAL_MODEL] &= ~STATE_CHANGED_VERTEX_SHADER;
m_DynamicState.m_TransformChanged[MATERIAL_VIEW] &= ~STATE_CHANGED_VERTEX_SHADER;
m_DynamicState.m_TransformChanged[MATERIAL_PROJECTION] &= ~STATE_CHANGED_VERTEX_SHADER;
//GLMPRINTF(( "<-M- CommitVertexShaderTransforms" ));
}
void CShaderAPIDx8::UpdateFixedFunctionMatrix( int iMatrix )
{
if ( IsX360() )
return;
int matrix = MATERIAL_MODEL + iMatrix;
if ( FixedFunctionTransformChanged( matrix ) )
{
SetTransform( D3DTS_WORLDMATRIX(iMatrix), &GetTransform(matrix) );
// clear the change flag
m_DynamicState.m_TransformChanged[matrix] &= ~STATE_CHANGED_FIXED_FUNCTION;
}
}
void CShaderAPIDx8::SetFixedFunctionStateSkinningMatrices()
{
if ( IsX360() )
return;
for( int i=1; i < g_pHardwareConfig->MaxBlendMatrices(); i++ )
{
UpdateFixedFunctionMatrix( i );
}
}
//-----------------------------------------------------------------------------
// Commits transforms for the fixed function pipeline that can happen on a per pass basis
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitPerPassFixedFunctionTransforms()
{
if ( IsX360() )
return;
// Update projection
if ( FixedFunctionTransformChanged( MATERIAL_PROJECTION ) )
{
D3DTRANSFORMSTATETYPE matrix = D3DTS_PROJECTION;
SetTransform( matrix, &GetProjectionMatrix() );
// clear the change flag
m_DynamicState.m_TransformChanged[MATERIAL_PROJECTION] &= ~STATE_CHANGED_FIXED_FUNCTION;
}
}
//-----------------------------------------------------------------------------
// Commits transforms for the fixed function pipeline
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitFixedFunctionTransforms()
{
if ( IsX360() )
return;
// Update view + projection
int i;
for ( i = MATERIAL_VIEW; i <= MATERIAL_PROJECTION; ++i)
{
if (FixedFunctionTransformChanged( i ))
{
D3DTRANSFORMSTATETYPE matrix = (i == MATERIAL_VIEW) ? D3DTS_VIEW : D3DTS_PROJECTION;
if ( i == MATERIAL_PROJECTION )
{
SetTransform( matrix, &GetProjectionMatrix() );
}
else
{
SetTransform( matrix, &GetTransform(i) );
}
// clear the change flag
m_DynamicState.m_TransformChanged[i] &= ~STATE_CHANGED_FIXED_FUNCTION;
}
}
UpdateFixedFunctionMatrix( 0 );
}
void CShaderAPIDx8::SetSkinningMatrices()
{
LOCK_SHADERAPI();
Assert( m_pMaterial );
if ( m_DynamicState.m_NumBones == 0 )
{
// ###OSX### punting on OSX for now
#if defined( DX_TO_GL_ABSTRACTION ) && !defined( OSX)
Dx9Device()->SetMaxUsedVertexShaderConstantsHint( VERTEX_SHADER_BONE_TRANSFORM( 0 ) + 3 );
#endif
return;
}
uint nMaxVertexConstantIndex = 0;
if ( IsX360() || UsesVertexShader(m_pMaterial->GetVertexFormat()) )
{
SetVertexShaderStateSkinningMatrices();
}
else if ( IsPC() )
{
#if defined( DX_TO_GL_ABSTRACTION ) && !defined( OSX)
Assert( 0 );
#else
SetFixedFunctionStateSkinningMatrices();
#endif
}
else
{
Assert( 0 );
}
}
//-----------------------------------------------------------------------------
// Commits vertex shader lighting
//-----------------------------------------------------------------------------
inline bool CShaderAPIDx8::VertexShaderLightingChanged( int i )
{
return (m_DynamicState.m_LightChanged[i] & STATE_CHANGED_VERTEX_SHADER) != 0;
}
inline bool CShaderAPIDx8::VertexShaderLightingEnableChanged( int i )
{
return (m_DynamicState.m_LightEnableChanged[i] & STATE_CHANGED_VERTEX_SHADER) != 0;
}
inline bool CShaderAPIDx8::FixedFunctionLightingChanged( int i )
{
return (m_DynamicState.m_LightChanged[i] & STATE_CHANGED_FIXED_FUNCTION) != 0;
}
inline bool CShaderAPIDx8::FixedFunctionLightingEnableChanged( int i )
{
return (m_DynamicState.m_LightEnableChanged[i] & STATE_CHANGED_FIXED_FUNCTION) != 0;
}
//-----------------------------------------------------------------------------
// Computes the light type
//-----------------------------------------------------------------------------
VertexShaderLightTypes_t CShaderAPIDx8::ComputeLightType( int i ) const
{
if (!m_DynamicState.m_LightEnable[i])
return LIGHT_NONE;
switch( m_DynamicState.m_Lights[i].Type )
{
case D3DLIGHT_POINT:
return LIGHT_POINT;
case D3DLIGHT_DIRECTIONAL:
return LIGHT_DIRECTIONAL;
case D3DLIGHT_SPOT:
return LIGHT_SPOT;
}
Assert(0);
return LIGHT_NONE;
}
//-----------------------------------------------------------------------------
// Sort the lights by type
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SortLights( int* index )
{
m_DynamicState.m_NumLights = 0;
for (int i = 0; i < MAX_NUM_LIGHTS; ++i)
{
VertexShaderLightTypes_t type = ComputeLightType(i); // returns LIGHT_NONE if the light is disabled
int j = m_DynamicState.m_NumLights;
if (type != LIGHT_NONE)
{
while ( --j >= 0 )
{
if (m_DynamicState.m_LightType[j] <= type)
break;
// shift...
m_DynamicState.m_LightType[j+1] = m_DynamicState.m_LightType[j];
index[j+1] = index[j];
}
++j;
m_DynamicState.m_LightType[j] = type;
index[j] = i;
++m_DynamicState.m_NumLights;
}
}
}
//-----------------------------------------------------------------------------
// Vertex Shader lighting
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitVertexShaderLighting()
{
// If nothing changed, then don't bother. Otherwise, reload...
int i;
for ( i = 0; i < MAX_NUM_LIGHTS; ++i )
{
if (VertexShaderLightingChanged(i) || VertexShaderLightingEnableChanged(i))
break;
}
// Yeah baby
if ( i == MAX_NUM_LIGHTS )
return;
// First, gotta sort the lights by their type
int lightIndex[MAX_NUM_LIGHTS];
memset( lightIndex, 0, sizeof( lightIndex ) );
SortLights( lightIndex );
// Clear the lighting enable flags
for ( i = 0; i < MAX_NUM_LIGHTS; ++i )
{
m_DynamicState.m_LightEnableChanged[i] &= ~STATE_CHANGED_VERTEX_SHADER;
m_DynamicState.m_LightChanged[i] &= ~STATE_CHANGED_VERTEX_SHADER;
}
bool bAtLeastDX90 = g_pHardwareConfig->GetDXSupportLevel() >= 90;
// Set the lighting state
for ( i = 0; i < m_DynamicState.m_NumLights; ++i )
{
D3DLIGHT& light = m_DynamicState.m_Lights[lightIndex[i]];
Vector4D lightState[5];
// The first one is the light color (and light type code on DX9)
float w = (light.Type == D3DLIGHT_DIRECTIONAL) && bAtLeastDX90 ? 1.0f : 0.0f;
lightState[0].Init( light.Diffuse.r, light.Diffuse.g, light.Diffuse.b, w);
// The next constant holds the light direction (and light type code on DX9)
w = (light.Type == D3DLIGHT_SPOT) && bAtLeastDX90 ? 1.0f : 0.0f;
lightState[1].Init( light.Direction.x, light.Direction.y, light.Direction.z, w );
// The next constant holds the light position
lightState[2].Init( light.Position.x, light.Position.y, light.Position.z, 1.0f );
// The next constant holds exponent, stopdot, stopdot2, 1 / (stopdot - stopdot2)
if (light.Type == D3DLIGHT_SPOT)
{
float stopdot = cos( light.Theta * 0.5f );
float stopdot2 = cos( light.Phi * 0.5f );
float oodot = (stopdot > stopdot2) ? 1.0f / (stopdot - stopdot2) : 0.0f;
lightState[3].Init( light.Falloff, stopdot, stopdot2, oodot );
}
else
{
lightState[3].Init( 0, 1, 1, 1 );
}
// The last constant holds attenuation0, attenuation1, attenuation2
lightState[4].Init( light.Attenuation0, light.Attenuation1, light.Attenuation2, 0.0f );
// Set the state
SetVertexShaderConstant( VERTEX_SHADER_LIGHTS + i * 5, lightState[0].Base(), 5 );
}
if ( g_pHardwareConfig->NumIntegerVertexShaderConstants() > 0 && g_pHardwareConfig->NumBooleanVertexShaderConstants() > 0 )
{
// Vertex Shader loop counter for number of lights (Only the .x component is used by our shaders)
// .x is the iteration count, .y is the initial value and .z is the increment step
int nLoopControl[4] = {m_DynamicState.m_NumLights, 0, 1, 0};
SetIntegerVertexShaderConstant( 0, nLoopControl, 1 );
// Enable lights using vertex shader static flow control
int nLightEnable[VERTEX_SHADER_LIGHT_ENABLE_BOOL_CONST_COUNT] = {0, 0, 0, 0};
for ( i = 0; i < m_DynamicState.m_NumLights; ++i )
{
nLightEnable[i] = 1;
}
SetBooleanVertexShaderConstant( VERTEX_SHADER_LIGHT_ENABLE_BOOL_CONST, nLightEnable, VERTEX_SHADER_LIGHT_ENABLE_BOOL_CONST_COUNT );
}
}
//-----------------------------------------------------------------------------
// Set the pixel shader constants for lights
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitPixelShaderLighting( int pshReg )
{
#ifndef NDEBUG
char const *materialName = m_pMaterial->GetName();
#endif
// First, gotta sort the lights by their type
int lightIndex[MAX_NUM_LIGHTS];
SortLights( lightIndex );
// Offset to create a point light from directional
const float fFarAway = 10000.0f;
// Total pixel shader lighting state for four lights
Vector4D lightState[6];
for ( int i = 0; i < 6; i++ )
lightState[i].Init();
int nNumLights = m_DynamicState.m_NumLights;
if ( nNumLights > 0 )
{
D3DLIGHT *light = &m_DynamicState.m_Lights[lightIndex[0]];
lightState[0].Init( light->Diffuse.r, light->Diffuse.g, light->Diffuse.b, 0.0f );
if ( light->Type == D3DLIGHT_DIRECTIONAL )
{
Vector vDir(light->Direction.x, light->Direction.y, light->Direction.z );
Vector vPos = m_DynamicState.m_vLightingOrigin - vDir * fFarAway;
lightState[1].Init( vPos.x, vPos.y, vPos.z, 0.0f );
}
else
{
lightState[1].Init( light->Position.x, light->Position.y, light->Position.z, 0.0f );
}
if ( nNumLights > 1 ) // At least two lights
{
light = &m_DynamicState.m_Lights[lightIndex[1]];
lightState[2].Init( light->Diffuse.r, light->Diffuse.g, light->Diffuse.b, 0.0f );
if ( light->Type == D3DLIGHT_DIRECTIONAL )
{
Vector vDir(light->Direction.x, light->Direction.y, light->Direction.z );
Vector vPos = m_DynamicState.m_vLightingOrigin - vDir * fFarAway;
lightState[3].Init( vPos.x, vPos.y, vPos.z, 0.0f );
}
else
{
lightState[3].Init( light->Position.x, light->Position.y, light->Position.z, 0.0f );
}
if ( nNumLights > 2 ) // At least three lights
{
light = &m_DynamicState.m_Lights[lightIndex[2]];
lightState[4].Init( light->Diffuse.r, light->Diffuse.g, light->Diffuse.b, 0.0f );
if ( light->Type == D3DLIGHT_DIRECTIONAL )
{
Vector vDir(light->Direction.x, light->Direction.y, light->Direction.z );
Vector vPos = m_DynamicState.m_vLightingOrigin - vDir * fFarAway;
lightState[5].Init( vPos.x, vPos.y, vPos.z, 0.0f );
}
else
{
lightState[5].Init( light->Position.x, light->Position.y, light->Position.z, 0.0f );
}
if ( nNumLights > 3 ) // At least four lights (our current max)
{
light = &m_DynamicState.m_Lights[lightIndex[3]]; // Spread 4th light's constants across w components
lightState[0].w = light->Diffuse.r;
lightState[1].w = light->Diffuse.g;
lightState[2].w = light->Diffuse.b;
if ( light->Type == D3DLIGHT_DIRECTIONAL )
{
Vector vDir(light->Direction.x, light->Direction.y, light->Direction.z );
Vector vPos = m_DynamicState.m_vLightingOrigin - vDir * fFarAway;
lightState[3].w = vPos.x;
lightState[4].w = vPos.y;
lightState[5].w = vPos.z;
}
else
{
lightState[3].w = light->Position.x;
lightState[4].w = light->Position.y;
lightState[5].w = light->Position.z;
}
}
}
}
}
SetPixelShaderConstant( pshReg, lightState[0].Base(), 6 );
}
//-----------------------------------------------------------------------------
// Fixed function lighting
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitFixedFunctionLighting()
{
if ( IsX360() )
{
return;
}
// Commit each light
for (int i = 0; i < g_pHardwareConfig->MaxNumLights(); ++i)
{
// Change light enable
if ( FixedFunctionLightingEnableChanged( i ) )
{
LightEnable( i, m_DynamicState.m_LightEnable[i] );
// Clear change flag
m_DynamicState.m_LightEnableChanged[i] &= ~STATE_CHANGED_FIXED_FUNCTION;
}
// Change lighting state...
if ( m_DynamicState.m_LightEnable[i] )
{
if ( FixedFunctionLightingChanged( i ) )
{
// Store off the "correct" falloff...
D3DLIGHT& light = m_DynamicState.m_Lights[i];
float falloff = light.Falloff;
SetLight( i, &light );
// Clear change flag
m_DynamicState.m_LightChanged[i] &= ~STATE_CHANGED_FIXED_FUNCTION;
// restore the correct falloff
light.Falloff = falloff;
}
}
}
}
//-----------------------------------------------------------------------------
// Commits user clip planes
//-----------------------------------------------------------------------------
D3DXMATRIX& CShaderAPIDx8::GetUserClipTransform( )
{
if ( !m_DynamicState.m_bUserClipTransformOverride )
return GetTransform(MATERIAL_VIEW);
return m_DynamicState.m_UserClipTransform;
}
//-----------------------------------------------------------------------------
// Commits user clip planes
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitUserClipPlanes( bool bUsingFixedFunction )
{
// We need to transform the clip planes, specified in world space,
// to be in projection space.. To transform the plane, we must transform
// the intercept and then transform the normal.
if( bUsingFixedFunction != m_DynamicState.m_UserClipLastUpdatedUsingFixedFunction )
{
//fixed function clip planes are in world space, vertex shader clip planes are in clip space, so we need to update every clip plane whenever there's a flip
m_DynamicState.m_UserClipPlaneChanged = (1 << g_pHardwareConfig->MaxUserClipPlanes()) - 1;
m_DynamicState.m_UserClipLastUpdatedUsingFixedFunction = bUsingFixedFunction;
}
D3DXMATRIX worldToProjectionInvTrans;
#ifndef _DEBUG
if( m_DynamicState.m_UserClipPlaneChanged & m_DynamicState.m_UserClipPlaneEnabled & ((1 << g_pHardwareConfig->MaxUserClipPlanes()) - 1) )
#endif
{
//we're going to need the transformation matrix at least once this call
if( bUsingFixedFunction )
{
if( m_DynamicState.m_bUserClipTransformOverride )
{
//D3DXMatrixIdentity( &worldToProjectionInvTrans ); //TODO: Test user clip transforms with this
//Since GetUserClipTransform() returns the view matrix if a user supplied transform doesn't exist, the general solution to this should be to transform the user transform by the inverse view matrix
//Since we don't know if the user clip is invertable, we'll premultiply by inverse view and cross our fingers that it's right more often than wrong
D3DXMATRIX viewInverse = GetTransform( MATERIAL_VIEW );
D3DXMatrixInverse(&viewInverse, NULL, &viewInverse);
worldToProjectionInvTrans = viewInverse * GetUserClipTransform(); //taking a cue from the multiplication below, multiplication goes left into right
D3DXMatrixInverse(&worldToProjectionInvTrans, NULL, &worldToProjectionInvTrans);
D3DXMatrixTranspose(&worldToProjectionInvTrans, &worldToProjectionInvTrans);
}
else
{
D3DXMatrixIdentity( &worldToProjectionInvTrans );
}
}
else
{
worldToProjectionInvTrans = GetUserClipTransform( ) * GetTransform( MATERIAL_PROJECTION );
D3DXMatrixInverse(&worldToProjectionInvTrans, NULL, &worldToProjectionInvTrans);
D3DXMatrixTranspose(&worldToProjectionInvTrans, &worldToProjectionInvTrans);
}
}
for (int i = 0; i < g_pHardwareConfig->MaxUserClipPlanes(); ++i)
{
// Don't bother with the plane if it's not enabled
if ( (m_DynamicState.m_UserClipPlaneEnabled & (1 << i)) == 0 )
continue;
// Don't bother if it didn't change...
if ( (m_DynamicState.m_UserClipPlaneChanged & (1 << i)) == 0 )
{
#ifdef _DEBUG
//verify that the plane has not actually changed
D3DXPLANE clipPlaneProj;
D3DXPlaneTransform( &clipPlaneProj, &m_DynamicState.m_UserClipPlaneWorld[i], &worldToProjectionInvTrans );
Assert ( clipPlaneProj == m_DynamicState.m_UserClipPlaneProj[i] );
#endif
continue;
}
m_DynamicState.m_UserClipPlaneChanged &= ~(1 << i);
D3DXPLANE clipPlaneProj;
D3DXPlaneTransform( &clipPlaneProj, &m_DynamicState.m_UserClipPlaneWorld[i], &worldToProjectionInvTrans );
if ( clipPlaneProj != m_DynamicState.m_UserClipPlaneProj[i] )
{
Dx9Device()->SetClipPlane( i, (float*)clipPlaneProj );
m_DynamicState.m_UserClipPlaneProj[i] = clipPlaneProj;
}
}
}
//-----------------------------------------------------------------------------
// Need to handle fog mode on a per-pass basis
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitPerPassFogMode( bool bUsingVertexAndPixelShaders )
{
if ( IsX360() )
{
// FF fog not applicable on 360
return;
}
D3DFOGMODE dxFogMode = D3DFOG_NONE;
if ( m_DynamicState.m_FogEnable )
{
dxFogMode = bUsingVertexAndPixelShaders ? D3DFOG_NONE : D3DFOG_LINEAR;
}
// Set fog mode if it's different than before.
if( m_DynamicState.m_FogMode != dxFogMode )
{
SetRenderStateConstMacro( this, D3DRS_FOGVERTEXMODE, dxFogMode );
m_DynamicState.m_FogMode = dxFogMode;
}
}
//-----------------------------------------------------------------------------
// Handle Xbox GPU/DX API fixups necessary before actual draw.
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitPerPassXboxFixups()
{
#if defined( _X360 )
// send updated shader constants to gpu
WriteShaderConstantsToGPU();
// sRGB write state may have changed after RT set, have to re-set correct RT
SetRenderTargetInternalXbox( m_hCachedRenderTarget );
#endif
}
//-----------------------------------------------------------------------------
// These states can change between each pass
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitPerPassStateChanges( StateSnapshot_t id )
{
if ( IsX360() || UsesVertexAndPixelShaders(id) )
{
CommitPerPassVertexShaderTransforms();
CommitPerPassFogMode( true );
CommitPerPassXboxFixups();
CallCommitFuncs( COMMIT_PER_PASS, false );
}
else if ( IsPC() )
{
CommitPerPassFixedFunctionTransforms();
CommitPerPassFogMode( false );
CallCommitFuncs( COMMIT_PER_PASS, true );
}
else
{
Assert( 0 );
}
}
//-----------------------------------------------------------------------------
// Commits transforms and lighting
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CommitStateChanges()
{
VPROF("CShaderAPIDx8::CommitStateChanges");
CommitFastClipPlane();
bool bUsingFixedFunction = !IsX360() && m_pMaterial && !UsesVertexShader( m_pMaterial->GetVertexFormat() );
// xboxissue - cannot support ff pipeline
Assert ( IsPC() || ( IsX360() && !bUsingFixedFunction ) );
if ( IsX360() || !bUsingFixedFunction )
{
CommitVertexShaderTransforms();
if ( m_pMaterial && m_pMaterial->IsVertexLit() )
{
CommitVertexShaderLighting();
}
}
else if ( IsPC() )
{
CommitFixedFunctionTransforms();
if ( m_pMaterial && ( m_pMaterial->IsVertexLit() || m_pMaterial->NeedsFixedFunctionFlashlight() ) )
{
CommitFixedFunctionLighting();
}
}
else
{
Assert( 0 );
}
if ( m_DynamicState.m_UserClipPlaneEnabled )
{
CommitUserClipPlanes( bUsingFixedFunction );
}
CallCommitFuncs( COMMIT_PER_DRAW, bUsingFixedFunction );
}
//-----------------------------------------------------------------------------
// Commits viewports
//-----------------------------------------------------------------------------
static void CommitSetViewports( IDirect3DDevice9 *pDevice, const DynamicState_t &desiredState, DynamicState_t &currentState, bool bForce )
{
bool bChanged = bForce || memcmp( &desiredState.m_Viewport, &currentState.m_Viewport, sizeof(D3DVIEWPORT9) );
// The width + height can be zero at startup sometimes.
if ( bChanged && ( desiredState.m_Viewport.Width != 0 ) && ( desiredState.m_Viewport.Height != 0 ) )
{
if( ReverseDepthOnX360() ) //reverse depth on 360 for better perf through hierarchical z
{
D3DVIEWPORT9 reverseDepthViewport;
reverseDepthViewport = desiredState.m_Viewport;
reverseDepthViewport.MinZ = 1.0f - desiredState.m_Viewport.MinZ;
reverseDepthViewport.MaxZ = 1.0f - desiredState.m_Viewport.MaxZ;
Dx9Device()->SetViewport( &reverseDepthViewport );
}
else
{
Dx9Device()->SetViewport( &desiredState.m_Viewport );
}
memcpy( &currentState.m_Viewport, &desiredState.m_Viewport, sizeof( D3DVIEWPORT9 ) );
}
}
void CShaderAPIDx8::SetViewports( int nCount, const ShaderViewport_t* pViewports )
{
Assert( nCount == 1 && pViewports[0].m_nVersion == SHADER_VIEWPORT_VERSION );
if ( nCount != 1 )
return;
LOCK_SHADERAPI();
D3DVIEWPORT9 viewport;
viewport.X = pViewports[0].m_nTopLeftX;
viewport.Y = pViewports[0].m_nTopLeftY;
viewport.Width = pViewports[0].m_nWidth;
viewport.Height = pViewports[0].m_nHeight;
viewport.MinZ = pViewports[0].m_flMinZ;
viewport.MaxZ = pViewports[0].m_flMaxZ;
// Clamp the viewport to the current render target...
if ( !m_UsingTextureRenderTarget )
{
// Clamp to both the back buffer and the window, if it is resizing
int nMaxWidth = 0, nMaxHeight = 0;
GetBackBufferDimensions( nMaxWidth, nMaxHeight );
if ( IsPC() && m_IsResizing )
{
RECT viewRect;
#if !defined( DX_TO_GL_ABSTRACTION )
GetClientRect( ( HWND )m_ViewHWnd, &viewRect );
#else
toglGetClientRect( (VD3DHWND)m_ViewHWnd, &viewRect );
#endif
m_nWindowWidth = viewRect.right - viewRect.left;
m_nWindowHeight = viewRect.bottom - viewRect.top;
nMaxWidth = min( m_nWindowWidth, nMaxWidth );
nMaxHeight = min( m_nWindowHeight, nMaxHeight );
}
// Dimensions can freak out on app exit, so at least make sure the viewport is positive
if ( (viewport.Width > (unsigned int)nMaxWidth ) && (nMaxWidth > 0) )
{
viewport.Width = nMaxWidth;
}
// Dimensions can freak out on app exit, so at least make sure the viewport is positive
if ( ( viewport.Height > (unsigned int)nMaxHeight ) && (nMaxHeight > 0) )
{
viewport.Height = nMaxHeight;
}
}
else
{
if ( viewport.Width > (unsigned int)m_ViewportMaxWidth )
{
viewport.Width = m_ViewportMaxWidth;
}
if ( viewport.Height > (unsigned int)m_ViewportMaxHeight )
{
viewport.Height = m_ViewportMaxHeight;
}
}
// FIXME: Once we extract buffered primitives out, we can directly fill in desired state
// and avoid the memcmp and copy
if ( memcmp( &m_DesiredState.m_Viewport, &viewport, sizeof(D3DVIEWPORT9) ) )
{
if ( !IsDeactivated() )
{
// State changed... need to flush the dynamic buffer
FlushBufferedPrimitives();
}
memcpy( &m_DesiredState.m_Viewport, &viewport, sizeof(D3DVIEWPORT9) );
}
ADD_COMMIT_FUNC( COMMIT_PER_DRAW, COMMIT_ALWAYS, CommitSetViewports );
}
//-----------------------------------------------------------------------------
// Gets the current viewport size
//-----------------------------------------------------------------------------
int CShaderAPIDx8::GetViewports( ShaderViewport_t* pViewports, int nMax ) const
{
if ( !pViewports || nMax == 0 )
return 1;
LOCK_SHADERAPI();
pViewports[0].m_nTopLeftX = m_DesiredState.m_Viewport.X;
pViewports[0].m_nTopLeftY = m_DesiredState.m_Viewport.Y;
pViewports[0].m_nWidth = m_DesiredState.m_Viewport.Width;
pViewports[0].m_nHeight = m_DesiredState.m_Viewport.Height;
pViewports[0].m_flMinZ = m_DesiredState.m_Viewport.MinZ;
pViewports[0].m_flMaxZ = m_DesiredState.m_Viewport.MaxZ;
return 1;
}
//-----------------------------------------------------------------------------
// Flushes buffered primitives
//-----------------------------------------------------------------------------
void CShaderAPIDx8::FlushBufferedPrimitives( )
{
if ( ShaderUtil() )
{
if ( !ShaderUtil()->OnFlushBufferedPrimitives() )
{
return;
}
}
FlushBufferedPrimitivesInternal();
}
void CShaderAPIDx8::FlushBufferedPrimitivesInternal( )
{
LOCK_SHADERAPI();
// This shouldn't happen in the inner rendering loop!
Assert( m_pRenderMesh == 0 );
// NOTE: We've gotta store off the matrix mode because
// it'll get reset by the default state application caused by the flush
int tempStack = m_CurrStack;
D3DTRANSFORMSTATETYPE tempMatrixMode = m_MatrixMode;
MeshMgr()->Flush();
m_CurrStack = tempStack;
m_MatrixMode = tempMatrixMode;
}
//-----------------------------------------------------------------------------
// Flush the hardware
//-----------------------------------------------------------------------------
void CShaderAPIDx8::FlushHardware( )
{
LOCK_SHADERAPI();
FlushBufferedPrimitives();
Dx9Device()->EndScene();
DiscardVertexBuffers();
Dx9Device()->BeginScene();
ForceHardwareSync();
}
//-----------------------------------------------------------------------------
// Deal with device lost (alt-tab)
//-----------------------------------------------------------------------------
void CShaderAPIDx8::HandleDeviceLost()
{
if ( IsX360() )
{
return;
}
LOCK_SHADERAPI();
if ( !IsActive() )
return;
// need to flush the dynamic buffer
FlushBufferedPrimitives();
if ( !IsDeactivated() )
{
Dx9Device()->EndScene();
}
CheckDeviceLost( m_bOtherAppInitializing );
if ( !IsDeactivated() )
{
Dx9Device()->BeginScene();
}
}
//-----------------------------------------------------------------------------
// Buffer clear color
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ClearColor3ub( unsigned char r, unsigned char g, unsigned char b )
{
LOCK_SHADERAPI();
float a = 255;//(r * 0.30f + g * 0.59f + b * 0.11f) / MAX_HDR_OVERBRIGHT;
// GR - need to force alpha to black for HDR
m_DynamicState.m_ClearColor = D3DCOLOR_ARGB((unsigned char)a,r,g,b);
}
void CShaderAPIDx8::ClearColor4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a )
{
LOCK_SHADERAPI();
m_DynamicState.m_ClearColor = D3DCOLOR_ARGB(a,r,g,b);
}
// Converts the clear color to be appropriate for HDR
D3DCOLOR CShaderAPIDx8::GetActualClearColor( D3DCOLOR clearColor )
{
bool bConvert = !IsX360() && m_TransitionTable.CurrentState().m_bLinearColorSpaceFrameBufferEnable;
#if defined( _X360 )
// The PC disables SRGBWrite when clearing so that the clear color won't get gamma converted
// The 360 cannot disable that state, and thus compensates for the sRGB conversion
// the desired result is the clear color written to the RT as-is
if ( clearColor & D3DCOLOR_ARGB( 0, 255, 255, 255 ) )
{
IDirect3DSurface *pRTSurface = NULL;
Dx9Device()->GetRenderTarget( 0, &pRTSurface );
if ( pRTSurface )
{
D3DSURFACE_DESC desc;
HRESULT hr = pRTSurface->GetDesc( &desc );
if ( !FAILED( hr ) && IS_D3DFORMAT_SRGB( desc.Format ) )
{
bConvert = true;
}
pRTSurface->Release();
}
}
#endif
if ( bConvert )
{
// HDRFIXME: need to make sure this works this way.
// HDRFIXME: Is there a helper function that'll do this easier?
// convert clearColor from gamma to linear since our frame buffer is linear.
Vector vecGammaColor;
vecGammaColor.x = ( 1.0f / 255.0f ) * ( ( clearColor >> 16 ) & 0xff );
vecGammaColor.y = ( 1.0f / 255.0f ) * ( ( clearColor >> 8 ) & 0xff );
vecGammaColor.z = ( 1.0f / 255.0f ) * ( clearColor & 0xff );
Vector vecLinearColor;
vecLinearColor.x = GammaToLinear( vecGammaColor.x );
vecLinearColor.y = GammaToLinear( vecGammaColor.y );
vecLinearColor.z = GammaToLinear( vecGammaColor.z );
clearColor &= D3DCOLOR_RGBA( 0, 0, 0, 255 );
clearColor |= D3DCOLOR_COLORVALUE( vecLinearColor.x, vecLinearColor.y, vecLinearColor.z, 0.0f );
}
return clearColor;
}
//-----------------------------------------------------------------------------
// Clear buffers while obeying stencil
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ClearBuffersObeyStencil( bool bClearColor, bool bClearDepth )
{
//copy the clear color bool into the clear alpha bool
ClearBuffersObeyStencilEx( bClearColor, bClearColor, bClearDepth );
}
void CShaderAPIDx8::ClearBuffersObeyStencilEx( bool bClearColor, bool bClearAlpha, bool bClearDepth )
{
LOCK_SHADERAPI();
if ( !bClearColor && !bClearAlpha && !bClearDepth )
return;
FlushBufferedPrimitives();
// Before clearing can happen, user clip planes must be disabled
SetRenderState( D3DRS_CLIPPLANEENABLE, 0 );
D3DCOLOR clearColor = GetActualClearColor( m_DynamicState.m_ClearColor );
unsigned char r, g, b, a;
b = clearColor& 0xFF;
g = ( clearColor >> 8 ) & 0xFF;
r = ( clearColor >> 16 ) & 0xFF;
a = ( clearColor >> 24 ) & 0xFF;
ShaderUtil()->DrawClearBufferQuad( r, g, b, a, bClearColor, bClearAlpha, bClearDepth );
// Reset user clip plane state
FlushBufferedPrimitives();
SetRenderState( D3DRS_CLIPPLANEENABLE, m_DynamicState.m_UserClipPlaneEnabled );
}
//-------------------------------------------------------------------------
//Perform stencil operations to every pixel on the screen
//-------------------------------------------------------------------------
void CShaderAPIDx8::PerformFullScreenStencilOperation( void )
{
LOCK_SHADERAPI();
FlushBufferedPrimitives();
// We'll be drawing a large quad in altered worldspace, user clip planes must be disabled
SetRenderStateConstMacro( this, D3DRS_CLIPPLANEENABLE, 0 );
ShaderUtil()->DrawClearBufferQuad( 0, 0, 0, 0, false, false, false );
// Reset user clip plane state
FlushBufferedPrimitives();
SetRenderStateConstMacro( this, D3DRS_CLIPPLANEENABLE, m_DynamicState.m_UserClipPlaneEnabled );
}
//-----------------------------------------------------------------------------
// Buffer clear
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ClearBuffers( bool bClearColor, bool bClearDepth, bool bClearStencil, int renderTargetWidth, int renderTargetHeight )
{
LOCK_SHADERAPI();
if ( ShaderUtil()->GetConfig().m_bSuppressRendering )
return;
if ( IsDeactivated() )
return;
// State changed... need to flush the dynamic buffer
FlushBufferedPrimitives();
CallCommitFuncs( COMMIT_PER_DRAW, true );
float depth = (ShaderUtil()->GetConfig().bReverseDepth ^ ReverseDepthOnX360()) ? 0.0f : 1.0f;
DWORD mask = 0;
if ( bClearColor )
{
mask |= D3DCLEAR_TARGET;
}
if ( bClearDepth )
{
mask |= D3DCLEAR_ZBUFFER;
}
if ( bClearStencil && m_bUsingStencil )
{
mask |= D3DCLEAR_STENCIL;
}
// Only clear the current view... right!??!
D3DRECT clear;
clear.x1 = m_DesiredState.m_Viewport.X;
clear.y1 = m_DesiredState.m_Viewport.Y;
clear.x2 = clear.x1 + m_DesiredState.m_Viewport.Width;
clear.y2 = clear.y1 + m_DesiredState.m_Viewport.Height;
// SRGBWrite is disabled when clearing so that the clear color won't get gamma converted
bool bSRGBWriteEnable = false;
if ( !IsX360() && bClearColor && m_TransitionTable.CurrentShadowState() )
{
bSRGBWriteEnable = m_TransitionTable.CurrentShadowState()->m_SRGBWriteEnable;
}
#if !defined( _X360 )
if ( bSRGBWriteEnable )
{
// This path used to be !IsPosix(), but this makes no sense and causes the clear color to differ in D3D9 vs. GL.
Dx9Device()->SetRenderState( D3DRS_SRGBWRITEENABLE, 0 );
}
#endif
D3DCOLOR clearColor = GetActualClearColor( m_DynamicState.m_ClearColor );
if ( mask != 0 )
{
bool bRenderTargetMatchesViewport =
( renderTargetWidth == -1 && renderTargetHeight == -1 ) ||
( m_DesiredState.m_Viewport.Width == -1 && m_DesiredState.m_Viewport.Height == -1 ) ||
( renderTargetWidth == ( int )m_DesiredState.m_Viewport.Width &&
renderTargetHeight == ( int )m_DesiredState.m_Viewport.Height );
if ( bRenderTargetMatchesViewport )
{
RECORD_COMMAND( DX8_CLEAR, 6 );
RECORD_INT( 0 );
RECORD_STRUCT( &clear, sizeof(clear) );
RECORD_INT( mask );
RECORD_INT( clearColor );
RECORD_FLOAT( depth );
RECORD_INT( 0 );
Dx9Device()->Clear( 0, NULL, mask, clearColor, depth, 0L );
}
else
{
RECORD_COMMAND( DX8_CLEAR, 6 );
RECORD_INT( 0 );
RECORD_STRUCT( &clear, sizeof(clear) );
RECORD_INT( mask );
RECORD_INT( clearColor );
RECORD_FLOAT( depth );
RECORD_INT( 0 );
Dx9Device()->Clear( 1, &clear, mask, clearColor, depth, 0L );
}
}
// Restore state
if ( bSRGBWriteEnable )
{
// sRGBWriteEnable shouldn't be true if we have no shadow state. . . Assert just in case.
Assert( m_TransitionTable.CurrentShadowState() );
m_TransitionTable.ApplySRGBWriteEnable( *m_TransitionTable.CurrentShadowState() );
}
}
//-----------------------------------------------------------------------------
// Bind
//-----------------------------------------------------------------------------
void CShaderAPIDx8::BindVertexShader( VertexShaderHandle_t hVertexShader )
{
ShaderManager()->BindVertexShader( hVertexShader );
}
void CShaderAPIDx8::BindGeometryShader( GeometryShaderHandle_t hGeometryShader )
{
Assert( hGeometryShader == GEOMETRY_SHADER_HANDLE_INVALID );
}
void CShaderAPIDx8::BindPixelShader( PixelShaderHandle_t hPixelShader )
{
ShaderManager()->BindPixelShader( hPixelShader );
}
//-----------------------------------------------------------------------------
// Returns a copy of the front buffer
//-----------------------------------------------------------------------------
IDirect3DSurface* CShaderAPIDx8::GetFrontBufferImage( ImageFormat& format )
{
#if !defined( _X360 )
// need to flush the dynamic buffer and make sure the entire image is there
FlushBufferedPrimitives();
int w, h;
GetBackBufferDimensions( w, h );
HRESULT hr;
IDirect3DSurface *pFullScreenSurfaceBits = 0;
hr = Dx9Device()->CreateOffscreenPlainSurface( w, h,
D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pFullScreenSurfaceBits, NULL );
if (FAILED(hr))
return 0;
hr = Dx9Device()->GetFrontBufferData( 0, pFullScreenSurfaceBits );
if (FAILED(hr))
return 0;
int windowWidth, windowHeight;
GetWindowSize( windowWidth, windowHeight );
IDirect3DSurface *pSurfaceBits = 0;
hr = Dx9Device()->CreateOffscreenPlainSurface( windowWidth, windowHeight,
D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pSurfaceBits, NULL );
Assert( hr == D3D_OK );
POINT pnt;
pnt.x = pnt.y = 0;
#ifdef _WIN32
BOOL result = ClientToScreen( ( HWND )m_hWnd, &pnt );
#else
BOOL result = ClientToScreen( (VD3DHWND)m_hWnd, &pnt );
#endif
Assert( result );
RECT srcRect;
srcRect.left = pnt.x;
srcRect.top = pnt.y;
srcRect.right = pnt.x + windowWidth;
srcRect.bottom = pnt.y + windowHeight;
POINT dstPnt;
dstPnt.x = dstPnt.y = 0;
D3DLOCKED_RECT lockedSrcRect;
hr = pFullScreenSurfaceBits->LockRect( &lockedSrcRect, &srcRect, D3DLOCK_READONLY );
Assert( hr == D3D_OK );
D3DLOCKED_RECT lockedDstRect;
hr = pSurfaceBits->LockRect( &lockedDstRect, NULL, 0 );
Assert( hr == D3D_OK );
int i;
for( i = 0; i < windowHeight; i++ )
{
memcpy( ( unsigned char * )lockedDstRect.pBits + ( i * lockedDstRect.Pitch ),
( unsigned char * )lockedSrcRect.pBits + ( i * lockedSrcRect.Pitch ),
windowWidth * 4 ); // hack . . what if this is a different format?
}
hr = pSurfaceBits->UnlockRect();
Assert( hr == D3D_OK );
hr = pFullScreenSurfaceBits->UnlockRect();
Assert( hr == D3D_OK );
pFullScreenSurfaceBits->Release();
format = ImageLoader::D3DFormatToImageFormat( D3DFMT_A8R8G8B8 );
return pSurfaceBits;
#else
Assert( 0 );
return NULL;
#endif
}
//-----------------------------------------------------------------------------
// Lets the shader know about the full-screen texture so it can
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetFullScreenTextureHandle( ShaderAPITextureHandle_t h )
{
LOCK_SHADERAPI();
m_hFullScreenTexture = h;
}
//-----------------------------------------------------------------------------
// Lets the shader know about the full-screen texture so it can
//-----------------------------------------------------------------------------
void CShaderAPIDx8::SetLinearToGammaConversionTextures( ShaderAPITextureHandle_t hSRGBWriteEnabledTexture, ShaderAPITextureHandle_t hIdentityTexture )
{
LOCK_SHADERAPI();
m_hLinearToGammaTableTexture = hSRGBWriteEnabledTexture;
m_hLinearToGammaTableIdentityTexture = hIdentityTexture;
}
//-----------------------------------------------------------------------------
// Returns a copy of the back buffer
//-----------------------------------------------------------------------------
IDirect3DSurface* CShaderAPIDx8::GetBackBufferImageHDR( Rect_t *pSrcRect, Rect_t *pDstRect, ImageFormat& format )
{
#if !defined( _X360 )
HRESULT hr;
IDirect3DSurface *pSurfaceBits = 0;
IDirect3DSurface *pTmpSurface = NULL;
// Get the back buffer
IDirect3DSurface* pBackBuffer;
hr = Dx9Device()->GetRenderTarget( 0, &pBackBuffer );
if (FAILED(hr))
return 0;
// Find about its size and format
D3DSURFACE_DESC desc;
D3DTEXTUREFILTERTYPE filter;
hr = pBackBuffer->GetDesc( &desc );
if (FAILED(hr))
goto CleanUp;
filter = ((pDstRect->width != pSrcRect->width) || (pDstRect->height != pSrcRect->height)) ? D3DTEXF_LINEAR : D3DTEXF_NONE;
if ( ( pDstRect->x + pDstRect->width <= SMALL_BACK_BUFFER_SURFACE_WIDTH ) &&
( pDstRect->y + pDstRect->height <= SMALL_BACK_BUFFER_SURFACE_HEIGHT ) )
{
if (!m_pSmallBackBufferFP16TempSurface)
{
hr = Dx9Device()->CreateRenderTarget(
SMALL_BACK_BUFFER_SURFACE_WIDTH, SMALL_BACK_BUFFER_SURFACE_HEIGHT,
desc.Format, D3DMULTISAMPLE_NONE, 0, TRUE, &m_pSmallBackBufferFP16TempSurface,
NULL );
}
pTmpSurface = m_pSmallBackBufferFP16TempSurface;
#if POSIX
pTmpSurface->AddRef( 0, "CShaderAPIDx8::GetBackBufferImageHDR public addref");
#else
pTmpSurface->AddRef();
#endif
desc.Width = SMALL_BACK_BUFFER_SURFACE_WIDTH;
desc.Height = SMALL_BACK_BUFFER_SURFACE_HEIGHT;
RECT srcRect, destRect;
RectToRECT( pSrcRect, srcRect );
RectToRECT( pDstRect, destRect );
hr = Dx9Device()->StretchRect( pBackBuffer, &srcRect, pTmpSurface, &destRect, filter );
if ( FAILED(hr) )
goto CleanUp;
}
else
{
// Normally we would only have to create a separate render target here and StretchBlt to it first
// if AA was enabled, but certain machines/drivers get reboots if we do GetRenderTargetData
// straight off the backbuffer.
hr = Dx9Device()->CreateRenderTarget( desc.Width, desc.Height, desc.Format,
D3DMULTISAMPLE_NONE, 0, TRUE, &pTmpSurface, NULL );
if ( FAILED(hr) )
goto CleanUp;
hr = Dx9Device()->StretchRect( pBackBuffer, NULL, pTmpSurface, NULL, filter );
if ( FAILED(hr) )
goto CleanUp;
}
// Create a buffer the same size and format
hr = Dx9Device()->CreateOffscreenPlainSurface( desc.Width, desc.Height,
desc.Format, D3DPOOL_SYSTEMMEM, &pSurfaceBits, NULL );
if (FAILED(hr))
goto CleanUp;
// Blit from the back buffer to our scratch buffer
hr = Dx9Device()->GetRenderTargetData( pTmpSurface ? pTmpSurface : pBackBuffer, pSurfaceBits );
if (FAILED(hr))
goto CleanUp2;
format = ImageLoader::D3DFormatToImageFormat(desc.Format);
if ( pTmpSurface )
{
pTmpSurface->Release();
}
pBackBuffer->Release();
return pSurfaceBits;
CleanUp2:
pSurfaceBits->Release();
CleanUp:
if ( pTmpSurface )
{
pTmpSurface->Release();
}
pBackBuffer->Release();
#else
Assert( 0 );
#endif
return 0;
}
//-----------------------------------------------------------------------------
// Returns a copy of the back buffer
//-----------------------------------------------------------------------------
IDirect3DSurface* CShaderAPIDx8::GetBackBufferImage( Rect_t *pSrcRect, Rect_t *pDstRect, ImageFormat& format )
{
#if !defined( _X360 )
if ( !m_pBackBufferSurface || ( m_hFullScreenTexture == INVALID_SHADERAPI_TEXTURE_HANDLE ) )
return NULL;
HRESULT hr;
D3DSURFACE_DESC desc;
FlushBufferedPrimitives();
// Get the current render target
IDirect3DSurface* pRenderTarget;
hr = Dx9Device()->GetRenderTarget( 0, &pRenderTarget );
if (FAILED(hr))
return 0;
// Find about its size and format
hr = pRenderTarget->GetDesc( &desc );
if ( desc.Format == D3DFMT_A16B16G16R16F || desc.Format == D3DFMT_A32B32G32R32F )
return GetBackBufferImageHDR( pSrcRect, pDstRect, format );
IDirect3DSurface *pSurfaceBits = NULL;
IDirect3DSurface *pTmpSurface = NULL;
int nRenderTargetRefCount;
nRenderTargetRefCount = 0;
if ( (desc.MultiSampleType == D3DMULTISAMPLE_NONE) && (pRenderTarget != m_pBackBufferSurface) &&
(pSrcRect->width == pDstRect->width) && (pSrcRect->height == pDstRect->height) )
{
// Don't bother to blit through the full-screen texture if we don't
// have to stretch, we're not coming from the backbuffer, and we don't have to do AA resolve
pTmpSurface = pRenderTarget;
#if POSIX
pTmpSurface->AddRef( 0, "CShaderAPIDx8::GetBackBufferImage public addref");
#else
pTmpSurface->AddRef();
#endif
}
else
{
Texture_t *pTex = &GetTexture( m_hFullScreenTexture );
IDirect3DTexture* pFullScreenTexture = (IDirect3DTexture*)pTex->GetTexture();
D3DTEXTUREFILTERTYPE filter = ((pDstRect->width != pSrcRect->width) || (pDstRect->height != pSrcRect->height)) ? D3DTEXF_LINEAR : D3DTEXF_NONE;
hr = pFullScreenTexture->GetSurfaceLevel( 0, &pTmpSurface );
if ( FAILED(hr) )
goto CleanUp;
if ( pTmpSurface == pRenderTarget )
{
Warning( "Can't blit from full-sized offscreen buffer!\n" );
goto CleanUp;
}
RECT srcRect, destRect;
srcRect.left = pSrcRect->x; srcRect.right = pSrcRect->x + pSrcRect->width;
srcRect.top = pSrcRect->y; srcRect.bottom = pSrcRect->y + pSrcRect->height;
srcRect.left = clamp( srcRect.left, 0, (int)desc.Width );
srcRect.right = clamp( srcRect.right, 0, (int)desc.Width );
srcRect.top = clamp( srcRect.top, 0, (int)desc.Height );
srcRect.bottom = clamp( srcRect.bottom, 0, (int)desc.Height );
destRect.left = pDstRect->x ; destRect.right = pDstRect->x + pDstRect->width;
destRect.top = pDstRect->y; destRect.bottom = pDstRect->y + pDstRect->height;
destRect.left = clamp( destRect.left, 0, (int)desc.Width );
destRect.right = clamp( destRect.right, 0, (int)desc.Width );
destRect.top = clamp( destRect.top, 0, (int)desc.Height );
destRect.bottom = clamp( destRect.bottom, 0, (int)desc.Height );
hr = Dx9Device()->StretchRect( pRenderTarget, &srcRect, pTmpSurface, &destRect, filter );
if ( FAILED(hr) )
{
AssertOnce( "Error resizing pixels!\n" );
goto CleanUp;
}
}
D3DSURFACE_DESC tmpDesc;
hr = pTmpSurface->GetDesc( &tmpDesc );
Assert( !FAILED(hr) );
// Create a buffer the same size and format
hr = Dx9Device()->CreateOffscreenPlainSurface( tmpDesc.Width, tmpDesc.Height,
desc.Format, D3DPOOL_SYSTEMMEM, &pSurfaceBits, NULL );
if ( FAILED(hr) )
{
AssertOnce( "Error creating offscreen surface!\n" );
goto CleanUp;
}
// Blit from the back buffer to our scratch buffer
hr = Dx9Device()->GetRenderTargetData( pTmpSurface, pSurfaceBits );
if ( FAILED(hr) )
{
AssertOnce( "Error copying bits into the offscreen surface!\n" );
goto CleanUp;
}
format = ImageLoader::D3DFormatToImageFormat( desc.Format );
pTmpSurface->Release();
#ifdef _DEBUG
nRenderTargetRefCount =
#endif
pRenderTarget->Release();
AssertOnce( nRenderTargetRefCount == 1 );
return pSurfaceBits;
CleanUp:
if ( pSurfaceBits )
{
pSurfaceBits->Release();
}
if ( pTmpSurface )
{
pTmpSurface->Release();
}
#else
Assert( 0 );
#endif
return 0;
}
//-----------------------------------------------------------------------------
// Copy bits from a host-memory surface
//-----------------------------------------------------------------------------
void CShaderAPIDx8::CopyBitsFromHostSurface( IDirect3DSurface* pSurfaceBits,
const Rect_t &dstRect, unsigned char *pData, ImageFormat srcFormat, ImageFormat dstFormat, int nDstStride )
{
// Copy out the bits...
RECT rect;
rect.left = dstRect.x;
rect.right = dstRect.x + dstRect.width;
rect.top = dstRect.y;
rect.bottom = dstRect.y + dstRect.height;
D3DLOCKED_RECT lockedRect;
HRESULT hr;
int flags = D3DLOCK_READONLY | D3DLOCK_NOSYSLOCK;
tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s", __FUNCTION__ );
hr = pSurfaceBits->LockRect( &lockedRect, &rect, flags );
if ( !FAILED( hr ) )
{
unsigned char *pImage = (unsigned char *)lockedRect.pBits;
ShaderUtil()->ConvertImageFormat( (unsigned char *)pImage, srcFormat,
pData, dstFormat, dstRect.width, dstRect.height, lockedRect.Pitch, nDstStride );
hr = pSurfaceBits->UnlockRect( );
}
}
//-----------------------------------------------------------------------------
// Reads from the current read buffer + stretches
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ReadPixels( Rect_t *pSrcRect, Rect_t *pDstRect, unsigned char *pData, ImageFormat dstFormat, int nDstStride )
{
LOCK_SHADERAPI();
Assert( pDstRect );
if ( IsPC() || !IsX360() )
{
Rect_t srcRect;
if ( !pSrcRect )
{
srcRect.x = srcRect.y = 0;
srcRect.width = m_nWindowWidth;
srcRect.height = m_nWindowHeight;
pSrcRect = &srcRect;
}
ImageFormat format;
IDirect3DSurface* pSurfaceBits = GetBackBufferImage( pSrcRect, pDstRect, format );
if ( pSurfaceBits )
{
CopyBitsFromHostSurface( pSurfaceBits, *pDstRect, pData, format, dstFormat, nDstStride );
// Release the temporary surface
pSurfaceBits->Release();
}
}
else
{
#if defined( _X360 )
// 360 requires material system to handle due to RT complexities
ShaderUtil()->ReadBackBuffer( pSrcRect, pDstRect, pData, dstFormat, nDstStride );
#endif
}
}
//-----------------------------------------------------------------------------
// Reads from the current read buffer
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ReadPixels( int x, int y, int width, int height, unsigned char *pData, ImageFormat dstFormat )
{
Rect_t rect;
rect.x = x;
rect.y = y;
rect.width = width;
rect.height = height;
if ( IsPC() || !IsX360() )
{
ImageFormat format;
IDirect3DSurface* pSurfaceBits = GetBackBufferImage( &rect, &rect, format );
if (pSurfaceBits)
{
CopyBitsFromHostSurface( pSurfaceBits, rect, pData, format, dstFormat, 0 );
// Release the temporary surface
pSurfaceBits->Release();
}
}
else
{
#if defined( _X360 )
// 360 requires material system to handle due to RT complexities
ShaderUtil()->ReadBackBuffer( &rect, &rect, pData, dstFormat, 0 );
#endif
}
}
//-----------------------------------------------------------------------------
// Binds a particular material to render with
//-----------------------------------------------------------------------------
void CShaderAPIDx8::Bind( IMaterial* pMaterial )
{
LOCK_SHADERAPI();
IMaterialInternal* pMatInt = static_cast<IMaterialInternal*>( pMaterial );
bool bMaterialChanged;
if ( m_pMaterial && pMatInt && m_pMaterial->InMaterialPage() && pMatInt->InMaterialPage() )
{
bMaterialChanged = ( m_pMaterial->GetMaterialPage() != pMatInt->GetMaterialPage() );
}
else
{
bMaterialChanged = ( m_pMaterial != pMatInt ) || ( m_pMaterial && m_pMaterial->InMaterialPage() ) || ( pMatInt && pMatInt->InMaterialPage() );
}
if ( bMaterialChanged )
{
FlushBufferedPrimitives();
#ifdef RECORDING
RECORD_DEBUG_STRING( ( char * )pMaterial->GetName() );
IShader *pShader = pMatInt->GetShader();
if( pShader && pShader->GetName() )
{
RECORD_DEBUG_STRING( pShader->GetName() );
}
else
{
RECORD_DEBUG_STRING( "<NULL SHADER>" );
}
#endif
m_pMaterial = pMatInt;
#if ( defined( PIX_INSTRUMENTATION ) || defined( NVPERFHUD ) )
PIXifyName( s_pPIXMaterialName, sizeof( s_pPIXMaterialName ), m_pMaterial->GetName() );
#endif
}
}
// Get the currently bound material
IMaterialInternal* CShaderAPIDx8::GetBoundMaterial()
{
return m_pMaterial;
}
//-----------------------------------------------------------------------------
// Binds a standard texture
//-----------------------------------------------------------------------------
void CShaderAPIDx8::BindStandardTexture( Sampler_t sampler, StandardTextureId_t id )
{
if ( m_StdTextureHandles[id] != INVALID_SHADERAPI_TEXTURE_HANDLE )
{
BindTexture( sampler, m_StdTextureHandles[id] );
}
else
{
ShaderUtil()->BindStandardTexture( sampler, id );
}
}
void CShaderAPIDx8::BindStandardVertexTexture( VertexTextureSampler_t sampler, StandardTextureId_t id )
{
ShaderUtil()->BindStandardVertexTexture( sampler, id );
}
void CShaderAPIDx8::GetStandardTextureDimensions( int *pWidth, int *pHeight, StandardTextureId_t id )
{
ShaderUtil()->GetStandardTextureDimensions( pWidth, pHeight, id );
}
//-----------------------------------------------------------------------------
// Gets the lightmap dimensions
//-----------------------------------------------------------------------------
void CShaderAPIDx8::GetLightmapDimensions( int *w, int *h )
{
ShaderUtil()->GetLightmapDimensions( w, h );
}
//-----------------------------------------------------------------------------
// Selection mode methods
//-----------------------------------------------------------------------------
int CShaderAPIDx8::SelectionMode( bool selectionMode )
{
LOCK_SHADERAPI();
int numHits = m_NumHits;
if (m_InSelectionMode)
{
WriteHitRecord();
}
m_InSelectionMode = selectionMode;
m_pCurrSelectionRecord = m_pSelectionBuffer;
m_NumHits = 0;
return numHits;
}
bool CShaderAPIDx8::IsInSelectionMode() const
{
return m_InSelectionMode;
}
void CShaderAPIDx8::SelectionBuffer( unsigned int* pBuffer, int size )
{
LOCK_SHADERAPI();
Assert( !m_InSelectionMode );
Assert( pBuffer && size );
m_pSelectionBufferEnd = pBuffer + size;
m_pSelectionBuffer = pBuffer;
m_pCurrSelectionRecord = pBuffer;
}
void CShaderAPIDx8::ClearSelectionNames( )
{
LOCK_SHADERAPI();
if (m_InSelectionMode)
{
WriteHitRecord();
}
m_SelectionNames.Clear();
}
void CShaderAPIDx8::LoadSelectionName( int name )
{
LOCK_SHADERAPI();
if (m_InSelectionMode)
{
WriteHitRecord();
Assert( m_SelectionNames.Count() > 0 );
m_SelectionNames.Top() = name;
}
}
void CShaderAPIDx8::PushSelectionName( int name )
{
LOCK_SHADERAPI();
if (m_InSelectionMode)
{
WriteHitRecord();
m_SelectionNames.Push(name);
}
}
void CShaderAPIDx8::PopSelectionName()
{
LOCK_SHADERAPI();
if (m_InSelectionMode)
{
WriteHitRecord();
m_SelectionNames.Pop();
}
}
void CShaderAPIDx8::WriteHitRecord( )
{
FlushBufferedPrimitives();
if (m_SelectionNames.Count() && (m_SelectionMinZ != FLT_MAX))
{
Assert( m_pCurrSelectionRecord + m_SelectionNames.Count() + 3 < m_pSelectionBufferEnd );
*m_pCurrSelectionRecord++ = m_SelectionNames.Count();
// NOTE: because of rounding, "(uint32)(float)UINT32_MAX" yields zero(!), hence the use of doubles.
// [ ALSO: As of Nov 2011, VS2010 exhibits a debug build code-gen bug if we cast the result to int32 instead of uint32 ]
*m_pCurrSelectionRecord++ = (uint32)( 0.5 + m_SelectionMinZ*(double)((uint32)~0) );
*m_pCurrSelectionRecord++ = (uint32)( 0.5 + m_SelectionMaxZ*(double)((uint32)~0) );
for (int i = 0; i < m_SelectionNames.Count(); ++i)
{
*m_pCurrSelectionRecord++ = m_SelectionNames[i];
}
++m_NumHits;
}
m_SelectionMinZ = FLT_MAX;
m_SelectionMaxZ = FLT_MIN;
}
// We hit somefin in selection mode
void CShaderAPIDx8::RegisterSelectionHit( float minz, float maxz )
{
if (minz < 0)
minz = 0;
if (maxz > 1)
maxz = 1;
if (m_SelectionMinZ > minz)
m_SelectionMinZ = minz;
if (m_SelectionMaxZ < maxz)
m_SelectionMaxZ = maxz;
}
int CShaderAPIDx8::GetCurrentNumBones( void ) const
{
return m_DynamicState.m_NumBones;
}
bool CShaderAPIDx8::IsHWMorphingEnabled( ) const
{
return m_DynamicState.m_bHWMorphingEnabled;
}
//-----------------------------------------------------------------------------
// Inserts the lighting block into the code
//-----------------------------------------------------------------------------
// If you change the number of lighting combinations, change this enum
enum
{
DX8_LIGHTING_COMBINATION_COUNT = 22,
DX9_LIGHTING_COMBINATION_COUNT = 35
};
#define MAX_LIGHTS 4
// NOTE: These should match g_lightType* in vsh_prep.pl!
static int g_DX8LightCombinations[][4] =
{
// static ambient local1 local2
// This is a special case for no lighting at all.
{ LIGHT_NONE, LIGHT_NONE, LIGHT_NONE, LIGHT_NONE },
// This is a special case so that we don't have to do the ambient cube
// when we only have static lighting
{ LIGHT_STATIC, LIGHT_NONE, LIGHT_NONE, LIGHT_NONE },
{ LIGHT_NONE, LIGHT_AMBIENTCUBE, LIGHT_NONE, LIGHT_NONE },
{ LIGHT_NONE, LIGHT_AMBIENTCUBE, LIGHT_SPOT, LIGHT_NONE },
{ LIGHT_NONE, LIGHT_AMBIENTCUBE, LIGHT_POINT, LIGHT_NONE },
{ LIGHT_NONE, LIGHT_AMBIENTCUBE, LIGHT_DIRECTIONAL, LIGHT_NONE },
{ LIGHT_NONE, LIGHT_AMBIENTCUBE, LIGHT_SPOT, LIGHT_SPOT },
{ LIGHT_NONE, LIGHT_AMBIENTCUBE, LIGHT_SPOT, LIGHT_POINT, },
{ LIGHT_NONE, LIGHT_AMBIENTCUBE, LIGHT_SPOT, LIGHT_DIRECTIONAL, },
{ LIGHT_NONE, LIGHT_AMBIENTCUBE, LIGHT_POINT, LIGHT_POINT, },
{ LIGHT_NONE, LIGHT_AMBIENTCUBE, LIGHT_POINT, LIGHT_DIRECTIONAL, },
{ LIGHT_NONE, LIGHT_AMBIENTCUBE, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL, },
{ LIGHT_STATIC, LIGHT_AMBIENTCUBE, LIGHT_NONE, LIGHT_NONE },
{ LIGHT_STATIC, LIGHT_AMBIENTCUBE, LIGHT_SPOT, LIGHT_NONE },
{ LIGHT_STATIC, LIGHT_AMBIENTCUBE, LIGHT_POINT, LIGHT_NONE },
{ LIGHT_STATIC, LIGHT_AMBIENTCUBE, LIGHT_DIRECTIONAL, LIGHT_NONE },
{ LIGHT_STATIC, LIGHT_AMBIENTCUBE, LIGHT_SPOT, LIGHT_SPOT },
{ LIGHT_STATIC, LIGHT_AMBIENTCUBE, LIGHT_SPOT, LIGHT_POINT, },
{ LIGHT_STATIC, LIGHT_AMBIENTCUBE, LIGHT_SPOT, LIGHT_DIRECTIONAL, },
{ LIGHT_STATIC, LIGHT_AMBIENTCUBE, LIGHT_POINT, LIGHT_POINT, },
{ LIGHT_STATIC, LIGHT_AMBIENTCUBE, LIGHT_POINT, LIGHT_DIRECTIONAL, },
{ LIGHT_STATIC, LIGHT_AMBIENTCUBE, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL, }
};
// NOTE: These should match g_lightType* in vsh_prep.pl!
// They also correspond to the parallel g_LocalLightTypeXArray[] arrays in common_vs_fxc.h
static int g_DX9LightCombinations[][MAX_LIGHTS] =
{
// local0 local1 local2 local3
{ LIGHT_NONE, LIGHT_NONE, LIGHT_NONE, LIGHT_NONE }, // Zero lights [ Combo 0]
{ LIGHT_SPOT, LIGHT_NONE, LIGHT_NONE, LIGHT_NONE }, // One light [ Combo 1]
{ LIGHT_POINT, LIGHT_NONE, LIGHT_NONE, LIGHT_NONE },
{ LIGHT_DIRECTIONAL, LIGHT_NONE, LIGHT_NONE, LIGHT_NONE },
{ LIGHT_SPOT, LIGHT_SPOT, LIGHT_NONE, LIGHT_NONE }, // Two lights [ Combo 4]
{ LIGHT_SPOT, LIGHT_POINT, LIGHT_NONE, LIGHT_NONE },
{ LIGHT_SPOT, LIGHT_DIRECTIONAL, LIGHT_NONE, LIGHT_NONE },
{ LIGHT_POINT, LIGHT_POINT, LIGHT_NONE, LIGHT_NONE },
{ LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_NONE, LIGHT_NONE },
{ LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL, LIGHT_NONE, LIGHT_NONE },
{ LIGHT_SPOT, LIGHT_SPOT, LIGHT_SPOT, LIGHT_NONE }, // Three lights [ Combo 10]
{ LIGHT_SPOT, LIGHT_SPOT, LIGHT_POINT, LIGHT_NONE },
{ LIGHT_SPOT, LIGHT_SPOT, LIGHT_DIRECTIONAL, LIGHT_NONE },
{ LIGHT_SPOT, LIGHT_POINT, LIGHT_POINT, LIGHT_NONE },
{ LIGHT_SPOT, LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_NONE },
{ LIGHT_SPOT, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL, LIGHT_NONE },
{ LIGHT_POINT, LIGHT_POINT, LIGHT_POINT, LIGHT_NONE },
{ LIGHT_POINT, LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_NONE },
{ LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL, LIGHT_NONE },
{ LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL, LIGHT_NONE },
{ LIGHT_SPOT, LIGHT_SPOT, LIGHT_SPOT, LIGHT_SPOT }, // Four lights [ Combo 20]
{ LIGHT_SPOT, LIGHT_SPOT, LIGHT_SPOT, LIGHT_POINT },
{ LIGHT_SPOT, LIGHT_SPOT, LIGHT_SPOT, LIGHT_DIRECTIONAL },
{ LIGHT_SPOT, LIGHT_SPOT, LIGHT_POINT, LIGHT_POINT },
{ LIGHT_SPOT, LIGHT_SPOT, LIGHT_POINT, LIGHT_DIRECTIONAL },
{ LIGHT_SPOT, LIGHT_SPOT, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL },
{ LIGHT_SPOT, LIGHT_POINT, LIGHT_POINT, LIGHT_POINT },
{ LIGHT_SPOT, LIGHT_POINT, LIGHT_POINT, LIGHT_DIRECTIONAL },
{ LIGHT_SPOT, LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL },
{ LIGHT_SPOT, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL },
{ LIGHT_POINT, LIGHT_POINT, LIGHT_POINT, LIGHT_POINT },
{ LIGHT_POINT, LIGHT_POINT, LIGHT_POINT, LIGHT_DIRECTIONAL },
{ LIGHT_POINT, LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL },
{ LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL },
{ LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL, LIGHT_DIRECTIONAL }
};
// This is just for getting light combos for DX8
// For DX9, use GetDX9LightState()
// It is up to the shader cpp files to use the right method
int CShaderAPIDx8::GetCurrentLightCombo( void ) const
{
Assert( g_pHardwareConfig->Caps().m_nDXSupportLevel <= 81 );
Assert( m_DynamicState.m_NumLights <= 2 );
COMPILE_TIME_ASSERT( DX8_LIGHTING_COMBINATION_COUNT ==
sizeof( g_DX8LightCombinations ) / sizeof( g_DX8LightCombinations[0] ) );
// hack . . do this a cheaper way.
bool bUseAmbientCube;
if( m_DynamicState.m_AmbientLightCube[0][0] == 0.0f &&
m_DynamicState.m_AmbientLightCube[0][1] == 0.0f &&
m_DynamicState.m_AmbientLightCube[0][2] == 0.0f &&
m_DynamicState.m_AmbientLightCube[1][0] == 0.0f &&
m_DynamicState.m_AmbientLightCube[1][1] == 0.0f &&
m_DynamicState.m_AmbientLightCube[1][2] == 0.0f &&
m_DynamicState.m_AmbientLightCube[2][0] == 0.0f &&
m_DynamicState.m_AmbientLightCube[2][1] == 0.0f &&
m_DynamicState.m_AmbientLightCube[2][2] == 0.0f &&
m_DynamicState.m_AmbientLightCube[3][0] == 0.0f &&
m_DynamicState.m_AmbientLightCube[3][1] == 0.0f &&
m_DynamicState.m_AmbientLightCube[3][2] == 0.0f &&
m_DynamicState.m_AmbientLightCube[4][0] == 0.0f &&
m_DynamicState.m_AmbientLightCube[4][1] == 0.0f &&
m_DynamicState.m_AmbientLightCube[4][2] == 0.0f &&
m_DynamicState.m_AmbientLightCube[5][0] == 0.0f &&
m_DynamicState.m_AmbientLightCube[5][1] == 0.0f &&
m_DynamicState.m_AmbientLightCube[5][2] == 0.0f )
{
bUseAmbientCube = false;
}
else
{
bUseAmbientCube = true;
}
Assert( m_pRenderMesh );
const VertexShaderLightTypes_t *pLightType = m_DynamicState.m_LightType;
if( m_DynamicState.m_NumLights == 0 && !bUseAmbientCube )
{
if( m_pRenderMesh->HasColorMesh() )
return 1; // special case for static lighting only
else
return 0; // special case for no lighting at all.
}
int i;
// hack - skip the first two for now since we don't know if the ambient cube is needed or not.
for( i = 2; i < DX9_LIGHTING_COMBINATION_COUNT; ++i )
{
int j;
for( j = 0; j < m_DynamicState.m_NumLights; ++j )
{
if( pLightType[j] != g_DX8LightCombinations[i][j+2] )
break;
}
if( j == m_DynamicState.m_NumLights )
{
while( j < 2 )
{
if (g_DX8LightCombinations[i][j+2] != LIGHT_NONE)
break;
++j;
}
if( j == 2 )
{
if( m_pRenderMesh->HasColorMesh() )
{
return i + 10;
}
else
{
return i;
}
}
}
}
// should never get here!
Assert( 0 );
return 0;
}
void CShaderAPIDx8::GetDX9LightState( LightState_t *state ) const
{
// hack . . do this a cheaper way.
if( m_DynamicState.m_AmbientLightCube[0][0] == 0.0f &&
m_DynamicState.m_AmbientLightCube[0][1] == 0.0f &&
m_DynamicState.m_AmbientLightCube[0][2] == 0.0f &&
m_DynamicState.m_AmbientLightCube[1][0] == 0.0f &&
m_DynamicState.m_AmbientLightCube[1][1] == 0.0f &&
m_DynamicState.m_AmbientLightCube[1][2] == 0.0f &&
m_DynamicState.m_AmbientLightCube[2][0] == 0.0f &&
m_DynamicState.m_AmbientLightCube[2][1] == 0.0f &&
m_DynamicState.m_AmbientLightCube[2][2] == 0.0f &&
m_DynamicState.m_AmbientLightCube[3][0] == 0.0f &&
m_DynamicState.m_AmbientLightCube[3][1] == 0.0f &&
m_DynamicState.m_AmbientLightCube[3][2] == 0.0f &&
m_DynamicState.m_AmbientLightCube[4][0] == 0.0f &&
m_DynamicState.m_AmbientLightCube[4][1] == 0.0f &&
m_DynamicState.m_AmbientLightCube[4][2] == 0.0f &&
m_DynamicState.m_AmbientLightCube[5][0] == 0.0f &&
m_DynamicState.m_AmbientLightCube[5][1] == 0.0f &&
m_DynamicState.m_AmbientLightCube[5][2] == 0.0f )
{
state->m_bAmbientLight = false;
}
else
{
state->m_bAmbientLight = true;
}
Assert( m_pRenderMesh );
Assert( m_DynamicState.m_NumLights <= 4 );
if ( g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
Assert( m_DynamicState.m_NumLights <= MAX_LIGHTS ); // 2b hardware gets four lights
}
else
{
Assert( m_DynamicState.m_NumLights <= (MAX_LIGHTS-2) ); // 2.0 hardware gets two less
}
#ifdef OSX
state->m_nNumLights = MIN(MAX_NUM_LIGHTS,m_DynamicState.m_NumLights);
#else
state->m_nNumLights = m_DynamicState.m_NumLights;
#endif
state->m_nNumLights = m_DynamicState.m_NumLights;
state->m_bStaticLightVertex = m_pRenderMesh->HasColorMesh();
state->m_bStaticLightTexel = false; // For now
}
MaterialFogMode_t CShaderAPIDx8::GetCurrentFogType( void ) const
{
return m_DynamicState.m_SceneFog;
}
void CShaderAPIDx8::RecordString( const char *pStr )
{
RECORD_STRING( pStr );
}
void CShaderAPIDx8::EvictManagedResourcesInternal()
{
if ( IsX360() )
return;
if ( !ThreadOwnsDevice() || !ThreadInMainThread() )
{
ShaderUtil()->OnThreadEvent( SHADER_THREAD_EVICT_RESOURCES );
return;
}
if ( mat_debugalttab.GetBool() )
{
Warning( "mat_debugalttab: CShaderAPIDx8::EvictManagedResourcesInternal\n" );
}
#if !defined( _X360 )
if ( Dx9Device() )
{
Dx9Device()->EvictManagedResources();
}
#endif
}
void CShaderAPIDx8::EvictManagedResources( void )
{
if ( IsX360() )
{
return;
}
LOCK_SHADERAPI();
Assert(ThreadOwnsDevice());
// Tell other material system applications to release resources
SendIPCMessage( EVICT_MESSAGE );
EvictManagedResourcesInternal();
}
bool CShaderAPIDx8::IsDebugTextureListFresh( int numFramesAllowed /* = 1 */ )
{
return ( m_nDebugDataExportFrame <= m_CurrentFrame ) && ( m_nDebugDataExportFrame >= m_CurrentFrame - numFramesAllowed );
}
bool CShaderAPIDx8::SetDebugTextureRendering( bool bEnable )
{
bool bVal = m_bDebugTexturesRendering;
m_bDebugTexturesRendering = bEnable;
return bVal;
}
void CShaderAPIDx8::EnableDebugTextureList( bool bEnable )
{
m_bEnableDebugTextureList = bEnable;
}
void CShaderAPIDx8::EnableGetAllTextures( bool bEnable )
{
m_bDebugGetAllTextures = bEnable;
}
KeyValues* CShaderAPIDx8::GetDebugTextureList()
{
return m_pDebugTextureList;
}
int CShaderAPIDx8::GetTextureMemoryUsed( TextureMemoryType eTextureMemory )
{
switch ( eTextureMemory )
{
case MEMORY_BOUND_LAST_FRAME:
return m_nTextureMemoryUsedLastFrame;
case MEMORY_TOTAL_LOADED:
return m_nTextureMemoryUsedTotal;
case MEMORY_ESTIMATE_PICMIP_1:
return m_nTextureMemoryUsedPicMip1;
case MEMORY_ESTIMATE_PICMIP_2:
return m_nTextureMemoryUsedPicMip2;
default:
return 0;
}
}
// Allocate and delete query objects.
ShaderAPIOcclusionQuery_t CShaderAPIDx8::CreateOcclusionQueryObject( void )
{
// don't allow this on <80 because it falls back to wireframe in that case
if( m_DeviceSupportsCreateQuery == 0 || g_pHardwareConfig->Caps().m_nDXSupportLevel < 80 )
return INVALID_SHADERAPI_OCCLUSION_QUERY_HANDLE;
// While we're deactivated, m_OcclusionQueryObjects just holds NULL pointers.
// Create a dummy one here and let ReacquireResources create the actual D3D object.
if ( IsDeactivated() )
return INVALID_SHADERAPI_OCCLUSION_QUERY_HANDLE;
IDirect3DQuery9 *pQuery = NULL;
HRESULT hr = Dx9Device()->CreateQuery( D3DQUERYTYPE_OCCLUSION, &pQuery );
return ( hr == D3D_OK ) ? (ShaderAPIOcclusionQuery_t)pQuery : INVALID_SHADERAPI_OCCLUSION_QUERY_HANDLE;
}
void CShaderAPIDx8::DestroyOcclusionQueryObject( ShaderAPIOcclusionQuery_t handle )
{
IDirect3DQuery9 *pQuery = (IDirect3DQuery9 *)handle;
int nRetVal = pQuery->Release();
Assert( nRetVal == 0 );
}
// Bracket drawing with begin and end so that we can get counts next frame.
void CShaderAPIDx8::BeginOcclusionQueryDrawing( ShaderAPIOcclusionQuery_t handle )
{
IDirect3DQuery9 *pQuery = (IDirect3DQuery9 *)handle;
HRESULT hResult = pQuery->Issue( D3DISSUE_BEGIN );
Assert( hResult == D3D_OK );
}
void CShaderAPIDx8::EndOcclusionQueryDrawing( ShaderAPIOcclusionQuery_t handle )
{
IDirect3DQuery9 *pQuery = (IDirect3DQuery9 *)handle;
HRESULT hResult = pQuery->Issue( D3DISSUE_END );
Assert( hResult == D3D_OK );
}
// Get the number of pixels rendered between begin and end on an earlier frame.
// Calling this in the same frame is a huge perf hit!
int CShaderAPIDx8::OcclusionQuery_GetNumPixelsRendered( ShaderAPIOcclusionQuery_t handle, bool bFlush )
{
LOCK_SHADERAPI();
IDirect3DQuery9 *pQuery = (IDirect3DQuery9 *)handle;
tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s", __FUNCTION__ );
DWORD nPixels;
HRESULT hResult = pQuery->GetData( &nPixels, sizeof( nPixels ), bFlush ? D3DGETDATA_FLUSH : 0 );
// This means that the query will not finish and resulted in an error, game should use
// the previous query's results and not reissue the query
if ( ( hResult == D3DERR_DEVICELOST ) || ( hResult == D3DERR_NOTAVAILABLE ) )
return OCCLUSION_QUERY_RESULT_ERROR;
// This means the query isn't finished yet, game will have to use the previous query's
// results and not reissue the query; wait for query to finish later.
if ( hResult == S_FALSE )
return OCCLUSION_QUERY_RESULT_PENDING;
// NOTE: This appears to work around a driver bug for ATI on Vista
if ( nPixels & 0x80000000 )
{
nPixels = 0;
}
return nPixels;
}
void CShaderAPIDx8::SetPixelShaderFogParams( int reg, ShaderFogMode_t fogMode )
{
m_DelayedShaderConstants.iPixelShaderFogParams = reg; //save it off in case the ShaderFogMode_t disables fog. We only find out later.
float fogParams[4];
if( (GetPixelFogMode() != MATERIAL_FOG_NONE) && (fogMode != SHADER_FOGMODE_DISABLED) )
{
float ooFogRange = 1.0f;
float fStart = m_VertexShaderFogParams[0];
float fEnd = m_VertexShaderFogParams[1];
// Check for divide by zero
if ( fEnd != fStart )
{
ooFogRange = 1.0f / ( fEnd - fStart );
}
fogParams[0] = fStart * ooFogRange; // fogStart / ( fogEnd - fogStart )
fogParams[1] = m_DynamicState.m_FogZ; // water height
fogParams[2] = clamp( m_flFogMaxDensity, 0.0f, 1.0f ); // Max fog density
fogParams[3] = ooFogRange; // 1 / ( fogEnd - fogStart );
if (GetPixelFogMode() == MATERIAL_FOG_LINEAR_BELOW_FOG_Z)
{
// terms are unused for height fog, forcing 1.0 allows unified PS math
fogParams[0] = 0.0f;
fogParams[2] = 1.0f;
}
}
else
{
//emulating MATERIAL_FOG_NONE by setting the parameters so that CalcRangeFog() always returns 0. Gets rid of a dynamic combo across the ps2x set.
fogParams[0] = 0.0f;
fogParams[1] = m_DynamicState.m_FogZ; // water height
fogParams[2] = 1.0f; // Max fog density
fogParams[3] = 0.0f;
}
// cFogEndOverFogRange, cFogOne, unused, cOOFogRange
SetPixelShaderConstant( reg, fogParams, 1 );
}
void CShaderAPIDx8::SetPixelShaderFogParams( int reg )
{
SetPixelShaderFogParams( reg, m_TransitionTable.CurrentShadowState()->m_FogMode );
}
void CShaderAPIDx8::SetFlashlightState( const FlashlightState_t &state, const VMatrix &worldToTexture )
{
LOCK_SHADERAPI();
SetFlashlightStateEx( state, worldToTexture, NULL );
}
void CShaderAPIDx8::SetFlashlightStateEx( const FlashlightState_t &state, const VMatrix &worldToTexture, ITexture *pFlashlightDepthTexture )
{
LOCK_SHADERAPI();
// fixme: do a test here.
FlushBufferedPrimitives();
m_FlashlightState = state;
m_FlashlightWorldToTexture = worldToTexture;
m_pFlashlightDepthTexture = pFlashlightDepthTexture;
if ( !g_pHardwareConfig->SupportsPixelShaders_2_b() )
{
m_FlashlightState.m_bEnableShadows = false;
m_pFlashlightDepthTexture = NULL;
}
}
const FlashlightState_t &CShaderAPIDx8::GetFlashlightState( VMatrix &worldToTexture ) const
{
worldToTexture = m_FlashlightWorldToTexture;
return m_FlashlightState;
}
const FlashlightState_t &CShaderAPIDx8::GetFlashlightStateEx( VMatrix &worldToTexture, ITexture **ppFlashlightDepthTexture ) const
{
worldToTexture = m_FlashlightWorldToTexture;
*ppFlashlightDepthTexture = m_pFlashlightDepthTexture;
return m_FlashlightState;
}
bool CShaderAPIDx8::SupportsMSAAMode( int nMSAAMode )
{
if ( IsX360() )
{
return false;
}
return ( D3D_OK == D3D()->CheckDeviceMultiSampleType( m_DisplayAdapter, m_DeviceType,
m_PresentParameters.BackBufferFormat,
m_PresentParameters.Windowed,
ComputeMultisampleType( nMSAAMode ), NULL ) );
}
bool CShaderAPIDx8::SupportsCSAAMode( int nNumSamples, int nQualityLevel )
{
#ifdef DX_TO_GL_ABSTRACTION
// GL_NV_framebuffer_multisample_coverage
return false;
#endif
// Only nVidia does this kind of AA
if ( g_pHardwareConfig->Caps().m_VendorID != VENDORID_NVIDIA )
return false;
DWORD dwQualityLevels = 0;
HRESULT hr = D3D()->CheckDeviceMultiSampleType( m_DisplayAdapter, m_DeviceType,
m_PresentParameters.BackBufferFormat,
m_PresentParameters.Windowed,
ComputeMultisampleType( nNumSamples ), &dwQualityLevels );
return ( ( D3D_OK == hr ) && ( (int) dwQualityLevels >= nQualityLevel ) );
}
bool CShaderAPIDx8::SupportsShadowDepthTextures( void )
{
return g_pHardwareConfig->Caps().m_bSupportsShadowDepthTextures;
}
bool CShaderAPIDx8::SupportsBorderColor( void ) const
{
return g_pHardwareConfig->Caps().m_bSupportsBorderColor;
}
bool CShaderAPIDx8::SupportsFetch4( void )
{
return IsPC() && g_pHardwareConfig->Caps().m_bSupportsFetch4;
}
ImageFormat CShaderAPIDx8::GetShadowDepthTextureFormat( void )
{
return g_pHardwareConfig->Caps().m_ShadowDepthTextureFormat;
}
ImageFormat CShaderAPIDx8::GetNullTextureFormat( void )
{
return g_pHardwareConfig->Caps().m_NullTextureFormat;
}
void CShaderAPIDx8::SetShadowDepthBiasFactors( float fShadowSlopeScaleDepthBias, float fShadowDepthBias )
{
m_fShadowSlopeScaleDepthBias = fShadowSlopeScaleDepthBias;
m_fShadowDepthBias = fShadowDepthBias;
}
void CShaderAPIDx8::ClearVertexAndPixelShaderRefCounts()
{
LOCK_SHADERAPI();
ShaderManager()->ClearVertexAndPixelShaderRefCounts();
}
void CShaderAPIDx8::PurgeUnusedVertexAndPixelShaders()
{
LOCK_SHADERAPI();
ShaderManager()->PurgeUnusedVertexAndPixelShaders();
}
bool CShaderAPIDx8::UsingSoftwareVertexProcessing() const
{
return g_pHardwareConfig->Caps().m_bSoftwareVertexProcessing;
}
ITexture *CShaderAPIDx8::GetRenderTargetEx( int nRenderTargetID )
{
return ShaderUtil()->GetRenderTargetEx( nRenderTargetID );
}
float CShaderAPIDx8::GetLightMapScaleFactor( void ) const
{
switch( HardwareConfig()->GetHDRType() )
{
case HDR_TYPE_FLOAT:
return 1.0;
break;
case HDR_TYPE_INTEGER:
return 16.0;
case HDR_TYPE_NONE:
default:
return GammaToLinearFullRange( 2.0 ); // light map scale
}
}
void CShaderAPIDx8::SetToneMappingScaleLinear( const Vector &scale )
{
if ( g_pHardwareConfig->SupportsPixelShaders_2_0() )
{
// Flush buffered primitives before changing the tone map scalar!
FlushBufferedPrimitives();
Vector scale_to_use = scale;
m_ToneMappingScale.AsVector3D() = scale_to_use;
bool mode_uses_srgb=false;
switch( HardwareConfig()->GetHDRType() )
{
case HDR_TYPE_NONE:
m_ToneMappingScale.x = 1.0; // output scale
m_ToneMappingScale.z = 1.0; // reflection map scale
break;
case HDR_TYPE_FLOAT:
m_ToneMappingScale.x = scale_to_use.x; // output scale
m_ToneMappingScale.z = 1.0; // reflection map scale
break;
case HDR_TYPE_INTEGER:
mode_uses_srgb = true;
m_ToneMappingScale.x = scale_to_use.x; // output scale
m_ToneMappingScale.z = 16.0; // reflection map scale
break;
}
m_ToneMappingScale.y = GetLightMapScaleFactor(); // light map scale
// w component gets gamma scale
m_ToneMappingScale.w = LinearToGammaFullRange( m_ToneMappingScale.x );
SetPixelShaderConstant( TONE_MAPPING_SCALE_PSH_CONSTANT, m_ToneMappingScale.Base() );
// We have to change the fog color since we tone map directly in the shaders in integer HDR mode.
if ( HardwareConfig()->GetHDRType() == HDR_TYPE_INTEGER && m_TransitionTable.CurrentShadowState() )
{
// Get the shadow state in sync since it depends on SetToneMappingScaleLinear.
ApplyFogMode( m_TransitionTable.CurrentShadowState()->m_FogMode, mode_uses_srgb, m_TransitionTable.CurrentShadowState()->m_bDisableFogGammaCorrection );
}
}
}
const Vector & CShaderAPIDx8::GetToneMappingScaleLinear( void ) const
{
return m_ToneMappingScale.AsVector3D();
}
void CShaderAPIDx8::EnableLinearColorSpaceFrameBuffer( bool bEnable )
{
LOCK_SHADERAPI();
m_TransitionTable.EnableLinearColorSpaceFrameBuffer( bEnable );
}
void CShaderAPIDx8::SetPSNearAndFarZ( int pshReg )
{
VMatrix m;
GetMatrix( MATERIAL_PROJECTION, m.m[0] );
// m[2][2] = F/(N-F) (flip sign if RH)
// m[3][2] = NF/(N-F)
float vNearFar[4];
float N = m[3][2] / m[2][2];
float F = (m[3][2]*N) / (N + m[3][2]);
vNearFar[0] = N;
vNearFar[1] = F;
SetPixelShaderConstant( pshReg, vNearFar, 1 );
}
void CShaderAPIDx8::SetFloatRenderingParameter( int parm_number, float value )
{
LOCK_SHADERAPI();
if ( parm_number < ARRAYSIZE( FloatRenderingParameters ))
FloatRenderingParameters[parm_number] = value;
}
void CShaderAPIDx8::SetIntRenderingParameter( int parm_number, int value )
{
LOCK_SHADERAPI();
if ( parm_number < ARRAYSIZE( IntRenderingParameters ))
IntRenderingParameters[parm_number] = value;
}
void CShaderAPIDx8::SetVectorRenderingParameter( int parm_number, Vector const & value )
{
LOCK_SHADERAPI();
if ( parm_number < ARRAYSIZE( VectorRenderingParameters ))
VectorRenderingParameters[parm_number] = value;
}
float CShaderAPIDx8::GetFloatRenderingParameter( int parm_number ) const
{
LOCK_SHADERAPI();
if ( parm_number < ARRAYSIZE( FloatRenderingParameters ))
return FloatRenderingParameters[parm_number];
else
return 0.0;
}
int CShaderAPIDx8::GetIntRenderingParameter( int parm_number ) const
{
LOCK_SHADERAPI();
if ( parm_number < ARRAYSIZE( IntRenderingParameters ))
return IntRenderingParameters[parm_number];
else
return 0;
}
Vector CShaderAPIDx8::GetVectorRenderingParameter( int parm_number ) const
{
LOCK_SHADERAPI();
if ( parm_number < ARRAYSIZE( VectorRenderingParameters ))
return VectorRenderingParameters[parm_number];
else
return Vector( 0, 0, 0 );
}
// stencil entry points
void CShaderAPIDx8::SetStencilEnable( bool onoff )
{
LOCK_SHADERAPI();
SetRenderState( D3DRS_STENCILENABLE, onoff?TRUE:FALSE, true );
}
void CShaderAPIDx8::SetStencilFailOperation( StencilOperation_t op )
{
LOCK_SHADERAPI();
SetRenderState( D3DRS_STENCILFAIL, op, true );
}
void CShaderAPIDx8::SetStencilZFailOperation( StencilOperation_t op )
{
LOCK_SHADERAPI();
SetRenderState( D3DRS_STENCILZFAIL, op, true );
}
void CShaderAPIDx8::SetStencilPassOperation( StencilOperation_t op )
{
LOCK_SHADERAPI();
SetRenderState( D3DRS_STENCILPASS, op, true );
}
void CShaderAPIDx8::SetStencilCompareFunction( StencilComparisonFunction_t cmpfn )
{
LOCK_SHADERAPI();
SetRenderState( D3DRS_STENCILFUNC, cmpfn, true );
}
void CShaderAPIDx8::SetStencilReferenceValue( int ref )
{
LOCK_SHADERAPI();
SetRenderState( D3DRS_STENCILREF, ref, true );
}
void CShaderAPIDx8::SetStencilTestMask( uint32 msk )
{
LOCK_SHADERAPI();
SetRenderState( D3DRS_STENCILMASK, msk, true );
}
void CShaderAPIDx8::SetStencilWriteMask( uint32 msk )
{
LOCK_SHADERAPI();
SetRenderState( D3DRS_STENCILWRITEMASK, msk, true );
}
void CShaderAPIDx8::ClearStencilBufferRectangle(
int xmin, int ymin, int xmax, int ymax,int value)
{
LOCK_SHADERAPI();
D3DRECT clear;
clear.x1 = xmin;
clear.y1 = ymin;
clear.x2 = xmax;
clear.y2 = ymax;
Dx9Device()->Clear(
1, &clear, D3DCLEAR_STENCIL, 0, 0, value );
}
int CShaderAPIDx8::CompareSnapshots( StateSnapshot_t snapshot0, StateSnapshot_t snapshot1 )
{
LOCK_SHADERAPI();
const ShadowState_t &shadow0 = m_TransitionTable.GetSnapshot(snapshot0);
const ShadowState_t &shadow1 = m_TransitionTable.GetSnapshot(snapshot1);
const ShadowShaderState_t &shader0 = m_TransitionTable.GetSnapshotShader(snapshot0);
const ShadowShaderState_t &shader1 = m_TransitionTable.GetSnapshotShader(snapshot1);
int dVertex = shader0.m_VertexShader - shader1.m_VertexShader;
if ( dVertex )
return dVertex;
int dVCombo = shader0.m_nStaticVshIndex - shader1.m_nStaticVshIndex;
if ( dVCombo)
return dVCombo;
int dPixel = shader0.m_PixelShader - shader1.m_PixelShader;
if ( dPixel )
return dPixel;
int dPCombo = shader0.m_nStaticPshIndex - shader1.m_nStaticPshIndex;
if ( dPCombo)
return dPCombo;
return snapshot0 - snapshot1;
}
//-----------------------------------------------------------------------------
// X360 TTF support requires XUI state manipulation of d3d.
// Font support lives inside the shaderapi in order to maintain privacy of d3d.
//-----------------------------------------------------------------------------
#if defined( _X360 )
HXUIFONT CShaderAPIDx8::OpenTrueTypeFont( const char *pFontname, int tall, int style )
{
LOCK_SHADERAPI();
struct fontTable_t
{
const char *pFontName;
const char *pPath;
};
// explicit mapping now required, dvd searching to expensive
static fontTable_t fontToFilename[] =
{
{"tf2", "tf/resource/tf2.ttf"},
{"tf2 build", "tf/resource/tf2build.ttf"},
{"tf2 professor", "tf/resource/tf2professor.ttf"},
{"tf2 secondary", "tf/resource/tf2secondary.ttf"},
{"team fortress", "tf/resource/tf.ttf"},
{"tfd", "tf/resource/tfd.ttf"},
{"tflogo", "tf/resource/tflogo.ttf"},
{"hl2ep2", "ep2/resource/hl2ep2.ttf"},
{"hl2ep1", "episodic/resource/hl2ep1.ttf"},
{"halflife2", "hl2/resource/halflife2.ttf"},
{"hl2cross", "hl2/resource/HL2Crosshairs.ttf"},
{"courier new", "platform/vgui/fonts/cour.ttf"},
{"times new roman", "platform/vgui/fonts/times.ttf"},
{"trebuchet ms", "platform/vgui/fonts/trebuc.ttf"},
{"verdana", "platform/vgui/fonts/verdana.ttf"},
{"tahoma", "platform/vgui/fonts/tahoma.ttf"},
};
// remap typeface to diskname
const char *pDiskname = NULL;
for ( int i=0; i<ARRAYSIZE( fontToFilename ); i++ )
{
if ( !V_stricmp( pFontname, fontToFilename[i].pFontName ) )
{
pDiskname = fontToFilename[i].pPath;
break;
}
}
if ( !pDiskname )
{
// not found
DevMsg( "True Type Font: '%s' unknown.\n", pFontname );
return NULL;
}
// font will be registered using typeface name
wchar_t wchFontname[MAX_PATH];
Q_UTF8ToUnicode( pFontname, wchFontname, sizeof( wchFontname ) );
// find font in registered typefaces
TypefaceDescriptor *pDescriptors = NULL;
DWORD numTypeFaces = 0;
HRESULT hr = XuiEnumerateTypefaces( &pDescriptors, &numTypeFaces );
if ( FAILED( hr ) )
{
return NULL;
}
bool bRegistered = false;
for ( DWORD i=0; i<numTypeFaces; i++ )
{
if ( !V_wcscmp( pDescriptors->szTypeface, wchFontname ) )
{
bRegistered = true;
break;
}
}
XuiDestroyTypefaceList( pDescriptors, numTypeFaces );
if ( !bRegistered )
{
// unregistered type face, register type face and retry
// only file based resource locators work
char filename[MAX_PATH];
V_snprintf( filename, sizeof( filename ), "file://d:/%s", pDiskname );
Q_FixSlashes( filename, '/' );
wchar_t wchFilename[MAX_PATH];
Q_UTF8ToUnicode( filename, wchFilename, sizeof( wchFilename ) );
TypefaceDescriptor desc;
desc.fBaselineAdjust = 0;
desc.szFallbackTypeface = NULL;
desc.szLocator = wchFilename;
desc.szReserved1 = 0;
desc.szTypeface = wchFontname;
hr = XuiRegisterTypeface( &desc, FALSE );
if ( FAILED( hr ) )
{
return NULL;
}
}
// empirically derived factor to achieve desired cell height
float pointSize = tall * 0.59f;
HXUIFONT hFont = NULL;
hr = XuiCreateFont( wchFontname, pointSize, style, 0, &hFont );
if ( FAILED( hr ) )
{
return NULL;
}
return hFont;
}
#endif
//-----------------------------------------------------------------------------
// Release TTF
//-----------------------------------------------------------------------------
#if defined( _X360 )
void CShaderAPIDx8::CloseTrueTypeFont( HXUIFONT hFont )
{
if ( !hFont )
return;
LOCK_SHADERAPI();
XuiReleaseFont( hFont );
}
#endif
//-----------------------------------------------------------------------------
// Get the TTF Metrics
//-----------------------------------------------------------------------------
#if defined( _X360 )
bool CShaderAPIDx8::GetTrueTypeFontMetrics( HXUIFONT hFont, XUIFontMetrics *pFontMetrics, XUICharMetrics charMetrics[256] )
{
if ( !hFont )
return false;
LOCK_SHADERAPI();
V_memset( charMetrics, 0, 256 * sizeof( XUICharMetrics ) );
HRESULT hr = XuiGetFontMetrics( hFont, pFontMetrics );
if ( !FAILED( hr ) )
{
// X360 issue: max character width may be too small.
// Run through each character and fixup
for ( int i = 1; i < 256; i++ )
{
wchar_t wch = i;
hr = XuiGetCharMetrics( hFont, wch, &charMetrics[i] );
if ( !FAILED( hr ) )
{
float maxWidth = charMetrics[i].fMaxX;
if ( charMetrics[i].fMinX < 0 )
{
maxWidth = charMetrics[i].fMaxX - charMetrics[i].fMinX;
}
if ( maxWidth > pFontMetrics->fMaxWidth )
{
pFontMetrics->fMaxWidth = maxWidth;
}
if ( charMetrics[i].fAdvance > pFontMetrics->fMaxWidth )
{
pFontMetrics->fMaxWidth = charMetrics[i].fAdvance;
}
}
}
// fonts are getting cut off, MaxHeight seems to be misreported smaller
// take MaxHeight to be the larger of its reported value or (ascent + descent)
float maxHeight = 0;
if ( pFontMetrics->fMaxDescent <= 0 )
{
// descent is negative for below baseline
maxHeight = pFontMetrics->fMaxAscent - pFontMetrics->fMaxDescent;
}
if ( maxHeight > pFontMetrics->fMaxHeight )
{
pFontMetrics->fMaxHeight = maxHeight;
}
}
return ( !FAILED( hr ) );
}
#endif
//-----------------------------------------------------------------------------
// Gets the glyph bits in rgba order. This function PURPOSELY hijacks D3D
// because XUI is involved. It is called at a very specific place in the VGUI
// render frame where its deleterious affects are going to be harmless.
//-----------------------------------------------------------------------------
#if defined( _X360 )
bool CShaderAPIDx8::GetTrueTypeGlyphs( HXUIFONT hFont, int numChars, wchar_t *pWch, int *pOffsetX, int *pOffsetY, int *pWidth, int *pHeight, unsigned char *pRGBA, int *pRGBAOffset )
{
if ( !hFont )
return false;
// Ensure this doesn't talk to D3D at the same time as the loading bar
AUTO_LOCK_FM( m_nonInteractiveModeMutex );
LOCK_SHADERAPI();
bool bSuccess = false;
IDirect3DSurface *pRTSurface = NULL;
IDirect3DSurface *pSavedSurface = NULL;
IDirect3DSurface *pSavedDepthSurface = NULL;
IDirect3DTexture *pTexture = NULL;
D3DVIEWPORT9 savedViewport;
D3DXMATRIX matView;
D3DXMATRIX matXForm;
D3DLOCKED_RECT lockedRect;
// have to reset to default state to rasterize glyph correctly
// state will get re-established during next mesh draw
ResetRenderState( false );
Dx9Device()->SetRenderState( D3DRS_ZENABLE, FALSE );
Dx9Device()->GetRenderTarget( 0, &pSavedSurface );
Dx9Device()->GetDepthStencilSurface( &pSavedDepthSurface );
Dx9Device()->GetViewport( &savedViewport );
// Figure out the size of surface/texture we need to allocate
int rtWidth = 0;
int rtHeight = 0;
for ( int i = 0; i < numChars; i++ )
{
rtWidth += pWidth[i];
rtHeight = max( rtHeight, pHeight[i] );
}
// per resolve() restrictions
rtWidth = AlignValue( rtWidth, 32 );
rtHeight = AlignValue( rtHeight, 32 );
// create a render target to capture the glyph render
pRTSurface = g_TextureHeap.AllocRenderTargetSurface( rtWidth, rtHeight, D3DFMT_A8R8G8B8 );
if ( !pRTSurface )
goto cleanUp;
Dx9Device()->SetRenderTarget( 0, pRTSurface );
// Disable depth here otherwise you get a colour/depth multisample mismatch error (in 480p)
Dx9Device()->SetDepthStencilSurface( NULL );
Dx9Device()->Clear( 0, NULL, D3DCLEAR_TARGET, 0x00000000, ( ReverseDepthOnX360() ? 0.0 : 1.0f ), 0 );
// create texture to get glyph render from EDRAM
HRESULT hr = Dx9Device()->CreateTexture( rtWidth, rtHeight, 1, 0, D3DFMT_A8R8G8B8, 0, &pTexture, NULL );
if ( FAILED( hr ) )
goto cleanUp;
bool bPreviousOwnState = OwnGPUResources( false );
XuiRenderBegin( m_hDC, 0x00000000 );
D3DXMatrixIdentity( &matView );
XuiRenderSetViewTransform( m_hDC, &matView );
XuiRenderSetTransform( m_hDC, &matView );
// rasterize the glyph
XuiSelectFont( m_hDC, hFont );
XuiSetColorFactor( m_hDC, 0xFFFFFFFF );
// Draw the characters, stepping across the texture
int xCursor = 0;
for ( int i = 0; i < numChars; i++)
{
// FIXME: the drawRect params don't make much sense (should use "(xCursor+pWidth[i]), pHeight[i]", but then some characters disappear!)
XUIRect drawRect = XUIRect( xCursor + pOffsetX[i], pOffsetY[i], rtWidth, rtHeight );
wchar_t text[2] = { pWch[i], 0 };
XuiDrawText( m_hDC, text, XUI_FONT_STYLE_NORMAL|XUI_FONT_STYLE_SINGLE_LINE|XUI_FONT_STYLE_NO_WORDWRAP, 0, &drawRect );
xCursor += pWidth[i];
}
XuiRenderEnd( m_hDC );
OwnGPUResources( bPreviousOwnState );
// transfer from edram to system
hr = Dx9Device()->Resolve( 0, NULL, pTexture, NULL, 0, 0, NULL, 0, 0, NULL );
if ( FAILED( hr ) )
goto cleanUp;
hr = pTexture->LockRect( 0, &lockedRect, NULL, 0 );
if ( FAILED( hr ) )
goto cleanUp;
// transfer to linear format, one character at a time
xCursor = 0;
for ( int i = 0;i < numChars; i++ )
{
int destPitch = pWidth[i]*4;
unsigned char *pLinear = pRGBA + pRGBAOffset[i];
RECT copyRect = { xCursor, 0, xCursor + pWidth[i], pHeight[i] };
xCursor += pWidth[i];
XGUntileSurface( pLinear, destPitch, NULL, lockedRect.pBits, rtWidth, rtHeight, &copyRect, 4 );
// convert argb to rgba
float r, g, b, a;
for ( int y = 0; y < pHeight[i]; y++ )
{
unsigned char *pSrc = (unsigned char*)pLinear + y*destPitch;
for ( int x = 0; x < pWidth[i]; x++ )
{
// undo pre-multiplied alpha since glyph bits will be sourced as a rgba texture
if ( !pSrc[0] )
a = 1;
else
a = (float)pSrc[0] * 1.0f/255.0f;
r = ((float)pSrc[1] * 1.0f/255.0f)/a * 255.0f;
if ( r > 255 )
r = 255;
g = ((float)pSrc[2] * 1.0f/255.0f)/a * 255.0f;
if ( g > 255 )
g = 255;
b = ((float)pSrc[3] * 1.0f/255.0f)/a * 255.0f;
if ( b > 255 )
b = 255;
pSrc[3] = pSrc[0];
pSrc[2] = b;
pSrc[1] = g;
pSrc[0] = r;
pSrc += 4;
}
}
}
pTexture->UnlockRect( 0 );
bSuccess = true;
cleanUp:
if ( pRTSurface )
{
Dx9Device()->SetRenderTarget( 0, pSavedSurface );
Dx9Device()->SetDepthStencilSurface( pSavedDepthSurface );
Dx9Device()->SetViewport( &savedViewport );
pRTSurface->Release();
}
if ( pTexture )
pTexture->Release();
if ( pSavedSurface )
pSavedSurface->Release();
// XUI changed renderstates behind our back, so we need to reset to defaults again to get back in synch:
ResetRenderState( false );
return bSuccess;
}
#endif
//-----------------------------------------------------------------------------
// Create a 360 Render Target Surface
//-----------------------------------------------------------------------------
#if defined( _X360 )
ShaderAPITextureHandle_t CShaderAPIDx8::CreateRenderTargetSurface( int width, int height, ImageFormat format, const char *pDebugName, const char *pTextureGroupName )
{
LOCK_SHADERAPI();
ShaderAPITextureHandle_t textureHandle = CreateTextureHandle();
Texture_t *pTexture = &GetTexture( textureHandle );
pTexture->m_Flags = (Texture_t::IS_ALLOCATED | Texture_t::IS_RENDER_TARGET_SURFACE);
pTexture->m_DebugName = pDebugName;
pTexture->m_Width = width;
pTexture->m_Height = height;
pTexture->m_Depth = 1;
pTexture->m_NumCopies = 1;
pTexture->m_CurrentCopy = 0;
ImageFormat dstImageFormat = FindNearestSupportedFormat( format, false, true, false );
D3DFORMAT actualFormat = ImageLoader::ImageFormatToD3DFormat( dstImageFormat );
pTexture->GetRenderTargetSurface( false ) = g_TextureHeap.AllocRenderTargetSurface( width, height, actualFormat );
pTexture->GetRenderTargetSurface( true ) = g_TextureHeap.AllocRenderTargetSurface( width, height, (D3DFORMAT)MAKESRGBFMT( actualFormat ) );
pTexture->SetImageFormat( dstImageFormat );
pTexture->m_UTexWrap = D3DTADDRESS_CLAMP;
pTexture->m_VTexWrap = D3DTADDRESS_CLAMP;
pTexture->m_WTexWrap = D3DTADDRESS_CLAMP;
pTexture->m_MagFilter = D3DTEXF_LINEAR;
pTexture->m_NumLevels = 1;
pTexture->m_MipFilter = D3DTEXF_NONE;
pTexture->m_MinFilter = D3DTEXF_LINEAR;
pTexture->m_SwitchNeeded = false;
ComputeStatsInfo( textureHandle, false, false );
SetupTextureGroup( textureHandle, pTextureGroupName );
return textureHandle;
}
#endif
//-----------------------------------------------------------------------------
// Shader constants are batched and written to gpu once prior to draw.
//-----------------------------------------------------------------------------
void CShaderAPIDx8::WriteShaderConstantsToGPU()
{
#if defined( _X360 )
// vector vertex constants can just blast their set range
if ( m_MaxVectorVertexShaderConstant )
{
if ( m_bGPUOwned )
{
// faster path, write directly into GPU command buffer, bypassing shadow state
// can only set what is actually owned
Assert( m_MaxVectorVertexShaderConstant <= VERTEX_SHADER_MODEL + 3*NUM_MODEL_TRANSFORMS );
int numVectors = AlignValue( m_MaxVectorVertexShaderConstant, 4 );
BYTE* pCommandBufferData;
Dx9Device()->GpuBeginVertexShaderConstantF4( 0, (D3DVECTOR4**)&pCommandBufferData, numVectors );
memcpy( pCommandBufferData, m_DesiredState.m_pVectorVertexShaderConstant[0].Base(), numVectors * (sizeof( float ) * 4) );
Dx9Device()->GpuEndVertexShaderConstantF4();
}
else
{
Dx9Device()->SetVertexShaderConstantF( 0, m_DesiredState.m_pVectorVertexShaderConstant[0].Base(), m_MaxVectorVertexShaderConstant );
}
memcpy( m_DynamicState.m_pVectorVertexShaderConstant[0].Base(), m_DesiredState.m_pVectorVertexShaderConstant[0].Base(), m_MaxVectorVertexShaderConstant * 4 * sizeof(float) );
m_MaxVectorVertexShaderConstant = 0;
}
if ( m_MaxVectorPixelShaderConstant )
{
if ( m_bGPUOwned )
{
// faster path, write directly into GPU command buffer, bypassing shadow state
// can only set what is actually owned
Assert( m_MaxVectorPixelShaderConstant <= 32 );
int numVectors = AlignValue( m_MaxVectorPixelShaderConstant, 4 );
BYTE* pCommandBufferData;
Dx9Device()->GpuBeginPixelShaderConstantF4( 0, (D3DVECTOR4**)&pCommandBufferData, numVectors );
memcpy( pCommandBufferData, m_DesiredState.m_pVectorPixelShaderConstant[0].Base(), numVectors * (sizeof( float ) * 4) );
Dx9Device()->GpuEndPixelShaderConstantF4();
}
else
{
Dx9Device()->SetPixelShaderConstantF( 0, m_DesiredState.m_pVectorPixelShaderConstant[0].Base(), m_MaxVectorPixelShaderConstant );
}
memcpy( m_DynamicState.m_pVectorPixelShaderConstant[0].Base(), m_DesiredState.m_pVectorPixelShaderConstant[0].Base(), m_MaxVectorPixelShaderConstant * 4 * sizeof(float) );
m_MaxVectorPixelShaderConstant = 0;
}
// boolean and integer constants can just blast their set range
// these are currently extremely small in number, if this changes they may benefit from a fast path pattern
if ( m_MaxBooleanVertexShaderConstant )
{
Dx9Device()->SetVertexShaderConstantB( 0, m_DesiredState.m_pBooleanVertexShaderConstant, m_MaxBooleanVertexShaderConstant );
memcpy( m_DynamicState.m_pBooleanVertexShaderConstant, m_DesiredState.m_pBooleanVertexShaderConstant, m_MaxBooleanVertexShaderConstant * sizeof(BOOL) );
m_MaxBooleanVertexShaderConstant = 0;
}
if ( m_MaxIntegerVertexShaderConstant )
{
Dx9Device()->SetVertexShaderConstantI( 0, (int *)m_DesiredState.m_pIntegerVertexShaderConstant, m_MaxIntegerVertexShaderConstant );
memcpy( m_DynamicState.m_pIntegerVertexShaderConstant[0].Base(), m_DesiredState.m_pIntegerVertexShaderConstant[0].Base(), m_MaxIntegerVertexShaderConstant * sizeof(IntVector4D) );
m_MaxIntegerVertexShaderConstant = 0;
}
if ( m_MaxBooleanPixelShaderConstant )
{
Dx9Device()->SetPixelShaderConstantB( 0, m_DesiredState.m_pBooleanPixelShaderConstant, m_MaxBooleanPixelShaderConstant );
memcpy( m_DynamicState.m_pBooleanPixelShaderConstant, m_DesiredState.m_pBooleanPixelShaderConstant, m_MaxBooleanPixelShaderConstant * sizeof(BOOL) );
m_MaxBooleanPixelShaderConstant = 0;
}
// integer pixel constants are not used, so not supporting
#if 0
if ( m_MaxIntegerPixelShaderConstant )
{
Dx9Device()->SetPixelShaderConstantI( 0, (int *)m_DesiredState.m_pIntegerPixelShaderConstant, m_MaxIntegerPixelShaderConstant );
memcpy( m_DynamicState.m_pIntegerPixelShaderConstant[0].Base(), m_DesiredState.m_pIntegerPixelShaderConstant[0].Base(), m_MaxIntegerPixelShaderConstant * sizeof(IntVector4D) );
m_MaxIntegerPixelShaderConstant = 0;
}
#endif
#endif
}
//-----------------------------------------------------------------------------
// The application is about to perform a hard reboot, but wants to hide the screen flash
// by persisting the front buffer across a reboot boundary. The persisted frame buffer
// can be detected and restored.
//-----------------------------------------------------------------------------
#if defined( _X360 )
void CShaderAPIDx8::PersistDisplay()
{
if ( m_PresentParameters.FrontBufferFormat != D3DFMT_LE_X8R8G8B8 )
{
// The format must be what PersistDisplay() expects, otherwise D3DRIP.
// If this hits due to sRGB bit set that confuses PersistDisplay(),
// the fix may be to slam the presentation parameters to the expected format,
// do a ResetDevice(), and then PersistDisplay().
Assert( 0 );
return;
}
IDirect3DTexture *pTexture;
HRESULT hr = Dx9Device()->GetFrontBuffer( &pTexture );
if ( !FAILED( hr ) )
{
OwnGPUResources( false );
Dx9Device()->PersistDisplay( pTexture, NULL );
pTexture->Release();
}
}
#endif
#if defined( _X360 )
bool CShaderAPIDx8::PostQueuedTexture( const void *pData, int nDataSize, ShaderAPITextureHandle_t *pHandles, int numHandles, int nWidth, int nHeight, int nDepth, int numMips, int *pRefCount )
{
CUtlBuffer vtfBuffer;
IVTFTexture *pVTFTexture = NULL;
bool bOK = false;
if ( !pData || !nDataSize )
{
// invalid
goto cleanUp;
}
// get a unique vtf and mount texture
// vtf can expect non-volatile buffer data to be stable through vtf lifetime
// this prevents redundant copious amounts of image memory transfers
pVTFTexture = CreateVTFTexture();
vtfBuffer.SetExternalBuffer( (void *)pData, nDataSize, nDataSize );
if ( !pVTFTexture->UnserializeFromBuffer( vtfBuffer, false, false, false, 0 ) )
{
goto cleanUp;
}
// provided vtf buffer is all mips, determine top mip due to possible picmip
int iTopMip = 0;
int mipWidth, mipHeight, mipDepth;
do
{
pVTFTexture->ComputeMipLevelDimensions( iTopMip, &mipWidth, &mipHeight, &mipDepth );
if ( nWidth == mipWidth && nHeight == mipHeight && nDepth == mipDepth )
{
break;
}
iTopMip++;
}
while ( mipWidth != 1 || mipHeight != 1 || mipDepth != 1 );
// create and blit
for ( int iFrame = 0; iFrame < numHandles; iFrame++ )
{
ShaderAPITextureHandle_t hTexture = pHandles[iFrame];
Texture_t *pTexture = &GetTexture( hTexture );
int nFaceCount = ( pTexture->m_CreationFlags & TEXTURE_CREATE_CUBEMAP ) ? CUBEMAP_FACE_COUNT-1 : 1;
IDirect3DBaseTexture *pD3DTexture;
if ( pTexture->m_CreationFlags & TEXTURE_CREATE_NOD3DMEMORY )
{
pD3DTexture = pTexture->GetTexture();
if ( !g_TextureHeap.AllocD3DMemory( pD3DTexture ) )
{
goto cleanUp;
}
}
else
{
pD3DTexture = pTexture->GetTexture();
}
// blit the hi-res texture bits into d3d memory
for ( int iFace = 0; iFace < nFaceCount; ++iFace )
{
for ( int iMip = 0; iMip < numMips; ++iMip )
{
pVTFTexture->ComputeMipLevelDimensions( iTopMip + iMip, &mipWidth, &mipHeight, &mipDepth );
unsigned char *pSourceBits = pVTFTexture->ImageData( iFrame, iFace, iTopMip + iMip, 0, 0, 0 );
TextureLoadInfo_t info;
info.m_TextureHandle = hTexture;
info.m_pTexture = pD3DTexture;
info.m_nLevel = iMip;
info.m_nCopy = 0;
info.m_CubeFaceID = (D3DCUBEMAP_FACES)iFace;
info.m_nWidth = mipWidth;
info.m_nHeight = mipHeight;
info.m_nZOffset = 0;
info.m_SrcFormat = pVTFTexture->Format();
info.m_pSrcData = pSourceBits;
info.m_bSrcIsTiled = pVTFTexture->IsPreTiled();
info.m_bCanConvertFormat = ( pTexture->m_Flags & Texture_t::CAN_CONVERT_FORMAT ) != 0;
LoadTexture( info );
}
}
pTexture->m_Flags |= Texture_t::IS_FINALIZED;
(*pRefCount)--;
}
// success
bOK = true;
cleanUp:
if ( pVTFTexture )
{
DestroyVTFTexture( pVTFTexture );
}
if ( !bOK )
{
// undo artificial lock
(*pRefCount) -= numHandles;
}
return bOK;
}
#endif
#if defined( _X360 )
void *CShaderAPIDx8::GetD3DDevice()
{
return Dx9Device();
}
#endif
#if defined( _X360 )
static void r_enable_gpr_allocations_callback( IConVar *var, const char *pOldValue, float flOldValue )
{
if ( ((ConVar *)var)->GetBool() == false )
{
//reset back the default 64/64 allocation before we stop updating
if( Dx9Device() != NULL )
{
Dx9Device()->SetShaderGPRAllocation( 0, 0, 0 );
}
}
}
ConVar r_enable_gpr_allocations( "r_enable_gpr_allocations", "1", 0, "Enable usage of IDirect3DDevice9::SetShaderGPRAllocation()", r_enable_gpr_allocations_callback );
static void CommitShaderGPRs( IDirect3DDevice9 *pDevice, const DynamicState_t &desiredState, DynamicState_t &currentState, bool bForce )
{
if( desiredState.m_iVertexShaderGPRAllocation != currentState.m_iVertexShaderGPRAllocation )
{
pDevice->SetShaderGPRAllocation( 0, desiredState.m_iVertexShaderGPRAllocation, 128 - desiredState.m_iVertexShaderGPRAllocation );
currentState.m_iVertexShaderGPRAllocation = desiredState.m_iVertexShaderGPRAllocation;
}
}
void CShaderAPIDx8::PushVertexShaderGPRAllocation( int iVertexShaderCount )
{
Assert( (iVertexShaderCount >= 16) && (iVertexShaderCount <= 112) );
m_VertexShaderGPRAllocationStack.Push( iVertexShaderCount );
if ( r_enable_gpr_allocations.GetBool() )
{
if ( m_DynamicState.m_iVertexShaderGPRAllocation != iVertexShaderCount )
{
m_DesiredState.m_iVertexShaderGPRAllocation = iVertexShaderCount;
ADD_COMMIT_FUNC( COMMIT_PER_DRAW, COMMIT_ALWAYS, CommitShaderGPRs );
}
}
}
void CShaderAPIDx8::PopVertexShaderGPRAllocation( void )
{
m_VertexShaderGPRAllocationStack.Pop();
if ( r_enable_gpr_allocations.GetBool() )
{
int iVertexShaderCount;
if ( m_VertexShaderGPRAllocationStack.Count() )
iVertexShaderCount = m_VertexShaderGPRAllocationStack.Top();
else
iVertexShaderCount = 64;
if ( m_DynamicState.m_iVertexShaderGPRAllocation != iVertexShaderCount )
{
m_DesiredState.m_iVertexShaderGPRAllocation = iVertexShaderCount;
ADD_COMMIT_FUNC( COMMIT_PER_DRAW, COMMIT_ALWAYS, CommitShaderGPRs );
}
}
}
void CShaderAPIDx8::EnableVSync_360( bool bEnable )
{
if( bEnable )
{
Dx9Device()->SetRenderState( D3DRS_PRESENTIMMEDIATETHRESHOLD, 0 ); //only swap on vertical blanks
}
else
{
Dx9Device()->SetRenderState( D3DRS_PRESENTIMMEDIATETHRESHOLD, 100 ); //allow a swap at any point in the DAC scan
}
}
#endif
// ------------ New Vertex/Index Buffer interface ----------------------------
void CShaderAPIDx8::BindVertexBuffer( int streamID, IVertexBuffer *pVertexBuffer, int nOffsetInBytes, int nFirstVertex, int nVertexCount, VertexFormat_t fmt, int nRepetitions )
{
LOCK_SHADERAPI();
MeshMgr()->BindVertexBuffer( streamID, pVertexBuffer, nOffsetInBytes, nFirstVertex, nVertexCount, fmt, nRepetitions );
}
void CShaderAPIDx8::BindIndexBuffer( IIndexBuffer *pIndexBuffer, int nOffsetInBytes )
{
LOCK_SHADERAPI();
MeshMgr()->BindIndexBuffer( pIndexBuffer, nOffsetInBytes );
}
void CShaderAPIDx8::Draw( MaterialPrimitiveType_t primitiveType, int nFirstIndex, int nIndexCount )
{
LOCK_SHADERAPI();
MeshMgr()->Draw( primitiveType, nFirstIndex, nIndexCount );
}
// ------------ End ----------------------------
float CShaderAPIDx8::GammaToLinear_HardwareSpecific( float fGamma ) const
{
if( IsPC() )
{
return SrgbGammaToLinear( fGamma );
}
else if( IsX360() )
{
return SrgbGammaToLinear( fGamma );
}
else
{
// Unknown console
return pow( fGamma, 2.2f ); // Use a gamma 2.2 curve
}
}
float CShaderAPIDx8::LinearToGamma_HardwareSpecific( float fLinear ) const
{
if ( IsPC() )
{
return SrgbLinearToGamma( fLinear );
}
else if ( IsX360() )
{
return SrgbLinearToGamma( fLinear );
}
else
{
// Unknown console
return pow( fLinear, ( 1.0f / 2.2f ) ); // Use a gamma 2.2 curve
}
}
bool CShaderAPIDx8::ShouldWriteDepthToDestAlpha( void ) const
{
return IsPC() && g_pHardwareConfig->SupportsPixelShaders_2_b() &&
(m_SceneFogMode != MATERIAL_FOG_LINEAR_BELOW_FOG_Z) &&
(GetIntRenderingParameter(INT_RENDERPARM_WRITE_DEPTH_TO_DESTALPHA) != 0);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CShaderAPIDx8::AcquireThreadOwnership()
{
SetCurrentThreadAsOwner();
#if (defined( _X360 ) || defined( DX_TO_GL_ABSTRACTION ))
Dx9Device()->AcquireThreadOwnership();
#endif
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CShaderAPIDx8::ReleaseThreadOwnership()
{
RemoveThreadOwner();
#if (defined( _X360 ) || defined( DX_TO_GL_ABSTRACTION ))
Dx9Device()->ReleaseThreadOwnership();
#endif
}
//-----------------------------------------------------------------------------
// Actual low level setting of the color RT. All Xbox RT funnels here
// to track the actual RT state. Returns true if the RT gets set, otherwise false.
//-----------------------------------------------------------------------------
bool CShaderAPIDx8::SetRenderTargetInternalXbox( ShaderAPITextureHandle_t hRenderTargetTexture, bool bForce )
{
// valid for 360 only
if ( IsPC() )
{
Assert( 0 );
return false;
}
if ( hRenderTargetTexture == INVALID_SHADERAPI_TEXTURE_HANDLE )
{
// could be a reset, force to back buffer
hRenderTargetTexture = SHADER_RENDERTARGET_BACKBUFFER;
}
if ( m_hCachedRenderTarget == INVALID_SHADERAPI_TEXTURE_HANDLE )
{
// let the set go through to establish the initial state
bForce = true;
}
if ( !bForce && ( hRenderTargetTexture == m_hCachedRenderTarget && m_DynamicState.m_bSRGBWritesEnabled == m_bUsingSRGBRenderTarget ) )
{
// current RT matches expected state, leave state intact
return false;
}
// track the updated state
m_bUsingSRGBRenderTarget = m_DynamicState.m_bSRGBWritesEnabled;
m_hCachedRenderTarget = hRenderTargetTexture;
IDirect3DSurface *pSurface;
if ( m_hCachedRenderTarget == SHADER_RENDERTARGET_BACKBUFFER )
{
if ( !m_bUsingSRGBRenderTarget )
{
pSurface = m_pBackBufferSurface;
}
else
{
pSurface = m_pBackBufferSurfaceSRGB;
}
}
else
{
AssertValidTextureHandle( m_hCachedRenderTarget );
Texture_t *pTexture = &GetTexture( m_hCachedRenderTarget );
pSurface = pTexture->GetRenderTargetSurface( m_bUsingSRGBRenderTarget );
}
// the 360 does a wierd reset of some states on a SetRenderTarget()
// the viewport is a clobbered state, it may not be changed by later callers, so it MUST be put back as expected
// the other clobbered states are waiting to be discovered ... sigh
#if defined( _X360 )
D3DVIEWPORT9 viewport;
Dx9Device()->GetViewport( &viewport );
Dx9Device()->SetRenderTarget( 0, pSurface );
Dx9Device()->SetViewport( &viewport );
#endif
return true;
}
//-----------------------------------------------------------------------------
// debug logging
//-----------------------------------------------------------------------------
void CShaderAPIDx8::PrintfVA( char *fmt, va_list vargs )
{
#ifdef DX_TO_GL_ABSTRACTION
#if GLMDEBUG
GLMPrintfVA( fmt, vargs );
#endif
#else
AssertOnce( !"Impl me" );
#endif
}
void CShaderAPIDx8::Printf( const char *fmt, ... )
{
#ifdef DX_TO_GL_ABSTRACTION
#if GLMDEBUG
va_list vargs;
va_start(vargs, fmt);
GLMPrintfVA( fmt, vargs );
va_end( vargs );
#endif
#else
AssertOnce( !"Impl me" );
#endif
}
float CShaderAPIDx8::Knob( char *knobname, float *setvalue )
{
#ifdef DX_TO_GL_ABSTRACTION
#if GLMDEBUG
return GLMKnob( knobname, setvalue );
#else
return 0.0f;
#endif
#else
return 0.0f;
#endif
}
#if defined( _X360 )
extern ConVar r_blocking_spew_threshold;
void D3DBlockingSpewCallback( DWORD Flags, D3DBLOCKTYPE BlockType, float ClockTime, DWORD ThreadTime )
{
if( ClockTime >= r_blocking_spew_threshold.GetFloat() )
{
const char *pBlockType = "";
switch( BlockType )
{
case D3DBLOCKTYPE_NONE:
pBlockType = "D3DBLOCKTYPE_NONE";
break;
case D3DBLOCKTYPE_PRIMARY_OVERRUN:
pBlockType = "D3DBLOCKTYPE_PRIMARY_OVERRUN";
break;
case D3DBLOCKTYPE_SECONDARY_OVERRUN:
pBlockType = "D3DBLOCKTYPE_SECONDARY_OVERRUN";
break;
case D3DBLOCKTYPE_SWAP_THROTTLE:
pBlockType = "D3DBLOCKTYPE_SWAP_THROTTLE";
break;
case D3DBLOCKTYPE_BLOCK_UNTIL_IDLE:
pBlockType = "D3DBLOCKTYPE_BLOCK_UNTIL_IDLE";
break;
case D3DBLOCKTYPE_BLOCK_UNTIL_NOT_BUSY:
pBlockType = "D3DBLOCKTYPE_BLOCK_UNTIL_NOT_BUSY";
break;
case D3DBLOCKTYPE_BLOCK_ON_FENCE:
pBlockType = "D3DBLOCKTYPE_BLOCK_ON_FENCE";
break;
case D3DBLOCKTYPE_VERTEX_SHADER_RELEASE:
pBlockType = "D3DBLOCKTYPE_VERTEX_SHADER_RELEASE";
break;
case D3DBLOCKTYPE_PIXEL_SHADER_RELEASE:
pBlockType = "D3DBLOCKTYPE_PIXEL_SHADER_RELEASE";
break;
case D3DBLOCKTYPE_VERTEX_BUFFER_RELEASE:
pBlockType = "D3DBLOCKTYPE_VERTEX_BUFFER_RELEASE";
break;
case D3DBLOCKTYPE_VERTEX_BUFFER_LOCK:
pBlockType = "D3DBLOCKTYPE_VERTEX_BUFFER_LOCK";
break;
case D3DBLOCKTYPE_INDEX_BUFFER_RELEASE:
pBlockType = "D3DBLOCKTYPE_INDEX_BUFFER_RELEASE";
break;
case D3DBLOCKTYPE_INDEX_BUFFER_LOCK:
pBlockType = "D3DBLOCKTYPE_INDEX_BUFFER_LOCK";
break;
case D3DBLOCKTYPE_TEXTURE_RELEASE:
pBlockType = "D3DBLOCKTYPE_TEXTURE_RELEASE";
break;
case D3DBLOCKTYPE_TEXTURE_LOCK:
pBlockType = "D3DBLOCKTYPE_TEXTURE_LOCK";
break;
case D3DBLOCKTYPE_COMMAND_BUFFER_RELEASE:
pBlockType = "D3DBLOCKTYPE_COMMAND_BUFFER_RELEASE";
break;
case D3DBLOCKTYPE_COMMAND_BUFFER_LOCK:
pBlockType = "D3DBLOCKTYPE_COMMAND_BUFFER_LOCK";
break;
case D3DBLOCKTYPE_CONSTANT_BUFFER_RELEASE:
pBlockType = "D3DBLOCKTYPE_CONSTANT_BUFFER_RELEASE";
break;
case D3DBLOCKTYPE_CONSTANT_BUFFER_LOCK:
pBlockType = "D3DBLOCKTYPE_CONSTANT_BUFFER_LOCK";
break;
NO_DEFAULT;
};
Warning( "D3D Block: %s for %.2f ms\n", pBlockType, ClockTime );
}
}
static void r_blocking_spew_threshold_callback( IConVar *var, const char *pOldValue, float flOldValue )
{
if( Dx9Device() != NULL )
{
if ( ((ConVar *)var)->GetFloat() >= 0.0f )
{
Dx9Device()->SetBlockCallback( 0, D3DBlockingSpewCallback );
}
else
{
Dx9Device()->SetBlockCallback( 0, NULL );
}
}
}
ConVar r_blocking_spew_threshold( "r_blocking_spew_threshold", "-1", 0, "Enable spew of Direct3D Blocks. Specify the minimum blocking time in milliseconds before spewing a warning.", r_blocking_spew_threshold_callback );
#endif
Reference in New Issue View Git Blame Copy Permalink