Engine.cpp

#include "Engine.h"
 
#include <deque>
 
#if defined(EMSCRIPTEN) && !defined(COGS_SINGLETHREADED)
#include <emscripten/threading.h>
#include <emscripten/proxying.h>
#endif
 
#include "Context.h"
#include "EngineSystems.h"
#include "EntityStore.h"
#include "ExtensionRegistry.h"
#include "ResourceManifest.h"
 
#include "Editor/IEditor.h"
 
#include "Platform/Instrumentation.h"
 
#include "Resources/AnimationManager.h"
#include "Resources/AssetManager.h"
#include "Resources/BufferManager.h"
#include "Resources/BasicBlueNoiseManager.h"
#include "Resources/EffectManager.h"
#include "Resources/FontManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/MeshManager.h"
#include "Resources/ModelManager.h"
#include "Resources/ResourceStore.h"
#include "Resources/TextureManager.h"
 
#include "Renderer/IRenderer.h"
 
#include "Services/Variables.h"
#include "Services/Time.h"
#include "Services/QualityService.h"
#include "Services/ResourceUsageLogger.h"
 
#include "Systems/Core/TransformSystem.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace
{
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Engine");
 
  struct SystemDefinition
  {
    ComponentSystemBase* system;
    int priority;
  };
 
  template<typename ResourceManagerType>
  ResourceManagerType* createResourceManager(Engine* engine, Context* context)
  {
    auto manager = std::make_unique<ResourceManagerType>(context);
 
    auto ptr = manager.get();
 
    engine->addResourceManager(std::move(manager));
 
    return ptr;
  }
 
}
 
namespace Cogs::Core {
 
  struct EngineData
  {
    std::vector<SystemDefinition> systems;
 
    struct {
      Cogs::Mutex lock;
      std::deque<std::function<void()>> tasks;
    } mainThreadTasks;
  };
 
}
 
Cogs::Core::Engine::Engine(Context * context) :
  context(context),
  data(new EngineData())
{
#ifdef COGS_SINGLETHREADED
  workParallelValue = false;
#else  
  workParallelValue = true;
#endif
}
 
Cogs::Core::Engine::~Engine()
{
  context->taskManager->waitAll();
 
  if (editor) {
    editor->cleanup();
    editor.reset();
  }
 
  ExtensionRegistry::cleanup(context);
 
  for (auto & system :data->systems) {
    system.system->cleanup(context);
 
    Memory::destroy<ComponentSystemBase>(system.system, context->memory->baseAllocator);
  }
 
  data->systems.clear();
 
  // Disable global update quota to ensure resource managers can cleanup all pending/orphaned resources before
  // destruction.
  auto globalQuota = context->variables->get("resources.globalFrameUpdateQuota", 1000);
  context->variables->set("resources.globalFrameUpdateQuota", 0);
 
  // Doesn't necessarily exists in unit tests
  if (context->materialManager) {
    context->materialManager->releaseAll();
  }
  // Do several passes to ensure async dependencies get a chance to propagate.
  for (int i = 0; i < 4; ++i) {
    clearResources();
    context->taskManager->waitAll();
  }
 
  //FIXME: Renderer might hold on to regular resources, should be freed before resource cleanup.
  context->resourceUsageLogger->update(context, true);
 
  context->bufferManager = nullptr;
  context->textureManager = nullptr;
  context->blueNoiseManager = nullptr;
  context->animationManager = nullptr;
  context->meshManager = nullptr;
  context->modelManager = nullptr;
  context->effectManager = nullptr;
  context->materialManager = nullptr;
  context->materialDefinitionManager = nullptr;
  context->materialInstanceManager = nullptr;
  context->fontManager = nullptr;
  context->assetManager = nullptr;
  resourceManagers.clear();
 
  context->variables->set("resources.globalFrameUpdateQuota", globalQuota);
 
  ExtensionRegistry::remove(context);
  context->resourceUsageLogger->update(context, true);
}
 
void Cogs::Core::Engine::runTaskInMainThread(std::function<void()>&& task)
{
  {
    Cogs::LockGuard guard(data->mainThreadTasks.lock);
    data->mainThreadTasks.tasks.emplace_back(std::move(task));
  }
  triggerUpdate();
}
 
#if defined(EMSCRIPTEN) && !defined(COGS_SINGLETHREADED)
 
void Cogs::Core::Engine::invokeCallback(void(*callback)(void*), void* data)
{
  static pthread_t mainThread = emscripten_main_runtime_thread_id();
  if (mainThread == pthread_self()) {
    callback(data);
  }
  else {
    emscripten_proxy_async(emscripten_proxy_get_system_queue(), mainThread, callback, data);
  }
}
 
