From 2bf401b16b227aa1ee7b203367288bb9d45446eb Mon Sep 17 00:00:00 2001
From: Sebastian Pape <Sebastian.Pape@rwth-aachen.de>
Date: Thu, 26 Jul 2018 12:22:48 +0200
Subject: [PATCH] Refactoring to adhere to naming convetions from googles style
 guide

---
 .../optical_bench/src/controller_overlay.cpp  |  34 +-
 .../optical_bench/src/controller_overlay.hpp  |   2 +-
 demos/optical_bench/src/file_reader_zmx.cpp   |   2 +-
 demos/optical_bench/src/file_reader_zmx.hpp   |   5 +-
 .../src/hmd_navigation_behavior.cpp           |  65 ++--
 .../src/hmd_navigation_behavior.hpp           |  14 +-
 demos/optical_bench/src/laser_menu.cpp        |  20 +-
 demos/optical_bench/src/laser_menu.hpp        |   5 +-
 demos/optical_bench/src/lens.cpp              | 156 ++++-----
 demos/optical_bench/src/lens.hpp              |  56 +--
 demos/optical_bench/src/lens_menu.cpp         |  32 +-
 demos/optical_bench/src/lens_menu.hpp         |   4 +-
 demos/optical_bench/src/menu_button.cpp       |  24 +-
 demos/optical_bench/src/menu_button.hpp       |  10 +-
 demos/optical_bench/src/menu_helper.hpp       |   6 +-
 demos/optical_bench/src/menu_manager.cpp      |  14 +-
 demos/optical_bench/src/menu_manager.hpp      |   9 +-
 demos/optical_bench/src/menu_slider.cpp       |  60 ++--
 demos/optical_bench/src/menu_slider.hpp       |  18 +-
 demos/optical_bench/src/menu_switch.cpp       |  14 +-
 demos/optical_bench/src/menu_switch.hpp       |   9 +-
 demos/optical_bench/src/object_manager.cpp    |  40 +--
 demos/optical_bench/src/object_manager.hpp    |  19 +-
 demos/optical_bench/src/object_menu.cpp       |   2 +-
 demos/optical_bench/src/object_menu.hpp       |   5 +-
 .../optical_bench/src/object_support_rod.cpp  |   8 +-
 .../optical_bench/src/object_support_rod.hpp  |   2 +-
 demos/optical_bench/src/optical_bench.cpp     |   4 +-
 .../src/optix_context_manager.cpp             |  92 ++---
 .../src/optix_context_manager.hpp             |  48 +--
 demos/optical_bench/src/optix_engine.cpp      |  10 +-
 demos/optical_bench/src/optix_engine.hpp      |  16 +-
 demos/optical_bench/src/optix_pass.cpp        | 122 +++----
 demos/optical_bench/src/optix_pass.hpp        |  30 +-
 demos/optical_bench/src/ray_pass.cpp          | 327 +++++++++---------
 demos/optical_bench/src/ray_pass.hpp          | 105 +++---
 demos/optical_bench/src/rotation_helper.cpp   |  94 ++---
 demos/optical_bench/src/rotation_helper.hpp   |  19 +-
 demos/optical_bench/src/selection_system.cpp  |  10 +-
 demos/optical_bench/src/selection_system.hpp  |   4 +-
 demos/optical_bench/src/selector.cpp          |  12 +-
 demos/optical_bench/src/selector.hpp          |  17 +-
 .../optical_bench/src/test_pattern_frame.cpp  |  44 +--
 .../optical_bench/src/test_pattern_frame.hpp  |  17 +-
 demos/optical_bench/src/text.cpp              |   8 +-
 demos/optical_bench/src/text.hpp              |   4 +-
 demos/optical_bench/src/text_pass.cpp         |  72 ++--
 demos/optical_bench/src/text_pass.hpp         |  24 +-
 .../optical_bench/src/translation_helper.cpp  |  54 +--
 .../optical_bench/src/translation_helper.hpp  |  11 +-
 50 files changed, 918 insertions(+), 861 deletions(-)

diff --git a/demos/optical_bench/src/controller_overlay.cpp b/demos/optical_bench/src/controller_overlay.cpp
index 3bea06ff..22515363 100644
--- a/demos/optical_bench/src/controller_overlay.cpp
+++ b/demos/optical_bench/src/controller_overlay.cpp
@@ -108,24 +108,24 @@ 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]);
+      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]);
+      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]);
+      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]);
+      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]);
+      SetEntityImage(grip_left_, grip_images_[1]);
+      SetEntityImage(grip_right_, grip_images_[2]);
       break;
   };
   current_grip_mode_ = m;
