anki-3d-engine/AnKi/Shaders/ForwardShadingGenericTransparent.ankiprog

// Copyright (C) 2009-present, Panagiotis Christopoulos Charitos and contributors.
// All rights reserved.
// Code licensed under the BSD License.
// http://www.anki3d.org/LICENSE

#pragma anki mutator TEXTURE 0 1
#pragma anki mutator LIGHT 0 1

#pragma anki technique ForwardLegacy vert pixel
#pragma anki technique ForwardSwMeshletRendering vert pixel
#pragma anki technique ForwardMeshShaders mesh pixel

#include <AnKi/Shaders/ForwardShadingCommon.hlsl>

#define SW_MESHLETS ANKI_TECHNIQUE_ForwardSwMeshletRendering

#pragma anki struct AnKiLocalConstants
#pragma anki member U32 m_texture
#pragma anki member Vec4 m_colorScale
#pragma anki member Vec4 m_colorBias
#pragma anki struct_end

struct VertIn
{
	UVec4 m_instanceData : MISC0;
	U32 m_svVertexId : SV_VERTEXID;
};

struct VertOut
{
	Vec2 m_uv : TEXCOORD;
	Vec3 m_worldPosition : WORLD_POSITION;
	Vec4 m_svPosition : SV_POSITION;
	nointerpolation U32 m_constantsOffset : CONSTANTS_OFFSET;
};

struct MeshPerVertOut
{
	Vec4 m_svPosition : SV_POSITION;
	Vec2 m_uv : TEXCOORD;
};

struct MeshPerPrimitiveOut
{
	ANKI_PER_PRIMITIVE_MEMBER U32 m_constantsOffset : UNIS_OFFSET;
};

// ===========================================================================
// Vert                                                                      =
// ===========================================================================
#if ANKI_VERTEX_SHADER
VertOut main(VertIn input)
{
	VertOut output;

#	if SW_MESHLETS
	const GpuSceneMeshletInstance instance = unpackGpuSceneMeshletInstance(input.m_instanceData);

	if(input.m_svVertexId >= (instance.m_worldTransformsIndex_25bit_meshletPrimitiveCount_7bit & ((1u << 7u) - 1u)) * 3u)
	{
		// Discard the primitive
		output = (VertOut)0;
		output.m_svPosition = kNaN;
		return output;
	}

	const MeshletGeometryDescriptor meshlet = g_meshletGeometryDescriptors[instance.m_meshletGeometryDescriptorIndex];
	const UnpackedMeshVertex vertex = loadVertex(meshlet, input.m_svVertexId, false);
	const U32 worldTransformsIndex = instance.m_worldTransformsIndex_25bit_meshletPrimitiveCount_7bit >> 7u;
#	else // SW_MESHLETS
	const GpuScenePerDraw instance = getGpuScenePerDraw();
	const GpuSceneMeshLod mesh = g_meshLods[instance.m_meshLodIndex];
	const U32 worldTransformsIndex = instance.m_worldTransformsIndex;
	const UnpackedMeshVertex vertex = loadVertex(mesh, input.m_svVertexId, false);
#	endif // SW_MESHLETS

	const U32 constantsOffset = instance.m_constantsOffset;

	const Mat3x4 worldTransform = g_transforms[worldTransformsIndex];

	output.m_worldPosition = mul(worldTransform, Vec4(vertex.m_position, 1.0));

	output.m_svPosition = mul(g_globalConstants.m_viewProjectionMatrix, Vec4(output.m_worldPosition, 1.0));

	output.m_uv = vertex.m_uv;
	output.m_constantsOffset = constantsOffset;

	return output;
}
#endif // ANKI_VERTEX_SHADER

// ===========================================================================
// Mesh                                                                      =
// ===========================================================================
#if ANKI_MESH_SHADER
[numthreads(ANKI_MESH_SHADER_THREADGROUP_SIZE, 1, 1)] [outputtopology("triangle")] void
main(U32 svGroupId : SV_GROUPID, U32 svGroupIndex : SV_GROUPINDEX, out vertices MeshPerVertOut verts[kMaxVerticesPerMeshlet],
	 out primitives MeshPerPrimitiveOut primitives[kMaxPrimitivesPerMeshlet], out indices UVec3 indices[kMaxPrimitivesPerMeshlet])
{
	const U32 instanceIdx = g_firstMeshlet[g_consts.m_bucketIndex] + svGroupId;

	const GpuSceneMeshletInstance instance = g_meshletInstances[instanceIdx];
	const U32 constantsOffset = instance.m_constantsOffset;
	const U32 worldTransformsIndex = instance.m_worldTransformsIndex_25bit_meshletPrimitiveCount_7bit >> 7u;

	const MeshletGeometryDescriptor meshlet = g_meshletGeometryDescriptors[instance.m_meshletGeometryDescriptorIndex];
	const U32 primCount = meshlet.m_primitiveCount;
	const U32 vertCount = meshlet.m_vertexCount;

	SetMeshOutputCounts(vertCount, primCount);

	// Write the verts
	const U32 vertLoopCount = kMaxVerticesPerMeshlet / ANKI_MESH_SHADER_THREADGROUP_SIZE;
	[unroll] for(U32 l = 0; l < vertLoopCount; ++l)
	{
		const U32 idx = l * ANKI_MESH_SHADER_THREADGROUP_SIZE + svGroupIndex;

		if(idx < vertCount)
		{
			MeshPerVertOut output;

			const UnpackedMeshVertex vert = loadVertexLocalIndex(meshlet, idx, false);

			const Mat3x4 worldTransform = g_transforms[worldTransformsIndex];
			const Vec3 worldPos = mul(worldTransform, Vec4(vert.m_position, 1.0));
			output.m_svPosition = mul(g_globalConstants.m_viewProjectionMatrix, Vec4(worldPos, 1.0f));

			output.m_uv = vert.m_uv;

			verts[idx] = output;
		}
	}

	// Write the primitive data
	const U32 primLoopCount = (kMaxPrimitivesPerMeshlet + ANKI_MESH_SHADER_THREADGROUP_SIZE - 1u) / ANKI_MESH_SHADER_THREADGROUP_SIZE;
	[unroll] for(U32 l = 0; l < primLoopCount; ++l)
	{
		const U32 idx = l * ANKI_MESH_SHADER_THREADGROUP_SIZE + svGroupIndex;

		if(idx < primCount)
		{
			const UVec3 prim = g_unifiedGeom_R8G8B8A8_Uint[meshlet.m_firstPrimitive + idx].xyz;
			indices[idx] = prim;

			primitives[idx].m_constantsOffset = constantsOffset;
		}
	}
}
#endif // ANKI_MESH_SHADER

// ===========================================================================
// Pixel                                                                     =
// ===========================================================================
#if ANKI_PIXEL_SHADER
PixelOut main(VertOut input)
{
	ANKI_MAYBE_UNUSED(input);
	PixelOut output;

	const AnKiLocalConstants localConstants = loadAnKiLocalConstants(g_gpuScene, WaveReadLaneFirst(input.m_constantsOffset));

	output.m_color = Vec4(1.0, 1.0, 1.0, 1.0);

#	if TEXTURE == 1
	output.m_color = getBindlessTexture2DVec4(localConstants.m_texture).Sample(g_globalSampler, input.m_uv);
#	endif

#	if LIGHT == 1
	output.m_color.rgb = computeLightColorLow(output.m_color.rgb, input.m_worldPosition, input.m_svPosition);
#	endif

	output.m_color = output.m_color * localConstants.m_colorScale + localConstants.m_colorBias;

	return output;
}
#endif // ANKI_PIXEL_SHADER