diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
new file mode 100644
index 0000000000000000000000000000000000000000..db2aaf642e8c820e93a1f9969b554fe9020e8f29
--- /dev/null
+++ b/.gitlab-ci.yml
@@ -0,0 +1,93 @@
+#-------------------------------------------------------------------------------
+# Copyright (c) 2020 RWTH Aachen University, Germany,
+# Virtual Reality & Immersive Visualisation Group.
+#-------------------------------------------------------------------------------
+
+# The include file can be change to either be removed or reference a specific commit.
+
+include:
+  - project: 'vr-group/unreal-development/unreal-ci'
+    ref: master 
+    file: '/shared_scripts.yml'
+    
+# In this file you are able to configure your plugins pipeline.
+# If you want to customize something, either overwrite things that are defined in the shared_scripts repository,
+# or remove the "extends" and write your own scripts
+# 
+# If you want your pipeline to run on every commit, just remove the "only" blocks. Keep in mind, that a build
+# can take some time.
+# 
+# If you want to alter the unreal-building process two variables are defined for either changing the CLIENT_CONFIG or
+# for adding EXTRA_ARGS to the building process
+# 
+# For the generate stage, you can specify needed dependencies in GEN_DEPENDENCIES with [Branch@PluginFolder] as key
+# Example:
+#
+# Generate_Project:
+#    only: ['web', 'schedules']
+#    extends: .Generate_Project_
+#    variables:
+#        GEN_TEMPLATE_REPO: "https://devhub.vr.rwth-aachen.de/VR-Group/unreal-development/unrealprojecttemplate.git"
+#        GEN_TEMPLATE_BRANCH: "develop"
+#        GEN_DEPENDENCIES: "(
+#            [master@nDisplayExtensions]='https://devhub.vr.rwth-aachen.de/VR-Group/unreal-development/ndisplayextensions.git'
+#            [master@UniversalLogging]='https://devhub.vr.rwth-aachen.de/VR-Group/unreal-development/universallogging.git'
+#        )"
+#
+# You can uncomment the deploy lines to deploy your project to the CAVE/VRDev. This only makes sense, if your plugin works
+# with a generated project.
+
+stages:
+  - generate
+  - build
+  - deploy
+
+Generate_Project:
+    only: ['web', 'schedules']
+    extends: .Generate_Project_
+    variables:
+        RUN_SETUP: "false"
+
+Build_Windows:
+    only: ['web', 'schedules']
+    extends: .Build_Windows_
+    tags:
+        - windows
+        - unreal-4.26
+    variables:
+        GIT_STRATEGY: none   
+        GIT_CHECKOUT: "false"
+        # CLIENT_CONFIG: "Shipping"
+        CLIENT_CONFIG: "DebugGame"
+    needs:
+        - job: "Generate_Project"
+          artifacts: true
+    
+Build_CentOS:
+    only: ['web', 'schedules']
+    extends: .Build_CentOS_
+    tags:
+        - centos
+        - unreal-4.26
+    variables:
+        GIT_STRATEGY: none   
+        GIT_CHECKOUT: "false"
+        # CLIENT_CONFIG: "Shipping"
+        CLIENT_CONFIG: "DebugGame"
+    needs:
+        - job: "Generate_Project"
+          artifacts: true
+          
+Deploy_CAVE:
+    only: ['web', 'schedules']
+    extends: .Deploy_CAVE_
+    needs:
+        - job: "Build_CentOS"
+          artifacts: true
+
+Deploy_Windows:
+    only: ['web', 'schedules']
+    extends: .Deploy_VRDev_
+    needs:
+        - job: "Build_Windows"
+          artifacts: true
diff --git a/Content/VRGroupDefaultDisplayClusterSettings.uasset b/Content/VRGroupDefaultDisplayClusterSettings.uasset
deleted file mode 100644
index 6c342149cd118410c38cb65670f2f349f5a46562..0000000000000000000000000000000000000000
Binary files a/Content/VRGroupDefaultDisplayClusterSettings.uasset and /dev/null differ
diff --git a/Source/DisplayClusterExtensions/Private/Cluster/CAVEOverlay/CAVEOverlayController.cpp b/Source/DisplayClusterExtensions/Private/Cluster/CAVEOverlay/CAVEOverlayController.cpp
index f18313db20809211f8fe87c47c371e473588d8c0..1d78376e2fa8aa55ae2597f59e913941906990dc 100644
--- a/Source/DisplayClusterExtensions/Private/Cluster/CAVEOverlay/CAVEOverlayController.cpp
+++ b/Source/DisplayClusterExtensions/Private/Cluster/CAVEOverlay/CAVEOverlayController.cpp
@@ -6,11 +6,10 @@
 #include "Cluster/IDisplayClusterClusterManager.h"
 #include "Game/IDisplayClusterGameManager.h"
 #include "UObject/ConstructorHelpers.h"
-#include <array>
 #include "Components/StaticMeshComponent.h"
 #include "Materials/MaterialInstanceDynamic.h"
-#include "Pawn/VirtualRealityPawn.h"
 #include "Components/DisplayClusterSceneComponent.h"
+#include "Engine/CollisionProfile.h"
 #include "Utility/VirtualRealityUtilities.h"
 
 DEFINE_LOG_CATEGORY(LogCAVEOverlay);
@@ -30,6 +29,7 @@ UStaticMeshComponent* ACAVEOverlayController::CreateMeshComponent(const FName& N
 	Result->SetStaticMesh(Mesh);
 	Result->SetupAttachment(Parent);
 	Result->SetVisibility(false);
+	Result->SetCollisionProfileName(UCollisionProfile::NoCollision_ProfileName);
 	return Result;
 }
 