@@ -134,9 +134,9 @@ void ControllerOverlay::SetGripMode(GripMode m) {
 void ControllerOverlay::SetTrackpadRotate(bool activate) {
   if (activate == current_trackpad_rotate_) return;
   if (activate) {
-    setEntityImage(grip_trackpad_, trackpad_images_[1]);
+    SetEntityImage(grip_trackpad_, trackpad_images_[1]);
   } else {
-    setEntityImage(grip_trackpad_, trackpad_images_[0]);
+    SetEntityImage(grip_trackpad_, trackpad_images_[0]);
   }
   current_trackpad_rotate_ = activate;
 }
@@ -154,22 +154,22 @@ void ControllerOverlay::SetTriggerMode(TriggerMode m) {
   if (m == current_trigger_mode_) return;
   switch (m) {
     case NORMAL:
-      setEntityImage(grip_trigger_, trigger_images_[0]);
+      SetEntityImage(grip_trigger_, trigger_images_[0]);
       break;
     case GRAB:
-      setEntityImage(grip_trigger_, trigger_images_[1]);
+      SetEntityImage(grip_trigger_, trigger_images_[1]);
       break;
     case GRABBED:
-      setEntityImage(grip_trigger_, trigger_images_[2]);
+      SetEntityImage(grip_trigger_, trigger_images_[2]);
       break;
     case DESELECT:
-      setEntityImage(grip_trigger_, trigger_images_[3]);
+      SetEntityImage(grip_trigger_, trigger_images_[3]);
       break;
   };
   current_trigger_mode_ = m;
 }
 
-void phx::ControllerOverlay::setEntityImage(
+void phx::ControllerOverlay::SetEntityImage(
     phx::Entity* e, phx::ResourcePointer<phx::Image> i) {
   e->GetFirstComponent<phx::MaterialHandle>()->GetMaterial()->SetAmbientImage(
       i);
diff --git a/demos/optical_bench/src/controller_overlay.hpp b/demos/optical_bench/src/controller_overlay.hpp
index cf761fa8..9a09d3c2 100644
--- a/demos/optical_bench/src/controller_overlay.hpp
+++ b/demos/optical_bench/src/controller_overlay.hpp
@@ -70,7 +70,7 @@ class ControllerOverlay : public Component {
   std::vector<phx::ResourcePointer<phx::Image>> trigger_images_;
   std::vector<phx::ResourcePointer<phx::Image>> trackpad_images_;
 
-  void setEntityImage(phx::Entity* e, phx::ResourcePointer<phx::Image> i);
+  void SetEntityImage(phx::Entity* e, phx::ResourcePointer<phx::Image> i);
 };
 
 }  // namespace phx
diff --git a/demos/optical_bench/src/file_reader_zmx.cpp b/demos/optical_bench/src/file_reader_zmx.cpp
index d56fdb3b..97a5681b 100644
--- a/demos/optical_bench/src/file_reader_zmx.cpp
+++ b/demos/optical_bench/src/file_reader_zmx.cpp
@@ -148,7 +148,7 @@ ZMXLoader::ZMXLoader(ObjectManager* manager, phx::RayPass* raypass,
 
   phx::info(("    Moved Laser to " + std::to_string(pos) + "Z.").c_str());
 
-  raypass->moveLaserObj(glm::vec3(manager->GetCenterAxisPos().x,
+  raypass->MoveLaserObject(glm::vec3(manager->GetCenterAxisPos().x,
                                   manager->GetCenterAxisPos().y, pos));
 
   phx::info("Finished parsing");
diff --git a/demos/optical_bench/src/file_reader_zmx.hpp b/demos/optical_bench/src/file_reader_zmx.hpp
index 25d20b8c..9145b2bc 100644
--- a/demos/optical_bench/src/file_reader_zmx.hpp
+++ b/demos/optical_bench/src/file_reader_zmx.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_FILE_READER_ZMX_HPP_
+#define OPTICAL_BENCH_FILE_READER_ZMX_HPP_
 
 #include "object_manager.hpp"
 #include "ray_pass.hpp"
@@ -10,3 +11,5 @@ class ZMXLoader {
 
  private:
 };
+
+#endif  // OPTICAL_BENCH_FILE_READER_ZMX_HPP_
diff --git a/demos/optical_bench/src/hmd_navigation_behavior.cpp b/demos/optical_bench/src/hmd_navigation_behavior.cpp
index 530dee2b..81d7e44c 100644
--- a/demos/optical_bench/src/hmd_navigation_behavior.cpp
+++ b/demos/optical_bench/src/hmd_navigation_behavior.cpp
@@ -93,7 +93,7 @@ HMDNavigationBehavior::HMDNavigationBehavior(
   right_controller_->RegisterButtonSignal(
       [this](phx::VRController::ButtonId id,
              phx::VRController::ButtonEvent event) {
-        buttonChange(id, event);
+        ButtonChange(id, event);
       });
 
   right_controller_transform_ =
@@ -126,8 +126,8 @@ HMDNavigationBehavior::HMDNavigationBehavior(
   auto selector = empty_holder_->AddComponent<phx::Selector>();
   selector->SetMove(nullptr);
 
-  setLastSelected(nullptr);
-  updateHelpers();
+  SetLastSelected(nullptr);
+  UpdateHelpers();
 }
 
 HMDNavigationBehavior::~HMDNavigationBehavior() {
@@ -136,7 +136,7 @@ HMDNavigationBehavior::~HMDNavigationBehavior() {
 }
 
 void HMDNavigationBehavior::OnUpdate() {
-  updateInsersectionData();
+  UpdateInsersectionData();
   select_->Move(right_controller_transform_);
 
   static bool trigger_pressed = false;
@@ -148,9 +148,9 @@ void HMDNavigationBehavior::OnUpdate() {
       select_->Grab(right_controller_transform_);
       if (!rotation_helper_->SelectablePartOf(select_->GetGrabbed()) &&
           !translation_helper_->SelectablePartOf(select_->GetGrabbed())) {
-        setLastSelected(select_->GetGrabbed());
-        grip_mode = 0;  // disable helpers
-        updateHelpers();
+        SetLastSelected(select_->GetGrabbed());
+        grip_mode_ = 0;  // disable helpers
+        UpdateHelpers();
       }
       trigger_pressed = true;
     }
@@ -164,7 +164,7 @@ void HMDNavigationBehavior::OnUpdate() {
   if (last_selected_ != nullptr &&
       last_selected_->GetFirstComponent<phx::TurnHandler>() != nullptr) {
     controller_overlay_->SetTrackpadRotate(true);
-    float delta = getTouchpadRotationDelta();
+    float delta = GetTouchpadRotationDelta();
     last_selected_->GetFirstComponent<phx::TurnHandler>()->Turn(delta);
     angle += delta;
   } else {
@@ -184,14 +184,14 @@ void HMDNavigationBehavior::OnUpdate() {
 
   // Change Grip Images
   if (!trigger_pressed) {
-    if (manipulationHelperAttachable(select_->GetHovered())) {
+    if (ManipulationHelperAttachable(select_->GetHovered())) {
       controller_overlay_->SetGripMode(phx::ControllerOverlay::SELECT);
     } else if (last_selected_ == nullptr) {
       controller_overlay_->SetGripMode(phx::ControllerOverlay::RESET);
     } else if (last_selected_ != nullptr &&
-               manipulationHelperAttachable(last_selected_)) {
+               ManipulationHelperAttachable(last_selected_)) {
       controller_overlay_->SetGripMode(
-          static_cast<phx::ControllerOverlay::GripMode>(grip_mode % 3));
+          static_cast<phx::ControllerOverlay::GripMode>(grip_mode_ % 3));
     } else {
       controller_overlay_->SetGripMode(phx::ControllerOverlay::RESET);
     }
@@ -208,7 +208,7 @@ void HMDNavigationBehavior::OnUpdate() {
                  nullptr) {
     controller_overlay_->SetTriggerMode(phx::ControllerOverlay::GRAB);
   } else if (!trigger_pressed && last_selected_ != nullptr &&
-             manipulationHelperAttachable(last_selected_)) {
+             ManipulationHelperAttachable(last_selected_)) {
     controller_overlay_->SetTriggerMode(phx::ControllerOverlay::DESELECT);
   } else {
     controller_overlay_->SetTriggerMode(phx::ControllerOverlay::NORMAL);
@@ -216,28 +216,28 @@ void HMDNavigationBehavior::OnUpdate() {
 }
 
 void HMDNavigationBehavior::DeletedObject() {
-  setLastSelected(nullptr);
-  updateHelpers();
+  SetLastSelected(nullptr);
+  UpdateHelpers();
 }
 
-void HMDNavigationBehavior::updateHelpers() {
+void HMDNavigationBehavior::UpdateHelpers() {
   if (last_selected_ == empty_holder_) last_selected_ = nullptr;
   if (last_selected_ != nullptr &&
       last_selected_->GetFirstComponent<phx::Selector>()
-          ->manipulation_helper_attachable_) {
-    if (grip_mode % 3 == 0) {
+          ->IsManipulationHelperAttachable()) {
+    if (grip_mode_ % 3 == 0) {
       translation_helper_->SetParent(
           empty_holder_->GetFirstComponent<phx::Transform>());
       rotation_helper_->SetParent(
           empty_holder_->GetFirstComponent<phx::Transform>());
     }
-    if (grip_mode % 3 == 1) {
+    if (grip_mode_ % 3 == 1) {
       translation_helper_->SetParent(
           empty_holder_->GetFirstComponent<phx::Transform>());
       rotation_helper_->SetParent(
           last_selected_->GetFirstComponent<phx::Transform>());
     }
-    if (grip_mode % 3 == 2) {
+    if (grip_mode_ % 3 == 2) {
       translation_helper_->SetParent(
           last_selected_->GetFirstComponent<phx::Transform>());
       rotation_helper_->SetParent(
@@ -251,7 +251,7 @@ void HMDNavigationBehavior::updateHelpers() {
   }
 }
 
-void HMDNavigationBehavior::setLastSelected(phx::Entity* e) {
+void HMDNavigationBehavior::SetLastSelected(phx::Entity* e) {
   if (last_selected_ != nullptr &&
       last_selected_->GetFirstComponent<phx::SelectionMarkHandler>() !=
           nullptr) {
@@ -268,7 +268,7 @@ void HMDNavigationBehavior::setLastSelected(phx::Entity* e) {
   }
 }
 
-float HMDNavigationBehavior::getTouchpadRotationDelta() {
+float HMDNavigationBehavior::GetTouchpadRotationDelta() {
   // % 32 is a weird hack to get the right data stream :/
   static glm::vec2 last_data = glm::vec2(0);
   static float last_angle = 0;
@@ -295,7 +295,7 @@ float HMDNavigationBehavior::getTouchpadRotationDelta() {
   return delta;
 }
 
-void HMDNavigationBehavior::updateInsersectionData() {
+void HMDNavigationBehavior::UpdateInsersectionData() {
   auto transform = scene_
                        ->GetEntitiesWithComponents<
                            phx::RuntimeComponent<phx::RIGHT_CONTROLLER>>()[0]
@@ -305,30 +305,31 @@ void HMDNavigationBehavior::updateInsersectionData() {
   glm::vec3 ori = ori_ / ori_.w;
   glm::vec3 forward = normalize(glm::vec3(transform * glm::vec4(0, 0, -1, 0)));
 
-  select_->updateInsersectThreadData(
+  select_->UpdateInsersectThreadData(
       ori, forward, transform,
       scene_->GetEntitiesWithComponents<phx::Selector>());
 }
 
-void HMDNavigationBehavior::buttonChange(
+void HMDNavigationBehavior::ButtonChange(
     phx::VRController::ButtonId& id, phx::VRController::ButtonEvent& event) {
   if (id == phx::VRController::ButtonId::k_EButton_Grip &&
       event == phx::VRController::ButtonEvent::BUTTON_PRESSED) {
     if (select_->GetHovered() == nullptr &&
-        manipulationHelperAttachable(last_selected_)) {
-      grip_mode = grip_mode + 1 % 3;
+        ManipulationHelperAttachable(last_selected_)) {
+      grip_mode_ = grip_mode_ + 1 % 3;
 
-      updateHelpers();
+      UpdateHelpers();
     } else {
-      setLastSelected(select_->GetHovered());
+      SetLastSelected(select_->GetHovered());
 
-      if (grip_mode == 0) grip_mode = 1;  // Hover without feedback sucks
-      updateHelpers();
+      if (grip_mode_ == 0) grip_mode_ = 1;  // Hover without feedback sucks
+      UpdateHelpers();
     }
   }
 }
 
-bool HMDNavigationBehavior::manipulationHelperAttachable(phx::Entity* e) {
+bool HMDNavigationBehavior::ManipulationHelperAttachable(phx::Entity* e) {
   return e != nullptr && e->GetFirstComponent<phx::Selector>() != nullptr &&
-         e->GetFirstComponent<phx::Selector>()->manipulation_helper_attachable_;
+         e->GetFirstComponent<phx::Selector>()
+             ->IsManipulationHelperAttachable();
 }
diff --git a/demos/optical_bench/src/hmd_navigation_behavior.hpp b/demos/optical_bench/src/hmd_navigation_behavior.hpp
index 094b3e93..3b56b01e 100644
--- a/demos/optical_bench/src/hmd_navigation_behavior.hpp
+++ b/demos/optical_bench/src/hmd_navigation_behavior.hpp
@@ -70,19 +70,19 @@ class HMDNavigationBehavior : public phx::Behavior {
   phx::Transform* right_controller_transform_;
   phx::ControllerOverlay* controller_overlay_;
 
-  unsigned int grip_mode = 0;
-  void updateHelpers();
+  unsigned int grip_mode_ = 0;
+  void UpdateHelpers();
 
   MenuManager* menu_manager_;
 
   phx::Entity* last_selected_ = nullptr;
-  void setLastSelected(phx::Entity* e);
+  void SetLastSelected(phx::Entity* e);
 
-  float getTouchpadRotationDelta();
-  void updateInsersectionData();
-  void buttonChange(phx::VRController::ButtonId& id,
+  float GetTouchpadRotationDelta();
+  void UpdateInsersectionData();
+  void ButtonChange(phx::VRController::ButtonId& id,
                     phx::VRController::ButtonEvent& event);
-  bool manipulationHelperAttachable(phx::Entity* e);
+  bool ManipulationHelperAttachable(phx::Entity* e);
 };
 
 #endif  // OPTICAL_BENCH_HMD_NAVIGATION_BEHAVIOR_HPP_
diff --git a/demos/optical_bench/src/laser_menu.cpp b/demos/optical_bench/src/laser_menu.cpp
index d3e67fd0..4700991a 100644
--- a/demos/optical_bench/src/laser_menu.cpp
+++ b/demos/optical_bench/src/laser_menu.cpp
@@ -38,7 +38,7 @@ LaserMenu::LaserMenu(phx::Scene* scene, phx::Engine* engine) {
                       ->GetEntity()
                       ->GetFirstComponent<phx::MaterialHandle>();
     if (handle->GetMaterial()->GetName().compare("Screen") == 0) {
-      handle->SetMaterial(MenuHelper::cloneMaterial(handle->GetMaterial(),
+      handle->SetMaterial(MenuHelper::CloneMaterial(handle->GetMaterial(),
                                                     "LaserMenuScreenMaterial"));
       handle->GetMaterial()->SetAmbientImage(image);
       break;
@@ -46,7 +46,7 @@ LaserMenu::LaserMenu(phx::Scene* scene, phx::Engine* engine) {
   }
 
   // Laser Pattern
-  MenuHelper::createButtonPairVertical(up_p_, down_p_, text_p_, -0.022f, -0.05f,
+  MenuHelper::CreateButtonPairVertical(up_p_, down_p_, text_p_, -0.022f, -0.05f,
                                        scene, engine, entity_);
   up_p_->SetOnPress([rayPass, this](phx::Transform*, glm::mat4) {
     rayPass->NextLaserPattern();
@@ -60,7 +60,7 @@ LaserMenu::LaserMenu(phx::Scene* scene, phx::Engine* engine) {
   text_p_->SetTextHeight(0.005f);  // bit smaller
 
   // Target Color
-  MenuHelper::createButtonPairVertical(up_tc_, down_tc_, text_tc_, 0.11f,
+  MenuHelper::CreateButtonPairVertical(up_tc_, down_tc_, text_tc_, 0.11f,
                                        -0.05f, scene, engine, entity_);
   up_tc_->SetOnPress([rayPass, this](phx::Transform*, glm::mat4) {
     rayPass->ToggleTargetColorMode();
@@ -75,7 +75,7 @@ LaserMenu::LaserMenu(phx::Scene* scene, phx::Engine* engine) {
   // TIR
   switch_tir_ = new MenuSwitch(engine, scene, rayPass->GetRayTIR());
   switch_tir_->SetOnSwitch([this, rayPass](bool a) {
-    rayPass->setRayTIR(a);
+    rayPass->SetRayTIR(a);
     text_tir_->SetText((a ? "on" : "off"));
   });
   switch_tir_->GetTransform()->SetParent(
@@ -93,9 +93,9 @@ LaserMenu::LaserMenu(phx::Scene* scene, phx::Engine* engine) {
   text_tir_->SetGradient(glm::vec4(0), glm::vec4(0));
 
   // target write
-  switch_tw_ = new MenuSwitch(engine, scene, rayPass->getTargetBufferWrite());
+  switch_tw_ = new MenuSwitch(engine, scene, rayPass->GetTargetBufferWrite());
   switch_tw_->SetOnSwitch([this, rayPass](bool a) {
-    rayPass->setTargetBufferWrite(a);
+    rayPass->SetTargetBufferWrite(a);
     text_tw_->SetText((a ? "on" : "off"));
   });
   switch_tw_->GetTransform()->SetParent(
@@ -109,7 +109,7 @@ LaserMenu::LaserMenu(phx::Scene* scene, phx::Engine* engine) {
       .SetLocalRotationEuler(glm::vec3(180, -90, 0))
       .SetParent(entity_->GetFirstComponent<phx::Transform>());
   text_tw_ = text_entity2->AddComponent<phx::Text>("", 0.006f);
-  text_tw_->SetText(((rayPass->getTargetBufferWrite()) ? "on" : "off"));
+  text_tw_->SetText(((rayPass->GetTargetBufferWrite()) ? "on" : "off"));
   text_tw_->SetGradient(glm::vec4(0), glm::vec4(0));
 
   // clear laser target
@@ -124,11 +124,11 @@ LaserMenu::LaserMenu(phx::Scene* scene, phx::Engine* engine) {
       "models/opticalBench/menu/Clear.png"));
   clear_target_->SetHoldable(false);
   clear_target_->SetOnPress([this, rayPass](phx::Transform*, glm::mat4) {
-    rayPass->clearTargetBuffers();
+    rayPass->ClearTargetBuffers();
   });
 
   // width
-  MenuHelper::createSliderTextPair(
+  MenuHelper::CreateSliderTextPair(
       scene, engine, slider_width_, text_width_, 0.05f, 0.073f, 0.0001f,
       0.0001f, 0.04f, entity_, [this, rayPass](float val) {
         rayPass->SetLaserRayWidth(val);
@@ -141,7 +141,7 @@ LaserMenu::LaserMenu(phx::Scene* scene, phx::Engine* engine) {
   auto obj_m = engine->GetSystem<ObjectManager>();
 
   // Wavelength
-  MenuHelper::createSliderTextPair(
+  MenuHelper::CreateSliderTextPair(
       scene, engine, slider_wlength_, text_wlength_, 0.05f, 0.038f, 5.0f,
       450.0f, 1075.0f, entity_, [this, rayPass, obj_m](float val) {
         rayPass->SetLaserWaveLength(val);
diff --git a/demos/optical_bench/src/laser_menu.hpp b/demos/optical_bench/src/laser_menu.hpp
index f7e5732d..b2e653f1 100644
--- a/demos/optical_bench/src/laser_menu.hpp
+++ b/demos/optical_bench/src/laser_menu.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_LASER_MENU_HPP_
+#define OPTICAL_BENCH_LASER_MENU_HPP_
 
 #include "phx/suppress_warnings.hpp"
 
@@ -64,3 +65,5 @@ class LaserMenu {
   MenuSwitch* switch_tw_;
   phx::Text* text_tw_;
 };
+
+#endif  // OPTICAL_BENCH_LASER_MENU_HPP_
diff --git a/demos/optical_bench/src/lens.cpp b/demos/optical_bench/src/lens.cpp
index 589485e7..20439bf3 100644
--- a/demos/optical_bench/src/lens.cpp
+++ b/demos/optical_bench/src/lens.cpp
@@ -25,35 +25,35 @@ Lens::Lens(phx::Engine* engine, phx::Scene* scene, OptixContextManager* manager,
   manager_ = manager;
 
   CreateGlassMaterialInstance();
-  geometry = manager->getContext()->createGeometryInstance(
-      manager->GetLensGeometry(), &glass_material, &glass_material + 1);
+  geometry_ = manager->GetContext()->createGeometryInstance(
+      manager->GetLensGeometry(), &glass_material_, &glass_material_ + 1);
 
-  geometry["center"]->setFloat(0, 0, 0);
-  geometry["radius"]->setFloat(radius);
-  geometry["radius2"]->setFloat(radius2);
-  geometry["orientation"]->setFloat(optix::make_float3(0.f, 0.f, -1.f));
-  geometry["lensRadius"]->setFloat(lensradius);
+  geometry_["center"]->setFloat(0, 0, 0);
+  geometry_["radius"]->setFloat(radius);
+  geometry_["radius2"]->setFloat(radius2);
+  geometry_["orientation"]->setFloat(optix::make_float3(0.f, 0.f, -1.f));
+  geometry_["lensRadius"]->setFloat(lensradius);
 
-  geometry["side1Type"]->setInt(type1);
-  geometry["side2Type"]->setInt(type2);
+  geometry_["side1Type"]->setInt(type1);
+  geometry_["side2Type"]->setInt(type2);
   type_1_ = type1;
   type_2_ = type2;
 
-  float cylinderLength = getCylinderLength(thickness);
-  geometry["halfCylinderLength"]->setFloat(cylinderLength / 2);
+  float cylinderLength = GetCylinderLength(thickness);
+  geometry_["halfCylinderLength"]->setFloat(cylinderLength / 2);
 
-  transform = manager->getContext()->createTransform();
-  transform->setMatrix(false, &glm::mat4()[0][0], &glm::mat4()[0][0]);
+  transform_ = manager->GetContext()->createTransform();
+  transform_->setMatrix(false, &glm::mat4()[0][0], &glm::mat4()[0][0]);
   // Add the lens to the scene
 
-  geometry_group_ = manager->getContext()->createGeometryGroup();
-  geometry_group_->addChild(geometry);
-  acceleration_structure_ = manager->getContext()->createAcceleration("Trbvh");
+  geometry_group_ = manager->GetContext()->createGeometryGroup();
+  geometry_group_->addChild(geometry_);
+  acceleration_structure_ = manager->GetContext()->createAcceleration("Trbvh");
   geometry_group_->setAcceleration(acceleration_structure_);
 
-  transform->setChild<optix::GeometryGroup>(geometry_group_);
-  manager->getTopObject()->addChild(transform);
-  manager->getTopObject()->getAcceleration()->markDirty();
+  transform_->setChild<optix::GeometryGroup>(geometry_group_);
+  manager->GetTopObject()->addChild(transform_);
+  manager->GetTopObject()->getAcceleration()->markDirty();
 
   // Attach handles
   entity_ = scene->CreateEntity();
@@ -81,14 +81,14 @@ Lens::Lens(phx::Engine* engine, phx::Scene* scene, OptixContextManager* manager,
     entity_->GetFirstComponent<phx::Transform>()->SetGlobalTranslation(pos);
     glm::mat4 trans =
         entity_->GetFirstComponent<phx::Transform>()->GetGlobalMatrix();
-    transform->setMatrix(true, &(trans[0][0]), &(inverse(trans)[0][0]));
+    transform_->setMatrix(true, &(trans[0][0]), &(inverse(trans)[0][0]));
 
     support_rod_->Moved();
   });
   selector_->SetExternalUpdate([this]() {
     glm::mat4 trans =
         entity_->GetFirstComponent<phx::Transform>()->GetGlobalMatrix();
-    transform->setMatrix(true, &(trans[0][0]), &(inverse(trans)[0][0]));
+    transform_->setMatrix(true, &(trans[0][0]), &(inverse(trans)[0][0]));
 
     support_rod_->Moved();
   });
@@ -97,22 +97,22 @@ Lens::Lens(phx::Engine* engine, phx::Scene* scene, OptixContextManager* manager,
   selector_->SetGrab([this](phx::Transform*, glm::mat4) { grabbed_ = true; });
   selector_->SetRelease([this]() { grabbed_ = false; });
 
-  recalcBB();
+  RecalculateBoundingBox();
 }
 
 Lens::~Lens() {
-  manager_->getTopObject()->removeChild(transform);
-  glass_material->destroy();
-  geometry->destroy();
+  manager_->GetTopObject()->removeChild(transform_);
+  glass_material_->destroy();
+  geometry_->destroy();
   acceleration_structure_->destroy();
   geometry_group_->destroy();
-  transform->destroy();
+  transform_->destroy();
   delete support_rod_;
 }
 
 void Lens::NextLensSideType1() {
-  auto s1 = geometry["side1Type"]->getInt();
-  auto s2 = geometry["side2Type"]->getInt();
+  auto s1 = geometry_["side1Type"]->getInt();
+  auto s2 = geometry_["side2Type"]->getInt();
 
   s1 = (((s1 + 1) + 1) % 3) - 1;
 
@@ -121,8 +121,8 @@ void Lens::NextLensSideType1() {
 }
 
 void Lens::PreviousLensSideType1() {
-  auto s1 = geometry["side1Type"]->getInt();
-  auto s2 = geometry["side2Type"]->getInt();
+  auto s1 = geometry_["side1Type"]->getInt();
+  auto s2 = geometry_["side2Type"]->getInt();
 
   s1 = (((s1 - 1 + 3) + 1) % 3) - 1;
 
@@ -131,8 +131,8 @@ void Lens::PreviousLensSideType1() {
 }
 
 void Lens::NextLensSideType2() {
-  auto s1 = geometry["side1Type"]->getInt();
-  auto s2 = geometry["side2Type"]->getInt();
+  auto s1 = geometry_["side1Type"]->getInt();
+  auto s2 = geometry_["side2Type"]->getInt();
 
   s2 = (((s2 + 1) + 1) % 3) - 1;
 
@@ -141,8 +141,8 @@ void Lens::NextLensSideType2() {
 }
 
 void Lens::PreviousLensSideType2() {
-  auto s1 = geometry["side1Type"]->getInt();
-  auto s2 = geometry["side2Type"]->getInt();
+  auto s1 = geometry_["side1Type"]->getInt();
+  auto s2 = geometry_["side2Type"]->getInt();
 
   s2 = (((s2 - 1 + 3) + 1) % 3) - 1;
 
@@ -161,13 +161,13 @@ void Lens::PreviousGlassType() {
 }
 
 std::string Lens::GetLensTypeName1() {
-  return getTypeString(
-      static_cast<LensSideType>(geometry["side1Type"]->getInt()));
+  return GetTypeString(
+      static_cast<LensSideType>(geometry_["side1Type"]->getInt()));
 }
 
 std::string Lens::GetLensTypeName2() {
-  return getTypeString(
-      static_cast<LensSideType>(geometry["side2Type"]->getInt()));
+  return GetTypeString(
+      static_cast<LensSideType>(geometry_["side2Type"]->getInt()));
 }
 
 std::string Lens::GetGlassTypeName() {
@@ -205,7 +205,7 @@ void Lens::ChangedWaveLength(float wavelength_nm) {
                             (glass_definitions[glass_type_][0].z * wl2) /
                                 (wl2 - glass_definitions[glass_type_][1].z));
 
-  glass_material["refraction_index"]->setFloat(index);
+  glass_material_["refraction_index"]->setFloat(index);
   current_wavelength_nm_ = wavelength_nm;
 }
 
@@ -262,10 +262,10 @@ glm::vec3 Lens::GetFrontCenter() {
              glm::vec3(0.f, 0.f, -1.f) * GetThickness() / 2.0f;
 }
 
-float Lens::getCylinderLength(float thickness) {
-  float lr = geometry["lensRadius"]->getFloat();
-  float r1 = geometry["radius"]->getFloat();
-  float r2 = geometry["radius2"]->getFloat();
+float Lens::GetCylinderLength(float thickness) {
+  float lr = geometry_["lensRadius"]->getFloat();
+  float r1 = geometry_["radius"]->getFloat();
+  float r2 = geometry_["radius2"]->getFloat();
 
   // thickness of the halfspheres
   float halfThickness1 = r1 - sqrtf(-lr * lr + r1 * r1);
@@ -279,10 +279,10 @@ float Lens::getCylinderLength(float thickness) {
   return thickness - halfThickness1 - halfThickness2;
 }
 
-float Lens::getThickness(float cylinder_length) {
-  float lr = geometry["lensRadius"]->getFloat();
-  float r1 = geometry["radius"]->getFloat();
-  float r2 = geometry["radius2"]->getFloat();
+float Lens::GetThickness(float cylinder_length) {
+  float lr = geometry_["lensRadius"]->getFloat();
+  float r1 = geometry_["radius"]->getFloat();
+  float r2 = geometry_["radius2"]->getFloat();
 
   // thickness of the halfspheres
   float halfThickness1 = r1 - sqrtf(-lr * lr + r1 * r1);
@@ -298,23 +298,23 @@ float Lens::getThickness(float cylinder_length) {
 
 void Lens::SetLensSideTypes(LensSideType type1, LensSideType type2) {
   float thickness =
-      getThickness(geometry["halfCylinderLength"]->getFloat() * 2);
+      GetThickness(geometry_["halfCylinderLength"]->getFloat() * 2);
 
-  geometry["side1Type"]->setInt(type1);
-  geometry["side2Type"]->setInt(type2);
+  geometry_["side1Type"]->setInt(type1);
+  geometry_["side2Type"]->setInt(type2);
 
   type_1_ = type1;
   type_2_ = type2;
 
-  geometry["halfCylinderLength"]->setFloat(getCylinderLength(thickness) / 2);
+  geometry_["halfCylinderLength"]->setFloat(GetCylinderLength(thickness) / 2);
 }
 
-void Lens::recalcBB() {
-  auto o = geometry["orientation"]->getFloat3();
-  float t = geometry["halfCylinderLength"]->getFloat() * 2;
-  float lr = geometry["lensRadius"]->getFloat();
+void Lens::RecalculateBoundingBox() {
+  auto o = geometry_["orientation"]->getFloat3();
+  float t = geometry_["halfCylinderLength"]->getFloat() * 2;
+  float lr = geometry_["lensRadius"]->getFloat();
 
-  t = getThickness(t);
+  t = GetThickness(t);
 
   auto bb =
       ComputeAABBFromCylinder(glm::vec3(o.x, o.y, o.z), t / 2.0f, t / 2.0f, lr);
@@ -322,12 +322,12 @@ void Lens::recalcBB() {
   selector_->ExternalUpdate();
 }
 
-void Lens::markDirty() {
+void Lens::MarkDirty() {
   acceleration_structure_->markDirty();
-  manager_->getTopObject()->getAcceleration()->markDirty();
+  manager_->GetTopObject()->getAcceleration()->markDirty();
 }
 
-std::string Lens::getTypeString(LensSideType t) {
+std::string Lens::GetTypeString(LensSideType t) {
   switch (t) {
     case CONCAVE:
       return "Concave";
@@ -340,27 +340,27 @@ std::string Lens::getTypeString(LensSideType t) {
 }
 
 void Lens::CreateGlassMaterialInstance() {
-  optix::Program closeHitP = manager_->getContext()->createProgramFromPTXString(
-      OptixContextManager::getPtxString("glass_perspective_camera.cu"),
+  optix::Program closeHitP = manager_->GetContext()->createProgramFromPTXString(
+      OptixContextManager::GetPtxString("glass_perspective_camera.cu"),
       "closest_hit_radiance");
-  optix::Program closeHitI = manager_->getContext()->createProgramFromPTXString(
-      OptixContextManager::getPtxString("glass_iterative_camera.cu"),
+  optix::Program closeHitI = manager_->GetContext()->createProgramFromPTXString(
+      OptixContextManager::GetPtxString("glass_iterative_camera.cu"),
       "closest_hit_radiance");
 
-  glass_material = manager_->getContext()->createMaterial();
-  glass_material->setClosestHitProgram(0, closeHitP);
-  glass_material->setClosestHitProgram(1, closeHitI);
-
-  glass_material["importance_cutoff"]->setFloat(1e-2f);
-  glass_material["cutoff_color"]->setFloat(0.034f, 0.055f, 0.085f);
-  glass_material["fresnel_exponent"]->setFloat(3.0f);
-  glass_material["fresnel_minimum"]->setFloat(0.1f);
-  glass_material["fresnel_maximum"]->setFloat(1.0f);
-  glass_material["refraction_index"]->setFloat(1.4f);
-  glass_material["refraction_color"]->setFloat(1.0f, 1.0f, 1.0f);
-  glass_material["reflection_color"]->setFloat(1.0f, 1.0f, 1.0f);
-  glass_material["refraction_maxdepth"]->setInt(10);
-  glass_material["reflection_maxdepth"]->setInt(5);
-  glass_material["extinction_constant"]->setFloat(log(0.83f), log(0.83f),
+  glass_material_ = manager_->GetContext()->createMaterial();
+  glass_material_->setClosestHitProgram(0, closeHitP);
+  glass_material_->setClosestHitProgram(1, closeHitI);
+
+  glass_material_["importance_cutoff"]->setFloat(1e-2f);
+  glass_material_["cutoff_color"]->setFloat(0.034f, 0.055f, 0.085f);
+  glass_material_["fresnel_exponent"]->setFloat(3.0f);
+  glass_material_["fresnel_minimum"]->setFloat(0.1f);
+  glass_material_["fresnel_maximum"]->setFloat(1.0f);
+  glass_material_["refraction_index"]->setFloat(1.4f);
+  glass_material_["refraction_color"]->setFloat(1.0f, 1.0f, 1.0f);
+  glass_material_["reflection_color"]->setFloat(1.0f, 1.0f, 1.0f);
+  glass_material_["refraction_maxdepth"]->setInt(10);
+  glass_material_["reflection_maxdepth"]->setInt(5);
+  glass_material_["extinction_constant"]->setFloat(log(0.83f), log(0.83f),
                                                   log(0.83f));
 }
diff --git a/demos/optical_bench/src/lens.hpp b/demos/optical_bench/src/lens.hpp
index 46bb523d..7bef1c8c 100644
--- a/demos/optical_bench/src/lens.hpp
+++ b/demos/optical_bench/src/lens.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_LENS_HPP_
+#define OPTICAL_BENCH_LENS_HPP_
 
 #include "object_support_rod.hpp"
 #include "optix_context_manager.hpp"
@@ -33,38 +34,34 @@ class Lens {
        float lensradius, float thickness, float radius, float radius2 = 0.0f);
   ~Lens();
 
-  optix::Transform transform;
-  optix::GeometryInstance geometry;
-  optix::Material glass_material;
-
   void SetThickness(float f) {
-    geometry["halfCylinderLength"]->setFloat(getCylinderLength(f) / 2);
-    markDirty();
-    recalcBB();
+    geometry_["halfCylinderLength"]->setFloat(GetCylinderLength(f) / 2);
+    MarkDirty();
+    RecalculateBoundingBox();
   };
   float GetThickness() {
-    return getThickness(geometry["halfCylinderLength"]->getFloat() * 2);
+    return GetThickness(geometry_["halfCylinderLength"]->getFloat() * 2);
   };
 
   void SetRadius(float f) {
-    geometry["radius"]->setFloat(f);
-    markDirty();
-    recalcBB();
+    geometry_["radius"]->setFloat(f);
+    MarkDirty();
+    RecalculateBoundingBox();
   }
-  float GetRadius() { return geometry["radius"]->getFloat(); };
+  float GetRadius() { return geometry_["radius"]->getFloat(); };
   void SetRadius2(float f) {
-    geometry["radius2"]->setFloat(f);
-    markDirty();
-    recalcBB();
+    geometry_["radius2"]->setFloat(f);
+    MarkDirty();
+    RecalculateBoundingBox();
   }
-  float GetRadius2() { return geometry["radius2"]->getFloat(); };
+  float GetRadius2() { return geometry_["radius2"]->getFloat(); };
 
   void SetLensRadius(float f) {
-    geometry["lensRadius"]->setFloat(f);
-    markDirty();
-    recalcBB();
+    geometry_["lensRadius"]->setFloat(f);
+    MarkDirty();
+    RecalculateBoundingBox();
   }
-  float GetLensRadius() { return geometry["lensRadius"]->getFloat(); };
+  float GetLensRadius() { return geometry_["lensRadius"]->getFloat(); };
 
   phx::Entity* GetEntity() { return entity_; }
   phx::Transform* GetTransform() {
@@ -73,8 +70,8 @@ class Lens {
 
   glm::vec3 GetFrontCenter();
 
-  float getCylinderLength(float thickness);
-  float getThickness(float cylinder_length);
+  float GetCylinderLength(float thickness);
+  float GetThickness(float cylinder_length);
 
   void SetLensSideTypes(LensSideType type1, LensSideType type2);
 
@@ -93,7 +90,7 @@ class Lens {
   std::string GetLensTypeName2();
   std::string GetGlassTypeName();
 
-  bool isGrabbed() { return grabbed_; };
+  bool IsGrabbed() { return grabbed_; };
 
   void Translate(glm::vec3 pos);
 
@@ -107,19 +104,23 @@ class Lens {
                                                     float halfLength2,
                                                     float radius);
 
+  optix::Transform transform_;
+  optix::GeometryInstance geometry_;
+  optix::Material glass_material_;
+
   phx::Entity* entity_;
   LensSideType type_1_;
   LensSideType type_2_;
   GlassType glass_type_ = GlassType::BK7;
   float current_wavelength_nm_ = 0.0f;
-  void recalcBB();
-  void markDirty();
+  void RecalculateBoundingBox();
+  void MarkDirty();
   SupportRod* support_rod_;
   OptixContextManager* manager_;
   phx::Selector* selector_;
   bool grabbed_ = false;
 
-  std::string getTypeString(LensSideType t);
+  std::string GetTypeString(LensSideType t);
 
   optix::Acceleration acceleration_structure_;
   optix::GeometryGroup geometry_group_;
@@ -150,3 +151,4 @@ class Lens {
       } }};
   // clang-format on
 };
+#endif  // OPTICAL_BENCH_LENS_HPP_
diff --git a/demos/optical_bench/src/lens_menu.cpp b/demos/optical_bench/src/lens_menu.cpp
index b2496e4e..f2449ee4 100644
--- a/demos/optical_bench/src/lens_menu.cpp
+++ b/demos/optical_bench/src/lens_menu.cpp
@@ -29,14 +29,14 @@ LensMenu::LensMenu(phx::Scene* scene, phx::Engine* engine, Lens* lens) {
                       ->GetEntity()
                       ->GetFirstComponent<phx::MaterialHandle>();
     if (handle->GetMaterial()->GetName().compare("Screen") == 0) {
-      handle->SetMaterial(MenuHelper::cloneMaterial(handle->GetMaterial(),
+      handle->SetMaterial(MenuHelper::CloneMaterial(handle->GetMaterial(),
                                                     "LensMenuScreenMaterial"));
       handle->GetMaterial()->SetAmbientImage(image);
       break;
     }
   }
 
-  MenuHelper::createSliderTextPair(
+  MenuHelper::CreateSliderTextPair(
       scene, engine, slider_thickness_, text_thickness_, 0.05f, 0.08f, 0.001f,
       0, 1, entity_, [this](float val) {
         if (current_lens_ == nullptr) return;
@@ -47,15 +47,15 @@ LensMenu::LensMenu(phx::Scene* scene, phx::Engine* engine, Lens* lens) {
         text_thickness_->SetText(std::string(te));
       });
 
-  MenuHelper::createSliderTextPair(
+  MenuHelper::CreateSliderTextPair(
       scene, engine, slider_radius1_, text_radius1_, 0.05f, 0.03f, 0.01f, 0.01f,
       2, entity_, [this](float val) {
         if (current_lens_ == nullptr) return;
         current_lens_->SetRadius(val);
 
         // No broken cylinder
-        auto min_max = slider_thickness_->getMinMaxValue();
-        slider_thickness_->SetMinMax(current_lens_->getThickness(0),
+        auto min_max = slider_thickness_->GetMinMaxValue();
+        slider_thickness_->SetMinMax(current_lens_->GetThickness(0),
                                      min_max[1]);
 
         static char te[] = "100.1cm";
@@ -63,15 +63,15 @@ LensMenu::LensMenu(phx::Scene* scene, phx::Engine* engine, Lens* lens) {
         text_radius1_->SetText(std::string(te));
       });
 
-  MenuHelper::createSliderTextPair(
+  MenuHelper::CreateSliderTextPair(
       scene, engine, slider_radius2_, text_radius2_, 0.05f, 0.005f, 0.01f,
       0.01f, 2, entity_, [this](float val) {
         if (current_lens_ == nullptr) return;
         current_lens_->SetRadius2(val);
 
         // No broken cylinder
-        auto min_max = slider_thickness_->getMinMaxValue();
-        slider_thickness_->SetMinMax(current_lens_->getThickness(0),
+        auto min_max = slider_thickness_->GetMinMaxValue();
+        slider_thickness_->SetMinMax(current_lens_->GetThickness(0),
                                      min_max[1]);
 
         static char te[] = "100.1cm";
@@ -79,21 +79,21 @@ LensMenu::LensMenu(phx::Scene* scene, phx::Engine* engine, Lens* lens) {
         text_radius2_->SetText(std::string(te));
       });
 
-  MenuHelper::createSliderTextPair(
+  MenuHelper::CreateSliderTextPair(
       scene, engine, slider_lens_radius_, text_lens_radius_, 0.05f, 0.055f,
       0.001f, 0.01f, 0.5f, entity_, [this](float val) {
         if (current_lens_ == nullptr) return;
         current_lens_->SetLensRadius(val);
 
         // fix lower bound
-        auto min_max = slider_radius1_->getMinMaxValue();
+        auto min_max = slider_radius1_->GetMinMaxValue();
         slider_radius1_->SetMinMax(val + 0.01f, min_max[1]);
-        min_max = slider_radius2_->getMinMaxValue();
+        min_max = slider_radius2_->GetMinMaxValue();
         slider_radius2_->SetMinMax(val + 0.01f, min_max[1]);
 
         // No broken cylinder
-        min_max = slider_thickness_->getMinMaxValue();
-        slider_thickness_->SetMinMax(current_lens_->getThickness(0),
+        min_max = slider_thickness_->GetMinMaxValue();
+        slider_thickness_->SetMinMax(current_lens_->GetThickness(0),
                                      min_max[1]);
 
         static char te[] = "00.11cm";
@@ -101,7 +101,7 @@ LensMenu::LensMenu(phx::Scene* scene, phx::Engine* engine, Lens* lens) {
         text_lens_radius_->SetText(std::string(te));
       });
 
-  MenuHelper::createButtonPairVertical(up_l1_, down_l1_, text_l1_, 0.02f,
+  MenuHelper::CreateButtonPairVertical(up_l1_, down_l1_, text_l1_, 0.02f,
                                        -0.055f, scene, engine, entity_);
   up_l1_->SetOnPress([this](phx::Transform*, glm::mat4) {
     if (current_lens_ == nullptr) return;
@@ -114,7 +114,7 @@ LensMenu::LensMenu(phx::Scene* scene, phx::Engine* engine, Lens* lens) {
     text_l1_->SetText(current_lens_->GetLensTypeName1());
   });
 
-  MenuHelper::createButtonPairVertical(up_l2_, down_l2_, text_l2_, 0.11f,
+  MenuHelper::CreateButtonPairVertical(up_l2_, down_l2_, text_l2_, 0.11f,
                                        -0.055f, scene, engine, entity_);
   up_l2_->SetOnPress([this](phx::Transform*, glm::mat4) {
     if (current_lens_ == nullptr) return;
@@ -127,7 +127,7 @@ LensMenu::LensMenu(phx::Scene* scene, phx::Engine* engine, Lens* lens) {
     text_l2_->SetText(current_lens_->GetLensTypeName2());
   });
 
-  MenuHelper::createButtonPairVertical(up_gl_, down_gl_, text_gl_, -0.045f,
+  MenuHelper::CreateButtonPairVertical(up_gl_, down_gl_, text_gl_, -0.045f,
                                        -0.055f, scene, engine, entity_);
   up_gl_->SetOnPress([this](phx::Transform*, glm::mat4) {
     if (current_lens_ == nullptr) return;
diff --git a/demos/optical_bench/src/lens_menu.hpp b/demos/optical_bench/src/lens_menu.hpp
index 3b09194f..643e84ca 100644
--- a/demos/optical_bench/src/lens_menu.hpp
+++ b/demos/optical_bench/src/lens_menu.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_LENS_MENU_HPP_
+#define OPTICAL_BENCH_LENS_MENU_HPP_
 
 #include "phx/suppress_warnings.hpp"
 
@@ -66,3 +67,4 @@ class LensMenu {
   MenuButton* down_gl_;
   phx::Text* text_gl_;
 };
+#endif  // OPTICAL_BENCH_LENS_MENU_HPP_
diff --git a/demos/optical_bench/src/menu_button.cpp b/demos/optical_bench/src/menu_button.cpp
index 06764917..ddf90bf0 100644
--- a/demos/optical_bench/src/menu_button.cpp
+++ b/demos/optical_bench/src/menu_button.cpp
@@ -53,10 +53,10 @@ MenuButton::MenuButton(phx::Engine* engine, phx::Scene* scene, TYPE type) {
   // of the mesh
   static unsigned int id = 0u;
   id++;
-  outer->SetMaterial(MenuHelper::cloneMaterial(
+  outer->SetMaterial(MenuHelper::CloneMaterial(
       outer->GetMaterial(),
       std::string("Button_Material_") + std::to_string(id)));
-  face_->SetMaterial(MenuHelper::cloneMaterial(
+  face_->SetMaterial(MenuHelper::CloneMaterial(
       face_->GetMaterial(),
       std::string("Button_Face_Material_") + std::to_string(id)));
 
@@ -65,8 +65,8 @@ MenuButton::MenuButton(phx::Engine* engine, phx::Scene* scene, TYPE type) {
     face_->GetMaterial()->SetDiffuseColor(glm::vec3(0.322f, 0.729f, 0.722f));
   }
 
-  outer->GetMaterial()->SetAmbientColor(color_unhovered);
-  outer->GetMaterial()->SetDiffuseColor(color_unhovered);
+  outer->GetMaterial()->SetAmbientColor(kColorUnhovered_);
+  outer->GetMaterial()->SetDiffuseColor(kColorUnhovered_);
 
   selector_ = entity_->AddComponent<phx::Selector>(entity_, false);
 
@@ -76,7 +76,7 @@ MenuButton::MenuButton(phx::Engine* engine, phx::Scene* scene, TYPE type) {
   selector_->SetUpdateHover(
       [outer, this](glm::mat4, std::chrono::milliseconds t) {
         if (grabbed_) return;
-        auto color = glm::mix(color_unhovered, color_hovered,
+        auto color = glm::mix(kColorUnhovered_, kColorHovered_,
                               glm::clamp(t.count() / 100.0f, 0.0f, 1.0f));
 
         outer->GetMaterial()->SetAmbientColor(color);
@@ -84,13 +84,13 @@ MenuButton::MenuButton(phx::Engine* engine, phx::Scene* scene, TYPE type) {
       });
   selector_->SetUnhover([outer, this]() {
     if (grabbed_) return;
-    outer->GetMaterial()->SetAmbientColor(color_unhovered);
-    outer->GetMaterial()->SetDiffuseColor(color_unhovered);
+    outer->GetMaterial()->SetAmbientColor(kColorUnhovered_);
+    outer->GetMaterial()->SetDiffuseColor(kColorUnhovered_);
   });
   selector_->SetGrab([outer, this, engine](phx::Transform* t, glm::mat4 r) {
     grabbed_ = true;
-    outer->GetMaterial()->SetAmbientColor(color_pressed);
-    outer->GetMaterial()->SetDiffuseColor(color_pressed);
+    outer->GetMaterial()->SetAmbientColor(kColorPressed_);
+    outer->GetMaterial()->SetDiffuseColor(kColorPressed_);
     auto old_scale_y =
         entity_->GetFirstComponent<phx::Transform>()->GetLocalScale().y;
     entity_->GetFirstComponent<phx::Transform>()->Scale(
@@ -121,15 +121,15 @@ MenuButton::MenuButton(phx::Engine* engine, phx::Scene* scene, TYPE type) {
 
   selector_->SetRelease([outer, this]() {
     grabbed_ = false;
-    outer->GetMaterial()->SetAmbientColor(color_unhovered);
-    outer->GetMaterial()->SetDiffuseColor(color_unhovered);
+    outer->GetMaterial()->SetAmbientColor(kColorUnhovered_);
+    outer->GetMaterial()->SetDiffuseColor(kColorUnhovered_);
     auto old_scale_y =
         entity_->GetFirstComponent<phx::Transform>()->GetLocalScale().y;
     entity_->GetFirstComponent<phx::Transform>()->Scale(
         glm::vec3(0, +old_scale_y, 0));
   });
 
-  selector_->intersection_dist = 0.1f;
+  selector_->SetIntersectionDistance(0.1f);
 }
 
 MenuButton::~MenuButton() {}
diff --git a/demos/optical_bench/src/menu_button.hpp b/demos/optical_bench/src/menu_button.hpp
index ffc0a769..65743b61 100644
--- a/demos/optical_bench/src/menu_button.hpp
+++ b/demos/optical_bench/src/menu_button.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_MENU_BUTTON_HPP_
+#define OPTICAL_BENCH_MENU_BUTTON_HPP_
 
 #include "phx/suppress_warnings.hpp"
 
@@ -41,9 +42,9 @@ class MenuButton {
   phx::Entity* entity_;
   phx::Selector* selector_;
   bool grabbed_ = false;
-  glm::vec3 color_unhovered = glm::vec3(0.5f);
-  glm::vec3 color_hovered = glm::vec3(1.0f, 0.502f, 0.0f);
-  glm::vec3 color_pressed = glm::vec3(1.0f, 0.0f, 0.0f);
+  const glm::vec3 kColorUnhovered_ = glm::vec3(0.5f);
+  const glm::vec3 kColorHovered_ = glm::vec3(1.0f, 0.502f, 0.0f);
+  const glm::vec3 kColorPressed_ = glm::vec3(1.0f, 0.0f, 0.0f);
   std::chrono::duration<double> grab_time_;
   bool hold_activated_ = false;
   bool holdable_ = true;
@@ -51,3 +52,4 @@ class MenuButton {
 
   std::function<void(phx::Transform*, glm::mat4)> onpress_function_ = nullptr;
 };
+#endif  // OPTICAL_BENCH_MENU_BUTTON_HPP_
diff --git a/demos/optical_bench/src/menu_helper.hpp b/demos/optical_bench/src/menu_helper.hpp
index 77f97341..0c86c188 100644
--- a/demos/optical_bench/src/menu_helper.hpp
+++ b/demos/optical_bench/src/menu_helper.hpp
@@ -23,7 +23,7 @@ SUPPRESS_WARNINGS_END
 
 class MenuHelper {
  public:
-  static phx::ResourcePointer<phx::Material> cloneMaterial(
+  static phx::ResourcePointer<phx::Material> CloneMaterial(
       phx::ResourcePointer<phx::Material> mat,
       const std::string material_name) {
     auto res = phx::ResourceUtils::LoadGenericMaterial(
@@ -35,7 +35,7 @@ class MenuHelper {
     return res;
   }
 
-  static void createSliderTextPair(phx::Scene* scene, phx::Engine* engine,
+  static void CreateSliderTextPair(phx::Scene* scene, phx::Engine* engine,
                                    MenuSlider*& slider, phx::Text*& text,
                                    float offset_x, float offset_y,
                                    float increments, float min, float max,
@@ -60,7 +60,7 @@ class MenuHelper {
         parent->GetFirstComponent<phx::Transform>(), false);
   };
 
-  static void createButtonPairVertical(MenuButton*& up, MenuButton*& down,
+  static void CreateButtonPairVertical(MenuButton*& up, MenuButton*& down,
                                        phx::Text*& text, float offset_x,
                                        float offset_y, phx::Scene* scene,
                                        phx::Engine* engine,
diff --git a/demos/optical_bench/src/menu_manager.cpp b/demos/optical_bench/src/menu_manager.cpp
index 8d7dc344..6788c4a6 100644
--- a/demos/optical_bench/src/menu_manager.cpp
+++ b/demos/optical_bench/src/menu_manager.cpp
@@ -33,7 +33,7 @@ MenuManager::MenuManager(phx::Scene* scene, phx::Engine* engine) {
   auto select = root_->AddComponent<phx::Selector>(nullptr, false);
   select->SetCollider(glm::vec3(0, -0.1065f, -0.1875f),
                       glm::vec3(0.01f, +0.1065f, +0.1875f));
-  select->intersection_dist = 0.1f;
+  select->SetIntersectionDistance(0.1f);
 
   // buttons
   right_button_ = new MenuButton(engine, scene, MenuButton::ROUND);
@@ -80,29 +80,29 @@ MenuManager::~MenuManager() {
 void MenuManager::ShowMenu(MenuType type) {
   switch (type) {
     case LASER_MENU:
-      moveMenuToFront(laser_menu_->GetTransform());
+      MoveMenuToFront(laser_menu_->GetTransform());
       current_menu_ = LASER_MENU;
       break;
     case LENS_MENU:
-      moveMenuToFront(lens_menu_->GetTransform());
+      MoveMenuToFront(lens_menu_->GetTransform());
       current_menu_ = LENS_MENU;
       break;
     case OBJECT_MENU:
-      moveMenuToFront(object_menu_->GetTransform());
+      MoveMenuToFront(object_menu_->GetTransform());
       current_menu_ = OBJECT_MENU;
       break;
   }
 }
 
 void MenuManager::NextMenu() {
-  ShowMenu(static_cast<MenuType>((current_menu_ + 1 + num_menus) % num_menus));
+  ShowMenu(static_cast<MenuType>((current_menu_ + 1 + kNumMenus_) % kNumMenus_));
 }
 
 void MenuManager::PrevMenu() {
-  ShowMenu(static_cast<MenuType>((current_menu_ - 1 + num_menus) % num_menus));
+  ShowMenu(static_cast<MenuType>((current_menu_ - 1 + kNumMenus_) % kNumMenus_));
 }
 
-void MenuManager::moveMenuToFront(phx::Transform* menu) {
+void MenuManager::MoveMenuToFront(phx::Transform* menu) {
   if (place_->GetFirstComponent<phx::Transform>()->GetChildCount() > 1) return;
   if (place_->GetFirstComponent<phx::Transform>()->GetChildCount() == 1) {
     auto old_child = place_->GetFirstComponent<phx::Transform>()->GetChild(0);
diff --git a/demos/optical_bench/src/menu_manager.hpp b/demos/optical_bench/src/menu_manager.hpp
index 47287565..b367671c 100644
--- a/demos/optical_bench/src/menu_manager.hpp
+++ b/demos/optical_bench/src/menu_manager.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_MENU_MANAGER_HPP_
+#define OPTICAL_BENCH_MENU_MANAGER_HPP_
 
 #include "phx/suppress_warnings.hpp"
 
@@ -42,7 +43,7 @@ class MenuManager {
   ObjectMenu* GetObjectMenu() { return object_menu_; }
 
  private:
-  const unsigned int num_menus = 3;
+  const unsigned int kNumMenus_ = 3;
 
   MenuType current_menu_ = LENS_MENU;
 
@@ -59,5 +60,7 @@ class MenuManager {
 
   SupportRod* support_rod_;
 
-  void moveMenuToFront(phx::Transform* menu);
+  void MoveMenuToFront(phx::Transform* menu);
 };
+
+#endif  // OPTICAL_BENCH_MENU_MANAGER_HPP_
diff --git a/demos/optical_bench/src/menu_slider.cpp b/demos/optical_bench/src/menu_slider.cpp
index 9cb55de5..1df37724 100644
--- a/demos/optical_bench/src/menu_slider.cpp
+++ b/demos/optical_bench/src/menu_slider.cpp
@@ -71,7 +71,7 @@ MenuSlider::MenuSlider(phx::Scene* scene, phx::Engine* engine,
     slider_grip_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
         glm::vec3(0, 0, pos_clamped));
 
-    if (value_changed_ != nullptr) value_changed_(posToValue(pos_clamped));
+    if (value_changed_ != nullptr) value_changed_(PositionToValue(pos_clamped));
   });
   button_left_->SetOnPress([this](phx::Transform*, glm::mat4) {
     auto pos = glm::clamp(slider_grip_->GetFirstComponent<phx::Transform>()
@@ -79,13 +79,13 @@ MenuSlider::MenuSlider(phx::Scene* scene, phx::Engine* engine,
                               .z,
                           -0.4f, 0.4f);
 
-    auto val = posToValue(pos);
+    auto val = PositionToValue(pos);
     val -= increments_;
 
     val = glm::clamp(val, min_max_value_[0], min_max_value_[1]);
 
     slider_grip_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
-        glm::vec3(0, 0, valueToPos(val)));
+        glm::vec3(0, 0, ValueToPosition(val)));
 
     if (value_changed_ != nullptr) value_changed_(val);
   });
@@ -95,13 +95,13 @@ MenuSlider::MenuSlider(phx::Scene* scene, phx::Engine* engine,
                               .z,
                           -0.4f, 0.4f);
 
-    auto val = posToValue(pos);
+    auto val = PositionToValue(pos);
     val += increments_;
 
     val = glm::clamp(val, min_max_value_[0], min_max_value_[1]);
 
     slider_grip_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
-        glm::vec3(0, 0, valueToPos(val)));
+        glm::vec3(0, 0, ValueToPosition(val)));
 
     if (value_changed_ != nullptr) value_changed_(val);
   });
@@ -112,13 +112,13 @@ MenuSlider::MenuSlider(phx::Scene* scene, phx::Engine* engine,
                               .z,
                           -0.4f, 0.4f);
 
-    auto val = posToValue(pos);
+    auto val = PositionToValue(pos);
     val += glm::degrees(deg) * 0.01f * increments_;
 
     val = glm::clamp(val, min_max_value_[0], min_max_value_[1]);
 
     slider_grip_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
-        glm::vec3(0, 0, valueToPos(val)));
+        glm::vec3(0, 0, ValueToPosition(val)));
 
     if (value_changed_ != nullptr) value_changed_(val);
   });
@@ -140,27 +140,27 @@ MenuSlider::MenuSlider(phx::Scene* scene, phx::Engine* engine,
   // of the mesh
   static unsigned int id = 0u;
   id++;
-  outer->SetMaterial(MenuHelper::cloneMaterial(
+  outer->SetMaterial(MenuHelper::CloneMaterial(
       outer->GetMaterial(),
       std::string("Slider_Material_") + std::to_string(id)));
 
-  outer->GetMaterial()->SetAmbientColor(color_normal);
-  outer->GetMaterial()->SetDiffuseColor(color_normal);
+  outer->GetMaterial()->SetAmbientColor(kColorNormal_);
+  outer->GetMaterial()->SetDiffuseColor(kColorNormal_);
 
   auto select_mark = slider_grip_->AddComponent<phx::SelectionMarkHandler>(
       [this, outer]() {
-        outer->GetMaterial()->SetAmbientColor(color_selected);
-        outer->GetMaterial()->SetDiffuseColor(color_selected);
+        outer->GetMaterial()->SetAmbientColor(kColorSelected_);
+        outer->GetMaterial()->SetDiffuseColor(kColorSelected_);
       },
       [this, outer]() {
-        outer->GetMaterial()->SetAmbientColor(color_normal);
-        outer->GetMaterial()->SetDiffuseColor(color_normal);
+        outer->GetMaterial()->SetAmbientColor(kColorNormal_);
+        outer->GetMaterial()->SetDiffuseColor(kColorNormal_);
       });
 
   slider_select->SetUpdateHover(
       [outer, select_mark, this](glm::mat4, std::chrono::milliseconds t) {
         if (grabbed_ || select_mark->GetSelected()) return;
-        auto color = glm::mix(color_normal, color_hovered,
+        auto color = glm::mix(kColorNormal_, kColorHovered_,
                               glm::clamp(t.count() / 100.0f, 0.0f, 1.0f));
 
         outer->GetMaterial()->SetAmbientColor(color);
@@ -168,13 +168,13 @@ MenuSlider::MenuSlider(phx::Scene* scene, phx::Engine* engine,
       });
   slider_select->SetUnhover([outer, select_mark, this]() {
     if (grabbed_ || select_mark->GetSelected()) return;
-    outer->GetMaterial()->SetAmbientColor(color_normal);
-    outer->GetMaterial()->SetDiffuseColor(color_normal);
+    outer->GetMaterial()->SetAmbientColor(kColorNormal_);
+    outer->GetMaterial()->SetDiffuseColor(kColorNormal_);
   });
   slider_select->SetGrab([outer, this, engine](phx::Transform*, glm::mat4) {
     grabbed_ = true;
-    outer->GetMaterial()->SetAmbientColor(color_pressed);
-    outer->GetMaterial()->SetDiffuseColor(color_pressed);
+    outer->GetMaterial()->SetAmbientColor(kColorPressed_);
+    outer->GetMaterial()->SetDiffuseColor(kColorPressed_);
     auto old_scale_x =
         entity_->GetFirstComponent<phx::Transform>()->GetLocalScale().x;
     entity_->GetFirstComponent<phx::Transform>()->Scale(
@@ -186,11 +186,11 @@ MenuSlider::MenuSlider(phx::Scene* scene, phx::Engine* engine,
     grabbed_ = false;
 
     if (select_mark->GetSelected()) {
-      outer->GetMaterial()->SetAmbientColor(color_selected);
-      outer->GetMaterial()->SetDiffuseColor(color_selected);
+      outer->GetMaterial()->SetAmbientColor(kColorSelected_);
+      outer->GetMaterial()->SetDiffuseColor(kColorSelected_);
     } else {
-      outer->GetMaterial()->SetAmbientColor(color_normal);
-      outer->GetMaterial()->SetDiffuseColor(color_normal);
+      outer->GetMaterial()->SetAmbientColor(kColorNormal_);
+      outer->GetMaterial()->SetDiffuseColor(kColorNormal_);
     }
 
     auto old_scale_x =
@@ -199,7 +199,7 @@ MenuSlider::MenuSlider(phx::Scene* scene, phx::Engine* engine,
         glm::vec3(+old_scale_x, 0, 0));
   });
 
-  slider_select->intersection_dist = 0.1f;
+  slider_select->SetIntersectionDistance(0.1f);
 }
 
 MenuSlider::~MenuSlider() {
@@ -208,7 +208,7 @@ MenuSlider::~MenuSlider() {
 }
 
 void MenuSlider::SetMinMax(float min, float max, bool changed_event) {
-  auto val = posToValue(slider_grip_->GetFirstComponent<phx::Transform>()
+  auto val = PositionToValue(slider_grip_->GetFirstComponent<phx::Transform>()
                             ->GetLocalTranslation()
                             .z);
 
@@ -218,7 +218,7 @@ void MenuSlider::SetMinMax(float min, float max, bool changed_event) {
   val = glm::clamp(val, min, max);
 
   slider_grip_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
-      glm::vec3(0, 0, valueToPos(val)));
+      glm::vec3(0, 0, ValueToPosition(val)));
 
   if (value_changed_ != nullptr && changed_event) value_changed_(val);
 }
@@ -230,25 +230,25 @@ void MenuSlider::SetValue(float f) {
     return;  // do not update if no change
 
   slider_grip_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
-      glm::vec3(0, 0, valueToPos(f)));
+      glm::vec3(0, 0, ValueToPosition(f)));
 
   if (value_changed_ != nullptr) value_changed_(f);
 }
 
 float MenuSlider::GetValue() {
-  return posToValue(slider_grip_->GetFirstComponent<phx::Transform>()
+  return PositionToValue(slider_grip_->GetFirstComponent<phx::Transform>()
                         ->GetLocalTranslation()
                         .z);
 }
 
-float MenuSlider::posToValue(float p) {
+float MenuSlider::PositionToValue(float p) {
   p = (p + 0.4f) / 0.8f;  //[0,1]
   p = p * (min_max_value_[1] - min_max_value_[0]) +
       min_max_value_[0];  //[min, max]
   return p;
 }
 
-float MenuSlider::valueToPos(float v) {
+float MenuSlider::ValueToPosition(float v) {
   v = (v - min_max_value_[0]) /
       (min_max_value_[1] - min_max_value_[0]);  //[0,1]
   v = v * 0.8f - 0.4f;                          //[-0.4,+0.4]
diff --git a/demos/optical_bench/src/menu_slider.hpp b/demos/optical_bench/src/menu_slider.hpp
index 0c07e49c..a771110e 100644
--- a/demos/optical_bench/src/menu_slider.hpp
+++ b/demos/optical_bench/src/menu_slider.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_MENU_SLIDER_HPP_
+#define OPTICAL_BENCH_MENU_SLIDER_HPP_
 
 #include "phx/suppress_warnings.hpp"
 
@@ -33,7 +34,7 @@ class MenuSlider {
   void SetValue(float f);
   float GetValue();
 
-  std::array<float, 2> getMinMaxValue() { return min_max_value_; }
+  std::array<float, 2> GetMinMaxValue() { return min_max_value_; }
 
  private:
   phx::Entity* entity_;
@@ -46,16 +47,17 @@ class MenuSlider {
 
   std::array<float, 2> min_max_value_ = {0, 1};
 
-  float posToValue(float p);
-  float valueToPos(float v);
+  float PositionToValue(float p);
+  float ValueToPosition(float v);
 
   std::function<void(float)> value_changed_ = nullptr;
 
   // highlight stuff
-  glm::vec3 color_normal = glm::vec3(0.5f);
-  glm::vec3 color_hovered = glm::vec3(1.0f, 0.502f, 0.0f);
-  glm::vec3 color_pressed = glm::vec3(1.0f, 0.0f, 0.0f);
-  glm::vec3 color_selected = glm::vec3(0.424f, 0.851f, 0.141f);
+  const glm::vec3 kColorNormal_ = glm::vec3(0.5f);
+  const glm::vec3 kColorHovered_ = glm::vec3(1.0f, 0.502f, 0.0f);
+  const glm::vec3 kColorPressed_ = glm::vec3(1.0f, 0.0f, 0.0f);
+  const glm::vec3 kColorSelected_ = glm::vec3(0.424f, 0.851f, 0.141f);
   std::chrono::duration<double> grab_time_;
   bool grabbed_ = false;
 };
+#endif  // OPTICAL_BENCH_MENU_SLIDER_HPP_
diff --git a/demos/optical_bench/src/menu_switch.cpp b/demos/optical_bench/src/menu_switch.cpp
index 37fcf539..f6b32733 100644
--- a/demos/optical_bench/src/menu_switch.cpp
+++ b/demos/optical_bench/src/menu_switch.cpp
@@ -41,12 +41,12 @@ MenuSwitch::MenuSwitch(phx::Engine* engine, phx::Scene* scene, bool activated) {
   // of the mesh
   static unsigned int id = 0u;
   id++;
-  outer->SetMaterial(MenuHelper::cloneMaterial(
+  outer->SetMaterial(MenuHelper::CloneMaterial(
       outer->GetMaterial(),
       std::string("Switch_Material_") + std::to_string(id)));
 
-  outer->GetMaterial()->SetAmbientColor(color_unhovered);
-  outer->GetMaterial()->SetDiffuseColor(color_unhovered);
+  outer->GetMaterial()->SetAmbientColor(kColorUnhovered_);
+  outer->GetMaterial()->SetDiffuseColor(kColorUnhovered_);
 
   selector_ = entity_->AddComponent<phx::Selector>(entity_, false);
 
@@ -55,22 +55,22 @@ MenuSwitch::MenuSwitch(phx::Engine* engine, phx::Scene* scene, bool activated) {
   // Set hover with color change
   selector_->SetUpdateHover(
       [outer, this](glm::mat4, std::chrono::milliseconds t) {
-        auto color = glm::mix(color_unhovered, color_hovered,
+        auto color = glm::mix(kColorUnhovered_, kColorHovered_,
                               glm::clamp(t.count() / 100.0f, 0.0f, 1.0f));
 
         outer->GetMaterial()->SetAmbientColor(color);
         outer->GetMaterial()->SetDiffuseColor(color);
       });
   selector_->SetUnhover([outer, this]() {
-    outer->GetMaterial()->SetAmbientColor(color_unhovered);
-    outer->GetMaterial()->SetDiffuseColor(color_unhovered);
+    outer->GetMaterial()->SetAmbientColor(kColorUnhovered_);
+    outer->GetMaterial()->SetDiffuseColor(kColorUnhovered_);
   });
   selector_->SetGrab([outer, this, engine](phx::Transform*, glm::mat4) {
     ToggleActive();
     if (on_switch_function_ != nullptr) on_switch_function_(activated_);
   });
 
-  selector_->intersection_dist = 0.1f;
+  selector_->SetIntersectionDistance(0.1f);
 
   SetActivated(activated);
 }
diff --git a/demos/optical_bench/src/menu_switch.hpp b/demos/optical_bench/src/menu_switch.hpp
index ae972a9b..31fbdf03 100644
--- a/demos/optical_bench/src/menu_switch.hpp
+++ b/demos/optical_bench/src/menu_switch.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_MENU_SWITCH_HPP_
+#define OPTICAL_BENCH_MENU_SWITCH_HPP_
 
 #include "phx/suppress_warnings.hpp"
 
@@ -33,10 +34,12 @@ class MenuSwitch {
  private:
   phx::Entity* entity_;
   phx::Selector* selector_;
-  glm::vec3 color_unhovered = glm::vec3(0.5f);
-  glm::vec3 color_hovered = glm::vec3(1.0f, 0.502f, 0.0f);
+  const glm::vec3 kColorUnhovered_ = glm::vec3(0.5f);
+  const glm::vec3 kColorHovered_ = glm::vec3(1.0f, 0.502f, 0.0f);
 
   bool activated_ = false;
 
   std::function<void(bool)> on_switch_function_ = nullptr;
 };
+
+#endif  // OPTICAL_BENCH_MENU_SWITCH_HPP_
diff --git a/demos/optical_bench/src/object_manager.cpp b/demos/optical_bench/src/object_manager.cpp
index f4fce831..a832e5d4 100644
--- a/demos/optical_bench/src/object_manager.cpp
+++ b/demos/optical_bench/src/object_manager.cpp
@@ -40,11 +40,11 @@ ObjectManager::ObjectManager(phx::Engine* engine, phx::Scene* scene,
     }
   }
 
-  bin_mat_->GetMaterial()->SetAmbientColor(bin_color_base);
-  bin_mat_->GetMaterial()->SetDiffuseColor(bin_color_base);
+  bin_mat_->GetMaterial()->SetAmbientColor(kBinColorBase_);
+  bin_mat_->GetMaterial()->SetDiffuseColor(kBinColorBase_);
 
   // intersection
-  intersection_thread_ = std::thread(&ObjectManager::intersectThread, this);
+  intersection_thread_ = std::thread(&ObjectManager::IntersectionThreadFunction, this);
 
   // Lens axis
   center_axis_ = phx::SceneLoader::InsertModelIntoScene(
@@ -61,7 +61,7 @@ ObjectManager::ObjectManager(phx::Engine* engine, phx::Scene* scene,
 ObjectManager::~ObjectManager() {}
 
 void ObjectManager::Update(const phx::FrameTimer::TimeInfo&) {
-  updateThreadData();
+  UpdateThreadData();
 
   Lens* current_lens = nullptr;
   TestPatternFrame* current_target = nullptr;
@@ -69,27 +69,27 @@ void ObjectManager::Update(const phx::FrameTimer::TimeInfo&) {
   intersector_output_mutex_.lock();
   intersector_invalidation_mutex_.lock();
   if (!intersector_data_invalidated_) {
-    if (intersector_res_lens >= 0)
-      current_lens = registered_lenses_[intersector_res_lens];
-    if (intersector_res_target >= 0)
-      current_target = registered_frames_[intersector_res_target];
+    if (intersector_res_lens_ >= 0)
+      current_lens = registered_lenses_[intersector_res_lens_];
+    if (intersector_res_target_ >= 0)
+      current_target = registered_frames_[intersector_res_target_];
   }
   intersector_invalidation_mutex_.unlock();
   intersector_output_mutex_.unlock();
 
   if (current_lens != nullptr || current_target != nullptr) {
-    bin_mat_->GetMaterial()->SetAmbientColor(bin_color_highlight);
-    bin_mat_->GetMaterial()->SetDiffuseColor(bin_color_highlight);
+    bin_mat_->GetMaterial()->SetAmbientColor(kBinColorHighlight);
+    bin_mat_->GetMaterial()->SetDiffuseColor(kBinColorHighlight);
   } else {
-    bin_mat_->GetMaterial()->SetAmbientColor(bin_color_base);
-    bin_mat_->GetMaterial()->SetDiffuseColor(bin_color_base);
+    bin_mat_->GetMaterial()->SetAmbientColor(kBinColorBase_);
+    bin_mat_->GetMaterial()->SetDiffuseColor(kBinColorBase_);
   }
 
   if (current_lens != nullptr) {
-    if (!current_lens->isGrabbed()) DeleteLens(current_lens);
+    if (!current_lens->IsGrabbed()) DeleteLens(current_lens);
   }
   if (current_target != nullptr) {
-    if (!current_target->isGrabbed()) DeleteTarget(current_target);
+    if (!current_target->IsGrabbed()) DeleteTarget(current_target);
   }
 }
 
@@ -177,7 +177,7 @@ Lens* ObjectManager::GetLens(phx::Entity* e) {
   return nullptr;
 }
 
-void ObjectManager::intersectThread() {
+void ObjectManager::IntersectionThreadFunction() {
   auto select_bin = bin_->GetFirstComponent<phx::Selector>();
 
   int current_lens_res = -1;
@@ -204,7 +204,7 @@ void ObjectManager::intersectThread() {
     current_frame_res = -1;
 
     for (auto i = 0u; i < lenses.size(); i++) {
-      dist = select_bin->intersect(lenses[i], glm::vec3(0, 1, 0));
+      dist = select_bin->Intersect(lenses[i], glm::vec3(0, 1, 0));
       if (dist == 0) {
         current_lens_res = i;
         break;
@@ -212,7 +212,7 @@ void ObjectManager::intersectThread() {
     }
 
     for (auto i = 0u; i < targets.size(); i++) {
-      dist = select_bin->intersect(targets[i], glm::vec3(0, 1, 0));
+      dist = select_bin->Intersect(targets[i], glm::vec3(0, 1, 0));
       if (dist == 0) {
         current_frame_res = i;
         break;
@@ -220,8 +220,8 @@ void ObjectManager::intersectThread() {
     }
 
     intersector_output_mutex_.lock();
-    intersector_res_lens = current_lens_res;
-    intersector_res_target = current_frame_res;
+    intersector_res_lens_ = current_lens_res;
+    intersector_res_target_ = current_frame_res;
     intersector_output_mutex_.unlock();
 
     // Update invalidation flag
@@ -234,7 +234,7 @@ void ObjectManager::intersectThread() {
   }
 }
 
-void ObjectManager::updateThreadData() {
+void ObjectManager::UpdateThreadData() {
   intersector_input_mutex_.lock();
 
   intersector_frames_pos_.clear();
diff --git a/demos/optical_bench/src/object_manager.hpp b/demos/optical_bench/src/object_manager.hpp
index a10e180a..dd5cf1c2 100644
--- a/demos/optical_bench/src/object_manager.hpp
+++ b/demos/optical_bench/src/object_manager.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_OBEJCT_MANAGER_HPP_
+#define OPTICAL_BENCH_OBEJCT_MANAGER_HPP_
 
 #include "hmd_navigation_behavior.hpp"
 #include "lens.hpp"
@@ -39,7 +40,7 @@ class ObjectManager : public phx::System {
   void SetMenuManager(MenuManager* manager);
   MenuManager* GetMenuManager() { return menu_; };
 
-  void registerHMDNav(HMDNavigationBehavior* nav) { hmd_nav_ = nav; }
+  void RegisterHMDNavigation(HMDNavigationBehavior* nav) { hmd_nav_ = nav; }
 
   void ChangedWavelength(float wavelength_nm);
 
@@ -62,8 +63,8 @@ class ObjectManager : public phx::System {
   phx::Entity* bin_;
 
   phx::MaterialHandle* bin_mat_ = nullptr;
-  glm::vec3 bin_color_base = glm::vec3(0.189474f, 0.189474f, 0.189474f);
-  glm::vec3 bin_color_highlight = glm::vec3(0.475f, 0.059f, 0.071f);
+  const glm::vec3 kBinColorBase_ = glm::vec3(0.189474f, 0.189474f, 0.189474f);
+  const glm::vec3 kBinColorHighlight = glm::vec3(0.475f, 0.059f, 0.071f);
 
   float current_wavelength_nm_ = 0.0f;
 
@@ -72,7 +73,7 @@ class ObjectManager : public phx::System {
   bool axis_visible_ = false;
 
   std::thread intersection_thread_;
-  void intersectThread();
+  void IntersectionThreadFunction();
   bool intersector_run_ = true;
   bool make_invalid_ = false;
   std::mutex intersector_input_mutex_;
@@ -81,9 +82,9 @@ class ObjectManager : public phx::System {
   bool intersector_data_invalidated_ = false;
   std::vector<glm::vec3> intersector_lenses_pos_;
   std::vector<glm::vec3> intersector_frames_pos_;
-  int intersector_res_lens = -1;
-  int intersector_res_target = -1;
-  void updateThreadData();
+  int intersector_res_lens_ = -1;
+  int intersector_res_target_ = -1;
+  void UpdateThreadData();
 
   HMDNavigationBehavior* hmd_nav_ = nullptr;
   OptixContextManager* manager_;
@@ -93,3 +94,5 @@ class ObjectManager : public phx::System {
   std::vector<Lens*> registered_lenses_;
   std::vector<TestPatternFrame*> registered_frames_;
 };
+
+#endif  // OPTICAL_BENCH_OBEJCT_MANAGER_HPP_
diff --git a/demos/optical_bench/src/object_menu.cpp b/demos/optical_bench/src/object_menu.cpp
index c3488da9..e1dc500f 100644
--- a/demos/optical_bench/src/object_menu.cpp
+++ b/demos/optical_bench/src/object_menu.cpp
@@ -33,7 +33,7 @@ ObjectMenu::ObjectMenu(phx::Scene* scene, phx::Engine* engine) {
                       ->GetEntity()
                       ->GetFirstComponent<phx::MaterialHandle>();
     if (handle->GetMaterial()->GetName().compare("Screen") == 0) {
-      handle->SetMaterial(MenuHelper::cloneMaterial(
+      handle->SetMaterial(MenuHelper::CloneMaterial(
           handle->GetMaterial(), "ObjectMenuScreenMaterial"));
       handle->GetMaterial()->SetAmbientImage(image);
       break;
diff --git a/demos/optical_bench/src/object_menu.hpp b/demos/optical_bench/src/object_menu.hpp
index 57cd0faa..576c72ed 100644
--- a/demos/optical_bench/src/object_menu.hpp
+++ b/demos/optical_bench/src/object_menu.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_OBJECT_MENU_HPP_
+#define OPTICAL_BENCH_OBJECT_MENU_HPP_
 
 #include "phx/suppress_warnings.hpp"
 
@@ -35,3 +36,5 @@ class ObjectMenu {
   MenuButton* create_frame_4_;
   MenuButton* toggle_guide_;
 };
+
+#endif  // OPTICAL_BENCH_OBJECT_MENU_HPP_
diff --git a/demos/optical_bench/src/object_support_rod.cpp b/demos/optical_bench/src/object_support_rod.cpp
index dd54abb7..a0282dce 100644
--- a/demos/optical_bench/src/object_support_rod.cpp
+++ b/demos/optical_bench/src/object_support_rod.cpp
@@ -19,8 +19,8 @@ SUPPRESS_WARNINGS_END
 SupportRod::SupportRod(phx::Scene* scene, phx::Selector* selector,
                        bool append_to_move) {
   selector_ = selector;
-  rod_support_entity_ = loadAndInsertRod(scene);
-  rod_holder_entity_ = loadAndInsertRod(scene);
+  rod_support_entity_ = LoadAndInsertRod(scene);
+  rod_holder_entity_ = LoadAndInsertRod(scene);
 
   auto trans_for_holder =
       rod_holder_entity_->GetFirstComponent<phx::Transform>();
@@ -33,7 +33,7 @@ SupportRod::SupportRod(phx::Scene* scene, phx::Selector* selector,
   static unsigned int id = 0u;
   id++;
   holder_mat_ = rod_holder_entity_->GetFirstComponent<phx::MaterialHandle>();
-  holder_mat_->SetMaterial(MenuHelper::cloneMaterial(
+  holder_mat_->SetMaterial(MenuHelper::CloneMaterial(
       rod_holder_entity_->GetFirstComponent<phx::MaterialHandle>()
           ->GetMaterial(),
       "Holder_Material" + std::to_string(id)));
@@ -75,7 +75,7 @@ SupportRod::~SupportRod() {
   scene->RemoveEntity(rod_holder_entity_);
 }
 
-phx::Entity* SupportRod::loadAndInsertRod(phx::Scene* scene) {
+phx::Entity* SupportRod::LoadAndInsertRod(phx::Scene* scene) {
   auto model = phx::ResourceUtils::LoadResourceFromFile<phx::Model>(
       "models/opticalBench/rod/rod.obj");
   if (model == nullptr) {
diff --git a/demos/optical_bench/src/object_support_rod.hpp b/demos/optical_bench/src/object_support_rod.hpp
index 59310dba..f7c28eea 100644
--- a/demos/optical_bench/src/object_support_rod.hpp
+++ b/demos/optical_bench/src/object_support_rod.hpp
@@ -29,7 +29,7 @@ class SupportRod {
   void Moved() { move_function_(); }
 
  private:
-  phx::Entity* loadAndInsertRod(phx::Scene* scene);
+  phx::Entity* LoadAndInsertRod(phx::Scene* scene);
   phx::Entity* rod_support_entity_;
   phx::Entity* rod_holder_entity_;
   phx::Selector* selector_;
diff --git a/demos/optical_bench/src/optical_bench.cpp b/demos/optical_bench/src/optical_bench.cpp
index c9080538..c848260e 100644
--- a/demos/optical_bench/src/optical_bench.cpp
+++ b/demos/optical_bench/src/optical_bench.cpp
@@ -86,7 +86,7 @@ int main(int argc, char** args) {
       std::make_shared<OptixContextManager>();
 
   std::unique_ptr<phx::Engine> engine =
-      phx::OpticalBenchSetup::CreateOptixEngine(contextManager);
+      phx::OpticalBenchSetup::CreateOptixEngine(contextManager.get());
   auto scene = engine->GetScene();
 
   auto object_manager = engine->GetSystem<ObjectManager>();
@@ -167,7 +167,7 @@ int main(int argc, char** args) {
     virtual_platform->AddComponent<DesktopNavigationBehavior>(
         engine->GetSystem<phx::InputSystem>());
   } else {  // HMD Rendering
-    object_manager->registerHMDNav(
+    object_manager->RegisterHMDNavigation(
         virtual_platform->AddComponent<HMDNavigationBehavior>(
             engine->GetSystem<phx::DisplaySystemOpenVR>()->GetHMD(), rayPass,
             scene.get(), engine->GetSystem<SelectionSystem>(), engine.get(),
diff --git a/demos/optical_bench/src/optix_context_manager.cpp b/demos/optical_bench/src/optix_context_manager.cpp
index ab03ef90..b3c49ea2 100644
--- a/demos/optical_bench/src/optix_context_manager.cpp
+++ b/demos/optical_bench/src/optix_context_manager.cpp
@@ -46,45 +46,45 @@ OptixContextManager::OptixContextManager() {
 
   // Exception program
   optix::Program exception_program = context_->createProgramFromPTXString(
-      getPtxString("exception.cu"), "exception");
+      GetPtxString("exception.cu"), "exception");
 
   // Miss Programm (avoid random data in buffer)
   context_->setMissProgram(0, context_->createProgramFromPTXString(
-                                  getPtxString("skybox.cu"), "skyboxLookup"));
+                                  GetPtxString("skybox.cu"), "skyboxLookup"));
 
   // Ray generation program
   optix::Program rayProg = context_->createProgramFromPTXString(
-      getPtxString("perspective_camera.cu"), "pinhole_camera");
+      GetPtxString("perspective_camera.cu"), "pinhole_camera");
   context_->setRayGenerationProgram(0, rayProg);
 
-  top_object = context_->createGroup();
-  top_object->setAcceleration(context_->createAcceleration(
+  top_object_ = context_->createGroup();
+  top_object_->setAcceleration(context_->createAcceleration(
       "NoAccel"));  //("Bvh" , "Bvh") or "Trbvh" or "NoAccel"
-  context_["top_object"]->set(top_object);
+  context_["top_object"]->set(top_object_);
 
-  createTargetGeometry();
-  createLensGeometry();
-  createDebugMaterial();
-  createTargetMaterial();
-  createSkybox();
+  CreateTargetGeometry();
+  CreateLensGeometry();
+  CreateDebugMaterial();
+  CreateTargetMaterial();
+  CreateSkybox();
 
   // context_->setUsageReportCallback(callbackUsageReport, 3, NULL);
 }
 
 OptixContextManager::~OptixContextManager() {
   if (context_) {
-    top_object->destroy();
-    debugMaterial->destroy();
-    targetMaterial->destroy();
-    lensGeomerty->destroy();
-    targetGeomerty->destroy();
+    top_object_->destroy();
+    debug_material_->destroy();
+    target_material_->destroy();
+    lens_geomerty_->destroy();
+    target_geomerty_->destroy();
 
     context_->destroy();
     context_ = 0;
   }
 }
 
-void OptixContextManager::updateCamera(phx::RenderTarget* render_target) {
+void OptixContextManager::UpdateCamera(phx::RenderTarget* render_target) {
   glm::mat4 viewProjMatrix =
       render_target->GetProjection() * render_target->GetView();
   glm::mat4 invViewProjMatrix = inverse(render_target->GetView()) *
@@ -94,7 +94,7 @@ void OptixContextManager::updateCamera(phx::RenderTarget* render_target) {
   context_["viewProjection"]->setMatrix4x4fv(true, &viewProjMatrix[0][0]);
 }
 
-std::string OptixContextManager::getPtxString(const char* filename) {
+std::string OptixContextManager::GetPtxString(const char* filename) {
   std::string source_filename = std::string(OPTICAL_BENCH_PTX_DIR) + "/" +
                                 TARGET_PROJECT_NAME + "_generated_" +
                                 std::string(filename) + ".ptx";
@@ -104,10 +104,10 @@ std::string OptixContextManager::getPtxString(const char* filename) {
       ->GetSource();
 }
 
-void OptixContextManager::launch(RTsize width, RTsize height) {
-  launch(0, width, height);
+void OptixContextManager::Launch(RTsize width, RTsize height) {
+  Launch(0, width, height);
 }
-void OptixContextManager::launch(unsigned int entryPoint, RTsize width,
+void OptixContextManager::Launch(unsigned int entryPoint, RTsize width,
                                  RTsize height) {
   try {
     context_->launch(entryPoint, width, height);
@@ -116,59 +116,59 @@ void OptixContextManager::launch(unsigned int entryPoint, RTsize width,
   }
 }
 
-void OptixContextManager::createDebugMaterial() {
-  std::string ptx = getPtxString("normal_shader.cu");
+void OptixContextManager::CreateDebugMaterial() {
+  std::string ptx = GetPtxString("normal_shader.cu");
   optix::Program closeHit =
       context_->createProgramFromPTXString(ptx, "closest_hit_radiance");
   try {
-    debugMaterial = context_->createMaterial();
-    debugMaterial->setClosestHitProgram(0, closeHit);
+    debug_material_ = context_->createMaterial();
+    debug_material_->setClosestHitProgram(0, closeHit);
   } catch (optix::Exception e) {
     phx::error(e.getErrorString().c_str());
   }
 }
 
-void OptixContextManager::createTargetMaterial() {
+void OptixContextManager::CreateTargetMaterial() {
   const std::string ptx =
-      OptixContextManager::getPtxString("frame_material.cu");
+      OptixContextManager::GetPtxString("frame_material.cu");
   optix::Program closeHitP =
       context_->createProgramFromPTXString(ptx, "closest_hit_radiance");
   optix::Program closeHitI =
       context_->createProgramFromPTXString(ptx, "closest_hit_iterative");
 
-  targetMaterial = context_->createMaterial();
-  targetMaterial->setClosestHitProgram(0, closeHitP);
-  targetMaterial->setClosestHitProgram(1, closeHitI);
+  target_material_ = context_->createMaterial();
+  target_material_->setClosestHitProgram(0, closeHitP);
+  target_material_->setClosestHitProgram(1, closeHitI);
 }
 
-void OptixContextManager::createLensGeometry() {
-  lensGeomerty = context_->createGeometry();
-  lensGeomerty->setPrimitiveCount(1u);
+void OptixContextManager::CreateLensGeometry() {
+  lens_geomerty_ = context_->createGeometry();
+  lens_geomerty_->setPrimitiveCount(1u);
 
   const std::string ptx =
-      OptixContextManager::getPtxString("lens_parametric.cu");
-  lensGeomerty->setBoundingBoxProgram(
+      OptixContextManager::GetPtxString("lens_parametric.cu");
+  lens_geomerty_->setBoundingBoxProgram(
       context_->createProgramFromPTXString(ptx, "bounds"));
-  lensGeomerty->setIntersectionProgram(
+  lens_geomerty_->setIntersectionProgram(
       context_->createProgramFromPTXString(ptx, "intersect"));
 }
 
-void OptixContextManager::createTargetGeometry() {
-  targetGeomerty = context_->createGeometry();
-  targetGeomerty->setPrimitiveCount(1u);
+void OptixContextManager::CreateTargetGeometry() {
+  target_geomerty_ = context_->createGeometry();
+  target_geomerty_->setPrimitiveCount(1u);
 
-  const std::string ptx = OptixContextManager::getPtxString("box_intersect.cu");
-  targetGeomerty->setBoundingBoxProgram(
+  const std::string ptx = OptixContextManager::GetPtxString("box_intersect.cu");
+  target_geomerty_->setBoundingBoxProgram(
       context_->createProgramFromPTXString(ptx, "bounds"));
-  targetGeomerty->setIntersectionProgram(
+  target_geomerty_->setIntersectionProgram(
       context_->createProgramFromPTXString(ptx, "intersect"));
 }
 
-void OptixContextManager::createSkybox() {
+void OptixContextManager::CreateSkybox() {
   std::vector<std::string> cube_filenames = {
       "skybox/skybox_xn.png", "skybox/skybox_xp.png", "skybox/skybox_yp.png",
       "skybox/skybox_yn.png", "skybox/skybox_zn.png", "skybox/skybox_zp.png"};
-  optix::Buffer skyBoxBuffer = loadCubeBuffer(context_, cube_filenames);
+  optix::Buffer skyBoxBuffer = LoadCubeBuffer(context_, cube_filenames);
   optix::TextureSampler skyBoxSampler = context_->createTextureSampler();
   skyBoxSampler->setWrapMode(0, RT_WRAP_CLAMP_TO_EDGE);
   skyBoxSampler->setWrapMode(1, RT_WRAP_CLAMP_TO_EDGE);
@@ -184,7 +184,7 @@ void OptixContextManager::createSkybox() {
   context_["skybox"]->setInt(skyBoxSampler->getId());
 }
 
-optix::TextureSampler OptixContextManager::loadTexture(
+optix::TextureSampler OptixContextManager::LoadTexture(
     optix::Context context, phx::ResourcePointer<phx::Image> image) {
   // Create tex sampler and populate with default values
   optix::TextureSampler sampler = context->createTextureSampler();
@@ -226,7 +226,7 @@ optix::TextureSampler OptixContextManager::loadTexture(
   return sampler;
 }
 
-optix::Buffer OptixContextManager::loadCubeBuffer(
+optix::Buffer OptixContextManager::LoadCubeBuffer(
     optix::Context context, const std::vector<std::string>& filenames) {
   optix::Buffer buffer = context->createBuffer(
       RT_BUFFER_INPUT | RT_BUFFER_CUBEMAP, RT_FORMAT_UNSIGNED_BYTE4);
diff --git a/demos/optical_bench/src/optix_context_manager.hpp b/demos/optical_bench/src/optix_context_manager.hpp
index 2af04859..f81f366a 100644
--- a/demos/optical_bench/src/optix_context_manager.hpp
+++ b/demos/optical_bench/src/optix_context_manager.hpp
@@ -14,37 +14,37 @@ class OptixContextManager {
   explicit OptixContextManager();
   ~OptixContextManager();
 
-  void updateCamera(phx::RenderTarget* render_target);
-  optix::Context getContext() { return context_; }
-  optix::Group getTopObject() { return top_object; }
+  void UpdateCamera(phx::RenderTarget* render_target);
+  optix::Context GetContext() { return context_; }
+  optix::Group GetTopObject() { return top_object_; }
 
-  static std::string getPtxString(const char* filename);
-  void launch(RTsize width, RTsize height);
-  void launch(unsigned int entryPoint, RTsize width, RTsize height);
+  static std::string GetPtxString(const char* filename);
+  void Launch(RTsize width, RTsize height);
+  void Launch(unsigned int entryPoint, RTsize width, RTsize height);
 
-  static optix::TextureSampler loadTexture(
+  static optix::TextureSampler LoadTexture(
       optix::Context context, phx::ResourcePointer<phx::Image> image);
 
-  optix::Material& GetDebugMaterial() { return debugMaterial; }
-  optix::Material& GetTargetMaterial() { return targetMaterial; }
-  optix::Geometry& GetLensGeometry() { return lensGeomerty; }
-  optix::Geometry& GetTargetGeometry() { return targetGeomerty; }
+  optix::Material& GetDebugMaterial() { return debug_material_; }
+  optix::Material& GetTargetMaterial() { return target_material_; }
+  optix::Geometry& GetLensGeometry() { return lens_geomerty_; }
+  optix::Geometry& GetTargetGeometry() { return target_geomerty_; }
 
  private:
   optix::Context context_;
-  optix::Group top_object;
-  optix::Material debugMaterial;
-  optix::Material targetMaterial;
-  optix::Geometry lensGeomerty;
-  optix::Geometry targetGeomerty;
-
-  void createDebugMaterial();
-  void createTargetMaterial();
-  void createLensGeometry();
-  void createTargetGeometry();
-  void createSkybox();
-
-  static optix::Buffer loadCubeBuffer(
+  optix::Group top_object_;
+  optix::Material debug_material_;
+  optix::Material target_material_;
+  optix::Geometry lens_geomerty_;
+  optix::Geometry target_geomerty_;
+
+  void CreateDebugMaterial();
+  void CreateTargetMaterial();
+  void CreateLensGeometry();
+  void CreateTargetGeometry();
+  void CreateSkybox();
+
+  static optix::Buffer LoadCubeBuffer(
       optix::Context context, const std::vector<std::string>& filenames);
 };
 
diff --git a/demos/optical_bench/src/optix_engine.cpp b/demos/optical_bench/src/optix_engine.cpp
index 9808a012..ed05f2af 100644
--- a/demos/optical_bench/src/optix_engine.cpp
+++ b/demos/optical_bench/src/optix_engine.cpp
@@ -60,7 +60,7 @@
 namespace phx {
 
 std::unique_ptr<Engine> OpticalBenchSetup::CreateOptixEngine(
-    std::shared_ptr<OptixContextManager> manager) {
+    OptixContextManager* manager) {
   auto engine = std::make_unique<Engine>();
   auto engine_ptr = engine.get();
   engine->SetScene(std::make_shared<Scene>());
@@ -96,8 +96,8 @@ std::unique_ptr<Engine> OpticalBenchSetup::CreateOptixEngine(
       engine->CreateSystem<RenderingSystem>(engine->GetSystem<DisplaySystem>());
 
   auto selection_system = engine->CreateSystem<SelectionSystem>();
-  auto object_manager = engine->CreateSystem<ObjectManager>(
-      engine->GetScene().get(), manager.get());
+  auto object_manager =
+      engine->CreateSystem<ObjectManager>(engine->GetScene().get(), manager);
 
   // fix update order
   engine->MoveSystemToBack(displaysys_window);
@@ -132,7 +132,7 @@ std::unique_ptr<Engine> OpticalBenchSetup::CreateOptixEngine(
 
 void OpticalBenchSetup::SetupOptixFrameGraphWindow(
     RenderingSystem* rendering_system, Engine* engine,
-    std::shared_ptr<OptixContextManager> manager) {
+    OptixContextManager* manager) {
   auto frame_graph = std::make_unique<FrameGraph>();
   auto render_target = engine->GetScene()
                            ->GetEntitiesWithComponents<RenderTarget>()[0]
@@ -159,7 +159,7 @@ void OpticalBenchSetup::SetupOptixFrameGraphWindow(
 
 void OpticalBenchSetup::SetupOptixFrameGraphOpenVR(
     RenderingSystem* rendering_system, Engine* engine,
-    std::shared_ptr<OptixContextManager> manager) {
+    OptixContextManager* manager) {
   auto frame_graph = std::make_unique<FrameGraph>();
   auto left_render_target =
       engine->GetScene()
diff --git a/demos/optical_bench/src/optix_engine.hpp b/demos/optical_bench/src/optix_engine.hpp
index a813a954..1ef2a850 100644
--- a/demos/optical_bench/src/optix_engine.hpp
+++ b/demos/optical_bench/src/optix_engine.hpp
@@ -45,14 +45,14 @@ class OpticalBenchSetup {
   // i.e.: RenderingSystem and an InputSystem
   // also creates an empty scene for the engine
   static std::unique_ptr<Engine> CreateOptixEngine(
-      std::shared_ptr<OptixContextManager> manager);
-
-  static void SetupOptixFrameGraphWindow(
-      RenderingSystem* rendering_system, Engine* engine,
-      std::shared_ptr<OptixContextManager> manager);
-  static void SetupOptixFrameGraphOpenVR(
-      RenderingSystem* rendering_system, Engine* engine,
-      std::shared_ptr<OptixContextManager> manager);
+      OptixContextManager* manager);
+
+  static void SetupOptixFrameGraphWindow(RenderingSystem* rendering_system,
+                                         Engine* engine,
+                                         OptixContextManager* manager);
+  static void SetupOptixFrameGraphOpenVR(RenderingSystem* rendering_system,
+                                         Engine* engine,
+                                         OptixContextManager* manager);
 };
 
 }  // namespace phx
diff --git a/demos/optical_bench/src/optix_pass.cpp b/demos/optical_bench/src/optix_pass.cpp
index 12cdf448..f105033f 100644
--- a/demos/optical_bench/src/optix_pass.cpp
+++ b/demos/optical_bench/src/optix_pass.cpp
@@ -42,63 +42,63 @@
 namespace phx {
 
 OptixPass::OptixPass(RenderTarget* render_target, Scene* scene,
-                     std::shared_ptr<OptixContextManager> optixContextManager) {
+                     OptixContextManager* optixContextManager) {
   render_target_right_ = render_target;
   render_target_left_ = nullptr;
   scene_ = scene;
-  optixContextManager_ = optixContextManager;
+  optix_context_manager_ = optixContextManager;
 }
 
 OptixPass::OptixPass(RenderTarget* render_target_left,
                      RenderTarget* render_target_right, Scene* scene,
-                     std::shared_ptr<OptixContextManager> optixContextManager) {
+                     OptixContextManager* optixContextManager) {
   render_target_right_ = render_target_right;
   render_target_left_ = render_target_left;
   scene_ = scene;
-  optixContextManager_ = optixContextManager;
+  optix_context_manager_ = optixContextManager;
 }
 
 OptixPass::~OptixPass() {
   // delete openGL resources
-  glDeleteTextures(1, &textureOpenGLColor);
-  glDeleteBuffers(1, &bufferOpenGLColor);
-  glDeleteTextures(1, &textureOpenGLDepth);
-  glDeleteBuffers(1, &bufferOpenGLDepth);
-  glDeleteBuffers(1, &bufferOpenGLVertices);
-  glDeleteVertexArrays(1, &vaoOpenGL);
+  glDeleteTextures(1, &texture_OpenGL_color_);
+  glDeleteBuffers(1, &buffer_OpenGL_color_);
+  glDeleteTextures(1, &texture_OpenGL_depth_);
+  glDeleteBuffers(1, &buffer_OpenGL_depth_);
+  glDeleteBuffers(1, &buffer_OpenGL_vertices_);
+  glDeleteVertexArrays(1, &vao_OpenGL_);
 
   // delete optix resources
-  bufferOptixColor->destroy();
-  bufferOptixDepth->destroy();
-  optixContextManager_->getContext()->getRayGenerationProgram(0)->destroy();
+  buffer_Optix_color_->destroy();
+  buffer_Optix_depth_->destroy();
+  optix_context_manager_->GetContext()->getRayGenerationProgram(0)->destroy();
 }
 
 void OptixPass::Initialize() {
   dims = glm::uvec2(render_target_right_->GetDimensions());
 
   // create OpenGL Buffers
-  glGenBuffers(1, &bufferOpenGLColor);
-  glGenBuffers(1, &bufferOpenGLDepth);
-  glBindBuffer(GL_ARRAY_BUFFER, bufferOpenGLColor);
+  glGenBuffers(1, &buffer_OpenGL_color_);
+  glGenBuffers(1, &buffer_OpenGL_depth_);
+  glBindBuffer(GL_ARRAY_BUFFER, buffer_OpenGL_color_);
   glBufferData(GL_ARRAY_BUFFER, dims.x * dims.y * sizeof(unsigned char) * 4,
                nullptr,
                GL_STREAM_DRAW);  // BRGA8
-  glBindBuffer(GL_ARRAY_BUFFER, bufferOpenGLDepth);
+  glBindBuffer(GL_ARRAY_BUFFER, buffer_OpenGL_depth_);
   glBufferData(GL_ARRAY_BUFFER, dims.x * dims.y * sizeof(float), nullptr,
                GL_STREAM_DRAW);  // Depth
   glBindBuffer(GL_ARRAY_BUFFER, 0);
 
   // create OpenGL Textures
-  glGenTextures(1, &textureOpenGLColor);
-  glGenTextures(1, &textureOpenGLDepth);
+  glGenTextures(1, &texture_OpenGL_color_);
+  glGenTextures(1, &texture_OpenGL_depth_);
   glActiveTexture(GL_TEXTURE2);
-  glBindTexture(GL_TEXTURE_2D, textureOpenGLColor);
+  glBindTexture(GL_TEXTURE_2D, texture_OpenGL_color_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glActiveTexture(GL_TEXTURE3);
-  glBindTexture(GL_TEXTURE_2D, textureOpenGLDepth);
+  glBindTexture(GL_TEXTURE_2D, texture_OpenGL_depth_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
@@ -109,53 +109,57 @@ void OptixPass::Initialize() {
       -1.0f, 1.0f, 1.0f, 1.0f,  1.0f,  -1.0f,
       -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f,
   };
-  bufferOpenGLVertices = 0;
-  glGenBuffers(1, &bufferOpenGLVertices);
-  glBindBuffer(GL_ARRAY_BUFFER, bufferOpenGLVertices);
+  buffer_OpenGL_vertices_ = 0;
+  glGenBuffers(1, &buffer_OpenGL_vertices_);
+  glBindBuffer(GL_ARRAY_BUFFER, buffer_OpenGL_vertices_);
   glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(float), points, GL_STATIC_DRAW);
 
   // create OpenGL VAO
-  vaoOpenGL = 0;
-  glGenVertexArrays(1, &vaoOpenGL);
-  glBindVertexArray(vaoOpenGL);
+  vao_OpenGL_ = 0;
+  glGenVertexArrays(1, &vao_OpenGL_);
+  glBindVertexArray(vao_OpenGL_);
   glEnableVertexAttribArray(0);
-  glBindBuffer(GL_ARRAY_BUFFER, bufferOpenGLVertices);
+  glBindBuffer(GL_ARRAY_BUFFER, buffer_OpenGL_vertices_);
   glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
   glBindVertexArray(0);
 
   // Color Buffer creation
-  bufferOptixColor = optixContextManager_->getContext()->createBufferFromGLBO(
-      RT_BUFFER_OUTPUT, bufferOpenGLColor);
-  bufferOptixColor->setFormat(RT_FORMAT_BYTE4);
-  bufferOptixColor->setSize(dims.x, dims.y);
-  optixContextManager_->getContext()["result_color"]->set(bufferOptixColor);
-
-  bufferOptixDepth = optixContextManager_->getContext()->createBufferFromGLBO(
-      RT_BUFFER_OUTPUT, bufferOpenGLDepth);
-  bufferOptixDepth->setFormat(RT_FORMAT_FLOAT);
-  bufferOptixDepth->setSize(dims.x, dims.y);
-  optixContextManager_->getContext()["result_depth"]->set(bufferOptixDepth);
-
-  optixContextManager_->getContext()->validate();
-  optixContextManager_->getContext()->compile();
-
-  setUpShaders();
+  buffer_Optix_color_ =
+      optix_context_manager_->GetContext()->createBufferFromGLBO(
+          RT_BUFFER_OUTPUT, buffer_OpenGL_color_);
+  buffer_Optix_color_->setFormat(RT_FORMAT_BYTE4);
+  buffer_Optix_color_->setSize(dims.x, dims.y);
+  optix_context_manager_->GetContext()["result_color"]->set(
+      buffer_Optix_color_);
+
+  buffer_Optix_depth_ =
+      optix_context_manager_->GetContext()->createBufferFromGLBO(
+          RT_BUFFER_OUTPUT, buffer_OpenGL_depth_);
+  buffer_Optix_depth_->setFormat(RT_FORMAT_FLOAT);
+  buffer_Optix_depth_->setSize(dims.x, dims.y);
+  optix_context_manager_->GetContext()["result_depth"]->set(
+      buffer_Optix_depth_);
+
+  optix_context_manager_->GetContext()->validate();
+  optix_context_manager_->GetContext()->compile();
+
+  SetUpShaders();
 }
 
 void OptixPass::Execute() {
-  optixContextManager_->updateCamera(render_target_right_);
-  optixContextManager_->launch(dims.x, dims.y);
-  copyBuffersAndRenderInOpenGL(render_target_right_);
+  optix_context_manager_->UpdateCamera(render_target_right_);
+  optix_context_manager_->Launch(dims.x, dims.y);
+  CopyBuffersAndRenderInOpenGL(render_target_right_);
 
-  if (isHMDRendering()) {
+  if (IsHMDRendering()) {
     dims = render_target_left_->GetDimensions();
-    optixContextManager_->updateCamera(render_target_left_);
-    optixContextManager_->launch(dims.x, dims.y);
-    copyBuffersAndRenderInOpenGL(render_target_left_);
+    optix_context_manager_->UpdateCamera(render_target_left_);
+    optix_context_manager_->Launch(dims.x, dims.y);
+    CopyBuffersAndRenderInOpenGL(render_target_left_);
   }
 }
 
-void OptixPass::setUpShaders() {
+void OptixPass::SetUpShaders() {
   auto vertex_shader =
       ResourceUtils::LoadResourceFromFile<ShaderSource>("shader/plain.vert");
   auto fragment_shader =
@@ -167,30 +171,30 @@ void OptixPass::setUpShaders() {
   shader_program_->Link();
 }
 
-bool OptixPass::isHMDRendering() { return render_target_left_ != nullptr; }
+bool OptixPass::IsHMDRendering() { return render_target_left_ != nullptr; }
 
-void OptixPass::copyBuffersAndRenderInOpenGL(RenderTarget* render_target) {
+void OptixPass::CopyBuffersAndRenderInOpenGL(RenderTarget* render_target) {
   render_target->bind();
 
   // send PBO to texture
   // Color
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, bufferOpenGLColor);
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer_OpenGL_color_);
   glActiveTexture(GL_TEXTURE2);
-  glBindTexture(GL_TEXTURE_2D, textureOpenGLColor);
+  glBindTexture(GL_TEXTURE_2D, texture_OpenGL_color_);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, dims.x, dims.y, 0, GL_BGRA,
                GL_UNSIGNED_BYTE, nullptr);  // BGRA8
   glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
   // Depth
-  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, bufferOpenGLDepth);
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer_OpenGL_depth_);
   glActiveTexture(GL_TEXTURE3);
-  glBindTexture(GL_TEXTURE_2D, textureOpenGLDepth);
+  glBindTexture(GL_TEXTURE_2D, texture_OpenGL_depth_);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_R32F, dims.x, dims.y, 0, GL_RED, GL_FLOAT,
                nullptr);  // Depth
   glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 
   shader_program_->use();
 
-  glBindVertexArray(vaoOpenGL);
+  glBindVertexArray(vao_OpenGL_);
 
   glEnable(GL_DEPTH_TEST);
   glDepthFunc(GL_LESS);
diff --git a/demos/optical_bench/src/optix_pass.hpp b/demos/optical_bench/src/optix_pass.hpp
index 241869d7..25c1450a 100644
--- a/demos/optical_bench/src/optix_pass.hpp
+++ b/demos/optical_bench/src/optix_pass.hpp
@@ -39,10 +39,10 @@ namespace phx {
 class OptixPass : public RenderPass {
  public:
   explicit OptixPass(RenderTarget* render_target, Scene* scene,
-                     std::shared_ptr<OptixContextManager> optixContextManager);
+                     OptixContextManager* optixContextManager);
   explicit OptixPass(RenderTarget* render_target_left,
                      RenderTarget* render_target_right, Scene* scene,
-                     std::shared_ptr<OptixContextManager> optixContextManager);
+                     OptixContextManager* optixContextManager);
   ~OptixPass();
   OptixPass(const OptixPass&) = default;
   OptixPass(OptixPass&&) = default;
@@ -53,26 +53,26 @@ class OptixPass : public RenderPass {
   void Initialize() override;
   void Execute() override;
 
-  void setUpShaders();
+  void SetUpShaders();
 
  private:
   glm::uvec2 dims = {0, 0};
 
-  std::shared_ptr<OptixContextManager> optixContextManager_;
+  OptixContextManager* optix_context_manager_;
 
   RenderTarget* render_target_right_;
   RenderTarget* render_target_left_;
-  optix::Buffer bufferOptixColor;
-  optix::Buffer bufferOptixDepth;
-  GLuint bufferOpenGLColor;
-  GLuint bufferOpenGLDepth;
-  GLuint bufferOpenGLVertices;
-  GLuint vaoOpenGL;
-  GLuint textureOpenGLColor;
-  GLuint textureOpenGLDepth;
-
-  bool isHMDRendering();
-  void copyBuffersAndRenderInOpenGL(RenderTarget* render_target);
+  optix::Buffer buffer_Optix_color_;
+  optix::Buffer buffer_Optix_depth_;
+  GLuint buffer_OpenGL_color_;
+  GLuint buffer_OpenGL_depth_;
+  GLuint buffer_OpenGL_vertices_;
+  GLuint vao_OpenGL_;
+  GLuint texture_OpenGL_color_;
+  GLuint texture_OpenGL_depth_;
+
+  bool IsHMDRendering();
+  void CopyBuffersAndRenderInOpenGL(RenderTarget* render_target);
 
   Scene* scene_;
 
diff --git a/demos/optical_bench/src/ray_pass.cpp b/demos/optical_bench/src/ray_pass.cpp
index dd2b0829..72524506 100644
--- a/demos/optical_bench/src/ray_pass.cpp
+++ b/demos/optical_bench/src/ray_pass.cpp
@@ -53,7 +53,7 @@ SUPPRESS_WARNINGS_END
 #undef CreateWindow
 namespace phx {
 RayPass::RayPass(RenderTarget* render_target, Engine* engine,
-                 std::shared_ptr<OptixContextManager> optixContextManager) {
+                 OptixContextManager* optixContextManager) {
   render_target_right_ = render_target;
   render_target_left_ = nullptr;
   engine_ = engine;
@@ -62,7 +62,7 @@ RayPass::RayPass(RenderTarget* render_target, Engine* engine,
 
 RayPass::RayPass(RenderTarget* render_target_left,
                  RenderTarget* render_target_right, Engine* engine,
-                 std::shared_ptr<OptixContextManager> optixContextManager) {
+                 OptixContextManager* optixContextManager) {
   render_target_right_ = render_target_right;
   render_target_left_ = render_target_left;
   engine_ = engine;
@@ -71,23 +71,23 @@ RayPass::RayPass(RenderTarget* render_target_left,
 
 RayPass::~RayPass() {
   // delete openGL resources
-  glDeleteBuffers(1, &bufferOpenGLLaserVertices);
-  glDeleteBuffers(1, &bufferOpenGLLaserColors);
-  glDeleteVertexArrays(1, &vaoOpenGL);
+  glDeleteBuffers(1, &buffer_OpenGL_laser_vertices_);
+  glDeleteBuffers(1, &buffer_OpenGL_laser_colors_);
+  glDeleteVertexArrays(1, &vao_OpenGL_);
 
-  bufferLaserOptix->destroy();
-  bufferLaserIndexOptix->destroy();
+  buffer_laser_Optix_->destroy();
+  buffer_laser_index_Optix_->destroy();
 
-  targetBuffer->destroy();
-  targetMaxBuffer->destroy();
-  targetGroup->destroy();
-  targetGeometry->destroy();
-  targetTransform->destroy();
-  targetMaterial->destroy();
-  targetAcc->destroy();
-  bufferLaserDirOptix->destroy();
+  target_buffer_->destroy();
+  target_max_buffer_->destroy();
+  target_group_->destroy();
+  target_geometry_->destroy();
+  target_transform_->destroy();
+  target_material_->destroy();
+  target_acceleration_->destroy();
+  buffer_laser_dir_Optix_->destroy();
 
-  free(textureDataBuffer);
+  free(texture_data_buffer_);
 
   delete rod_;
 }
@@ -95,32 +95,32 @@ RayPass::~RayPass() {
 void RayPass::Initialize() {
   auto dims = render_target_right_->GetDimensions();
 
-  bufferOpenGLLaserVertices = 0;
-  glGenBuffers(1, &bufferOpenGLLaserVertices);
+  buffer_OpenGL_laser_vertices_ = 0;
+  glGenBuffers(1, &buffer_OpenGL_laser_vertices_);
 
-  bufferOpenGLLaserColors = 0;
-  glGenBuffers(1, &bufferOpenGLLaserColors);
+  buffer_OpenGL_laser_colors_ = 0;
+  glGenBuffers(1, &buffer_OpenGL_laser_colors_);
 
   // create OpenGL VAO
-  vaoOpenGL = 0;
-  glGenVertexArrays(1, &vaoOpenGL);
-  glBindVertexArray(vaoOpenGL);
+  vao_OpenGL_ = 0;
+  glGenVertexArrays(1, &vao_OpenGL_);
+  glBindVertexArray(vao_OpenGL_);
   glEnableVertexAttribArray(0);  // Vertices
-  glBindBuffer(GL_ARRAY_BUFFER, bufferOpenGLLaserVertices);
+  glBindBuffer(GL_ARRAY_BUFFER, buffer_OpenGL_laser_vertices_);
   glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
   glEnableVertexAttribArray(1);  // Colors
-  glBindBuffer(GL_ARRAY_BUFFER, bufferOpenGLLaserColors);
+  glBindBuffer(GL_ARRAY_BUFFER, buffer_OpenGL_laser_colors_);
   glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL);
 
   glBindVertexArray(0);
 
-  createLaser();
-  createTarget();
-  setUpShaders();
+  CreateLaser();
+  CreateTarget();
+  SetUpShaders();
 
-  glBindBuffer(GL_ARRAY_BUFFER, bufferOpenGLLaserVertices);
+  glBindBuffer(GL_ARRAY_BUFFER, buffer_OpenGL_laser_vertices_);
   glBufferData(GL_ARRAY_BUFFER,
-               laser_max_depth * 50 * 50 * 2 * 3 * sizeof(float), NULL,
+               kLaserMaxDepth_ * 50 * 50 * 2 * 3 * sizeof(float), NULL,
                GL_DYNAMIC_DRAW);
   glBindBuffer(GL_ARRAY_BUFFER, 0);
 
@@ -156,18 +156,18 @@ void RayPass::Initialize() {
 void RayPass::Execute() {
   auto transform =
       laser_object_->GetFirstComponent<phx::Transform>()->GetGlobalMatrix();
-  moveLaser(transform);
+  MoveLaser(transform);
 
-  launchLaser();
+  LaunchLaser();
 
-  render(render_target_right_);
+  Render(render_target_right_);
 
-  if (isHMDRendering()) {
-    render(render_target_left_);
+  if (IsHMDRendering()) {
+    Render(render_target_left_);
   }
 }
 
-void RayPass::setUpShaders() {
+void RayPass::SetUpShaders() {
   auto vertex_shader =
       ResourceUtils::LoadResourceFromFile<ShaderSource>("shader/ray.vert");
   auto fragment_shader =
@@ -184,13 +184,13 @@ void RayPass::setUpShaders() {
   SetLaserRayWidth(0.0025f);
 }
 
-void RayPass::setRayTIR(bool active) {
-  optixContextManager_->getContext()["allowTir"]->setInt(active);
+void RayPass::SetRayTIR(bool active) {
+  optixContextManager_->GetContext()["allowTir"]->setInt(active);
 }
 
-bool RayPass::isHMDRendering() { return render_target_left_ != nullptr; }
+bool RayPass::IsHMDRendering() { return render_target_left_ != nullptr; }
 
-void RayPass::render(RenderTarget* render_target) {
+void RayPass::Render(RenderTarget* render_target) {
   glm::mat4 projectionMatrix = render_target->GetProjection();
   glm::mat4 viewMatrix = render_target->GetView();
 
@@ -203,7 +203,7 @@ void RayPass::render(RenderTarget* render_target) {
   glm::vec4 eye_ = inverse(viewMatrix) * glm::vec4(0, 0, 0, 1);
   shader_program_->SetUniform("camera_position", glm::vec3(eye_) / eye_.w);
 
-  glBindVertexArray(vaoOpenGL);
+  glBindVertexArray(vao_OpenGL_);
 
   glEnable(GL_DEPTH_TEST);
   glDepthFunc(GL_ALWAYS);
@@ -211,7 +211,7 @@ void RayPass::render(RenderTarget* render_target) {
   glEnable(GL_BLEND);
   glBlendFunc(GL_ONE, GL_ONE);
 
-  glDrawArrays(GL_LINES, 0, 50 * 50 * laser_max_depth * 2);
+  glDrawArrays(GL_LINES, 0, 50 * 50 * kLaserMaxDepth_ * 2);
 
   glBindVertexArray(0);
 
@@ -222,70 +222,70 @@ void RayPass::render(RenderTarget* render_target) {
   render_target->unbind();
 }
 
-void RayPass::launchLaser() {
+void RayPass::LaunchLaser() {
   static unsigned int random_seed = 0;
-  optixContextManager_->getContext()["random_frame_seed"]->setUint(
+  optixContextManager_->GetContext()["random_frame_seed"]->setUint(
       random_seed++);  // totally "random" (only used as seed)
   try {
-    optixContextManager_->getContext()->launch(laser_entry, 50, 50,
-                                               laser_traces_per_frame);
+    optixContextManager_->GetContext()->launch(laser_entry_, 50, 50,
+                                               kLaserTracesPerFrame_);
   } catch (optix::Exception e) {
     phx::error(e.getErrorString().c_str());
   }
 
   // copy retrieved intersection data to texture
-  copyAndScaleTargetData();
+  CopyAndScaleTargetData();
 }
 
-void RayPass::createLaser() {
-  auto context = optixContextManager_->getContext();
+void RayPass::CreateLaser() {
+  auto context = optixContextManager_->GetContext();
 
-  context["max_depth_laser"]->setInt(laser_max_depth);
+  context["max_depth_laser"]->setInt(kLaserMaxDepth_);
 
-  laser_entry = context->getEntryPointCount();
-  context->setEntryPointCount(laser_entry + 1);  // Add new Entrypoint
+  laser_entry_ = context->getEntryPointCount();
+  context->setEntryPointCount(laser_entry_ + 1);  // Add new Entrypoint
 
   // Ray generation program
   optix::Program rayProg = context->createProgramFromPTXString(
-      OptixContextManager::getPtxString("laser_caster.cu"), "laser_caster");
-  context->setRayGenerationProgram(laser_entry, rayProg);
+      OptixContextManager::GetPtxString("laser_caster.cu"), "laser_caster");
+  context->setRayGenerationProgram(laser_entry_, rayProg);
 
   optix::Program missProg = context->createProgramFromPTXString(
-      OptixContextManager::getPtxString("miss.cu"), "miss_iterative");
+      OptixContextManager::GetPtxString("miss.cu"), "miss_iterative");
   context->setMissProgram(1, missProg);
 
-  bufferLaserIndexOptix =
+  buffer_laser_index_Optix_ =
       context->createBuffer(RT_BUFFER_INPUT, RT_FORMAT_INT, 50, 50);
 
-  bufferLaserDirOptix =
+  buffer_laser_dir_Optix_ =
       context->createBuffer(RT_BUFFER_INPUT, RT_FORMAT_FLOAT3, 50, 50);
 
-  loadAllPatterns("Rainbow");
+  LoadAllPatterns("Rainbow");
   SetLaserWaveLength(450.0f);
 
   context["allowTir"]->setInt(0);
-  context["laserIndex"]->set(bufferLaserIndexOptix);
-  context["laserDir"]->set(bufferLaserDirOptix);
+  context["laserIndex"]->set(buffer_laser_index_Optix_);
+  context["laserDir"]->set(buffer_laser_dir_Optix_);
 
-  bufferLaserOptix = context->createBufferFromGLBO(RT_BUFFER_OUTPUT,
-                                                   bufferOpenGLLaserVertices);
-  bufferLaserOptix->setFormat(RT_FORMAT_FLOAT3);
-  bufferLaserOptix->setSize(laser_max_depth * 50 * 50 * 2);
-  context["result_laser"]->set(bufferLaserOptix);
+  buffer_laser_Optix_ = context->createBufferFromGLBO(
+      RT_BUFFER_OUTPUT, buffer_OpenGL_laser_vertices_);
+  buffer_laser_Optix_->setFormat(RT_FORMAT_FLOAT3);
+  buffer_laser_Optix_->setSize(kLaserMaxDepth_ * 50 * 50 * 2);
+  context["result_laser"]->set(buffer_laser_Optix_);
 
   context->validate();
   context->compile();
 }
 
-void RayPass::createTarget() {
-  auto context = optixContextManager_->getContext();
+void RayPass::CreateTarget() {
+  auto context = optixContextManager_->GetContext();
 
-  targetEntity = phx::SceneLoader::InsertModelIntoScene(
+  target_entity_ = phx::SceneLoader::InsertModelIntoScene(
       "models/opticalBench/laser/target.obj", engine_->GetScene().get());
-  targetEntity->GetFirstComponent<phx::Transform>()->Translate(
+  target_entity_->GetFirstComponent<phx::Transform>()->Translate(
       glm::vec3(-0.2f, 1.20f, -0.6f));
 
-  auto transform = targetEntity->GetFirstComponent<phx::Transform>();
+  auto transform = target_entity_->GetFirstComponent<phx::Transform>();
   for (auto i = 0u; i < transform->GetChildCount(); i++) {
     auto handle = transform->GetChild(i)
                       ->GetEntity()
@@ -295,17 +295,18 @@ void RayPass::createTarget() {
     }
   }
   target_screen_->GetMaterial()->UploadTextures();
-  target_texture = target_screen_->GetMaterial()->GetAmbientTexture();
+  target_texture_ = target_screen_->GetMaterial()->GetAmbientTexture();
 
   // used to expand the data in RAM and map back to GPU
-  textureDataBuffer =
-      (float*)std::malloc(target_res * target_res * sizeof(float) * 3l);
+  texture_data_buffer_ = (float*)std::malloc(
+      kTargetResolution_ * kTargetResolution_ * sizeof(float) * 3l);
 
-  targetBuffer = context->createBuffer(RT_BUFFER_INPUT_OUTPUT, RT_FORMAT_FLOAT,
-                                       target_res, target_res);
-  targetMaxBuffer =
+  target_buffer_ =
+      context->createBuffer(RT_BUFFER_INPUT_OUTPUT, RT_FORMAT_FLOAT,
+                            kTargetResolution_, kTargetResolution_);
+  target_max_buffer_ =
       context->createBuffer(RT_BUFFER_INPUT_OUTPUT, RT_FORMAT_UNSIGNED_INT, 1);
-  clearTargetBuffers();
+  ClearTargetBuffers();
 
   // Init LUT
   auto lut_img = phx::ResourceUtils::LoadResourceFromFile<phx::Image>(
@@ -314,136 +315,140 @@ void RayPass::createTarget() {
   auto color = lut_img->GetPixelColor({0, 0});
   for (auto i = 0u; i < 256u; i++) {
     color = lut_img->GetPixelColor({i, 0});
-    LUT[i] = glm::vec3((float)color[0] / 255.0f, (float)color[1] / 255.0f,
-                       (float)color[2] / 255.0f);
+    color_lut_[i] =
+        glm::vec3((float)color[0] / 255.0f, (float)color[1] / 255.0f,
+                  (float)color[2] / 255.0f);
   }
 
   // Material
   std::string ptx =
-      OptixContextManager::getPtxString("laser_target_material.cu");
+      OptixContextManager::GetPtxString("laser_target_material.cu");
   optix::Program anyHitP =
       context->createProgramFromPTXString(ptx, "any_hit_radiance");
   optix::Program closeHitI =
       context->createProgramFromPTXString(ptx, "closest_hit_iterative");
 
-  targetMaterial = context->createMaterial();
-  targetMaterial->setAnyHitProgram(0, anyHitP);
-  targetMaterial->setClosestHitProgram(1, closeHitI);
+  target_material_ = context->createMaterial();
+  target_material_->setAnyHitProgram(0, anyHitP);
+  target_material_->setClosestHitProgram(1, closeHitI);
 
   // Geometry
   auto geo = context->createGeometry();
   geo->setPrimitiveCount(1u);
 
-  ptx = OptixContextManager::getPtxString("laser_target.cu");
+  ptx = OptixContextManager::GetPtxString("laser_target.cu");
   geo->setBoundingBoxProgram(
       context->createProgramFromPTXString(ptx, "bounds"));
   geo->setIntersectionProgram(
       context->createProgramFromPTXString(ptx, "intersect"));
 
-  targetTransform = context->createTransform();
-  targetGeometry = context->createGeometryInstance(geo, &targetMaterial,
-                                                   &targetMaterial + 1);
-  targetGroup = context->createGeometryGroup();
-  targetGroup->addChild(targetGeometry);
-  targetAcc = context->createAcceleration("Trbvh");
-  targetGroup->setAcceleration(targetAcc);
+  target_transform_ = context->createTransform();
+  target_geometry_ = context->createGeometryInstance(geo, &target_material_,
+                                                     &target_material_ + 1);
+  target_group_ = context->createGeometryGroup();
+  target_group_->addChild(target_geometry_);
+  target_acceleration_ = context->createAcceleration("Trbvh");
+  target_group_->setAcceleration(target_acceleration_);
 
-  targetGeometry["p1"]->setFloat(0, 0.0275f, 0.0289f);
-  targetGeometry["p2"]->setFloat(-0.129f, 0.08f, 0.0f);
+  target_geometry_["p1"]->setFloat(0, 0.0275f, 0.0289f);
+  target_geometry_["p2"]->setFloat(-0.129f, 0.08f, 0.0f);
 
-  targetGeometry["stretchXY1"]->setFloat(0.05f, 0.05f);
-  targetGeometry["stretchXZ2"]->setFloat(0.155f, 0.155f);
+  target_geometry_["stretchXY1"]->setFloat(0.05f, 0.05f);
+  target_geometry_["stretchXZ2"]->setFloat(0.155f, 0.155f);
 
-  targetGeometry["targetBufferWrite"]->setInt(1);
-  targetGeometry["targetBuffer"]->setBuffer(targetBuffer);
-  targetGeometry["targetBufferMax"]->setBuffer(targetMaxBuffer);
-  targetGeometry["targetBufferDim"]->setFloat((float)target_res,
-                                              (float)target_res);
+  target_geometry_["targetBufferWrite"]->setInt(1);
+  target_geometry_["targetBuffer"]->setBuffer(target_buffer_);
+  target_geometry_["targetBufferMax"]->setBuffer(target_max_buffer_);
+  target_geometry_["targetBufferDim"]->setFloat((float)kTargetResolution_,
+                                                (float)kTargetResolution_);
 
-  targetTransform->setChild<optix::GeometryGroup>(targetGroup);
+  target_transform_->setChild<optix::GeometryGroup>(target_group_);
 
-  optixContextManager_->getTopObject()->addChild(targetTransform);
-  optixContextManager_->getTopObject()->getAcceleration()->markDirty();
+  optixContextManager_->GetTopObject()->addChild(target_transform_);
+  optixContextManager_->GetTopObject()->getAcceleration()->markDirty();
 
-  auto selector = targetEntity->AddComponent<phx::Selector>(targetEntity);
+  auto selector = target_entity_->AddComponent<phx::Selector>(target_entity_);
   selector->SetMove([this](phx::Transform* t, glm::mat4 r) {
-    targetEntity->GetFirstComponent<phx::Transform>()->SetGlobalMatrix(
+    target_entity_->GetFirstComponent<phx::Transform>()->SetGlobalMatrix(
         t->GetGlobalMatrix() * r);
 
     glm::mat4 trans =
-        targetEntity->GetFirstComponent<phx::Transform>()->GetGlobalMatrix();
-    targetTransform->setMatrix(true, &(trans[0][0]), &(inverse(trans)[0][0]));
+        target_entity_->GetFirstComponent<phx::Transform>()->GetGlobalMatrix();
+    target_transform_->setMatrix(true, &(trans[0][0]), &(inverse(trans)[0][0]));
   });
   selector->SetRelease([this]() {
-    if (getTargetBufferWrite()) clearTargetBuffers();
+    if (GetTargetBufferWrite()) ClearTargetBuffers();
   });
 
-  selector->intersection_dist = 1.5f;
+  selector->SetIntersectionDistance(1.5f);
 
-  targetSupportRod = new SupportRod(engine_->GetScene().get(), selector);
+  target_support_rod_ = new SupportRod(engine_->GetScene().get(), selector);
 }
 
-void RayPass::copyAndScaleTargetData() {
+void RayPass::CopyAndScaleTargetData() {
   const static float highlight_color_value = 0.8f;
   const static glm::vec3 highlight_color = glm::vec3(1, 0, 0);
 
   // fetch max
-  float max = (float)*(
-      static_cast<unsigned int*>(targetMaxBuffer->map(0, RT_BUFFER_MAP_READ)));
-  targetMaxBuffer->unmap();
+  float max = (float)*(static_cast<unsigned int*>(
+      target_max_buffer_->map(0, RT_BUFFER_MAP_READ)));
+  target_max_buffer_->unmap();
   if (max == 0) max = 1;
 
   // expand & scale buffer
   float* buffer_data =
-      static_cast<float*>(targetBuffer->map(0, RT_BUFFER_MAP_READ));
+      static_cast<float*>(target_buffer_->map(0, RT_BUFFER_MAP_READ));
 
   float curr_val = 0;
   glm::vec3* curr_color;
   bool tmp = false;
   if (!target_color_mode_) {
-    for (unsigned long i = 0; i < target_res * target_res; i++) {
+    for (unsigned long i = 0; i < kTargetResolution_ * kTargetResolution_;
+         i++) {
       curr_val = buffer_data[i] / max;
       tmp = curr_val >= highlight_color_value;
-      textureDataBuffer[i * 3] = (tmp) ? highlight_color.x : curr_val;
-      textureDataBuffer[i * 3 + 1] = (tmp) ? highlight_color.y : curr_val;
-      textureDataBuffer[i * 3 + 2] = (tmp) ? highlight_color.z : curr_val;
+      texture_data_buffer_[i * 3] = (tmp) ? highlight_color.x : curr_val;
+      texture_data_buffer_[i * 3 + 1] = (tmp) ? highlight_color.y : curr_val;
+      texture_data_buffer_[i * 3 + 2] = (tmp) ? highlight_color.z : curr_val;
     }
   } else {
-    for (unsigned long i = 0; i < target_res * target_res; i++) {
+    for (unsigned long i = 0; i < kTargetResolution_ * kTargetResolution_;
+         i++) {
       curr_val = buffer_data[i] / max;
 
       // LUT
-      curr_color = &LUT[(int)(255.0f * curr_val)];
+      curr_color = &color_lut_[(int)(255.0f * curr_val)];
 
       // color highest values red
-      textureDataBuffer[i * 3] = curr_color->x;
-      textureDataBuffer[i * 3 + 1] = curr_color->y;
-      textureDataBuffer[i * 3 + 2] = curr_color->z;
+      texture_data_buffer_[i * 3] = curr_color->x;
+      texture_data_buffer_[i * 3 + 1] = curr_color->y;
+      texture_data_buffer_[i * 3 + 2] = curr_color->z;
     }
   }
 
-  targetBuffer->unmap();
+  target_buffer_->unmap();
 
   // copy to texture
-  target_texture->set_sub_image(0, 0, 0, target_res, target_res, GL_RGB,
-                                GL_FLOAT, textureDataBuffer);
+  target_texture_->set_sub_image(0, 0, 0, kTargetResolution_,
+                                 kTargetResolution_, GL_RGB, GL_FLOAT,
+                                 texture_data_buffer_);
 }
 
-void RayPass::clearTargetBuffers() {
+void RayPass::ClearTargetBuffers() {
   // null initially
   float* buffer_data =
-      static_cast<float*>(targetBuffer->map(0, RT_BUFFER_MAP_WRITE_DISCARD));
-  for (unsigned long i = 0; i < target_res * target_res; i++) {
+      static_cast<float*>(target_buffer_->map(0, RT_BUFFER_MAP_WRITE_DISCARD));
+  for (unsigned long i = 0; i < kTargetResolution_ * kTargetResolution_; i++) {
     buffer_data[i] = 0.0f;
   }
-  targetBuffer->unmap();
+  target_buffer_->unmap();
 
-  *(static_cast<float*>(targetMaxBuffer->map(0, RT_BUFFER_MAP_WRITE_DISCARD))) =
-      0.0f;
-  targetMaxBuffer->unmap();
+  *(static_cast<float*>(
+      target_max_buffer_->map(0, RT_BUFFER_MAP_WRITE_DISCARD))) = 0.0f;
+  target_max_buffer_->unmap();
 }
 
-void RayPass::moveLaser(glm::mat4 transform) {
+void RayPass::MoveLaser(glm::mat4 transform) {
   glm::vec4 ori_ = transform * glm::vec4(0, 0, 0, 1);
   glm::vec3 ori = ori_ / ori_.w;
 
@@ -454,16 +459,16 @@ void RayPass::moveLaser(glm::mat4 transform) {
 
   ori += 0.03626f * forward;  // Center at beginning of "front"
 
-  moveLaser(ori, forward, right, up, mat_rot);
+  MoveLaser(ori, forward, right, up, mat_rot);
 }
 
-void RayPass::moveLaser(glm::vec3 pos, glm::vec3 forward, glm::vec3 right,
+void RayPass::MoveLaser(glm::vec3 pos, glm::vec3 forward, glm::vec3 right,
                         glm::vec3 up, glm::mat3 rot_mat) {
   forward = normalize(forward);
   right = normalize(right);
   up = normalize(up);
 
-  auto context = optixContextManager_->getContext();
+  auto context = optixContextManager_->GetContext();
   context["laser_origin"]->setFloat(pos.x, pos.y, pos.z);
   context["laser_forward"]->setFloat(forward.x, forward.y, forward.z);
   context["laser_right"]->setFloat(right.x, right.y, right.z);
@@ -472,7 +477,7 @@ void RayPass::moveLaser(glm::vec3 pos, glm::vec3 forward, glm::vec3 right,
   context["laser_rot"]->setMatrix3x3fv(true, &rot_mat[0][0]);
 }
 
-void RayPass::moveLaserObj(glm::vec3 pos) {
+void RayPass::MoveLaserObject(glm::vec3 pos) {
   glm::vec3 f = glm::mat3(laser_object_->GetFirstComponent<phx::Transform>()
                               ->GetGlobalMatrix()) *
                 glm::vec3(0, 0, -1);
@@ -483,16 +488,16 @@ void RayPass::moveLaserObj(glm::vec3 pos) {
 }
 
 void RayPass::SetLaserRayWidth(float width) {
-  optixContextManager_->getContext()["laserBeamWidth"]->setFloat(width);
+  optixContextManager_->GetContext()["laserBeamWidth"]->setFloat(width);
   // min needed to not make rays invisible
   shader_program_->SetUniform("line_thickness", glm::max(width, 0.001f));
 }
 
 void RayPass::SetLaserPattern(unsigned int index) {
   current_pattern_index_ = index % patterns_.size();
-  bufferLaserColors(patterns_[current_pattern_index_]);
-  bufferLaserIndex(patterns_[current_pattern_index_]);
-  bufferLaserDirection(patterns_dir_[current_pattern_index_]);
+  BufferLaserColors(patterns_[current_pattern_index_]);
+  BufferLaserIndex(patterns_[current_pattern_index_]);
+  BufferLaserDirection(patterns_dir_[current_pattern_index_]);
 }
 
 void RayPass::NextLaserPattern() {
@@ -504,17 +509,17 @@ void RayPass::PreviousLaserPattern() {
 }
 
 std::string RayPass::GetCurrentPatternName() {
-  return pattern_files_[current_pattern_index_];
+  return kPatternFiles_[current_pattern_index_];
 }
 
-void RayPass::bufferLaserColors(phx::ResourcePointer<phx::Image> image) {
+void RayPass::BufferLaserColors(phx::ResourcePointer<phx::Image> image) {
   std::array<size_t, 2> dims = {50, 50};
   if (image->GetDimensions() != dims) {
     phx::warn("Only 50x50px laser pattern are allowed. Skipping.");
     return;
   }
 
-  unsigned int depth = laser_max_depth * 2;
+  unsigned int depth = kLaserMaxDepth_ * 2;
 
   const unsigned int buffer_size = 50 * 50 * 3 * depth;
   float* buffer = (float*)malloc(buffer_size * sizeof(float));
@@ -532,7 +537,7 @@ void RayPass::bufferLaserColors(phx::ResourcePointer<phx::Image> image) {
     }
   }
 
-  glBindBuffer(GL_ARRAY_BUFFER, bufferOpenGLLaserColors);
+  glBindBuffer(GL_ARRAY_BUFFER, buffer_OpenGL_laser_colors_);
   glBufferData(GL_ARRAY_BUFFER, buffer_size * sizeof(float), buffer,
                GL_STATIC_DRAW);
   glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ -540,7 +545,7 @@ void RayPass::bufferLaserColors(phx::ResourcePointer<phx::Image> image) {
   free(buffer);
 }  // namespace phx
 
-void RayPass::bufferLaserIndex(phx::ResourcePointer<phx::Image> image) {
+void RayPass::BufferLaserIndex(phx::ResourcePointer<phx::Image> image) {
   std::array<size_t, 2> dims = {50, 50};
   if (image->GetDimensions() != dims) {
     phx::warn("Only 50x50px laser pattern are allowed. Skipping.");
@@ -549,7 +554,7 @@ void RayPass::bufferLaserIndex(phx::ResourcePointer<phx::Image> image) {
 
   // Create buffer and populate with data
   int* buffer_data = static_cast<int*>(
-      bufferLaserIndexOptix->map(0, RT_BUFFER_MAP_WRITE_DISCARD));
+      buffer_laser_index_Optix_->map(0, RT_BUFFER_MAP_WRITE_DISCARD));
 
   for (unsigned int i = 0; i < dims[0]; ++i) {
     for (unsigned int j = 0; j < dims[1]; ++j) {
@@ -565,10 +570,10 @@ void RayPass::bufferLaserIndex(phx::ResourcePointer<phx::Image> image) {
     }
   }
 
-  bufferLaserIndexOptix->unmap();
+  buffer_laser_index_Optix_->unmap();
 }
 
-void RayPass::bufferLaserDirection(phx::ResourcePointer<phx::Image> image) {
+void RayPass::BufferLaserDirection(phx::ResourcePointer<phx::Image> image) {
   std::array<size_t, 2> dims = {50, 50};
   if (image->GetDimensions() != dims) {
     phx::warn("Only 50x50px laser pattern are allowed. Skipping.");
@@ -577,7 +582,7 @@ void RayPass::bufferLaserDirection(phx::ResourcePointer<phx::Image> image) {
 
   // Create buffer and populate with data
   float* buffer_data = static_cast<float*>(
-      bufferLaserDirOptix->map(0, RT_BUFFER_MAP_WRITE_DISCARD));
+      buffer_laser_dir_Optix_->map(0, RT_BUFFER_MAP_WRITE_DISCARD));
 
   for (size_t x = 0; x < dims[0]; x++) {
     for (size_t y = 0; y < dims[1]; y++) {
@@ -591,21 +596,21 @@ void RayPass::bufferLaserDirection(phx::ResourcePointer<phx::Image> image) {
     }
   }
 
-  bufferLaserDirOptix->unmap();
+  buffer_laser_dir_Optix_->unmap();
 }
 
-void RayPass::loadAllPatterns(std::string use_directly) {
-  for (auto i = 0u; i < pattern_files_.size(); i++) {
+void RayPass::LoadAllPatterns(std::string use_directly) {
+  for (auto i = 0u; i < kPatternFiles_.size(); i++) {
     auto image = phx::ResourceUtils::LoadResourceFromFile<phx::Image>(
-        "laser/pattern/" + pattern_files_[i] + ".png");
+        "laser/pattern/" + kPatternFiles_[i] + ".png");
     auto image_dir = phx::ResourceUtils::LoadResourceFromFile<phx::Image>(
-        "laser/pattern/" + pattern_files_[i] + "_dir.png");
+        "laser/pattern/" + kPatternFiles_[i] + "_dir.png");
     patterns_.push_back(image);
     patterns_dir_.push_back(image_dir);
-    if (pattern_files_[i].compare(use_directly) == 0) {
-      bufferLaserColors(image);
-      bufferLaserIndex(image);
-      bufferLaserDirection(image_dir);
+    if (kPatternFiles_[i].compare(use_directly) == 0) {
+      BufferLaserColors(image);
+      BufferLaserIndex(image);
+      BufferLaserDirection(image_dir);
       current_pattern_index_ = i;
     }
   }
diff --git a/demos/optical_bench/src/ray_pass.hpp b/demos/optical_bench/src/ray_pass.hpp
index 2b43f94d..3a9a177f 100644
--- a/demos/optical_bench/src/ray_pass.hpp
+++ b/demos/optical_bench/src/ray_pass.hpp
@@ -42,10 +42,10 @@ namespace phx {
 class RayPass : public RenderPass {
  public:
   explicit RayPass(RenderTarget* render_target, Engine* engine,
-                   std::shared_ptr<OptixContextManager> optixContextManager);
+                   OptixContextManager* optixContextManager);
   explicit RayPass(RenderTarget* render_target_left,
                    RenderTarget* render_target_right, Engine* engine,
-                   std::shared_ptr<OptixContextManager> optixContextManager);
+                   OptixContextManager* optixContextManager);
   ~RayPass();
   RayPass(const RayPass&) = default;
   RayPass(RayPass&&) = default;
@@ -56,37 +56,33 @@ class RayPass : public RenderPass {
   void Initialize() override;
   void Execute() override;
 
-  void setUpShaders();
-  void setRayTIR(bool active);
+  void SetUpShaders();
+  void SetRayTIR(bool active);
   bool GetRayTIR() {
-    return optixContextManager_->getContext()["allowTir"]->getInt();
+    return optixContextManager_->GetContext()["allowTir"]->getInt();
   };
-  bool getTargetBufferWrite() {
-    return targetGeometry["targetBufferWrite"]->getInt();
+  bool GetTargetBufferWrite() {
+    return target_geometry_["targetBufferWrite"]->getInt();
   };
-  void setTargetBufferWrite(bool a) {
-    targetGeometry["targetBufferWrite"]->setInt(a);
+  void SetTargetBufferWrite(bool a) {
+    target_geometry_["targetBufferWrite"]->setInt(a);
   };
   void ToggleTargetColorMode() { target_color_mode_ = !target_color_mode_; }
   bool GetTargetColorMode() { return target_color_mode_; }
 
-  void launchLaser();
-  void moveLaser(glm::mat4 transform);
-  void moveLaser(glm::vec3 pos, glm::vec3 forward, glm::vec3 right,
-                 glm::vec3 up, glm::mat3 rot_mat);
-  void moveLaserObj(glm::vec3 pos);
-  unsigned int GetLaserMaxDepth() { return laser_max_depth; }
+  void MoveLaserObject(glm::vec3 pos);
+  unsigned int GetLaserMaxDepth() { return kLaserMaxDepth_; }
 
   // Ray Parameter
   void SetLaserRayWidth(float width);
   float GetLaserRayWidth() {
-    return optixContextManager_->getContext()["laserBeamWidth"]->getFloat();
+    return optixContextManager_->GetContext()["laserBeamWidth"]->getFloat();
   };
   void SetLaserWaveLength(float wavelength) {
-    optixContextManager_->getContext()["laserWaveLength"]->setFloat(wavelength);
+    optixContextManager_->GetContext()["laserWaveLength"]->setFloat(wavelength);
   };
   float GetLaserWaveLength() {
-    return optixContextManager_->getContext()["laserWaveLength"]->getFloat();
+    return optixContextManager_->GetContext()["laserWaveLength"]->getFloat();
   };
 
   size_t GetMaxNumberOfLaserPatterns() { return patterns_.size(); }
@@ -96,36 +92,41 @@ class RayPass : public RenderPass {
 
   std::string GetCurrentPatternName();
 
-  void clearTargetBuffers();
+  void ClearTargetBuffers();
 
  private:
-  const unsigned int laser_max_depth = 20;
-  const std::vector<std::string> pattern_files_ = {"Crosshair", "Pointer",
+  void LaunchLaser();
+  void MoveLaser(glm::mat4 transform);
+  void MoveLaser(glm::vec3 pos, glm::vec3 forward, glm::vec3 right,
+                 glm::vec3 up, glm::mat3 rot_mat);
+
+  const unsigned int kLaserMaxDepth_ = 20;
+  const std::vector<std::string> kPatternFiles_ = {"Crosshair", "Pointer",
                                                    "Rainbow", "RayTest"};
 
   Engine* engine_;
-  std::shared_ptr<OptixContextManager> optixContextManager_;
+  OptixContextManager* optixContextManager_;
 
-  bool isHMDRendering();
+  bool IsHMDRendering();
 
   // For Laser Rendering
   RenderTarget* render_target_right_;
   RenderTarget* render_target_left_;
-  GLuint bufferOpenGLLaserVertices;
-  GLuint bufferOpenGLLaserColors;
-  GLuint vaoOpenGL;
+  GLuint buffer_OpenGL_laser_vertices_;
+  GLuint buffer_OpenGL_laser_colors_;
+  GLuint vao_OpenGL_;
   std::shared_ptr<ShaderProgram> shader_program_;
 
-  optix::Buffer bufferLaserOptix;
-  optix::Buffer bufferLaserIndexOptix;
-  optix::Buffer bufferLaserDirOptix;
-  unsigned int laser_entry;
+  optix::Buffer buffer_laser_Optix_;
+  optix::Buffer buffer_laser_index_Optix_;
+  optix::Buffer buffer_laser_dir_Optix_;
+  unsigned int laser_entry_;
 
-  void render(RenderTarget* render_target);
-  void bufferLaserColors(phx::ResourcePointer<phx::Image> image);
-  void bufferLaserIndex(phx::ResourcePointer<phx::Image> image);
-  void bufferLaserDirection(phx::ResourcePointer<phx::Image> image);
-  void loadAllPatterns(std::string use_directly);
+  void Render(RenderTarget* render_target);
+  void BufferLaserColors(phx::ResourcePointer<phx::Image> image);
+  void BufferLaserIndex(phx::ResourcePointer<phx::Image> image);
+  void BufferLaserDirection(phx::ResourcePointer<phx::Image> image);
+  void LoadAllPatterns(std::string use_directly);
 
   std::vector<phx::ResourcePointer<phx::Image>> patterns_;
   std::vector<phx::ResourcePointer<phx::Image>> patterns_dir_;
@@ -133,31 +134,31 @@ class RayPass : public RenderPass {
 
   // target buffer
   // The resource image needs to be adjusted to set the right texture resolution
-  const unsigned long target_res = 512l;
-  optix::Buffer targetBuffer;
-  optix::Buffer targetMaxBuffer;
+  const unsigned long kTargetResolution_ = 512l;
+  optix::Buffer target_buffer_;
+  optix::Buffer target_max_buffer_;
   bool target_color_mode_ = false;  // false = grey, true = LUT
-  std::array<glm::vec3, 256u> LUT;
+  std::array<glm::vec3, 256u> color_lut_;
 
   // target object
-  void createTarget();
-  optix::GeometryGroup targetGroup;
-  optix::GeometryInstance targetGeometry;
-  optix::Transform targetTransform;
-  optix::Material targetMaterial;
-  optix::Acceleration targetAcc;
-  gl::texture_2d* target_texture;
+  void CreateTarget();
+  optix::GeometryGroup target_group_;
+  optix::GeometryInstance target_geometry_;
+  optix::Transform target_transform_;
+  optix::Material target_material_;
+  optix::Acceleration target_acceleration_;
+  gl::texture_2d* target_texture_;
   phx::MaterialHandle* target_screen_;
-  phx::Entity* targetEntity;
-  SupportRod* targetSupportRod;
-  const unsigned int laser_traces_per_frame = 300u;
+  phx::Entity* target_entity_;
+  SupportRod* target_support_rod_;
+  const unsigned int kLaserTracesPerFrame_ = 300u;
 
   // used to copy and expand data
-  float* textureDataBuffer = nullptr;
-  void copyAndScaleTargetData();
+  float* texture_data_buffer_ = nullptr;
+  void CopyAndScaleTargetData();
 
   // laser object
-  void createLaser();
+  void CreateLaser();
   phx::Entity* laser_object_;
   SupportRod* rod_;
 };
diff --git a/demos/optical_bench/src/rotation_helper.cpp b/demos/optical_bench/src/rotation_helper.cpp
index 914ce423..9d5ec74e 100644
--- a/demos/optical_bench/src/rotation_helper.cpp
+++ b/demos/optical_bench/src/rotation_helper.cpp
@@ -21,51 +21,52 @@ SUPPRESS_WARNINGS_BEGIN
 SUPPRESS_WARNINGS_END
 
 RotationHelper::RotationHelper(phx::Scene* scene) {
-  horizontal_disk = phx::SceneLoader::InsertModelIntoScene(
+  horizontal_disk_ = phx::SceneLoader::InsertModelIntoScene(
       "models/opticalBench/scale/Scale.obj", scene);
-  horizontal_disk->GetFirstComponent<phx::Transform>()->Rotate(
+  horizontal_disk_->GetFirstComponent<phx::Transform>()->Rotate(
       glm::vec3(0, -glm::pi<float>() / 2, 0));
 
-  vertical_disk = phx::SceneLoader::InsertModelIntoScene(
+  vertical_disk_ = phx::SceneLoader::InsertModelIntoScene(
       "models/opticalBench/scale/Scale.obj", scene);
-  vertical_disk->GetFirstComponent<phx::Transform>()->Rotate(
+  vertical_disk_->GetFirstComponent<phx::Transform>()->Rotate(
       glm::vec3(glm::pi<float>() / 2, -glm::pi<float>() / 2, 0));
 
   root_ = scene->CreateEntity();
   root_->SetName("RotationHelper");
   auto root_t = root_->AddComponent<phx::Transform>();
 
-  horizontal_rod = loadAndInsertMesh(
+  horizontal_rod_ = LoadAndInsertMesh(
       scene, "models/opticalBench/scale/ArmH.obj", "arm_horiz");
-  horizontal_rod->GetFirstComponent<phx::Transform>()->SetLocalScale(
+  horizontal_rod_->GetFirstComponent<phx::Transform>()->SetLocalScale(
       glm::vec3(0.3f, 1, 1));
-  vertical_rod = loadAndInsertMesh(scene, "models/opticalBench/scale/ArmV.obj",
-                                   "arm_vert");
-  vertical_rod->GetFirstComponent<phx::Transform>()->SetLocalScale(
+  vertical_rod_ = LoadAndInsertMesh(scene, "models/opticalBench/scale/ArmV.obj",
+                                    "arm_vert");
+  vertical_rod_->GetFirstComponent<phx::Transform>()->SetLocalScale(
       glm::vec3(1, 0.3f, 1));
-  horizontal_rod_ball = loadAndInsertMesh(
+  horizontal_rod_ball_ = LoadAndInsertMesh(
       scene, "models/opticalBench/scale/GrabBallH.obj", "ball_horiz");
-  horizontal_rod_ball->GetFirstComponent<phx::Transform>()->SetLocalScale(
+  horizontal_rod_ball_->GetFirstComponent<phx::Transform>()->SetLocalScale(
       glm::vec3(0.05f));
-  vertical_rod_ball = loadAndInsertMesh(
+  vertical_rod_ball_ = LoadAndInsertMesh(
       scene, "models/opticalBench/scale/GrabBallV.obj", "ball_vert");
-  vertical_rod_ball->GetFirstComponent<phx::Transform>()->SetLocalScale(
+  vertical_rod_ball_->GetFirstComponent<phx::Transform>()->SetLocalScale(
       glm::vec3(0.05f));
 
-  vertical_rod_ball->AddComponent<phx::Selector>(vertical_rod_ball, false);
-  horizontal_rod_ball->AddComponent<phx::Selector>(horizontal_rod_ball, false);
-  horizontal_rod_ball->GetFirstComponent<phx::Transform>()->Translate(
+  vertical_rod_ball_->AddComponent<phx::Selector>(vertical_rod_ball_, false);
+  horizontal_rod_ball_->AddComponent<phx::Selector>(horizontal_rod_ball_,
+                                                    false);
+  horizontal_rod_ball_->GetFirstComponent<phx::Transform>()->Translate(
       glm::vec3(0.3f, 0, 0));
-  vertical_rod_ball->GetFirstComponent<phx::Transform>()->Translate(
+  vertical_rod_ball_->GetFirstComponent<phx::Transform>()->Translate(
       glm::vec3(0, 0.3f, 0));
 
   // glue components together
-  horizontal_disk->GetFirstComponent<phx::Transform>()->SetParent(root_t);
-  vertical_disk->GetFirstComponent<phx::Transform>()->SetParent(root_t);
-  horizontal_rod->GetFirstComponent<phx::Transform>()->SetParent(root_t);
-  vertical_rod->GetFirstComponent<phx::Transform>()->SetParent(root_t);
-  vertical_rod_ball->GetFirstComponent<phx::Transform>()->SetParent(root_t);
-  horizontal_rod_ball->GetFirstComponent<phx::Transform>()->SetParent(root_t);
+  horizontal_disk_->GetFirstComponent<phx::Transform>()->SetParent(root_t);
+  vertical_disk_->GetFirstComponent<phx::Transform>()->SetParent(root_t);
+  horizontal_rod_->GetFirstComponent<phx::Transform>()->SetParent(root_t);
+  vertical_rod_->GetFirstComponent<phx::Transform>()->SetParent(root_t);
+  vertical_rod_ball_->GetFirstComponent<phx::Transform>()->SetParent(root_t);
+  horizontal_rod_ball_->GetFirstComponent<phx::Transform>()->SetParent(root_t);
 
   // text nodes
   horizontal_text_ = scene->CreateEntity();
@@ -73,7 +74,7 @@ RotationHelper::RotationHelper(phx::Scene* scene) {
   auto text_node_h = horizontal_text_->AddComponent<phx::Text>("", 0.0125f);
   text_trans_h->SetLocalTranslation(glm::vec3(0, 1, 0));
   text_trans_h->SetParent(
-      horizontal_rod_ball->GetFirstComponent<phx::Transform>(), false);
+      horizontal_rod_ball_->GetFirstComponent<phx::Transform>(), false);
   text_node_h->SetManualUpdate([root_t, text_node_h, this]() {
     static char deg[] = "000�";
     float degr = -glm::degrees(angle_horizontal_);
@@ -88,7 +89,7 @@ RotationHelper::RotationHelper(phx::Scene* scene) {
   auto text_node_v = vertical_text_->AddComponent<phx::Text>("", 0.0125f);
   text_trans_v->SetLocalTranslation(glm::vec3(0, 1, 0));
   text_trans_v->SetParent(
-      vertical_rod_ball->GetFirstComponent<phx::Transform>(), false);
+      vertical_rod_ball_->GetFirstComponent<phx::Transform>(), false);
   text_node_v->SetManualUpdate([root_t, text_node_v, this]() {
     static char deg[] = "000�";
     float degr = glm::degrees(angle_vertical_);
@@ -99,29 +100,29 @@ RotationHelper::RotationHelper(phx::Scene* scene) {
   text_node_v->SetBillboard(true);
 
   // selector functions
-  auto select_h = horizontal_rod_ball->GetFirstComponent<phx::Selector>();
+  auto select_h = horizontal_rod_ball_->GetFirstComponent<phx::Selector>();
   select_h->SetMove([this, text_node_h](phx::Transform* t, glm::mat4 r) {
     auto root_pos = parent_->GetGlobalTranslation();
 
     auto pos_h = glm::vec3((t->GetGlobalMatrix() * r)[3]);
     pos_h.y = root_pos.y;
-    horizontal_rod_ball->GetFirstComponent<phx::Transform>()
+    horizontal_rod_ball_->GetFirstComponent<phx::Transform>()
         ->SetGlobalTranslation(pos_h);
 
     angle_horizontal_ = -glm::atan(pos_h.z - root_pos.z, pos_h.x - root_pos.x);
 
-    horizontal_rod->GetFirstComponent<phx::Transform>()->SetLocalScale(
+    horizontal_rod_->GetFirstComponent<phx::Transform>()->SetLocalScale(
         glm::vec3(length(pos_h - root_pos), 1, 1));
 
-    horizontal_rod->GetFirstComponent<phx::Transform>()->SetLocalRotation(
+    horizontal_rod_->GetFirstComponent<phx::Transform>()->SetLocalRotation(
         glm::vec3(0, angle_horizontal_, 0));
 
-    vertical_disk->GetFirstComponent<phx::Transform>()->SetLocalRotation(
+    vertical_disk_->GetFirstComponent<phx::Transform>()->SetLocalRotation(
         glm::vec3(glm::pi<float>() / 2,
                   -glm::pi<float>() / 2 + angle_horizontal_, 0));
 
     // update vertical balls position and rod
-    auto v_ball_trans = vertical_rod_ball->GetFirstComponent<phx::Transform>();
+    auto v_ball_trans = vertical_rod_ball_->GetFirstComponent<phx::Transform>();
     glm::vec3 new_ball_pos =
         glm::vec3(0, sin(-angle_vertical_ + glm::pi<float>() / 2),
                   cos(-angle_vertical_ + glm::pi<float>() / 2)) *
@@ -129,7 +130,7 @@ RotationHelper::RotationHelper(phx::Scene* scene) {
     new_ball_pos = rotateY(new_ball_pos, angle_horizontal_);
     v_ball_trans->SetLocalTranslation(new_ball_pos);
 
-    vertical_rod->GetFirstComponent<phx::Transform>()->SetLocalRotation(
+    vertical_rod_->GetFirstComponent<phx::Transform>()->SetLocalRotation(
         glm::vec3(angle_vertical_, angle_horizontal_, 0));
 
     // update parents
@@ -140,7 +141,7 @@ RotationHelper::RotationHelper(phx::Scene* scene) {
     text_node_h->ManualUpdate();
   });
 
-  auto select_v = vertical_rod_ball->GetFirstComponent<phx::Selector>();
+  auto select_v = vertical_rod_ball_->GetFirstComponent<phx::Selector>();
   select_v->SetMove([this, text_node_v](phx::Transform* t, glm::mat4 r) {
     auto root_pos = parent_->GetGlobalTranslation();
     auto pos_v = glm::vec3((t->GetGlobalMatrix() * r)[3]);
@@ -156,13 +157,13 @@ RotationHelper::RotationHelper(phx::Scene* scene) {
     angle_vertical_ =
         -glm::atan(position_YZ.y, position_YZ.z) + glm::pi<float>() / 2;
 
-    vertical_rod_ball->GetFirstComponent<phx::Transform>()
+    vertical_rod_ball_->GetFirstComponent<phx::Transform>()
         ->SetGlobalTranslation(pos_v);
 
-    vertical_rod->GetFirstComponent<phx::Transform>()->SetLocalRotation(
+    vertical_rod_->GetFirstComponent<phx::Transform>()->SetLocalRotation(
         glm::vec3(angle_vertical_, angle_horizontal_, 0));
 
-    vertical_rod->GetFirstComponent<phx::Transform>()->SetLocalScale(
+    vertical_rod_->GetFirstComponent<phx::Transform>()->SetLocalScale(
         glm::vec3(1, length(pos_v - root_pos), 1));
 
     // update parents
@@ -191,23 +192,24 @@ void RotationHelper::SetParent(phx::Transform* parent) {
 
   root_->GetFirstComponent<phx::Transform>()->SetParent(parent, false);
 
-  horizontal_rod_ball->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
-      glm::rotateY(glm::vec3(0.3f, 0, 0), angle_horizontal_));
-  vertical_rod_ball->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
+  horizontal_rod_ball_->GetFirstComponent<phx::Transform>()
+      ->SetLocalTranslation(
+          glm::rotateY(glm::vec3(0.3f, 0, 0), angle_horizontal_));
+  vertical_rod_ball_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
       glm::rotateY(glm::rotateX(glm::vec3(0, 0.3f, 0), angle_vertical_),
                    angle_horizontal_));
   root_->GetFirstComponent<phx::Transform>()->SetGlobalRotation(glm::vec3(0));
-  vertical_disk->GetFirstComponent<phx::Transform>()->SetLocalRotation(
+  vertical_disk_->GetFirstComponent<phx::Transform>()->SetLocalRotation(
       glm::vec3(glm::pi<float>() / 2, -glm::pi<float>() / 2 + angle_horizontal_,
                 0));
 
-  horizontal_rod->GetFirstComponent<phx::Transform>()->SetLocalScale(
+  horizontal_rod_->GetFirstComponent<phx::Transform>()->SetLocalScale(
       glm::vec3(0.3f, 1, 1));
-  horizontal_rod->GetFirstComponent<phx::Transform>()->SetLocalRotation(
+  horizontal_rod_->GetFirstComponent<phx::Transform>()->SetLocalRotation(
       glm::vec3(0, angle_horizontal_, 0));
-  vertical_rod->GetFirstComponent<phx::Transform>()->SetLocalRotation(
+  vertical_rod_->GetFirstComponent<phx::Transform>()->SetLocalRotation(
       glm::vec3(angle_vertical_, angle_horizontal_, 0));
-  vertical_rod->GetFirstComponent<phx::Transform>()->SetLocalScale(
+  vertical_rod_->GetFirstComponent<phx::Transform>()->SetLocalScale(
       glm::vec3(1, 0.3f, 1));
 
   horizontal_text_->GetFirstComponent<phx::Text>()->ManualUpdate();
@@ -215,10 +217,10 @@ void RotationHelper::SetParent(phx::Transform* parent) {
 }
 
 bool RotationHelper::SelectablePartOf(phx::Entity* o) {
-  return o == horizontal_rod_ball || o == vertical_rod_ball;
+  return o == horizontal_rod_ball_ || o == vertical_rod_ball_;
 }
 
-phx::Entity* RotationHelper::loadAndInsertMesh(phx::Scene* scene,
+phx::Entity* RotationHelper::LoadAndInsertMesh(phx::Scene* scene,
                                                std::string file,
                                                std::string name) {
   auto model = phx::ResourceUtils::LoadResourceFromFile<phx::Model>(file);
diff --git a/demos/optical_bench/src/rotation_helper.hpp b/demos/optical_bench/src/rotation_helper.hpp
index 13f55145..4fb6b746 100644
--- a/demos/optical_bench/src/rotation_helper.hpp
+++ b/demos/optical_bench/src/rotation_helper.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_ROTATION_HELPER_HPP_
+#define OPTICAL_BENCH_ROTATION_HELPER_HPP_
 
 #include "object_support_rod.hpp"
 
@@ -27,12 +28,12 @@ class RotationHelper {
   bool SelectablePartOf(phx::Entity* o);
 
  private:
-  phx::Entity* horizontal_disk;
-  phx::Entity* vertical_disk;
-  phx::Entity* horizontal_rod;
-  phx::Entity* vertical_rod;
-  phx::Entity* horizontal_rod_ball;
-  phx::Entity* vertical_rod_ball;
+  phx::Entity* horizontal_disk_;
+  phx::Entity* vertical_disk_;
+  phx::Entity* horizontal_rod_;
+  phx::Entity* vertical_rod_;
+  phx::Entity* horizontal_rod_ball_;
+  phx::Entity* vertical_rod_ball_;
   phx::Entity* vertical_text_;
   phx::Entity* horizontal_text_;
   phx::Entity* root_;
@@ -41,6 +42,8 @@ class RotationHelper {
   float angle_horizontal_ = 0;
   float angle_vertical_ = 0;
 
-  phx::Entity* loadAndInsertMesh(phx::Scene* scene, std::string file,
+  phx::Entity* LoadAndInsertMesh(phx::Scene* scene, std::string file,
                                  std::string name);
 };
+
+#endif  // OPTICAL_BENCH_ROTATION_HELPER_HPP_
diff --git a/demos/optical_bench/src/selection_system.cpp b/demos/optical_bench/src/selection_system.cpp
index 99277ded..1bd8bb58 100644
--- a/demos/optical_bench/src/selection_system.cpp
+++ b/demos/optical_bench/src/selection_system.cpp
@@ -45,7 +45,7 @@ SUPPRESS_WARNINGS_END
 #include "phx/rendering/components/transform.hpp"
 
 SelectionSystem::SelectionSystem(phx::Engine* engine) : phx::System(engine) {
-  intersection_thread_ = std::thread(&SelectionSystem::intersectThread, this);
+  intersection_thread_ = std::thread(&SelectionSystem::IntersectionThreadFunction, this);
 }
 
 SelectionSystem::~SelectionSystem() {}
@@ -140,7 +140,7 @@ float SelectionSystem::GetIntersectionDistance() {
   return res;
 }
 
-void SelectionSystem::intersectThread() {
+void SelectionSystem::IntersectionThreadFunction() {
   std::vector<phx::Entity*> entities;
   glm::vec3 ori;
   glm::vec3 dir;
@@ -160,10 +160,10 @@ void SelectionSystem::intersectThread() {
 
     for (auto i = 0u; i < entities.size(); ++i) {
       curr = entities[i]->GetFirstComponent<phx::Selector>();
-      current_intersection = curr->intersect(ori, dir);
+      current_intersection = curr->Intersect(ori, dir);
 
       if (current_intersection >= 0.0f &&
-          current_intersection < curr->intersection_dist &&
+          current_intersection < curr->GetIntersectionDistance() &&
           current_intersection < closest_intersection) {
         res = entities[i];
         closest_intersection = current_intersection;
@@ -177,7 +177,7 @@ void SelectionSystem::intersectThread() {
   }
 }
 
-void SelectionSystem::updateInsersectThreadData(
+void SelectionSystem::UpdateInsersectThreadData(
     glm::vec3 ori, glm::vec3 dir, glm::mat4 trans,
     std::vector<phx::Entity*> entities) {
   selector_input_mutex_.lock();
diff --git a/demos/optical_bench/src/selection_system.hpp b/demos/optical_bench/src/selection_system.hpp
index 629fdba8..176f9562 100644
--- a/demos/optical_bench/src/selection_system.hpp
+++ b/demos/optical_bench/src/selection_system.hpp
@@ -52,14 +52,14 @@ class SelectionSystem : public phx::System {
   phx::Entity* GetHovered();
   float GetIntersectionDistance();
 
-  void updateInsersectThreadData(glm::vec3 ori, glm::vec3 dir, glm::mat4 trans,
+  void UpdateInsersectThreadData(glm::vec3 ori, glm::vec3 dir, glm::mat4 trans,
                                  std::vector<phx::Entity*> entities);
 
   void KillThread();
 
  private:
   std::thread intersection_thread_;
-  void intersectThread();
+  void IntersectionThreadFunction();
 
   std::mutex selector_input_mutex_;
   std::vector<phx::Entity*> selector_entities_;
diff --git a/demos/optical_bench/src/selector.cpp b/demos/optical_bench/src/selector.cpp
index 414ac6d2..efb40179 100644
--- a/demos/optical_bench/src/selector.cpp
+++ b/demos/optical_bench/src/selector.cpp
@@ -57,10 +57,10 @@ Selector::Selector(phx::Entity *mesh_to_fetch_bb_from,
                         ->GetFirstComponent<phx::MeshHandle>();
       if (mesh_handle != nullptr && mesh_handle->GetMesh() != nullptr) {
         auto bb = mesh_handle->GetMesh()->GetBoundingBox();
-        swapMinMaxVectorEntries(bb[0], bb[1]);
+        SwapMinMaxVectorEntries(bb[0], bb[1]);
         // swap bigger/smaller enties into vector
-        swapMinMaxVectorEntries(min, bb[0]);
-        swapMinMaxVectorEntries(bb[1], max);
+        SwapMinMaxVectorEntries(min, bb[0]);
+        SwapMinMaxVectorEntries(bb[1], max);
         fitted_one = true;
       }
     }
@@ -86,7 +86,7 @@ std::string Selector::ToString() const {
 // https://www.scratchapixel.com/lessons/3d-basic-rendering/...
 // minimal-ray-tracer-rendering-simple-shapes/ray-box-intersection
 //
-float Selector::intersect(glm::vec3 ray_origin, glm::vec3 ray_direction) {
+float Selector::Intersect(glm::vec3 ray_origin, glm::vec3 ray_direction) {
   float tmin, tmax, tymin, tymax, tzmin, tzmax;
   glm::vec3 ori = glm::vec3(ray_origin);
 
@@ -132,12 +132,12 @@ float Selector::intersect(glm::vec3 ray_origin, glm::vec3 ray_direction) {
 }
 
 void Selector::SetCollider(glm::vec3 c1, glm::vec3 c2) {
-  swapMinMaxVectorEntries(c1, c2);
+  SwapMinMaxVectorEntries(c1, c2);
   collider_.corner_max = c2;
   collider_.corner_min = c1;
 }
 
-void Selector::swapMinMaxVectorEntries(glm::vec3 &min, glm::vec3 &max) {
+void Selector::SwapMinMaxVectorEntries(glm::vec3 &min, glm::vec3 &max) {
   glm::vec3 str1 = glm::vec3(min);
   glm::vec3 str2 = glm::vec3(max);
 
diff --git a/demos/optical_bench/src/selector.hpp b/demos/optical_bench/src/selector.hpp
index 58446240..fe5820f5 100644
--- a/demos/optical_bench/src/selector.hpp
+++ b/demos/optical_bench/src/selector.hpp
@@ -50,9 +50,14 @@ class Selector : public Component {
 
   std::string ToString() const override;
 
-  bool manipulation_helper_attachable_ = false;
+  bool IsManipulationHelperAttachable() {
+    return manipulation_helper_attachable_;
+  }
+  void SetManipulationHelperAttachable(bool b) {
+    manipulation_helper_attachable_ = b;
+  }
 
-  float intersect(glm::vec3 ray_origin, glm::vec3 ray_direction);
+  float Intersect(glm::vec3 ray_origin, glm::vec3 ray_direction);
 
   // Set/Get Collider
   void SetCollider(MeshHandle& handle) {
@@ -66,7 +71,9 @@ class Selector : public Component {
 
   // Object info
   glm::vec3 GetBottomCenter();
-  float intersection_dist = 0.05f;
+
+  void SetIntersectionDistance(float d) { intersection_dist_ = d; }
+  float GetIntersectionDistance() { return intersection_dist_; }
 
   // selection functions setter/getter
   void SetHover(std::function<void(glm::mat4, std::chrono::milliseconds)> f) {
@@ -133,7 +140,9 @@ class Selector : public Component {
 
  private:
   AABB collider_;
-  void swapMinMaxVectorEntries(glm::vec3& min, glm::vec3& max);
+  void SwapMinMaxVectorEntries(glm::vec3& min, glm::vec3& max);
+  bool manipulation_helper_attachable_ = false;
+  float intersection_dist_ = 0.05f;
 
   // selection functions
   std::function<void(glm::mat4, std::chrono::milliseconds)> hover_function_ =
diff --git a/demos/optical_bench/src/test_pattern_frame.cpp b/demos/optical_bench/src/test_pattern_frame.cpp
index 66903f4e..d46e7fa0 100644
--- a/demos/optical_bench/src/test_pattern_frame.cpp
+++ b/demos/optical_bench/src/test_pattern_frame.cpp
@@ -18,15 +18,15 @@ TestPatternFrame::TestPatternFrame(phx::Scene* scene,
                                    std::string image, glm::vec3 pos,
                                    bool use_interpolation) {
   manager_ = manager;
-  material = manager_->GetTargetMaterial();
+  material_ = manager_->GetTargetMaterial();
 
-  transform = manager_->getContext()->createTransform();
-  geometry = manager_->getContext()->createGeometryInstance(
-      manager_->GetTargetGeometry(), &material, &material + 1);
-  geometry_group = manager_->getContext()->createGeometryGroup();
-  geometry_group->addChild(geometry);
-  acceleration = manager_->getContext()->createAcceleration("Trbvh");
-  geometry_group->setAcceleration(acceleration);
+  transform_ = manager_->GetContext()->createTransform();
+  geometry_ = manager_->GetContext()->createGeometryInstance(
+      manager_->GetTargetGeometry(), &material_, &material_ + 1);
+  geometry_group_ = manager_->GetContext()->createGeometryGroup();
+  geometry_group_->addChild(geometry_);
+  acceleration_ = manager_->GetContext()->createAcceleration("Trbvh");
+  geometry_group_->setAcceleration(acceleration_);
 
   auto image_loaded = phx::ResourceUtils::LoadResourceFromFile<phx::Image>(
       "laser/target/" + image);
@@ -34,22 +34,22 @@ TestPatternFrame::TestPatternFrame(phx::Scene* scene,
   auto image_dims = image_loaded->GetDimensions();
   glm::vec3 size = glm::vec3(0.2f, 0.2f * image_dims[1] / image_dims[0], 0.02);
 
-  geometry["size"]->setFloat(size.x, size.y, size.z);
+  geometry_["size"]->setFloat(size.x, size.y, size.z);
 
   // Load texture
   auto sampler =
-      OptixContextManager::loadTexture(manager_->getContext(), image_loaded);
+      OptixContextManager::LoadTexture(manager_->GetContext(), image_loaded);
   if (!use_interpolation) {
     sampler->setFilteringModes(RT_FILTER_NEAREST, RT_FILTER_NEAREST,
                                RT_FILTER_NONE);
   }
-  geometry["frameTexture"]->setTextureSampler(sampler);
+  geometry_["frameTexture"]->setTextureSampler(sampler);
 
-  transform->setChild<optix::GeometryGroup>(geometry_group);
-  transform->setMatrix(false, &glm::mat4()[0][0], &glm::mat4()[0][0]);
+  transform_->setChild<optix::GeometryGroup>(geometry_group_);
+  transform_->setMatrix(false, &glm::mat4()[0][0], &glm::mat4()[0][0]);
 
-  manager->getTopObject()->addChild(transform);
-  manager->getTopObject()->getAcceleration()->markDirty();
+  manager->GetTopObject()->addChild(transform_);
+  manager->GetTopObject()->getAcceleration()->markDirty();
 
   entity_ = scene->CreateEntity();
   entity_->AddComponent<phx::Transform>()->Translate(pos);
@@ -61,7 +61,7 @@ TestPatternFrame::TestPatternFrame(phx::Scene* scene,
 
     glm::mat4 trans =
         entity_->GetFirstComponent<phx::Transform>()->GetGlobalMatrix();
-    transform->setMatrix(true, &(trans[0][0]), &(inverse(trans)[0][0]));
+    transform_->setMatrix(true, &(trans[0][0]), &(inverse(trans)[0][0]));
   });
 
   selector->SetExternalUpdate([this, selector]() {
@@ -72,7 +72,7 @@ TestPatternFrame::TestPatternFrame(phx::Scene* scene,
   selector->SetGrab([this](phx::Transform*, glm::mat4) { grabbed_ = true; });
   selector->SetRelease([this]() { grabbed_ = false; });
 
-  selector->intersection_dist = 1.5f;
+  selector->SetIntersectionDistance(1.5f);
 
   selector->SetCollider(
       glm::vec3(-size.x / 2.0f, -size.y / 2.0f, -size.z / 2.0f),
@@ -82,11 +82,11 @@ TestPatternFrame::TestPatternFrame(phx::Scene* scene,
 }
 
 TestPatternFrame::~TestPatternFrame() {
-  manager_->getTopObject()->removeChild(transform);
-  geometry->destroy();
-  acceleration->destroy();
-  geometry_group->destroy();
-  transform->destroy();
+  manager_->GetTopObject()->removeChild(transform_);
+  geometry_->destroy();
+  acceleration_->destroy();
+  geometry_group_->destroy();
+  transform_->destroy();
   delete support_rod_;
 }
 
diff --git a/demos/optical_bench/src/test_pattern_frame.hpp b/demos/optical_bench/src/test_pattern_frame.hpp
index 04b0373a..4c1728f1 100644
--- a/demos/optical_bench/src/test_pattern_frame.hpp
+++ b/demos/optical_bench/src/test_pattern_frame.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_TEST_PATTERN_FRAME_HPP_
+#define OPTICAL_BENCH_TEST_PATTERN_FRAME_HPP_
 
 #include "object_support_rod.hpp"
 
@@ -22,19 +23,21 @@ class TestPatternFrame {
     return entity_->GetFirstComponent<phx::Transform>();
   }
 
-  bool isGrabbed() { return grabbed_; };
+  bool IsGrabbed() { return grabbed_; };
 
   void Translate(glm::vec3 pos);
 
  private:
-  optix::Transform transform;
-  optix::GeometryInstance geometry;
-  optix::Material material;
-  optix::GeometryGroup geometry_group;
-  optix::Acceleration acceleration;
+  optix::Transform transform_;
+  optix::GeometryInstance geometry_;
+  optix::Material material_;
+  optix::GeometryGroup geometry_group_;
+  optix::Acceleration acceleration_;
   OptixContextManager* manager_;
   bool grabbed_ = false;
 
   phx::Entity* entity_;
   SupportRod* support_rod_;
 };
+
+#endif  // OPTICAL_BENCH_TEST_PATTERN_FRAME_HPP_
diff --git a/demos/optical_bench/src/text.cpp b/demos/optical_bench/src/text.cpp
index f991efd4..14a11b54 100644
--- a/demos/optical_bench/src/text.cpp
+++ b/demos/optical_bench/src/text.cpp
@@ -29,7 +29,7 @@ namespace phx {
 Text::Text(std::string text, float text_height) {
   text_height_ = text_height;
   text_ = text;
-  recalc_metrics_ = true;
+  recalculate_metrics_ = true;
 
   glGenBuffers(1, &ubo_);
   glBindBuffer(GL_UNIFORM_BUFFER, ubo_);
@@ -50,11 +50,11 @@ std::string Text::ToString() const {
   return "Text Element with Text: '" + text_ + "'";
 }
 void Text::SetText(std::string text) {
-  recalc_metrics_ |= text_.compare(text) != 0;
+  recalculate_metrics_ |= text_.compare(text) != 0;
 
   text_ = text;
 
-  updatedTextRel();  // writes text too
+  UpdatedTextOrRelativeWidths();  // writes text too
 }
 void Text::SetGradient(glm::vec4 g1, glm::vec4 g2) {
   gradient1_ = g1;
@@ -74,7 +74,7 @@ void Text::SetTextColor(glm::vec4 color) {
   glBindBuffer(GL_UNIFORM_BUFFER, 0);
 }
 void Text::SetAnchor(Anchor a) { alignment_x_ = static_cast<float>(a); }
-void Text::updatedTextRel() {
+void Text::UpdatedTextOrRelativeWidths() {
   glm::vec4 *data = new glm::vec4[text_.length()];
   for (auto i = 0u; i < text_.length(); i++) {
 	//cast to unsigned to guarantee positive numbers
diff --git a/demos/optical_bench/src/text.hpp b/demos/optical_bench/src/text.hpp
index b18f21ab..af9bc968 100644
--- a/demos/optical_bench/src/text.hpp
+++ b/demos/optical_bench/src/text.hpp
@@ -80,12 +80,12 @@ class Text : public Component {
   bool visible_ = true;
   float aspect_ = 1;
   float text_height_;
-  bool recalc_metrics_ = false;
+  bool recalculate_metrics_ = false;
   bool billboarded_ = false;
 
   float alignment_x_ = 0;  // center = 0, right = -1, left = 1
 
-  void updatedTextRel();
+  void UpdatedTextOrRelativeWidths();
 
   glm::vec4 gradient1_ = glm::vec4(0.74f, 0.92f, 0.96f, 1.0f);
   glm::vec4 gradient2_ = glm::vec4(0.36f, 0.62f, 0.84f, 1.0f);
diff --git a/demos/optical_bench/src/text_pass.cpp b/demos/optical_bench/src/text_pass.cpp
index eceb1b8c..9f0349f8 100644
--- a/demos/optical_bench/src/text_pass.cpp
+++ b/demos/optical_bench/src/text_pass.cpp
@@ -56,11 +56,11 @@ TextPass::TextPass(RenderTarget* render_target_left,
 TextPass::~TextPass() {
   glDeleteBuffers(1, &buffer_vertices_);
   glDeleteVertexArrays(1, &vao_);
-  glDeleteTextures(1, &char_atlas);
+  glDeleteTextures(1, &char_atlas_);
 }
 
 void TextPass::Initialize() {
-  setUpShaders();
+  SetUpShaders();
 
   // create OpenGL Vertices
   float points[] = {
@@ -80,33 +80,33 @@ void TextPass::Initialize() {
   glBindVertexArray(0);
 
   // Init freetype
-  if (FT_Init_FreeType(&fT_lib)) {
+  if (FT_Init_FreeType(&fT_lib_)) {
     phx::error("Could not init freetype library\n");
     return;
   }
 
   if (FT_New_Face(
-          fT_lib,
+          fT_lib_,
           (resources_root + std::string("/font/RobotoMono.ttf")).c_str(), 0,
-          &fT_face)) {
+          &fT_face_)) {
     phx::error("Could not open freetype font\n");
     return;
   }
 
-  FT_Set_Pixel_Sizes(fT_face, 0, 96);
+  FT_Set_Pixel_Sizes(fT_face_, 0, 96);
 
-  createTextureAtlas();
+  CreateTextureAtlas();
 }
 
-void TextPass::createTextureAtlas() {
-  FT_GlyphSlot g = fT_face->glyph;
+void TextPass::CreateTextureAtlas() {
+  FT_GlyphSlot g = fT_face_->glyph;
 
   int max_pos_v = -INT_MAX;
   int max_neg_v = -INT_MAX;
 
   // Get size of buffer
   for (int i = 32; i < 256; i++) {
-    if (FT_Load_Char(fT_face, i, FT_LOAD_RENDER)) {
+    if (FT_Load_Char(fT_face_, i, FT_LOAD_RENDER)) {
       phx::warn("Loading character %c failed!\n", i);
       continue;
     }
@@ -115,38 +115,38 @@ void TextPass::createTextureAtlas() {
     max_neg_v = glm::max(max_neg_v, (int)g->bitmap.rows - g->bitmap_top);
 
     if (i == 32) {
-      atlas_width += g->advance.x / 128;
-      char_width[i] = g->advance.x / 128;
+      atlas_width_ += g->advance.x / 128;
+      char_width_[i] = g->advance.x / 128;
     } else {
-      atlas_width += g->bitmap.width;
-      char_width[i] = g->bitmap.width;
+      atlas_width_ += g->bitmap.width;
+      char_width_[i] = g->bitmap.width;
     }
 
-    char_height[i] = g->bitmap.rows;
+    char_height_[i] = g->bitmap.rows;
   }
 
-  atlas_height = max_pos_v + max_neg_v;
+  atlas_height_ = max_pos_v + max_neg_v;
 
   // create opengl texture for it
-  glGenTextures(1, &char_atlas);
+  glGenTextures(1, &char_atlas_);
   glActiveTexture(GL_TEXTURE6);
-  glBindTexture(GL_TEXTURE_2D, char_atlas);
+  glBindTexture(GL_TEXTURE_2D, char_atlas_);
 
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, atlas_width, atlas_height, 0, GL_RED,
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, atlas_width_, atlas_height_, 0, GL_RED,
                GL_UNSIGNED_BYTE, nullptr);
 
   // load chars into texture
   unsigned int x = 0;
   for (int i = 32; i < 256; i++) {
-    if (FT_Load_Char(fT_face, i, FT_LOAD_RENDER)) continue;
+    if (FT_Load_Char(fT_face_, i, FT_LOAD_RENDER)) continue;
 
     glTexSubImage2D(GL_TEXTURE_2D, 0, x, max_pos_v - g->bitmap_top,
                     g->bitmap.width, g->bitmap.rows, GL_RED, GL_UNSIGNED_BYTE,
                     g->bitmap.buffer);
 
     shader_program_->SetUniform("char_pos_rel[" + std::to_string(i) + "]",
-                                ((float)x) / atlas_width);
+                                ((float)x) / atlas_width_);
 
     if (i == 32) {
       x += g->advance.x / 128;
@@ -164,40 +164,40 @@ void TextPass::createTextureAtlas() {
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 }
 
-float TextPass::getTextAscpect(std::string& text) {  // calc new aspect ratio
+float TextPass::GetTextAscpect(std::string& text) {  // calc new aspect ratio
   unsigned int max_height = 0;
   float aspect = 0.0f;
   for (char c : text) {
-    max_height = glm::max(max_height, char_height[c]);
-    aspect += char_width[c];
+    max_height = glm::max(max_height, char_height_[c]);
+    aspect += char_width_[c];
   }
   aspect /= max_height;
   return aspect;
 }
 
-void TextPass::calcRelWidths(Text* component) {
+void TextPass::CalculateRelativeWidths(Text* component) {
   unsigned int width = 0;
   for (auto i = 0u; i < component->text_.length(); i++) {
-    width += char_width[component->text_[i]];
+    width += char_width_[component->text_[i]];
   }
 
   float offset = 0;
   for (auto i = 0u; i < component->text_.length(); i++) {
     component->width_rel_[i] = offset;
-    offset += ((float)char_width[component->text_[i]]) / width;
+    offset += ((float)char_width_[component->text_[i]]) / width;
   }
-  component->updatedTextRel();
+  component->UpdatedTextOrRelativeWidths();
 }
 
 void TextPass::Execute() {
   auto camera_pos = render_target_right_->GetEntity()
                         ->GetFirstComponent<phx::Transform>()
                         ->GetGlobalTranslation();
-  if (render_target_left_ != nullptr) render(render_target_left_, camera_pos);
-  render(render_target_right_, camera_pos);
+  if (render_target_left_ != nullptr) Render(render_target_left_, camera_pos);
+  Render(render_target_right_, camera_pos);
 }
 
-void TextPass::render(RenderTarget* target, glm::vec3 camera_pos) {
+void TextPass::Render(RenderTarget* target, glm::vec3 camera_pos) {
   target->bind();
 
   shader_program_->use();
@@ -218,10 +218,10 @@ void TextPass::render(RenderTarget* target, glm::vec3 camera_pos) {
     if (!entity_text->visible_ || entity_text->text_.length() == 0) continue;
 
     // recalc metrics if necessary
-    if (entity_text->recalc_metrics_) {
-      entity_text->aspect_ = getTextAscpect(entity_text->text_);
-      calcRelWidths(entity_text);
-      entity_text->recalc_metrics_ = false;
+    if (entity_text->recalculate_metrics_) {
+      entity_text->aspect_ = GetTextAscpect(entity_text->text_);
+      CalculateRelativeWidths(entity_text);
+      entity_text->recalculate_metrics_ = false;
     }
 
     // adjust scale of transform
@@ -254,7 +254,7 @@ void TextPass::render(RenderTarget* target, glm::vec3 camera_pos) {
   target->unbind();
 }
 
-void TextPass::setUpShaders() {
+void TextPass::SetUpShaders() {
   auto vertex_shader =
       ResourceUtils::LoadResourceFromFile<ShaderSource>("shader/text.vert");
   auto fragment_shader =
diff --git a/demos/optical_bench/src/text_pass.hpp b/demos/optical_bench/src/text_pass.hpp
index ee17a3e3..eb8ff431 100644
--- a/demos/optical_bench/src/text_pass.hpp
+++ b/demos/optical_bench/src/text_pass.hpp
@@ -60,25 +60,25 @@ class TextPass : public RenderPass {
   // OpenGL Stuff
   GLuint buffer_vertices_ = 0;
   GLuint vao_ = 0;
-  GLuint char_atlas = 0;
+  GLuint char_atlas_ = 0;
 
-  void setUpShaders();
-  void render(RenderTarget* target, glm::vec3 camera_pos);
+  void SetUpShaders();
+  void Render(RenderTarget* target, glm::vec3 camera_pos);
 
   RenderTarget* render_target_right_;
   RenderTarget* render_target_left_;
   std::shared_ptr<ShaderProgram> shader_program_;
 
   // freetype
-  FT_Library fT_lib;
-  FT_Face fT_face;
-  unsigned int atlas_width = 0;
-  unsigned int atlas_height = 0;
-  unsigned int char_height[256];
-  unsigned int char_width[256];
-  void createTextureAtlas();
-  float getTextAscpect(std::string& text);
-  void calcRelWidths(phx::Text* component);
+  FT_Library fT_lib_;
+  FT_Face fT_face_;
+  unsigned int atlas_width_ = 0;
+  unsigned int atlas_height_ = 0;
+  unsigned int char_height_[256];
+  unsigned int char_width_[256];
+  void CreateTextureAtlas();
+  float GetTextAscpect(std::string& text);
+  void CalculateRelativeWidths(phx::Text* component);
 };
 
 }  // namespace phx
diff --git a/demos/optical_bench/src/translation_helper.cpp b/demos/optical_bench/src/translation_helper.cpp
index 2b4c0e5c..f6eb5e76 100644
--- a/demos/optical_bench/src/translation_helper.cpp
+++ b/demos/optical_bench/src/translation_helper.cpp
@@ -27,17 +27,17 @@ TranslationHelper::TranslationHelper(phx::Scene* scene, phx::Engine* engine) {
   root_->SetName("TranslationHelper");
   auto root_t = root_->AddComponent<phx::Transform>();
 
-  x_rod_ = loadAndInsertMesh(
+  x_rod_ = LoadAndInsertMesh(
       scene, "models/opticalBench/translation_helper/ArmX.obj", "ArmX");
-  y_rod_ = loadAndInsertMesh(
+  y_rod_ = LoadAndInsertMesh(
       scene, "models/opticalBench/translation_helper/ArmY.obj", "ArmY");
-  z_rod_ = loadAndInsertMesh(
+  z_rod_ = LoadAndInsertMesh(
       scene, "models/opticalBench/translation_helper/ArmZ.obj", "ArmZ");
-  x_rod_grip_ = loadAndInsertMesh(
+  x_rod_grip_ = LoadAndInsertMesh(
       scene, "models/opticalBench/translation_helper/GripX.obj", "GripX");
-  y_rod_grip_ = loadAndInsertMesh(
+  y_rod_grip_ = LoadAndInsertMesh(
       scene, "models/opticalBench/translation_helper/GripY.obj", "GripY");
-  z_rod_grip_ = loadAndInsertMesh(
+  z_rod_grip_ = LoadAndInsertMesh(
       scene, "models/opticalBench/translation_helper/GripZ.obj", "GripZ");
 
   x_rod_->GetFirstComponent<phx::Transform>()->SetParent(root_t);
@@ -51,26 +51,26 @@ TranslationHelper::TranslationHelper(phx::Scene* scene, phx::Engine* engine) {
       x_rod_grip_->AddComponent<phx::Selector>(x_rod_grip_, false);
   x_rod_grip_->GetFirstComponent<phx::Transform>()
       ->SetLocalScale(glm::vec3(0.05f))
-      .SetLocalTranslation(glm::vec3(grip_offset, 0, 0));
+      .SetLocalTranslation(glm::vec3(kGripOffset_, 0, 0));
 
   auto selector_y =
       y_rod_grip_->AddComponent<phx::Selector>(y_rod_grip_, false);
   y_rod_grip_->GetFirstComponent<phx::Transform>()
       ->SetLocalScale(glm::vec3(0.05f))
-      .SetLocalTranslation(glm::vec3(0, grip_offset, 0));
+      .SetLocalTranslation(glm::vec3(0, kGripOffset_, 0));
 
   auto selector_z =
       z_rod_grip_->AddComponent<phx::Selector>(z_rod_grip_, false);
   z_rod_grip_->GetFirstComponent<phx::Transform>()
       ->SetLocalScale(glm::vec3(0.05f))
-      .SetLocalTranslation(glm::vec3(0, 0, grip_offset));
+      .SetLocalTranslation(glm::vec3(0, 0, kGripOffset_));
 
   x_rod_->GetFirstComponent<phx::Transform>()->SetLocalScale(
-      glm::vec3(grip_offset, 1, 1));
+      glm::vec3(kGripOffset_, 1, 1));
   y_rod_->GetFirstComponent<phx::Transform>()->SetLocalScale(
-      glm::vec3(1, grip_offset, 1));
+      glm::vec3(1, kGripOffset_, 1));
   z_rod_->GetFirstComponent<phx::Transform>()->SetLocalScale(
-      glm::vec3(1, 1, grip_offset));
+      glm::vec3(1, 1, kGripOffset_));
 
   auto obj_m = engine_->GetSystem<ObjectManager>();
 
@@ -121,7 +121,7 @@ TranslationHelper::TranslationHelper(phx::Scene* scene, phx::Engine* engine) {
     // update parents
     auto prev_trans = parent_->GetLocalTranslation();
     parent_->SetLocalTranslation(
-        glm::vec3(glm::mix(x_grip_start_, pos.x - grip_offset, scale_factor),
+        glm::vec3(glm::mix(x_grip_start_, pos.x - kGripOffset_, kScaleFactor_),
                   prev_trans.y, prev_trans.z));
     parent_->GetEntity()->GetFirstComponent<phx::Selector>()->ExternalUpdate();
 
@@ -129,9 +129,9 @@ TranslationHelper::TranslationHelper(phx::Scene* scene, phx::Engine* engine) {
   });
   selector_x->SetRelease([this]() {
     x_rod_grip_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
-        glm::vec3(grip_offset, 0, 0));
+        glm::vec3(kGripOffset_, 0, 0));
     x_rod_->GetFirstComponent<phx::Transform>()->SetLocalScale(
-        glm::vec3(grip_offset, 1, 1));
+        glm::vec3(kGripOffset_, 1, 1));
   });
 
   selector_y->SetGrab([this, text_trans](phx::Transform*, glm::mat4) {
@@ -156,7 +156,7 @@ TranslationHelper::TranslationHelper(phx::Scene* scene, phx::Engine* engine) {
     auto prev_trans = parent_->GetLocalTranslation();
     parent_->SetLocalTranslation(
         glm::vec3(prev_trans.x,
-                  glm::mix(y_grip_start_, pos.y - grip_offset, scale_factor),
+                  glm::mix(y_grip_start_, pos.y - kGripOffset_, kScaleFactor_),
                   prev_trans.z));
     parent_->GetEntity()->GetFirstComponent<phx::Selector>()->ExternalUpdate();
 
@@ -164,9 +164,9 @@ TranslationHelper::TranslationHelper(phx::Scene* scene, phx::Engine* engine) {
   });
   selector_y->SetRelease([this]() {
     y_rod_grip_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
-        glm::vec3(0, grip_offset, 0));
+        glm::vec3(0, kGripOffset_, 0));
     y_rod_->GetFirstComponent<phx::Transform>()->SetLocalScale(
-        glm::vec3(1, grip_offset, 1));
+        glm::vec3(1, kGripOffset_, 1));
   });
 
   selector_z->SetGrab([this, text_trans](phx::Transform*, glm::mat4) {
@@ -188,18 +188,18 @@ TranslationHelper::TranslationHelper(phx::Scene* scene, phx::Engine* engine) {
 
     // update parents
     auto prev_trans = parent_->GetLocalTranslation();
-    parent_->SetLocalTranslation(
-        glm::vec3(prev_trans.x, prev_trans.y,
-                  glm::mix(z_grip_start_, pos.z - grip_offset, scale_factor)));
+    parent_->SetLocalTranslation(glm::vec3(
+        prev_trans.x, prev_trans.y,
+        glm::mix(z_grip_start_, pos.z - kGripOffset_, kScaleFactor_)));
     parent_->GetEntity()->GetFirstComponent<phx::Selector>()->ExternalUpdate();
 
     text_node->ManualUpdate();
   });
   selector_z->SetRelease([this]() {
     z_rod_grip_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
-        glm::vec3(0, 0, grip_offset));
+        glm::vec3(0, 0, kGripOffset_));
     z_rod_->GetFirstComponent<phx::Transform>()->SetLocalScale(
-        glm::vec3(1, 1, grip_offset));
+        glm::vec3(1, 1, kGripOffset_));
   });
 }
 
@@ -212,11 +212,11 @@ void TranslationHelper::SetParent(phx::Transform* parent) {
       engine_->GetSystem<ObjectManager>()->GetLens(parent->GetEntity());
 
   x_rod_grip_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
-      glm::vec3(grip_offset, 0, 0));
+      glm::vec3(kGripOffset_, 0, 0));
   y_rod_grip_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
-      glm::vec3(0, grip_offset, 0));
+      glm::vec3(0, kGripOffset_, 0));
   z_rod_grip_->GetFirstComponent<phx::Transform>()->SetLocalTranslation(
-      glm::vec3(0, 0, grip_offset));
+      glm::vec3(0, 0, kGripOffset_));
 
   root_->GetFirstComponent<phx::Transform>()->SetParent(parent, false);
   root_->GetFirstComponent<phx::Transform>()->SetGlobalRotation(glm::vec3(0));
@@ -226,7 +226,7 @@ bool TranslationHelper::SelectablePartOf(phx::Entity* o) {
   return o == x_rod_grip_ || o == y_rod_grip_ || o == z_rod_grip_;
 }
 
-phx::Entity* TranslationHelper::loadAndInsertMesh(phx::Scene* scene,
+phx::Entity* TranslationHelper::LoadAndInsertMesh(phx::Scene* scene,
                                                   std::string file,
                                                   std::string name) {
   auto model = phx::ResourceUtils::LoadResourceFromFile<phx::Model>(file);
diff --git a/demos/optical_bench/src/translation_helper.hpp b/demos/optical_bench/src/translation_helper.hpp
index 79b33bf9..007f61bc 100644
--- a/demos/optical_bench/src/translation_helper.hpp
+++ b/demos/optical_bench/src/translation_helper.hpp
@@ -1,4 +1,5 @@
-#pragma once
+#ifndef OPTICAL_BENCH_TRANSLATION_HELPER_HPP_
+#define OPTICAL_BENCH_TRANSLATION_HELPER_HPP_
 
 #include "object_support_rod.hpp"
 #include "text.hpp"
@@ -30,8 +31,8 @@ class TranslationHelper {
   bool SelectablePartOf(phx::Entity* o);
 
  private:
-  const float scale_factor = 0.1f;
-  const float grip_offset = 0.3f;
+  const float kScaleFactor_ = 0.1f;
+  const float kGripOffset_ = 0.3f;
 
   phx::Entity* x_rod_;
   phx::Entity* y_rod_;
@@ -50,6 +51,8 @@ class TranslationHelper {
   float y_grip_start_ = 0;
   float z_grip_start_ = 0;
 
-  phx::Entity* loadAndInsertMesh(phx::Scene* scene, std::string file,
+  phx::Entity* LoadAndInsertMesh(phx::Scene* scene, std::string file,
                                  std::string name);
 };
+
+#endif  // OPTICAL_BENCH_TRANSLATION_HELPER_HPP_
-- 
GitLab