Added support for transforming homogenous W geometry into world geomtry

Settings/Settings.h

@@ -43,8 +43,16 @@
 	visit(DdrawOverrideStencilFormat) \
 	visit(DdrawResolutionHack) \
 	visit(DdrawUseDirect3D9Ex) \
+	visit(DdrawConvertHomogeneousW) \
+	visit(DdrawConvertHomogeneousToWorld) \
+	visit(DdrawConvertHomogeneousToWorldUseGameCamera) \
+	visit(DdrawConvertHomogeneousToWorldFOV) \
+	visit(DdrawConvertHomogeneousToWorldNearPlane) \
+	visit(DdrawConvertHomogeneousToWorldFarPlane) \
+	visit(DdrawConvertHomogeneousToWorldDepthOffset) \
 	visit(DdrawUseNativeResolution) \
 	visit(DdrawEnableMouseHook) \
+	visit(DdrawDisableLighting) \
 	visit(DdrawHookSystem32) \
 	visit(D3d8HookSystem32) \
 	visit(D3d9HookSystem32) \
@@ -209,6 +217,13 @@ struct CONFIG
 	bool DdrawIntegerScalingClamp = false;		// Scales the screen by an integer value to help preserve video quality
 	bool DdrawMaintainAspectRatio = false;		// Keeps the current DirectDraw aspect ratio when overriding the game's resolution
 	bool DdrawUseDirect3D9Ex = false;			// Use Direct3D9Ex extensions for Dd7to9
+	bool DdrawConvertHomogeneousW = false;		// Convert primites using D3DFVF_XYZRHW to D3DFVF_XYZW.
+	bool DdrawConvertHomogeneousToWorld = false;			// Convert primitives back into a world space. Needed for RTX.
+	bool DdrawConvertHomogeneousToWorldUseGameCamera = false;	// Use the game's view matrix instead of replacing it with our own.
+	float DdrawConvertHomogeneousToWorldFOV = 90.0f;		// The field of view of the camera used to reconstruct the original 3D world.
+	float DdrawConvertHomogeneousToWorldNearPlane = 1.0f;	// The near plane of the camera used to reconstruct the original 3D world.
+	float DdrawConvertHomogeneousToWorldFarPlane = 1000.0f;	// The far plane of the camera used to reconstruct the original 3D world.
+	float DdrawConvertHomogeneousToWorldDepthOffset = 0.0f;	// The offset to add to the geometry so it does not clip into the near plane.
 	bool DdrawUseNativeResolution = false;		// Uses the current screen resolution for Dd7to9
 	DWORD DdrawClippedWidth = 0;				// Used to scaled Direct3d9 to use this width when using Dd7to9
 	DWORD DdrawClippedHeight = 0;				// Used to scaled Direct3d9 to use this height when using Dd7to9
@@ -219,6 +234,7 @@ struct CONFIG
 	DWORD DdrawOverrideRefreshRate = 0;			// Force Direct3d9 to use this refresh rate when using Dd7to9
 	DWORD DdrawOverrideStencilFormat = 0;		// Force Direct3d9 to use this AutoStencilFormat when using Dd7to9
 	bool DdrawEnableMouseHook = true;			// Allow to hook into mouse to limit it to the chosen resolution
+	bool DdrawDisableLighting = false;			// Allow to disable lighting
 	DWORD DdrawHookSystem32 = 0;				// Hooks the ddraw.dll file in the Windows System32 folder
 	DWORD D3d8HookSystem32 = 0;					// Hooks the d3d8.dll file in the Windows System32 folder
 	DWORD D3d9HookSystem32 = 0;					// Hooks the d3d9.dll file in the Windows System32 folder

ddraw/IDirect3DDeviceX.cpp

@@ -16,6 +16,7 @@
 
 #include "ddraw.h"
 #include <d3dhal.h>
+#include <DirectXMath.h>
 
 // Enable for testing only
 //#define ENABLE_DEBUGOVERLAY
@@ -338,15 +339,95 @@ HRESULT m_IDirect3DDeviceX::SetTransform(D3DTRANSFORMSTATETYPE dtstTransformStat
 			break;
 		}
 
