separated lod selection; improved scene picking

Author: malytomas

sources/asset-processor/model.cpp

@@ -6,6 +6,7 @@
 #include <cage-core/flatSet.h>
 #include <cage-core/hashString.h>
 #include <cage-core/mesh.h>
+#include <cage-core/meshAlgorithms.h>
 #include <cage-core/meshImport.h>
 #include <cage-core/skeletalAnimation.h>
 #include <cage-engine/shaderConventions.h>
@@ -239,6 +240,47 @@ namespace
 		if (dsm.textureNames[CAGE_SHADER_TEXTURE_NORMAL] != 0 && none(flags & ModelDataFlags::Normals))
 			CAGE_THROW_ERROR(Exception, "model uses normal map texture but has no normals");
 	}
+
+	Holder<PointerRange<const char>> generateAndSerializeCollider(const MeshImportPart &part, const MeshImportResult &result)
+	{
+		if (part.mesh->type() != MeshTypeEnum::Triangles)
+			return {};
+		if (part.mesh->indicesCount() == 0)
+			return {}; // indexed mesh only
+
+		CAGE_LOG(SeverityEnum::Info, "assetProcessor", "building collider");
+
+		Holder<Mesh> mesh = newMesh();
+		const auto &append = [&](const Mesh *tmp)
+		{
+			PointerRange<const Vec3> poss = tmp->positions();
+			PointerRange<const uint32> inds = tmp->indices();
+			for (uint32 i = 0; i < inds.size(); i += 3)
+				mesh->addTriangle(Triangle(poss[inds[i]], poss[inds[i + 1]], poss[inds[i + 2]]));
+		};
+		append(+part.mesh);
+
+		if (!part.mesh->boneIndices().empty())
+		{
+			for (const MeshImportAnimation &ani : result.animations)
+			{
+				for (Real t = 0; t <= 1; t += 0.05) // sample the animation at 20 positions
+				{
+					Holder<Mesh> tmp = part.mesh->copy();
+					animateMesh(+result.skeleton, +ani.animation, t, +tmp);
+					append(+tmp);
+				}
+			}
+		}
+
+		Holder<Mesh> convex = meshConvexHull(+mesh, {});
+
+		Holder<Collider> collider = newCollider();
+		collider->importMesh(+convex);
+		collider->optimize();
+		collider->rebuild();
+		return collider->exportBuffer();
+	}
 }
 
 void processModel()
@@ -336,17 +378,8 @@ void processModel()
 	Holder<PointerRange<const char>> serMesh = part.mesh->exportBuffer();
 	dsm.meshSize = serMesh.size();
 
-	Holder<PointerRange<const char>> serCol;
-	if (part.mesh->type() == MeshTypeEnum::Triangles)
-	{
-		CAGE_LOG(SeverityEnum::Info, "assetProcessor", "building collider");
-		Holder<Collider> collider = newCollider();
-		collider->importMesh(+part.mesh);
-		collider->optimize();
-		collider->rebuild();
-		serCol = collider->exportBuffer();
-		dsm.colliderSize = serCol.size();
-	}
+	Holder<PointerRange<const char>> serCol = generateAndSerializeCollider(part, result);
+	dsm.colliderSize = serCol.size();
 
 	CAGE_LOG(SeverityEnum::Info, "assetProcessor", "serializing");
 	AssetHeader h = processor->initializeAssetHeader();
@@ -360,8 +393,7 @@ void processModel()
 	ser << dsm;
 	ser << mat;
 	ser.write(serMesh);
-	if (serMesh)
-		ser.write(serCol);
+	ser.write(serCol);
 	h.originalSize = buffer.size();
 	Holder<PointerRange<char>> compressed = memoryCompress(buffer);
 	h.compressedSize = compressed.size();

sources/include/cage-core/collider.h

@@ -70,6 +70,7 @@ namespace cage
 
 	CAGE_CORE_API bool collisionDetection(CollisionDetectionConfig &params);
 