@@ -53,7 +53,7 @@ ACAVEOverlayController::ACAVEOverlayController()
 	ConstructorHelpers::FClassFinder<UDoorOverlayData> WidgetClassFinder(TEXT("Blueprint'/nDisplayExtensions/CAVEOverlay/DoorOverlay'"));
 	if (WidgetClassFinder.Succeeded())
 	{
-		Overlay_Class = WidgetClassFinder.Class;
+		OverlayClass = WidgetClassFinder.Class;
 	}
 	else
 	{
@@ -63,47 +63,47 @@ ACAVEOverlayController::ACAVEOverlayController()
 	//Creation of sub-components
 	Root = CreateDefaultSubobject<USceneComponent>("DefaultSceneRoot");
 	SetRootComponent(Root);
-	Tape_Root = CreateDefaultSubobject<USceneComponent>("TapeRoot");
-	Sign_Root = CreateDefaultSubobject<USceneComponent>("SignRoot");
-	Tape_Root->SetupAttachment(Root);
-	Sign_Root->SetupAttachment(Root);
+	TapeRoot = CreateDefaultSubobject<USceneComponent>("TapeRoot");
+	SignRoot = CreateDefaultSubobject<USceneComponent>("SignRoot");
+	TapeRoot->SetupAttachment(Root);
+	SignRoot->SetupAttachment(Root);
 
 	//Loading of Materials and Meshes
-	LoadAsset("/nDisplayExtensions/CAVEOverlay/Stripes", Tape_Material);
-	LoadAsset("/nDisplayExtensions/CAVEOverlay/StopMaterial", Sign_Material);
-	LoadAsset("/nDisplayExtensions/CAVEOverlay/Plane", Plane_Mesh_);
+	LoadAsset("/nDisplayExtensions/CAVEOverlay/Stripes", TapeMaterial);
+	LoadAsset("/nDisplayExtensions/CAVEOverlay/StopMaterial", SignMaterial);
+	LoadAsset("/nDisplayExtensions/CAVEOverlay/Plane", PlaneMesh);
 
-	Tape_Negative_Y = CreateMeshComponent("TapeNegY", Plane_Mesh_, Tape_Root);
-	Tape_Negative_X = CreateMeshComponent("TapeNegX", Plane_Mesh_, Tape_Root);
-	Tape_Positive_Y = CreateMeshComponent("TapePosY", Plane_Mesh_, Tape_Root);
-	Tape_Positive_X = CreateMeshComponent("TapePosX", Plane_Mesh_, Tape_Root);
+	TapeNegativeY = CreateMeshComponent("TapeNegY", PlaneMesh, TapeRoot);
+	TapeNegativeX = CreateMeshComponent("TapeNegX", PlaneMesh, TapeRoot);
+	TapePositiveY = CreateMeshComponent("TapePosY", PlaneMesh, TapeRoot);
+	TapePositiveX = CreateMeshComponent("TapePosX", PlaneMesh, TapeRoot);
 
-	Sign_Negative_Y = CreateMeshComponent("SignNegY", Plane_Mesh_, Sign_Root);
-	Sign_Negative_X = CreateMeshComponent("SignNegX", Plane_Mesh_, Sign_Root);
-	Sign_Positive_Y = CreateMeshComponent("SignPosY", Plane_Mesh_, Sign_Root);
-	Sign_Positive_X = CreateMeshComponent("SignPosX", Plane_Mesh_, Sign_Root);
+	SignNegativeY = CreateMeshComponent("SignNegY", PlaneMesh, SignRoot);
+	SignNegativeX = CreateMeshComponent("SignNegX", PlaneMesh, SignRoot);
+	SignPositiveY = CreateMeshComponent("SignPosY", PlaneMesh, SignRoot);
+	SignPositiveX = CreateMeshComponent("SignPosX", PlaneMesh, SignRoot);
 
 	//Set initial Position, Rotation and Scale of Tape
-	Tape_Negative_Y->SetRelativeLocationAndRotation(FVector(0, -Wall_Distance, 0), FRotator(0, 0, 90));
-	Tape_Positive_Y->SetRelativeLocationAndRotation(FVector(0, +Wall_Distance, 0), FRotator(0, 180, 90));
-	Tape_Negative_X->SetRelativeLocationAndRotation(FVector(-Wall_Distance, 0, 0), FRotator(0, -90, 90));
-	Tape_Positive_X->SetRelativeLocationAndRotation(FVector(+Wall_Distance, 0, 0), FRotator(0, 90, 90));
+	TapeNegativeY->SetRelativeLocationAndRotation(FVector(0, -WallDistance, 0), FRotator(0, 0, 90));
+	TapePositiveY->SetRelativeLocationAndRotation(FVector(0, +WallDistance, 0), FRotator(0, 180, 90));
+	TapeNegativeX->SetRelativeLocationAndRotation(FVector(-WallDistance, 0, 0), FRotator(0, -90, 90));
+	TapePositiveX->SetRelativeLocationAndRotation(FVector(+WallDistance, 0, 0), FRotator(0, 90, 90));
 
-	Tape_Negative_Y->SetRelativeScale3D(FVector(Wall_Distance / 100 * 2, 0.15, 1));
-	Tape_Positive_Y->SetRelativeScale3D(FVector(Wall_Distance / 100 * 2, 0.15, 1));
-	Tape_Negative_X->SetRelativeScale3D(FVector(Wall_Distance / 100 * 2, 0.15, 1));
-	Tape_Positive_X->SetRelativeScale3D(FVector(Wall_Distance / 100 * 2, 0.15, 1));
+	TapeNegativeY->SetRelativeScale3D(FVector(WallDistance / 100 * 2, 0.15, 1));
+	TapePositiveY->SetRelativeScale3D(FVector(WallDistance / 100 * 2, 0.15, 1));
+	TapeNegativeX->SetRelativeScale3D(FVector(WallDistance / 100 * 2, 0.15, 1));
+	TapePositiveX->SetRelativeScale3D(FVector(WallDistance / 100 * 2, 0.15, 1));
 
 	//Set initial Position, Rotation and Scale of Signs
-	Sign_Negative_Y->SetRelativeLocationAndRotation(FVector(0, -Wall_Distance, 0), FRotator(0, 0, 90));
-	Sign_Positive_Y->SetRelativeLocationAndRotation(FVector(0, +Wall_Distance, 0), FRotator(0, 180, 90));
-	Sign_Negative_X->SetRelativeLocationAndRotation(FVector(-Wall_Distance, 0, 0), FRotator(0, -90, 90));
-	Sign_Positive_X->SetRelativeLocationAndRotation(FVector(+Wall_Distance, 0, 0), FRotator(0, 90, 90));
-
-	Sign_Negative_Y->SetRelativeScale3D(FVector(0.5f));
-	Sign_Positive_Y->SetRelativeScale3D(FVector(0.5f));
-	Sign_Negative_X->SetRelativeScale3D(FVector(0.5f));
-	Sign_Positive_X->SetRelativeScale3D(FVector(0.5f));
+	SignNegativeY->SetRelativeLocationAndRotation(FVector(0, -WallDistance, 0), FRotator(0, 0, 90));
+	SignPositiveY->SetRelativeLocationAndRotation(FVector(0, +WallDistance, 0), FRotator(0, 180, 90));
+	SignNegativeX->SetRelativeLocationAndRotation(FVector(-WallDistance, 0, 0), FRotator(0, -90, 90));
+	SignPositiveX->SetRelativeLocationAndRotation(FVector(+WallDistance, 0, 0), FRotator(0, 90, 90));
+
+	SignNegativeY->SetRelativeScale3D(FVector(0.5f));
+	SignPositiveY->SetRelativeScale3D(FVector(0.5f));
+	SignNegativeX->SetRelativeScale3D(FVector(0.5f));
+	SignPositiveX->SetRelativeScale3D(FVector(0.5f));
 }
 
 void ACAVEOverlayController::PostInitializeComponents()
