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

Adding normal mapping

Browse Source
This commit is contained in:
Dynamitos
2024-07-15 17:55:22 +02:00
parent 38986f4bfc
commit 064ba22391
15 changed files with 151 additions and 210 deletions
Download Patch File Download Diff File Expand all files Collapse all files
res/shaders/lib/BRDF.slang
+17 -20
View File
@@ -2,7 +2,7 @@ import Common;
interface IBRDF interface IBRDF
{ {
float3 evaluate(float3x3 tbn, float3 viewDir_WS, float3 lightDir_WS, float3 normal_WS, float3 lightColor); float3 evaluate(float3 viewDir_TS, float3 lightDir_TS, float3 lightColor);
float3 evaluateAmbient(); float3 evaluateAmbient();
}; };
@@ -19,13 +19,12 @@ struct Phong : IBRDF
normal = float3(0, 0, 1); normal = float3(0, 0, 1);
} }
float3 evaluate(float3x3 tbn, float3 viewDir_WS, float3 lightDir_WS, float3 n, float3 lightColor) float3 evaluate(float3 viewDir_TS, float3 lightDir_TS, float3 lightColor)
{ {
float3 normal_TS = normal; float3 normal_TS = normal;
float3 normal_WS = n;//normalize(mul(tbn, normal_TS)); float3 nDotL = dot(normal_TS, lightDir_TS);
float3 nDotL = dot(normal_WS, lightDir_WS); float3 r = 2 * (nDotL) * normal_TS - lightDir_TS;
float3 r = 2 * (nDotL) * normal_WS - lightDir_WS; float rDotV = dot(r, viewDir_TS);
float rDotV = dot(r, viewDir_WS);
return lightColor * (baseColor * max(nDotL, 0.0));// + specular * pow(max(rDotV, 0.0), max(shininess, 1))); return lightColor * (baseColor * max(nDotL, 0.0));// + specular * pow(max(rDotV, 0.0), max(shininess, 1)));
} }
@@ -49,12 +48,11 @@ struct BlinnPhong : IBRDF
normal = float3(0, 0, 1); normal = float3(0, 0, 1);
} }
float3 evaluate(float3x3 tbn, float3 viewDir_WS, float3 lightDir_WS, float3 normal_WS, float3 lightColor) float3 evaluate(float3 viewDir_TS, float3 lightDir_TS, float3 lightColor)
{ {
float3 normal_TS = normalize(normal); float3 normal_TS = normalize(normal);
//float3 normal_WS = normalize(mul(tbn, normal_TS)); float diffuse = max(dot(normal_TS, lightDir_TS), 0);
float diffuse = max(dot(normal_WS, lightDir_WS), 0); float3 h = normalize(lightDir_TS + viewDir_TS);
float3 h = normalize(lightDir_WS + viewDir_WS);
float specular = pow(saturate(dot(normal_TS, h)), shininess); float specular = pow(saturate(dot(normal_TS, h)), shininess);
return (baseColor * diffuse * lightColor) + (specularColor * specular); return (baseColor * diffuse * lightColor) + (specularColor * specular);
@@ -76,11 +74,10 @@ struct CelShading : IBRDF
normal = float3(0, 0, 1); normal = float3(0, 0, 1);
} }
float3 evaluate(float3x3 tbn, float3 viewDir_WS, float3 lightDir_WS, float3 n, float3 lightColor) float3 evaluate(float3 viewDir_TS, float3 lightDir_TS, float3 lightColor)
{ {
float3 normal_TS = normalize(normal); float3 normal_TS = normalize(normal);
float3 normal_WS = normalize(mul(tbn, normal_TS)); float nDotL = dot(normal_TS, lightDir_TS);
float nDotL = dot(normal_WS, lightDir_WS);
float diffuse = max(nDotL, 0); float diffuse = max(nDotL, 0);
float3 darkenedBase = baseColor * 0.8; float3 darkenedBase = baseColor * 0.8;
@@ -148,21 +145,21 @@ struct CookTorrance : IBRDF
return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0); return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
} }
float3 evaluate(float3x3 tbn, float3 viewDir_WS, float3 lightDir_WS, float3 normal_WS, float3 lightColor) float3 evaluate(float3 viewDir_TS, float3 lightDir_TS, float3 lightColor)
{ {
float3 n = normal_WS;//normalize(mul(tbn, normal)); float3 n = normal;//normalize(mul(tbn, normal));
float3 h = normalize(lightDir_WS + viewDir_WS); float3 h = normalize(lightDir_TS + viewDir_TS);
float3 F0 = float3(0.04); float3 F0 = float3(0.04);
F0 = lerp(F0, baseColor, metallic); F0 = lerp(F0, baseColor, metallic);
float3 F = FresnelSchlick(max(dot(h, viewDir_WS), 0.0), F0); float3 F = FresnelSchlick(max(dot(h, viewDir_TS), 0.0), F0);
float NDF = TrowbridgeReitzGGX(n, h); float NDF = TrowbridgeReitzGGX(n, h);
float G = Smith(n, viewDir_WS, lightDir_WS); float G = Smith(n, viewDir_TS, lightDir_TS);
float3 num = NDF * G * F; float3 num = NDF * G * F;
float denom = 4.0 * max(dot(n, viewDir_WS), 0.0) * max(dot(n, lightDir_WS), 0.0) + 0.000001; float denom = 4.0 * max(dot(n, viewDir_TS), 0.0) * max(dot(n, lightDir_TS), 0.0) + 0.000001;
float3 specular = num / denom; float3 specular = num / denom;
float3 k_s = F; float3 k_s = F;
@@ -170,7 +167,7 @@ struct CookTorrance : IBRDF
k_d *= 1.0 - metallic; k_d *= 1.0 - metallic;
float nDotL = max(dot(n, lightDir_WS), 0.0); float nDotL = max(dot(n, lightDir_TS), 0.0);
float3 result = (k_d * baseColor / PI + specular) * nDotL * lightColor; float3 result = (k_d * baseColor / PI + specular) * nDotL * lightColor;
return result * ambientOcclusion; return result * ambientOcclusion;
res/shaders/lib/LightEnv.slang
+6 -4
View File
@@ -14,7 +14,8 @@ struct DirectionalLight : ILightEnv
float3 illuminate<B:IBRDF>(LightingParameter params, B brdf) float3 illuminate<B:IBRDF>(LightingParameter params, B brdf)
{ {
return brdf.evaluate(params.tbn, params.viewDir_WS, -normalize(direction.xyz), params.normal_WS, color.xyz); float3 dir_TS = mul(params.tbn, -normalize(direction.xyz));
return brdf.evaluate(params.viewDir_TS, dir_TS, color.xyz);
} }
}; };
@@ -25,10 +26,11 @@ struct PointLight : ILightEnv
float3 illuminate<B:IBRDF>(LightingParameter params, B brdf) float3 illuminate<B:IBRDF>(LightingParameter params, B brdf)
{ {
float3 lightDir_WS = position_WS.xyz - params.position_WS; float3 pos_TS = mul(params.tbn, position_WS.xyz);
float d = length(lightDir_WS); float3 lightDir_TS = pos_TS.xyz - params.position_TS;
float d = length(lightDir_TS);
float illuminance = max(1 - d / colorRange.w, 0); float illuminance = max(1 - d / colorRange.w, 0);
return illuminance * brdf.evaluate(params.tbn, params.viewDir_WS, normalize(lightDir_WS), normalize(params.normal_WS), colorRange.xyz); return illuminance * brdf.evaluate(params.viewDir_TS, normalize(lightDir_TS), colorRange.xyz);
} }
bool insidePlane(Plane plane, float3 position) bool insidePlane(Plane plane, float3 position)
res/shaders/lib/MaterialParameter.slang
+8 -7
View File
@@ -11,9 +11,9 @@ struct MaterialParameter
struct LightingParameter struct LightingParameter
{ {
float3x3 tbn; float3x3 tbn;
float3 normal_WS; float3 normal_TS;
float3 position_WS; float3 position_TS;
float3 viewDir_WS; float3 viewDir_TS;
}; };
// data passed to fragment shader // data passed to fragment shader
@@ -42,10 +42,11 @@ struct FragmentParameter
LightingParameter getLightingParameter() LightingParameter getLightingParameter()
{ {
LightingParameter result; LightingParameter result;
result.tbn = float3x3(normalize(tangent_WS), normalize(biTangent_WS), normalize(normal_WS)); float3x3 tbn = float3x3(normalize(tangent_WS), normalize(biTangent_WS), normalize(normal_WS));
result.position_WS = position_WS; result.tbn = tbn;
result.viewDir_WS = normalize(cameraPos_WS - position_WS); result.position_TS = mul(tbn, position_WS);
result.normal_WS = normal_WS; result.viewDir_TS = mul(tbn, normalize(cameraPos_WS - position_WS));
result.normal_TS = mul(tbn, normal_WS);
return result; return result;
} }
#endif #endif
res/shaders/raytracing/ClosestHit.slang
+43 -28
View File
@@ -3,40 +3,55 @@ import MaterialParameter;
import LightEnv; import LightEnv;
import Scene; import Scene;
import RayTracingData; import RayTracingData;
import VertexData;
import Material;
import MATERIAL_FILE_NAME;
// simplification: all BLAS only have 1 geometry // simplification: all BLAS only have 1 geometry
[shader("closesthit")] [shader("closesthit")]
void closestHit(inout RayPayload hitValue, in BuiltInTriangleIntersectionAttributes attr) void closestHit(inout RayPayload hitValue, in BuiltInTriangleIntersectionAttributes attr)
{ {
//const float3 barycentricCoords = float3(1.0f - attr.barycentrics.x - attr.barycentrics.y, attr.barycentrics.x, attr.barycentrics.y); const float3 barycentricCoords = float3(1.0f - attr.barycentrics.x - attr.barycentrics.y, attr.barycentrics.x, attr.barycentrics.y);
//InstanceData inst = pScene.instances[InstanceID()]; InstanceData inst = pScene.instances[InstanceID()];
//MeshData m = pScene.meshData[InstanceID()]; MeshData m = pScene.meshData[InstanceID()];
//
//// offset into the index buffer
//uint indexOffset = m.firstIndex;
//// added to indices to reference correct part of global mesh pool
//uint vertexOffset = pScene.meshletInfos[m.meshletOffset].indicesOffset;
//
//uint vertexIndex0 = vertexOffset + pRayTracingParams.indexBuffer[indexOffset + 3 * PrimitiveIndex() + 0];
//uint vertexIndex1 = vertexOffset + pRayTracingParams.indexBuffer[indexOffset + 3 * PrimitiveIndex() + 1];
//uint vertexIndex2 = vertexOffset + pRayTracingParams.indexBuffer[indexOffset + 3 * PrimitiveIndex() + 2];
//
//VertexAttributes attr0 = pVertexData.getAttributes(vertexIndex0);
//VertexAttributes attr1 = pVertexData.getAttributes(vertexIndex1);
//VertexAttributes attr2 = pVertexData.getAttributes(vertexIndex2);
//
//FragmentParameter f0 = attr0.getParameter(inst.transformMatrix);
//FragmentParameter f1 = attr1.getParameter(inst.transformMatrix);
//FragmentParameter f2 = attr2.getParameter(inst.transformMatrix);
//
//FragmentParameter params = FragmentParameter.interpolate(f0, f1, f2, barycentricCoords);
//
//CallablePayload callable;
//callable.params = params;
//
//CallShader(InstanceID(), callable);
hitValue.color = float3(1, 0, 0); // offset into the index buffer
uint indexOffset = m.firstIndex;
// added to indices to reference correct part of global mesh pool
uint vertexOffset = pScene.meshletInfos[m.meshletOffset].indicesOffset;
uint vertexIndex0 = vertexOffset + pRayTracingParams.indexBuffer[indexOffset + 3 * PrimitiveIndex() + 0];
uint vertexIndex1 = vertexOffset + pRayTracingParams.indexBuffer[indexOffset + 3 * PrimitiveIndex() + 1];
uint vertexIndex2 = vertexOffset + pRayTracingParams.indexBuffer[indexOffset + 3 * PrimitiveIndex() + 2];
VertexAttributes attr0 = pVertexData.getAttributes(vertexIndex0);
VertexAttributes attr1 = pVertexData.getAttributes(vertexIndex1);
VertexAttributes attr2 = pVertexData.getAttributes(vertexIndex2);
FragmentParameter f0 = attr0.getParameter(inst.transformMatrix);
FragmentParameter f1 = attr1.getParameter(inst.transformMatrix);
FragmentParameter f2 = attr2.getParameter(inst.transformMatrix);
FragmentParameter params = FragmentParameter.interpolate(f0, f1, f2, barycentricCoords);
LightingParameter lightingParams = params.getLightingParameter();
MaterialParameter materialParams = params.getMaterialParameter();
let brdf = Material.prepare(materialParams);
float3 result = float3(0, 0, 0);
for(int i = 0; i < pLightEnv.numDirectionalLights; ++i)
{
result += pLightEnv.directionalLights[i].illuminate(lightingParams, brdf);
}
for(uint i = 0; i < pLightEnv.numPointLights; ++i)
{
result += pLightEnv.pointLights[i].illuminate(lightingParams, brdf);
}
result += brdf.evaluateAmbient();
// gamma correction
result = result / (result + float3(1.0));
result = pow(result, float3(1.0/2.2));
hitValue.color = getMaterialTextureParameter(0).Sample(getMaterialSamplerParameter(0), params.texCoords[0]).xyz;
} }
src/Engine/Asset/TextureAsset.cpp
+3 -4
View File
@@ -22,9 +22,7 @@ TextureAsset::TextureAsset(std::string_view folderPath, std::string_view name) :
TextureAsset::~TextureAsset() {} TextureAsset::~TextureAsset() {}
void TextureAsset::save(ArchiveBuffer& buffer) const { void TextureAsset::save(ArchiveBuffer& buffer) const { Serialization::save(buffer, ktxData); }
Serialization::save(buffer, ktxData);
}
void TextureAsset::load(ArchiveBuffer& buffer) { void TextureAsset::load(ArchiveBuffer& buffer) {
ktxTexture2* ktxHandle; ktxTexture2* ktxHandle;
@@ -33,7 +31,7 @@ void TextureAsset::load(ArchiveBuffer& buffer) {
ktxTexture_CreateFromMemory(ktxData.data(), ktxData.size(), KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT, (ktxTexture**)&ktxHandle)); ktxTexture_CreateFromMemory(ktxData.data(), ktxData.size(), KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT, (ktxTexture**)&ktxHandle));
ktxTexture2_TranscodeBasis(ktxHandle, KTX_TTF_RGBA32, 0); ktxTexture2_TranscodeBasis(ktxHandle, KTX_TTF_RGBA32, 0);
//ktxTexture2_DeflateZstd(ktxHandle, 0); // ktxTexture2_DeflateZstd(ktxHandle, 0);
Gfx::PGraphics graphics = buffer.getGraphics(); Gfx::PGraphics graphics = buffer.getGraphics();
TextureCreateInfo createInfo = { TextureCreateInfo createInfo = {
@@ -51,6 +49,7 @@ void TextureAsset::load(ArchiveBuffer& buffer) {
.layers = ktxHandle->numFaces, .layers = ktxHandle->numFaces,
.elements = ktxHandle->numLayers, .elements = ktxHandle->numLayers,
.usage = Gfx::SE_IMAGE_USAGE_SAMPLED_BIT, .usage = Gfx::SE_IMAGE_USAGE_SAMPLED_BIT,
.name = name,
}; };
if (ktxHandle->isCubemap) { if (ktxHandle->isCubemap) {
texture = graphics->createTextureCube(createInfo); texture = graphics->createTextureCube(createInfo);
src/Engine/Graphics/RenderPass/RayTracingPass.cpp
+15 -19
View File
@@ -33,7 +33,7 @@ RayTracingPass::RayTracingPass(Gfx::PGraphics graphics, PScene scene) : RenderPa
pipelineLayout->addDescriptorLayout(StaticMeshVertexData::getInstance()->getInstanceDataLayout()); pipelineLayout->addDescriptorLayout(StaticMeshVertexData::getInstance()->getInstanceDataLayout());
graphics->getShaderCompiler()->registerRenderPass("RayTracing", Gfx::PassConfig{ graphics->getShaderCompiler()->registerRenderPass("RayTracing", Gfx::PassConfig{
.baseLayout = pipelineLayout, .baseLayout = pipelineLayout,
.mainFile = "Callable", .mainFile = "ClosestHit",
.useMaterial = true, .useMaterial = true,
.rayTracing = true, .rayTracing = true,
}); });
@@ -42,8 +42,7 @@ RayTracingPass::RayTracingPass(Gfx::PGraphics graphics, PScene scene) : RenderPa
void RayTracingPass::beginFrame(const Component::Camera& cam) { RenderPass::beginFrame(cam); } void RayTracingPass::beginFrame(const Component::Camera& cam) { RenderPass::beginFrame(cam); }
void RayTracingPass::render() { void RayTracingPass::render() {
Gfx::ORenderCommand command = graphics->createRenderCommand("RayTracing"); Array<Gfx::RayTracingHitGroup> callableGroups;
Array<Gfx::RayTracingCallableGroup> callableGroups;
Array<Gfx::PBottomLevelAS> accelerationStructures; Array<Gfx::PBottomLevelAS> accelerationStructures;
Array<InstanceData> instanceData; Array<InstanceData> instanceData;
@@ -64,8 +63,8 @@ void RayTracingPass::render() {
for (auto& inst : matData.instances) { for (auto& inst : matData.instances) {
for (uint32 i = 0; i < inst.instanceData.size(); ++i) { for (uint32 i = 0; i < inst.instanceData.size(); ++i) {
Gfx::RayTracingCallableGroup callableGroup = { Gfx::RayTracingHitGroup callableGroup = {
.shader = collection->callableShader, .closestHitShader = collection->callableShader,
}; };
callableGroup.parameters.resize(sizeof(VertexData::DrawCallOffsets)); callableGroup.parameters.resize(sizeof(VertexData::DrawCallOffsets));
std::memcpy(callableGroup.parameters.data(), &inst.offsets, sizeof(VertexData::DrawCallOffsets)); std::memcpy(callableGroup.parameters.data(), &inst.offsets, sizeof(VertexData::DrawCallOffsets));
@@ -77,6 +76,13 @@ void RayTracingPass::render() {
} }
} }
} }
pipeline = graphics->createRayTracingPipeline(Gfx::RayTracingPipelineCreateInfo{
.pipelineLayout = pipelineLayout,
.rayGenGroup = {.shader = rayGen},
.hitGroups = callableGroups,
.missGroups = {{.shader = miss}},
//.callableGroups = callableGroups,
});
tlas = graphics->createTopLevelAccelerationStructure(Gfx::TopLevelASCreateInfo{ tlas = graphics->createTopLevelAccelerationStructure(Gfx::TopLevelASCreateInfo{
.instances = instanceData, .instances = instanceData,
.bottomLevelStructures = accelerationStructures, .bottomLevelStructures = accelerationStructures,
@@ -87,6 +93,7 @@ void RayTracingPass::render() {
desc->updateBuffer(2, StaticMeshVertexData::getInstance()->getIndexBuffer()); desc->updateBuffer(2, StaticMeshVertexData::getInstance()->getIndexBuffer());
desc->writeChanges(); desc->writeChanges();
Gfx::ORenderCommand command = graphics->createRenderCommand("RayTracing");
command->bindPipeline(pipeline); command->bindPipeline(pipeline);
StaticMeshVertexData::getInstance()->getInstanceDataSet()->writeChanges(); StaticMeshVertexData::getInstance()->getInstanceDataSet()->writeChanges();
StaticMeshVertexData::getInstance()->getVertexDataSet()->writeChanges(); StaticMeshVertexData::getInstance()->getVertexDataSet()->writeChanges();
@@ -118,26 +125,15 @@ void RayTracingPass::publishOutputs() {
Gfx::SE_ACCESS_SHADER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT); Gfx::SE_ACCESS_SHADER_WRITE_BIT, Gfx::SE_PIPELINE_STAGE_COMPUTE_SHADER_BIT);
ShaderCompilationInfo compileInfo = { ShaderCompilationInfo compileInfo = {
.name = "RT", .name = "RT",
.modules = {"RayGen", "ClosestHit", "Miss"}, .modules = {"RayGen", "Miss"},
.entryPoints = {{"raygen", "RayGen"}, {"closestHit", "ClosestHit"}, {"miss", "Miss"}}, .entryPoints = {{"raygen", "RayGen"}, {"miss", "Miss"}},
.defines = {{"RAY_TRACING", "1"}}, .defines = {{"RAY_TRACING", "1"}},
.rootSignature = pipelineLayout, .rootSignature = pipelineLayout,
}; };
graphics->beginShaderCompilation(compileInfo); graphics->beginShaderCompilation(compileInfo);
rayGen = graphics->createRayGenShader({0}); rayGen = graphics->createRayGenShader({0});
closestHit = graphics->createClosestHitShader({1}); miss = graphics->createMissShader({1});
miss = graphics->createMissShader({2});
pipelineLayout->create(); pipelineLayout->create();
pipeline = graphics->createRayTracingPipeline(Gfx::RayTracingPipelineCreateInfo{
.pipelineLayout = pipelineLayout,
.rayGenGroup = {.shader = rayGen},
.hitGroups = {{.closestHitShader = closestHit}},
.missGroups = {{.shader = miss}},
//.callableGroups = callableGroups,
});
Component::Transform transform;
transform.setScale(Vector(1, 1, 1));
transform.setPosition(Vector(0, 0, 1));
} }
void RayTracingPass::createRenderPass() {} void RayTracingPass::createRenderPass() {}
src/Engine/Graphics/RenderPass/RayTracingPass.h
-1
View File
@@ -19,7 +19,6 @@ class RayTracingPass : public RenderPass {
Gfx::OPipelineLayout pipelineLayout; Gfx::OPipelineLayout pipelineLayout;
Gfx::OTexture2D texture; Gfx::OTexture2D texture;
Gfx::ORayGenShader rayGen; Gfx::ORayGenShader rayGen;
Gfx::OClosestHitShader closestHit;
Gfx::OMissShader miss; Gfx::OMissShader miss;
Gfx::PRayTracingPipeline pipeline; Gfx::PRayTracingPipeline pipeline;
Gfx::OTopLevelAS tlas; Gfx::OTopLevelAS tlas;
src/Engine/Graphics/Shader.cpp
+2 -2
View File
@@ -129,7 +129,7 @@ void ShaderCompiler::createShaders(ShaderPermutation permutation, Gfx::OPipeline
createInfo.modules.add(permutation.vertexMeshFile); createInfo.modules.add(permutation.vertexMeshFile);
} else if (permutation.rayTracing) { } else if (permutation.rayTracing) {
createInfo.defines["RAY_TRACING"] = "1"; createInfo.defines["RAY_TRACING"] = "1";
createInfo.entryPoints = {{"callable", "Callable"}}; createInfo.entryPoints = {{"closestHit", "ClosestHit"}};
createInfo.modules.add(permutation.vertexMeshFile); createInfo.modules.add(permutation.vertexMeshFile);
} else { } else {
createInfo.entryPoints.add({"vertexMain", permutation.vertexMeshFile}); createInfo.entryPoints.add({"vertexMain", permutation.vertexMeshFile});
@@ -148,7 +148,7 @@ void ShaderCompiler::createShaders(ShaderPermutation permutation, Gfx::OPipeline
} }
collection.meshShader = graphics->createMeshShader({shaderIndex++}); collection.meshShader = graphics->createMeshShader({shaderIndex++});
} else if (permutation.rayTracing) { } else if (permutation.rayTracing) {
collection.callableShader = graphics->createCallableShader({shaderIndex++}); collection.callableShader = graphics->createClosestHitShader({shaderIndex++});
} else { } else {
collection.vertexShader = graphics->createVertexShader({shaderIndex++}); collection.vertexShader = graphics->createVertexShader({shaderIndex++});
} }
src/Engine/Graphics/Shader.h
+1 -1
View File
@@ -154,7 +154,7 @@ struct ShaderCollection {
OTaskShader taskShader; OTaskShader taskShader;
OMeshShader meshShader; OMeshShader meshShader;
OFragmentShader fragmentShader; OFragmentShader fragmentShader;
OCallableShader callableShader; OClosestHitShader callableShader;
}; };
struct PassConfig { struct PassConfig {
src/Engine/Graphics/Vulkan/Buffer.cpp
+1
View File
@@ -20,6 +20,7 @@ BufferAllocation::BufferAllocation(PGraphics graphics, const std::string& name,
.objectHandle = (uint64)buffer, .objectHandle = (uint64)buffer,
.pObjectName = name.c_str(), .pObjectName = name.c_str(),
}; };
assert(!name.empty());
vkSetDebugUtilsObjectNameEXT(graphics->getDevice(), &nameInfo); vkSetDebugUtilsObjectNameEXT(graphics->getDevice(), &nameInfo);
if (bufferInfo.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) { if (bufferInfo.usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) {
VkBufferDeviceAddressInfo addrInfo = { VkBufferDeviceAddressInfo addrInfo = {
src/Engine/Graphics/Vulkan/PipelineCache.cpp
+44 -113
View File
@@ -490,7 +490,7 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
}); });
} }
{ {
for (auto hitgroup : createInfo.hitGroups) { for (const auto& hitgroup : createInfo.hitGroups) {
auto hit = hitgroup.closestHitShader.cast<ClosestHitShader>(); auto hit = hitgroup.closestHitShader.cast<ClosestHitShader>();
shaderStages.add(VkPipelineShaderStageCreateInfo{ shaderStages.add(VkPipelineShaderStageCreateInfo{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
@@ -594,174 +594,105 @@ PRayTracingPipeline PipelineCache::createPipeline(Gfx::RayTracingPipelineCreateI
}; };
VkPipeline pipelineHandle; VkPipeline pipelineHandle;
VK_CHECK(vkCreateRayTracingPipelinesKHR(graphics->getDevice(), VK_NULL_HANDLE, cache, 1, &pipelineInfo, nullptr, &pipelineHandle)); VK_CHECK(vkCreateRayTracingPipelinesKHR(graphics->getDevice(), VK_NULL_HANDLE, cache, 1, &pipelineInfo, nullptr, &pipelineHandle));
/*
const uint32_t handle_size = graphics->getRayTracingProperties().shaderGroupHandleSize;
const uint32_t handle_size_aligned =
align(graphics->getRayTracingProperties().shaderGroupHandleSize, graphics->getRayTracingProperties().shaderGroupHandleAlignment);
const uint32_t handle_alignment = graphics->getRayTracingProperties().shaderGroupHandleAlignment;
const uint32_t group_count = static_cast<uint32_t>(shaderGroups.size());
const uint32_t sbt_size = group_count * handle_size_aligned;
const VkBufferUsageFlags sbt_buffer_usage_flags =
VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
const VmaMemoryUsage sbt_memory_usage = VMA_MEMORY_USAGE_CPU_TO_GPU;
// Raygen
// Create binding table buffers for each shader type
OBufferAllocation raygen_shader_binding_table = new BufferAllocation(graphics, "RayGen",
VkBufferCreateInfo{
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.size = handle_size,
.usage = sbt_buffer_usage_flags,
},
VmaAllocationCreateInfo{
.usage = sbt_memory_usage,
},
Gfx::QueueType::GRAPHICS, 0);
OBufferAllocation miss_shader_binding_table = new BufferAllocation(graphics, "Miss",
VkBufferCreateInfo{
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.size = handle_size,
.usage = sbt_buffer_usage_flags,
},
VmaAllocationCreateInfo{
.usage = sbt_memory_usage,
},
Gfx::QueueType::GRAPHICS, 0);
OBufferAllocation hit_shader_binding_table = new BufferAllocation(graphics, "Hit",
VkBufferCreateInfo{
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.size = handle_size,
.usage = sbt_buffer_usage_flags,
},
VmaAllocationCreateInfo{
.usage = sbt_memory_usage,
},
Gfx::QueueType::GRAPHICS, 0);
// Copy the pipeline's shader handles into a host buffer
std::vector<uint8_t> shader_handle_storage(sbt_size);
VK_CHECK(vkGetRayTracingShaderGroupHandlesKHR(graphics->getDevice(), pipelineHandle, 0, group_count, sbt_size,
shader_handle_storage.data()));
// Copy the shader handles from the host buffer to the binding tables
uint8_t* data = static_cast<uint8_t*>(raygen_shader_binding_table->map());
memcpy(data, shader_handle_storage.data(), handle_size);
data = static_cast<uint8_t*>(miss_shader_binding_table->map());
memcpy(data, shader_handle_storage.data() + handle_size_aligned, handle_size);
data = static_cast<uint8_t*>(hit_shader_binding_table->map());
memcpy(data, shader_handle_storage.data() + handle_size_aligned * 2, handle_size);
raygen_shader_binding_table->unmap();
miss_shader_binding_table->unmap();
hit_shader_binding_table->unmap();*/
const uint32_t handleSize = graphics->getRayTracingProperties().shaderGroupHandleSize; const uint32_t handleSize = graphics->getRayTracingProperties().shaderGroupHandleSize;
const uint32_t handleSizeAligned = const uint32_t handleSizeAligned =
align(graphics->getRayTracingProperties().shaderGroupHandleSize, graphics->getRayTracingProperties().shaderGroupHandleAlignment); align(graphics->getRayTracingProperties().shaderGroupHandleSize, graphics->getRayTracingProperties().shaderGroupHandleAlignment);
const uint32_t handleAlignment = graphics->getRayTracingProperties().shaderGroupHandleAlignment; const uint32_t handleAlignment = graphics->getRayTracingProperties().shaderGroupHandleAlignment;
const uint32_t sbtAlignment = graphics->getRayTracingProperties().shaderGroupBaseAlignment;
const uint32_t groupCount = static_cast<uint32_t>(shaderGroups.size()); const uint32_t groupCount = static_cast<uint32_t>(shaderGroups.size());
const uint32_t sbtSize = groupCount * handleSizeAligned; const uint32_t sbtSize = groupCount * handleSizeAligned;
const VkBufferUsageFlags sbtBufferUsage = const VkBufferUsageFlags sbtBufferUsage =
VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT; VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR | VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
const VmaMemoryUsage sbtMemoryUsage = VMA_MEMORY_USAGE_CPU_TO_GPU; const VmaMemoryUsage sbtMemoryUsage = VMA_MEMORY_USAGE_AUTO;
uint64 rayGenStride = align<uint64>(handleSize + createInfo.rayGenGroup.parameters.size(), handleAlignment);
uint64 hitStride = handleSize;
for (const auto& h : createInfo.hitGroups) {
hitStride = std::max(hitStride, align<uint64>(handleSize + h.parameters.size(), handleAlignment));
}
uint64 missStride = handleSize;
for (const auto& m : createInfo.missGroups) {
missStride = std::max(missStride, align<uint64>(handleSize + m.parameters.size(), handleAlignment));
}
OBufferAllocation rayGenBuffer = new BufferAllocation(graphics, "RayGenSBT", OBufferAllocation rayGenBuffer = new BufferAllocation(graphics, "RayGenSBT",
VkBufferCreateInfo{ VkBufferCreateInfo{
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.size = handleSize, .size = rayGenStride,
.usage = sbtBufferUsage, .usage = sbtBufferUsage,
}, },
VmaAllocationCreateInfo{ VmaAllocationCreateInfo{
.usage = sbtMemoryUsage, .usage = sbtMemoryUsage,
}, },
Gfx::QueueType::GRAPHICS); Gfx::QueueType::GRAPHICS, sbtAlignment);
OBufferAllocation hitBuffer = new BufferAllocation(graphics, "HitSBT", OBufferAllocation hitBuffer = new BufferAllocation(graphics, "HitSBT",
VkBufferCreateInfo{ VkBufferCreateInfo{
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.size = handleSize * createInfo.hitGroups.size(), .size = hitStride * createInfo.hitGroups.size(),
.usage = sbtBufferUsage, .usage = sbtBufferUsage,
}, },
VmaAllocationCreateInfo{ VmaAllocationCreateInfo{
.usage = sbtMemoryUsage, .usage = sbtMemoryUsage,
}, },
Gfx::QueueType::GRAPHICS); Gfx::QueueType::GRAPHICS, sbtAlignment);
OBufferAllocation missBuffer = new BufferAllocation(graphics, "MissSBT", OBufferAllocation missBuffer = new BufferAllocation(graphics, "MissSBT",
VkBufferCreateInfo{ VkBufferCreateInfo{
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr, .pNext = nullptr,
.flags = 0, .flags = 0,
.size = handleSize * createInfo.missGroups.size(), .size = missStride * createInfo.missGroups.size(),
.usage = sbtBufferUsage, .usage = sbtBufferUsage,
}, },
VmaAllocationCreateInfo{ VmaAllocationCreateInfo{
.usage = sbtMemoryUsage, .usage = sbtMemoryUsage,
}, },
Gfx::QueueType::GRAPHICS); Gfx::QueueType::GRAPHICS, sbtAlignment);
Array<uint8> sbt(sbtSize); Array<uint8> sbt(sbtSize);
vkGetRayTracingShaderGroupHandlesKHR(graphics->getDevice(), pipelineHandle, 0, shaderGroups.size(), sbtSize, sbt.data()); vkGetRayTracingShaderGroupHandlesKHR(graphics->getDevice(), pipelineHandle, 0, shaderGroups.size(), sbtSize, sbt.data());
/* maxParamSize = 0;
for (auto& callableGroup : createInfo.callableGroups) {
maxParamSize = std::max<uint32>(maxParamSize, callableGroup.parameters.size());
}
uint64 callableStride = align(handleSize + maxParamSize, handleAlignment);
OBufferAllocation callableBuffer = new BufferAllocation(graphics, "CallableSBT",
VkBufferCreateInfo{
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.size = callableStride * createInfo.callableGroups.size(),
.usage = sbtBufferUsage,
},
VmaAllocationCreateInfo{
.usage = sbtMemoryUsage,
},
Gfx::QueueType::GRAPHICS);
uint8* callableData = static_cast<uint8*>(callableBuffer->map());
for (uint64 i = 0; i < createInfo.callableGroups.size(); ++i) {
std::memcpy(callableData, sbt.data() + sbtOffset, handleSize);
std::memcpy(callableData + handleSize, createInfo.callableGroups[i].parameters.data(),
createInfo.callableGroups[i].parameters.size());
sbtOffset += handleSizeAligned;
callableData += callableStride;
}
callableBuffer->unmap();
*/
uint64 sbtOffset = 0; uint64 sbtOffset = 0;
uint8* rayGenData = static_cast<uint8*>(rayGenBuffer->map()); Array<uint8> rayGenSbt(rayGenStride);
std::memcpy(rayGenData, sbt.data() + sbtOffset, handleSize); std::memcpy(rayGenSbt.data(), sbt.data() + sbtOffset, handleSize);
rayGenBuffer->unmap(); std::memcpy(rayGenSbt.data() + handleSize, createInfo.rayGenGroup.parameters.data(), createInfo.rayGenGroup.parameters.size());
sbtOffset += handleSizeAligned; sbtOffset += handleSizeAligned;
rayGenBuffer->updateContents(0, rayGenSbt.size(), rayGenSbt.data());
rayGenBuffer->pipelineBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
uint8* hitData = static_cast<uint8*>(hitBuffer->map());
Array<uint8> hitSbt(hitStride * createInfo.hitGroups.size());
for (uint64 i = 0; i < createInfo.hitGroups.size(); ++i) { for (uint64 i = 0; i < createInfo.hitGroups.size(); ++i) {
std::memcpy(hitData, sbt.data() + sbtOffset, handleSize); std::memcpy(hitSbt.data() + i * hitStride, sbt.data() + sbtOffset, handleSize);
std::memcpy(hitSbt.data() + i * hitStride + handleSize, createInfo.hitGroups[i].parameters.data(),
createInfo.hitGroups[i].parameters.size());
sbtOffset += handleSizeAligned; sbtOffset += handleSizeAligned;
hitData += handleSizeAligned;
} }
hitBuffer->unmap(); hitBuffer->updateContents(0, hitSbt.size(), hitSbt.data());
hitBuffer->pipelineBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
uint8* missData = static_cast<uint8*>(missBuffer->map());
Array<uint8> missSbt(missStride * createInfo.missGroups.size());
for (uint64 i = 0; i < createInfo.missGroups.size(); ++i) { for (uint64 i = 0; i < createInfo.missGroups.size(); ++i) {
std::memcpy(missData, sbt.data() + sbtOffset, handleSize); std::memcpy(missSbt.data() + i * missStride, sbt.data() + sbtOffset, handleSize);
std::memcpy(missSbt.data() + i * missStride + handleSize, createInfo.missGroups[i].parameters.data(),
createInfo.missGroups[i].parameters.size());
sbtOffset += handleSizeAligned; sbtOffset += handleSizeAligned;
missData += handleSizeAligned;
} }
missBuffer->unmap(); missBuffer->updateContents(0, missSbt.size(), missSbt.data());
missBuffer->pipelineBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR);
ORayTracingPipeline pipeline = ORayTracingPipeline pipeline =
new RayTracingPipeline(graphics, pipelineHandle, std::move(rayGenBuffer), handleSizeAligned, std::move(hitBuffer), new RayTracingPipeline(graphics, pipelineHandle, std::move(rayGenBuffer), rayGenStride, std::move(hitBuffer),
handleSizeAligned, std::move(missBuffer), handleSizeAligned, nullptr, 0, createInfo.pipelineLayout); hitStride, std::move(missBuffer), missStride, nullptr, 0, createInfo.pipelineLayout);
PRayTracingPipeline handle = pipeline; PRayTracingPipeline handle = pipeline;
rayTracingPipelines[hash] = std::move(pipeline); rayTracingPipelines[hash] = std::move(pipeline);
return handle; return handle;
src/Engine/Graphics/Vulkan/RayTracing.cpp
+1 -1
View File
@@ -56,7 +56,7 @@ TopLevelAS::TopLevelAS(PGraphics graphics, const Gfx::TopLevelASCreateInfo& crea
}, },
.instanceCustomIndex = i, .instanceCustomIndex = i,
.mask = 0xff, .mask = 0xff,
.instanceShaderBindingTableRecordOffset = 0, .instanceShaderBindingTableRecordOffset = i,
.flags = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, .flags = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR,
.accelerationStructureReference = blas->getDeviceAddress(), .accelerationStructureReference = blas->getDeviceAddress(),
}; };
src/Engine/Graphics/slang-compile.cpp
+1 -1
View File
@@ -78,9 +78,9 @@ void Seele::beginCompilation(const ShaderCompilationInfo& info, SlangCompileTarg
Map<std::string, slang::IModule*> moduleMap; Map<std::string, slang::IModule*> moduleMap;
for (const auto& moduleName : info.modules) { for (const auto& moduleName : info.modules) {
slang::IModule* loaded = session->loadModule(moduleName.c_str(), diagnostics.writeRef()); slang::IModule* loaded = session->loadModule(moduleName.c_str(), diagnostics.writeRef());
CHECK_DIAGNOSTICS();
components.add(loaded); components.add(loaded);
moduleMap[moduleName] = loaded; moduleMap[moduleName] = loaded;
CHECK_DIAGNOSTICS();
} }
entryPoints.clear(); entryPoints.clear();
for (const auto& [name, mod] : info.entryPoints) { for (const auto& [name, mod] : info.entryPoints) {
src/Engine/Material/Material.cpp
+3 -3
View File
@@ -40,21 +40,21 @@ void Material::init(Gfx::PGraphics graphics) {
.descriptorType = Gfx::SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE, .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
.descriptorCount = 2000, .descriptorCount = 2000,
.bindingFlags = Gfx::SE_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, .bindingFlags = Gfx::SE_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT,
.shaderStages = Gfx::SE_SHADER_STAGE_FRAGMENT_BIT | Gfx::SE_SHADER_STAGE_CALLABLE_BIT_KHR, .shaderStages = Gfx::SE_SHADER_STAGE_FRAGMENT_BIT | Gfx::SE_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
}); });
layout->addDescriptorBinding(Gfx::DescriptorBinding{ layout->addDescriptorBinding(Gfx::DescriptorBinding{
.binding = 1, .binding = 1,
.descriptorType = Gfx::SE_DESCRIPTOR_TYPE_SAMPLER, .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_SAMPLER,
.descriptorCount = 2000, .descriptorCount = 2000,
.bindingFlags = Gfx::SE_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, .bindingFlags = Gfx::SE_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT,
.shaderStages = Gfx::SE_SHADER_STAGE_FRAGMENT_BIT | Gfx::SE_SHADER_STAGE_CALLABLE_BIT_KHR, .shaderStages = Gfx::SE_SHADER_STAGE_FRAGMENT_BIT | Gfx::SE_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
}); });
layout->addDescriptorBinding(Gfx::DescriptorBinding{ layout->addDescriptorBinding(Gfx::DescriptorBinding{
.binding = 2, .binding = 2,
.descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER, .descriptorType = Gfx::SE_DESCRIPTOR_TYPE_STORAGE_BUFFER,
.descriptorCount = 1, .descriptorCount = 1,
.bindingFlags = Gfx::SE_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, .bindingFlags = Gfx::SE_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT,
.shaderStages = Gfx::SE_SHADER_STAGE_FRAGMENT_BIT | Gfx::SE_SHADER_STAGE_CALLABLE_BIT_KHR, .shaderStages = Gfx::SE_SHADER_STAGE_FRAGMENT_BIT | Gfx::SE_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,
}); });
layout->create(); layout->create();
floatBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{ floatBuffer = graphics->createShaderBuffer(ShaderBufferCreateInfo{
src/Engine/Window/GameView.cpp
+6 -6
View File
@@ -23,12 +23,12 @@ using namespace Seele;
GameView::GameView(Gfx::PGraphics graphics, PWindow window, const ViewportCreateInfo& createInfo, std::string dllPath) GameView::GameView(Gfx::PGraphics graphics, PWindow window, const ViewportCreateInfo& createInfo, std::string dllPath)
: View(graphics, window, createInfo, "Game"), scene(new Scene(graphics)), gameInterface(dllPath) { : View(graphics, window, createInfo, "Game"), scene(new Scene(graphics)), gameInterface(dllPath) {
reloadGame(); reloadGame();
//renderGraph.addPass(new CachedDepthPass(graphics, scene)); renderGraph.addPass(new CachedDepthPass(graphics, scene));
//renderGraph.addPass(new DepthCullingPass(graphics, scene)); renderGraph.addPass(new DepthCullingPass(graphics, scene));
//renderGraph.addPass(new VisibilityPass(graphics, scene)); renderGraph.addPass(new VisibilityPass(graphics, scene));
//renderGraph.addPass(new LightCullingPass(graphics, scene)); renderGraph.addPass(new LightCullingPass(graphics, scene));
//renderGraph.addPass(new BasePass(graphics, scene)); renderGraph.addPass(new BasePass(graphics, scene));
renderGraph.addPass(new RayTracingPass(graphics, scene)); //renderGraph.addPass(new RayTracingPass(graphics, scene));
renderGraph.setViewport(viewport); renderGraph.setViewport(viewport);
renderGraph.createRenderPass(); renderGraph.createRenderPass();
} }