Unreal Engine开发：虚拟摄像机开发_C++与蓝图实现虚拟摄像机

C++与蓝图实现虚拟摄像机

在Unreal Engine中，虚拟摄像机是游戏中一个非常重要的元素，它负责捕捉和展示游戏世界中的视角。本节将详细介绍如何使用C++和蓝图来实现虚拟摄像机的功能，包括摄像机的基本设置、移动和旋转、以及高级摄像机效果的实现。

摄像机的基本设置

在Unreal Engine中，虚拟摄像机的基本设置可以通过创建一个新的摄像机组件（Camera Component）来实现。摄像机组件可以附加到任何游戏对象（如角色、车辆等）上，从而实现跟随功能。

使用C++创建摄像机组件

首先，我们需要在C++中创建一个新的摄像机组件。假设我们正在开发一个角色控制类，名为MyCharacter，我们可以在其头文件中添加一个摄像机组件。


// MyCharacter.h

#pragma once



#include "CoreMinimal.h"

#include "GameFramework/Character.h"

#include "Camera/CameraComponent.h"

#include "MyCharacter.generated.h"



UCLASS()

class MYGAME_API AMyCharacter : public ACharacter

{
    
    

    GENERATED_BODY()



public:

    // 构造函数

    AMyCharacter();



protected:

    // 摄像机组件

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))

    UCameraComponent* MyCamera;



    // 重载父类函数

    virtual void BeginPlay() override;



public:

    // 重载父类函数

    virtual void Tick(float DeltaTime) override;

};

在源文件中，我们需要初始化和设置这个摄像机组件。


// MyCharacter.cpp

#include "MyCharacter.h"



AMyCharacter::AMyCharacter()

{
    
    

    // 创建摄像机组件

    MyCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("MyCamera"));



    // 设置摄像机组件的位置

    MyCamera->SetupAttachment(RootComponent);

    MyCamera->SetRelativeLocation(FVector(0.0f, 0.0f, 64.0f)); // 例如，将摄像机放置在角色上方64单位

    MyCamera->bUsePawnControlRotation = true; // 使摄像机跟随角色的旋转

}



void AMyCharacter::BeginPlay()

{
    
    

    Super::BeginPlay();

    // 可以在这里进行更多的初始设置

}



void AMyCharacter::Tick(float DeltaTime)

{
    
    

    Super::Tick(DeltaTime);

    // 可以在这里进行每帧的更新逻辑

}

摄像机的移动和旋转

虚拟摄像机的移动和旋转可以通过多种方式实现，包括直接操作摄像机组件的位置和旋转，或者使用输入绑定来控制摄像机的移动和旋转。

使用C++控制摄像机的移动和旋转

我们可以通过输入绑定来控制摄像机的移动和旋转。首先，需要在角色类中设置输入绑定。


// MyCharacter.h

#pragma once



#include "CoreMinimal.h"

#include "GameFramework/Character.h"

#include "Camera/CameraComponent.h"

#include "MyCharacter.generated.h"



UCLASS()

class MYGAME_API AMyCharacter : public ACharacter

{
    
    

    GENERATED_BODY()



public:

    // 构造函数

    AMyCharacter();



protected:

    // 摄像机组件

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))

    UCameraComponent* MyCamera;



    // 输入绑定

    virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;



    // 控制摄像机旋转的函数

    UFUNCTION()

    void Turn(float Value);



    // 控制摄像机移动的函数

    UFUNCTION()

    void MoveForward(float Value);

    UFUNCTION()

    void MoveRight(float Value);



    // 重载父类函数

    virtual void BeginPlay() override;

    virtual void Tick(float DeltaTime) override;

};

在源文件中，我们需要实现这些函数。


// MyCharacter.cpp

#include "MyCharacter.h"



AMyCharacter::AMyCharacter()

