Virtual Reality Scene Explorer C++, Unreal Engine

```cpp
// Fill out your copyright notice in the Description page of Project Settings.

#include "VRSceneExplorer.h"
#include "HeadMountedDisplayFunctionLibrary.h" // For VR Headset functionality
#include "MotionControllerComponent.h"      // For Motion Controllers
#include "Kismet/GameplayStatics.h"        // For getting all actors of a class
#include "Components/StaticMeshComponent.h" // For manipulating static meshes


// Sets default values
AVRSceneExplorer::AVRSceneExplorer()
{
 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

	// Create a root component.  This will be the world origin for our VR experience.
	VRRoot = CreateDefaultSubobject<USceneComponent>(TEXT("VRRoot"));
	RootComponent = VRRoot;

	// Create the Camera component and attach it to the VRRoot.
	Camera = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));
	Camera->SetupAttachment(VRRoot);

	// Create left hand motion controller
	LeftMotionController = CreateDefaultSubobject<UMotionControllerComponent>(TEXT("LeftMotionController"));
	LeftMotionController->SetupAttachment(VRRoot);
	LeftMotionController->MotionSource = FXRMotionControllerBase::LeftHand;

	// Create right hand motion controller
	RightMotionController = CreateDefaultSubobject<UMotionControllerComponent>(TEXT("RightMotionController"));
	RightMotionController->SetupAttachment(VRRoot);
	RightMotionController->MotionSource = FXRMotionControllerBase::RightHand;

	// Create a Static Mesh Component for visual representation of the left controller
	LeftControllerMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("LeftControllerMesh"));
	LeftControllerMesh->SetupAttachment(LeftMotionController);

	// Create a Static Mesh Component for visual representation of the right controller
	RightControllerMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("RightControllerMesh"));
	RightControllerMesh->SetupAttachment(RightMotionController);
}

// Called when the game starts or when spawned
void AVRSceneExplorer::BeginPlay()
{
	Super::BeginPlay();

	// Check if VR is enabled.  If not, we might need to enable it (if desired).
	UHeadMountedDisplayFunctionLibrary::EnableHMD(true);  // Enable VR
	UHeadMountedDisplayFunctionLibrary::SetTrackingOrigin(EHMDTrackingOrigin::Floor); // Set tracking origin

	// Find all Static Mesh Actors in the scene.
	TArray<AActor*> FoundActors;
	UGameplayStatics::GetAllActorsOfClass(GetWorld(), AStaticMeshActor::StaticClass(), FoundActors);

	for (AActor* Actor : FoundActors)
	{
		AStaticMeshActor* MeshActor = Cast<AStaticMeshActor>(Actor);
		if (MeshActor)
		{
			AllStaticMeshes.Add(MeshActor);
		}
	}
}

// Called every frame
void AVRSceneExplorer::Tick(float DeltaTime)
{
	Super::Tick(DeltaTime);

	// Check for input and perform actions (example: teleport)
	HandleInput();
}

// Called to bind functionality to input
void AVRSceneExplorer::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);

	// Bind input actions (e.g., a teleport action)
	PlayerInputComponent->BindAction("Teleport", IE_Pressed, this, &AVRSceneExplorer::Teleport);
}

void AVRSceneExplorer::Teleport()
{
	// Simple Teleportation logic.  You can make this more sophisticated (e.g., using a parabolic arc)

	FHitResult HitResult;
	FVector Start = Camera->GetComponentLocation();  // Start from the camera's location
	FVector End = Start + Camera->GetForwardVector() * TeleportDistance; // Teleport a certain distance forward

	FCollisionQueryParams QueryParams;
	QueryParams.AddIgnoredActor(this); // Ignore the player actor in the collision check

	// Perform a line trace to check for obstacles
	bool bHit = GetWorld()->LineTraceSingleByChannel(HitResult, Start, End, ECC_Visibility, QueryParams);

	if (bHit)
	{
		// Teleport to the hit location (slightly above the ground to avoid getting stuck)
		SetActorLocation(HitResult.Location + FVector(0, 0, 50));
	}
	else
	{
		// Teleport to the end location of the trace.
		SetActorLocation(End + FVector(0, 0, 50));
	}
}


void AVRSceneExplorer::HandleInput()
{
	// Example: Rotate an object in the scene
	if (AllStaticMeshes.Num() > 0 && bRotateObject)
	{
		// Rotate the first static mesh actor in the list.
		AStaticMeshActor* MeshToRotate = AllStaticMeshes[0];

		if (MeshToRotate)
		{
			FRotator RotationToAdd = FRotator(0.0f, RotationSpeed * GetWorld()->DeltaTimeSeconds, 0.0f);
			MeshToRotate->AddActorLocalRotation(RotationToAdd);
		}
	}


    //Example: Change material of an object
	if(AllStaticMeshes.Num() > 0 && bChangeMaterial)
	{
		AStaticMeshActor* MeshToChange = AllStaticMeshes[0];

		if(MeshToChange)
		{
			UStaticMeshComponent* MeshComponent = MeshToChange->GetStaticMeshComponent();

			if(MeshComponent && NewMaterial != nullptr)
			{
				MeshComponent->SetMaterial(0,NewMaterial);
			}

			//Set bChangeMaterial to false to only change the material once
			bChangeMaterial = false;
		}
	}
}
```