@@ -111,32 +111,32 @@ void ACAVEOverlayController::PostInitializeComponents()
 	Super::PostInitializeComponents();
 
 	//Create dynamic materials in runtime
-	Tape_Material_Dynamic_ = UMaterialInstanceDynamic::Create(Tape_Material, Tape_Root);
-	Sign_Material_Dynamic_ = UMaterialInstanceDynamic::Create(Sign_Material, Sign_Root);
-
-	Tape_Negative_Y->SetMaterial(0, Tape_Material_Dynamic_);
-	Tape_Negative_X->SetMaterial(0, Tape_Material_Dynamic_);
-	Tape_Positive_Y->SetMaterial(0, Tape_Material_Dynamic_);
-	Tape_Positive_X->SetMaterial(0, Tape_Material_Dynamic_);
-
-	Sign_Negative_Y->SetMaterial(0, Sign_Material_Dynamic_);
-	Sign_Negative_X->SetMaterial(0, Sign_Material_Dynamic_);
-	Sign_Positive_Y->SetMaterial(0, Sign_Material_Dynamic_);
-	Sign_Positive_X->SetMaterial(0, Sign_Material_Dynamic_);
+	TapeMaterialDynamic = UMaterialInstanceDynamic::Create(TapeMaterial, TapeRoot);
+	SignMaterialDynamic = UMaterialInstanceDynamic::Create(SignMaterial, SignRoot);
+
+	TapeNegativeY->SetMaterial(0, TapeMaterialDynamic);
+	TapeNegativeX->SetMaterial(0, TapeMaterialDynamic);
+	TapePositiveY->SetMaterial(0, TapeMaterialDynamic);
+	TapePositiveX->SetMaterial(0, TapeMaterialDynamic);
+
+	SignNegativeY->SetMaterial(0, SignMaterialDynamic);
+	SignNegativeX->SetMaterial(0, SignMaterialDynamic);
+	SignPositiveY->SetMaterial(0, SignMaterialDynamic);
+	SignPositiveX->SetMaterial(0, SignMaterialDynamic);
 }
 
 void ACAVEOverlayController::CycleDoorType()
 {
-	Door_Current_Mode = static_cast<EDoor_Mode>((Door_Current_Mode + 1) % DOOR_NUM_MODES);
+	DoorCurrentMode = static_cast<EDoorMode>((DoorCurrentMode + 1) % DOOR_NUM_MODES);
 
 	IDisplayClusterClusterManager* const Manager = IDisplayCluster::Get().GetClusterMgr();
 	if (Manager)
 	{
 		FDisplayClusterClusterEventJson cluster_event;
-		cluster_event.Name = "CAVEOverlay Change Door to " + Door_Mode_Names[Door_Current_Mode];
+		cluster_event.Name = "CAVEOverlay Change Door to " + DoorModeNames[DoorCurrentMode];
 		cluster_event.Type = "DoorChange";
 		cluster_event.Category = "CAVEOverlay";
-		cluster_event.Parameters.Add("NewDoorState", FString::FromInt(Door_Current_Mode));
+		cluster_event.Parameters.Add("NewDoorState", FString::FromInt(DoorCurrentMode));
 		Manager->EmitClusterEventJson(cluster_event, true);
 	}
 }
@@ -145,46 +145,46 @@ void ACAVEOverlayController::HandleClusterEvent(const FDisplayClusterClusterEven
 {
 	if (Event.Category.Equals("CAVEOverlay") && Event.Type.Equals("DoorChange") && Event.Parameters.Contains("NewDoorState"))
 	{
-		SetDoorMode(static_cast<EDoor_Mode>(FCString::Atoi(*Event.Parameters["NewDoorState"])));
+		SetDoorMode(static_cast<EDoorMode>(FCString::Atoi(*Event.Parameters["NewDoorState"])));
 	}
 }
 
-void ACAVEOverlayController::SetDoorMode(EDoor_Mode NewMode)
+void ACAVEOverlayController::SetDoorMode(EDoorMode NewMode)
 {
-	Door_Current_Mode = NewMode;
-	switch (Door_Current_Mode)
+	DoorCurrentMode = NewMode;
+	switch (DoorCurrentMode)
 	{
-	case EDoor_Mode::DOOR_DEBUG:
-	case EDoor_Mode::DOOR_PARTIALLY_OPEN:
-		Door_Current_Opening_Width_Absolute = Door_Opening_Width_Absolute;
-		if (Screen_Type == SCREEN_DOOR) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1));
-		if (Screen_Type == SCREEN_DOOR_PARTIAL) Overlay->BlackBox->SetRenderScale(FVector2D(Door_Opening_Width_Relative, 1));
-		if (Screen_Type == SCREEN_MASTER) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1));
+	case EDoorMode::DOOR_DEBUG:
+	case EDoorMode::DOOR_PARTIALLY_OPEN:
+		DoorCurrentOpeningWidthAbsolute = DoorOpeningWidthAbsolute;
+		if (ScreenType == SCREEN_DOOR) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1));
+		if (ScreenType == SCREEN_DOOR_PARTIAL) Overlay->BlackBox->SetRenderScale(FVector2D(DoorOpeningWidthRelative, 1));
+		if (ScreenType == SCREEN_MASTER) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1));
 		Overlay->BlackBox->SetVisibility(ESlateVisibility::Visible);
 		break;