-		HRESULT hr = (*d3d9Device)->SetTransform(dtstTransformStateType, lpD3DMatrix);
-
-		if (SUCCEEDED(hr))
+		_D3DMATRIX view;
+		if (Config.DdrawConvertHomogeneousW)
 		{
 #ifdef ENABLE_DEBUGOVERLAY
+			// Set the original matrix
 			DOverlay.SetTransform(dtstTransformStateType, lpD3DMatrix);
 #endif
+
+			if (dtstTransformStateType == D3DTS_VIEW)
+			{
+				D3DVIEWPORT9 Viewport9;
+				if (SUCCEEDED((*d3d9Device)->GetViewport(&Viewport9)))
+				{
+					const float width = (float)Viewport9.Width;
+					const float height = (float)Viewport9.Height;
+					const float ratio = width / height;
+
+					// Replace the matrix with one that handles D3DFVF_XYZRHW geometry
+					ZeroMemory(&view, sizeof(_D3DMATRIX));
+					view._11 = 2.0f / width;
+					view._22 = -2.0f / height;
+					view._33 = 1.0f;
+					view._41 = -1.0f;  // translate X
+					view._42 = 1.0f;   // translate Y
+					view._44 = 1.0f;
+
+					// Override original matrix pointer
+					lpD3DMatrix = &view;
+
+					if (Config.DdrawConvertHomogeneousToWorld)
+					{
+						DirectX::XMVECTOR position, direction;
+						if (Config.DdrawConvertHomogeneousToWorldUseGameCamera)
+						{
+							// To reconstruct the 3D world, we need to know where the camera is and where it is looking
+							position = DirectX::XMVectorSet(lpD3DMatrix->_41, lpD3DMatrix->_42, lpD3DMatrix->_43, lpD3DMatrix->_44);
+							direction = DirectX::XMVectorSet(lpD3DMatrix->_31, lpD3DMatrix->_32, lpD3DMatrix->_33, lpD3DMatrix->_34);
+						}
+						else
+						{
+							const float cameradir = 1.0f;
+
+							position = DirectX::XMVectorSet(0.0f, 0.0f, -cameradir, 0.0f);
+							direction = DirectX::XMVectorSet(0.0f, 0.0f, cameradir, 0.0f);
+						}
+
+						// Store the original matrix so it can be restored
+						std::memcpy(&RenderData.DdrawConvertHomogeneousToWorld_ViewMatrixOriginal, &view, sizeof(_D3DMATRIX));
+
+						// The Black & White matrix is an ortho camera, so create a perspective one matching the game
+						const float fov = Config.DdrawConvertHomogeneousToWorldFOV;
+						const float nearplane = Config.DdrawConvertHomogeneousToWorldNearPlane;
+						const float farplane = Config.DdrawConvertHomogeneousToWorldFarPlane;
+						DirectX::XMMATRIX proj = DirectX::XMMatrixPerspectiveFovLH(fov * (3.14159265359f / 180.0f), ratio, nearplane, farplane);
+
+						DirectX::XMStoreFloat4x4((DirectX::XMFLOAT4X4*)&RenderData.DdrawConvertHomogeneousToWorld_ProjectionMatrix, proj);
+
+						DirectX::XMVECTOR up = DirectX::XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
+						DirectX::XMMATRIX viewMatrix = DirectX::XMMatrixLookToLH(position, direction, up);
+
+						// Store the 3D view matrix so it can be set later
+						DirectX::XMStoreFloat4x4((DirectX::XMFLOAT4X4*)&RenderData.DdrawConvertHomogeneousToWorld_ViewMatrix, viewMatrix);
+
+						// Store the view inverse matrix of the game, so we can transform the geometry with it
+						DirectX::XMMATRIX toViewSpace = DirectX::XMLoadFloat4x4((DirectX::XMFLOAT4X4*)lpD3DMatrix);
+						DirectX::XMMATRIX vp = DirectX::XMMatrixMultiply(viewMatrix, proj);
+						DirectX::XMMATRIX vpinv = DirectX::XMMatrixInverse(nullptr, vp);
+
+						DirectX::XMMATRIX depthoffset = DirectX::XMMatrixTranslation(0.0f, 0.0f, Config.DdrawConvertHomogeneousToWorldDepthOffset);
+
+						RenderData.DdrawConvertHomogeneousToWorld_ViewMatrixInverse = DirectX::XMMatrixMultiply(depthoffset, DirectX::XMMatrixMultiply(toViewSpace, vpinv));
+					}
+				}
+			}
+			else
+			{
+				return D3D_OK;
+			}
 		}
 
+		HRESULT hr = (*d3d9Device)->SetTransform(dtstTransformStateType, lpD3DMatrix);
+
+#ifdef ENABLE_DEBUGOVERLAY
+		if (SUCCEEDED(hr) && !Config.DdrawConvertHomogeneousW)
+		{
+			DOverlay.SetTransform(dtstTransformStateType, lpD3DMatrix);
+		}
+#endif
+
 		return hr;
 	}
 
@@ -2050,6 +2131,12 @@ HRESULT m_IDirect3DDeviceX::SetRenderState(D3DRENDERSTATETYPE dwRenderStateType,
 			dwRenderStateType = D3DRS_DEPTHBIAS;
 			break;
 		}