namespace {
 
  // Force alignment of struct to be that of a double so when the payload that
  // follows this struct contains double it will have the sufficient alignment.
  struct alignas(8) InvokeComponentNotifyProxyPayload {
    Context* context;
    int componentTypeId;
    size_t entityId;
    int notification;
    size_t dataSize;
  };
  static_assert((sizeof(InvokeComponentNotifyProxyPayload) % 8) == 0);
 
  void invokeComponentNotifyProxy(void* payload)
  {
    InvokeComponentNotifyProxyPayload* p = reinterpret_cast<InvokeComponentNotifyProxyPayload*>(payload);
    const void* data = p->dataSize ? ((const char*)p + sizeof(InvokeComponentNotifyProxyPayload)) : nullptr;
    p->context->callbacks.componentNotifyCallback(p->context, p->componentTypeId, p->entityId, p->notification, data, p->dataSize);
    free(payload);
  }
}
 
void Cogs::Core::Engine::invokeComponentNotifyCallback(const ComponentModel::Component& component, int notification, const void* data, size_t dataSize)
{
  static pthread_t mainThread = emscripten_main_runtime_thread_id();
  if (context->callbacks.componentNotifyCallback) {
    if (mainThread == pthread_self()) {
      context->callbacks.componentNotifyCallback(context, component.getTypeId(), component.getContainer()->getId(), notification, data, dataSize);
    }
    else {
      if (dataSize) { assert(data); }
 
      // We shall do a async proxy, so we must allocate memory that we can give to the
      // callback (and the callback must release). We piggy-back a copy of the data
      // in the same allocation since we the data pointer is only valid for the duration
      // of this call.
      char* payload = (char*)malloc(sizeof(InvokeComponentNotifyProxyPayload) + dataSize);
 
      InvokeComponentNotifyProxyPayload* p = (InvokeComponentNotifyProxyPayload*)payload;
      *p = InvokeComponentNotifyProxyPayload{ .context = context,
        .componentTypeId = component.getTypeId(),
        .entityId = component.getContainer()->getId(),
        .notification = notification,
        .dataSize = dataSize
      };
 
      if (data) {
        std::memcpy(payload + sizeof(InvokeComponentNotifyProxyPayload), data, dataSize);
      }
 
      emscripten_proxy_async(emscripten_proxy_get_system_queue(), mainThread, invokeComponentNotifyProxy, payload);
    }
  }
}
 
namespace {
  struct InvokeResourceLoadProxyPayload {
    Context* context;
    int resourceType;
    ResourceId id;
    int code;
  };
 
  void invokeResourceLoadProxy(void* payload)
  {
    InvokeResourceLoadProxyPayload* p = reinterpret_cast<InvokeResourceLoadProxyPayload*>(payload);
    p->context->callbacks.resourceLoadCallback(p->context, p->resourceType, p->id, p->code);
    delete p;
  }
}
 
void Cogs::Core::Engine::invokeResourceLoadCallback(int resourceType, ResourceId id, int code)
{
  static pthread_t mainThread = emscripten_main_runtime_thread_id();
  if (context->callbacks.resourceLoadCallback) {
    if (mainThread == pthread_self()) {
      context->callbacks.resourceLoadCallback(context, resourceType, id, code);
    }
    else {
      // We shall do a async proxy, so we must allocate memory that we can give to the
      // callback (and the callback must release).
      InvokeResourceLoadProxyPayload* payload = new InvokeResourceLoadProxyPayload{
        .context= context,
        .resourceType = resourceType,
        .id = id,
        .code = code
      };
      emscripten_proxy_async(emscripten_proxy_get_system_queue(), mainThread, invokeResourceLoadProxy, payload);
    }
  }
}
 
#endif
 
void Cogs::Core::Engine::setDirtyState()
{
  lastDirtyFrame = context->time->getFrame();
  triggerUpdate();
}
 
