TransformSystem.cpp

#include "Foundation/Logging/Logger.h"
 
#include "TransformSystem.h"
 
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
#include <glm/ext/quaternion_float.hpp>
#include <glm/gtx/matrix_decompose.hpp>
 
#include "Services/Variables.h"
 
#include "Utilities/Parallel.h"
 
namespace
{
  using namespace Cogs::Core;
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TransformSystem");
 
  auto transformChainChanged(TransformSystem * system, TransformComponent * component) -> bool
  {
    const auto & transformState = system->getData<TransformState>(component);
 
    bool componentChanged = !transformState.cached || component->hasChanged();
 
    if(auto * parentTransform = component->parent.resolveComponent<TransformComponent>(); parentTransform) {
      return componentChanged || transformChainChanged(system, parentTransform);
    } else {
      return componentChanged;
    }
  }
}
 
void Cogs::Core::TransformSystem::update(class Context *)
{
  const bool workParallel = context->engine->workParallel();
 
  if (workParallel) {
    auto group = Parallel::processComponents(context, pool, "TransformSystem::transformChain", [this](TransformComponent & component, size_t) {
      TransformState & transformState = this->getData<TransformState>(&component);
 
      transformState.cached = !transformChainChanged(this, &component);
      transformState.changed = !transformState.cached;
    });
 
    context->taskManager->destroy(group);
 
    group = Parallel::processComponents(context, pool, "TransformSystem::updateLocal", [this](TransformComponent & component, size_t) {
      if (component.hasChanged()) {
        updateLocalTransform(component);
      }
    });
 
    context->taskManager->destroy(group);
  } else {
    for (auto & component : pool) {
      TransformState & transformState = this->getData<TransformState>(&component);
 
      transformState.cached = !transformChainChanged(this, &component);
      transformState.changed = !transformState.cached;
    }
 
    for (auto & component : pool) {
      if (component.hasChanged()) {
        updateLocalTransform(component);
      }
    }
  }
 
  {
    CpuInstrumentationScope(SCOPE_SYSTEMS, "TransformSystem::updateLocalToWorldTransform");
    for (auto & component : pool) {
      updateLocalToWorldTransform(component);
    }
  }
}
 
void  Cogs::Core::TransformSystem::handleOriginUpdate(class Context* /*context*/)
{
  if (origin.x == originUpdate.x && origin.y == originUpdate.y && origin.z == originUpdate.z) {
    // Origin update is exactly identical current origin, so no need to do anything
    return;
  }
 
  // Swap in new origin and trigger calculation of new transforms for all components.
  origin = originUpdate;
  for (auto& component : pool) {
    component.setChanged();
  }
}
 
void Cogs::Core::TransformSystem::setLocalTransform(TransformComponent* component, const glm::mat4& matrix)
{
  // The matrix decompose function uses the determinant of the matrix to check if it is singular (i.e. broken),
  // and since this is numerics, there needs to be a threshold set somewhere. GLM has chosen FLT_MIN (~1.2e-7).
  //
  // If the matrix contains a uniform scale of e.g. 3/1000, the determinant of this matrix is (3/1000)^3=2.7e-8,
  // and the matrix will fail the test in the decompose function, even though it is definitely non-singular.
  //
  // To circument this, we factor out the uniform scale before passing the matrix to decompose (and thus remove
  // the scaling of the determinant which caused the problem), and apply the scaling afterwards.
  //
  // We set the sanity check on scale factor to that we should be able to calculate the inverse scale matrix.
  float uniformScale = std::cbrt(std::abs(glm::determinant(glm::mat3(matrix))));
  float reciprocalUniformScale = 1.f / uniformScale;
  if (std::isfinite(reciprocalUniformScale)) {
    glm::mat4 conditionedMatrix = matrix * glm::mat4(reciprocalUniformScale, 0.f, 0.f, 0.f,
                                                     0.f, reciprocalUniformScale, 0.f, 0.f,
                                                     0.f, 0.f, reciprocalUniformScale, 0.f,
                                                     0.f, 0.f, 0.f, 1.f);
 
    glm::vec3 skew;
    glm::vec4 perspective;
    if (glm::decompose(conditionedMatrix, component->scale, component->rotation, component->position, skew, perspective)) {
 
      // decompose supports extracting skew and perspective from the transform matrix, which we don't support via
      // transformcomponent properties. If we encounter such a matrix, warn the user and just use the matrix directly.
      if (std::numeric_limits<float>::epsilon() <= dot(skew, skew)) {
        LOG_WARNING(logger, "Transform matrix contains skew, which is not supported, using matrix directly. Check your models.");
        component->transform = matrix;
        component->transformFlags = 1;
      }
      else if (auto t = perspective - glm::vec4(0, 0, 0, 1); std::numeric_limits<float>::epsilon() <= dot(t, t)) {
        LOG_WARNING(logger, "Transform matrix contains perspective, which is not supported, using matrix directly. Check your models.");
        component->transform = matrix;
        component->transformFlags = 1;
      }
 
      // Apply uniform scale factor
      else {
        component->scale *= uniformScale;
      }
 
    }
    else {
      LOG_WARNING(logger, "Failed to decompose matrix, using matrix directly and position/scale/rotation will have no effect. Check your models.");
      component->transform = matrix;
      component->transformFlags = 1;
    }
  }
  else {
    LOG_ERROR(logger, "Transform matrix probably totally broken, ignoring. Check your models.");
    component->position = glm::vec3(0.f);
    component->rotation = glm::quat();
    component->scale = glm::vec3(1.f);
  }
 
  getLocalTransform(component) = matrix;
 
  component->resetCarryChanged();
  component->resetChanged();
 
  getData<TransformState>(component).cached = false;
}
 
void Cogs::Core::TransformSystem::updateLocalToWorldTransform(const TransformComponent & component, bool dirty)
{
  auto & transformState = getData<Core::TransformState>(&component);
 
  if (transformState.cached && !dirty) return;
 
  if (dirty) updateLocalTransform(component);
 
  if (component.parent) {
    auto parent = component.parent.resolveComponent<TransformComponent>();
 
    updateLocalToWorldTransform(*parent, dirty);
 
    getLocalToWorld(&component) = getLocalToWorld(parent) * getLocalTransform(&component);
  } else {
    getLocalToWorld(&component) = getLocalTransform(&component);
  }
 
  transformState.changed = true;
  transformState.cached = true;
}