+	CAGE_CORE_API Real distance(Vec3 shape, const Collider *collider, Transform t);
 	CAGE_CORE_API Real distance(Line shape, const Collider *collider, Transform t);
 	CAGE_CORE_API Real distance(Triangle shape, const Collider *collider, Transform t);
 	CAGE_CORE_API Real distance(Plane shape, const Collider *collider, Transform t);

sources/include/cage-engine/lodSelection.h

@@ -0,0 +1,30 @@
+#ifndef guard_lodSelection_h_dsthgiztr8
+#define guard_lodSelection_h_dsthgiztr8
+
+#include <vector>
+
+#include <cage-engine/core.h>
+
+namespace cage
+{
+	struct CameraComponent;
+	class RenderObject;
+	class Model;
+	class AssetsOnDemand;
+
+	struct CAGE_ENGINE_API LodSelection
+	{
+		Vec3 center = Vec3::Nan(); // center of camera
+		Real screenSize = -1; // vertical size of screen in pixels, one meter in front of the camera
+		bool orthographic = false;
+
+		LodSelection() = default;
+		LodSelection(Vec3 center, const CameraComponent &cam, sint32 screenHeightPx);
+
+		uint32 selectLod(const Vec3 position, const RenderObject *object) const;
+		void selectModels(std::vector<Holder<Model>> &outModels, const Vec3 position, const RenderObject *object, AssetsOnDemand *assets) const;
+		void selectModels(std::vector<Holder<Model>> &outModels, const Vec3 position, const RenderObject *object, const AssetsManager *assets) const;
+	};
+}
+
+#endif // guard_lodSelection_h_dsthgiztr8

sources/include/cage-engine/renderPipeline.h

@@ -1,25 +1,18 @@
 #ifndef guard_renderPipeline_h_4hg1s8596drfh4
 #define guard_renderPipeline_h_4hg1s8596drfh4
 