{
    
    

    // 创建摄像机组件

    MyCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("MyCamera"));



    // 设置摄像机组件的位置

    MyCamera->SetupAttachment(RootComponent);

    MyCamera->SetRelativeLocation(FVector(0.0f, 0.0f, 64.0f)); // 例如，将摄像机放置在角色上方64单位

    MyCamera->bUsePawnControlRotation = true; // 使摄像机跟随角色的旋转

}



void AMyCharacter::BeginPlay()

{
    
    

    Super::BeginPlay();

    // 可以在这里进行更多的初始设置

}



void AMyCharacter::Tick(float DeltaTime)

{
    
    

    Super::Tick(DeltaTime);

    // 可以在这里进行每帧的更新逻辑

}



void AMyCharacter::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)

{
    
    

    Super::SetupPlayerInputComponent(PlayerInputComponent);



    // 绑定输入到摄像机旋转

    PlayerInputComponent->BindAxis("Turn", this, &AMyCharacter::Turn);

    PlayerInputComponent->BindAxis("LookUp", this, &ACharacter::AddControllerPitchInput);



    // 绑定输入到角色移动

    PlayerInputComponent->BindAxis("MoveForward", this, &AMyCharacter::MoveForward);

    PlayerInputComponent->BindAxis("MoveRight", this, &AMyCharacter::MoveRight);

}



void AMyCharacter::Turn(float Value)

{
    
    

    if (Value != 0.0f)

    {
    
    

        // 添加控制器的偏航输入

        AddControllerYawInput(Value);

    }

}



void AMyCharacter::MoveForward(float Value)

{
    
    

    if (Value != 0.0f)

    {
    
    

        // 获取当前控制器的前向向量

        const FRotator Rotation = Controller->GetControlRotation();

        const FVector Direction = FRotationMatrix(Rotation).GetUnitAxis(EAxis::X);

        AddMovementInput(Direction, Value);

    }

}



void AMyCharacter::MoveRight(float Value)

{
    
    

    if (Value != 0.0f)

    {
    
    

        // 获取当前控制器的右向向量

        const FRotator Rotation = Controller->GetControlRotation();

        const FVector Direction = FRotationMatrix(Rotation).GetUnitAxis(EAxis::Y);

        AddMovementInput(Direction, Value);

    }

}

蓝图实现虚拟摄像机

除了C++，Unreal Engine还提供了蓝图（Blueprint）系统，使得非程序员也可以方便地实现虚拟摄像机的功能。我们可以使用蓝图来创建一个简单的虚拟摄像机。

创建蓝图摄像机组件

打开Unreal Engine编辑器，创建一个新的角色蓝图（例如BP_MyCharacter）。
在蓝图编辑器中，点击“添加组件”按钮，添加一个新的摄像机组件。
选择摄像机组件，设置其相对位置和旋转，例如将摄像机放置在角色上方64单位。

使用蓝图控制摄像机的移动和旋转

在角色蓝图的“事件图表”（Event Graph）中，右键点击并选择“添加事件”。
选择“输入轴”（Input Axis）事件，例如“Turn”和“LookUp”。
拖动事件节点，添加“添加控制器偏航输入”（Add Controller Yaw Input）和“添加控制器俯仰输入”（Add Controller Pitch Input）节点。

选择“输入轴”事件，例如“MoveForward”和“MoveRight”。
拖动事件节点，添加“获取控制器旋转”（Get Control Rotation）节点。
使用“旋转矩阵”（Rotation Matrix）节点获取前向和右向向量。
使用“添加移动输入”（Add Movement Input）节点来控制角色的移动。

高级摄像机效果

除了基本的摄像机移动和旋转，Unreal Engine还提供了许多高级摄像机效果，如平滑跟随、摄像机抖动、摄像机切换等。

平滑跟随效果

平滑跟随效果可以使得摄像机在跟随目标时更加自然。我们可以通过C++来实现这一效果。


// MyCharacter.h

#pragma once



#include "CoreMinimal.h"

#include "GameFramework/Character.h"

#include "Camera/CameraComponent.h"

#include "Components/SceneComponent.h"

#include "MyCharacter.generated.h"



UCLASS()

