Fix RigidStatic intersetion at initial pose

Fixes include:
- Buffer sizes corrections in the triangle mesh descriptor
- Raycasting against the object itself, and not over the PxScene.
- Updating object pose
- Changing initialization order in Games between ObjectList and Physics to prevent double freeing of physics objects
- Triangle mesh post processing(physx::PxMeshPreprocessingFlag::eWELD_VERTICES)

Author: NicusorN5

3DRadSpace/Engine3DRadSpace/Games/Game.cpp

@@ -80,19 +80,19 @@ IService* Game::RequireService(const std::type_index& type)
 
 Game::Game(const std::string &title, size_t width, size_t height) :
 	Window(std::make_unique<Native::Window>(title, width, height)),
-	Objects(std::make_unique<ObjectList>(this)),
 	Keyboard(Window->GetKeyboardState()),
-	Mouse(Window->GetMouseState())
+	Mouse(Window->GetMouseState()),
+	Objects(std::make_unique<ObjectList>(this))
 {
 	Device = GameFactory::CreateGraphicsDevice("", Window->NativeHandle(), width, height);
 	_initialize();
 }
 
 Game::Game(Native::Window &&window) :
 	Window(std::make_unique<Native::Window>(std::move(window))),
-	Objects(std::make_unique<ObjectList>(this)),
 	Keyboard(Window->GetKeyboardState()),
-	Mouse(Window->GetMouseState())
+	Mouse(Window->GetMouseState()),
+	Objects(std::make_unique<ObjectList>(this))
 {
 	Math::Point size = Window->Size();
 

3DRadSpace/Engine3DRadSpace/Games/Game.hpp

@@ -42,7 +42,6 @@ namespace Engine3DRadSpace
 
 		std::unique_ptr<Native::Window> Window;
 		std::unique_ptr<Graphics::IGraphicsDevice> Device;
-		std::unique_ptr<Objects::ObjectList> Objects;
 
 		Math::Matrix4x4 View;
 		Math::Matrix4x4 Projection;
@@ -60,6 +59,8 @@ namespace Engine3DRadSpace
 		std::unique_ptr<Audio::IAudioEngine> Audio;
 		std::unique_ptr<Graphics::Rendering::PostProcessCollection> PostProcesses;
 
+		std::unique_ptr<Objects::ObjectList> Objects;
+
 		IService* RequireService(const std::type_index& type);
 
 		double Draw_dt = 0;

3DRadSpace/Engine3DRadSpace/Graphics/DirectX11/VertexBuffer.cpp

@@ -73,7 +73,7 @@ size_t VertexBuffer::ReadData(void** data)
 	_device->_context->Map(_buffer.Get(), 0, D3D11_MAP_READ, 0, &res);
 
 	*data = res.pData;
-	return size_t(res.DepthPitch);
+	return _numVerts * _structSize;
 }
 
 void VertexBuffer::EndRead()

3DRadSpace/Engine3DRadSpace/Physics/ICollider.hpp

@@ -25,6 +25,7 @@ namespace Engine3DRadSpace::Physics
 
 		virtual std::optional<float> Intersects(const Math::Ray& r) = 0;
 		virtual void UpdateTransform() = 0;
+		virtual void UpdateTransform(const Math::Vector3& position, const Math::Quaternion& rotation) = 0;
 
 		virtual ~ICollider() = default;
 	};

3DRadSpace/Engine3DRadSpace/Physics/NVPhysX/DynamicCollider.cpp

@@ -120,6 +120,10 @@ void DynamicCollider::UpdateTransform()
 
 }
 
