viewcube.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    2025-08-05
// Version V1.1.0
//##################################################################################################
 
#pragma once
 
#include <cilcore.h>
#include <cilselector.h>
 
#include <functional>
#include <string>
 
namespace cil
{
    class Block
    {
    public:
        Box3f box;
        Vector3f dir;
    };
 
    /*enum class ViewCubeType
    {
        None,
        Full,
        Mini,
        Corner
    };*/
 
    class ViewCube : public Pass
    {
    public:
        ViewCube(const std::shared_ptr<Renderer>& renderer, const std::shared_ptr<Image2D>& image,
            const std::shared_ptr<Vector2i>& coordinate, const std::shared_ptr<Vector2i>& backgroundSize, const std::shared_ptr<Vector2i>& windowSize);
        virtual ~ViewCube();
 
        int hilited() const;
        void setHilited(int hilited);
        void align(const std::shared_ptr<Camera>& camera, const std::shared_ptr<BoundingBox>& boundingBox, bool animate = false);
        int hit(int x, int y);
        void sync(const std::shared_ptr<Camera>& camera);
        void bind(const std::string& name, std::function<void()> callback);
        void unbind(const std::string& name);
        void send(const std::string& name);
 
        void setImage(const std::shared_ptr<Image2D>& image);
        std::shared_ptr<Image2D> image() const;
        void setBackgroundColor(const Color3f& color);
        Color3f backgroundColor() const;
        void setTextColor(const Color3f& color);
        Color3f textColor() const;
        void setHilitedColor(const Color3f& color);
        Color3f hilitedColor() const;
        void setBorderColor(const Color3f& color);
        Color3f borderColor() const;
        void setHilitedBorderColor(const Color3f& color);
        Color3f hilitedBorderColor() const;
 
        // setLocation
        // updatelocation
 
    private:
        std::shared_ptr<Node> buildCube();
        std::shared_ptr<Node> buildEdge();
        std::shared_ptr<Node> buildAxis();
        std::shared_ptr<Node> buildHilite();
        std::shared_ptr<Primitive> buildFace(const Vector3f& p0, const Vector3f& p1, const Vector3f& p2, const Vector3f& p3, const std::string& text, float texCoordOffset);
        std::shared_ptr<Material> buildFaceMaterial();
        void onTimeout();
        Vector3f slerp(const Vector3f& start, const Vector3f& end, float t);
        Quaternion slerp(const Quaternion& start, const Quaternion& end, float t);
 
    protected:
        std::shared_ptr<Node> m_hilite;
        std::shared_ptr<std::vector<std::shared_ptr<Block>>> m_blocks;
        int m_hilited;
        int m_unhilited;
        std::shared_ptr<Geometry> m_blockCube;
        std::shared_ptr<Material> m_faceMaterial;
        std::shared_ptr<FaceSelector<Block>> m_selector;
        std::shared_ptr<Image2D> m_image;
 
    private:
        std::shared_ptr<Renderer> m_renderer;
        std::shared_ptr<Color3f> m_backgroundColor;
        std::shared_ptr<Color3f> m_borderColor;
        std::shared_ptr<Color3f> m_textColor;
        std::shared_ptr<Color3f> m_hilitedBorderColor;
        std::shared_ptr<Color3f> m_hilitedColor;
        std::function<void()> m_onHilited;
        std::function<void()> m_onUpdated;
        std::function<void()> m_onAnimationStarted;
        std::function<void()> m_onAnimationEnded;
        std::shared_ptr<Timer> m_timer;
        int m_duration;
        int m_elapsedTime;
        std::shared_ptr<Camera> m_camera;
        Matrix4f m_viewMatrix;
        Vector3f m_startTrans;
        Vector3f m_endTrans;
        Quaternion m_startRot;
        Quaternion m_endRot;
    };
 
    class FullViewCube : public ViewCube
    {
    public:
        FullViewCube(const std::shared_ptr<Renderer>& renderer, const std::shared_ptr<Image2D>& image,
            const std::shared_ptr<Vector2i>& coordinate, const std::shared_ptr<Vector2i>& backgroundSize, const std::shared_ptr<Vector2i>& windowSize);
        virtual ~FullViewCube();
 
    private:
        void initialize();
    };
 
    class MiniViewCube : public ViewCube
    {
    public:
        MiniViewCube(const std::shared_ptr<Renderer>& renderer, const std::shared_ptr<Image2D>& image,
            const std::shared_ptr<Vector2i>& coordinate, const std::shared_ptr<Vector2i>& backgroundSize, const std::shared_ptr<Vector2i>& windowSize);
        virtual ~MiniViewCube();
 
    private:
        void initialize();
    };
 
    class CornerViewCube : public ViewCube
    {
    public:
        CornerViewCube(const std::shared_ptr<Renderer>& renderer, const std::shared_ptr<Image2D>& image,
            const std::shared_ptr<Vector2i>& coordinate, const std::shared_ptr<Vector2i>& backgroundSize, const std::shared_ptr<Vector2i>& windowSize);
        virtual ~CornerViewCube();
 
    private:
        void initialize();
    };
 
    std::shared_ptr<FullViewCube> _fullViewCube(const std::shared_ptr<Renderer>& renderer, const std::shared_ptr<Image2D>& image,
        const std::shared_ptr<Vector2i>& coordinate, const std::shared_ptr<Vector2i>& backgroundSize, const std::shared_ptr<Vector2i>& windowSize);
 
    std::shared_ptr<MiniViewCube> _miniViewCube(const std::shared_ptr<Renderer>& renderer, const std::shared_ptr<Image2D>& image,
        const std::shared_ptr<Vector2i>& coordinate, const std::shared_ptr<Vector2i>& backgroundSize, const std::shared_ptr<Vector2i>& windowSize);
 
    std::shared_ptr<CornerViewCube> _cornerViewCube(const std::shared_ptr<Renderer>& renderer, const std::shared_ptr<Image2D>& image,
        const std::shared_ptr<Vector2i>& coordinate, const std::shared_ptr<Vector2i>& backgroundSize, const std::shared_ptr<Vector2i>& windowSize);
}