Mesh shaders and SW meslet rendering

.clang-format-hlsl

@@ -164,7 +164,7 @@ SpacesInParentheses: false
 SpacesInSquareBrackets: false
 SpaceBeforeSquareBrackets: false
 BitFieldColonSpacing: Both
-Standard:        Latest
+Standard:        Cpp03
 StatementAttributeLikeMacros:
   - Q_EMIT
 StatementMacros:

.gitignore

@@ -4,3 +4,5 @@ out/*
 CMakeSettings.json
 *.TMP
 AndroidProject_*
+*.diff
+*.patch

AnKi/Collision/Aabb.cpp

@@ -15,13 +15,17 @@ Aabb Aabb::getTransformed(const Transform& trf) const
 		absM[i] = absolute(trf.getRotation()[i]);
 	}
 
-	Vec4 center = (m_min + m_max) * 0.5f;
-	Vec4 extend = (m_max - m_min) * 0.5f;
+	const Vec4 center = (m_min + m_max) * 0.5f;
+	const Vec4 extend = (m_max - m_min) * 0.5f;
 
-	Vec4 newC = trf.transform(center);
-	Vec4 newE = Vec4(absM * (extend * trf.getScale()), 0.0f);
+	const Vec4 newC = trf.transform(center);
+	const Vec4 newE = Vec4(absM * (extend * trf.getScale()), 0.0f);
 
-	return Aabb(newC - newE, newC + newE + Vec4(kEpsilonf, kEpsilonf, kEpsilonf, 0.0f));
+	const Vec4 min = newC - newE;
+	const Vec4 max = newC + newE;
+
+	const F32 epsilon = kEpsilonf * 100.0f;
+	return Aabb(min, max + Vec4(epsilon, epsilon, epsilon, 0.0f));
 }
 
 Aabb Aabb::getCompoundShape(const Aabb& b) const

AnKi/Collision/Cone.h

@@ -100,7 +100,8 @@ class Cone
 		Cone out;
 		out.m_origin = transform.transform(m_origin);
 		out.m_dir = (transform.getRotation() * m_dir.xyz0()).xyz0();
-		out.m_length *= transform.getScale();
+		ANKI_ASSERT(transform.hasUniformScale());
+		out.m_length *= transform.getScale().x();
 		return out;
 	}
 

AnKi/Collision/Functions.h

@@ -229,7 +229,10 @@ void extractClipPlane(const Mat4& mvp, FrustumPlaneType id, Plane& plane);
 void computeEdgesOfFrustum(F32 far, F32 fovX, F32 fovY, Vec3 points[4]);
 
 /// Welzl's algorithm that computes a compact bounding sphere given a point cloud.
-Sphere computeBoundingSphere(ConstWeakArray<Vec3> points);
+ANKI_PURE Sphere computeBoundingSphere(const Vec3* firstPoint, U32 pointCount, PtrSize stride);
+
+/// Computes an AABB given a point cloud.
+ANKI_PURE Aabb computeBoundingAabb(const Vec3* firstPoint, U32 pointCount, PtrSize stride);
 
 /// @}
 

AnKi/Collision/FunctionsMisc.cpp

@@ -66,56 +66,69 @@ void computeEdgesOfFrustum(F32 far, F32 fovX, F32 fovY, Vec3 points[4])
 	points[3] = Vec3(x, -y, z); // bot right
 }
 
+static Vec4 computeBoundingSphere2(const Vec3 O, const Vec3 A)
+{
+	const Vec3 a = A - O;
+
+	const Vec3 o = 0.5f * a;
+
+	const F32 radius = o.getLength() + kEpsilonf;
+	const Vec3 center = O + o;
+
+	return Vec4(center, radius);
+}
+
+static Vec4 computeBoundingSphere3(const Vec3 O, const Vec3 A, const Vec3 B)
+{
+	const Vec3 a = A - O;
+	const Vec3 b = B - O;
+
+	const Vec3 acrossb = a.cross(b);
+	const F32 denominator = 2.0f * (acrossb.dot(acrossb));
+
+	if(denominator == 0.0f) [[unlikely]]
+	{
+		// A pair in A,B,O are the same point or they are in the same line
+
+		if(a.getLengthSquared() > b.getLengthSquared())
+		{
+			return computeBoundingSphere2(O, A);
+		}
+		else
+		{
+			return computeBoundingSphere2(O, B);
+		}
+	}
+
+	Vec3 o = b.dot(b) * acrossb.cross(a);
+	o += a.dot(a) * b.cross(acrossb);
+	o /= denominator;
+
+	const F32 radius = o.getLength() + kEpsilonf;
+	const Vec3 center = O + o;
+
+	return Vec4(center, radius);
+}
+
 Vec4 computeBoundingSphereRecursive(WeakArray<const Vec3*> pPoints, U32 begin, U32 p, U32 b)
 {
 	Vec4 sphere;
 
 	switch(b)
 	{
 	case 0:
-		sphere = Vec4(0.0f, 0.0f, 0.0f, -1.0f);
+		sphere = Vec4(0.0f, 0.0f, 0.0f, 0.0f);
 		break;
 	case 1:
 		sphere = Vec4(*pPoints[begin - 1], kEpsilonf);
 		break;
 	case 2:
-	{
-		const Vec3 O = *pPoints[begin - 1];
-		const Vec3 A = *pPoints[begin - 2];
-
-		const Vec3 a = A - O;
-
-		const Vec3 o = 0.5f * a;
-
-		const F32 radius = o.getLength() + kEpsilonf;
-		const Vec3 center = O + o;
-
-		sphere = Vec4(center, radius);
+		sphere = computeBoundingSphere2(*pPoints[begin - 1], *pPoints[begin - 2]);
 		break;
-	}
 	case 3:
-	{
-		const Vec3 O = *pPoints[begin - 1];
-		const Vec3 A = *pPoints[begin - 2];
-		const Vec3 B = *pPoints[begin - 3];
-
-		const Vec3 a = A - O;
-		const Vec3 b = B - O;
-
-		const Vec3 acrossb = a.cross(b);
-		const F32 denominator = 2.0f * (acrossb.dot(acrossb));
-
-		Vec3 o = b.dot(b) * acrossb.cross(a);
-		o += a.dot(a) * b.cross(acrossb);
-		o /= denominator;
-
-		const F32 radius = o.getLength() + kEpsilonf;
-		const Vec3 center = O + o;
-
-		sphere = Vec4(center, radius);
-
+		sphere = computeBoundingSphere3(*pPoints[begin - 1], *pPoints[begin - 2], *pPoints[begin - 3]);
 		return sphere;
-	}
+		break;
 #if 0
 	// There is this case as well but it fails if points are coplanar so avoid it
 	case 4:
@@ -173,32 +186,56 @@ Vec4 computeBoundingSphereRecursive(WeakArray<const Vec3*> pPoints, U32 begin, U
 	return sphere;
 }
 
-Sphere computeBoundingSphere(ConstWeakArray<Vec3> points)
+Sphere computeBoundingSphere(const Vec3* firstPoint, U32 pointCount, PtrSize stride)
 {
-	ANKI_ASSERT(points.getSize() >= 3);
+	ANKI_ASSERT(firstPoint);
+	ANKI_ASSERT(pointCount >= 3);
+	ANKI_ASSERT(stride >= sizeof(Vec3));
 
 	DynamicArray<const Vec3*> pPointsDyn;
 	Array<const Vec3*, 8> pPointsArr;
 	WeakArray<const Vec3*> pPoints;
 
-	if(points.getSize() > pPointsArr.getSize())
+	if(pointCount > pPointsArr.getSize())
 	{
-		pPointsDyn.resize(points.getSize());
+		pPointsDyn.resize(pointCount);
 		pPoints = pPointsDyn;
 	}
 	else
 	{
-		pPoints = {&pPointsArr[0], points.getSize()};
+		pPoints = {&pPointsArr[0], pointCount};
 	}
 
-	for(U32 i = 0; i < points.getSize(); ++i)
+	for(U32 i = 0; i < pointCount; ++i)
 	{
-		pPoints[i] = &points[i];
+		pPoints[i] = reinterpret_cast<const Vec3*>(ptrToNumber(firstPoint) + i * stride);
 	}
 
 	const Vec4 sphere = computeBoundingSphereRecursive(pPoints, 0, pPoints.getSize(), 0);
 
 	return Sphere(sphere.xyz(), sphere.w());
 }
 
+Aabb computeBoundingAabb(const Vec3* firstPoint, U32 pointCount, PtrSize stride)
+{
+	ANKI_ASSERT(firstPoint);
+	ANKI_ASSERT(pointCount >= 3);
+	ANKI_ASSERT(stride >= sizeof(Vec3));
+
+	Vec3 min(kMaxF32);
+	Vec3 max(kMinF32);
+
+	for(U32 i = 0; i < pointCount; ++i)
+	{
+		const Vec3& point = *reinterpret_cast<const Vec3*>(ptrToNumber(firstPoint) + i * stride);
+
+		min = min.min(point);
+		max = max.max(point);
+	}
+
+	max += 10.0f * kEpsilonf;
+
+	return Aabb(min, max);
+}
+
 } // end namespace anki

AnKi/Collision/Plane.cpp

@@ -46,7 +46,8 @@ Plane Plane::getTransformed(const Transform& trf) const
 	Mat3x4 rot = trf.getRotation();
 	rot.transposeRotationPart();
 	Vec4 newTrans(rot * trf.getOrigin(), 0.0f);
-	plane.m_offset = m_offset * trf.getScale() + newTrans.dot(m_normal);
+	ANKI_ASSERT(trf.hasUniformScale());
+	plane.m_offset = m_offset * trf.getScale().x() + newTrans.dot(m_normal);
 
 	return plane;
 }

AnKi/Collision/Sphere.h

@@ -84,6 +84,7 @@ class Sphere
 
 	void setRadius(const F32 x)
 	{
+		ANKI_ASSERT(x > 0.0f);
 		m_radius = x;
 	}
 
@@ -95,7 +96,8 @@ class Sphere
 		check();
 		Sphere out;
 		out.m_center = transform.transform(m_center);
-		out.m_radius = m_radius * transform.getScale();
+		ANKI_ASSERT(transform.hasUniformScale());
+		out.m_radius = m_radius * transform.getScale().x();
 		return out;
 	}
 

AnKi/Config.h.cmake

@@ -143,8 +143,13 @@
 #endif
 
 // Graphics backend
-#define ANKI_GR_BACKEND_GL 0
-#define ANKI_GR_BACKEND_VULKAN 1
+#if ${_ANKI_GR_BACKEND} == 0
+#	define ANKI_GR_BACKEND_VULKAN 1
+#	define ANKI_GR_BACKEND_DIRECT3D 0
+#else
+#	define ANKI_GR_BACKEND_VULKAN 0
+#	define ANKI_GR_BACKEND_DIRECT3D 1
+#endif
 
 // Windowing system
 #if ${_ANKI_WINDOWING_SYSTEM} == 0
@@ -162,7 +167,7 @@
 #endif
 
 // Mobile or not
-#define ANKI_PLATFORM_MOBILE (ANKI_CPU_ARCH_ARM)
+#define ANKI_PLATFORM_MOBILE ${_ANKI_PLATFORM_MOBILE}
 
 // Some compiler attributes
 #if ANKI_COMPILER_GCC_COMPATIBLE

AnKi/Core/App.cpp

@@ -62,6 +62,7 @@ BoolCVar g_verboseLogCVar(CVarSubsystem::kCore, "VerboseLog", false, "Verbose lo
 BoolCVar g_benchmarkModeCVar(CVarSubsystem::kCore, "BenchmarkMode", false, "Run in a benchmark mode. Fixed timestep, unlimited target FPS");
 NumericCVar<U32> g_benchmarkModeFrameCountCVar(CVarSubsystem::kCore, "BenchmarkModeFrameCount", 60 * 60 * 2, 1, kMaxU32,
 											   "How many frames the benchmark will run before it quits");
+BoolCVar g_meshletRenderingCVar(CVarSubsystem::kCore, "MeshletRendering", false, "Do meshlet culling and rendering");
 
 #if ANKI_PLATFORM_MOBILE
 static StatCounter g_maliGpuActiveStatVar(StatCategory::kGpuMisc, "Mali active cycles", StatFlag::kMainThreadUpdates);
@@ -222,13 +223,11 @@ Error App::initInternal()
 		"NOT built with tracing";
 #endif
 
-	ANKI_CORE_LOGI("Initializing application ("
-				   "version %u.%u, "
-				   "%s, "
-				   "compiler %s, "
-				   "build date %s, "
-				   "commit %s)",
-				   ANKI_VERSION_MAJOR, ANKI_VERSION_MINOR, buildType, ANKI_COMPILER_STR, __DATE__, ANKI_REVISION);
+	ANKI_CORE_LOGI("Initializing application");
+	ANKI_CORE_LOGI("\tBuild type %s", buildType);
+	ANKI_CORE_LOGI("\tBuild time %s %s", __DATE__, __TIME__);
+	ANKI_CORE_LOGI("\tCompiler %s", ANKI_COMPILER_STR);
+	ANKI_CORE_LOGI("\tCommit %s", ANKI_REVISION);
 
 // Check SIMD support
 #if ANKI_SIMD_SSE && ANKI_COMPILER_GCC_COMPATIBLE
@@ -323,11 +322,13 @@ Error App::initInternal()
 	String executableFname;
 	ANKI_CHECK(getApplicationPath(executableFname));
 	ANKI_CORE_LOGI("Executable path is: %s", executableFname.cstr());
-	String shadersPath;
-	getParentFilepath(executableFname, shadersPath);
-	shadersPath += ":";
-	shadersPath += g_dataPathsCVar.get();
-	g_dataPathsCVar.set(shadersPath);
+	String extraPaths;
+	getParentFilepath(executableFname, extraPaths);
+	extraPaths += "|ankiprogbin"; // Shaders
+	extraPaths += ":" ANKI_SOURCE_DIRECTORY "|EngineAssets,!AndroidProject"; // EngineAssets
+	extraPaths += ":";
+	extraPaths += g_dataPathsCVar.get();
+	g_dataPathsCVar.set(extraPaths);
 #endif
 
 	ANKI_CHECK(ResourceManager::allocateSingleton().init(allocCb, allocCbUserData));

AnKi/Core/App.h

@@ -21,6 +21,7 @@ extern NumericCVar<U32> g_windowHeightCVar;
 extern NumericCVar<U32> g_windowFullscreenCVar;
 extern NumericCVar<U32> g_targetFpsCVar;
 extern NumericCVar<U32> g_displayStatsCVar;
+extern BoolCVar g_meshletRenderingCVar;
 extern StatCounter g_cpuTotalTimeStatVar;
 extern StatCounter g_rendererGpuTimeStatVar;
 

AnKi/Core/CMakeLists.txt

@@ -7,7 +7,8 @@ set(sources
 	GpuMemory/UnifiedGeometryBuffer.cpp
 	GpuMemory/GpuSceneBuffer.cpp
 	GpuMemory/RebarTransientMemoryPool.cpp
-	GpuMemory/GpuReadbackMemoryPool.cpp)
+	GpuMemory/GpuReadbackMemoryPool.cpp
+	GpuMemory/GpuVisibleTransientMemoryPool.cpp)
 
 set(headers
 	App.h

AnKi/Core/CVarSet.cpp

@@ -62,7 +62,7 @@ Error CVarSet::setFromCommandLineArguments(U32 cmdLineArgsCount, char* cmdLineAr
 			{
 				if(foundCVar)
 				{
-					ANKI_CORE_LOGW("Command line arg %s has ambiguous name", varName.cstr());
+					ANKI_CORE_LOGE("Command line arg %s has ambiguous name. Skipping", varName.cstr());
 				}
 				else
 				{
@@ -102,6 +102,7 @@ Error CVarSet::setFromCommandLineArguments(U32 cmdLineArgsCount, char* cmdLineAr
 				break;
 			}
 				ANKI_CVAR_NUMERIC_SET(U8)
+				ANKI_CVAR_NUMERIC_SET(U16)
 				ANKI_CVAR_NUMERIC_SET(U32)
 				ANKI_CVAR_NUMERIC_SET(PtrSize)
 				ANKI_CVAR_NUMERIC_SET(F32)
@@ -117,7 +118,7 @@ Error CVarSet::setFromCommandLineArguments(U32 cmdLineArgsCount, char* cmdLineAr
 		}
 		else
 		{
-			ANKI_CORE_LOGW("Can't recognize command line argument: %s. Skipping", varName.cstr());
+			ANKI_CORE_LOGE("Can't recognize command line argument: %s. Skipping", varName.cstr());
 		}
 	}
 

AnKi/Core/CVarSet.h

@@ -52,6 +52,7 @@ class CVar : public IntrusiveListEnabled<CVar>
 		kString,
 		kBool,
 		kNumericU8,
+		kNumericU16,
 		kNumericU32,
 		kNumericPtrSize,
 		kNumericF32
@@ -122,6 +123,7 @@ class NumericCVar : public CVar
 	}
 
 ANKI_CVAR_NUMERIC_TYPE(U8)
+ANKI_CVAR_NUMERIC_TYPE(U16)
 ANKI_CVAR_NUMERIC_TYPE(U32)
 ANKI_CVAR_NUMERIC_TYPE(PtrSize)
 ANKI_CVAR_NUMERIC_TYPE(F32)