-	case EDoor_Mode::DOOR_OPEN:
-		Door_Current_Opening_Width_Absolute = Wall_Distance * 2;
-		if (Screen_Type == SCREEN_DOOR) Overlay->BlackBox->SetRenderScale(FVector2D(1, 1));
-		if (Screen_Type == SCREEN_DOOR_PARTIAL) Overlay->BlackBox->SetRenderScale(FVector2D(1, 1));
-		if (Screen_Type == SCREEN_MASTER) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1));
+	case EDoorMode::DOOR_OPEN:
+		DoorCurrentOpeningWidthAbsolute = WallDistance * 2;
+		if (ScreenType == SCREEN_DOOR) Overlay->BlackBox->SetRenderScale(FVector2D(1, 1));
+		if (ScreenType == SCREEN_DOOR_PARTIAL) Overlay->BlackBox->SetRenderScale(FVector2D(1, 1));
+		if (ScreenType == SCREEN_MASTER) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1));
 		Overlay->BlackBox->SetVisibility(ESlateVisibility::Visible);
 		break;
-	case EDoor_Mode::DOOR_CLOSED:
-		Door_Current_Opening_Width_Absolute = 0;
-		if (Screen_Type == SCREEN_DOOR) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1));
-		if (Screen_Type == SCREEN_DOOR_PARTIAL) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1));
-		if (Screen_Type == SCREEN_MASTER) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1));
+	case EDoorMode::DOOR_CLOSED:
+		DoorCurrentOpeningWidthAbsolute = 0;
+		if (ScreenType == SCREEN_DOOR) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1));
+		if (ScreenType == SCREEN_DOOR_PARTIAL) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1));
+		if (ScreenType == SCREEN_MASTER) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1));
 		Overlay->BlackBox->SetVisibility(ESlateVisibility::Hidden);
 		break;
 	default: ;
 	}
-	if (Screen_Type == SCREEN_NORMAL) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1)); //no overlay
+	if (ScreenType == SCREEN_NORMAL) Overlay->BlackBox->SetRenderScale(FVector2D(0, 1)); //no overlay
 
-	UE_LOG(LogCAVEOverlay, Log, TEXT("Switched door state to '%s'. New opening width is %f."), *Door_Mode_Names[Door_Current_Mode], Door_Current_Opening_Width_Absolute);
+	UE_LOG(LogCAVEOverlay, Log, TEXT("Switched door state to '%s'. New opening width is %f."), *DoorModeNames[DoorCurrentMode], DoorCurrentOpeningWidthAbsolute);
 
-	if (Screen_Type == SCREEN_MASTER)
+	if (ScreenType == SCREEN_MASTER)
 	{
-		Overlay->CornerText->SetText(FText::FromString(Door_Mode_Names[Door_Current_Mode]));
+		Overlay->CornerText->SetText(FText::FromString(DoorModeNames[DoorCurrentMode]));
 	}
 }
 
@@ -193,9 +193,9 @@ void ACAVEOverlayController::BeginPlay()
 {
 	Super::BeginPlay();
 
-	bCAVE_Mode = UVirtualRealityUtilities::IsCave(); /* Store current situation */
+	bCAVEMode = UVirtualRealityUtilities::IsCave(); /* Store current situation */
 
-	if (!bCAVE_Mode) return; // Not our business
+	if (!bCAVEMode) return; // Not our business
 
 	//Input config
 	InputComponent->BindKey(EKeys::F10, EInputEvent::IE_Pressed, this, &ACAVEOverlayController::CycleDoorType);
@@ -207,34 +207,32 @@ void ACAVEOverlayController::BeginPlay()
 	}
 
 	//Determine the screen-type for later usage
-	if (IDisplayCluster::Get().GetClusterMgr()->GetNodeId().Equals(Screen_Main, ESearchCase::IgnoreCase))
+	if (IDisplayCluster::Get().GetClusterMgr()->GetNodeId().Equals(ScreenMain, ESearchCase::IgnoreCase))
 	{
-		Screen_Type = SCREEN_MASTER;
+		ScreenType = SCREEN_MASTER;
 	}
-	else if (ContainsFString(Screens_Door, IDisplayCluster::Get().GetClusterMgr()->GetNodeId()))
+	else if (ContainsFString(ScreensDoor, IDisplayCluster::Get().GetClusterMgr()->GetNodeId()))
 	{
-		Screen_Type = SCREEN_DOOR;
+		ScreenType = SCREEN_DOOR;
 	}
-	else if (ContainsFString(Screens_Door_Partial, IDisplayCluster::Get().GetClusterMgr()->GetNodeId()))
+	else if (ContainsFString(ScreensDoorPartial, IDisplayCluster::Get().GetClusterMgr()->GetNodeId()))
 	{
-		Screen_Type = SCREEN_DOOR_PARTIAL;
+		ScreenType = SCREEN_DOOR_PARTIAL;
 	}
 	else
 	{
-		Screen_Type = SCREEN_NORMAL;
+		ScreenType = SCREEN_NORMAL;
 	}
 
-	Overlay = CreateWidget<UDoorOverlayData>(GetWorld()->GetFirstPlayerController(), Overlay_Class);
+	Overlay = CreateWidget<UDoorOverlayData>(GetWorld()->GetFirstPlayerController(), OverlayClass);
 	Overlay->AddToViewport(0);
-	SetDoorMode(Door_Current_Mode);
+	SetDoorMode(DoorCurrentMode);
 	Overlay->CornerText->SetText(FText::FromString("")); //Set Text to "" until someone presses the key for the first time
 
-	Player_Pawn = Cast<AVirtualRealityPawn>(GetWorld()->GetFirstPlayerController()->GetPawn());
-
-	if (!bAttached && Cave_Origin)
+	if (!bAttachedToCAVEOrigin && CaveOrigin)
 	{
-		AttachToComponent(Cave_Origin, FAttachmentTransformRules::SnapToTargetNotIncludingScale);
-		bAttached = true;
+		AttachToComponent(CaveOrigin, FAttachmentTransformRules::SnapToTargetNotIncludingScale);
+		bAttachedToCAVEOrigin = true;
 	}
 }
 
