Environment.h

Go to the documentation of this file.

// Copyright (c) 2011-2018 Sundog Software LLC. All rights reserved worldwide.
 
#ifndef TRITON_ENVIRONMENT_H
#define TRITON_ENVIRONMENT_H
 
// Data for SWIG follows, used for automatically creating our C# wrapper. Move along...
#ifdef SWIG
#define TRITONAPI
#define SL_VECTOR(a) std::vector<a>
%module TritonEnvironment
%include "carrays.i"
%include "typemaps.i"
%include "ResourceLoader.h"
%include "WindFetch.h"
%include "Matrix3.h"
%include "Matrix4.h"
%include "CoordinateSystem.h"
%array_functions( double, double_array )
%typemap(ctype) void * "void *"
%typemap(imtype) void * "System.IntPtr"
%typemap(cstype) void * "System.IntPtr"
%typemap(csin) void * "$csinput"
%typemap(in) void * %{ $1 = $input; %}
%typemap(out) void * %{ $result = $1; %}
%typemap(csout) void * {
     return $imcall;
   }
%typemap(ctype) TextureHandle "void *"
%typemap(imtype) TextureHandle"System.IntPtr"
%typemap(cstype) TextureHandle "System.IntPtr"
%typemap(csin) TextureHandle "$csinput"
%typemap(in) TextureHandle %{ $1 = $input; %}
%typemap(out) TextureHandle %{ $result = $1; %}
%typemap(csout) TextureHandle {
     return $imcall;
   }
SWIG_CSBODY_PROXY(public, public, SWIGTYPE)
SWIG_CSBODY_TYPEWRAPPER(public, public, public, SWIGTYPE)
%{
#include "Environment.h"
using namespace Triton;
%}
#endif
 
// And now, our actual C++ header:
#include "TritonCommon.h"
#include "ResourceLoader.h"
#include "RandomNumberGenerator.h"
#include "WindFetch.h"
#include "Matrix3.h"
#include "Matrix4.h"
#include "OrientedBoundingBox.h"
#include "CoordinateSystem.h"
 
#include "TritonMap.h"
#include "TritonVector.h"
#include "TritonSet.h"
 
#pragma pack(push)
#pragma pack(8)
 
namespace Triton
{
class Frustum;
class Ocean;
class Camera;
class Mutex;
class Stream;
class BindlessCapsGL;
class OpenGLDevice;
 
enum Renderer {
    OPENGL_2_0,         
    OPENGL_3_2,         
    OPENGL_4_0,         
    OPENGL_4_1,         
    OPENGL_4_5,         
    DIRECTX_9,          
    DIRECT3D9_EX,       
    DIRECTX_11,         
    NO_RENDERER         
};
 
enum EnvironmentError {
    SUCCEEDED = 0,          
    NO_CONFIG_FOUND,        
    NULL_RESOURCE_LOADER,   
    NO_DEVICE,              
    NO_CONTEXT              
};
 
class HeightMapContainer
{
public:
    HeightMapContainer();
    ~HeightMapContainer();
    TextureHandle heightMap;
    Matrix4 heightMapMatrix;
};
 
class BreakingWavesParameters : public MemObject {
public:
    BreakingWavesParameters();
 
    void SetSteepness(float pSteepness) {
        steepness = pSteepness; ComputeDerivedValues();
    }
 
    void SetWavelength(float pWavelength) {
        wavelength = pWavelength; ComputeDerivedValues();
    }
 
    void SetWavelengthVariance(float pWavelengthVariance) {
        wavelengthVariance = pWavelengthVariance;
    }
 
    void SetWaveDirection(const Vector3& pDirection) {
        waveDirection = pDirection;
        waveDirection.Normalize();
    }
 
    void SetAutoWaveDirection(bool on) {
        autoWaveDirection = on;
    }
 
    void SetAmplitude(float pAmplitude) {
        amplitude = pAmplitude; ComputeDerivedValues();
    }
 
    void SetSurgeDepth(float pSurgeDepth) {
        surgeDepth = pSurgeDepth;
    }
 
    void SetSteepnessVariance(float pSteepnessVariance) {
        steepnessVariance = pSteepnessVariance;
    }
 
    void SetDepthFalloff(float pFalloff) {
        depthFalloff = pFalloff;
    }
 
