scene.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "instanceproperty.h"
#include "entitycreationparameters.h"
 
// External Includes
#include <rtti/object.h>
#include <utility/uniqueptrmapiterator.h>
#include <rtti/factory.h>
#include <nap/resource.h>
 
namespace nap
{
    // Forward Declares
    class Entity;
    class SpawnedEntityInstance;
    class Core;
 
    class NAPAPI RootEntity final
    {
        RTTI_ENABLE()
    public:
        rtti::ObjectPtr<Entity>                         mEntity;                
        std::vector<ComponentInstanceProperties>        mInstanceProperties;    
    };
 
    class NAPAPI Scene : public Resource
    {
        RTTI_ENABLE(Resource)
    public:
        using EntityByIDMap = std::unordered_map<std::string, std::unique_ptr<EntityInstance>>;
        using EntityIterator = utility::UniquePtrMapWrapper<EntityByIDMap, EntityInstance*>;
        using RootEntityList = std::vector<RootEntity>;
        using InstanceByIDMap = std::unordered_map<std::string, rtti::Object*>;
        using SortedComponentInstanceList = std::vector<ComponentInstance*>;
        using SpawnedComponentInstanceMap = std::unordered_map<EntityInstance*, SortedComponentInstanceList>;
 
        Scene(Core& core);
        virtual ~Scene() override;
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual void onDestroy() override;
 
        void update(double deltaTime);
 
        SpawnedEntityInstance spawn(const Entity& entity, utility::ErrorState& errorState);
 
        SpawnedEntityInstance spawn(const Entity& entity, const std::vector<ComponentInstanceProperties>& instanceProperties, utility::ErrorState& errorState);
 
        void destroy(SpawnedEntityInstance& entity);
 
        void updateTransforms(double deltaTime);
 
        EntityIterator getEntities() { return EntityIterator(mEntityInstancesByID); }
 
        const rtti::ObjectPtr<EntityInstance> findEntity(const std::string& inID) const;
 
        const EntityInstance& getRootEntity() const     { return *mRootEntityInstance;}
 
        EntityInstance& getRootEntity()                 { return *mRootEntityInstance;}
 
        RootEntityList getEntityResources()             { return mEntities; }
 
        RootEntityList& getEntityResourcesRef()         { return mEntities; }
 
    private:
        EntityInstance* createEntityInstance(const Entity& entityResource, EntityCreationParameters& entityCreationParams, utility::ErrorState& errorState);
 
        EntityInstance* createChildEntityInstance(const Entity& entity, int childIndex, EntityCreationParameters& entityCreationParams, utility::ErrorState& errorState);
 
        bool spawnInternal(const RootEntityList& rootEntities, const std::vector<rtti::Object*>& allObjects, bool clearChildren, std::vector<EntityInstance*>& spawnedRootEntityInstances, SortedComponentInstanceList& sortedComponentInstances, utility::ErrorState& errorState);
 
    public:
        RootEntityList                      mEntities;                      
 
    private:
        friend class EntityInstance;
 
        Core*                               mCore;
        std::unique_ptr<EntityInstance>     mRootEntityInstance;            
        std::unique_ptr<Entity>             mRootEntityResource;            
        EntityByIDMap                       mEntityInstancesByID;           
        InstanceByIDMap                     mInstancesByID;                 
        ClonedComponentResourceList         mAllClonedComponents;           
        SortedComponentInstanceList         mLoadedComponentInstances;      
        SpawnedComponentInstanceMap         mSpawnedComponentInstanceMap;   
    };
 
    using SceneCreator = rtti::ObjectCreator<Scene, Core>;
}