@@ -249,24 +247,18 @@ void ACAVEOverlayController::EndPlay(const EEndPlayReason::Type EndPlayReason)
 	Super::EndPlay(EndPlayReason);
 }
 
-float ACAVEOverlayController::CalculateOpacityFromPosition(FVector Position)
+float ACAVEOverlayController::CalculateOpacityFromPosition(FVector Position) const
 {
 	return FMath::Max(
-		FMath::Clamp((FMath::Abs(Position.X) - (Wall_Distance - Wall_Close_Distance)) / Wall_Fade_Distance, 0.0f, 1.0f),
-		FMath::Clamp((FMath::Abs(Position.Y) - (Wall_Distance - Wall_Close_Distance)) / Wall_Fade_Distance, 0.0f, 1.0f)
+		FMath::Clamp((FMath::Abs(Position.X) - (WallDistance - WallCloseDistance)) / WallFadeDistance, 0.0f, 1.0f),
+		FMath::Clamp((FMath::Abs(Position.Y) - (WallDistance - WallCloseDistance)) / WallFadeDistance, 0.0f, 1.0f)
 	);
 }
 
-bool ACAVEOverlayController::PositionInDoorOpening(FVector Position)
+bool ACAVEOverlayController::PositionInDoorOpening(FVector Position) const
 {
-	return FMath::IsWithinInclusive(-Position.X, Wall_Distance + 10 - 20 - Wall_Close_Distance, Wall_Distance + 10) //Overlap both sides 10cm
-		&& FMath::IsWithinInclusive(-Position.Y, Wall_Distance + 10 - Door_Current_Opening_Width_Absolute, Wall_Distance + 10); //Overlap one side 10cm
-}
-
-void ACAVEOverlayController::RefreshPawnComponents()
-{
-	Cave_Origin = UVirtualRealityUtilities::GetNamedClusterComponent(ENamedClusterComponent::NCC_CAVE_ORIGIN);
-	Head = Player_Pawn->Head;
+	return FMath::IsWithinInclusive(-Position.X, WallDistance + 10 - 20 - WallCloseDistance, WallDistance + 10) //Overlap both sides 10cm
+		&& FMath::IsWithinInclusive(-Position.Y, WallDistance + 10 - DoorCurrentOpeningWidthAbsolute, WallDistance + 10); //Overlap one side 10cm
 }
 
 // Called every frame
@@ -274,23 +266,23 @@ void ACAVEOverlayController::Tick(float DeltaTime)
 {
 	Super::Tick(DeltaTime);
 
-	if (!bCAVE_Mode) return; // Not our business
+	if (!bCAVEMode) return; // Not our business
 
-	if (!Cave_Origin || !Head)
+	if (!CaveOrigin)
 	{
-		RefreshPawnComponents();
+		CaveOrigin = UVirtualRealityUtilities::GetNamedClusterComponent(ENamedClusterComponent::NCC_CAVE_ORIGIN);
 	}
 
-	if (!bAttached && Cave_Origin)
+	if (!bAttachedToCAVEOrigin && CaveOrigin)
 	{
-		AttachToComponent(Cave_Origin, FAttachmentTransformRules::SnapToTargetNotIncludingScale);
-		bAttached = true;
+		AttachToComponent(CaveOrigin, FAttachmentTransformRules::SnapToTargetNotIncludingScale);
+		bAttachedToCAVEOrigin = true;
 	}
 
 	//FPS Counter
 	if (Overlay)
 	{
-		if (Door_Current_Mode == EDoor_Mode::DOOR_DEBUG && ContainsFString(Screens_FPS, IDisplayCluster::Get().GetClusterMgr()->GetNodeId()))
+		if (DoorCurrentMode == EDoorMode::DOOR_DEBUG && ContainsFString(ScreensFPS, IDisplayCluster::Get().GetClusterMgr()->GetNodeId()))
 		{
 			Overlay->FPS->SetText(FText::FromString(FString::Printf(TEXT("FPS: %.1f"), 1.0f / DeltaTime)));
 		}
@@ -300,60 +292,66 @@ void ACAVEOverlayController::Tick(float DeltaTime)
 		}
 	}
 
-	if (!Head || !Cave_Origin) return; //Display Cluster not initialized
+	if (!Head)
+	{
+	    Head = UVirtualRealityUtilities::GetNamedClusterComponent(ENamedClusterComponent::NCC_SHUTTERGLASSES);
+	}
+
+	if (!Head || !CaveOrigin) return; //Display Cluster not fully initialized
 
-	//Tape Logic
-	FVector Shutter_Position = Head->GetComponentLocation() - Cave_Origin->GetComponentLocation();
-	bool bOverlay_Visible = FMath::IsWithinInclusive(Shutter_Position.GetAbsMax(), Wall_Distance - Wall_Close_Distance, Wall_Distance);
+	//Head/Tape Logic
+    const FVector ShutterPosition = Head->GetComponentLocation() - CaveOrigin->GetComponentLocation();
+    const bool bHeadIsCloseToWall = FMath::IsWithinInclusive(ShutterPosition.GetAbsMax(), WallDistance - WallCloseDistance, WallDistance);
 
-	if (bOverlay_Visible && !PositionInDoorOpening(Shutter_Position))
+	if (bHeadIsCloseToWall && !PositionInDoorOpening(ShutterPosition))
 	{
-		Tape_Root->SetVisibility(true, true);
-		Tape_Root->SetRelativeLocation(Shutter_Position * FVector(0, 0, 1)); //Only apply Z
+		TapeRoot->SetVisibility(true, true);
+		TapeRoot->SetRelativeLocation(ShutterPosition * FVector(0, 0, 1)); //Only apply Z
 
-		float Tape_Opacity = CalculateOpacityFromPosition(Shutter_Position);
-		Tape_Material_Dynamic_->SetScalarParameterValue("BarrierOpacity", Tape_Opacity);
+		TapeMaterialDynamic->SetScalarParameterValue("BarrierOpacity", CalculateOpacityFromPosition(ShutterPosition));
 
-		if (FMath::IsWithin(FVector2D(Shutter_Position).GetAbsMax(), Wall_Distance - Wall_Warning_Distance, Wall_Distance))
+		if (FMath::IsWithin(FVector2D(ShutterPosition).GetAbsMax(), WallDistance - WallWarningDistance, WallDistance))
 		{
 			//in warning distance == red tape
-			Tape_Material_Dynamic_->SetVectorParameterValue("StripeColor", FVector(1, 0, 0));
+			TapeMaterialDynamic->SetVectorParameterValue("StripeColor", FVector(1, 0, 0));
 		}
 		else
 		{
-			Tape_Material_Dynamic_->SetVectorParameterValue("StripeColor", FVector(1, 1, 0));
+			TapeMaterialDynamic->SetVectorParameterValue("StripeColor", FVector(1, 1, 0));
 		}
 	}
 	else
 	{
-		Tape_Root->SetVisibility(false, true);
+		TapeRoot->SetVisibility(false, true);
 	}
 
