Shape.hpp

Go to the documentation of this file.

/*
 * Author: Sven Gothel <sgothel@jausoft.com> (C++, Java) and Rami Santina (Java)
 * Copyright Gothel Software e.K. and the authors
 *
 * SPDX-License-Identifier: MIT
 *
 * This Source Code Form is subject to the terms of the MIT License
 * If a copy of the MIT was not distributed with this file,
 * you can obtain one at https://opensource.org/license/mit/.
 */
#ifndef JAU_GAMP_GRAPH_UI_SHAPE_HPP_
#define JAU_GAMP_GRAPH_UI_SHAPE_HPP_
 
#include <jau/basic_types.hpp>
#include <jau/darray.hpp>
#include <jau/float_math.hpp>
#include <jau/float_types.hpp>
#include <jau/int_types.hpp>
#include <jau/enum_util.hpp>
#include <jau/fraction_type.hpp>
#include <jau/math/geom/aabbox3f.hpp>
#include <jau/math/geom/geom3f.hpp>
#include <jau/math/vec3f.hpp>
#include <jau/math/vec4f.hpp>
#include <jau/math/vec4f.hpp>
#include <jau/math/quaternion.hpp>
#include <jau/ordered_atomic.hpp>
 
#include <gamp/render/gl/GLTypes.hpp>
#include <gamp/GampTypes.hpp>
#include <gamp/Gamp.hpp>
#include <gamp/graph/OutlineShape.hpp>
#include <gamp/graph/ui/Container.hpp>
#include <gamp/render/RenderContext.hpp>
#include <gamp/wt/event/PointerEvent.hpp>
#include <mutex>
 
namespace gamp::graph::ui {
 
    using namespace jau::math;
    using namespace jau::math::util;
    using namespace jau::math::geom;
    
    using namespace gamp::wt;
    using namespace gamp::wt::event;
    
    using namespace gamp::graph;
    
    using namespace jau::int_literals;
    
    using namespace jau::enums;
    
    /** \addtogroup Gamp_GraphUI
     *
     *  @{
     */
     
    namespace impl {        
        enum class IOState : uint32_t {
            none               = 0,
            visible            = 1_u32 << 0,
            interactive        = 1_u32 << 1,
            activable          = 1_u32 << 2,
            toggleable         = 1_u32 << 3,
            draggable          = 1_u32 << 4,
            resizable          = 1_u32 << 5,
            resize_fixed_ratio = 1_u32 << 6,
            active             = 1_u32 << 7,
            discarded          = 1_u32 << 25,
            down               = 1_u32 << 26,
            toggle             = 1_u32 << 27,
            drag_first         = 1_u32 << 28,
            in_move            = 1_u32 << 29,
            in_resize_br       = 1_u32 << 30,
            in_resize_bl       = 1_u32 << 31
        };        
        JAU_MAKE_BITFIELD_ENUM_STRING(IOState, visible, interactive, activable, toggleable, draggable,
                                               resizable, resize_fixed_ratio, active, discarded,
                                               down, toggle, drag_first, in_move, in_resize_br, in_resize_bl);        
    }
    
    class Shape {
      public:
        /**
         * Visitor1 method
         * @param s the {@link Shape} to process
         * @return true to signal operation complete and to stop traversal, otherwise false
         */
        typedef jau::function<bool(ShapeRef& s)> Visitor1Func;
    
        /**
         * Visitor2 method
         * @param s the {@link Shape} to process
         * @param pmv the {@link PMVMatrix4f} setup from the {@link Scene} down to the {@link Shape}
         * @return true to signal operation complete and to stop traversal, otherwise false
         */
        typedef jau::function<bool(ShapeRef& s, PMVMat4f& pmv)> Visitor2Func;
    
        /**
         * {@link Shape} move listener
         * @param s the moved shape
         * @param origin original position, relative object coordinates to the associated {@link Shape}
         * @param dest new position, relative object coordinates to the associated {@link Shape}
         * @param e original Newt {@link MouseEvent}
         */
        typedef jau::function<void(ShapeRef& s, const Vec3f& origin, const Vec3f& dest, const PointerEvent& e)> MoveEventCallback;
    
