Unreal Engine开发：虚拟摄像机开发_UnrealEngine虚拟摄像机开发基础

企业开发 2025-04-08 10:57:11 阅读次数: 0

Unreal Engine虚拟摄像机开发基础

虚拟摄像机的基础概念

在Unreal Engine中，虚拟摄像机是用于捕捉游戏世界的视角的关键组件。它不仅决定了玩家看到的内容，还影响着游戏的整体视觉体验。虚拟摄像机可以通过多种方式来实现，包括静态摄像机、动态摄像机、第三方摄像机等。本节将详细介绍虚拟摄像机的基本概念及其在Unreal Engine中的应用。

静态摄像机

静态摄像机是最简单的摄像机类型，它固定在一个位置，视角和方向都不会改变。静态摄像机通常用于过场动画或特定的观察点。

例子：设置静态摄像机

  1. 打开Unreal Engine编辑器，创建一个新的场景。

  2. 在场景中放置一个静态摄像机（Static Camera）。

  3. 通过变换摄像机的位置和旋转角度，调整其视角。


// 在蓝图中设置静态摄像机的位置和旋转

AStaticCameraActor* StaticCamera = GetWorld()->SpawnActor<AStaticCameraActor>(AStaticCameraActor::StaticClass(), FVector(0, 0, 200), FRotator(0, -45, 0));

StaticCamera->SetActorLocation(FVector(0, 0, 200)); // 设置摄像机的位置

StaticCamera->SetActorRotation(FRotator(0, -45, 0)); // 设置摄像机的旋转角度

动态摄像机

动态摄像机可以移动和旋转，通常用于玩家控制的视角。动态摄像机可以通过脚本或蓝图来实现，以响应玩家的输入或游戏中的事件。

例子：实现一个简单的动态摄像机

  1. 创建一个新的C++类，继承自ACameraActor。

  2. 在类中添加输入处理逻辑，以便摄像机可以根据玩家的输入进行移动和旋转。


// MyDynamicCamera.h

#pragma once



#include "CoreMinimal.h"

#include "GameFramework/Actor.h"

#include "MyDynamicCamera.generated.h"



UCLASS()

class MYGAME_API AMyDynamicCamera : public ACameraActor

{
    
    

    GENERATED_BODY()

    

public:	

    // Sets default values for this actor's properties

    AMyDynamicCamera();



protected:

    // Called when the game starts or when spawned

    virtual void BeginPlay() override;



public:	

    // Called every frame

    virtual void Tick(float DeltaTime) override;



private:

    // 处理输入以移动摄像机

    void MoveForward(float Value);

    void MoveRight(float Value);



    // 处理输入以旋转摄像机

    void AddControllerPitchInput(float Value);

    void AddControllerYawInput(float Value);



    // 摄像机的移动速度

    UPROPERTY(EditAnywhere)

    float MoveSpeed;



    // 摄像机的旋转速度

    UPROPERTY(EditAnywhere)

    float RotateSpeed;

};



// MyDynamicCamera.cpp

#include "MyDynamicCamera.h"

#include "GameFramework/SpringArmComponent.h"

#include "GameFramework/PawnMovementComponent.h"

#include "Components/InputComponent.h"



AMyDynamicCamera::AMyDynamicCamera()

{
    
    

    // 设置默认移动和旋转速度

    MoveSpeed = 1000.0f;

    RotateSpeed = 50.0f;



    // 启用输入

    PrimaryActorTick.bCanEverTick = true;

}



void AMyDynamicCamera::BeginPlay()

{
    
    

    Super::BeginPlay();



    // 设置输入映射

    if (UInputComponent* InputComponent = GetInputComponent())

    {
    
    

        InputComponent->BindAxis("MoveForward", this, &AMyDynamicCamera::MoveForward);

        InputComponent->BindAxis("MoveRight", this, &AMyDynamicCamera::MoveRight);

        InputComponent->BindAxis("LookUp", this, &AMyDynamicCamera::AddControllerPitchInput);

        InputComponent->BindAxis("Turn", this, &AMyDynamicCamera::AddControllerYawInput);

    }

}



void AMyDynamicCamera::Tick(float DeltaTime)

{
    
    

    Super::Tick(DeltaTime);

}



