CollisionSystem.cpp

#include "CollisionSystem.h"
 
#include "Resources/Model.h"
#include "Resources/Mesh.h"
 
#include "Components/Core/MeshComponent.h"
 
#include "PhysicsManager.h"
 
void Cogs::Core::PlaneCollisionSystem::update(Context * /*context*/)
{
  for (auto & c : pool) {
    auto & data = getData(&c);
 
    if (c.hasChanged() || !data.collisionShape) {
      data.collisionShape = std::make_unique<btStaticPlaneShape>(btVector3(0, 0, 1), 0.0f);
    }
 
    c.collisionShape = data.collisionShape.get();
  }
}
 
void Cogs::Core::SphereCollisionSystem::update(Context * /*context*/)
{
  for (auto & c : pool) {
    auto & data = getData(&c);
 
    if (c.hasChanged() || !data.collisionShape) {
      data.collisionShape = std::make_unique<btSphereShape>(c.radius);
    }
 
    c.collisionShape = data.collisionShape.get();
  }
}
 
void Cogs::Core::BoxCollisionSystem::update(Context * /*context*/)
{
  for (auto & c : pool) {
    auto & data = getData(&c);
 
    if (c.hasChanged() || !data.collisionShape) {
      data.collisionShape = std::make_unique<btBoxShape>(toBullet(c.halfSize));
    }
 
    c.collisionShape = data.collisionShape.get();
  }
}
 
void Cogs::Core::CapsuleCollisionSystem::update(Context * /*context*/)
{
  for (auto & c : pool) {
    auto & data = getData(&c);
 
    if (c.hasChanged() || !data.collisionShape) {
      data.collisionShape = std::make_unique<btCapsuleShapeZ>(c.radius, c.height);
    }
 
    c.collisionShape = data.collisionShape.get();
  }
}
 
void Cogs::Core::CylinderCollisionSystem::update(Context * /*context*/)
{
  for (auto & c : pool) {
    auto & data = getData(&c);
 
    if (c.hasChanged() || !data.collisionShape) {
      data.collisionShape = std::make_unique<btCylinderShapeZ>(btVector3(c.radius, c.radius, c.height));
    }
 
    c.collisionShape = data.collisionShape.get();
  }
}
 
void Cogs::Core::EmptyCollisionSystem::update(Context * /*context*/)
{
  for (auto & c : pool) {
    auto & data = getData(&c);
 
    if (c.hasChanged() || !data.collisionShape) {
      data.collisionShape = std::make_unique<btEmptyShape>();
    }
 
    c.collisionShape = data.collisionShape.get();
  }
}
 
namespace Cogs::Core
{
  ModelPart * findFirst(Model & model)
  {
    for (auto & part : model.parts) {
      if (part.meshIndex != static_cast<uint32_t>(-1)) return &part;
    }
 
    return nullptr;
  }
}
 
void Cogs::Core::MeshCollisionSystem::update(Context * /*context*/)
{
  for (auto & c : pool) {
    auto & data = getData(&c);
 
    if (c.hasChanged() || !data.collisionShape) {
      Mesh * mesh = nullptr;
      glm::mat4 transform(1.0f);
 
      if (c.mesh) {
        mesh = c.mesh.resolve();
      } else if (c.model) {
        auto model = c.model.resolve();
 
        if (model->isLoaded() && model->parts.size()) {
          auto part = findFirst(*model);
 
          if (part) {
            mesh = model->meshes[part->meshIndex].resolve();
            transform = model->getPartTransform(*part);
          }
        }
      } else {
        auto mc = c.getComponent<MeshComponent>();
 
        if (mc && mc->meshHandle) {
          mesh = mc->meshHandle.resolve();
        }
      }
 
      if (mesh) {
        data.mesh = std::make_unique<btTriangleMesh>();
 
        auto [vertexData, count, stride] = mesh->getPositionStream();
 
        auto indexes = mesh->getIndexes();
        if (indexes.size()) {
          const size_t faces = indexes.size() / 3;
 
          for (size_t i = 0; i < faces; ++i) {
            auto v1 = *reinterpret_cast<const glm::vec3 *>(vertexData + indexes[i * 3 + 0] * stride);
            auto v2 = *reinterpret_cast<const glm::vec3 *>(vertexData + indexes[i * 3 + 1] * stride);
            auto v3 = *reinterpret_cast<const glm::vec3 *>(vertexData + indexes[i * 3 + 2] * stride);
 
            v1 = glm::vec3(transform * glm::vec4(v1, 1));
            v2 = glm::vec3(transform * glm::vec4(v2, 1));
            v3 = glm::vec3(transform * glm::vec4(v3, 1));
 
            data.mesh->addTriangle(
              toBullet(v1),
              toBullet(v2),
              toBullet(v3)
            );
          }
 
          data.collisionShape = std::make_unique<btBvhTriangleMeshShape>(data.mesh.get(), false);
        }
      }
    }
 
    c.collisionShape = data.collisionShape.get();
  }
}