AssetSystem.cpp

#include "AssetSystem.h"
 
#include "Context.h"
#include "EntityStore.h"
 
#include "Resources/AssetManager.h"
#include "Resources/ModelManager.h"
#include "Resources/MaterialManager.h"
 
#include "Serialization/SceneReader.h"
#include "Serialization/EntityCreator.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/CameraSystem.h"
 
#include "Resources/ResourceStore.h"
#include "Resources/ModelManager.h"
#include "Serialization/ModelLoader.h"
 
#include "Systems/Core/ClipShapeSystem.h"
#include "Systems/Core/RenderSystem.h"
#include "Systems/Core/MeshSystem.h"
#include "Systems/Core/SceneSystem.h"
#include "Systems/Core/DynamicComponentSystem.h"
 
#include "Resources/MaterialInstance.h"
 
#include "Platform/Instrumentation.h"
 
#include "Services/Variables.h"
#include "Services/QualityService.h"
 
#include "Utilities/Parallel.h"
 
#include "AssetInstanceData.h"
 
#include "Foundation/Collections/Pool.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
#include "Foundation/Platform/Timer.h"
#include "Foundation/Memory/MemTypeAllocator.h"
 
 
using namespace Cogs::Geometry;
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("AssetSystem");
 
  constexpr Cogs::StringView lodFreezeVariableName             = "resources.assets.lodFreeze";
  constexpr Cogs::StringView cullModelsName                    = "resources.assets.cullModels";
  constexpr Cogs::StringView maxModelsInFlightVariableName     = "resources.assets.maxModelsInFlight";
  constexpr Cogs::StringView maxModelLoadsPerFrameVariableName = "resources.assets.maxModelLoadsPerFrame";
  constexpr Cogs::StringView maxDistanceVariableName           = "resources.assets.maxDistance";
  constexpr Cogs::StringView maxLodDepthVariableName           = "resources.assets.maxLodDepth";
  constexpr Cogs::StringView allowMaterialOverride             = "resources.assets.allowMaterialOverride";
 
  constexpr bool kDefaultLodFreeze = false;
  constexpr int kDefaultMaxModelsInFlight = 100;
  constexpr int kDefaultMaxModelLoadsPerFrame = 100;
  constexpr float kDefaultMaxDistance = -1.0f;
  constexpr int kDefaultMaxLodDepth = -1;
  constexpr bool kDefaultAllowMaterialOverride = true;
 
  const Cogs::Core::StringRef idsString = Cogs::Core::Strings::add("ids");
  const Cogs::Core::StringRef bboxString = Cogs::Core::Strings::add("bbox");
  const Cogs::Core::StringRef errorsString = Cogs::Core::Strings::add("errors");
  const Cogs::Core::StringRef byteSizeString = Cogs::Core::Strings::add("byteSize");
 
  constexpr uint32_t NoValue = static_cast<uint32_t>(-1);
 
  template<class T> using AssetInstanceVector = std::vector<T, Cogs::Memory::MemTypeAllocator<T, Cogs::MemBlockType::AssetInstance>>;
  template<class T> using AssetSystemVector = std::vector<T, Cogs::Memory::MemTypeAllocator<T, Cogs::MemBlockType::AssetSystemData>>;
 
  bool cullModelsValue = true;
 
}
 
namespace Cogs::Core
{
  struct EntityInstanceFlags
  {
    enum EFlags
    {
      Staging = SceneEntityFlags::Last << 1,
      Ready = Staging << 1,
      Spawned = Ready << 1,
    };
  };
 
  struct EntityInstanceData
  {
    uint32_t index = 0;
    uint32_t flags = 0;
 
    union
    {
      struct
      {
        uint32_t target;
        uint32_t current;
        uint32_t index;
      } lod;
 
      struct
      {
        uint32_t index;
      } model;
 
      struct AssetInstanceData * assetInstance;
    };
 
    uint32_t nextSibling = ::NoValue;
    uint32_t nextLodSibling = ::NoValue;
 
    EntityPtr entity;
    ComponentModel::Entity * entityPtr = nullptr;
 
    void setFlag(uint32_t flag, bool value) { flags = (flags & ~flag) | (uint32_t(-(int32_t)value) & flag); }
 
    void setStaging(bool value) { setFlag(EntityInstanceFlags::Staging, value); }
    bool isStaging() const { return flags & EntityInstanceFlags::Staging; }
 
    void setReady(bool value) { setFlag(EntityInstanceFlags::Ready, value); }
    bool isReady() const { return flags & EntityInstanceFlags::Ready; }
 
    void setSpawned(bool value) { setFlag(EntityInstanceFlags::Spawned, value); }
    bool isSpawned() const { return flags & EntityInstanceFlags::Spawned; }
 
    bool isAtDesiredLod() const { return lod.current == lod.target; }
    bool isVisible() const { return lod.target != ::NoValue; }
 
    bool isLodGroup() const { return flags & SceneEntityFlags::LodGroup; }
    bool isAsset() const { return flags & SceneEntityFlags::Asset; }
    bool isModel() const { return flags & SceneEntityFlags::Model; }
    bool hasChildren() const { return flags & SceneEntityFlags::Children; }
    bool hasError() const { return flags & SceneEntityFlags::Error; }
  };
 
  struct LodInstanceData
  {
    AssetInstanceVector<float> errors;
    AssetInstanceVector<uint32_t> ids;
    AssetInstanceVector<uint32_t> lods;
 
    uint32_t previousTarget = ::NoValue;
    uint32_t nextLodSibling = ::NoValue;
  };
 
  struct ModelFileData
  {
    ModelHandle model;
    std::string path;
    uint32_t byteSize = 0;
    uint32_t references = 0;
    struct AssetModelRequest * request = nullptr;
    bool requested = false;
    bool ready = false;
 
    void setReady() { ready = true; }
 
    void unref()
    {
      assert(references > 0 && "Cannot dereference with zero count.");
 
      if (--references == 0) {
        model = {};
        ready = false;
        requested = false;
 
        if (request) {
          request->canceled = true;
        }
      }
    }
 
    void ref()
    {
      ++references;
      requested = true;
    }
  };
 
  struct ModelInstanceData
  {
    uint32_t index = ::NoValue;
    uint32_t fileIndex = ::NoValue;
    uint32_t part = ::NoValue;
    uint32_t depth = 0;     
    AssetGpuStats cost;
    bool requested = false;
  };
 
  struct SceneInstanceData
  {
    SceneInstanceData() : boxes(MemBlockType::AssetInstance) {}
 
    AssetInstanceVector<uint32_t> roots;                // One per scene top level entity
    AssetInstanceVector<EntityInstanceData> entities;   // One per scene entity
 
    AssetInstanceVector<LodInstanceData> lods;          // One per scene lod group
    Memory::TypedBuffer<Geometry::BoundingBox> boxes;   // One per scene entity
 
    AssetInstanceVector<ModelFileData> modelFiles;
    AssetInstanceVector<ModelInstanceData> models;
 
    EntityInstanceData & operator[](size_t index) { return entities[index]; }
 
    bool initialized = false;
 
    Geometry::BoundingBox & getLocalBounds(const EntityInstanceData & e) { return boxes[e.index]; }
    LodInstanceData & getLodData(const EntityInstanceData & e) { assert(e.isLodGroup());  return lods[e.lod.index]; }
    ModelInstanceData & getModelData(const EntityInstanceData & e) { return models[e.model.index]; }
  };
 
  struct AssetInstanceData
  {
    AssetInstanceData() :
      spawnedEntities(MemBlockType::AssetInstance),
      destroyedEntities(MemBlockType::AssetInstance)
    {}
 
    struct AssetSystemData * systemData = nullptr;
 
    AssetInstanceData * parentInstance = nullptr;
    AssetInstanceData * next = nullptr;
    AssetInstanceData * prev = nullptr;
 
    MaterialInstanceHandle material;
 
    StringView path;
    AssetHandle asset;
    uint16_t assetGeneration = 0;
 
    Entity * container = nullptr;
    uint32_t objectId = NoObjectId;
    RenderLayers renderLayers = RenderLayers::Default;
    ComponentModel::ComponentHandle clipShapeComponent = ComponentModel::ComponentHandle::Empty();
 
    SceneInstanceData scene;
 
    AssetInstanceStats stats;
 
    std::vector<uint32_t> selectedIdRanges;
 
    bool visible = false;
    bool onDemand = false;
    bool relativePaths = false;
    bool overrideMaterial = false;
    bool cloneMaterial = false;
    bool initialized = false;
    bool freezeLod = false;
    bool forceTolerance = false;
    float tolerance = 1.0f;
    float priority = 0.0f;
    float minDistance = 1.f;
 
    std::string directoryPath;
 
    Memory::TypedBuffer<EntityId> spawnedEntities;
    Memory::TypedBuffer<EntityId> destroyedEntities;
 
    bool useOverrideMaterial() const { return overrideMaterial; }
    bool useCloneMaterial() const { return cloneMaterial; }
    bool useRelativePaths() const { return relativePaths; }
 
    void spawned(EntityId entityId)
    {
      EntityId& dst = spawnedEntities.grow();
      dst = entityId;
 
      ++stats.frame.spawnedEntities;
      ++stats.numEntities;
    }
 
    void destroyed(EntityId entityId)
    {
      EntityId& dst = destroyedEntities.grow();
      dst = entityId;
 
      ++stats.frame.destroyedEntities;
      --stats.numEntities;
    }
 
    void link(AssetInstanceData * instance)
    {
      systemData = instance->systemData;
      parentInstance = instance;
 
      prev = instance;
      next = instance->next;
      if (instance->next) instance->next->prev = this;
      instance->next = this;
    }
 
    void unlink()
    {
      prev->next = next;
      if (next) next->prev = prev;
      next = prev = nullptr;
    }
 
    void destroy();
 
    SceneEntityDefinition & getDefinition(EntityInstanceData & instance)
    {
      return asset->definition.scene[instance.index];
    }
  };
 
  struct AssetUpdate
  {
    Entity * container;
    ComponentHandle component;
    AssetHandle asset;
 
    AssetInstanceData * instanceData;
  };
 
  struct AssetSystemData
  {
    AssetSystemData() :
      instanceData(MemBlockType::AssetInstance),
      requestPool(MemBlockType::AssetSystemData)
    {}
 
    Collections::Pool<AssetInstanceData> instanceData;
    Collections::Pool<AssetModelRequest> requestPool;
 
    AssetSystemVector<AssetModelRequest *> pendingRequests;
    AssetSystemVector<AssetModelRequest *> inFlightRequests;
    AssetSystemVector<AssetModelRequest *> stillInFlight;
 
    // Scratch memory used by AssetSystem::update.
    // Held here to minimize reallocations.
    AssetSystemVector<AssetUpdate> newUpdates;
    AssetSystemVector<AssetInstanceData*> currentOnDemandInstances;
    AssetSystemVector<AssetUpdate> readyUpdates;
    AssetSystemVector<AssetInstanceData*> liveAssetInstances;
 
    // Matrices used by getLodReference, pulled from main camera
    glm::mat4 worldFromView = glm::mat4(1.f);
    glm::mat4 viewFromWorld = glm::mat4(1.f);
    glm::mat4 clipFromWorld = glm::mat4(1.f);
    glm::mat4 worldFromClip = glm::mat4(1.f);
    float minDistance = 0.f;
    float maxDistance = 0.f;
    uint32_t maxLodDepth = 0;
 
    MessageId entityCreatedId = NoMessage;
    MessageId entityDestroyedId = NoMessage;
 