-	//Sign Logic
-	UDisplayClusterSceneComponent* Flystick = UVirtualRealityUtilities::GetNamedClusterComponent(ENamedClusterComponent::NCC_FLYSTICK);
+	// Flystick/Sign Logic
+    if(!Flystick)
+	{
+	    Flystick = UVirtualRealityUtilities::GetNamedClusterComponent(ENamedClusterComponent::NCC_FLYSTICK);
+	}
 	if (Flystick)
 	{
-		FVector Flystick_Position = Flystick->GetRelativeTransform().GetLocation();
-		bool bFlystick_In_Door = PositionInDoorOpening(Flystick_Position);
-		float Sign_Opacity = CalculateOpacityFromPosition(Flystick_Position);
+        const FVector FlystickPosition = Flystick->GetRelativeTransform().GetLocation();
+        const bool bFlystickInDoor = PositionInDoorOpening(FlystickPosition);
 
-		Sign_Negative_X->SetRelativeLocation(FVector(-Wall_Distance, Flystick_Position.Y, Flystick_Position.Z));
-		Sign_Negative_Y->SetRelativeLocation(FVector(Flystick_Position.X, -Wall_Distance, Flystick_Position.Z));
-		Sign_Positive_X->SetRelativeLocation(FVector(+Wall_Distance, Flystick_Position.Y, Flystick_Position.Z));
-		Sign_Positive_Y->SetRelativeLocation(FVector(Flystick_Position.X, +Wall_Distance, Flystick_Position.Z));
+		SignNegativeX->SetRelativeLocation(FVector(-WallDistance, FlystickPosition.Y, FlystickPosition.Z));
+		SignNegativeY->SetRelativeLocation(FVector(FlystickPosition.X, -WallDistance, FlystickPosition.Z));
+		SignPositiveX->SetRelativeLocation(FVector(+WallDistance, FlystickPosition.Y, FlystickPosition.Z));
+		SignPositiveY->SetRelativeLocation(FVector(FlystickPosition.X, +WallDistance, FlystickPosition.Z));
 
-		Sign_Negative_X->SetVisibility(FMath::IsWithin(-Flystick_Position.X, Wall_Distance - Wall_Close_Distance, Wall_Distance) && !bFlystick_In_Door);
-		Sign_Negative_Y->SetVisibility(FMath::IsWithin(-Flystick_Position.Y, Wall_Distance - Wall_Close_Distance, Wall_Distance) && !bFlystick_In_Door);
-		Sign_Positive_X->SetVisibility(FMath::IsWithin(+Flystick_Position.X, Wall_Distance - Wall_Close_Distance, Wall_Distance) && !bFlystick_In_Door);
-		Sign_Positive_Y->SetVisibility(FMath::IsWithin(+Flystick_Position.Y, Wall_Distance - Wall_Close_Distance, Wall_Distance) && !bFlystick_In_Door);
+		SignNegativeX->SetVisibility(FMath::IsWithin(-FlystickPosition.X, WallDistance - WallCloseDistance, WallDistance) && !bFlystickInDoor);
+		SignNegativeY->SetVisibility(FMath::IsWithin(-FlystickPosition.Y, WallDistance - WallCloseDistance, WallDistance) && !bFlystickInDoor);
+		SignPositiveX->SetVisibility(FMath::IsWithin(+FlystickPosition.X, WallDistance - WallCloseDistance, WallDistance) && !bFlystickInDoor);
+		SignPositiveY->SetVisibility(FMath::IsWithin(+FlystickPosition.Y, WallDistance - WallCloseDistance, WallDistance) && !bFlystickInDoor);
 
-		Sign_Material_Dynamic_->SetScalarParameterValue("SignOpacity", Sign_Opacity);
+		SignMaterialDynamic->SetScalarParameterValue("SignOpacity", CalculateOpacityFromPosition(FlystickPosition));
 	}
 	else
 	{
-		Sign_Negative_X->SetVisibility(false);
-		Sign_Negative_Y->SetVisibility(false);
-		Sign_Positive_X->SetVisibility(false);
-		Sign_Positive_Y->SetVisibility(false);
+		SignNegativeX->SetVisibility(false);
+		SignNegativeY->SetVisibility(false);
+		SignPositiveX->SetVisibility(false);
+		SignPositiveY->SetVisibility(false);
 	}
 }