void AMyDynamicCamera::MoveForward(float Value)

{
    
    

    if (Value != 0.0f)

    {
    
    

        // 摄像机沿当前方向移动

        AddMovementInput(GetActorForwardVector(), Value * MoveSpeed);

    }

}



void AMyDynamicCamera::MoveRight(float Value)

{
    
    

    if (Value != 0.0f)

    {
    
    

        // 摄像机沿当前右侧方向移动

        AddMovementInput(GetActorRightVector(), Value * MoveSpeed);

    }

}



void AMyDynamicCamera::AddControllerPitchInput(float Value)

{
    
    

    // 摄像机沿上下方向旋转

    AddControllerPitchInput(Value * RotateSpeed);

}



void AMyDynamicCamera::AddControllerYawInput(float Value)

{
    
    

    // 摄像机沿左右方向旋转

    AddControllerYawInput(Value * RotateSpeed);

}

第三方摄像机

第三方摄像机通常用于第三人称视角游戏，它跟随角色但保持一定的距离。在Unreal Engine中，通常使用Spring Arm组件来实现第三方摄像机。

例子：实现一个简单的第三方摄像机

  1. 创建一个新的C++类，继承自APawn。

  2. 在类中添加一个Spring Arm组件和一个Camera组件。

  3. 通过Spring Arm组件的属性来控制摄像机的位置和旋转。


// MyThirdPersonCharacter.h

#pragma once



#include "CoreMinimal.h"

#include "GameFramework/Pawn.h"

#include "MyThirdPersonCharacter.generated.h"



UCLASS()

class MYGAME_API AMyThirdPersonCharacter : public APawn

{
    
    

    GENERATED_BODY()

    

public:	

    // Sets default values for this pawn's properties

    AMyThirdPersonCharacter();



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;



private:

    // 角色的移动速度

    UPROPERTY(EditAnywhere)

    float MoveSpeed;



    // 角色的旋转速度

    UPROPERTY(EditAnywhere)

    float RotateSpeed;



    // Spring Arm组件

    USpringArmComponent* SpringArm;



    // Camera组件

    UCameraComponent* Camera;



    // 处理输入以移动角色

    void MoveForward(float Value);

    void MoveRight(float Value);



    // 处理输入以旋转角色

    void AddControllerPitchInput(float Value);

    void AddControllerYawInput(float Value);

};



// MyThirdPersonCharacter.cpp

#include "MyThirdPersonCharacter.h"

#include "GameFramework/SpringArmComponent.h"

#include "GameFramework/CharacterMovementComponent.h"

#include "Components/InputComponent.h"



AMyThirdPersonCharacter::AMyThirdPersonCharacter()

{
    
    

    // 设置默认移动和旋转速度

    MoveSpeed = 1000.0f;

    RotateSpeed = 50.0f;



    // 创建Spring Arm组件

    SpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArm"));

    SpringArm->SetupAttachment(RootComponent);

    SpringArm->TargetArmLength = 400.0f; // 摄像机距离角色的距离

    SpringArm->SocketOffset = FVector(0, 0, 300); // 摄像机的偏移

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



    // 创建Camera组件

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

    Camera->SetupAttachment(SpringArm, USpringArmComponent::SocketName);



    // 启用输入

    PrimaryActorTick.bCanEverTick = true;

}



void AMyThirdPersonCharacter::BeginPlay()

{
    
    

    Super::BeginPlay();



    // 设置输入映射

    if (UInputComponent* InputComponent = GetInputComponent())

    {
    
    

        InputComponent->BindAxis("MoveForward", this, &AMyThirdPersonCharacter::MoveForward);

        InputComponent->BindAxis("MoveRight", this, &AMyThirdPersonCharacter::MoveRight);

        InputComponent->BindAxis("LookUp", this, &AMyThirdPersonCharacter::AddControllerPitchInput);

        InputComponent->BindAxis("Turn", this, &AMyThirdPersonCharacter::AddControllerYawInput);

    }

}



void AMyThirdPersonCharacter::Tick(float DeltaTime)

{
    
    

    Super::Tick(DeltaTime);

}



void AMyThirdPersonCharacter::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)

{
    
    

    Super::SetupPlayerInputComponent(PlayerInputComponent);

}



void AMyThirdPersonCharacter::MoveForward(float Value)

