ProceduralSkyComponent.cpp

#include <cmath>
#include <sstream>
#include "ProceduralSkyComponent.h"
#include "Types.h"
#include "Context.h"
#include "EntityStore.h"
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Systems/Core/MeshSystem.h"
 
using namespace Cogs::Geometry;
using namespace Cogs::Reflection;
 
static const float EARTH_RADIUS = 10000;// 6370997.0f;
static const float EARTH_ATMOSPHERE_RADIUS = EARTH_RADIUS * 1.025f;
 
struct AtmosphericScatteringParams
{
  float fRayleighScatteringConstant = 0.0025f;                // Rayleigh scattering constant
  float fMieScatteringConstant = 0.0015f;                     // Mie scattering constant
  float fSunBrightness = 15.0f;                               // Sun brightness
  float fRayleighScaleDepth = 0.25f;                          // Raylight scale depth
  float fMiePhaseAsymmetryFactor = -0.98f;                    // The Mie phase asymmetry factor
  glm::vec3 vWaveLength = glm::vec3(0.680f, 0.550f, 0.475f);  // Wave length for red, green and blue
};
 
float toRadian(float _x)
{
  return _x * 0.017453292519f;
}
 
float lerp(float _x1, float _x2, float _w)
{
  return (_x1 + _w * (_x2 - _x1));
}
 
float truncate(float a_Value, float a_Min, float a_Max)
{
  if (a_Value < a_Min) return a_Min;
  if (a_Value > a_Max) return a_Max;
 
  return a_Value;
}
 
void createSkyDomeMesh(std::vector<Cogs::Core::PositionNormalVertex>& vertices, std::vector<unsigned int>& indices, int a_nStacks, int a_nSlices, float a_fRadius, float a_fDistribution)
{
    // Create vertex buffer
    for (auto nStackNumber = 0; nStackNumber <= a_nStacks; nStackNumber++)
    {
        for (auto nSliceNumber = 0; nSliceNumber < a_nSlices; nSliceNumber++)
        {
            auto fTheta = powf((float)nStackNumber / (float)a_nStacks, a_fDistribution) * glm::pi<float>();
            auto fPhi = (float)nSliceNumber / (float)a_nSlices * glm::pi<float>() * 2.0f;
            auto fSinTheta = sinf(fTheta);
            auto fSinPhi = sinf(fPhi);
            auto fCosTheta = cosf(fTheta);
            auto fCosPhi = cosf(fPhi);
            auto pos = glm::vec3(fSinPhi * fSinTheta * a_fRadius, fCosPhi * fSinTheta * a_fRadius, fCosTheta * a_fRadius);
            auto n = glm::normalize(-pos);
            vertices.push_back({ pos, n });
        }
    }
 
    // Create index buffer
    for (auto nStackNumber = 0; nStackNumber < a_nStacks; nStackNumber++)
    {
        for (auto nSliceNumber = 0; nSliceNumber <= a_nSlices; nSliceNumber++)
        {
            auto nIndexA = (nStackNumber * a_nSlices) + (nSliceNumber % a_nSlices);
            auto nIndexB = ((nStackNumber + 1) * a_nSlices) + (nSliceNumber % a_nSlices);
            indices.push_back(nIndexA);
            indices.push_back(nIndexB);
        }
    }
}
 
void Cogs::Core::ProceduralSkyComponent::registerType()
{
    Field fields[] = {
        Field(Name("sunDirection"), &ProceduralSkyComponent::sunDirection)
    };
 
    Method methods[] = {
        Method(Name("initialize"), &ProceduralSkyComponent::initialize),
        Method(Name("update"), &ProceduralSkyComponent::update),
    };
 
    DynamicComponent::registerDerivedType<ProceduralSkyComponent>()
        .setFields(fields)
        .setMethods(methods);
}
 
