selector.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 "builder.h"
#include "producer.h"
#include "consumer.h"
 
#include <cilcore.h>
 
#include <memory>
#include <vector>
#include <set>
#include <functional>
#include <algorithm>
 
namespace cil
{
    enum class SelectorUpdateMode
    {
        None,
        View,
        Entity,
        All
    };
 
    class SelectorEngine
    {
    public:
        std::shared_ptr<Renderer> renderer;
        std::shared_ptr<Camera> camera;
        std::shared_ptr<Vector2i> backgroundSize;
        std::shared_ptr<Vector2i> windowSize;
    };
 
    template <typename T>
    class SelectorOptions
    {
    public:
        std::shared_ptr<std::vector<std::shared_ptr<T>>> entities;
        std::function<std::shared_ptr<Node>(std::shared_ptr<T>)> entity2node;
    };
 
    class Selector
    {
    public:
        Selector()
        {
        }
 
        virtual ~Selector()
        {
        }
    };
 
    template <typename T>
    class BaseSelector : public Selector
    {
    public:
        BaseSelector() : Selector()
 
        {
        }
 
        virtual ~BaseSelector()
        {
        }
 
        virtual void update(SelectorUpdateMode mode) = 0;
        virtual void setEntities(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities) = 0;
    };
 
    template <typename T>
    class EntitySelector : public BaseSelector<T>
    {
    protected:
        std::shared_ptr<EntityBuilder<T>> m_builder;
        std::shared_ptr<EntityProducer> m_producer;
        bool m_buffered;
 
    private:
        std::shared_ptr<std::vector<std::shared_ptr<Node>>> m_builtNodes;
        std::shared_ptr<Image2D> m_bufferImage;
 
    public:
        EntitySelector() : BaseSelector<T>()
        {
        }
 
        virtual ~EntitySelector()
        {
        }
 
        virtual void update(SelectorUpdateMode mode)
        {
            switch (mode)
            {
            case SelectorUpdateMode::View:
                this->m_bufferImage = nullptr;
                break;
            case SelectorUpdateMode::All:
            case SelectorUpdateMode::Entity:
            {
                this->m_builtNodes = nullptr;
                this->m_bufferImage = 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::shared_ptr<T> select(int x, int y)
        {
            this->buildNodes();
            if (this->m_buffered)
            {
                this->produceBufferImage();
                auto consumer = std::make_shared<PixelConsumer>(this->m_producer->windowSize());
                auto pixelIndex = consumer->select(x, y);
                unsigned int entityIndex = ((unsigned int*)this->m_bufferImage->data())[pixelIndex];
                return entityIndex != 0XFFFFFFFF ? (*this->m_builder->entities())[entityIndex] : nullptr;
            }
            else
            {
                this->m_producer->toPixel(x, y);
                auto image = this->m_producer->produce(this->m_builtNodes);
                unsigned int entityIndex = ((unsigned int*)image->data())[0];
                return entityIndex != 0XFFFFFFFF ? (*this->m_builder->entities())[entityIndex] : nullptr;
            }
        }
 
        std::vector<std::shared_ptr<T>> multiSelect(int x1, int y1, int x2, int y2)
        {
            this->buildNodes();
            if (this->m_buffered)
            {
                this->produceBufferImage();
                auto consumer = std::make_shared<BoxConsumer>(this->m_producer->windowSize());
                std::vector<int> pixelIndices = consumer->select(x1, y1, x2, y2);
 
                std::set<unsigned int> entityIndices;
                auto imageData = (unsigned int*)this->m_bufferImage->data();
                for (auto pixelIndex : pixelIndices)
                {
                    entityIndices.insert(imageData[pixelIndex]);
                }
                entityIndices.erase(0XFFFFFFFF);
 
                std::vector<std::shared_ptr<T>> result;
                auto& entities = *this->m_builder->entities();
                for (auto entityIndex : entityIndices)
                {
                    result.push_back(entities[entityIndex]);
                }
 
                return result;
            }
            else
            {
                this->m_producer->toBox(x1, y1, x2, y2);
                auto image = this->m_producer->produce(this->m_builtNodes);
 
                std::set<unsigned int> entityIndices;
                auto imageData = (unsigned int*)image->data();
                auto length = image->width() * image->height();
                for (int i = 0; i < length; ++i)
                {
                    entityIndices.insert(imageData[i]);
                }
                entityIndices.erase(0XFFFFFFFF);
 
                std::vector<std::shared_ptr<T>> result;
                auto& entities = *this->m_builder->entities();
                for (auto entityIndex : entityIndices)
                {
                    result.push_back(entities[entityIndex]);
                }
 
                return result;
            }
        }
 
    private:
        void buildNodes()
        {
            if (!this->m_builtNodes)
            {
                this->m_builtNodes = this->m_builder->build();
                this->m_producer->updatePass();
            }
        }
 
        void produceBufferImage()
        {
            if (!this->m_bufferImage) {
                this->m_producer->toWindow();
                this->m_bufferImage = this->m_producer->produce(this->m_builtNodes);
            }
        }
    };
 
    template <typename T>
    class FaceSelector : public EntitySelector<T>
    {
    public:
        FaceSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options, bool buffered = true)
            : EntitySelector<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);
            this->m_buffered = buffered;
        }
 
