RenderObject.hpp

#pragma once
 
#include <Engine/RaEngine.hpp>
 
#include <memory>
#include <mutex>
#include <string>
 
#include <Core/Types.hpp>
#include <Core/Utils/IndexedObject.hpp>
 
#include <Engine/Data/ShaderProgram.hpp>
#include <Engine/Rendering/RenderObjectTypes.hpp>
#include <Engine/Rendering/RenderTechnique.hpp>
 
namespace Ra {
namespace Engine {
 
namespace Scene {
class Component;
} // namespace Scene
 
namespace Data {
class Displayable;
class Material;
struct ViewingParameters;
class RenderParameters;
} // namespace Data
 
namespace Rendering {
 
class RA_ENGINE_API RenderObject final : public Core::Utils::IndexedObject
{
  public:
    RenderObject( const std::string& name,
                  Scene::Component* comp,
                  const RenderObjectType& type,
                  int lifetime = -1 );
 
    ~RenderObject() override;
 
    static RenderObject* createRenderObject(
        const std::string& name,
        Scene::Component* comp,
        const RenderObjectType& type,
        std::shared_ptr<Data::Displayable> mesh,
        const RenderTechnique& techniqueConfig = RenderTechnique::createDefaultRenderTechnique() );
 
    void updateGL();
 
    const std::string& getName() const;
    const Scene::Component* getComponent() const;
    Scene::Component* getComponent();
 
    const RenderObjectType& getType() const;
    void setType( const RenderObjectType& t );
 
    void setVisible( bool visible );
    void toggleVisible();
    bool isVisible() const;
 
    void setPickable( bool pickable );
    void togglePickable();
    bool isPickable() const;
 
    void setXRay( bool xray );
    void toggleXRay();
    bool isXRay() const;
 
    void setTransparent( bool transparent );
    void toggleTransparent();
    bool isTransparent() const;
 
    void setColoredByVertexAttrib( bool state );
    void toggleColoredByVertexAttrib();
    bool isColoredByVertexAttrib() const;
 
    bool isDirty() const;
 
    void setRenderTechnique( std::shared_ptr<RenderTechnique> technique );
    std::shared_ptr<const RenderTechnique> getRenderTechnique() const;
    std::shared_ptr<RenderTechnique> getRenderTechnique();
 
    void setMaterial( std::shared_ptr<Data::Material> material );
    std::shared_ptr<const Data::Material> getMaterial() const;
    std::shared_ptr<Data::Material> getMaterial();
 
    void setMesh( std::shared_ptr<Data::Displayable> mesh );
    std::shared_ptr<const Data::Displayable> getMesh() const;
    const std::shared_ptr<Data::Displayable>& getMesh();
 
    Core::Transform getTransform() const;
    Core::Matrix4 getTransformAsMatrix() const;
 
    Core::Aabb computeAabb();
 
    void setLocalTransform( const Core::Transform& transform );
    void setLocalTransform( const Core::Matrix4& transform );
    const Core::Transform& getLocalTransform() const;
    const Core::Matrix4& getLocalTransformAsMatrix() const;
 
    void hasBeenRenderedOnce();
 
    void hasExpired();
 
    void setLifetime( int t );
 
    void render( const Data::RenderParameters& lightParams,
                 const Data::ViewingParameters& viewParams,
                 const Data::ShaderProgram* shader,
                 const Data::RenderParameters& shaderParams );
 
    void render( const Data::RenderParameters& lightParams,
                 const Data::ViewingParameters& viewParams,
                 Core::Utils::Index passId = DefaultRenderingPasses::LIGHTING_OPAQUE );
 
    void invalidateAabb();
 
  private:
    Core::Transform m_localTransform { Core::Transform::Identity() };
 
    Scene::Component* m_component { nullptr };
    std::string m_name {};
 
    RenderObjectType m_type { RenderObjectType::Geometry };
    std::shared_ptr<RenderTechnique> m_renderTechnique { nullptr };
    std::shared_ptr<Data::Displayable> m_mesh { nullptr };
    std::shared_ptr<Data::Material> m_material { nullptr };
 
    mutable std::mutex m_updateMutex;
 
    int m_lifetime { -1 };
    bool m_visible { true };
    bool m_pickable { true };
    bool m_xray { false };
    bool m_transparent { false };
    bool m_dirty { true };
    bool m_hasLifetime { false };
 
    bool m_isAabbValid { false };
    Core::Aabb m_aabb;
    int m_aabbObserverIndex { -1 };
};
 
} // namespace Rendering
} // namespace Engine
} // namespace Ra