Ocean.h

Go to the documentation of this file.

// Copyright (c) 2011-2021 Sundog Software, LLC. All rights reserved worldwide.
 
#ifndef TRITON_OCEAN_H
#define TRITON_OCEAN_H
 
#ifdef SWIG
#define TRITONAPI
%module TritonOcean
%include "carrays.i"
%include "cpointer.i"
%import "Environment.h"
%pointer_functions(float, floatp);
%array_functions( double, double_array )
SWIG_CSBODY_PROXY(public, public, SWIGTYPE)
SWIG_CSBODY_TYPEWRAPPER(public, public, public, SWIGTYPE)
%{
#include "Ocean.h"
using namespace Triton;
%}
#endif
 
#include "Environment.h"
#include "WakeGenerator.h"
#include "RotorWash.h"
#include "TidalStreamWake.h"
 
#pragma pack(push)
#pragma pack(8)
 
namespace Triton
{
class ProjectedGrid;
class WakeManager;
class ParticleSystemManager;
class SprayManager;
class DecalManager;
class Mutex;
class GodRays;
class Camera;
class WaterModelInitializationParams;
class ComplexNumber;
 
enum WaterModelTypes {
    TESSENDORF,  
    PIERSON_MOSKOWITZ, 
    JONSWAP, 
    UNKNOWN_WATERMODEL
};
 
enum Shaders {
      WATER_SURFACE
    , WATER_SURFACE_PATCH
    , SPRAY_PARTICLES
    , WAKE_SPRAY_PARTICLES
    , GOD_RAYS
    , WATER_DECALS
};
 
enum OceanQuality {
    GOOD,
    BETTER,
    BEST
};
 
class TritComplex : public MemObject
{
public:
        float real, imaginary;
};
 
class Ocean : public MemObject
{
public:
    static Ocean * TRITONAPI Create(Environment *env, WaterModelTypes type = JONSWAP, bool enableHeightTests = false,
        bool enableBreakingWaves = false, OceanQuality quality = GOOD);
 
#ifndef SWIG
    static Ocean * TRITONAPI Create(Environment *env, const TRITON_VECTOR(unsigned int)& userShaders, WaterModelTypes type = JONSWAP, 
        bool enableHeightTests = false, bool enableBreakingWaves = false, OceanQuality quality = GOOD);
#endif
 
    virtual ~Ocean();
 
    virtual void TRITONAPI Draw(double time, bool depthWrites = true, bool drawWater = true, bool drawParticles = true, void* context = 0, const Camera* camera = 0);
 
 
    virtual void TRITONAPI DrawConcurrent(double time, bool depthWrites = true, bool drawWater = true, bool drawParticles = true, void* context = 0, const Camera* camera = 0);
 
    void TRITONAPI PostDrawConcurrent();
 
    virtual bool TRITONAPI SetPatchShader(double time, int vertexStride, int positionOffset, bool doublePrecisionVertices,
                                          const double *modelMatrix = 0, bool decalPass = false, void* context = 0, const Camera* camera = 0);
 
    virtual bool TRITONAPI SetPatchMatrix(const double *modelMatrix, void* context = 0, const Camera* camera = 0);
 
    virtual void TRITONAPI UnsetPatchShader(double time = 0.0, const TBoundingBox* patchBounds = 0, bool decalPass = false, void* context = 0, const Camera* camera = 0);
 
#ifndef SWIG
    virtual bool ReloadShaders(const TRITON_VECTOR(unsigned int)& shaders, bool reloadSurface = true, 
        bool reloadWakes = true, bool reloadSprays = true, bool reloadDecals = true, bool reloadGodRays = true);
#endif
 
    virtual bool Initialize(void* context, const Camera* camera);
 
    virtual void TRITONAPI UpdateSimulation(double time, const Camera* camera = 0);
 
    void TRITONAPI D3D9DeviceLost();
 
    void TRITONAPI D3D9DeviceReset();
 
    float TRITONAPI GetChoppiness() const;
 
    void TRITONAPI SetChoppiness(float chop);
 
    float TRITONAPI GetLoopingPeriod() const;
 
    void TRITONAPI SetLoopingPeriod(float loopingPeriod);
 
    float TRITONAPI GetDepth(Triton::Vector3& floorNormal, const Camera* camera = 0) const;
 
    void TRITONAPI SetDepth(float depth, const Triton::Vector3& floorNormal, const Camera* camera = 0);
 
