Ray tracing hit shaders can now access the GPU scene. Alpha testing works with RT shadows

AnKi/Gr/Vulkan/AccelerationStructureImpl.cpp

@@ -40,7 +40,7 @@ Error AccelerationStructureImpl::init(const AccelerationStructureInitInfo& inf)
 		geom.geometry.triangles.indexType = convertIndexType(inf.m_bottomLevel.m_indexType);
 		geom.geometry.triangles.indexData.deviceAddress =
 			inf.m_bottomLevel.m_indexBuffer->getGpuAddress() + inf.m_bottomLevel.m_indexBufferOffset;
-		geom.flags = VK_GEOMETRY_OPAQUE_BIT_KHR; // TODO
+		geom.flags = 0; // VK_GEOMETRY_OPAQUE_BIT_KHR; // TODO
 
 		// Geom build info
 		VkAccelerationStructureBuildGeometryInfoKHR& buildInfo = m_buildInfo;

AnKi/Importer/GltfImporter.cpp

@@ -798,6 +798,8 @@ Error GltfImporter::visitNode(const cgltf_node& node, const Transform& parentTrf
 				addRequest<const cgltf_skin*>(node.skin, m_skinImportRequests);
 			}
 
+			addRequest<const cgltf_mesh*>(node.mesh, m_modelImportRequests);
+
 			HashMapRaii<CString, StringRaii>::Iterator it2;
 			const Bool selfCollision = (it2 = extras.find("collision_mesh")) != extras.getEnd() && *it2 == "self";
 

AnKi/Importer/GltfImporterMaterial.cpp

@@ -47,7 +47,7 @@ inline constexpr const Char* kMaterialTemplate = R"(<!-- This file is auto gener
 inline constexpr const Char* kRtMaterialTemplate = R"(
 		<shaderProgram name="RtShadowsHit">
 			<mutation>
-				<mutator name="ALPHA_TEXTURE" value="0"/>
+				<mutator name="ALPHA_TEXTURE" value="%rtAlphaTestMutator%"/>
 			</mutation>
 		</shaderProgram>
 )";
@@ -175,6 +175,7 @@ Error GltfImporter::writeMaterial(const cgltf_material& mtl, Bool writeRayTracin
 	}
 
 	// Diffuse