{
    
    

    if (Value != 0.0f)

    {
    
    

        // 角色沿当前方向移动

        AddMovementInput(GetActorForwardVector(), Value * MoveSpeed);

    }

}



void AMyThirdPersonCharacter::MoveRight(float Value)

{
    
    

    if (Value != 0.0f)

    {
    
    

        // 角色沿当前右侧方向移动

        AddMovementInput(GetActorRightVector(), Value * MoveSpeed);

    }

}



void AMyThirdPersonCharacter::AddControllerPitchInput(float Value)

{
    
    

    // 角色沿上下方向旋转

    Super::AddControllerPitchInput(Value * RotateSpeed);

}



void AMyThirdPersonCharacter::AddControllerYawInput(float Value)

{
    
    

    // 角色沿左右方向旋转

    Super::AddControllerYawInput(Value * RotateSpeed);

}

摄像机组件

在Unreal Engine中，摄像机组件（Camera Component）是用于控制摄像机视角的关键组件。摄像机组件可以附加到任何Actor上，通过设置其位置和旋转来控制摄像机的视角。

例子：使用Camera组件

  1. 创建一个新的C++类，继承自AActor。

  2. 在类中添加一个Camera组件。

  3. 通过设置Camera组件的属性来调整摄像机的视角。


// MyCameraActor.h

#pragma once



#include "CoreMinimal.h"

#include "GameFramework/Actor.h"

#include "MyCameraActor.generated.h"



UCLASS()

class MYGAME_API AMyCameraActor : public AActor

{
    
    

    GENERATED_BODY()

    

public:	

    // Sets default values for this actor's properties

    AMyCameraActor();



protected:

    // Called when the game starts or when spawned

    virtual void BeginPlay() override;



public:	

    // Called every frame

    virtual void Tick(float DeltaTime) override;



private:

    // Camera组件

    UCameraComponent* Camera;



    // 处理输入以移动摄像机

    void MoveForward(float Value);

    void MoveRight(float Value);



    // 处理输入以旋转摄像机

    void AddControllerPitchInput(float Value);

    void AddControllerYawInput(float Value);



    // 摄像机的移动速度

    UPROPERTY(EditAnywhere)

    float MoveSpeed;



    // 摄像机的旋转速度

    UPROPERTY(EditAnywhere)

    float RotateSpeed;

};



// MyCameraActor.cpp

#include "MyCameraActor.h"

#include "Components/CameraComponent.h"

#include "Components/InputComponent.h"



AMyCameraActor::AMyCameraActor()

{
    
    

    // 设置默认移动和旋转速度

    MoveSpeed = 1000.0f;

    RotateSpeed = 50.0f;



    // 创建Camera组件

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

    Camera->SetupAttachment(RootComponent);

    Camera->SetRelativeLocation(FVector(0, 0, 200)); // 设置摄像机的相对位置

    Camera->SetRelativeRotation(FRotator(0, -45, 0)); // 设置摄像机的相对旋转



    // 启用输入

    PrimaryActorTick.bCanEverTick = true;

}



void AMyCameraActor::BeginPlay()

{
    
    

    Super::BeginPlay();



    // 设置输入映射

    if (UInputComponent* InputComponent = GetInputComponent())

    {
    
    

        InputComponent->BindAxis("MoveForward", this, &AMyCameraActor::MoveForward);

        InputComponent->BindAxis("MoveRight", this, &AMyCameraActor::MoveRight);

        InputComponent->BindAxis("LookUp", this, &AMyCameraActor::AddControllerPitchInput);

        InputComponent->BindAxis("Turn", this, &AMyCameraActor::AddControllerYawInput);

    }

}



void AMyCameraActor::Tick(float DeltaTime)

{
    
    

    Super::Tick(DeltaTime);

}



void AMyCameraActor::MoveForward(float Value)

{
    
    

    if (Value != 0.0f)

    {
    
    

        // 摄像机沿当前方向移动

        AddMovementInput(GetActorForwardVector(), Value * MoveSpeed);

    }

}



void AMyCameraActor::MoveRight(float Value)

{
    
    

    if (Value != 0.0f)

    {
    
    

        // 摄像机沿当前右侧方向移动

        AddMovementInput(GetActorRightVector(), Value * MoveSpeed);

    }

}



