locator.h

//##################################################################################################
//
// Copyright (c) 2024 Beijing Qiongqi Tech Co.,Ltd. All rights reserved. 
 
// This source code is confidential and proprietary to Beijing Qiongqi Tech Co.,Ltd(The Holder). 
// Any unauthorized use, copying, modification, or distribution of the code is strictly prohibited. 
// Any user shall obtain authorizaition from the Holder before modifying the source code. And the user shall not
// sublicense, sell, distribute, or transfer the source code, whether in original or modified form, to any third party
// without the prior written consent of the Holder.
 
// This copyright notice and permission grant shall be included in all copies or substantial portions of the source code.
 
// Author  Cumulia Illustrator
// Date    2024-05-01
// Version V1.0.0
//##################################################################################################
 
#pragma once
 
#include "../utils/event.h"
 
#include <cilcore.h>
 
#include <string>
#include <vector>
#include <map>
 
namespace cil
{
    class Handler;
    enum class Modifier
    {
        None = 0x0000,
        Shift = 0x0200,
        Ctrl = 0x0400,
        Alt = 0x0800,
        Meta = 0x1000
    };
    class AbstractLocator : public Node, public EventWatcher
    {
    public:
        AbstractLocator();
        virtual ~AbstractLocator();
    };
    class Locator : public AbstractLocator
    {
    public:
        static std::map<std::string, Vector3f> trans;
        static std::map<std::string, Matrix4f> rot;
 
    public:
        std::vector<std::shared_ptr<Handler>> handlers;
 
    public:
        Locator();
        virtual ~Locator();
 
        void setTransform(const Matrix4f& transform);
        virtual void update(const Handler& handler, Modifier modifier = Modifier::None);
    };
    class ArrowLocator : public Locator
    {
    public:
        ArrowLocator();
        virtual ~ArrowLocator();
    };
    class PositionLocator : public Locator
    {
    public:
        PositionLocator();
        virtual ~PositionLocator();
    };
    class OrientationLocator : public PositionLocator
    {
    public:
        OrientationLocator();
        virtual ~OrientationLocator();
    };
    class PlaneLocator : public Locator
    {
    public:
        PlaneLocator();
        virtual ~PlaneLocator();
    };
    class DiskLocator : public PlaneLocator
    {
    public:
        DiskLocator();
        virtual ~DiskLocator();
    };
    class ShapeLocator : public Locator
    {
    protected:
        std::shared_ptr<Matrix4f> m_local;
        std::vector<std::string> m_names;
 
    public:
        ShapeLocator();
        virtual ~ShapeLocator();
 
        std::shared_ptr<Matrix4f> local();
        void setLocal(const std::shared_ptr<Matrix4f>& local);
        void updateHandler();
    };
    class BoxLocator : public ShapeLocator
    {
    public:
        BoxLocator();
        virtual ~BoxLocator();
 
        virtual void update(const Handler& handler, Modifier modifier = Modifier::None);
    };
    class BottomBoxLocator : public BoxLocator
    {
    public:
        BottomBoxLocator();
        virtual ~BottomBoxLocator();
 
        virtual void update(const Handler& handler, Modifier modifier = Modifier::None);
    };
    class CylinderLocator : public ShapeLocator
    {
    public:
        CylinderLocator();
        virtual ~CylinderLocator();
 
        virtual void update(const Handler& handler, Modifier modifier = Modifier::None);
    };
    class BottomCylinderLocator : public CylinderLocator
    {
    public:
        BottomCylinderLocator();
        virtual ~BottomCylinderLocator();
 
        virtual void update(const Handler& handler, Modifier modifier = Modifier::None);
    };
    class SphereLocator : public ShapeLocator
    {
    public:
        SphereLocator();
        virtual ~SphereLocator();
 
        virtual void update(const Handler& handler, Modifier modifier = Modifier::None);
    };
 
    std::shared_ptr<ArrowLocator> _arrowLocator();
    std::shared_ptr<PositionLocator> _positionLocator();
    std::shared_ptr<OrientationLocator> _orientationLocator();
    std::shared_ptr<PlaneLocator> _planeLocator();
    std::shared_ptr<DiskLocator> _diskLocator();
    std::shared_ptr<BoxLocator> _boxLocator();
    std::shared_ptr<BottomBoxLocator> _bottomBoxLocator();
    std::shared_ptr<CylinderLocator> _cylinderLocator();
    std::shared_ptr<BottomCylinderLocator> _bottomCylinderLocator();
    std::shared_ptr<SphereLocator> _sphereLocator();
}