+void DynamicCollider::UpdateTransform(const Math::Vector3 & position, const Math::Quaternion & rotation)
+{
+}
+
 std::optional<float> DynamicCollider::Intersects(const Math::Ray& r)
 {
 	return 0.0f;

3DRadSpace/Engine3DRadSpace/Physics/NVPhysX/DynamicCollider.hpp

@@ -44,6 +44,7 @@ namespace Engine3DRadSpace::Physics::NVPhysX
 
 		std::optional<float> Intersects(const Math::Ray& r) override;
 		void UpdateTransform() override;
+		void UpdateTransform(const Math::Vector3& position, const Math::Quaternion& rotation) override;
 
 		friend class PhysicsEngine;
 

3DRadSpace/Engine3DRadSpace/Physics/NVPhysX/PhysicsEngine.cpp

@@ -101,9 +101,12 @@ PhysicsEngine::~PhysicsEngine()
 	PX_RELEASE(_cpuDispatcher);
 	PX_RELEASE(_physics);
 
-	auto transport = _pvd->getTransport();
-	PX_RELEASE(transport);
-	PX_RELEASE(_pvd);
+	if(_pvd)
+	{
+		auto transport = _pvd->getTransport();
+		PX_RELEASE(transport);
+		PX_RELEASE(_pvd);
+	}
 
 	PX_RELEASE(_foundation);
 }

3DRadSpace/Engine3DRadSpace/Physics/NVPhysX/PhysicsEngine.hpp

@@ -24,13 +24,13 @@ namespace Engine3DRadSpace::Physics::NVPhysX
 		std::unique_ptr<physx::PxDefaultAllocator> _allocator;
 		std::unique_ptr<physx::PxErrorCallback> _errCallback;
 
-		physx::PxFoundation* _foundation;
-		physx::PxPvd* _pvd;
-		physx::PxPvdTransport* _pvdTransport;
+		physx::PxFoundation* _foundation = nullptr;
+		physx::PxPvd* _pvd = nullptr;
+		physx::PxPvdTransport* _pvdTransport = nullptr;
 
-		physx::PxPhysics* _physics;
-		physx::PxDefaultCpuDispatcher* _cpuDispatcher;
-		physx::PxScene* _scene;
+		physx::PxPhysics* _physics = nullptr;
+		physx::PxDefaultCpuDispatcher* _cpuDispatcher = nullptr;
+		physx::PxScene* _scene = nullptr;
 
 		double _accTimer = 0;
 		double _timeStep;

3DRadSpace/Engine3DRadSpace/Physics/NVPhysX/StaticMeshCollider.cpp

@@ -7,6 +7,7 @@
 #include <geometry/PxTriangleMeshGeometry.h>
 #include <PxPhysicsAPI.h>
 #include "../../Content/Assets/ModelAsset.hpp"
+#include "../../Logging/Warning.hpp"
 
 using namespace Engine3DRadSpace;
 using namespace Engine3DRadSpace::Content::Assets;
@@ -31,52 +32,60 @@ void StaticMeshCollider::_generateRigidbody()
 
 	physx::PxTolerancesScale toleranceScale;
 	physx::PxCookingParams cookParams(toleranceScale);