void AMyCameraActor::AddControllerPitchInput(float Value)

{
    
    

    // 摄像机沿上下方向旋转

    AddControllerPitchInput(Value * RotateSpeed);

}



void AMyCameraActor::AddControllerYawInput(float Value)

{
    
    

    // 摄像机沿左右方向旋转

    AddControllerYawInput(Value * RotateSpeed);

}

摄像机控制器

摄像机控制器（Camera Controller）是用于管理和控制摄像机视角的类。它可以处理玩家输入、摄像机过渡动画等高级功能。在Unreal Engine中，通常使用APlayerController类来实现摄像机控制器。

例子：实现一个简单的摄像机控制器

  1. 创建一个新的C++类，继承自APlayerController。

  2. 在类中添加摄像机控制逻辑。

  3. 通过设置摄像机的属性来调整视角。


// MyCameraController.h

#pragma once



#include "CoreMinimal.h"

#include "GameFramework/PlayerController.h"

#include "MyCameraController.generated.h"



UCLASS()

class MYGAME_API AMyCameraController : public APlayerController

{
    
    

    GENERATED_BODY()

    

public:	

    // Sets default values for this pawn's properties

    AMyCameraController();



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 SetupInputComponent() override;



private:

    // 摄像机的移动速度

    UPROPERTY(EditAnywhere)

    float MoveSpeed;



    // 摄像机的旋转速度

    UPROPERTY(EditAnywhere)

    float RotateSpeed;



    // 处理输入以移动摄像机

    void MoveForward(float Value);

    void MoveRight(float Value);



    // 处理输入以旋转摄像机

    void AddPitchInput(float Value);

    void AddYawInput(float Value);

};



// MyCameraController.cpp

#include "MyCameraController.h"

#include "Components/InputComponent.h"

#include "GameFramework/Pawn.h"



AMyCameraController::AMyCameraController()

{
    
    

    // 设置默认移动和旋转速度

    MoveSpeed = 1000.0f;

    RotateSpeed = 50.0f;



    // 启用输入

    PrimaryActorTick.bCanEverTick = true;

}



void AMyCameraController::BeginPlay()

{
    
    

    Super::BeginPlay();



    // 设置输入映射

    if (UInputComponent* InputComponent = GetInputComponent())

    {
    
    

        InputComponent->BindAxis("MoveForward", this, &AMyCameraController::MoveForward);

        InputComponent->BindAxis("MoveRight", this, &AMyCameraController::MoveRight);

        InputComponent->BindAxis("LookUp", this, &AMyCameraController::AddPitchInput);

        InputComponent->BindAxis("Turn", this, &AMyCameraController::AddYawInput);

    }

}



void AMyCameraController::Tick(float DeltaTime)

{
    
    

    Super::Tick(DeltaTime);

}



void AMyCameraController::SetupInputComponent()

{
    
    

    Super::SetupInputComponent();

}



void AMyCameraController::MoveForward(float Value)

{
    
    

    if (Value != 0.0f)

    {
    
    

        // 摄像机沿当前方向移动

        APawn* ControlledPawn = GetPawn();

        if (ControlledPawn)

        {
    
    

            ControlledPawn->AddMovementInput(ControlledPawn->GetActorForwardVector(), Value * MoveSpeed);

        }

    }

}



void AMyCameraController::MoveRight(float Value)

{
    
    

    if (Value != 0.0f)

    {
    
    

        // 摄像机沿当前右侧方向移动

        APawn* ControlledPawn = GetPawn();

        if (ControlledPawn)

        {
    
    

            ControlledPawn->AddMovementInput(ControlledPawn->GetActorRightVector(), Value * MoveSpeed);

        }

    }

}



void AMyCameraController::AddPitchInput(float Value)

{
    
    

    // 摄像机沿上下方向旋转

    Super::AddPitchInput(Value * RotateSpeed);

}



void AMyCameraController::AddYawInput(float Value)

{
    
    

    // 摄像机沿左右方向旋转

    Super::AddYawInput(Value * RotateSpeed);

}

摄像机混合

在Unreal Engine中，可以使用摄像机混合（Camera Blending）来平滑地切换不同的摄像机视角。摄像机混合可以通过ACameraManager类来实现，该类可以管理多个摄像机并进行平滑过渡。