**Explanation:**

This C++ code provides a basic framework for creating a VR Scene Explorer in Unreal Engine.  It includes features like VR setup, motion controller integration, teleportation, and basic object manipulation.  Here's a breakdown of the code:

**1. Header (`VRSceneExplorer.h` - Implicit):**

While not explicitly shown, the header file would declare the class `AVRSceneExplorer` which inherits from `AActor`.  It would also declare the member variables listed below and the functions declared in the .cpp file.

**2. Includes:**

*   `VRSceneExplorer.h`: The header file for this class.
*   `HeadMountedDisplayFunctionLibrary.h`:  Provides functions for enabling and managing VR headsets.
*   `MotionControllerComponent.h`:  Provides components for representing and tracking motion controllers.
*   `Kismet/GameplayStatics.h`: Provides static helper functions for various game-related tasks, like finding all actors of a specific class.
*   `Components/StaticMeshComponent.h`:  Provides components that represent static meshes (3D models).

**3. Class Definition (`AVRSceneExplorer`):**

*   **Inheritance:** `AVRSceneExplorer` inherits from `AActor`, meaning it's an object that can be placed in the Unreal Engine world.
*   **Components:**
    *   `VRRoot`:  A `USceneComponent` that acts as the root of the VR rig.  All other VR components are attached to this.  This allows you to move the entire VR rig as a single unit.
    *   `Camera`: A `UCameraComponent` that represents the player's viewpoint in VR. It is attached to `VRRoot`.
    *   `LeftMotionController`: A `UMotionControllerComponent` that tracks the left hand motion controller.
    *   `RightMotionController`: A `UMotionControllerComponent` that tracks the right hand motion controller.
    *   `LeftControllerMesh`:  A `UStaticMeshComponent` that provides a visual representation of the left controller in the scene.
    *   `RightControllerMesh`: A `UStaticMeshComponent` that provides a visual representation of the right controller in the scene.
    *   `AllStaticMeshes`: A `TArray` to store all `AStaticMeshActor` found in the scene.
    *  `NewMaterial`: A `UMaterialInterface` pointer to hold a new material to be applied to the Static Mesh.
*   **Variables:**
    *   `TeleportDistance`: A `float` that determines the distance the player teleports.  (Note: Should be marked `UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "VR")` in the header file to make it configurable in the Unreal Editor.)
    *   `RotationSpeed`: A `float` that controls the rotation speed of the object. (Note: Should be marked `UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "VR")` in the header file to make it configurable in the Unreal Editor.)
    *   `bRotateObject`: A `bool` that determines whether to rotate the first object found in the scene. (Note: Should be marked `UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "VR")` in the header file to make it configurable in the Unreal Editor.)
		*   `bChangeMaterial`: A `bool` that determines whether to change the material of the first object found in the scene. (Note: Should be marked `UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "VR")` in the header file to make it configurable in the Unreal Editor.)
*   **Constructor (`AVRSceneExplorer()`):**
    *   Sets `PrimaryActorTick.bCanEverTick = true;`  This enables the `Tick()` function to be called every frame.
    *   Creates and attaches the components to the `VRRoot`. This establishes the hierarchy of the VR rig.  `SetupAttachment()` attaches the component to the specified parent.  `CreateDefaultSubobject()` is used to create instances of Unreal Engine's component classes within the actor.