        /**
         * {@link Shape} pointer listener, e.g. for {@link Shape#onClicked(PointerListener)}
         * @param s the associated {@link Shape} for this event
         * @param pos relative object coordinates to the associated {@link Shape}
         * @param e original Newt {@link MouseEvent}
         */
        typedef jau::function<void(ShapeRef& s, const Vec3f& pos, const PointerEvent& e)> PointerEventCallback;
    
        /**
         * General {@link Shape} listener action
         */
        typedef jau::function<void(ShapeRef& s)> ShapeEventCallback;
        
        /**
         * {@link Shape} draw listener action returning a boolean value
         * <p>
         * If {@link #run(Shape, GL2ES2, RegionRenderer)} returns {@code true},
         * the listener will be removed at {@link Shape#draw(GL2ES2, RegionRenderer)}
         * otherwise kept calling.
         * </p>
         *
         * Return {@code true} to remove this {@link DrawListener} at {@link Shape#draw(GL2ES2, RegionRenderer)},
         * otherwise it is being kept and called.
         * @param shape The shape
         * @param gl the current {@link GL2ES2} object
         * @param renderer the {@link RegionRenderer}
         */
        // FIXME typedef jau::function<void(ShapeRef& s, RenderContext& rc, GraphRenderer& renderer)> DrawEventCallback;
        
        constexpr static const uint32_t DIRTY_SHAPE    = 1_u32 << 0 ;
        constexpr static const uint32_t DIRTY_STATE    = 1_u32 << 1 ;
        
      protected:        
        jau::math::geom::AABBox3f box;
        
        /** Default base-color w/o color channel, will be modulated w/ pressed- and toggle color */
        constexpr static Vec4f rgbaColor             = Vec4f(0.60f, 0.60f, 0.60f, 1.0f);
        /** Default pressed color-factor (darker and slightly transparent), modulates base-color. ~0.65 (due to alpha) */
        constexpr static Vec4f pressedRGBAModulate   = Vec4f(0.70f, 0.70f, 0.70f, 0.8f);
        /** Default toggle color-factor (darker), modulates base-color.  0.60 * 0.83 ~= 0.50 */
        constexpr static Vec4f toggleOnRGBAModulate  = Vec4f(0.83f, 0.83f, 0.83f, 1.0f);
        /** Default toggle color-factor (original), modulates base-color.  0.60 * 1.00 ~= 0.60 */
        constexpr static Vec4f toggleOffRGBAModulate = Vec4f(1.00f, 1.00f, 1.00f, 1.0f);
        /** Default active color-factor (dark), modulates base-color.  0.60 * 0.25 ~= 0.15 */
        constexpr static Vec4f activeRGBAModulate = Vec4f(0.25f, 0.25f, 0.25f, 1.0f);
        constexpr static Vec4f cWhite = Vec4f(1, 1, 1, 1);
        
        bool activeRGBAModulateOn = false;
            
      private:
        // volatile Group parent = null;
      
        OutlineShape m_outlines;
        
        Vec3f m_position;
        Quat4f m_rotation;
        Vec3f m_rotPivot;
        Vec3f m_scale = Vec3f(1, 1, 1);
        float m_zOffset;
        Vec4f m_color = Vec4f(0, 0, 0, 1);
        
        Mat4f iMat;
        Mat4f tmpMat;
        bool iMatIdent = true;
        bool iMatDirty = false;
                
        jau::relaxed_atomic_uint32 dirty = DIRTY_SHAPE | DIRTY_STATE;
        std::mutex dirtySync;
        
        Vec4f m_rgba_tmp = Vec4f(0, 0, 0, 1);
        
        impl::IOState m_ioState = impl::IOState::draggable | impl::IOState::resizable | impl::IOState::interactive | 
                                  impl::IOState::activable | impl::IOState::visible;
            
        jau::cow_darray<KeyListenerRef> m_keyListener;
        jau::cow_darray<PointerListenerRef> m_pointerListener;
 
      protected:
        //
        //
        //
    