例子：实现一个简单的摄像机混合

  1. 创建一个新的C++类，继承自ACameraManager。

  2. 在类中添加多个摄像机。

  3. 通过设置摄像机的权重来实现平滑过渡。


// MyCameraManager.h

#pragma once



#include "CoreMinimal.h"

#include "GameFramework/CameraManager.h"

#include "MyCameraManager.generated.h"



UCLASS()

class MYGAME_API AMyCameraManager : public ACameraManager

{
    
    

    GENERATED_BODY()

    

public:	

    // 设置默认值

    AMyCameraManager();



protected:

    // 游戏开始或Actor生成时调用

    virtual void BeginPlay() override;



public:	

    // 每帧调用

    virtual void Tick(float DeltaTime) override;



    // 切换到摄像机1

    void SwitchToCamera1();



    // 切换到摄像机2

    void SwitchToCamera2();



private:

    // 摄像机1

    UPROPERTY(EditAnywhere)

    AActor* Camera1;



    // 摄像机2

    UPROPERTY(EditAnywhere)

    AActor* Camera2;



    // 摄像机1的权重

    UPROPERTY(EditAnywhere)

    float Camera1BlendWeight;



    // 摄像机2的权重

    UPROPERTY(EditAnywhere)

    float Camera2BlendWeight;



    // 摄像机混合的时间

    UPROPERTY(EditAnywhere)

    float BlendTime;



    // 当前正在使用的摄像机

    AActor* CurrentCamera;

};



// MyCameraManager.cpp

#include "MyCameraManager.h"

#include "Components/CameraComponent.h"

#include "Engine/World.h"

#include "GameFramework/PlayerController.h"



AMyCameraManager::AMyCameraManager()

{
    
    

    // 设置默认混合时间

    BlendTime = 1.0f;



    // 设置默认摄像机1和摄像机2的权重

    Camera1BlendWeight = 1.0f;

    Camera2BlendWeight = 0.0f;



    // 启用每帧调用

    PrimaryActorTick.bCanEverTick = true;

}



void AMyCameraManager::BeginPlay()

{
    
    

    Super::BeginPlay();



    // 初始化当前摄像机

    if (Camera1)

    {
    
    

        CurrentCamera = Camera1;

    }

    else

    {
    
    

        UE_LOG(LogTemp, Warning, TEXT("Camera1 is not set in MyCameraManager!"));

    }

}



void AMyCameraManager::Tick(float DeltaTime)

{
    
    

    Super::Tick(DeltaTime);



    // 平滑地混合摄像机

    if (CurrentCamera)

    {
    
    

        APlayerController* PlayerController = GetWorld()->GetFirstPlayerController();

        if (PlayerController)

        {
    
    

            FMinimalViewInfo CurrentView;

            FMinimalViewInfo Camera1View;

            FMinimalViewInfo Camera2View;



            // 获取当前摄像机的视角信息

            if (UCameraComponent* Camera1Comp = Cast<UCameraComponent>(Camera1))

            {
    
    

                Camera1Comp->GetCameraView(DeltaTime, Camera1View);

            }



            // 获取摄像机2的视角信息

            if (UCameraComponent* Camera2Comp = Cast<UCameraComponent>(Camera2))

            {
    
    

                Camera2Comp->GetCameraView(DeltaTime, Camera2View);

            }



            // 混合摄像机视角

            FMinimalViewInfo BlendedView;

            BlendedView.Location = FMath::Lerp(Camera1View.Location, Camera2View.Location, Camera2BlendWeight);

            BlendedView.Rotation = FMath::Lerp(Camera1View.Rotation, Camera2View.Rotation, Camera2BlendWeight);

            BlendedView.FieldOfView = FMath::Lerp(Camera1View.FieldOfView, Camera2View.FieldOfView, Camera2BlendWeight);



            // 设置混合后的视角

            PlayerController->SetViewTargetWithBlend(CurrentCamera, BlendTime, EViewTargetBlendFunction::VTBlend_Cubic, 0.0f, 0.0f, BlendedView);

        }

    }

}



void AMyCameraManager::SwitchToCamera1()