+	Bool alphaTested = false;
 	if(mtl.pbr_metallic_roughness.base_color_texture.texture)
 	{
 		const CString fname = getTextureUri(mtl.pbr_metallic_roughness.base_color_texture);
@@ -190,6 +191,7 @@ Error GltfImporter::writeMaterial(const cgltf_material& mtl, Bool writeRayTracin
 
 		const Bool constantAlpha = constantColor.w() >= 0.0f;
 		xml.replaceAll("%alphaTestMutator%", (constantAlpha) ? "0" : "1");
+		alphaTested = !constantAlpha;
 
 		if(m_importTextures)
 		{
@@ -210,6 +212,8 @@ Error GltfImporter::writeMaterial(const cgltf_material& mtl, Bool writeRayTracin
 		xml.replaceAll("%alphaTestMutator%", "0");
 	}
 
+	xml.replaceAll("%rtAlphaTestMutator%", (alphaTested) ? "1" : "0");
+
 	// Specular color (freshnel)
 	{
 		Vec3 specular;

AnKi/Renderer/Drawer.cpp

@@ -61,19 +61,10 @@ void RenderableDrawer::drawRange(const RenderableDrawerArguments& args, const Re
 	cmdb->bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene), args.m_gpuSceneBuffer, 0,
 							kMaxPtrSize);
 
-#define _ANKI_BIND_TEXTURE_BUFFER(format) \
-	cmdb->bindReadOnlyTextureBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kUnifiedGeometry_##format), \
-									args.m_unifiedGeometryBuffer, 0, kMaxPtrSize, Format::k##format)
-
-	_ANKI_BIND_TEXTURE_BUFFER(R32_Sfloat);
-	_ANKI_BIND_TEXTURE_BUFFER(R32G32_Sfloat);
-	_ANKI_BIND_TEXTURE_BUFFER(R32G32B32_Sfloat);
-	_ANKI_BIND_TEXTURE_BUFFER(R32G32B32A32_Sfloat);
-	_ANKI_BIND_TEXTURE_BUFFER(R16G16B16A16_Unorm);
-	_ANKI_BIND_TEXTURE_BUFFER(R8G8B8A8_Snorm);
-	_ANKI_BIND_TEXTURE_BUFFER(R8G8B8A8_Uint);
-
-#undef _ANKI_BIND_TEXTURE_BUFFER
+#define ANKI_UNIFIED_GEOM_FORMAT(fmt, shaderType) \
+	cmdb->bindReadOnlyTextureBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kUnifiedGeometry_##fmt), \
+									args.m_unifiedGeometryBuffer, 0, kMaxPtrSize, Format::k##fmt);
+#include <AnKi/Shaders/Include/UnifiedGeometryTypes.defs.h>
 
 	// Misc
 	cmdb->setVertexAttribute(0, 0, Format::kR32G32B32A32_Uint, 0);

AnKi/Renderer/RtShadows.cpp

@@ -13,6 +13,8 @@
 #include <AnKi/Renderer/RenderQueue.h>
 #include <AnKi/Util/Tracer.h>
 #include <AnKi/Core/ConfigSet.h>
+#include <AnKi/Shaders/Include/MaterialTypes.h>
+#include <AnKi/Shaders/Include/GpuSceneTypes.h>
 
 namespace anki {
 
@@ -441,31 +443,59 @@ void RtShadows::run(const RenderingContext& ctx, RenderPassWorkContext& rgraphCt
 
 	cmdb->bindShaderProgram(m_rtLibraryGrProg);
 
-	bindUniforms(cmdb, 0, 0, rsrc.m_clusteredShadingUniformsToken);
+	// Allocate, set and bind global uniforms
+	{
+		RebarGpuMemoryToken globalUniformsToken;
+		MaterialGlobalUniforms* globalUniforms =
+			static_cast<MaterialGlobalUniforms*>(getExternalSubsystems().m_rebarStagingPool->allocateFrame(
+				sizeof(MaterialGlobalUniforms), globalUniformsToken));
+
+		memset(globalUniforms, 0, sizeof(*globalUniforms)); // Don't care for now
+
+		cmdb->bindUniformBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGlobalUniforms),
+								getExternalSubsystems().m_rebarStagingPool->getBuffer(), globalUniformsToken.m_offset,
+								globalUniformsToken.m_range);
+	}
+
+	// More globals
+	cmdb->bindAllBindless(U32(MaterialSet::kBindless));
+	cmdb->bindSampler(U32(MaterialSet::kGlobal), U32(MaterialBinding::kTrilinearRepeatSampler),
+					  m_r->getSamplers().m_trilinearRepeat);
+	cmdb->bindStorageBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kGpuScene),
+							getExternalSubsystems().m_gpuScenePool->getBuffer(), 0, kMaxPtrSize);
 
-	bindUniforms(cmdb, 0, 1, rsrc.m_pointLightsToken);
-	bindUniforms(cmdb, 0, 2, rsrc.m_spotLightsToken);
-	rgraphCtx.bindColorTexture(0, 3, m_r->getShadowMapping().getShadowmapRt());
+#define ANKI_UNIFIED_GEOM_FORMAT(fmt, shaderType) \
+	cmdb->bindReadOnlyTextureBuffer(U32(MaterialSet::kGlobal), U32(MaterialBinding::kUnifiedGeometry_##fmt), \
+									getExternalSubsystems().m_unifiedGometryMemoryPool->getBuffer(), 0, kMaxPtrSize, \
+									Format::k##fmt);
+#include <AnKi/Shaders/Include/UnifiedGeometryTypes.defs.h>
 
-	bindStorage(cmdb, 0, 4, rsrc.m_clustersToken);
+	constexpr U32 kSet = 2;
 
-	cmdb->bindSampler(0, 5, m_r->getSamplers().m_trilinearRepeat);
+	bindUniforms(cmdb, kSet, 0, rsrc.m_clusteredShadingUniformsToken);
 
-	rgraphCtx.bindImage(0, 6, m_runCtx.m_intermediateShadowsRts[0]);
+	bindUniforms(cmdb, kSet, 1, rsrc.m_pointLightsToken);
+	bindUniforms(cmdb, kSet, 2, rsrc.m_spotLightsToken);
+	rgraphCtx.bindColorTexture(kSet, 3, m_r->getShadowMapping().getShadowmapRt());
 
-	rgraphCtx.bindColorTexture(0, 7, m_runCtx.m_historyRt);
-	cmdb->bindSampler(0, 8, m_r->getSamplers().m_trilinearClamp);
-	cmdb->bindSampler(0, 9, m_r->getSamplers().m_nearestNearestClamp);
-	rgraphCtx.bindTexture(0, 10, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
-	rgraphCtx.bindColorTexture(0, 11, m_r->getMotionVectors().getMotionVectorsRt());
-	rgraphCtx.bindColorTexture(0, 12, m_r->getMotionVectors().getHistoryLengthRt());
-	rgraphCtx.bindColorTexture(0, 13, m_r->getGBuffer().getColorRt(2));
-	rgraphCtx.bindAccelerationStructure(0, 14, m_r->getAccelerationStructureBuilder().getAccelerationStructureHandle());
-	rgraphCtx.bindColorTexture(0, 15, m_runCtx.m_prevMomentsRt);
-	rgraphCtx.bindImage(0, 16, m_runCtx.m_currentMomentsRt);
-	cmdb->bindTexture(0, 17, m_blueNoiseImage->getTextureView());
+	bindStorage(cmdb, kSet, 4, rsrc.m_clustersToken);
 
-	cmdb->bindAllBindless(1);
+	cmdb->bindSampler(kSet, 5, m_r->getSamplers().m_trilinearRepeat);
+
+	rgraphCtx.bindImage(kSet, 6, m_runCtx.m_intermediateShadowsRts[0]);
+
+	rgraphCtx.bindColorTexture(kSet, 7, m_runCtx.m_historyRt);
+	cmdb->bindSampler(kSet, 8, m_r->getSamplers().m_trilinearClamp);
+	cmdb->bindSampler(kSet, 9, m_r->getSamplers().m_nearestNearestClamp);
+	rgraphCtx.bindTexture(kSet, 10, m_r->getDepthDownscale().getHiZRt(), kHiZHalfSurface);
+	rgraphCtx.bindColorTexture(kSet, 11, m_r->getMotionVectors().getMotionVectorsRt());
+	rgraphCtx.bindColorTexture(kSet, 12, m_r->getMotionVectors().getHistoryLengthRt());
+	rgraphCtx.bindColorTexture(kSet, 13, m_r->getGBuffer().getColorRt(2));
+	rgraphCtx.bindAccelerationStructure(kSet, 14,
+										m_r->getAccelerationStructureBuilder().getAccelerationStructureHandle());
+	rgraphCtx.bindColorTexture(kSet, 15, m_runCtx.m_prevMomentsRt);
+	rgraphCtx.bindImage(kSet, 16, m_runCtx.m_currentMomentsRt);
+	cmdb->bindTexture(kSet, 17, m_blueNoiseImage->getTextureView());
 
 	RtShadowsUniforms unis;
 	for(U32 i = 0; i < kMaxRtShadowLayers; ++i)
@@ -623,7 +653,14 @@ void RtShadows::buildSbt(RenderingContext& ctx)
 
 		// Init SBT record
 		memcpy(sbt, &shaderGroupHandles[element.m_shaderGroupHandleIndex * shaderHandleSize], shaderHandleSize);
-		// TODO add some reference to the RenderableGpuView
+
+		ANKI_ASSERT(shaderHandleSize + sizeof(GpuSceneRenderable) <= m_sbtRecordSize);
+		GpuSceneRenderable* shaderRecord = reinterpret_cast<GpuSceneRenderable*>(sbt + shaderHandleSize);
+		shaderRecord->m_worldTransformsOffset = element.m_worldTransformsOffset;
+		shaderRecord->m_uniformsOffset = element.m_uniformsOffset;
+		shaderRecord->m_geometryOffset = element.m_geometryOffset;
+		shaderRecord->m_boneTransformsOffset = 0;
+
 		sbt += m_sbtRecordSize;
 	}
 

AnKi/Scene/Components/ModelComponent.cpp

@@ -140,11 +140,14 @@ Error ModelComponent::update(SceneComponentUpdateInfo& info, Bool& updated)
 					meshLod.m_vertexOffsets[U32(stream)] = U32(offset / elementSize);
 				}
 
-				PtrSize offset;
+				U32 firstIndex;
 				U32 indexCount;
+				Aabb aabb;
+				mesh.getSubMeshInfo(l, i, firstIndex, indexCount, aabb);
+				PtrSize offset;
 				IndexType indexType;
 				mesh.getIndexBufferInfo(l, offset, indexCount, indexType);
-				meshLod.m_indexOffset = U32(offset);
+				meshLod.m_indexBufferOffset = U32(offset) / getIndexSize(indexType) + firstIndex;
 				meshLod.m_indexCount = indexCount;
 			}
 

AnKi/Shaders/GBufferGeneric.ankiprog

@@ -35,11 +35,12 @@
 
 #pragma anki reflect AnKiLocalUniforms
 #pragma anki struct AnKiLocalUniforms
-#pragma anki member U32 m_normalTex if NORMAL_TEX is 1
 
 #pragma anki member RVec3 m_diffColor if DIFFUSE_TEX is 0
 #pragma anki member U32 m_diffTex if DIFFUSE_TEX is 1
 
+#pragma anki member U32 m_normalTex if NORMAL_TEX is 1
+
 #pragma anki member RF32 m_roughness if ROUGHNESS_TEX is 0
 #pragma anki member U32 m_roughnessTex if ROUGHNESS_TEX is 1
 
@@ -56,6 +57,7 @@
 #pragma anki member U32 m_heightTex if PARALLAX is 1
 
 #pragma anki member RF32 m_subsurface
+
 #pragma anki struct end
 
 struct VertIn

AnKi/Shaders/Include/GpuSceneTypes.h

@@ -25,7 +25,7 @@ struct GpuSceneMeshLod
 {
 	U32 m_vertexOffsets[(U32)VertexStreamId::kMeshRelatedCount];
 	U32 m_indexCount;
-	U32 m_indexOffset; // TODO Decide on its type
+	U32 m_indexBufferOffset; // In sizeof(indexType)
 
 	Vec3 m_positionTranslation;
 	F32 m_positionScale;

AnKi/Shaders/Include/MaterialTypes.h

@@ -61,13 +61,8 @@ enum class MaterialBinding : U32
 	kGpuScene,
 
 	// Texture buffer bindings pointing to unified geom buffer:
-	kUnifiedGeometry_R32_Sfloat,
-	kUnifiedGeometry_R32G32_Sfloat,
-	kUnifiedGeometry_R32G32B32_Sfloat,
-	kUnifiedGeometry_R32G32B32A32_Sfloat,
-	kUnifiedGeometry_R16G16B16A16_Unorm,
-	kUnifiedGeometry_R8G8B8A8_Snorm,
-	kUnifiedGeometry_R8G8B8A8_Uint,
+#define ANKI_UNIFIED_GEOM_FORMAT(fmt, shaderType) kUnifiedGeometry_##fmt,
+#include <AnKi/Shaders/Include/UnifiedGeometryTypes.defs.h>
 
 	// For FW shading:
 	kLinearClampSampler,

AnKi/Shaders/Include/UnifiedGeometryTypes.defs.h

@@ -0,0 +1,29 @@
+// Copyright (C) 2009-2022, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+// File includes the defines of the various texel buffer formats of the unified geometry buffer
+
+#if !defined(ANKI_UNIFIED_GEOM_FORMAT_SEPERATOR)
+#	define ANKI_UNIFIED_GEOM_FORMAT_SEPERATOR
+#endif
+
+ANKI_UNIFIED_GEOM_FORMAT(R32_Sfloat, F32)
+ANKI_UNIFIED_GEOM_FORMAT_SEPERATOR
+ANKI_UNIFIED_GEOM_FORMAT(R32G32_Sfloat, Vec2)
+ANKI_UNIFIED_GEOM_FORMAT_SEPERATOR
+ANKI_UNIFIED_GEOM_FORMAT(R32G32B32_Sfloat, Vec3)
+ANKI_UNIFIED_GEOM_FORMAT_SEPERATOR
+ANKI_UNIFIED_GEOM_FORMAT(R32G32B32A32_Sfloat, Vec4)
+ANKI_UNIFIED_GEOM_FORMAT_SEPERATOR
+ANKI_UNIFIED_GEOM_FORMAT(R16G16B16A16_Unorm, Vec4)
+ANKI_UNIFIED_GEOM_FORMAT_SEPERATOR
+ANKI_UNIFIED_GEOM_FORMAT(R8G8B8A8_Snorm, Vec4)
+ANKI_UNIFIED_GEOM_FORMAT_SEPERATOR
+ANKI_UNIFIED_GEOM_FORMAT(R8G8B8A8_Uint, UVec4)
+ANKI_UNIFIED_GEOM_FORMAT_SEPERATOR
+ANKI_UNIFIED_GEOM_FORMAT(R16_Uint, U32)
+
+#undef ANKI_UNIFIED_GEOM_FORMAT
+#undef ANKI_UNIFIED_GEOM_FORMAT_SEPERATOR

AnKi/Shaders/MaterialShadersCommon.hlsl

@@ -19,19 +19,10 @@ ANKI_BINDLESS_SET(MaterialSet::kBindless)
 [[vk::binding(MaterialBinding::kGpuScene, MaterialSet::kGlobal)]] ByteAddressBuffer g_gpuScene;
 
 // Unified geom:
-#define _ANKI_DEFINE_BINDING(format, type) \
-	[[vk::binding(MaterialBinding::kUnifiedGeometry_##format, MaterialSet::kGlobal)]] Buffer<type> \
-		g_unifiedGeom_##format;
-
-_ANKI_DEFINE_BINDING(R32_Sfloat, F32)
-_ANKI_DEFINE_BINDING(R32G32_Sfloat, Vec2)
-_ANKI_DEFINE_BINDING(R32G32B32_Sfloat, Vec3)
-_ANKI_DEFINE_BINDING(R32G32B32A32_Sfloat, Vec4)
-_ANKI_DEFINE_BINDING(R16G16B16A16_Unorm, Vec4)
-_ANKI_DEFINE_BINDING(R8G8B8A8_Snorm, Vec4)
-_ANKI_DEFINE_BINDING(R8G8B8A8_Uint, UVec4)
-
-#undef _ANKI_DEFINE_BINDING
+#define ANKI_UNIFIED_GEOM_FORMAT(fmt, shaderType) \
+	[[vk::binding(MaterialBinding::kUnifiedGeometry_##fmt, MaterialSet::kGlobal)]] Buffer<shaderType> \
+		g_unifiedGeom_##fmt;
+#include <AnKi/Shaders/Include/UnifiedGeometryTypes.defs.h>
 
 // FW shading specific
 #if defined(FORWARD_SHADING)

AnKi/Shaders/RtShadowsHit.ankiprog

@@ -11,15 +11,58 @@
 #pragma anki mutator ALPHA_TEXTURE 0 1
 
 #include <AnKi/Shaders/RtShadows.hlsl>
+#include <AnKi/Shaders/MaterialShadersCommon.hlsl>
+
+#pragma anki reflect AnKiLocalUniforms
+#pragma anki struct AnKiLocalUniforms
+#pragma anki member U32 m_diffTex if ALPHA_TEXTURE is 1
+#pragma anki struct end
 
 #pragma anki start ahit
 
+#if ALPHA_TEXTURE
+[[vk::shader_record_ext]] ConstantBuffer<GpuSceneRenderable> g_gpuSceneRenderable;
+#endif
+
 [shader("anyhit")] void main(inout RayPayload payload, in Barycentrics barycentrics)
 {
 	ANKI_MAYBE_UNUSED(payload);
 	ANKI_MAYBE_UNUSED(barycentrics);
 
+#if ALPHA_TEXTURE
+	payload.m_shadowFactor = 1.0;
+
+	const Vec3 bary =
+		Vec3(1.0f - barycentrics.m_value.x - barycentrics.m_value.y, barycentrics.m_value.x, barycentrics.m_value.y);
+
+	const GpuSceneMeshLod mesh = g_gpuScene.Load<GpuSceneMeshLod>(g_gpuSceneRenderable.m_geometryOffset);
+
+	const U32 idx0 = g_unifiedGeom_R16_Uint[mesh.m_indexBufferOffset + PrimitiveIndex() * 3 + 0];
+	const U32 idx1 = g_unifiedGeom_R16_Uint[mesh.m_indexBufferOffset + PrimitiveIndex() * 3 + 1];
+	const U32 idx2 = g_unifiedGeom_R16_Uint[mesh.m_indexBufferOffset + PrimitiveIndex() * 3 + 2];
+
+	const UnpackedMeshVertex vert0 = loadVertex(mesh, idx0, false);
+	const UnpackedMeshVertex vert1 = loadVertex(mesh, idx1, false);
+	const UnpackedMeshVertex vert2 = loadVertex(mesh, idx2, false);
+
+	const Vec2 uv = vert0.m_uv * bary.x + vert1.m_uv * bary.y + vert2.m_uv * bary.z;
+
+	const AnKiLocalUniforms localUniforms = loadAnKiLocalUniforms(g_gpuScene, g_gpuSceneRenderable.m_uniformsOffset);
+	const RVec4 diffColorA = g_bindlessTextures2dF32[localUniforms.m_diffTex].SampleLevel(g_globalSampler, uv, 0.0);
+
+	if(diffColorA.a < 1.0)
+	{
+		payload.m_shadowFactor = 0.0;
+		AcceptHitAndEndSearch();
+	}
+	else
+	{
+		IgnoreHit();
+	}
+#else
+	payload.m_shadowFactor = 0.0;
 	AcceptHitAndEndSearch();
+#endif
 }
 #pragma anki end
 

AnKi/Shaders/RtShadowsRayGen.ankiprog

@@ -14,37 +14,37 @@
 #include <AnKi/Shaders/ImportanceSampling.hlsl>
 #include <AnKi/Shaders/PackFunctions.hlsl>
 #include <AnKi/Shaders/RtShadows.hlsl>
+#include <AnKi/Shaders/MaterialShadersCommon.hlsl>
 
-#define CLUSTERED_SHADING_SET 0u
+#define SET 2u
+
+#define CLUSTERED_SHADING_SET SET
 #define CLUSTERED_SHADING_UNIFORMS_BINDING 0u
 #define CLUSTERED_SHADING_LIGHTS_BINDING 1u
 #define CLUSTERED_SHADING_CLUSTERS_BINDING 4u
 #include <AnKi/Shaders/ClusteredShadingCommon.hlsl>
 
 // Used by the hit shaders. When changing the binding you need to update other shaders
-[[vk::binding(5)]] SamplerState g_trilinearRepeatSampler;
-
-[[vk::binding(6)]] RWTexture2D<UVec4> g_shadowsImage;
-[[vk::binding(7)]] Texture2D<UVec4> g_historyShadowsTex;
-[[vk::binding(8)]] SamplerState g_linearAnyClampSampler;
-[[vk::binding(9)]] SamplerState g_nearestAnyClampSampler;
-[[vk::binding(10)]] Texture2D g_depthRt;
-[[vk::binding(11)]] Texture2D g_motionVectorsRt;
-[[vk::binding(12)]] Texture2D g_historyLengthTex;
-[[vk::binding(13)]] Texture2D g_normalRt;
-[[vk::binding(14)]] RaytracingAccelerationStructure g_tlas;
-[[vk::binding(15)]] Texture2D g_prevMomentsTex;
-[[vk::binding(16)]] RWTexture2D<Vec4> g_momentsImage;
-[[vk::binding(17)]] Texture2D g_blueNoiseTex;
-
-ANKI_BINDLESS_SET(1); // Used by the hit shaders
+[[vk::binding(5, SET)]] SamplerState g_trilinearRepeatSampler;
+
+[[vk::binding(6, SET)]] RWTexture2D<UVec4> g_shadowsImage;
+[[vk::binding(7, SET)]] Texture2D<UVec4> g_historyShadowsTex;
+[[vk::binding(8, SET)]] SamplerState g_linearAnyClampSampler;
+[[vk::binding(9, SET)]] SamplerState g_nearestAnyClampSampler;
+[[vk::binding(10, SET)]] Texture2D g_depthRt;
+[[vk::binding(11, SET)]] Texture2D g_motionVectorsRt;
+[[vk::binding(12, SET)]] Texture2D g_historyLengthTex;
+[[vk::binding(13, SET)]] Texture2D g_normalRt;
+[[vk::binding(14, SET)]] RaytracingAccelerationStructure g_tlas;
+[[vk::binding(15, SET)]] Texture2D g_prevMomentsTex;
+[[vk::binding(16, SET)]] RWTexture2D<Vec4> g_momentsImage;
+[[vk::binding(17, SET)]] Texture2D g_blueNoiseTex;
 
 [[vk::push_constant]] ConstantBuffer<RtShadowsUniforms> g_unis;
 
 F32 trace(const Vec3 rayOrigin, const Vec3 rayDir, F32 tMax)
 {
-	const U32 flags =
-		RAY_FLAG_FORCE_OPAQUE | RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH | RAY_FLAG_SKIP_CLOSEST_HIT_SHADER;
+	const U32 flags = RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH | RAY_FLAG_SKIP_CLOSEST_HIT_SHADER;
 	const U32 cullMask = 0xFFu;
 	const U32 sbtRecordOffset = 0u;
 	const U32 sbtRecordStride = 0u;
@@ -55,7 +55,8 @@ F32 trace(const Vec3 rayOrigin, const Vec3 rayDir, F32 tMax)
 	ray.Direction = rayDir;
 	ray.TMax = tMax;
 
-	RayPayload payload = (RayPayload)0;
+	RayPayload payload;
+	payload.m_shadowFactor = 0.0;
 	TraceRay(g_tlas, flags, cullMask, sbtRecordOffset, sbtRecordStride, missIndex, ray, payload);
 
 	return payload.m_shadowFactor;

Samples/Sponza/Assets/leaf_3a245efd17475037.ankimtl

@@ -17,7 +17,7 @@
 		
 		<shaderProgram name="RtShadowsHit">
 			<mutation>
-				<mutator name="ALPHA_TEXTURE" value="0"/>
+				<mutator name="ALPHA_TEXTURE" value="1"/>
 			</mutation>
 		</shaderProgram>
 

Samples/Sponza/Assets/vase_fl_580cea687de3d758.ankimtl

@@ -17,7 +17,7 @@
 		
 		<shaderProgram name="RtShadowsHit">
 			<mutation>
-				<mutator name="ALPHA_TEXTURE" value="0"/>
+				<mutator name="ALPHA_TEXTURE" value="1"/>
 			</mutation>
 		</shaderProgram>