        virtual void validateImpl(const render::gl::GL& gl, const render::gl::GLProfile& glp) noexcept;
    
        /**
         * Actual draw implementation, called by {@link #draw(GL2ES2, RegionRenderer)}
         * @param gl
         * @param renderer
         * @param rgba
         */
        virtual void drawImpl0(const render::gl::GL& gl, RegionRenderer& renderer, const Vec4f& rgba) noexcept;
    
        /**
         * Actual draw implementation, called by {@link #drawToSelect(GL2ES2, RegionRenderer)}
         * @param gl
         * @param renderer
         */
        virtual void drawToSelectImpl0(const render::gl::GL& gl, RegionRenderer& renderer);
    
        /** Custom {@link #clear(GL2ES2, RegionRenderer)} task, called 1st. */
        virtual void clearImpl0(const render::gl::GL& gl, RegionRenderer& renderer);
    
        /** Custom {@link #destroy(GL2ES2, RegionRenderer)} task, called 1st. */
        virtual void destroyImpl0(const render::gl::GL& gl, RegionRenderer& renderer);
    
      public:
        /**
         * Returns true if implementation uses an extra color channel or texture
         * which will be modulated with the passed rgba color {@link #drawImpl0(GL2ES2, RegionRenderer, float[])}.
         *
         * Otherwise the base color will be modulated and passed to {@link #drawImpl0(GL2ES2, RegionRenderer, float[])}.
         */
        virtual bool hasColorChannel() const noexcept;
                      
        Shape()
        : m_outlines() 
        { }
        
        virtual Container* asContainer() const noexcept { return nullptr; }
        
        constexpr const Vec3f& position() const noexcept { return m_position; }
        constexpr Vec3f& position() noexcept { iMatDirty=true; return m_position; }
        
        constexpr const float& zOffset() const noexcept { return m_zOffset; }
        constexpr float& zOffset() noexcept { iMatDirty=true; return m_zOffset; }
        
        constexpr const Quat4f& rotation() const noexcept { return m_rotation; }
        constexpr Quat4f& rotation() noexcept { iMatDirty=true; return m_rotation; }
        
        constexpr const Vec3f& rotationPivot() const noexcept { return m_rotPivot; }
        constexpr Vec3f& rotationPivot() noexcept { iMatDirty=true; return m_rotPivot; }
        
        constexpr const Vec3f& scale() const noexcept { return m_scale; }
        constexpr Vec3f& scale() noexcept { iMatDirty=true; return m_scale; }
            
        constexpr const OutlineShape& outlines() const noexcept { return m_outlines; }
        constexpr OutlineShape& outlines() noexcept { return m_outlines; }
                
        constexpr const Vec4f& color() const noexcept { return m_color; }
        constexpr void setColor(const Vec4f& c) noexcept { m_color=c; }
         
        //
        // Input
        //
    
        Shape& setPressed(bool b) noexcept {
            write(m_ioState, impl::IOState::down, b);
            markStateDirty();
            return *this;
        }
        bool isPressed() const noexcept { return is_set(m_ioState, impl::IOState::down); }
    
        /**
         * Set this shape toggleable, default is off.
         * @param toggleable
         * @see #isInteractive()
         */
        Shape& setToggleable(bool toggleable) noexcept { 
            write(m_ioState, impl::IOState::toggleable, toggleable); 
            return *this; 
        }
    
        /**
         * Returns true if this shape is toggable,
         * i.e. rendered w/ {@link #setToggleOnColorMod(float, float, float, float)} or {@link #setToggleOffColorMod(float, float, float, float)}.
         * @see #isInteractive()
         */
        bool isToggleable() const noexcept { return is_set(m_ioState, impl::IOState::toggleable); }
        
