rendering_system.cpp

//------------------------------------------------------------------------------
// Project Phoenix
//
// Copyright (c) 2017-2018 RWTH Aachen University, Germany,
// Virtual Reality & Immersive Visualization Group.
//------------------------------------------------------------------------------
//                                 License
//
// Licensed under the 3-Clause BSD License (the "License");
// you may not use this file except in compliance with the License.
// See the file LICENSE for the full text.
// You may obtain a copy of the License at
//
//     https://opensource.org/licenses/BSD-3-Clause
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//------------------------------------------------------------------------------

#include "phx/rendering/rendering_system.hpp"

#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "phx/core/engine.hpp"
#include "phx/core/logger.hpp"
#include "phx/core/scene.hpp"
#include "phx/core/system.hpp"
#include "phx/rendering/components/light.hpp"
#include "phx/rendering/components/mesh_render_settings.hpp"
#include "phx/rendering/components/resource_component.hpp"
#include "phx/rendering/components/skybox.hpp"
#include "phx/rendering/components/transform.hpp"
#include "phx/rendering/render_passes/skybox_pass.hpp"
#include "phx/resources/resource_pointer.hpp"
#include "phx/resources/types/material.hpp"
#include "phx/resources/types/mesh.hpp"

#include "gl/debug.hpp"
#include "gl/opengl.hpp"

namespace phx {

RenderingSystem::RenderingSystem(Engine* engine, DisplaySystem* display_system)
    : System(engine) {
  if (!display_system) error("RenderingSystem needs a valid DisplaySystem.");
  InitializeOpenGL();
  SetupFramegraph();
}

void RenderingSystem::InitializeOpenGL() {
  if (!gl::initialize()) {
    error("Initializing gl failed");
  }

  gl::set_debug_output_enabled(true);
  gl::set_debug_log_callback([&](gl::debug_log log) {
    warn("[gl::error] with message {}", log.message);
  });
}

void RenderingSystem::SetupFramegraph() {
  // set up an empty frame graph, just so we always have one...
  frame_graph_ = std::make_unique<FrameGraph>();
  frame_graph_->Initialize();
}

void RenderingSystem::Update(const FrameTimer::TimeInfo&) {
  if (GetEngine()->GetScene() == nullptr) {
    return;
  }

  std::vector<GeometryPass::RenderingInstance> rendering_instances;
  std::vector<std::pair<Light*, Transform*>> light_transform_pairs;
  Skybox* skybox = nullptr;

  for (auto& entity : GetEngine()->GetEntities()) {
    auto light = entity->GetFirstComponent<Light>();
    auto transform = entity->GetFirstComponent<Transform>();

    const auto material =
        entity->GetFirstComponent<ResourceComponent<Material>>();
    const auto mesh = entity->GetFirstComponent<ResourceComponent<Mesh>>();
    const auto mesh_render_settings =
        entity->GetFirstComponent<MeshRenderSettings>();
    if (transform != nullptr) {
      if (mesh != nullptr) {
        rendering_instances.push_back(
            {mesh->GetResourcePointer().Get(),
             (material != nullptr ? material->GetResourcePointer().Get()
                                  : nullptr),
             transform, mesh_render_settings});

      } else if (light != nullptr) {
        light_transform_pairs.push_back(
            std::pair<Light*, Transform*>(light, transform));
      }
    }
    if (entity->GetFirstComponent<Skybox>() != nullptr) {
      skybox = entity->GetFirstComponent<Skybox>();
    }
  }

  auto skybox_passes = frame_graph_->GetRenderPasses<SkyboxPass>();
  for (auto skybox_pass : skybox_passes) {
    skybox_pass->SetSkyboxComponent(skybox);
  }

  auto geometry_passes = frame_graph_->GetRenderPasses<GeometryPass>();
  for (auto geometry_pass : geometry_passes) {
    geometry_pass->SetData(rendering_instances, light_transform_pairs);
  }

  frame_graph_->Execute();
}

FrameGraph* RenderingSystem::GetFrameGraph() const {
  return frame_graph_.get();
}

void RenderingSystem::SetFrameGraph(std::unique_ptr<FrameGraph> frame_graph) {
  frame_graph_ = std::move(frame_graph);
}

std::string RenderingSystem::ToString() const {
  return "RenderingSystem with #FrameGraph-Passes: " +
         std::to_string(frame_graph_->GetNumberOfPasses());
}

}  // namespace phx