gfILensComponent.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           gfILensComponent.h
*
*       Purpose:        Interface class for all screen type interactions
*                               Used as cover over normal game objects to control
*                               user input and pass it on down the line to a target
*                               entity - normally the current active sub scene, but
*                               over ridable if need be
*
*********************************************************************/
 
#ifndef gfILensComponenthdr
#define gfILensComponenthdr
 
#include <fsAppCore/src/components/fsIGestureHandlingComponent.h>
 
struct fsPoint;
 
class fsCDrag
{
public:
 
        void updatePos(fsPoint const& pPos, fsF32 pCurrentZoom, fsF32 pMinZoom);
 
        void init(const fsPoint& pDimensions, const fsPoint& pScrollWindow, const fsPoint& pDragEnable,
                  const fsPoint& pLookAt);
 
        fsPoint const& focusPointGet() const { return mFocusPoint; }
        fsBool focusPointSet(fsPoint const& pPos);
        fsBool focusPointUpdate(fsS32 pDeltaMS, fsF32 pCurrentZoom, fsS32 pMinZoom);
        void focusPointCalculate(fsPoint const& pTapPos, fsF32 pCurrentZoom);
 
        fsPoint scrollRangeCalculate(fsF32 pCurrentZoom, fsF32 pMinZoom);
 
        void enabledAxisSet(const fsPoint& pPoint) { mEnabledAxis = pPoint; }
 
        void startSet(fsPoint pStartPos);
        void endSet(fsPoint pEndPos);
        void clear();
 
        fsCDrag();
 
protected:
 
private:
 
        void moveSet(fsPoint pPos);
        fsBool draggingInertiaGet() const { return mDragVelocity.x != 0.0f || mDragVelocity.y != 0.0f; }
 
        fsPoint overScrollCalculate(fsF32 pCurrentZoom, fsF32 pMinZoom);
        void dragValuesDampen(fsS32 pOverX, fsS32 pOverY);
        void scrollSnapBack(fsPoint const& pOverScroll);
        void overDragDampen(fsPoint const& pOverScroll);
        void deltaClear();
        void dragDampen(fsPoint const& pOverScroll);
 
        fsPoint mFocusPoint;
        fsVec2d mFocusPointVelocity;
 
        fsPoint mEnabledAxis;
        fsBool mDragging;
 
        fsPoint mPrevPos;
        fsPoint mStartPos;
        fsPoint mTouchDelta;
 
        fsVec2d mDragVelocity;
 
        fsPoint mDisplayDimensions;
        fsPoint mDimensions;
        fsPoint mScrollWindow;
};
 
 
class fsCZoom
{
public:
 
        void zoomSet(fsF32 pMin, fsF32 pMax, fsF32 pCurr);
 
        fsPoint pinchZoomCentrePointGet();
 
        fsF32 minZoomGet() const { return mMinScale; }
        fsBool maxScale() const { return mMaxScale == mCurrScale; }
        fsBool scaleUpdate(fsS32 pDeltaTime);
        fsBool reset();
        void toggle();
 
        fsF32 currentScaleGet() const { return mCurrScale; }
 
        void pinchZoomClear() { mPinchZoom = 0.0f; }
 
        fsBool zoomingGet() const { return mZooming; }
        void start(const fsPoint& pStartPosPointA, const fsPoint& pStartPosPointB);
        void update(const fsPoint& pCurrPos, const fsPoint& pDelta, fsS32 pPointID);
        void end(const fsPoint& pCurrPos, const fsPoint& pDelta, fsS32 pPointID);
 
        fsCZoom();
 
protected:
private:
 
        void pinchZoomCalculate();
 
        fsBool mZooming;
 
        fsPoint mPinchPrevPosA;
        fsPoint mPinchPrevPosB;
        fsF32 mPinchZoom;
 
        fsF32 mMaxScale;
        fsF32 mMinScale;
        fsF32 mCurrScale;
};
 
 
class gfILensComponent : public fsIGestureHandlingComponent
{
public:
 
        static const fsCUniqueId mDragMessage;
 
        struct sLensMessageParam : public fsIMessageDispatcher::sMessageParameters
        {
                fsPoint mDragDelta;
        };
 
        void zoomSet(fsF32 pMin, fsF32 pMax, fsF32 pCurr);
        void zoomClear();
 
        virtual ~gfILensComponent();
 
protected:
 
        fsCEntity* const targetGet();
        virtual fsCEntity* const targetGetDo();
 
        void zoomAndScrollReset();
 
        void updateDo(fsS32 pDeltaMs) override;
 
        virtual void doOnTap(const fsPoint& pTapPos);
 
        virtual void doOnDragStart(const fsPoint& pStartPos);
        virtual void doOnDragMove(const fsPoint& pCurrPos);
        virtual void doOnDragEnd(const fsPoint& pEndPos);
 
        virtual void doOnPinchStart(const fsPoint& pStartPosPointA, const fsPoint& pStartPosPointB);
        virtual void doOnPinchMove(const fsPoint& pCurrPos, const fsPoint& pDelta, fsS32 pPointID);
        virtual void doOnPinchEnd(const fsPoint& pCurrPos, const fsPoint& pDelta, fsS32 pPointID);
 
        gfILensComponent(fsCEntity* pParent, fsBool pHandleTaps, fsBool pHandleDragEvent, fsBool pHandlePinchEvents);
 
        fsPoint mDragPos;
        fsS32 mRunningTime;
 
        std::unique_ptr<fsCDrag> mDrag;
        std::unique_ptr<fsCZoom> mZoom;
 
        fsCEntity* mInitialisedTarget = nullptr;
 
        // The active subscene's authored position is its home; the drag focus point is a
        // scroll offset applied on top of it, so an off-centre subscene keeps its placement
        // instead of being slammed to (0,0) when the lens first takes it as a target.
        fsCEntity* mHomeTarget = nullptr;
        fsVec2d mHomePos{0.0f, 0.0f};
 
private:
 
        void dragMessageBroadcast(const fsPoint& pCurrentPot);
 
        void activeSubSceneUpdate();
        fsS32 mySubsceneGroupID() const;
 
        void onTap(const fsPoint& pTapPos) override;
 
        void onDragStart(const fsPoint& pStartPos) override;
        void onDragMove(const fsPoint& pCurrPos) override;
        void onDragEnd(const fsPoint& pEndPos) override;
 
        void onPinchStart(const fsPoint& pStartPosPointA, const fsPoint& pStartPosPointB) override;
        void onPinchMove(const fsPoint& pCurrPos, const fsPoint& pDelta, fsS32 pPointID) override;
        void onPinchEnd(const fsPoint& pCurrPos, const fsPoint& pDelta, fsS32 pPointID) override;
 
        fsS32 mDoubleTapTime;
};
 
#endif