        /**
         * Renders the shape.
         * <p>
         * {@link #applyMatToMv(PMVMatrix4f)} is expected to be completed beforehand.
         * </p>
         * @param gl the current GL object
         * @param renderer {@link RegionRenderer} which might be used for Graph Curve Rendering, also source of {@link RegionRenderer#getMatrix()} and {@link RegionRenderer#getViewport()}.
         */
        void draw(render::gl::GL& gl, RegionRenderer& renderer) noexcept {
            const bool _isPressed = isPressed(), _isToggleOn = isToggleOn();
            final Vec4f rgba;
            if( hasColorChannel() ) {
                if( isPressed ) {
                    rgba = pressedRGBAModulate;
                } else if( isToggleable() ) {
                    if( isToggleOn ) {
                        rgba = toggleOnRGBAModulate;
                    } else {
                        rgba = toggleOffRGBAModulate;
                    }
                } else if( activeRGBAModulateOn && isActive() ) {
                    rgba = activeRGBAModulate;
                } else {
                    rgba = cWhite;
                }
            } else {
                rgba = rgba_tmp;
                if( isPressed ) {
                    rgba.mul(rgbaColor, pressedRGBAModulate);
                } else if( isToggleable() ) {
                    if( isToggleOn ) {
                        rgba.mul(rgbaColor, toggleOnRGBAModulate);
                    } else {
                        rgba.mul(rgbaColor, toggleOffRGBAModulate);
                    }
                } else if( activeRGBAModulateOn && isActive() ) {
                    rgba.mul(rgbaColor, activeRGBAModulate);
                } else {
                    rgba.set(rgbaColor);
                }
            }
            synchronized ( dirtySync ) {
                validate(gl);
                drawImpl0(gl, renderer, rgba);
            }
            if( null != onDrawListener ) {
                if( onDrawListener.run(this, gl, renderer) ) {
                    onDrawListener = null;
                }
            }
        }
    
        /**
         * Validates the shape's underlying {@link GLRegion}.
         * <p>
         * If the region is dirty, it gets {@link GLRegion#clear(GL2ES2) cleared} and is reused.
         * </p>
         * @param gl current {@link GL2ES2} object
         * @see #validate(GLProfile)
         */
        public final Shape validate(final GL2ES2 gl) {
            synchronized ( dirtySync ) {
                if( isShapeDirty() ) {
                    box.reset();
                }
                validateImpl(gl, gl.getGLProfile());
                dirty.set(0);
            }
            return this;
        }
    
        /**
         * Validates the shape's underlying {@link GLRegion} w/o a current {@link GL2ES2} object
         * <p>
         * If the region is dirty a new region is created
         * and the old one gets pushed to a dirty-list to get disposed when a GL context is available.
         * </p>
         * @see #validate(GL2ES2)
         */
        public final Shape validate(final GLProfile glp) {
            synchronized ( dirtySync ) {
                if( isShapeDirty() ) {
                    box.reset();
                }
                validateImpl(null, glp);
                dirty.set(0);
            }
            return this;
        }
    
        /**
         * Validate the shape via {@link #validate(GL2ES2)} if {@code gl} is not null,
         * otherwise uses {@link #validate(GLProfile)}.
         * @see #validate(GL2ES2)
         * @see #validate(GLProfile)
         */
        public final Shape validate(final GL2ES2 gl, final GLProfile glp) {
            if( null != gl ) {
                return validate(gl);
            } else {
                return validate(glp);
            }
        }
                
        /**
         * Applies the internal {@link Matrix4f} to the given {@link PMVMatrix4f#getMv() modelview matrix},
         * i.e. {@code pmv.mulMv( getMat() )}.
         * <p>
         * Calls {@link #updateMat()} if dirty.
         * </p>
         * In case {@link #isMatIdentity()} is {@code true}, implementation is a no-operation.
         * </p>
         * @param pmv the matrix
         * @see #isMatIdentity()
         * @see #updateMat()
         * @see #getMat()
         * @see PMVMatrix4f#mulMv(Matrix4f)
         */
        void applyMatToMv(PMVMat4f& pmvMat) noexcept {
            if( iMatDirty ) {
                updateMat();
            }
            if( !iMatIdent ) {
                pmvMat.mulMv(iMat);
            }
        }
        
