diff --git a/CMakeLists.txt b/CMakeLists.txt index b681195..8654a8d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -77,6 +77,7 @@ target_link_libraries(Engine PUBLIC shader-slang) if(APPLE) target_link_directories(Engine PUBLIC /usr/local/lib) target_link_libraries(Engine PUBLIC metal) + SET(CMAKE_OSX_DEPLOYMENT_TARGET 14.3) endif() if(UNIX) target_link_libraries(Engine PUBLIC Threads::Threads) diff --git a/src/Engine/Asset/FontAsset.cpp b/src/Engine/Asset/FontAsset.cpp index 443f162..7856f91 100644 --- a/src/Engine/Asset/FontAsset.cpp +++ b/src/Engine/Asset/FontAsset.cpp @@ -1,6 +1,5 @@ #include "FontAsset.h" #include "Graphics/Graphics.h" -#include "Graphics/Vulkan/Enums.h" #include "Graphics/Texture.h" #include @@ -100,7 +99,7 @@ void FontAsset::load(ArchiveBuffer& buffer) .data = ktxTexture_GetData(ktxTexture(kTexture)), .owner = Gfx::QueueType::GRAPHICS, }, - .format = Vulkan::cast((VkFormat)kTexture->vkFormat), + .format = (Gfx::SeFormat)kTexture->vkFormat, .width = kTexture->baseWidth, .height = kTexture->baseHeight, .depth = kTexture->baseDepth, diff --git a/src/Engine/Asset/TextureAsset.cpp b/src/Engine/Asset/TextureAsset.cpp index 385926a..7923817 100644 --- a/src/Engine/Asset/TextureAsset.cpp +++ b/src/Engine/Asset/TextureAsset.cpp @@ -91,7 +91,7 @@ void TextureAsset::load(ArchiveBuffer& buffer) .data = ktxTexture_GetData(ktxTexture(kTexture)), .owner = Gfx::QueueType::TRANSFER, }, - .format = Vulkan::cast((VkFormat)kTexture->vkFormat), + .format = (Gfx::SeFormat)kTexture->vkFormat, .width = kTexture->baseWidth, .height = kTexture->baseHeight, .depth = kTexture->baseDepth, diff --git a/src/Engine/Graphics/CMakeLists.txt b/src/Engine/Graphics/CMakeLists.txt index e197bc6..f6a72f0 100644 --- a/src/Engine/Graphics/CMakeLists.txt +++ b/src/Engine/Graphics/CMakeLists.txt @@ -56,7 +56,8 @@ target_sources(Engine Window.h) add_subdirectory(RenderPass/) -add_subdirectory(Vulkan/) -#if(APPLE) -# add_subdirectory(Metal/) -#endif() \ No newline at end of file +if(APPLE) + add_subdirectory(Metal/) +else() + add_subdirectory(Vulkan/) +endif() \ No newline at end of file diff --git a/src/Engine/Graphics/Enums.h b/src/Engine/Graphics/Enums.h index ef62a82..788b9f6 100644 --- a/src/Engine/Graphics/Enums.h +++ b/src/Engine/Graphics/Enums.h @@ -925,54 +925,20 @@ typedef enum SeFormat SE_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, SE_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, SE_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, - SE_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = 1000066000, - SE_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = 1000066001, - SE_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = 1000066002, - SE_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = 1000066003, - SE_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = 1000066004, - SE_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = 1000066005, - SE_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = 1000066006, - SE_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = 1000066007, - SE_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = 1000066008, - SE_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = 1000066009, - SE_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = 1000066010, - SE_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = 1000066011, - SE_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = 1000066012, - SE_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = 1000066013, - SE_FORMAT_G8B8G8R8_422_UNORM_KHR = SE_FORMAT_G8B8G8R8_422_UNORM, - SE_FORMAT_B8G8R8G8_422_UNORM_KHR = SE_FORMAT_B8G8R8G8_422_UNORM, - SE_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = SE_FORMAT_G8_B8_R8_3PLANE_420_UNORM, - SE_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = SE_FORMAT_G8_B8R8_2PLANE_420_UNORM, - SE_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = SE_FORMAT_G8_B8_R8_3PLANE_422_UNORM, - SE_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = SE_FORMAT_G8_B8R8_2PLANE_422_UNORM, - SE_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = SE_FORMAT_G8_B8_R8_3PLANE_444_UNORM, - SE_FORMAT_R10X6_UNORM_PACK16_KHR = SE_FORMAT_R10X6_UNORM_PACK16, - SE_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = SE_FORMAT_R10X6G10X6_UNORM_2PACK16, - SE_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = SE_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, - SE_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = SE_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, - SE_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = SE_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, - SE_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = SE_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, - SE_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = SE_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, - SE_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = SE_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, - SE_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = SE_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, - SE_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = SE_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, - SE_FORMAT_R12X4_UNORM_PACK16_KHR = SE_FORMAT_R12X4_UNORM_PACK16, - SE_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = SE_FORMAT_R12X4G12X4_UNORM_2PACK16, - SE_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = SE_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, - SE_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = SE_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, - SE_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = SE_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, - SE_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = SE_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, - SE_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = SE_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, - SE_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = SE_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, - SE_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = SE_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, - SE_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = SE_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, - SE_FORMAT_G16B16G16R16_422_UNORM_KHR = SE_FORMAT_G16B16G16R16_422_UNORM, - SE_FORMAT_B16G16R16G16_422_UNORM_KHR = SE_FORMAT_B16G16R16G16_422_UNORM, - SE_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = SE_FORMAT_G16_B16_R16_3PLANE_420_UNORM, - SE_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = SE_FORMAT_G16_B16R16_2PLANE_420_UNORM, - SE_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = SE_FORMAT_G16_B16_R16_3PLANE_422_UNORM, - SE_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = SE_FORMAT_G16_B16R16_2PLANE_422_UNORM, - SE_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = SE_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + SE_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 1000066000, + SE_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 1000066001, + SE_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 1000066002, + SE_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 1000066003, + SE_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 1000066004, + SE_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 1000066005, + SE_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 1000066006, + SE_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 1000066007, + SE_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 1000066008, + SE_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 1000066009, + SE_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 1000066010, + SE_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 1000066011, + SE_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 1000066012, + SE_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 1000066013, SE_FORMAT_BEGIN_RANGE = SE_FORMAT_UNDEFINED, SE_FORMAT_END_RANGE = SE_FORMAT_ASTC_12x12_SRGB_BLOCK, SE_FORMAT_RANGE_SIZE = (SE_FORMAT_ASTC_12x12_SRGB_BLOCK - SE_FORMAT_UNDEFINED + 1), diff --git a/src/Engine/Graphics/Meshlet.cpp b/src/Engine/Graphics/Meshlet.cpp index b30aea3..2edaf90 100644 --- a/src/Engine/Graphics/Meshlet.cpp +++ b/src/Engine/Graphics/Meshlet.cpp @@ -15,13 +15,13 @@ struct AdjacencyInfo void buildAdjacency(const uint32 numVerts, const Array& indices, AdjacencyInfo& info) { info.trianglesPerVertex.resize(numVerts, 0); - for (int i = 0; i < indices.size(); ++i) + for (size_t i = 0; i < indices.size(); ++i) { info.trianglesPerVertex[indices[i]]++; } uint32 triangleOffset = 0; info.indexBufferOffset.resize(numVerts, 0); - for (int j = 0; j < numVerts; ++j) + for (size_t j = 0; j < numVerts; ++j) { info.indexBufferOffset[j] = triangleOffset; triangleOffset += info.trianglesPerVertex[j]; @@ -42,7 +42,7 @@ void buildAdjacency(const uint32 numVerts, const Array& indices, Adjacen } } -uint32 skipDeadEnd(const Array& liveTriCount, List& deadEndStack, uint32& cursor) +int32 skipDeadEnd(const Array& liveTriCount, List& deadEndStack, uint32& cursor) { while (!deadEndStack.empty()) { @@ -64,7 +64,7 @@ uint32 skipDeadEnd(const Array& liveTriCount, List& deadEndStack return -1; } -uint32 getNextVertex(const int cacheSize, const Array& oneRing, const Array& cacheTimeStamps, const uint32 timeStamp, const Array& liveTriCount, List& deadEndStack, uint32& cursor) +int32 getNextVertex(const uint32 cacheSize, const Array& oneRing, const Array& cacheTimeStamps, const uint32 timeStamp, const Array& liveTriCount, List& deadEndStack, uint32& cursor) { uint32 bestCandidate = std::numeric_limits::max(); int highestPriority = -1; @@ -91,7 +91,7 @@ uint32 getNextVertex(const int cacheSize, const Array& oneRing, const Ar return bestCandidate; } -void tipsifyIndexBuffer(const Array& indices, const uint32 numVerts, const int cacheSize, Array& outIndices) +void tipsifyIndexBuffer(const Array& indices, const uint32 numVerts, const uint32 cacheSize, Array& outIndices) { AdjacencyInfo adjacencyStruct; buildAdjacency(numVerts, indices, adjacencyStruct); @@ -104,7 +104,7 @@ void tipsifyIndexBuffer(const Array& indices, const uint32 numVerts, con Array emittedTriangles(indices.size() / 3); - uint32 curVert = 0; + int32 curVert = 0; uint32 timeStamp = cacheSize + 1; uint32 cursor = 1; while (curVert != -1) diff --git a/src/Engine/Graphics/Metal/CMakeLists.txt b/src/Engine/Graphics/Metal/CMakeLists.txt index 9ddc784..bcc5cdc 100644 --- a/src/Engine/Graphics/Metal/CMakeLists.txt +++ b/src/Engine/Graphics/Metal/CMakeLists.txt @@ -1,4 +1,14 @@ target_sources(Engine PRIVATE + Enums.h + Enums.mm Graphics.h - Graphics.cpp) \ No newline at end of file + Graphics.mm + PrivateImpl.mm + RenderPass.h + RenderPass.mm + Resources.h + Texture.h + Texture.mm + Window.h + Window.mm) \ No newline at end of file diff --git a/src/Engine/Graphics/Metal/Enums.h b/src/Engine/Graphics/Metal/Enums.h new file mode 100644 index 0000000..b116d7a --- /dev/null +++ b/src/Engine/Graphics/Metal/Enums.h @@ -0,0 +1,15 @@ +#pragma once +#include "Graphics/Enums.h" +#include "Metal/MTLPixelFormat.hpp" +#include "Metal/MTLTexture.hpp" + +namespace Seele +{ +namespace Metal +{ +MTL::PixelFormat cast(Gfx::SeFormat format); +Gfx::SeFormat cast(MTL::PixelFormat format); +MTL::TextureUsage cast(Gfx::SeImageUsageFlags usage); +Gfx::SeImageUsageFlags cast(MTL::TextureUsage usage); +} +} \ No newline at end of file diff --git a/src/Engine/Graphics/Metal/Enums.mm b/src/Engine/Graphics/Metal/Enums.mm new file mode 100644 index 0000000..e8fde19 --- /dev/null +++ b/src/Engine/Graphics/Metal/Enums.mm @@ -0,0 +1,540 @@ +#include "Enums.h" +#include + +using namespace Seele; +using namespace Seele::Metal; + +MTL::PixelFormat Seele::Metal::cast(Gfx::SeFormat format) { + switch (format) { + case Gfx::SE_FORMAT_UNDEFINED: + return MTL::PixelFormatInvalid; + case Gfx::SE_FORMAT_R8_UNORM: + return MTL::PixelFormatR8Unorm; + case Gfx::SE_FORMAT_R8_SRGB: + return MTL::PixelFormatR8Unorm_sRGB; + case Gfx::SE_FORMAT_R8_SNORM: + return MTL::PixelFormatR8Snorm; + case Gfx::SE_FORMAT_R8_UINT: + return MTL::PixelFormatR8Uint; + case Gfx::SE_FORMAT_R8_SINT: + return MTL::PixelFormatR8Sint; + case Gfx::SE_FORMAT_R16_UNORM: + return MTL::PixelFormatR16Unorm; + case Gfx::SE_FORMAT_R16_SNORM: + return MTL::PixelFormatR16Snorm; + case Gfx::SE_FORMAT_R16_UINT: + return MTL::PixelFormatR16Uint; + case Gfx::SE_FORMAT_R16_SINT: + return MTL::PixelFormatR16Sint; + case Gfx::SE_FORMAT_R16_SFLOAT: + return MTL::PixelFormatR16Float; + case Gfx::SE_FORMAT_R8G8_UNORM: + return MTL::PixelFormatRG8Unorm; + case Gfx::SE_FORMAT_R8G8_SRGB: + return MTL::PixelFormatRG8Unorm_sRGB; + case Gfx::SE_FORMAT_R8G8_SNORM: + return MTL::PixelFormatRG8Snorm; + case Gfx::SE_FORMAT_R8G8_UINT: + return MTL::PixelFormatRG8Uint; + case Gfx::SE_FORMAT_R8G8_SINT: + return MTL::PixelFormatRG8Sint; + case Gfx::SE_FORMAT_B5G6R5_UNORM_PACK16: + return MTL::PixelFormatB5G6R5Unorm; + case Gfx::SE_FORMAT_R4G4B4A4_UNORM_PACK16: + return MTL::PixelFormatABGR4Unorm; + case Gfx::SE_FORMAT_B5G5R5A1_UNORM_PACK16: + return MTL::PixelFormatBGR5A1Unorm; + case Gfx::SE_FORMAT_R32_UINT: + return MTL::PixelFormatR32Uint; + case Gfx::SE_FORMAT_R32_SINT: + return MTL::PixelFormatR32Sint; + case Gfx::SE_FORMAT_R32_SFLOAT: + return MTL::PixelFormatR32Float; + case Gfx::SE_FORMAT_R16G16_UNORM: + return MTL::PixelFormatRG16Unorm; + case Gfx::SE_FORMAT_R16G16_SNORM: + return MTL::PixelFormatRG16Snorm; + case Gfx::SE_FORMAT_R16G16_UINT: + return MTL::PixelFormatRG16Uint; + case Gfx::SE_FORMAT_R16G16_SINT: + return MTL::PixelFormatRG16Sint; + case Gfx::SE_FORMAT_R16G16_SFLOAT: + return MTL::PixelFormatRG16Float; + case Gfx::SE_FORMAT_R8G8B8A8_UNORM: + return MTL::PixelFormatRGBA8Unorm; + case Gfx::SE_FORMAT_R8G8B8A8_SRGB: + return MTL::PixelFormatRGBA8Unorm_sRGB; + case Gfx::SE_FORMAT_R8G8B8A8_SNORM: + return MTL::PixelFormatRGBA8Snorm; + case Gfx::SE_FORMAT_R8G8B8A8_UINT: + return MTL::PixelFormatRGBA8Uint; + case Gfx::SE_FORMAT_R8G8B8A8_SINT: + return MTL::PixelFormatRGBA8Sint; + case Gfx::SE_FORMAT_B8G8R8A8_UNORM: + return MTL::PixelFormatBGRA8Unorm; + case Gfx::SE_FORMAT_B8G8R8A8_SRGB: + return MTL::PixelFormatBGRA8Unorm_sRGB; + case Gfx::SE_FORMAT_R32G32_UINT: + return MTL::PixelFormatRG32Uint; + case Gfx::SE_FORMAT_R32G32_SINT: + return MTL::PixelFormatRG32Sint; + case Gfx::SE_FORMAT_R32G32_SFLOAT: + return MTL::PixelFormatRG32Float; + case Gfx::SE_FORMAT_R16G16B16A16_UNORM: + return MTL::PixelFormatRGBA16Unorm; + case Gfx::SE_FORMAT_R16G16B16A16_SNORM: + return MTL::PixelFormatRGBA16Snorm; + case Gfx::SE_FORMAT_R16G16B16A16_UINT: + return MTL::PixelFormatRGBA16Uint; + case Gfx::SE_FORMAT_R16G16B16A16_SINT: + return MTL::PixelFormatRGBA16Sint; + case Gfx::SE_FORMAT_R16G16B16A16_SFLOAT: + return MTL::PixelFormatRGBA16Float; + case Gfx::SE_FORMAT_R32G32B32A32_UINT: + return MTL::PixelFormatRGBA32Uint; + case Gfx::SE_FORMAT_R32G32B32A32_SINT: + return MTL::PixelFormatRGBA32Sint; + case Gfx::SE_FORMAT_R32G32B32A32_SFLOAT: + return MTL::PixelFormatRGBA32Float; + case Gfx::SE_FORMAT_BC1_RGBA_UNORM_BLOCK: + return MTL::PixelFormatBC1_RGBA; + case Gfx::SE_FORMAT_BC1_RGBA_SRGB_BLOCK: + return MTL::PixelFormatBC1_RGBA_sRGB; + case Gfx::SE_FORMAT_BC2_UNORM_BLOCK: + return MTL::PixelFormatBC2_RGBA; + case Gfx::SE_FORMAT_BC2_SRGB_BLOCK: + return MTL::PixelFormatBC2_RGBA_sRGB; + case Gfx::SE_FORMAT_BC3_UNORM_BLOCK: + return MTL::PixelFormatBC3_RGBA; + case Gfx::SE_FORMAT_BC3_SRGB_BLOCK: + return MTL::PixelFormatBC3_RGBA_sRGB; + case Gfx::SE_FORMAT_BC4_UNORM_BLOCK: + return MTL::PixelFormatBC4_RUnorm; + case Gfx::SE_FORMAT_BC4_SNORM_BLOCK: + return MTL::PixelFormatBC4_RSnorm; + case Gfx::SE_FORMAT_BC5_UNORM_BLOCK: + return MTL::PixelFormatBC5_RGUnorm; + case Gfx::SE_FORMAT_BC5_SNORM_BLOCK: + return MTL::PixelFormatBC5_RGSnorm; + case Gfx::SE_FORMAT_BC6H_SFLOAT_BLOCK: + return MTL::PixelFormatBC6H_RGBFloat; + case Gfx::SE_FORMAT_BC6H_UFLOAT_BLOCK: + return MTL::PixelFormatBC6H_RGBUfloat; + case Gfx::SE_FORMAT_BC7_UNORM_BLOCK: + return MTL::PixelFormatBC7_RGBAUnorm; + case Gfx::SE_FORMAT_BC7_SRGB_BLOCK: + return MTL::PixelFormatBC7_RGBAUnorm_sRGB; + case Gfx::SE_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: + return MTL::PixelFormatPVRTC_RGB_2BPP; + case Gfx::SE_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: + return MTL::PixelFormatPVRTC_RGB_2BPP_sRGB; + case Gfx::SE_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: + return MTL::PixelFormatPVRTC_RGB_4BPP; + case Gfx::SE_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: + return MTL::PixelFormatPVRTC_RGB_4BPP_sRGB; + case Gfx::SE_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: + return MTL::PixelFormatPVRTC_RGBA_2BPP; + case Gfx::SE_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: + return MTL::PixelFormatPVRTC_RGBA_2BPP_sRGB; + case Gfx::SE_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: + return MTL::PixelFormatPVRTC_RGBA_4BPP; + case Gfx::SE_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: + return MTL::PixelFormatPVRTC_RGBA_4BPP_sRGB; + case Gfx::SE_FORMAT_EAC_R11_UNORM_BLOCK: + return MTL::PixelFormatEAC_R11Unorm; + case Gfx::SE_FORMAT_EAC_R11_SNORM_BLOCK: + return MTL::PixelFormatEAC_R11Snorm; + case Gfx::SE_FORMAT_EAC_R11G11_UNORM_BLOCK: + return MTL::PixelFormatEAC_RG11Unorm; + case Gfx::SE_FORMAT_EAC_R11G11_SNORM_BLOCK: + return MTL::PixelFormatEAC_RG11Snorm; + case Gfx::SE_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: + return MTL::PixelFormatETC2_RGB8; + case Gfx::SE_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: + return MTL::PixelFormatETC2_RGB8_sRGB; + case Gfx::SE_FORMAT_ASTC_4x4_SRGB_BLOCK: + return MTL::PixelFormatASTC_4x4_sRGB; + case Gfx::SE_FORMAT_ASTC_5x4_SRGB_BLOCK: + return MTL::PixelFormatASTC_5x4_sRGB; + case Gfx::SE_FORMAT_ASTC_5x5_SRGB_BLOCK: + return MTL::PixelFormatASTC_5x5_sRGB; + case Gfx::SE_FORMAT_ASTC_6x5_SRGB_BLOCK: + return MTL::PixelFormatASTC_6x5_sRGB; + case Gfx::SE_FORMAT_ASTC_6x6_SRGB_BLOCK: + return MTL::PixelFormatASTC_6x6_sRGB; + case Gfx::SE_FORMAT_ASTC_8x5_SRGB_BLOCK: + return MTL::PixelFormatASTC_8x5_sRGB; + case Gfx::SE_FORMAT_ASTC_8x6_SRGB_BLOCK: + return MTL::PixelFormatASTC_8x6_sRGB; + case Gfx::SE_FORMAT_ASTC_8x8_SRGB_BLOCK: + return MTL::PixelFormatASTC_8x8_sRGB; + case Gfx::SE_FORMAT_ASTC_10x5_SRGB_BLOCK: + return MTL::PixelFormatASTC_10x5_sRGB; + case Gfx::SE_FORMAT_ASTC_10x6_SRGB_BLOCK: + return MTL::PixelFormatASTC_10x6_sRGB; + case Gfx::SE_FORMAT_ASTC_10x8_SRGB_BLOCK: + return MTL::PixelFormatASTC_10x8_sRGB; + case Gfx::SE_FORMAT_ASTC_10x10_SRGB_BLOCK: + return MTL::PixelFormatASTC_10x10_sRGB; + case Gfx::SE_FORMAT_ASTC_12x10_SRGB_BLOCK: + return MTL::PixelFormatASTC_12x10_sRGB; + case Gfx::SE_FORMAT_ASTC_12x12_SRGB_BLOCK: + return MTL::PixelFormatASTC_12x12_sRGB; + case Gfx::SE_FORMAT_ASTC_4x4_UNORM_BLOCK: + return MTL::PixelFormatASTC_4x4_LDR; + case Gfx::SE_FORMAT_ASTC_5x4_UNORM_BLOCK: + return MTL::PixelFormatASTC_5x4_LDR; + case Gfx::SE_FORMAT_ASTC_5x5_UNORM_BLOCK: + return MTL::PixelFormatASTC_5x5_LDR; + case Gfx::SE_FORMAT_ASTC_6x5_UNORM_BLOCK: + return MTL::PixelFormatASTC_6x5_LDR; + case Gfx::SE_FORMAT_ASTC_6x6_UNORM_BLOCK: + return MTL::PixelFormatASTC_6x6_LDR; + case Gfx::SE_FORMAT_ASTC_8x5_UNORM_BLOCK: + return MTL::PixelFormatASTC_8x5_LDR; + case Gfx::SE_FORMAT_ASTC_8x6_UNORM_BLOCK: + return MTL::PixelFormatASTC_8x6_LDR; + case Gfx::SE_FORMAT_ASTC_8x8_UNORM_BLOCK: + return MTL::PixelFormatASTC_8x8_LDR; + case Gfx::SE_FORMAT_ASTC_10x5_UNORM_BLOCK: + return MTL::PixelFormatASTC_10x5_LDR; + case Gfx::SE_FORMAT_ASTC_10x6_UNORM_BLOCK: + return MTL::PixelFormatASTC_10x6_LDR; + case Gfx::SE_FORMAT_ASTC_10x8_UNORM_BLOCK: + return MTL::PixelFormatASTC_10x8_LDR; + case Gfx::SE_FORMAT_ASTC_10x10_UNORM_BLOCK: + return MTL::PixelFormatASTC_10x10_LDR; + case Gfx::SE_FORMAT_ASTC_12x10_UNORM_BLOCK: + return MTL::PixelFormatASTC_12x10_LDR; + case Gfx::SE_FORMAT_ASTC_12x12_UNORM_BLOCK: + return MTL::PixelFormatASTC_12x12_LDR; + case Gfx::SE_FORMAT_ASTC_4x4_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_4x4_HDR; + case Gfx::SE_FORMAT_ASTC_5x4_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_5x4_HDR; + case Gfx::SE_FORMAT_ASTC_5x5_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_5x5_HDR; + case Gfx::SE_FORMAT_ASTC_6x5_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_6x5_HDR; + case Gfx::SE_FORMAT_ASTC_6x6_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_6x6_HDR; + case Gfx::SE_FORMAT_ASTC_8x5_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_8x5_HDR; + case Gfx::SE_FORMAT_ASTC_8x6_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_8x6_HDR; + case Gfx::SE_FORMAT_ASTC_8x8_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_8x8_HDR; + case Gfx::SE_FORMAT_ASTC_10x5_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_10x5_HDR; + case Gfx::SE_FORMAT_ASTC_10x6_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_10x6_HDR; + case Gfx::SE_FORMAT_ASTC_10x8_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_10x8_HDR; + case Gfx::SE_FORMAT_ASTC_10x10_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_10x10_HDR; + case Gfx::SE_FORMAT_ASTC_12x10_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_12x10_HDR; + case Gfx::SE_FORMAT_ASTC_12x12_SFLOAT_BLOCK: + return MTL::PixelFormatASTC_12x12_HDR; + case Gfx::SE_FORMAT_G8B8G8R8_422_UNORM: + return MTL::PixelFormatGBGR422; + case Gfx::SE_FORMAT_B8G8R8G8_422_UNORM: + return MTL::PixelFormatBGRG422; + case Gfx::SE_FORMAT_D16_UNORM: + return MTL::PixelFormatDepth16Unorm; + case Gfx::SE_FORMAT_D32_SFLOAT: + return MTL::PixelFormatDepth32Float; + case Gfx::SE_FORMAT_S8_UINT: + return MTL::PixelFormatStencil8; + case Gfx::SE_FORMAT_D24_UNORM_S8_UINT: + return MTL::PixelFormatDepth24Unorm_Stencil8; + case Gfx::SE_FORMAT_D32_SFLOAT_S8_UINT: + return MTL::PixelFormatDepth32Float_Stencil8; + default: + throw std::logic_error("Not implemented"); + } +} +Gfx::SeFormat Seele::Metal::cast(MTL::PixelFormat format) { + switch (format) { + case MTL::PixelFormatInvalid: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatA8Unorm: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatR8Unorm: + return Gfx::SE_FORMAT_R8_UNORM; + case MTL::PixelFormatR8Unorm_sRGB: + return Gfx::SE_FORMAT_R8_SRGB; + case MTL::PixelFormatR8Snorm: + return Gfx::SE_FORMAT_R8_SNORM; + case MTL::PixelFormatR8Uint: + return Gfx::SE_FORMAT_R8_UINT; + case MTL::PixelFormatR8Sint: + return Gfx::SE_FORMAT_R8_SINT; + case MTL::PixelFormatR16Unorm: + return Gfx::SE_FORMAT_R16_UNORM; + case MTL::PixelFormatR16Snorm: + return Gfx::SE_FORMAT_R16_SNORM; + case MTL::PixelFormatR16Uint: + return Gfx::SE_FORMAT_R16_UINT; + case MTL::PixelFormatR16Sint: + return Gfx::SE_FORMAT_R16_SINT; + case MTL::PixelFormatR16Float: + return Gfx::SE_FORMAT_R16_SFLOAT; + case MTL::PixelFormatRG8Unorm: + return Gfx::SE_FORMAT_R8G8_UNORM; + case MTL::PixelFormatRG8Unorm_sRGB: + return Gfx::SE_FORMAT_R8G8_SRGB; + case MTL::PixelFormatRG8Snorm: + return Gfx::SE_FORMAT_R8G8_SNORM; + case MTL::PixelFormatRG8Uint: + return Gfx::SE_FORMAT_R8G8_UINT; + case MTL::PixelFormatRG8Sint: + return Gfx::SE_FORMAT_R8G8_SINT; + case MTL::PixelFormatB5G6R5Unorm: + return Gfx::SE_FORMAT_B5G6R5_UNORM_PACK16; + case MTL::PixelFormatA1BGR5Unorm: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatABGR4Unorm: + return Gfx::SE_FORMAT_R4G4B4A4_UNORM_PACK16; + case MTL::PixelFormatBGR5A1Unorm: + return Gfx::SE_FORMAT_B5G5R5A1_UNORM_PACK16; + case MTL::PixelFormatR32Uint: + return Gfx::SE_FORMAT_R32_UINT; + case MTL::PixelFormatR32Sint: + return Gfx::SE_FORMAT_R32_SINT; + case MTL::PixelFormatR32Float: + return Gfx::SE_FORMAT_R32_SFLOAT; + case MTL::PixelFormatRG16Unorm: + return Gfx::SE_FORMAT_R16G16_UNORM; + case MTL::PixelFormatRG16Snorm: + return Gfx::SE_FORMAT_R16G16_SNORM; + case MTL::PixelFormatRG16Uint: + return Gfx::SE_FORMAT_R16G16_UINT; + case MTL::PixelFormatRG16Sint: + return Gfx::SE_FORMAT_R16G16_SINT; + case MTL::PixelFormatRG16Float: + return Gfx::SE_FORMAT_R16G16_SFLOAT; + case MTL::PixelFormatRGBA8Unorm: + return Gfx::SE_FORMAT_R8G8B8A8_UNORM; + case MTL::PixelFormatRGBA8Unorm_sRGB: + return Gfx::SE_FORMAT_R8G8B8A8_SRGB; + case MTL::PixelFormatRGBA8Snorm: + return Gfx::SE_FORMAT_R8G8B8A8_SNORM; + case MTL::PixelFormatRGBA8Uint: + return Gfx::SE_FORMAT_R8G8B8A8_UINT; + case MTL::PixelFormatRGBA8Sint: + return Gfx::SE_FORMAT_R8G8B8A8_SINT; + case MTL::PixelFormatBGRA8Unorm: + return Gfx::SE_FORMAT_B8G8R8A8_UNORM; + case MTL::PixelFormatBGRA8Unorm_sRGB: + return Gfx::SE_FORMAT_B8G8R8A8_SRGB; + case MTL::PixelFormatRGB10A2Unorm: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatRGB10A2Uint: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatRG11B10Float: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatRGB9E5Float: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatBGR10A2Unorm: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatBGR10_XR: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatBGR10_XR_sRGB: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatRG32Uint: + return Gfx::SE_FORMAT_R32G32_UINT; + case MTL::PixelFormatRG32Sint: + return Gfx::SE_FORMAT_R32G32_SINT; + case MTL::PixelFormatRG32Float: + return Gfx::SE_FORMAT_R32G32_SFLOAT; + case MTL::PixelFormatRGBA16Unorm: + return Gfx::SE_FORMAT_R16G16B16A16_UNORM; + case MTL::PixelFormatRGBA16Snorm: + return Gfx::SE_FORMAT_R16G16B16A16_SNORM; + case MTL::PixelFormatRGBA16Uint: + return Gfx::SE_FORMAT_R16G16B16A16_UINT; + case MTL::PixelFormatRGBA16Sint: + return Gfx::SE_FORMAT_R16G16B16A16_SINT; + case MTL::PixelFormatRGBA16Float: + return Gfx::SE_FORMAT_R16G16B16A16_SFLOAT; + case MTL::PixelFormatBGRA10_XR: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatBGRA10_XR_sRGB: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatRGBA32Uint: + return Gfx::SE_FORMAT_R32G32B32A32_UINT; + case MTL::PixelFormatRGBA32Sint: + return Gfx::SE_FORMAT_R32G32B32A32_SINT; + case MTL::PixelFormatRGBA32Float: + return Gfx::SE_FORMAT_R32G32B32A32_SFLOAT; + case MTL::PixelFormatBC1_RGBA: + return Gfx::SE_FORMAT_BC1_RGBA_UNORM_BLOCK; + case MTL::PixelFormatBC1_RGBA_sRGB: + return Gfx::SE_FORMAT_BC1_RGBA_SRGB_BLOCK; + case MTL::PixelFormatBC2_RGBA: + return Gfx::SE_FORMAT_BC2_UNORM_BLOCK; + case MTL::PixelFormatBC2_RGBA_sRGB: + return Gfx::SE_FORMAT_BC2_SRGB_BLOCK; + case MTL::PixelFormatBC3_RGBA: + return Gfx::SE_FORMAT_BC3_UNORM_BLOCK; + case MTL::PixelFormatBC3_RGBA_sRGB: + return Gfx::SE_FORMAT_BC3_SRGB_BLOCK; + case MTL::PixelFormatBC4_RUnorm: + return Gfx::SE_FORMAT_BC4_UNORM_BLOCK; + case MTL::PixelFormatBC4_RSnorm: + return Gfx::SE_FORMAT_BC4_SNORM_BLOCK; + case MTL::PixelFormatBC5_RGUnorm: + return Gfx::SE_FORMAT_BC4_SNORM_BLOCK; + case MTL::PixelFormatBC5_RGSnorm: + return Gfx::SE_FORMAT_BC5_SNORM_BLOCK; + case MTL::PixelFormatBC6H_RGBFloat: + return Gfx::SE_FORMAT_BC6H_SFLOAT_BLOCK; + case MTL::PixelFormatBC6H_RGBUfloat: + return Gfx::SE_FORMAT_BC6H_UFLOAT_BLOCK; + case MTL::PixelFormatBC7_RGBAUnorm: + return Gfx::SE_FORMAT_BC7_UNORM_BLOCK; + case MTL::PixelFormatBC7_RGBAUnorm_sRGB: + return Gfx::SE_FORMAT_BC7_SRGB_BLOCK; + case MTL::PixelFormatPVRTC_RGB_2BPP: + return Gfx::SE_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG; + case MTL::PixelFormatPVRTC_RGB_2BPP_sRGB: + return Gfx::SE_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG; + case MTL::PixelFormatPVRTC_RGB_4BPP: + return Gfx::SE_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG; + case MTL::PixelFormatPVRTC_RGB_4BPP_sRGB: + return Gfx::SE_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG; + case MTL::PixelFormatPVRTC_RGBA_2BPP: + return Gfx::SE_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG; + case MTL::PixelFormatPVRTC_RGBA_2BPP_sRGB: + return Gfx::SE_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG; + case MTL::PixelFormatPVRTC_RGBA_4BPP: + return Gfx::SE_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG; + case MTL::PixelFormatPVRTC_RGBA_4BPP_sRGB: + return Gfx::SE_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG; + case MTL::PixelFormatEAC_R11Unorm: + return Gfx::SE_FORMAT_EAC_R11_UNORM_BLOCK; + case MTL::PixelFormatEAC_R11Snorm: + return Gfx::SE_FORMAT_EAC_R11_SNORM_BLOCK; + case MTL::PixelFormatEAC_RG11Unorm: + return Gfx::SE_FORMAT_EAC_R11G11_UNORM_BLOCK; + case MTL::PixelFormatEAC_RG11Snorm: + return Gfx::SE_FORMAT_EAC_R11G11_SNORM_BLOCK; + case MTL::PixelFormatEAC_RGBA8: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatEAC_RGBA8_sRGB: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatETC2_RGB8: + return Gfx::SE_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; + case MTL::PixelFormatETC2_RGB8_sRGB: + return Gfx::SE_FORMAT_ETC2_R8G8B8_SRGB_BLOCK; + case MTL::PixelFormatETC2_RGB8A1: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatETC2_RGB8A1_sRGB: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatASTC_4x4_sRGB: + return Gfx::SE_FORMAT_ASTC_4x4_SRGB_BLOCK; + case MTL::PixelFormatASTC_5x4_sRGB: + return Gfx::SE_FORMAT_ASTC_5x4_SRGB_BLOCK; + case MTL::PixelFormatASTC_5x5_sRGB: + return Gfx::SE_FORMAT_ASTC_5x5_SRGB_BLOCK; + case MTL::PixelFormatASTC_6x5_sRGB: + return Gfx::SE_FORMAT_ASTC_6x5_SRGB_BLOCK; + case MTL::PixelFormatASTC_6x6_sRGB: + return Gfx::SE_FORMAT_ASTC_6x6_SRGB_BLOCK; + case MTL::PixelFormatASTC_8x5_sRGB: + return Gfx::SE_FORMAT_ASTC_8x5_SRGB_BLOCK; + case MTL::PixelFormatASTC_8x6_sRGB: + return Gfx::SE_FORMAT_ASTC_8x6_SRGB_BLOCK; + case MTL::PixelFormatASTC_8x8_sRGB: + return Gfx::SE_FORMAT_ASTC_8x8_SRGB_BLOCK; + case MTL::PixelFormatASTC_10x5_sRGB: + return Gfx::SE_FORMAT_ASTC_10x5_SRGB_BLOCK; + case MTL::PixelFormatASTC_10x6_sRGB: + return Gfx::SE_FORMAT_ASTC_10x6_SRGB_BLOCK; + case MTL::PixelFormatASTC_10x8_sRGB: + return Gfx::SE_FORMAT_ASTC_10x8_SRGB_BLOCK; + case MTL::PixelFormatASTC_10x10_sRGB: + return Gfx::SE_FORMAT_ASTC_10x10_SRGB_BLOCK; + case MTL::PixelFormatASTC_12x10_sRGB: + return Gfx::SE_FORMAT_ASTC_12x10_SRGB_BLOCK; + case MTL::PixelFormatASTC_12x12_sRGB: + return Gfx::SE_FORMAT_ASTC_12x12_SRGB_BLOCK; + case MTL::PixelFormatASTC_4x4_LDR: + return Gfx::SE_FORMAT_ASTC_4x4_UNORM_BLOCK; + case MTL::PixelFormatASTC_5x4_LDR: + return Gfx::SE_FORMAT_ASTC_5x4_UNORM_BLOCK; + case MTL::PixelFormatASTC_5x5_LDR: + return Gfx::SE_FORMAT_ASTC_5x5_UNORM_BLOCK; + case MTL::PixelFormatASTC_6x5_LDR: + return Gfx::SE_FORMAT_ASTC_6x5_UNORM_BLOCK; + case MTL::PixelFormatASTC_6x6_LDR: + return Gfx::SE_FORMAT_ASTC_6x6_UNORM_BLOCK; + case MTL::PixelFormatASTC_8x5_LDR: + return Gfx::SE_FORMAT_ASTC_8x5_UNORM_BLOCK; + case MTL::PixelFormatASTC_8x6_LDR: + return Gfx::SE_FORMAT_ASTC_8x6_UNORM_BLOCK; + case MTL::PixelFormatASTC_8x8_LDR: + return Gfx::SE_FORMAT_ASTC_8x8_UNORM_BLOCK; + case MTL::PixelFormatASTC_10x5_LDR: + return Gfx::SE_FORMAT_ASTC_10x5_UNORM_BLOCK; + case MTL::PixelFormatASTC_10x6_LDR: + return Gfx::SE_FORMAT_ASTC_10x6_UNORM_BLOCK; + case MTL::PixelFormatASTC_10x8_LDR: + return Gfx::SE_FORMAT_ASTC_10x8_UNORM_BLOCK; + case MTL::PixelFormatASTC_10x10_LDR: + return Gfx::SE_FORMAT_ASTC_10x10_UNORM_BLOCK; + case MTL::PixelFormatASTC_12x10_LDR: + return Gfx::SE_FORMAT_ASTC_12x10_UNORM_BLOCK; + case MTL::PixelFormatASTC_12x12_LDR: + return Gfx::SE_FORMAT_ASTC_12x12_UNORM_BLOCK; + case MTL::PixelFormatASTC_4x4_HDR: + return Gfx::SE_FORMAT_ASTC_4x4_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_5x4_HDR: + return Gfx::SE_FORMAT_ASTC_5x4_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_5x5_HDR: + return Gfx::SE_FORMAT_ASTC_5x5_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_6x5_HDR: + return Gfx::SE_FORMAT_ASTC_6x5_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_6x6_HDR: + return Gfx::SE_FORMAT_ASTC_6x6_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_8x5_HDR: + return Gfx::SE_FORMAT_ASTC_8x5_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_8x6_HDR: + return Gfx::SE_FORMAT_ASTC_8x6_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_8x8_HDR: + return Gfx::SE_FORMAT_ASTC_8x8_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_10x5_HDR: + return Gfx::SE_FORMAT_ASTC_10x5_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_10x6_HDR: + return Gfx::SE_FORMAT_ASTC_10x6_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_10x8_HDR: + return Gfx::SE_FORMAT_ASTC_10x8_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_10x10_HDR: + return Gfx::SE_FORMAT_ASTC_10x10_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_12x10_HDR: + return Gfx::SE_FORMAT_ASTC_12x10_SFLOAT_BLOCK; + case MTL::PixelFormatASTC_12x12_HDR: + return Gfx::SE_FORMAT_ASTC_12x12_SFLOAT_BLOCK; + case MTL::PixelFormatGBGR422: + return Gfx::SE_FORMAT_G8B8G8R8_422_UNORM; + case MTL::PixelFormatBGRG422: + return Gfx::SE_FORMAT_B8G8R8G8_422_UNORM; + case MTL::PixelFormatDepth16Unorm: + return Gfx::SE_FORMAT_D16_UNORM; + case MTL::PixelFormatDepth32Float: + return Gfx::SE_FORMAT_D32_SFLOAT; + case MTL::PixelFormatStencil8: + return Gfx::SE_FORMAT_S8_UINT; + case MTL::PixelFormatDepth24Unorm_Stencil8: + return Gfx::SE_FORMAT_D24_UNORM_S8_UINT; + case MTL::PixelFormatDepth32Float_Stencil8: + return Gfx::SE_FORMAT_D32_SFLOAT_S8_UINT; + case MTL::PixelFormatX32_Stencil8: + return Gfx::SE_FORMAT_UNDEFINED; + case MTL::PixelFormatX24_Stencil8: + return Gfx::SE_FORMAT_UNDEFINED; + default: + throw std::logic_error("Not implemented"); + } +} diff --git a/src/Engine/Graphics/Metal/Graphics.h b/src/Engine/Graphics/Metal/Graphics.h index 934b78b..f6ebcba 100644 --- a/src/Engine/Graphics/Metal/Graphics.h +++ b/src/Engine/Graphics/Metal/Graphics.h @@ -51,8 +51,13 @@ public: virtual Gfx::OVertexInput createVertexInput(VertexInputStateCreateInfo createInfo) = 0; virtual void resolveTexture(Gfx::PTexture source, Gfx::PTexture destination) = 0; + + MTL::Device* getDevice() const { return device; } protected: MTL::Device* device; + MTL::Library* library; + MTL::CommandQueue* queue; }; +DEFINE_REF(Graphics) } // namespace Metal } // namespace Seele diff --git a/src/Engine/Graphics/Metal/Graphics.cpp b/src/Engine/Graphics/Metal/Graphics.mm similarity index 89% rename from src/Engine/Graphics/Metal/Graphics.cpp rename to src/Engine/Graphics/Metal/Graphics.mm index 88c03c1..7e159c5 100644 --- a/src/Engine/Graphics/Metal/Graphics.cpp +++ b/src/Engine/Graphics/Metal/Graphics.mm @@ -1,12 +1,5 @@ #include "Graphics.h" -#include "Metal/MTLDevice.hpp" -#include "Metal/MTLRenderCommandEncoder.hpp" -#define NS_PRIVATE_IMPLEMENTATION -#define CA_PRIVATE_IMPLEMENTATION -#define MTL_PRIVATE_IMPLEMENTATION -#include "Foundation/Foundation.hpp" -#include "Metal/Metal.hpp" -#include "QuartzCore/QuartzCore.hpp" +#include "Window.h" using namespace Seele; using namespace Seele::Metal; @@ -15,28 +8,35 @@ Graphics::Graphics() { } + Graphics::~Graphics() { } -void Graphics::init(GraphicsInitializer initializer) + +void Graphics::init(GraphicsInitializer) { device = MTL::CreateSystemDefaultDevice(); + library = device->newDefaultLibrary(); + assert(library); + queue = device->newCommandQueue(); } Gfx::OWindow Graphics::createWindow(const WindowCreateInfo &createInfo) { - + return new Window(this, createInfo); } + Gfx::OViewport Graphics::createViewport(Gfx::PWindow owner, const ViewportCreateInfo &createInfo) { - + return new Viewport(owner, createInfo); } Gfx::ORenderPass Graphics::createRenderPass(Gfx::RenderTargetLayout layout, Array dependencies, Gfx::PViewport renderArea) { } + void Graphics::beginRenderPass(Gfx::PRenderPass renderPass) { diff --git a/src/Engine/Graphics/Metal/PrivateImpl.mm b/src/Engine/Graphics/Metal/PrivateImpl.mm new file mode 100644 index 0000000..63a9ca6 --- /dev/null +++ b/src/Engine/Graphics/Metal/PrivateImpl.mm @@ -0,0 +1,6 @@ +#define NS_PRIVATE_IMPLEMENTATION +#define CA_PRIVATE_IMPLEMENTATION +#define MTL_PRIVATE_IMPLEMENTATION +#include +#include +#include \ No newline at end of file diff --git a/src/Engine/Graphics/Metal/RenderPass.h b/src/Engine/Graphics/Metal/RenderPass.h new file mode 100644 index 0000000..de0de3b --- /dev/null +++ b/src/Engine/Graphics/Metal/RenderPass.h @@ -0,0 +1,20 @@ +#pragma once +#include "Graphics/RenderTarget.h" +#include "Graphics.h" + +namespace Seele +{ +namespace Metal +{ +class RenderPass : public Gfx::RenderPass +{ +public: + RenderPass(PGraphics graphics, Gfx::RenderTargetLayout layout, Array dependencies, Gfx::PViewport viewport); + virtual ~RenderPass(); +private: + PGraphics graphics; + Gfx::PViewport viewport; +}; +DEFINE_REF(RenderPass) +} // namespace Metal +} // namespace Seele \ No newline at end of file diff --git a/src/Engine/Graphics/Metal/RenderPass.mm b/src/Engine/Graphics/Metal/RenderPass.mm new file mode 100644 index 0000000..b8a1090 --- /dev/null +++ b/src/Engine/Graphics/Metal/RenderPass.mm @@ -0,0 +1,17 @@ +#include "RenderPass.h" +#include "Graphics/RenderTarget.h" +#include "Metal/MTLRenderPass.hpp" + +using namespace Seele; +using namespace Seele::Metal; + +RenderPass::RenderPass(PGraphics graphics, Gfx::RenderTargetLayout layout, Array dependencies, Gfx::PViewport viewport) + : Gfx::RenderPass(layout, dependencies) + , graphics(graphics) + , viewport(viewport) +{ + +} +RenderPass::~RenderPass() +{ +} \ No newline at end of file diff --git a/src/Engine/Graphics/Metal/Resources.h b/src/Engine/Graphics/Metal/Resources.h new file mode 100644 index 0000000..d91121a --- /dev/null +++ b/src/Engine/Graphics/Metal/Resources.h @@ -0,0 +1,6 @@ +#pragma once +#include +#include +#include +#include +#include \ No newline at end of file diff --git a/src/Engine/Graphics/Metal/Texture.h b/src/Engine/Graphics/Metal/Texture.h new file mode 100644 index 0000000..abbd779 --- /dev/null +++ b/src/Engine/Graphics/Metal/Texture.h @@ -0,0 +1,112 @@ +#pragma once +#include "Graphics/Texture.h" +#include "Graphics.h" +#include "Metal/MTLTexture.hpp" + +namespace Seele +{ +namespace Metal +{ +class TextureBase +{ +public: + TextureBase(PGraphics graphics, MTL::TextureType type, const TextureCreateInfo& createInfo, Gfx::QueueType& owner, MTL::Texture* existingImage = nullptr); + virtual ~TextureBase(); + uint32 getWidth() const + { + return width; + } + uint32 getHeight() const + { + return height; + } + uint32 getDepth() const + { + return depth; + } + constexpr MTL::Texture* getTexture() const + { + return texture; + } + constexpr Gfx::SeImageLayout getLayout() const + { + return layout; + } + void setLayout(Gfx::SeImageLayout val) + { + layout = val; + } + constexpr Gfx::SeFormat getFormat() const + { + return format; + } + constexpr Gfx::SeSampleCountFlags getNumSamples() const + { + return samples; + } + constexpr uint32 getMipLevels() const + { + return mipLevels; + } + void executeOwnershipBarrier(Gfx::QueueType newOwner) { currentOwner = newOwner; } + void executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage, + Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage); + void changeLayout(Gfx::SeImageLayout newLayout, + Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage, + Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage); + void download(uint32 mipLevel, uint32 arrayLayer, uint32 face, Array& buffer); + +protected: + //Updates via reference + Gfx::QueueType& currentOwner; + PGraphics graphics; + uint32 width; + uint32 height; + uint32 depth; + uint32 arrayCount; + uint32 layerCount; + uint32 mipLevels; + uint32 samples; + Gfx::SeFormat format; + Gfx::SeImageUsageFlags usage; + MTL::Texture* texture; + MTL::TextureType type; + Gfx::SeImageLayout layout; + uint8 ownsImage; + friend class Graphics; +}; +DEFINE_REF(TextureBase) +class Texture2D : public Gfx::Texture2D +{ +public: + Texture2D(PGraphics graphics, const TextureCreateInfo& createInfo, MTL::Texture* existingImage = nullptr); + virtual ~Texture2D(); + + virtual Gfx::SeFormat getFormat() const override; + virtual uint32 getWidth() const override; + virtual uint32 getHeight() const override; + virtual uint32 getDepth() const override; + virtual Gfx::SeSampleCountFlags getNumSamples() const override; + virtual uint32 getMipLevels() const override; + virtual void changeLayout(Gfx::SeImageLayout newLayout, + Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage, + Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) override; +protected: + //Inherited via QueueOwnedResource + virtual void executeOwnershipBarrier(Gfx::QueueType newOwner) override; + virtual void executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage, + Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) override; +}; +DEFINE_REF(Texture2D) +class Texture3D : public Gfx::Texture3D +{ + +}; +DEFINE_REF(Texture3D) +class TextureCube : public Gfx::TextureCube +{ + +}; +DEFINE_REF(TextureCube) +} +} \ No newline at end of file diff --git a/src/Engine/Graphics/Metal/Texture.mm b/src/Engine/Graphics/Metal/Texture.mm new file mode 100644 index 0000000..391ad64 --- /dev/null +++ b/src/Engine/Graphics/Metal/Texture.mm @@ -0,0 +1,50 @@ +#include "Texture.h" +#include "Graphics/Enums.h" +#include "Graphics/Initializer.h" +#include "Graphics/Metal/Graphics.h" +#include "Metal/MTLTexture.hpp" +#include "Enums.h" + +using namespace Seele; +using namespace Seele::Metal; + +TextureBase::TextureBase(PGraphics graphics, MTL::TextureType type, const TextureCreateInfo& createInfo, Gfx::QueueType& owner, MTL::Texture* existingImage) + : currentOwner(owner) + , graphics(graphics) + , width(createInfo.width) + , height(createInfo.height) + , depth(createInfo.depth) + , arrayCount(createInfo.elements) + , layerCount(createInfo.layers) + , mipLevels(createInfo.mipLevels) + , samples(createInfo.samples) + , format(createInfo.format) + , usage(createInfo.usage) + , texture(existingImage) + , type(type) + , layout(Gfx::SE_IMAGE_LAYOUT_UNDEFINED) + , ownsImage(existingImage == nullptr) +{ + if(existingImage == nullptr) + { + MTL::TextureDescriptor* descriptor = MTL::TextureDescriptor::alloc()->init(); + descriptor->setPixelFormat(cast(format)); + descriptor->setWidth(width); + descriptor->setHeight(height); + descriptor->setDepth(depth); + descriptor->setArrayLength(arrayCount); + descriptor->setMipmapLevelCount(mipLevels); + descriptor->setTextureType(type); + descriptor->setSampleCount(samples); + descriptor->setUsage(cast(usage)); + + + + descriptor->release(); + } +} + +Texture::~Texture() +{ + +} \ No newline at end of file diff --git a/src/Engine/Graphics/Metal/Window.h b/src/Engine/Graphics/Metal/Window.h new file mode 100644 index 0000000..286ad8f --- /dev/null +++ b/src/Engine/Graphics/Metal/Window.h @@ -0,0 +1,72 @@ +#pragma once +#include "Graphics.h" +#include "Graphics/Window.h" +#include "Resources.h" + +#define GLFW_INCLUDE_NONE +#include +#define GLFW_EXPOSE_NATIVE_COCOA +#include + +#include +#include +#include + +namespace Seele +{ +namespace Metal +{ +class Window : public Gfx::Window +{ +public: + Window(PGraphics graphics, const WindowCreateInfo& createInfo); + virtual ~Window(); + virtual void pollInput() override; + virtual void beginFrame() override; + virtual void endFrame() override; + virtual Gfx::PTexture2D getBackBuffer() override; + virtual void onWindowCloseEvent() override; + virtual void setKeyCallback(std::function callback) override; + virtual void setMouseMoveCallback(std::function callback) override; + virtual void setMouseButtonCallback(std::function callback) override; + virtual void setScrollCallback(std::function callback) override; + virtual void setFileCallback(std::function callback) override; + virtual void setCloseCallback(std::function callback) override; + virtual void setResizeCallback(std::function callback) override; + + void keyPress(KeyCode code, InputAction action, KeyModifier modifier); + void mouseMove(double x, double y); + void mouseButton(MouseButton button, InputAction action, KeyModifier modifier); + void scroll(double x, double y); + void fileDrop(int num, const char** files); + void close(); + void resize(int width, int height); +private: + PGraphics graphics; + WindowCreateInfo preferences; + GLFWwindow* windowHandle; + NSWindow* metalWindow; + CAMetalLayer* metalLayer; + CA::MetalDrawable* drawable; + + std::function keyCallback; + std::function mouseMoveCallback; + std::function mouseButtonCallback; + std::function scrollCallback; + std::function fileCallback; + std::function closeCallback; + std::function resizeCallback; +}; +DEFINE_REF(Window); +class Viewport : public Gfx::Viewport +{ +public: + Viewport(PWindow owner, const ViewportCreateInfo& createInfo); + virtual ~Viewport(); + virtual void resize(uint32 newX, uint32 newY); + virtual void move(uint32 newOffset, uint32 newOffsetY); +private: + Rect viewport; +}; +} // namespace Metal +} // namespace Seele diff --git a/src/Engine/Graphics/Metal/Window.mm b/src/Engine/Graphics/Metal/Window.mm new file mode 100644 index 0000000..10bb021 --- /dev/null +++ b/src/Engine/Graphics/Metal/Window.mm @@ -0,0 +1,217 @@ +#include "Window.h" +#include "Foundation/NSSharedPtr.hpp" +#include "Graphics/Texture.h" +using namespace Seele; +using namespace Seele::Metal; + +double currentFrameDelta = 0; +double Gfx::getCurrentFrameDelta() +{ + return currentFrameDelta; +} + +void glfwKeyCallback(GLFWwindow* handle, int key, int, int action, int modifier) +{ + if (key == -1) + { + return; + } + Window* window = (Window*)glfwGetWindowUserPointer(handle); + window->keyPress((KeyCode)key, (InputAction)action, (KeyModifier)modifier); +} + +void glfwMouseMoveCallback(GLFWwindow* handle, double xpos, double ypos) +{ + Window* window = (Window*)glfwGetWindowUserPointer(handle); + window->mouseMove(xpos, ypos); +} + +void glfwMouseButtonCallback(GLFWwindow* handle, int button, int action, int modifier) +{ + Window* window = (Window*)glfwGetWindowUserPointer(handle); + window->mouseButton((MouseButton)button, (InputAction)action, (KeyModifier)modifier); +} + +void glfwScrollCallback(GLFWwindow* handle, double xoffset, double yoffset) +{ + Window* window = (Window*)glfwGetWindowUserPointer(handle); + window->scroll(xoffset, yoffset); +} + +void glfwFileCallback(GLFWwindow* handle, int count, const char** paths) +{ + Window* window = (Window*)glfwGetWindowUserPointer(handle); + window->fileDrop(count, paths); +} + +void glfwCloseCallback(GLFWwindow* handle) +{ + Window* window = (Window*)glfwGetWindowUserPointer(handle); + window->close(); +} + +void glfwFramebufferResizeCallback(GLFWwindow* handle, int width, int height) +{ + Window* window = (Window*)glfwGetWindowUserPointer(handle); + window->resize(width, height); +} + +Window::Window(PGraphics graphics, const WindowCreateInfo& createInfo) + : graphics(graphics) + , preferences(createInfo) +{ + float xscale, yscale; + glfwGetMonitorContentScale(glfwGetPrimaryMonitor(), &xscale, &yscale); + glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); + GLFWwindow *handle = glfwCreateWindow(createInfo.width / xscale, createInfo.height / yscale, createInfo.title, nullptr, nullptr); + windowHandle = handle; + glfwSetWindowUserPointer(handle, this); + + glfwSetKeyCallback(handle, &glfwKeyCallback); + glfwSetCursorPosCallback(handle, &glfwMouseMoveCallback); + glfwSetMouseButtonCallback(handle, &glfwMouseButtonCallback); + glfwSetScrollCallback(handle, &glfwScrollCallback); + glfwSetDropCallback(handle, &glfwFileCallback); + glfwSetWindowCloseCallback(handle, &glfwCloseCallback); + glfwSetFramebufferSizeCallback(handle, &glfwFramebufferResizeCallback); + + metalWindow = glfwGetCocoaWindow(handle); + metalLayer = [CAMetalLayer layer]; + metalLayer.device = (__bridge id)graphics->getDevice(); + metalLayer.pixelFormat = MTLPixelFormatBGRA8Unorm; + metalLayer.drawableSize = CGSizeMake(createInfo.width, createInfo.height); + metalWindow.contentView.layer = metalLayer; + metalWindow.contentView.wantsLayer = YES; +} + +Window::~Window() +{ + glfwDestroyWindow(static_cast(windowHandle)); +} + +void Window::pollInput() +{ + glfwPollEvents(); +} + +void Window::beginFrame() +{ + @autoreleasepool { + drawable = (__bridge CA::MetalDrawable*)[metalLayer nextDrawable]; + } +} + +void Window::endFrame() +{ +} + +void Window::onWindowCloseEvent() +{ +} + +Gfx::PTexture2D Window::getBackBuffer() +{ + return nullptr; //drawable->texture() +} + +void Window::setKeyCallback(std::function callback) +{ + keyCallback = callback; +} + +void Window::setMouseMoveCallback(std::function callback) +{ + mouseMoveCallback = callback; +} + +void Window::setMouseButtonCallback(std::function callback) +{ + mouseButtonCallback = callback; +} + +void Window::setScrollCallback(std::function callback) +{ + scrollCallback = callback; +} + +void Window::setFileCallback(std::function callback) +{ + fileCallback = callback; +} + +void Window::setCloseCallback(std::function callback) +{ + closeCallback = callback; +} + +void Window::setResizeCallback(std::function callback) +{ + resizeCallback = callback; +} + +void Window::keyPress(KeyCode code, InputAction action, KeyModifier modifier) +{ + keyCallback(code, action, modifier); +} + +void Window::mouseMove(double x, double y) +{ + mouseMoveCallback(x, y); +} + +void Window::mouseButton(MouseButton button, InputAction action, KeyModifier modifier) +{ + mouseButtonCallback(button, action, modifier); +} + +void Window::scroll(double x, double y) +{ + scrollCallback(x, y); +} + +void Window::fileDrop(int num, const char** files) +{ + fileCallback(num, files); +} + +void Window::close() +{ + closeCallback(); +} + +void Window::resize(int width, int height) +{ + if(width == 0 || height == 0) + { + paused = true; + return; + } + paused = true; + resizeCallback(width, height); +} + +Viewport::Viewport(PWindow owner, const ViewportCreateInfo& createInfo) + : Gfx::Viewport(owner, createInfo) +{ + viewport.size.x = sizeX; + viewport.size.y = sizeY; + viewport.offset.x = offsetX; + viewport.offset.y = offsetY; +} + +Viewport::~Viewport() +{ + +} + +void Viewport::resize(uint32 newX, uint32 newY) +{ + viewport.size.x = newX; + viewport.size.y = newY; +} + +void Viewport::move(uint32 newOffset, uint32 newOffsetY) +{ + viewport.offset.x = newOffset; + viewport.offset.y = newOffsetY; +} diff --git a/src/Engine/Graphics/RenderTarget.h b/src/Engine/Graphics/RenderTarget.h index 3144287..37655b4 100644 --- a/src/Engine/Graphics/RenderTarget.h +++ b/src/Engine/Graphics/RenderTarget.h @@ -80,7 +80,7 @@ public: constexpr void setStencilStoreOp(SeAttachmentStoreOp val) { stencilStoreOp = val; } constexpr void setInitialLayout(SeImageLayout val) { initialLayout = val; } constexpr void setFinalLayout(SeImageLayout val) { finalLayout = val; } - SeClearValue clear = { 0 }; + SeClearValue clear = { { { 0 } } }; SeColorComponentFlags componentFlags = 0; protected: PTexture2D texture = nullptr; diff --git a/src/Engine/Graphics/Vulkan/Graphics.cpp b/src/Engine/Graphics/Vulkan/Graphics.cpp index 28735cb..b464e27 100644 --- a/src/Engine/Graphics/Vulkan/Graphics.cpp +++ b/src/Engine/Graphics/Vulkan/Graphics.cpp @@ -78,7 +78,7 @@ Gfx::OWindow Graphics::createWindow(const WindowCreateInfo &createInfo) Gfx::OViewport Graphics::createViewport(Gfx::PWindow owner, const ViewportCreateInfo &viewportInfo) { - return new Viewport(this, owner, viewportInfo); + return new Viewport(owner, viewportInfo); } Gfx::ORenderPass Graphics::createRenderPass(Gfx::RenderTargetLayout layout, Array dependencies, Gfx::PViewport renderArea) diff --git a/src/Engine/Graphics/Vulkan/Window.cpp b/src/Engine/Graphics/Vulkan/Window.cpp index bc700ea..c491fc4 100644 --- a/src/Engine/Graphics/Vulkan/Window.cpp +++ b/src/Engine/Graphics/Vulkan/Window.cpp @@ -184,7 +184,7 @@ void Window::setCloseCallback(std::function callback) closeCallback = callback; } -void Seele::Vulkan::Window::setResizeCallback(std::function callback) +void Window::setResizeCallback(std::function callback) { resizeCallback = callback; } @@ -352,8 +352,8 @@ void Window::createSwapChain() } } -Viewport::Viewport(PGraphics graphics, PWindow owner, const ViewportCreateInfo &viewportInfo) - : Gfx::Viewport(owner, viewportInfo), graphics(graphics) +Viewport::Viewport(PWindow owner, const ViewportCreateInfo &viewportInfo) + : Gfx::Viewport(owner, viewportInfo) { handle.width = static_cast(sizeX); handle.height = static_cast(sizeY); diff --git a/src/Engine/Graphics/Vulkan/Window.h b/src/Engine/Graphics/Vulkan/Window.h index 61e040e..a1a72de 100644 --- a/src/Engine/Graphics/Vulkan/Window.h +++ b/src/Engine/Graphics/Vulkan/Window.h @@ -74,15 +74,13 @@ DEFINE_REF(Window) class Viewport : public Gfx::Viewport { public: - Viewport(PGraphics graphics, PWindow owner, const ViewportCreateInfo &createInfo); + Viewport(PWindow owner, const ViewportCreateInfo &createInfo); virtual ~Viewport(); virtual void resize(uint32 newX, uint32 newY); virtual void move(uint32 newOffsetX, uint32 newOffsetY); VkViewport getHandle() const { return handle; } private: VkViewport handle; - PGraphics graphics; - friend class Graphics; }; DECLARE_REF(Viewport) } diff --git a/src/Engine/Math/Math.h b/src/Engine/Math/Math.h index 722f326..fd1bbc6 100644 --- a/src/Engine/Math/Math.h +++ b/src/Engine/Math/Math.h @@ -7,18 +7,6 @@ namespace Seele { struct Rect { - Rect() - : size(0, 0), offset(0, 0) - { - } - Rect(float sizeX, float sizeY, float offsetX, float offsetY) - : size(sizeX, sizeY), offset(offsetX, offsetY) - { - } - Rect(Vector2 size, Vector2 offset) - : size(size), offset(offset) - { - } bool isEmpty() const { return size.x == 0 || size.y == 0;