    float GetSteepness() const {return steepness;}
    float GetWavelength() const {return wavelength;}
    float GetWavelengthVariance() const {return wavelengthVariance;}
    const Vector3& GetWaveDirection() const {return waveDirection;}
    float GetAmplitude() const {return amplitude;}
    float GetSurgeDepth() const {return surgeDepth;}
    float GetSteepnessVariance() const {return steepnessVariance;}
    float GetPhaseConstant() const {return phaseConstant;}
    float GetExpK() const {return kexp;}
    float GetSpeed() const {return speed;}
    bool GetAutoWaveDirection() const {return autoWaveDirection;}
    float GetDepthFalloff() const {return depthFalloff;}
 
private:
    float steepness;            
    float wavelength;           
    float wavelengthVariance;   
    Vector3 waveDirection;
    float amplitude;            
    float surgeDepth;           
    float steepnessVariance;    
    void ComputeDerivedValues();
    float phaseConstant, kexp, speed;
    bool autoWaveDirection;
    float depthFalloff;
};
 
class SwellDescription : public MemObject
{
public:
    float wavelength; 
    float height;     
    float direction;  
    float phase;      
};
 
// Putting this in here for lack of a better place.
typedef float (*GETUSERHEIGHTPROC)( const Vector3& position );
 
class Environment : public MemObject
{
public:
    Environment();
 
    EnvironmentError TRITONAPI Initialize(CoordinateSystem cs, Renderer ren, ResourceLoader *rl, void *device = NULL, bool hdr = false);
 
    virtual ~Environment();
 
    void TRITONAPI SetLicenseCode(const char *userName, const char *registrationCode);
 
#ifndef SWIG
    void TRITONAPI SetRandomNumberGenerator(RandomNumberGenerator *rng);
 
    RandomNumberGenerator * TRITONAPI GetRandomNumberGenerator() const {
        return randomNumberGenerator;
    }
#endif // SWIG
 
    ResourceLoader * TRITONAPI GetResourceLoader() const {
        return resourceLoader;
    }
 
    void * TRITONAPI GetDevice() const {
        return device;
    }
 
    void TRITONAPI SetDirectionalLight(const Vector3& direction, const Vector3& color);
 
    void TRITONAPI SetAmbientLight(const Vector3& color) {
        ambientColor = color;
    }
 
    const Vector3& TRITONAPI GetLightDirection() const {
        return lightDirection;
    }
 
    const Vector3& TRITONAPI GetDirectionalLightColor() const {
        return lightColor;
    }
 
    const Vector3& TRITONAPI GetAmbientLightColor() const {
        return ambientColor;
    }
 
    void TRITONAPI SetEnvironmentMap(TextureHandle cubeMap, const Matrix3& textureMatrix = Matrix3::Identity) {
        envMap = cubeMap;
        envMapMatrix = textureMatrix;
    }
 
    TextureHandle TRITONAPI GetEnvironmentMap() const {
        return envMap;
    }
 
    Matrix3 TRITONAPI GetEnvironmentMapMatrix() const {
        return envMapMatrix;
    }
 
    void TRITONAPI SetHeightMap(TextureHandle pHeightMap, const Matrix4& worldToTextureCoords, void* context=0, const Camera* camera=0);
 
    TextureHandle TRITONAPI GetHeightMap(const Camera* camera = 0) const;
 
    Matrix4 TRITONAPI GetHeightMapMatrix(const Camera* camera = 0) const;
 
#ifndef SWIG
    void TRITONAPI SetUserHeightCB( GETUSERHEIGHTPROC _userHeightCB ) {
      userHeightCB = _userHeightCB;
    }
 
    GETUSERHEIGHTPROC TRITONAPI GetUserHeightCB() const {
      return userHeightCB;
    }
#endif
 
    void TRITONAPI SetHeightMapRange( float _range ) {
        heightMapRange = _range;
    }
 
    void TRITONAPI SetHeightMapOffset( float _offset ) {
        heightMapOffset = _offset;
    }
 
    float TRITONAPI GetHeightMapRange() const {
        return heightMapRange;
    }
 
    float TRITONAPI GetHeightMapOffset() const {
        return heightMapOffset;
    }
 
    void TRITONAPI SetDepthMap(TextureHandle pDepthMap);
 
    TextureHandle TRITONAPI GetDepthMap() const {
        return depthMap;
    }
 
    void TRITONAPI SetBreakingWavesParameters(const BreakingWavesParameters& params) {
        breakingWavesParameters = params;
    }
 
    const BreakingWavesParameters& TRITONAPI GetBreakingWavesParameters() const {
        return breakingWavesParameters;
    }
 
    void TRITONAPI SetPlanarReflectionMap(TextureHandle textureMap,
                                          const Matrix3& textureMatrix,
                                          float normalDisplacementScale = 0.125f) {
        planarReflectionMap = textureMap;
        planarReflectionMapMatrix = textureMatrix;
        planarReflectionDisplacementScale = normalDisplacementScale;
    }
 
    TextureHandle TRITONAPI GetPlanarReflectionMap() const {
        return planarReflectionMap;
    }
 
    Matrix3 TRITONAPI GetPlanarReflectionMapMatrix() const {
        return planarReflectionMapMatrix;
    }
 
    float TRITONAPI GetPlanarReflectionDisplacementScale( ) const {
        return planarReflectionDisplacementScale;
    }
 
