Scene.h

//
//  Scene.h
//  render/src/render
//
//  Created by Sam Gateau on 1/11/15.
//  Copyright 2014 High Fidelity, Inc.
//  Copyright 2024 Overte e.V.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
 
#ifndef hifi_render_Scene_h
#define hifi_render_Scene_h
 
#include "Item.h"
#include "SpatialTree.h"
#include "Stage.h"
#include "Selection.h"
#include "Transition.h"
#include "HighlightStyle.h"
 
namespace render {
 
class RenderEngine;
class Scene;
 
class Transaction {
    friend class Scene;
public:
 
    typedef std::function<void(ItemID, const Transition*)> TransitionQueryFunc;
    typedef std::function<void()> TransitionFinishedFunc;
    typedef std::function<void(HighlightStyle const*)> SelectionHighlightQueryFunc;
 
    Transaction() {}
    ~Transaction() {}
 
    // Item transactions
 
    void resetItem(ItemID id, const PayloadPointer& payload);
 
    void removeItem(ItemID id);
 
    bool hasRemovedItems() const { return !_removedItems.empty(); }
 
    template <class T> void updateItem(ItemID id, std::function<void(T&)> func) {
        updateItem(id, std::make_shared<UpdateFunctor<T>>(func));
    }
 
 
    void updateItem(ItemID id) { updateItem(id, nullptr); }
 
    // Transition (applied to an item) transactions
 
    void resetTransitionOnItem(ItemID id, TransitionType transition, ItemID boundId = render::Item::INVALID_ITEM_ID);
 
    void removeTransitionFromItem(ItemID id);
 
    void setTransitionFinishedOperator(ItemID id, TransitionFinishedFunc func);
 
    void queryTransitionOnItem(ItemID id, TransitionQueryFunc func);
   
    // Selection transactions
 
    void resetSelection(const Selection& selection);
 
    void resetSelectionHighlight(const std::string& selectionName, const HighlightStyle& style = HighlightStyle());
 
    void removeHighlightFromSelection(const std::string& selectionName);
 
    void querySelectionHighlight(const std::string& selectionName, const SelectionHighlightQueryFunc& func);
 
    void reserve(const std::vector<Transaction>& transactionContainer);
 
    void mergeByCopying(const std::vector<Transaction>& transactionContainer);
 
    void mergeByMoving(std::vector<Transaction>&& transactionContainer);
 
    void mergeByCopying(const Transaction& transaction);
 
    void mergeByMoving(Transaction&& transaction);
 
    void clear();
 
private:
 
    void updateItem(ItemID id, const UpdateFunctorPointer& functor);
 
    using Reset = std::tuple<ItemID, PayloadPointer>;
    using Remove = ItemID;
    using Update = std::tuple<ItemID, UpdateFunctorPointer>;
 
    using TransitionReset = std::tuple<ItemID, TransitionType, ItemID>;
    using TransitionRemove = ItemID;
    using TransitionFinishedOperator = std::tuple<ItemID, TransitionFinishedFunc>;
    using TransitionQuery = std::tuple<ItemID, TransitionQueryFunc>;
 
    using SelectionReset = Selection;
 
    using HighlightReset = std::tuple<std::string, HighlightStyle>;
    using HighlightRemove = std::string;
    using HighlightQuery = std::tuple<std::string, SelectionHighlightQueryFunc>;
 
    using Resets = std::vector<Reset>;
    using Removes = std::vector<Remove>;
    using Updates = std::vector<Update>;
 
    using TransitionResets = std::vector<TransitionReset>;
    using TransitionRemoves = std::vector<TransitionRemove>;
    using TransitionFinishedOperators = std::vector<TransitionFinishedOperator>;
    using TransitionQueries = std::vector<TransitionQuery>;
 
    using SelectionResets = std::vector<SelectionReset>;
 
    using HighlightResets = std::vector<HighlightReset>;
    using HighlightRemoves = std::vector<HighlightRemove>;
    using HighlightQueries = std::vector<HighlightQuery>;
 
    Resets _resetItems;
    Removes _removedItems;
    Updates _updatedItems;
 
    TransitionResets _resetTransitions;
    TransitionRemoves _removeTransitions;
    TransitionFinishedOperators _transitionFinishedOperators;
    TransitionQueries _queriedTransitions;
 
    SelectionResets _resetSelections;
 
    HighlightResets _highlightResets;
    HighlightRemoves _highlightRemoves;
    HighlightQueries _highlightQueries;
};
typedef std::vector<Transaction> TransactionQueue;
 
 
class Scene {
public:
    Scene(glm::vec3 origin, float size);
    ~Scene();
 
