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/file_util.hpp>
#include <jau/float_math.hpp>
#include <jau/float_types.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 <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>
 
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;
    
    /** \addtogroup Gamp_GraphUI
     *
     *  @{
     */
     
    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;
        
      private:
        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;
        
      public:
        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; }
                
        /**
         * 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;
        }
                
    };
 
    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;
    
    /**@}*/
 
} // namespace gamp::graph
 
#endif /* JAU_GAMP_GRAPH_UI_SHAPE_HPP_ */