ecvDrawableObject.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
// LOCAL
#include "ecvDrawContext.h"
#include "ecvGLMatrix.h"
 
// CV_CORE_LIB
#include <CVGeom.h>
 
struct ccClipPlane {
    Tuple4Tpl<double> equation;
};
using ccClipPlaneSet = std::vector<ccClipPlane>;
 
class CV_DB_LIB_API ccDrawableObject {
public:
    ccDrawableObject();
    ccDrawableObject(const ccDrawableObject& object);
 
    virtual ~ccDrawableObject() = default;
 
public:  // drawing and drawing options
    virtual void draw(CC_DRAW_CONTEXT& context) = 0;
 
    inline virtual bool isVisible() const { return m_visible; }
    inline virtual void setVisible(bool state) { m_visible = state; }
 
    inline virtual void toggleVisibility() { setVisible(!isVisible()); }
 
    inline virtual bool isRedraw() const { return m_modelRedraw; }
    inline virtual void setRedraw(bool state) { m_modelRedraw = state; }
    inline virtual void setForceRedraw(bool state) { m_forceRedraw = state; }
 
    inline virtual void setFixedId(bool state) { m_fixedId = state; }
    inline virtual bool isFixedId() { return m_fixedId; }
 
    inline virtual bool isVisibilityLocked() const {
        return m_lockedVisibility;
    }
 
    inline virtual void lockVisibility(bool state) {
        m_lockedVisibility = state;
    }
 
    inline virtual bool isSelected() const { return m_selected; }
    inline virtual void setSelected(bool state) { m_selected = state; }
 
 
    virtual void getDrawingParameters(glDrawParams& params) const;
 
    inline virtual bool hasColors() const { return false; }
    inline virtual bool colorsShown() const { return m_colorsDisplayed; }
    inline virtual void showColors(bool state) { m_colorsDisplayed = state; }
    inline virtual void toggleColors() { showColors(!colorsShown()); }
 
    inline virtual bool hasNormals() const { return false; }
    inline virtual bool normalsShown() const { return m_normalsDisplayed; }
    inline virtual void showNormals(bool state) { m_normalsDisplayed = state; }
    inline virtual void toggleNormals() { showNormals(!normalsShown()); }
 
public:  // scalar fields
    inline virtual bool hasDisplayedScalarField() const { return false; }
 
 
    inline virtual bool hasScalarFields() const { return false; }
 
    inline virtual void showSF(bool state) {
        m_sfDisplayed = state;
        setRedraw(state);
    }
 
    inline virtual void toggleSF() { showSF(!sfShown()); }
 
    inline virtual bool sfShown() const { return m_sfDisplayed; }
 
public:  //(Mesh) materials
    virtual void toggleMaterials() {}  // does nothing by default!
 
public:  // Name display in 3D
    inline virtual void showNameIn3D(bool state) { m_showNameIn3D = state; }
 
    inline virtual bool nameShownIn3D() const { return m_showNameIn3D; }
 
    inline virtual void toggleShowName() { showNameIn3D(!nameShownIn3D()); }
 
public:  // Temporary color
 
    inline virtual bool isColorOverridden() const {
        return m_colorIsOverridden;
    }
 
    inline virtual const ecvColor::Rgb& getTempColor() const {
        return m_tempColor;
    }
 
 
    virtual void setTempColor(const ecvColor::Rgb& col,
                              bool autoActivate = true);
 
    inline virtual void enableTempColor(bool state) {
        m_colorIsOverridden = state;
    }
 
    // Get opacity
    inline virtual float getOpacity() const { return m_opacity; }
 
    inline virtual void setOpacity(float opacity) {
        m_opacity = opacity;
        setRedraw(false);
    }
 
public:  // Transformation matrix management (for display only)
 
    virtual void setGLTransformation(const ccGLMatrix& trans);
 
 
    virtual void enableGLTransformation(bool state);
 
    inline virtual bool isGLTransEnabled() const { return m_glTransEnabled; }
 
 
    inline virtual const ccGLMatrix& getGLTransformation() const {
        return m_glTrans;
    }
 
 
    virtual void resetGLTransformation();
 
 
    virtual void rotateGL(const ccGLMatrix& rotMat);
 
 
    virtual void translateGL(const CCVector3& trans);
 
public:  // clipping planes
    virtual void removeAllClipPlanes() { m_clipPlanes.resize(0); }
 
 
    virtual bool addClipPlanes(const ccClipPlane& plane);
 
 
    virtual void toggleClipPlanes(CC_DRAW_CONTEXT& context, bool enable);
 
public:  // push and pop display state
    struct DisplayState {
        DisplayState() {}
        DisplayState(const ccDrawableObject& dobj);
 
        using Shared = QSharedPointer<DisplayState>;
 
        bool visible = false;
        bool colorsDisplayed = false;
        bool normalsDisplayed = false;
        bool sfDisplayed = false;
        bool colorIsOverridden = false;
        bool showNameIn3D = false;
    };
 
    virtual bool pushDisplayState();
 
    virtual void popDisplayState(bool apply = true);
 
    virtual void applyDisplayState(const DisplayState& state);
 
protected:  // members
    bool m_fixedId;
    bool m_modelRedraw;
    bool m_forceRedraw;
    float m_opacity;
 
 
    bool m_visible;
 
    bool m_selected;
 
    bool m_lockedVisibility;
 
    bool m_colorsDisplayed;
    bool m_normalsDisplayed;
    bool m_sfDisplayed;
 
    ecvColor::Rgb m_tempColor;
    bool m_colorIsOverridden;
 
 
    ccGLMatrix m_glTrans;
 
    bool m_glTransEnabled;
 
    bool m_showNameIn3D;
    CCVector3d m_nameIn3DPos;
 
    ccClipPlaneSet m_clipPlanes;
 
    std::vector<DisplayState::Shared> m_displayStateStack;
};