class MYGAME_API AMyCharacter : public ACharacter

{
    
    

    GENERATED_BODY()



public:

    // 构造函数

    AMyCharacter();



protected:

    // 摄像机组件

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))

    UCameraComponent* MyCamera;



    // 平滑跟随的目标组件

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))

    USceneComponent* FollowTarget;



    // 平滑跟随的速度

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Camera)

    float FollowSpeed;



    // 重载父类函数

    virtual void BeginPlay() override;

    virtual void Tick(float DeltaTime) override;

};

在源文件中，我们需要实现平滑跟随的逻辑。


// MyCharacter.cpp

#include "MyCharacter.h"



AMyCharacter::AMyCharacter()

{
    
    

    // 创建摄像机组件

    MyCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("MyCamera"));



    // 创建平滑跟随的目标组件

    FollowTarget = CreateDefaultSubobject<USceneComponent>(TEXT("FollowTarget"));

    FollowTarget->SetupAttachment(RootComponent);

    FollowTarget->SetRelativeLocation(FVector(0.0f, 0.0f, 64.0f)); // 例如，将目标组件放置在角色上方64单位



    // 设置平滑跟随的速度

    FollowSpeed = 10.0f;

}



void AMyCharacter::BeginPlay()

{
    
    

    Super::BeginPlay();

    // 可以在这里进行更多的初始设置

}



void AMyCharacter::Tick(float DeltaTime)

{
    
    

    Super::Tick(DeltaTime);



    // 计算摄像机的目标位置

    FVector TargetLocation = FollowTarget->GetComponentLocation();



    // 使用插值函数实现平滑跟随

    FVector NewLocation = FMath::VInterpTo(MyCamera->GetComponentLocation(), TargetLocation, DeltaTime, FollowSpeed);

    MyCamera->SetWorldLocation(NewLocation);

}

摄像机抖动效果

摄像机抖动效果可以增强游戏的真实感。我们可以通过C++来实现这一效果。


// MyCharacter.h

#pragma once



#include "CoreMinimal.h"

#include "GameFramework/Character.h"

#include "Camera/CameraComponent.h"

#include "MyCharacter.generated.h"



UCLASS()

class MYGAME_API AMyCharacter : public ACharacter

{
    
    

    GENERATED_BODY()



public:

    // 构造函数

    AMyCharacter();



protected:

    // 摄像机组件

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))

    UCameraComponent* MyCamera;



    // 抖动效果的幅度

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Camera)

    float ShakeAmplitude;



    // 抖动效果的频率

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Camera)

    float ShakeFrequency;



    // 抖动效果的持续时间

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Camera)

    float ShakeDuration;



    // 抖动效果的时间计数器

    float ShakeTimeCounter;



    // 重载父类函数

    virtual void BeginPlay() override;

    virtual void Tick(float DeltaTime) override;



    // 开始抖动效果

    UFUNCTION(BlueprintCallable, Category = "Camera")

    void StartCameraShake();

};

在源文件中，我们需要实现抖动效果的逻辑。


// MyCharacter.cpp

#include "MyCharacter.h"

#include "GameFramework/PlayerController.h"



AMyCharacter::AMyCharacter()

{
    
    

    // 创建摄像机组件

    MyCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("MyCamera"));



    // 设置抖动效果的参数

    ShakeAmplitude = 5.0f;

    ShakeFrequency = 10.0f;

    ShakeDuration = 1.0f;

}



void AMyCharacter::BeginPlay()

{
    
    

    Super::BeginPlay();

    ShakeTimeCounter = 0.0f;

}



void AMyCharacter::Tick(float DeltaTime)