      private:    
        void updateMat() noexcept {
            bool hasPos = !m_position.is_zero();
            bool hasScale = m_scale != Vec3f::one;
            bool hasRotate = !m_rotation.isIdentity();
            bool hasRotPivot = false; // null != rotPivot;
            const Vec3f& ctr = m_outlines.bounds().center();
            bool sameScaleRotatePivot = hasScale && hasRotate && ( !hasRotPivot || m_rotPivot == ctr );
    
            if( sameScaleRotatePivot ) {
                iMatIdent = false;
                iMat.setToTranslation(m_position); // identity + translate, scaled
                // Scale shape from its center position and rotate around its center
                iMat.translate(Vec3f(ctr).mul(m_scale)); // add-back center, scaled
                iMat.rotate(m_rotation);
                iMat.scale(m_scale);
                iMat.translate(-ctr); // move to center
            } else if( hasRotate || hasScale ) {
                iMatIdent = false;
                iMat.setToTranslation(m_position); // identity + translate, scaled
                if( hasRotate ) {
                    if( hasRotPivot ) {
                        // Rotate shape around its scaled pivot
                        iMat.translate(Vec3f(m_rotPivot).mul(m_scale)); // pivot back from rot-pivot, scaled
                        iMat.rotate(m_rotation);
                        iMat.translate(Vec3f(-m_rotPivot).mul(m_scale)); // pivot to rot-pivot, scaled
                    } else {
                        // Rotate shape around its scaled center
                        iMat.translate(Vec3f(ctr).mul(m_scale)); // pivot back from center-pivot, scaled
                        iMat.rotate(m_rotation);
                        iMat.translate(Vec3f(-ctr).mul(m_scale)); // pivot to center-pivot, scaled
                    }
                }
                if( hasScale ) {
                    // Scale shape from its center position
                    iMat.translate(Vec3f(ctr).mul(m_scale)); // add-back center, scaled
                    iMat.scale(m_scale);
                    iMat.translate(Vec3f(-ctr).mul(m_scale)); // move to center
                }
            } else if( hasPos ) {
                iMatIdent = false;
                iMat.setToTranslation(m_position); // identity + translate, scaled
    
            } else {
                iMatIdent = true;
                iMat.loadIdentity();
            }
            iMatDirty = false;
        }
                
    };
 
#if 0
    class ShapeMyPointerListener : public PointerListener {
      private:
        GearsES2&        m_parent;
        jau::math::Vec2i preWinPos;
        jau::math::Vec3f startPos;
        GearsObjectES2* m_picked = nullptr;
        bool m_dragInit = true;
 
        bool mapWinToObj(const GearsObjectES2& shape, const jau::math::Vec2i& winPos, jau::math::Vec3f& viewPos) noexcept {
            // OK global: m_parent.m_pmvMatrix, m_parent.m_viewport
            const jau::math::Vec3f& ctr = shape.objBounds().center();
            if( m_parent.pmvMatrix().mapObjToWin(ctr, m_parent.viewport(), viewPos) ) {
                const float winZ = viewPos.z;
                return m_parent.pmvMatrix().mapWinToObj((float)winPos.x, (float)winPos.y, winZ, m_parent.viewport(), viewPos);
            }
            return false;
        }
        bool mapWinToObjRay(const jau::math::Vec2i& pos, jau::math::Ray3f& ray, const Mat4f& mPmvi) noexcept {
            // OK global: m_parent.m_pmvMatrix, m_parent.m_viewport
            constexpr float winZ0 = 0.0f;
            constexpr float winZ1 = 0.3f;
            return Mat4f::mapWinToAnyRay((float)pos.x, (float)pos.y, winZ0, winZ1, mPmvi, m_parent.viewport(), ray);
        }
 
        bool pick(const PointerEvent& e, const WindowRef&, GearsObjectES2& shape) noexcept {
            // While being processed fast w/o matrix traversal of shapes,
            // we still need to use the cached PMvi matrix for win->obj ray for accuracy.
            // A win->view ray fails in certain angles in edge cases!
            jau::math::Vec3f objPos;
            jau::math::Ray3f objRay;
            const jau::math::Vec2i& winPos = e.position();
            if( !mapWinToObjRay(winPos, objRay, shape.matPMvi()) ) {
                return false;
            }
            const jau::math::geom::AABBox3f& objBox = shape.objBounds();
 
            if( !objBox.intersectsRay(objRay) ) {
                return false;
            }
            if( !objBox.getRayIntersection(objPos, objRay, std::numeric_limits<float>::epsilon(), /*assumeIntersection=*/true) ) {
                printf("obj  getRayIntersection failed\n");
                return false;
            }
            preWinPos = winPos;
            printf("XXX pick: mouse %s -> %s\n", winPos.toString().c_str(), objPos.toString().c_str());
            printf("XXX pick: %s\n", shape.toString().c_str());
            return true;
        }
 