diff --git a/Source/DisplayClusterExtensions/Private/Pawn/BasicVRInteractionComponent.cpp b/Source/DisplayClusterExtensions/Private/Pawn/BasicVRInteractionComponent.cpp
index 4ac891dbf80e959a50389518abab20ffdbff9458..3c205f3c093c384f4ad58817ad4b31e489465e10 100644
--- a/Source/DisplayClusterExtensions/Private/Pawn/BasicVRInteractionComponent.cpp
+++ b/Source/DisplayClusterExtensions/Private/Pawn/BasicVRInteractionComponent.cpp
@@ -137,6 +137,7 @@ void UBasicVRInteractionComponent::TickComponent(float DeltaTime, ELevelTick Tic
 
 	const FTwoVectors StartEnd = GetHandRay(MaxClickDistance);
 	TOptional<FHitResult> Hit = RaytraceForFirstHit(StartEnd);
+
 	if (!Hit.IsSet())
 	{
 		if(InteractionRayVisibility==EInteractionRayVisibility::VisibleOnHoverOnly)
@@ -144,9 +145,35 @@ void UBasicVRInteractionComponent::TickComponent(float DeltaTime, ELevelTick Tic
 			InteractionRay->SetVisibility(false);
 		}
 		return;
+
+		// Execute leave event on the actor that lost the focus if there was one
+		if (LastActorHit && LastActorHit->Implements<UTargetable>())
+		{
+				ITargetable::Execute_OnTargetedLeave(LastActorHit);
+		}
+
+		LastActorHit = nullptr;
+		return;
 	}
+	
 	AActor* HitActor = Hit->GetActor();
 
+	// Execute Leave and enter events when the focused actor changed
+	if (HitActor != LastActorHit)
+	{
+		//We can always execute the enter event as we are sure that a hit occured
+		if (HitActor->Implements<UTargetable>())
+		{
+			ITargetable::Execute_OnTargetedEnter(HitActor);
+		}
+
+		//Only execute the Leave Event if there was an actor that was focused previously
+		if (LastActorHit != nullptr && LastActorHit->Implements<UTargetable>())
+		{
+			ITargetable::Execute_OnTargetedLeave(LastActorHit);
+		}
+	}
+
 	// for now uses the same distance as clicking
 	if (HitActor->Implements<UTargetable>() && Hit->Distance < MaxClickDistance)
 	{
@@ -166,6 +193,7 @@ void UBasicVRInteractionComponent::TickComponent(float DeltaTime, ELevelTick Tic
 			InteractionRay->SetVisibility(false);
 		}
 	}
+	LastActorHit = HitActor; // Store the actor that was hit to have access to it in the next frame as well
 }
 
 void UBasicVRInteractionComponent::Initialize(USceneComponent* RayEmitter, float InMaxGrabDistance, float InMaxClickDistance)
diff --git a/Source/DisplayClusterExtensions/Public/Cluster/CAVEOverlay/CAVEOverlayController.h b/Source/DisplayClusterExtensions/Public/Cluster/CAVEOverlay/CAVEOverlayController.h
index 6bec3d500bd571cc60fc9ab85790f17b9eec8009..d73f121425cbb57cc73e9b962bdd80027e913d74 100644
--- a/Source/DisplayClusterExtensions/Public/Cluster/CAVEOverlay/CAVEOverlayController.h
+++ b/Source/DisplayClusterExtensions/Public/Cluster/CAVEOverlay/CAVEOverlayController.h
@@ -3,7 +3,6 @@
 #include "CoreMinimal.h"
 #include "GameFramework/Actor.h"
 #include "Cluster/CAVEOverlay/DoorOverlayData.h"
-#include "Pawn/VirtualRealityPawn.h"
 #include "Cluster/IDisplayClusterClusterManager.h"
 #include "Cluster/DisplayClusterClusterEvent.h"
 #include "CAVEOverlayController.generated.h"
@@ -25,47 +24,46 @@ protected:
 
 private:
 	//Execution Modes
-	bool bCAVE_Mode = false;
+	bool bCAVEMode = false;
 
 	//Screen Types
 	enum EScreen_Type { SCREEN_MASTER, SCREEN_NORMAL, SCREEN_DOOR_PARTIAL, SCREEN_DOOR };
 
-	EScreen_Type Screen_Type = SCREEN_NORMAL;
-	const TArray<FString> Screens_Door = {"node_bul_left_eye", "node_bul_right_eye", "node_bll_left_eye", "node_bll_right_eye"};
-	const TArray<FString> Screens_Door_Partial = {"node_bur_left_eye", "node_bur_right_eye", "node_blr_left_eye", "node_blr_right_eye"};
-	const TArray<FString> Screens_FPS = {"node_rur_left_eye", "node_rur_right_eye", "node_lur_left_eye", "node_lur_right_eye", "node_main"};
-	const FString Screen_Main = "node_main";
+	EScreen_Type ScreenType = SCREEN_NORMAL;
+	const TArray<FString> ScreensDoor = {"node_bul_left_eye", "node_bul_right_eye", "node_bll_left_eye", "node_bll_right_eye"};
+	const TArray<FString> ScreensDoorPartial = {"node_bur_left_eye", "node_bur_right_eye", "node_blr_left_eye", "node_blr_right_eye"};
+	const TArray<FString> ScreensFPS = {"node_rur_left_eye", "node_rur_right_eye", "node_lur_left_eye", "node_lur_right_eye", "node_main"};
+	const FString ScreenMain = "node_main";
 
 	//Door Mode
-	enum EDoor_Mode { DOOR_PARTIALLY_OPEN = 0, DOOR_OPEN = 1, DOOR_CLOSED = 2, DOOR_DEBUG = 3, DOOR_NUM_MODES = 4 };
-
-	const FString Door_Mode_Names[DOOR_NUM_MODES] = {"Partially Open", "Open", "Closed", "Debug"};
-	EDoor_Mode Door_Current_Mode = DOOR_PARTIALLY_OPEN;
-	const float Door_Opening_Width_Relative = 0.522; //%, used for the overlay width on the screen
-	const float Door_Opening_Width_Absolute = 165; //cm, used for the non tape part at the door
-	const float Wall_Distance = 262.5; //cm, distance from center to a wall, *2 = wall width
-	const float Wall_Close_Distance = 75; //cm, the distance considered to be too close to the walls
-	const float Wall_Fade_Distance = 35; //cm, the distance over which the tape is faded
-	const float Wall_Warning_Distance = 40; //cm, distance on which the tape turns red, measured from wall
-	float Door_Current_Opening_Width_Absolute = 0;
+	enum EDoorMode { DOOR_PARTIALLY_OPEN = 0, DOOR_OPEN = 1, DOOR_CLOSED = 2, DOOR_DEBUG = 3, DOOR_NUM_MODES = 4 };
+
+	const FString DoorModeNames[DOOR_NUM_MODES] = {"Partially Open", "Open", "Closed", "Debug"};
+	EDoorMode DoorCurrentMode = DOOR_PARTIALLY_OPEN;
+	const float DoorOpeningWidthRelative = 0.522; //%, used for the overlay width on the screen
+	const float DoorOpeningWidthAbsolute = 165; //cm, used for the non tape part at the door
+	const float WallDistance = 262.5; //cm, distance from center to a wall, *2 = wall width
+	const float WallCloseDistance = 75; //cm, the distance considered to be too close to the walls
+	const float WallFadeDistance = 35; //cm, the distance over which the tape is faded
+	const float WallWarningDistance = 40; //cm, distance on which the tape turns red, measured from wall
+	float DoorCurrentOpeningWidthAbsolute = 0;
 
 	//Overlay
