Engine.h

#pragma once
 
#include "Context.h"
#include "MemoryContext.h"
 
#include "Services/TaskManager.h"
 
#include "Foundation/Memory/Allocator.h"
 
#include <atomic>
#include <vector>
 
namespace Cogs
{
  class IGraphicsDevice;
 
  namespace Core
  {
    class Context;
    class ComponentSystemBase;
    class IResourceManager;
    class IValueTypeManager;
 
    typedef void NeedsUpdateCallback(void* data);
 
    struct SystemPriority
    {
      enum ESystemPriority : int32_t
      {
        PreDynamicComponents = -200,
        DynamicComponents = -150,
        PreTransform = -100,
        Transform = 0,
        PostTransform = 100,
        PreView = 190,
        View = 200,
        PreLightView = 203,
        LightView = 205,
        DispatchViewDependent = 208,
        PostView = 210,
        PreGeometry = 900,
        Geometry = 1000,
        PostGeometry = 1100,
        PreRendering = 9900,
        Rendering = 10000,
      };
    };
 
    class COGSCORE_DLL_API Engine
    {
    public:
      Engine(Context * context);
 
      Engine(const Engine & other) = delete;
 
      ~Engine();
 
      Engine & operator=(const Engine & other) = delete;
 
      void update();
 
      /* Wrappers for calling client-provided callbacks.
 
         On web, client-provided callbacks must be called from the main thread. These wrappers handle
         this by proxying the call to the main-thread if called on a worker thread.
 
         On desktop and single-thread web, these wrappers just directly calls the callbacks.
      */
 
#if defined(EMSCRIPTEN) && !defined(COGS_SINGLETHREADED)
      void invokeCallback(void(*callback)(void*), void* data);
 
      void invokeComponentNotifyCallback(const ComponentModel::Component& component, int notification, const void* data, size_t dataSize);
 
      void invokeResourceLoadCallback(int resourceType, ResourceId id, int code);
#else
      void invokeCallback(void(*callback)(void*), void* data) { if (callback) { callback(data); } }
 
      void invokeComponentNotifyCallback(const ComponentModel::Component& component, int notification, const void* data, size_t dataSize) {
        if (context->callbacks.componentNotifyCallback) {
          context->callbacks.componentNotifyCallback(context, component.getTypeId(), component.getContainer()->getId(), notification, data, dataSize);
        }
      }
 
      void invokeResourceLoadCallback(int resourceType, ResourceId id, int code) {
        if (context->callbacks.resourceLoadCallback) {
          context->callbacks.resourceLoadCallback(context, resourceType, id, code);
        }
      }
#endif
 
      inline bool needsUpdate() const
      {
        return updateRequested;
      }
 
      inline void triggerUpdate()
      {
        bool wasRequested = updateRequested.exchange(true);
        if ((wasRequested == false) && needsUpdateCallback) {
          invokeCallback(needsUpdateCallback, needsUpdateData);
        }
      }
 
      inline void setDirty()
      {
        if (!updateRequested) setDirtyState();
      }
 
      inline uint32_t getLastDirtyFrame() { return lastDirtyFrame; }
 
      void setNeedsUpdateCallback(NeedsUpdateCallback* callback, void* data) { needsUpdateCallback = callback; needsUpdateData = data; }
 
      void updateSystems();
 
      void registerSystem(ComponentSystemBase * system, int priority, bool registerInStore = true);
 
      template<typename SystemType>
      SystemType * registerSystem(int priority, SystemType ** storage, uint32_t capacity, bool registerInStore = true)
      {
        auto system = Memory::create<SystemType>(
          context->memory->baseAllocator,
          context->memory->componentAllocator,
          capacity);
 
        if (storage) {
          *storage = system;
        }
 
        registerSystem(system, priority, registerInStore);
 
        return system;
      }
 
      void addResourceManager(std::unique_ptr<IResourceManager> && resourceManager);
 
      IValueTypeManager* getResourceManagerByValueType(int valueType);
 
      void initializeResources();
 
      void clearResources();
 
      void runTaskInMainThread(std::function<void()>&& task);
 
      void preRender();
      void render();
      void postRender();
 
      void swapResources();
 
      bool workParallel() const { return workParallelValue; }
 
      bool isReady() const { return ready; }
 
      void checkAndUpdateResources();
 
      void setEditor(class IEditor * editor);
      class IEditor * getEditor() const { return editor.get(); }
 
    private:
 
 
      void setDirtyState();
 
      Context * context = nullptr;
 
      NeedsUpdateCallback* needsUpdateCallback = nullptr;
      void* needsUpdateData = nullptr;
 
      std::vector<std::string> resourceManifest;
 
      std::unique_ptr<class IEditor> editor;
 
      struct SystemFlags
      {
        enum ESystemFlags
        {
          None = 0x0002,
          Changed = 0x0001,
        };
      };
 
      uint32_t systemFlags = SystemFlags::None;
 
      uint32_t lastDirtyFrame = 0;
      std::atomic_bool updateRequested = true;
 
      // Multi pass initialization of graphics device, needed for WebGPU, waiting for
      // Async adapter request
      bool initializing_device = false;
      bool ready = false;
      bool firstInit = true;
      bool workParallelValue = true;
 
      std::vector<std::unique_ptr<IResourceManager>> resourceManagers;
 
      std::unique_ptr<struct EngineData> data;
    };
  }
}