Context.h

#pragma once
 
#include "Base.h"
#include "EntityPtr.h"
 
#include <list>
#include <span>
 
namespace Cogs
{
  struct WindowData;
  class FileSystemWatcher;
  class IGraphicsDevice;
 
  namespace Platform
  {
    class GamepadHandler;
  }
 
  namespace Core
  {
    struct CameraData;
    class Time;
    class ViewContext;
 
    typedef void ResourceLoadCallback(class Context * context, int resourceType, ResourceId id, int code);
 
    typedef void HierarchyChangeCallback(class Context * context, EntityId entityId);
 
    typedef void RenderCallback(class Context * context);
 
    typedef void ReadbackCallback(class Context * context, const char * key, const void * data, int size);
 
    typedef void ReadbackCallbackInternal(class Context* context, const CameraData *, uint32_t frame, const char * key, const void * data, int size);
 
    typedef void MessageCallback(int messageId, const void * data);
 
    typedef void ComponentNotifyCallback(BridgeContext* context, int componentTypeId, size_t entityId, int notification, const void* data, size_t dataSize);
 
    class COGSCORE_DLL_API ContextBase
    {
    public:
      virtual ~ContextBase() = default;
 
      class TransformSystem * transformSystem = nullptr;
      class SceneSystem * sceneSystem = nullptr;
      class MeshSystem * meshSystem = nullptr;
      class RenderSystem * renderSystem = nullptr;
      class SubMeshRenderSystem * subMeshRenderSystem = nullptr;
      class InstancedMeshRenderSystem * instancedMeshRenderSystem = nullptr;
    };
 
    class COGSCORE_DLL_API Context : public ContextBase
    {
    public:
      Context(const char ** variables, int count);
      Context();
 
      ~Context() override;
 
      static void initializeStatic();
 
      static void cleanupStatic();
 
      bool createDevice();
 
      void initialize();
 
      void clear();
 
      void initializeDynamicComponents();
 
      void registerDynamicComponentType(const StringView & typeName);
 
      void registerExtensionSystem(const uint16_t id, class ComponentSystemBase * system);
 
      class ComponentSystemBase * getExtensionSystem(const uint16_t id);
 
      void update();
      void preRender();
 
      ViewContext* createView(WindowData* windowData);
      void deleteView(ViewContext* view);
 
      void setDefaultView(ViewContext* view)  { defaultView = view; }
      ViewContext* getDefaultView() const     { return defaultView; }
      std::span<ViewContext*> getViews()     { return views; }
 
      std::unique_ptr<struct MemoryContext> memory;
 
      std::unique_ptr<class Services> services;
 
      std::unique_ptr<class Features> features;
 
      std::unique_ptr<class Variables> variables;
 
      std::unique_ptr<class ResourceUsageLogger> resourceUsageLogger;
 
      std::unique_ptr<class TaskManager> taskManager;
 
      std::unique_ptr<class Random> random;
 
      std::unique_ptr<class ScriptingManager> scriptingManager;
 
      std::unique_ptr<class CullingManager> cullingManager;
 
      std::unique_ptr<class Time> time;
 
      std::unique_ptr<class QualityService> qualityService;
 
      std::unique_ptr<class DeferredNameResolution> deferredResolution;
 
      std::unique_ptr<FileSystemWatcher> watcher;
 
      std::unique_ptr<class ResourceStore> resourceStore;
 
      std::unique_ptr<class RayPicking> rayPicking;
 
      std::unique_ptr<class Bounds> bounds;
 
      std::unique_ptr<class ExtensionSystems> extensionSystems;
 
      std::unique_ptr<class Engine> engine;
 
      std::unique_ptr<class Scene> scene;
 
      class IRenderer* renderer;
 
      class EntityStore* store;
 
 
      IGraphicsDevice * device = nullptr;
 
      struct IVideoDecoderContext *videoDecoderContext = nullptr;
      struct IVideoEncoderContext *videoEncoderContext = nullptr;
 
      class AssetSystem * assetSystem = nullptr;
      class PropertiesSystem * propertiesSystem = nullptr;
      class TrajectorySystem * trajectorySystem = nullptr;
      class ModelSystem * modelSystem = nullptr;
      class InstancedModelSystem * instancedModelSystem = nullptr;
      class StaticModelSystem * staticModelSystem = nullptr;
      class LodSystem * lodSystem = nullptr;
      class AnimationSystem * animationSystem = nullptr;
      class ScriptSystem * scriptSystem = nullptr;
      class CameraSystem * cameraSystem = nullptr;
      class CameraArraySystem* cameraArraySystem = nullptr;
      class ClipShapeSystem* clipShapeSystem = nullptr;
      class ClipShapeRefSystem* clipShapeRefSystem = nullptr;
      class BillboardSystem * billboardSystem = nullptr;
      class LightSystem * lightSystem = nullptr;
      class FogSystem * fogSystem = nullptr;
      class EnvironmentSystem * environmentSystem = nullptr;
      class BasicOceanSystem * basicOceanSystem = nullptr;
      class TextSystem * textSystem = nullptr;
      class Text3DSystem * text3DSystem = nullptr;
      class OverlaySystem * overlaySystem = nullptr;
      class AdaptivePlanarGridSystem * adaptivePlanarGridSystem = nullptr;
      class SpriteRenderSystem * spriteRenderSystem = nullptr;
      class CaptureSystem * captureSystem = nullptr;
      class MaterialSystem * materialSystem = nullptr;
 
      class DynamicComponentSystem * dynamicComponentSystem = nullptr;
 
      class BufferManager * bufferManager = nullptr;
      class TextureManager * textureManager = nullptr;
      class IBlueNoiseManager * blueNoiseManager = nullptr;
      class AnimationManager * animationManager = nullptr;
      class MeshManager * meshManager = nullptr;
      class ModelManager * modelManager = nullptr;
      class EffectManager * effectManager = nullptr;
      class MaterialManager * materialManager = nullptr;
      class MaterialDefinitionManager * materialDefinitionManager = nullptr;
      class MaterialInstanceManager * materialInstanceManager = nullptr;
      class FontManager * fontManager = nullptr;
      class AssetManager * assetManager = nullptr;
      void * sharedSurface = nullptr;
 
 
      struct Debug
      {
        bool enableExecutionChecks = false;
 
        std::string miniDumpPath = "./";
 
        std::string miniDumpName = "Cogs";
      } debug;
 
      struct Callbacks
      {
        ResourceLoadCallback* resourceLoadCallback = nullptr;
        HierarchyChangeCallback* hierarchyChangeCallback = nullptr;
        RenderCallback* postSystemsUpdateCallback = nullptr;
        RenderCallback* preRenderCallback = nullptr;
        RenderCallback* postRenderCallback = nullptr;
        ReadbackCallback* readbackCallback = nullptr;
        ComponentNotifyCallback* componentNotifyCallback = nullptr;
 
        std::list<ReadbackCallbackInternal*> readbackCallbackInternal;
 
      } callbacks;
 
    private:
      ViewContext* defaultView = nullptr;
      std::vector<ViewContext*> views;
    };
  }
}