    MaterialInstanceHandle defaultMaterialHandle;
  };
 
  void AssetInstanceData::destroy()
  {
    unlink();
 
    systemData->instanceData.destroy(this);
  }
 
  uint32_t findFirstLodChild(const AssetDefinition & definition, uint32_t firstChild, int32_t targetLevel);
 
  void initializeAssetInstance(AssetInstanceData & assetInstance)
  {
    auto initTime = assetInstance.stats.frame.startInit();
    assetInstance.assetGeneration = static_cast<uint16_t>(assetInstance.asset->getGeneration());
    assetInstance.directoryPath = IO::parentPath(assetInstance.asset->getSource());
 
    assetInstance.stats = {};
#if ENABLE_COST_TRACKING
    assetInstance.stats.max.memory = 512 * 1024 * 1024;
    assetInstance.stats.max.drawCalls = 100'000;
    assetInstance.stats.max.primitiveCount = 10'000'000;
#endif
    assetInstance.stats.frameLimits.processingTime = 0.010;
 
    const AssetDefinition & definition = assetInstance.asset->definition;
    SceneInstanceData & scene = assetInstance.scene;
 
    scene.roots.reserve(definition.scene.numTopLevelEntities);
    scene.entities.resize(definition.scene.entities.size());
    scene.lods.reserve(definition.scene.numLodGroups);
    scene.boxes.resize(definition.scene.entities.size());
 
    std::unordered_map<size_t, uint32_t> modelFileIndexes;
 
    for (size_t i = 0; i < definition.scene.entities.size(); ++i) {
      const SceneEntityDefinition& entityDef = definition.scene.entities[i];
      EntityInstanceData & entityInstance = scene[i];
      PropertyRange properties = definition.scene.getProperties(entityDef);
 
      entityInstance.index = uint32_t(i);
      entityInstance.flags = entityDef.flags;
      entityInstance.nextSibling = entityDef.nextSibling;
      entityInstance.nextLodSibling = entityDef.nextLodSibling;
 
      if (entityDef.parentIndex == ::NoValue) {
        scene.roots.emplace_back(uint32_t(i));
      }
 
      // Entity is a AssetSystem managed lod-group
      if (entityDef.isLodGroup()) {
        entityInstance.lod.index = (uint32_t)scene.lods.size();
        auto & lodData = scene.lods.emplace_back();
 
        entityInstance.lod.current = entityInstance.lod.target = ::NoValue;
 
        std::span<const uint32_t> lodIds = properties.getProperty(idsString, std::span<const uint32_t>());
        if (!lodIds.empty()) {
          size_t lodCount = lodIds.size();
          if (lodCount % 2) {
            LOG_ERROR(logger, "Lod id range array should have an even number of items (n=%zu)", lodCount);
          }
          else {
            lodData.ids.clear();
            lodData.ids.reserve(lodCount);
            for (size_t k = 0; k + 1 < lodCount; k += 2) {
              uint32_t a = lodIds[k + 0];
              uint32_t b = lodIds[k + 1];
              if (b < a) {
                LOG_ERROR(logger, "Lod id range contains an invalid range ([%u, %u])", a, b);
                lodData.ids.clear();
                break;
              }
              if (!lodData.ids.empty() && b < lodData.ids.back()) {
                LOG_ERROR(logger, "Lod id ranges are not sorted.");
                lodData.ids.clear();
                break;
              }
              lodData.ids.emplace_back(a);
              lodData.ids.emplace_back(b);
            }
          }
        }
 
        std::span<const float> bboxValues = properties.getProperty(bboxString, std::span<const float>());
        if (bboxValues.size() == 6) {
          scene.boxes[entityDef.index] = Geometry::BoundingBox(std::span<const float, 6>(bboxValues));
        }
        else {
          LOG_ERROR(logger, "Lod level item bounding box has wrong number of elements (%zu != 6)", bboxValues.size());
          scene.boxes[entityDef.index] = Cogs::Geometry::BoundingBox();
        }
 
        std::span<const float> errorValues = properties.getProperty(errorsString, std::span<const float>());
        if (errorValues.size() != entityDef.lod.numLods) {
          LOG_WARNING(logger, "Lod level item count (=%u) does not match number of error values (=%zu)", entityDef.lod.numLods, errorValues.size());
        }
 
        if (errorValues.size()) {
          lodData.errors.assign(errorValues.begin(), errorValues.end());
          // We have at least one item, fill until we have enought exponentially.
          while (lodData.errors.size() < entityDef.lod.numLods) lodData.errors.push_back(lodData.errors.back() * lodData.errors.back());
        }
 
        // No values at all
        else {
          lodData.errors.resize(entityDef.lod.numLods);
 
          // If we have a bounding box, use its diagonal as a scale for the levels
          float scale = 1.f;
          if (!isEmpty(scene.boxes[entityDef.index])) scale = glm::distance(scene.boxes[entityDef.index].min, scene.boxes[entityDef.index].max);
 
          for (size_t l = 0; l < lodData.errors.size(); ++l) {
            lodData.errors[l] = scale * scale * float(l) * float(l);
          }
        }
 
        lodData.lods.resize(entityDef.lod.numLods);
        for (uint32_t j = 0; j < entityDef.lod.numLods; ++j) {
          lodData.lods[j] = findFirstLodChild(definition, entityDef.firstChild, j);
        }
 
      }
 
      else if (entityDef.isModel()) {
        uint32_t modelIndex = uint32_t(scene.models.size());
        ModelInstanceData & modelData = scene.models.emplace_back();
        modelData.index = entityInstance.index;
        modelData.cost = { 0, 0, 0 };
        modelData.part = entityDef.model.part;
        modelData.depth = entityDef.model.depth;
        entityInstance.model.index = modelIndex;
 
        if (entityInstance.hasError()) continue;
 
        // Extract bounding box if provided
        Cogs::Geometry::BoundingBox bbox;
        if (entityDef.numProperties) {
          std::span<const float> bboxValues = properties.getProperty(bboxString, std::span<const float>());
          if (bboxValues.size() == 6) {
            bbox = Geometry::BoundingBox(std::span<const float, 6>(bboxValues));
          }
        }
        scene.boxes[entityDef.index] = bbox;
 
        // Link to existing ModelFileData or create new instance
        std::string path;
        const PropertyInfo& pathItem = definition.scene.properties.getPropertyByIndex(entityDef.model.index);
        if (pathItem.type == PropertyType::UnsignedInteger) {
          path = createAssetResourcePathFromIndex(pathItem.uintValue, AssetResourceType::Model);
        }
        else if (pathItem.type == PropertyType::String) {
          path = definition.scene.properties.getString(entityDef.model.index).to_string();
        }
 
        size_t code = StringView(path).hash();
        if (auto foundIt = modelFileIndexes.find(code); foundIt != modelFileIndexes.end()) {
          modelData.fileIndex = foundIt->second;
        }
 
        else {
          uint32_t fileIndex = (uint32_t)scene.modelFiles.size();
          ModelFileData & modelFile = scene.modelFiles.emplace_back();
 
          if (assetInstance.useRelativePaths() && IO::isRelative(path)) {
            modelFile.path = IO::combine(assetInstance.directoryPath, std::move(path));
          } else {
            modelFile.path = std::move(path);
          }
 
          int byteSize = properties.getProperty(byteSizeString, 0);
          if (byteSize) {
            modelFile.byteSize = byteSize;
          } else {
            modelFile.byteSize = 1000;
          }
 
          modelData.fileIndex = fileIndex;
          modelFileIndexes[code] = fileIndex;
        }
      }
    }
 
    scene.initialized = true;
  }
 
  glm::vec3 euclidean(const glm::vec4& a)
  {
    return (1.f / a.w)*glm::vec3(a);
  }
 
  struct AssetLodReference
  {
    glm::vec3 frustumEdgesP[4];
    glm::vec3 frustumEdgesD[4];
 
    glm::vec3 lodRef = glm::vec3(0, 0, 0);
    glm::vec4 planes[12] = { glm::vec4(0,0,0,1), glm::vec4(0,0,0,1),glm::vec4(0,0,0,1),glm::vec4(0,0,0,1),glm::vec4(0,0,0,1) };
    uint32_t planeCount = 6;
    bool invertedClip = false;  // Invert the test for the clip planes (plane 6 and up).
 
    float nearDistance = 1.f;
    float maxDistance = FLT_MAX;
    uint32_t maxLodDepth = ~0u;
    uint32_t frustumCullIn = 0;
    uint32_t frustumCullOut = 0;
    uint32_t bboxCullOut = 0;
  };
 
  void getLodReference(Context* context, AssetInstanceData& assetInstance, AssetLodReference & lodRef, Entity * ref)
  {
    const AssetSystemData* systemData = assetInstance.systemData;
 
    TransformComponent* trCompRef = ref->getComponent<TransformComponent>();
    if (!trCompRef) return;
    if (trCompRef->hasChanged()) {
      context->transformSystem->updateTransformData(*trCompRef);
    }
 
    const glm::mat4& worldFromModel = context->transformSystem->getLocalToWorld(ref->getComponent<TransformComponent>());
    const glm::mat4 modelFromWorld = glm::inverse(worldFromModel);
    const glm::mat4 modelFromView = modelFromWorld * systemData->worldFromView;
    const glm::mat4 rawViewProjectionTransposed = glm::transpose(systemData->clipFromWorld * worldFromModel);
 
    lodRef.lodRef = euclidean(modelFromView * glm::vec4(0, 0, 0, 1));
    lodRef.nearDistance = std::max(assetInstance.minDistance, systemData->minDistance);
    lodRef.planes[0] = rawViewProjectionTransposed[3] + rawViewProjectionTransposed[0]; // Left.
    lodRef.planes[1] = rawViewProjectionTransposed[3] - rawViewProjectionTransposed[0]; // Right.
    lodRef.planes[2] = rawViewProjectionTransposed[3] + rawViewProjectionTransposed[1]; // Bottom.
    lodRef.planes[3] = rawViewProjectionTransposed[3] - rawViewProjectionTransposed[1]; // Top.
 
    if (0 < systemData->maxDistance) {
      lodRef.planes[4] = glm::transpose(systemData->viewFromWorld * worldFromModel) * glm::vec4(0, 0, 1, systemData->maxDistance);
      lodRef.maxDistance = systemData->maxDistance;
    }
    else {
      lodRef.planes[4] = glm::vec4(0, 0, 0, 1); // will always pass
    }
 
    // calc near plane through eye
    lodRef.planes[5] = glm::vec4(normalize(euclidean(modelFromView * glm::vec4(0, 0, -1, 1)) - lodRef.lodRef), 0.f);
    lodRef.planes[5].w = -dot(glm::vec3(lodRef.planes[5]), lodRef.lodRef);
 
    lodRef.planeCount = 6;
    if (const ClipShapeComponent* clipComp = assetInstance.clipShapeComponent.resolveComponent<ClipShapeComponent>(); clipComp) {
      const ClipShapeData& clipData = context->clipShapeSystem->getData(clipComp);
      switch (clipData.shape) {
      case ClipShapeType::None:
        break;
      case ClipShapeType::Cube:
      case ClipShapeType::InvertedCube:
        assert(clipData.planeCount == 6);
        for (size_t i = 0; i < clipData.planeCount; i++) {
          lodRef.planes[lodRef.planeCount++] = clipData.planes[i] * worldFromModel;
        }
        lodRef.invertedClip = clipData.shape == ClipShapeType::InvertedCube;
        break;
      default:
        assert(false && "Unhandled case");
        break;
      }
    }
 
    lodRef.maxLodDepth = systemData->maxLodDepth;
 
    const glm::mat4 M = modelFromWorld * systemData->worldFromClip;
    for (size_t i = 0; i < 4; i++) {
      glm::vec3 a = euclidean(M * glm::vec4((i & 1) ? -1.f : 1.f,
                                            (i & 2) ? -1.f : 1.f,
                                            -1.f, 1.f));
      glm::vec3 b = euclidean(M * glm::vec4((i & 1) ? -1.f : 1.f,
                                            (i & 2) ? -1.f : 1.f,
                                            1.f, 1.f));
      float az = dot(lodRef.planes[5], glm::vec4(a, 1.f));
      float bz = dot(lodRef.planes[5], glm::vec4(b, 1.f));
      lodRef.frustumEdgesD[i] = (1.f / (bz - az)) * (b - a);      // Scale direction to unit step along depth in view
      lodRef.frustumEdgesP[i] = a - az * lodRef.frustumEdgesD[i]; // Move back until plane through eye
    }
  }
 
