ShuriZma
/
Cxbx-Reloaded
mirror of https://github.com/Cxbx-Reloaded/Cxbx-Reloaded.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

More reverting to have less differences with master

This commit is contained in:
PatrickvL 2023-11-11 13:44:20 +01:00
parent 3a74d92247
commit 2f2a3498e9
19 changed files with 549 additions and 556 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/core/hle/D3D8/Direct3D9/CxbxPixelShaderTemplate.hlsl
View File

@ -272,7 +272,7 @@ float4 Sample6F(int ts, float3 s)
float3 DoBumpEnv(const float4 TexCoord, const float4 BumpEnvMat, const float4 src)
{
// Convert the input bump map (source texture) value range into two's complement signed values (from (0, +1) to (-1, +1), using s_bx2):
const float4 BumpMap = src;// m21(src); //s_bx2(src); // Note : medieval discovered s_bias improved JSRF, PatrickvL changed it into s_bx2 thanks to http://www.rastertek.com/dx11tut20.html
const float4 BumpMap = src;// m21(src); //s_bx2(src); // Note : medieval discovered s_bias improved JSRF, PatrickvL changed it into s_bx2 thanks to http://www.rastertek.com/dx11tut20.html
// TODO : The above should be removed, and replaced by some form of COLORSIGN handling, which may not be possible inside this pixel shader, because filtering-during-sampling would cause artifacts.
const float u = TexCoord.x + (BumpEnvMat.x * BumpMap.r) + (BumpEnvMat.z * BumpMap.g); // Or : TexCoord.x + dot(BumpEnvMat.xz, BumpMap.rg)

10
src/core/hle/D3D8/Direct3D9/CxbxVertexShaderTemplate.hlsl
View File

@ -58,9 +58,9 @@ float4 clean(float4 x)
// https://shader-playground.timjones.io/0bbe04704caddadb52cd4134daab8ac3
// Test case: Otogi does math ops on -NaN
// which seems to become +NaN -> +1 in the PS
return (x < 0.f || x > 0.f || x == 0.f) ? x : 1;
return (x < 0.f || x > 0.f || x == 0.f) ? x : 1;
}
float4 c(int register_number)
{
// Map Xbox [-96, 95] to Host [0, 191]
@ -336,8 +336,8 @@ VS_OUTPUT main(const VS_INPUT xIn)
init_v( 8); init_v( 9); init_v(10); init_v(11);
init_v(12); init_v(13); init_v(14); init_v(15);
// Temp variable for paired VS instruction
float4 temp;
// Temp variable for paired VS instruction
float4 temp;
// Xbox shader program)DELIMITER", /* This terminates the header raw string" // */
@ -360,7 +360,7 @@ R"DELIMITER(
const float FOG_TABLE_LINEAR = 3;
float fogFactor;
if(fogTableMode == FOG_TABLE_NONE)
if(fogTableMode == FOG_TABLE_NONE)
fogFactor = fogDepth;
//if(fogDepth < 0)
//fogFactor = 1 + fogDepth;

166
src/core/hle/D3D8/Direct3D9/Direct3D9.cpp
View File

@ -30,6 +30,7 @@
#include <condition_variable>
#include <stack>
#include <core\kernel\exports\xboxkrnl.h>
#include "common\util\CxbxUtil.h"
#include "CxbxVersion.h"
@ -80,7 +81,7 @@
#include <wrl/client.h>
#include "nv2a_vsh_emulator.h"
#include "HleInNv2a.h"
#include "HleInNv2a.h" // For X_D3DAPI_ENUM, HLE_PUSH_ENCODE, FtoDW, DWtoF
//#include "dxgi.h"
#include "D3dx9tex.h"
@ -274,7 +275,7 @@ static LRESULT WINAPI EmuMsgProc(HWND hWnd, UINT msg, WPARAM wPara
static xbox::void_xt NTAPI EmuUpdateTickCount(xbox::PVOID Arg);
static inline void EmuVerifyResourceIsRegistered(xbox::X_D3DResource *pResource, DWORD D3DUsage, int iTextureStage, DWORD dwSize);
static void UpdateCurrentMSpFAndFPS(); // Used for benchmarking/fps count
void CxbxrImpl_SetRenderTarget(xbox::X_D3DSurface *pRenderTarget, xbox::X_D3DSurface *pNewZStencil);
void CxbxImpl_SetRenderTarget(xbox::X_D3DSurface *pRenderTarget, xbox::X_D3DSurface *pNewZStencil);
#define CXBX_D3DCOMMON_IDENTIFYING_MASK (X_D3DCOMMON_TYPE_MASK)// | X_D3DCOMMON_D3DCREATED)
@ -2866,10 +2867,10 @@ IDirect3DIndexBuffer* CxbxCreateIndexBuffer(unsigned IndexCount)
return Result;
}
enum convertIndexBuffer
enum ConvertIndexBuffer
{
passthrough=0,
convertQuadList=1,
convertQuadList=1,
convertQuadStrip=2,
};
@ -2877,7 +2878,7 @@ ConvertedIndexBuffer& CxbxUpdateActiveIndexBuffer
(
INDEX16* pXboxIndexData,
unsigned XboxIndexCount,
convertIndexBuffer convertIndexBuffer
ConvertIndexBuffer convertIndexBuffer
)
{
LOG_INIT; // Allows use of DEBUG_D3DRESULT
@ -3021,8 +3022,9 @@ void SetAspectRatioScale(const xbox::X_D3DPRESENT_PARAMETERS* pPresentationParam
#define CXBX_D3DMULTISAMPLE_XSCALE(type) (((type) & xbox::X_D3DMULTISAMPLE_XSCALE_MASK) >> xbox::X_D3DMULTISAMPLE_XSCALE_SHIFT)
#define CXBX_D3DMULTISAMPLE_YSCALE(type) (((type) & xbox::X_D3DMULTISAMPLE_YSCALE_MASK) >> xbox::X_D3DMULTISAMPLE_YSCALE_SHIFT)
void SetXboxMultiSampleType(xbox::X_D3DMULTISAMPLE_TYPE value)
void SetXboxMultiSampleType(xbox::X_D3DMULTISAMPLE_TYPE arg)
{
DWORD value = (DWORD)arg;
// Validate & correct input, to detect test cases and avoid trouble when using g_Xbox_MultiSampleType :
if (value == 0) {
// Correcting zero to X_D3DMULTISAMPLE_NONE
@ -3054,7 +3056,7 @@ void SetXboxMultiSampleType(xbox::X_D3DMULTISAMPLE_TYPE value)
LOG_TEST_CASE("X_D3DMULTISAMPLE_9_SAMPLES_MULTISAMPLE_GAUSSIAN"); // This used to use scale 1.5f
}
// Set the now-validated g_Xbox_MultiSampleType value :
g_Xbox_MultiSampleType = value;
g_Xbox_MultiSampleType = (xbox::X_D3DMULTISAMPLE_TYPE)value;
}
float GetMultiSampleOffsetDelta()
@ -3517,7 +3519,7 @@ void Direct3D_CreateDevice_End
}
// Set the backbuffer as the initial rendertarget
CxbxrImpl_SetRenderTarget(g_pXbox_BackBufferSurface, xbox::zeroptr);
CxbxImpl_SetRenderTarget(g_pXbox_BackBufferSurface, xbox::zeroptr);
}
// Now do the same, but for the default depth stencil surface
@ -3535,7 +3537,7 @@ void Direct3D_CreateDevice_End
LOG_TEST_CASE("Unable to determine default Xbox depth stencil");
} else {
// Update only the depth stencil
CxbxrImpl_SetRenderTarget(xbox::zeroptr, g_pXbox_DefaultDepthStencilSurface);
CxbxImpl_SetRenderTarget(xbox::zeroptr, g_pXbox_DefaultDepthStencilSurface);
}
}
}
@ -3936,7 +3938,7 @@ static void CxbxrImpl_Reset(xbox::X_D3DPRESENT_PARAMETERS* pPresentationParamete
// Below requirement for patched function(s) in order to function properly.
// Perform xbox's D3DDevice_Reset call.
// Perform CxbxrImpl_SetRenderTarget call.
// Perform CxbxImpl_SetRenderTarget call.
}
// ******************************************************************
@ -3958,7 +3960,7 @@ xbox::hresult_xt WINAPI xbox::EMUPATCH(D3DDevice_Reset)
// Refresh the current render target and depth stencil, to apply changes made within D3DDevice_Reset
// Some XDKs do this for us, but not all do!
CxbxrImpl_SetRenderTarget(g_pXbox_RenderTarget, g_pXbox_DepthStencil);
CxbxImpl_SetRenderTarget(g_pXbox_RenderTarget, g_pXbox_DepthStencil);
return hRet;
}
@ -3989,7 +3991,7 @@ LTCG_DECL xbox::hresult_xt WINAPI xbox::EMUPATCH(D3DDevice_Reset_0__LTCG_edi1)()
call XB_TRMP(D3DDevice_Reset_0__LTCG_edi1)
}
CxbxrImpl_SetRenderTarget(g_pXbox_RenderTarget, g_pXbox_DepthStencil);
CxbxImpl_SetRenderTarget(g_pXbox_RenderTarget, g_pXbox_DepthStencil);
__asm {
LTCG_EPILOGUE
@ -4023,7 +4025,7 @@ LTCG_DECL xbox::hresult_xt WINAPI xbox::EMUPATCH(D3DDevice_Reset_0__LTCG_ebx1)()
call XB_TRMP(D3DDevice_Reset_0__LTCG_ebx1)
}
CxbxrImpl_SetRenderTarget(g_pXbox_RenderTarget, g_pXbox_DepthStencil);
CxbxImpl_SetRenderTarget(g_pXbox_RenderTarget, g_pXbox_DepthStencil);
__asm {
LTCG_EPILOGUE
@ -4471,7 +4473,7 @@ LTCG_DECL xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG
// Log
D3DDevice_LoadVertexShader_0__LTCG_eax_Address_ecx_Handle(Handle, Address);
//CxbxrImpl_LoadVertexShader(Handle, Address);
//CxbxImpl_LoadVertexShader(Handle, Address);
HLE_PushApi(X_D3DDevice_LoadVertexShader,
(DWORD)Handle,
@ -4515,7 +4517,7 @@ LTCG_DECL xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_LoadVertexShader_0__LTCG
// Log
D3DDevice_LoadVertexShader_0__LTCG_eax_Address_edx_Handle(Handle, Address);
//CxbxrImpl_LoadVertexShader(Handle, Address);
//CxbxImpl_LoadVertexShader(Handle, Address);
HLE_PushApi(X_D3DDevice_LoadVertexShader,
(DWORD)Handle,
@ -4558,7 +4560,7 @@ LTCG_DECL xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_LoadVertexShader_4)
// Log
D3DDevice_LoadVertexShader_4(Handle, Address);
//CxbxrImpl_LoadVertexShader(Handle, Address);
//CxbxImpl_LoadVertexShader(Handle, Address);
HLE_PushApi(X_D3DDevice_LoadVertexShader,
(DWORD)Handle,
@ -4587,7 +4589,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_LoadVertexShader)
XB_TRMP(D3DDevice_LoadVertexShader)(Handle, Address);
#if !USEPGRAPH_LoadVertexShader
CxbxrImpl_LoadVertexShader(Handle, Address);
CxbxImpl_LoadVertexShader(Handle, Address);
#else
HLE_PushApi(X_D3DDevice_LoadVertexShader,
(DWORD)Handle,
@ -4628,7 +4630,7 @@ LTCG_DECL xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SelectVertexShader_0__LT
D3DDevice_SelectVertexShader_0__LTCG_eax1_ebx2(Handle, Address);
#if !USEPGRAPH_SelectVertexShader
CxbxrImpl_SelectVertexShader(Handle, Address);
CxbxImpl_SelectVertexShader(Handle, Address);
#else
HLE_PushApi(X_D3DDevice_SelectVertexShader,
(DWORD)Handle,
@ -4672,7 +4674,7 @@ LTCG_DECL xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SelectVertexShader_4__LT
D3DDevice_SelectVertexShader_4__LTCG_eax1(Handle, Address);
#if !USEPGRAPH_SelectVertexShader
CxbxrImpl_SelectVertexShader(Handle, Address);
CxbxImpl_SelectVertexShader(Handle, Address);
#else
HLE_PushApi(X_D3DDevice_SelectVertexShader,
(DWORD)Handle,
@ -4702,7 +4704,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SelectVertexShader)
XB_TRMP(D3DDevice_SelectVertexShader)(Handle, Address);
#if !USEPGRAPH_SelectVertexShader
CxbxrImpl_SelectVertexShader(Handle, Address);
CxbxImpl_SelectVertexShader(Handle, Address);
#else
HLE_PushApi(X_D3DDevice_SelectVertexShader,
(DWORD)Handle,
@ -5202,7 +5204,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetViewport)
XB_TRMP(D3DDevice_SetViewport)(pViewport);
#if !USEPGRAPH_SetViewport
CxbxrImpl_SetViewport(pViewport);
CxbxImpl_SetViewport(pViewport);
#else
int dword_count = HLE_PushStart + 1;
if (pViewport)
@ -5226,7 +5228,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetViewport)
}
// Set the viewport
void CxbxrImpl_SetViewport(xbox::X_D3DVIEWPORT8* pViewport)
void CxbxImpl_SetViewport(xbox::X_D3DVIEWPORT8* pViewport)
{
LOG_INIT;
@ -5299,7 +5301,7 @@ xbox::void_xt WINAPI CxbxrImpl_SetShaderConstantMode
// reset Transform
// reset fixed function T&L constants
CxbxrImpl_SetVertexShaderConstant(NV_IGRAPH_XF_XFCTX_CONS0 - X_D3DSCM_CORRECTION, (xbox::PVOID)&FixedFunctionPipelineConstants[0], 3);
CxbxImpl_SetVertexShaderConstant(NV_IGRAPH_XF_XFCTX_CONS0 - X_D3DSCM_CORRECTION, (xbox::PVOID)&FixedFunctionPipelineConstants[0], 3);
// reset 4 Texgen Planes with Identity Matrix
// reset Fog Plane with (0.0f, 0.0f, 0.0f, 1.0f)
@ -5373,7 +5375,7 @@ xbox::void_xt __fastcall xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant_8)
XB_TRMP(D3DDevice_SetVertexShaderConstant_8)(tmp, ConstantCount, Register, pConstantData);
}
CxbxrImpl_SetVertexShaderConstant(Register, pConstantData, ConstantCount);
CxbxImpl_SetVertexShaderConstant(Register, pConstantData, ConstantCount);
}
// ******************************************************************
@ -5402,7 +5404,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant)
// Or better yet, remove all D3DDevice_SetVertexShaderConstant patches
// once CxbxUpdateHostVertexShaderConstants is reliable (ie. : when we're
// able to flush the NV2A push buffer)
CxbxrImpl_SetVertexShaderConstant(Register, pConstantData, ConstantCount);
CxbxImpl_SetVertexShaderConstant(Register, pConstantData, ConstantCount);
}
// ******************************************************************
@ -5424,7 +5426,7 @@ xbox::void_xt __fastcall xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant1)
// but D3DDevice_SetVertexShaderConstant expects -96..95 range
// so we adjust before forwarding
//EMUPATCH(D3DDevice_SetVertexShaderConstant)(Register - X_D3DSCM_CORRECTION, pConstantData, 1);
CxbxrImpl_SetVertexShaderConstant(Register - X_D3DSCM_CORRECTION, pConstantData, 1);
CxbxImpl_SetVertexShaderConstant(Register - X_D3DSCM_CORRECTION, pConstantData, 1);
}
// ******************************************************************
@ -5445,7 +5447,7 @@ xbox::void_xt __fastcall xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant1Fast)
// but D3DDevice_SetVertexShaderConstant expects -96..95 range
// so we adjust before forwarding
//EMUPATCH(D3DDevice_SetVertexShaderConstant)(Register - X_D3DSCM_CORRECTION, pConstantData, 1);
CxbxrImpl_SetVertexShaderConstant(Register - X_D3DSCM_CORRECTION, pConstantData, 1);
CxbxImpl_SetVertexShaderConstant(Register - X_D3DSCM_CORRECTION, pConstantData, 1);
}
// ******************************************************************
@ -5466,7 +5468,7 @@ xbox::void_xt __fastcall xbox::EMUPATCH(D3DDevice_SetVertexShaderConstant4)
// but D3DDevice_SetVertexShaderConstant expects -96..95 range
// so we adjust before forwarding
//EMUPATCH(D3DDevice_SetVertexShaderConstant)(Register - X_D3DSCM_CORRECTION, pConstantData, 4);
CxbxrImpl_SetVertexShaderConstant(Register - X_D3DSCM_CORRECTION, pConstantData, 4);
CxbxImpl_SetVertexShaderConstant(Register - X_D3DSCM_CORRECTION, pConstantData, 4);
}
// ******************************************************************
@ -5487,7 +5489,7 @@ xbox::void_xt __fastcall xbox::EMUPATCH(D3DDevice_SetVertexShaderConstantNotInli
// but D3DDevice_SetVertexShaderConstant expects -96..95 range
// so we adjust before forwarding
//EMUPATCH(D3DDevice_SetVertexShaderConstant)(Register - X_D3DSCM_CORRECTION, pConstantData, ConstantCount / 4);
CxbxrImpl_SetVertexShaderConstant(Register - X_D3DSCM_CORRECTION, pConstantData, ConstantCount / 4);
CxbxImpl_SetVertexShaderConstant(Register - X_D3DSCM_CORRECTION, pConstantData, ConstantCount / 4);
}
// ******************************************************************
@ -5508,7 +5510,7 @@ xbox::void_xt __fastcall xbox::EMUPATCH(D3DDevice_SetVertexShaderConstantNotInli
// but D3DDevice_SetVertexShaderConstant expects -96..95 range
// so we adjust before forwarding
//EMUPATCH(D3DDevice_SetVertexShaderConstant)(Register - X_D3DSCM_CORRECTION, pConstantData, ConstantCount / 4);
CxbxrImpl_SetVertexShaderConstant(Register - X_D3DSCM_CORRECTION, pConstantData, ConstantCount / 4);
CxbxImpl_SetVertexShaderConstant(Register - X_D3DSCM_CORRECTION, pConstantData, ConstantCount / 4);
}
// Overload for logging
@ -5962,7 +5964,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_Begin)
else {
assert((xbox::X_D3DPRIMITIVETYPE)PrimitiveType != xbox::X_D3DPT_INVALID);
CxbxrImpl_Begin(PrimitiveType);
CxbxImpl_Begin(PrimitiveType);
/*
HLE_PushApi(X_D3DDevice_Begin,
(DWORD)PrimitiveType);
@ -5990,7 +5992,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVertexData2f)
XB_TRMP(D3DDevice_SetVertexData2f)(Register, a, b);
}
else {
CxbxrImpl_SetVertexData4f(Register, a, b, 0.0f, 1.0f);
CxbxImpl_SetVertexData4f(Register, a, b, 0.0f, 1.0f);
/*
HLE_PushApi(X_D3DDevice_SetVertexData4f,
(DWORD)Register,
@ -6002,9 +6004,6 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVertexData2f)
}
}
//static inline DWORD FtoDW(FLOAT f) { return *((DWORD*)&f); }
//static inline FLOAT DWtoF(DWORD f) { return *((FLOAT*)&f); }
// ******************************************************************
// * patch: D3DDevice_SetVertexData2s
// ******************************************************************
@ -6032,7 +6031,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVertexData2s)
const float fa = static_cast<float>(a);
const float fb = static_cast<float>(b);
CxbxrImpl_SetVertexData4f(Register, a, b, 0.0f, 1.0f);
CxbxImpl_SetVertexData4f(Register, a, b, 0.0f, 1.0f);
/*
HLE_PushApi(X_D3DDevice_SetVertexData4f,
(DWORD)Register,
@ -6092,7 +6091,7 @@ LTCG_DECL xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVertexData4f_16)
// Log
D3DDevice_SetVertexData4f_16(Register, a, b, c, d);
CxbxrImpl_SetVertexData4f(Register, a, b, c, d);
CxbxImpl_SetVertexData4f(Register, a, b, c, d);
/*
HLE_PushApi(X_D3DDevice_SetVertexData4f,
@ -6133,7 +6132,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVertexData4f)
XB_TRMP(D3DDevice_SetVertexData4f)(Register, a, b, c, d);
}
else {
CxbxrImpl_SetVertexData4f(Register, a, b, c, d);
CxbxImpl_SetVertexData4f(Register, a, b, c, d);
/*
HLE_PushApi(X_D3DDevice_SetVertexData4f,
(DWORD)Register,
@ -6174,7 +6173,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVertexData4ub)
const float fc = c / 255.0f;
const float fd = d / 255.0f;
CxbxrImpl_SetVertexData4f(Register, fa, fb, fc, fd);
CxbxImpl_SetVertexData4f(Register, fa, fb, fc, fd);
/*
HLE_PushApi(X_D3DDevice_SetVertexData4f,
(DWORD)Register,
@ -6219,7 +6218,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVertexData4s)
const float fc = static_cast<float>(c);
const float fd = static_cast<float>(d);
CxbxrImpl_SetVertexData4f(Register, fa, fb, fc, fd);
CxbxImpl_SetVertexData4f(Register, fa, fb, fc, fd);
/*
HLE_PushApi(X_D3DDevice_SetVertexData4f,
(DWORD)Register,
@ -6251,7 +6250,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVertexDataColor)
else {
const D3DXCOLOR XColor = Color;
CxbxrImpl_SetVertexData4f(Register, XColor.r, XColor.g, XColor.b, XColor.a);
CxbxImpl_SetVertexData4f(Register, XColor.r, XColor.g, XColor.b, XColor.a);
/*
HLE_PushApi(X_D3DDevice_SetVertexData4f,
(DWORD)Register,
@ -6275,7 +6274,7 @@ xbox::hresult_xt WINAPI xbox::EMUPATCH(D3DDevice_End)()
}
else {
EmuKickOffWait(X_D3DDevice_End);
CxbxrImpl_End(); //we unpatched D3DDevice_End, but found that there are memory corruptions introduced by multi entrance. so we have to come out a workaround.
CxbxImpl_End(); //we unpatched D3DDevice_End, but found that there are memory corruptions introduced by multi entrance. so we have to come out a workaround.
}
hresult_xt result = 0;// XB_TRMP(D3DDevice_End)();
@ -10247,7 +10246,7 @@ LTCG_DECL xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetStreamSource_0__LTCG_
// Log
D3DDevice_SetStreamSource_0__LTCG_eax_StreamNumber_edi_pStreamData_ebx_Stride(StreamNumber, pStreamData, Stride);
//CxbxrImpl_SetStreamSource(StreamNumber, pStreamData, Stride);
//CxbxImpl_SetStreamSource(StreamNumber, pStreamData, Stride);
//EMUPATCH(D3DDevice_SetShaderConstantMode)(Mode);
//CxbxrImpl_SetShaderConstantMode(Mode);
@ -10300,7 +10299,7 @@ LTCG_DECL xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetStreamSource_4)
// Log
D3DDevice_SetStreamSource_4(StreamNumber, pStreamData, Stride);
//CxbxrImpl_SetStreamSource(StreamNumber, pStreamData, Stride);
//CxbxImpl_SetStreamSource(StreamNumber, pStreamData, Stride);
//EMUPATCH(D3DDevice_SetShaderConstantMode)(Mode);
//CxbxrImpl_SetShaderConstantMode(Mode);
@ -10353,7 +10352,7 @@ LTCG_DECL xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetStreamSource_8)
// Log
D3DDevice_SetStreamSource_8(StreamNumber, pStreamData, Stride);
//CxbxrImpl_SetStreamSource(StreamNumber, pStreamData, Stride);
//CxbxImpl_SetStreamSource(StreamNumber, pStreamData, Stride);
//EMUPATCH(D3DDevice_SetShaderConstantMode)(Mode);
//CxbxrImpl_SetShaderConstantMode(Mode);
@ -10396,7 +10395,7 @@ xbox::void_xt __fastcall xbox::EMUPATCH(D3DDevice_SetStreamSource_8__LTCG_edx_St
// This should stop us having to patch GetStreamSource!
XB_TRMP(D3DDevice_SetStreamSource_8__LTCG_edx_StreamNumber)(nullptr, StreamNumber, pStreamData, Stride);
//CxbxrImpl_SetStreamSource(StreamNumber, pStreamData, Stride);
//CxbxImpl_SetStreamSource(StreamNumber, pStreamData, Stride);
//EMUPATCH(D3DDevice_SetShaderConstantMode)(Mode);
//CxbxrImpl_SetShaderConstantMode(Mode);
@ -10427,7 +10426,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetStreamSource)
// This should stop us having to patch GetStreamSource!
XB_TRMP(D3DDevice_SetStreamSource)(StreamNumber, pStreamData, Stride);
//CxbxrImpl_SetStreamSource(StreamNumber, pStreamData, Stride);
//CxbxImpl_SetStreamSource(StreamNumber, pStreamData, Stride);
//EMUPATCH(D3DDevice_SetShaderConstantMode)(Mode);
@ -10457,12 +10456,12 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVertexShader)
HLE_PushInit();
}
else {
CxbxrImpl_SetVertexShader(Handle);
CxbxImpl_SetVertexShader(Handle);
}
#if 0
#if !USEPGRAPH_SetVertexShader
CxbxrImpl_SetVertexShader(Handle);
CxbxImpl_SetVertexShader(Handle);
#else
HLE_PushApi(X_D3DDevice_SetVertexShader,
Handle);
@ -10504,14 +10503,14 @@ LTCG_DECL xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVertexShader_0)()
HLE_PushInit();
}
else {
CxbxrImpl_SetVertexShader(Handle);
CxbxImpl_SetVertexShader(Handle);
}
#if 0
HLE_PushApi(X_D3DDevice_SetVertexShader,
Handle);
#endif
#if !USEPGRAPH_SetVertexShader
//CxbxrImpl_SetVertexShader(Handle);
//CxbxImpl_SetVertexShader(Handle);
#endif
__asm {
@ -10526,7 +10525,7 @@ constexpr unsigned int InputQuadsPerPage = ((IndicesPerPage) / VERTICES_PER_TRIA
// TODO : Move to own file
// Called by CxbxDrawPrimitiveUP (indirectly by D3DDevice_DrawVerticesUP,
// EmuExecutePushBufferRaw and CxbxrImpl_End) when PrimitiveType == X_D3DPT_QUADLIST.
// EmuExecutePushBufferRaw and CxbxImpl_End) when PrimitiveType == X_D3DPT_QUADLIST.
// Emulated by calling g_pD3DDevice->DrawIndexedPrimitiveUP with index data that maps
// quads to triangles. This function creates the index buffer that is needed for this;
// For every quad that must be drawn, we generate indices for two triangles.
@ -10572,7 +10571,7 @@ INDEX16* CxbxConvertQuadListIndexData(CxbxDrawContext& DrawContext)
// TODO : Move to own file
// Called by CxbxDrawPrimitiveUP (indirectly by D3DDevice_DrawVerticesUP,
// EmuExecutePushBufferRaw and CxbxrImpl_End) when PrimitiveType == X_D3DPT_QUADLIST.
// EmuExecutePushBufferRaw and CxbxImpl_End) when PrimitiveType == X_D3DPT_QUADLIST.
// Emulated by calling g_pD3DDevice->DrawIndexedPrimitiveUP with index data that maps
// quads to triangles. This function creates the index buffer that is needed for this;
// For every quad that must be drawn, we generate indices for two triangles.
@ -10762,7 +10761,7 @@ void CxbxDrawIndexed(CxbxDrawContext& DrawContext)
//assert(DrawContext.dwStartVertex == 0);
assert(DrawContext.pXboxIndexData != nullptr);
assert(DrawContext.dwVertexCount > 0); // TODO : If this fails, make responsible callers do an early-exit
convertIndexBuffer convertIndexBuffer=passthrough;
ConvertIndexBuffer convertIndexBuffer = passthrough;
if (DrawContext.XboxPrimitiveType == xbox::X_D3DPT_QUADLIST) {
convertIndexBuffer = convertQuadList;
}
@ -10817,7 +10816,7 @@ void CxbxDrawIndexed(CxbxDrawContext& DrawContext)
}
// TODO : Move to own file
// Drawing function specifically for rendering Xbox draw calls supplying a 'User Pointer'.
// Called by D3DDevice_DrawVerticesUP, EmuExecutePushBufferRaw and CxbxrImpl_End
// Called by D3DDevice_DrawVerticesUP, EmuExecutePushBufferRaw and CxbxImpl_End
void CxbxDrawIndexedPrimitiveUP(CxbxDrawContext& DrawContext)
{
LOG_INIT // Allows use of DEBUG_D3DRESULT
@ -10932,7 +10931,7 @@ void CxbxDrawIndexedPrimitiveUP(CxbxDrawContext& DrawContext)
}
// TODO : Move to own file
// Drawing function specifically for rendering Xbox draw calls supplying a 'User Pointer'.
// Called by D3DDevice_DrawVerticesUP, EmuExecutePushBufferRaw and CxbxrImpl_End
// Called by D3DDevice_DrawVerticesUP, EmuExecutePushBufferRaw and CxbxImpl_End
void CxbxDrawPrimitiveUP(CxbxDrawContext &DrawContext)
{
LOG_INIT // Allows use of DEBUG_D3DRESULT
@ -11020,7 +11019,7 @@ void CxbxDrawPrimitiveUP(CxbxDrawContext &DrawContext)
}
// TODO : Move to own file
// Drawing function specifically for rendering Xbox draw calls supplying a 'User Pointer'.
// Called by D3DDevice_DrawVerticesUP, EmuExecutePushBufferRaw and CxbxrImpl_End
// Called by D3DDevice_DrawVerticesUP, EmuExecutePushBufferRaw and CxbxImpl_End
void CxbxDrawPrimitive(CxbxDrawContext& DrawContext)
{
LOG_INIT // Allows use of DEBUG_D3DRESULT
@ -11044,7 +11043,7 @@ void CxbxDrawPrimitive(CxbxDrawContext& DrawContext)
//DrawContext.dwVertexCount = DrawContext.dwHostPrimitiveCount * 3;
//DrawContext.NumVerticesToUse = DrawContext.dwVertexCount;
//we're only using this function call to setup host index buffer.
ConvertedIndexBuffer& CacheEntry = CxbxUpdateActiveIndexBuffer(pIndexData, DrawContext.dwHostPrimitiveCount * 3, convertIndexBuffer::passthrough);
ConvertedIndexBuffer& CacheEntry = CxbxUpdateActiveIndexBuffer(pIndexData, DrawContext.dwHostPrimitiveCount * 3, ConvertIndexBuffer::passthrough);
// Note : CxbxUpdateActiveIndexBuffer calls SetIndices
@ -11076,7 +11075,7 @@ void CxbxDrawPrimitive(CxbxDrawContext& DrawContext)
//DrawContext.NumVerticesToUse = DrawContext.dwVertexCount;
//we're only using this function call to setup host index buffer.
ConvertedIndexBuffer& CacheEntry = CxbxUpdateActiveIndexBuffer(pIndexData, DrawContext.dwHostPrimitiveCount * 3, convertIndexBuffer::passthrough);
ConvertedIndexBuffer& CacheEntry = CxbxUpdateActiveIndexBuffer(pIndexData, DrawContext.dwHostPrimitiveCount * 3, ConvertIndexBuffer::passthrough);
// Note : CxbxUpdateActiveIndexBuffer calls SetIndices
// Set LowIndex and HighIndex *before* VerticesInBuffer gets derived
@ -11118,7 +11117,7 @@ void CxbxDrawPrimitive(CxbxDrawContext& DrawContext)
// Close line-loops using a final single line, drawn from the end to the start vertex :
INDEX16 pIndexData[2] = { 0, (INDEX16)DrawContext.dwVertexCount };
//we're only using this function call to setup host index buffer.
ConvertedIndexBuffer& CacheEntry = CxbxUpdateActiveIndexBuffer(pIndexData, DrawContext.dwVertexCount, convertIndexBuffer::passthrough);
ConvertedIndexBuffer& CacheEntry = CxbxUpdateActiveIndexBuffer(pIndexData, DrawContext.dwVertexCount, ConvertIndexBuffer::passthrough);
HRESULT hRet = g_pD3DDevice->DrawIndexedPrimitive(
/* PrimitiveType = */EmuXB2PC_D3DPrimitiveType(DrawContext.XboxPrimitiveType),
@ -11434,7 +11433,7 @@ void CxbxUpdateDirtyVertexShaderConstants(const float* constants, bool* dirty) {
extern float* HLE_get_NV2A_vertex_constant_float4_ptr(unsigned const_index); // TMP glue
// TODO : Once we're able to flush the NV2A push buffer
// remove our patches on D3DDevice_SetVertexShaderConstant (and CxbxrImpl_SetVertexShaderConstant)
// remove our patches on D3DDevice_SetVertexShaderConstant (and CxbxImpl_SetVertexShaderConstant)
void CxbxUpdateHostVertexShaderConstants()
{
// For Xbox vertex shader programs, the Xbox vertex shader constants
@ -12527,7 +12526,7 @@ static thread_local uint32_t setRenderTargetCount = 0;
//create cache key of xbox texture which contents the render target surface. and get host container resource of host surface set to that xbox render target surface,
//then set host container resource to xbox texture key. this is in case any render target (including render target and depth buffer) being used as texture input in texture stage.
//by creating the texture in cache and setup the correct host container resource, the data will be linked.
void CxbxrImpl_SetRenderTargetTexture(xbox::X_D3DSurface* pXborSurface, IDirect3DSurface* pHostSurface, D3DSURFACE_DESC HostSurfaceDesc)
void CxbxImpl_SetRenderTargetTexture(xbox::X_D3DSurface* pXborSurface, IDirect3DSurface* pHostSurface, D3DSURFACE_DESC HostSurfaceDesc)
{
LOG_INIT;
if (pXborSurface != nullptr) {
@ -12546,9 +12545,9 @@ void CxbxrImpl_SetRenderTargetTexture(xbox::X_D3DSurface* pXborSurface, IDirect3
g_TextureCache[key].Parent = nullptr;
//pHostTexture = CxbxConvertXboxSurfaceToHostTexture(pXboxTexture);
auto hRet = pHostSurface->GetContainer(IID_PPV_ARGS(&pHostTexture));
DEBUG_D3DRESULT(hRet, "CxbxrImpl_SetRenderTargetTexture: pHostSurface->GetContainer");
DEBUG_D3DRESULT(hRet, "CxbxImpl_SetRenderTargetTexture: pHostSurface->GetContainer");
if (FAILED(hRet)) {
LOG_TEST_CASE("CxbxrImpl_SetRenderTargetTexture: Failed to get Texture from Surface");
LOG_TEST_CASE("CxbxImpl_SetRenderTargetTexture: Failed to get Texture from Surface");
}else{
auto key = GetHostResourceKey(pXboxTexture);
auto& ResourceCache = GetResourceCache(key);
@ -12585,9 +12584,9 @@ void CxbxrImpl_SetRenderTargetTexture(xbox::X_D3DSurface* pXborSurface, IDirect3
g_TextureCache[key].Parent = nullptr;
//pHostTexture = CxbxConvertXboxSurfaceToHostTexture(pXboxTexture);
auto hRet = pHostSurface->GetContainer(IID_PPV_ARGS(&pHostTexture));
DEBUG_D3DRESULT(hRet, "CxbxrImpl_SetRenderTargetTexture: pHostSurface->GetContainer");
DEBUG_D3DRESULT(hRet, "CxbxImpl_SetRenderTargetTexture: pHostSurface->GetContainer");
if (FAILED(hRet)) {
LOG_TEST_CASE("CxbxrImpl_SetRenderTargetTexture: Failed to get Texture from Surface");
LOG_TEST_CASE("CxbxImpl_SetRenderTargetTexture: Failed to get Texture from Surface");
}
else {
auto key = GetHostResourceKey(pXboxTexture);
@ -12712,7 +12711,7 @@ void EmuSetRenderTarget
defaultViewport.Height = INT_MAX;
defaultViewport.MinZ = 0;
defaultViewport.MaxZ = 1;
CxbxrImpl_SetViewport(&defaultViewport);
CxbxImpl_SetViewport(&defaultViewport);
pHostRenderTarget = GetHostSurface(pRenderTarget, D3DUSAGE_RENDERTARGET);
if (pHostRenderTarget != nullptr) {
@ -12720,7 +12719,7 @@ void EmuSetRenderTarget
D3DSURFACE_DESC HostRenderTarget_Desc;
pHostRenderTarget->GetDesc(&HostRenderTarget_Desc);
// create resource cache for containers of both xbox and host surfaces and link two containers together.
CxbxrImpl_SetRenderTargetTexture(pRenderTarget, pHostRenderTarget, HostRenderTarget_Desc);
CxbxImpl_SetRenderTargetTexture(pRenderTarget, pHostRenderTarget, HostRenderTarget_Desc);
}
HRESULT hRet;
@ -12838,7 +12837,7 @@ void EmuSetDepthStencil
// Get current host render target dimensions
D3DSURFACE_DESC HostDepthStencilSurface_Desc;
hRet = pHostDepthStencilSurface->GetDesc(&HostDepthStencilSurface_Desc);
CxbxrImpl_SetRenderTargetTexture(g_pXbox_DepthStencil, pHostDepthStencilSurface, HostDepthStencilSurface_Desc);
CxbxImpl_SetRenderTargetTexture(g_pXbox_DepthStencil, pHostDepthStencilSurface, HostDepthStencilSurface_Desc);
}
}
}
@ -12852,7 +12851,7 @@ void EmuSetDepthStencil
}
}
void CxbxrImpl_SetRenderTarget
void CxbxImpl_SetRenderTarget
(
xbox::X_D3DSurface* pRenderTarget,
xbox::X_D3DSurface* pNewZStencil
@ -12950,13 +12949,13 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetRenderTarget)
LOG_FUNC_ARG(pNewZStencil)
LOG_FUNC_END;
//move to CxbxrImpl_SetRenderTarget()
//move to CxbxImpl_SetRenderTarget()
//NestedPatchCounter call(setRenderTargetCount);
XB_TRMP(D3DDevice_SetRenderTarget)(pRenderTarget, pNewZStencil);
if (!bRenderTargetInit) {
bRenderTargetInit = true;
CxbxrImpl_SetRenderTarget(pRenderTarget, pNewZStencil);
CxbxImpl_SetRenderTarget(pRenderTarget, pNewZStencil);
}
else {
if (pRenderTarget)
@ -12999,14 +12998,14 @@ LTCG_DECL xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetRenderTarget_0)
}
//this must be called before we trampolin to avoid HLE D3D_CommonSetRenderTarget() being called twice
//move to CxbxrImpl_SetRenderTarget()
//move to CxbxImpl_SetRenderTarget()
//NestedPatchCounter call(setRenderTargetCount);
// logging only
D3DDevice_SetRenderTarget_0(pRenderTarget, pNewZStencil);
//CxbxrImpl_SetRenderTarget(pRenderTarget, pNewZStencil);
//CxbxImpl_SetRenderTarget(pRenderTarget, pNewZStencil);
if (!bRenderTargetInit) {
bRenderTargetInit = true;
CxbxrImpl_SetRenderTarget(pRenderTarget, pNewZStencil);
CxbxImpl_SetRenderTarget(pRenderTarget, pNewZStencil);
}
else {
// add reference to the surfaces to prevent them being released before we access them in pgraph.
@ -13039,7 +13038,7 @@ void WINAPI CxbxrImpl_D3D_CommonSetRenderTarget
NestedPatchCounter call(setRenderTargetCount);
if (call.GetLevel() == 0) {
CxbxrImpl_SetRenderTarget(pRenderTarget, pNewZStencil);
CxbxImpl_SetRenderTarget(pRenderTarget, pNewZStencil);
}
}
// ******************************************************************
@ -13258,7 +13257,7 @@ LTCG_DECL xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_DeleteVertexShader_0)
// Log
D3DDevice_DeleteVertexShader_0(Handle);
CxbxrImpl_DeleteVertexShader(Handle);
CxbxImpl_DeleteVertexShader(Handle);
// When deleting, call trampoline *after* our implementation,
// so that we can still access it's fields before it gets deleted!
@ -13281,7 +13280,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_DeleteVertexShader)
{
LOG_FUNC_ONE_ARG(Handle);
CxbxrImpl_DeleteVertexShader(Handle);
CxbxImpl_DeleteVertexShader(Handle);
// When deleting, call trampoline *after* our implementation,
// so that we can still access it's fields before it gets deleted!
@ -13397,7 +13396,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetVertexShaderInput)
Spyro A Hero's Tail-b18e00e5.ini:D3DDevice_SetVertexShaderInputDirect = 0x286760
*/
//CxbxrImpl_SetVertexShaderInput(Handle, StreamCount, pStreamInputs);
//CxbxImpl_SetVertexShaderInput(Handle, StreamCount, pStreamInputs);
HLE_PushApi(X_D3DDevice_SetVertexShaderInput,
(DWORD)Handle,
@ -13502,7 +13501,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_LoadVertexShaderProgram)
XB_TRMP(D3DDevice_LoadVertexShaderProgram)(pFunction, Address);
}
#if !USEPGRAPH_LoadVertexShaderProgram
CxbxrImpl_LoadVertexShaderProgram((DWORD *)pFunction, Address);
CxbxImpl_LoadVertexShaderProgram((DWORD *)pFunction, Address);
#else
// TODO : Likely, the entire program should be pushed here instead of just the pointer
// which the X_D3DDevice_LoadVertexShaderProgram handler must cater for as well.
@ -13669,7 +13668,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetScreenSpaceOffset)
LOG_FUNC_END;
XB_TRMP(D3DDevice_SetScreenSpaceOffset)(x, y);
//CxbxrImpl_SetScreenSpaceOffset(x, y);
//CxbxImpl_SetScreenSpaceOffset(x, y);
HLE_PushApi(X_D3DDevice_SetScreenSpaceOffset,
FtoDW(x),
@ -14076,7 +14075,7 @@ xbox::X_D3DSurface* CxbxrImpl_GetAvSavedDataSurface()
return (xbox::X_D3DSurface*)xbox::AvSavedDataAddress;
IDirect3DSurface* pHostPersistSurface;
pHostPersistSurface = GetHostSurface(pPersistSurface, D3DUSAGE_RENDERTARGET);
//copy AVSavedAddress common and modify it then set to our own persist texture/surface
//copy AvSavedDataAddress common and modify it then set to our own persist texture/surface
xboxPersistTexture = *(xbox::X_D3DBaseTexture*)xbox::AvSavedDataAddress;
xboxPersistTexture.Common &= 0xFFFEFFFF;
@ -14247,6 +14246,7 @@ void CxbxrImpl_PersistDisplay()
memcpy(dst, src, HostLockedRect.Pitch * pXboxBackBufferHostSurdaceDesc.Height);
pXboxPersistSurfaceHostSurface->UnlockRect();
}
// ******************************************************************
// * patch: D3DDevice_PersistDisplay
// ******************************************************************
@ -14630,7 +14630,7 @@ xbox::void_xt WINAPI xbox::EMUPATCH(D3DDevice_SetRenderTargetFast)
XB_TRMP(D3DDevice_SetRenderTargetFast)(pRenderTarget, pNewZStencil,Flags);
//CxbxrImpl_SetRenderTarget(pRenderTarget, pNewZStencil);
//CxbxImpl_SetRenderTarget(pRenderTarget, pNewZStencil);
}
// ******************************************************************

