Scene.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_SCENE_HPP_
#define JAU_GAMP_GRAPH_UI_SCENE_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/vec2i.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/graph/ui/Shape.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;
    
    /** @defgroup Gamp_GraphUI Gamp Graph UI
     *  Graph UI Framework
     *
     *  @{
     */
     
    class Scene {
      private:
        ShapeRef m_activeShape;
        
      public:
        Scene()
        { }
        
      private:
        /**
         * General {@link Shape} visitor
         * @param s the {@link Shape} to process
         * @param pmv the {@link PMVMatrix4f} setup from the {@link Scene} down to the {@link Shape}
         * @return the picked shape signaling end of traversal, otherwise null to continue
         */
        typedef jau::function<ShapeRef(ShapeRef& s, PMVMat4f& pmv)> PickVisitorFunc;
        
        static ShapeRef pickForAllRenderedDesc(Container& cont, PMVMat4f& pmv, const PickVisitorFunc& visitor) {
            ShapeRef picked = nullptr;
            ShapeList& shapes = cont.renderedShapes();
            // synchronized( shapes ) {  // tripple-buffering is just almost enough FIXME
                for(size_t i=shapes.size(); !picked && i-- > 0; ) {
                    ShapeRef& s = shapes[i];
                    pmv.pushMv();
                    s->applyMatToMv(pmv);
                    picked = visitor(s, pmv);
                    if( s->asContainer() ) {
                        ShapeRef childPick = pickForAllRenderedDesc(*s->asContainer(), pmv, visitor);
                        if( childPick ) {
                            picked = childPick; // child picked overrides group parent!
                        }
                    }
                    pmv.popMv();
                }
            // }
            return picked;
        }
        
        /**
         * Attempt to pick a {@link Shape} using the window coordinates and contained {@ling Shape}'s {@link AABBox} {@link Shape#getBounds() bounds}
         * using a ray-intersection algorithm in Z-axis descending order.
         * <p>
         * If {@link Shape} was found the given action is performed.
         * </p>
         * <p>
         * Method performs on current thread and returns after either a shaper is determined to be picked/active or
         * probing every {@link Shape} w/o result.
         * </p>
         * @param pmv a new {@link PMVMatrix4f} which will {@link Scene.PMVMatrixSetup#set(PMVMatrix4f, Recti) be setup},
         *            {@link Shape#applyMatToMv(PMVMatrix4f) shape-transformed} and can be reused by the caller and runnable.
         * @param ray temporary {@link Ray} storage, passed for reusage
         * @param glWinX window X coordinate, bottom-left origin
         * @param glWinY window Y coordinate, bottom-left origin
         * @param objPos storage for found object position in model-space if found {@link Shape}
         * @param runnable the action to perform if {@link Shape} was found
         * @return last picked (inner) Shape if any or null
         */
        ShapeRef pickShape(PMVMat4f& pmv, const Vec2i& winPos, Vec3f& objPos, final Shape.Visitor1 visitor) {
            setupMatrix(pmv);
    
            final float winZ0 = 0f;
            final float winZ1 = 0.3f;
            /**
                final FloatBuffer winZRB = Buffers.newDirectFloatBuffer(1);
                gl.glReadPixels( x, y, 1, 1, GL2ES2.GL_DEPTH_COMPONENT, GL.GL_FLOAT, winZRB);
                winZ1 = winZRB.get(0); // dir
            */
            final Recti viewport = getViewport();
            final int[] shapeIdx = { -1 };
            return pickForAllRenderedDesc(this, pmv, (final Shape s, final PMVMatrix4f pmv2) -> {
                shapeIdx[0]++;
                if( pmv.mapWinToRay(glWinX, glWinY, winZ0, winZ1, viewport, ray) ) {
                    final AABBox sbox = s.getBounds();
                    if( sbox.intersectsRay(ray) ) {
                        if( null == sbox.getRayIntersection(objPos, ray, FloatUtil.EPSILON, true) ) {
                            throw new InternalError("Ray "+ray+", box "+sbox);
                        }
                        if( visitor.visit(s) ) {
                            return s;
                        }
                    }
                }
                return null;
            });
        }
        /**
         * Pick the shape using the event coordinates
         * @param e original Newt {@link MouseEvent}
         * @param glWinX in GL window coordinates, origin bottom-left
         * @param glWinY in GL window coordinates, origin bottom-left
         */
        private final Shape dispatchMouseEventPickShape(final MouseEvent e, final int glWinX, final int glWinY) {
            final Shape shape = pickShape(dispMEPSPMv, dispMEPSRay, glWinX, glWinY, dispMEPSObjPos, (final Shape s) -> {
                // return s.isInteractive() && ( s.dispatchMouseEvent(e, glWinX, glWinY, dispMEPSObjPos) || true );
                if( !s.isInteractive() ) {
                    if( DEBUG_PICKING ) {
                        System.err.printf("Pick.X.0: shape %s/%s, [%d, %d]%n", s.getClass().getSimpleName(), s.getName(), glWinX, glWinY);
                    }
                    return false;
                }
                if( !s.dispatchMouseEvent(e, glWinX, glWinY, dispMEPSObjPos) ) {
                    if( DEBUG_PICKING ) {
                        System.err.printf("Pick.X.1: shape %s/%s, [%d, %d], %s%n", s.getClass().getSimpleName(), s.getName(), glWinX, glWinY, e);
                    }
                    return false;
                }
                if( DEBUG_PICKING ) {
                    System.err.printf("Pick.X.S: shape %s/%s, [%d, %d], %s%n", s.getClass().getSimpleName(), s.getName(), glWinX, glWinY, e);
                }
                return true;
               });
            if( null != shape ) {
                if( DEBUG_PICKING ) {
                    System.err.printf("Pick.X: shape %s/%s%n%n", shape.getClass().getSimpleName(), shape.getName());
                }
                setActiveShape(shape);
                return shape;
            } else {
                if( DEBUG_PICKING ) {
                    System.err.printf("Pick.X: shape null%n%n");
                }
                releaseActiveShape();
                return null;
            }
        }
        private final PMVMatrix4f dispMEPSPMv = new PMVMatrix4f();
        private final Ray dispMEPSRay = new Ray();
        private final Vec3f dispMEPSObjPos = new Vec3f();
    
        /**
         * Dispatch event to shape
         * @param shape target active shape of event
         * @param e original Newt {@link MouseEvent}
         * @param glWinX in GL window coordinates, origin bottom-left
         * @param glWinY in GL window coordinates, origin bottom-left
         */
        private final void dispatchMouseEventForShape(final Shape shape, final MouseEvent e, final int glWinX, final int glWinY) {
            final PMVMatrix4f pmv = new PMVMatrix4f();
            final Vec3f objPos = new Vec3f();
            winToShapeCoord(shape, glWinX, glWinY, pmv, objPos, () -> { shape.dispatchMouseEvent(e, glWinX, glWinY, objPos); });
            if( DEBUG_PICKING ) {
                System.err.printf("ForShape: shape %s/%s%n%n", shape.getClass().getSimpleName(), shape.getName());
            }
        }
    
        class SBCPointerListener : public PointerListener {
          private:
            Scene& scene;
            Vec2i lastPos;
            int lastId;
            bool mouseOver;
        
            void clear() {
                lastPos.x = -1; lastPos.y = -1; lastId = -1; mouseOver = false;
            }
            const ShapeRef& dispatchPickShape(const PointerEvent& e) {
                const ShapeRef s = dispatchMouseEventPickShape(e);
                if( !s ) {
                    clear();
                }
                return s;
            }
          public:
            SBCPointerListener(Scene& p): scene(p) { clear(); }
            
            void pointerPressed(PointerEvent& e) override {
                if( -1 == lastId || e.pointerId() == lastId ) {
                    lastPos = e.position();
                    lastId = e.pointerId();
                }
                // Can't use selected activeShape via mouseOver,
                // since mouseMove and mousePressed/Drag or mouseClicked may-shall select a different shape
                // based on draggable. mouseMove simply activates any shape.
                dispatchPickShape(e);
            }
    
            void pointerReleased(PointerEvent& e) override {                
                if( mouseOver && scene.m_activeShape && 
                    scene.m_activeShape.isInteractive() && 
                    // !pinchToZoomGesture.isWithinGesture() && 
                    e.pointerId() == lastId ) 
                {
                    scene.dispatchMouseEventForShape(scene.m_activeShape, e);
                } else {
                    dispatchPickShape(e);
                }
                if( !mouseOver && 1 == e.pointerCount() ) {
                    // Release active shape: last pointer has been lifted!
                    scene.releaseActiveShape();
                    clear();
                }
            }
    
            void pointerClicked(PointerEvent& e) override {
                // Can't use selected activeShape via mouseOver,
                // since mouseMove and mousePressed/Drag or mouseClicked may-shall select a different shape
                // based on draggable. mouseMove simply activates any shape.
                dispatchPickShape(e);
            }
    
            void pointerDragged(PointerEvent& e) override {
                scene.clearToolTip();
                // drag activeShape, if no gesture-activity, only on 1st pointer
                if( scene.m_activeShape && 
                    scene.m_activeShape.isInteractive() && 
                    // !pinchToZoomGesture.isWithinGesture() && 
                    e.pointerId() == lastId ) 
                {
                    lastPos = e.position();
                    scene.dispatchMouseEventForShape(scene.m_activeShape, e);
                }
            }
    
            void pointerWheelMoved(PointerEvent&) override {
                scene.clearToolTip();
                if( mouseOver && scene.m_activeShape && 
                    scene.m_activeShape.isInteractive() && 
                    // !pinchToZoomGesture.isWithinGesture() && 
                    e.pointerId() == lastId ) {
                    scene.dispatchMouseEventForShape(scene.m_activeShape, e);
                } else {
                    dispatchPickShape(e);
                }
            }
    
            void pointerMoved(PointerEvent&) override {                
                if( -1 == lastId || e.pointerId() == lastId ) {
                    lastPos = e.position();
                    lastId = e.getPointerId(0);
                }
                scene.clearToolTip();
                const ShapeRef& s = dispatchPickShape(e);
                if( s ) {
                    mouseOver = true;
                    // synchronized( toolTipActive ) {
                    // FIXME    toolTipActive.set( s.startToolTip(true /* lookupParents */) );
                    // }
                }
            }
            void pointerExited(PointerEvent&) override {
                scene.clearToolTip();
                scene.releaseActiveShape();
                clear();
            }
        };
        
        class SBCKeyListener : public KeyListener {
          private:
            Scene& m_parent;
    
          public:
            SBCKeyListener(Scene& p): m_parent(p) { }
    
            void keyPressed(KeyEvent& e, const KeyboardTracker& kt) override {
                if( m_parent.m_activeShape && m_parent.activeShape.isInteractive() ) {
                    m_parent.activeShape.dispatchKeyEvent(e, kt);
                }
            }
            void keyReleased(KeyEvent& e, const KeyboardTracker& kt) override {
                if( m_parent.m_activeShape && m_parent.activeShape.isInteractive() ) {
                    m_parent.activeShape.dispatchKeyEvent(e, kt);
                }
            }
        };
        typedef std::shared_ptr<SBCKeyListener> SBCKeyListenerRef;
        
    };
    
    /**@}*/
 
} // namespace gamp::graph
 
#endif /* JAU_GAMP_GRAPH_UI_SCENE_HPP_ */