{
    
    

    Super::Tick(DeltaTime);



    // 如果抖动效果正在进行

    if (ShakeTimeCounter > 0.0f)

    {
    
    

        // 计算抖动效果

        const float ShakeOffset = FMath::Sin(ShakeTimeCounter * ShakeFrequency) * ShakeAmplitude;

        const FVector CurrentLocation = MyCamera->GetComponentLocation();

        const FVector NewLocation = CurrentLocation + FVector(ShakeOffset, 0.0f, 0.0f);

        MyCamera->SetWorldLocation(NewLocation);



        // 减少时间计数器

        ShakeTimeCounter -= DeltaTime;



        // 如果时间计数器小于等于0，停止抖动

        if (ShakeTimeCounter <= 0.0f)

        {
    
    

            MyCamera->SetWorldLocation(CurrentLocation);

        }

    }

}



void AMyCharacter::StartCameraShake()

{
    
    

    ShakeTimeCounter = ShakeDuration;

}

使用蓝图实现摄像机抖动效果

打开角色蓝图（例如BP_MyCharacter）。
在“事件图表”（Event Graph）中，右键点击并选择“添加事件”。
选择“开始摄像机抖动”（Start Camera Shake）事件。
拖动事件节点，添加一个“设置变量”（Set Variable）节点，将ShakeTimeCounter设置为ShakeDuration。
添加一个“延迟”（Delay）节点，设置延迟时间为ShakeDuration。
在延迟节点后，添加一个“设置变量”（Set Variable）节点，将ShakeTimeCounter设置为0。

摄像机切换

在某些情况下，我们可能需要在不同的摄像机之间进行切换，例如从第一人称切换到第三人称。我们可以通过C++和蓝图来实现这一功能。

使用C++实现摄像机切换

首先，我们需要在角色类中添加多个摄像机组件，并提供一个切换函数。假设我们已经在角色类中创建了两个摄像机组件：FirstPersonCamera 和 ThirdPersonCamera。


// MyCharacter.h

#pragma once



#include "CoreMinimal.h"

#include "GameFramework/Character.h"

#include "Camera/CameraComponent.h"

#include "MyCharacter.generated.h"



UCLASS()

class MYGAME_API AMyCharacter : public ACharacter

{
    
    

    GENERATED_BODY()



public:

    // 构造函数

    AMyCharacter();



protected:

    // 第一人称摄像机组件

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))

    UCameraComponent* FirstPersonCamera;



    // 第三人称摄像机组件

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))

    UCameraComponent* ThirdPersonCamera;



    // 当前使用的摄像机组件

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))

    UCameraComponent* ActiveCamera;



    // 重载父类函数

    virtual void BeginPlay() override;

    virtual void Tick(float DeltaTime) override;



    // 切换摄像机

    UFUNCTION(BlueprintCallable, Category = "Camera")

    void SwitchCamera();

};

在源文件中，我们需要实现摄像机组件的初始化和切换逻辑。


// MyCharacter.cpp

#include "MyCharacter.h"

#include "GameFramework/PlayerController.h"



AMyCharacter::AMyCharacter()

{
    
    

    // 创建第一人称摄像机组件

    FirstPersonCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));

    FirstPersonCamera->SetupAttachment(GetMesh(), TEXT("head")); // 将摄像头附加到角色头部

    FirstPersonCamera->bUsePawnControlRotation = true;



    // 创建第三人称摄像机组件

    ThirdPersonCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("ThirdPersonCamera"));

    ThirdPersonCamera->SetupAttachment(RootComponent);

    ThirdPersonCamera->SetRelativeLocation(FVector(-300.0f, 0.0f, 120.0f)); // 例如，将摄像机放置在角色后方300单位，上方120单位

    ThirdPersonCamera->bUsePawnControlRotation = true;



    // 设置初始摄像机

    ActiveCamera = FirstPersonCamera;

}



void AMyCharacter::BeginPlay()

{
    
    

    Super::BeginPlay();

    // 可以在这里进行更多的初始设置

}



void AMyCharacter::Tick(float DeltaTime)

{
    
    

    Super::Tick(DeltaTime);

    // 可以在这里进行每帧的更新逻辑

}



void AMyCharacter::SwitchCamera()

