Scene.cpp

#include "Scene.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Context.h"
#include "Engine.h"
#include "EntityStore.h"
 
#include "Services/Variables.h"
#include "Services/TaskManager.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/FogSystem.h"
#include "Systems/Core/EnvironmentSystem.h"
 
#include "Serialization/AssetReader.h"
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("Scene");
}
 
Cogs::Core::Scene::Scene(Context * context) : context(context)
{
 
}
 
void Cogs::Core::Scene::setup(bool readDefaultScene)
{
  if (readDefaultScene && context->variables->get("noDefaultScene")->isEmpty()) {
    Cogs::Core::readAsset(context, context->variables->get("defaultScene", "Scenes/Default.scene"), AssetLoadFlags::NoDefault);
  }
 
  EntityPtr camera = context->store->getEntity("Camera", false);
 
  if (!camera) {
    LOG_WARNING(logger, "Default camera missing. Creating fallback camera.");
 
    camera = context->store->createEntity("Camera", "Camera");
  }
 
  ComponentHandle cameraComponent = camera->getComponentHandle<CameraComponent>();
 
  if (!cameraComponent) {
    LOG_ERROR(logger, "Default camera invalid. No CameraComponent. Adding fallback.");
 
    cameraComponent = context->cameraSystem->createComponent();
    camera->addComponent(cameraComponent);
  }
 
  if (!camera->getComponent<TransformComponent>()) {
    LOG_ERROR(logger, "Default camera invalid. No TransformComponent. Adding fallback.");
 
    camera->addComponent(context->transformSystem->createComponent());
  }
 
  context->cameraSystem->setMainCamera(cameraComponent);
  context->getDefaultView()->setCamera(camera);
 
  cameraComponent.resolveComponent<CameraComponent>()->viewportSize = context->getDefaultView()->getSize();
 
  EntityPtr fog = context->store->getEntity("Fog");
  ComponentHandle fogComponent;
  if (fog) {
    fogComponent = fog->getComponentHandle<FogComponent>();
    if (!fogComponent) {
      LOG_ERROR(logger, "Entity 'Fog' expected to have FogComponent.");
    }
  }
 
  context->fogSystem->setGlobalFog(fogComponent);
 
  EntityPtr env = context->store->getEntity("Environment");
  ComponentHandle environmentComponent;
  if (env) {
    environmentComponent = env->getComponentHandle<EnvironmentComponent>();
    if (!environmentComponent) {
      LOG_ERROR(logger, "Entity 'Environment' expected to have EnvironmentComponent.");
    }
  }
 
  context->environmentSystem->setGlobalEnvironment(environmentComponent);
}
 
void Cogs::Core::Scene::clear()
{
  sceneResources.clear();
 
  context->taskManager->waitAll();
 
  context->store->clear();
 
  context->engine->clearResources();
 
  context->engine->initializeResources();
}
 
void Cogs::Core::Scene::addResource(ResourceHandleBase & resource)
{
  sceneResources.emplace_back(resource);
}