Context.cpp

#include "Context.h"
 
#include "MemoryContext.h"
#include "ViewContext.h"
 
#include "Types.h"
 
#include "ExtensionRegistry.h"
#include "Engine.h"
#include "EntityStore.h"
 
#include "Scene.h"
 
#include "Renderer/CullingManager.h"
#include "Renderer/RenderResources.h"
#include "Renderer/RenderTexture.h"
#include "Renderer/Renderer.h"
 
#include "Scene/RayPick.h"
#include "Scene/GetBounds.h"
 
#include "Services/PipelineService.h"
#include "Services/QualityService.h"
#include "Services/Services.h"
#include "Services/DPIService.h"
#include "Services/Features.h"
#include "Services/Variables.h"
#include "Services/TaskManager.h"
#include "Services/Time.h"
#include "Services/Random.h"
#include "Services/DeferredNameResolution.h"
#include "Services/ResourceUsageLogger.h"
 
#include "Scripting/ScriptingManager.h"
 
#include "Components/Data/TrajectoryComponent.h"
#include "Components/Data/DataSetComponent.h"
#include "Components/Geometry/MarkerPointSetComponent.h"
 
#include "Generators/MeshGenerator.h"
#include "Generators/TextureGenerator.h"
 
#include "Input/InputManager.h"
 
#include "Systems/Core/DynamicComponentSystem.h"
#include "Systems/Core/InstancedModelSystem.h"
#include "Systems/Core/LightSystem.h"
#include "Systems/Core/ModelSystem.h"
 
#include "Systems/Data/TrajectorySystem.h"
 
#include "Systems/Geometry/ExtrusionSystem.h"
#include "Systems/Geometry/ShapeSystem.h"
#include "Systems/Geometry/VariableExtrusionSystem.h"
#include "Systems/Geometry/MarkerPointSetSystem.h"
#include "Systems/Geometry/MeshGeneratorSystem.h"
#include "Systems/Geometry/AdaptivePlanarGridSystem.h"
 
#include "Systems/Appearance/MaterialSystem.h"
#include "Systems/Appearance/TextureGeneratorSystem.h"
#include "Systems/Appearance/BasicOceanSystem.h"
#include "Systems/Appearance/ScreenSizeSystem.h"
 
#include "Systems/Geometry/InstancedMeshBuilderSystem.h"
 
#include "Systems/Layout/TrajectoryLayoutSystem.h"
 
#include "Resources/MaterialManager.h"
#include "Resources/ModelManager.h"
#include "Resources/ResourceStore.h"
#include "Resources/Texture.h"
#include "Resources/TextureManager.h"
 
#include "ResourceManifest.h"
 
#include "Serialization/AssetReader.h"
 
#include "Rendering/Factory.h"
#include "Rendering/ISwapChain.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/FileSystemWatcher.h"
#include "Foundation/Platform/WindowData.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Context");
 
  void onRedrawRequested(void* userData)
  {
    static_cast<Cogs::Core::Context*>(userData)->engine->triggerUpdate();
  }
}
 
namespace Cogs
{
  namespace Core
  {
    class ExtensionSystems
    {
    public:
      std::unordered_map<Reflection::TypeId, ComponentSystemBase *> systems;
    };
  }
}
 
Cogs::Core::Context::Context() : Context(nullptr, 0) {
}
 
Cogs::Core::Context::Context(const char ** variableValues, int count) :
  memory(std::make_unique<MemoryContext>()),
  services(std::make_unique<Services>(this)),
  features(std::make_unique<Features>()),
  variables(std::make_unique<Variables>(variableValues, count)),
  resourceUsageLogger(std::make_unique<ResourceUsageLogger>(this)),
  taskManager(std::make_unique<TaskManager>(this)),
  random(std::make_unique<Random>(this)),
  scriptingManager(std::make_unique<ScriptingManager>(this)),
  cullingManager(std::make_unique<CullingManager>(this)),
  time(std::make_unique<Time>(this)),
  qualityService(std::make_unique<QualityService>(this)),
  deferredResolution(std::make_unique<DeferredNameResolution>(this)),
  resourceStore(std::make_unique<ResourceStore>(this)),
  rayPicking(std::make_unique<RayPicking>()),
  bounds(std::make_unique<Bounds>()),
  extensionSystems(std::make_unique<ExtensionSystems>()),
  engine(std::make_unique<Engine>(this)),
  scene(std::make_unique<Scene>(this)),
  renderer(new Renderer(this)) // NOTE change all dynamic_cast<Cogs::Core::Renderer> if changing.
{
  LOG_TRACE(logger, "Created context.");
 
  if (variables->exist("filesystemwatcher")) {
    LOG_DEBUG(logger, "Enabling filesystemwatcher for auto-reload");
    watcher = std::make_unique<FileSystemWatcher>();
  }
 
  store = new EntityStore(this);
 
  if (variables->exist("nowindow") && !variables->exist("renderer.graphicsDevice")) {
    variables->set("renderer.graphicsDevice", "Null");
  }
  else if (variables->exist("nowindow")) {
    LOG_DEBUG(logger, "renderer.graphicsDevice is already set.  Ignoring nowindow.");
  }
 
  // Load configuration variables as early as possible.
#ifndef __EMSCRIPTEN__
  // this is done in Engine for Cogs.js since on the web we need to download config file from web before we can initialize variables
  resourceStore->addResourceArchive(variables->get("resources.zipPath", "Cogs.Resources.zip"));
  variables->initialize(*resourceStore);
#endif
 
  dynamicComponentSystem = Memory::create<DynamicComponentSystem>(memory->baseAllocator);
}
 
