Upd

src/engine/physics/physicsworld.cpp

@@ -1,4 +1,5 @@
 #include "engine/core.h"
+#include "engine/log.h"
 #include "engine/engine.h"
 #include "engine/camera.h"
 #include "engine/physics/physicsworld.h"
@@ -10,6 +11,8 @@
 #include <BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h>
 #include <BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h>
 
+PhysicsWorld* g_PhysicsWorld = nullptr;
+
 static void InternalTickCallback(btDynamicsWorld* world, btScalar timeStep)
 {
 	SDL_assert(world);
@@ -88,9 +91,9 @@ const std::vector<RigidBody*>& PhysicsWorld::GetRigidBodies()
 
 void PhysicsWorld::Step(float delta)
 {
-	//	m_world->stepSimulation(delta);
+		m_world->stepSimulation(delta);
 	//	m_world->stepSimulation(delta, 12, m_stepTime);
-#if 1
+#if 0
 	if (delta < 0.01f)
 	{
 		m_accumulatedTime += delta;
@@ -178,3 +181,100 @@ void PhysicsWorld::InternalTick()
 	}
 }
 
+void PhysicsWorld::AddCollisionModel(StaticMeshVertex* vertices, size_t verticesCount, uint32_t* indices, size_t indicesCount)
+{
+	int index = (int)m_collisionModels.size();
+	m_collisionModels.resize((size_t)index + 1);
+
+	// Check for is indices are 32 bits
+	bool is32Bits = true;// sizeof(index_t) == sizeof(uint32_t);
+
+	m_collisionModels[index].triangleMesh = new btTriangleMesh(is32Bits);
+	m_collisionModels[index].triangleMesh->preallocateVertices((int)verticesCount);
+	m_collisionModels[index].triangleMesh->preallocateIndices((int)indicesCount);
+
+	// Initialize triangle mesh 
+	uint32_t trianglesCount = 0;
+	for (uint32_t n = 0; n < indicesCount; n += 3) {
+		m_collisionModels[index].triangleMesh->addTriangle(
+			glmVectorToBt(vertices[indices[n]].position),
+			glmVectorToBt(vertices[indices[n + 1]].position),
+			glmVectorToBt(vertices[indices[n + 2]].position),
+			true);
+
+		trianglesCount++;
+	}
+
+	// Create shape
+	m_collisionModels[index].shape = new btBvhTriangleMeshShape(m_collisionModels[index].triangleMesh, true);
+
+	// Create collision body
+	m_collisionModels[index].object = new btCollisionObject();
+	m_collisionModels[index].object->setCollisionShape(m_collisionModels[index].shape);
+	m_collisionModels[index].object->setUserPointer(&m_collisionModels[index]);
+
+	// Add to scene
+	m_world->addCollisionObject(m_collisionModels[index].object);
+
+	// Report
+	Msg("PhysicsSystem::AddCollisionModel: %i triangles %i bytes", trianglesCount, trianglesCount * sizeof(btVector3));
+}
+
+void PhysicsWorld::Reset()
+{
+	int numModels = (int)m_collisionModels.size();
+	for (int i = 0; i < numModels; i++)
+	{
+		if (m_collisionModels[i].object)
+		{
+			// remove object from world
+			m_world->removeCollisionObject(m_collisionModels[i].object);
+
+			// reset shape
+			m_collisionModels[i].object->setCollisionShape(nullptr);
+
+			// delete
+			delete m_collisionModels[i].object;
+			m_collisionModels[i].object = nullptr;
+		}
+
+		if (m_collisionModels[i].shape)
+		{
+			delete m_collisionModels[i].shape;
+			m_collisionModels[i].shape = nullptr;
+		}
+
+		if (m_collisionModels[i].triangleMesh)
+		{
+			delete m_collisionModels[i].triangleMesh;
+			m_collisionModels[i].triangleMesh = nullptr;
+		}
+	}
+
+	Msg("PhysicsSystem: Destroyed %d static collision models", numModels);
+
+	m_collisionModels.clear();
+}
+
+//
+ClosestRayResultCallback::ClosestRayResultCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld, IEntityBase* entity) :
+	btCollisionWorld::ClosestRayResultCallback(rayFromWorld, rayToWorld),
+	m_entity(entity)
+{
+}
+
+ClosestRayResultCallback::~ClosestRayResultCallback()
+{
+	m_entity = nullptr;
+}
+
+bool ClosestRayResultCallback::needsCollision(btBroadphaseProxy* proxy0) const
+{
+	bool needsCollision = inherited::needsCollision(proxy0);
+
+	btCollisionObject* collisionObject = (btCollisionObject*)proxy0->m_clientObject;
+	if (m_entity && collisionObject->getUserPointer() == m_entity)
+		return false;
+
+	return needsCollision;
+}