Skip to content
Snippets Groups Projects
Select Git revision
  • 7118faecbf983998936fdb61a0c5e9cc3837b108
  • stable default protected
  • MA_Pape_2018
  • MA_2018_Lopatin
  • feature/mesh_viewer
  • feature/#468_access_isosurface_scalar
  • feature/#459_default_primitives
  • master protected
  • feature/#470_Create_a_color_lookup_table
  • feature/#473_resize_companion_window
  • feature/#462_do_not_use_arb_extensions
  • feature/#495_Provide_data_for_larger_isosurfaces
  • feature/#323_default_image
  • feature/#480_Create_a_smaller_test_mesh_for_combustion_demo
  • feature/#236_Get_Integration_tests_running_on_CI
  • feature/#447_Copy_standard_assets_to_build_folder
  • 447-copy-standard-assets-to-build-folder-and-remove-resource-path
  • feature/#445_mesh_render_settings_component
  • feature/#251_Make_sure_tests_cpp_is_compiled_once
  • feature/#455_Remove_navigation_and_improve_interaction_for_combustion_demo
  • feature/446_strange_txt_files
  • v18.06.0
  • v18.05.0
  • #251_bad
  • #251_good
  • v18.03.0
  • v18.02.0
  • v18.01.0
  • v17.12.0
  • v17.11.0
  • v17.10.0
  • v17.09.0
  • v17.07.0
33 results

viewer.cpp

Blame
  • viewer.cpp 4.43 KiB
    //------------------------------------------------------------------------------
    // 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 <chrono>
    #include <iostream>
    #include <memory>
    #include <vector>
    
    #include "phx/core/engine.hpp"
    #include "phx/core/entity.hpp"
    #include "phx/core/logger.hpp"
    #include "phx/core/runtime_component.hpp"
    #include "phx/core/scene.hpp"
    #include "phx/display/display_system_openvr.hpp"
    #include "phx/display/display_system_window.hpp"
    #include "phx/display/window.hpp"
    #include "phx/input/input_system.hpp"
    #include "phx/rendering/auxiliary/splash_screen.hpp"
    #include "phx/rendering/components/light.hpp"
    #include "phx/rendering/components/transform.hpp"
    #include "phx/resources/loaders/assimp_model_loader.hpp"
    #include "phx/resources/loaders/openvr_resource_loader.hpp"
    #include "phx/resources/loaders/scene_loader.hpp"
    #include "phx/resources/resource_manager.hpp"
    #include "phx/setup.hpp"
    
    #include "navigation_behavior.hpp"
    #include "viewer_system.hpp"
    
    #if defined __clang__
    #pragma clang diagnostic ignored "-Wmissing-prototypes"
    #endif
    
    int main(int, char**) {
      std::unique_ptr<phx::Engine> engine = phx::Setup::CreateDefaultEngine();
      auto scene = engine->GetScene();
    
      phx::SplashScreen splash(
          engine->GetSystem<phx::DisplaySystemWindow>()->GetWindow());
      splash.Draw();
      auto assimp_loader = static_cast<phx::AssimpModelLoader*>(
          phx::ResourceManager::instance().GetLoaderForType(".obj"));
      assimp_loader->SetProgressUpdateCallback([&splash](float progress) {
        splash.SetLoadProgress(progress);
        splash.Draw();
      });
    
      phx::InputSystem* input_system = engine->GetSystem<phx::InputSystem>();
      ViewerSystem* viewer_system = engine->CreateSystem<ViewerSystem>();
    
      input_system->AddKeyPressCallback([&engine, &viewer_system](char key) {
        if (key == 'q') engine->Stop();
        if (key == 'f')
          viewer_system->SetShowFramerate(!viewer_system->GetShowFramerate());
      });
    
      phx::SceneLoader::InsertModelIntoScene(
          "models/UniversityScene/Univers20171013.obj", scene.get());
    
      std::vector<glm::quat> light_dirs{
          glm::quat(glm::angleAxis(-0.25f * glm::pi<float>(), glm::vec3(1, 0, 0))),
          glm::quat(glm::angleAxis(0.25f * glm::pi<float>(), glm::vec3(0, 1, 0))),
          glm::quat(glm::angleAxis(-0.25f * glm::pi<float>(), glm::vec3(0, 1, 0))),
          glm::quat(glm::angleAxis(0.75f * glm::pi<float>(), glm::vec3(1, 0, 0)))};
      std::vector<glm::vec3> light_colors{
          glm::vec3(1.0, 1.0, 1.0), glm::vec3(1.0, 1.0, 1.0),
          glm::vec3(1.0, 1.0, 1.0), glm::vec3(1.0, 1.0, 1.0)};
      std::vector<float> light_intensities{1.0f, 0.9f, 0.8f, 0.7f};
    
      for (std::size_t i = 0; i < light_dirs.size(); i++) {
        phx::Entity* light_entity = scene->CreateEntity();
        phx::Transform* light_transform =
            light_entity->AddComponent<phx::Transform>();
        light_transform->SetLocalRotation(light_dirs[i]);
        phx::Light* light = light_entity->AddComponent<phx::Light>();
        light->SetType(phx::Light::Type::kDirectional);
        light->SetColor(light_colors[i]);
        light->SetIntensity(light_intensities[i]);
      }
    
      auto virtual_platform = scene->GetEntitiesWithComponents<
          phx::RuntimeComponent<phx::USER_PLATFORM>>()[0];
      auto virtual_platform_transform =
          virtual_platform->GetFirstComponent<phx::Transform>();
      glm::vec3 start_position{0.f, -1.f, -2.f};
      virtual_platform_transform->SetLocalTranslation(start_position);
      phx::info("The  virtual platform's start position is: {}", start_position);
    
      virtual_platform->AddComponent<NavigationBehavior>(
          engine->GetSystem<phx::DisplaySystemOpenVR>());
    
      engine->Run();
    
      return EXIT_SUCCESS;
    }