+	cookParams.meshPreprocessParams |= physx::PxMeshPreprocessingFlag::eWELD_VERTICES;
+	cookParams.meshWeldTolerance = 0.001f;
 
 	for(auto &mesh : *_model)
 	{
 		for(auto &part : *mesh.get())
 		{
+			auto [vertexBuffer, indexBuffer] = part->CreateStagingBuffers();
+			
 			void* verts;
-			size_t structSize = part->VertexBuffer->StructSize();
-			size_t numVertices = part->VertexBuffer->NumVertices();
-
 			void* indices;
-			part->VertexBuffer->ReadData(&verts);
-			
-			//create a copy of the position vertices.
-			std::unique_ptr<Vector3[]> vertices = std::make_unique<Vector3[]>(numVertices); 
-			for(size_t i = 0; i < numVertices; ++i)
+
+			size_t structSize = vertexBuffer->StructSize();
+			std::ignore = vertexBuffer->ReadData(&verts);
+			size_t numVertices = vertexBuffer->NumVertices();
+
+			std::unique_ptr<Vector3[]> vertices = std::make_unique<Vector3[]>(numVertices);
+			for(size_t i = 0; i < numVertices; i++)
 			{
+				//Assume VS_Position as first element of the declaration.
 				vertices[i] = *reinterpret_cast<Vector3*>((static_cast<std::byte*>(verts) + (structSize * i)));
 			}
 
-			part->VertexBuffer->EndRead();
-			part->IndexBuffer->ReadData(&indices);
+			std::ignore = indexBuffer->ReadData(&indices);	
+			size_t numIndices = indexBuffer->NumIndices();
 
-			physx::PxTriangleMeshDesc meshDesc;
+			physx::PxTriangleMeshDesc meshDesc{};
+			meshDesc.setToDefault();
 
 			meshDesc.points.count = numVertices;
 			meshDesc.points.data = vertices.get();
-			meshDesc.points.stride = part->VertexBuffer->StructSize();
+			meshDesc.points.stride = sizeof(Vector3);
 
-			meshDesc.triangles.count = part->IndexBuffer->NumIndices();
+			meshDesc.triangles.count = numIndices / 3;
 			meshDesc.triangles.data = indices;
-			meshDesc.triangles.stride = sizeof(unsigned);
+			meshDesc.triangles.stride = 3 * sizeof(unsigned);
 
 #if _DEBUG
-			auto b = PxValidateTriangleMesh(cookParams, meshDesc);
-			PX_ASSERT(b);
-			assert(b);
+			if(!PxValidateTriangleMesh(cookParams, meshDesc))
+				Logging::SetLastWarning("PhysX: PxValidateTriangleMesh failed!");
 #endif
-			meshes.push_back(
-				PxCreateTriangleMesh(
-					cookParams,
-					meshDesc, 
-					nvPhysics->getPhysicsInsertionCallback()
-				)
+			auto cookedMesh = PxCreateTriangleMesh(
+				cookParams,
+				meshDesc, 
+				nvPhysics->getPhysicsInsertionCallback()
 			);
 
-			part->IndexBuffer->EndRead();
+			vertexBuffer->EndRead();
+			indexBuffer->EndRead();
+
+			if(cookedMesh != nullptr)
+				meshes.push_back(cookedMesh);
+			else
+				Logging::SetLastWarning("PhysX: PxCreateTriangleMesh failed!");
 		}
 	}
 
@@ -104,8 +113,6 @@ float StaticMeshCollider::_getMass()
 
 void StaticMeshCollider::_setMass(float mass)
 {
-	_mass = mass;
-	//static_cast<physx::PxRigidStatic*>(_rigidbody.get());
 }
 
 float StaticMeshCollider::_getLinearDamping()
@@ -156,76 +163,70 @@ StaticMeshCollider::StaticMeshCollider(
 	IPhysicsEngine* physics,
 	Graphics::Model3D* model,
 	const Math::Vector3 scale
-) : IStaticCollider(physics)
+) : IStaticCollider(physics),
+	_model(model),
+	_scale(scale)
 {
 	_generateRigidbody();
 }
 
 void StaticMeshCollider::UpdateTransform()
 {
-	auto rigidbody = static_cast<physx::PxRigidStatic*>(_rigidbody.get());
-	auto tr = rigidbody->getGlobalPose();
-
-	_position = Vector3(
-		tr.p.x,
-		tr.p.y,
-		tr.p.z
-	);
-	
-	_rotation = Quaternion(
-		tr.q.x,
-		tr.q.y,
-		tr.q.z,
-		tr.q.w
-	);
 }
 
-std::optional<float> StaticMeshCollider::Intersects(const Math::Ray &r)
+void StaticMeshCollider::UpdateTransform(const Math::Vector3 &position, const Math::Quaternion &rotation)
 {
-	if(_physics == nullptr) return std::nullopt;
-
-	auto scene = static_cast<physx::PxScene*>(_physics->GetScene());
-	
-	auto origin = physx::PxVec3(r.Origin.X, r.Origin.Y, r.Origin.Z);
-	auto dir = physx::PxVec3(r.Direction.X, r.Direction.Y, r.Direction.Z);
-
-	physx::PxRaycastBuffer buffer;
-
-	bool result = scene->raycast(
-		origin,
-		dir,
-		std::numeric_limits<float>::infinity(),
-		buffer
-	);
-	if(!result || !buffer.hasBlock) return std::nullopt;
-	
-	if(buffer.block.actor != static_cast<physx::PxRigidStatic*>(_rigidbody.get())) return false;
-	else return buffer.block.distance;
+	_rigidbody->setGlobalPose(physx::PxTransform(
+		physx::PxVec3(_position.X, _position.Y, _position.Z),
+		physx::PxQuat(_rotation.X, _rotation.Y, _rotation.Z, _rotation.W)
+	));
 }
 
