passthrough.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 "selector.h"
 
namespace cil
{
    template <typename T>
    class PassThroughEntitySelector : public BaseSelector<T>
    {
    protected:
        std::shared_ptr<EntityBuilder<T>> m_builder;
        std::shared_ptr<EntityProducer> m_producer;
 
    private:
        std::shared_ptr<std::vector<std::shared_ptr<Node>>> m_builtNodes;
 
    public:
        PassThroughEntitySelector()
            : BaseSelector<T>()
        {
        }
 
        virtual ~PassThroughEntitySelector()
        {
        }
 
        virtual void update(SelectorUpdateMode mode)
        {
            switch (mode)
            {
            case SelectorUpdateMode::All:
            case SelectorUpdateMode::Entity:
            {
                this->m_builtNodes = nullptr;
                break;
            }
            default: break;
            }
        }
 
        virtual void setEntities(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities)
        {
            this->m_builder->setEntities(entities);
            this->update(SelectorUpdateMode::Entity);
        }
 
        std::vector<std::shared_ptr<T>> select(int x, int y, int depth = 0)
        {
            this->buildNodes();
            this->m_producer->toPixel(x, y);
 
            int count = 0;
            auto nodes = _nodes();
            *nodes = *this->m_builtNodes;
            std::vector<std::shared_ptr<T>> result;
 
            std::function<void()> render;
            render = [&]() -> void {
                this->m_producer->updatePassBatch();
                auto image = this->m_producer->produce(nodes);
                auto entityIndex = ((unsigned int*)image->data())[0];
                if (entityIndex != 0XFFFFFFFF)
                {
                    result.push_back((*this->m_builder->entities())[entityIndex]);
 
                    auto& node = (*this->m_builtNodes)[entityIndex];
                    auto it = std::find(nodes->begin(), nodes->end(), node);
                    if (it != nodes->end())
                    {
                        nodes->erase(it);
 
                        count++;
                        if (!depth || count < depth)
                            render();
                    }
                }
                };
            render();
 
            return result;
        }
 
        std::vector<std::shared_ptr<T>> multiSelect(int x1, int y1, int x2, int y2, int depth = 0)
        {
            this->buildNodes();
            this->m_producer->toBox(x1, y1, x2, y2);
 
            int count = 0;
            auto nodes = _nodes();
            *nodes = *this->m_builtNodes;
            std::vector<std::shared_ptr<T>> result;
 
            std::function<void()> render;
            render = [&]() -> void {
                this->m_producer->updatePassBatch();
                auto image = this->m_producer->produce(nodes);
                auto imageData = (unsigned int*)image->data();
 
                std::set<unsigned int> entityIndices;
                auto length = image->width() * image->height();
                for (int i = 0; i < length; ++i)
                {
                    entityIndices.insert(imageData[i]);
                }
                entityIndices.erase(0XFFFFFFFF);
 
                if (entityIndices.size() != 0)
                {
                    auto entities = *this->m_builder->entities();
                    for (auto entityIndex : entityIndices)
                    {
                        result.push_back(entities[entityIndex]);
 
                        auto& node = (*this->m_builtNodes)[entityIndex];
                        auto it = std::find(nodes->begin(), nodes->end(), node);
                        if (it != nodes->end())
                        {
                            nodes->erase(it);
                        }
                    }
 
                    count++;
                    if (!depth || count < depth)
                        render();
                }
                };
            render();
 
            return result;
        }
 
    private:
        void buildNodes()
        {
            if (!this->m_builtNodes)
            {
                this->m_builtNodes = this->m_builder->build();
                this->m_producer->updatePass();
            }
        }
    };
 
    template <typename T>
    class PassThroughFaceSelector : public PassThroughEntitySelector<T>
    {
    public:
        PassThroughFaceSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options)
            : PassThroughEntitySelector<T>()
        {
            this->m_builder = std::make_shared<FaceBuilder<T>>(options->entities, options->entity2node);
            this->m_producer = std::make_shared<FaceProducer>(engine->renderer, engine->camera, engine->backgroundSize, engine->windowSize);
        }
 
        virtual ~PassThroughFaceSelector()
        {
        }
    };
 
    template <typename T>
    class PassThroughVertexSelector : public PassThroughEntitySelector<T>
    {
    public:
        PassThroughVertexSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options)
            : PassThroughEntitySelector<T>()
        {
            this->m_builder = std::make_shared<VertexBuilder<T>>(options->entities, options->entity2node);
            this->m_producer = std::make_shared<VertexProducer>(engine->renderer, engine->camera, engine->backgroundSize, engine->windowSize);
        }
 
        virtual ~PassThroughVertexSelector()
        {
        }
    };
 
    template <typename T>
    class PassThroughEdgeSelector : public PassThroughEntitySelector<T>
    {
    public:
        PassThroughEdgeSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options)
            : PassThroughEntitySelector<T>()
        {
            this->m_builder = std::make_shared<EdgeBuilder<T>>(options->entities, options->entity2node);
            this->m_producer = std::make_shared<EdgeProducer>(engine->renderer, engine->camera, engine->backgroundSize, engine->windowSize);
        }
 
        virtual ~PassThroughEdgeSelector()
        {
        }
    };
 
    template <typename T>
    std::shared_ptr<PassThroughFaceSelector<T>> _passThroughFaceSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options)
    {
        return std::make_shared<PassThroughFaceSelector<T>>(engine, options);
    }
 
    template <typename T>
    std::shared_ptr<PassThroughVertexSelector<T>> _passThroughVertexSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options)
    {
        return std::make_shared<PassThroughVertexSelector<T>>(engine, options);
    }
 
    template <typename T>
    std::shared_ptr<PassThroughEdgeSelector<T>> _passThroughEdgeSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options)
    {
        return std::make_shared<PassThroughEdgeSelector<T>>(engine, options);
    }
}