    void TRITONAPI SimulateSeaState(double beaufortScale, double windDirection, bool leftHanded = false);
 
    void TRITONAPI AddWindFetch(const WindFetch& fetch, bool leftHanded = false);
 
    void TRITONAPI ClearWindFetches();
 
    void TRITONAPI AddSwell(float waveLength, float waveHeight, float direction, float phase = 0, bool leftHanded = false);
 
    void TRITONAPI ClearSwells();
 
#ifndef SWIG
    const TRITON_VECTOR(SwellDescription)& TRITONAPI GetSwells() const;
#endif
 
    void TRITONAPI SetDouglasSeaScale(int seaState, float windWaveDirection, int swellState, float swellDirection, bool leftHanded = false);
 
    void TRITONAPI GetWind(const Vector3& pos, double& windSpeed, double& windDirection, double& fetchLength) const;
 
    void TRITONAPI SetSeaLevel(double altitudeMSL) {
        seaLevel = altitudeMSL;
    }
 
    double TRITONAPI GetSeaLevel() const {
        return seaLevel;
    }
 
    void TRITONAPI SetAboveWaterVisibility(double visibility, const Vector3& fogColor) {
        aboveWaterVisibility = visibility;
        aboveWaterFogColor = fogColor;
    }
 
    void TRITONAPI GetAboveWaterVisibility(double& visibility, Vector3& fogColor) const {
        visibility = aboveWaterVisibility;
        fogColor = aboveWaterFogColor;
    }
 
    void TRITONAPI SetBelowWaterVisibility(double visibility, const Vector3& fogColor) {
        belowWaterVisibility = visibility;
        belowWaterFogColor = fogColor;
    }
 
    void TRITONAPI GetBelowWaterVisibility(double& visibility, Vector3& fogColor) const {
        visibility = belowWaterVisibility;
        fogColor = belowWaterFogColor;
    }
 
    void TRITONAPI SetWaveBlendDepth(double depth) {
        blendDepth = depth;
        hasBlendDepth = true;
    }
 
    double TRITONAPI GetWaveBlendDepth() const {
        if (hasBlendDepth) {
            return blendDepth;
        } else {
            return belowWaterVisibility;
        }
    }
 
    void TRITONAPI SetSunIntensity(float intensity) {
        sunIntensity = intensity;
    }
 
    float TRITONAPI GetSunIntensity() const {
        return sunIntensity;
    }
 
    void TRITONAPI SetWorldUnits(double worldUnits) {
        units = worldUnits;
    }
 
    double TRITONAPI GetWorldUnits() const {
        return units;
    }
 
    CoordinateSystem TRITONAPI GetCoordinateSystem() const {
        return coordinateSystem;
    }
 
    bool TRITONAPI IsGeocentric() const {
        return coordinateSystem < FLAT_ZUP;
    }
 
    Renderer TRITONAPI GetRenderer() const {
        return renderer;
    }
 
    bool TRITONAPI IsOpenGL() const {
        return renderer < DIRECTX_9;
    }
 
    bool TRITONAPI IsDirectX() const {
        return renderer >= DIRECTX_9 && renderer != NO_RENDERER;
    }
 
    void TRITONAPI SetCameraMatrix(const double *m, const double *explicitCameraPosition = 0);
 
    void TRITONAPI SetProjectionMatrix(const double *p);
 
    void TRITONAPI SetViewport(int x, int y, int width, int height);
 
    void TRITONAPI SetZoomLevel(float zoom) { zoomLevel = zoom; }
 
    float TRITONAPI GetZoomLevel() const { return zoomLevel; }
 
    void TRITONAPI SetUserDefinedVertString( const char *userDefinedString );
 
    void TRITONAPI SetUserDefinedFragString( const char *userDefinedString );
 
    const char * TRITONAPI GetUserDefinedVertString() const { return userDefinedVertString; }
 
    const char * TRITONAPI GetUserDefinedFragString() const { return userDefinedFragString; }
 
    bool TRITONAPI GetViewport(int& x, int& y, int& width, int& height) const;
 
    const Camera* TRITONAPI GetCamera() const { return camera; };
 
    Camera* TRITONAPI GetCamera() { return camera; };
 
    Camera* TRITONAPI CreateCamera(void);
 
    void TRITONAPI DestroyCamera(Camera* camera);
 
#ifndef SWIG
    const TRITON_SET(Camera*)& GetCameras(void) const;
#endif
 
    const double * TRITONAPI GetCameraMatrix() const;
 
    const double * TRITONAPI GetProjectionMatrix() const;
 
    const double * TRITONAPI GetCameraPosition() const;
 
    Vector3 TRITONAPI GetUpVector() const;
 
    Vector3 TRITONAPI GetRightVector() const;
 
    void TRITONAPI SetConfigOption(const char *key, const char *value);
 
