You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
14354 lines
444 KiB
14354 lines
444 KiB
//========= 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 ¤tState, bool bForce );
|
|
static void CommitSetViewports( IDirect3DDevice9 *pDevice, const DynamicState_t &desiredState, DynamicState_t ¤tState, 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 ¤tState, 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 ¤tState, bool bForce )
|
|
{
|
|
int nCount = g_pMaterialSystemHardwareConfig->GetVertexTextureCount();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
VertexTextureState_t ¤tVTState = 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 ¤tState, 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( ¤tState.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( ¤tState.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 ¤tState, 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 ¤tState, bool bForce )
|
|
{
|
|
bool bChanged = bForce || memcmp( &desiredState.m_Viewport, ¤tState.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( ¤tState.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, ©Rect, 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 ¤tState, 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
|
|
|