  bool isOutside(AssetLodReference& lodReference, const Geometry::BoundingBox & bbox)
  {
    float minDist, maxDist;
    bool outsideOne = false;
    size_t fullyInside = 0;
    for (size_t j = 0; j < 6; j++) {
      minDist = FLT_MAX;
      maxDist = -FLT_MAX;
      for (size_t i = 0; i < 8; i++) {
        glm::vec4 p((i & 1) ? bbox.min.x : bbox.max.x,
                    (i & 2) ? bbox.min.y : bbox.max.y,
                    (i & 4) ? bbox.min.z : bbox.max.z,
                    1.f);
        float t = dot(lodReference.planes[j], p);
        minDist = std::min(minDist, t);
        maxDist = std::max(maxDist, t);
      }
      if (maxDist < 0.f) {
        outsideOne = true;
      }
      if (0 <= minDist) {
        fullyInside++;
      }
    }
 
    { // ClipShape clipping
      size_t fullyInsideClip = 0;
      bool outsideOneClip = false;
      for (size_t j = 6; j < lodReference.planeCount; j++) {
        float min = FLT_MAX;
        float max = -FLT_MAX;
        for (size_t i = 0; i < 8; i++) {
          glm::vec4 p((i & 1) ? bbox.min.x : bbox.max.x,
                      (i & 2) ? bbox.min.y : bbox.max.y,
                      (i & 4) ? bbox.min.z : bbox.max.z,
                      1.f);
          float t = dot(lodReference.planes[j], p);
          min = std::min(min, t);
          max = std::max(max, t);
        }
        if (max < 0.f) {
          outsideOneClip = true;
        }
        if (0 <= min) {
          fullyInsideClip++;
        }
      }
 
      if (lodReference.invertedClip == false) {
        outsideOne = outsideOne || outsideOneClip;
        fullyInside += fullyInsideClip;
      }
      else {
        if (6 + fullyInsideClip == lodReference.planeCount) {
          return true;
        }
      }
    }
 
    if (outsideOne) {
      // bbox is completely outside one of the frustum planes, absolutely outside.
      lodReference.frustumCullOut++;
      return true;
    }
    else if (fullyInside == lodReference.planeCount) {
      // bbox is completely inside all of the frustum planes, absolutely inside.
      lodReference.frustumCullIn++;
      return false;
    }
    else {
      // bbox intersects some of the planes, indeterminate.
      // Tighten frustum around depth-range of bbox and check that against the bbox planes
      minDist = std::max(0.f, std::min(lodReference.maxDistance, minDist));
      maxDist = std::max(0.f, std::min(lodReference.maxDistance, maxDist));
      uint32_t planes = 63u;
      for (size_t i = 0; i < 4; i++) {
        glm::vec3 pa = lodReference.frustumEdgesP[i] + minDist * lodReference.frustumEdgesD[i];
        planes = planes & ((pa.x < bbox.min.x ? 1 : 0) |
                           (pa.y < bbox.min.y ? 2 : 0) |
                           (pa.z < bbox.min.z ? 4 : 0) |
                           (bbox.max.x < pa.x ? 8 : 0) |
                           (bbox.max.y < pa.y ? 16 : 0) |
                           (bbox.max.z < pa.z ? 32 : 0));
        glm::vec3 pb = lodReference.frustumEdgesP[i] + maxDist * lodReference.frustumEdgesD[i];
        planes = planes & ((pb.x < bbox.min.x ? 1 : 0) |
                           (pb.y < bbox.min.y ? 2 : 0) |
                           (pb.z < bbox.min.z ? 4 : 0) |
                           (bbox.max.x < pb.x ? 8 : 0) |
                           (bbox.max.y < pb.y ? 16 : 0) |
                           (bbox.max.z < pb.z ? 32 : 0));
      }
      if (planes != 0) {
        lodReference.bboxCullOut++;
        return true;
      }
    }
 
    // Cannot guarantee that it is not visible
    lodReference.frustumCullIn++;
    return false;
  }
 
  void updateLodGroupDesiredLevel(AssetInstanceData & instance, AssetLodReference & lodReference, EntityInstanceData & lodInstance, uint32_t lodDepth, const float tolerance)
  {
    auto & localBounds = instance.scene.getLocalBounds(lodInstance);
    auto & lodData = instance.scene.getLodData(lodInstance);
    auto & errors = lodData.errors;
 
 
    lodData.previousTarget = lodInstance.lod.target;
 
    if (!instance.visible) {
      lodInstance.lod.target = ::NoValue;
      return;
    }
 
    if (!instance.selectedIdRanges.empty() && !lodData.ids.empty()) {
      // If lod level contains id ranges and we have specified which we
      // are interested in, only instantiate lod level if there is some
      // overlap between these two sets of ranges.
 
      const std::vector<uint32_t>& selectedIds = instance.selectedIdRanges;
      const size_t selectedCount = selectedIds.size() / 2;
 
      const AssetInstanceVector<uint32_t>& lodIds = lodData.ids;
      const size_t lodCount = lodIds.size() / 2;
 
      // Since the two ranges are sorted, it is possible to do this more
      // cleverly, reducing complexity from n^2 to n. But the number of
      // ranges are assumed to be low (4 or less), the naive n^2 approach
      // is probably ok.
      bool overlap = false;
      for (size_t j = 0; !overlap && j < selectedCount; j++) {
        const uint32_t selectedMin = selectedIds[2 * j + 0];
        const uint32_t selectedMax = selectedIds[2 * j + 1];
 
        for (size_t i = 0; !overlap && i < lodCount; i++) {
          const uint32_t lodMin = lodIds[2 * i + 0];
          const uint32_t lodMax = lodIds[2 * i + 1];
 
          // Check if there is some overlap between [selectedMin,seletedMax] and [lodMin,lodMax],
          if (lodMin <= selectedMax && selectedMin <= lodMax) {
            overlap = true;
          }
        }
      }
      if (!overlap) {
        lodInstance.lod.target = ::NoValue;
        return;
      }
    }
 
    const bool outside = isOutside(lodReference, localBounds);
    if (outside) {
      lodInstance.lod.target = ::NoValue;
    } else {
      const uint32_t maxLodDepth = lodReference.maxLodDepth;
      const size_t maxLocalLodDepth = maxLodDepth - std::min(maxLodDepth, lodDepth);
 
      // lodref constrainted to bounding box.
      glm::vec3 nearest = glm::max(localBounds.min, glm::min(localBounds.max, lodReference.lodRef));
      auto d = glm::max(lodReference.nearDistance, glm::distance(nearest, lodReference.lodRef));
 
      auto error = d * tolerance;
 
      const size_t N = errors.size();
      const size_t M = N - 1;
      const size_t O = M - std::min(M, maxLocalLodDepth);
      if (N == 0) {
        // No lod-levels
        lodInstance.lod.target = ::NoValue;
      }
      else if (lodInstance.lod.current == ::NoValue) {
        // No geometry present, load the most crappy version to have something to show.
        lodInstance.lod.target = static_cast<uint32_t>(M);
      }
      else if (M <= 8) {
        // Small number of levels, use linear search
        size_t i = O;
        for (; i < M && errors[i + 1] < error; i++) {}
        lodInstance.lod.target = static_cast<uint32_t>(i);
      }
      else {
        // Bisection to find lod with appropriate error.
        size_t i1 = M;
        size_t i0 = O;
        while (i0 + 1 < i1) {
          size_t m = (i0 + i1) / 2;
          assert(i0 != m);
          assert(i1 != m);
          bool less = error < errors[m];
          i0 = less ? i0 : m;   // random probability, so conditional move is prob better than branch prediction.
          i1 = less ? m : i1;
        }
        if (i0 < i1) {
          bool less = error < errors[i1];
          i0 = less ? i0 : i1;
        }
        lodInstance.lod.target = static_cast<uint32_t>(i0);
      }
    }
  }
 
  uint32_t findFirstLodChild(const AssetDefinition & definition, uint32_t firstChild, int32_t targetLevel)
  {
    uint32_t childIndex = definition.scene.getChild(firstChild, 0);
 
    for (int32_t i = 0; i < targetLevel; ++i) {
      // Skip all on current lod level
      auto ccDef = &definition.scene[childIndex];
 
      while (ccDef->nextLodSibling != ::NoValue) {
        ccDef = &definition.scene[ccDef->nextLodSibling];
      }
 
      childIndex = ccDef->nextSibling;
    }
 
    return childIndex;
  }
 
  void calculateModelCost(Context * /*context*/, ModelInstanceData & modelData, Model * model)
  {
    modelData.cost = { 0, 0, 0 };
    //modelData.cost.memory = modelData.byteSize;
 
    auto parts = modelData.part == ::NoValue ? std::span(model->parts) : std::span(&model->parts[modelData.part], &model->parts[modelData.part] + 1);
 
    for (auto & part : parts) {
      //TODO: Handle line, point etc.
      if (part.vertexCount == ::NoValue && part.meshIndex != ::NoValue) {
        auto & mesh = model->meshes[part.meshIndex];
        modelData.cost.primitiveCount += mesh->getCount() / 3;
      } else {
        modelData.cost.primitiveCount += part.vertexCount / 3;
      }
 
      modelData.cost.drawCalls += part.meshIndex != ::NoValue ? 1 : 0;
    }
  }
 
#if ENABLE_COST_TRACKING
  void calculateCost(Context* context, AssetInstanceData & instance, EntityInstanceData & entityInstance)
  {
    if (entityInstance.hasError()) return;
 
    if (entityInstance.isLodGroup() && entityInstance.lod.current != ::NoValue) {
      auto & lodData = instance.scene.getLodData(entityInstance);
      uint32_t childIndex = lodData.lods[entityInstance.lod.current];
 
      while (childIndex != ::NoValue) {
        calculateCost(context, instance, instance.scene[childIndex]);
 
        childIndex = instance.scene[childIndex].nextLodSibling;
      }
    } else if (entityInstance.isAsset() && entityInstance.isSpawned()) {
      auto & nestedInstance = *entityInstance.assetInstance;
      nestedInstance.stats.current = { 0, 0, 0 };
      for (size_t i = 0; i < nestedInstance.scene.roots.size(); ++i) {
        calculateCost(context, nestedInstance, nestedInstance.scene[nestedInstance.scene.roots[i]]);
      }
      instance.stats.current += nestedInstance.stats.current;
    } else if (entityInstance.isModel() && entityInstance.isSpawned()) {
      auto & modelData = instance.scene.getModelData(entityInstance);
      instance.stats.current += modelData.cost;
    } else {
 
    }
  }
#endif
 
#if ENABLE_COST_TRACKING
  void estimateCost(Context* context, AssetInstanceData & instance, EntityInstanceData & entityInstance)
  {
    if (entityInstance.hasError()) return;
 
    if (entityInstance.isLodGroup() && entityInstance.isVisible()) {
      auto & lodData = instance.scene.getLodData(entityInstance);
      uint32_t childIndex = lodData.lods[entityInstance.lod.target];
 
      while (childIndex != ::NoValue) {
        estimateCost(context, instance, instance.scene[childIndex]);
 
        childIndex = instance.scene[childIndex].nextLodSibling;
      }
    } else if (entityInstance.isAsset() && entityInstance.isSpawned()) {
      auto & nestedInstance = *entityInstance.assetInstance;
      nestedInstance.stats.projected = { 0, 0, 0 };
      for (size_t i = 0; i < nestedInstance.scene.roots.size(); ++i) {
        estimateCost(context, nestedInstance, nestedInstance.scene[nestedInstance.scene.roots[i]]);
      }
      instance.stats.projected += nestedInstance.stats.projected;
    } else if (entityInstance.isModel()) {
      //auto & modelData = instance.scene.getModelData(entityInstance);
      //instance.stats.projected.memory += modelData.byteSize;
      instance.stats.projected.drawCalls += 1;
    } else {
      const uint64_t bogusEstimate = 10 * 1024;
      instance.stats.projected.memory += bogusEstimate;
    }
  }
#endif
 
