TriggerSystem.cpp

#include "TriggerSystem.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"
 
void Cogs::Core::TriggerSystem::update(Context * context)
{
  auto manager = context->services->getService<PhysicsManager>();
 
  for (auto & c : pool) {
    if (!c.isActive()) continue;
 
    auto & data = getData(&c);
 
    auto transformComponent = c.getComponent<TransformComponent>();
 
    if (!data.rigidBody) {
      auto collisionComponent = c.getComponent<CollisionComponent>();
 
      if (!collisionComponent || !collisionComponent->collisionShape) {
        continue;
      }
 
      data.collisionShape = collisionComponent->collisionShape;
 
      context->transformSystem->updateLocalToWorldTransform(*transformComponent, true);
      auto worldTransform = context->transformSystem->getLocalToWorld(transformComponent);
 
      auto scale = glm::vec3(glm::length(worldTransform[0]), glm::length(worldTransform[1]), glm::length(worldTransform[2]));
      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)))));
      auto position = glm::vec4(worldTransform[3]);
 
      data.scale = scale;
      data.collisionShape->setLocalScaling(toBullet(scale));
 
      const btTransform origin(toBullet(rotation), toBullet(position));
 
      data.motionState = std::make_unique<btDefaultMotionState>(origin);
 
      btRigidBody::btRigidBodyConstructionInfo ci(0, data.motionState.get(), data.collisionShape, btVector3());
 
      data.rigidBody = std::make_unique<btRigidBody>(ci);
      data.shared = std::make_unique<SharedRigidBodyData>();
      data.shared->trigger = true;
      data.shared->entity = context->store->getEntity(c.getContainer()->getId());
      data.rigidBody->setUserPointer(data.shared.get());
 
      data.rigidBody->setCollisionFlags(data.rigidBody->getCollisionFlags() | btCollisionObject::CF_NO_CONTACT_RESPONSE | btCollisionObject::CF_KINEMATIC_OBJECT);
      data.rigidBody->setActivationState(DISABLE_DEACTIVATION);
 
      manager->addRigidBody(data.rigidBody.get());
    }
 
    if (data.rigidBody) {
      auto motionState = static_cast<btDefaultMotionState *>(data.motionState.get());
 
      context->transformSystem->updateLocalToWorldTransform(*transformComponent, true);
      const auto & worldTransform = context->transformSystem->getLocalToWorld(transformComponent);
 
      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]);
 
      if (glm::any(glm::greaterThan(glm::abs(scale - data.scale), glm::vec3(0.001f)))) {
        manager->removeRigidBody(data.rigidBody.get());
        updateMassProperties(data, 0, scale);
        manager->addRigidBody(data.rigidBody.get());
      }
 
      const btTransform origin(toBullet(rotation), toBullet(position));
 
      motionState->setWorldTransform(origin);
    }
  }
}
 
void Cogs::Core::TriggerSystem::destroyComponent(ComponentHandle component)
{
  auto manager = context->services->getService<PhysicsManager>();
  manager->waitForASync(context);
 
  auto c = component.resolveComponent<TriggerComponent>();
  auto & data = getData(c);
 
  if (data.rigidBody) {
    manager->removeRigidBody(data.rigidBody.get());
  }
 
  ComponentSystemWithDataPool::destroyComponent(component);
}