ModelSystem.h

#pragma once
 
#include "Systems/ComponentSystem.h"
 
#include "Components/Core/ModelComponent.h"
 
#include "Context.h"
 
#include <map>
 
#include "DynamicComponentSystem.h"
 
namespace Cogs
{
  namespace Core
  {
    typedef std::function<void(Context*, EntityId)> HierarchyChangedCallback;
    class Context;
 
    class ModelData
    {
    public:
      ModelData() = default;
      ModelData(const ModelData & other) = delete;
 
      void setLoaded() { modelState |= 1; }
      bool isLoaded() const { return modelState != 0; }
 
      // Helper flag used when tracking progress in subresource (mesh) loading
      void setResourcesLoaded() { modelState |= 2; }
      bool isResourcesLoaded() const { return modelState & 2; }
      void clearResourcesLoaded() { modelState = modelState & ~2; }
 
      void setGeneration(uint8_t generation) { this->generation = generation; }
      bool isGeneration(uint8_t generation) const { return this->generation == generation; }
 
      ResourceId getResourceId() { return resourceId; };
      void setResourceId(ResourceId rid) { resourceId = rid; };
      MaterialInstanceHandle masterMaterial;
      std::vector<MaterialInstanceHandle> materials;
 
    private:
      uint8_t modelState = 0;
      uint8_t generation = 0;
 
      ResourceId resourceId = NoResourceId;
    };
 
    class COGSCORE_DLL_API ModelSystem : public ComponentSystemWithDataPools<ModelComponent, ModelData>
    {
    public:
      ModelSystem(Memory::Allocator * allocator, SizeType capacity) : ComponentSystemWithDataPools(allocator, capacity) 
      {
        addHierarchyCallback([](Context * context, EntityId id) {
          if (context->callbacks.hierarchyChangeCallback) {
            context->callbacks.hierarchyChangeCallback(context, id);
          }
        });
      }
 
      void initialize(Context * context) override;
      void update(Context * context) override;
      void postUpdate(Context * context) override;
 
      int addHierarchyCallback(HierarchyChangedCallback callback);
      void removeHierarchyCallback(int id);
 
      float getLoadProgress(ModelComponent* modelComponent);
 
    private:
      void loadModel(Context * context, const ModelComponent & component, ModelData & modelData, Model * model);
      void clearModel(Context * context, const ModelComponent & component);
 
      int nextId = 0;
      std::map<int, HierarchyChangedCallback> callbacks;
      MessageId hierarchyUpdatedMessage = NoMessage;
    };
  }
}