void Cogs::Core::ProceduralSkyComponent::initialize(Context * ctx)
{
    context = ctx;
 
    auto meshEntity = context->store->createChildEntity("MeshPart", getContainer(), "Skydome");
 
    auto meshComp = meshEntity->getComponent<MeshComponent>();
    if (meshComp->meshHandle == MeshHandle::NoHandle)
    {
        meshComp->meshHandle = context->meshManager->create();
    }
 
    // Material.
    auto materialHandle = context->materialManager->loadMaterial("ProceduralSkyMaterial.material");
    context->materialManager->processLoading();
 
    material = materialHandle.resolve();
    auto materialInstance = context->materialInstanceManager->createMaterialInstance(MaterialHandle(material));
 
    auto meshRenderComp = meshEntity->getComponent<MeshRenderComponent>();
    meshRenderComp->material = materialInstance;
    meshRenderComp->setChanged();
 
    krKmMaterialPropertyKey = material->getVec4Key("g_vKrKm");
    scaleMaterialPropertyKey = material->getVec3Key("g_vScale");
    invWavelengthMaterialPropertyKey = material->getVec3Key("g_vInvWavelength");
    miePhaseAsymmetryFactorMaterialPropertyKey = material->getVec2Key("g_fMiePhaseAsymmetryFactor");
    cameraPos_HeightMaterialPropertyKey = material->getVec4Key("g_vCameraPos_Height");
    sunDirectionMaterialPropertyKey = material->getVec3Key("g_vSunDirection");
 
    // Geometry.
    auto mesh = context->meshManager->get(meshEntity->getComponent<MeshComponent>()->meshHandle);
    mesh->primitiveType = Cogs::PrimitiveType::TriangleStrip;
 
    std::vector<PositionNormalVertex> vertices;
    std::vector<unsigned int> indices;
    createSkyDomeMesh(vertices, indices, 50, 25, EARTH_ATMOSPHERE_RADIUS, 20.0f);
 
    mesh->setVertexData(vertices.data(), vertices.size());
    mesh->setIndexes(std::move(indices));
}
 
void Cogs::Core::ProceduralSkyComponent::update()
{
  glm::vec4 vKrKm;
  glm::vec3 vScale;
  glm::vec3 vInvWavelength;
  auto fMiePhaseAsymmetryFactor = getAtmosphericScatteringData(vKrKm, vScale, vInvWavelength);
 
  material->setVec4Property(krKmMaterialPropertyKey, vKrKm);
  material->setVec3Property(scaleMaterialPropertyKey, vScale);
  material->setVec3Property(invWavelengthMaterialPropertyKey, vInvWavelength);
  material->setVec2Property(miePhaseAsymmetryFactorMaterialPropertyKey, glm::vec2(fMiePhaseAsymmetryFactor, fMiePhaseAsymmetryFactor * fMiePhaseAsymmetryFactor));
  material->setVec4Property(cameraPos_HeightMaterialPropertyKey, glm::vec4(0.0f, EARTH_RADIUS, 0.0f, EARTH_RADIUS)); // Locate camera on then north pole
  material->setVec3Property(sunDirectionMaterialPropertyKey, sunDirection);
}
 
float Cogs::Core::ProceduralSkyComponent::getSunBrightness()
{
  static const float s_fAngle95 = toRadian(95.0f);
  static const float s_fInvAngle20 = 1.0f / toRadian(20.0f);
  const glm::vec3&   vSunDirection = sunDirection;
  float              fAngle = truncate((s_fAngle95 - acosf(vSunDirection.y)) * s_fInvAngle20, 0.0f, 1.0f); // -5..15
 
  return powf(fAngle, 1.0f / 1.5f);
}
 
float Cogs::Core::ProceduralSkyComponent::getAtmosphericScatteringData(glm::vec4& vKrKm, glm::vec3& vScale, glm::vec3& vInvWavelength)
{
  AtmosphericScatteringParams cAtmosphericScattering;
 
  const float fKr = lerp(0.0075f, cAtmosphericScattering.fRayleighScatteringConstant, getSunBrightness());
  const float fKr4PI = fKr * 4.0f * glm::pi<float>();
  const float fKm = cAtmosphericScattering.fMieScatteringConstant;
  const float fKm4PI = fKm * 4.0f * glm::pi<float>();
  const float fKrESun = fKr * cAtmosphericScattering.fSunBrightness;
  const float fKmESun = fKm * cAtmosphericScattering.fSunBrightness;
  vKrKm = glm::vec4(fKrESun, fKmESun, fKr4PI, fKm4PI);
 
  const float fScale = 1.0f / (EARTH_ATMOSPHERE_RADIUS - EARTH_RADIUS);
  const float fScaleDepth = cAtmosphericScattering.fRayleighScaleDepth;
  const float fScaleOverScaleDepth = fScale / cAtmosphericScattering.fRayleighScaleDepth;
  vScale = glm::vec3(fScale, fScaleDepth, fScaleOverScaleDepth);
 
  vInvWavelength.x = 1.0f / powf(cAtmosphericScattering.vWaveLength.x, 4.0f);
  vInvWavelength.y = 1.0f / powf(cAtmosphericScattering.vWaveLength.y, 4.0f);
  vInvWavelength.z = 1.0f / powf(cAtmosphericScattering.vWaveLength.z, 4.0f);
 
  return cAtmosphericScattering.fMiePhaseAsymmetryFactor;
}