+		case D3DRS_LIGHTING:
+			if (Config.DdrawDisableLighting)
+			{
+				dwRenderState = FALSE;
+			}
+			break;
 		case D3DRENDERSTATE_TEXTUREPERSPECTIVE:
 			return D3D_OK;		// As long as the device's D3DPTEXTURECAPS_PERSPECTIVE is enabled, the correction will be applied automatically.
 		case D3DRENDERSTATE_LINEPATTERN:
@@ -2453,11 +2540,99 @@ HRESULT m_IDirect3DDeviceX::DrawIndexedPrimitive(D3DPRIMITIVETYPE dptPrimitiveTy
 		}
 		else
 		{
+			const UINT stride = GetVertexStride(dwVertexTypeDesc);
+
+			// Handle PositionT
+			if (Config.DdrawConvertHomogeneousW && (dwVertexTypeDesc & 0x0E) == D3DFVF_XYZRHW)
+			{
+				D3DFVF_XYZB1;
+				if (!Config.DdrawConvertHomogeneousToWorld)
+				{
+					/*UINT8 *vertex = (UINT8*)lpVertices;
+
+					for (UINT x = 0; x < dwVertexCount; x++)
+					{
+						float *pos = (float*) vertex;
+
+						pos[3] = 1.0f;
+
+						vertex += stride;
+					}*/
+
+					// Update the FVF
+					dwVertexTypeDesc = (dwVertexTypeDesc & ~D3DFVF_XYZRHW) | D3DFVF_XYZW;
+				}
+				else
+				{
+					const UINT targetStride = stride - sizeof(float);
+					const UINT restSize = stride - sizeof(float) * 4;
+
+					RenderData.DdrawConvertHomogeneousToWorld_IntermediateGeometry.resize(targetStride * dwVertexCount);
+
+					UINT8 *sourceVertex = (UINT8*)lpVertices;
+					UINT8 *targetVertex = (UINT8*)RenderData.DdrawConvertHomogeneousToWorld_IntermediateGeometry.data();
+
+					lpVertices = targetVertex;
+
+					for (UINT x = 0; x < dwVertexCount; x++)
+					{
+						// Transform the vertices into world space
+						float *srcpos = (float*) sourceVertex;
+						float *trgtpos = (float*) targetVertex;
+
+						DirectX::XMVECTOR xpos = DirectX::XMVectorSet(srcpos[0], srcpos[1], srcpos[2], srcpos[3]);
+
+						DirectX::XMVECTOR xpos_global = DirectX::XMVector3TransformCoord(xpos, RenderData.DdrawConvertHomogeneousToWorld_ViewMatrixInverse);
+
+						xpos_global = DirectX::XMVectorDivide(xpos_global, DirectX::XMVectorSplatW(xpos_global));
+
+						trgtpos[0] = DirectX::XMVectorGetX(xpos_global);
+						trgtpos[1] = DirectX::XMVectorGetY(xpos_global);
+						trgtpos[2] = DirectX::XMVectorGetZ(xpos_global);
+
+						// Copy the rest
+						std::memcpy(targetVertex + sizeof(float) * 3, sourceVertex + sizeof(float) * 4, restSize);
+
+						// Move to next vertex
+						sourceVertex += stride;
+						targetVertex += targetStride;
+					}
+
+					// Set transform
+					(*d3d9Device)->SetTransform(D3DTS_VIEW, &RenderData.DdrawConvertHomogeneousToWorld_ViewMatrix);
+					(*d3d9Device)->SetTransform(D3DTS_PROJECTION, &RenderData.DdrawConvertHomogeneousToWorld_ProjectionMatrix);
+
+					// Update the FVF
+					const DWORD newVertexTypeDesc = (dwVertexTypeDesc & ~D3DFVF_XYZRHW) | D3DFVF_XYZ;
+
+					// Set fixed function vertex type
+					(*d3d9Device)->SetFVF(newVertexTypeDesc);
+
+					// Draw indexed primitive UP
+					hr = (*d3d9Device)->DrawIndexedPrimitiveUP(dptPrimitiveType, 0, dwVertexCount, GetNumberOfPrimitives(dptPrimitiveType, dwIndexCount), lpIndices, D3DFMT_INDEX16, lpVertices, targetStride);
+
+					// Restore transform
+					_D3DMATRIX identityMatrix;
+					ZeroMemory(&identityMatrix, sizeof(_D3DMATRIX));
+					identityMatrix._11 = 1.0f;
+					identityMatrix._22 = 1.0f;
+					identityMatrix._33 = 1.0f;
+
+					(*d3d9Device)->SetTransform(D3DTS_VIEW, &RenderData.DdrawConvertHomogeneousToWorld_ViewMatrixOriginal);
+					(*d3d9Device)->SetTransform(D3DTS_PROJECTION, &identityMatrix);
+
+					// Handle dwFlags
+					UnSetDrawFlags(rsClipping, rsLighting, rsExtents, newVertexTypeDesc, dwFlags, DirectXVersion);
+
+					return hr;
+				}
+			}
+
 			// Set fixed function vertex type
 			(*d3d9Device)->SetFVF(dwVertexTypeDesc);
 
 			// Draw indexed primitive UP
-			hr = (*d3d9Device)->DrawIndexedPrimitiveUP(dptPrimitiveType, 0, dwVertexCount, GetNumberOfPrimitives(dptPrimitiveType, dwIndexCount), lpIndices, D3DFMT_INDEX16, lpVertices, GetVertexStride(dwVertexTypeDesc));
+			hr = (*d3d9Device)->DrawIndexedPrimitiveUP(dptPrimitiveType, 0, dwVertexCount, GetNumberOfPrimitives(dptPrimitiveType, dwIndexCount), lpIndices, D3DFMT_INDEX16, lpVertices, stride);
 		}
 
 		// Handle dwFlags

