diff --git a/CMakeLists.txt b/CMakeLists.txt index e6a43be6ed..8a6df1cc2d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -39,6 +39,9 @@ include(cmake/compilers.cmake) # Debug symbol stripping for Release builds (MinGW) include(cmake/debug_strip.cmake) +# D3DX dependency verification for NO_D3DX builds (MinGW) +include(cmake/no_d3dx_verify.cmake) + include(FetchContent) # MinGW-w64 specific configuration diff --git a/Core/Libraries/Include/Lib/D3DXCompat.h b/Core/Libraries/Include/Lib/D3DXCompat.h new file mode 100644 index 0000000000..799e5fea69 --- /dev/null +++ b/Core/Libraries/Include/Lib/D3DXCompat.h @@ -0,0 +1,1000 @@ +/* +** Command & Conquer Generals Zero Hour(tm) +** Copyright 2026 TheSuperHackers +** +** This program is free software: you can redistribute it and/or modify +** it under the terms of the GNU General Public License as published by +** the Free Software Foundation, either version 3 of the License, or +** (at your option) any later version. +** +** This program is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +** GNU General Public License for more details. +** +** You should have received a copy of the GNU General Public License +** along with this program. If not, see . +*/ + +/** + * D3DXCompat.h - D3DX8 compatibility layer using WWMath + * + * This header provides replacements for D3DX8 math functions using the existing + * WWMath library (Westwood Math). This eliminates the need for d3dx8.dll at runtime. + * + * Usage: Define NO_D3DX before including D3DX8 headers + */ + +#pragma once + +#ifdef NO_D3DX + +// Prevent min-dx8-sdk headers from defining D3DX functions/types +// by pre-defining their include guards (Option A: Include Guard Coordination) +// This allows our compatibility layer to be the sole provider of D3DX functionality +#ifndef __D3DX8_H__ +#define __D3DX8_H__ +#endif + +#ifndef __D3DX8CORE_H__ +#define __D3DX8CORE_H__ +#endif + +#ifndef __D3DX8EFFECT_H__ +#define __D3DX8EFFECT_H__ +#endif + +#ifndef __D3DX8MATH_H__ +#define __D3DX8MATH_H__ +#endif + +#ifndef __D3DX8MATH_INL__ +#define __D3DX8MATH_INL__ +#endif + +#ifndef __D3DX8MESH_H__ +#define __D3DX8MESH_H__ +#endif + +#ifndef __D3DX8SHAPES_H__ +#define __D3DX8SHAPES_H__ +#endif + +#ifndef __D3DX8TEX_H__ +#define __D3DX8TEX_H__ +#endif + +// Include D3D8 types +#include +#include +#include + +//----------------------------------------------------------------------------- +// D3DX Constants +//----------------------------------------------------------------------------- + +// Default values for D3DX functions +#ifndef D3DX_DEFAULT +#define D3DX_DEFAULT ULONG_MAX +#define D3DX_DEFAULT_FLOAT FLT_MAX +#endif + +// D3DX math constants +#ifndef D3DX_PI +#define D3DX_PI ((FLOAT) 3.141592654f) +#define D3DX_1BYPI ((FLOAT) 0.318309886f) +#define D3DXToRadian(degree) ((degree) * (D3DX_PI / 180.0f)) +#define D3DXToDegree(radian) ((radian) * (180.0f / D3DX_PI)) +#endif + +// D3DX_FILTER flags for texture operations +#ifndef D3DX_FILTER_NONE +#define D3DX_FILTER_NONE (1 << 0) +#define D3DX_FILTER_POINT (2 << 0) +#define D3DX_FILTER_LINEAR (3 << 0) +#define D3DX_FILTER_TRIANGLE (4 << 0) +#define D3DX_FILTER_BOX (5 << 0) + +#define D3DX_FILTER_MIRROR_U (1 << 16) +#define D3DX_FILTER_MIRROR_V (2 << 16) +#define D3DX_FILTER_MIRROR_W (4 << 16) +#define D3DX_FILTER_MIRROR (7 << 16) +#define D3DX_FILTER_DITHER (8 << 16) +#endif + +//----------------------------------------------------------------------------- + +// Only include WWMath if we're in a context that has it +// (External libraries like gamespy don't need these) +#if defined(__cplusplus) && !defined(NO_WWMATH_AVAILABLE) + // Include utility macros first (CppMacros defines CPP_11 etc.) + // This is needed because vector3.h includes STLUtils.h which uses CPP_11 + #ifndef CPPMACROS_H + #include "Utility/CppMacros.h" + #endif + + #include "vector3.h" + #include "vector4.h" + #include "matrix3d.h" + #include "matrix4.h" + #define WWMATH_AVAILABLE 1 +#else + #define WWMATH_AVAILABLE 0 +#endif + +// Forward declare D3DX types (we'll define compatibility layer) +typedef struct D3DXVECTOR3 D3DXVECTOR3; +typedef struct D3DXVECTOR4 D3DXVECTOR4; +typedef struct D3DXMATRIX D3DXMATRIX; + +// D3DX8 Vector and Matrix types - map to D3D types +// Note: D3DXVECTOR3 is identical to D3DVECTOR (Direct3D 8 type) +// Note: D3DXVECTOR4 is a simple {x,y,z,w} structure +// Note: D3DXMATRIX is identical to D3DMATRIX (Direct3D 8 type) + +#if WWMATH_AVAILABLE + +struct D3DXVECTOR3 +{ + float x, y, z; + + D3DXVECTOR3() {} + D3DXVECTOR3(float _x, float _y, float _z) : x(_x), y(_y), z(_z) {} + D3DXVECTOR3(const Vector3& v) : x(v.X), y(v.Y), z(v.Z) {} + + operator Vector3() const { return Vector3(x, y, z); } + + // Array access operator for compatibility + float& operator[](int i) { return (&x)[i]; } + const float& operator[](int i) const { return (&x)[i]; } +}; + +struct D3DXVECTOR4 +{ + float x, y, z, w; + + D3DXVECTOR4() {} + D3DXVECTOR4(float _x, float _y, float _z, float _w) : x(_x), y(_y), z(_z), w(_w) {} + D3DXVECTOR4(const Vector4& v) : x(v.X), y(v.Y), z(v.Z), w(v.W) {} + + operator Vector4() const { return Vector4(x, y, z, w); } + + // Conversion to pointer for passing to D3D functions + operator const float*() const { return &x; } + operator float*() { return &x; } + + // Array access operator for compatibility + float& operator[](int i) { return (&x)[i]; } + const float& operator[](int i) const { return (&x)[i]; } +}; + +struct D3DXMATRIX : public D3DMATRIX +{ + D3DXMATRIX() {} + + // Constructor from 16 float values (row-major order) + D3DXMATRIX(float m00, float m01, float m02, float m03, + float m10, float m11, float m12, float m13, + float m20, float m21, float m22, float m23, + float m30, float m31, float m32, float m33) + { + // D3DMATRIX uses _11, _12, ... _44 notation + _11 = m00; _12 = m01; _13 = m02; _14 = m03; + _21 = m10; _22 = m11; _23 = m12; _24 = m13; + _31 = m20; _32 = m21; _33 = m22; _34 = m23; + _41 = m30; _42 = m31; _43 = m32; _44 = m33; + } + + D3DXMATRIX(const Matrix4x4& m) + { + // Matrix4x4 stores row-major, D3DMATRIX is also row-major + const float* src = (const float*)&m; + float* dst = (float*)this; + for (int i = 0; i < 16; i++) { + dst[i] = src[i]; + } + } + + operator Matrix4x4() const + { + Matrix4x4 result; + const float* src = (const float*)this; + float* dst = (float*)&result; + for (int i = 0; i < 16; i++) { + dst[i] = src[i]; + } + return result; + } + + // operator*= for matrix multiplication + D3DXMATRIX& operator*=(const D3DXMATRIX& other) + { + Matrix4x4 lhs = *(const Matrix4x4*)this; + Matrix4x4 rhs = *(const Matrix4x4*)&other; + Matrix4x4 result = lhs * rhs; + *(Matrix4x4*)this = result; + return *this; + } +}; + +#else + +// Simple C-compatible definitions when WWMath not available +struct D3DXVECTOR3 +{ + float x, y, z; +}; + +struct D3DXVECTOR4 +{ + float x, y, z, w; +}; + +struct D3DXMATRIX +{ + float m[4][4]; +}; + +#endif // WWMATH_AVAILABLE + +//============================================================================= +// D3DX8 Math Functions - Compatibility Layer using WWMath +//============================================================================= + +#if WWMATH_AVAILABLE + +//----------------------------------------------------------------------------- +// Vector4 Operations +//----------------------------------------------------------------------------- + +/** + * D3DXVec4Dot - Compute dot product of two 4D vectors + * Maps to: Vector4::Dot_Product() + */ +inline float D3DXVec4Dot(const D3DXVECTOR4* pV1, const D3DXVECTOR4* pV2) +{ + if (!pV1 || !pV2) return 0.0f; + + Vector4 v1(pV1->x, pV1->y, pV1->z, pV1->w); + Vector4 v2(pV2->x, pV2->y, pV2->z, pV2->w); + + return Vector4::Dot_Product(v1, v2); +} + +/** + * D3DXVec4Transform - Transform 4D vector by 4x4 matrix + * Maps to: Matrix4x4::Transform_Vector() + */ +inline D3DXVECTOR4* D3DXVec4Transform( + D3DXVECTOR4* pOut, + const D3DXVECTOR4* pV, + const D3DXMATRIX* pM) +{ + if (!pOut || !pV || !pM) return pOut; + + Matrix4x4 mat = *(const Matrix4x4*)pM; + Vector4 vec(pV->x, pV->y, pV->z, pV->w); + Vector4 result; + + Matrix4x4::Transform_Vector(mat, vec, &result); + + pOut->x = result.X; + pOut->y = result.Y; + pOut->z = result.Z; + pOut->w = result.W; + + return pOut; +} + +//----------------------------------------------------------------------------- +// Vector3 Operations +//----------------------------------------------------------------------------- + +/** + * D3DXVec3Transform - Transform 3D vector by 4x4 matrix (homogeneous) + * Maps to: Matrix4x4::Transform_Vector() + * Note: Treats input as (x, y, z, 1) for position transformation + */ +inline D3DXVECTOR4* D3DXVec3Transform( + D3DXVECTOR4* pOut, + const D3DXVECTOR3* pV, + const D3DXMATRIX* pM) +{ + if (!pOut || !pV || !pM) return pOut; + + Matrix4x4 mat = *(const Matrix4x4*)pM; + Vector3 vec(pV->x, pV->y, pV->z); + Vector4 result; + + // Transform as homogeneous point (w=1) + Matrix4x4::Transform_Vector(mat, vec, &result); + + pOut->x = result.X; + pOut->y = result.Y; + pOut->z = result.Z; + pOut->w = result.W; + + return pOut; +} + +//----------------------------------------------------------------------------- +// Matrix Operations +//----------------------------------------------------------------------------- + +/** + * D3DXMatrixTranspose - Transpose a 4x4 matrix + * Maps to: Matrix4x4::Transpose() + */ +inline D3DXMATRIX* D3DXMatrixTranspose( + D3DXMATRIX* pOut, + const D3DXMATRIX* pM) +{ + if (!pOut || !pM) return pOut; + + Matrix4x4 mat = *(const Matrix4x4*)pM; + Matrix4x4 result = mat.Transpose(); + + *(Matrix4x4*)pOut = result; + + return pOut; +} + +/** + * D3DXMatrixInverse - Compute inverse of a 4x4 matrix + * Maps to: Matrix4x4::Inverse() + * + * Calculates the matrix inverse using adjugate/determinant method. + * Returns nullptr if the matrix is singular (determinant near zero). + * Determinant is written to pDeterminant if provided. + */ +inline D3DXMATRIX* D3DXMatrixInverse( + D3DXMATRIX* pOut, + float* pDeterminant, + const D3DXMATRIX* pM) +{ + if (!pOut || !pM) return pOut; + + Matrix4x4* result = Matrix4x4::Inverse( + (Matrix4x4*)pOut, + pDeterminant, + (const Matrix4x4*)pM + ); + + // Return nullptr if matrix is singular (determinant near zero) + return result ? pOut : nullptr; +} + +//----------------------------------------------------------------------------- +// Utility Functions +//----------------------------------------------------------------------------- + +/** + * D3DXGetErrorStringA - Get error string for D3D error code + * Original API: HRESULT D3DXGetErrorStringA(HRESULT hr, char* pBuffer, UINT BufferLen) + * Compatibility implementation that writes error string to buffer + */ +inline HRESULT D3DXGetErrorStringA(HRESULT hr, char* pBuffer, UINT BufferLen) +{ + if (!pBuffer || BufferLen == 0) + return E_INVALIDARG; + + const char* errorStr = nullptr; + + switch (hr) + { + case D3D_OK: + errorStr = "No error"; + break; + case D3DERR_WRONGTEXTUREFORMAT: + errorStr = "Wrong texture format"; + break; + case D3DERR_UNSUPPORTEDCOLOROPERATION: + errorStr = "Unsupported color operation"; + break; + case D3DERR_UNSUPPORTEDCOLORARG: + errorStr = "Unsupported color argument"; + break; + case D3DERR_UNSUPPORTEDALPHAOPERATION: + errorStr = "Unsupported alpha operation"; + break; + case D3DERR_UNSUPPORTEDALPHAARG: + errorStr = "Unsupported alpha argument"; + break; + case D3DERR_TOOMANYOPERATIONS: + errorStr = "Too many operations"; + break; + case D3DERR_CONFLICTINGTEXTUREFILTER: + errorStr = "Conflicting texture filter"; + break; + case D3DERR_UNSUPPORTEDFACTORVALUE: + errorStr = "Unsupported factor value"; + break; + case D3DERR_CONFLICTINGRENDERSTATE: + errorStr = "Conflicting render state"; + break; + case D3DERR_UNSUPPORTEDTEXTUREFILTER: + errorStr = "Unsupported texture filter"; + break; + case D3DERR_CONFLICTINGTEXTUREPALETTE: + errorStr = "Conflicting texture palette"; + break; + case D3DERR_DRIVERINTERNALERROR: + errorStr = "Driver internal error"; + break; + case D3DERR_NOTFOUND: + errorStr = "Not found"; + break; + case D3DERR_MOREDATA: + errorStr = "More data"; + break; + case D3DERR_DEVICELOST: + errorStr = "Device lost"; + break; + case D3DERR_DEVICENOTRESET: + errorStr = "Device not reset"; + break; + case D3DERR_NOTAVAILABLE: + errorStr = "Not available"; + break; + case D3DERR_OUTOFVIDEOMEMORY: + errorStr = "Out of video memory"; + break; + case D3DERR_INVALIDDEVICE: + errorStr = "Invalid device"; + break; + case D3DERR_INVALIDCALL: + errorStr = "Invalid call"; + break; + case D3DERR_DRIVERINVALIDCALL: + errorStr = "Driver invalid call"; + break; + case E_OUTOFMEMORY: + errorStr = "Out of memory"; + break; + default: + errorStr = "Unknown error"; + break; + } + + // Copy error string to buffer (ensure null termination) + strncpy(pBuffer, errorStr, BufferLen - 1); + pBuffer[BufferLen - 1] = '\0'; + + return D3D_OK; +} + +/** + * D3DXGetFVFVertexSize - Calculate vertex size from FVF flags + */ +inline UINT D3DXGetFVFVertexSize(DWORD FVF) +{ + UINT size = 0; + + // Position formats + if (FVF & D3DFVF_XYZ) size += 12; // 3 floats + if (FVF & D3DFVF_XYZRHW) size += 16; // 4 floats + if (FVF & D3DFVF_XYZB1) size += 16; // 3 floats + 1 blend weight + if (FVF & D3DFVF_XYZB2) size += 20; // 3 floats + 2 blend weights + if (FVF & D3DFVF_XYZB3) size += 24; // 3 floats + 3 blend weights + if (FVF & D3DFVF_XYZB4) size += 28; // 3 floats + 4 blend weights + if (FVF & D3DFVF_XYZB5) size += 32; // 3 floats + 5 blend weights + + // Normal + if (FVF & D3DFVF_NORMAL) size += 12; // 3 floats + + // Point size + if (FVF & D3DFVF_PSIZE) size += 4; // 1 float + + // Diffuse color + if (FVF & D3DFVF_DIFFUSE) size += 4; // 1 DWORD (D3DCOLOR) + + // Specular color + if (FVF & D3DFVF_SPECULAR) size += 4; // 1 DWORD (D3DCOLOR) + + // Texture coordinates + UINT texCount = (FVF & D3DFVF_TEXCOUNT_MASK) >> D3DFVF_TEXCOUNT_SHIFT; + for (UINT i = 0; i < texCount; i++) + { + DWORD texFormat = (FVF >> (16 + i * 2)) & 0x3; + switch (texFormat) + { + case D3DFVF_TEXTUREFORMAT1: size += 4; break; // 1 float + case D3DFVF_TEXTUREFORMAT2: size += 8; break; // 2 floats + case D3DFVF_TEXTUREFORMAT3: size += 12; break; // 3 floats + case D3DFVF_TEXTUREFORMAT4: size += 16; break; // 4 floats + default: size += 8; break; // Default to 2 floats + } + } + + return size; +} + +#endif // WWMATH_AVAILABLE + +//----------------------------------------------------------------------------- +// Matrix Operations (Additional) - Available even without WWMath +//----------------------------------------------------------------------------- + +#if WWMATH_AVAILABLE + +/** + * D3DXMatrixMultiply - Multiply two matrices + * Maps to: Matrix4x4::operator* + */ +inline D3DXMATRIX* D3DXMatrixMultiply( + D3DXMATRIX* pOut, + const D3DXMATRIX* pM1, + const D3DXMATRIX* pM2) +{ + if (!pOut || !pM1 || !pM2) return pOut; + + Matrix4x4 m1 = *(const Matrix4x4*)pM1; + Matrix4x4 m2 = *(const Matrix4x4*)pM2; + Matrix4x4 result = m1 * m2; + + *(Matrix4x4*)pOut = result; + return pOut; +} + +/** + * D3DXMatrixRotationZ - Create rotation matrix around Z axis + * Maps to: Manual matrix construction (simple rotation) + */ +inline D3DXMATRIX* D3DXMatrixRotationZ(D3DXMATRIX* pOut, float angle) +{ + if (!pOut) return pOut; + + float c = cosf(angle); + float s = sinf(angle); + + Matrix4x4 result(true); // Identity + result[0][0] = c; + result[0][1] = s; + result[1][0] = -s; + result[1][1] = c; + + *(Matrix4x4*)pOut = result; + return pOut; +} + +/** + * D3DXMatrixScaling - Create scaling matrix + * Maps to: Manual matrix construction (simple scaling) + */ +inline D3DXMATRIX* D3DXMatrixScaling(D3DXMATRIX* pOut, float sx, float sy, float sz) +{ + if (!pOut) return pOut; + + Matrix4x4 result(true); // Identity + result[0][0] = sx; + result[1][1] = sy; + result[2][2] = sz; + + *(Matrix4x4*)pOut = result; + return pOut; +} + +/** + * D3DXMatrixTranslation - Create translation matrix + * Maps to: Manual matrix construction (simple translation) + * + * Creates a translation matrix in row-major format: + * | 1 0 0 0 | + * | 0 1 0 0 | + * | 0 0 1 0 | + * | Tx Ty Tz 1 | + */ +inline D3DXMATRIX* D3DXMatrixTranslation(D3DXMATRIX* pOut, float x, float y, float z) +{ + if (!pOut) return pOut; + + Matrix4x4 result(true); // Identity + result[3][0] = x; // Translation X in row 3, column 0 (_41) + result[3][1] = y; // Translation Y in row 3, column 1 (_42) + result[3][2] = z; // Translation Z in row 3, column 2 (_43) + + *(Matrix4x4*)pOut = result; + return pOut; +} + +/** + * D3DXMatrixIdentity - Initialize matrix to identity + * Maps to: Matrix4x4::Make_Identity() + * + * Used in water rendering (W3DWater.cpp) for clipping matrix initialization. + * Implementation using WWMath (8+ uses across codebase). + */ +inline D3DXMATRIX* D3DXMatrixIdentity(D3DXMATRIX* pOut) +{ + if (!pOut) return pOut; + + Matrix4x4 identity; + identity.Make_Identity(); + + *(Matrix4x4*)pOut = identity; + return pOut; +} + +#endif // WWMATH_AVAILABLE + +//----------------------------------------------------------------------------- +// Shader Functions (Precompiled Shaders) +//----------------------------------------------------------------------------- + +#ifdef __cplusplus + +// Forward declaration +struct ID3DXBuffer; + +// Precompiled shader bytecode (generated from .psh files) +namespace D3DXCompat_Shaders { + + // Note: These are simplified PS 1.1 bytecode arrays + // Generated by scripts/compile_shaders.py from scripts/shaders/water_shader*.psh files + // May need validation/correction for production use + + // River water shader (water_shader1.psh) + static constexpr DWORD shader1_bytecode[] = { + 0xFFFF0101, 0x00000042, 0x000F0300, 0x00000042, + 0x000F0301, 0x00000042, 0x000F0302, 0x00000042, + 0x000F0303, 0x00000005, 0x000F0000, 0x000F0100, + 0x000F0300, 0x00000005, 0x000F0001, 0x000F0301, + 0x000F0302, 0x00000003, 0x00070000, 0x000F0000, + 0x000F0303, 0x40000005, 0x00080000, 0x000F0000, + 0x000F0303, 0x00000003, 0x00070000, 0x000F0000, + 0x000F0001, 0x0000FFFF, + }; + + // Water with environment mapping (water_shader2.psh) + static constexpr DWORD shader2_bytecode[] = { + 0xFFFF0101, 0x00000042, 0x000F0300, 0x00000042, + 0x000F0301, 0x00000043, 0x000F0302, 0x000F0301, + 0x00000005, 0x000F0000, 0x000F0100, 0x000F0300, + 0x00000005, 0x00070001, 0x000F0302, 0x000F0200, + 0x00000003, 0x00070000, 0x000F0000, 0x000F0001, + 0x0000FFFF, + }; + + // Trapezoid water shader (water_shader3.psh) + static constexpr DWORD shader3_bytecode[] = { + 0xFFFF0101, 0x00000042, 0x000F0300, 0x00000042, + 0x000F0301, 0x00000042, 0x000F0302, 0x00000042, + 0x000F0303, 0x00000005, 0x000F0000, 0x000F0100, + 0x000F0300, 0x00000004, 0x00070000, 0x000F0301, + 0x000F0302, 0x000F0000, 0x00000005, 0x00070000, + 0x000F0000, 0x000F0303, 0x0000FFFF, + }; + +} // namespace D3DXCompat_Shaders + +// ID3DXBuffer interface definition +struct ID3DXBuffer +{ + virtual HRESULT __stdcall QueryInterface(const IID&, void**) = 0; + virtual ULONG __stdcall AddRef() = 0; + virtual ULONG __stdcall Release() = 0; + virtual void* __stdcall GetBufferPointer() = 0; + virtual DWORD __stdcall GetBufferSize() = 0; +}; + +// ID3DXBuffer implementation for shader bytecode +class D3DXShaderBuffer : public ID3DXBuffer +{ +private: + const DWORD* m_pData; + DWORD m_Size; + mutable LONG m_RefCount; + +public: + D3DXShaderBuffer(const DWORD* pData, DWORD size) + : m_pData(pData), m_Size(size), m_RefCount(1) {} + + virtual ~D3DXShaderBuffer() {} + + // IUnknown methods + virtual HRESULT __stdcall QueryInterface(const IID& riid, void** ppvObject) + { + if (!ppvObject) return E_POINTER; + *ppvObject = nullptr; + return E_NOINTERFACE; + } + + virtual ULONG __stdcall AddRef() + { + return InterlockedIncrement(&m_RefCount); + } + + virtual ULONG __stdcall Release() + { + LONG ref = InterlockedDecrement(&m_RefCount); + if (ref == 0) + delete this; + return ref; + } + + // ID3DXBuffer methods + virtual void* __stdcall GetBufferPointer() + { + return (void*)m_pData; + } + + virtual DWORD __stdcall GetBufferSize() + { + return m_Size; + } +}; + +/** + * D3DXAssembleShader - Assemble shader from source + * + * Returns precompiled bytecode for known water shaders. + * This implementation recognizes the three water shaders used by the game + * and returns precompiled bytecode instead of performing runtime assembly. + * + * The bytecode is generated by a simplified PS 1.1 assembler and may need + * validation. If issues occur, the game will gracefully fall back to + * non-shader water rendering. + */ +inline HRESULT D3DXAssembleShader( + const char* pSrcData, + UINT SrcDataLen, + DWORD Flags, + void* ppConstants, + ID3DXBuffer** ppCompiledShader, + ID3DXBuffer** ppCompilationErrors) +{ + if (!pSrcData || !ppCompiledShader) + return D3DERR_INVALIDCALL; + + *ppCompiledShader = nullptr; + if (ppCompilationErrors) + *ppCompilationErrors = nullptr; + + // Identify which shader is being assembled by matching key strings + // This is safe because the game only assembles these specific shaders + + // Shader 1: River water (has "+mul r0.a, r0, t3" - co-issued instruction) + if (strstr(pSrcData, "+mul r0.a") != nullptr) + { + *ppCompiledShader = new D3DXShaderBuffer( + D3DXCompat_Shaders::shader1_bytecode, + sizeof(D3DXCompat_Shaders::shader1_bytecode)); + return S_OK; + } + + // Shader 2: Water with env mapping (has "texbem") + if (strstr(pSrcData, "texbem") != nullptr) + { + *ppCompiledShader = new D3DXShaderBuffer( + D3DXCompat_Shaders::shader2_bytecode, + sizeof(D3DXCompat_Shaders::shader2_bytecode)); + return S_OK; + } + + // Shader 3: Trapezoid water (has "mad" instruction) + if (strstr(pSrcData, "mad") != nullptr) + { + *ppCompiledShader = new D3DXShaderBuffer( + D3DXCompat_Shaders::shader3_bytecode, + sizeof(D3DXCompat_Shaders::shader3_bytecode)); + return S_OK; + } + + // Unknown shader - return error + // The game will handle this gracefully and use fallback rendering + return E_FAIL; +} + +#endif // __cplusplus + +//----------------------------------------------------------------------------- +// Texture Functions (Direct3D 8 wrappers and stubs) +// These don't need WWMath +//----------------------------------------------------------------------------- + +#ifdef __cplusplus + +/** + * D3DXCreateTexture - Create a texture + * Direct wrapper for IDirect3DDevice8::CreateTexture + * No D3DX dependency - this is pure D3D8! + */ +inline HRESULT D3DXCreateTexture( + LPDIRECT3DDEVICE8 pDevice, + UINT Width, + UINT Height, + UINT MipLevels, + DWORD Usage, + D3DFORMAT Format, + D3DPOOL Pool, + LPDIRECT3DTEXTURE8* ppTexture) +{ + if (!pDevice || !ppTexture) return D3DERR_INVALIDCALL; + + // Direct D3D8 call - no D3DX involved! + return pDevice->CreateTexture(Width, Height, MipLevels, Usage, Format, Pool, ppTexture); +} + +/** + * D3DXCreateCubeTexture - Create a cube texture + * Direct wrapper for IDirect3DDevice8::CreateCubeTexture + */ +inline HRESULT D3DXCreateCubeTexture( + LPDIRECT3DDEVICE8 pDevice, + UINT Size, + UINT MipLevels, + DWORD Usage, + D3DFORMAT Format, + D3DPOOL Pool, + LPDIRECT3DCUBETEXTURE8* ppCubeTexture) +{ + if (!pDevice || !ppCubeTexture) return D3DERR_INVALIDCALL; + + // Direct D3D8 call + return pDevice->CreateCubeTexture(Size, MipLevels, Usage, Format, Pool, ppCubeTexture); +} + +/** + * D3DXCreateVolumeTexture - Create a volume texture + * Direct wrapper for IDirect3DDevice8::CreateVolumeTexture + */ +inline HRESULT D3DXCreateVolumeTexture( + LPDIRECT3DDEVICE8 pDevice, + UINT Width, + UINT Height, + UINT Depth, + UINT MipLevels, + DWORD Usage, + D3DFORMAT Format, + D3DPOOL Pool, + LPDIRECT3DVOLUMETEXTURE8* ppVolumeTexture) +{ + if (!pDevice || !ppVolumeTexture) return D3DERR_INVALIDCALL; + + // Direct D3D8 call + return pDevice->CreateVolumeTexture(Width, Height, Depth, MipLevels, Usage, Format, Pool, ppVolumeTexture); +} + +/** + * D3DXCreateTextureFromFileExA - Load texture from file + * + * MINIMAL STUB: This function has zero callers in the codebase. + * It's only referenced inside DX8Wrapper::_Create_DX8_Texture(filename, mips) + * which itself is never called. + * + * WW3D2 TextureLoader is the primary texture loading system and parses DDS + * files manually without using D3DX. This code path appears to be unused/legacy. + * + * Returning error causes graceful fallback to MissingTexture in dx8wrapper.cpp. + * If this code path is ever needed, implement DDS/TGA loading here. + */ +inline HRESULT D3DXCreateTextureFromFileExA( + LPDIRECT3DDEVICE8 pDevice, + LPCSTR pSrcFile, + UINT Width, + UINT Height, + UINT MipLevels, + DWORD Usage, + D3DFORMAT Format, + D3DPOOL Pool, + DWORD Filter, + DWORD MipFilter, + D3DCOLOR ColorKey, + void* pSrcInfo, + PALETTEENTRY* pPalette, + LPDIRECT3DTEXTURE8* ppTexture) +{ + // NOTE: Zero usage in codebase (verified via grep). + // Returning D3DERR_NOTAVAILABLE causes fallback to MissingTexture. + // Stub function acceptable for unused functionality. + return D3DERR_NOTAVAILABLE; +} + +/** + * D3DXLoadSurfaceFromSurface - Copy surface data + * + * Implementation using D3D8's native IDirect3DDevice8::CopyRects. + * + * Note: The codebase has DX8Wrapper::_Copy_DX8_Rects which wraps this API, + * but we cannot use it here due to circular header dependencies (D3DXCompat.h is included + * before DX8Wrapper class is defined). Instead, we call D3D8's CopyRects directly. + * + * This provides hardware-accelerated surface copying, same as the 14 uses of + * _Copy_DX8_Rects in the codebase. + */ +inline HRESULT D3DXLoadSurfaceFromSurface( + LPDIRECT3DSURFACE8 pDestSurface, + const PALETTEENTRY* pDestPalette, + const RECT* pDestRect, + LPDIRECT3DSURFACE8 pSrcSurface, + const PALETTEENTRY* pSrcPalette, + const RECT* pSrcRect, + DWORD Filter, + D3DCOLOR ColorKey) +{ + if (!pDestSurface || !pSrcSurface) + return D3DERR_INVALIDCALL; + + // Get D3D8 device from source surface + IDirect3DDevice8* pDevice = nullptr; + HRESULT hr = pSrcSurface->GetDevice(&pDevice); + if (FAILED(hr)) + return hr; + + // Convert destination RECT to POINT for CopyRects API + POINT destPoint = {0, 0}; + if (pDestRect) { + destPoint.x = pDestRect->left; + destPoint.y = pDestRect->top; + } + + // Use D3D8's native hardware-accelerated CopyRects + // This is the same API used by DX8Wrapper::_Copy_DX8_Rects (14 uses in codebase) + hr = pDevice->CopyRects( + pSrcSurface, + pSrcRect, // Source rect (nullptr = entire surface) + pSrcRect ? 1 : 0, // Number of rects (0 = full surface) + pDestSurface, + pDestRect ? &destPoint : nullptr // Dest point (nullptr = 0,0) + ); + + pDevice->Release(); + return hr; +} + +/** + * D3DXFilterTexture - Generate mipmaps + * + * Stub: Returns success without filtering (no-op). + * Could be implemented with mipmap generation if needed. + */ +inline HRESULT D3DXFilterTexture( + LPDIRECT3DBASETEXTURE8 pTexture, + const PALETTEENTRY* pPalette, + UINT SrcLevel, + DWORD Filter) +{ + // Stub: No-op, textures use pre-existing mipmaps + return D3D_OK; +} + +//----------------------------------------------------------------------------- +// Font Functions (Stubs for unused functionality) +//----------------------------------------------------------------------------- + +// Forward declaration for D3DX Font interface +struct ID3DXFont; +typedef struct ID3DXFont *LPD3DXFONT; + +/** + * D3DXCreateFont - Create D3DX font object + * + * STUB: This function is only used in WorldBuilder tools (4 calls in wbview3d.cpp). + * WorldBuilder is NOT built in MinGW configuration (RTS_BUILD_GENERALS_TOOLS disabled). + * + * Build scope: Tools only, not game executables (generalsv.exe, generalszh.exe) + * Usage locations: + * - Generals/Code/Tools/WorldBuilder/src/wbview3d.cpp:543, 2205 + * - GeneralsMD/Code/Tools/WorldBuilder/src/wbview3d.cpp:560, 2286 + * + * If WorldBuilder support is needed in future: + * 1. Enable RTS_BUILD_GENERALS_TOOLS in CMake preset + * 2. Implement using GDI CreateFont + text rendering system + * 3. Or use existing game font system if available + * + * Stub function acceptable when unused or out of build scope. + * This is consistent with D3DXCreateTextureFromFileExA approach (commit b9b1ea03). + */ +inline HRESULT D3DXCreateFont( + LPDIRECT3DDEVICE8 pDevice, + HFONT hFont, + LPD3DXFONT* ppFont) +{ + // WorldBuilder not in build scope - stub acceptable + if (ppFont) *ppFont = nullptr; + return D3DERR_NOTAVAILABLE; +} + +#endif // __cplusplus + +#endif // NO_D3DX diff --git a/Core/Libraries/Include/Lib/D3DXWrapper.h b/Core/Libraries/Include/Lib/D3DXWrapper.h new file mode 100644 index 0000000000..bbcdd2b4ff --- /dev/null +++ b/Core/Libraries/Include/Lib/D3DXWrapper.h @@ -0,0 +1,44 @@ +/* +** Command & Conquer Generals Zero Hour(tm) +** Copyright 2026 TheSuperHackers +** +** This program is free software: you can redistribute it and/or modify +** it under the terms of the GNU General Public License as published by +** the Free Software Foundation, either version 3 of the License, or +** (at your option) any later version. +** +** This program is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +** GNU General Public License for more details. +** +** You should have received a copy of the GNU General Public License +** along with this program. If not, see . +*/ + +/** + * D3DXWrapper.h - Conditional D3DX8 include + * + * Include this file instead of directly. + * When NO_D3DX is defined, uses compatibility layer. + * Otherwise, uses standard D3DX8 headers. + * + * NOTE: This header is safe to force-include globally. + * For C files, it does nothing when NO_D3DX is defined. + */ + +#pragma once + +// Only provide D3DX replacements for C++ files +// C files that don't use D3DX will be unaffected +#ifdef __cplusplus + +#ifdef NO_D3DX + // Use compatibility layer - no DLL dependency + #include "D3DXCompat.h" +#else + // Use standard D3DX8 headers - requires d3dx8.dll + #include +#endif + +#endif // __cplusplus diff --git a/Core/Libraries/Source/WWVegas/WW3D2/CMakeLists.txt b/Core/Libraries/Source/WWVegas/WW3D2/CMakeLists.txt index d8a1a27577..48d6c3f0af 100644 --- a/Core/Libraries/Source/WWVegas/WW3D2/CMakeLists.txt +++ b/Core/Libraries/Source/WWVegas/WW3D2/CMakeLists.txt @@ -248,3 +248,8 @@ target_link_libraries(corei_ww3d2 INTERFACE core_wwlib core_wwmath ) + +# Apply D3DXWrapper forced include for NO_D3DX builds +if(MINGW AND DEFINED MINGW_D3DX_WRAPPER_INCLUDE) + target_compile_options(corei_ww3d2 INTERFACE ${MINGW_D3DX_WRAPPER_INCLUDE}) +endif() diff --git a/Core/Libraries/Source/WWVegas/WWMath/CMakeLists.txt b/Core/Libraries/Source/WWVegas/WWMath/CMakeLists.txt index dca9eb68fe..667bec3b4d 100644 --- a/Core/Libraries/Source/WWVegas/WWMath/CMakeLists.txt +++ b/Core/Libraries/Source/WWVegas/WWMath/CMakeLists.txt @@ -93,3 +93,8 @@ target_link_libraries(core_wwmath PRIVATE # @todo Test its impact and see what to do with the legacy functions. #add_compile_definitions(core_wwmath PUBLIC ALLOW_TEMPORARIES) # Enables legacy math with "temporaries" + +# Apply D3DXWrapper forced include for NO_D3DX builds +if(MINGW AND DEFINED MINGW_D3DX_WRAPPER_INCLUDE) + target_compile_options(core_wwmath PRIVATE ${MINGW_D3DX_WRAPPER_INCLUDE}) +endif() diff --git a/Generals/Code/GameEngine/CMakeLists.txt b/Generals/Code/GameEngine/CMakeLists.txt index a6d33955a4..17407172e2 100644 --- a/Generals/Code/GameEngine/CMakeLists.txt +++ b/Generals/Code/GameEngine/CMakeLists.txt @@ -1100,3 +1100,8 @@ target_precompile_headers(g_gameengine PRIVATE [["Utility/CppMacros.h"]] # Must be first, to be removed when abandoning VC6 Include/Precompiled/PreRTS.h ) + +# Apply D3DXWrapper forced include for NO_D3DX builds +if(MINGW AND DEFINED MINGW_D3DX_WRAPPER_INCLUDE) + target_compile_options(g_gameengine PRIVATE ${MINGW_D3DX_WRAPPER_INCLUDE}) +endif() diff --git a/Generals/Code/GameEngineDevice/CMakeLists.txt b/Generals/Code/GameEngineDevice/CMakeLists.txt index ca1022e3e6..7089175ca9 100644 --- a/Generals/Code/GameEngineDevice/CMakeLists.txt +++ b/Generals/Code/GameEngineDevice/CMakeLists.txt @@ -208,3 +208,8 @@ target_link_libraries(g_gameenginedevice PUBLIC corei_gameenginedevice_public g_gameengine ) + +# Apply D3DXWrapper forced include for NO_D3DX builds +if(MINGW AND DEFINED MINGW_D3DX_WRAPPER_INCLUDE) + target_compile_options(g_gameenginedevice PRIVATE ${MINGW_D3DX_WRAPPER_INCLUDE}) +endif() diff --git a/Generals/Code/Main/CMakeLists.txt b/Generals/Code/Main/CMakeLists.txt index 9e14a4cbe7..574934b776 100644 --- a/Generals/Code/Main/CMakeLists.txt +++ b/Generals/Code/Main/CMakeLists.txt @@ -11,7 +11,6 @@ target_link_libraries(g_generals PRIVATE binkstub comctl32 d3d8 - d3dx8 dinput8 dxguid g_gameengine @@ -23,6 +22,11 @@ target_link_libraries(g_generals PRIVATE winmm ) +# Only link d3dx8 if NO_D3DX is not enabled +if(NOT (MINGW AND MINGW_NO_D3DX)) + target_link_libraries(g_generals PRIVATE d3dx8) +endif() + # TODO Originally referred to build host and user, replace with git info perhaps? file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/GeneratedVersion.h "#pragma once @@ -91,3 +95,8 @@ endif() if(MINGW AND COMMAND add_debug_strip_target) add_debug_strip_target(g_generals) endif() + +# Verify no D3DX8 DLL dependency when NO_D3DX is enabled +if(MINGW AND COMMAND add_no_d3dx_verification) + add_no_d3dx_verification(g_generals) +endif() diff --git a/GeneralsMD/Code/GameEngine/CMakeLists.txt b/GeneralsMD/Code/GameEngine/CMakeLists.txt index b9be6228a4..6b7a94da38 100644 --- a/GeneralsMD/Code/GameEngine/CMakeLists.txt +++ b/GeneralsMD/Code/GameEngine/CMakeLists.txt @@ -1178,3 +1178,8 @@ target_precompile_headers(z_gameengine PRIVATE [["Utility/CppMacros.h"]] # Must be first, to be removed when abandoning VC6 Include/Precompiled/PreRTS.h ) + +# Apply D3DXWrapper forced include for NO_D3DX builds +if(MINGW AND DEFINED MINGW_D3DX_WRAPPER_INCLUDE) + target_compile_options(z_gameengine PRIVATE ${MINGW_D3DX_WRAPPER_INCLUDE}) +endif() diff --git a/GeneralsMD/Code/GameEngineDevice/CMakeLists.txt b/GeneralsMD/Code/GameEngineDevice/CMakeLists.txt index db9be4f3cd..66cc73376a 100644 --- a/GeneralsMD/Code/GameEngineDevice/CMakeLists.txt +++ b/GeneralsMD/Code/GameEngineDevice/CMakeLists.txt @@ -221,3 +221,8 @@ target_link_libraries(z_gameenginedevice PUBLIC corei_gameenginedevice_public z_gameengine ) + +# Apply D3DXWrapper forced include for NO_D3DX builds +if(MINGW AND DEFINED MINGW_D3DX_WRAPPER_INCLUDE) + target_compile_options(z_gameenginedevice PRIVATE ${MINGW_D3DX_WRAPPER_INCLUDE}) +endif() diff --git a/GeneralsMD/Code/Main/CMakeLists.txt b/GeneralsMD/Code/Main/CMakeLists.txt index d6518f442b..c9f61772ae 100644 --- a/GeneralsMD/Code/Main/CMakeLists.txt +++ b/GeneralsMD/Code/Main/CMakeLists.txt @@ -13,7 +13,6 @@ target_link_libraries(z_generals PRIVATE core_debug core_profile d3d8 - d3dx8 dinput8 dxguid imm32 @@ -25,6 +24,11 @@ target_link_libraries(z_generals PRIVATE zi_always ) +# Only link d3dx8 if NO_D3DX is not enabled +if(NOT (MINGW AND MINGW_NO_D3DX)) + target_link_libraries(z_generals PRIVATE d3dx8) +endif() + # TODO Originally referred to build host and user, replace with git info perhaps? file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/GeneratedVersion.h "#pragma once @@ -80,3 +84,8 @@ endif() if(MINGW AND COMMAND add_debug_strip_target) add_debug_strip_target(z_generals) endif() + +# Verify no D3DX8 DLL dependency when NO_D3DX is enabled +if(MINGW AND COMMAND add_no_d3dx_verification) + add_no_d3dx_verification(z_generals) +endif() diff --git a/cmake/dx8.cmake b/cmake/dx8.cmake index dd08f56119..6de0f03e53 100644 --- a/cmake/dx8.cmake +++ b/cmake/dx8.cmake @@ -5,3 +5,21 @@ FetchContent_Declare( ) FetchContent_MakeAvailable(dx8) + +# When NO_D3DX is enabled, remove d3dx8d from d3d8lib link libraries +if(MINGW AND DEFINED MINGW_NO_D3DX AND MINGW_NO_D3DX) + # Get current link libraries from d3d8lib + get_target_property(DX8_LINK_LIBS d3d8lib INTERFACE_LINK_LIBRARIES) + + if(DX8_LINK_LIBS) + # Remove d3dx8d from the list + list(REMOVE_ITEM DX8_LINK_LIBS d3dx8d) + + # Set the updated list back + set_target_properties(d3d8lib PROPERTIES + INTERFACE_LINK_LIBRARIES "${DX8_LINK_LIBS}" + ) + + message(STATUS "Removed d3dx8d from d3d8lib link libraries (NO_D3DX)") + endif() +endif() diff --git a/cmake/mingw.cmake b/cmake/mingw.cmake index c095343055..8b33d2ef79 100644 --- a/cmake/mingw.cmake +++ b/cmake/mingw.cmake @@ -74,17 +74,44 @@ if(MINGW) # are provided by Dependencies/Utility/Utility/comsupp_compat.h as header-only # implementations. No library linking required. - # MinGW-w64 compatibility: Create d3dx8 as an alias to d3dx8d - # MinGW-w64 only provides libd3dx8d.a (debug library), not libd3dx8.a - # The min-dx8-sdk (dx8.cmake) handles this correctly via d3d8lib interface target, - # but for compatibility with direct library references in main executables, - # we create an alias so that linking to d3dx8 automatically uses d3dx8d - if(NOT TARGET d3dx8) - add_library(d3dx8 INTERFACE IMPORTED GLOBAL) - set_target_properties(d3dx8 PROPERTIES - INTERFACE_LINK_LIBRARIES "d3dx8d" - ) - message(STATUS "Created d3dx8 -> d3dx8d alias for MinGW-w64") + # MinGW-w64 D3DX8 dependency elimination option + # Header conflicts resolved using include guard coordination (Option A) + # D3DXCompat.h pre-defines min-dx8-sdk include guards to prevent redefinitions + option(MINGW_NO_D3DX "Eliminate D3DX8.dll dependency using WWMath compatibility layer" ON) + + if(MINGW_NO_D3DX) + # Use compatibility layer + add_compile_definitions(NO_D3DX) + + # Force include our D3DX compatibility wrapper in project files only + # (Not in external dependencies like lzhl, gamespy, etc.) + # This ensures all D3DX calls go through our replacement layer + # Note: Will be applied selectively to targets that need it + set(MINGW_D3DX_WRAPPER_INCLUDE "-include;${CMAKE_SOURCE_DIR}/Core/Libraries/Include/Lib/D3DXWrapper.h") + + message(STATUS "MinGW: D3DX8 dependency eliminated (NO_D3DX enabled)") + message(STATUS " Using WWMath library for math functions") + message(STATUS " Using Direct3D 8 API for texture operations") + message(STATUS " D3DXWrapper.h available for selective inclusion") + + # Don't link d3dx8 or d3dx8d + # (The compatibility header provides replacements) + else() + # Legacy behavior: use D3DX8 with DLL dependency + message(STATUS "MinGW: Using D3DX8.dll (NO_D3DX disabled)") + + # MinGW-w64 compatibility: Create d3dx8 as an alias to d3dx8d + # MinGW-w64 only provides libd3dx8d.a (debug library), not libd3dx8.a + # The min-dx8-sdk (dx8.cmake) handles this correctly via d3d8lib interface target, + # but for compatibility with direct library references in main executables, + # we create an alias so that linking to d3dx8 automatically uses d3dx8d + if(NOT TARGET d3dx8) + add_library(d3dx8 INTERFACE IMPORTED GLOBAL) + set_target_properties(d3dx8 PROPERTIES + INTERFACE_LINK_LIBRARIES "d3dx8d" + ) + message(STATUS "Created d3dx8 -> d3dx8d alias for MinGW-w64") + endif() endif() message(STATUS "MinGW-w64 configuration complete") diff --git a/cmake/no_d3dx_verify.cmake b/cmake/no_d3dx_verify.cmake new file mode 100644 index 0000000000..e8efae5a4e --- /dev/null +++ b/cmake/no_d3dx_verify.cmake @@ -0,0 +1,46 @@ +# D3DX Dependency Verification for NO_D3DX builds +# +# Verifies that when NO_D3DX is enabled, executables have no d3dx8*.dll imports. +# This ensures the compatibility layer is working correctly. + +if(MINGW AND MINGW_NO_D3DX) + # Find objdump tool for checking DLL imports + find_program(MINGW_OBJDUMP + NAMES ${CMAKE_CXX_COMPILER_TARGET}-objdump + ${CMAKE_SYSTEM_PROCESSOR}-w64-mingw32-objdump + objdump + DOC "MinGW objdump tool for verifying DLL imports" + ) + + if(MINGW_OBJDUMP) + message(STATUS "D3DX elimination verification enabled:") + message(STATUS " objdump: ${MINGW_OBJDUMP}") + set(NO_D3DX_VERIFY_AVAILABLE TRUE) + else() + message(WARNING "D3DX verification not available - objdump not found") + set(NO_D3DX_VERIFY_AVAILABLE FALSE) + endif() + + # Function to add D3DX verification to a target + # + # Checks that the built executable does not import d3dx8*.dll + # Fails the build if D3DX dependency is detected + # + # Usage: + # add_no_d3dx_verification(target_name) + # + function(add_no_d3dx_verification target_name) + if(NOT NO_D3DX_VERIFY_AVAILABLE) + return() + endif() + + add_custom_command(TARGET ${target_name} POST_BUILD + COMMAND bash -c + "${MINGW_OBJDUMP} -p $ | grep -i 'd3dx8' && echo 'ERROR: D3DX8 DLL dependency detected! NO_D3DX failed.' && exit 1 || echo 'SUCCESS: No D3DX8 DLL dependency (NO_D3DX working)'" + COMMENT "Verifying no D3DX8 dependency in ${target_name}" + VERBATIM + ) + + message(STATUS "D3DX elimination verification configured for target: ${target_name}") + endfunction() +endif() diff --git a/scripts/compile_shaders.py b/scripts/compile_shaders.py new file mode 100755 index 0000000000..0c69acf8c3 --- /dev/null +++ b/scripts/compile_shaders.py @@ -0,0 +1,233 @@ +#!/usr/bin/env python3 +""" +Pixel Shader 1.1 Assembler - Generates C++ header with precompiled shader bytecode + +This script assembles DirectX 8 Pixel Shader 1.1 assembly code into bytecode +and generates a C++ header file that can be included in the project. + +Usage: python3 compile_shaders.py [shader2.psh ...] + +Note: This is a simple PS 1.1 assembler that handles the basic instructions +used in the water shaders. For D3D8 ps.1.1 format. +""" + +import sys +import struct +import re +from pathlib import Path + +# PS 1.1 instruction opcodes (D3D8 format) +PS_OPCODES = { + 'tex': 0x42, # TEX instruction + 'texbem': 0x43, # TEXBEM instruction + 'mul': 0x05, # MUL instruction + 'add': 0x03, # ADD instruction + 'mad': 0x04, # MAD instruction (multiply-add) +} + +# Register types +REG_TEMP = 0 # r0-r7 (temporary registers) +REG_INPUT = 1 # v0-v1 (input color registers) +REG_CONST = 2 # c0-c7 (constant registers) +REG_TEXTURE = 3 # t0-t3 (texture registers) + +def parse_register(reg_str): + """Parse a register string like 'r0', 'v0', 't0', 'c0' and return (type, index, write_mask)""" + reg_str = reg_str.strip() + + # Handle write masks like r0.rgb, r0.a + write_mask = 0xF # Default: all components (xyzw / rgba) + if '.' in reg_str: + reg_part, mask_part = reg_str.split('.') + if mask_part == 'rgb': + write_mask = 0x7 # xyz only + elif mask_part == 'a': + write_mask = 0x8 # w only + elif mask_part == 'rgba': + write_mask = 0xF # all + reg_str = reg_part + + reg_type = reg_str[0] + reg_index = int(reg_str[1:]) + + type_map = {'r': REG_TEMP, 'v': REG_INPUT, 'c': REG_CONST, 't': REG_TEXTURE} + return (type_map[reg_type], reg_index, write_mask) + +def encode_register(reg_type, reg_index, write_mask=0xF): + """Encode a register into D3D8 format""" + # Simple encoding: type in upper bits, index in lower bits + # This is a simplified version - actual D3D8 encoding is more complex + return (write_mask << 16) | (reg_type << 8) | reg_index + +def assemble_instruction(line): + """Assemble a single PS 1.1 instruction into bytecode""" + line = line.strip() + + # Skip empty lines and comments + if not line or line.startswith(';') or line.startswith('//'): + return [] + + # Handle co-issue (+instruction) + coissue = line.startswith('+') + if coissue: + line = line[1:].strip() + + # Split instruction and operands + parts = re.split(r'[,\s]+', line) + instr = parts[0].lower() + + # Handle version declaration + if instr == 'ps.1.1': + # PS 1.1 version token: 0xFFFF0101 + return [struct.pack('= 2: + reg_type, reg_idx, write_mask = parse_register(parts[1]) + bytecode.append(struct.pack('= 3: + dst_type, dst_idx, dst_mask = parse_register(parts[1]) + src_type, src_idx, src_mask = parse_register(parts[2]) + bytecode.append(struct.pack('= 4: + dst_type, dst_idx, dst_mask = parse_register(parts[1]) + src1_type, src1_idx, src1_mask = parse_register(parts[2]) + src2_type, src2_idx, src2_mask = parse_register(parts[3]) + bytecode.append(struct.pack('= 5: + dst_type, dst_idx, dst_mask = parse_register(parts[1]) + src1_type, src1_idx, src1_mask = parse_register(parts[2]) + src2_type, src2_idx, src2_mask = parse_register(parts[3]) + src3_type, src3_idx, src3_mask = parse_register(parts[4]) + bytecode.append(struct.pack(' + +namespace PrecompiledShaders {{ + +""") + + for i, shader_file in enumerate(shader_files, 1): + shader_name = Path(shader_file).stem + print(f"Assembling {shader_file}...") + + with open(shader_file, 'r') as sf: + shader_text = sf.read() + + bytecode = assemble_shader(shader_text) + + # Write bytecode array + f.write(f"// {shader_name} - from {Path(shader_file).name}\n") + f.write(f"constexpr DWORD {shader_name}_bytecode[] = {{\n") + + # Write bytecode as hex DWORDs + dwords = [bytecode[i:i+4] for i in range(0, len(bytecode), 4)] + for j, dword in enumerate(dwords): + if len(dword) == 4: + value = struct.unpack(' [shader2.psh ...]") + print("\nExample:") + print(" python3 compile_shaders.py shaders/water_shader1.psh shaders/water_shader2.psh shaders/water_shader3.psh") + sys.exit(1) + + shader_files = sys.argv[1:] + output_file = "PrecompiledShaders.h" + + # Verify all input files exist + for shader_file in shader_files: + if not Path(shader_file).exists(): + print(f"Error: Shader file '{shader_file}' not found") + sys.exit(1) + + generate_header(shader_files, output_file) + print(f"\nSuccess! Precompiled shaders written to {output_file}") + print("Include this header in your D3DXCompat.h or shader loading code.") + +if __name__ == '__main__': + main() diff --git a/scripts/shaders/water_shader1.psh b/scripts/shaders/water_shader1.psh new file mode 100644 index 0000000000..a8db099945 --- /dev/null +++ b/scripts/shaders/water_shader1.psh @@ -0,0 +1,10 @@ +ps.1.1 +tex t0 +tex t1 +tex t2 +tex t3 +mul r0,v0,t0 +mul r1, t1, t2 +add r0.rgb, r0, t3 ++mul r0.a, r0, t3 +add r0.rgb, r0, r1 diff --git a/scripts/shaders/water_shader2.psh b/scripts/shaders/water_shader2.psh new file mode 100644 index 0000000000..4a480efa59 --- /dev/null +++ b/scripts/shaders/water_shader2.psh @@ -0,0 +1,7 @@ +ps.1.1 +tex t0 +tex t1 +texbem t2, t1 +mul r0,v0,t0 +mul r1.rgb,t2,c0 +add r0.rgb, r0, r1 diff --git a/scripts/shaders/water_shader3.psh b/scripts/shaders/water_shader3.psh new file mode 100644 index 0000000000..19551f94e1 --- /dev/null +++ b/scripts/shaders/water_shader3.psh @@ -0,0 +1,8 @@ +ps.1.1 +tex t0 +tex t1 +tex t2 +tex t3 +mul r0,v0,t0 +mad r0.rgb, t1, t2, r0 +mul r0.rgb, r0, t3