Skip to content
Snippets Groups Projects
Select Git revision
  • c253b671c849b97e01f92cbfd5b7c62bed6b777f
  • 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

controller_overlay.cpp

Blame
  • controller_overlay.cpp 6.81 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 <string>
    
    #include "controller_overlay.hpp"
    #include "phx/rendering/components/material_handle.hpp"
    #include "phx/rendering/components/transform.hpp"
    #include "phx/resources/loaders/scene_loader.hpp"
    #include "phx/resources/resource_utils.hpp"
    #include "phx/resources/types/image.hpp"
    #include "phx/suppress_warnings.hpp"
    
    SUPPRESS_WARNINGS_BEGIN
    #include "glm/gtc/matrix_transform.hpp"
    SUPPRESS_WARNINGS_END
    
    namespace phx {
    ControllerOverlay::ControllerOverlay(phx::Entity* controller,
                                         phx::Scene* scene) {
      auto controller_overlay = phx::SceneLoader::InsertModelIntoScene(
          "models/opticalBench/controller_overlay/Controller_Buttons.obj", scene);
    
      controller_overlay->GetFirstComponent<phx::Transform>()->SetParent(
          controller->GetFirstComponent<phx::Transform>());
    
      // select entitys
      auto transform = controller_overlay->GetFirstComponent<phx::Transform>();
      for (auto i = 0u; i < transform->GetChildCount(); i++) {
        auto entity = transform->GetChild(i)->GetEntity();
        auto handle = entity->GetFirstComponent<phx::MaterialHandle>();
    
        if (handle->GetMaterial()->GetName().compare("Grip_Left") == 0)
          grip_left_ = entity;
        else if (handle->GetMaterial()->GetName().compare("Grip_Right") == 0)
          grip_right_ = entity;
        else if (handle->GetMaterial()->GetName().compare("Trigger") == 0)
          grip_trigger_ = entity;
        else if (handle->GetMaterial()->GetName().compare("Trackpad") == 0)
          grip_trackpad_ = entity;
      }
    
      // store/load images
      grip_images_.push_back(grip_left_->GetFirstComponent<phx::MaterialHandle>()
                                 ->GetMaterial()
                                 ->GetAmbientImage());
      grip_images_.push_back(phx::ResourceUtils::LoadResourceFromFile<phx::Image>(
          "models/opticalBench/controller_overlay/menu_images/"
          "Grip_Select_Left.png"));
      grip_images_.push_back(phx::ResourceUtils::LoadResourceFromFile<phx::Image>(
          "models/opticalBench/controller_overlay/menu_images/"
          "Grip_Select_Right.png"));
      grip_images_.push_back(phx::ResourceUtils::LoadResourceFromFile<phx::Image>(
          "models/opticalBench/controller_overlay/menu_images/Grip1.png"));
      grip_images_.push_back(phx::ResourceUtils::LoadResourceFromFile<phx::Image>(
          "models/opticalBench/controller_overlay/menu_images/Grip2.png"));
      grip_images_.push_back(phx::ResourceUtils::LoadResourceFromFile<phx::Image>(
          "models/opticalBench/controller_overlay/menu_images/Grip3.png"));
    
      trigger_images_.push_back(
          grip_trigger_->GetFirstComponent<phx::MaterialHandle>()
              ->GetMaterial()
              ->GetAmbientImage());
      trigger_images_.push_back(phx::ResourceUtils::LoadResourceFromFile<
                                phx::Image>(
          "models/opticalBench/controller_overlay/menu_images/Trigger_Grab.png"));
      trigger_images_.push_back(
          phx::ResourceUtils::LoadResourceFromFile<phx::Image>(
              "models/opticalBench/controller_overlay/menu_images/"
              "Trigger_Grabbed.png"));
      trigger_images_.push_back(
          phx::ResourceUtils::LoadResourceFromFile<phx::Image>(
              "models/opticalBench/controller_overlay/menu_images/"
              "Trigger_Deselect.png"));
    
      trackpad_images_.push_back(
          grip_trackpad_->GetFirstComponent<phx::MaterialHandle>()
              ->GetMaterial()
              ->GetAmbientImage());
      trackpad_images_.push_back(
          phx::ResourceUtils::LoadResourceFromFile<phx::Image>(
              "models/opticalBench/controller_overlay/menu_images/"
              "Trackpad_Rotate.png"));
    }
    
    std::string ControllerOverlay::ToString() const { return "Controller Overlay"; }
    
    void ControllerOverlay::SetGripMode(GripMode m) {
      if (m == current_grip_mode_) return;
      switch (m) {
        case EMPTY:
          setEntityImage(grip_left_, grip_images_[4]);
          setEntityImage(grip_right_, grip_images_[4]);
          break;
        case ROTATION:
          setEntityImage(grip_left_, grip_images_[5]);
          setEntityImage(grip_right_, grip_images_[5]);
          break;
        case TRANSLATION:
          setEntityImage(grip_left_, grip_images_[3]);
          setEntityImage(grip_right_, grip_images_[3]);
          break;
        case RESET:
          setEntityImage(grip_left_, grip_images_[0]);
          setEntityImage(grip_right_, grip_images_[0]);
          break;
        case SELECT:
          setEntityImage(grip_left_, grip_images_[1]);
          setEntityImage(grip_right_, grip_images_[2]);
          break;
      };
      current_grip_mode_ = m;
    }
    
    void ControllerOverlay::SetTrackpadRotate(bool activate) {
      if (activate == current_trackpad_rotate_) return;
      if (activate) {
        setEntityImage(grip_trackpad_, trackpad_images_[1]);
      } else {
        setEntityImage(grip_trackpad_, trackpad_images_[0]);
      }
      current_trackpad_rotate_ = activate;
    }
    
    void ControllerOverlay::SetTrackpadAngle(float angle) {
      if (current_angle_ == angle) return;
      grip_trackpad_->GetFirstComponent<phx::Transform>()->SetLocalMatrix(
          glm::translate(glm::mat4(), glm::vec3(0, -0.00509f, 0.04835f)) *
          glm::rotate(glm::mat4(), angle, glm::vec3(0, 0.9935f, 0.1138f)) *
          glm::translate(glm::mat4(), glm::vec3(0, 0.00509f, -0.04835f)));
      current_angle_ = angle;
    }
    
    void ControllerOverlay::SetTriggerMode(TriggerMode m) {
      if (m == current_trigger_mode_) return;
      switch (m) {
        case NORMAL:
          setEntityImage(grip_trigger_, trigger_images_[0]);
          break;
        case GRAB:
          setEntityImage(grip_trigger_, trigger_images_[1]);
          break;
        case GRABBED:
          setEntityImage(grip_trigger_, trigger_images_[2]);
          break;
        case DESELECT:
          setEntityImage(grip_trigger_, trigger_images_[3]);
          break;
      };
      current_trigger_mode_ = m;
    }
    
    void phx::ControllerOverlay::setEntityImage(
        phx::Entity* e, phx::ResourcePointer<phx::Image> i) {
      e->GetFirstComponent<phx::MaterialHandle>()->GetMaterial()->SetAmbientImage(
          i);
      e->GetFirstComponent<phx::MaterialHandle>()->GetMaterial()->UploadTextures();
    }
    }  // namespace phx