OceanSystem.cpp

#include "OceanSystem.h"
 
#include "Terrain.h"
 
#include "Context.h"
#include "ViewContext.h"
#include "EntityStore.h"
 
#include "Services/Variables.h"
 
#include "Components/Core/RenderComponent.h"
#include "Components/Core/NearLimitComponent.h"
#include "Components/Behavior/ReflectionComponent.h"
#include "Components/Appearance/MaterialComponent.h"
 
#include "Systems/Core/CameraSystem.h"
 
#include "Resources/ResourceStore.h"
#include "Resources/MaterialManager.h"
#include "Resources/TextureManager.h"
 
#include "TerrainSystem.h"
 
#include "Foundation/ComponentModel/Entity.h"
 
using namespace Cogs::Geometry;
 
Cogs::Core::OceanPicker::OceanPicker(OceanComponent * oceanComponent, OceanData * oceanData)
  : oceanComponent(oceanComponent), oceanData(oceanData)
{
}
 
bool Cogs::Core::OceanPicker::pickCamera(Context* context,
                                         const CameraComponent& camera,
                                         const glm::vec2& normPosition,
                                         float /*rayLength*/,
                                         float /*radius*/,
                                         PickingFlags pickingFlags,
                                         PicksReturned returnFlag,
                                         const RayPicking::RayPickFilter& filter,
                                         std::vector<RayPicking::RayPickHit>& hits)
{
  const CameraData& cameraData = context->cameraSystem->getData(&camera);
 
  const RenderComponent* renderComponent = oceanComponent->getComponent<RenderComponent>();
  assert(renderComponent);
  if (!renderComponent->isPickable() || filter.isUnwantedType(*renderComponent) || !renderComponent->isVisibleInLayer(filter.layerMask)) {
    return false;
  }
 
  float dummy = 0.f;
  Geometry::BoundingBox terrainBounds = Geometry::makeEmptyBoundingBox<BoundingBox>();
  oceanData->terrainData->getBounds->getBounds(context, terrainBounds, dummy);
 
  if (isEmpty(terrainBounds)) {
    return false;
  }
 
  glm::mat4 M = cameraData.inverseViewMatrix*glm::inverse(cameraData.rawProjectionMatrix);
 
  glm::vec4 aH = M * glm::vec4(normPosition, -1, 1.f);
  glm::vec4 bH = M * glm::vec4(normPosition, 1, 1.f);
  glm::vec3 a = (1.f / aH.w)*glm::vec3(aH);
  glm::vec3 b = (1.f / bH.w)*glm::vec3(bH);
  glm::vec3 d = b - a;
 
  glm::vec4 eq = glm::vec4(0, 0, 1, 0);  // plane equation of ocean
 
  float den = glm::dot(d, glm::vec3(eq));
  if (glm::abs(den) < std::numeric_limits<float>::min()) {
    return false;
  }
  float t = -glm::dot(glm::vec4(a, 1.f), eq) / den;
  if ((t < 0.f) || (1.f < t)) {
    return false;
  }
 
  glm::vec3 coordinates = glm::mix(a, b, t);
 
  if ((coordinates.x < terrainBounds.min.x) ||
      (coordinates.y < terrainBounds.min.y) ||
      (terrainBounds.max.x < coordinates.x) ||
      (terrainBounds.max.y < coordinates.y))
  {
    return false;
  }
 
  glm::vec4 clipPos = cameraData.rawViewProjection * glm::vec4(coordinates, 1.f);
  if ((-clipPos.w > clipPos.z) || (clipPos.z > clipPos.w)) {
    return false;
  }
 
  glm::vec4 viewPos = cameraData.viewMatrix * glm::vec4(glm::vec3(coordinates), 1.f);
  float viewDist = -viewPos.z;
 
  if (returnFlag == PicksReturned::Closest && !hits.empty()) {
    if (viewDist < hits[0].distance) {
      hits[0] = {*oceanComponent, (pickingFlags & PickingFlags::ReturnChildEntity) == PickingFlags::ReturnChildEntity, coordinates, viewDist};
      return true;
    }
    // Else the intersection we found is further, so don't report a hit
    return false;
  }
 
  hits.emplace_back(*oceanComponent, (pickingFlags & PickingFlags::ReturnChildEntity) == PickingFlags::ReturnChildEntity, coordinates, viewDist);
  return true;
}
 
 
void Cogs::Core::OceanSystem::initialize(Context * context)
{
  ComponentSystemBase::initialize(context);
  Cogs::VertexElement format{ 0, DataFormat::X32Y32_FLOAT, ElementSemantic::Position, 0, {}, {} };
  oceanFormat = Cogs::VertexFormats::createVertexFormat(format);
}
 
