ReflectionComponent.cpp

#include "ReflectionComponent.h"
 
#include "Context.h"
 
#include "Renderer/IRenderer.h"
 
#include "Components/Core/RenderComponent.h"
#include "Components/Core/SceneComponent.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Types.h"
 
using namespace Cogs::Reflection;
 
void Cogs::Core::ReflectionComponent::registerType()
{
  Field fields [] = {
    Field(Name("position"), &ReflectionComponent::position),
    Field(Name("normal"), &ReflectionComponent::normal),
  };
 
  Method methods [] = {
    Method(Name("postUpdate"), &ReflectionComponent::postUpdate),
    Method(Name("initialize"), &ReflectionComponent::initialize),
  };
 
  DynamicComponent::registerDerivedType<ReflectionComponent>().setFields(fields).setMethods(methods);
}
 
void Cogs::Core::ReflectionComponent::initialize(Context * context)
{
  this->context = context;
}
 
namespace
{
  const float offset = 0.01f;
 
  glm::vec4 cameraSpacePlane(const glm::mat4 & viewMatrix, glm::vec3 position, glm::vec3 normal, float s)
  {
    const glm::vec3 offsetPos = position + normal * offset;
 
    const glm::vec3 cPos = glm::vec3(viewMatrix * glm::vec4(offsetPos, 1.0f));
    const glm::vec3 cNormal = glm::normalize(glm::vec3(viewMatrix * glm::vec4(normal, 0.0))) * s;
 
    return glm::vec4(cNormal, -glm::dot(cPos, cNormal));
  }
 
  glm::mat4 calculateOblique(const glm::mat4 & projectionMatrix, glm::vec4 clipPlane)
  {
    // Calculate the clip-space corner point opposite the clipping plane
    // as (sign(clipPlane.x), sign(clipPlane.y), 1, 1) and
    // transform it into camera space by multiplying it
    // by the inverse of the projection matrix
    glm::vec4 q = glm::inverse(projectionMatrix) * glm::vec4(
      glm::sign(clipPlane.x),
      glm::sign(clipPlane.y),
      1.0f,
      1.0f);
 
    glm::vec4 c = clipPlane * (2.0f / (glm::dot(clipPlane, q)));
 
    glm::mat4 output = projectionMatrix;
 
    output[0][2] = c.x - projectionMatrix[0][3];
    output[1][2] = c.y - projectionMatrix[1][3];
    output[2][2] = c.z - projectionMatrix[2][3];
    output[3][2] = c.w - projectionMatrix[3][3];
 
    return output;
  }
 
  glm::mat4 calculateReflectionPlane(glm::vec4 plane)
  {
    glm::mat4 r(1.0f);
 
    r[0][0] = 1 - 2 * plane.x * plane.x;
    r[0][1] = -2 * plane.x * plane.y;
    r[0][2] = -2 * plane.x * plane.z;
    r[0][3] = 0.0f;
 
    r[1][0] = -2 * plane.x * plane.y;
    r[1][1] = 1 - 2 * plane.y * plane.y;
    r[1][2] = -2 * plane.z * plane.y;
    r[1][3] = 0.0f;
 
    r[2][0] = -2 * plane.x * plane.z;
    r[2][1] = -2 * plane.y * plane.z;
    r[2][2] = 1 - 2 * plane.z * plane.z;
    r[2][3] = 0.0f;
 
    r[3][0] = -2 * plane.w * plane.x;
    r[3][1] = -2 * plane.w * plane.y;
    r[3][2] = -2 * plane.w * plane.z;
    r[3][3] = 1.0f;
 
    return r;
  }
}
 
void Cogs::Core::ReflectionComponent::postUpdate()
{
  if (!context || !texture) return;
 
  const CameraComponent* parentCamera = nullptr;
  auto parent = getComponent<SceneComponent>()->parent;
  if (auto * parentContainer = parent.resolve(); parentContainer) {
    parentCamera = parentContainer->getComponent<CameraComponent>();
  }
  if (!parentCamera) {
    parentCamera = context->cameraSystem->getMainCamera();
  }
  const auto & parentCameraData = context->cameraSystem->getData(parentCamera);
 
 
 
  auto cameraComponent = getComponent<CameraComponent>();
  cameraComponent->enableClippingPlaneAdjustment = false;
  cameraComponent->renderTexture = texture;
 
  auto & cameraData = context->cameraSystem->getData(cameraComponent);
  cameraData.passOptions = &passOptions;
 
  cameraData.layerMask = cameraData.layerMask & ~(RenderLayers::Ocean | RenderLayers::Annotations | RenderLayers::Overlay);
 
  const float d = -glm::dot(normal, position) - offset;
  const glm::vec4 reflectionPlane(normal, d);
 
  bool below = glm::dot(reflectionPlane, cameraData.inverseViewMatrix[3]) < 0.f;
 
  const auto reflectionMatrix = below ? glm::mat4() : calculateReflectionPlane(reflectionPlane);
 
  cameraData.viewportSize = cameraComponent->viewportSize;
  cameraData.viewportOrigin = cameraComponent->viewportOrigin;
  cameraData.viewMatrix = cameraData.viewMatrix * reflectionMatrix;
  cameraData.inverseViewMatrix = glm::inverse(cameraData.viewMatrix);
  cameraData.reflection = true;
  cameraData.flipWindingOrder = !below;
 
  const glm::vec4 clipPlane = cameraSpacePlane(cameraData.viewMatrix, glm::vec3(0.0f), normal, 1.0f);
 
  cameraData.rawProjectionMatrix = calculateOblique(parentCameraData.rawProjectionMatrix, clipPlane);
  cameraData.projectionMatrix = context->renderer->getProjectionMatrix(cameraData.rawProjectionMatrix);
  cameraData.viewProjection = cameraData.projectionMatrix * cameraData.viewMatrix;
  cameraData.inverseViewProjectionMatrix = glm::inverse(cameraData.viewProjection);
  cameraData.frustum = Geometry::calculateFrustum<Geometry::Frustum, glm::mat4>(cameraData.viewProjection);
  cameraData.renderPass = RenderPass::Reflection;
 
  cameraData.discardThreshold = parentCameraData.discardThreshold;
  cameraData.keepThreshold = parentCameraData.keepThreshold;
}