Diamond75/Panda3DS
1
0
Fork 0
mirror of https://github.com/wheremyfoodat/Panda3DS.git synced 2025-04-06 22:25:41 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

Format

Browse source
This commit is contained in:
wheremyfoodat 2025-03-14 12:38:09 +02:00
parent 67f0388eae
commit c061bb7b47
7 changed files with 182 additions and 180 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
include/renderer_mtl/mtl_texture.hpp
View file

@ -28,7 +28,7 @@ namespace Metal {
// Range of VRAM taken up by buffer // Range of VRAM taken up by buffer
Interval<u32> range; Interval<u32> range;
PICA::PixelFormatInfo formatInfo; PICA::MTLPixelFormatInfo formatInfo;
MTL::Texture* base = nullptr; MTL::Texture* base = nullptr;
MTL::Texture* texture = nullptr; MTL::Texture* texture = nullptr;
MTL::SamplerState* sampler = nullptr; MTL::SamplerState* sampler = nullptr;

19
include/renderer_mtl/pica_to_mtl.hpp
View file

@ -7,19 +7,24 @@
#include "opengl.hpp" #include "opengl.hpp"
namespace PICA { namespace PICA {
struct PixelFormatInfo { struct MTLPixelFormatInfo {
MTL::PixelFormat pixelFormat; MTL::PixelFormat pixelFormat;
size_t bytesPerTexel; size_t bytesPerTexel;
void (*decoder)(OpenGL::uvec2, u32, u32, std::span<const u8>, std::vector<u8>&); void (*decoder)(OpenGL::uvec2, u32, u32, std::span<const u8>, std::vector<u8>&);
bool needsSwizzle{false};
MTL::TextureSwizzleChannels swizzle{.red = MTL::TextureSwizzleRed, .green = MTL::TextureSwizzleGreen, .blue = MTL::TextureSwizzleBlue, .alpha = MTL::TextureSwizzleAlpha}; bool needsSwizzle = false;
MTL::TextureSwizzleChannels swizzle{
.red = MTL::TextureSwizzleRed,
.green = MTL::TextureSwizzleGreen,
.blue = MTL::TextureSwizzleBlue,
.alpha = MTL::TextureSwizzleAlpha,
};
}; };
extern PixelFormatInfo pixelFormatInfos[14]; extern MTLPixelFormatInfo mtlPixelFormatInfos[14];
void checkForPixelFormatSupport(MTL::Device* device); void checkForMTLPixelFormatSupport(MTL::Device* device);
inline MTLPixelFormatInfo getMTLPixelFormatInfo(TextureFmt format) { return mtlPixelFormatInfos[static_cast<int>(format)]; }
inline PixelFormatInfo getPixelFormatInfo(TextureFmt format) { return pixelFormatInfos[static_cast<int>(format)]; }
inline MTL::PixelFormat toMTLPixelFormatColor(ColorFmt format) { inline MTL::PixelFormat toMTLPixelFormatColor(ColorFmt format) {
switch (format) { switch (format) {

11
src/core/renderer_mtl/mtl_texture.cpp
View file

@ -1,16 +1,17 @@
#include "renderer_mtl/mtl_texture.hpp" #include "renderer_mtl/mtl_texture.hpp"
#include <fmt/format.h>
#include <array> #include <array>
#include "colour.hpp" #include "colour.hpp"
#include "renderer_mtl/objc_helper.hpp" #include "renderer_mtl/objc_helper.hpp"
using namespace Helpers; using namespace Helpers;
namespace Metal { namespace Metal {
void Texture::allocate() { void Texture::allocate() {
formatInfo = PICA::getPixelFormatInfo(format); formatInfo = PICA::getMTLPixelFormatInfo(format);
MTL::TextureDescriptor* descriptor = MTL::TextureDescriptor::alloc()->init(); MTL::TextureDescriptor* descriptor = MTL::TextureDescriptor::alloc()->init();
descriptor->setTextureType(MTL::TextureType2D); descriptor->setTextureType(MTL::TextureType2D);
@ -20,9 +21,7 @@ namespace Metal {
descriptor->setUsage(MTL::TextureUsageShaderRead); descriptor->setUsage(MTL::TextureUsageShaderRead);
descriptor->setStorageMode(MTL::StorageModeShared); // TODO: use private + staging buffers? descriptor->setStorageMode(MTL::StorageModeShared); // TODO: use private + staging buffers?
texture = device->newTexture(descriptor); texture = device->newTexture(descriptor);
texture->setLabel(toNSString( texture->setLabel(toNSString(fmt::format("Base texture {} {}x{}", std::string(PICA::textureFormatToString(format)), size.u(), size.v())));
"Base texture " + std::string(PICA::textureFormatToString(format)) + " " + std::to_string(size.u()) + "x" + std::to_string(size.v())
));
descriptor->release(); descriptor->release();
if (formatInfo.needsSwizzle) { if (formatInfo.needsSwizzle) {
@ -63,9 +62,11 @@ namespace Metal {
if (texture) { if (texture) {
texture->release(); texture->release();
} }
if (base) { if (base) {
base->release(); base->release();
} }
if (sampler) { if (sampler) {
sampler->release(); sampler->release();
} }

53
src/core/renderer_mtl/pica_to_mtl.cpp
View file

@ -5,50 +5,51 @@
using namespace Helpers; using namespace Helpers;
namespace PICA { namespace PICA {
PixelFormatInfo pixelFormatInfos[14] = { MTLPixelFormatInfo mtlPixelFormatInfos[14] = {
{MTL::PixelFormatRGBA8Unorm, 4, decodeTexelABGR8ToRGBA8}, // RGBA8 {MTL::PixelFormatRGBA8Unorm, 4, decodeTexelABGR8ToRGBA8}, // RGBA8
{MTL::PixelFormatRGBA8Unorm, 4, decodeTexelBGR8ToRGBA8}, // RGB8 {MTL::PixelFormatRGBA8Unorm, 4, decodeTexelBGR8ToRGBA8}, // RGB8
{MTL::PixelFormatBGR5A1Unorm, 2, decodeTexelA1BGR5ToBGR5A1}, // RGBA5551 {MTL::PixelFormatBGR5A1Unorm, 2, decodeTexelA1BGR5ToBGR5A1}, // RGBA5551
{MTL::PixelFormatB5G6R5Unorm, 2, decodeTexelB5G6R5ToB5G6R5}, // RGB565 {MTL::PixelFormatB5G6R5Unorm, 2, decodeTexelB5G6R5ToB5G6R5}, // RGB565
{MTL::PixelFormatABGR4Unorm, 2, decodeTexelABGR4ToABGR4}, // RGBA4 {MTL::PixelFormatABGR4Unorm, 2, decodeTexelABGR4ToABGR4}, // RGBA4
{MTL::PixelFormatRG8Unorm, 2, decodeTexelAI8ToRG8, true, {MTL::PixelFormatRG8Unorm,
2,
decodeTexelAI8ToRG8,
true,
{ {
.red = MTL::TextureSwizzleRed, .red = MTL::TextureSwizzleRed,
.green = MTL::TextureSwizzleRed, .green = MTL::TextureSwizzleRed,
.blue = MTL::TextureSwizzleRed, .blue = MTL::TextureSwizzleRed,
.alpha = MTL::TextureSwizzleGreen, .alpha = MTL::TextureSwizzleGreen,
} }}, // IA8
}, // IA8
{MTL::PixelFormatRG8Unorm, 2, decodeTexelGR8ToRG8}, // RG8 {MTL::PixelFormatRG8Unorm, 2, decodeTexelGR8ToRG8}, // RG8
{MTL::PixelFormatR8Unorm, 1, decodeTexelI8ToR8, true, {MTL::PixelFormatR8Unorm,
{ 1,
.red = MTL::TextureSwizzleRed, decodeTexelI8ToR8,
.green = MTL::TextureSwizzleRed, true,
.blue = MTL::TextureSwizzleRed, {.red = MTL::TextureSwizzleRed, .green = MTL::TextureSwizzleRed, .blue = MTL::TextureSwizzleRed, .alpha = MTL::TextureSwizzleOne}}, // I8
.alpha = MTL::TextureSwizzleOne
}
}, // I8
{MTL::PixelFormatA8Unorm, 1, decodeTexelA8ToA8}, // A8 {MTL::PixelFormatA8Unorm, 1, decodeTexelA8ToA8}, // A8
{MTL::PixelFormatABGR4Unorm, 2, decodeTexelAI4ToABGR4}, // IA4 {MTL::PixelFormatABGR4Unorm, 2, decodeTexelAI4ToABGR4}, // IA4
{MTL::PixelFormatR8Unorm, 1, decodeTexelI4ToR8, true, {MTL::PixelFormatR8Unorm,
{ 1,
.red = MTL::TextureSwizzleRed, decodeTexelI4ToR8,
.green = MTL::TextureSwizzleRed, true,
.blue = MTL::TextureSwizzleRed, {.red = MTL::TextureSwizzleRed, .green = MTL::TextureSwizzleRed, .blue = MTL::TextureSwizzleRed, .alpha = MTL::TextureSwizzleOne}}, // I4
.alpha = MTL::TextureSwizzleOne
}
}, // I4
{MTL::PixelFormatA8Unorm, 1, decodeTexelA4ToA8}, // A4 {MTL::PixelFormatA8Unorm, 1, decodeTexelA4ToA8}, // A4
{MTL::PixelFormatRGBA8Unorm, 4, decodeTexelETC1ToRGBA8}, // ETC1 {MTL::PixelFormatRGBA8Unorm, 4, decodeTexelETC1ToRGBA8}, // ETC1
{MTL::PixelFormatRGBA8Unorm, 4, decodeTexelETC1A4ToRGBA8}, // ETC1A4 {MTL::PixelFormatRGBA8Unorm, 4, decodeTexelETC1A4ToRGBA8}, // ETC1A4
}; };
void checkForPixelFormatSupport(MTL::Device* device) { void checkForMTLPixelFormatSupport(MTL::Device* device) {
if (!device->supportsFamily(MTL::GPUFamilyApple1)) { if (!device->supportsFamily(MTL::GPUFamilyApple1)) {
pixelFormatInfos[2] = {MTL::PixelFormatRGBA8Unorm, 4, decodeTexelA1BGR5ToRGBA8}; mtlPixelFormatInfos[2] = {MTL::PixelFormatRGBA8Unorm, 4, decodeTexelA1BGR5ToRGBA8};
pixelFormatInfos[3] = {MTL::PixelFormatRGBA8Unorm, 4, decodeTexelB5G6R5ToRGBA8}; mtlPixelFormatInfos[3] = {MTL::PixelFormatRGBA8Unorm, 4, decodeTexelB5G6R5ToRGBA8};
pixelFormatInfos[4] = {MTL::PixelFormatRGBA8Unorm, 4, decodeTexelABGR4ToRGBA8}; mtlPixelFormatInfos[4] = {MTL::PixelFormatRGBA8Unorm, 4, decodeTexelABGR4ToRGBA8};
pixelFormatInfos[9] = {MTL::PixelFormatRG8Unorm, 2, decodeTexelAI4ToRG8, true,
mtlPixelFormatInfos[9] = {
MTL::PixelFormatRG8Unorm,
2,
decodeTexelAI4ToRG8,
true,
{ {
.red = MTL::TextureSwizzleRed, .red = MTL::TextureSwizzleRed,
.green = MTL::TextureSwizzleRed, .green = MTL::TextureSwizzleRed,
@ -58,4 +59,4 @@ namespace PICA {
}; };
} }
} }
} } // namespace PICA

9
src/core/renderer_mtl/renderer_mtl.cpp
View file

@ -102,19 +102,16 @@ void RendererMTL::display() {
renderCommandEncoder->setRenderPipelineState(displayPipeline); renderCommandEncoder->setRenderPipelineState(displayPipeline);
renderCommandEncoder->setFragmentSamplerState(nearestSampler, 0); renderCommandEncoder->setFragmentSamplerState(nearestSampler, 0);
const int xMultiplier = 2;
const int yMultiplier = 2;
// Top screen // Top screen
if (topScreen) { if (topScreen) {
renderCommandEncoder->setViewport(MTL::Viewport{0, 0, 400 * xMultiplier, 240 * yMultiplier, 0.0f, 1.0f}); renderCommandEncoder->setViewport(MTL::Viewport{0, 0, 400, 240, 0.0f, 1.0f});
renderCommandEncoder->setFragmentTexture(topScreen->get().texture, 0); renderCommandEncoder->setFragmentTexture(topScreen->get().texture, 0);
renderCommandEncoder->drawPrimitives(MTL::PrimitiveTypeTriangleStrip, NS::UInteger(0), NS::UInteger(4)); renderCommandEncoder->drawPrimitives(MTL::PrimitiveTypeTriangleStrip, NS::UInteger(0), NS::UInteger(4));
} }
// Bottom screen // Bottom screen
if (bottomScreen) { if (bottomScreen) {
renderCommandEncoder->setViewport(MTL::Viewport{40 * xMultiplier, 240 * yMultiplier, 320 * xMultiplier, 240 * yMultiplier, 0.0f, 1.0f}); renderCommandEncoder->setViewport(MTL::Viewport{40, 240, 320, 240, 0.0f, 1.0f});
renderCommandEncoder->setFragmentTexture(bottomScreen->get().texture, 0); renderCommandEncoder->setFragmentTexture(bottomScreen->get().texture, 0);
renderCommandEncoder->drawPrimitives(MTL::PrimitiveTypeTriangleStrip, NS::UInteger(0), NS::UInteger(4)); renderCommandEncoder->drawPrimitives(MTL::PrimitiveTypeTriangleStrip, NS::UInteger(0), NS::UInteger(4));
} }
@ -141,7 +138,7 @@ void RendererMTL::initGraphicsContext(SDL_Window* window) {
device = MTL::CreateSystemDefaultDevice(); device = MTL::CreateSystemDefaultDevice();
metalLayer->setDevice(device); metalLayer->setDevice(device);
#endif #endif
checkForPixelFormatSupport(device); checkForMTLPixelFormatSupport(device);
commandQueue = device->newCommandQueue(); commandQueue = device->newCommandQueue();

6
src/core/renderer_mtl/texture_decoder.cpp
View file

@ -3,8 +3,8 @@
#include <array> #include <array>
#include <string> #include <string>
#include "math_util.hpp"
#include "colour.hpp" #include "colour.hpp"
#include "math_util.hpp"
using namespace Helpers; using namespace Helpers;
@ -216,9 +216,7 @@ void decodeTexelA4ToA8(OpenGL::uvec2 size, u32 u, u32 v, std::span<const u8> inD
outData.push_back(alpha); outData.push_back(alpha);
} }
static constexpr u32 signExtend3To32(u32 val) { static constexpr u32 signExtend3To32(u32 val) { return (u32)(s32(val) << 29 >> 29); }
return (u32)(s32(val) << 29 >> 29);
}
void decodeETC(u32 u, u32 v, u64 colourData, u32 alpha, std::vector<u8>& outData) { void decodeETC(u32 u, u32 v, u64 colourData, u32 alpha, std::vector<u8>& outData) {
static constexpr u32 modifiers[8][2] = { static constexpr u32 modifiers[8][2] = {

4
src/host_shaders/metal_shaders.metal
View file

@ -655,7 +655,7 @@ float4 performLogicOp(LogicOp logicOp, float4 s, float4 d) {
return as_type<float4>(performLogicOpU(logicOp, as_type<uint4>(s), as_type<uint4>(d))); return as_type<float4>(performLogicOpU(logicOp, as_type<uint4>(s), as_type<uint4>(d)));
} }
fragment float4 fragmentDraw(DrawVertexOut in [[stage_in]], constant PicaRegs& picaRegs [[buffer(0)]], constant FragTEV& tev [[buffer(1)]], constant LogicOp& logicOp [[buffer(2)]], constant uint2& lutSlices [[buffer(3)]], texture2d<float> tex0 [[texture(0)]], texture2d<float> tex1 [[texture(1)]], texture2d<float> tex2 [[texture(2)]], texture2d_array<float> texLightingLut [[texture(3)]], texture1d_array<float> texFogLut [[texture(4)]], sampler samplr0 [[sampler(0)]], sampler samplr1 [[sampler(1)]], sampler samplr2 [[sampler(2)]], sampler linearSampler [[sampler(3)]]) { fragment float4 fragmentDraw(DrawVertexOut in [[stage_in]], float4 prevColor [[color(0)]], constant PicaRegs& picaRegs [[buffer(0)]], constant FragTEV& tev [[buffer(1)]], constant LogicOp& logicOp [[buffer(2)]], constant uint2& lutSlices [[buffer(3)]], texture2d<float> tex0 [[texture(0)]], texture2d<float> tex1 [[texture(1)]], texture2d<float> tex2 [[texture(2)]], texture2d_array<float> texLightingLut [[texture(3)]], texture1d_array<float> texFogLut [[texture(4)]], sampler samplr0 [[sampler(0)]], sampler samplr1 [[sampler(1)]], sampler samplr2 [[sampler(2)]], sampler linearSampler [[sampler(3)]]) {
Globals globals; Globals globals;
// HACK // HACK
@ -755,5 +755,5 @@ fragment float4 fragmentDraw(DrawVertexOut in [[stage_in]], constant PicaRegs& p
} }
} }
return performLogicOp(logicOp, color, float4(1.0, 0.0, 0.0, 1.0)); return performLogicOp(logicOp, color, prevColor);
} }