clipping.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-10-31
// Version V1.1.0
//##################################################################################################
 
#pragma once
 
#include <cilcore.h>
 
#include <vector>
 
namespace cil
{
    class Clipping
    {
    public:
        enum class Scope
        {
            Inner = 0,
            Outer = 1,
        };
 
    protected:
        Scope m_scope;
 
        std::shared_ptr<Culling> m_culling_front;
        std::shared_ptr<Culling> m_culling_back;
        std::shared_ptr<ColorMask> m_colorMask_back;
        std::shared_ptr<Depth> m_depth_front;
        std::shared_ptr<Depth> m_depth_back;
        std::shared_ptr<Stencil> m_stencil_front;
        std::shared_ptr<Stencil> m_stencil_back;
        std::shared_ptr<PolygonOffset> m_polygonOffset_front;
        std::shared_ptr<PolygonOffset> m_polygonOffset_back;
        std::shared_ptr<VertexSource> m_vertex_front;
        std::shared_ptr<FragmentSource> m_fragment_front;
        std::shared_ptr<VertexSource> m_vertex_back;
        std::shared_ptr<FragmentSource> m_fragment_back;
        std::shared_ptr<Stencil> m_stencil_cap;
        std::shared_ptr<Culling> m_culling_cap;
        std::shared_ptr<Depth> m_depth_cap;
        std::shared_ptr<VertexSource> m_vertex_cap;
        std::shared_ptr<FragmentSource> m_fragment_cap;
        std::shared_ptr<Geometry> m_geometry_cap;
 
        virtual void addParameters(const std::shared_ptr<std::map<std::string, std::shared_ptr<Variant>>>& parameters);
 
    public:
        Clipping();
 
        void setScope(Scope scope);
        Scope scope();
 
        virtual std::shared_ptr<Node> getClippedNode(const std::shared_ptr<Node>& node);
        virtual std::shared_ptr<Node> getCapNode(const std::shared_ptr<BoundingBox>& boundingBox);
    };
 
    class PlaneClipping : public Clipping
    {
    private:
        std::shared_ptr<Plane> m_parameters_clipping;
 
    protected:
        virtual void addParameters(const std::shared_ptr<std::map<std::string, std::shared_ptr<Variant>>>& parameters);
 
    public:
        PlaneClipping();
 
        void set(float a, float b, float c, float d);
        void set(const std::shared_ptr<Vector3f>& origin, const std::shared_ptr<Vector3f>& normal);
        Vector3f getNormal();
        Vector3f getOrigin();
    };
 
    class TwoPlaneClipping : public Clipping
    {
    private:
        std::shared_ptr<Plane> m_parameters_clipping1;
        std::shared_ptr<Plane> m_parameters_clipping2;
 
    protected:
        virtual void addParameters(const std::shared_ptr<std::map<std::string, std::shared_ptr<Variant>>>& parameters);
 
    public:
        TwoPlaneClipping();
 
        void setPlane1(float a, float b, float c, float d);
        void setPlane1(const std::shared_ptr<Vector3f>& origin, const std::shared_ptr<Vector3f>& normal);
        Vector3f getPlane1Normal();
        Vector3f getPlane1Origin();
 
        void setPlane2(float a, float b, float c, float d);
        void setPlane2(const std::shared_ptr<Vector3f>& origin, const std::shared_ptr<Vector3f>& normal);
        Vector3f getPlane2Normal();
        Vector3f getPlane2Origin();
 
        virtual std::shared_ptr<Node> getCapNode(const std::shared_ptr<BoundingBox>& boundingBox);
    };
 
    class SphereClipping : public Clipping
    {
    private:
        std::shared_ptr<Vector4f> m_parameters_clipping;
 
    protected:
        virtual void addParameters(const std::shared_ptr<std::map<std::string, std::shared_ptr<Variant>>>& parameters);
 
    public:
        SphereClipping();
 
        void set(float a, float b, float c, float d);
        void set(const std::shared_ptr<Vector3f>& position, float radius);
        Vector3f getPosition();
        float getRadius();
    };
 
    std::shared_ptr<PlaneClipping> _planeClipping();
    std::shared_ptr<PlaneClipping> _planeClipping(float a, float b, float c, float d);
    std::shared_ptr<PlaneClipping> _planeClipping(const std::shared_ptr<Vector3f>& origin, const std::shared_ptr<Vector3f>& normal);
 
    std::shared_ptr<TwoPlaneClipping> _2planeClipping();
    std::shared_ptr<TwoPlaneClipping> _2planeClipping(const std::shared_ptr<Vector3f>& origin1,
                                                      const std::shared_ptr<Vector3f>& normal1,
                                                      const std::shared_ptr<Vector3f>& origin2,
                                                      const std::shared_ptr<Vector3f>& normal2);
 
    std::shared_ptr<SphereClipping> _sphereClipping();
    std::shared_ptr<SphereClipping> _sphereClipping(float a, float b, float c, float d);
    std::shared_ptr<SphereClipping> _sphereClipping(const std::shared_ptr<Vector3f>& position, float radius);
}