Move collision objects to the new library

src/anki/physics/Common.h

@@ -68,26 +68,14 @@ enum class PhysicsMaterialBit : U16
 };
 ANKI_ENUM_ALLOW_NUMERIC_OPERATIONS(PhysicsMaterialBit, inline)
 
-ANKI_USE_RESULT inline Vec4 toAnki(const dVector& v)
+ANKI_USE_RESULT inline Vec3 toAnki(const btVector3& v)
 {
-	return Vec4(v.m_x, v.m_y, v.m_z, v.m_w);
+	return Vec3(v.getX(), v.getY(), v.getZ());
 }
 
-ANKI_USE_RESULT inline dVector toNewton(const Vec4& v)
+ANKI_USE_RESULT inline btVector3 toBt(const Vec3& v)
 {
-	return dVector(v.x(), v.y(), v.z(), v.w());
-}
-
-ANKI_USE_RESULT inline Mat4 toAnki(const dMatrix& m)
-{
-	Mat4 ak(*reinterpret_cast<const Mat4*>(&m));
-	return ak.getTransposed();
-}
-
-ANKI_USE_RESULT inline dMatrix toNewton(const Mat4& m)
-{
-	Mat4 transp = m.getTransposed();
-	return dMatrix(&transp(0, 0));
+	return btVector3(v.x(), v.y(), v.z());
 }
 /// @}
 

src/anki/physics/PhysicsCollisionShape.cpp

@@ -5,84 +5,47 @@
 
 #include <anki/physics/PhysicsCollisionShape.h>
 #include <anki/physics/PhysicsWorld.h>
+#include <BulletCollision/Gimpact/btGImpactShape.h>
 
 namespace anki
 {
 
-I32 PhysicsCollisionShape::m_gid = 1;
-
 PhysicsCollisionShape::~PhysicsCollisionShape()
 {
-	if(m_shape)
-	{
-		NewtonDestroyCollision(m_shape);
-	}
+	getAllocator().deleteInstance(m_shape);
 }
 
-Error PhysicsSphere::create(PhysicsCollisionShapeInitInfo& init, F32 radius)
+PhysicsSphere::PhysicsSphere(PhysicsWorld* world, F32 radius)
+	: PhysicsCollisionShape(world)
 {
-	Error err = Error::NONE;
-
-	m_shape = NewtonCreateSphere(m_world->getNewtonWorld(), radius, m_gid++, nullptr);
-	if(!m_shape)
-	{
-		ANKI_PHYS_LOGE("NewtonCreateSphere() failed");
-		err = Error::FUNCTION_FAILED;
-	}
-
-	return err;
+	m_shape = getAllocator().newInstance<btSphereShape>(radius);
 }
 
-Error PhysicsBox::create(PhysicsCollisionShapeInitInfo& init, const Vec3& extend)
+PhysicsBox::PhysicsBox(PhysicsWorld* world, const Vec3& extend)
+	: PhysicsCollisionShape(world)
 {
-	Error err = Error::NONE;
-
-	m_shape = NewtonCreateBox(m_world->getNewtonWorld(), extend.x(), extend.y(), extend.z(), m_gid++, nullptr);
-	if(!m_shape)
-	{
-		ANKI_PHYS_LOGE("NewtonCreateBox() failed");
-		err = Error::FUNCTION_FAILED;
-	}
-
-	return err;
+	m_shape = getAllocator().newInstance<btBoxShape>(toBt(extend));
 }
 
-Error PhysicsTriangleSoup::create(PhysicsCollisionShapeInitInfo& init,
-	const Vec3* positions,
-	U32 positionsStride,
-	const U32* indices,
-	U32 indicesCount)
+PhysicsTriangleSoup::PhysicsTriangleSoup(
+	PhysicsWorld* world, ConstWeakArray<Vec3> positions, ConstWeakArray<U32> indices)
+	: PhysicsCollisionShape(world)
 {
-	m_shape = NewtonCreateTreeCollision(m_world->getNewtonWorld(), 0);
-	if(!m_shape)
-	{
-		ANKI_PHYS_LOGE("NewtonCreateBox() failed");
-		return Error::FUNCTION_FAILED;
-	}
+	ANKI_ASSERT((indices.getSize() % 3) == 0);
 
-	NewtonTreeCollisionBeginBuild(m_shape);
-
-	// Iterate index array
-	const U32* indicesEnd = indices + indicesCount;
-	for(; indices != indicesEnd; indices += 3)
+	m_mesh = getAllocator().newInstance<btTriangleMesh>();
+	for(U i = 0; i < indices.getSize(); i += 3)
 	{
-		Array<Vec3, 3> facePos;
-
-		for(U i = 0; i < 3; ++i)
-		{
-			U idx = indices[i];
-			const U8* ptr = reinterpret_cast<const U8*>(positions) + positionsStride * idx;
-
-			facePos[i] = *reinterpret_cast<const Vec3*>(ptr);
-		}
-
-		NewtonTreeCollisionAddFace(m_shape, 3, &facePos[0][0], sizeof(Vec3), 0);
+		m_mesh->addTriangle(
+			toBt(positions[indices[i]]), toBt(positions[indices[i + 1]]), toBt(positions[indices[i + 2]]));
 	}
 
-	const I optimize = 1;
-	NewtonTreeCollisionEndBuild(m_shape, optimize);
+	m_shape = getAllocator().newInstance<btGImpactMeshShape>(m_mesh);
+}
 
-	return Error::NONE;
+PhysicsTriangleSoup::~PhysicsTriangleSoup()
+{
+	getAllocator().deleteInstance(m_mesh);
 }
 
 } // end namespace anki

