BasicTerrainComponent.cpp

#include "BasicTerrainComponent.h"
 
#include "Types.h"
#include "Context.h"
 
#include "Resources/MaterialManager.h"
#include "Resources/TextureManager.h"
#include "Resources/Texture.h"
 
#include "Systems/Geometry/AdaptivePlanarGridSystem.h"
 
#include "Foundation/ComponentModel/Attributes.h"
 
#include <cassert>
 
namespace {
  using namespace Cogs::Core;
 
  void initMaterialInstanceCallback(MaterialInstance* instance, Cogs::ComponentModel::Entity* /*container*/, void* data)
  {
    auto* terrainComp = static_cast<const BasicTerrainComponent*>(data);
    instance->setVariant("HasNoData", terrainComp->noDataEnabled);
    switch (terrainComp->elevationChannel) {
    case BasicTerrainElevationChannel::Red:
      instance->setVariant("ElevationChannel", "Red");
      break;
    case BasicTerrainElevationChannel::Alpha:
      instance->setVariant("ElevationChannel", "Alpha");
      break;
    case BasicTerrainElevationChannel::RedGreenBlue:
      instance->setVariant("ElevationChannel", "RedGreenBlue");
      break;
    default:
      assert(false && "Unhandled case.");
    }
    if (terrainComp->colorMap) {
      switch (terrainComp->transparencyMode) {
      case BasicTerrainTransparencyMode::None:
        instance->setOpaque();
        instance->setVariant("Color", "TextureRGB");
        instance->options.blendMode = BlendMode::None;
        break;
      case BasicTerrainTransparencyMode::Regular:
        instance->options.blendMode = BlendMode::None;
        instance->setTransparent();
        instance->setVariant("Color", "TextureRGBA");
        break;
      case BasicTerrainTransparencyMode::BlendWithZWrite:
        instance->setOpaque();
        instance->setVariant("Color", "TextureRGBA");
        instance->options.blendMode = BlendMode::Blend;
        break;
      default:
        assert(false && "Unhandled case.");
      }
    }
    else {
      instance->setVariant("Color", "Solid");
    }
    instance->setVariant("ElevationToAlpha", terrainComp->elevationToAlpha);
 
    instance->setVec4Property(terrainComp->elevationTransformKey, terrainComp->elevationTransform);
    instance->setVec2Property(terrainComp->normalTransformKey, terrainComp->normalTransform);
    instance->setVec3Property(terrainComp->elevationToAlphaTransformKey, terrainComp->elevationToAlphaTransform);
    instance->setTextureProperty(terrainComp->elevationTexKey, terrainComp->elevationMap);
    instance->setTextureAddressMode(terrainComp->elevationTexKey, Cogs::SamplerState::AddressMode::Clamp);
    instance->setTextureProperty(terrainComp->colorTexKey, terrainComp->colorMap);
    instance->setTextureAddressMode(terrainComp->colorTexKey, Cogs::SamplerState::AddressMode::Clamp);
    instance->setVec4Property(terrainComp->diffuseColorKey, terrainComp->diffuseColor);
    instance->setFloatProperty(terrainComp->noDataValueKey, terrainComp->noDataValue);
    instance->setFloatProperty(terrainComp->vibranceKey, glm::clamp(2.f-terrainComp->vibrance, 0.001f, 2.f));
  }
 
}
 
using namespace Cogs::Reflection;
 