Cogs::Core::Context::~Context()
{
  // Relese services that cache engine resources.
  if (auto textureGenerator = services->getService<TextureGenerator>()) {
    textureGenerator->cleanup();
  }
  if (auto meshGenerator = services->getService<MeshGenerator>()) {
    meshGenerator->cleanup();
  }
 
  for (ViewContext* viewContext : views) {
    delete viewContext;
  }
  views.clear();
  defaultView = nullptr;
 
  scriptingManager->cleanup();
 
  // Make sure all tasks are finished before proceeding.  Otherwise a task
  // might try to update the engine's dirty status after it's been deleted.
  taskManager->waitAll();
 
  if (device) {
    // Unregister the redraw-request callback before the engine is destroyed, since the device (or its
    // async worker threads) could otherwise invoke it and dereference a stale engine pointer.
    GraphicsDeviceSettings deviceSettings = device->getSettings();
    deviceSettings.redrawRequestCallback = nullptr;
    deviceSettings.redrawRequestCallbackUserData = nullptr;
    device->setSettings(deviceSettings);
  }
 
  renderer->cleanup();
  store->clear();
 
  scene.reset();
  engine.reset();
  services->clear();
 
  delete store;
  delete renderer;
 
  if (device) {
 
    Cogs::Factory::releaseDevice(device);
  }
 
  LOG_DEBUG(logger, "Destroyed context.");
}
 
void Cogs::Core::Context::initializeStatic()
{
  // Avoid double initialization.
  static bool initialized = false;
 
  if (initialized) {
    LOG_WARNING(logger, "Context already statically initialized.");
 
    return;
  }
 
  LOG_DEBUG(logger, "COGS_VERSION_STRING %s", COGS_VERSION_STRING);
  LOG_DEBUG(logger, "COGS_GIT_REVISION %s", COGS_XQUOTE(COGS_GIT_REVISION));
 
  initialized = true;
 
  srand(42);
 
  initializeTypes();
 
  ExtensionRegistry::initializeStatic();
 
  LOG_DEBUG(logger, "Initialized types for reflection.");
}
 
void Cogs::Core::Context::cleanupStatic()
{
  // Avoid double cleanup.
  static bool cleaned = false;
 
  if (cleaned) {
    LOG_WARNING(logger, "Context already statically cleaned.");
 
    return;
  }
 
  Cogs::Core::cleanupTypes();
  Cogs::Core::Strings::cleanup();
}
 
