Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Basic buffer implementation

Browse Source
This commit is contained in:
Dynamitos
2024-04-11 18:51:47 +02:00
parent 77dc9ef3fd
commit 4dc2df800a
5 changed files with 526 additions and 451 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Graphics/Metal/Buffer.h
+24
View File
@@ -1,6 +1,8 @@
#pragma once
#include "Graphics/Buffer.h"
#include "Graphics/Enums.h"
#include "Graphics/Initializer.h"
#include "Resources.h"
namespace Seele {
namespace Metal {
@@ -8,7 +10,29 @@ DECLARE_REF(Graphics)
class Buffer
{
public:
Buffer(PGraphics graphics, uint64 size, void* data, bool dynamic);
virtual ~Buffer();
MTL::Buffer* getHandle() const
{
return buffers[currentBuffer];
}
uint64 getSize() const
{
return size;
}
void advanceBuffer()
{
currentBuffer = (currentBuffer + 1) % numBuffers;
}
void* map(bool writeOnly = true);
void* mapRegion(uint64 regionOffset, uint64 regionSize, bool writeOnly);
void unmap();
private:
PGraphics graphics;
uint32 currentBuffer;
uint64 size;
MTL::Buffer* buffers[Gfx::numFramesBuffered];
uint32 numBuffers;
};
DEFINE_REF(Buffer)
class VertexBuffer : public Gfx::VertexBuffer, public Buffer
src/Engine/Graphics/Metal/Buffer.mm
+76 -1
View File
@@ -1 +1,76 @@
#include "Buffer.h"
#include "Buffer.h"
#include "Graphics.h"
#include "Graphics/Buffer.h"
#include "Graphics/Enums.h"
#include "Graphics/Initializer.h"
#include "Metal/MTLResource.hpp"
using namespace Seele;
using namespace Seele::Metal;
Buffer::Buffer(PGraphics graphics, uint64 size, void *data, bool dynamic)
: graphics(graphics), size(size) {
if (dynamic) {
numBuffers = Gfx::numFramesBuffered;
} else {
numBuffers = 1;
}
for (size_t i = 0; i < numBuffers; ++i) {
if (data != nullptr) {
buffers[i] = graphics->getDevice()->newBuffer(
data, size, MTL::ResourceOptionCPUCacheModeDefault);
} else {
buffers[i] = graphics->getDevice()->newBuffer(
size, MTL::ResourceOptionCPUCacheModeDefault);
}
}
}
Buffer::~Buffer() {
for (size_t i = 0; i < numBuffers; ++i) {
buffers[i]->release();
}
}
void *Buffer::map(bool) { return getHandle()->contents(); }
void *Buffer::mapRegion(uint64 regionOffset, uint64, bool) {
return (char *)getHandle()->contents() + regionOffset;
}
void unmap() {}
VertexBuffer::VertexBuffer(PGraphics graphics,
const VertexBufferCreateInfo &createInfo)
: Gfx::VertexBuffer(graphics->getFamilyMapping(), createInfo.numVertices,
createInfo.vertexSize, createInfo.sourceData.owner),
Seele::Metal::Buffer(graphics, createInfo.sourceData.size,
createInfo.sourceData.data, false) {}
VertexBuffer::~VertexBuffer() {}
IndexBuffer::IndexBuffer(PGraphics graphics,
const IndexBufferCreateInfo &createInfo)
: Gfx::IndexBuffer(graphics->getFamilyMapping(), createInfo.sourceData.size,
createInfo.indexType, createInfo.sourceData.owner),
Seele::Metal::Buffer(graphics, createInfo.sourceData.size,
createInfo.sourceData.data, false) {}
IndexBuffer::~IndexBuffer() {}
UniformBuffer::UniformBuffer(PGraphics graphics,
const UniformBufferCreateInfo &createInfo)
: Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo.sourceData),
Seele::Metal::Buffer(graphics, createInfo.sourceData.size,
createInfo.sourceData.data, createInfo.dynamic) {}
UniformBuffer::~UniformBuffer() {}
ShaderBuffer::ShaderBuffer(PGraphics graphics,
const ShaderBufferCreateInfo &createInfo)
: Gfx::ShaderBuffer(graphics->getFamilyMapping(), createInfo.numElements,
createInfo.sourceData),
Seele::Metal::Buffer(graphics, createInfo.sourceData.size,
createInfo.sourceData.data, createInfo.dynamic) {}
ShaderBuffer::~ShaderBuffer() {}
src/Engine/Graphics/Metal/Shader.h
+11 -8
View File
@@ -1,12 +1,14 @@
#pragma once
#include "Graphics/Enums.h"
#include "Graphics/Shader.h"
#include "Resources.h"
namespace Seele {
namespace Metal {
class Shader {
public:
Shader(PGraphics graphics);
Shader(PGraphics graphics, Gfx::SeShaderStageFlags stage);
virtual ~Shader();
void create(const ShaderCreateInfo &createInfo);
@@ -19,6 +21,7 @@ public:
uint32 getShaderHash() const;
private:
Gfx::SeShaderStageFlags stage;
PGraphics graphics;
MTL::Library* library;
MTL::Function *function;
@@ -26,16 +29,16 @@ private:
};
DEFINE_REF(Shader)
template <typename Base> class ShaderBase : public Base, public Shader {
template <typename Base, Gfx::SeShaderStageFlags flags> class ShaderBase : public Base, public Shader {
public:
ShaderBase(PGraphics graphics) : Shader(graphics) {}
ShaderBase(PGraphics graphics) : Shader(graphics, flags) {}
virtual ~ShaderBase() {}
};
using VertexShader = ShaderBase<Gfx::VertexShader>;
using FragmentShader = ShaderBase<Gfx::FragmentShader>;
using ComputeShader = ShaderBase<Gfx::ComputeShader>;
using TaskShader = ShaderBase<Gfx::TaskShader>;
using MeshShader = ShaderBase<Gfx::MeshShader>;
using VertexShader = ShaderBase<Gfx::VertexShader, Gfx::SE_SHADER_STAGE_VERTEX_BIT>;
using FragmentShader = ShaderBase<Gfx::FragmentShader, Gfx::SE_SHADER_STAGE_FRAGMENT_BIT>;
using ComputeShader = ShaderBase<Gfx::ComputeShader, Gfx::SE_SHADER_STAGE_COMPUTE_BIT>;
using TaskShader = ShaderBase<Gfx::TaskShader, Gfx::SE_SHADER_STAGE_TASK_BIT_NV>;
using MeshShader = ShaderBase<Gfx::MeshShader, Gfx::SE_SHADER_STAGE_MESH_BIT_NV>;
DEFINE_REF(VertexShader)
DEFINE_REF(FragmentShader)
src/Engine/Graphics/Metal/Shader.mm
+34 -21
View File
@@ -1,13 +1,16 @@
#include "Shader.h"
#include "Graphics.h"
#include "Graphics/Enums.h"
#include "Graphics/slang-compile.h"
#include "Metal/MTLLibrary.hpp"
#include "metal_irconverter/metal_irconverter.h"
#include <slang.h>
using namespace Seele;
using namespace Seele::Metal;
Shader::Shader(PGraphics graphics) : graphics(graphics) {}
Shader::Shader(PGraphics graphics, Gfx::SeShaderStageFlags stage)
: stage(stage), graphics(graphics) {}
Shader::~Shader() {
if (function) {
function->release();
@@ -16,42 +19,52 @@ Shader::~Shader() {
}
void Shader::create(const ShaderCreateInfo &createInfo) {
Slang::ComPtr<slang::IBlob> kernelBlob = generateShader(createInfo, SLANG_DXIL);
thread_local IRCompiler* pCompiler = nullptr;
if(pCompiler == nullptr)
{
Slang::ComPtr<slang::IBlob> kernelBlob =
generateShader(createInfo, SLANG_DXIL);
thread_local IRCompiler *pCompiler = nullptr;
if (pCompiler == nullptr) {
pCompiler = IRCompilerCreate();
}
IRCompilerSetEntryPointName(pCompiler, "main");
IRObject* pDXIL = IRObjectCreateFromDXIL(kernelBlob->getBufferPointer(), kernelBlob->getBufferSize(), IRBytecodeOwnershipNone);
IRObject *pDXIL = IRObjectCreateFromDXIL(
(const uint8 *)kernelBlob->getBufferPointer(),
kernelBlob->getBufferSize(), IRBytecodeOwnershipNone);
// Compile DXIL to Metal IR:
IRError* pError = nullptr;
IRObject* pOutIR = IRCompilerAllocCompileAndLink(pCompiler, NULL, pDXIL, &pError);
IRError *pError = nullptr;
IRObject *pOutIR =
IRCompilerAllocCompileAndLink(pCompiler, NULL, pDXIL, &pError);
if (!pOutIR)
{
if (!pOutIR) {
// Inspect pError to determine cause.
IRErrorDestroy( pError );
IRErrorDestroy(pError);
}
IRShaderStage irStage;
switch (stage) {
case Gfx::SE_SHADER_STAGE_VERTEX_BIT: irStage = IRShaderStageVertex;
case Gfx::SE_SHADER_STAGE_FRAGMENT_BIT: irStage = IRShaderStageFragment;
case Gfx::SE_SHADER_STAGE_COMPUTE_BIT: irStage = IRShaderStageCompute;
case Gfx::SE_SHADER_STAGE_TASK_BIT_NV: irStage = IRShaderStageAmplification;
case Gfx::SE_SHADER_STAGE_MESH_BIT_NV: irStage = IRShaderStageMesh;
}
// Retrieve Metallib:
MetaLibBinary* pMetallib = IRMetalLibBinaryCreate();
IRObjectGetMetalLibBinary(pOutIR, stage, pMetallib);
IRMetalLibBinary *pMetallib = IRMetalLibBinaryCreate();
IRObjectGetMetalLibBinary(pOutIR, irStage, pMetallib);
size_t metallibSize = IRMetalLibGetBytecodeSize(pMetallib);
uint8_t* metallib = new uint8_t[metallibSize];
uint8_t *metallib = new uint8_t[metallibSize];
IRMetalLibGetBytecode(pMetallib, metallib);
// Store the metallib to custom format or disk, or use to create a MTLLibrary.
NS::Error* __autoreleasing error = nil;
dispatch_data_t data =
dispatch_data_create(metallib, metallibSize, dispatch_get_main_queue(), NULL);
NS::Error *__autoreleasing error = nil;
dispatch_data_t data = dispatch_data_create(metallib, metallibSize,
dispatch_get_main_queue(), NULL);
library = graphics->getDevice()->newLibrary(data, &error);
function = library->newFunction(NS::String::string("main", NS::ASCIIStringEncoding));
delete [] metallib;
function =
library->newFunction(NS::String::string("main", NS::ASCIIStringEncoding));
delete[] metallib;
IRMetalLibBinaryDestroy(pMetallib);
IRObjectDestroy(pDXIL);
IRObjectDestroy(pOutIR);