    void TRITONAPI EnableWireframe(bool wireframeOn);
 
    const char * TRITONAPI GetFFTName() const;
 
    unsigned int TRITONAPI GetNumTriangles() const;
 
    ShaderHandle TRITONAPI GetShaderObject(Shaders shaderProgram, void* context = 0, const Camera* camera = 0) const;
 
    // Retrives the underlying WakeManager. For internal use only.
    WakeManager * TRITONAPI GetWakeManager() {
        return wakeManager;
    }
 
    // Retrieves the underlying DecalManager. For internal use only.
    DecalManager * TRITONAPI GetDecalManager() {
        return decalManager;
    }
 
    DecalHandle TRITONAPI AddDecal(TextureHandle texture, float size, const Vector3& position);
 
    void TRITONAPI ScaleDecal(DecalHandle decal, float scaleWidth, float scaleDepth);
 
    void TRITONAPI MoveDecal(DecalHandle decal, const Vector3& position);
 
    void TRITONAPI RotateDecal(DecalHandle decal, double radians);
 
    void TRITONAPI SetDecalAlpha(DecalHandle decal, float alpha);
 
    void TRITONAPI RemoveDecal(DecalHandle decal);
 
    bool TRITONAPI GetHeight(const Vector3& point, const Vector3& direction, float& height, Vector3& normal,
                             bool visualCorrelation = true, bool includeWakes = true, bool highResolution = true,
                             bool threadSafe = true, Vector3 *intersectionPoint = 0, bool autoFlip = true, const Camera* camera = 0);
 
#ifndef SWIG
    bool TRITONAPI GetBatchHeight(const TRITON_VECTOR(Vector3) points, const TRITON_VECTOR(Vector3) directions, TRITON_VECTOR(float)& heights, 
        TRITON_VECTOR(Vector3)& normals, TRITON_VECTOR(Vector3)& intersectionPoints,
        bool visualCorrelation = true, bool includeWakes = true, bool highResolution = true,
        bool threadSafe = true, bool autoFlip = true, const Camera* camera = 0);
#endif
 
    bool TRITONAPI GetWavesIntersection(const Vector3& point, const Vector3& direction, Vector3& normal, Vector3& intersectionPoint,
                                        double precision = 0.1, bool visualCorrelation = true, bool threadSafe = true, 
                                        const Camera* camera = 0);
 
    bool TRITONAPI GetIntersection(const Vector3& point, const Vector3& direction, Vector3& intersection, const Camera* camera = 0);
 
    float TRITONAPI GetWaveHeading() const {
        return waveHeading;
    }
 
    void TRITONAPI EnableSpray(bool enable);
 
    bool TRITONAPI SprayEnabled() const {
        return sprayEnabled;
    }
 
    void TRITONAPI SetRefractionColor(const Vector3& refractionColor);
 
    const Vector3& TRITONAPI GetRefractionColor() const;
 
        void TRITONAPI SetReflectionScale(float reflectionScale);
 
        float TRITONAPI GetReflectionScale() const;
 
    void TRITONAPI SetPlanarReflectionBlend(float blendPercent);
 
    float TRITONAPI GetPlanarReflectionBlend() const;
 
    bool TRITONAPI ComputeReflectionMatrices(Matrix4& reflectionMatrix, Matrix3& textureMatrix, const Camera* camera = 0);
 
    const Environment * TRITONAPI GetEnvironment() const {
        return environment;
    }
 
    virtual bool TRITONAPI IsCameraAboveWater(const Camera* camera = 0);
 
    void TRITONAPI SetDepthOffset(float offset);
 
    float TRITONAPI GetDepthOffset() const;
 
    void TRITONAPI SetDisplacementDampingDistance(double distance);
 
    double TRITONAPI GetDisplacementDampingDistance() const;
 
    void TRITONAPI EnableGodRays(bool enable) {
        enableGodRays = enable;
    }
 
    bool TRITONAPI GodRaysEnabled() const {
        return godRays != 0 && enableGodRays;
    }
 
    void TRITONAPI SetGodRaysFade(float fadeAmount);
 
    float TRITONAPI GetGodRaysFade() const;
 
    void TRITONAPI Lock();
 
    void TRITONAPI Unlock();
 
    void TRITONAPI SetQuality(OceanQuality quality);
 
    OceanQuality TRITONAPI GetQuality() const {
        return quality;
    }
 
    void TRITONAPI SetLinearColorSpace(bool linearOn);
 
