TerrainSystem.cpp

#include "TerrainSystem.h"
 
#include "Terrain.h"
 
#include "Context.h"
 
#include "Components/Core/RenderComponent.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Resources/ResourceStore.h"
#include "Resources/MaterialManager.h"
 
#include "TerrainRenderer.h"
#include "OceanSystem.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
 
using namespace Cogs::Geometry;
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("TerrainSystem");
}
 
void Cogs::Core::TerrainSystem::initialize(Context * context)
{
  ComponentSystemBase::initialize(context);
 
  VertexElement format{ 0, DataFormat::X32Y32_FLOAT, ElementSemantic::Position, 0, {}, {} };
  terrainFormat = VertexFormats::createVertexFormat(format);
 
  if (!terrainRenderer) {
    terrainRenderer = new TerrainRenderer();
    context->renderer->registerExtension(terrainRenderer);
  }
 
  const auto dependencyDir = IO::expandEnvironmentVariable("CogsDir");
  context->resourceStore->addSearchPath(dependencyDir + "/");
 
  context->resourceStore->addSearchPath("../Extensions/Terrain/Data");
 
  // Register empty custom snippets to avoid getting errors when resolving contents.
  context->resourceStore->addResource("Shaders/Terrain/CustomComputeColor.hlsl", "");
  context->resourceStore->addResource("Shaders/Terrain/CustomProcessColor.hlsl", "");
}
 
void Cogs::Core::TerrainSystem::cleanup(Context* context)
{
  assert(terrainRenderer);
  if (context->renderer) {
    context->renderer->unregisterExtension(terrainRenderer);
  }
  delete terrainRenderer;
  terrainRenderer = nullptr;
  ComponentSystemWithDataPool::cleanup(context);
}
 
 
void Cogs::Core::TerrainSystem::update(Context * context)
{
  for (TerrainComponent& terrain : pool) {
    auto & terrainData = getData(&terrain);
 
    if (!terrainData.initialized) {
      if (context->device->getType() == GraphicsDeviceType::OpenGL20 || context->device->getType() == GraphicsDeviceType::Direct3D11 || context->device->getType() == GraphicsDeviceType::Direct3D12) {
        terrainInitializeInstance(terrainData.context, context->device);
 
        terrainData.getBounds = std::make_unique<TerrainBounds>(&terrain, &terrainData);
        context->bounds->addBoundsExtension(terrainData.getBounds.get());
 
        terrainData.initialized = true;
      }
 
      terrainData.terrainStreamsLayout.numStreams = 1;
      terrainData.terrainStreamsLayout.vertexFormats[0] = terrainFormat;
      terrainData.terrainStreamsLayout.updateHash();
    }
 
    if (terrainData.initialized) {
      bool materialChanged = terrainData.depthMaterial != terrain.depthMaterial || terrainData.material != terrain.material;
 
      auto customTextureKey = terrain.material->material->getTextureKey("customTexture");
      terrain.material->setTextureProperty(customTextureKey, terrain.customTexture);
      terrain.material->setTextureAddressMode(customTextureKey, terrain.addressMode);
 
      terrainData.offset = terrain.getComponent<TransformComponent>()->coordinates;
 
      terrainUpdate(terrainData.context);
 
      Cogs::EffectParameters p;
      terrainGetEffectParameters(terrainData.context, &p);
 
      if (p.changed || materialChanged) {
        terrainData.depthMaterial = terrain.depthMaterial;
        terrainData.material = terrain.material;
 
        terrain.material->setVariant("NumTextures", p.numTextures);
        terrainData.depthMaterial->setVariant("NumTextures", p.numTextures);
        terrain.material->setVariant("NumActiveTextures", p.numActiveImagery);
        terrainData.depthMaterial->setVariant("NumActiveTextures", p.numActiveImagery);
 
        if (terrainData.customComputeColor.size()) {
          terrain.material->setVariant("CustomComputeColor", terrainData.customComputeColor);
          terrainData.depthMaterial->setVariant("CustomComputeColor", terrainData.customComputeColor);
        }
 
        if (p.precomputeNormals) {
          terrain.material->setVariant("PrecomputeNormals", p.precomputeNormals);
          terrainData.depthMaterial->setVariant("PrecomputeNormals", p.precomputeNormals);
        }
      }
 
      float nearPlaneLimit = terrainGetNearestSample(terrainData.context);
 
      terrainData.nearPlaneLimit = nearPlaneLimit;
    }
  }
}
 