        bool navigate(const PointerEvent& e, const WindowRef& win, GearsObjectES2& shape) noexcept {
            jau::math::Vec3f objPos;
            const jau::math::Vec2i& winPos = e.position();
            if( !mapWinToObj(shape, winPos, objPos) ) {
                return false;
            }
            if( e.isControlDown() ) {
                if( m_dragInit ) {
                    m_dragInit = false;
                    startPos = objPos;
                } else {
                    jau::math::Vec3f flip = jau::math::util::getEulerAngleOrientation(m_parent.rotEuler());
                    jau::math::Vec3f diffPos = ( objPos - startPos ).mul(flip);
                    m_parent.pan() += diffPos;
                }
            } else {
                const jau::math::Vec2i& sdim    = win->surfaceSize();
                const float thetaY  = 360.0f * ((float)(winPos.x - preWinPos.x) / (float)sdim.x);
                const float thetaX  = 360.0f * ((float)(preWinPos.y - winPos.y) / (float)sdim.y);
                m_parent.rotEuler().x += jau::adeg_to_rad(thetaX);
                m_parent.rotEuler().y += jau::adeg_to_rad(thetaY);
                m_dragInit = true;
            }
            preWinPos = winPos;
            // printf("XXX navi: mouse %s -> %s\n", winPos.toString().c_str(), objPos.toString().c_str());
            return true;
        }
 
        PointerShapeAction pickAction, navigateAction;
 
      public:
        MyPointerListener(GearsES2& p): m_parent(p) {
            pickAction = jau::bind_member(this, &MyPointerListener::pick);
            navigateAction = jau::bind_member(this, &MyPointerListener::navigate);
        }
        void pointerPressed(PointerEvent& e) override {
            if( e.pointerCount() == 1 ) {
                WindowRef win = e.source().lock();
                if( !win ) {
                    return;
                }
                GearsObjectES2* new_pick = m_parent.findPick(pickAction, e, win); // no matrix traversal
                if( m_picked ) {
                    m_picked->picked() = false;
                }
                m_picked = new_pick;
                if( m_picked ) {
                    m_picked->picked() = true;
                }
            }
        }
        void pointerDragged(PointerEvent& e) override {
            if( m_picked ) {
                WindowRef win = e.source().lock();
                if( !win ) {
                    return;
                }
                if( !m_parent.dispatchForShape(*m_picked, navigateAction, e, win) ) { // matrix traversal
                    if( m_picked ) {
                        m_picked->picked() = false;
                    }
                    m_picked = nullptr;
                    printf("XXX shape: lost\n");
                }
            }
        }
        void pointerWheelMoved(PointerEvent& e) override {
            const jau::math::Vec3f& rot = e.rotation();
            if( e.isControlDown() ) {
                // alternative zoom
                float incr       = e.isShiftDown() ? rot.x : rot.y * 0.5f;
                m_parent.pan().z += incr;
            } else {
                // panning
                m_parent.pan().x -= rot.x;  // positive -> left
                m_parent.pan().y += rot.y;  // positive -> up
            }
        }
        void pointerReleased(PointerEvent&) override {
            if( m_picked ) {
                m_picked->picked() = false;
                printf("XXX shape: released\n");
            }
            m_picked = nullptr;
            m_dragInit = true;
        }
    };
    typedef std::shared_ptr<MyPointerListener> MyPointerListenerRef;
    
#endif
    
    /**@}*/
 
} // namespace gamp::graph
 
#endif /* JAU_GAMP_GRAPH_UI_SHAPE_HPP_ */