void Cogs::Core::Engine::checkAndUpdateResources()
{
  if (ready) return;
 
  if (firstInit) {
    resourceManifest = getResourceManifest(context);
 
    context->resourceStore->preloadResources(resourceManifest);
 
    firstInit = false;
  }
 
  if (!initializing_device && context->resourceStore->hasResources(resourceManifest)) {
    LOG_INFO(logger, "Found all resources. Running...");
 
#ifdef EMSCRIPTEN
    // see comment in Context (ifndef EMSCRIPTEN)
    context->resourceStore->addResourceArchive(context->variables->get("resources.zipPath", "Cogs.Resources.zip"));
    context->variables->initialize(*context->resourceStore);
#endif
    context->device->initialize();
    initializing_device = true;
  }
 
  if(initializing_device && context->device->isInitializationFinished()){
    initializing_device = false;
    LOG_TRACE(logger, "Initializing resource managers...");
 
    context->bufferManager = createResourceManager<BufferManager>(this, context);
    context->fontManager = createResourceManager<FontManager>(this, context);
    context->animationManager = createResourceManager<AnimationManager>(this, context);
    context->modelManager = createResourceManager<ModelManager>(this, context);
    context->effectManager = createResourceManager<EffectManager>(this, context);
    context->materialManager = createResourceManager<MaterialManager>(this, context);
    context->materialInstanceManager = createResourceManager<MaterialInstanceManager>(this, context);
    context->meshManager = createResourceManager<MeshManager>(this, context);
    context->textureManager = createResourceManager<TextureManager>(this, context);
    context->assetManager = createResourceManager<AssetManager>(this, context);
    context->blueNoiseManager = createResourceManager<BasicBlueNoiseManager>(this, context);
 
    context->materialDefinitionManager = context->materialManager->materialDefinitionManager.get();
 
    initializeResources();
 
    LOG_TRACE(logger, "Resource managers initialized.");
 
    context->renderer->initialize(context->device);
 
    LOG_TRACE(logger, "Initializing engine subsystems...");
 
    EngineSystems::initialize(context, this);
 
    LOG_TRACE(logger, "Engine subsystems initialized.");
 
    Instrumentation::initialize(context);
    Instrumentation::initializeThread("Main");
 
    context->initialize();
 
    // Note: The ready flag below is (among other things) used to signal that extensions
    // registered also must run system initialization when registering as the engine is
    // already initialized. That is, be careful of adding code between the loop below and
    // setting ready to true.
    for (SystemDefinition& system : data->systems) {
      system.system->initialize(context);
    }
    ready = true;
  }
 
  if (!ready) {
    static bool loggedDelay = false;
    if (!loggedDelay) {
      LOG_INFO(logger, "Delaying initialization for resource load...");
      loggedDelay = true;
    }
  }
}
 
void Cogs::Core::Engine::setEditor(IEditor * editor) { this->editor.reset(editor); }
 
void Cogs::Core::Engine::addResourceManager(std::unique_ptr<IResourceManager> && resourceManager)
{
  resourceManagers.push_back(std::move(resourceManager));
}
 
void Cogs::Core::Engine::update()
{
  CpuInstrumentationScope(SCOPE_ENGINE, "Engine::update");
  OsoMP_Message("Engine::update", 0xFFFF9911, nullptr, 0);
 
  context->qualityService->beginFrame();
 
  workParallelValue = context->variables->get("engine.workParallel", workParallelValue);
 
  // Process tasks that have arrived since last frame
  bool tasksDone = true;
  Cogs::Timer taskTimer = Cogs::Timer::startNew();
  const int mainThreadTasksFrameLimitMs = context->variables->get("engine.mainThreadTasksFrameLimitMs", 5);
  while(true) {
 
    // Try to pull a task
    std::function<void()> f;
    {
      Cogs::LockGuard guard(data->mainThreadTasks.lock);
      if (data->mainThreadTasks.tasks.empty()) break;
      f = std::move(data->mainThreadTasks.tasks.front());
      data->mainThreadTasks.tasks.pop_front();
    }
    // Break out if there are no more tasks to run.
    if (!f) {
      break;
    }
    // Run task
    f();
    // To avoid stuttering, we limit the amount of tasks we do per frame.
    // Test is after running the task, so we will always run at least one task and have progress.
    if ((0 < mainThreadTasksFrameLimitMs) && (mainThreadTasksFrameLimitMs < taskTimer.elapsedMilliseconds())) {
      Cogs::LockGuard guard(data->mainThreadTasks.lock);
      tasksDone = data->mainThreadTasks.tasks.empty();
      break;
    }
  }
 
  if (!ready) {
    checkAndUpdateResources();
    if (!ready) return;
  }
 
  updateRequested = false;
  if (!tasksDone) {
    setDirty(); // We're not done with the main thread task request another frame
  }
 
  if (editor) {
    editor->beginFrame();
  }
 
  bool vsync = context->variables->get("renderer.vSync", false);
  bool rendererDisable = context->variables->get("renderer.disable", false);
 
  if (!rendererDisable) {
    CpuInstrumentationScope(SCOPE_RENDERING, "Engine::beginFrame");
    context->renderer->beginFrame();
  }
 
  context->update();
  updateSystems();
 
  if (!rendererDisable) {
    {
      CpuInstrumentationScope(SCOPE_RENDERING, "Engine::render");
      context->qualityService->begin(MetricType::PreRender);
      preRender();
      context->qualityService->end(MetricType::PreRender);
      render();
      postRender();
    }
    {
      CpuInstrumentationScope(SCOPE_RENDERING, "Engine::present");
      context->qualityService->begin(MetricType::Present);
      context->renderer->endFrame(vsync ? 1 : 0);
      context->qualityService->end(MetricType::Present);
    }
  }
 
  context->resourceUsageLogger->update(context);
  context->qualityService->endFrame();
}
 
