MRIRenderObject.h

Go to the documentation of this file.

#pragma once
#include "MRMesh/MRFlagOperators.h"
#include "MRPch/MRBindingMacros.h"
#include "MRRenderModelParameters.h"
#include "MRMeshFwd.h"
#include "MRViewportId.h"
#include "MRVector2.h"
#include "MRVector4.h"
#include "MRAffineXf3.h"
#include <functional>
#include <typeindex>
#include <memory>
 
namespace MR
{
 
 
enum class DepthFunction
{
    Never = 0,
    Less = 1,
    Equal = 2,
    Greater = 4,
    LessOrEqual = Less | Equal,
    GreaterOrEqual = Greater | Equal,
    NotEqual = Less | Greater,
    Always = Less | Equal | Greater,
    Default = 8 
};
MR_MAKE_FLAG_OPERATORS( DepthFunction )
 
 
struct BaseRenderParams
{
    const Matrix4f& viewMatrix;
    const Matrix4f& projMatrix;
    ViewportId viewportId;       
    Vector4i viewport;           
};
 
struct ModelBaseRenderParams : BaseRenderParams
{
    const Matrix4f& modelMatrix;
    const Plane3f& clipPlane;    
    DepthFunction depthFunction = DepthFunction::Default;
};
 
struct ModelRenderParams : ModelBaseRenderParams
{
    const Matrix4f* normMatrixPtr{ nullptr }; 
    Vector3f lightPos;            
    TransparencyMode transparencyMode; 
 
    RenderModelPassMask passMask = RenderModelPassMask::All; 
};
 
struct BasicUiRenderTask
{
    virtual ~BasicUiRenderTask() = default;
 
    BasicUiRenderTask() = default;
    BasicUiRenderTask( const BasicUiRenderTask& ) = default;
    BasicUiRenderTask( BasicUiRenderTask&& ) = default;
    BasicUiRenderTask& operator=( const BasicUiRenderTask& ) = default;
    BasicUiRenderTask& operator=( BasicUiRenderTask&& ) = default;
 
    float renderTaskDepth = 0;
 
    enum class InteractionMask
    {
        mouseHover = 1 << 0,
        mouseScroll = 1 << 1,
    };
    MR_MAKE_FLAG_OPERATORS_IN_CLASS( InteractionMask )
 
    struct BackwardPassParams
    {
        mutable InteractionMask consumedInteractions{};
 
        [[nodiscard]] bool tryConsumeMouseHover() const
        {
            if ( !bool( consumedInteractions & InteractionMask::mouseHover ) )
            {
                consumedInteractions |= InteractionMask::mouseHover;
                return true;
            }
            return false;
        }
    };
 
    virtual void earlyBackwardPass( const BackwardPassParams& params ) { (void)params; }
 
    virtual void renderPass() = 0;
};
 
struct UiRenderParams : BaseRenderParams
{
    using UiTaskList = std::vector<std::shared_ptr<BasicUiRenderTask>>;
 
    UiTaskList* tasks = nullptr;
};
 
struct UiRenderManager
{
    virtual ~UiRenderManager() = default;
 
    virtual void preRenderViewport( ViewportId viewport ) { (void)viewport; }
    virtual void postRenderViewport( ViewportId viewport ) { (void)viewport; }
 
    virtual BasicUiRenderTask::BackwardPassParams beginBackwardPass( ViewportId viewport, UiRenderParams::UiTaskList& tasks ) { (void)viewport; (void)tasks; return {}; }
    virtual void finishBackwardPass( ViewportId viewport, const BasicUiRenderTask::BackwardPassParams& params ) { (void)viewport, (void)params; }
};
 
class IRenderObject
{
public:
    virtual ~IRenderObject() = default;
 
 
    virtual bool render( const ModelRenderParams& params ) = 0;
    virtual void renderPicker( const ModelBaseRenderParams& params, unsigned geomId ) = 0;
    virtual size_t heapBytes() const = 0;
    virtual size_t glBytes() const = 0;
    virtual void forceBindAll() {}
 
    virtual void renderUi( const UiRenderParams& params ) { (void)params; }
};
inline bool IRenderObject::render( const ModelRenderParams& ) { return false; }
inline void IRenderObject::renderPicker( const ModelBaseRenderParams&, unsigned ) {}
inline size_t IRenderObject::heapBytes() const { return 0; }
inline size_t IRenderObject::glBytes() const { return 0; }
 
template <typename ...Bases>
requires ( ( std::derived_from<Bases, IRenderObject> && !std::same_as<Bases, IRenderObject> ) && ... )
class RenderObjectCombinator : public Bases...
{
public:
    RenderObjectCombinator( const VisualObject& object )
        : Bases( object )...
    {}
 
    bool render( const ModelRenderParams& params ) override
    {
        bool ret = false;
        (void)( ..., ( ret = Bases::render( params ) || ret ) );
        return ret;
    }
    void renderPicker( const ModelBaseRenderParams& params, unsigned geomId ) override { ( Bases::renderPicker( params, geomId ), ... ); }
    size_t heapBytes() const override { return ( std::size_t{} + ... + Bases::heapBytes() ); }
    size_t glBytes() const override { return ( std::size_t{} + ... + Bases::glBytes() ); }
    void forceBindAll() override { ( Bases::forceBindAll(), ... ); }
    void renderUi( const UiRenderParams& params ) override { ( Bases::renderUi( params ), ... ); }
};
 
MR_BIND_IGNORE MRMESH_API std::unique_ptr<IRenderObject> createRenderObject( const VisualObject& visObj, const std::type_index& type );
 
template<typename ObjectType>
MR_BIND_IGNORE std::unique_ptr<IRenderObject> createRenderObject( const VisualObject& visObj )
{
    static_assert( std::is_base_of_v<VisualObject, std::remove_reference_t<ObjectType>>, "MR::VisualObject is not base of ObjectType" );
    return createRenderObject( visObj, typeid( ObjectType ) );
}
 
using IRenderObjectConstructorLambda = std::function<std::unique_ptr<IRenderObject>( const VisualObject& )>;
 
template<typename RenderObjType>
MR_BIND_IGNORE IRenderObjectConstructorLambda makeRenderObjectConstructor()
{
    return [] ( const VisualObject& visObj ) { return std::make_unique<RenderObjType>( visObj ); };
}
 
class RegisterRenderObjectConstructor
{
public:
    MRMESH_API RegisterRenderObjectConstructor( const std::type_index& type, IRenderObjectConstructorLambda lambda );
    MRMESH_API ~RegisterRenderObjectConstructor();
 
private:
    std::type_index type_;
};
 
#define MR_REGISTER_RENDER_OBJECT_IMPL(objectType, ...)\
    static MR::RegisterRenderObjectConstructor __objectRegistrator##objectType{typeid(objectType),makeRenderObjectConstructor<__VA_ARGS__>()};
 
}