    const char * TRITONAPI GetConfigOption(const char *key);
 
    bool TRITONAPI CullSphere(const Vector3& position, double radius) const;
 
    bool TRITONAPI CullOrientedBoundingBox(const OrientedBoundingBox& obb) const;
 
        const bool TRITONAPI GetHDREnabled() const {
                return hdr;
        }
 
    void TRITONAPI EnableOpenMP(bool enabled) {
        useOpenMP = enabled;
    }
 
    bool TRITONAPI GetOpenMPEnabled() const {
        return useOpenMP;
    }
 
    float TRITONAPI GetMaximumWaveHeight() const;
 
    void TRITONAPI SetCurrent(const Vector3& direction, double speed) { currentDirection = direction; currentSpeed = speed; }
 
    void TRITONAPI GetCurrent(Vector3& direction, double& speed) const { direction = currentDirection, speed = currentSpeed; }
 
    void TRITONAPI SetWaterTransparency(float t) {
        transparency = t;
    }
 
    float TRITONAPI GetWaterTransparency() const {
        return transparency;
    }
 
    Stream* TRITONAPI CreateOpenGLStream(void);
 
    void    TRITONAPI DestroyOpenGLStream(Stream* stream);
 
    void    TRITONAPI ExecuteOpenGLStream(Stream* stream);
 
    void    TRITONAPI ResetOpenGLStream(Stream* stream);
 
#ifndef SWIG
 
    // Internal use only:
    void RegisterOcean(Ocean *ocean);
    void UnregisterOcean(Ocean *ocean);
    bool GetConfusedSeas() const {return confusedSeas;}
    void TRITONAPI SetBreakingWaveMap(TextureHandle pBreakingWaveMap, const Matrix4& worldToTextureCoords);
    TextureHandle TRITONAPI GetBreakingWaveMap() const {
        return breakingWaveMap;
    }
    Matrix4 TRITONAPI GetBreakingWaveMapMatrix() const {
        return breakingWaveMapMatrix;
    }
 
    void GetUpRightInVectors(const Vector3& position, Vector3& up, Vector3& right, Vector3& in) const;
 
    TextureHandle GetHeightMapAndMatrix(Matrix4& heightMapMatrix, const Camera* camera) const;
 
    const BindlessCapsGL* GetBindlessCaps(void) const;
 
    const OpenGLDevice* GetOpenGLDevice(void) const;
protected:
 
    void TRITONAPI DestroyAllCameras(void);
 
    float adjustDirectionForLeftHanded(float radians);
 
    CoordinateSystem coordinateSystem;
 
    void *device;
 
    Renderer renderer;
 
    ResourceLoader *resourceLoader;
 
    RandomNumberGenerator *randomNumberGenerator, *defaultRandomNumberGenerator;
 
    TRITON_VECTOR(WindFetch) windFetches;
 
    TRITON_VECTOR(Ocean *) oceans;
 
    TRITON_VECTOR(SwellDescription) swells;
 
    bool confusedSeas;
 
    Camera* camera;
 
    TRITON_SET(Camera*) cameras;
 
    double units;
 
    Vector3 lightDirection, lightColor, ambientColor;
 
    double seaLevel;
 
        bool hdr, useOpenMP;
 
    double aboveWaterVisibility, belowWaterVisibility;
 
    float sunIntensity;
 
    Vector3 aboveWaterFogColor, belowWaterFogColor;
 
    TextureHandle  envMap, breakingWaveMap, depthMap;
 
    GETUSERHEIGHTPROC userHeightCB;
 
    float heightMapRange, heightMapOffset;
 
    Matrix3 envMapMatrix;
    
    Matrix4 breakingWaveMapMatrix;
 
    typedef TRITON_MAP(const Camera*, HeightMapContainer) MapCameraToHeightMapConfig;
    MapCameraToHeightMapConfig mapCameraToHeightMapConfig;
    Mutex* heightMapMutex;
 
    TextureHandle planarReflectionMap;
 
    Matrix3 planarReflectionMapMatrix;
 
    float  planarReflectionDisplacementScale;
 
    Frustum *frustum;
 
    BreakingWavesParameters breakingWavesParameters;
 
    bool doHeightMapCopy;
 
    float douglasShortWL, douglasAvgWL, douglasLongWL;
    float douglasLowHeight, douglasModerateHeight, douglasHighHeight;
 
    float zoomLevel;
 
    char *userDefinedVertString;
    char *userDefinedFragString;
 
    double blendDepth;
    bool hasBlendDepth;
 
    Vector3 currentDirection;
    double currentSpeed;
 
    float transparency;
 
    TRITON_SET(Stream*) streams;
    void DestroyAllOpenGLStreams();
    void DestroyOpenGLDevice();
#endif // SWIG
 
};
}
 
#pragma pack(pop)
 
#endif