RomanRom2/whoa
1
0
Fork 0
mirror of https://github.com/whoahq/whoa.git synced 2026-03-18 05:31:07 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity
0c0c936874
whoa/src/gx/mtl/CGxDeviceMTL.mm

1856 lines
68 KiB
Plaintext
Raw Blame History

#include "gx/mtl/CGxDeviceMTL.hpp"
#include "app/mac/View.h"
#include "gx/Buffer.hpp"
#include "gx/CGxBatch.hpp"
#include "gx/Window.hpp"
#include "gx/texture/CGxTex.hpp"
#include "math/Utils.hpp"
#include "util/Autorelease.hpp"
#include <storm/Memory.hpp>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#import <AppKit/AppKit.h>
#import <Metal/Metal.h>
#import <QuartzCore/CAMetalLayer.h>
namespace {
MTLPrimitiveType MtlPrimitiveType(EGxPrim prim) {
switch (prim) {
case GxPrim_Points:
return MTLPrimitiveTypePoint;
case GxPrim_Lines:
return MTLPrimitiveTypeLine;
case GxPrim_LineStrip:
return MTLPrimitiveTypeLineStrip;
case GxPrim_Triangles:
return MTLPrimitiveTypeTriangle;
case GxPrim_TriangleStrip:
return MTLPrimitiveTypeTriangleStrip;
case GxPrim_TriangleFan:
return MTLPrimitiveTypeTriangle;
default:
return MTLPrimitiveTypeTriangle;
}
}
bool GxTexIsCompressed(EGxTexFormat format) {
return format == GxTex_Dxt1 || format == GxTex_Dxt3 || format == GxTex_Dxt5;
}
MTLPixelFormat MtlPixelFormatForGx(EGxTexFormat format) {
// Note: GxTex format names describe the packed 32-bit value layout (MSB to LSB).
// On little-endian, this means the byte order in memory is reversed.
// Metal pixel formats describe byte order in memory.
// GxTex_Argb8888: packed as 0xAARRGGBB, bytes in memory: BB GG RR AA -> use BGRA
// GxTex_Abgr8888: packed as 0xAABBGGRR, bytes in memory: RR GG BB AA -> use RGBA
switch (format) {
case GxTex_Abgr8888:
return MTLPixelFormatRGBA8Unorm;
case GxTex_Argb8888:
return MTLPixelFormatBGRA8Unorm;
case GxTex_Argb4444:
// Convert ARGB4444 to RGBA8 during upload for simpler handling
return MTLPixelFormatRGBA8Unorm;
case GxTex_Argb1555:
return MTLPixelFormatBGR5A1Unorm;
case GxTex_Rgb565:
return MTLPixelFormatB5G6R5Unorm;
case GxTex_Dxt1:
return MTLPixelFormatBC1_RGBA;
case GxTex_Dxt3:
return MTLPixelFormatBC2_RGBA;
case GxTex_Dxt5:
return MTLPixelFormatBC3_RGBA;
case GxTex_Uv88:
return MTLPixelFormatRG8Unorm;
case GxTex_Gr1616F:
return MTLPixelFormatRG16Float;
case GxTex_R32F:
return MTLPixelFormatR32Float;
default:
return MTLPixelFormatInvalid;
}
}
MTLBlendFactor MtlBlendFactorForSrc(EGxBlend blend) {
switch (blend) {
case GxBlend_Alpha:
case GxBlend_Add:
case GxBlend_SrcAlphaOpaque:
return MTLBlendFactorSourceAlpha;
case GxBlend_Mod:
case GxBlend_Mod2x:
case GxBlend_ModAdd:
return MTLBlendFactorDestinationColor;
case GxBlend_InvSrcAlphaAdd:
case GxBlend_InvSrcAlphaOpaque:
return MTLBlendFactorOneMinusSourceAlpha;
case GxBlend_NoAlphaAdd:
case GxBlend_Opaque:
case GxBlend_AlphaKey:
return MTLBlendFactorOne;
case GxBlend_ConstantAlpha:
return MTLBlendFactorBlendAlpha;
default:
return MTLBlendFactorOne;
}
}
MTLBlendFactor MtlBlendFactorForDst(EGxBlend blend) {
switch (blend) {
case GxBlend_Alpha:
return MTLBlendFactorOneMinusSourceAlpha;
case GxBlend_Add:
case GxBlend_ModAdd:
case GxBlend_InvSrcAlphaAdd:
case GxBlend_NoAlphaAdd:
case GxBlend_ConstantAlpha:
return MTLBlendFactorOne;
case GxBlend_Mod:
return MTLBlendFactorZero;
case GxBlend_Mod2x:
return MTLBlendFactorSourceColor;
case GxBlend_InvSrcAlphaOpaque:
case GxBlend_SrcAlphaOpaque:
case GxBlend_Opaque:
case GxBlend_AlphaKey:
return MTLBlendFactorZero;
default:
return MTLBlendFactorZero;
}
}
void ApplyViewport(CGxDeviceMTL* device, id<MTLRenderCommandEncoder> encoder, id<MTLTexture> texture) {
const double width = texture.width;
const double height = texture.height;
double x = (device->m_viewport.x.l * width) + 0.5;
double y = ((1.0 - device->m_viewport.y.h) * height) + 0.5;
double w = (device->m_viewport.x.h * width) - x + 0.5;
double h = ((1.0 - device->m_viewport.y.l) * height) - y + 0.5;
if (w < 0.0) {
w = 0.0;
}
if (h < 0.0) {
h = 0.0;
}
MTLViewport viewport = { x, y, w, h, device->m_viewport.z.l, device->m_viewport.z.h };
[encoder setViewport:viewport];
NSUInteger sx = x < 0.0 ? 0 : static_cast<NSUInteger>(x);
NSUInteger sy = y < 0.0 ? 0 : static_cast<NSUInteger>(y);
NSUInteger sw = static_cast<NSUInteger>(w);
NSUInteger sh = static_cast<NSUInteger>(h);
if (sx > texture.width) {
sx = texture.width;
}
if (sy > texture.height) {
sy = texture.height;
}
if (sx + sw > texture.width) {
sw = texture.width - sx;
}
if (sy + sh > texture.height) {
sh = texture.height - sy;
}
MTLScissorRect scissor = { sx, sy, sw, sh };
[encoder setScissorRect:scissor];
device->intF6C = 0;
}
const char kMetalShaderSource[] =
"#include <metal_stdlib>\n"
"using namespace metal;\n"
"struct VertexColorIn {\n"
" float3 position [[attribute(0)]];\n"
" float4 color [[attribute(1)]];\n"
"};\n"
"struct VertexTexIn {\n"
" float3 position [[attribute(0)]];\n"
" float2 texcoord [[attribute(1)]];\n"
"};\n"
"struct VertexTex2In {\n"
" float3 position [[attribute(0)]];\n"
" float2 texcoord [[attribute(1)]];\n"
" float2 texcoord1 [[attribute(2)]];\n"
"};\n"
"struct VertexColorTexIn {\n"
" float3 position [[attribute(0)]];\n"
" float4 color [[attribute(1)]];\n"
" float2 texcoord [[attribute(2)]];\n"
"};\n"
"struct VertexColorTex2In {\n"
" float3 position [[attribute(0)]];\n"
" float4 color [[attribute(1)]];\n"
" float2 texcoord [[attribute(2)]];\n"
" float2 texcoord1 [[attribute(3)]];\n"
"};\n"
"struct VertexSolidIn {\n"
" float3 position [[attribute(0)]];\n"
"};\n"
"struct VertexSkinIn {\n"
" float3 position [[attribute(0)]];\n"
" float4 weights [[attribute(1)]];\n"
" uchar4 indices [[attribute(2)]];\n"
"};\n"
"struct VertexSkinTexIn {\n"
" float3 position [[attribute(0)]];\n"
" float4 weights [[attribute(1)]];\n"
" uchar4 indices [[attribute(2)]];\n"
" float2 texcoord [[attribute(3)]];\n"
"};\n"
"struct VertexSkinTex2In {\n"
" float3 position [[attribute(0)]];\n"
" float4 weights [[attribute(1)]];\n"
" uchar4 indices [[attribute(2)]];\n"
" float2 texcoord [[attribute(3)]];\n"
" float2 texcoord1 [[attribute(4)]];\n"
"};\n"
"struct VertexOut {\n"
" float4 position [[position]];\n"
" float pointSize [[point_size]];\n"
" float4 color;\n"
" float2 texcoord;\n"
" float2 texcoord1;\n"
" float viewZ;\n"
"};\n"
"struct PSConstants {\n"
" float alphaRef;\n"
" float fogStart;\n"
" float fogEnd;\n"
" float fogEnabled;\n"
" float4 color;\n"
" float4 fogColor;\n"
"};\n"
"struct VSConstants {\n"
" float4x4 mvp;\n"
" float pointSize;\n"
" float pad[3];\n"
"};\n"
"// Transform UV using texture matrix from vertex constants\n"
"// Texture matrix 0: vc[6] and vc[7] (2 rows for tex unit 0)\n"
"// Texture matrix 1: vc[8] and vc[9] (2 rows for tex unit 1)\n"
"float2 transformTexCoord(float2 uv, constant float4* vc, uint unit) {\n"
" uint base = 6 + unit * 2;\n"
" float4 row0 = vc[base];\n"
" float4 row1 = vc[base + 1];\n"
" // Check if matrix is uninitialized (identity placeholder)\n"
" if (row0.x > 1e30) return uv;\n"
" float4 uvw = float4(uv, 0.0, 1.0);\n"
" return float2(dot(uvw, row0), dot(uvw, row1));\n"
"}\n"
"vertex VertexOut vs_color(VertexColorIn in [[stage_in]], constant VSConstants& c [[buffer(1)]]) {\n"
" VertexOut out;\n"
" float4 pos4 = c.mvp * float4(in.position, 1.0);\n"
" out.position = pos4;\n"
" out.color = in.color;\n"
" out.texcoord = float2(0.0, 0.0);\n"
" out.texcoord1 = float2(0.0, 0.0);\n"
" out.viewZ = pos4.w;\n"
" out.pointSize = c.pointSize;\n"
" return out;\n"
"}\n"
"vertex VertexOut vs_tex(VertexTexIn in [[stage_in]], constant VSConstants& c [[buffer(1)]], constant float4* vc [[buffer(2)]]) {\n"
" VertexOut out;\n"
" float4 pos4 = c.mvp * float4(in.position, 1.0);\n"
" out.position = pos4;\n"
" out.color = float4(1.0, 1.0, 1.0, 1.0);\n"
" out.texcoord = transformTexCoord(in.texcoord, vc, 0);\n"
" out.texcoord1 = transformTexCoord(in.texcoord, vc, 1);\n"
" out.viewZ = pos4.w;\n"
" out.pointSize = c.pointSize;\n"
" return out;\n"
"}\n"
"vertex VertexOut vs_tex2(VertexTex2In in [[stage_in]], constant VSConstants& c [[buffer(1)]], constant float4* vc [[buffer(2)]]) {\n"
" VertexOut out;\n"
" float4 pos4 = c.mvp * float4(in.position, 1.0);\n"
" out.position = pos4;\n"
" out.color = float4(1.0, 1.0, 1.0, 1.0);\n"
" out.texcoord = transformTexCoord(in.texcoord, vc, 0);\n"
" out.texcoord1 = transformTexCoord(in.texcoord1, vc, 1);\n"
" out.viewZ = pos4.w;\n"
" out.pointSize = c.pointSize;\n"
" return out;\n"
"}\n"
"vertex VertexOut vs_color_tex(VertexColorTexIn in [[stage_in]], constant VSConstants& c [[buffer(1)]], constant float4* vc [[buffer(2)]]) {\n"
" VertexOut out;\n"
" float4 pos4 = c.mvp * float4(in.position, 1.0);\n"
" out.position = pos4;\n"
" out.color = in.color;\n"
" out.texcoord = transformTexCoord(in.texcoord, vc, 0);\n"
" out.texcoord1 = transformTexCoord(in.texcoord, vc, 1);\n"
" out.viewZ = pos4.w;\n"
" out.pointSize = c.pointSize;\n"
" return out;\n"
"}\n"
"vertex VertexOut vs_color_tex2(VertexColorTex2In in [[stage_in]], constant VSConstants& c [[buffer(1)]], constant float4* vc [[buffer(2)]]) {\n"
" VertexOut out;\n"
" float4 pos4 = c.mvp * float4(in.position, 1.0);\n"
" out.position = pos4;\n"
" out.color = in.color;\n"
" out.texcoord = transformTexCoord(in.texcoord, vc, 0);\n"
" out.texcoord1 = transformTexCoord(in.texcoord1, vc, 1);\n"
" out.viewZ = pos4.w;\n"
" out.pointSize = c.pointSize;\n"
" return out;\n"
"}\n"
"vertex VertexOut vs_solid(VertexSolidIn in [[stage_in]], constant VSConstants& c [[buffer(1)]]) {\n"
" VertexOut out;\n"
" float4 pos4 = c.mvp * float4(in.position, 1.0);\n"
" out.position = pos4;\n"
" out.color = float4(1.0, 1.0, 1.0, 1.0);\n"
" out.texcoord = float2(0.0, 0.0);\n"
" out.texcoord1 = float2(0.0, 0.0);\n"
" out.viewZ = pos4.w;\n"
" out.pointSize = c.pointSize;\n"
" return out;\n"
"}\n"
"vertex VertexOut vs_skin(VertexSkinIn in [[stage_in]], constant VSConstants& c [[buffer(1)]], constant float4* vc [[buffer(2)]]) {\n"
" VertexOut out;\n"
" float4 pos = float4(in.position, 1.0);\n"
" float4 w = in.weights;\n"
" uint4 idx = uint4(in.indices);\n"
" float3 skinned = float3(0.0);\n"
" for (uint i = 0; i < 4; ++i) {\n"
" uint base = 31 + idx[i] * 3;\n"
" float4 c0 = vc[base + 0];\n"
" float4 c1 = vc[base + 1];\n"
" float4 c2 = vc[base + 2];\n"
" float3 p;\n"
" p.x = dot(pos, c0);\n"
" p.y = dot(pos, c1);\n"
" p.z = dot(pos, c2);\n"
" skinned += p * w[i];\n"
" }\n"
" float4 pos4 = c.mvp * float4(skinned, 1.0);\n"
" out.position = pos4;\n"
" // Read diffuse (vc[28]) and emissive (vc[29]) for color animation\n"
" float4 diffuse = vc[28];\n"
" float4 emissive = vc[29];\n"
" float4 color = diffuse + emissive;\n"
" out.color = (diffuse.x > 1e30) ? float4(1.0, 1.0, 1.0, 1.0) : color;\n"
" out.texcoord = float2(0.0, 0.0);\n"
" out.texcoord1 = float2(0.0, 0.0);\n"
" out.viewZ = pos4.w;\n"
" out.pointSize = c.pointSize;\n"
" return out;\n"
"}\n"
"vertex VertexOut vs_skin_tex(VertexSkinTexIn in [[stage_in]], constant VSConstants& c [[buffer(1)]], constant float4* vc [[buffer(2)]]) {\n"
" VertexOut out;\n"
" float4 pos = float4(in.position, 1.0);\n"
" float4 w = in.weights;\n"
" uint4 idx = uint4(in.indices);\n"
" float3 skinned = float3(0.0);\n"
" for (uint i = 0; i < 4; ++i) {\n"
" uint base = 31 + idx[i] * 3;\n"
" float4 c0 = vc[base + 0];\n"
" float4 c1 = vc[base + 1];\n"
" float4 c2 = vc[base + 2];\n"
" float3 p;\n"
" p.x = dot(pos, c0);\n"
" p.y = dot(pos, c1);\n"
" p.z = dot(pos, c2);\n"
" skinned += p * w[i];\n"
" }\n"
" float4 pos4 = c.mvp * float4(skinned, 1.0);\n"
" out.position = pos4;\n"
" // Read diffuse (vc[28]) and emissive (vc[29]) for color animation\n"
" float4 diffuse = vc[28];\n"
" float4 emissive = vc[29];\n"
" float4 color = diffuse + emissive;\n"
" out.color = (diffuse.x > 1e30) ? float4(1.0, 1.0, 1.0, 1.0) : color;\n"
" out.texcoord = transformTexCoord(in.texcoord, vc, 0);\n"
" out.texcoord1 = transformTexCoord(in.texcoord, vc, 1);\n"
" out.viewZ = pos4.w;\n"
" out.pointSize = c.pointSize;\n"
" return out;\n"
"}\n"
"vertex VertexOut vs_skin_tex2(VertexSkinTex2In in [[stage_in]], constant VSConstants& c [[buffer(1)]], constant float4* vc [[buffer(2)]]) {\n"
" VertexOut out;\n"
" float4 pos = float4(in.position, 1.0);\n"
" float4 w = in.weights;\n"
" uint4 idx = uint4(in.indices);\n"
" float3 skinned = float3(0.0);\n"
" for (uint i = 0; i < 4; ++i) {\n"
" uint base = 31 + idx[i] * 3;\n"
" float4 c0 = vc[base + 0];\n"
" float4 c1 = vc[base + 1];\n"
" float4 c2 = vc[base + 2];\n"
" float3 p;\n"
" p.x = dot(pos, c0);\n"
" p.y = dot(pos, c1);\n"
" p.z = dot(pos, c2);\n"
" skinned += p * w[i];\n"
" }\n"
" float4 pos4 = c.mvp * float4(skinned, 1.0);\n"
" out.position = pos4;\n"
" // Read diffuse (vc[28]) and emissive (vc[29]) for color animation\n"
" float4 diffuse = vc[28];\n"
" float4 emissive = vc[29];\n"
" float4 color = diffuse + emissive;\n"
" out.color = (diffuse.x > 1e30) ? float4(1.0, 1.0, 1.0, 1.0) : color;\n"
" out.texcoord = transformTexCoord(in.texcoord, vc, 0);\n"
" out.texcoord1 = transformTexCoord(in.texcoord1, vc, 1);\n"
" out.viewZ = pos4.w;\n"
" out.pointSize = c.pointSize;\n"
" return out;\n"
"}\n"
"float4 applyFog(float4 color, float viewZ, constant PSConstants& ps) {\n"
" if (ps.fogEnabled > 0.0 && ps.fogEnd > ps.fogStart) {\n"
" float fogFactor = saturate((ps.fogEnd - viewZ) / (ps.fogEnd - ps.fogStart));\n"
" color.rgb = mix(ps.fogColor.rgb, color.rgb, fogFactor);\n"
" }\n"
" return color;\n"
"}\n"
"fragment float4 ps_main(VertexOut in [[stage_in]], constant PSConstants& ps [[buffer(0)]]) {\n"
" float4 color = in.color * ps.color;\n"
" if (ps.alphaRef > 0.0 && color.a < ps.alphaRef) {\n"
" discard_fragment();\n"
" }\n"
" return applyFog(color, in.viewZ, ps);\n"
"}\n"
"fragment float4 ps_tex1(VertexOut in [[stage_in]], texture2d<float> tex0 [[texture(0)]], sampler samp0 [[sampler(0)]], constant PSConstants& ps [[buffer(0)]]) {\n"
" float4 color = tex0.sample(samp0, in.texcoord) * in.color * ps.color;\n"
" if (ps.alphaRef > 0.0 && color.a < ps.alphaRef) {\n"
" discard_fragment();\n"
" }\n"
" return applyFog(color, in.viewZ, ps);\n"
"}\n"
"fragment float4 ps_tex(VertexOut in [[stage_in]], texture2d<float> tex0 [[texture(0)]], sampler samp0 [[sampler(0)]], texture2d<float> tex1 [[texture(1)]], sampler samp1 [[sampler(1)]], constant PSConstants& ps [[buffer(0)]]) {\n"
" float4 color = tex0.sample(samp0, in.texcoord) * tex1.sample(samp1, in.texcoord1) * in.color * ps.color;\n"
" if (ps.alphaRef > 0.0 && color.a < ps.alphaRef) {\n"
" discard_fragment();\n"
" }\n"
" return applyFog(color, in.viewZ, ps);\n"
"}\n";
}
CGxDeviceMTL::CGxDeviceMTL() : CGxDevice() {
this->m_api = GxApi_Metal;
this->m_caps.m_colorFormat = GxCF_rgba;
this->DeviceCreatePools();
this->DeviceCreateStreamBufs();
}
void CGxDeviceMTL::ITexMarkAsUpdated(CGxTex* texId) {
if (texId->m_needsFlagUpdate && texId->m_apiSpecificData2) {
auto sampler = (id<MTLSamplerState>)texId->m_apiSpecificData2;
[sampler release];
texId->m_apiSpecificData2 = nullptr;
}
if (texId->m_needsUpdate) {
if (texId->m_needsCreation || !texId->m_apiSpecificData) {
this->ITexCreate(texId);
}
if (!texId->m_needsCreation && texId->m_apiSpecificData && texId->m_userFunc) {
this->ITexUpload(texId);
}
CGxDevice::ITexMarkAsUpdated(texId);
}
}
void CGxDeviceMTL::IRsSendToHw(EGxRenderState which) {
auto* state = &this->m_appRenderStates[which];
switch (which) {
// Texture states - mark textures as needing update
case GxRs_Texture0:
case GxRs_Texture1:
case GxRs_Texture2:
case GxRs_Texture3:
case GxRs_Texture4:
case GxRs_Texture5:
case GxRs_Texture6:
case GxRs_Texture7:
case GxRs_Texture8:
case GxRs_Texture9:
case GxRs_Texture10:
case GxRs_Texture11:
case GxRs_Texture12:
case GxRs_Texture13:
case GxRs_Texture14:
case GxRs_Texture15: {
CGxTex* texture = static_cast<CGxTex*>(static_cast<void*>(state->m_value));
if (texture) {
this->ITexMarkAsUpdated(texture);
}
break;
}
// States handled at draw time - no immediate GPU action needed
case GxRs_BlendingMode:
case GxRs_AlphaRef:
case GxRs_DepthTest:
case GxRs_DepthFunc:
case GxRs_DepthWrite:
case GxRs_Culling:
case GxRs_Fog:
case GxRs_FogStart:
case GxRs_FogEnd:
case GxRs_FogColor:
case GxRs_Lighting:
case GxRs_VertexShader:
case GxRs_PixelShader:
case GxRs_ColorWrite:
case GxRs_ScissorTest:
// Metal applies these during Draw() call
break;
// States not yet implemented
case GxRs_PolygonOffset:
case GxRs_MatDiffuse:
case GxRs_MatEmissive:
case GxRs_MatSpecular:
case GxRs_MatSpecularExp:
case GxRs_NormalizeNormals:
case GxRs_ClipPlaneMask:
case GxRs_Multisample:
case GxRs_ColorOp0:
case GxRs_ColorOp1:
case GxRs_ColorOp2:
case GxRs_ColorOp3:
case GxRs_ColorOp4:
case GxRs_ColorOp5:
case GxRs_ColorOp6:
case GxRs_ColorOp7:
case GxRs_AlphaOp0:
case GxRs_AlphaOp1:
case GxRs_AlphaOp2:
case GxRs_AlphaOp3:
case GxRs_AlphaOp4:
case GxRs_AlphaOp5:
case GxRs_AlphaOp6:
case GxRs_AlphaOp7:
case GxRs_TexGen0:
case GxRs_TexGen1:
case GxRs_TexGen2:
case GxRs_TexGen3:
case GxRs_TexGen4:
case GxRs_TexGen5:
case GxRs_TexGen6:
case GxRs_TexGen7:
case GxRs_PointScale:
case GxRs_PointScaleAttenuation:
case GxRs_PointScaleMin:
case GxRs_PointScaleMax:
case GxRs_PointSprite:
case GxRs_ColorMaterial:
// Not implemented in Metal backend
break;
default:
// Unknown state
break;
}
}
int32_t CGxDeviceMTL::DeviceCreate(int32_t (*windowProc)(void* window, uint32_t message, uintptr_t wparam, intptr_t lparam), const CGxFormat& format) {
System_Autorelease::ScopedPool autorelease;
CGRect rect;
Rect* bounds;
Rect* zoomedBounds = GetSavedZoomedWindowBounds();
if (
zoomedBounds
&& zoomedBounds->bottom - zoomedBounds->top > 599
&& zoomedBounds->right - zoomedBounds->left > 799
) {
bounds = GetSavedZoomedWindowBounds();
} else {
bounds = GetSavedWindowBounds();
}
if (
bounds->bottom - bounds->top > 599
&& bounds->right - bounds->left > 799
) {
rect.origin.x = bounds->left;
rect.origin.y = bounds->top;
rect.size.width = bounds->right - bounds->left;
rect.size.height = bounds->bottom - bounds->top;
} else {
Rect newBounds = {
0,
0,
static_cast<int16_t>(std::floor((static_cast<float>(format.size.y) / static_cast<float>(format.size.x)) * 1024.0f)),
1024,
};
SetSavedWindowBounds(newBounds);
rect.origin.x = newBounds.left;
rect.origin.y = newBounds.top;
rect.size.width = newBounds.right;
rect.size.height = newBounds.bottom;
}
this->m_window.SetViewClass(GetEngineViewClass());
this->m_window.Init(rect, nullptr);
this->m_window.SetTitle("World of Warcraft");
this->m_window.CreateView();
id<MTLDevice> device = MTLCreateSystemDefaultDevice();
if (!device) {
return 0;
}
id<MTLCommandQueue> commandQueue = [device newCommandQueue];
if (!commandQueue) {
return 0;
}
NSView* view = this->m_window.GetNSView();
CAMetalLayer* layer = view ? (CAMetalLayer*)[view layer] : nil;
if (!layer) {
return 0;
}
layer.device = device;
layer.pixelFormat = MTLPixelFormatBGRA8Unorm;
layer.framebufferOnly = YES;
CGSize drawableSize = [view convertSizeToBacking:view.bounds.size];
layer.drawableSize = drawableSize;
this->m_device = device;
this->m_commandQueue = commandQueue;
this->m_layer = layer;
if (CGxDevice::DeviceCreate(windowProc, format)) {
auto callbacks = new GLWindowCallbacks();
AssignEngineViewCallbacks(callbacks);
this->m_window.SetCallbacks(callbacks);
this->m_window.Show();
this->ISetCaps(format);
this->m_context = 1;
this->ICursorCreate(format);
return 1;
}
return 0;
}
void CGxDeviceMTL::ISetCaps(const CGxFormat& format) {
(void)format;
this->m_caps.m_pixelCenterOnEdge = 1;
this->m_caps.m_texelCenterOnEdge = 1;
this->m_caps.m_colorFormat = GxCF_rgba;
this->m_caps.m_generateMipMaps = 1;
this->m_caps.int10 = 1;
this->m_caps.m_texFmt[GxTex_Dxt1] = 1;
this->m_caps.m_texFmt[GxTex_Dxt3] = 1;
this->m_caps.m_texFmt[GxTex_Dxt5] = 1;
this->m_caps.m_shaderTargets[GxSh_Vertex] = GxShVS_arbvp1;
this->m_caps.m_shaderTargets[GxSh_Pixel] = GxShPS_arbfp1;
this->m_caps.m_texFilterAnisotropic = 1;
this->m_caps.m_maxTexAnisotropy = 16;
for (int32_t i = 0; i < GxTexTargets_Last; ++i) {
this->m_caps.m_texTarget[i] = 1;
this->m_caps.m_texMaxSize[i] = 4096;
}
}
int32_t CGxDeviceMTL::DeviceSetFormat(const CGxFormat& format) {
CGxDevice::DeviceSetFormat(format);
CRect rect = { 0.0f, 0.0f, static_cast<float>(format.size.y), static_cast<float>(format.size.x) };
this->DeviceSetDefWindow(rect);
if (this->m_window.m_Window) {
this->m_window.Resize(format.size.x, format.size.y);
}
return 1;
}
void CGxDeviceMTL::EnsureLibrary() {
if (this->m_shaderLibrary || !this->m_device) {
return;
}
auto device = (id<MTLDevice>)this->m_device;
NSString* source = [[NSString alloc] initWithUTF8String:kMetalShaderSource];
NSError* error = nil;
id<MTLLibrary> library = [device newLibraryWithSource:source options:nil error:&error];
[source release];
if (!library) {
return;
}
this->m_shaderLibrary = library;
}
void* CGxDeviceMTL::GetPipeline(EGxVertexBufferFormat format, bool useColor, bool useSkin, bool useTex, int32_t blendMode) {
if (format >= GxVertexBufferFormats_Last || !this->m_device || !this->m_layer) {
return nullptr;
}
if (blendMode < 0 || blendMode >= GxBlends_Last) {
blendMode = GxBlend_Opaque;
}
this->EnsureLibrary();
if (!this->m_shaderLibrary) {
return nullptr;
}
auto device = (id<MTLDevice>)this->m_device;
auto layer = (CAMetalLayer*)this->m_layer;
auto library = (id<MTLLibrary>)this->m_shaderLibrary;
NSString* vsName = nil;
NSString* psName = nil;
bool hasPosition = false;
bool hasColor = false;
bool hasBlendWeight = false;
bool hasBlendIndices = false;
bool hasTex0 = false;
bool hasTex1 = false;
uint32_t posOffset = 0;
uint32_t colorOffset = 0;
uint32_t blendWeightOffset = 0;
uint32_t blendIndexOffset = 0;
uint32_t tex0Offset = 0;
uint32_t tex1Offset = 0;
auto& bufDesc = Buffer::s_vertexBufDesc[format];
for (uint32_t i = 0; i < bufDesc.attribCount; ++i) {
const auto& attrib = bufDesc.attribs[i];
if (attrib.attrib == GxVA_Position) {
posOffset = attrib.offset;
hasPosition = true;
} else if (attrib.attrib == GxVA_BlendWeight) {
blendWeightOffset = attrib.offset;
hasBlendWeight = true;
} else if (attrib.attrib == GxVA_BlendIndices) {
blendIndexOffset = attrib.offset;
hasBlendIndices = true;
} else if (attrib.attrib == GxVA_Color0) {
colorOffset = attrib.offset;
hasColor = true;
} else if (attrib.attrib == GxVA_TexCoord0) {
tex0Offset = attrib.offset;
hasTex0 = true;
} else if (attrib.attrib == GxVA_TexCoord1) {
tex1Offset = attrib.offset;
hasTex1 = true;
}
}
bool useTexPipeline = useTex && hasTex0;
bool useTex2Pipeline = useTexPipeline && hasTex1;
void* (*pipelineTable)[GxBlends_Last] = nullptr;
if (useSkin) {
if (useTex2Pipeline) {
pipelineTable = this->m_pipelineSkinTex2;
} else if (useTexPipeline) {
pipelineTable = this->m_pipelineSkinTex;
} else {
pipelineTable = this->m_pipelineSkin;
}
} else if (useColor) {
if (useTex2Pipeline) {
pipelineTable = this->m_pipelineColorTex2;
} else if (useTexPipeline) {
pipelineTable = this->m_pipelineColorTex;
} else {
pipelineTable = this->m_pipelineColor;
}
} else {
if (useTex2Pipeline) {
pipelineTable = this->m_pipelineSolidTex2;
} else if (useTexPipeline) {
pipelineTable = this->m_pipelineSolidTex;
} else {
pipelineTable = this->m_pipelineSolid;
}
}
if (pipelineTable[format][blendMode]) {
return pipelineTable[format][blendMode];
}
if (useSkin) {
if (useTex2Pipeline) {
vsName = @"vs_skin_tex2";
} else {
vsName = useTexPipeline ? @"vs_skin_tex" : @"vs_skin";
}
} else if (useColor) {
if (useTex2Pipeline) {
vsName = @"vs_color_tex2";
} else {
vsName = useTexPipeline ? @"vs_color_tex" : @"vs_color";
}
} else {
if (useTex2Pipeline) {
vsName = @"vs_tex2";
} else {
vsName = useTexPipeline ? @"vs_tex" : @"vs_solid";
}
}
// Select pixel shader based on texture usage:
// - ps_main: no textures
// - ps_tex1: single texture (tex0 only)
// - ps_tex: two textures (tex0 * tex1)
if (useTex2Pipeline) {
psName = @"ps_tex";
} else if (useTexPipeline) {
psName = @"ps_tex1";
} else {
psName = @"ps_main";
}
id<MTLFunction> vs = [library newFunctionWithName:vsName];
id<MTLFunction> ps = [library newFunctionWithName:psName];
if (!vs || !ps) {
if (vs) {
[vs release];
}
if (ps) {
[ps release];
}
return nullptr;
}
auto desc = [MTLRenderPipelineDescriptor new];
desc.vertexFunction = vs;
desc.fragmentFunction = ps;
desc.colorAttachments[0].pixelFormat = layer.pixelFormat;
desc.depthAttachmentPixelFormat = MTLPixelFormatDepth32Float;
auto vdesc = [MTLVertexDescriptor vertexDescriptor];
if (!hasPosition || (useColor && !hasColor) || (useSkin && (!hasBlendWeight || !hasBlendIndices)) || (useTexPipeline && !hasTex0) || (useTex2Pipeline && !hasTex1)) {
[desc release];
[vs release];
[ps release];
return nullptr;
}
vdesc.attributes[0].format = MTLVertexFormatFloat3;
vdesc.attributes[0].offset = posOffset;
vdesc.attributes[0].bufferIndex = 0;
if (useSkin) {
vdesc.attributes[1].format = MTLVertexFormatUChar4Normalized;
vdesc.attributes[1].offset = blendWeightOffset;
vdesc.attributes[1].bufferIndex = 0;
vdesc.attributes[2].format = MTLVertexFormatUChar4;
vdesc.attributes[2].offset = blendIndexOffset;
vdesc.attributes[2].bufferIndex = 0;
if (useTexPipeline) {
vdesc.attributes[3].format = MTLVertexFormatFloat2;
vdesc.attributes[3].offset = tex0Offset;
vdesc.attributes[3].bufferIndex = 0;
if (useTex2Pipeline) {
vdesc.attributes[4].format = MTLVertexFormatFloat2;
vdesc.attributes[4].offset = tex1Offset;
vdesc.attributes[4].bufferIndex = 0;
}
}
} else if (useColor) {
vdesc.attributes[1].format = MTLVertexFormatUChar4Normalized;
vdesc.attributes[1].offset = colorOffset;
vdesc.attributes[1].bufferIndex = 0;
if (useTexPipeline) {
vdesc.attributes[2].format = MTLVertexFormatFloat2;
vdesc.attributes[2].offset = tex0Offset;
vdesc.attributes[2].bufferIndex = 0;
if (useTex2Pipeline) {
vdesc.attributes[3].format = MTLVertexFormatFloat2;
vdesc.attributes[3].offset = tex1Offset;
vdesc.attributes[3].bufferIndex = 0;
}
}
} else if (useTexPipeline) {
vdesc.attributes[1].format = MTLVertexFormatFloat2;
vdesc.attributes[1].offset = tex0Offset;
vdesc.attributes[1].bufferIndex = 0;
if (useTex2Pipeline) {
vdesc.attributes[2].format = MTLVertexFormatFloat2;
vdesc.attributes[2].offset = tex1Offset;
vdesc.attributes[2].bufferIndex = 0;
}
}
vdesc.layouts[0].stride = bufDesc.size;
vdesc.layouts[0].stepFunction = MTLVertexStepFunctionPerVertex;
vdesc.layouts[0].stepRate = 1;
desc.vertexDescriptor = vdesc;
bool enableBlend = blendMode > GxBlend_AlphaKey;
desc.colorAttachments[0].blendingEnabled = enableBlend ? YES : NO;
if (enableBlend) {
desc.colorAttachments[0].rgbBlendOperation = MTLBlendOperationAdd;
desc.colorAttachments[0].alphaBlendOperation = MTLBlendOperationAdd;
desc.colorAttachments[0].sourceRGBBlendFactor = MtlBlendFactorForSrc(static_cast<EGxBlend>(blendMode));
desc.colorAttachments[0].destinationRGBBlendFactor = MtlBlendFactorForDst(static_cast<EGxBlend>(blendMode));
desc.colorAttachments[0].sourceAlphaBlendFactor = desc.colorAttachments[0].sourceRGBBlendFactor;
desc.colorAttachments[0].destinationAlphaBlendFactor = desc.colorAttachments[0].destinationRGBBlendFactor;
}
// ColorWrite is applied via writeMask; for now set all channels enabled.
// A full implementation would need separate pipelines per write mask value.
desc.colorAttachments[0].writeMask = MTLColorWriteMaskAll;
NSError* error = nil;
id<MTLRenderPipelineState> pipeline = [device newRenderPipelineStateWithDescriptor:desc error:&error];
[desc release];
[vs release];
[ps release];
if (!pipeline) {
return nullptr;
}
pipelineTable[format][blendMode] = pipeline;
return pipeline;
}
void* CGxDeviceMTL::GetPoolBuffer(CGxPool* pool) {
if (!pool || !this->m_device) {
return nullptr;
}
auto device = (id<MTLDevice>)this->m_device;
auto buffer = (id<MTLBuffer>)pool->m_apiSpecific;
if (!pool->m_mem) {
pool->m_mem = SMemAlloc(pool->m_size, __FILE__, __LINE__, 0x0);
}
if (!buffer || buffer.length < static_cast<NSUInteger>(pool->m_size)) {
if (buffer) {
[buffer release];
}
buffer = [device newBufferWithBytesNoCopy:pool->m_mem
length:pool->m_size
options:MTLResourceStorageModeShared
deallocator:nil];
pool->m_apiSpecific = buffer;
}
return buffer;
}
void CGxDeviceMTL::BeginFrame() {
if (this->m_frameEncoder || !this->m_device || !this->m_commandQueue || !this->m_layer) {
return;
}
auto commandQueue = (id<MTLCommandQueue>)this->m_commandQueue;
auto layer = (CAMetalLayer*)this->m_layer;
id<CAMetalDrawable> drawable = [layer nextDrawable];
if (!drawable) {
return;
}
const bool clearRequested = (this->m_clearMask & 0x1) != 0;
const uint8_t r = (this->m_clearColor >> 16) & 0xFF;
const uint8_t g = (this->m_clearColor >> 8) & 0xFF;
const uint8_t b = this->m_clearColor & 0xFF;
const uint8_t a = (this->m_clearColor >> 24) & 0xFF;
auto pass = [MTLRenderPassDescriptor renderPassDescriptor];
pass.colorAttachments[0].texture = drawable.texture;
pass.colorAttachments[0].loadAction = MTLLoadActionClear;
pass.colorAttachments[0].storeAction = MTLStoreActionStore;
pass.colorAttachments[0].clearColor = MTLClearColorMake(
clearRequested ? r / 255.0f : 0.0f,
clearRequested ? g / 255.0f : 0.0f,
clearRequested ? b / 255.0f : 0.0f,
clearRequested ? a / 255.0f : 1.0f
);
this->EnsureDepthTexture(drawable.texture.width, drawable.texture.height);
if (this->m_depthTexture) {
auto depthTex = (id<MTLTexture>)this->m_depthTexture;
pass.depthAttachment.texture = depthTex;
pass.depthAttachment.loadAction = (this->m_clearMask & 0x2) ? MTLLoadActionClear : MTLLoadActionLoad;
pass.depthAttachment.storeAction = MTLStoreActionStore;
pass.depthAttachment.clearDepth = 1.0;
}
id<MTLCommandBuffer> commandBuffer = [commandQueue commandBuffer];
id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:pass];
ApplyViewport(this, encoder, drawable.texture);
this->m_frameCommandBuffer = commandBuffer;
this->m_frameEncoder = encoder;
this->m_frameDrawable = drawable;
this->m_frameHasDraw = 0;
}
void* CGxDeviceMTL::DeviceWindow() {
return &this->m_window;
}
void CGxDeviceMTL::CapsWindowSize(CRect& rect) {
CRect windowRect = this->DeviceCurWindow();
rect.minX = windowRect.minX;
rect.minY = windowRect.minY;
rect.maxX = windowRect.maxX;
rect.maxY = windowRect.maxY;
}
void CGxDeviceMTL::CapsWindowSizeInScreenCoords(CRect& dst) {
if (this->IDevIsWindowed()) {
auto windowRect = this->DeviceCurWindow();
auto deviceRect = this->m_window.GetRect();
dst.minX = windowRect.minX + deviceRect.origin.x;
dst.maxX = windowRect.maxX + deviceRect.origin.x;
dst.minY = windowRect.minY + deviceRect.origin.y;
dst.maxY = windowRect.maxY + deviceRect.origin.y;
} else {
dst = this->DeviceCurWindow();
}
}
void CGxDeviceMTL::SceneClear(uint32_t mask, CImVector color) {
CGxDevice::SceneClear(mask, color);
if (!this->m_context) {
return;
}
this->m_clearMask = mask;
this->m_clearColor = color.value;
}
void CGxDeviceMTL::ScenePresent() {
if (!this->m_context) {
return;
}
System_Autorelease::ScopedPool autorelease;
if (!this->m_frameEncoder) {
this->BeginFrame();
}
if (!this->m_frameEncoder || !this->m_frameCommandBuffer || !this->m_frameDrawable) {
return;
}
auto encoder = (id<MTLRenderCommandEncoder>)this->m_frameEncoder;
if (this->intF6C) {
auto drawable = (id<CAMetalDrawable>)this->m_frameDrawable;
ApplyViewport(this, encoder, drawable.texture);
}
auto commandBuffer = (id<MTLCommandBuffer>)this->m_frameCommandBuffer;
auto drawable = (id<CAMetalDrawable>)this->m_frameDrawable;
[encoder endEncoding];
[commandBuffer presentDrawable:drawable];
[commandBuffer commit];
this->m_frameCommandBuffer = nullptr;
this->m_frameEncoder = nullptr;
this->m_frameDrawable = nullptr;
}
void CGxDeviceMTL::Draw(CGxBatch* batch, int32_t indexed) {
if (!this->m_context || !batch) {
return;
}
this->BeginFrame();
if (!this->m_frameEncoder) {
return;
}
auto encoder = (id<MTLRenderCommandEncoder>)this->m_frameEncoder;
auto vertexBuf = this->m_primVertexFormatBuf[GxVA_Position];
if (!vertexBuf) {
return;
}
// Check ColorWrite - skip rendering if completely disabled
int32_t colorWrite = static_cast<int32_t>(this->m_appRenderStates[GxRs_ColorWrite].m_value);
bool colorWriteEnabled = this->MasterEnable(GxMasterEnable_ColorWrite);
if (!colorWriteEnabled || colorWrite == 0) {
return; // No color channels will be written
}
bool useColor = (this->m_primVertexMask & GxPrim_Color0) != 0;
bool useSkin = this->m_primVertexFormat == GxVBF_PBNT2;
bool useTex = false;
// Check for texture coordinates in two ways:
// 1. Standard vertex buffer format - check buffer descriptor
// 2. Custom vertex format (m_primVertexFormat == Last) - check m_primVertexMask
if (this->m_primVertexFormat < GxVertexBufferFormats_Last) {
const auto& bufDesc = Buffer::s_vertexBufDesc[this->m_primVertexFormat];
for (uint32_t i = 0; i < bufDesc.attribCount; ++i) {
if (bufDesc.attribs[i].attrib == GxVA_TexCoord0) {
useTex = true;
break;
}
}
}
// Also check the primitive vertex mask for TexCoord0 bit (covers custom formats)
if (!useTex && (this->m_primVertexMask & (1 << GxVA_TexCoord0))) {
useTex = true;
}
// Debug logging - enable with WHOA_GX_MTL_LOG_DRAW=1
static bool s_logDraw = std::getenv("WHOA_GX_MTL_LOG_DRAW") != nullptr;
static int s_drawCount = 0;
if (s_logDraw && s_drawCount < 500) {
auto texState = static_cast<CGxTex*>(static_cast<void*>(this->m_appRenderStates[GxRs_Texture0].m_value));
int32_t blendModeDbg = static_cast<int32_t>(this->m_appRenderStates[GxRs_BlendingMode].m_value);
fprintf(stderr, "[MTL Draw #%d] fmt=%d mask=0x%x useTex=%d useColor=%d blend=%d tex0=%p count=%d\n",
s_drawCount++, this->m_primVertexFormat, this->m_primVertexMask, useTex, useColor, blendModeDbg, texState, batch->m_count);
}
int32_t blendMode = static_cast<int32_t>(this->m_appRenderStates[GxRs_BlendingMode].m_value);
auto pipeline = (id<MTLRenderPipelineState>)this->GetPipeline(this->m_primVertexFormat, useColor, useSkin, useTex, blendMode);
if (!pipeline && useColor) {
useColor = false;
pipeline = (id<MTLRenderPipelineState>)this->GetPipeline(this->m_primVertexFormat, false, useSkin, useTex, blendMode);
}
if (!pipeline) {
return;
}
auto mtlVertexBuf = (id<MTLBuffer>)this->GetPoolBuffer(vertexBuf->m_pool);
if (!mtlVertexBuf) {
return;
}
// VSConstants struct matches the Metal shader's VSConstants
struct MtlVSConstants {
C44Matrix mvp;
float pointSize;
float pad[3];
} vsConsts;
vsConsts.pointSize = 1.0f; // Default point size
bool useShaderMvp = false;
// Restore shader constant usage for standard UI formats.
if (!useSkin) {
auto vsState = static_cast<CGxShader*>(static_cast<void*>(this->m_appRenderStates[GxRs_VertexShader].m_value));
if (vsState) {
static bool s_logConstants = std::getenv("WHOA_GX_MTL_LOG_CONSTANTS") != nullptr;
if (s_logConstants) {
const auto& c = CGxDevice::s_shadowConstants[1].constants;
fprintf(stderr, "VS Consts: [0] %f %f %f %f\n", c[0].x, c[0].y, c[0].z, c[0].w);
fprintf(stderr, " [1] %f %f %f %f\n", c[1].x, c[1].y, c[1].z, c[1].w);
fprintf(stderr, " [2] %f %f %f %f\n", c[2].x, c[2].y, c[2].z, c[2].w);
fprintf(stderr, " [3] %f %f %f %f\n", c[3].x, c[3].y, c[3].z, c[3].w);
}
// NOTE: VS constant MVP from c[0-3] is disabled - it causes rendering issues.
// The game may store MVP in constants for some shaders, but the format varies.
// For now, we rely on the transform stack (world * view * proj).
}
}
if (!useShaderMvp) {
if (useSkin) {
vsConsts.mvp = this->m_projNative;
} else {
const auto& world = this->m_xforms[GxXform_World].TopConst();
const auto& view = this->m_xforms[GxXform_View].TopConst();
vsConsts.mvp = (world * view) * this->m_projNative;
}
}
// Get point size from render state if point sprites are enabled
int32_t pointSprite = static_cast<int32_t>(this->m_appRenderStates[GxRs_PointSprite].m_value);
if (pointSprite) {
float pointScale = static_cast<float>(static_cast<int32_t>(this->m_appRenderStates[GxRs_PointScale].m_value));
if (pointScale > 0.0f) {
vsConsts.pointSize = pointScale;
}
}
[encoder setRenderPipelineState:pipeline];
if (blendMode == GxBlend_ConstantAlpha) {
float alphaRef = static_cast<float>(static_cast<int32_t>(this->m_appRenderStates[GxRs_AlphaRef].m_value)) / 255.0f;
[encoder setBlendColorRed:1.0 green:1.0 blue:1.0 alpha:alphaRef];
}
int32_t depthTest = static_cast<int32_t>(this->m_appRenderStates[GxRs_DepthTest].m_value);
uint32_t depthFunc = static_cast<uint32_t>(this->m_appRenderStates[GxRs_DepthFunc].m_value);
int32_t depthWrite = static_cast<int32_t>(this->m_appRenderStates[GxRs_DepthWrite].m_value);
bool depthTestEnabled = this->MasterEnable(GxMasterEnable_DepthTest) && depthTest;
bool depthWriteEnabled = this->MasterEnable(GxMasterEnable_DepthWrite) && depthWrite;
auto depthState = (id<MTLDepthStencilState>)this->GetDepthState(depthTestEnabled, depthWriteEnabled, depthFunc);
if (depthState) {
[encoder setDepthStencilState:depthState];
}
// Polygon offset (depth bias) for decals and overlapping geometry
int32_t polygonOffset = static_cast<int32_t>(this->m_appRenderStates[GxRs_PolygonOffset].m_value);
if (polygonOffset != 0) {
// Apply depth bias to push geometry slightly back, avoiding z-fighting
float slopeScale = static_cast<float>(polygonOffset) * 2.0f;
float units = static_cast<float>(polygonOffset);
[encoder setDepthBias:units slopeScale:slopeScale clamp:0.0f];
} else {
[encoder setDepthBias:0.0f slopeScale:0.0f clamp:0.0f];
}
int32_t cullMode = static_cast<int32_t>(this->m_appRenderStates[GxRs_Culling].m_value);
if (cullMode == 0) {
[encoder setCullMode:MTLCullModeNone];
} else {
[encoder setCullMode:MTLCullModeBack];
// Swap winding: OpenGL uses opposite convention from what we originally had
[encoder setFrontFacingWinding:(cullMode == 1) ? MTLWindingCounterClockwise : MTLWindingClockwise];
}
// Scissor test: when disabled, use full framebuffer; when enabled, use viewport scissor
int32_t scissorTest = static_cast<int32_t>(this->m_appRenderStates[GxRs_ScissorTest].m_value);
if (!scissorTest) {
auto layer = (CAMetalLayer*)this->m_layer;
CGSize size = layer.drawableSize;
MTLScissorRect fullRect = { 0, 0, static_cast<NSUInteger>(size.width), static_cast<NSUInteger>(size.height) };
[encoder setScissorRect:fullRect];
}
// When scissor test is enabled, the scissor rect is set by IStateSyncScissorRect via BeginFrame
[encoder setVertexBuffer:mtlVertexBuf offset:vertexBuf->m_index atIndex:0];
[encoder setVertexBytes:&vsConsts length:sizeof(vsConsts) atIndex:1];
// Pass vertex constants for texture matrix transforms (needed for animated textures)
// and skinning. All texture shaders now use buffer(2) for texture matrix lookup.
if (useSkin || useTex) {
[encoder setVertexBytes:CGxDevice::s_shadowConstants[1].constants
length:sizeof(CGxDevice::s_shadowConstants[1].constants)
atIndex:2];
}
if (useTex) {
auto texState = static_cast<CGxTex*>(static_cast<void*>(this->m_appRenderStates[GxRs_Texture0].m_value));
auto texture = (id<MTLTexture>)this->GetTexture(texState);
if (!texture) {
this->EnsureFallbackTexture();
texture = (id<MTLTexture>)this->m_fallbackTexture;
}
auto sampler = (id<MTLSamplerState>)this->GetSampler(texState);
if (!sampler) {
sampler = (id<MTLSamplerState>)this->m_fallbackSampler;
}
// Debug tex binding
if (s_logDraw && s_drawCount <= 10) {
EGxTexFormat gxfmt = texState ? texState->m_format : GxTex_Unknown;
fprintf(stderr, " [Tex0] ptr=%p mtlTex=%p dim=%lux%lu gxfmt=%d pixelFmt=%lu\n",
texState, texture, texture.width, texture.height, gxfmt, (unsigned long)texture.pixelFormat);
}
[encoder setFragmentTexture:texture atIndex:0];
[encoder setFragmentSamplerState:sampler atIndex:0];
auto texState1 = static_cast<CGxTex*>(static_cast<void*>(this->m_appRenderStates[GxRs_Texture1].m_value));
auto texture1 = (id<MTLTexture>)this->GetTexture(texState1);
if (!texture1) {
this->EnsureFallbackTexture();
texture1 = (id<MTLTexture>)this->m_fallbackTexture;
}
auto sampler1 = (id<MTLSamplerState>)this->GetSampler(texState1);
if (!sampler1) {
sampler1 = (id<MTLSamplerState>)this->m_fallbackSampler;
}
[encoder setFragmentTexture:texture1 atIndex:1];
[encoder setFragmentSamplerState:sampler1 atIndex:1];
}
struct MtlPSConstants {
float alphaRef;
float fogStart;
float fogEnd;
float fogEnabled;
float color[4];
float fogColor[4];
} psConsts;
psConsts.alphaRef = static_cast<float>(static_cast<int32_t>(this->m_appRenderStates[GxRs_AlphaRef].m_value)) / 255.0f;
// Read fog render states
int32_t fogEnabled = static_cast<int32_t>(this->m_appRenderStates[GxRs_Fog].m_value);
psConsts.fogEnabled = fogEnabled ? 1.0f : 0.0f;
psConsts.fogStart = static_cast<float>(static_cast<int32_t>(this->m_appRenderStates[GxRs_FogStart].m_value));
psConsts.fogEnd = static_cast<float>(static_cast<int32_t>(this->m_appRenderStates[GxRs_FogEnd].m_value));
// Fog color is stored as CImVector (packed ARGB)
uint32_t fogColorPacked = static_cast<uint32_t>(this->m_appRenderStates[GxRs_FogColor].m_value);
psConsts.fogColor[0] = static_cast<float>((fogColorPacked >> 16) & 0xFF) / 255.0f; // R
psConsts.fogColor[1] = static_cast<float>((fogColorPacked >> 8) & 0xFF) / 255.0f; // G
psConsts.fogColor[2] = static_cast<float>((fogColorPacked >> 0) & 0xFF) / 255.0f; // B
psConsts.fogColor[3] = static_cast<float>((fogColorPacked >> 24) & 0xFF) / 255.0f; // A
// Default color to white
psConsts.color[0] = 1.0f; psConsts.color[1] = 1.0f; psConsts.color[2] = 1.0f; psConsts.color[3] = 1.0f;
// Apply pixel shader constants if a pixel shader is active AND Lighting is DISABLED.
// UI rendering typically disables lighting and uses c[0] for color modulation.
// World rendering enables lighting and uses c[0] for lighting parameters (which we don't support yet in this simple backend),
// so we default to white for world objects to avoid blown-out colors.
auto psState = static_cast<CGxShader*>(static_cast<void*>(this->m_appRenderStates[GxRs_PixelShader].m_value));
int32_t lighting = static_cast<int32_t>(this->m_appRenderStates[GxRs_Lighting].m_value);
if (psState) {
static bool s_logConstants = std::getenv("WHOA_GX_MTL_LOG_CONSTANTS") != nullptr;
if (s_logConstants) {
const auto& c = CGxDevice::s_shadowConstants[0].constants;
fprintf(stderr, "PS Consts (Light=%d, Blend=%d): [0] %f %f %f %f\n", lighting, blendMode, c[0].x, c[0].y, c[0].z, c[0].w);
}
if (lighting == 0) {
const auto& c = CGxDevice::s_shadowConstants[0].constants[0];
// Apply shader constants if they appear initialized (not FLT_MAX from ShaderConstantsClear).
// Zero values are valid - they mean "don't modulate" or intentional transparency.
// Color values are typically in 0-1 range, using 2.0f threshold for HDR margin.
if (std::abs(c.x) <= 2.0f && std::abs(c.y) <= 2.0f && std::abs(c.z) <= 2.0f && std::abs(c.w) <= 2.0f) {
psConsts.color[0] = c.x;
psConsts.color[1] = c.y;
psConsts.color[2] = c.z;
psConsts.color[3] = c.w;
}
}
}
// Debug PS constants color
if (s_logDraw && s_drawCount <= 10) {
int32_t depthTest = static_cast<int32_t>(this->m_appRenderStates[GxRs_DepthTest].m_value);
int32_t depthWrite = static_cast<int32_t>(this->m_appRenderStates[GxRs_DepthWrite].m_value);
fprintf(stderr, " [PSConsts] color=(%.2f, %.2f, %.2f, %.2f) alphaRef=%.3f lighting=%d depthTest=%d depthWrite=%d\n",
psConsts.color[0], psConsts.color[1], psConsts.color[2], psConsts.color[3],
psConsts.alphaRef, lighting, depthTest, depthWrite);
}
[encoder setFragmentBytes:&psConsts length:sizeof(psConsts) atIndex:0];
auto primitive = MtlPrimitiveType(batch->m_primType);
if (indexed) {
auto indexBuf = this->m_primIndexBuf;
if (!indexBuf || indexBuf->m_itemSize != 2) {
return;
}
auto mtlIndexBuf = (id<MTLBuffer>)this->GetPoolBuffer(indexBuf->m_pool);
if (!mtlIndexBuf) {
return;
}
const NSUInteger indexOffset = indexBuf->m_index + (batch->m_start * indexBuf->m_itemSize);
[encoder drawIndexedPrimitives:primitive
indexCount:batch->m_count
indexType:MTLIndexTypeUInt16
indexBuffer:mtlIndexBuf
indexBufferOffset:indexOffset];
} else {
[encoder drawPrimitives:primitive
vertexStart:batch->m_start
vertexCount:batch->m_count];
}
this->m_frameHasDraw = 1;
}
void CGxDeviceMTL::PoolSizeSet(CGxPool* pool, uint32_t size) {
if (!pool || pool->m_size >= static_cast<int32_t>(size)) {
return;
}
pool->m_size = static_cast<int32_t>(size);
pool->unk1C = 0;
if (pool->m_apiSpecific) {
auto buffer = (id<MTLBuffer>)pool->m_apiSpecific;
[buffer release];
pool->m_apiSpecific = nullptr;
}
if (pool->m_mem) {
SMemFree(pool->m_mem, __FILE__, __LINE__, 0x0);
pool->m_mem = nullptr;
}
}
char* CGxDeviceMTL::BufLock(CGxBuf* buf) {
CGxDevice::BufLock(buf);
if (!this->m_context) {
return nullptr;
}
CGxPool* pool = buf->m_pool;
if (!pool->m_mem) {
pool->m_mem = SMemAlloc(pool->m_size, __FILE__, __LINE__, 0x0);
}
if (pool->m_usage == GxPoolUsage_Stream) {
uint32_t v7 = pool->unk1C + buf->m_itemSize - 1;
uint32_t alignedNext = v7 - v7 % buf->m_itemSize;
if (alignedNext + buf->m_size > static_cast<uint32_t>(pool->m_size)) {
pool->Discard();
alignedNext = 0;
}
buf->m_index = alignedNext;
pool->unk1C = alignedNext + buf->m_size;
}
if (!pool->m_mem) {
return nullptr;
}
return static_cast<char*>(pool->m_mem) + buf->m_index;
}
int32_t CGxDeviceMTL::BufUnlock(CGxBuf* buf, uint32_t size) {
CGxDevice::BufUnlock(buf, size);
buf->unk1D = 1;
return 1;
}
void CGxDeviceMTL::BufData(CGxBuf* buf, const void* data, size_t size, uintptr_t offset) {
CGxDevice::BufData(buf, data, size, offset);
auto bufData = this->BufLock(buf);
if (bufData) {
memcpy(&bufData[offset], data, size);
}
this->BufUnlock(buf, static_cast<uint32_t>(size));
}
void CGxDeviceMTL::TexDestroy(CGxTex* texId) {
if (texId && texId->m_apiSpecificData) {
auto texture = (id<MTLTexture>)texId->m_apiSpecificData;
[texture release];
texId->m_apiSpecificData = nullptr;
}
if (texId && texId->m_apiSpecificData2) {
auto sampler = (id<MTLSamplerState>)texId->m_apiSpecificData2;
[sampler release];
texId->m_apiSpecificData2 = nullptr;
}
CGxDevice::TexDestroy(texId);
}
void CGxDeviceMTL::IShaderCreate(CGxShader* shader) {
shader->loaded = 1;
shader->valid = 1;
}
void CGxDeviceMTL::ShaderCreate(CGxShader* shaders[], EGxShTarget target, const char* a4, const char* a5, int32_t permutations) {
CGxDevice::ShaderCreate(shaders, target, a4, a5, permutations);
}
int32_t CGxDeviceMTL::StereoEnabled() {
return 0;
}
void CGxDeviceMTL::XformSetProjection(const C44Matrix& matrix) {
CGxDevice::XformSetProjection(matrix);
C44Matrix projNative = matrix;
if (NotEqual(projNative.c3, 1.0f, WHOA_EPSILON_1) && NotEqual(projNative.c3, 0.0f, WHOA_EPSILON_1)) {
projNative = projNative * (1.0f / projNative.c3);
}
if (projNative.d3 == 0.0f) {
auto v5 = -(projNative.d2 / (projNative.c2 + 1.0f));
auto v6 = -(projNative.d2 / (projNative.c2 - 1.0f));
projNative.c2 = v6 / (v6 - v5);
projNative.d2 = v6 * v5 / (v5 - v6);
} else {
auto v8 = 1.0f / projNative.c2;
auto v9 = (-1.0f - projNative.d2) * v8;
auto v10 = v8 * (1.0f - projNative.d2);
projNative.c2 = 1.0f / (v10 - v9);
projNative.d2 = v9 / (v9 - v10);
}
if (!this->MasterEnable(GxMasterEnable_NormalProjection) && projNative.d3 != 1.0f) {
C44Matrix shrink = {
0.2f, 0.0f, 0.0f, 0.0f,
0.0f, 0.2f, 0.0f, 0.0f,
0.0f, 0.0f, 0.2f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
};
projNative = projNative * shrink;
}
this->m_xforms[GxXform_Projection].m_dirty = 1;
this->m_projNative = projNative;
}
void CGxDeviceMTL::EnsureDepthTexture(uint32_t width, uint32_t height) {
if (!this->m_device || (this->m_depthTexture && this->m_depthWidth == width && this->m_depthHeight == height)) {
return;
}
if (this->m_depthTexture) {
auto depthTex = (id<MTLTexture>)this->m_depthTexture;
[depthTex release];
this->m_depthTexture = nullptr;
}
auto device = (id<MTLDevice>)this->m_device;
auto desc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatDepth32Float width:width height:height mipmapped:NO];
desc.usage = MTLTextureUsageRenderTarget;
desc.storageMode = MTLStorageModePrivate;
id<MTLTexture> depthTex = [device newTextureWithDescriptor:desc];
this->m_depthTexture = depthTex;
this->m_depthWidth = width;
this->m_depthHeight = height;
}
void* CGxDeviceMTL::GetDepthState(bool depthTest, bool depthWrite, uint32_t depthFunc) {
uint32_t funcIndex = std::min<uint32_t>(depthFunc, 3u);
auto& cached = this->m_depthStates[depthTest ? 1 : 0][depthWrite ? 1 : 0][funcIndex];
if (cached) {
return cached;
}
auto device = (id<MTLDevice>)this->m_device;
if (!device) {
return nullptr;
}
auto desc = [MTLDepthStencilDescriptor new];
if (!depthTest) {
desc.depthCompareFunction = MTLCompareFunctionAlways;
} else {
switch (funcIndex) {
case 0:
desc.depthCompareFunction = MTLCompareFunctionLessEqual;
break;
case 1:
desc.depthCompareFunction = MTLCompareFunctionEqual;
break;
case 2:
desc.depthCompareFunction = MTLCompareFunctionGreaterEqual;
break;
case 3:
desc.depthCompareFunction = MTLCompareFunctionLess;
break;
default:
desc.depthCompareFunction = MTLCompareFunctionAlways;
break;
}
}
desc.depthWriteEnabled = depthWrite ? YES : NO;
id<MTLDepthStencilState> state = [device newDepthStencilStateWithDescriptor:desc];
[desc release];
cached = state;
return state;
}
void CGxDeviceMTL::ITexCreate(CGxTex* texId) {
if (!texId || !this->m_device) {
return;
}
EGxTexFormat format = texId->m_dataFormat != GxTex_Unknown ? texId->m_dataFormat : texId->m_format;
auto pixelFormat = MtlPixelFormatForGx(format);
if (pixelFormat == MTLPixelFormatInvalid) {
return;
}
uint32_t width = 0;
uint32_t height = 0;
uint32_t baseMip = 0;
uint32_t mipCount = 0;
this->ITexWHDStartEnd(texId, width, height, baseMip, mipCount);
auto device = (id<MTLDevice>)this->m_device;
MTLTextureDescriptor* desc = nil;
if (texId->m_target == GxTex_CubeMap) {
// Create cubemap texture (6 faces)
desc = [MTLTextureDescriptor textureCubeDescriptorWithPixelFormat:pixelFormat size:width mipmapped:(mipCount - baseMip) > 1];
} else {
// Create 2D texture
desc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:pixelFormat width:width height:height mipmapped:(mipCount - baseMip) > 1];
}
desc.usage = MTLTextureUsageShaderRead;
desc.storageMode = MTLStorageModeShared;
id<MTLTexture> texture = [device newTextureWithDescriptor:desc];
texId->m_apiSpecificData = texture;
texId->m_needsCreation = 0;
}
void CGxDeviceMTL::ITexUpload(CGxTex* texId) {
auto texture = (id<MTLTexture>)texId->m_apiSpecificData;
if (!texture) {
return;
}
uint32_t texelStrideInBytes = 0;
const void* texels = nullptr;
texId->m_userFunc(
GxTex_Lock,
texId->m_width,
texId->m_height,
0,
0,
texId->m_userArg,
texelStrideInBytes,
texels
);
uint32_t width = 0;
uint32_t height = 0;
uint32_t baseMip = 0;
uint32_t mipCount = 0;
this->ITexWHDStartEnd(texId, width, height, baseMip, mipCount);
EGxTexFormat format = texId->m_dataFormat != GxTex_Unknown ? texId->m_dataFormat : texId->m_format;
const bool compressed = GxTexIsCompressed(format);
// Cubemaps have 6 faces, regular textures have 1
int32_t numFaces = texId->m_target == GxTex_CubeMap ? 6 : 1;
for (int32_t face = 0; face < numFaces; ++face) {
for (uint32_t mipLevel = baseMip; mipLevel < mipCount; ++mipLevel) {
texels = nullptr;
texId->m_userFunc(
GxTex_Latch,
std::max(texId->m_width >> mipLevel, 1u),
std::max(texId->m_height >> mipLevel, 1u),
face,
mipLevel,
texId->m_userArg,
texelStrideInBytes,
texels
);
if (!texels) {
continue;
}
uint32_t mipWidth = std::max(texId->m_width >> mipLevel, 1u);
uint32_t mipHeight = std::max(texId->m_height >> mipLevel, 1u);
MTLRegion region = MTLRegionMake2D(0, 0, mipWidth, mipHeight);
if (compressed) {
uint32_t blockSize = CGxDevice::s_texFormatBytesPerBlock[format];
uint32_t blocksWide = std::max(1u, (mipWidth + 3) / 4);
uint32_t bytesPerRow = blocksWide * blockSize;
if (texId->m_target == GxTex_CubeMap) {
[texture replaceRegion:region mipmapLevel:mipLevel - baseMip slice:face withBytes:texels bytesPerRow:bytesPerRow bytesPerImage:0];
} else {
[texture replaceRegion:region mipmapLevel:mipLevel - baseMip withBytes:texels bytesPerRow:bytesPerRow];
}
} else {
const void* uploadTexels = texels;
std::vector<uint32_t> convertedData; // RGBA8 is 32-bit per pixel
// Handle Argb4444 format conversion to RGBA8
// Game packs as: A[15:12] R[11:8] G[7:4] B[3:0] (each 4 bits)
// We expand to RGBA8: R[7:0] G[7:0] B[7:0] A[7:0] (each 8 bits)
if (format == GxTex_Argb4444) {
uint32_t pixelCount = mipWidth * mipHeight;
convertedData.resize(pixelCount);
const uint16_t* srcData = static_cast<const uint16_t*>(texels);
for (uint32_t i = 0; i < pixelCount; ++i) {
uint16_t pixel = srcData[i];
// Extract 4-bit nibbles from game's ARGB format
uint8_t a4 = (pixel >> 12) & 0xF;
uint8_t r4 = (pixel >> 8) & 0xF;
uint8_t g4 = (pixel >> 4) & 0xF;
uint8_t b4 = pixel & 0xF;
// Expand 4-bit to 8-bit (multiply by 17 = 0x11 to scale 0-15 to 0-255)
uint8_t r8 = r4 * 17;
uint8_t g8 = g4 * 17;
uint8_t b8 = b4 * 17;
uint8_t a8 = a4 * 17;
// Pack as RGBA8 (little-endian: ABGR in memory)
convertedData[i] = (a8 << 24) | (b8 << 16) | (g8 << 8) | r8;
}
uploadTexels = convertedData.data();
texelStrideInBytes = mipWidth * 4; // 4 bytes per pixel for RGBA8
}
if (texId->m_target == GxTex_CubeMap) {
[texture replaceRegion:region mipmapLevel:mipLevel - baseMip slice:face withBytes:uploadTexels bytesPerRow:texelStrideInBytes bytesPerImage:0];
} else {
[texture replaceRegion:region mipmapLevel:mipLevel - baseMip withBytes:uploadTexels bytesPerRow:texelStrideInBytes];
}
}
}
}
texId->m_userFunc(
GxTex_Unlock,
texId->m_width,
texId->m_height,
0,
0,
texId->m_userArg,
texelStrideInBytes,
texels
);
}
void* CGxDeviceMTL::GetTexture(CGxTex* texId) {
if (!texId) {
return nullptr;
}
if (texId->m_needsCreation || texId->m_needsUpdate || !texId->m_apiSpecificData) {
texId->m_needsUpdate = 1;
this->ITexMarkAsUpdated(texId);
}
return texId->m_apiSpecificData;
}
void* CGxDeviceMTL::GetSampler(CGxTex* texId) {
if (!texId) {
this->EnsureFallbackTexture();
return this->m_fallbackSampler;
}
if (!texId->m_apiSpecificData2 || texId->m_needsFlagUpdate) {
auto device = (id<MTLDevice>)this->m_device;
if (!device) {
return nullptr;
}
if (texId->m_apiSpecificData2) {
auto sampler = (id<MTLSamplerState>)texId->m_apiSpecificData2;
[sampler release];
texId->m_apiSpecificData2 = nullptr;
}
auto desc = [MTLSamplerDescriptor new];
desc.sAddressMode = texId->m_flags.m_wrapU ? MTLSamplerAddressModeRepeat : MTLSamplerAddressModeClampToEdge;
desc.tAddressMode = texId->m_flags.m_wrapV ? MTLSamplerAddressModeRepeat : MTLSamplerAddressModeClampToEdge;
switch (texId->m_flags.m_filter) {
case GxTex_Nearest:
desc.minFilter = MTLSamplerMinMagFilterNearest;
desc.magFilter = MTLSamplerMinMagFilterNearest;
desc.mipFilter = MTLSamplerMipFilterNotMipmapped;
break;
case GxTex_NearestMipNearest:
desc.minFilter = MTLSamplerMinMagFilterNearest;
desc.magFilter = MTLSamplerMinMagFilterNearest;
desc.mipFilter = MTLSamplerMipFilterNearest;
break;
case GxTex_LinearMipNearest:
desc.minFilter = MTLSamplerMinMagFilterLinear;
desc.magFilter = MTLSamplerMinMagFilterLinear;
desc.mipFilter = MTLSamplerMipFilterNearest;
break;
case GxTex_LinearMipLinear:
desc.minFilter = MTLSamplerMinMagFilterLinear;
desc.magFilter = MTLSamplerMinMagFilterLinear;
desc.mipFilter = MTLSamplerMipFilterLinear;
break;
case GxTex_Anisotropic:
desc.minFilter = MTLSamplerMinMagFilterLinear;
desc.magFilter = MTLSamplerMinMagFilterLinear;
desc.mipFilter = MTLSamplerMipFilterLinear;
desc.maxAnisotropy = std::max<uint32_t>(texId->m_flags.m_maxAnisotropy, 1);
break;
default:
desc.minFilter = MTLSamplerMinMagFilterLinear;
desc.magFilter = MTLSamplerMinMagFilterLinear;
desc.mipFilter = MTLSamplerMipFilterNotMipmapped;
break;
}
id<MTLSamplerState> sampler = [device newSamplerStateWithDescriptor:desc];
[desc release];
texId->m_apiSpecificData2 = sampler;
texId->m_needsFlagUpdate = 0;
}
return texId->m_apiSpecificData2;
}
void CGxDeviceMTL::EnsureFallbackTexture() {
if (this->m_fallbackTexture || !this->m_device) {
return;
}
auto device = (id<MTLDevice>)this->m_device;
auto desc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatBGRA8Unorm width:1 height:1 mipmapped:NO];
desc.usage = MTLTextureUsageShaderRead;
desc.storageMode = MTLStorageModeShared;
id<MTLTexture> texture = [device newTextureWithDescriptor:desc];
uint32_t pixel = 0xFFFFFFFF;
MTLRegion region = MTLRegionMake2D(0, 0, 1, 1);
[texture replaceRegion:region mipmapLevel:0 withBytes:&pixel bytesPerRow:4];
auto samplerDesc = [MTLSamplerDescriptor new];
samplerDesc.sAddressMode = MTLSamplerAddressModeClampToEdge;
samplerDesc.tAddressMode = MTLSamplerAddressModeClampToEdge;
samplerDesc.minFilter = MTLSamplerMinMagFilterLinear;
samplerDesc.magFilter = MTLSamplerMinMagFilterLinear;
samplerDesc.mipFilter = MTLSamplerMipFilterNotMipmapped;
id<MTLSamplerState> sampler = [device newSamplerStateWithDescriptor:samplerDesc];
[samplerDesc release];
this->m_fallbackTexture = texture;
this->m_fallbackSampler = sampler;
}
void CGxDeviceMTL::Resize(uint32_t width, uint32_t height) {
CRect rect = { 0.0f, 0.0f, static_cast<float>(height), static_cast<float>(width) };
this->DeviceSetDefWindow(rect);
}
Reference in New Issue View Git Blame Copy Permalink