{
    
    

    // 切换到摄像机1

    Camera1BlendWeight = 1.0f;

    Camera2BlendWeight = 0.0f;

    CurrentCamera = Camera1;

}



void AMyCameraManager::SwitchToCamera2()

{
    
    

    // 切换到摄像机2

    Camera1BlendWeight = 0.0f;

    Camera2BlendWeight = 1.0f;

    CurrentCamera = Camera2;

}

摄像机动画

摄像机动画（Camera Animation）可以用于创建复杂的摄像机运动效果，例如过场动画、特殊效果等。Unreal Engine提供了多种动画资源和动画蓝图来实现这些效果。

例子：实现一个简单的摄像机动画

  1. 创建一个新的C++类，继承自ACameraActor。

  2. 在类中添加一个摄像机动画组件（Camera Animation Component）。

  3. 通过蓝图或代码来控制摄像机的动画播放。


// MyCameraAnimationActor.h

#pragma once



#include "CoreMinimal.h"

#include "GameFramework/Actor.h"

#include "Camera/CameraAnimationSequence.h"

#include "MyCameraAnimationActor.generated.h"



UCLASS()

class MYGAME_API AMyCameraAnimationActor : public ACameraActor

{
    
    

    GENERATED_BODY()

    

public:	

    // 设置默认值

    AMyCameraAnimationActor();



    // 播放摄像机动画

    void PlayCameraAnimation();



private:

    // 摄像机动画组件

    UPROPERTY(EditAnywhere)

    UCameraAnimationComponent* CameraAnimationComponent;



    // 摄像机动画序列

    UPROPERTY(EditAnywhere)

    UCameraAnimationSequence* CameraAnimationSequence;

};



// MyCameraAnimationActor.cpp

#include "MyCameraAnimationActor.h"

#include "Camera/CameraAnimationComponent.h"



AMyCameraAnimationActor::AMyCameraAnimationActor()

{
    
    

    // 创建摄像机动画组件

    CameraAnimationComponent = CreateDefaultSubobject<UCameraAnimationComponent>(TEXT("CameraAnimationComponent"));

    CameraAnimationComponent->SetupAttachment(RootComponent);



    // 启用每帧调用

    PrimaryActorTick.bCanEverTick = true;

}



void AMyCameraAnimationActor::PlayCameraAnimation()

{
    
    

    if (CameraAnimationComponent && CameraAnimationSequence)

    {
    
    

        // 播放摄像机动画

        CameraAnimationComponent->Play(CameraAnimationSequence);

    }

    else

    {
    
    

        UE_LOG(LogTemp, Warning, TEXT("CameraAnimationComponent or CameraAnimationSequence is not set in MyCameraAnimationActor!"));

    }

}

摄像机效果

摄像机效果（Camera Effects）可以用于增强游戏的视觉表现，例如景深（Depth of Field）、运动模糊（Motion Blur）、镜头光晕（Lens Flare）等。这些效果可以通过摄像机组件的后处理设置来实现。

例子：实现一个简单的摄像机效果

  1. 创建一个新的C++类，继承自ACameraActor。

  2. 在类中添加后处理体积（Post Process Volume）。

  3. 通过设置后处理体积的属性来实现摄像机效果。


// MyCameraEffectsActor.h

#pragma once



#include "CoreMinimal.h"

#include "GameFramework/Actor.h"

#include "Components/PostProcessComponent.h"

#include "MyCameraEffectsActor.generated.h"



UCLASS()

class MYGAME_API AMyCameraEffectsActor : public ACameraActor

{
    
    

    GENERATED_BODY()

    

public:	

    // 设置默认值

    AMyCameraEffectsActor();



    // 开启或关闭景深效果

    void ToggleDepthOfField();



private:

    // 后处理组件

    UPROPERTY(EditAnywhere)

    UPostProcessComponent* PostProcessComponent;



    // 景深效果是否开启

    UPROPERTY(EditAnywhere)

    bool bDepthOfFieldEnabled;

};



// MyCameraEffectsActor.cpp

#include "MyCameraEffectsActor.h"

#include "Components/PostProcessComponent.h"



AMyCameraEffectsActor::AMyCameraEffectsActor()