77
src/core/hle/D3D8/Direct3D9/Direct3D9.h
View File

@ -44,8 +44,8 @@ extern void CxbxInitWindow(bool bFullInit);
void CxbxUpdateNativeD3DResources();
void CxbxrImpl_SetRenderTarget(xbox::X_D3DSurface* pRenderTarget, xbox::X_D3DSurface* pNewZStencil);
void CxbxrImpl_SetViewport(xbox::X_D3DVIEWPORT8* pViewport);
void CxbxImpl_SetRenderTarget(xbox::X_D3DSurface* pRenderTarget, xbox::X_D3DSurface* pNewZStencil);
void CxbxImpl_SetViewport(xbox::X_D3DVIEWPORT8* pViewport);
// initialize direct3d
extern void EmuD3DInit();
@ -58,7 +58,7 @@ extern IDirect3DDevice9Ex *g_pD3DDevice;
extern xbox::dword_xt g_Xbox_VertexShader_Handle;
extern xbox::X_PixelShader *g_pXbox_PixelShader;
extern xbox::X_PixelShader* pNV2A_PixelShader;
extern xbox::X_PixelShader* pNV2A_PixelShader; // Declared in XbPushBuffer.cpp
extern xbox::X_D3DBaseTexture *g_pXbox_SetTexture[xbox::X_D3DTS_STAGECOUNT];
@ -396,7 +396,7 @@ X_D3DSurface * WINAPI EMUPATCH(D3DDevice_GetDepthStencilSurface2)();
xbox::hresult_xt WINAPI EMUPATCH(D3DDevice_GetTile)
(
xbox::dword_xt Index,
xbox::X_D3DTILE * pTile
xbox::X_D3DTILE *pTile
);
// ******************************************************************
@ -405,7 +405,7 @@ xbox::hresult_xt WINAPI EMUPATCH(D3DDevice_GetTile)
xbox::hresult_xt WINAPI EMUPATCH(D3DDevice_SetTile)
(
xbox::dword_xt Index,
CONST xbox::X_D3DTILE * pTile
CONST xbox::X_D3DTILE *pTile
);
// ******************************************************************
@ -839,26 +839,6 @@ xbox::hresult_xt WINAPI EMUPATCH(Lock3DSurface)
dword_xt Flags
);
// ******************************************************************
// * patch: IDirect3DTexture8_GetSurfaceLevel
// ******************************************************************
xbox::hresult_xt WINAPI EMUPATCH(D3DTexture_GetSurfaceLevel)
(
X_D3DTexture* pThis,
uint_xt Level,
X_D3DSurface** ppSurfaceLevel
);
// ******************************************************************
// * patch: IDirect3DTexture8_GetSurfaceLevel2
// ******************************************************************
X_D3DSurface* WINAPI EMUPATCH(D3DTexture_GetSurfaceLevel2)
(
X_D3DTexture* pThis,
uint_xt Level
);
#if 0 // patch disabled
// ******************************************************************
// * patch: Get2DSurfaceDesc
@ -890,6 +870,25 @@ xbox::void_xt WINAPI EMUPATCH(D3DSurface_LockRect)
dword_xt Flags
);
// ******************************************************************
// * patch: IDirect3DBaseTexture8_GetLevelCount
// ******************************************************************
xbox::dword_xt WINAPI EMUPATCH(D3DBaseTexture_GetLevelCount)
(
X_D3DBaseTexture *pThis
);
#endif
// ******************************************************************
// * patch: IDirect3DTexture8_GetSurfaceLevel2
// ******************************************************************
X_D3DSurface * WINAPI EMUPATCH(D3DTexture_GetSurfaceLevel2)
(
X_D3DTexture *pThis,
uint_xt Level
);
#if 0 // patch disabled
// ******************************************************************
// * patch: IDirect3DTexture8_LockRect
// ******************************************************************
@ -901,15 +900,19 @@ xbox::void_xt WINAPI EMUPATCH(D3DTexture_LockRect)
CONST RECT *pRect,
dword_xt Flags
);
#endif
// ******************************************************************
// * patch: IDirect3DBaseTexture8_GetLevelCount
// * patch: IDirect3DTexture8_GetSurfaceLevel
// ******************************************************************
xbox::dword_xt WINAPI EMUPATCH(D3DBaseTexture_GetLevelCount)
xbox::hresult_xt WINAPI EMUPATCH(D3DTexture_GetSurfaceLevel)
(
X_D3DBaseTexture* pThis
X_D3DTexture *pThis,
uint_xt Level,
X_D3DSurface **ppSurfaceLevel
);
#if 0 // patch disabled
// ******************************************************************
// * patch: IDirect3DVolumeTexture8_LockBox
// ******************************************************************
@ -1539,14 +1542,6 @@ xbox::void_xt WINAPI EMUPATCH(D3D_CommonSetRenderTarget)
void *unknown
);
// ******************************************************************
// * patch: D3D_UpdateProjectionViewportTransform
// ******************************************************************
xbox::hresult_xt WINAPI EMUPATCH(D3D_UpdateProjectionViewportTransform)
(
xbox::void_xt
);
// ******************************************************************
// * patch: D3DDevice_SetPalette
// ******************************************************************
@ -2234,4 +2229,12 @@ xbox::hresult_xt WINAPI EMUPATCH(CreateStandAloneSurface)
xbox::X_D3DSurface** ppSurface
);
#endif
// ******************************************************************
// * patch: D3D_UpdateProjectionViewportTransform
// ******************************************************************
xbox::hresult_xt WINAPI EMUPATCH(D3D_UpdateProjectionViewportTransform)
(
xbox::void_xt
);
#endif // DIRECT3D9_H

