カメラ追従の計算方法 | Unity実装ガイド

ゲーム開発でプレイヤーを追いかけるカメラを実装しようとすると、様々な計算が必要になります。

「カメラをどうやってプレイヤーに追従させるの？」
「オフセットってどう計算するの？」
「壁を通り抜けないようにするには？」

そんな疑問を抱えている方に向けて、カメラ追従の計算方法について、初心者でも理解できるように解説します。

＼読むだけで終わらせない！実際にゲームを作って実力をつけよう／

トレンド×入門に最適

Unity ノンフィールドRPG
＋スレスパ風JRPG講座

★★★★★ (Unity6対応)

Unity ノンフィールドRPGの作り方講座＋Slay the Spire風デッキ構築JRPGの作り方講座

Unity6対応・スマホ化対応の最新カリキュラム。今もっとも人気のデッキ構築型ゲームをJRPGと組み合わせて実装。初心者が最初に選ぶ一本として最適です。

講座を見てみる＼スマホ対応！初心者から最速で1本完成させる／

王道アクションに挑戦

Unity 2Dアクションゲーム
の作り方講座（ロックマン風）

★★★★★ (スマホ化・広告実装)

ロックマン風の本格横スクロールACTをスマホ化・広告実装まで対応。7ステージ＋ラスボスという市販ゲームに近い本格構成で、リリースまで見据えて作れます。

講座を見てみる＼入学前に1本完成させてスタートダッシュ！／

3D入門に最適

ゼルダ風3Dアクションゲーム
の作り方講座

★★★★★ (スマホ化対応)

ゼルダの伝説・モンハン・原神のような3Dアクションをスマホ対応で作れる入門講座。初心者でも全16回でしっかり3D開発の基礎を習得できます。

講座を見てみる＼初心者でも3Dアクションが作れる！／

ゲームを「遊ぶ側」から「作る側」へ

あなたのオリジナルゲーム、今年こそ完成させませんか？

RPG・アクション・ホラー…Unityで本格ゲームを作りたい人のための学習サイトです。

Unity入門の森｜永久会員チケット

全講座ラインナップを見てみる

実際に完成するゲームを題材に、
ソースコード・素材・プロジェクト一式をすべて公開。
仕事や学校の合間の1〜2時間でも、
「写経→改造」で自分のゲームまで作りきれる環境です。

カメラ追従とは何か
1. カメラ追従の基本概念
2. カメラ追従の種類
基本的な追従の計算
滑らかな追従の計算
オフセットの計算と調整
壁を通り抜けない追従
1. レイキャストによる衝突検出
2. SphereCastを使った衝突検出
Unityでの実装例（C#コード）
1. 高度な追従カメラクラス
カメラ追従の実装手順
よくある問題と解決方法
カメラ追従の学習を深めるには
記事を読んで「作ってみたい！」と思ったら！人気ゲームを題材にした講座で実力をつけよう
まとめ

カメラ追従とは何か

カメラ追従とは、プレイヤーやオブジェクトの動きに合わせて、カメラが自動的に移動する技術です。

ゲームでは、プレイヤーが常に画面の中心にいるように、カメラが追いかける仕組みが必要になります。

単純にカメラの位置をプレイヤーの位置に設定するだけでは、カメラがプレイヤーと重なってしまうため、適切な距離と角度を保つ計算が必要なんです。

カメラ追従の基本概念

カメラ追従を実現するには、以下の要素が必要になります。

目標位置：カメラが向かうべき位置
オフセット：目標位置からの相対的な位置
補間：滑らかな移動を実現する計算
制約：壁との衝突や範囲制限

カメラ追従の種類

ゲームで使われる主なカメラ追従には、以下のようなものがあります。

直接追従：カメラの位置を直接目標位置に設定
滑らかな追従：補間を使って滑らかに追従
予測追従：プレイヤーの動きを予測して追従
範囲制限付き追従：カメラの移動範囲を制限

カメラ追従の特徴

プレイヤーやオブジェクトを追いかける技術
適切な距離と角度を保つ計算が必要
補間を使うことで滑らかな動きを実現
壁との衝突などを考慮した制約が重要

基本的な追従の計算