ddraw/IDirect3DDeviceX.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "IDirectDrawX.h"
+#include "RenderData.h"
 
 class m_IDirect3DDeviceX : public IUnknown, public AddressLookupTableDdrawObject
 {
@@ -27,6 +28,9 @@ class m_IDirect3DDeviceX : public IUnknown, public AddressLookupTableDdrawObject
 	// SetTexture array
 	LPDIRECTDRAWSURFACE7 AttachedTexture[8] = {};
 
+	// The data used for rendering
+	RenderData RenderData;
+
 	// Wrapper interface functions
 	inline REFIID GetWrapperType(DWORD DirectXVersion)
 	{

ddraw/RenderData.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <d3d9types.h>
+#include <DirectXMath.h>
+#include <vector>
+
+class RenderData
+{
+public:
+
+	// Store the projection matrix used to transform the geometry on the gpu
+	_D3DMATRIX DdrawConvertHomogeneousToWorld_ProjectionMatrix;
+
+	// Store the view matrix used to transform the geometry on the gpu
+	_D3DMATRIX DdrawConvertHomogeneousToWorld_ViewMatrix;
+
+	// Store the original view matrix, so we can restore it
+	_D3DMATRIX DdrawConvertHomogeneousToWorld_ViewMatrixOriginal;
+
+	// Store the inverse view matrix to transform the geometry on the cpu
+	DirectX::XMMATRIX DdrawConvertHomogeneousToWorld_ViewMatrixInverse;
+
+	// Intermediate buffer for the geometry conversion
+	std::vector<uint8_t> DdrawConvertHomogeneousToWorld_IntermediateGeometry;
+
+	RenderData()
+	{
+		ZeroMemory(&DdrawConvertHomogeneousToWorld_ViewMatrix, sizeof(_D3DMATRIX));
+		DdrawConvertHomogeneousToWorld_ViewMatrix._11 = 1.0f;
+		DdrawConvertHomogeneousToWorld_ViewMatrix._22 = 1.0f;
+		DdrawConvertHomogeneousToWorld_ViewMatrix._33 = 1.0f;
+		DdrawConvertHomogeneousToWorld_ViewMatrix._44 = 1.0f;
+
+		std::memcpy(&DdrawConvertHomogeneousToWorld_ProjectionMatrix, &DdrawConvertHomogeneousToWorld_ViewMatrix, sizeof(_D3DMATRIX));
+		std::memcpy(&DdrawConvertHomogeneousToWorld_ViewMatrixOriginal, &DdrawConvertHomogeneousToWorld_ViewMatrix, sizeof(_D3DMATRIX));
+	}
+};

dxwrapper.vcxproj

@@ -588,6 +588,7 @@ cmd /q /c "cd /D ""$(ProjectDir)d3d8\"" &amp;&amp; del build.bat"</Command>
     <ClInclude Include="ddraw\IDirectDrawGammaControl.h" />
     <ClInclude Include="ddraw\IDirectDrawPalette.h" />
     <ClInclude Include="ddraw\IDirectDrawX.h" />
+    <ClInclude Include="ddraw\RenderData.h" />
     <ClInclude Include="ddraw\Versions\IDirect3D.h" />
     <ClInclude Include="ddraw\Versions\IDirect3D2.h" />
     <ClInclude Include="ddraw\Versions\IDirect3D3.h" />

dxwrapper.vcxproj.filters

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
     <Filter Include="DDrawCompat">
@@ -1868,6 +1868,9 @@
     <ClInclude Include="ddraw\DebugOverlay.h">
       <Filter>ddraw</Filter>
     </ClInclude>
+    <ClInclude Include="ddraw\RenderData.h">
+      <Filter>ddraw</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="Dllmain\BuildNo.rc">