void Cogs::Core::BasicTerrainComponent::registerType()
{
  {
    static constexpr EnumeratorDef enumerators[] = {
        { "Red", BasicTerrainElevationChannel::Red },
        { "Alpha", BasicTerrainElevationChannel::Alpha },
        { "RedGreenBlue", BasicTerrainElevationChannel::RedGreenBlue },
    };
    TypeDatabase::createType<BasicTerrainElevationChannel>().setEnumerators(enumerators);
  }
  {
    static constexpr EnumeratorDef enumerators[] = {
        { "None", BasicTerrainTransparencyMode::None },
        { "Regular", BasicTerrainTransparencyMode::Regular },
        { "BlendWithZWrite", BasicTerrainTransparencyMode::BlendWithZWrite },
    };
    TypeDatabase::createType<BasicTerrainTransparencyMode>().setEnumerators(enumerators);
  }
 
  Field fields[] = {
    Field(Name("elevationChannel"), &BasicTerrainComponent::elevationChannel),
    Field(Name("elevationMap"), &BasicTerrainComponent::elevationMap),
    Field(Name("transparencyMode"), &BasicTerrainComponent::transparencyMode),
    Field(Name("colorMap"), &BasicTerrainComponent::colorMap),
    Field(Name("vibrance"), &BasicTerrainComponent::vibrance)
      .add(RangeAttribute(0.0f, 2.f)),
    Field(Name("diffuseColor"), &BasicTerrainComponent::diffuseColor)
      .add(ColorAttribute()),
    Field(Name("noDataEnabled"), &BasicTerrainComponent::noDataEnabled),
    Field(Name("noDataValue"), &BasicTerrainComponent::noDataValue),
    Field(Name("elevationScale"), &BasicTerrainComponent::elevationScale),
    Field(Name("elevationBias"), &BasicTerrainComponent::elevationBias),
    Field(Name("elevationMin"), &BasicTerrainComponent::elevationMin),
    Field(Name("elevationMax"), &BasicTerrainComponent::elevationMax),
    Field(Name("elevationMapNormalized"), &BasicTerrainComponent::elevationMapNormalized),
    Field(Name("elevationToAlpha"), &BasicTerrainComponent::elevationToAlpha),
    Field(Name("elevationToAlphaMin"), &BasicTerrainComponent::elevationToAlphaMin),
    Field(Name("elevationToAlphaMax"), &BasicTerrainComponent::elevationToAlphaMax),
    Field(Name("elevationToAlphaPower"), &BasicTerrainComponent::elevationToAlphaPower)
      .add(RangeAttribute(0.0f, 2.f)),
    Field(Name("cullMode"), &BasicTerrainComponent::cullMode)
  };
 
  Method methods[] = {
    Method(Name("initialize"), &BasicTerrainComponent::initialize),
    Method(Name("update"), &BasicTerrainComponent::update),
  };
 
  DynamicComponent::registerDerivedType<BasicTerrainComponent>()
    .setFields(fields)
    .setMethods(methods);
}
 
void Cogs::Core::BasicTerrainComponent::initialize(Context * context)
{
  this->context = context;
 
  material = context->materialManager->loadMaterial("BasicTerrainMaterial.material");
 
  context->materialManager->processLoading();
 
  elevationTexKey = material->getTextureKey("Elevation");
  colorTexKey = material->getTextureKey("Color");
  diffuseColorKey = material->getVec4Key("diffuseColor");
  elevationTransformKey = material->getVec2Key("elevationTransform");
  normalTransformKey = material->getVec2Key("normalTransform");
  noDataValueKey = material->getFloatKey("noDataValue");
  vibranceKey = material->getFloatKey("vibrance");
  elevationToAlphaTransformKey = material->getFloatKey("elevationToAlphaTransform");
 
  auto gridComp = getComponent<AdaptivePlanarGridComponent>();
 
  context->adaptivePlanarGridSystem->registerMaterial(gridComp, material, nullptr, nullptr);
 
  gridComp->setChanged();
}
 
void Cogs::Core::BasicTerrainComponent::update()
{
  auto * gridComp = getComponent<AdaptivePlanarGridComponent>();
  if (!gridComp) return;
 
  if (hasChanged() || gridComp->hasChanged()) {
    forceUpdate = true;
  }
 
  if (elevationMap) {
    if (auto flags = elevationMap->getFlags(); elevationFlags != flags) {
      elevationFlags = flags;
      forceUpdate = true;
    }
  }
 
  if (forceUpdate && elevationMap) {
    forceUpdate = false;
 
    material->options.cullMode = cullMode;
 
    glm::vec2 extent = glm::vec2(gridComp->extentMax - gridComp->extentMin);
    if (elevationMapNormalized) {
      float scale_z = elevationMax - elevationMin;
      elevationTransform = glm::vec4(scale_z,
                                     elevationMin,
                                     1.f / elevationMap->description.width,
                                     1.f / elevationMap->description.height);
      normalTransform = glm::vec2(2.f * extent.x / (elevationMap->description.width * scale_z),
                                  2.f * extent.y / (elevationMap->description.height * scale_z));
      elevationToAlphaTransform = glm::vec3((elevationToAlphaMin - elevationMin) / scale_z,
                                            scale_z / (elevationToAlphaMax - elevationToAlphaMin),
                                            elevationToAlphaPower);
    }
    else {
      elevationTransform = glm::vec4(elevationScale,
                                     elevationBias,
                                     1.f / elevationMap->description.width,
                                     1.f / elevationMap->description.height);
      normalTransform = glm::vec2(2.f * extent.x / (elevationMap->description.width * elevationScale),
                                  2.f * extent.y / (elevationMap->description.height * elevationScale));
      elevationToAlphaTransform = glm::vec3((elevationToAlphaMin - elevationBias) / elevationScale,
                                            elevationScale / (elevationToAlphaMax - elevationToAlphaMin),
                                            elevationToAlphaPower);
    }
    gridComp->displaceMin = glm::vec3(0.f, 0.f, elevationMin);
    gridComp->displaceMax = glm::vec3(0.f, 0.f, elevationMax);
    context->adaptivePlanarGridSystem->registerMaterial(gridComp, material, initMaterialInstanceCallback, this);
    gridComp->setChanged();
  }
}