attributes.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 <string>
#include <tuple>
#include <memory>
 
#include <cilcore.h>
 
namespace cil
{
    class Part;
    class PartData;
    class FilterData;
    class EntityData;
    class ScenarioSettings;
 
    class Attributes
    {
    protected:
        bool isScalarExisted(const std::shared_ptr<ScenarioSettings>& settings) const;
        bool isVectorExisted(const std::shared_ptr<ScenarioSettings>& settings) const;
        bool isOffsetExisted(const std::shared_ptr<ScenarioSettings>& settings) const;
 
    public:
        enum class Appearence {
            None,
            Color,
            Result,
            Texture,
        };
 
        bool visible;
        Appearence appearence;
        std::string scalar;
        std::string vector;
        std::string offset;
        std::shared_ptr<Color3f> color;
 
        Attributes();
 
        virtual std::shared_ptr<Node> entityData2Node(std::tuple<const std::shared_ptr<EntityData>&,
                                                                 const std::shared_ptr<ScenarioSettings>&> data);
        virtual std::shared_ptr<Node> partData2Node(std::tuple<const std::shared_ptr<PartData>&,
                                                               const std::shared_ptr<ScenarioSettings>&> data);
        virtual std::shared_ptr<Node> filterData2Node(std::tuple<const std::shared_ptr<FilterData>&,
                                                                 const std::shared_ptr<ScenarioSettings>&> data);
 
        virtual std::shared_ptr<Node> operator<< (std::tuple<const std::shared_ptr<FilterData>&,
                                                             const std::shared_ptr<ScenarioSettings>&> data);
    };
 
    class PolygonAttributes : public Attributes
    {
    private:
        std::shared_ptr<Primitive> findShaded(const std::shared_ptr<EntityData>& entityData,
                                              const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findOutline(const std::shared_ptr<EntityData>& entityData,
                                               const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findTransparent(const std::shared_ptr<EntityData>& entityData,
                                                   const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findWireframe(const std::shared_ptr<EntityData>& entityData,
                                                 const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findGrille(const std::shared_ptr<EntityData>& entityData,
                                              const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findSphere(const std::shared_ptr<EntityData>& entityData,
                                              const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findStrip(const std::shared_ptr<EntityData>& entityData,
                                               const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findVector(const std::shared_ptr<EntityData>& entityData,
                                              const std::shared_ptr<ScenarioSettings>& settings);
 
    public:
        enum class Display {
            None,
            Outline,
            Wireframe,
            Grille,
            Shaded,
            Shaded_Outline,
            Shaded_Wireframe,
            Shaded_Grille,
            Transparent,
            Transparent_Outline,
            Transparent_Wireframe,
            Transparent_Grille,
            Sphere,
            Sphere_Outline,
            Sphere_Wireframe,
            Strip,
            Strip_Outline,
            Strip_Wireframe,
            Strip_Grille,
        };
        Display display;
 
        PolygonAttributes();
 
        virtual std::shared_ptr<Node> entityData2Node(std::tuple<const std::shared_ptr<EntityData>&,
                                                             const std::shared_ptr<ScenarioSettings>&> data);
    };
 
    class PartAttributes : public PolygonAttributes
    {
    public:
        PartAttributes();
 
        std::map<Part*, std::shared_ptr<PolygonAttributes>> children;
 
        virtual std::shared_ptr<Node> filterData2Node(std::tuple<const std::shared_ptr<FilterData>&,
                                                             const std::shared_ptr<ScenarioSettings>&> data);
 
        void sync();
    };
 
    class TracerAttributes : public Attributes
    {
    private:
        std::shared_ptr<Primitive> findLine(const std::shared_ptr<EntityData>& entityData,
                                            const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findSphere(const std::shared_ptr<EntityData>& entityData,
                                              const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findRibbon(const std::shared_ptr<EntityData>& entityData,
                                             const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findCylinder(const std::shared_ptr<EntityData>& entityData,
                                                const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findVector(const std::shared_ptr<EntityData>& entityData,
                                              const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findForwardCylinder(const std::shared_ptr<EntityData>& entityData,
                                                        const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findForwardRibbon(const std::shared_ptr<EntityData>& entityData,
                                                     const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findForwardSphere(const std::shared_ptr<EntityData>& entityData,
                                                      const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findMeteorCylinder(const std::shared_ptr<EntityData>& entityData,
                                                      const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findMeteorLine(const std::shared_ptr<EntityData>& entityData,
                                                    const std::shared_ptr<ScenarioSettings>& settings);
 
    public:
        enum class Display {
            None,
 
            Line,
            Sphere,
            Ribbon,
            Cylinder,
 
            Forward_Line,
            Forward_Sphere,
            Forward_Ribbon,
            Forward_Cylinder,
 
            Meteor_Line,
            Meteor_Cylinder,
        };
 
        Display display;
 
        TracerAttributes();
 
        virtual std::shared_ptr<Node> entityData2Node(std::tuple<const std::shared_ptr<EntityData>&,
                                                             const std::shared_ptr<ScenarioSettings>&> data);
    };
 
    class PointAttributes : public Attributes
    {
    private:
        std::shared_ptr<Primitive> findSphere(const std::shared_ptr<EntityData>& entityData,
            const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findSquare(const std::shared_ptr<EntityData>& entityData,
            const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findCloud(const std::shared_ptr<EntityData>& entityData,
            const std::shared_ptr<ScenarioSettings>& settings);
    public:
        enum class Display {
            None,
            Point,
            Circle,
            Ring,
            Star,
            Square,
            Sphere,
            Cloud,
        };
 
        Display display;
 
        PointAttributes();
 
        virtual std::shared_ptr<Node> entityData2Node(std::tuple<const std::shared_ptr<EntityData>&,
            const std::shared_ptr<ScenarioSettings>&> data);
    };
 
    class BlockAttributes : public Attributes
    {
    private:
        std::shared_ptr<Primitive> findSphere(const std::shared_ptr<EntityData>& entityData,
            const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findCube(const std::shared_ptr<EntityData>& entityData,
            const std::shared_ptr<ScenarioSettings>& settings);
        std::shared_ptr<Primitive> findCubeOutline(const std::shared_ptr<EntityData>& entityData,
            const std::shared_ptr<ScenarioSettings>& settings);
 
    public:
        enum class Display {
            None,
            Sphere,
            Cube,
            Cube_Outline,
        };
 
        Display display;
 
        BlockAttributes();
 
        virtual std::shared_ptr<Node> entityData2Node(std::tuple<const std::shared_ptr<EntityData>&,
            const std::shared_ptr<ScenarioSettings>&> data);
    };
}