  void updateAssetDesiredLevels(Context* context, AssetInstanceData& assetInstance, uint32_t lodDepth, uint32_t maxIterations);
 
  void updateEntityDesiredLevels(Context* context, AssetInstanceData & instance, AssetLodReference & lodReference, EntityInstanceData & entityInstance, uint32_t lodDepth, const float tolerance)
  {
    if (entityInstance.isLodGroup()) {
      updateLodGroupDesiredLevel(instance, lodReference, entityInstance, lodDepth, tolerance);
 
      if (entityInstance.isVisible() && entityInstance.isAtDesiredLod()) {
        auto & lodData = instance.scene.getLodData(entityInstance);
        uint32_t childIndex = lodData.lods[entityInstance.lod.target];
 
        // Entities of a given lod-group, we increase lod depth when we recurse into that
        while (childIndex != ::NoValue) {
 
          updateEntityDesiredLevels(context, instance, lodReference, instance.scene[childIndex], lodDepth + 1 + entityInstance.lod.target, tolerance);
 
          childIndex = instance.scene[childIndex].nextLodSibling;
        }
      }
    } else if (entityInstance.isSpawned()) {
      auto & definition = instance.asset->definition;
      auto & entityDefinition = definition.scene[entityInstance.index];
 
      if (entityInstance.isAsset()) {
        entityInstance.assetInstance->tolerance = instance.tolerance;
        entityInstance.assetInstance->forceTolerance = instance.forceTolerance;
#if ENABLE_COST_TRACKING
        entityInstance.assetInstance->stats.toleranceScale = instance.stats.toleranceScale;
#endif
        entityInstance.assetInstance->visible = instance.visible;
 
        entityInstance.assetInstance->stats.frustumCullIn = 0;
        entityInstance.assetInstance->stats.frustumCullOut = 0;
        entityInstance.assetInstance->stats.bboxCullOut = 0;
        updateAssetDesiredLevels(context, *entityInstance.assetInstance, lodDepth, 1);
        instance.stats.frustumCullIn += entityInstance.assetInstance->stats.frustumCullIn;
        instance.stats.frustumCullOut += entityInstance.assetInstance->stats.frustumCullOut;
        instance.stats.bboxCullOut += entityInstance.assetInstance->stats.bboxCullOut;
      } else if (entityInstance.hasChildren()) {
        uint32_t childIndex = entityDefinition.firstChild;
 
        while (childIndex != ::NoValue) {
          updateEntityDesiredLevels(context, instance, lodReference, instance.scene[childIndex], lodDepth, tolerance);
 
          childIndex = definition.scene[childIndex].nextSibling;
        }
      }
    }
  }
 
#if ENABLE_COST_TRACKING
  bool updateToleranceScale(AssetInstanceStats & stats)
  {
    const float currentToleranceScale = stats.toleranceScale;
    const float frameToleranceMax = glm::min(currentToleranceScale + stats.toleranceScaleIncrement, stats.toleranceScaleMax);
    const float frameToleranceMin = glm::max(currentToleranceScale - stats.toleranceScaleIncrement, stats.toleranceScaleMin);
 
    if (stats.projected.memory > stats.max.memory) {
      const float newToleranceScale = (0.9f * stats.max.memory) / glm::max((decltype(stats.current.memory))1, stats.current.memory) * stats.toleranceScale;
      stats.toleranceScale = glm::clamp(newToleranceScale, frameToleranceMin, frameToleranceMax);
      return true;
    } else if (stats.projected.memory < 0.8f * stats.max.memory) {
      if (stats.current.memory != 0) {
        const float targetToleranceScale = stats.max.memory / glm::max((decltype(stats.current.memory))1, stats.current.memory) * currentToleranceScale;
        stats.toleranceScale = glm::clamp(targetToleranceScale, frameToleranceMin, frameToleranceMax);
      } else {
        stats.toleranceScale = frameToleranceMax;
      }
 
      return true;
    }
 
    return false;
  }
#endif
 