{
    
    

    // 创建后处理组件

    PostProcessComponent = CreateDefaultSubobject<UPostProcessComponent>(TEXT("PostProcessComponent"));

    PostProcessComponent->SetupAttachment(RootComponent);



    // 设置默认景深效果

    bDepthOfFieldEnabled = false;

}



void AMyCameraEffectsActor::ToggleDepthOfField()

{
    
    

    if (PostProcessComponent)

    {
    
    

        // 切换景深效果

        bDepthOfFieldEnabled = !bDepthOfFieldEnabled;

        PostProcessComponent->Settings.bOverride_DepthOfField = bDepthOfFieldEnabled;

        PostProcessComponent->Settings.DepthOfFieldAmount = bDepthOfFieldEnabled ? 1.0f : 0.0f;

    }

    else

    {
    
    

        UE_LOG(LogTemp, Warning, TEXT("PostProcessComponent is not set in MyCameraEffectsActor!"));

    }

}

摄像机蓝图

除了使用C++实现摄像机功能外，Unreal Engine还提供了蓝图（Blueprint）系统，可以更直观地创建和管理摄像机。蓝图允许开发者通过可视化编程来实现摄像机的移动、旋转和效果。

例子：使用蓝图实现一个简单的动态摄像机

  1. 打开Unreal Engine编辑器，创建一个新的蓝图类，继承自ACameraActor。

  2. 在蓝图中添加输入事件，以便摄像机可以根据玩家的输入进行移动和旋转。

  3. 使用蓝图节点来实现摄像机的移动和旋转逻辑。


// 创建一个新的蓝图类，继承自ACameraActor

// 在Event Graph中添加输入事件



// 输入事件：MoveForward

Event Tick -> Get Actor Forward Vector -> Multiply by Value (Input Axis Value) -> Multiply by Move Speed -> Add to Actor Location



// 输入事件：MoveRight

Event Tick -> Get Actor Right Vector -> Multiply by Value (Input Axis Value) -> Multiply by Move Speed -> Add to Actor Location



// 输入事件：LookUp

Event Tick -> Add Controller Pitch Input (Input Axis Value * Rotate Speed)



// 输入事件：Turn

Event Tick -> Add Controller Yaw Input (Input Axis Value * Rotate Speed)

总结

在Unreal Engine中，虚拟摄像机是实现游戏视角和视觉效果的重要工具。通过静态摄像机、动态摄像机、第三方摄像机、摄像机混合、摄像机动画和摄像机效果，开发者可以创建多种多样的摄像机功能，以满足不同游戏的需求。同时，Unreal Engine的蓝图系统提供了灵活的可视化编程工具，使得摄像机的实现更加简便。

通过上述例子，我们介绍了如何在Unreal Engine中使用C++和蓝图来实现不同类型的虚拟摄像机，并提供了具体的代码和步骤。希望这些内容能帮助你更好地理解和应用虚拟摄像机开发基础。
在这里插入图片描述

猜你喜欢

转载自blog.csdn.net/chenlz2007/article/details/147017136
今日推荐
deepseek热度已过？
MOOC习题:“GPS数据处理”题目个人解析(C语言)
DeepSeek接入微信公众号小白保姆教程
图+语义：RDF语义处理组件Neosemantics功能列表
大语言模型Prompt工程之使用GPT4生成图数据库Cypher
大语言模型Prompt工程之使用GPT3.5生成图数据库Cypher
GPT-3.5 生成 Fabric Cypher
生成 Cypher 能力：GPT3.5 VS ChatGLM
LangChain 2 ONgDB：大模型+知识图谱实现领域知识问答
生成 Cypher 能力：MOSS VS ChatGLM
Neo4j/ONgDB 图数据库快速处理 Excel 文件
LangChain-Agents 入门指南
周排行
blog公告
Lucene：基本增删改查（Java方式）
1、类库
android环信集成单聊功能
删除数据库表数据SQL语句
rhel6.3安装Percona XtraDB Cluster 5.7时错误的解决方法
天梯赛-堆栈（线段树）
ES6原生Class
20120607
张正友标定算法原理详解
每日归档
更多
2025-04-11(9561)
2025-04-10(1213)
2025-04-09(10354)
2025-04-08(12998)
2025-04-07(0)
2025-04-06(0)
2025-04-05(0)
2025-04-04(0)
2025-04-03(0)
2025-04-02(0)