WaveSpectrum.h

#pragma once
 
#include "FourierTransform.h"
#include "GPGPUQuadRenderer.h"
 
#include "Rendering/Common.h"
 
#include <vector>
 
namespace Cogs
{
  class IGraphicsDevice;
 
  class WaveSpectrum
  {
  public:
 
    void initialize(IGraphicsDevice* device);
 
    void setSize(const int Nlog2);
 
    float setConditions(const float tileExtent,
                        const float waveNumberMute,
                        const float waveNumberPass,
                        const float significantWavePeriod,
                        const float windSpeed,
                        const float windDirection,
                        const float scale = 0.f,
                        const unsigned int seed = 42);
 
    bool update(RenderContext& renderContext, const float dt);
 
    TextureHandle positionTex() { return packed.xyzTex; }
 
    TextureHandle derivativesTex() { return packed.dxdu_dydv_dzdu_dzdvTex; }
 
 
    float getTileExtent() const { return tileExtent; }
 
    float getTileExtentAdjust() const { return tileExtentAdjust; }
 
    float getAdjustedTileExtent() const { return tileExtentAdjust*tileExtent; }
 
  protected:
    GPGPUQuadRenderer gpgpuQuadRenderer;
    FourierTransform2D fourierTransform;
    IGraphicsDevice* device;
    float tileExtent;
    float tileExtentAdjust;
    int NLog2;
    int N;
 
    int frame;
 
    TextureHandle phaseTex[2];
    RenderTargetHandle dispersionTarget[2];
 
    struct {
      EffectHandle effect;
      InputLayoutHandle il;
      BufferHandle constantBuffer;
    } texturePack;
 
 
    struct {
      EffectHandle effect;
      InputLayoutHandle il;
      BufferHandle constantBuffer;
    } disperse;
 
    struct {
      std::vector<float> E;
      std::vector<glm::vec2> a;          
      TextureHandle aTex;
      TextureHandle xyTex;
      TextureHandle zTex;
      TextureHandle dzdu_dzdv_Tex;
    } frequencyDomain;
 
    struct {
      TextureHandle xyzTex;
      TextureHandle dxdu_dydv_dzdu_dzdvTex;
      RenderTargetHandle packTarget;
    } packed;
 
    struct {
      TextureHandle xyTex;
      TextureHandle zTex;
      TextureHandle dzdu_dzdv_Tex;
      RenderTargetHandle xyTarget;
      RenderTargetHandle zTarget;
      RenderTargetHandle dzduTarget;
    } spatialDomain;
 
    static float createDirectionalWaveSpectrum(std::vector<float>& E,        
                                               int N,                     
                                               float L,                      
                                               float freqPassZero,
                                               float freqPassOne,
                                               float windSpeed,              
                                               float windDirection,          
                                               float dominantWavePeriod,     
                                               float scale = 0.f);
 
    static void createRandomizedWaveSpectrumInstance(std::vector<glm::vec2>& H,
                                                     const std::vector<float>& E,
                                                     const unsigned int seed,
                                                     const size_t N);
  };
 
}