+#include <cage-engine/lodSelection.h>
 #include <cage-engine/provisionalHandles.h>
 #include <cage-engine/scene.h>
 #include <cage-engine/sceneScreenSpaceEffects.h>
 
 namespace cage
 {
 	class EntityManager;
-	class ShaderProgram;
 	class RenderQueue;
 	class ProvisionalGraphics;
 	class AssetsOnDemand;
 
-	struct CAGE_ENGINE_API LodSelection
-	{
-		Vec3 center; // center of camera
-		Real screenSize = 0; // vertical size of screen in pixels, one meter in front of the camera
-		bool orthographic = false;
-	};
-
 	struct CAGE_ENGINE_API RenderPipelineConfig
 	{
 		String name;

sources/include/cage-engine/scenePicking.h

@@ -3,38 +3,19 @@
 
 #include <cage-core/entities.h>
 #include <cage-core/geometry.h>
-#include <cage-engine/scene.h>
+#include <cage-engine/lodSelection.h>
 
 namespace cage
 {
-	class Mesh;
-
 	struct CAGE_ENGINE_API PickableComponent
 	{};
 
-	/*
-	enum class ScenePickingPrecisionEnum
-	{
-		None = 0,
-		BoundingBoxesOnly,
-		BoundingMeshesOnly,
-		Models,
-		ModelsWithAlphaCut,
-		ModelsWithAnimations,
-		ModelsWithAnimationsAndAlphaCut,
-	};
-	*/
-
 	struct CAGE_ENGINE_API ScenePickingConfig
 	{
 		Line picker;
+		LodSelection lodSelection;
 		const AssetsManager *assets = nullptr;
 		const EntityManager *entities = nullptr;
-		//ScenePickingPrecisionEnum precision = ScenePickingPrecisionEnum::Models;
-
-		// used for lod selection
-		const Entity *camera = nullptr;
-		uint32 screenHeight = 0;
 	};
 
 	struct CAGE_ENGINE_API ScenePickingResult

sources/libcore/geometry/collider.cpp

@@ -2,7 +2,6 @@
 #include <vector>
 
 #include <cage-core/collider.h>
-//#include <cage-core/flatSet.h>
 #include <cage-core/geometry.h>
 #include <cage-core/memoryBuffer.h>
 #include <cage-core/mesh.h>
@@ -430,6 +429,7 @@ namespace cage
 
 			CollisionDetector(const ColliderImpl *ao, const ColliderImpl *bo, Transform am, Transform bm, Holder<PointerRange<CollisionPair>> &outputBuffer) : ats(ao->tris.data(), numeric_cast<uint32>(ao->tris.size()), am), bts(bo->tris.data(), numeric_cast<uint32>(bo->tris.size()), bm), abs(ao->boxes.data(), numeric_cast<uint32>(ao->boxes.size()), am), bbs(bo->boxes.data(), numeric_cast<uint32>(bo->boxes.size()), bm), ao(ao), bo(bo), outputBuffer(outputBuffer) {}
 
+		private:
 			void process(uint32 a, uint32 b)
 			{
 				CAGE_ASSERT(a < ao->nodes.size());
@@ -483,6 +483,7 @@ namespace cage
 				}
 			}
 
+		public:
 			void process()
 			{
 				process(0, 0);
@@ -528,6 +529,7 @@ namespace cage
 
 			IntersectionDetector(const ColliderImpl *collider, Transform m) : col(collider), m(m) { CAGE_ASSERT(!collider->dirty); }
 
+		private:
 			template<class T>
 			Real distance(const T &l, uint32 nodeIdx)
 			{
@@ -561,12 +563,16 @@ namespace cage
 				}
 			}
 
+		public:
 			template<class T>
 			Real distance(const T &shape)
 			{
-				return distance(shape * inverse(m), 0);
+				CAGE_THROW_CRITICAL(Exception, "distance to collider is untested and broken");
+				// the result is in the original space of the collider and must be converted back to the space of the shape
+				return distance(shape * inverse(m), 0) * m.scale;
 			}
 
+		private:
 			template<class T>
 			bool intersects(const T &l, uint32 nodeIdx)
 			{
@@ -590,12 +596,14 @@ namespace cage
 				}
 			}
 
+		public:
 			template<class T>
 			bool intersects(const T &shape)
 			{
 				return intersects(shape * inverse(m), 0);
 			}
 
+		private:
 			bool intersection(Line l, uint32 nodeIdx, Vec3 &point, uint32 &triangleIndex)
 			{
 				const Aabb b = col->boxes[nodeIdx];
@@ -664,14 +672,15 @@ namespace cage
 				}
 			}
 
+		public:
 			bool intersection(Line l, Vec3 &point, uint32 &triangleIndex)
 			{
+				// p is in the original space of the collider and must be converted back to the space of the shape
 				Vec3 pt;
 				uint32 ti = 0;
 				if (intersection(l * inverse(m), 0, pt, ti))
 				{
-					const Vec4 r4 = Vec4(pt, 1) * Mat4(m);
-					point = Vec3(r4) / r4[3];
+					point = pt * m;
 					triangleIndex = ti;
 					return true;
 				}
@@ -789,6 +798,12 @@ namespace cage
 		}
 	}
 
+	Real distance(Vec3 shape, const Collider *collider, Transform t)
+	{
+		IntersectionDetector d((const ColliderImpl *)collider, t);
+		return d.distance(shape);
+	}
+
 	Real distance(Line shape, const Collider *collider, Transform t)
 	{
 		IntersectionDetector d((const ColliderImpl *)collider, t);
@@ -892,7 +907,6 @@ namespace cage
 
 	Vec3 intersection(Line shape, const Collider *collider, Transform t, uint32 &triangleIndex)
 	{
-		// todo
 		IntersectionDetector d((const ColliderImpl *)collider, t);
 		Vec3 p;
 		if (d.intersection(shape, p, triangleIndex))