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_DAG_SHAPE_HPP_
#define JAU_GAMP_DAG_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/GLContext.hpp>
#include <gamp/render/gl/GLTypes.hpp>
#include <gamp/GampTypes.hpp>
#include <gamp/Gamp.hpp>
#include <gamp/wt/event/PointerEvent.hpp>
#include <mutex>
#include <vector>
 
namespace gamp::dag {
 
    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 jau::int_literals;
 
    using namespace jau::enums;
 
    /** \addtogroup Gamp_DAG
     *
     *  @{
     */
 
    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;
    typedef std::shared_ptr<Shape> ShapeRef;
    typedef std::vector<ShapeRef> ShapeList;
 
    class RenderState {
    };
 
    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(Shape& 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(Shape& 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(Shape& 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(Shape& s, const Vec3f& pos, const PointerEvent& e)> PointerEventCallback;
 
        /**
         * General {@link Shape} listener action
         */
        typedef jau::function<void(Shape& s)> ShapeEventCallback;
 
        /**
         * {@link Shape} draw listener action returning a boolean value
         * <p>
         * If {@link #run(Shape, GL2ES2, RenderState)} returns {@code true},
         * the listener will be removed at {@link Shape#draw(GL2ES2, RenderState)}
         * otherwise kept calling.
         * </p>
         *
         * Return {@code true} to remove this {@link DrawListener} at {@link Shape#draw(GL2ES2, RenderState)},
         * otherwise it is being kept and called.
         * @param shape The shape
         * @param gl the current {@link GL2ES2} object
         * @param rs the {@link RenderState}
         */
        typedef jau::function<bool(Shape& s, render::gl::GL& gl, RenderState& rs)> DrawCallback;
 
        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 m_box;
 
      private:
        // volatile Group parent = null;
 
        Vec3f m_position;
        Quat4f m_rotation;
        Vec3f m_rotPivot;
        Vec3f m_scale = Vec3f(1, 1, 1);
        float m_zOffset;
 
        Mat4f m_iMat;
        Mat4f m_tmpMat;
        bool m_iMatIdent = true;
        bool m_iMatDirty = false;
 
        jau::relaxed_atomic_uint32 m_dirty = DIRTY_SHAPE | DIRTY_STATE;
        std::recursive_mutex m_dirtySync;
 
        impl::IOState m_ioState = impl::IOState::draggable | impl::IOState::resizable | impl::IOState::interactive |
                                  impl::IOState::activable | impl::IOState::visible;
 
        std::vector<KeyListenerRef> m_keyListener;
        std::vector<PointerListenerRef> m_pointerListener;
 
        DrawCallback m_onDrawCallback;
 
      protected:
        //
        //
        //
 
        virtual void validateImpl(render::gl::GL& gl) noexcept;
        virtual void validateImpl(const render::gl::GLProfile& glp) noexcept;
 
        /**
         * Actual draw implementation, called by {@link #draw(GL2ES2, RenderState)}
         * @param gl
         * @param rs
         * @param rgba
         */
        virtual void drawImpl0(render::gl::GL& gl, RenderState& rs) noexcept;
 
        /** Custom {@link #clear(GL2ES2, RenderState)} task, called 1st. */
        virtual void clearImpl0(render::gl::GL& gl, RenderState& rs);
 
        /** Custom {@link #destroy(GL2ES2, RenderState)} task, called 1st. */
        virtual void destroyImpl0(render::gl::GL& gl, RenderState& rs);
 
      public:
        Shape() = default;
 
        /**
         * Set a user one-shot initializer callback or custom {@link #draw(GL2ES2, RegionRenderer)} hook.
         * <p>
         * {@link #run(Shape, GL2ES2, RegionRenderer)} is called at {@link Shape#draw(GL2ES2, RegionRenderer)}
         * and if returning {@code true}, the listener will be removed.
         * Otherwise kept calling.
         * </p>
         * <p>
         * This instrument allows the user either to be signaled when initialization
         * of this {@link Shape} is completed, or just too hook-up custom {@link #draw(GL2ES2, RegionRenderer)}
         * actions.
         * </p>
         * @param l callback, which shall return true to be removed, i.e. user initialization is done.
         */
        void onDrawOneShot(DrawCallback l) { m_onDrawCallback = std::move(l); }
 
        /**
         * Returns true if implementation uses an extra color channel or texture
         * which will be modulated with the passed rgba color {@link #drawImpl0(GL2ES2, RenderState, float[])}.
         *
         * Otherwise the base color will be modulated and passed to {@link #drawImpl0(GL2ES2, RenderState, float[])}.
         */
        virtual bool hasColorChannel() const noexcept;
 
        constexpr const Vec3f& position() const noexcept { return m_position; }
        constexpr Vec3f& position() noexcept { m_iMatDirty=true; return m_position; }
 
        constexpr const float& zOffset() const noexcept { return m_zOffset; }
        constexpr float& zOffset() noexcept { m_iMatDirty=true; return m_zOffset; }
 
        constexpr const Quat4f& rotation() const noexcept { return m_rotation; }
        constexpr Quat4f& rotation() noexcept { m_iMatDirty=true; return m_rotation; }
 
        constexpr const Vec3f& rotationPivot() const noexcept { return m_rotPivot; }
        constexpr Vec3f& rotationPivot() noexcept { m_iMatDirty=true; return m_rotPivot; }
 
        constexpr const Vec3f& scale() const noexcept { return m_scale; }
        constexpr Vec3f& scale() noexcept { m_iMatDirty=true; return m_scale; }
 
        /**
         * Marks the shape dirty, causing next {@link #draw(GL2ES2, RegionRenderer) draw()}
         * to recreate the Graph shape and reset the region.
         */
        void markShapeDirty() noexcept {
            m_dirty.fetch_or(DIRTY_SHAPE);
        }
 
        /**
         * Marks the rendering state dirty, causing next {@link #draw(GL2ES2, RegionRenderer) draw()}
         * to notify the Graph region to reselect shader and repaint potentially used FBOs.
         */
        void markStateDirty() noexcept {
            m_dirty.fetch_or(DIRTY_STATE);
        }
 
      protected:
 
        /** Returns the shape's dirty state, see {@link #markShapeDirty()}. */
        bool isShapeDirty() const noexcept {
            return 0 != ( m_dirty & DIRTY_SHAPE ) ;
        }
        /** Returns the rendering dirty state, see {@link #markStateDirty()}. */
        bool isStateDirty() const noexcept {
            return 0 != ( m_dirty & DIRTY_STATE ) ;
        }
 
        std::string_view getDirtyString() const noexcept {
            if( isShapeDirty() && isShapeDirty() ) {
                return "dirty[shape, state]";
            } else if( isShapeDirty() ) {
                return "dirty[shape]";
            } else if( isStateDirty() ) {
                return "dirty[state]";
            } else {
                return "clean";
            }
        }
 
      public:
        //
        // 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 RenderState} which might be used for Graph Curve Rendering, also source of {@link RenderState#getMatrix()} and {@link RenderState#getViewport()}.
         */
        void draw(render::gl::GL& gl, RenderState& rs) noexcept {
            {
                const std::lock_guard<std::recursive_mutex> lock(m_dirtySync);
                validate(gl);
                drawImpl0(gl, rs);
            }
            if( m_onDrawCallback) {
                if( m_onDrawCallback(*this, gl, rs) ) {
                    m_onDrawCallback = nullptr;
                }
            }
        }
 
        /**
         * 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)
         */
        Shape& validate(render::gl::GL& gl) noexcept {
            {
                const std::lock_guard<std::recursive_mutex> lock(m_dirtySync);
                if( isShapeDirty() ) {
                    m_box.reset();
                }
                validateImpl(gl);
                m_dirty = 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)
         */
        Shape& validate(render::gl::GLProfile& glp) {
            {
                const std::lock_guard<std::recursive_mutex> lock(m_dirtySync);
                if( isShapeDirty() ) {
                    m_box.reset();
                }
                validateImpl(glp);
                m_dirty = 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_ */