    ItemID allocateID();
 
    bool isAllocatedID(const ItemID& id) const;
 
    size_t getNumItems() const { return _numAllocatedItems.load(); }
 
    void enqueueTransaction(const Transaction& transaction);
 
    void enqueueTransactionMove(Transaction&& transaction);
 
    uint32_t enqueueFrame();
 
    void processTransactionQueue();
 
    Selection getSelection(const Selection::Name& name) const;
 
    bool isSelectionEmpty(const Selection::Name& name) const;
 
    void addItemToSelection(const std::string& selectionName, ItemID itemID);
 
    void removeSelection(const std::string& selectionName);
 
    // Following call are NOT threadsafe, you have to call them from the correct thread to avoid any potential issues.
 
    const Item& getItem(const ItemID& id) const { return _items[id]; }
 
    const Item getItemSafe(const ItemID& id) const { if (isAllocatedID(id)) { return _items[id]; } else { return Item(); } }
 
    const ItemSpatialTree& getSpatialTree() const { return _primarySpatialTree; }
 
    const ItemIDSet& getNonspatialSet() const { return _primaryNonspatialSet; }
 
    StagePointer getStage(const Stage::Name& name) const;
 
    template <class T>
    std::shared_ptr<T> getStage(const Stage::Name& name = T::getName()) const {
        auto stage = getStage(name);
        return (stage ? std::static_pointer_cast<T>(stage) : std::shared_ptr<T>());
    }
 
    void resetStage(const Stage::Name& name, const StagePointer& stage);
 
    void simulate(ItemID id, RenderArgs* args) { _items[id].renderSimulate(args); }
 
    HighlightStyle getOutlineStyle(ItemID id, const ViewFrustum& viewFrustum, uint16_t height) { return _items[id].getOutlineStyle(viewFrustum, height); }
 
private:
    void setItemTransition(ItemID id, Index transitionId);
 
    void removeItemTransition(ItemID id);
 
 
    // Thread safe elements that can be accessed from anywhere
    std::atomic<unsigned int> _IDAllocator{ 1 }; // first valid itemID will be One
    std::atomic<unsigned int> _numAllocatedItems{ 1 }; // num of allocated items, matching the _items.size()
 
    std::mutex _transactionQueueMutex;
 
    TransactionQueue _transactionQueue;
 
    std::mutex _transactionFramesMutex;
 
    using TransactionFrames = std::vector<Transaction>;
 
    TransactionFrames _transactionFrames;
 
    uint32_t _transactionFrameNumber{ 0 };
 
    void processTransactionFrame(const Transaction& transaction);
 
    // The actual database
 
    std::mutex _itemsMutex;
 
    Item::Vector _items;
 
    ItemSpatialTree _primarySpatialTree;
 
    ItemIDSet _primaryNonspatialSet;
 
    void resetItems(const Transaction::Resets& transactions);
 
    void resetTransitionFinishedOperator(const Transaction::TransitionFinishedOperators& transactions);
 
    void removeItems(const Transaction::Removes& transactions);
 
    void updateItems(const Transaction::Updates& transactions);
 
    void resetTransitionItems(const Transaction::TransitionResets& transactions);
 
    void removeTransitionItems(const Transaction::TransitionRemoves& transactions);
 
    void queryTransitionItems(const Transaction::TransitionQueries& transactions);
 
    void resetHighlights(const Transaction::HighlightResets& transactions);
 
    void removeHighlights(const Transaction::HighlightRemoves& transactions);
 
    void queryHighlights(const Transaction::HighlightQueries& transactions);
 
    void collectSubItems(ItemID parentId, ItemIDs& subItems) const;
 
    // The Selection map
    mutable std::mutex _selectionsMutex; // mutable so it can be used in the thread safe getSelection const method
    SelectionMap _selections;
 
    std::unordered_map<int32_t, std::vector<Transaction::TransitionFinishedFunc>> _transitionFinishedOperatorMap;
 
    void resetSelections(const Transaction::SelectionResets& transactions);
    // More actions coming to selections soon:
    //  void removeFromSelection(const Selection& selection);
    //  void appendToSelection(const Selection& selection);
    //  void mergeWithSelection(const Selection& selection);
 
    // The Stage map
    mutable std::mutex _stagesMutex;
 
    StageMap _stages;
 
 
    friend class RenderEngine;
};
 
typedef std::shared_ptr<Scene> ScenePointer;
typedef std::vector<ScenePointer> Scenes;
 
}
 
#endif // hifi_render_Scene_h