SceneSystem.cpp

#include "SceneSystem.h"
#include "Components/Core/RenderComponent.h"
 
#include "Foundation/ComponentModel/Entity.h"
 
#include <functional>
 
void Cogs::Core::SceneSystem::update(Context * /*context*/)
{
  ComponentModel::ComponentCollection<RenderComponent> renderComponents;
  bool updateHierarchy = false;
 
  needsPost = false;
 
  for (const auto & sceneComponent : pool) {
    if (!sceneComponent.isActive()) continue;
    if (!sceneComponent.hasChanged()) continue;
 
    needsPost = true;
 
    sceneComponent.getContainer()->getComponents(renderComponents);
 
    for (auto & renderComponent : renderComponents) {
      renderComponent.setRenderFlag(RenderFlags::SelfVisibility, sceneComponent.visible);
      renderComponent.setRenderFlag(RenderFlags::SelfPickable, sceneComponent.pickable);
    }
 
    if (!sceneComponent.children.empty()) {
      // If component has children, we must propagate properties down the hierarchy. Since
      // we don't have current parent-flags, we defer the traversal until we have plowed
      // through all components and start at the roots.
      updateHierarchy = true;
    }
  }
 
  if (updateHierarchy) {
    for (auto & sceneComponent : pool) {
      if (sceneComponent.parent || sceneComponent.children.empty()) {
        // Neither a root nor a parent node, skip
        continue;
      }
 
      std::function<void(SceneComponent &, bool, bool)> updateChildren = [&](SceneComponent & component, bool parentVisible, bool parentPickable)
      {
        for (const auto & child : component.children) {
          child->getComponents(renderComponents);
 
          for (auto & childComponent : renderComponents) {
            childComponent.setRenderFlag(RenderFlags::ParentVisibility, parentVisible);
            childComponent.setRenderFlag(RenderFlags::ParentPickable, parentPickable);
          }
 
          auto childSceneComponent = child->getComponent<SceneComponent>();
 
          if (childSceneComponent) {
            childSceneComponent->parent = getHandle(&component);
            updateChildren(*childSceneComponent, parentVisible && childSceneComponent->visible, parentPickable && childSceneComponent->pickable);
          }
        }
      };
 
      updateChildren(sceneComponent, sceneComponent.visible, sceneComponent.pickable);
    }
  }
}
 
void Cogs::Core::SceneSystem::postUpdate(Context * context)
{
  if (!needsPost) return;
 
  ComponentSystem::postUpdate(context);
}
 
Cogs::Core::SceneState Cogs::Core::SceneSystem::getSceneState(const SceneComponent & sceneComponent)
{
  if (sceneComponent.parent) {
    auto parentSceneComponent = sceneComponent.parent.resolveComponent<SceneComponent>();
    auto parentState = getSceneState(*parentSceneComponent);
 
    return SceneState{ parentState.visible && sceneComponent.visible, parentState.pickable && sceneComponent.pickable };
  } else {
    return SceneState{ sceneComponent.visible, sceneComponent.pickable };
  }
}
 
void Cogs::Core::SceneSystem::updateState(SceneComponent & sceneComponent)
{
  auto parentState = sceneComponent.parent ? getSceneState(*sceneComponent.parent.resolveComponent<SceneComponent>()) : SceneState{ true, true };
 
  ComponentModel::ComponentCollection<RenderComponent> collection;
  sceneComponent.getContainer()->getComponents(collection);
 
  for (auto & component : collection) {
    component.setRenderFlag(RenderFlags::ParentVisibility, parentState.visible);
    component.setRenderFlag(RenderFlags::ParentPickable, parentState.pickable);
    component.setRenderFlag(RenderFlags::SelfVisibility, sceneComponent.visible);
    component.setRenderFlag(RenderFlags::SelfPickable, sceneComponent.pickable);
  }
}