bool Cogs::Core::Context::createDevice()
{
  Cogs::RenderingAllocatorInfo  allocatorInfo = { memory->baseAllocator, memory->resourceAllocator };
  auto                          deviceType = parseEnum<GraphicsDeviceType>(variables->get("renderer.graphicsDevice", "Default"), GraphicsDeviceType::Default);
 
  device = Cogs::Factory::createDevice(deviceType, &allocatorInfo);
 
  if (!device && deviceType != GraphicsDeviceType::Default) {
    LOG_WARNING(logger, "Device could not be created using the given type id: %d", static_cast<int>(deviceType));
    LOG_DEBUG(logger, "Trying to create default device.");
 
    // If no device could be created using the provided type, try to fall back to creating a default device.
    device = Cogs::Factory::createDevice(GraphicsDeviceType::Default, &allocatorInfo);
 
    if (device) {
      LOG_DEBUG(logger, "Successfully created fallback device of type %s", device->getIdentifier().c_str());
    }
  }
  else if (device) {
    LOG_DEBUG(logger, "Initialized device of type %s", device->getIdentifier().c_str());
  }
 
  if (!device) {
    LOG_ERROR(logger, "Could not create graphics device. Destroying context.");
    return false;
  }
 
  GraphicsDeviceSettings settings = {};
  settings.windowData = getDefaultView()->refWindowData();
  settings.redrawRequestCallback = &onRedrawRequested;
  settings.redrawRequestCallbackUserData = this;
 
  if (device->getType() == GraphicsDeviceType::OpenGL20) {
    // We request a feature level roughly matching what we can run all our features on. This is currently only
    // relevant when using the OpenGL20 device, and is ignored by other types of devices.
    settings.featureLevelMajor = 4;
    settings.featureLevelMinor = 6;
  }
 
  settings.numSamples = variables->get("renderer.samples", 2);
 
  int fakeAsyncEffectLoadFrames = variables->get("renderer.fakeAsyncEffectLoadFrames", 0);
  if (fakeAsyncEffectLoadFrames > 0) {
    LOG_DEBUG(logger, "renderer.fakeAsyncEffectLoadFrames set to %d, effects will simulate async loading.", fakeAsyncEffectLoadFrames);
    settings.fakeAsyncEffectLoadFrames = static_cast<uint32_t>(fakeAsyncEffectLoadFrames);
  }
 
  if (variables->get("cache.enableShaderCache", false)) {
    settings.flags |= GraphicsDeviceFlags::EnableShaderCache;
  }
 
  if (variables->get("effects.dumpShaders", false)) {
    settings.flags |= GraphicsDeviceFlags::DumpShaderContents;
  }
 
  if (variables->get("renderer.forceSoftwareRendering", false)) {
    settings.flags |= GraphicsDeviceFlags::ForceSoftwareRendering;
  }
 
  if (variables->get("renderer.sharedSurface", false)) {
    settings.flags |= GraphicsDeviceFlags::UseSharedSurface;
  }
 
  if (variables->get("renderer.debugDevice", false)) {
    settings.flags |= GraphicsDeviceFlags::Debug;
  }
 
  if (variables->get("renderer.useSwapEffectDiscard", false)) {
    settings.flags |= GraphicsDeviceFlags::UseSwapEffectDiscard;
  }
 
  if (!variables->get("renderer.disableClipControl", false)) {
    settings.flags |= GraphicsDeviceFlags::UseOpenGLClipControl;
  }
 
  settings.colorFormat = parseTextureFormat(variables->get("renderer.colorFormat", "R8G8B8A8_UNORM_SRGB"), TextureFormat::R8G8B8A8_UNORM_SRGB);
  settings.depthFormat = parseTextureFormat(variables->get("renderer.depthFormat", "D32_FLOAT"), TextureFormat::D32_FLOAT);
  settings.ioHandler = resourceStore->getIOHandler();
  settings.sharedSurface = &sharedSurface;              // Provide storage for shared surface pointer.
 
  return device->setSettings(settings);
}
 
void Cogs::Core::Context::initialize() {
  scriptingManager->initialize();
 
  services->registerService<PipelineService>(this);
  services->registerService<MeshGenerator>(this);
  services->registerService<TextureGenerator>(this);
 
  readAsset(this, variables->get("store.entityDefinitions", "Default.entities"), AssetLoadFlags::NoDefault);
 
  engine->registerSystem<ComponentSystem<DataSetComponent>>(SystemPriority::PreTransform, nullptr, 128);
 
  LOG_TRACE(logger, "Initialized static systems.");
 
  trajectorySystem = engine->registerSystem<TrajectorySystem>(SystemPriority::PreTransform, nullptr, 128);
  modelSystem = engine->registerSystem<ModelSystem>(SystemPriority::PreTransform, nullptr, 1024);
  instancedModelSystem = engine->registerSystem<InstancedModelSystem>(SystemPriority::PreTransform, nullptr, 128);
  engine->registerSystem<ShapeSystem>(SystemPriority::PreTransform, nullptr, 1024);
 
  engine->registerSystem<ExtrusionSystem>(SystemPriority::Geometry, nullptr, 128);
  engine->registerSystem<VariableExtrusionSystem>(SystemPriority::Geometry, nullptr, 128);
  engine->registerSystem<TextureGeneratorSystem>(SystemPriority::Geometry, nullptr, 128);
  engine->registerSystem<MarkerPointSetSystem>(SystemPriority::Geometry, nullptr, 128);
  engine->registerSystem<MeshGeneratorSystem>(SystemPriority::Geometry, nullptr, 128);
 
  materialSystem = engine->registerSystem<MaterialSystem>(SystemPriority::PreRendering, nullptr, 1024);
 
  engine->registerSystem<TrajectoryLayoutSystem>(SystemPriority::PostTransform, nullptr, 32);
  adaptivePlanarGridSystem = engine->registerSystem<AdaptivePlanarGridSystem>(SystemPriority::PreTransform, nullptr, 32);
  basicOceanSystem = engine->registerSystem<BasicOceanSystem>(SystemPriority::PostView, nullptr, 32);
 
  engine->registerSystem<ScreenSizeSystem>(SystemPriority::PreLightView, nullptr, 32);
 
  engine->registerSystem<InstancedMeshBuilderSystem>(SystemPriority::PreRendering, nullptr, 32);
 
  initializeDynamicComponents();
 
  materialManager->initializeDefaultMaterial();
  materialInstanceManager->initializeDefaultMaterialInstance();
 
  LOG_TRACE(logger, "Initializing extensions...");
 
  ExtensionRegistry::initialize(this);
 
  LOG_TRACE(logger, "Extensions initialized.");
 
  if (defaultView) {
    // The camera will be set in scene->setup(), after the mainCamera is created.
    defaultView->initialize(nullptr);
  }
 
  scene->setup(true);
}
 