        virtual ~FaceSelector()
        {
        }
    };
 
    template <typename T>
    class VertexSelector : public EntitySelector<T>
    {
    public:
        VertexSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options, bool buffered = true)
            : EntitySelector<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);
            this->m_buffered = buffered;
        }
 
        virtual ~VertexSelector()
        {
        }
    };
 
    template <typename T>
    class EdgeSelector : public EntitySelector<T>
    {
    public:
        EdgeSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options, bool buffered = true)
            : EntitySelector<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);
            this->m_buffered = buffered;
        }
 
        virtual ~EdgeSelector()
        {
        }
    };
 
    template <typename T>
    class AttributeSelector : public BaseSelector<T>
    {
    protected:
        std::shared_ptr<AttributeBuilder<T>> m_builder;
        std::shared_ptr<AttributeProducer> m_producer;
        bool m_buffered;
 
    private:
        std::shared_ptr<std::vector<std::shared_ptr<Node>>> m_builtNodes;
        std::vector<std::shared_ptr<Image2D>> m_bufferImages;
 
    public:
        AttributeSelector()
            : BaseSelector<T>()
        {
        }
 
        virtual ~AttributeSelector()
        {
        }
 
        virtual void update(SelectorUpdateMode mode)
        {
            switch (mode)
            {
            case SelectorUpdateMode::View:
                this->m_bufferImages.clear();
                break;
            case SelectorUpdateMode::All:
            case SelectorUpdateMode::Entity:
            {
                this->m_builtNodes = nullptr;
                this->m_bufferImages.clear();
                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::shared_ptr<Vector3f> select(int x, int y)
        {
            this->buildNodes();
            if (this->m_buffered)
            {
                this->produceBufferImages();
                auto consumer = std::make_shared<PixelConsumer>(this->m_producer->windowSize());
                auto pixelIndex = consumer->select(x, y);
                unsigned int value = ((unsigned int*)this->m_bufferImages[0]->data())[pixelIndex];
                if (value != 0XFFFFFFFF)
                {
                    auto x = ((float*)this->m_bufferImages[0]->data())[pixelIndex];
                    auto y = ((float*)this->m_bufferImages[1]->data())[pixelIndex];
                    auto z = ((float*)this->m_bufferImages[2]->data())[pixelIndex];
 
                    return _vec3(x, y, z);
                }
                else
                {
                    return nullptr;
                }
            }
            else
            {
                this->m_producer->toPixel(x, y);
                auto images = this->m_producer->produce(this->m_builtNodes);
                unsigned int value = ((unsigned int*)images[0]->data())[0];
                if (value != 0XFFFFFFFF)
                {
                    auto x = ((float*)images[0]->data())[0];
                    auto y = ((float*)images[1]->data())[0];
                    auto z = ((float*)images[2]->data())[0];
 
                    return _vec3(x, y, z);
                }
                else
                {
                    return nullptr;
                }
            }
        }
 
    private:
        void buildNodes()
        {
            if (!this->m_builtNodes)
            {
                this->m_builtNodes = this->m_builder->build();
                this->m_producer->updatePass();
            }
        }
 
        void produceBufferImages()
        {
            if (this->m_bufferImages.size() == 0) {
                this->m_producer->toWindow();
                this->m_bufferImages = this->m_producer->produce(this->m_builtNodes);
            }
        }
    };
 
    template <typename T>
    class PositionSelector : public AttributeSelector<T>
    {
    public:
        PositionSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options, bool buffered = false)
            : AttributeSelector<T>()
        {
            this->m_builder = std::make_shared<PositionBuilder<T>>(options->entities, options->entity2node);
            this->m_producer = std::make_shared<PositionProducer>(engine->renderer, engine->camera, engine->backgroundSize, engine->windowSize);
            this->m_buffered = buffered;
        }
 
        virtual ~PositionSelector()
        {
        }
    };
 
    template <typename T>
    class NormalSelector : public AttributeSelector<T>
    {
    public:
        NormalSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options, bool buffered = false)
            : AttributeSelector<T>()
        {
            this->m_builder = std::make_shared<NormalBuilder<T>>(options->entities, options->entity2node);
            this->m_producer = std::make_shared<NormalProducer>(engine->renderer, engine->camera, engine->backgroundSize, engine->windowSize);
            this->m_buffered = buffered;
        }
 
        virtual ~NormalSelector()
        {
        }
    };
 
    template <typename T>
    class PrimitiveSelector : public BaseSelector<T>
    {
    protected:
        std::shared_ptr<PrimitiveBuilder<T>> m_builder;
        std::shared_ptr<PrimitiveProducer> m_producer;
        bool m_buffered;
 
    private:
        std::shared_ptr<std::vector<std::shared_ptr<Node>>> m_builtNodes;
        std::shared_ptr<Image2D> m_bufferImage;
 
    public:
        PrimitiveSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options, bool buffered = false)
            : BaseSelector<T>()
        {
            this->m_builder = std::make_shared<PrimitiveBuilder<T>>(options->entities, options->entity2node);
            this->m_producer = std::make_shared<PrimitiveProducer>(engine->renderer, engine->camera, engine->backgroundSize, engine->windowSize);
            this->m_buffered = buffered;
        }
 
        virtual ~PrimitiveSelector()
        {
        }
 
        virtual void update(SelectorUpdateMode mode)
        {
            switch (mode)
            {
            case SelectorUpdateMode::View:
                this->m_bufferImage = nullptr;
                break;
            case SelectorUpdateMode::All:
            case SelectorUpdateMode::Entity:
            {
                this->m_builtNodes = nullptr;
                this->m_bufferImage = 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);
        }
 
        unsigned int select(int x, int y)
        {
            this->buildNodes();
            if (this->m_buffered)
            {
                this->produceBufferImage();
                auto consumer = std::make_shared<PixelConsumer>(this->m_producer->windowSize());
                auto pixelIndex = consumer->select(x, y);
                unsigned int primitiveIndex = ((unsigned int*)this->m_bufferImage->data())[pixelIndex];
 
                return primitiveIndex;
            }
            else
            {
                this->m_producer->toPixel(x, y);
                auto image = this->m_producer->produce(this->m_builtNodes);
                unsigned int primitiveIndex = ((unsigned int*)image->data())[0];
 
                return primitiveIndex;
            }
        }
 
        std::vector<unsigned int> multiSelect(int x1, int y1, int x2, int y2)
        {
            this->buildNodes();
            if (this->m_buffered)
            {
                this->produceBufferImage();
                auto consumer = std::make_shared<BoxConsumer>(this->m_producer->windowSize());
                std::vector<int> pixelIndices = consumer->select(x1, y1, x2, y2);
 
                std::set<unsigned int> primitiveIndices;
                auto imageData = (unsigned int*)this->m_bufferImage->data();
                for (auto pixelIndex : pixelIndices)
                {
                    primitiveIndices.insert(imageData[pixelIndex]);
                }
                primitiveIndices.erase(0XFFFFFFFF);
 
                return std::vector<unsigned int>(primitiveIndices.begin(), primitiveIndices.end());
            }
            else
            {
                this->m_producer->toBox(x1, y1, x2, y2);
                auto image = this->m_producer->produce(this->m_builtNodes);
                auto imageData = (unsigned int*)image->data();
 
                std::set<unsigned int> primitiveIndices;
                auto length = image->width() * image->height();
                for (int i = 0; i < length; ++i)
                {
                    primitiveIndices.insert(imageData[i]);
                }
                primitiveIndices.erase(0XFFFFFFFF);
 
                return std::vector<unsigned int>(primitiveIndices.begin(), primitiveIndices.end());
            }
        }
 
    private:
        void buildNodes()
        {
            if (!this->m_builtNodes)
            {
                this->m_builtNodes = this->m_builder->build();
                this->m_producer->updatePass();
            }
        }
 
        void produceBufferImage()
        {
            if (!this->m_bufferImage) {
                this->m_producer->toWindow();
                this->m_bufferImage = this->m_producer->produce(this->m_builtNodes);
            }
        }
    };
 
    std::shared_ptr<SelectorEngine> _selectorEngine(const std::shared_ptr<Renderer>& renderer, const std::shared_ptr<Camera>& camera, const std::shared_ptr<Vector2i>& backgroundSize, const std::shared_ptr<Vector2i>& windowSize);
 
    template <typename T>
    std::shared_ptr<SelectorOptions<T>> _selectorOptions(const std::shared_ptr<std::vector<std::shared_ptr<T>>>& entities, const std::function<std::shared_ptr<Node>(std::shared_ptr<T>)>& entity2node)
    {
        auto options = std::make_shared<SelectorOptions<T>>();
        options->entities = entities;
        options->entity2node = entity2node;
 
        return options;
    }
 
    template <typename T>
    std::shared_ptr<FaceSelector<T>> _faceSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options, bool buffered = true)
    {
        return std::make_shared<FaceSelector<T>>(engine, options, buffered);
    }
 
    template <typename T>
    std::shared_ptr<VertexSelector<T>> _vertexSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options, bool buffered = true)
    {
        return std::make_shared<VertexSelector<T>>(engine, options, buffered);
    }
 
    template <typename T>
    std::shared_ptr<EdgeSelector<T>> _edgeSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options, bool buffered = true)
    {
        return std::make_shared<EdgeSelector<T>>(engine, options, buffered);
    }
 
    template <typename T>
    std::shared_ptr<PositionSelector<T>> _positionSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options, bool buffered = false)
    {
        return std::make_shared<PositionSelector<T>>(engine, options, buffered);
    }
 
    template <typename T>
    std::shared_ptr<NormalSelector<T>> _normalSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options, bool buffered = false)
    {
        return std::make_shared<NormalSelector<T>>(engine, options, buffered);
    }
 
    template <typename T>
    std::shared_ptr<PrimitiveSelector<T>> _primitiveSelector(const std::shared_ptr<SelectorEngine>& engine, const std::shared_ptr<SelectorOptions<T>>& options, bool buffered = false)
    {
        return std::make_shared<PrimitiveSelector<T>>(engine, options, buffered);
    }
}