最もシンプルなカメラ追従の実装から見ていきましょう。

直接追従

カメラの位置を目標位置に直接設定する方法です。

public Transform target;  // 追従対象

void Update()
{
    if (target != null)
    {
        transform.position = target.position;
    }
}

public Transform target; // 追従対象

void Update()

{

if (target != null)

{

transform.position = target.position;

}

ただし、この方法だとカメラがプレイヤーと完全に重なってしまい、何も見えなくなります。

オフセットを使った追従

オフセット（相対位置）を設定することで、カメラとプレイヤーの間に適切な距離を保てます。

public Transform target;
public Vector3 offset = new Vector3(0, 5, -10);  // カメラの相対位置

void Update()
{
    if (target != null)
    {
        // 目標位置 = 対象の位置 + オフセット
        Vector3 targetPosition = target.position + offset;
        transform.position = targetPosition;
        
        // 対象を見る
        transform.LookAt(target);
    }
}

public Transform target;

public Vector3 offset = new Vector3(0, 5, -10); // カメラの相対位置

void Update()

{

if (target != null)

{

// 目標位置 = 対象の位置 + オフセット

Vector3 targetPosition = target.position + offset;

transform.position = targetPosition;

// 対象を見る

transform.LookAt(target);

}

目標位置 = 対象の位置 + オフセットという計算式が基本になります。

オフセットの計算方法

オフセットを計算するには、カメラと対象の初期位置の差を求めます。

void Start()
{
    if (target != null)
    {
        // 初期位置の差を計算してオフセットとする
        offset = transform.position - target.position;
    }
}

void Update()
{
    if (target != null)
    {
        transform.position = target.position + offset;
        transform.LookAt(target);
    }
}

void Start()

{

if (target != null)

{

// 初期位置の差を計算してオフセットとする

offset = transform.position - target.position;

}

void Update()

{

if (target != null)

{

transform.position = target.position + offset;

transform.LookAt(target);

}

これにより、シーンの初期配置から自動的にオフセットを計算できます。

【ゲームの作り方講座プレゼント中！】

滑らかな追従の計算

直接追従だとカメラの動きがカクつくため、補間を使って滑らかに追従させる方法を見ていきましょう。

Lerpを使った滑らかな追従

Vector3.Lerpを使って、カメラの位置を滑らかに補間します。

public Transform target;
public Vector3 offset = new Vector3(0, 5, -10);
public float smoothSpeed = 5.0f;  // 追従速度

void LateUpdate()
{
    if (target == null) return;
    
    // 目標位置を計算
    Vector3 desiredPosition = target.position + offset;
    
    // 滑らかに移動
    transform.position = Vector3.Lerp(
        transform.position,
        desiredPosition,
        smoothSpeed * Time.deltaTime
    );
    
    // 対象を見る
    transform.LookAt(target);
}

public Transform target;

public Vector3 offset = new Vector3(0, 5, -10);

public float smoothSpeed = 5.0f; // 追従速度

void LateUpdate()

{

if (target == null) return;

// 目標位置を計算

Vector3 desiredPosition = target.position + offset;

// 滑らかに移動

transform.position = Vector3.Lerp(

transform.position,

desiredPosition,

smoothSpeed * Time.deltaTime

);

// 対象を見る

transform.LookAt(target);

}

LateUpdateを使うことで、プレイヤーの移動後にカメラを更新できます。

距離ベースの追従速度

カメラと目標位置の距離に応じて、追従速度を調整することもできます。

public float minSmoothSpeed = 3.0f;
public float maxSmoothSpeed = 10.0f;
public float maxDistance = 20.0f;

void LateUpdate()
{
    if (target == null) return;
    
    Vector3 desiredPosition = target.position + offset;
    float distance = Vector3.Distance(transform.position, desiredPosition);
    
    // 距離に応じて速度を調整
    float normalizedDistance = Mathf.Clamp01(distance / maxDistance);
    float currentSmoothSpeed = Mathf.Lerp(minSmoothSpeed, maxSmoothSpeed, normalizedDistance);
    
    transform.position = Vector3.Lerp(
        transform.position,
        desiredPosition,
        currentSmoothSpeed * Time.deltaTime
    );
    
    transform.LookAt(target);
}

public float minSmoothSpeed = 3.0f;

public float maxSmoothSpeed = 10.0f;

public float maxDistance = 20.0f;

void LateUpdate()

{

if (target == null) return;

Vector3 desiredPosition = target.position + offset;

float distance = Vector3.Distance(transform.position, desiredPosition);

// 距離に応じて速度を調整

float normalizedDistance = Mathf.Clamp01(distance / maxDistance);

float currentSmoothSpeed = Mathf.Lerp(minSmoothSpeed, maxSmoothSpeed, normalizedDistance);

transform.position = Vector3.Lerp(

transform.position,

desiredPosition,

currentSmoothSpeed * Time.deltaTime

);

transform.LookAt(target);

}

距離が遠いほど速く追従し、近いほどゆっくり追従するようになります。

予測追従の計算

プレイヤーの速度を考慮して、将来の位置を予測して追従することもできます。

public Transform target;
public Vector3 offset = new Vector3(0, 5, -10);
public float smoothSpeed = 5.0f;
public float predictionAmount = 0.5f;  // 予測の強度

private Vector3 previousTargetPosition;
private Vector3 targetVelocity;

void LateUpdate()
{
    if (target == null) return;
    
    // 速度を計算
    targetVelocity = (target.position - previousTargetPosition) / Time.deltaTime;
    previousTargetPosition = target.position;
    
    // 予測位置を計算
    Vector3 predictedPosition = target.position + targetVelocity * predictionAmount;
    
    // 予測位置を基準に目標位置を計算
    Vector3 desiredPosition = predictedPosition + offset;
    
    // 滑らかに移動
    transform.position = Vector3.Lerp(
        transform.position,
        desiredPosition,
        smoothSpeed * Time.deltaTime
    );
    
    transform.LookAt(predictedPosition);
}

public Transform target;

public Vector3 offset = new Vector3(0, 5, -10);

public float smoothSpeed = 5.0f;

public float predictionAmount = 0.5f; // 予測の強度

private Vector3 previousTargetPosition;

private Vector3 targetVelocity;

void LateUpdate()

{

if (target == null) return;

// 速度を計算

targetVelocity = (target.position - previousTargetPosition) / Time.deltaTime;

previousTargetPosition = target.position;

// 予測位置を計算

Vector3 predictedPosition = target.position + targetVelocity * predictionAmount;

// 予測位置を基準に目標位置を計算

Vector3 desiredPosition = predictedPosition + offset;

// 滑らかに移動

transform.position = Vector3.Lerp(

transform.position,

desiredPosition,

smoothSpeed * Time.deltaTime

);

transform.LookAt(predictedPosition);

}

これにより、カメラがプレイヤーの動きを先読みして追従できるようになります。

オフセットの計算と調整

カメラ追従では、オフセットの計算と調整が重要になります。

ローカル座標系でのオフセット

対象のローカル座標系（向きを基準）でオフセットを計算することで、対象が回転しても適切な位置を保てます。

public Transform target;
public Vector3 localOffset = new Vector3(0, 5, -10);  // ローカル座標でのオフセット

void LateUpdate()
{
    if (target == null) return;
    
    // ローカル座標系でのオフセットをワールド座標に変換
    Vector3 worldOffset = target.TransformDirection(localOffset);
    Vector3 desiredPosition = target.position + worldOffset;
    
    transform.position = Vector3.Lerp(
        transform.position,
        desiredPosition,
        smoothSpeed * Time.deltaTime
    );
    
    transform.LookAt(target);
}

public Transform target;

public Vector3 localOffset = new Vector3(0, 5, -10); // ローカル座標でのオフセット

void LateUpdate()

{

if (target == null) return;

// ローカル座標系でのオフセットをワールド座標に変換

Vector3 worldOffset = target.TransformDirection(localOffset);

Vector3 desiredPosition = target.position + worldOffset;

transform.position = Vector3.Lerp(

transform.position,

desiredPosition,

smoothSpeed * Time.deltaTime

);

transform.LookAt(target);

}

Transform.TransformDirectionを使って、ローカル座標をワールド座標に変換できます。

高さのオフセット調整

カメラの高さを、プレイヤーの状態に応じて動的に調整することもできます。

public float baseHeight = 5.0f;  // 基本の高さ
public float crouchHeightOffset = -2.0f;  // しゃがみ時の高さオフセット

void LateUpdate()
{
    if (target == null) return;
    
    // プレイヤーの状態に応じて高さを調整
    bool isCrouching = /* プレイヤーのしゃがみ状態を取得 */;
    float currentHeight = baseHeight + (isCrouching ? crouchHeightOffset : 0);
    
    Vector3 offset = new Vector3(0, currentHeight, -10);
    Vector3 desiredPosition = target.position + offset;
    
    transform.position = Vector3.Lerp(
        transform.position,
        desiredPosition,
        smoothSpeed * Time.deltaTime
    );
    
    transform.LookAt(target);
}

public float baseHeight = 5.0f; // 基本の高さ

public float crouchHeightOffset = -2.0f; // しゃがみ時の高さオフセット

void LateUpdate()

{

if (target == null) return;

// プレイヤーの状態に応じて高さを調整

bool isCrouching = /* プレイヤーのしゃがみ状態を取得 */;

float currentHeight = baseHeight + (isCrouching ? crouchHeightOffset : 0);

Vector3 offset = new Vector3(0, currentHeight, -10);

Vector3 desiredPosition = target.position + offset;

transform.position = Vector3.Lerp(

transform.position,

desiredPosition,

smoothSpeed * Time.deltaTime

);

transform.LookAt(target);

}

これにより、プレイヤーがしゃがんだ時など、状況に応じてカメラの高さを調整できます。

オフセットの補間

オフセット自体も滑らかに変化させることができます。

public Vector3 targetOffset = new Vector3(0, 5, -10);
public float offsetSmoothSpeed = 2.0f;

private Vector3 currentOffset;

void LateUpdate()
{
    if (target == null) return;
    
    // オフセットを滑らかに変化
    currentOffset = Vector3.Lerp(
        currentOffset,
        targetOffset,
        offsetSmoothSpeed * Time.deltaTime
    );
    
    Vector3 desiredPosition = target.position + currentOffset;
    
    transform.position = Vector3.Lerp(
        transform.position,
        desiredPosition,
        smoothSpeed * Time.deltaTime
    );
    
    transform.LookAt(target);
}

public Vector3 targetOffset = new Vector3(0, 5, -10);

public float offsetSmoothSpeed = 2.0f;

private Vector3 currentOffset;

void LateUpdate()

{

if (target == null) return;

// オフセットを滑らかに変化

currentOffset = Vector3.Lerp(

currentOffset,

targetOffset,

offsetSmoothSpeed * Time.deltaTime

);

Vector3 desiredPosition = target.position + currentOffset;

transform.position = Vector3.Lerp(

transform.position,

desiredPosition,

smoothSpeed * Time.deltaTime

);

transform.LookAt(target);

}

これにより、オフセットの変更も滑らかになります。

壁を通り抜けない追従

カメラが壁を通り抜けてしまうのを防ぐ実装方法を見ていきましょう。

レイキャストによる衝突検出

Physics.Raycastを使って、カメラと対象の間に壁があるかを検出します。

public Transform target;
public Vector3 offset = new Vector3(0, 5, -10);
public float smoothSpeed = 5.0f;
public LayerMask wallLayer;  // 壁のレイヤー
public float minDistance = 2.0f;  // 最小距離

void LateUpdate()
{
    if (target == null) return;
    
    Vector3 desiredPosition = target.position + offset;
    Vector3 direction = desiredPosition - target.position;
    float distance = direction.magnitude;
    
    RaycastHit hit;
    if (Physics.Raycast(target.position, direction.normalized, out hit, distance, wallLayer))
    {
        // 壁にぶつかった場合は、壁の手前に配置
        desiredPosition = hit.point - direction.normalized * minDistance;
    }
    
    transform.position = Vector3.Lerp(
        transform.position,
        desiredPosition,
        smoothSpeed * Time.deltaTime
    );
    
    transform.LookAt(target);
}

public Transform target;

public Vector3 offset = new Vector3(0, 5, -10);

public float smoothSpeed = 5.0f;

public LayerMask wallLayer; // 壁のレイヤー

public float minDistance = 2.0f; // 最小距離

void LateUpdate()

{

if (target == null) return;

Vector3 desiredPosition = target.position + offset;

Vector3 direction = desiredPosition - target.position;

float distance = direction.magnitude;

RaycastHit hit;

if (Physics.Raycast(target.position, direction.normalized, out hit, distance, wallLayer))

{

// 壁にぶつかった場合は、壁の手前に配置

desiredPosition = hit.point - direction.normalized * minDistance;

}

transform.position = Vector3.Lerp(

transform.position,

desiredPosition,

smoothSpeed * Time.deltaTime

);

transform.LookAt(target);

}

これにより、カメラが壁を通り抜けることを防げます。

SphereCastを使った衝突検出

カメラのサイズを考慮する場合は、Physics.SphereCastを使います。

public float cameraRadius = 0.5f;  // カメラの半径

void LateUpdate()
{
    if (target == null) return;
    
    Vector3 desiredPosition = target.position + offset;
    Vector3 direction = desiredPosition - target.position;
    float distance = direction.magnitude;
    
    RaycastHit hit;
    if (Physics.SphereCast(target.position, cameraRadius, direction.normalized, out hit, distance, wallLayer))
    {
        // カメラの半径を考慮して配置
        desiredPosition = hit.point - direction.normalized * (minDistance + cameraRadius);
    }
    
    transform.position = Vector3.Lerp(
        transform.position,
        desiredPosition,
        smoothSpeed * Time.deltaTime
    );
    
    transform.LookAt(target);
}

public float cameraRadius = 0.5f; // カメラの半径

void LateUpdate()

{

if (target == null) return;

Vector3 desiredPosition = target.position + offset;

Vector3 direction = desiredPosition - target.position;

float distance = direction.magnitude;

RaycastHit hit;

if (Physics.SphereCast(target.position, cameraRadius, direction.normalized, out hit, distance, wallLayer))

{

// カメラの半径を考慮して配置

desiredPosition = hit.point - direction.normalized * (minDistance + cameraRadius);

}

transform.position = Vector3.Lerp(

transform.position,

desiredPosition,

smoothSpeed * Time.deltaTime

);

transform.LookAt(target);

}

これにより、カメラのサイズを考慮した衝突検出が可能になります。

Unityでの実装例（C#コード）

Unityでカメラ追従を実装する具体的な例を見ていきましょう。

高度な追従カメラクラス

using UnityEngine;

public class AdvancedFollowCamera : MonoBehaviour
{
    [Header("追従設定")]
    public Transform target;
    public Vector3 offset = new Vector3(0, 5, -10);
    public float smoothSpeed = 5.0f;
    
    [Header("予測追従")]
    public bool usePrediction = false;
    public float predictionAmount = 0.5f;
    
    [Header("距離ベースの速度調整")]
    public bool useDistanceBasedSpeed = false;
    public float minSmoothSpeed = 3.0f;
    public float maxSmoothSpeed = 10.0f;
    public float maxDistance = 20.0f;
    
    [Header("壁との衝突")]
    public bool checkWallCollision = true;
    public LayerMask wallLayer;
    public float minDistance = 2.0f;
    public float cameraRadius = 0.5f;
    
    [Header("ローカル座標オフセット")]
    public bool useLocalOffset = false;
    public Vector3 localOffset = new Vector3(0, 5, -10);
    
    private Vector3 previousTargetPosition;
    private Vector3 targetVelocity;
    private Vector3 currentOffset;
    
    void Start()
    {
        if (target != null)
        {
            previousTargetPosition = target.position;
            if (!useLocalOffset)
            {
                currentOffset = offset;
            }
            else
            {
                currentOffset = localOffset;
            }
        }
    }
    
    void LateUpdate()
    {
        if (target == null) return;
        
        // 速度を計算（予測追従用）
        if (usePrediction)
        {
            targetVelocity = (target.position - previousTargetPosition) / Time.deltaTime;
            previousTargetPosition = target.position;
        }
        
        // 目標位置を計算
        Vector3 targetPosition = target.position;
        if (usePrediction)
        {
            targetPosition += targetVelocity * predictionAmount;
        }
        
        // オフセットを計算
        Vector3 calculatedOffset;
        if (useLocalOffset)
        {
            calculatedOffset = target.TransformDirection(localOffset);
        }
        else
        {
            calculatedOffset = offset;
        }
        
        Vector3 desiredPosition = targetPosition + calculatedOffset;
        
        // 壁との衝突をチェック
        if (checkWallCollision)
        {
            Vector3 direction = desiredPosition - targetPosition;
            float distance = direction.magnitude;
            
            RaycastHit hit;
            if (Physics.SphereCast(targetPosition, cameraRadius, direction.normalized, out hit, distance, wallLayer))
            {
                desiredPosition = hit.point - direction.normalized * (minDistance + cameraRadius);
            }
        }
        
        // 距離ベースの速度調整
        float currentSmoothSpeed = smoothSpeed;
        if (useDistanceBasedSpeed)
        {
            float distance = Vector3.Distance(transform.position, desiredPosition);
            float normalizedDistance = Mathf.Clamp01(distance / maxDistance);
            currentSmoothSpeed = Mathf.Lerp(minSmoothSpeed, maxSmoothSpeed, normalizedDistance);
        }
        
        // 滑らかに移動
        transform.position = Vector3.Lerp(
            transform.position,
            desiredPosition,
            currentSmoothSpeed * Time.deltaTime
        );
        
        // 対象を見る
        if (usePrediction)
        {
            transform.LookAt(targetPosition);
        }
        else
        {
            transform.LookAt(target);
        }
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

using UnityEngine;

public class AdvancedFollowCamera : MonoBehaviour

{

[Header("追従設定")]

public Transform target;

public Vector3 offset = new Vector3(0, 5, -10);

public float smoothSpeed = 5.0f;

[Header("予測追従")]

public bool usePrediction = false;

public float predictionAmount = 0.5f;

[Header("距離ベースの速度調整")]

public bool useDistanceBasedSpeed = false;

public float minSmoothSpeed = 3.0f;

public float maxSmoothSpeed = 10.0f;

public float maxDistance = 20.0f;

[Header("壁との衝突")]

public bool checkWallCollision = true;

public LayerMask wallLayer;

public float minDistance = 2.0f;

public float cameraRadius = 0.5f;

[Header("ローカル座標オフセット")]

public bool useLocalOffset = false;

public Vector3 localOffset = new Vector3(0, 5, -10);

private Vector3 previousTargetPosition;

private Vector3 targetVelocity;

private Vector3 currentOffset;

void Start()

{

if (target != null)

{

previousTargetPosition = target.position;

if (!useLocalOffset)

{

currentOffset = offset;

}

else

{

currentOffset = localOffset;

}

void LateUpdate()

{

if (target == null) return;

// 速度を計算（予測追従用）

if (usePrediction)

{

targetVelocity = (target.position - previousTargetPosition) / Time.deltaTime;

previousTargetPosition = target.position;

}

// 目標位置を計算

Vector3 targetPosition = target.position;

if (usePrediction)

{

targetPosition += targetVelocity * predictionAmount;

}

// オフセットを計算

Vector3 calculatedOffset;

if (useLocalOffset)

{

calculatedOffset = target.TransformDirection(localOffset);

}

else

{

calculatedOffset = offset;

}

Vector3 desiredPosition = targetPosition + calculatedOffset;

// 壁との衝突をチェック

if (checkWallCollision)

{

Vector3 direction = desiredPosition - targetPosition;

float distance = direction.magnitude;

RaycastHit hit;

if (Physics.SphereCast(targetPosition, cameraRadius, direction.normalized, out hit, distance, wallLayer))

{

desiredPosition = hit.point - direction.normalized * (minDistance + cameraRadius);

}

// 距離ベースの速度調整

float currentSmoothSpeed = smoothSpeed;

if (useDistanceBasedSpeed)

{

float distance = Vector3.Distance(transform.position, desiredPosition);

float normalizedDistance = Mathf.Clamp01(distance / maxDistance);

currentSmoothSpeed = Mathf.Lerp(minSmoothSpeed, maxSmoothSpeed, normalizedDistance);

}

// 滑らかに移動

transform.position = Vector3.Lerp(

transform.position,

desiredPosition,

currentSmoothSpeed * Time.deltaTime

);

// 対象を見る

if (usePrediction)

{

transform.LookAt(targetPosition);

}

else

{

transform.LookAt(target);

}

このクラスでは、様々なオプションを組み合わせて、柔軟なカメラ追従が可能になります。

⚠️ 注意点

LateUpdateを使うことで、プレイヤーの移動後にカメラを更新できる
Time.deltaTimeを掛けることで、フレームレートに依存しない補間になる
壁の衝突チェックは、計算コストがかかるため必要に応じて有効化する
予測追従は、プレイヤーの動きが予測可能な場合に有効

カメラ追従の実装手順

※この順番を守らずに作り始めると、だいたい後で全部作り直すことになります。

カメラ追従の実装手順

STEP1
基本的な追従を実装

オフセットを使った基本的な追従カメラを実装します。

目標位置 = 対象の位置 + オフセットの計算を実装しましょう。
STEP2
滑らかな追従の追加

Lerpを使って、滑らかな追従を追加します。

LateUpdateを使い、Time.deltaTimeを掛けて補間しましょう。
STEP3
オフセットの調整

必要に応じて、ローカル座標系でのオフセットや動的なオフセット調整を実装します。
STEP4
壁との衝突検出

レイキャストやSphereCastを使って、壁との衝突を検出します。

衝突時は、適切な位置にカメラを配置しましょう。
STEP5
最適化と調整

パラメータを調整して、快適なカメラ追従を実現します。

予測追従や距離ベースの速度調整などを追加してもよいでしょう。

よくある問題と解決方法

カメラ追従を実装する際によくある問題と、その解決方法を紹介します。

カメラがプレイヤーと重なる

オフセットを設定していない、またはオフセットが0になっている可能性があります。

// ✅ 正しい実装
public Vector3 offset = new Vector3(0, 5, -10);
Vector3 desiredPosition = target.position + offset;

// ❌ 間違った実装
transform.position = target.position;  // 重なってしまう

// ✅ 正しい実装

public Vector3 offset = new Vector3(0, 5, -10);

Vector3 desiredPosition = target.position + offset;

// ❌ 間違った実装

transform.position = target.position; // 重なってしまう

カメラがカクつく

UpdateではなくLateUpdateを使い、Time.deltaTimeを掛ける必要があります。

// ✅ 正しい実装
void LateUpdate()
{
    transform.position = Vector3.Lerp(
        transform.position,
        desiredPosition,
        smoothSpeed * Time.deltaTime  // Time.deltaTimeを掛ける
    );
}

// ❌ 間違った実装
void Update()
{
    transform.position = Vector3.Lerp(
        transform.position,
        desiredPosition,
        smoothSpeed  // Time.deltaTimeがないとカクつく
    );
}

// ✅ 正しい実装

void LateUpdate()

{

transform.position = Vector3.Lerp(

transform.position,

desiredPosition,

smoothSpeed * Time.deltaTime // Time.deltaTimeを掛ける

);

}

// ❌ 間違った実装

void Update()

{

transform.position = Vector3.Lerp(

transform.position,

desiredPosition,

smoothSpeed // Time.deltaTimeがないとカクつく

);

}

対象が回転するとオフセットがずれる

ローカル座標系でのオフセットを使うか、オフセットを回転させます。

// ✅ ローカル座標系でのオフセット
Vector3 worldOffset = target.TransformDirection(localOffset);

// または、オフセットを回転
Vector3 rotatedOffset = target.rotation * offset;

// ✅ ローカル座標系でのオフセット

Vector3 worldOffset = target.TransformDirection(localOffset);

// または、オフセットを回転

Vector3 rotatedOffset = target.rotation * offset;

壁を通り抜ける

レイキャストやSphereCastで衝突を検出し、適切な位置に配置します。

RaycastHit hit;
if (Physics.Raycast(target.position, direction.normalized, out hit, distance, wallLayer))
{
    desiredPosition = hit.point - direction.normalized * minDistance;
}

RaycastHit hit;