src/anki/physics/PhysicsCollisionShape.h

@@ -6,6 +6,7 @@
 #pragma once
 
 #include <anki/physics/PhysicsObject.h>
+#include <anki/util/WeakArray.h>
 
 namespace anki
 {
@@ -13,21 +14,6 @@ namespace anki
 /// @addtogroup physics
 /// @{
 
-/// Standard initializer for all collision shapes.
-struct PhysicsCollisionShapeInitInfo
-{
-	// Empty for now
-};
-
-/// Type of supported physics collision shapes.
-enum class PhysicsCollisionShapeType : U8
-{
-	NONE,
-	SPHERE,
-	BOX,
-	STATIC_TRIANGLE_SOUP
-};
-
 /// The base of all collision shapes.
 class PhysicsCollisionShape : public PhysicsObject
 {
@@ -40,85 +26,47 @@ public:
 	~PhysicsCollisionShape();
 
 anki_internal:
-	NewtonCollision* getNewtonShape() const
+	btCollisionShape* getBtShape() const
 	{
 		ANKI_ASSERT(m_shape);
 		return m_shape;
 	}
 
 protected:
-	NewtonCollision* m_shape = nullptr;
-	void* m_sceneCollisionProxy = nullptr;
-	static I32 m_gid;
+	btCollisionShape* m_shape = nullptr;
 };
 
 /// Sphere collision shape.
 class PhysicsSphere final : public PhysicsCollisionShape
 {
 public:
-	PhysicsSphere(PhysicsWorld* world)
-		: PhysicsCollisionShape(world)
-	{
-	}
-
-	~PhysicsSphere()
-	{
-	}
-
-	ANKI_USE_RESULT Error create(PhysicsCollisionShapeInitInfo& init, F32 radius);
+	PhysicsSphere(PhysicsWorld* world, F32 radius);
 };
 
 /// Box collision shape.
 class PhysicsBox final : public PhysicsCollisionShape
 {
 public:
-	PhysicsBox(PhysicsWorld* world)
-		: PhysicsCollisionShape(world)
-	{
-	}
-
-	~PhysicsBox()
-	{
-	}
-
-	ANKI_USE_RESULT Error create(PhysicsCollisionShapeInitInfo& init, const Vec3& extend);
+	PhysicsBox(PhysicsWorld* world, const Vec3& extend);
 };
 
 /// Convex hull collision shape.
 class PhysicsConvexHull final : public PhysicsCollisionShape
 {
 public:
-	PhysicsConvexHull(PhysicsWorld* world)
-		: PhysicsCollisionShape(world)
-	{
-	}
-
-	~PhysicsConvexHull()
-	{
-	}
-
-	ANKI_USE_RESULT Error create(
-		PhysicsCollisionShapeInitInfo& init, const Vec3* positions, U32 positionsCount, U32 positionsStride);
+	PhysicsConvexHull(PhysicsWorld* world, const Vec3* positions, U32 positionsCount, U32 positionsStride);
 };
 
 /// Static triangle mesh shape.
 class PhysicsTriangleSoup final : public PhysicsCollisionShape
 {
 public:
-	PhysicsTriangleSoup(PhysicsWorld* world)
-		: PhysicsCollisionShape(world)
-	{
-	}
+	PhysicsTriangleSoup(PhysicsWorld* world, ConstWeakArray<Vec3> positions, ConstWeakArray<U32> indices);
 
-	~PhysicsTriangleSoup()
-	{
-	}
+	~PhysicsTriangleSoup();
 
-	ANKI_USE_RESULT Error create(PhysicsCollisionShapeInitInfo& init,
-		const Vec3* positions,
-		U32 positionsStride,
-		const U32* indices,
-		U32 indicesCount);
+private:
+	btTriangleMesh* m_mesh = nullptr;
 };
 /// @}
 

src/anki/physics/PhysicsObject.cpp

@@ -0,0 +1,17 @@
+// Copyright (C) 2009-2018, Panagiotis Christopoulos Charitos and contributors.
+// All rights reserved.
+// Code licensed under the BSD License.
+// http://www.anki3d.org/LICENSE
+
+#include <anki/physics/PhysicsObject.h>
+#include <anki/physics/PhysicsWorld.h>
+
+namespace anki
+{
+
+HeapAllocator<U8> PhysicsObject::getAllocator() const
+{
+	return m_world->getAllocator();
+}
+
+} // end namespace anki

src/anki/physics/PhysicsObject.h

@@ -30,7 +30,6 @@ public:
 	PhysicsObject(PhysicsObjectType type, PhysicsWorld* world)
 		: m_world(world)
 		, m_type(type)
-		, m_refcount(0)
 	{
 		ANKI_ASSERT(m_world);
 	}
@@ -59,12 +58,14 @@ public:
 		return m_refcount;
 	}
 