void Cogs::Core::Context::clear()
{
  scene->clear();
  transformSystem->setOrigin({ 0, 0, 0 });
  engine->setDirty();
}
 
void Cogs::Core::Context::initializeDynamicComponents()
{
  registerDynamicComponentType("CurvedEarthPositionComponent");
  registerDynamicComponentType("FontSelectorComponent");
  registerDynamicComponentType("TrajectoryAlignedComponent");
  registerDynamicComponentType("ReflectionComponent");
  registerDynamicComponentType("BasicTerrainComponent");
  registerDynamicComponentType("NearLimitComponent");
  registerDynamicComponentType("ExpressionComponent");
  registerDynamicComponentType("FPSNavigationComponent");
  registerDynamicComponentType("TeleportNavigationComponent");
  registerDynamicComponentType("PickingBeamComponent");
  registerDynamicComponentType("MotionComponent");
  registerDynamicComponentType("SwitchComponent");
  registerDynamicComponentType("OrbitingCameraController");
}
 
void Cogs::Core::Context::registerDynamicComponentType(const StringView & typeName)
{
  auto & type = Reflection::TypeDatabase::getType(typeName);
 
  if (!type.isValid()) {
    LOG_ERROR(logger, "Cannot register %.*s as dynamic component. Did you forget to register the type?", StringViewFormat(typeName));
 
    return;
  }
 
  auto base = type.getBase();
  while (base && base != &Reflection::TypeDatabase::getType<DynamicComponent>()) {
    base = base->getBase();
  }
 
  if (!base) {
    LOG_ERROR(logger, "Cannot register %.*s as dynamic component without inheriting from DynamicComponent base class.", StringViewFormat(typeName));
 
    assert(false && "Invalid dynamic component base class.");
  }
 
  dynamicComponentSystem->registerType(this, type);
}
 
void Cogs::Core::Context::registerExtensionSystem(const uint16_t id, ComponentSystemBase * system)
{
  extensionSystems->systems[id] = system;
 
  // The engine will run initialization of registered systems when it initializes. If the extension is
  // registered after the engine has run, we must initialize it.
  if (engine && engine->isReady()) {
    system->initialize(this);
  }
}
 
Cogs::Core::ComponentSystemBase * Cogs::Core::Context::getExtensionSystem(const uint16_t id)
{
  return extensionSystems->systems[id];
}
 
void Cogs::Core::Context::update() {
  // Update time before everything else.
  time->update();
  taskManager->updateState(this);
 
  // Notify all a new frame is in progress.
  services->dispatchFrameCallbacks();
 
  for (ViewContext* view : views) {
    view->update();
  }
}
 
void Cogs::Core::Context::preRender() {
  for (auto & c : cameraSystem->pool) {
    if ((c.flags & CameraFlags::EnableRender) == CameraFlags::EnableRender) {
      cullingManager->dispatchCulling(&cameraSystem->getData(&c));
    }
  }
  lightSystem->preRender(this);
 
  if (callbacks.preRenderCallback) {
    callbacks.preRenderCallback(this);
  }
  for (ViewContext* view : views) {
    view->preRender();
  }
}
 
Cogs::Core::ViewContext* Cogs::Core::Context::createView(WindowData* windowData) {
  ViewContext*  viewContext = new ViewContext(this, windowData);
 
  views.push_back(viewContext);
  return viewContext;
}
 
void Cogs::Core::Context::deleteView(ViewContext* view) {
  auto e = views.end();
  auto i = std::find(views.begin(), e, view);
 
  if (i != e) {
    views.erase(i);
    delete view;
  }
}