    bool TRITONAPI GetLinearColorSpace() const;
 
    void TRITONAPI SetMaximumWavePeriod(double maxPeriod);
 
    double TRITONAPI GetMaximumWavePeriod() const;
 
    void TRITONAPI SetClipDistances(double nearClip, double farClip);
 
    void TRITONAPI GetClipDistances(double& nearClip, double& farClip) const;
 
        bool TRITONAPI OverrideFFTInputArray(const TritComplex *H0, unsigned int size);
 
        void TRITONAPI ClearFFTInputArray();
 
    void TRITONAPI SetRotorWashUseDecals(bool useDecals);
    bool TRITONAPI GetRotorWashUseDecals(void) const;
 
    void TRITONAPI SetWaterModel(WaterModelTypes waterModel);
 
    WaterModelTypes TRITONAPI GetWaterModel(void) const;
 
    // Wrappers for interpreted languages require a publicly declared default constructor. You should always use Ocean::Create, however.
    Ocean() {}
 
#ifndef SWIG
 
    // Used internally 
    void RegisterWakeGenerator(WakeGenerator* wg);
    void UnregisterWakeGenerator(WakeGenerator *wg);
    void RegisterRotorWash(RotorWash *rw);
    void UnregisterRotorWash(RotorWash *rw);
    void RegisterTidalStreamWake(TidalStreamWake *tsw);
    void UnregisterTidalStreamWake(TidalStreamWake *tsw);
    void EnvironmentDeleted();
    void NotifySwellsChanged();
    void SetConfused(bool);
    void UpdateHeightMap(void* context, const Camera* camera, TextureHandle heightMap, const Matrix4& heightMapMatrix);
    GodRays *GetGodRays() const { return godRays; }
    const TRITON_VECTOR(unsigned int)& GetUserShaders() const {return userShaders;}
    ProjectedGrid* GetProjectedGrid() const {return grid;}
 
    typedef void(*GETOCEANHEIGHTPROC)(const Vector3& point, Vector3& normal, float& height);
 
    void TRITONAPI SetOceanHeightCB(GETOCEANHEIGHTPROC _oceanHeightCB) {
        oceanHeightCB = _oceanHeightCB;
    }
 
    GETOCEANHEIGHTPROC TRITONAPI GetOceanHeightCB() const {
        return oceanHeightCB;
    }
 
protected:
    Ocean(Environment *env, WaterModelTypes type, bool enableHeightTest, bool enableBreakingWaves, OceanQuality quality);
    Ocean(Environment *env, WaterModelTypes type, bool enableHeightTest, bool enableBreakingWaves, OceanQuality quality, const TRITON_VECTOR(unsigned int)& userShaders);
    virtual void Initialize(const Environment *env, WaterModelTypes type, bool enableHeightTest, bool enableBreakingWaves);
 
    virtual bool CreateWaterSimulation();
    void DestroyWaterSimulation();
 
    void SetWaveHeading(const Camera* camera);
 
    void DrawInternal(double time, bool depthWrites, bool drawWater, bool drawParticles, void* context, const Camera* camera, bool respectThreadSafe, bool respectAvoidStalls);
 
    bool isGlobal, initialized, heightReadsEnabled, enableGodRays;
 
    Environment *environment;
 
    ProjectedGrid *grid;
 
    WakeManager *wakeManager;
 
    SprayManager *sprayManager;
 
    DecalManager *decalManager;
 
    GodRays *godRays;
 
    float waveHeading;
 
    bool sprayEnabled, enableKelvin;
 
    double dampingDistance;
 
    Mutex *mutex;
 
    bool simulationUpdated;
 
    WaterModelTypes waterModelType;
 
    double lastUpdateTime;
    const Camera* lastCamera;
 
    double timeAdjustment;
 
    TRITON_VECTOR(WakeGenerator *) wakeGenerators;
 
    TRITON_VECTOR(RotorWash *) rotorWashes;
 
    TRITON_VECTOR(TidalStreamWake *) tidalStreams;
 
    TRITON_VECTOR(unsigned int) userShaders;
 
    bool hasBreakingWaves, linearEnabled;
 
    OceanQuality quality;
 
    GETOCEANHEIGHTPROC oceanHeightCB;
 
    WaterModelInitializationParams* watermodelparams;
 
        double cameraMotionThreshold;
 
    void createAndInitializeFallbackWaterModel(void);
#endif //SWIG
};
}
 
#pragma pack(pop)
 
#endif