6
src/core/hle/D3D8/Direct3D9/FixedFunctionPixelShader.hlsl
View File

@ -179,9 +179,9 @@ TextureArgs ExecuteTextureStage(
// The w component can be set by titles in vertex shaders
// without using texture transform flags
// Test case: DoA 3 reflections on 'Ice Stage'
//float4 coords;// = TexCoords[i].xyzw / TexCoords[i].w;
if (TexCoords[i].w > 1.0)
TexCoords[i].xyzw = TexCoords[i].xyzw / TexCoords[i].w;
//float4 coords;// = TexCoords[i].xyzw / TexCoords[i].w;
if (TexCoords[i].w > 1.0)
TexCoords[i].xyzw = TexCoords[i].xyzw / TexCoords[i].w;
if (type == SAMPLE_NONE)
t = 1; // Test case JSRF
else if (type == SAMPLE_2D)

32
src/core/hle/D3D8/Direct3D9/HleInNv2a.h
View File

@ -204,7 +204,7 @@ typedef enum _X_D3DAPI_ENUM {
// virtual NV2A register for HLE API handler
# define NV097_HLE_API 0x00000080 /* Snugged this method in the middle between
# define NV097_SET_OBJECT 0x00000000 the first method, and the next known one :
# define NV097_NO_OPERATION 0x00000100 Aternatively, move to the end, after NV097_DEBUG_INIT */
# define NV097_NO_OPERATION 0x00000100 Alternatively, move to the end, after NV097_DEBUG_INIT */
#define HLE_PUSH_ENCODE(dword_count) PUSH_ENCODE(PUSH_INSTR_IMM_NOINC, dword_count, PUSH_SUBCH_0, NV097_HLE_API, PUSH_TYPE_METHOD)
@ -213,7 +213,7 @@ static inline FLOAT DWtoF(DWORD f) { return *((FLOAT*)&f); }
// prototypes for xbox D3DDevice API HLE handlers in NV2A pgraph, implemented in Direct3D9.cpp, called in EmuNV2A_PGRAPH.cpp
// we create defines for each patched api in general format USEPGRAPH_ + apu post names without D3DDevice_. define it as 1 to enable the patch and prgaph handler, as 0 to keep original Cxbxr behavior. this is to speed up the test which api is not feasible for this POC.
void CxbxrImpl_Begin(xbox::X_D3DPRIMITIVETYPE PrimitiveType);
void CxbxImpl_Begin(xbox::X_D3DPRIMITIVETYPE PrimitiveType);
void CxbxrImpl_BlockUntilVerticalBlank();
#define USEPGRAPH_BlockUntilVerticalBlank 0
void CxbxrImpl_Clear(xbox::dword_xt Count, CONST D3DRECT* pRects, xbox::dword_xt Flags, D3DCOLOR Color, float Z, xbox::dword_xt Stencil);
@ -230,17 +230,17 @@ void WINAPI CxbxrImpl_CopyRects(xbox::X_D3DSurface* pSourceSurface, CONST RECT*
#define USEPGRAPH_DrawVertices 0
void WINAPI CxbxrImpl_DrawVerticesUP(xbox::X_D3DPRIMITIVETYPE PrimitiveType, xbox::uint_xt VertexCount, CONST PVOID pVertexStreamZeroData, xbox::uint_xt VertexStreamZeroStride);
#define USEPGRAPH_DrawVerticesUP 0
void CxbxrImpl_End();
void CxbxImpl_End();
void CxbxrImpl_InsertCallback(xbox::X_D3DCALLBACKTYPE Type, xbox::X_D3DCALLBACK pCallback, xbox::dword_xt Context);
//void WINAPI CxbxrImpl_LightEnable(xbox::dword_xt Index, xbox::bool_xt bEnable);
void CxbxrImpl_LoadVertexShader(DWORD Handle, DWORD ProgramRegister);
void CxbxImpl_LoadVertexShader(DWORD Handle, DWORD ProgramRegister);
#define USEPGRAPH_LoadVertexShader 1
void CxbxrImpl_LoadVertexShaderProgram(CONST DWORD* pFunction, DWORD Address);
void CxbxImpl_LoadVertexShaderProgram(CONST DWORD* pFunction, DWORD Address);
#define USEPGRAPH_LoadVertexShaderProgram 0
#define USEPGRAPH_Lock2DSurface 0
#define USEPGRAPH_Lock3DSurface 0
void WINAPI CxbxrImpl_RunVertexStateShader(xbox::dword_xt Address, CONST xbox::float_xt* pData);
void CxbxrImpl_SelectVertexShader(DWORD Handle, DWORD Address);
void CxbxImpl_SelectVertexShader(DWORD Handle, DWORD Address);
#define USEPGRAPH_SelectVertexShader 1
void WINAPI CxbxrImpl_SetBackBufferScale(xbox::float_xt x, xbox::float_xt y);
// todo: CxbxrImpl_SetFlickerFilter() not implemented yet.
@ -254,29 +254,29 @@ void WINAPI CxbxrImpl_SetModelView(CONST D3DMATRIX* pModelView, CONST D3DMATRIX*
void CxbxrImpl_SetPalette(xbox::dword_xt Stage, xbox::X_D3DPalette* pPalette);
void CxbxrImpl_SetPixelShader(xbox::dword_xt Handle);
//void WINAPI CxbxrImpl_SetRenderState_Simple(xbox::dword_xt Method, xbox::dword_xt Value);
void CxbxrImpl_SetRenderTarget(xbox::X_D3DSurface* pRenderTarget, xbox::X_D3DSurface* pNewZStencil);
void CxbxImpl_SetRenderTarget(xbox::X_D3DSurface* pRenderTarget, xbox::X_D3DSurface* pNewZStencil);
void WINAPI CxbxrImpl_D3D_CommonSetRenderTarget(xbox::X_D3DSurface* pRenderTarget, xbox::X_D3DSurface* pNewZStencil, void* unknown);
void CxbxrImpl_ReleaseRenderTarget(xbox::X_D3DSurface* pTarget, xbox::X_D3DSurface* pZbuffer);
#define USEPGRAPH_SetRenderTarget 0 /*SetRenderTarget() is used in D3DDevice_Create() and we need it to be implemented right away. to do: */
void CxbxrImpl_SetScreenSpaceOffset(float x, float y);
void CxbxImpl_SetScreenSpaceOffset(float x, float y);
#define USEPGRAPH_SetScreenSpaceOffset 0
void WINAPI CxbxrImpl_SetShaderConstantMode(xbox::X_VERTEXSHADERCONSTANTMODE Mode);
// todo: CxbxrImpl_SetSoftDisplayFilter() not implemented yet.
//void WINAPI CxbxrImpl_SetSoftDisplayFilter(xbox::bool_xt Enable);
void CxbxrImpl_SetStreamSource(UINT StreamNumber, xbox::X_D3DVertexBuffer* pStreamData, UINT Stride);
void CxbxImpl_SetStreamSource(UINT StreamNumber, xbox::X_D3DVertexBuffer* pStreamData, UINT Stride);
//#define USEPGRAPH_SetStreamSource 0 /*not permitted in pushbuffer recording*/
void WINAPI CxbxrImpl_SetTexture(xbox::dword_xt Stage, xbox::X_D3DBaseTexture* pTexture);
void CxbxrImpl_SwitchTexture(xbox::dword_xt Method, xbox::dword_xt Data, xbox::dword_xt Format);
void CxbxrImpl_SetTransform(xbox::X_D3DTRANSFORMSTATETYPE State, CONST D3DMATRIX* pMatrix);
void CxbxrImpl_SetVertexData4f(int Register, FLOAT a, FLOAT b, FLOAT c, FLOAT d);
void CxbxrImpl_SetVertexShader(DWORD Handle);
void CxbxImpl_SetVertexData4f(int Register, FLOAT a, FLOAT b, FLOAT c, FLOAT d);
void CxbxImpl_SetVertexShader(DWORD Handle);
#define USEPGRAPH_SetVertexShader 1
//all SetVertexShaderConstant variants are unpatched now. but we have to use CxbxrImpl_SetVertexShaderConstant() to handle the constant change in pgraph.
//all SetVertexShaderConstant variants are unpatched now. but we have to use CxbxImpl_SetVertexShaderConstant() to handle the constant change in pgraph.
//void CxbxrImpl_GetVertexShaderConstant(INT Register, PVOID pConstantData, DWORD ConstantCount);
//void CxbxrImpl_SetVertexShaderConstant(INT Register, PVOID pConstantData, DWORD ConstantCount);
//void CxbxrImpl_SetVertexShaderInput(DWORD Handle, UINT StreamCount, xbox::X_STREAMINPUT* pStreamInputs);
//void WINAPI CxbxrImpl_SetVertexShaderInputDirect(xbox::X_VERTEXATTRIBUTEFORMAT* pVAF, UINT StreamCount, xbox::X_STREAMINPUT* pStreamInputs);
void CxbxrImpl_SetViewport(xbox::X_D3DVIEWPORT8* pViewport);
//void CxbxImpl_SetVertexShaderConstant(INT Register, PVOID pConstantData, DWORD ConstantCount);
//void CxbxImpl_SetVertexShaderInput(DWORD Handle, UINT StreamCount, xbox::X_STREAMINPUT* pStreamInputs);
//void WINAPI CxbxImpl_SetVertexShaderInputDirect(xbox::X_VERTEXATTRIBUTEFORMAT* pVAF, UINT StreamCount, xbox::X_STREAMINPUT* pStreamInputs);
void CxbxImpl_SetViewport(xbox::X_D3DVIEWPORT8* pViewport);
#define USEPGRAPH_SetViewport 1
// Present() also calls Swap(), patched LTCG version of Swap also calls Swap(). so we only handle Swap().
xbox::void_xt WINAPI CxbxrImpl_Present(xbox::dword_xt Flags);

373
src/core/hle/D3D8/Direct3D9/RenderStates.cpp
View File

@ -30,272 +30,119 @@
#include "RenderStates.h"
#include "Logging.h"
#include "core/hle/D3D8/Direct3D9/Direct3D9.h" // For g_pD3DDevice
#include "core/hle/D3D8/XbD3D8Types.h"
#include "core/hle/D3D8/XbConvert.h"
void SetXboxMultiSampleType(xbox::X_D3DMULTISAMPLE_TYPE value);
#define F_ONE 0x3f800000
#define F_64 0x42800000
typedef enum _X_D3DCMPFUNC {
X_D3DCMP_NEVER = 0x200,
X_D3DCMP_LESS = 0x201,
X_D3DCMP_EQUAL = 0x202,
X_D3DCMP_LESSEQUAL = 0x203,
X_D3DCMP_GREATER = 0x204,
X_D3DCMP_NOTEQUAL = 0x205,
X_D3DCMP_GREATEREQUAL = 0x206,
X_D3DCMP_ALWAYS = 0x207,
X_D3DCMP_FORCE_DWORD = 0x7fffffff,
} X_D3DCMPFUNC;
typedef enum _X_D3DBLEND {
X_D3DBLEND_ZERO = 0,
X_D3DBLEND_ONE = 1,
X_D3DBLEND_SRCCOLOR = 0x300,
X_D3DBLEND_INVSRCCOLOR = 0x301,
X_D3DBLEND_SRCALPHA = 0x302,
X_D3DBLEND_INVSRCALPHA = 0x303,
X_D3DBLEND_DESTALPHA = 0x304,
X_D3DBLEND_INVDESTALPHA = 0x305,
X_D3DBLEND_DESTCOLOR = 0x306,
X_D3DBLEND_INVDESTCOLOR = 0x307,
X_D3DBLEND_SRCALPHASAT = 0x308,
X_D3DBLEND_CONSTANTCOLOR = 0x8001,
X_D3DBLEND_INVCONSTANTCOLOR = 0x8002,
X_D3DBLEND_CONSTANTALPHA = 0x8003,
X_D3DBLEND_INVCONSTANTALPHA = 0x8004,
X_D3DBLEND_FORCE_DWORD = 0x7fffffff,
} X_D3DBLEND;
namespace xbox {
typedef enum _X_D3DSHADEMODE {
X_D3DSHADE_FLAT = 0x1d00,
X_D3DSHADE_GOURAUD = 0x1d01,
X_D3DSHADE_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
} X_D3DSHADEMODE;
typedef enum _X_D3DSTENCILOP {
X_D3DSTENCILOP_KEEP = 0x1e00,
X_D3DSTENCILOP_ZERO = 0,
X_D3DSTENCILOP_REPLACE = 0x1e01,
X_D3DSTENCILOP_INCRSAT = 0x1e02,
X_D3DSTENCILOP_DECRSAT = 0x1e03,
X_D3DSTENCILOP_INVERT = 0x150a,
X_D3DSTENCILOP_INCR = 0x8507,
X_D3DSTENCILOP_DECR = 0x8508,
X_D3DSTENCILOP_FORCE_DWORD = 0x7fffffff,
} X_D3DSTENCILOP;
typedef enum _X_D3DSWATHWIDTH {
X_D3DSWATH_8 = 0,
X_D3DSWATH_16 = 1,
X_D3DSWATH_32 = 2,
X_D3DSWATH_64 = 3,
X_D3DSWATH_128 = 4,
X_D3DSWATH_OFF = 0xf,
X_D3DSWATH_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
} X_D3DSWATHWIDTH;
typedef enum _X_D3DBLENDOP {
X_D3DBLENDOP_ADD = 0x8006,
X_D3DBLENDOP_SUBTRACT = 0x800a,
X_D3DBLENDOP_REVSUBTRACT = 0x800b,
X_D3DBLENDOP_MIN = 0x8007,
X_D3DBLENDOP_MAX = 0x8008,
X_D3DBLENDOP_ADDSIGNED = 0xf006, // Xbox extension
X_D3DBLENDOP_REVSUBTRACTSIGNED = 0xf005, // Xbox extension
X_D3DBLENDOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
} X_D3DBLENDOP;
typedef enum _X_D3DFOGMODE {
X_D3DFOG_NONE = 0,
X_D3DFOG_EXP = 1,
X_D3DFOG_EXP2 = 2,
X_D3DFOG_LINEAR = 3,
X_D3DFOG_FORCE_DWORD = 0x7fffffff
} X_D3DFOGMODE;
typedef enum _X_D3DMATERIALCOLORSOURCE {
X_D3DMCS_MATERIAL = 0,
X_D3DMCS_COLOR1 = 1,
X_D3DMCS_COLOR2 = 2,
X_D3DMCS_FORCE_DWORD = 0x7fffffff
} X_D3DMATERIALCOLORSOURCE;
typedef enum _X_D3DPATCHEDGESTYLE {
X_D3DPATCHEDGE_DISCRETE = 0,
X_D3DPATCHEDGE_CONTINUOUS = 1,
X_D3DPATCHEDGE_FORCE_DWORD = 0x7fffffff,
} X_D3DPATCHEDGESTYLE;
typedef enum _X_D3DVERTEXBLENDFLAGS {
X_D3DVBF_DISABLE = 0, // Disable vertex blending
X_D3DVBF_1WEIGHTS = 1, // 2 matrix blending
X_D3DVBF_2WEIGHTS = 3, // 3 matrix blending
X_D3DVBF_3WEIGHTS = 5, // 4 matrix blending
X_D3DVBF_2WEIGHTS2MATRICES = 2, // Xbox extension
X_D3DVBF_3WEIGHTS3MATRICES = 4, // Xbox extension
X_D3DVBF_4WEIGHTS4MATRICES = 6, // Xbox extension
X_D3DVBF_MAX = 7,
X_D3DVBF_FORCE_DWORD = 0x7fffffff, // force 32-bit size enum
} X_D3DVERTEXBLENDFLAGS;
typedef enum _X_D3DFILLMODE {
X_D3DFILL_POINT = 0x1b00,
X_D3DFILL_WIREFRAME = 0x1b01,
X_D3DFILL_SOLID = 0x1b02,
X_D3DFILL_FORCE_DWORD = 0x7fffffff,
} X_D3DFILLMODE;
typedef enum _X_D3DFRONT { // Xbox extension
X_D3DFRONT_CW = 0x900,
X_D3DFRONT_CCW = 0x901,
X_D3DFRONT_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
} X_D3DFRONT;
typedef enum _X_D3DCULL {
X_D3DCULL_NONE = 0,
X_D3DCULL_CW = 0x900,
X_D3DCULL_CCW = 0x901,
X_D3DCULL_FORCE_DWORD = 0x7fffffff,
}X_D3DCULL;
typedef enum _X_D3DLOGICOP { // Xbox extension
X_D3DLOGICOP_NONE = 0,
X_D3DLOGICOP_CLEAR = 0x1500,
X_D3DLOGICOP_AND = 0x1501,
X_D3DLOGICOP_AND_REVERSE = 0x1502,
X_D3DLOGICOP_COPY = 0x1503,
X_D3DLOGICOP_AND_INVERTED = 0x1504,
X_D3DLOGICOP_NOOP = 0x1505,
X_D3DLOGICOP_XOR = 0x1506,
X_D3DLOGICOP_OR = 0x1507,
X_D3DLOGICOP_NOR = 0x1508,
X_D3DLOGICOP_EQUIV = 0x1509,
X_D3DLOGICOP_INVERT = 0x150a,
X_D3DLOGICOP_OR_REVERSE = 0x150b,
X_D3DLOGICOP_COPY_INVERTED = 0x150c,
X_D3DLOGICOP_OR_INVERTED = 0x150d,
X_D3DLOGICOP_NAND = 0x150e,
X_D3DLOGICOP_SET = 0x150f,
X_D3DLOGICOP_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
} X_D3DLOGICOP;
typedef enum _X_D3DMULTISAMPLEMODE
const uint32_t g_DefaultRenderStates[][2] =
{
X_D3DMULTISAMPLEMODE_1X = 0,
X_D3DMULTISAMPLEMODE_2X = 1,
X_D3DMULTISAMPLEMODE_4X = 2,
X_D3DMULTISAMPLEMODE_FORCE_DWORD = 0x7fffffff
} X_D3DMULTISAMPLETYPE;
CONST UINT32 g_DefaultRenderStates[][2] =
{
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_ZFUNC , _X_D3DCMPFUNC::X_D3DCMP_LESSEQUAL },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_ALPHAFUNC , X_D3DCMP_ALWAYS },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_ALPHABLENDENABLE , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_ALPHATESTENABLE , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_ALPHAREF , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_SRCBLEND , X_D3DBLEND_ONE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_DESTBLEND , X_D3DBLEND_ZERO },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_ZWRITEENABLE , TRUE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_DITHERENABLE , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_SHADEMODE , X_D3DSHADE_GOURAUD },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_COLORWRITEENABLE , xbox::X_D3DCOLORWRITEENABLE_ALL },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_STENCILZFAIL , X_D3DSTENCILOP_KEEP },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_STENCILPASS , X_D3DSTENCILOP_KEEP },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_STENCILFUNC , X_D3DCMP_ALWAYS },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_STENCILREF , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_STENCILMASK , 0xffffffff },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_STENCILWRITEMASK , 0xffffffff },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_BLENDOP , X_D3DBLENDOP_ADD },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_BLENDCOLOR , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_SWATHWIDTH , X_D3DSWATH_128 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_POLYGONOFFSETZSLOPESCALE , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_POLYGONOFFSETZOFFSET , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_POINTOFFSETENABLE , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_WIREFRAMEOFFSETENABLE , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_SOLIDOFFSETENABLE , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_FOGENABLE , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_FOGTABLEMODE , X_D3DFOG_NONE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_FOGSTART , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_FOGEND , F_ONE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_FOGDENSITY , F_ONE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_RANGEFOGENABLE , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_WRAP0 , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_WRAP1 , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_WRAP2 , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_WRAP3 , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_LIGHTING , TRUE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_SPECULARENABLE , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_LOCALVIEWER , TRUE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_COLORVERTEX , TRUE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_BACKSPECULARMATERIALSOURCE, X_D3DMCS_COLOR2 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_BACKDIFFUSEMATERIALSOURCE , X_D3DMCS_COLOR1 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_BACKAMBIENTMATERIALSOURCE , X_D3DMCS_MATERIAL },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_BACKEMISSIVEMATERIALSOURCE, X_D3DMCS_MATERIAL },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_SPECULARMATERIALSOURCE , X_D3DMCS_COLOR2 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_DIFFUSEMATERIALSOURCE , X_D3DMCS_COLOR1 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_AMBIENTMATERIALSOURCE , X_D3DMCS_MATERIAL },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_EMISSIVEMATERIALSOURCE , X_D3DMCS_MATERIAL },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_BACKAMBIENT , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_AMBIENT , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_POINTSIZE , F_ONE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_POINTSIZE_MIN , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_POINTSPRITEENABLE , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_POINTSCALEENABLE , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_POINTSCALE_A , F_ONE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_POINTSCALE_B , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_POINTSCALE_C , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_POINTSIZE_MAX , F_64 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_PATCHEDGESTYLE , X_D3DPATCHEDGE_DISCRETE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_PATCHSEGMENTS , F_ONE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_SWAPFILTER, 0xdeadbeef },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_PSTEXTUREMODES , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_VERTEXBLEND , X_D3DVBF_DISABLE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_FOGCOLOR , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_FILLMODE , X_D3DFILL_SOLID },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_BACKFILLMODE , X_D3DFILL_SOLID },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_TWOSIDEDLIGHTING , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_NORMALIZENORMALS , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_ZENABLE, D3DZB_USEW },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_STENCILENABLE , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_STENCILFAIL , X_D3DSTENCILOP_KEEP },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_FRONTFACE , X_D3DFRONT_CW },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_CULLMODE , X_D3DCULL_CCW },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_TEXTUREFACTOR , 0xffffffff },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_ZBIAS , 0 },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_LOGICOP , X_D3DLOGICOP_NONE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_EDGEANTIALIAS , FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_MULTISAMPLEANTIALIAS , TRUE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_MULTISAMPLEMASK , 0xffffffff },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_MULTISAMPLEMODE, 0xdeadbeef },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_MULTISAMPLERENDERTARGETMODE, X_D3DMULTISAMPLEMODE_1X },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_SHADOWFUNC , D3DCMP_NEVER },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_LINEWIDTH , F_ONE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_DXT1NOISEENABLE, TRUE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_YUVENABLE, FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_OCCLUSIONCULLENABLE, TRUE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_STENCILCULLENABLE, TRUE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_ROPZCMPALWAYSREAD, FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_ROPZREAD, FALSE },
{ xbox::_X_D3DRENDERSTATETYPE::X_D3DRS_DONOTCULLUNCOMPRESSED, FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_ZFUNC , X_D3DCMPFUNC::X_D3DCMP_LESSEQUAL },
{ X_D3DRENDERSTATETYPE::X_D3DRS_ALPHAFUNC , X_D3DCMP_ALWAYS },
{ X_D3DRENDERSTATETYPE::X_D3DRS_ALPHABLENDENABLE , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_ALPHATESTENABLE , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_ALPHAREF , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_SRCBLEND , X_D3DBLEND_ONE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_DESTBLEND , X_D3DBLEND_ZERO },
{ X_D3DRENDERSTATETYPE::X_D3DRS_ZWRITEENABLE , TRUE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_DITHERENABLE , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_SHADEMODE , X_D3DSHADE_GOURAUD },
{ X_D3DRENDERSTATETYPE::X_D3DRS_COLORWRITEENABLE , X_D3DCOLORWRITEENABLE_ALL },
{ X_D3DRENDERSTATETYPE::X_D3DRS_STENCILZFAIL , X_D3DSTENCILOP_KEEP },
{ X_D3DRENDERSTATETYPE::X_D3DRS_STENCILPASS , X_D3DSTENCILOP_KEEP },
{ X_D3DRENDERSTATETYPE::X_D3DRS_STENCILFUNC , X_D3DCMP_ALWAYS },
{ X_D3DRENDERSTATETYPE::X_D3DRS_STENCILREF , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_STENCILMASK , 0xffffffff },
{ X_D3DRENDERSTATETYPE::X_D3DRS_STENCILWRITEMASK , 0xffffffff },
{ X_D3DRENDERSTATETYPE::X_D3DRS_BLENDOP , X_D3DBLENDOP_ADD },
{ X_D3DRENDERSTATETYPE::X_D3DRS_BLENDCOLOR , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_SWATHWIDTH , X_D3DSWATH_128 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_POLYGONOFFSETZSLOPESCALE , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_POLYGONOFFSETZOFFSET , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_POINTOFFSETENABLE , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_WIREFRAMEOFFSETENABLE , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_SOLIDOFFSETENABLE , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_FOGENABLE , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_FOGTABLEMODE , X_D3DFOG_NONE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_FOGSTART , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_FOGEND , F_ONE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_FOGDENSITY , F_ONE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_RANGEFOGENABLE , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_WRAP0 , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_WRAP1 , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_WRAP2 , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_WRAP3 , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_LIGHTING , TRUE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_SPECULARENABLE , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_LOCALVIEWER , TRUE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_COLORVERTEX , TRUE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_BACKSPECULARMATERIALSOURCE, X_D3DMCS_COLOR2 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_BACKDIFFUSEMATERIALSOURCE , X_D3DMCS_COLOR1 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_BACKAMBIENTMATERIALSOURCE , X_D3DMCS_MATERIAL },
{ X_D3DRENDERSTATETYPE::X_D3DRS_BACKEMISSIVEMATERIALSOURCE, X_D3DMCS_MATERIAL },
{ X_D3DRENDERSTATETYPE::X_D3DRS_SPECULARMATERIALSOURCE , X_D3DMCS_COLOR2 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_DIFFUSEMATERIALSOURCE , X_D3DMCS_COLOR1 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_AMBIENTMATERIALSOURCE , X_D3DMCS_MATERIAL },
{ X_D3DRENDERSTATETYPE::X_D3DRS_EMISSIVEMATERIALSOURCE , X_D3DMCS_MATERIAL },
{ X_D3DRENDERSTATETYPE::X_D3DRS_BACKAMBIENT , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_AMBIENT , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_POINTSIZE , F_ONE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_POINTSIZE_MIN , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_POINTSPRITEENABLE , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_POINTSCALEENABLE , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_POINTSCALE_A , F_ONE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_POINTSCALE_B , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_POINTSCALE_C , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_POINTSIZE_MAX , F_64 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_PATCHEDGESTYLE , X_D3DPATCHEDGE_DISCRETE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_PATCHSEGMENTS , F_ONE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_SWAPFILTER, 0xdeadbeef },
{ X_D3DRENDERSTATETYPE::X_D3DRS_PSTEXTUREMODES , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_VERTEXBLEND , X_D3DVBF_DISABLE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_FOGCOLOR , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_FILLMODE , X_D3DFILL_SOLID },
{ X_D3DRENDERSTATETYPE::X_D3DRS_BACKFILLMODE , X_D3DFILL_SOLID },
{ X_D3DRENDERSTATETYPE::X_D3DRS_TWOSIDEDLIGHTING , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_NORMALIZENORMALS , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_ZENABLE, D3DZB_USEW },
{ X_D3DRENDERSTATETYPE::X_D3DRS_STENCILENABLE , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_STENCILFAIL , X_D3DSTENCILOP_KEEP },
{ X_D3DRENDERSTATETYPE::X_D3DRS_FRONTFACE , X_D3DFRONT_CW },
{ X_D3DRENDERSTATETYPE::X_D3DRS_CULLMODE , X_D3DCULL_CCW },
{ X_D3DRENDERSTATETYPE::X_D3DRS_TEXTUREFACTOR , 0xffffffff },
{ X_D3DRENDERSTATETYPE::X_D3DRS_ZBIAS , 0 },
{ X_D3DRENDERSTATETYPE::X_D3DRS_LOGICOP , X_D3DLOGICOP_NONE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_EDGEANTIALIAS , FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_MULTISAMPLEANTIALIAS , TRUE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_MULTISAMPLEMASK , 0xffffffff },
{ X_D3DRENDERSTATETYPE::X_D3DRS_MULTISAMPLEMODE, 0xdeadbeef },
{ X_D3DRENDERSTATETYPE::X_D3DRS_MULTISAMPLERENDERTARGETMODE, X_D3DMULTISAMPLEMODE_1X },
{ X_D3DRENDERSTATETYPE::X_D3DRS_SHADOWFUNC , D3DCMP_NEVER },
{ X_D3DRENDERSTATETYPE::X_D3DRS_LINEWIDTH , F_ONE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_DXT1NOISEENABLE, TRUE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_YUVENABLE, FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_OCCLUSIONCULLENABLE, TRUE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_STENCILCULLENABLE, TRUE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_ROPZCMPALWAYSREAD, FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_ROPZREAD, FALSE },
{ X_D3DRENDERSTATETYPE::X_D3DRS_DONOTCULLUNCOMPRESSED, FALSE },
// use 0xFFFFFFFF for both elements to indicate the end of array.
{ 0xFFFFFFFF,0xFFFFFFFF }
};
}; // namespace xbox
bool XboxRenderStateConverter::Init()
{
// Get render state
if (g_SymbolAddresses.find("D3D_g_RenderState") != g_SymbolAddresses.end()) {
D3D__RenderState = (uint32_t*)g_SymbolAddresses["D3D_g_RenderState"];
}
else {
} else {
EmuLog(LOG_LEVEL::ERROR2, "D3D_g_RenderState was not found!");
return false;
}
@ -320,16 +167,16 @@ bool XboxRenderStateConverter::InitWithNV2A()
BuildRenderStateMappingTable();
// steup default xbox render state values.
// another way is to use XboxRenderStages.GetXboxRenderState() to get xbox values and set to NV2ARenderStages
int i = 0;
while (g_DefaultRenderStates[i][0]!=0xFFFFFFFF) {
unsigned int RenderState = g_DefaultRenderStates[i][0];
unsigned int value = g_DefaultRenderStates [i][1];
unsigned int i = 0;
while (xbox::g_DefaultRenderStates[i][0]!=0xFFFFFFFF) {
uint32_t renderState = xbox::g_DefaultRenderStates[i][0];
uint32_t value = xbox::g_DefaultRenderStates[i][1];
// Skip Render States that don't exist within this XDK
if (!XboxRenderStateExists(RenderState)) {
if (!XboxRenderStateExists(renderState)) {
i++;
continue;
}
SetXboxRenderState(RenderState,value);
SetXboxRenderState(renderState, value);
i++;
}
@ -519,23 +366,23 @@ void XboxRenderStateConverter::ApplySimpleRenderState(uint32_t State, uint32_t V
}
} break;
case xbox::X_D3DRS_SHADEMODE:
Value = EmuXB2PC_D3DSHADEMODE(Value);
Value = EmuXB2PC_D3DSHADEMODE((xbox::X_D3DSHADEMODE)Value);
break;
case xbox::X_D3DRS_BLENDOP:
Value = EmuXB2PC_D3DBLENDOP(Value);
Value = EmuXB2PC_D3DBLENDOP((xbox::X_D3DBLENDOP)Value);
break;
case xbox::X_D3DRS_SRCBLEND:
case xbox::X_D3DRS_DESTBLEND:
Value = EmuXB2PC_D3DBLEND(Value);
Value = EmuXB2PC_D3DBLEND((xbox::X_D3DBLEND)Value);
break;
case xbox::X_D3DRS_ZFUNC:
case xbox::X_D3DRS_ALPHAFUNC:
case xbox::X_D3DRS_STENCILFUNC:
Value = EmuXB2PC_D3DCMPFUNC(Value);
Value = EmuXB2PC_D3DCMPFUNC((xbox::X_D3DCMPFUNC)Value);
break;
case xbox::X_D3DRS_STENCILZFAIL:
case xbox::X_D3DRS_STENCILPASS:
Value = EmuXB2PC_D3DSTENCILOP(Value);
Value = EmuXB2PC_D3DSTENCILOP((xbox::X_D3DSTENCILOP)Value);
break;
case xbox::X_D3DRS_ALPHATESTENABLE:
case xbox::X_D3DRS_ALPHABLENDENABLE:
@ -668,7 +515,7 @@ void XboxRenderStateConverter::ApplyComplexRenderState(uint32_t State, uint32_t
}
break;
case xbox::X_D3DRS_FILLMODE:
Value = EmuXB2PC_D3DFILLMODE(Value);
Value = EmuXB2PC_D3DFILLMODE((xbox::X_D3DFILLMODE)Value);
if (WireFrameMode > 0) {
if (WireFrameMode == 1) {
@ -701,10 +548,10 @@ void XboxRenderStateConverter::ApplyComplexRenderState(uint32_t State, uint32_t
case xbox::X_D3DRS_MULTISAMPLEMASK:
break;
case xbox::X_D3DRS_STENCILFAIL:
Value = EmuXB2PC_D3DSTENCILOP(Value);
Value = EmuXB2PC_D3DSTENCILOP((xbox::X_D3DSTENCILOP)Value);
break;
case xbox::X_D3DRS_MULTISAMPLETYPE://D3DRS_MULTISAMPLEMODE
SetXboxMultiSampleType(Value);
SetXboxMultiSampleType((xbox::X_D3DMULTISAMPLE_TYPE)Value);
break;
default:
// Only log missing state if it has a PC counterpart

1
src/core/hle/D3D8/XbConvert.cpp
View File

@ -1203,7 +1203,6 @@ ComponentEncoding EmuXBFormatComponentEncoding(xbox::X_D3DFORMAT Format)
return FormatInfos[Format].components;
}
D3DFORMAT EmuXB2PC_D3DFormat(xbox::X_D3DFORMAT Format)
{
if (Format <= xbox::X_D3DFMT_LIN_R8G8B8A8 && Format != -1 /*xbox::X_D3DFMT_UNKNOWN*/) // The last bit prevents crashing (Metal Slug 3)

272
src/core/hle/D3D8/XbD3D8Types.h
View File

@ -95,23 +95,178 @@ typedef D3DVIEWPORT9 X_D3DVIEWPORT8;
// TODO: fill out these enumeration tables for convienance
typedef D3DSWAPEFFECT X_D3DSWAPEFFECT;
typedef D3DXVECTOR4 X_D3DXVECTOR4;
typedef DWORD X_D3DBLENDOP;
typedef DWORD X_D3DBLEND;
typedef DWORD X_D3DCMPFUNC;
typedef DWORD X_D3DFILLMODE;
typedef DWORD X_D3DMULTISAMPLE_TYPE;
typedef DWORD X_D3DSHADEMODE;
typedef DWORD X_D3DSTENCILOP;
typedef DWORD X_D3DTEXTURESTAGESTATETYPE;
typedef enum _X_D3DCULL
{
typedef enum _X_D3DBLEND {
X_D3DBLEND_ZERO = 0,
X_D3DBLEND_ONE = 1,
X_D3DBLEND_SRCCOLOR = 0x300,
X_D3DBLEND_INVSRCCOLOR = 0x301,
X_D3DBLEND_SRCALPHA = 0x302,
X_D3DBLEND_INVSRCALPHA = 0x303,
X_D3DBLEND_DESTALPHA = 0x304,
X_D3DBLEND_INVDESTALPHA = 0x305,
X_D3DBLEND_DESTCOLOR = 0x306,
X_D3DBLEND_INVDESTCOLOR = 0x307,
X_D3DBLEND_SRCALPHASAT = 0x308,
X_D3DBLEND_CONSTANTCOLOR = 0x8001,
X_D3DBLEND_INVCONSTANTCOLOR = 0x8002,
X_D3DBLEND_CONSTANTALPHA = 0x8003,
X_D3DBLEND_INVCONSTANTALPHA = 0x8004,
X_D3DBLEND_FORCE_DWORD = 0x7fffffff
} X_D3DBLEND;
typedef enum _X_D3DBLENDOP {
X_D3DBLENDOP_ADD = 0x8006,
X_D3DBLENDOP_SUBTRACT = 0x800a,
X_D3DBLENDOP_REVSUBTRACT = 0x800b,
X_D3DBLENDOP_MIN = 0x8007,
X_D3DBLENDOP_MAX = 0x8008,
X_D3DBLENDOP_ADDSIGNED = 0xf006, // Xbox extension
X_D3DBLENDOP_REVSUBTRACTSIGNED = 0xf005, // Xbox extension
X_D3DBLENDOP_FORCE_DWORD = 0x7fffffff /* force 32-bit size enum */
} X_D3DBLENDOP;
typedef enum _X_D3DCMPFUNC {
X_D3DCMP_NEVER = 0x200,
X_D3DCMP_LESS = 0x201,
X_D3DCMP_EQUAL = 0x202,
X_D3DCMP_LESSEQUAL = 0x203,
X_D3DCMP_GREATER = 0x204,
X_D3DCMP_NOTEQUAL = 0x205,
X_D3DCMP_GREATEREQUAL = 0x206,
X_D3DCMP_ALWAYS = 0x207,
X_D3DCMP_FORCE_DWORD = 0x7fffffff
} X_D3DCMPFUNC;
typedef enum _X_D3DCULL {
X_D3DCULL_NONE = 0,
X_D3DCULL_CW = 0x900,
X_D3DCULL_CCW = 0x901,
X_D3DCULL_FORCE_DWORD = 0x7fffffff
}
X_D3DCULL;
} X_D3DCULL;
typedef enum _X_D3DFILLMODE {
X_D3DFILL_POINT = 0x1b00,
X_D3DFILL_WIREFRAME = 0x1b01,
X_D3DFILL_SOLID = 0x1b02,
X_D3DFILL_FORCE_DWORD = 0x7fffffff
} X_D3DFILLMODE;
typedef enum _X_D3DFOGMODE {
X_D3DFOG_NONE = 0,
X_D3DFOG_EXP = 1,
X_D3DFOG_EXP2 = 2,
X_D3DFOG_LINEAR = 3,
X_D3DFOG_FORCE_DWORD = 0x7fffffff
} X_D3DFOGMODE;
typedef enum _X_D3DFRONT { // Xbox extension
X_D3DFRONT_CW = 0x900,
X_D3DFRONT_CCW = 0x901,
X_D3DFRONT_FORCE_DWORD = 0x7fffffff /* force 32-bit size enum */
} X_D3DFRONT;
typedef enum _X_D3DLOGICOP { // Xbox extension
X_D3DLOGICOP_NONE = 0,
X_D3DLOGICOP_CLEAR = 0x1500,
X_D3DLOGICOP_AND = 0x1501,
X_D3DLOGICOP_AND_REVERSE = 0x1502,
X_D3DLOGICOP_COPY = 0x1503,
X_D3DLOGICOP_AND_INVERTED = 0x1504,
X_D3DLOGICOP_NOOP = 0x1505,
X_D3DLOGICOP_XOR = 0x1506,
X_D3DLOGICOP_OR = 0x1507,
X_D3DLOGICOP_NOR = 0x1508,
X_D3DLOGICOP_EQUIV = 0x1509,
X_D3DLOGICOP_INVERT = 0x150a,
X_D3DLOGICOP_OR_REVERSE = 0x150b,
X_D3DLOGICOP_COPY_INVERTED = 0x150c,
X_D3DLOGICOP_OR_INVERTED = 0x150d,
X_D3DLOGICOP_NAND = 0x150e,
X_D3DLOGICOP_SET = 0x150f,
X_D3DLOGICOP_FORCE_DWORD = 0x7fffffff /* force 32-bit size enum */
} X_D3DLOGICOP;
typedef enum _X_D3DMATERIALCOLORSOURCE {
X_D3DMCS_MATERIAL = 0,
X_D3DMCS_COLOR1 = 1,
X_D3DMCS_COLOR2 = 2,
X_D3DMCS_FORCE_DWORD = 0x7fffffff
} X_D3DMATERIALCOLORSOURCE;
// Multisample types
typedef enum _X_D3DMULTISAMPLEMODE
{
X_D3DMULTISAMPLEMODE_1X = 0,
X_D3DMULTISAMPLEMODE_2X = 1,
X_D3DMULTISAMPLEMODE_4X = 2,
X_D3DMULTISAMPLEMODE_FORCE_DWORD = 0x7fffffff
} X_D3DMULTISAMPLEMODE;
typedef enum _X_D3DMULTISAMPLE_TYPE
{
X_D3DMULTISAMPLE_NONE = 0x0011,
X_D3DMULTISAMPLE_2_SAMPLES_MULTISAMPLE_LINEAR = 0x1021,
X_D3DMULTISAMPLE_2_SAMPLES_MULTISAMPLE_QUINCUNX = 0x1121,
X_D3DMULTISAMPLE_2_SAMPLES_SUPERSAMPLE_HORIZONTAL_LINEAR = 0x2021,
X_D3DMULTISAMPLE_2_SAMPLES_SUPERSAMPLE_VERTICAL_LINEAR = 0x2012,
X_D3DMULTISAMPLE_4_SAMPLES_MULTISAMPLE_LINEAR = 0x1022,
X_D3DMULTISAMPLE_4_SAMPLES_MULTISAMPLE_GAUSSIAN = 0x1222,
X_D3DMULTISAMPLE_4_SAMPLES_SUPERSAMPLE_LINEAR = 0x2022,
X_D3DMULTISAMPLE_4_SAMPLES_SUPERSAMPLE_GAUSSIAN = 0x2222,
X_D3DMULTISAMPLE_9_SAMPLES_MULTISAMPLE_GAUSSIAN = 0x1233,
X_D3DMULTISAMPLE_9_SAMPLES_SUPERSAMPLE_GAUSSIAN = 0x2233,
X_D3DMULTISAMPLE_FORCE_DWORD = 0x7fffffff /* force 32-bit size enum */
} X_D3DMULTISAMPLE_TYPE;
typedef enum _X_D3DPATCHEDGESTYLE {
X_D3DPATCHEDGE_DISCRETE = 0,
X_D3DPATCHEDGE_CONTINUOUS = 1,
X_D3DPATCHEDGE_FORCE_DWORD = 0x7fffffff
} X_D3DPATCHEDGESTYLE;
typedef enum _X_D3DSHADEMODE {
X_D3DSHADE_FLAT = 0x1d00,
X_D3DSHADE_GOURAUD = 0x1d01,
X_D3DSHADE_FORCE_DWORD = 0x7fffffff /* force 32-bit size enum */
} X_D3DSHADEMODE;
typedef enum _X_D3DSTENCILOP {
X_D3DSTENCILOP_KEEP = 0x1e00,
X_D3DSTENCILOP_ZERO = 0,
X_D3DSTENCILOP_REPLACE = 0x1e01,
X_D3DSTENCILOP_INCRSAT = 0x1e02,
X_D3DSTENCILOP_DECRSAT = 0x1e03,
X_D3DSTENCILOP_INVERT = 0x150a,
X_D3DSTENCILOP_INCR = 0x8507,
X_D3DSTENCILOP_DECR = 0x8508,
X_D3DSTENCILOP_FORCE_DWORD = 0x7fffffff
} X_D3DSTENCILOP;
typedef enum _X_D3DSWATHWIDTH {
X_D3DSWATH_8 = 0,
X_D3DSWATH_16 = 1,
X_D3DSWATH_32 = 2,
X_D3DSWATH_64 = 3,
X_D3DSWATH_128 = 4,
X_D3DSWATH_OFF = 0xf,
X_D3DSWATH_FORCE_DWORD = 0x7fffffff /* force 32-bit size enum */
} X_D3DSWATHWIDTH;
typedef enum _X_D3DFORMAT
{
@ -465,19 +620,6 @@ struct X_D3DResource
#define X_D3DLOCK_TILED 0x00000040 // Xbox extension
#define X_D3DLOCK_READONLY 0x00000080
// Multisample modes
const int X_D3DMULTISAMPLE_NONE = 0x0011;
const int X_D3DMULTISAMPLE_2_SAMPLES_MULTISAMPLE_LINEAR = 0x1021;
const int X_D3DMULTISAMPLE_2_SAMPLES_MULTISAMPLE_QUINCUNX = 0x1121;
const int X_D3DMULTISAMPLE_2_SAMPLES_SUPERSAMPLE_HORIZONTAL_LINEAR = 0x2021;
const int X_D3DMULTISAMPLE_2_SAMPLES_SUPERSAMPLE_VERTICAL_LINEAR = 0x2012;
const int X_D3DMULTISAMPLE_4_SAMPLES_MULTISAMPLE_LINEAR = 0x1022;
const int X_D3DMULTISAMPLE_4_SAMPLES_MULTISAMPLE_GAUSSIAN = 0x1222;
const int X_D3DMULTISAMPLE_4_SAMPLES_SUPERSAMPLE_LINEAR = 0x2022;
const int X_D3DMULTISAMPLE_4_SAMPLES_SUPERSAMPLE_GAUSSIAN = 0x2222;
const int X_D3DMULTISAMPLE_9_SAMPLES_MULTISAMPLE_GAUSSIAN = 0x1233;
const int X_D3DMULTISAMPLE_9_SAMPLES_SUPERSAMPLE_GAUSSIAN = 0x2233;
// Multisample masks (Cxbx additions)
const int X_D3DMULTISAMPLE_YSCALE_MASK = 0x000F;
const int X_D3DMULTISAMPLE_YSCALE_SHIFT = 0;
@ -895,41 +1037,46 @@ constexpr DWORD X_D3DWRAP_V = 0x00001000;
constexpr DWORD X_D3DWRAP_W = 0x00100000;
// X_D3DTEXTURESTAGESTATETYPE values :
// Dxbx note : See DxbxFromOldVersion_D3DTSS(), as these might need correction for older SDK versions!
// The set starts out with "deferred" texture states :
constexpr DWORD X_D3DTSS_ADDRESSU = 0;
constexpr DWORD X_D3DTSS_ADDRESSV = 1;
constexpr DWORD X_D3DTSS_ADDRESSW = 2;
constexpr DWORD X_D3DTSS_MAGFILTER = 3;
constexpr DWORD X_D3DTSS_MINFILTER = 4;
constexpr DWORD X_D3DTSS_MIPFILTER = 5;
constexpr DWORD X_D3DTSS_MIPMAPLODBIAS = 6;
constexpr DWORD X_D3DTSS_MAXMIPLEVEL = 7;
constexpr DWORD X_D3DTSS_MAXANISOTROPY = 8;
constexpr DWORD X_D3DTSS_COLORKEYOP = 9; // Xbox ext.
constexpr DWORD X_D3DTSS_COLORSIGN = 10; // Xbox ext.
constexpr DWORD X_D3DTSS_ALPHAKILL = 11; // Xbox ext.
constexpr DWORD X_D3DTSS_COLOROP = 12;
constexpr DWORD X_D3DTSS_COLORARG0 = 13;
constexpr DWORD X_D3DTSS_COLORARG1 = 14;
constexpr DWORD X_D3DTSS_COLORARG2 = 15;
constexpr DWORD X_D3DTSS_ALPHAOP = 16;
constexpr DWORD X_D3DTSS_ALPHAARG0 = 17;
constexpr DWORD X_D3DTSS_ALPHAARG1 = 18;
constexpr DWORD X_D3DTSS_ALPHAARG2 = 19;
constexpr DWORD X_D3DTSS_RESULTARG = 20;
constexpr DWORD X_D3DTSS_TEXTURETRANSFORMFLAGS = 21;
// End of "deferred" texture states, continuing with the rest :
constexpr DWORD X_D3DTSS_BUMPENVMAT00 = 22;
constexpr DWORD X_D3DTSS_BUMPENVMAT01 = 23;
constexpr DWORD X_D3DTSS_BUMPENVMAT11 = 24;
constexpr DWORD X_D3DTSS_BUMPENVMAT10 = 25;
constexpr DWORD X_D3DTSS_BUMPENVLSCALE = 26;
constexpr DWORD X_D3DTSS_BUMPENVLOFFSET = 27;
constexpr DWORD X_D3DTSS_TEXCOORDINDEX = 28;
constexpr DWORD X_D3DTSS_BORDERCOLOR = 29;
constexpr DWORD X_D3DTSS_COLORKEYCOLOR = 30; // Xbox ext.
constexpr DWORD X_D3DTSS_UNSUPPORTED = 31; // Note : Somehow, this one comes through D3DDevice_SetTextureStageStateNotInline sometimes
typedef enum _X_D3DTEXTURESTAGESTATETYPE
{
// Dxbx note : See DxbxFromOldVersion_D3DTSS(), as these might need correction for older SDK versions!
// The set starts out with "deferred" texture states :
X_D3DTSS_ADDRESSU = 0,
X_D3DTSS_ADDRESSV = 1,
X_D3DTSS_ADDRESSW = 2,
X_D3DTSS_MAGFILTER = 3,
X_D3DTSS_MINFILTER = 4,
X_D3DTSS_MIPFILTER = 5,
X_D3DTSS_MIPMAPLODBIAS = 6,
X_D3DTSS_MAXMIPLEVEL = 7,
X_D3DTSS_MAXANISOTROPY = 8,
X_D3DTSS_COLORKEYOP = 9, // Xbox ext.
X_D3DTSS_COLORSIGN = 10, // Xbox ext.
X_D3DTSS_ALPHAKILL = 11, // Xbox ext.
X_D3DTSS_COLOROP = 12,
X_D3DTSS_COLORARG0 = 13,
X_D3DTSS_COLORARG1 = 14,
X_D3DTSS_COLORARG2 = 15,
X_D3DTSS_ALPHAOP = 16,
X_D3DTSS_ALPHAARG0 = 17,
X_D3DTSS_ALPHAARG1 = 18,
X_D3DTSS_ALPHAARG2 = 19,
X_D3DTSS_RESULTARG = 20,
X_D3DTSS_TEXTURETRANSFORMFLAGS = 21,
// End of "deferred" texture states, continuing with the rest :
X_D3DTSS_BUMPENVMAT00 = 22,
X_D3DTSS_BUMPENVMAT01 = 23,
X_D3DTSS_BUMPENVMAT11 = 24,
X_D3DTSS_BUMPENVMAT10 = 25,
X_D3DTSS_BUMPENVLSCALE = 26,
X_D3DTSS_BUMPENVLOFFSET = 27,
X_D3DTSS_TEXCOORDINDEX = 28,
X_D3DTSS_BORDERCOLOR = 29,
X_D3DTSS_COLORKEYCOLOR = 30, // Xbox ext.
X_D3DTSS_UNSUPPORTED = 31, // Note : Somehow, this one comes through D3DDevice_SetTextureStageStateNotInline sometimes
X_D3DTSS_FORCE_DWORD = 0x7fffffff, /* force 32-bit size enum */
} X_D3DTEXTURESTAGESTATETYPE;
// End of texture states.
// Texture state boundaries :
@ -1020,9 +1167,6 @@ constexpr DWORD X_D3DCOLORWRITEENABLE_BLUE = (1 << 0);
constexpr DWORD X_D3DCOLORWRITEENABLE_ALPHA = (1 << 24);
constexpr DWORD X_D3DCOLORWRITEENABLE_ALL = 0x01010101; // Xbox ext.
// deferred texture stage state "unknown" flag
#define X_D3DTSS_UNK 0x7fffffff
typedef enum _D3DVERTEXBLENDFLAGS
{
X_D3DVBF_DISABLE = 0, // 1 matrix, 0 weights => final weight effectively 1 (Disable vertex blending)
@ -1032,6 +1176,8 @@ typedef enum _D3DVERTEXBLENDFLAGS
X_D3DVBF_2WEIGHTS2MATRICES = 2, // 2 matrices, 2 weights (Xbox ext.)
X_D3DVBF_3WEIGHTS3MATRICES = 4, // 3 matrices, 3 weights (Xbox ext.)
X_D3DVBF_4WEIGHTS4MATRICES = 6, // 4 matrices, 4 weights (Xbox ext.)
X_D3DVBF_MAX = 7,
X_D3DVBF_FORCE_DWORD = 0x7fffffff
} X_D3DVERTEXBLENDFLAGS;

1
src/core/hle/D3D8/XbPixelShader.cpp
View File

@ -1220,7 +1220,6 @@ void DxbxUpdateActivePixelShader() // NOPATCH
// manually read from D3D__RenderState[X_D3DRS_PSTEXTUREMODES] for that one field.
// See D3DDevice_SetPixelShaderCommon which implements this
extern XboxRenderStateConverter NV2ARenderStates;
extern xbox::X_PixelShader* pNV2A_PixelShader;
const xbox::X_D3DPIXELSHADERDEF* pPSDef;
if (is_pgraph_using_NV2A_Kelvin())
pPSDef = pNV2A_PixelShader != nullptr ? pNV2A_PixelShader->pPSDef : nullptr;//(xbox::X_D3DPIXELSHADERDEF*)(NV2ARenderStates.GetPixelShaderRenderStatePointer()) : nullptr;

12
src/core/hle/D3D8/XbPushBuffer.cpp
View File

@ -449,7 +449,7 @@ bool g_xbox_transform_use_DirectModelView = false;
bool g_NV2A_transform_ModelView_dirty[4] = { false,false,false,false };
bool g_NV2A_transform_InverseModelView_dirty[4] = { false,false,false,false };
bool g_NV2A_transform_Composite_dirty = false;
// virtual pixle shader, convert content from KelvinPrimitive to the pixel shader below and call CxbxrImpl_SetPixelShader(pNV2A_PixelShader).
// virtual pixel shader, convert content from KelvinPrimitive to the pixel shader below and call CxbxrImpl_SetPixelShader(pNV2A_PixelShader).
xbox::X_PixelShader* pNV2A_PixelShader;
xbox::X_PixelShader NV2A_PixelShader;
xbox::X_D3DPIXELSHADERDEF NV2A_PSDef;
@ -1199,7 +1199,7 @@ void pgraph_ComposeViewport(NV2AState *d)
Viewport.MaxZ = clipFar / ScaleZ;
}
//FIXME!! Viewport.Width/Height are not set in Fixed Mode. xbox d3d set it to 0x7FFFFFFF,
// CxbxrImpl_SetViewport() will cap the Width/Height to render target width/height. anyway, we cap them to render target value here.
// CxbxImpl_SetViewport() will cap the Width/Height to render target width/height. anyway, we cap them to render target value here.
Viewport.Width= (DWORD)rendertargetBaseWidth;
Viewport.Height = (DWORD)rendertargetBaseHeight;
@ -3277,7 +3277,7 @@ void D3D_draw_state_update(NV2AState* d)
NV2A_DirtyFlags &= ~X_D3DDIRTYFLAG_LIGHTS;
}
// update viewport state when we're in pushbuffer replay mode.
// CxbxUpdateNativeD3DResources() calls CxbxUpdateHostViewport() to update host viewpot, we call pgraph_SetViewport(d) to convert NV2A viewport content to xbox vieport and then call CxbxrImpl_SetViewport() there.
// CxbxUpdateNativeD3DResources() calls CxbxUpdateHostViewport() to update host viewpot, we call pgraph_SetViewport(d) to convert NV2A viewport content to xbox vieport and then call CxbxImpl_SetViewport() there.
// only update viewport if viewport got dirty.
if (NV2A_viewport_dirty == true) {
// this only compose viewport from pgraph content
@ -3287,7 +3287,7 @@ void D3D_draw_state_update(NV2AState* d)
xbox::X_D3DVIEWPORT8 Viewport;
CxbxrGetViewport(Viewport);
// no need to call SetViewport here.in CxbxUpdateNativeD3DResources(), CxbxUpdateHostViewport() will pickup our viewport.
// CxbxrImpl_SetViewport(&Viewport);
// CxbxImpl_SetViewport(&Viewport);
NV2A_viewport_dirty = false;
}
@ -3431,7 +3431,7 @@ void D3D_draw_state_update(NV2AState* d)
for (auto it = g_RenderTargetCache.begin(); it != g_RenderTargetCache.end(); it++) {
//calculate xbox surface data size.
// todo: calculate and cache the xbox data size in CxbxrImpl_SetRenderTarget to save overheads here.
// todo: calculate and cache the xbox data size in CxbxImpl_SetRenderTarget to save overheads here.
//process host surface data transfer to xbox data with data conversion.
xbox::X_D3DSurface* pXboxSurface = &it->second;
//UINT XBWidth, XBHeight, XBDepth, XBRowPitch, XBSlicePitch;
@ -3496,7 +3496,7 @@ void D3D_draw_state_update(NV2AState* d)
}
}
}
// todo: call CxbxrImpl_SetVertexShader() here. There are certain varialbes needs to be initialized, mostly setup unexisting vertex attribute defaults.
// todo: call CxbxImpl_SetVertexShader() here. There are certain varialbes needs to be initialized, mostly setup unexisting vertex attribute defaults.
extern bool g_NV2AVertexShader_dirty; // tmp glue
extern void pgraph_SetVertexShader(NV2AState* d);// tmp glue, XBVertexShader.cpp
if (g_NV2AVertexShader_dirty)

36
src/core/hle/D3D8/XbVertexBuffer.cpp
View File

@ -37,10 +37,10 @@
#include "core\hle\D3D8\XbPushBuffer.h" // For CxbxDrawPrimitiveUP
#include "core\hle\D3D8\XbVertexBuffer.h"
#include "core\hle\D3D8\XbConvert.h"
#include "devices/video/nv2a.h" // For g_NV2A, PGRAPHState
#include "devices/Xbox.h" // For g_NV2A
#include "devices/video/nv2a.h" // For PGRAPHState
#include "devices/video/nv2a_int.h" // For NV** defines
#include <imgui.h>
#include <ctime>
@ -63,13 +63,21 @@ UINT g_InlineVertexBuffer_TableOffset = 0;
// Copy of active Xbox D3D Vertex Streams (and strides), set by [D3DDevice|CxbxImpl]_SetStreamSource*
xbox::X_STREAMINPUT g_Xbox_SetStreamSource[X_VSH_MAX_STREAMS] = { 0 }; // Note : .Offset member is never set (so always 0)
extern float *HLE_get_NV2A_vertex_attribute_value_pointer(unsigned VertexSlot); // Declared in PushBuffer.cpp
extern float* pgraph_get_vertex_attribute_inline_value(PGRAPHState* pg, int attribute_index); // Implemented in EmuNV2A_PGRAPH.cpp
void *GetDataFromXboxResource(xbox::X_D3DResource *pXboxResource);
bool GetHostRenderTargetDimensions(DWORD* pHostWidth, DWORD* pHostHeight, IDirect3DSurface* pHostRenderTarget = nullptr);
uint32_t GetPixelContainerWidth(xbox::X_D3DPixelContainer* pPixelContainer);
uint32_t GetPixelContainerHeight(xbox::X_D3DPixelContainer* pPixelContainer);
float* HLE_get_NV2A_vertex_attribute_value_pointer(unsigned slot)
{
NV2AState* dev = g_NV2A->GetDeviceState();
PGRAPHState* pg = &(dev->pgraph);
return pgraph_get_vertex_attribute_inline_value(pg, slot);
}
void CxbxPatchedStream::Activate(CxbxDrawContext *pDrawContext, UINT HostStreamNumber) const
{
//LOG_INIT // Allows use of DEBUG_D3DRESULT
@ -703,13 +711,13 @@ void CxbxSetVertexAttribute(int Register, FLOAT a, FLOAT b, FLOAT c, FLOAT d)
g_pD3DDevice->SetVertexShaderConstantF(CXBX_D3DVS_CONSTREG_VREGDEFAULTS_BASE + Register, attribute_floats, 1);
}
void CxbxrImpl_Begin(xbox::X_D3DPRIMITIVETYPE PrimitiveType)
void CxbxImpl_Begin(xbox::X_D3DPRIMITIVETYPE PrimitiveType)
{
g_InlineVertexBuffer_PrimitiveType = PrimitiveType;
g_InlineVertexBuffer_TableOffset = 0;
}
void CxbxrImpl_End()
void CxbxImpl_End()
{
using namespace xbox;
@ -752,7 +760,7 @@ void CxbxrImpl_End()
// ExFreePool(g_InlineVertexBuffer_Table);
}
void CxbxrImpl_SetVertexData4f(int Register, FLOAT a, FLOAT b, FLOAT c, FLOAT d)
void CxbxImpl_SetVertexData4f(int Register, FLOAT a, FLOAT b, FLOAT c, FLOAT d)
{
using namespace xbox;
@ -816,10 +824,10 @@ void CxbxrImpl_SetVertexData4f(int Register, FLOAT a, FLOAT b, FLOAT c, FLOAT d)
}
}
void CxbxrImpl_SetStreamSource(UINT StreamNumber, xbox::X_D3DVertexBuffer* pStreamData, UINT Stride)
void CxbxImpl_SetStreamSource(UINT StreamNumber, xbox::X_D3DVertexBuffer* pStreamData, UINT Stride)
{
if (pStreamData != xbox::zeroptr && Stride == 0) {
LOG_TEST_CASE("CxbxrImpl_SetStreamSource : Stream assigned, and stride set to 0 (might be okay)");
LOG_TEST_CASE("CxbxImpl_SetStreamSource : Stream assigned, and stride set to 0 (might be okay)");
}
assert(StreamNumber < X_VSH_MAX_STREAMS);
@ -827,15 +835,3 @@ void CxbxrImpl_SetStreamSource(UINT StreamNumber, xbox::X_D3DVertexBuffer* pStre
g_Xbox_SetStreamSource[StreamNumber].VertexBuffer = pStreamData;
g_Xbox_SetStreamSource[StreamNumber].Stride = Stride;
}
extern NV2ADevice* g_NV2A;// TMP glue
extern float *pgraph_get_vertex_attribute_inline_value(PGRAPHState *pg, int attribute_index); // Implemented in EmuNV2A_PGRAPH.cpp
float *HLE_get_NV2A_vertex_attribute_value_pointer(unsigned slot)
{
NV2AState* dev = g_NV2A->GetDeviceState();
PGRAPHState *pg = &(dev->pgraph);
return pgraph_get_vertex_attribute_inline_value(pg, slot);
}

8
src/core/hle/D3D8/XbVertexBuffer.h
View File

@ -136,10 +136,10 @@ extern void EmuUpdateActiveTexture();
extern void CxbxSetVertexAttribute(int Register, FLOAT a, FLOAT b, FLOAT c, FLOAT d);
extern void CxbxrImpl_Begin(xbox::X_D3DPRIMITIVETYPE PrimitiveType);
extern void CxbxrImpl_End();
extern void CxbxrImpl_SetStreamSource(UINT StreamNumber, xbox::X_D3DVertexBuffer* pStreamData, UINT Stride);
extern void CxbxrImpl_SetVertexData4f(int Register, FLOAT a, FLOAT b, FLOAT c, FLOAT d);
extern void CxbxImpl_Begin(xbox::X_D3DPRIMITIVETYPE PrimitiveType);
extern void CxbxImpl_End();
extern void CxbxImpl_SetStreamSource(UINT StreamNumber, xbox::X_D3DVertexBuffer* pStreamData, UINT Stride);
extern void CxbxImpl_SetVertexData4f(int Register, FLOAT a, FLOAT b, FLOAT c, FLOAT d);
extern DWORD g_dwPrimPerFrame;

41
src/core/hle/D3D8/XbVertexShader.cpp
View File

@ -35,7 +35,7 @@
#include "core\hle\D3D8\Direct3D9\Direct3D9.h" // For g_Xbox_VertexShader_Handle
#include "core\hle\D3D8\Direct3D9\RenderStates.h" // For XboxRenderStateConverter
#include "core\hle\D3D8\Direct3D9\VertexShaderSource.h" // For g_VertexShaderSource
#include "core\hle\D3D8\XbVertexBuffer.h" // For CxbxrImpl_SetVertexData4f
#include "core\hle\D3D8\XbVertexBuffer.h" // For CxbxImpl_SetVertexData4f
#include "core\hle\D3D8\XbVertexShader.h"
#include "core\hle\D3D8\XbD3D8Logging.h" // For DEBUG_D3DRESULT
#include "devices\xbox.h"
@ -52,6 +52,7 @@
// External symbols :
extern xbox::X_STREAMINPUT g_Xbox_SetStreamSource[X_VSH_MAX_STREAMS]; // Declared in XbVertexBuffer.cpp
extern VertexShaderMode g_NV2A_VertexShaderMode;
extern XboxRenderStateConverter XboxRenderStates; // Declared in Direct3D9.cpp
// Variables set by [D3DDevice|CxbxImpl]_SetVertexShaderInput() :
@ -364,7 +365,7 @@ xbox::X_VERTEXATTRIBUTEFORMAT* GetXboxVertexAttributeFormat()
return &g_NV2AVertexAttributeFormat;
}
// Special case for CxbxrImpl_End() based drawing
// Special case for CxbxImpl_End() based drawing
if (g_InlineVertexBuffer_DeclarationOverride != nullptr) {
return g_InlineVertexBuffer_DeclarationOverride; // either &g_InlineVertexBuffer_AttributeFormat
}
@ -1455,8 +1456,8 @@ static void CxbxSetVertexShaderPassthroughProgram()
// Test-case : XDK Ripple sample
// TODO : Apparently, offset and scale are swapped in some XDK versions, but which?
CxbxrImpl_SetVertexShaderConstant(0 - X_D3DSCM_CORRECTION, scale, 1);
CxbxrImpl_SetVertexShaderConstant(1 - X_D3DSCM_CORRECTION, offset, 1);
CxbxImpl_SetVertexShaderConstant(0 - X_D3DSCM_CORRECTION, scale, 1);
CxbxImpl_SetVertexShaderConstant(1 - X_D3DSCM_CORRECTION, offset, 1);
}
CxbxVertexDeclaration* CxbxGetVertexDeclaration()
@ -1515,7 +1516,7 @@ void CxbxUpdateHostVertexDeclaration()
g_pD3DDevice->SetVertexShaderConstantF(CXBX_D3DVS_CONSTREG_VREGDEFAULTS_FLAG_BASE, vertexDefaultFlags, CXBX_D3DVS_CONSTREG_VREGDEFAULTS_FLAG_SIZE);
}
void CxbxrImpl_SetScreenSpaceOffset(float x, float y)
void CxbxImpl_SetScreenSpaceOffset(float x, float y)
{
// See https://microsoft.github.io/DirectX-Specs/d3d/archive/D3D11_3_FunctionalSpec.htm#3.3.1%20Pixel%20Coordinate%20System
static float PixelOffset = 0.53125f; // 0.5 for pixel center + 1/16?
@ -1526,7 +1527,7 @@ void CxbxrImpl_SetScreenSpaceOffset(float x, float y)
// Note : SetVertexShaderInputDirect needs no EMUPATCH CxbxrImpl_..., since it just calls SetVertexShaderInput
void CxbxrImpl_SetVertexShaderInput(DWORD Handle, UINT StreamCount, xbox::X_STREAMINPUT* pStreamInputs)
void CxbxImpl_SetVertexShaderInput(DWORD Handle, UINT StreamCount, xbox::X_STREAMINPUT* pStreamInputs)
{
using namespace xbox;
@ -1562,7 +1563,7 @@ void CxbxrImpl_SetVertexShaderInput(DWORD Handle, UINT StreamCount, xbox::X_STRE
// Note : SelectVertexShaderDirect needs no EMUPATCH CxbxrImpl_..., since it just calls SelectVertexShader
void CxbxrImpl_SelectVertexShader(DWORD Handle, DWORD Address)
void CxbxImpl_SelectVertexShader(DWORD Handle, DWORD Address)
{
LOG_INIT; // Allows use of DEBUG_D3DRESULT
@ -1590,7 +1591,7 @@ void CxbxrImpl_SelectVertexShader(DWORD Handle, DWORD Address)
g_VertexShader_dirty = true;
}
void CxbxrImpl_LoadVertexShaderProgram(CONST DWORD* pFunction, DWORD Address)
void CxbxImpl_LoadVertexShaderProgram(CONST DWORD* pFunction, DWORD Address)
{
// pFunction is a X_VSH_SHADER_HEADER pointer
// D3DDevice_LoadVertexShaderProgram splits the given function buffer into batch-wise pushes to the NV2A
@ -1611,7 +1612,7 @@ void CxbxrImpl_LoadVertexShaderProgram(CONST DWORD* pFunction, DWORD Address)
//static unsigned int ProgramAndConstantsDwords_Offset = 0;//
//static unsigned int pProgramAndConstants_Offset = 0;//
void CxbxrImpl_LoadVertexShader(DWORD Handle, DWORD ProgramRegister)
void CxbxImpl_LoadVertexShader(DWORD Handle, DWORD ProgramRegister)
{
/* //dynamic code to get ProgramAndConstantsDwords_Offset and pProgramAndConstants_Offset from vertex shader structure. not used because CxbxGetVertexShaderTokens() has the same function.
if (ProgramAndConstantsDwords_Offset == 0 || pProgramAndConstants_Offset == 0) {
@ -1666,8 +1667,8 @@ void CxbxrImpl_LoadVertexShader(DWORD Handle, DWORD ProgramRegister)
if ((nrDWORDS & 3) != 0) LOG_TEST_CASE("NV2A_VP_UPLOAD_CONST arguments should be a multiple of 4!");
unsigned nrConstants = nrDWORDS / X_VSH_INSTRUCTION_SIZE;
// TODO : FIXME : Implement and call SetVertexShaderConstants(pNV2ATokens, ConstantAddress, nrConstants);
//CxbxrImpl_SetVertexShaderConstant() uses Register -96~96. vertex shader pushbuffer snapshot uses 0~192.
CxbxrImpl_SetVertexShaderConstant(ConstantRegister- X_D3DSCM_CORRECTION, argv, nrConstants);
//CxbxImpl_SetVertexShaderConstant() uses Register -96~96. vertex shader pushbuffer snapshot uses 0~192.
CxbxImpl_SetVertexShaderConstant(ConstantRegister- X_D3DSCM_CORRECTION, argv, nrConstants);
ConstantRegister += nrConstants;
break;
@ -1711,7 +1712,7 @@ void SetFixedFunctionDefaultVertexAttributes(DWORD vshFlags) {
value = black;
}
// Note : We avoid calling CxbxrImpl_SetVertexData4f here, as that would
// Note : We avoid calling CxbxImpl_SetVertexData4f here, as that would
// start populating g_InlineVertexBuffer_Table, which is not our intent here.
CxbxSetVertexAttribute(i, value[0], value[1], value[2], value[3]);
}
@ -1751,13 +1752,13 @@ void NV2ASetFixedFunctionDefaultVertexAttributes(DWORD& vshFlags) {
value = black;
}
// Note : We avoid calling CxbxrImpl_SetVertexData4f here, as that would
// Note : We avoid calling CxbxImpl_SetVertexData4f here, as that would
// start populating g_InlineVertexBuffer_Table, which is not our intent here.
CxbxSetVertexAttribute(i, value[0], value[1], value[2], value[3]);
}
}
void CxbxrImpl_SetVertexShader(DWORD Handle)
void CxbxImpl_SetVertexShader(DWORD Handle)
{
LOG_INIT; // Allows use of DEBUG_D3DRESULT
@ -1780,8 +1781,8 @@ void CxbxrImpl_SetVertexShader(DWORD Handle)
if (pXboxVertexShader->Flags & g_X_VERTEXSHADER_FLAG_PROGRAM) { // Global variable set from CxbxVertexShaderSetFlags
#if 0 // Since the D3DDevice_SetVertexShader patch already called it's trampoline, these calls have already been executed :
CxbxrImpl_LoadVertexShader(Handle, 0);
CxbxrImpl_SelectVertexShader(Handle, 0);
CxbxImpl_LoadVertexShader(Handle, 0);
CxbxImpl_SelectVertexShader(Handle, 0);
#else // So let's check if that indeed happened :
bool bHackCallSelectAgain = false;
if (g_Xbox_VertexShader_Handle != Handle) {
@ -1801,7 +1802,7 @@ void CxbxrImpl_SetVertexShader(DWORD Handle)
// If any of the above test-cases was hit, perhaps our patch on
// _SelectVertexShader isn't applied;
// 'solve' that by calling it here instead.
CxbxrImpl_SelectVertexShader(Handle, 0);
CxbxImpl_SelectVertexShader(Handle, 0);
}
#endif
} else {
@ -1830,7 +1831,7 @@ void CxbxrImpl_SetVertexShader(DWORD Handle)
g_VertexShader_dirty = true;
}
//NV2A version of CxbxrImpl_SetVertexShader(), called via end of D3D_draw_state_update()
//NV2A version of CxbxImpl_SetVertexShader(), called via end of D3D_draw_state_update()
void pgraph_SetVertexShader(NV2AState* d)
{
PGRAPHState* pg = &d->pgraph;
@ -1873,7 +1874,7 @@ void pgraph_SetVertexShader(NV2AState* d)
}
void CxbxrImpl_DeleteVertexShader(DWORD Handle)
void CxbxImpl_DeleteVertexShader(DWORD Handle)
{
LOG_INIT; // Allows use of DEBUG_D3DRESULT
@ -1917,7 +1918,7 @@ void CxbxrImpl_GetVertexShaderConstant(INT Register, PVOID pConstantData, DWORD
}
// TODO : Remove SetVertexShaderConstant implementation and the patch once
// CxbxUpdateHostVertexShaderConstants is reliable (ie. : when we're able to flush the NV2A push buffer)
void CxbxrImpl_SetVertexShaderConstant(INT Register, PVOID pConstantData, DWORD ConstantCount)
void CxbxImpl_SetVertexShaderConstant(INT Register, PVOID pConstantData, DWORD ConstantCount)
{
LOG_INIT; // Allows use of DEBUG_D3DRESULT

17
src/core/hle/D3D8/XbVertexShader.h
View File

@ -89,7 +89,6 @@ enum class VertexShaderMode {
};
extern VertexShaderMode g_Xbox_VertexShaderMode;
extern VertexShaderMode g_NV2A_VertexShaderMode;
extern bool g_UseFixedFunctionVertexShader;
// Intermediate vertex shader structures
@ -245,13 +244,13 @@ extern bool g_Xbox_VertexShader_IsFixedFunction;
extern CxbxVertexDeclaration* CxbxGetVertexDeclaration();
extern xbox::X_STREAMINPUT& GetXboxVertexStreamInput(unsigned XboxStreamNumber);
extern void CxbxrImpl_SetScreenSpaceOffset(float x, float y);
extern void CxbxrImpl_LoadVertexShaderProgram(CONST DWORD* pFunction, DWORD Address);
extern void CxbxrImpl_LoadVertexShader(DWORD Handle, DWORD Address);
extern void CxbxrImpl_SetVertexShader(DWORD Handle);
extern void CxbxrImpl_SelectVertexShader(DWORD Handle, DWORD Address);
extern void CxbxrImpl_SetVertexShaderInput(DWORD Handle, UINT StreamCount, xbox::X_STREAMINPUT* pStreamInputs);
extern void CxbxrImpl_SetVertexShaderConstant(INT Register, PVOID pConstantData, DWORD ConstantCount);
extern void CxbxrImpl_DeleteVertexShader(DWORD Handle);
extern void CxbxImpl_SetScreenSpaceOffset(float x, float y);
extern void CxbxImpl_LoadVertexShaderProgram(CONST DWORD* pFunction, DWORD Address);
extern void CxbxImpl_LoadVertexShader(DWORD Handle, DWORD Address);
extern void CxbxImpl_SetVertexShader(DWORD Handle);
extern void CxbxImpl_SelectVertexShader(DWORD Handle, DWORD Address);
extern void CxbxImpl_SetVertexShaderInput(DWORD Handle, UINT StreamCount, xbox::X_STREAMINPUT* pStreamInputs);
extern void CxbxImpl_SetVertexShaderConstant(INT Register, PVOID pConstantData, DWORD ConstantCount);
extern void CxbxImpl_DeleteVertexShader(DWORD Handle);
extern void CxbxVertexShaderSetFlags();
#endif

2
src/core/hle/Intercept.cpp
View File

@ -233,7 +233,7 @@ void CDECL EmuRegisterSymbol(const char* library_str,
case XREF_ADDR_NOT_FOUND:
{
EmuLog(LOG_LEVEL::WARNING, "Found OOVPA after first finding nothing?");
[[fallthrough]]; // to XREF_ADDR_UNDETERMINED
// fallthrough to XREF_ADDR_UNDETERMINED
}
case XREF_ADDR_UNDETERMINED:
{

6
src/core/hle/XAPI/Xapi.cpp
View File

@ -431,7 +431,7 @@ void SetupXboxDeviceTypes()
}
template<bool IsXInputPoll>
xbox::dword_xt CxbxrImpl_XInputHandler(xbox::HANDLE hDevice, xbox::PXINPUT_STATE pState)
xbox::dword_xt CxbxImpl_XInputHandler(xbox::HANDLE hDevice, xbox::PXINPUT_STATE pState)
{
xbox::dword_xt status = ERROR_DEVICE_NOT_CONNECTED;
DeviceState *dev = static_cast<DeviceState *>(hDevice);
@ -673,7 +673,7 @@ xbox::dword_xt WINAPI xbox::EMUPATCH(XInputPoll)
LOG_FUNC_ONE_ARG(hDevice);
// Test cases: Oddworld: Stranger's Wrath, Jet Set Radio Future, Splinter Cell 2, Panzer Dragoon Orta and 1
dword_xt ret = CxbxrImpl_XInputHandler<true>(hDevice, nullptr);
dword_xt ret = CxbxImpl_XInputHandler<true>(hDevice, nullptr);
RETURN(ret);
}
@ -721,7 +721,7 @@ xbox::dword_xt WINAPI xbox::EMUPATCH(XInputGetState)
LOG_FUNC_ARG_OUT(pState)
LOG_FUNC_END;
dword_xt ret = CxbxrImpl_XInputHandler<false>(hDevice, pState);
dword_xt ret = CxbxImpl_XInputHandler<false>(hDevice, pState);
RETURN(ret);
}

11
src/core/kernel/exports/EmuKrnlAv.cpp
View File

@ -154,22 +154,25 @@ ULONG AvQueryAvCapabilities()
}
xbox::PVOID xbox::AvSavedDataAddress = xbox::zeroptr;
extern xbox::X_D3DSurface* CxbxrImpl_GetPersistedSurface();
extern xbox::X_D3DSurface xboxPersistSurface;
extern VMManager g_VMManager;
extern xbox::X_D3DSurface* CxbxrImpl_GetAvSavedDataSurface();
// ******************************************************************
// * 0x0001 - AvGetSavedDataAddress()
// ******************************************************************
XBSYSAPI EXPORTNUM(1) xbox::PVOID NTAPI xbox::AvGetSavedDataAddress(void)
{
LOG_FUNC();
//RETURN(AvSavedDataAddress);
#if 0
RETURN(AvSavedDataAddress);
#else
//if xbox persist surface was not created yet, create it first.
if (AvSavedDataAddress != nullptr)
return CxbxrImpl_GetAvSavedDataSurface();
else
return nullptr;
#endif
}
// ******************************************************************

32
src/devices/video/EmuNV2A_PGRAPH.cpp
View File

@ -1570,7 +1570,7 @@ void HLE_API_handle_method
ReceiveKickOffWaitForAPI(); // was missing
break;
case X_D3DDevice_Begin:
CxbxrImpl_Begin((xbox::X_D3DPRIMITIVETYPE)argv[1]);
CxbxImpl_Begin((xbox::X_D3DPRIMITIVETYPE)argv[1]);
break;
case X_D3DDevice_BeginPush: break;
case X_D3DDevice_BeginPushBuffer: break;
@ -1644,9 +1644,9 @@ void HLE_API_handle_method
case X_D3DDevice_End:
#if 1 // X_D3DDevice_End calls EmuKickOffWait
ReceiveKickOffWaitForAPI(); // was missing
CxbxrImpl_End(); // This has no use (waited-for API's aren't pushed thus not handled)
CxbxImpl_End(); // This has no use (waited-for API's aren't pushed thus not handled)
#else // experimental
CxbxrImpl_End();
CxbxImpl_End();
#endif
break;
case X_D3DDevice_EndPush: break;
@ -1726,10 +1726,10 @@ void HLE_API_handle_method
CxbxrImpl_LightEnable((xbox::dword_xt) /* Index */ argv[1], (xbox::bool_xt) /* bEnable */ argv[2]);
break;
case X_D3DDevice_LoadVertexShader:
CxbxrImpl_LoadVertexShader(argv[1], argv[2]);
CxbxImpl_LoadVertexShader(argv[1], argv[2]);
break;
case X_D3DDevice_LoadVertexShaderProgram:
CxbxrImpl_LoadVertexShaderProgram((DWORD*)argv[1], argv[2]);
CxbxImpl_LoadVertexShaderProgram((DWORD*)argv[1], argv[2]);
break;
case X_D3DDevice_MultiplyTransform: break;
case X_D3DDevice_Nop: break;
@ -1767,7 +1767,7 @@ void HLE_API_handle_method
CxbxrImpl_RunVertexStateShader(argv[1], (xbox::float_xt*)argv[2]);
break;
case X_D3DDevice_SelectVertexShader:
CxbxrImpl_SelectVertexShader(argv[1], argv[2]);
CxbxImpl_SelectVertexShader(argv[1], argv[2]);
break;
case X_D3DDevice_SelectVertexShaderDirect: break;
case X_D3DDevice_SetBackBufferScale:
@ -1810,13 +1810,13 @@ void HLE_API_handle_method
case X_D3DDevice_SetRenderState_Simple: break;
case X_D3DDevice_SetRenderStateNotInline: break;
case X_D3DDevice_SetRenderTarget:
CxbxrImpl_SetRenderTarget((xbox::X_D3DSurface*)argv[1], (xbox::X_D3DSurface*)argv[2]);
CxbxImpl_SetRenderTarget((xbox::X_D3DSurface*)argv[1], (xbox::X_D3DSurface*)argv[2]);
// release reference to the surfaces since we add extra references to them in the patched SetRenderTarget()
CxbxrImpl_ReleaseRenderTarget((xbox::X_D3DSurface*)argv[1], (xbox::X_D3DSurface*)argv[2]);
break;
case X_D3DDevice_SetScissors: break;
case X_D3DDevice_SetScreenSpaceOffset:
CxbxrImpl_SetScreenSpaceOffset(DWtoF(argv[1]), DWtoF(argv[2]));
CxbxImpl_SetScreenSpaceOffset(DWtoF(argv[1]), DWtoF(argv[2]));
break;
case X_D3DDevice_SetShaderConstantMode:
CxbxrImpl_SetShaderConstantMode((xbox::X_VERTEXSHADERCONSTANTMODE)argv[1]);
@ -1824,7 +1824,7 @@ void HLE_API_handle_method
case X_D3DDevice_SetSoftDisplayFilter: break;
case X_D3DDevice_SetStipple: break;
case X_D3DDevice_SetStreamSource:
CxbxrImpl_SetStreamSource((UINT)argv[1], (xbox::X_D3DVertexBuffer*)argv[2], (UINT)argv[3]);
CxbxImpl_SetStreamSource((UINT)argv[1], (xbox::X_D3DVertexBuffer*)argv[2], (UINT)argv[3]);
break;
case X_D3DDevice_SetSwapCallback: break;
case X_D3DDevice_SetTexture:
@ -1843,14 +1843,14 @@ void HLE_API_handle_method
case X_D3DDevice_SetVertexData2f: break;
case X_D3DDevice_SetVertexData2s: break;
case X_D3DDevice_SetVertexData4f:
CxbxrImpl_SetVertexData4f(argv[1], DWtoF(argv[2]), DWtoF(argv[3]), DWtoF(argv[4]), DWtoF(argv[5]));
CxbxImpl_SetVertexData4f(argv[1], DWtoF(argv[2]), DWtoF(argv[3]), DWtoF(argv[4]), DWtoF(argv[5]));
break;
case X_D3DDevice_SetVertexData4f_16: break;
case X_D3DDevice_SetVertexData4s: break;
case X_D3DDevice_SetVertexData4ub: break;
case X_D3DDevice_SetVertexDataColor: break;
case X_D3DDevice_SetVertexShader:
CxbxrImpl_SetVertexShader((DWORD)argv[1]);
CxbxImpl_SetVertexShader((DWORD)argv[1]);
break;
case X_D3DDevice_SetVertexShaderConstant: break;
case X_D3DDevice_SetVertexShaderInput: break;
@ -1861,7 +1861,7 @@ void HLE_API_handle_method
if (argv[1] != 0)
HLEViewport = *(xbox::X_D3DVIEWPORT8*)argv[1];
CxbxrImpl_SetViewport((xbox::X_D3DVIEWPORT8*)argv[1]);
CxbxImpl_SetViewport((xbox::X_D3DVIEWPORT8*)argv[1]);
break;
case X_D3DDevice_SetWaitCallback: break;
case X_D3DDevice_Swap:
@ -3473,7 +3473,7 @@ int pgraph_handle_method(
// safe guard to make sure vertex shader program token parser won't went over the end of final slot.
pg->vsh_program_slots[X_VSH_MAX_INSTRUCTION_COUNT][3] = 1; // TODO : Move this to immediately prior to parsing
*/
// use CxbxSetVertexShaderSlots() directly, these codes come from CxbxrImpl_LoadVertexShaderProgram(). update pg->KelvinPrimitive.SetTransformProgramLoad accrodingly.
// use CxbxSetVertexShaderSlots() directly, these codes come from CxbxImpl_LoadVertexShaderProgram(). update pg->KelvinPrimitive.SetTransformProgramLoad accrodingly.
extern void CxbxSetVertexShaderSlots(DWORD * pTokens, DWORD Address, DWORD NrInstructions);
CxbxSetVertexShaderSlots((DWORD*) & argv[0], pg->KelvinPrimitive.SetTransformProgramLoad, (method_count / 4));
// set vertex shader dirty flag
@ -3510,8 +3510,8 @@ int pgraph_handle_method(
}
}
*/
// use CxbxrImpl_SetVertexShaderConstant() directly and update KelvinPrimitive.SetTransformConstantLoad accrodingly.
CxbxrImpl_SetVertexShaderConstant(pg->KelvinPrimitive.SetTransformConstantLoad- X_D3DSCM_CORRECTION,&argv[0],method_count/4);
// use CxbxImpl_SetVertexShaderConstant() directly and update KelvinPrimitive.SetTransformConstantLoad accrodingly.
CxbxImpl_SetVertexShaderConstant(pg->KelvinPrimitive.SetTransformConstantLoad- X_D3DSCM_CORRECTION,&argv[0],method_count/4);
//pick up SuperSampleScaleX/SuperSampleScaleY/ZScale/wScale after calling CommonSetPassthroughProgram().
@ -4888,7 +4888,7 @@ int pgraph_handle_method(
*/
}else if (slot== NV097_SET_TRANSFORM_EXECUTION_MODE_MODE_FIXED){//fix function mode
//Call CxbxrImpl_SetVertexShaderInput(pg->vsh_FVF_handle) here? or set the global xbox vertex attribute []
//Call CxbxImpl_SetVertexShaderInput(pg->vsh_FVF_handle) here? or set the global xbox vertex attribute []
//or g_Xbox_SetVertexShaderInput_Attributes = *CxbxGetVertexShaderAttributes(pXboxVertexShader); ??
//to set vertex format info, but wihthout stream info.