Cogs::ComponentModel::ComponentHandle Cogs::Core::TerrainSystem::createComponent()
{
  auto component = ComponentSystemWithDataPool::createComponent();
  TerrainComponent* terrainPtr = component.resolveComponent<TerrainComponent>();
  auto & terrainData = getData(terrainPtr);
  terrainData.context = terrainCreate();
 
  MaterialHandle terrainMaterial = context->materialManager->loadMaterial("TerrainMaterial.material", MaterialLoadFlags::DelayVariantLoading);
  context->materialManager->processLoading();
 
  TerrainComponent& terrainComponent = *terrainPtr;
  terrainComponent.material = context->materialInstanceManager->createMaterialInstance(terrainMaterial);
  terrainComponent.material->setPermutation("Normal");
  terrainComponent.depthMaterial = context->materialInstanceManager->createMaterialInstance(terrainMaterial);
  terrainComponent.depthMaterial->setPermutation("Depth");
 
  if (pool.size() == 1) {
    assert(picker == nullptr);
    picker = new TerrainPicker(this);
    context->rayPicking->addPickable(picker);
 
    LOG_DEBUG(logger, "Registered terrain picker extension");
  }
 
  return component;
}
 
void Cogs::Core::TerrainSystem::destroyComponent(ComponentHandle component)
{
  auto & terrainData = getData(component.resolveComponent<TerrainComponent>());
 
  if (terrainData.initialized) {
    terrainDestroy(terrainData.context);
 
    context->bounds->removeBoundsExtension(terrainData.getBounds.get());
  }
 
  ComponentSystemWithDataPool::destroyComponent(component);
 
  if (pool.size() == 0) {
    assert(picker != nullptr);
    context->rayPicking->removePickable(picker);
    delete picker;
    picker = nullptr;
 
    LOG_DEBUG(logger, "Last component destroyed, unregistered terrain picker extension");
  }
}
 
bool Cogs::Core::TerrainPicker::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)
{
  // Convert the normalized screen coordinates into [0..1] range which is needed by the terrain engine.
  glm::vec2 screenPos = normPosition * .5f + .5f;
 
  auto & cameraData = context->cameraSystem->getData(&camera);
  for (const TerrainComponent& terrain : terrainSystem->pool) {
 
    auto& terrainData = terrainSystem->getData(&terrain);
 
    if (!terrainData.initialized) {
      return false;
    }
 
    const RenderComponent* renderComponent = terrain.getComponent<RenderComponent>();
    if (renderComponent && !renderComponent->isVisibleInLayer(filter.layerMask) && !filter.isUnwantedType(*renderComponent)) {
      return false;
    }
 
    glm::vec4 pickedCoordinates;
    if (cameraData.rayPickId == -1 && &camera != context->cameraSystem->getMainCamera())
    {
      //Either the camera doesn't support picking or the depth texture hasn't been rendered yet.
      return false;
    }
 
    if (terrainRayPick(terrainData.context, glm::value_ptr(screenPos), glm::value_ptr(cameraData.inverseViewProjectionMatrix), glm::value_ptr(pickedCoordinates), cameraData.rayPickId)) {
      glm::vec3 coordinates = glm::vec3(pickedCoordinates);
      glm::vec4 clipPos = cameraData.rawViewProjection * glm::vec4(coordinates, 1.f);
      if ((-clipPos.w <= clipPos.z) && (clipPos.z <= clipPos.w)) {
 
        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] = { terrain, (pickingFlags & PickingFlags::ReturnChildEntity) == PickingFlags::ReturnChildEntity, coordinates, viewDist };
            return true;
          }
          // Else the intersection we found is further, so don't report a hit
          return false;
        }
 
        // Returning just the first intersected object should be enough for terrain.
        hits.emplace_back(terrain, (pickingFlags & PickingFlags::ReturnChildEntity) == PickingFlags::ReturnChildEntity, coordinates, viewDist);
        return true;
      }
    }
  }
  return false;
}
 
inline void Cogs::Core::TerrainBounds::getBounds(Context * context, Cogs::Geometry::BoundingBox & bounds, float& nearPlaneLimit)
{
  auto renderComponent = terrain->getComponent<RenderComponent>();
 
  if (!renderComponent->isVisible()) {
    if (terrainData->oceanData) {
      auto renderComponent_ = terrainData->oceanData->oceanComponent->getComponent<RenderComponent>();
 
      if (!renderComponent_->isVisible()) return;
    } else {
      return;
    }
  }
 
  if (terrainData->initialized) {
    auto offsetFromOrigin = terrain->getComponent<TransformComponent>()->coordinates - context->transformSystem->getOrigin();
 
    glm::dvec3 globalBounds[2];
    terrainGetBounds(terrainData->context, (double *)globalBounds);
 
    Cogs::BoundingBox terrainBounds = {
      glm::vec3(globalBounds[0] + offsetFromOrigin),
      glm::vec3(globalBounds[1] + offsetFromOrigin),
    };
 
    if (!isEmpty(terrainBounds)) {
      //nearPlaneLimit = terrain->getComponent<NearLimitComponent>()->nearPlaneLimit;
      nearPlaneLimit = terrainData->nearPlaneLimit * 0.85f;
      bounds += terrainBounds;
    }
  }
}