void Cogs::Core::Engine::updateSystems()
{
  if (systemFlags & SystemFlags::Changed) {
    std::sort(data->systems.begin(), data->systems.end(), [&](const SystemDefinition & left, const SystemDefinition & right)
    {
      return left.priority < right.priority;
    });
 
    systemFlags &= ~SystemFlags::Changed;
  }
 
  static thread_local std::vector<SystemDefinition> localSystems;
  // Make a local copy of the systems array in case it is modified during the update
  // phase. This ensures we only iterate over systems once in a given frame, and that the
  // data is not invalidated while iterating.
  localSystems = data->systems;
 
  context->transformSystem->handleOriginUpdate(context);
  {
    CpuInstrumentationScope(SCOPE_ENGINE, "Engine::preUpdateSystems");
    for (auto & system : localSystems) {
      system.system->instrumentedPreUpdate();
    }
  }
 
  {
    CpuInstrumentationScope(SCOPE_ENGINE, "Engine::updateSystems");
    for (auto & system : localSystems) {
      system.system->instrumentedUpdate();
    }
  }
 
  if (context->callbacks.postSystemsUpdateCallback) {
    context->callbacks.postSystemsUpdateCallback(context);
  }
 
  {
    CpuInstrumentationScope(SCOPE_ENGINE, "Engine::postUpdateSystems");
    for (auto & system : localSystems) {
      system.system->instrumentedPostUpdate();
    }
  }
}
 
void Cogs::Core::Engine::preRender()
{
  CpuInstrumentationScope(SCOPE_ENGINE, "PreRender");
 
  context->preRender();
 
  for (auto & resourceManager : resourceManagers) {
    resourceManager->processLoading();
  }
 
  {
    CpuInstrumentationScope(SCOPE_ENGINE, "processSwapping");
 
    for (auto & resourceManager : resourceManagers) {
      resourceManager->processSwapping();
    }
  }
 
  {
    CpuInstrumentationScope(SCOPE_ENGINE, "activateResources");
 
    for (auto & resourceManager : resourceManagers) {
      resourceManager->activateResources();
    }
  }
 
  {
    CpuInstrumentationScope(SCOPE_ENGINE, "processDeletion");
 
    for (auto & resourceManager : resourceManagers) {
      resourceManager->processDeletion();
    }
  }
}
 
void Cogs::Core::Engine::swapResources()
{
  CpuInstrumentationScope(SCOPE_ENGINE, "SwapResources");
 
  for (auto & resourceManager : resourceManagers) {
    resourceManager->processSwapping();
  }
}
 
 
void Cogs::Core::Engine::render()
{
  CpuInstrumentationScope(SCOPE_ENGINE, "Render");
 
  context->renderer->render();
}
 
void Cogs::Core::Engine::postRender()
{
 
}
 
void Cogs::Core::Engine::registerSystem(ComponentSystemBase * system, int priority, bool registerInStore)
{
  SystemDefinition definition = { system, priority };
 
  if (registerInStore) {
    context->store->addSystem(system);
  }
 
  data->systems.push_back(definition);
 
  systemFlags |= SystemFlags::Changed;
}
 
void Cogs::Core::Engine::initializeResources()
{
  for (auto & resourceManager : resourceManagers) {
    resourceManager->initialize();
  }
}
 
void Cogs::Core::Engine::clearResources()
{
  for (auto & resourceManager : resourceManagers) {
    resourceManager->clearSwapping();
  }
 
  for (auto & resourceManager : resourceManagers) {
    resourceManager->clear();
  }
  for (auto & resourceManager : resourceManagers) {
    resourceManager->processDeletion();
  }
}
 
Cogs::Core::IValueTypeManager* Cogs::Core::Engine::getResourceManagerByValueType(int valueType)
{
  auto valueType_ = (Cogs::Core::DefaultValueType)valueType;
  for (auto & mgt : resourceManagers) {
    auto * ptr = dynamic_cast<IValueTypeManager*>(mgt.get());
    if (ptr && ptr->doesManage(valueType_)) return ptr;
  }
  return nullptr;
}