*   **`BeginPlay()`:**
    *   `Super::BeginPlay();`:  Calls the `BeginPlay()` function of the parent class (`AActor`). This is important for proper initialization.
    *   `UHeadMountedDisplayFunctionLibrary::EnableHMD(true);`:  Enables the VR headset.
    *   `UHeadMountedDisplayFunctionLibrary::SetTrackingOrigin(EHMDTrackingOrigin::Floor);`: Sets the tracking origin to the floor. This means the origin (0,0,0) of the VR space will be at floor level.
    *   `UGameplayStatics::GetAllActorsOfClass()`:  Finds all actors in the scene that are instances of `AStaticMeshActor` (i.e., static meshes).  The result is stored in `FoundActors`.
    *   Iterates through `FoundActors` and casts each actor to `AStaticMeshActor*`. If the cast is successful (meaning the actor is a static mesh), it's added to the `AllStaticMeshes` array.
*   **`Tick(float DeltaTime)`:**
    *   `Super::Tick(DeltaTime);`: Calls the `Tick()` function of the parent class.
    *   `HandleInput();`:  Calls the `HandleInput()` function to process player input (e.g., teleportation, rotation).  `DeltaTime` represents the time elapsed since the last frame, which is essential for frame-rate independent movement and rotation.
*   **`SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)`:**
    *   This function is overridden to bind input actions to functions in the C++ class.
    *   `PlayerInputComponent->BindAction("Teleport", IE_Pressed, this, &AVRSceneExplorer::Teleport);`:  Binds the "Teleport" input action (which you'd define in the Unreal Engine project settings) to the `Teleport()` function.  `IE_Pressed` means the action is triggered when the button is pressed.  `this` refers to the current instance of the `AVRSceneExplorer` class, and `&AVRSceneExplorer::Teleport` is a pointer to the `Teleport()` function.
*   **`Teleport()`:**
    *   Implements a simple teleportation mechanic.
    *   `FHitResult HitResult;`:  A struct to store information about what the line trace hits.
    *   `FVector Start = Camera->GetComponentLocation();`:  Gets the location of the camera component (the player's current viewpoint).
    *   `FVector End = Start + Camera->GetForwardVector() * TeleportDistance;`:  Calculates the teleport destination by adding the camera's forward vector multiplied by the `TeleportDistance` to the starting location.
    *   `FCollisionQueryParams QueryParams;`:  Specifies collision parameters for the line trace.
    *   `QueryParams.AddIgnoredActor(this);`: Prevents the line trace from colliding with the player actor itself.
    *   `GetWorld()->LineTraceSingleByChannel()`: Performs a line trace (a raycast) from the start location to the end location.  It checks for collisions along the line.
        *   `ECC_Visibility` specifies the collision channel to use for the trace (Visibility channel is a common choice).
    *   If the line trace hits something (`bHit` is true):
        *   Teleports the actor to the hit location, slightly above the ground.
    *   If the line trace doesn't hit anything:
        *   Teleports the actor to the end of the trace.
*   **`HandleInput()`:**
    *   Example of rotating a static mesh: If `AllStaticMeshes` has elements and `bRotateObject` is true, it rotates the first static mesh in the array.
    *   Example of changing a material: If `AllStaticMeshes` has elements and `bChangeMaterial` is true, it changes the material of the first static mesh to the `NewMaterial`. Sets `bChangeMaterial` to `false` to prevent continuously changing the material every frame.

**How to Use This Code in Unreal Engine:**

1.  **Create a New C++ Class:** In the Unreal Editor, create a new C++ class that inherits from `Actor` (or `Pawn` if you want player-controlled movement). Name it `VRSceneExplorer`.
2.  **Replace the Code:** Replace the contents of the generated `.h` and `.cpp` files with the code provided above.  **IMPORTANT:**  In the `.h` file, you'll need to *declare* all the member variables (e.g., `UPROPERTY()` for the variables you want to expose in the editor). For Example:

```c++
// VRSceneExplorer.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "VRSceneExplorer.generated.h"

UCLASS()
class MYPROJECT_API AVRSceneExplorer : public AActor
{
	GENERATED_BODY()

public:
	// Sets default values for this actor's properties
	AVRSceneExplorer();

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;

public:
	// Called every frame
	virtual void Tick(float DeltaTime) override;

	// Called to bind functionality to input
	virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;

	UFUNCTION()
	void Teleport();

private:
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "VR", meta = (AllowPrivateAccess = "true"))
	USceneComponent* VRRoot;

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "VR", meta = (AllowPrivateAccess = "true"))
	UCameraComponent* Camera;

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "VR", meta = (AllowPrivateAccess = "true"))
	UMotionControllerComponent* LeftMotionController;

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "VR", meta = (AllowPrivateAccess = "true"))
	UMotionControllerComponent* RightMotionController;

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "VR", meta = (AllowPrivateAccess = "true"))
	UStaticMeshComponent* LeftControllerMesh;

	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "VR", meta = (AllowPrivateAccess = "true"))
	UStaticMeshComponent* RightControllerMesh;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "VR")
	float TeleportDistance = 1000.0f;

	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "VR")
	float RotationSpeed = 50.0f;

	UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "VR")
	bool bRotateObject = false;

    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "VR")
	bool bChangeMaterial = false;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "VR", meta = (AllowPrivateAccess = "true"))
    UMaterialInterface* NewMaterial;


	TArray<AStaticMeshActor*> AllStaticMeshes;

	void HandleInput();
};
```

3.  **Compile the Code:**  Compile the C++ code within the Unreal Editor.

4.  **Create a Blueprint Class:** Create a new Blueprint class based on your `VRSceneExplorer` C++ class.
5.  **Configure Components (Blueprint):** In the Blueprint editor:
    *   Select the `LeftControllerMesh` and `RightControllerMesh` components.  In the details panel, assign a Static Mesh asset to the "Static Mesh" property.  This will determine the visual model for the controllers. You can use the default cube or find a controller model.
    *   Adjust the `TeleportDistance`, `RotationSpeed` and `bRotateObject` values in the Details panel (under the "VR" category).
	*	Assign a material to `NewMaterial`.
6.  **Set up Input Bindings:**  Go to Project Settings -> Input.
    *   Create a new Action Mapping called "Teleport".
    *   Assign a key (e.g., a button on your VR controller) to the "Teleport" action.

7.  **Add to the Scene:** Drag an instance of your `VRSceneExplorer` Blueprint into your Unreal Engine level.
8.  **Set as Default Pawn (Optional):** If you are using this as your player, go to Project Settings -> Maps & Modes, and set the "Default Pawn Class" to your `VRSceneExplorer` Blueprint.

9.  **Add Static Meshes:**  Add some `StaticMeshActor` objects to your scene. These are the objects you'll be able to explore and manipulate in VR.
10. **Run in VR:** Make sure your VR headset is connected and enabled, and then run the game in VR preview mode.

**Key Improvements and Considerations:**

*   **Error Handling:** The code lacks robust error handling.  You should add checks to ensure that the `AllStaticMeshes` array isn't empty before trying to access elements in it.  Also, check for null pointers before dereferencing them.
*   **Input Handling:** The `HandleInput()` function is very basic.  You would typically use input events from the motion controllers (e.g., trigger presses, button presses, joystick movement) to control more complex interactions.
*   **Teleportation:** The teleportation is simplistic.  A more sophisticated system would:
    *   Use a parabolic arc to visualize the teleport destination.
    *   Check for valid teleport locations (e.g., prevent teleporting into walls).
    *   Provide visual feedback about whether a location is safe to teleport to.
*   **Motion Controller Meshes:**  Make sure you assign appropriate Static Mesh assets to the `LeftControllerMesh` and `RightControllerMesh` components so the controllers are visible in the VR world.
*   **Interaction System:**  A key part of a VR scene explorer is a good interaction system.  You'll need to implement ways to:
    *   Select objects.
    *   Move objects.
    *   Rotate objects.
    *   Interact with UI elements.
*   **Performance:** VR development is performance-sensitive.  Optimize your scene for VR by:
    *   Using efficient static meshes.
    *   Reducing draw calls.
    *   Using level of detail (LOD) meshes.
    *   Profiling your code to identify bottlenecks.
*  **Material Handling:** Ensure your `NewMaterial` variable is properly assigned with a valid material asset in the Unreal Editor.
* **VR Template:** Starting with the Unreal Engine VR template is a great way to get a basic VR project set up with locomotion and interaction.

This example provides a solid foundation.  You'll need to expand upon it to create a fully functional and engaging VR scene explorer.