void Cogs::Core::OceanSystem::update(Context * context)
{
  for (auto & ocean : pool) {
    auto & oceanData = getData(&ocean);
 
    if (!oceanData.initialized && ocean.terrain) {
      oceanData.oceanMaterial = context->materialManager->loadMaterial("OceanMaterial.material", MaterialLoadFlags::DelayVariantLoading);
 
      auto terrainComponent = ocean.terrain->getComponent<TerrainComponent>();
 
      auto renderComponent = ocean.terrain->getComponent<RenderComponent>();
      renderComponent->unsetRenderFlag(RenderFlags::CastShadows);
 
      context->materialManager->processLoading();
 
      oceanData.streamsLayout.numStreams = 1;
      oceanData.streamsLayout.vertexFormats[0] = oceanFormat;
      oceanData.streamsLayout.updateHash();
      oceanData.material = context->materialInstanceManager->createMaterialInstance(oceanData.oceanMaterial);
 
      oceanData.terrainData = &terrainSystem->getData(terrainComponent);
      oceanData.terrainData->oceanData = &oceanData;
 
      oceanData.reflectionTexture = context->textureManager->create();
      oceanData.reflectionTexture->setName("Ocean.Reflection");
 
      auto planarKey = oceanData.oceanMaterial->getTextureKey("PlanarReflection");
      oceanData.oceanMaterial->setTextureProperty(planarKey, oceanData.reflectionTexture);
      oceanData.oceanMaterial->setTextureAddressMode(planarKey, SamplerState::Clamp);
      const auto textureResolution = static_cast<uint32_t>(context->variables->get("ocean.reflectionTextureResolution", 1024));
      auto reflectionTex = context->textureManager->get(oceanData.reflectionTexture);
 
      if (reflectionTex->description.width != textureResolution) {
        reflectionTex->description.width = textureResolution;
        reflectionTex->description.height = textureResolution;
        reflectionTex->description.format = TextureFormat::R8G8B8A8_UNORM;
        reflectionTex->description.flags = TextureFlags::RenderTarget;
        reflectionTex->setChanged();
      }
 
      context->textureManager->processLoading();
 
      auto camera = context->cameraSystem->getMainCamera();
      oceanData.reflectionCamera = context->store->createChildEntity("ReflectionCamera", camera->getContainer());
 
      auto reflectionComponent = oceanData.reflectionCamera->getComponent<ReflectionComponent>();
      reflectionComponent->texture = oceanData.reflectionTexture;
 
      auto cameraComponent = oceanData.reflectionCamera->getComponent<CameraComponent>();
      cameraComponent->viewportSize = glm::vec2(reflectionTex->description.width, reflectionTex->description.height);
 
      if (!oceanData.rayPick) {
        oceanData.rayPick = std::make_unique<OceanPicker>(&ocean, &oceanData);
        context->rayPicking->addPickable(oceanData.rayPick.get());
      }
 
      oceanData.bounds = std::make_unique<OceanBounds>(&ocean, &oceanData);
      context->bounds->addBoundsExtension(oceanData.bounds.get());
 
      oceanData.initialized = true;
    }
 
    if (!oceanData.initialized) continue;
 
    oceanData.oceanComponent = &ocean;
 
    if (oceanData.initialized && oceanData.terrainData->initialized) {
      auto terrainData = oceanData.terrainData;
 
      terrainData->renderContext.oceanEnabled = true;
 
      Cogs::EffectParameters p;
      terrainGetEffectParameters(terrainData->context, &p);
 
      if (p.changed || oceanData.first) {
        oceanData.material->setVariant("NumTextures", p.numTextures);
        oceanData.material->setVariant("NumActiveTextures", p.numActiveImagery);
 
        if (terrainData->customComputeColor.size()) {
          oceanData.material->setVariant("CustomComputeColor", terrainData->customComputeColor);
        }
 
        if (p.precomputeNormals) {
          oceanData.material->setVariant("PrecomputeNormals", p.precomputeNormals);
        }
 
        oceanData.first = false;
      }
    }
  }
}
 
void Cogs::Core::OceanSystem::destroyComponent(ComponentHandle component)
{
  auto & oceanData = getData(component.resolveComponent<OceanComponent>());
 
  if (oceanData.rayPick) context->rayPicking->removePickable(oceanData.rayPick.get());
  if (oceanData.bounds) context->bounds->removeBoundsExtension(oceanData.bounds.get());
 
  ComponentSystemWithDataPool::destroyComponent(component);
}
 
void Cogs::Core::OceanBounds::getBounds(Context* context, Cogs::Geometry::BoundingBox& bounds)
{
  if (!oceanData->initialized || !oceanData->terrainData || !oceanData->terrainData->initialized) return;
 
  float dummy = 0.f;
  Geometry::BoundingBox terrainBounds = Geometry::makeEmptyBoundingBox<BoundingBox>();
  oceanData->terrainData->getBounds->getBounds(context, terrainBounds, dummy);
 
  if (isEmpty(terrainBounds)) {
    return;
  }
 
  auto oceanBounds = terrainBounds;
  oceanBounds.min.z = -oceanComponent->significantWaveHeight;
  oceanBounds.max.z = oceanComponent->significantWaveHeight;
 
  bounds += oceanBounds;
}
 
void Cogs::Core::OceanBounds::getBounds(Context* context, Cogs::Geometry::BoundingBox& bounds, float& nearPlaneLimit)
{
  if (!oceanData->initialized || !oceanData->terrainData || !oceanData->terrainData->initialized) return;
 
  getBounds(context, bounds);
  nearPlaneLimit = oceanComponent->getComponent<NearLimitComponent>()->nearPlaneLimit;
}