+	HeapAllocator<U8> getAllocator() const;
+
 protected:
 	PhysicsWorld* m_world = nullptr;
 
 private:
+	Atomic<I32> m_refcount = {};
 	PhysicsObjectType m_type;
-	Atomic<I32> m_refcount;
 };
 /// @}
 

src/anki/physics/PhysicsWorld.cpp

@@ -4,9 +4,9 @@
 // http://www.anki3d.org/LICENSE
 
 #include <anki/physics/PhysicsWorld.h>
-#include <anki/physics/PhysicsPlayerController.h>
 #include <anki/physics/PhysicsCollisionShape.h>
 #include <anki/physics/PhysicsBody.h>
+#include <BulletCollision/Gimpact/btGImpactCollisionAlgorithm.h>
 
 namespace anki
 {
@@ -54,10 +54,15 @@ Error PhysicsWorld::create(AllocAlignedCallback allocCb, void* allocCbData)
 	// Create objects
 	m_broadphase = m_alloc.newInstance<btDbvtBroadphase>();
 	m_collisionConfig = m_alloc.newInstance<btDefaultCollisionConfiguration>();
+
 	m_dispatcher = m_alloc.newInstance<btCollisionDispatcher>(m_collisionConfig);
+	btGImpactCollisionAlgorithm::registerAlgorithm(m_dispatcher);
+
 	m_solver = m_alloc.newInstance<btSequentialImpulseConstraintSolver>();
 	m_world = m_alloc.newInstance<btDiscreteDynamicsWorld>(m_dispatcher, m_broadphase, m_solver, m_collisionConfig);
 
+	m_world->setGravity(btVector3(0.0f, -9.8f, 0.0f));
+
 	return Error::NONE;
 }