BasicOceanSystem.h

#pragma once
#include <complex>
#include <vector>
 
#include "Systems/ComponentSystem.h"
 
#include "Platform/Instrumentation.h"
 
#include "Components/Appearance/BasicOceanComponent.h"
 
#include "Resources/Resources.h"
 
#include "Services/TaskManager.h"
 
namespace Cogs
{
  namespace Core
  {
    class Context;
 
    struct BasicOceanData
    {
      glm::vec4 color;
      float transparency = 0.0;
      float seaLevel = 0.0;
      float reflectionBrightness = 1.f;
 
      TextureHandle skyDomeTex = TextureHandle::NoHandle;
      bool transparent = false;
      bool initialized = false;
 
      const char * encoding = nullptr;
      const char * waveVariant = nullptr;
      const char * beliefSystem = nullptr;
      const char * reflectionVariant = nullptr;
      const char* lightModelVariant = nullptr;
 
      EntityPtr reflectionCamera;
      EntityPtr defaultReflectionCamera;
    };
 
    class ComplexArray
    {
    public:
      ComplexArray()
      {
        resize(0);
      }
 
      ComplexArray(size_t N)
      {
        resize(N);
      }
 
      void resize(size_t N)
      {
        this->N = N;
        storage.resize((2 * N * sizeof(float) + sizeof(Chunk) - 1) / sizeof(Chunk));
      }
 
      size_t size() const
      {
        return N;
      }
 
      float* real()
      {
        return reinterpret_cast<float*>(storage.data());
      }
 
      const float* real() const
      {
        return reinterpret_cast<const float*>(storage.data());
      }
 
      float* imag()
      {
        return reinterpret_cast<float*>(storage.data()) + N;
      }
 
      const float* imag() const
      {
        return reinterpret_cast<const float*>(storage.data()) + N;
      }
 
      std::complex<float> load(const size_t index) const
      {
        return std::complex<float>(reinterpret_cast<const float*>(storage.data())[index],
                                   reinterpret_cast<const float*>(storage.data())[N + index]);
      }
 
      void store(const size_t index, const std::complex<float> value)
      {
        reinterpret_cast<float*>(storage.data())[index] = std::real(value);
        reinterpret_cast<float*>(storage.data())[N + index] = std::imag(value);
      }
 
    protected:
#ifdef _MSC_VER
      _declspec(align(32)) struct Chunk { uint8_t data[32]; };
#elif defined(__GNUC__) || defined(__clang__)
      struct Chunk { uint8_t data[32]; } __attribute__((aligned(32)));
#endif
 
      size_t N = 0;
      std::vector<Chunk> storage;
    };
 
    class BasicOceanSystem : public ComponentSystemWithDataPool<BasicOceanComponent, BasicOceanData>
    {
    public:
      BasicOceanSystem(Memory::Allocator * allocator, SizeType capacity) : ComponentSystemWithDataPool(allocator, capacity) {}
 
      void initialize(Context * context) override;
      void cleanup(Context * context) override;
      void update(Context * context) override;
      void postUpdate(Context * context) override;
 
      TextureHandle getRealTex() const { return DisplacementTexH; }
      TextureHandle getImagTex() const { return NormalTexH; }
      TextureHandle getTangentTex() const { return TangentsTexH; }
 
      float getTileScale() const { return 1.f / fftTileExtent; }
      float getSignificantWaveHeight() const { return significantWaveHeight; }
 
    private:
      float fftTileExtent = 10.f;                 
      int   fftTileResolutionLog2 = 7;
      float significantWaveHeight = 4.f;
      float dominantWavePeriod = 25.f;
      float windSpeed = 10.f;
      float windDirection = 0.f;
      unsigned int phaseShiftNoiseFrequency = 3;  
      unsigned int tilePeriod = 30;               
      BasicOceanWaves waves = BasicOceanWaves::Default;
 
      struct {
        float channel0 = std::numeric_limits<float>::quiet_NaN();
        float channel1 = std::numeric_limits<float>::quiet_NaN();
      } magnitudes,     // Main thread
        magnitudes_tmp; // Tmp used by worker task
 
      bool animate = true;
      bool specsChanged = true;
 
      bool eightBit = false;  
      bool extraStep = false;
 
      TaskId oceanTaskGroup = NoTask;
 
      std::vector<float> P;
 
      ComplexArray frqH0;
      ComplexArray frqDz;
      ComplexArray frqDx;
      ComplexArray frqDy;
      ComplexArray frqdDzdu;
      ComplexArray frqdDzdv;
 
      ComplexArray spcDz;
      ComplexArray spcDx;
      ComplexArray spcDy;
      ComplexArray spcdDzdu;
      ComplexArray spcdDzdv;
 
      std::vector<uint8_t> fftScratch1;
      std::vector<uint8_t> fftScratch2;
      std::vector<uint8_t> fftScratch3;
      std::vector<uint8_t> fftScratch4;
      std::vector<uint8_t> fftScratch5;
 
      std::vector<uint8_t> fftScratch;
 
      TextureHandle DisplacementTexH = TextureHandle::NoHandle;
      TextureHandle NormalTexH = TextureHandle::NoHandle;
      TextureHandle TangentsTexH = TextureHandle::NoHandle;
      TextureHandle ReflectionTextureH = TextureHandle::NoHandle;
 
      MaterialHandle oceanMaterial = MaterialHandle::NoHandle;
      MaterialHandle oceanMaterial2 = MaterialHandle::NoHandle;
      VariableKey DisplacementKey = NoProperty;
      VariableKey NormalKey = NoProperty;
      VariableKey TangentsKey = NoProperty;
      VariableKey SkyDomeKey = NoProperty;
      VariableKey PlanarReflectionKey = NoProperty;
      VariableKey cameraYAxisKey = NoProperty;
      VariableKey waterColorKey = NoProperty;
      VariableKey waveDirectionKey = NoProperty;
      VariableKey significantWaveHeightKey = NoProperty;
      VariableKey fftTileScaleKey = NoProperty;
      VariableKey camPlaneDirKey = NoProperty;
      VariableKey camAzimuthKey = NoProperty;
      VariableKey seaLevelKey = NoProperty;
      VariableKey phaseShiftNoiseFrequencyKey = NoProperty;
      VariableKey phaseShiftNoisePeriodKey = NoProperty;
      VariableKey reflectionBrightnessKey = NoProperty;
 
      void setupMaterial();
      void updateTextureResolution(BasicOceanComponent* oceanComp);
 
      void setupWaveSpectrum();
 
      void updateTextures(const float magnitudeIn0, const float magnitudeIn1);
 
      void updateTileMaterialInstances(const BasicOceanData & oceanData,
                                       class AdaptivePlanarGridComponent * gridComp,
                                       struct AdaptivePlanarGridData & gridData,
                                       const glm::mat4& viewToWorld,
                                       const glm::vec2& viewPortSize);
    };
  }
}