{
    
    

    if (ActiveCamera == FirstPersonCamera)

    {
    
    

        // 切换到第三人称摄像机

        ActiveCamera = ThirdPersonCamera;

    }

    else

    {
    
    

        // 切换到第一人称摄像机

        ActiveCamera = FirstPersonCamera;

    }



    // 设置当前摄像机

    APlayerController* PlayerController = Cast<APlayerController>(GetController());

    if (PlayerController)

    {
    
    

        PlayerController->SetViewTargetWithBlend(this, 0.5f); // 切换摄像机并进行平滑过渡

    }

}

使用蓝图实现摄像机切换

除了C++，我们还可以使用蓝图来实现摄像机切换功能。以下是详细步骤：

打开角色蓝图（例如BP_MyCharacter）。
在“事件图表”（Event Graph）中，右键点击并选择“添加事件”。
选择“切换摄像机”（Switch Camera）事件。
拖动事件节点，添加一个“条件判断”（Branch）节点，判断当前摄像机是否为第一人称摄像机。
在条件判断的两个分支中，分别设置当前摄像机。

具体步骤如下：

在蓝图编辑器中，打开BP_MyCharacter。
在“事件图表”（Event Graph）中，右键点击并选择“添加事件”。
选择“切换摄像机”（Switch Camera）事件。
拖动“切换摄像机”事件节点，添加一个“条件判断”（Branch）节点。
在“条件判断”节点的条件部分，使用“等于”（Equal）节点来判断当前摄像机（ActiveCamera）是否为第一人称摄像机（FirstPersonCamera）。
如果当前摄像机是第一人称摄像机，则设置当前摄像机为第三人称摄像机（ThirdPersonCamera），反之亦然。
使用“设置视图目标并混合”（Set View Target with Blend）节点来平滑过渡摄像机。


graph TD

    A[Switch Camera Event] --> B[Get ActiveCamera]

    B --> C[Is ActiveCamera Equal to FirstPersonCamera?]

    C -->|Yes| D[Set ActiveCamera to ThirdPersonCamera]

    C -->|No| E[Set ActiveCamera to FirstPersonCamera]

    D --> F[Set View Target with Blend (0.5s)]

    E --> G[Set View Target with Blend (0.5s)]

具体实现步骤如下：

右键点击“事件图表”中的空白区域，选择“添加事件” -> “切换摄像机”（Switch Camera）。
拖动“切换摄像机”事件节点，选择“添加节点” -> “获取变量” -> ActiveCamera。
拖动ActiveCamera节点，选择“添加节点” -> “等于”（Equal），然后设置另一个输入为FirstPersonCamera。
从“等于”节点拖出一个线，选择“添加节点” -> “条件判断”（Branch）。
从“条件判断”节点的“是”（Yes）分支拖出一个线，选择“添加节点” -> “设置变量” -> ActiveCamera，然后设置值为ThirdPersonCamera。
从“条件判断”节点的“否”（No）分支拖出一个线，选择“添加节点” -> “设置变量” -> ActiveCamera，然后设置值为FirstPersonCamera。
从两个“设置变量”节点分别拖出一个线，选择“添加节点” -> “玩家控制器” -> “获取玩家控制器”（Get Player Controller）。
从“获取玩家控制器”节点拖出一个线，选择“添加节点” -> “控制” -> “设置视图目标并混合”（Set View Target with Blend），设置混合时间为0.5秒。
将“设置视图目标并混合”节点的目标设置为this（当前角色）。

通过以上步骤，我们可以在蓝图中实现摄像机的平滑切换效果。

总结

在Unreal Engine中，虚拟摄像机的功能可以通过C++和蓝图两种方式来实现。C++提供了更强大的控制和性能优化，而蓝图则使得非程序员也能方便地实现复杂的摄像机逻辑。无论是基本的摄像机设置、移动和旋转，还是高级的摄像机效果如平滑跟随和摄像机抖动，Unreal Engine都提供了丰富的工具和API来帮助开发者实现这些功能。希望本节的内容能帮助你在游戏中实现更加丰富和自然的摄像机效果。
在这里插入图片描述