GhostSystem.cpp

#include "GhostSystem.h"
#include "PhysicsManager.h"
 
#include <glm/gtc/type_ptr.hpp>
 
#include "Systems/Core/TransformSystem.h"
 
#include "Context.h"
 
#include "Services/Services.h"
#include "Services/Time.h"
#include "Services/TaskManager.h"
 
#include "EntityStore.h"
 
#include "CollisionComponent.h"
 
#include "Platform/Instrumentation.h"
 
namespace {
  using namespace Cogs::Core;
 
  void updateProperties(GhostData& ghostData)
  {
    ghostData.collisionShape->setLocalScaling(toBullet(ghostData.scale));
 
    const float margin = glm::min(glm::min(ghostData.scale.x, ghostData.scale.y), ghostData.scale.z);
    const float marginMultiplier = 0.1f;
    auto diff = ghostData.scale - glm::vec3(1, 1, 1);
 
    if (glm::any(glm::greaterThan(glm::abs(diff), glm::vec3(0.01f, 0.01f, 0.01f)))) {
      ghostData.collisionShape->setMargin(margin * marginMultiplier);
    }
  }
 
}
 
 
void Cogs::Core::GhostSystem::update(Context * context)
{
  auto manager = context->services->getService<PhysicsManager>();
  for (auto & ghostComp : pool) {
    if (!ghostComp.isActive()) continue;
 
    auto & ghostData = getData(&ghostComp);
 
    const auto * trComp = ghostComp.getComponent<TransformComponent>();
    context->transformSystem->updateLocalToWorldTransform(*trComp, true);
    const auto & worldTransform = context->transformSystem->getLocalToWorld(trComp);
    const auto scale = glm::vec3(glm::length(worldTransform[0]), glm::length(worldTransform[1]), glm::length(worldTransform[2]));
    const auto rotation = glm::normalize(glm::quat_cast(glm::mat3(worldTransform * glm::scale(glm::vec3(1.0f / scale.x, 1.0f / scale.y, 1.0f / scale.z)))));
    const auto position = glm::vec4(worldTransform[3]);
    const btTransform origin(toBullet(rotation), toBullet(position));
 
    if (!ghostData.collisionObject) {
      const auto * collComp = ghostComp.getComponent<CollisionComponent>();
      if (!collComp || !collComp->collisionShape) {
        continue;
      }
      ghostData.collisionShape = collComp->collisionShape;
 
 
      //ghostData.motionState = std::make_unique<btDefaultMotionState>(origin);
 
      ghostData.scale = scale;
      updateProperties(ghostData);
 
      ghostData.shared = std::make_unique<SharedRigidBodyData>();
      ghostData.shared->entity = context->store->getEntity(ghostComp.getContainer()->getId());
 
      ghostData.collisionObject = std::make_unique<btPairCachingGhostObject>();
      ghostData.collisionObject->setUserPointer(ghostData.shared.get());
 
      ghostData.collisionObject->setCollisionShape(collComp->collisionShape);
      ghostData.collisionObject->setCollisionFlags(ghostData.collisionObject->getCollisionFlags() | btCollisionObject::CF_CHARACTER_OBJECT);  // Blind copy from an example, no idea what proper flags are.
      //data.rigidBody->setCollisionFlags(data.rigidBody->getCollisionFlags() | btCollisionObject::CF_NO_CONTACT_RESPONSE | btCollisionObject::CF_KINEMATIC_OBJECT);
      //data.rigidBody->setActivationState(DISABLE_DEACTIVATION);
 
      manager->addCollisionObject(ghostData.collisionObject.get());
    }
 
    if (glm::any(glm::greaterThan(glm::abs(scale - ghostData.scale), glm::vec3(0.001f)))) {
      manager->removeCollisionObject(ghostData.collisionObject.get());
      ghostData.scale = scale;
      updateProperties(ghostData);
      manager->addCollisionObject(ghostData.collisionObject.get());
    }
    ghostData.collisionObject->setWorldTransform(origin);
  }
}
 
void Cogs::Core::GhostSystem::destroyComponent(ComponentHandle component)
{
  auto * ghostComp = component.resolveComponent<GhostComponent>();
  auto & ghostData = getData(ghostComp);
 
  if (ghostData.collisionObject) {
    auto manager = context->services->getService<PhysicsManager>();
    manager->removeCollisionObject(ghostData.collisionObject.get());
  }
  ComponentSystemWithDataPool::destroyComponent(component);
}