builder.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 V2.1.0
//##################################################################################################
 
#pragma once
 
#include <cilcore.h>
 
#include <memory>
#include <vector>
#include <functional>
 
namespace cil
{
    template <typename T>
    class SelectionBuilder
    {
    protected:
        std::shared_ptr<std::vector<std::shared_ptr<T>>> m_entities;
        std::function<std::shared_ptr<Node>(std::shared_ptr<T>)> m_entity2node; // geometry and tranform only, no material
 
    public:
        SelectionBuilder(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities, const std::function<std::shared_ptr<Node>(std::shared_ptr<T>)>& entity2node)
        {
            this->m_entities = entities;
            this->m_entity2node = entity2node;
        }
 
        virtual ~SelectionBuilder()
        {
        }
 
        std::shared_ptr<std::vector<std::shared_ptr<T>>> entities()
        {
            return this->m_entities;
        }
 
        void setEntities(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities)
        {
            this->m_entities = entities;
        }
 
        virtual std::shared_ptr<std::vector<std::shared_ptr<Node>>> build() = 0;
    };
 
    template <typename T>
    class EntityBuilder : public SelectionBuilder<T>
    {
    public:
        EntityBuilder(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities, const std::function<std::shared_ptr<Node>(std::shared_ptr<T>)>& entity2node)
            : SelectionBuilder<T>(entities, entity2node)
        {
        }
 
        virtual ~EntityBuilder()
        {
        }
 
        virtual std::shared_ptr<std::vector<std::shared_ptr<Node>>> build()
        {
            auto nodes = _nodes();
 
            unsigned int index = 0;
            for (auto& entity : *this->m_entities)
            {
                auto node = this->m_entity2node(entity);
                if (node)
                {
                    auto value = _clr4((unsigned char)index / 255.0, (unsigned char)(index >> 8) / 255.0, (unsigned char)(index >> 16) / 255.0, (unsigned char)(index >> 24) / 255.0);
                    node->material = _material(nullptr, _parameters(
                        {
                            {"index", value},
                        }
                        ), nullptr);
                    nodes->push_back(node);
                }
 
                index++;
            }
 
            return nodes;
        }
    };
 
    template <typename T>
    class FaceBuilder : public EntityBuilder<T>
    {
    public:
        FaceBuilder(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities, const std::function<std::shared_ptr<Node>(std::shared_ptr<T>)>& entity2node)
            : EntityBuilder<T>(entities, entity2node)
        {
        }
 
        virtual ~FaceBuilder()
        {
        }
    };
 
    template <typename T>
    class VertexBuilder : public EntityBuilder<T>
    {
    public:
        VertexBuilder(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities, const std::function<std::shared_ptr<Node>(std::shared_ptr<T>)>& entity2node)
            : EntityBuilder<T>(entities, entity2node)
        {
        }
 
        virtual ~VertexBuilder()
        {
        }
    };
 
    template <typename T>
    class EdgeBuilder : public EntityBuilder<T>
    {
    public:
        EdgeBuilder(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities, const std::function<std::shared_ptr<Node>(std::shared_ptr<T>)>& entity2node)
            : EntityBuilder<T>(entities, entity2node)
        {
        }
 
        virtual ~EdgeBuilder()
        {
        }
    };
 
    template <typename T>
    class AttributeBuilder : public SelectionBuilder<T>
    {
    public:
        AttributeBuilder(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities, const std::function<std::shared_ptr<Node>(std::shared_ptr<T>)>& entity2node)
            : SelectionBuilder<T>(entities, entity2node)
        {
        }
 
        virtual ~AttributeBuilder()
        {
        }
 
        virtual std::shared_ptr<std::vector<std::shared_ptr<Node>>> build()
        {
            auto nodes = _nodes();
 
            for (auto& entity : *this->m_entities)
            {
                auto node = this->m_entity2node(entity);
                if (node)
                {
                    nodes->push_back(node);
                }  
            }
 
            return nodes;
        }
    };
 
    template <typename T>
    class PositionBuilder : public AttributeBuilder<T>
    {
    public:
        PositionBuilder(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities, const std::function<std::shared_ptr<Node>(std::shared_ptr<T>)>& entity2node)
            : AttributeBuilder<T>(entities, entity2node)
        {
        }
 
        virtual ~PositionBuilder()
        {
        }
    };
 
    template <typename T>
    class NormalBuilder : public AttributeBuilder<T>
    {
    public:
        NormalBuilder(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities, const std::function<std::shared_ptr<Node>(std::shared_ptr<T>)>& entity2node)
            : AttributeBuilder<T>(entities, entity2node)
        {
        }
 
        virtual ~NormalBuilder()
        {
        }
    };
 
    template <typename T>
    class PrimitiveBuilder : public AttributeBuilder<T>
    {
    public:
        PrimitiveBuilder(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities, const std::function<std::shared_ptr<Node>(std::shared_ptr<T>)>& entity2node)
            : AttributeBuilder<T>(entities, entity2node)
        {
        }
 
        virtual ~PrimitiveBuilder()
        {
        }
    };
}