  void updateAssetDesiredLevels(Context* context, AssetInstanceData & assetInstance, uint32_t lodDepth, uint32_t maxIterations)
  {
    CpuInstrumentationScope(SCOPE_ASSETSYSTEM, "AssetSystem::updateAssetDesiredLevels");
    auto lodTime = assetInstance.stats.frame.startLodCalculation();
 
    AssetLodReference lodReference = {};
    getLodReference(context, assetInstance, lodReference, assetInstance.container);
 
    auto & scene = assetInstance.scene;
 
    float tolerance = assetInstance.tolerance;
#if ENABLE_COST_TRACKING
    uint64_t prevIteration = assetInstance.stats.projected.memory;
#endif
#if ENABLE_COST_TRACKING
    for (uint32_t it = 0; it < maxIterations; it++) {
      float clampedTolerance = glm::max(1e-5f, (1.f / assetInstance.stats.toleranceScale) * tolerance);
#else
    if (maxIterations > 0) {
      float clampedTolerance = tolerance;
#endif
      if (assetInstance.forceTolerance) clampedTolerance = assetInstance.tolerance;
 
      for (auto & root : scene.roots) {
        updateEntityDesiredLevels(context, assetInstance, lodReference, scene[root], lodDepth, clampedTolerance);
      }
 
      assetInstance.stats.frustumCullIn += lodReference.frustumCullIn;
      assetInstance.stats.frustumCullOut += lodReference.frustumCullOut;
      assetInstance.stats.bboxCullOut += lodReference.bboxCullOut;
 
#if ENABLE_COST_TRACKING
      if (assetInstance.parentInstance) {
        break;
      }
 
      {
        CpuInstrumentationScope(SCOPE_ASSETSYSTEM, "AssetSystem::estimateCost");
 
        assetInstance.stats.projected = { 0, 0, 0 };
        for (size_t i = 0; i < scene.roots.size(); ++i) {
          estimateCost(context, assetInstance, scene[scene.roots[i]]);
        }
      }
 
      if (assetInstance.stats.projected.memory == prevIteration) {
        break;
      } else {
        prevIteration = assetInstance.stats.projected.memory;
      }
 
      if (!updateToleranceScale(assetInstance.stats)) {
        break;
      }
#endif
    }
  }
 
  void clearEntity(Context * context, AssetInstanceData & assetInstance, EntityInstanceData & entityInstance)
  {
    if (entityInstance.entity) {
      assetInstance.destroyed(entityInstance.entity->getId());
    }
 
    entityInstance.entity = {};
    entityInstance.setSpawned(false);
    entityInstance.setReady(false);
 
    if (entityInstance.isLodGroup()) {
      entityInstance.lod.current = ::NoValue;
    }
 
    if (entityInstance.isStaging()) {
      entityInstance.setStaging(false);
    }
 
    if (entityInstance.hasChildren()) {
      auto & definition = assetInstance.asset->definition;
      auto & entityDefinition = definition.scene[entityInstance.index];
 
      for (uint32_t i = 0; i < entityDefinition.numChildren; ++i) {
        uint32_t childIndex = definition.scene.getChild(entityDefinition.firstChild, i);
 
        clearEntity(context, assetInstance, assetInstance.scene[childIndex]);
      }
    } else if (entityInstance.isAsset() && entityInstance.assetInstance) {
      for (auto & instance : entityInstance.assetInstance->scene.entities) {
        clearEntity(context, *entityInstance.assetInstance, instance);
      }
 
      entityInstance.assetInstance->destroy();
      entityInstance.assetInstance = nullptr;
    } else if (entityInstance.isModel()) {
      auto & modelData = assetInstance.scene.getModelData(entityInstance);
 
      //if (modelData.model && spawned) {
      //  //TODO: Send destroyed message for all parts.
      //  assetInstance.stats.numEntities -= modelData.part == ::NoValue ? (uint32_t)modelData.model->parts.size() : 1;
      //}
 
      if (modelData.requested) {
        auto & modelFile = assetInstance.scene.modelFiles[modelData.fileIndex];
        modelFile.unref();
        modelData.requested = false;
      }
    }
  }
 
  bool checkEntity(Context * context, AssetLodReference& lodReference, AssetInstanceData & assetInstance, EntityInstanceData & entityInstance, EntityInstanceData * parentInstance)
  {
    if (entityInstance.hasError()) return true;
 
    if (cullModelsValue && entityInstance.isModel()) {
      AssetDefinition& assetDef = assetInstance.asset->definition;
      SceneEntityDefinition& entityDef = assetDef.scene[entityInstance.index];
      const Cogs::Geometry::BoundingBox& bbox = assetInstance.scene.boxes[entityDef.index];
      if (!isEmpty(bbox) && isOutside(lodReference, bbox)) {
        ModelInstanceData& modelData = assetInstance.scene.getModelData(entityInstance);
        if (entityInstance.isSpawned() || entityInstance.isReady() || modelData.requested) {
          clearEntity(context, assetInstance, entityInstance);
        }
        return true;
      }
    }
 
    if (entityInstance.isReady()) return true;
 
    if (entityInstance.isModel()) {
      auto& modelData = assetInstance.scene.getModelData(entityInstance);
      auto& modelFile = assetInstance.scene.modelFiles[modelData.fileIndex];
 
      constexpr uint32_t kPriorityPerLevel = 1000;
      constexpr uint32_t kMaxInstancePriority = 100000;
 
      if (!modelData.requested) {
        if (!modelFile.requested) {
          AssetModelRequest* request = assetInstance.systemData->requestPool.create();
          request->assetInstance = &assetInstance;
          request->modelFileIndex = modelData.fileIndex;
          request->path = modelFile.path;
          request->priority += (uint32_t)((float)kMaxInstancePriority * assetInstance.priority);
          modelFile.request = request;
          assetInstance.systemData->pendingRequests.emplace_back(request);
          ++assetInstance.stats.frame.modelsRequested;
          ++assetInstance.stats.numRequests;
 
          modelFile.requested = true;
        }
 
        if (modelFile.request) {
          modelFile.request->priority += modelData.depth * kPriorityPerLevel;
        }
 
        modelFile.ref();
 
        modelData.requested = true;
      }
 
      if (modelFile.ready) {
        entityInstance.setReady(true);
        return true;
      }
 
      if (!modelFile.model) return false;
 
      if (!modelFile.model->isLoaded()) return false;
 
      for (auto & mesh : modelFile.model->meshes) {
        if (!mesh->isInitialized() && mesh->getCount() == 0) continue;
        if (!mesh->hasAttachedResource()) return false;
      }
 
      if (!assetInstance.useOverrideMaterial() && !assetInstance.useCloneMaterial()) {
        for (auto & material : modelFile.model->materials) {
          if (!material->isActive()) return false;
        }
      }
 
      modelFile.setReady();
 
      entityInstance.setReady(true);
 
      // Trigger a new frame as this model ready might open up for new lod-levels.
      context->engine->setDirty();
      return true;
    } else if (entityInstance.isAsset()) {
      auto & definition = assetInstance.asset->definition;
      auto & entityDefinition = definition.scene[entityInstance.index];
 
      if (!entityInstance.assetInstance) {
        entityInstance.assetInstance = assetInstance.systemData->instanceData.create();
        entityInstance.assetInstance->link(&assetInstance);
        entityInstance.assetInstance->container = parentInstance->entityPtr;
        entityInstance.assetInstance->objectId = assetInstance.objectId;
        entityInstance.assetInstance->renderLayers = assetInstance.renderLayers;
        entityInstance.assetInstance->clipShapeComponent = assetInstance.clipShapeComponent;
      }
 
      if (!entityInstance.assetInstance->initialized) {
 
        std::string path;
        const PropertyInfo& pathItem = definition.scene.properties.getPropertyByIndex(entityDefinition.asset.index);
        if (pathItem.type == PropertyType::UnsignedInteger) {
          path = createAssetResourcePathFromIndex(pathItem.uintValue, AssetResourceType::Asset);
        }
        else if (pathItem.type == PropertyType::String) {
          path = definition.scene.properties.getString(entityDefinition.asset.index).to_string();
        }
 
        if (assetInstance.useRelativePaths() && IO::isRelative(path)) {
          path = IO::combine(assetInstance.directoryPath, std::move(path));
        }
 
        entityInstance.assetInstance->asset = context->assetManager->loadAsset(path, NoResourceId, AssetLoadFlags::None);
 
        entityInstance.assetInstance->initialized = true;
 
        if (assetInstance.onDemand) {
          entityInstance.assetInstance->onDemand = true;
        }
 
        if (assetInstance.useOverrideMaterial()) {
          entityInstance.assetInstance->overrideMaterial = true;
          entityInstance.assetInstance->material = assetInstance.material;
        }
        if (assetInstance.useCloneMaterial()) {
          entityInstance.assetInstance->cloneMaterial = true;
          entityInstance.assetInstance->material = assetInstance.material;
        }
      }
 
      if (!entityInstance.assetInstance->asset->isLoaded()) {
        return false;
      }
 
      if (!entityInstance.assetInstance->scene.initialized) {
        auto flags = (AssetFlags)entityDefinition.asset.flags;
        entityInstance.assetInstance->onDemand = (flags & AssetFlags::InstantiateOnDemand) != 0;
        entityInstance.assetInstance->relativePaths = (flags & AssetFlags::RelativePaths) != 0;
 
        initializeAssetInstance(*entityInstance.assetInstance);
      }
 
      bool ready = true;
      for (const uint32_t rootIx : entityInstance.assetInstance->scene.roots) {
        ready &= checkEntity(context, lodReference, *entityInstance.assetInstance, entityInstance.assetInstance->scene[rootIx], parentInstance);
      }
      entityInstance.setReady(ready);
 
      // Trigger a new frame as this model ready might open up for new lod-levels.
      context->engine->setDirty();
      return ready;
 
    } else if (entityInstance.isLodGroup()) {
      auto & definition = assetInstance.asset->definition;
      auto & lodData = assetInstance.scene.getLodData(entityInstance);
 
      entityInstance.lod.target = uint32_t(lodData.lods.size()) - 1;
      uint32_t childIndex = entityInstance.lod.current != ::NoValue ? entityInstance.lod.current : lodData.lods.back();
 
      bool retval = true;
      while (childIndex != ::NoValue) {
        retval &= checkEntity(context, lodReference, assetInstance, assetInstance.scene[childIndex], parentInstance);
        childIndex = definition.scene[childIndex].nextLodSibling;
      }
      return retval;
    } else if (entityInstance.hasChildren()) {
      auto & definition = assetInstance.asset->definition;
      auto & entityDefinition = definition.scene[entityInstance.index];
 
      uint32_t childIndex = entityDefinition.firstChild;
 
      while (childIndex != ::NoValue) {
        if (!checkEntity(context, lodReference, assetInstance, assetInstance.scene[childIndex], parentInstance)) {
          return false;
        }
 
        childIndex = definition.scene[childIndex].nextSibling;
      }
    }
 
    return true;
  }
 
  bool spawnEntity(Context * context, AssetLodReference& lodReference, AssetInstanceData & assetInstance, EntityInstanceData & entityInstance, EntityInstanceData * parentInstance, EntityParentMode parentMode);
 
  bool spawnLodGroup(Context * context, AssetLodReference& lodReference, AssetInstanceData & assetInstance, EntityInstanceData & entityInstance, EntityInstanceData * parentInstance, EntityParentMode /*parentMode*/)
  {
    assert(entityInstance.isLodGroup() && "Invalid LoD group instance.");
 
    if (entityInstance.isAtDesiredLod()) return false;
 
    auto & scene = assetInstance.scene;
    auto & lodData = scene.getLodData(entityInstance);
 
    if (lodData.previousTarget != ::NoValue && lodData.previousTarget != entityInstance.lod.target && lodData.previousTarget != entityInstance.lod.current) {
      uint32_t currentLodChild = lodData.lods[lodData.previousTarget];
 
      while (currentLodChild != ::NoValue) {
        clearEntity(context, assetInstance, scene[currentLodChild]);
        currentLodChild = scene[currentLodChild].nextLodSibling;
      }
 
      lodData.previousTarget = ::NoValue;
    }
 
    if (!entityInstance.isVisible()) {
      clearEntity(context, assetInstance, entityInstance);
      return {};
    }
 
    if (entityInstance.lod.target != ::NoValue) {
      uint32_t currentLodChild = lodData.lods[entityInstance.lod.target];
 
      while (currentLodChild != ::NoValue) {
        scene[currentLodChild].setStaging(false);
        currentLodChild = scene[currentLodChild].nextLodSibling;
      }
    }
 
    const uint32_t firstChildIndex = lodData.lods[entityInstance.lod.target];
 
    bool ready = true;
    uint32_t childIndex = firstChildIndex;
    while (childIndex != ::NoValue) {
      auto & childInstance = scene[childIndex];
 
      childInstance.setStaging(true);
 
      // Check if the target LOD level is ready to be switched to.
      ready &= checkEntity(context, lodReference, assetInstance, childInstance, parentInstance);
 
      childIndex = childInstance.nextLodSibling;
    }
 
    if (!ready) return false;
 
    if (entityInstance.lod.current != ::NoValue) {
      uint32_t currentLodChild = lodData.lods[entityInstance.lod.current];
 
      while (currentLodChild != ::NoValue) {
        clearEntity(context, assetInstance, scene[currentLodChild]);
        currentLodChild = scene[currentLodChild].nextLodSibling;
      }
    }
 
    auto currentParent = parentInstance;
 
    childIndex = firstChildIndex;
    while (childIndex != ::NoValue) {
      spawnEntity(context, lodReference, assetInstance, scene[childIndex], currentParent, EntityParentMode::TransformOnly);
 
      childIndex = scene[childIndex].nextLodSibling;
    }
 
    entityInstance.lod.current = entityInstance.lod.target;
 
    return true;
  }
 
  bool spawnAsset(Context * context, AssetLodReference& lodReference, EntityInstanceData & entityInstance, EntityInstanceData * parentInstance)
  {
    if (entityInstance.isSpawned()) return false;
    if (!entityInstance.isReady()) return false;
 
    auto & assetInstance = *entityInstance.assetInstance;
 
    EntityInstanceData root;
    root.entityPtr = parentInstance->entityPtr;
 
    for (auto & subroot : assetInstance.scene.roots) {
      spawnEntity(context, lodReference, assetInstance, assetInstance.scene[subroot], parentInstance, EntityParentMode::TransformOnly);
    }
 
    entityInstance.setSpawned(true);
    entityInstance.setStaging(false);
 
    return true;
  }
 
  bool spawnModel(Context * context, AssetInstanceData & assetInstance, EntityInstanceData & entityInstance, EntityInstanceData * parentInstance, EntityParentMode parentMode)
  {
    if (entityInstance.isSpawned()) return false;
    if (!entityInstance.isReady()) return false;
 
    if (entityInstance.hasError()) {
      entityInstance.setSpawned(true);
      return true;
    }
 
    auto & modelData = assetInstance.scene.getModelData(entityInstance);
    assert(modelData.index == entityInstance.index && "Model data attached to invalid entity instance.");
    auto & modelFile = assetInstance.scene.modelFiles[modelData.fileIndex];
 
    auto model = modelFile.model.resolve();
 
    if (!model->isLoaded()) return false;
    if (model->meshes.empty()) return false;
 
    auto & scene = assetInstance.asset->definition.scene;
    auto & entityDefinition = scene[entityInstance.index];
 
    EntityCreationContext entityContext{};
    entityContext.context = context;
    entityContext.scene = &assetInstance.asset->definition.scene;
    entityContext.parent = parentInstance->entityPtr;
    entityContext.parentMode = parentMode;
    entityContext.skipModel = true;
 
    entityInstance.entity = createEntity(entityContext, entityDefinition);
 
    assetInstance.spawned(entityInstance.entity->getId());
 
    auto parentTransform = entityInstance.entity->getComponentHandle<TransformComponent>();
    auto parentSceneComponent = entityInstance.entity->getComponentHandle<SceneComponent>();
 
    size_t begin = modelData.part != ::NoValue ? modelData.part : 0;
    size_t end = modelData.part != ::NoValue ? modelData.part + 1 : model->parts.size();
    assert(end > begin && "Invalid part range");
    size_t count = end - begin;
    assert(count && "Invalid part range.");
 
    std::vector<EntityPtr> entities(count);
    context->store->createEntities(count, entities);
 
    std::vector<ComponentModel::ComponentHandle> transformComponents(count);
    std::vector<ComponentModel::ComponentHandle> sceneComponents(count);
 
    for (size_t i = 0; i < count; ++i) {
      auto & part = model->parts[begin + i];
      const EntityPtr& entity = entities[i];
 
      auto sceneComponent = context->sceneSystem->createComponent();
      sceneComponents[i] = sceneComponent;
      entity->addComponent(sceneComponent);
 
      auto tcHandle = context->transformSystem->createComponent();
      transformComponents[i] = tcHandle;
      entity->addComponent(tcHandle);
      auto transformComponent = tcHandle.resolveComponent<TransformComponent>();
 
      context->transformSystem->setLocalTransform(transformComponent, model->getPartTransform(part));
 
      if (part.parentIndex == ::NoValue) {
        transformComponent->parent = parentTransform;
        parentSceneComponent.resolveComponent<SceneComponent>()->children.emplace_back(entity);
      } else {
        if (part.parentIndex < begin || end <= part.parentIndex) {
          LOG_ERROR(logger, "Model part parent index %u is outside of requested model part range [%zu, %zu) (%s)", part.parentIndex, begin, end, modelFile.path.c_str());
        }
        else {
          const ComponentHandle& childParentSceneComponent = sceneComponents[part.parentIndex - begin];
          childParentSceneComponent.resolveComponent<SceneComponent>()->children.emplace_back(entity);
          transformComponent->parent = transformComponents[part.parentIndex - begin];
        }
      }
 
      transformComponent->setChanged();
 
      if (part.meshIndex != NoIndex) {
        auto mcHandle = context->meshSystem->createComponent();
        entity->addComponent(mcHandle);
 
        auto meshComponent = mcHandle.resolveComponent<MeshComponent>();
        meshComponent->meshHandle = model->meshes[part.meshIndex];
        meshComponent->setChanged();
 
        auto mrcHandle = context->renderSystem->createComponent();
        entity->addComponent(mrcHandle);
 
        auto renderComponent = mrcHandle.resolveComponent<MeshRenderComponent>();
        if (part.boundsIndex != NoIndex) {
          context->renderSystem->setLocalBounds(renderComponent, model->bounds[part.boundsIndex]);
        }
        renderComponent->startIndex = part.startIndex;
        renderComponent->vertexCount = part.vertexCount;
        renderComponent->objectId = assetInstance.objectId;
        renderComponent->layer = assetInstance.renderLayers;
        renderComponent->clipShapeComponent = assetInstance.clipShapeComponent;
 
        MaterialInstanceHandle partMaterial = part.materialIndex < model->materials.size()
                                            ? model->materials[part.materialIndex]
                                            : MaterialInstanceHandle::NoHandle;
        if (assetInstance.useOverrideMaterial()) {
          renderComponent->material = assetInstance.material;
        }
        else if(assetInstance.useCloneMaterial()){
          MaterialInstanceHandle master = assetInstance.material;
          renderComponent->material = context->materialInstanceManager->createMaterialInstance(context->materialManager->generateHandle(master->material));
          renderComponent->material->clone(master.resolve());
          // Copy over settings from partMaterial
          if(partMaterial){
            renderComponent->material->setPermutation(partMaterial->getPermutation());
            renderComponent->material->instanceFlags = partMaterial->instanceFlags;
            renderComponent->material->options = partMaterial->options;
            renderComponent->material->cloneMatchingProperties(partMaterial.resolve());
            renderComponent->material->cloneMatchingVariants(partMaterial.resolve());
          }
        }
        else if(HandleIsValid(partMaterial)){
          renderComponent->material = partMaterial;
        }
        else {
          MaterialHandle master = context->materialManager->getDefaultMaterial();
          renderComponent->material = context->materialInstanceManager->createMaterialInstance(master);
        }
        renderComponent->setChanged();
      }
 
      assetInstance.spawned(entity->getId());
    }
 
    calculateModelCost(context, modelData, model);
 
    entityInstance.setSpawned(true);
    entityInstance.setStaging(false);
 
    return true;
  }
 
  bool spawnEntity(Context * context, AssetLodReference& lodReference, AssetInstanceData & assetInstance, EntityInstanceData & entityInstance, EntityInstanceData * parentInstance, EntityParentMode parentMode)
  {
    auto & definition = assetInstance.asset->definition;
    auto & scene = assetInstance.scene;
    auto & entityDefinition = definition.scene[entityInstance.index];
 
    if (entityDefinition.isLodGroup()) {
      return spawnLodGroup(context, lodReference, assetInstance, entityInstance, parentInstance, parentMode);
    } else if (entityDefinition.isAsset()) {
      return spawnAsset(context, lodReference, entityInstance, parentInstance);
    } else if (entityDefinition.isModel()) {
      return spawnModel(context, assetInstance, entityInstance, parentInstance, parentMode);
    } else {
      if (entityDefinition.isEmpty()) {
        entityInstance.setSpawned(true);
        return true;
      }
 
      EntityCreationContext entityContext{};
      entityContext.context = context;
      entityContext.scene = &definition.scene;
      entityContext.parent = parentInstance->entityPtr;
      entityContext.parentMode = parentMode;
 
      entityInstance.entity = createEntity(entityContext, entityDefinition);
      entityInstance.entityPtr = entityInstance.entity.get();
      entityInstance.setSpawned(true);
      entityInstance.setStaging(false);
 
      assetInstance.spawned(entityInstance.entity->getId());
 
      auto rHandle = entityInstance.entity->getComponentHandle<MeshRenderComponent>();
      if(rHandle){
        auto renderComponent = rHandle.resolveComponent<MeshRenderComponent>();
        if(renderComponent){
          renderComponent->material = assetInstance.material;
        }
      }
 
      if (entityDefinition.numChildren) {
        uint32_t childIndex = entityDefinition.firstChild;
 
        while (childIndex != ::NoValue) {
          checkEntity(context, lodReference, assetInstance, scene[childIndex], parentInstance);
 
          spawnEntity(context, lodReference, assetInstance, scene[childIndex], &entityInstance, EntityParentMode::Default);
 
          childIndex = definition.scene[childIndex].nextSibling;
        }
      }
 
      return true;
    }
  }
 
  void updateEntity(Context * context, AssetLodReference& lodReference, AssetInstanceData & assetInstance, EntityInstanceData & entityInstance, EntityInstanceData * parentInstance)
  {
    auto & scene = assetInstance.scene;
 
    if (entityInstance.isLodGroup()) {
      if (!entityInstance.isAtDesiredLod()) {
        spawnEntity(context, lodReference, assetInstance, entityInstance, parentInstance, EntityParentMode::TransformOnly);
      } else if (entityInstance.isVisible()) {
        auto & lodData = scene.getLodData(entityInstance);
        uint32_t childIndex = lodData.lods[entityInstance.lod.target];
 
        while (childIndex != ::NoValue) {
          updateEntity(context, lodReference, assetInstance, scene[childIndex], parentInstance);
 
          childIndex = scene[childIndex].nextLodSibling;
        }
      }
    } else if (entityInstance.isSpawned()) {
      if (entityInstance.isAsset()) {
        entityInstance.assetInstance->priority = assetInstance.priority;
        for (auto & root : entityInstance.assetInstance->scene.roots) {
          updateEntity(context, lodReference, *entityInstance.assetInstance, entityInstance.assetInstance->scene[root], parentInstance);
        }
      } else if (entityInstance.hasChildren()) {
        auto & definition = assetInstance.asset->definition;
        auto & entityDefinition = definition.scene[entityInstance.index];
 
        for (uint32_t i = 0; i < entityDefinition.numChildren; ++i) {
          auto & childDefinition = definition.scene[definition.scene.getChild(entityDefinition.firstChild, i)];
 
          updateEntity(context, lodReference, assetInstance, scene[childDefinition.index], &entityInstance);
        }
      }
    } else if (entityInstance.isStaging()) {
      if (entityInstance.isAsset() || entityInstance.isModel()) {
        if (checkEntity(context, lodReference, assetInstance, entityInstance, parentInstance)) {
          spawnEntity(context, lodReference, assetInstance, entityInstance, parentInstance, EntityParentMode::TransformOnly);
        }
      } else {
        spawnEntity(context, lodReference, assetInstance, entityInstance, parentInstance, EntityParentMode::TransformOnly);
      }
    } else {
      if (!entityInstance.isSpawned()) {
        if (checkEntity(context, lodReference, assetInstance, entityInstance, parentInstance)) {
          spawnEntity(context, lodReference, assetInstance, entityInstance, parentInstance, EntityParentMode::TransformOnly);
        }
      }
    }
  }
 
  void dispatchMessages(Context * context, AssetInstanceData & assetInstance)
  {
    CpuInstrumentationScope(SCOPE_ASSETSYSTEM, "AssetSystem::dispatch");
    auto dispatchTime =assetInstance.stats.frame.startDispatch();
 
    auto systemData = assetInstance.systemData;
 
    //TODO: Check for subscribers before dispatch.
    //TODO: Cache dispatch table per entity (?)
    //TODO: Batch entities in single created/destroyed message
 
    for (EntityId spawned : assetInstance.spawnedEntities) {
      context->dynamicComponentSystem->sendMessage(assetInstance.container, systemData->entityCreatedId, (void *)spawned);
    }
 
    for (EntityId destroyed : assetInstance.destroyedEntities) {
      context->dynamicComponentSystem->sendMessage(assetInstance.container, systemData->entityDestroyedId, (void *)destroyed);
    }
 
    assetInstance.spawnedEntities.clear();
    assetInstance.destroyedEntities.clear();
  }
 
  void processInFlightRequests(Context* context, AssetSystemData * systemData)
  {
    CpuInstrumentationScope(SCOPE_ASSETSYSTEM, "AssetSystem::processInFlightRequests");
 
    for (auto request : systemData->inFlightRequests) {
      if (request->canceled) {
        context->modelManager->cancelModelLoad(request->model);
        systemData->requestPool.destroy(request);
        continue;
      }
 
      if (request->model && request->model->isLoaded()) {
        auto assetInstance = request->assetInstance;
 
        auto & modelFile = assetInstance->scene.modelFiles[request->modelFileIndex];
        modelFile.model = request->model;
        modelFile.request = nullptr;
 
        --assetInstance->stats.numRequests;
 
        systemData->requestPool.destroy(request);
      } else {
        systemData->stillInFlight.emplace_back(request);
      }
    }
 
    std::swap(systemData->stillInFlight, systemData->inFlightRequests);
    systemData->stillInFlight.clear();
  }
 
  size_t processPendingRequests(Context* context, 
                                AssetSystemData* systemData,
                                ModelManager* modelManager,
                                AssetSystemVector<AssetModelRequest*>& pendingRequests,
                                AssetSystemVector<AssetModelRequest*>& inFlightRequests,
                                const size_t maxInFlight,
                                const size_t maxProcessed)
  {
    CpuInstrumentationScope(SCOPE_ASSETSYSTEM, "AssetSystem::processPendingRequests");
 
    size_t processed = 0;
 
    if (!pendingRequests.empty()) {
      std::sort(pendingRequests.begin(), pendingRequests.end(), [](auto a, auto b) -> bool
      {
        return a->priority < b->priority;
      });
    }
 
    while (!pendingRequests.empty() && processed < maxProcessed && inFlightRequests.size() < maxInFlight) {
      auto request = pendingRequests.back();
      pendingRequests.pop_back();
 
      if (systemData && request->canceled) {
        LOG_TRACE(logger, "Discarding cancelled pending request");
        systemData->requestPool.destroy(request);
        continue;
      }
 
      auto assetInstance = request->assetInstance;
 
      ModelLoadFlags flags = ModelLoadFlags::NoDefaultName;
      if (assetInstance && assetInstance->useOverrideMaterial()) {
        flags |= ModelLoadFlags::SkipMaterials;
      }
      if (assetInstance && assetInstance->useCloneMaterial()) {
        flags |= ModelLoadFlags::SkipMaterials;
      }
 
      request->model = modelManager ? modelManager->loadModel(request->path, NoResourceId, flags) : ModelHandle{};
 
      inFlightRequests.emplace_back(request);
 
      ++processed;
    }
 
    while (systemData && maxInFlight < inFlightRequests.size()) {
      LOG_TRACE(logger, "Cancelling in-flight request and moving it to pending as limits are violated.");
 
      AssetModelRequest* request = inFlightRequests.back();
      inFlightRequests.pop_back();
 
      if (request->model) {
        context->modelManager->cancelModelLoad(request->model);
        request->model = ModelHandle{};
      }
 
      pendingRequests.emplace_back(request);
    }
 
    return processed;
  }
 
  void pullCameraMatrices(Context* context, AssetSystemData* systemData)
  {
    if (CameraComponent* mainCam = context->cameraSystem->getMainCamera(); mainCam) {
      if (TransformComponent* trCompLod = mainCam->getComponent<TransformComponent>(); trCompLod) {
 
        if (trCompLod->hasChanged()) {
          context->transformSystem->updateTransformData(*trCompLod);
        }
        const CameraData& camData = context->cameraSystem->getData(mainCam);
 
        systemData->worldFromView = context->transformSystem->getLocalToWorld(trCompLod);
        systemData->worldFromClip = systemData->worldFromView * glm::inverse(camData.rawProjectionMatrix);
 
        systemData->viewFromWorld = glm::inverse(systemData->worldFromView);
        systemData->clipFromWorld = camData.rawProjectionMatrix * systemData->viewFromWorld;
 
        systemData->minDistance = mainCam->enableClippingPlaneAdjustment ? mainCam->nearPlaneLimit : mainCam->nearDistance;
        systemData->maxDistance = context->variables->get(maxDistanceVariableName, kDefaultMaxDistance);
 
        if (int maxLodDepth = context->variables->get(maxLodDepthVariableName, kDefaultMaxLodDepth); 0 <= maxLodDepth) {
          systemData->maxLodDepth = maxLodDepth;
        }
        else {
          systemData->maxLodDepth = ~0u;
        }
        return;
      }
    }
    systemData->worldFromView = glm::mat4(1.f);
    systemData->worldFromClip = glm::mat4(1.f);
    systemData->viewFromWorld = glm::mat4(1.f);
    systemData->clipFromWorld = glm::mat4(1.f);
  }
 
  void updateRenderPropertiesRecurse(const AssetInstanceData& instanceData, Entity* entity) {
 
    if (RenderComponent* renderComp = entity->getComponent<RenderComponent>(); renderComp) {
      renderComp->layer = instanceData.renderLayers;
      renderComp->objectId = instanceData.objectId;
      renderComp->clipShapeComponent = instanceData.clipShapeComponent;
      renderComp->setChanged();
    }
 
    if (SceneComponent* sceneComp = entity->getComponent<SceneComponent>(); sceneComp) {
      for (EntityPtr& e : sceneComp->children) {
        updateRenderPropertiesRecurse(instanceData, e.get());
      }
    }
  }
 
  // Recursively update the entities of an instantiated model
  void updateInstancedModelChildEntityRenderProperties(Context* context, AssetInstanceData& assetInstance, Entity& entity)
  {
    if (RenderComponent* renderComp = entity.getComponent<RenderComponent>(); renderComp) {
      renderComp->objectId = assetInstance.objectId;
      renderComp->layer = assetInstance.renderLayers;
      renderComp->clipShapeComponent = assetInstance.clipShapeComponent;
      renderComp->setChanged();
    }
 
    if (SceneComponent* sceneComp = entity.getComponent<SceneComponent>(); sceneComp) {
      for (EntityPtr& child : sceneComp->children) {
        assert(child);
        updateInstancedModelChildEntityRenderProperties(context, assetInstance, *child.get());
      }
    }
  }
 
  void updateAssetInstanceRenderProperties(Context* context, AssetInstanceData& assetInstance);
 
  void updateEntityInstanceRenderProperties(Context* context, AssetInstanceData& assetInstance, EntityInstanceData& entityInstance)
  {
    if (entityInstance.isLodGroup()) {
 
      if (entityInstance.isVisible() && entityInstance.isAtDesiredLod()) {
        LodInstanceData& lodData = assetInstance.scene.getLodData(entityInstance);
        uint32_t childIndex = lodData.lods[entityInstance.lod.target];
        while (childIndex != ::NoValue) {
          updateEntityInstanceRenderProperties(context, assetInstance, assetInstance.scene[childIndex]);
          childIndex = assetInstance.scene[childIndex].nextLodSibling;
        }
      }
 
    }
 
    else if (entityInstance.isSpawned()) {
 
      const AssetDefinition& definition = assetInstance.asset->definition;
      const SceneEntityDefinition& entityDefinition = definition.scene[entityInstance.index];
 
      if (entityInstance.isAsset()) {
        entityInstance.assetInstance->clipShapeComponent = assetInstance.clipShapeComponent;
        updateAssetInstanceRenderProperties(context, *entityInstance.assetInstance);
      }
 
      else if (entityInstance.isModel()) {
        if (entityInstance.entity) {
          updateInstancedModelChildEntityRenderProperties(context, assetInstance, *entityInstance.entity.get());
        }
      }
 
      else if (entityInstance.hasChildren()) {
 
        uint32_t childIndex = entityDefinition.firstChild;
        while (childIndex != ::NoValue) {
          updateEntityInstanceRenderProperties(context, assetInstance, assetInstance.scene[childIndex]);
          childIndex = definition.scene[childIndex].nextSibling;
        }
 
      }
    }
 
  }
 
  void updateAssetInstanceRenderProperties(Context* context, AssetInstanceData& assetInstance)
  {
    for (uint32_t root : assetInstance.scene.roots) {
      updateEntityInstanceRenderProperties(context, assetInstance, assetInstance.scene[root]);
    }
  }
 
 
 
}
 
 
void Cogs::Core::AssetBounds::getBounds(Context* /*context*/, Cogs::Geometry::BoundingBox& bounds)
{
  for (auto& assetComponent : assetSystem->pool) {
    const auto bbox = assetSystem->getWorldBounds(&assetComponent, false);
    if (!isEmpty(bbox))
      bounds += bbox;
  }
}
 
bool Cogs::Core::AssetBounds::getBounds(Context* context, const ComponentModel::Entity* entity, Cogs::Geometry::BoundingBox& bounds, bool ignoreVisibility) const
{
  auto assetComponent = entity->getComponent<AssetComponent>();
  if (!assetComponent) return false;
  const auto bbox = context->assetSystem->getWorldBounds(assetComponent, ignoreVisibility);
  if (!isEmpty(bbox)) {
    bounds = bbox;
    return true;
  }
  else
    return false;
}
 
 
Cogs::Core::AssetSystem::AssetSystem(Memory::Allocator * allocator, SizeType capacity) : ComponentSystemWithDataPools(allocator, capacity) {}
 
Cogs::Core::AssetSystem::~AssetSystem() = default;
 
void Cogs::Core::AssetSystem::initialize(Context * context)
{
  this->context = context;
 
  systemData = std::make_unique<AssetSystemData>();
 
  context->modelManager->registerLoader(new CogsModelLoader());
 
  systemData->entityCreatedId = context->dynamicComponentSystem->registerMessage("entityCreated");
  systemData->entityDestroyedId = context->dynamicComponentSystem->registerMessage("entityDestroyed");
 
  context->variables->getOrAdd(lodFreezeVariableName, kDefaultLodFreeze);
  context->variables->getOrAdd(cullModelsName, cullModelsValue);
  if (Variable* var = context->variables->get(maxModelsInFlightVariableName); var->isEmpty()) {
    context->variables->set(maxModelsInFlightVariableName, kDefaultMaxModelsInFlight);
  }
  if (Variable* var = context->variables->get(maxModelLoadsPerFrameVariableName); var->isEmpty()) {
    context->variables->set(maxModelLoadsPerFrameVariableName, kDefaultMaxModelLoadsPerFrame);
  }
  if (Variable* var = context->variables->get(maxDistanceVariableName); var->isEmpty()) {
    context->variables->set(maxDistanceVariableName, kDefaultMaxDistance);
  }
  if (Variable* var = context->variables->get(maxLodDepthVariableName); var->isEmpty()) {
    context->variables->set(maxLodDepthVariableName, kDefaultMaxLodDepth);
  }
  context->variables->getOrAdd(allowMaterialOverride, kDefaultAllowMaterialOverride);
 
}
 
void Cogs::Core::AssetSystem::update(Context * context)
{
  const float qualityScale = context->qualityService->assetSystemToleranceScale;
 
  bool freeze = context->variables->get(lodFreezeVariableName, kDefaultLodFreeze);
 
  if (const Variable* var = context->variables->get(cullModelsName); !var->isEmpty()) {
    cullModelsValue = var->getBool();
  }
 
  pullCameraMatrices(context, systemData.get());
 
  bool allowOverrideMaterial = context->variables->get(allowMaterialOverride, true);
 
  // Run through all components,
  // - Check if asset resource has changed or has been updated.
  // - Populate newUpdates with detected changes.
  // - Populate currentOnDemandInstances with all assets that are flagged as ondemand.
  AssetSystemVector<AssetUpdate>& newUpdates = systemData->newUpdates; assert(newUpdates.empty());
  AssetSystemVector<AssetInstanceData*>& currentOnDemandInstances = systemData->currentOnDemandInstances; assert(currentOnDemandInstances.empty());
  for (auto & assetComponent : pool) {
 
 
 
    AssetData& assetData = getData<AssetData>(&assetComponent);
 
    // Check if the asset resource of the asset property has changed, other changes handled below.
    if (assetData.hasChanged(assetComponent.asset)) {
      assetData.setAsset(assetComponent.asset);
 
      // First run, set up initial asset instance data with destructor
      // that frees the full chain of linked asset instance datas.
      if (!assetData.instanceData) {
        auto instanceData = systemData->instanceData.create();
        assetData.instanceData = std::shared_ptr<AssetInstanceData>(instanceData, [&](AssetInstanceData * d)
        {
          auto current = d->next;
          while (current) {
            auto next = current->next;
            systemData->instanceData.destroy(current);
            current = next;
          }
          systemData->instanceData.destroy(d);
        });
      }
 
      // Populate head of asset instance data with data from the componnent.
      //
      // This is only triggered by change of asset resource.
      AssetInstanceData* assetInstance = assetData.instanceData.get();
      assetInstance->systemData = systemData.get();
      assetInstance->asset = assetData.asset;
      assetInstance->container = assetComponent.getContainer();
      assetInstance->scene.initialized = false;
      assetInstance->onDemand = (assetComponent.flags & AssetFlags::InstantiateOnDemand) != 0;
      assetInstance->relativePaths = (assetComponent.flags & AssetFlags::RelativePaths) != 0;
      assetInstance->overrideMaterial = allowOverrideMaterial && (assetComponent.flags & AssetFlags::OverrideMaterial) != 0;
      assetInstance->cloneMaterial = allowOverrideMaterial && (assetComponent.flags & AssetFlags::CloneMaterial) != 0;
      assetInstance->priority = assetComponent.priority;
 
      if (const RenderComponent* renderComponent = assetComponent.getContainer()->getComponent<RenderComponent>(); renderComponent) {
        assetInstance->objectId = renderComponent->objectId;
        assetInstance->renderLayers = renderComponent->layer;
      }
 
      // Create material if needed
      if (assetInstance->useOverrideMaterial() || assetInstance->useCloneMaterial()) {
        if (assetComponent.material) {
          assetInstance->material = assetComponent.material;
        } else {
 
          if (!systemData->defaultMaterialHandle) {
            systemData->defaultMaterialHandle = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
          }
          assetInstance->material = systemData->defaultMaterialHandle;
        }
      }
 
      // Schedule asset for update.
      newUpdates.push_back({
        assetComponent.getContainer(),
        getHandle(&assetComponent),
        assetComponent.asset,
        assetInstance
      });
    }
 
    // Handle other changes than changed asset resource (handled above):
    if (assetData.asset && assetData.instanceData) {
      AssetInstanceData& assetInstance = *assetData.instanceData.get();
 
      // Forward clipshape if present
      ComponentModel::ComponentHandle clipShapeComponent = ComponentModel::ComponentHandle::Empty();
      if (const ClipShapeRefComponent* clipRefComp = assetComponent.getComponent<ClipShapeRefComponent>(); clipRefComp) {
        if (EntityPtr clipShape = clipRefComp->clipShape.lock(); clipShape) {
          clipShapeComponent = clipShape->getComponentHandle<ClipShapeComponent>();
        }
      }
      bool forward = assetInstance.clipShapeComponent != clipShapeComponent;
      assetInstance.clipShapeComponent = clipShapeComponent;
 
      // Forward objectId and layer from the render component
      if (const RenderComponent* renderComponent = assetComponent.getContainer()->getComponent<RenderComponent>(); renderComponent) {
        forward = forward || (assetInstance.objectId != renderComponent->objectId);
        assetInstance.objectId = renderComponent->objectId;
 
        forward = forward || (assetInstance.renderLayers != renderComponent->layer);
        assetInstance.renderLayers = renderComponent->layer;
      }
 
      // Something has changed, recurse down and update everything
      if (forward) {
        updateAssetInstanceRenderProperties(context, assetInstance);
      }
    }
 
    // If asset is on demand, pull data from component that doesn't require an update the asset.
    if (assetData.asset && assetData.instanceData && assetData.instanceData->onDemand) {
      assetData.instanceData->freezeLod = freeze || assetComponent.freezeLod;
      assetData.instanceData->forceTolerance = assetComponent.forceTolerance;
      assetData.instanceData->tolerance = (assetComponent.forceTolerance ? 1.f : qualityScale) * assetComponent.tolerance;
      assetData.instanceData->minDistance = assetComponent.minDistance;
 
      assetData.instanceData->selectedIdRanges.clear();
      if (!assetComponent.idRanges.empty()) {
 
        size_t count = assetComponent.idRanges.size() / 2;
        std::vector<uint32_t>& selectedIdRanges = assetData.instanceData->selectedIdRanges;
        for (size_t k = 0; k < count; k++) {
          const uint32_t rangeMin = assetComponent.idRanges[2 * k + 0];
          const uint32_t rangeMax = assetComponent.idRanges[2 * k + 1];
          if (rangeMax < rangeMin || (!selectedIdRanges.empty() && rangeMin < selectedIdRanges.back()) ) {
            // Either invalid range or unsorted/overlapping ranges.
            selectedIdRanges.clear();
            break;
          }
          selectedIdRanges.push_back(rangeMin);
          selectedIdRanges.push_back(rangeMax);
        }
      }
 
      currentOnDemandInstances.emplace_back(assetData.instanceData.get());
    }
  }
 
  // Run through all new asset updates
  // - release the associated node hiearchies,
  // - Populate readyUpdates with non-ondemand updates that is loaded.
  //   - Non-loaded assets gets their generation updated when loaded,
  //     which puts them into this queue again
  AssetSystemVector<AssetUpdate>& readyUpdates = systemData->readyUpdates; assert(readyUpdates.empty());
  for (auto & assetUpdate : newUpdates) {
    if (!assetUpdate.asset) {
      context->store->removeChildren(assetUpdate.container);
    } else if (assetUpdate.asset && assetUpdate.asset->isLoaded()) {
 
      for (auto & resourceDefinition : assetUpdate.asset->definition.resources) {
        context->assetManager->instantiateResource(assetUpdate.asset, resourceDefinition);
      }
 
      if (!assetUpdate.instanceData->onDemand) {
        context->store->removeChildren(assetUpdate.container);
        readyUpdates.emplace_back(assetUpdate);
      }
    }
  }
  newUpdates.clear();
 
  // Run through new non-ondemand asset updates that are ready.
  for (auto & assetUpdate : readyUpdates) {
    auto asset = assetUpdate.asset.resolve();
    const size_t entityCount = asset->definition.scene.entities.size();
    std::vector<ComponentModel::Entity*> entities(entityCount);
    for (auto & def : asset->definition.scene.entities) {
      Entity* parent = assetUpdate.container;
      if (def.parentIndex != static_cast<uint32_t>(-1)) {
        assert(def.parentIndex < entityCount && entities[def.parentIndex]);
        parent = entities[def.parentIndex];
      }
      assert(def.index < entityCount && entities[def.index] == nullptr);
      entities[def.index] = createEntity(context, asset->definition.scene, def, parent);
    }
  }
  readyUpdates.clear();
 
  // Run through ondemand requests in SystemData::inFlightRequests
  // - If cancelled, destroy
  // - If loaded, remove from list and update corresponding modelFile in assetInstance.
  processInFlightRequests(context, systemData.get());
 
  // Run through newOnDemandInstances
  // - Initialize asset instance
  // - Populate liveAssetInstances current set of assets that are visible with a non-empty scene
  AssetSystemVector<AssetInstanceData*>& liveAssetInstances = systemData->liveAssetInstances; assert(liveAssetInstances.empty());
  liveAssetInstances.reserve(currentOnDemandInstances.size());
  for (auto assetInstance : currentOnDemandInstances) {
    assetInstance->stats.frame = {};
 
    if (!assetInstance->scene.initialized) {
      initializeAssetInstance(*assetInstance);
    }
 
    if (assetInstance->scene.entities.empty()) continue;
 
    auto sceneComponent = assetInstance->container->getComponent<SceneComponent>();
 
    const bool visible = sceneComponent ? sceneComponent->visible : true;
    const bool visibleChanged = visible != assetInstance->visible;
 
    if (!visible && !visibleChanged) continue;
 
    assetInstance->visible = visible;
 
    liveAssetInstances.emplace_back(assetInstance);
  }
  currentOnDemandInstances.clear();
 
  // Recursively figure out target lod-levels for active on-demand assets.
  Parallel::forEach(context, liveAssetInstances.size(), [&](size_t i)
  {
    auto assetInstance = liveAssetInstances[i];
 
    if (!assetInstance->freezeLod) {
      assetInstance->stats.frustumCullIn = 0;
      assetInstance->stats.frustumCullOut = 0;
      assetInstance->stats.bboxCullOut = 0;
      updateAssetDesiredLevels(context, *assetInstance, 0, 1);
    }
  }, "AssetSystem::updateLiveInstances");
 
  for (auto assetInstance : liveAssetInstances) {
    {
      auto processingTime = assetInstance->stats.frame.startProcessing();
 
      {
        auto updateTime = assetInstance->stats.frame.startUpdate();
 
        {
          CpuInstrumentationScope(SCOPE_ASSETSYSTEM, "AssetSystem::updateEntities");
 
          EntityInstanceData root;
          root.entityPtr = assetInstance->container;
 
          AssetLodReference lodReference = {};
          getLodReference(context, *assetInstance, lodReference, assetInstance->container);
 
          for (size_t i = 0; i < assetInstance->scene.roots.size(); ++i) {
            updateEntity(context, lodReference, *assetInstance, assetInstance->scene[assetInstance->scene.roots[i]], &root);
          }
        }
 
        CpuInstrumentationScope(SCOPE_ASSETSYSTEM, "AssetSystem::calculateCost");
 
        auto costTime = assetInstance->stats.frame.startCostCalculation();
 
#if ENABLE_COST_TRACKING
        assetInstance->stats.current = { 0, 0, 0 };
        for (size_t i = 0; i < assetInstance->scene.roots.size(); ++i) {
          calculateCost(context, *assetInstance, assetInstance->scene[assetInstance->scene.roots[i]]);
        }
#endif
      }
 
      dispatchMessages(context, *assetInstance);
    }
 
    double limit = assetInstance->stats.frameLimits.processingTime;
    if (assetInstance->stats.frame.processingTime > limit) {
      LOG_TRACE(logger, "Asset processing time exceeded limit %.3fs.", limit);
      LOG_TRACE(logger, "  Lod time:    %.3fs", assetInstance->stats.frame.lodTime);
      LOG_TRACE(logger, "  Update time: %.3fs", assetInstance->stats.frame.updateTime);
      LOG_TRACE(logger, "  Cost time:   %.3fs", assetInstance->stats.frame.calculateCostTime);
      LOG_TRACE(logger, "  ------------------------");
      LOG_TRACE(logger, "  Entities spawned:   %d", assetInstance->stats.frame.spawnedEntities);
      LOG_TRACE(logger, "  Entities destroyed: %d", assetInstance->stats.frame.destroyedEntities);
      LOG_TRACE(logger, "  Models requested:   %d", assetInstance->stats.frame.modelsRequested);
      LOG_TRACE(logger, "");
    }
  }
  liveAssetInstances.clear();
 
  processPendingRequests(context, systemData.get(),
                         context->modelManager,
                         systemData->pendingRequests,
                         systemData->inFlightRequests,
                         (size_t)context->variables->get(maxModelsInFlightVariableName, kDefaultMaxModelsInFlight),
                         (size_t)context->variables->get(maxModelLoadsPerFrameVariableName, kDefaultMaxModelLoadsPerFrame));
}
 
void Cogs::Core::AssetSystem::postUpdate(Context * context)
{
  base::postUpdate(context);
}
 
ComponentHandle Cogs::Core::AssetSystem::createComponent()
{
  ComponentHandle handle = base::createComponent();
 
  // Ensure consistent AssetBounds.
  if (pool.size() == 1u) {
    assert(bounds == nullptr);
    bounds = std::make_unique<AssetBounds>(this);
    context->bounds->addBoundsExtension(bounds.get());
  }
 
  return handle;
}
 
void Cogs::Core::AssetSystem::destroyComponent(ComponentHandle component)
{
  base::destroyComponent(component);
 
  if (pool.size() == 0u && bounds) {
    context->bounds->removeBoundsExtension(bounds.get());
    bounds.reset();
  }
}
 
const Cogs::Core::AssetInstanceStats * Cogs::Core::AssetSystem::getStats(AssetComponent * assetComponent) const
{
  if (!assetComponent) return nullptr;
 
  auto & data = getData<AssetData>(assetComponent);
 
  return data.instanceData ? &data.instanceData->stats : nullptr;
}
 
const Cogs::Geometry::BoundingBox* Cogs::Core::AssetSystem::getLocalBounds(AssetComponent* assetComponent) const
{
  if (!assetComponent)
    return nullptr;
 
  auto& data = getData<AssetData>(assetComponent);
  if (!data.instanceData) return nullptr;
  if (data.instanceData->scene.entities.empty()) return nullptr;
 
  // Assuming Root: index=0
  return &data.instanceData->scene.getLocalBounds(data.instanceData->scene[0]);
}
 
std::span<const Cogs::Core::AssetModelRequest* const> Cogs::Core::AssetSystem::getPendingRequests() const
{
  return systemData->pendingRequests;
}
 
std::span<const Cogs::Core::AssetModelRequest* const> Cogs::Core::AssetSystem::getInFlightRequests() const
{
  return systemData->inFlightRequests;
}
 
Cogs::Geometry::BoundingBox Cogs::Core::AssetSystem::getWorldBounds(AssetComponent* assetComponent, bool ignoreVisibility) const
{
  if (!ignoreVisibility) {
    auto sc = assetComponent->getComponent<SceneComponent>();
    if (sc && !sc->visible)
      return Cogs::Geometry::BoundingBox();
  }
 
  auto bbox = getLocalBounds(assetComponent);
  if (bbox == nullptr || isEmpty(*bbox))
    return Cogs::Geometry::BoundingBox();
 
  auto transformComponent = assetComponent->getComponent<TransformComponent>();
  if (transformComponent) {
    const auto& transform = context->transformSystem->getLocalToWorld(transformComponent);
    return Bounds::getTransformedBounds(*bbox, transform);
  }
 
  return *bbox;
}