-	TSubclassOf<class UDoorOverlayData> Overlay_Class;
+	TSubclassOf<class UDoorOverlayData> OverlayClass;
 	UPROPERTY() UDoorOverlayData* Overlay;
 
 	//Geometry and Material
 	UStaticMeshComponent* CreateMeshComponent(const FName& Name, UStaticMesh* Mesh, USceneComponent* Parent);
-	UPROPERTY() UMaterial* Tape_Material = nullptr;
-	UPROPERTY() UMaterial* Sign_Material = nullptr;
-	float CalculateOpacityFromPosition(FVector Position);
-	bool PositionInDoorOpening(FVector Position);
+	UPROPERTY() UMaterial* TapeMaterial = nullptr;
+	UPROPERTY() UMaterial* SignMaterial = nullptr;
+	float CalculateOpacityFromPosition(FVector Position) const;
+	bool PositionInDoorOpening(FVector Position) const;
 
 	//Pawn Components
-	bool bAttached = false;
-	void RefreshPawnComponents();
-	UPROPERTY() AVirtualRealityPawn* Player_Pawn;
-	UPROPERTY() USceneComponent* Cave_Origin;
+	bool bAttachedToCAVEOrigin = false;
+	UPROPERTY() USceneComponent* CaveOrigin;
 	UPROPERTY() USceneComponent* Head;
+	UPROPERTY() USceneComponent* Flystick;
 
 	//Cluster Events
 	FOnClusterEventJsonListener ClusterEventListenerDelegate;
@@ -77,24 +75,24 @@ public:
 	virtual void Tick(float DeltaTime) override;
 
 	void CycleDoorType();
-	void SetDoorMode(EDoor_Mode M);
+	void SetDoorMode(EDoorMode M);
 
 	//Signs and Banners
 	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) USceneComponent* Root = nullptr;
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) USceneComponent* Tape_Root = nullptr;
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) USceneComponent* Sign_Root = nullptr;
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* Tape_Negative_Y = nullptr;
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* Tape_Negative_X = nullptr;
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* Tape_Positive_Y = nullptr;
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* Tape_Positive_X = nullptr;
-
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* Sign_Negative_Y = nullptr;
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* Sign_Negative_X = nullptr;
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* Sign_Positive_Y = nullptr;
-	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* Sign_Positive_X = nullptr;
-
-	UPROPERTY() UMaterialInstanceDynamic* Tape_Material_Dynamic_ = nullptr;
-	UPROPERTY() UMaterialInstanceDynamic* Sign_Material_Dynamic_ = nullptr;
-	UPROPERTY() UStaticMesh* Plane_Mesh_ = nullptr;
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) USceneComponent* TapeRoot = nullptr;
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) USceneComponent* SignRoot = nullptr;
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* TapeNegativeY = nullptr;
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* TapeNegativeX = nullptr;
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* TapePositiveY = nullptr;
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* TapePositiveX = nullptr;
+
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* SignNegativeY = nullptr;
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* SignNegativeX = nullptr;
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* SignPositiveY = nullptr;
+	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "CAVEOverlay", meta = (AllowPrivateAccess = "true")) UStaticMeshComponent* SignPositiveX = nullptr;
+
+	UPROPERTY() UMaterialInstanceDynamic* TapeMaterialDynamic = nullptr;
+	UPROPERTY() UMaterialInstanceDynamic* SignMaterialDynamic = nullptr;
+	UPROPERTY() UStaticMesh* PlaneMesh = nullptr;
 };
diff --git a/Source/DisplayClusterExtensions/Public/Interaction/Targetable.h b/Source/DisplayClusterExtensions/Public/Interaction/Targetable.h
index a11da8bd223ecfdc4f66863eabc70d71ee5f15e8..334eebb35b1786d484a79c731c384a26dde1efe9 100644
--- a/Source/DisplayClusterExtensions/Public/Interaction/Targetable.h
+++ b/Source/DisplayClusterExtensions/Public/Interaction/Targetable.h
@@ -19,7 +19,15 @@ class ITargetable
 	GENERATED_IINTERFACE_BODY()
 
 public:
-	// function that will be called when clickable actor got clicked, and passed the world pos of the click
+	// function that will be called when targetable actor is targeted, the world pos of the target is returned
 	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = Gameplay)
 	void OnTargeted(FVector WorldPositionOfTarget);
+	
+	//function that will be called when a targetable actor gets focused
+	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = Gameplay)
+	void OnTargetedEnter();
+
+	//function that will be called when a targetable actor loses focused
+	UFUNCTION(BlueprintNativeEvent, BlueprintCallable, Category = Gameplay)
+	void OnTargetedLeave();
 };
diff --git a/Source/DisplayClusterExtensions/Public/Pawn/BasicVRInteractionComponent.h b/Source/DisplayClusterExtensions/Public/Pawn/BasicVRInteractionComponent.h
index b7609aaa488c0086afb166bf665bd9e1a5ba893f..b096d5f74a1583dee359d4ba1c607fed97463e79 100644
--- a/Source/DisplayClusterExtensions/Public/Pawn/BasicVRInteractionComponent.h
+++ b/Source/DisplayClusterExtensions/Public/Pawn/BasicVRInteractionComponent.h
@@ -57,6 +57,8 @@ private:
 	UPROPERTY() USceneComponent* InteractionRayEmitter = nullptr;
 	UPROPERTY() UStaticMeshComponent* InteractionRay = nullptr;
 	
+	/* Stores the reference of the Actor that was hit in the last frame*/
+	UPROPERTY() AActor* LastActorHit = nullptr;
 	void HandlePhysicsAndAttachActor(AActor* HitActor);
 	FTwoVectors GetHandRay(float Length) const;
 	TOptional<FHitResult> RaytraceForFirstHit(const FTwoVectors& Ray) const;