-void StaticMeshCollider::SetPosition(const Vector3& pos, bool wake)
+std::optional<float> StaticMeshCollider::Intersects(const Math::Ray &r)
 {
-	auto rigidbody = static_cast<physx::PxRigidStatic*>(_rigidbody.get());
-	auto tr = rigidbody->getGlobalPose();
+	if(_rigidbody == nullptr) return std::nullopt;
 
-	tr.p = physx::PxVec3(pos.X, pos.Y, pos.Z);
-	rigidbody->setGlobalPose(physx::PxTransform(tr));
-}
+	auto* actor = static_cast<physx::PxRigidStatic*>(_rigidbody.get());
 
-void StaticMeshCollider::SetRotation(const Math::Quaternion & newQuat, bool wake)
-{
-	auto rigidbody = static_cast<physx::PxRigidStatic*>(_rigidbody.get());
-	auto tr = rigidbody->getGlobalPose();
-	
-	tr.q = physx::PxQuat(newQuat.X, newQuat.Y, newQuat.Z, newQuat.W);
-	rigidbody->setGlobalPose(physx::PxTransform(tr));
-}
+	physx::PxVec3 origin(r.Origin.X, r.Origin.Y, r.Origin.Z);
+	physx::PxVec3 dir(r.Direction.X, r.Direction.Y, r.Direction.Z);
 
-void StaticMeshCollider::SetPositionRotation(const Math::Vector3 & newPos, const Math::Vector3 & newQuat, bool wake)
-{
-	physx::PxTransform tr;
-	tr.p = { _position.X, _position.Y, _position.Z};
-	tr.q = {_rotation.X, _rotation.Y, _rotation.Z, _rotation.W};
+	if(dir.normalize() == 0.0f) return std::nullopt;
+
+	physx::PxU32 numShapes = actor->getNbShapes();
+	if(numShapes == 0)
+	{
+		Logging::SetLastWarning("PhysX: StaticMeshCollider::Intersects - no shapes attached (mesh cooking may have failed).");
+		return std::nullopt;
+	}
+
+	std::vector<physx::PxShape*> shapes(numShapes);
+	actor->getShapes(shapes.data(), numShapes);
+
+	float closestDist = PX_MAX_F32;
+	bool hasHit = false;
+
+	for(auto* shape : shapes)
+	{
+		physx::PxTransform pose = actor->getGlobalPose() * shape->getLocalPose();
+		physx::PxRaycastHit hit;
+
+		physx::PxU32 hitCount = physx::PxGeometryQuery::raycast(
+			origin, dir,
+			shape->getGeometry(),
+			pose,
+			PX_MAX_F32,
+			physx::PxHitFlag::eDEFAULT | physx::PxHitFlag::eMESH_BOTH_SIDES,
+			1,
+			&hit
+		);
+
+		if(hitCount > 0 && hit.distance < closestDist)
+		{
+			closestDist = hit.distance;
+			hasHit = true;
+		}
+	}
 
-	static_cast<physx::PxRigidStatic*>(_rigidbody.get())->setGlobalPose(tr);
+	return hasHit ? std::optional<float>(closestDist) : std::nullopt;
 }

3DRadSpace/Engine3DRadSpace/Physics/NVPhysX/StaticMeshCollider.hpp

@@ -52,12 +52,9 @@ namespace Engine3DRadSpace::Physics::NVPhysX
 		StaticMeshCollider(StaticMeshCollider&& rb) noexcept = default;
 		StaticMeshCollider& operator=(StaticMeshCollider&& rb) noexcept = default;
 
-		void SetPosition(const Math::Vector3& newPos, bool wake = false);
-		void SetRotation(const Math::Quaternion& newQuat, bool wake = false);
-		void SetPositionRotation(const Math::Vector3& newPos, const Math::Vector3& newQuat, bool wake);
-
 		std::optional<float> Intersects(const Math::Ray& r) override;
 		void UpdateTransform() override;
+		void UpdateTransform(const Math::Vector3& position, const Math::Quaternion& rotation) override;
 
 		friend class PhysicsEngine;