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

slang doesnt support mesh shading yet, exploring later

Browse Source
This commit is contained in:
Dynamitos
2024-04-21 10:37:15 +02:00
parent d09dcb3a33
commit 16c7fb5159
7 changed files with 20 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Graphics/Metal/Descriptor.h
+1 -1
View File
@@ -71,7 +71,7 @@ public:
PipelineLayout(PGraphics graphics, const std::string& name, Gfx::PPipelineLayout baseLayout);
virtual ~PipelineLayout();
virtual void create() override;
Array<Array<uint32>>
private:
PGraphics graphics;
};
src/Engine/Graphics/Metal/Shader.mm
+8 -116
View File
@@ -9,7 +9,6 @@
#include "Metal/MTLLibrary.hpp"
#include <fstream>
#include <iostream>
#include <metal_irconverter/metal_irconverter.h>
#include <slang.h>
using namespace Seele;
@@ -27,127 +26,20 @@ Shader::~Shader() {
void Shader::create(const ShaderCreateInfo& createInfo) {
std::cout << "Compiling " << createInfo.name << std::endl;
Map<std::string, uint32> paramMapping;
Slang::ComPtr<slang::IBlob> kernelBlob = generateShader(createInfo, SLANG_DXIL, paramMapping);
Slang::ComPtr<slang::IBlob> kernelBlob = generateShader(createInfo, SLANG_METAL, paramMapping);
std::cout << (char*)kernelBlob->getBufferPointer() << std::endl;
hash = CRC::Calculate(kernelBlob->getBufferPointer(), kernelBlob->getBufferSize(), CRC::CRC_32());
IRCompiler* pCompiler = IRCompilerCreate();
IRCompilerSetMinimumGPUFamily(pCompiler, IRGPUFamilyMetal3);
IRCompilerIgnoreRootSignature(pCompiler, true);
IRCompilerSetEntryPointName(pCompiler, "main");
IRCompilerSetValidationFlags(pCompiler, IRCompilerValidationFlagAll);
IRObject* pDXIL = IRObjectCreateFromDXIL((const uint8*)kernelBlob->getBufferPointer(), kernelBlob->getBufferSize(),
IRBytecodeOwnershipNone);
IRVersionedRootSignatureDescriptor descriptor;
descriptor.version = IRRootSignatureVersion_1_1;
Map<std::string, Gfx::PDescriptorLayout> layouts = createInfo.rootSignature->getLayouts();
descriptor.desc_1_1.NumParameters = layouts.size();
descriptor.desc_1_1.NumStaticSamplers = 0;
descriptor.desc_1_1.pStaticSamplers = nullptr;
Array<IRRootParameter1> parameters;
// each layout has an array for its bindings
Array<Array<IRDescriptorRange1>> ranges;
for (const auto& [name, layout] : layouts) {
uint32 textureReg = 0; // SRV
uint32 samplerReg = 0; // Sampler
uint32 uavReg = 0; // UAV
uint32 constantReg = 0; // CBV
auto& bindingRanges = ranges.add();
for (auto binding : layout->getBindings()) {
IRDescriptorRangeType type;
uint32 reg = 0;
switch (binding.descriptorType) {
case Gfx::SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
type = IRDescriptorRangeTypeSRV;
reg = textureReg++;
break;
case Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
type = IRDescriptorRangeTypeCBV;
reg = constantReg++;
break;
case Gfx::SE_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
case Gfx::SE_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER:
if (binding.access == Gfx::SE_DESCRIPTOR_ACCESS_READ_ONLY_BIT) {
type = IRDescriptorRangeTypeSRV;
reg = textureReg++;
break;
} else {
type = IRDescriptorRangeTypeUAV;
reg = uavReg++;
break;
}
default:
throw std::logic_error("Not implemented");
};
bindingRanges.add() = IRDescriptorRange1{
.BaseShaderRegister = reg,
.NumDescriptors = binding.descriptorCount,
.RangeType = type,
.RegisterSpace = createInfo.rootSignature->findParameter(name),
.Flags = IRDescriptorRangeFlagDescriptorsStaticKeepingBufferBoundsChecks,
};
dispatch_data_t dispatchData = dispatch_data_create(kernelBlob->getBufferPointer(), kernelBlob->getBufferSize(), dispatch_get_main_queue(), NULL);
NS::Error* error;
library = graphics->getDevice()->newLibrary(dispatchData, &error);
if(error)
{
std::cout << error->localizedDescription()->cString(NS::ASCIIStringEncoding) << std::endl;
}
parameters.add() = IRRootParameter1{
.ParameterType = IRRootParameterTypeDescriptorTable,
.DescriptorTable =
IRRootDescriptorTable1{.NumDescriptorRanges = (uint32)(bindingRanges.size()), bindingRanges.data()},
.ShaderVisibility = IRShaderVisibilityAll,
};
}
IRError* signatureError = nullptr;
descriptor.desc_1_1.NumParameters = parameters.size();
descriptor.desc_1_1.pParameters = parameters.data();
IRRootSignature* rootSignature = IRRootSignatureCreateFromDescriptor(&descriptor, &signatureError);
assert(rootSignature);
// IRCompilerSetGlobalRootSignature(pCompiler, rootSignature);
// Compile DXIL to Metal IR:
IRError* pError = nullptr;
IRObject* pOutIR = IRCompilerAllocCompileAndLink(pCompiler, NULL, pDXIL, &pError);
if (!pOutIR) {
// Inspect pError to determine cause.
IRErrorDestroy(pError);
}
IRShaderStage irStage;
switch (stage) {
case Gfx::SE_SHADER_STAGE_VERTEX_BIT:
irStage = IRShaderStageVertex;
break;
case Gfx::SE_SHADER_STAGE_FRAGMENT_BIT:
irStage = IRShaderStageFragment;
break;
case Gfx::SE_SHADER_STAGE_COMPUTE_BIT:
irStage = IRShaderStageCompute;
break;
case Gfx::SE_SHADER_STAGE_TASK_BIT_EXT:
irStage = IRShaderStageAmplification;
break;
case Gfx::SE_SHADER_STAGE_MESH_BIT_EXT:
irStage = IRShaderStageMesh;
break;
}
// Retrieve Metallib:
IRMetalLibBinary* pMetallib = IRMetalLibBinaryCreate();
IRObjectGetMetalLibBinary(pOutIR, irStage, pMetallib);
dispatch_data_t data = IRMetalLibGetBytecodeData(pMetallib);
IRShaderReflection* reflection = IRShaderReflectionCreate();
IRObjectGetReflection(pOutIR, irStage, reflection);
std::cout << IRShaderReflectionAllocStringAndSerialize(reflection) << std::endl;
IRShaderReflectionDestroy(reflection);
// Store the metallib to custom format or disk, or use to create a MTLLibrary.
NS::Error* error;
library = graphics->getDevice()->newLibrary(data, &error);
function = library->newFunction(NS::String::string("main", NS::ASCIIStringEncoding));
if (!function) {
assert(false);
}
IRMetalLibBinaryDestroy(pMetallib);
IRObjectDestroy(pDXIL);
IRObjectDestroy(pOutIR);
IRCompilerDestroy(pCompiler);
}
uint32 Shader::getShaderHash() const { return hash; }