EnvironmentTexture.hpp

#pragma once
#include <Core/Types.hpp>
#include <Engine/Data/Mesh.hpp>
#include <Engine/Data/Texture.hpp>
#include <Engine/RaEngine.hpp>
 
#include <array>
#include <memory>
#include <string>
 
namespace Ra {
namespace Engine {
namespace Data {
class ShaderProgram;
struct ViewingParameters;
 
class RA_ENGINE_API EnvironmentTexture
{
  public:
    enum class EnvMapType { ENVMAP_PFM, ENVMAP_CUBE, ENVMAP_LATLON };
    explicit EnvironmentTexture( const std::string& mapName, bool isSkybox = false );
    EnvironmentTexture( const EnvironmentTexture& )            = delete;
    EnvironmentTexture& operator=( const EnvironmentTexture& ) = delete;
    EnvironmentTexture( EnvironmentTexture&& )                 = default;
    EnvironmentTexture& operator=( EnvironmentTexture&& )      = default;
    ~EnvironmentTexture() = default;
    inline const std::string& getImageName() const { return m_name; }
    inline EnvMapType getImageType() const { return m_type; }
 
    void saveShProjection( const std::string& filename );
 
    const Ra::Core::Matrix4& getShMatrix( int channel );
 
    void render( const Ra::Engine::Data::ViewingParameters& viewParams );
 
    inline void setSkybox( bool state ) { m_isSkyBox = state; }
 
    void setStrength( float s );
 
    float getStrength() const;
 
    inline bool isSkybox() const { return m_isSkyBox; }
 
    Ra::Engine::Data::Texture* getEnvironmentTexture();
 
    void updateGL();
 
  private:
    void initializeTexture();
 
    void setupTexturesFromPfm();
    void setupTexturesFromCube();
    void setupTexturesFromSphericalEquiRectangular();
 
    void computeSHMatrices();
 
    void updateCoeffs( float* hdr, float x, float y, float z, float domega );
    float* getPixel( float x, float y, float z );
    void tomatrix();
    Ra::Engine::Data::Texture* getSHImage();
 
    std::string m_name;
    EnvMapType m_type;
 
    // The raw pixel values of the envmap
    std::array<std::shared_ptr<float[]>, 6> m_skyData;
    size_t m_width { 0 };
    size_t m_height { 0 };
    float m_shcoefs[9][3];
    Ra::Core::Matrix4 m_shMatrices[3];
    std::unique_ptr<Ra::Engine::Data::Texture> m_shtexture { nullptr };
    bool m_isSkyBox { false };
    std::unique_ptr<Ra::Engine::Data::Mesh> m_displayMesh { nullptr };
    std::unique_ptr<Ra::Engine::Data::Texture> m_skyTexture { nullptr };
    float m_environmentStrength { 1 };
    const Ra::Engine::Data::ShaderProgram* m_skyShader { nullptr };
    bool m_glReady { false };
};
class RA_ENGINE_API EnvironmentTexture {…};
 
} // namespace Data
} // namespace Engine
} // namespace Ra