【C++】第五回 C++を使ったゲーム開発 〜OpenGLを使った3Dゲーム開発編〜

.
└── src
    ├── Actors
    │   ├── Actor.cpp
    │   ├── Actor.h
    │   ├── Bomb.cpp
    │   ├── Bomb.h
    │   ├── Camera.cpp
    │   ├── Camera.h
    │   ├── Enemy.cpp
    │   ├── Enemy.h
    │   ├── EnemyMarker.cpp
    │   ├── EnemyMarker.h
    │   ├── Missile.cpp
    │   ├── Missile.h
    │   ├── Ship.cpp
    │   ├── Ship.h
    │   ├── SkyBox.cpp
    │   └── SkyBox.h
    ├── Commons
    │   ├── Collider.cpp
    │   ├── Collider.h
    │   ├── Math.h
    │   ├── Mesh.cpp
    │   ├── Mesh.h
    │   ├── Renderer.cpp
    │   ├── Renderer.h
    │   ├── Shader.cpp
    │   ├── Shader.h
    │   ├── Texture.cpp
    │   ├── Texture.h
    │   ├── VertexArray.cpp
    │   └── VertexArray.h
    ├── Components
    │   ├── BoxColliderComponent.cpp
    │   ├── BoxColliderComponent.h
    │   ├── Component.cpp
    │   ├── Component.h
    │   ├── MeshComponent.cpp
    │   ├── MeshComponent.h
    │   ├── SpriteComponent.cpp
    │   └── SpriteComponent.h
    ├── Scenes
    │   ├── EndScene.cpp
    │   ├── EndScene.h
    │   ├── GameScene.cpp
    │   ├── GameScene.h
    │   ├── ReadyScene.cpp
    │   ├── ReadyScene.h
    │   ├── Scene.cpp
    │   └── Scene.h
    ├── Shaders
    │   ├── BasicFrag.glsl
    │   ├── BasicVert.glsl
    │   ├── LambertFrag.glsl
    │   ├── LambertVert.glsl
    │   ├── PhongFrag.glsl
    │   ├── PhongVert.glsl
    │   ├── SpriteFrag.glsl
    │   └── SpriteVert.glsl
    ├── Game.cpp
    ├── Game.h
    └── main.cpp

// データロード処理
bool Game::LoadData()
{
    // 描画データロード
    if (!mRenderer->LoadData()) return false;

    // 背景の作成
    auto* bgBack = new SkyBox(this, "bg_back.fbx", 5.0f);
    bgBack->SetScale(Vector3(1.2f, 1.2f, 1.2f));
    auto* bgFront = new SkyBox(this, "bg_front.fbx", 7.0f);
    bgFront->SetScale(Vector3(0.65f, 0.65f, 0.65f));

    return true;
}

#include "SkyBox.h"
#include "../Game.h"
#include "../Commons/Mesh.h"
#include "../Components/MeshComponent.h"

SkyBox::SkyBox(class Game *game, std::string fbxName, float rotSpeed)
:Actor(game)
{
    auto* bgBackMeshComp = new MeshComponent(this);
    auto* bgBackMesh = game->GetRenderer()->GetMesh(game->GetAssetsPath() + fbxName);
    bgBackMeshComp->SetMesh(bgBackMesh);
    auto* bgBackShader = game->GetRenderer()->GetShader(Shader::ShaderType::SPRITE);
    bgBackMeshComp->SetShader(bgBackShader);

    // 回転速度を設定
    mRotSpeed = rotSpeed;
}

void SkyBox::UpdateActor(float deltaTime)
{
    Actor::UpdateActor(deltaTime);

    // 回転させる
    Vector3 rotation = GetRotation();
    rotation.y += mRotSpeed * deltaTime;
    SetRotation(rotation);
}

void SkyBox::ProcessInput(const uint8_t *state, float deltaTime)
{
    Actor::ProcessInput(state, deltaTime);
}

#include "Ship.h"
#include "Bomb.h"
#include "Camera.h"
#include "Enemy.h"
#include "Missile.h"
#include "../Game.h"
#include "../Commons/Mesh.h"
#include "../Components/BoxColliderComponent.h"
#include "../Components/MeshComponent.h"
#include "../Scenes/EndScene.h"

Ship::Ship(class Game *game)
: Actor(game)
{
    auto* meshComp = new MeshComponent(this);
    auto* mesh = game->GetRenderer()->GetMesh(game->GetAssetsPath() + "ship.fbx");
    meshComp->SetMesh(mesh);
    auto* shader = game->GetRenderer()->GetShader(Shader::ShaderType::PHONG);
    meshComp->SetShader(shader);
    mCollider = new BoxColliderComponent(this);
    mCollider->SetObjectAABB(mesh->GetBox());

    // gameクラスに保持
    game->SetShip(this);
}

void Ship::UpdateActor(float deltaTime)
{
    Actor::UpdateActor(deltaTime);

    // GameScene以外は向き固定
    if (GetGame()->GetScene()->GetSceneName() != "GAME")
    {
        Vector3 rotation = GetRotation();
        rotation.z = 0.0f;
        SetRotation(rotation);
        return;
    }

    // 回転が変わった場合
    bool isChangeRotLeft  = mIsRotLeft  != mIsRotLeftBefore;
    bool isChangeRotRight = mIsRotRight != mIsRotRightBefore;
    if (isChangeRotLeft || isChangeRotRight)
    {
        // 船の傾きを調整
        // 同時押しされた場合も考慮
        float rot = 0.0f;
        if (mIsRotLeft)  rot += mRotTilt;
        if (mIsRotRight) rot += -mRotTilt;
        Vector3 rotation = GetRotation();
        rotation.z = rot;
        SetRotation(rotation);
    }
    // 回転中フラグを保持
    mIsRotLeftBefore = mIsRotLeft;
    mIsRotRightBefore = mIsRotRight;

    // ミサイルを撃つ間隔を開ける
    if (!mIsCanShot)
    {
        mDeltaShotTime += deltaTime;
        if (mDeltaShotTime > CanShotTime)
        {
            mIsCanShot = true;
            mDeltaShotTime = 0.0f;
        }
    }
}

・・・略・・・

void Ship::ProcessInput(const uint8_t *state, float deltaTime)
{
    Actor::ProcessInput(state, deltaTime);

    // GameScene以外は操作不能にする
    if (GetGame()->GetScene()->GetSceneName() != "GAME") return;

    // 押下キー方向に回転する
    mIsRotLeft = false;
    mIsRotRight = false;
    if (state[SDL_SCANCODE_A])
    {
        Vector3 rotation = GetRotation();
        rotation.y += -mRotSpeed * deltaTime;
        SetRotation(rotation);
        mIsRotLeft = true;
    }
    if (state[SDL_SCANCODE_D])
    {
        Vector3 rotation = GetRotation();
        rotation.y += mRotSpeed * deltaTime;
        SetRotation(rotation);
        mIsRotRight = true;
    }
    // ミサイル発射
    if (state[SDL_SCANCODE_K])
    {
        if (mIsCanShot) {
            // 撃つ間隔を開けるためフラグを変更
            mIsCanShot = false;
            mDeltaShotTime = 0.0f;
            // 前方にミサイル生成
            auto* missile = new Missile(GetGame());
            missile->SetPosition(GetPosition() + 3.0f * GetForward());
            // 縦方向の調整
            Vector3 rotation = GetRotation();
            if (state[SDL_SCANCODE_W])
            {
                rotation.x = -mShotRotVertical;
            }
            if (state[SDL_SCANCODE_S])
            {
                rotation.x = mShotRotVertical;
            }
            missile->SetRotation(rotation);
        }
    }
}

void Camera::UpdateActor(float deltaTime)
{
    Actor::UpdateActor(deltaTime);

    Vector3 position; // カメラ位置
    Vector3 target;   // ターゲット位置
    Vector3 up = Math::VEC3_UNIT_Y; // 上方向ベクトル

・・・略・・・

            // カメラ位置をターゲットの後方に設定
            position = mTargetActor->GetPosition();
            position -= mOffsetPosForward * mTargetActor->GetForward();
            position += mOffsetPosUp * Math::VEC3_UNIT_Y;
            SetPosition(position);
            // 注視点をターゲットの前方に設定
            target = mTargetActor->GetPosition();
            target += mOffsetLookForward * mTargetActor->GetForward();

・・・略・・・

    Matrix4 viewMatrix = Matrix4::CreateLookAt(position, target, up);
    GetGame()->GetRenderer()->SetViewMatrix(viewMatrix);
}

void Actor::SetRotation(const Vector3& rotation)
{
    mRotation = rotation;
    // 0〜360の間に収める
    mRotation.x = fmod(mRotation.x, 360.0f);
    mRotation.y = fmod(mRotation.y, 360.0f);
    mRotation.z = fmod(mRotation.z, 360.0f);
    // -の場合は+360する
    if (mRotation.x < 0.0f) mRotation.x += 360.0f;
    if (mRotation.y < 0.0f) mRotation.y += 360.0f;
    if (mRotation.z < 0.0f) mRotation.z += 360.0f;
    mRecalculateWorldTransform = true;
}

const Quaternion Actor::GetRotationQuaternion() const
{
    Quaternion q = Quaternion();
    // rotate Y Y軸そのまま回転
    q = Quaternion::Concatenate(q, Quaternion(Math::VEC3_UNIT_Y, Math::ToRadians(mRotation.y)));
    // rotate X Y軸適用後に回転
    Vector3 right = Quaternion::RotateVec(Math::VEC3_UNIT_X, q);
    q = Quaternion::Concatenate(q, Quaternion(right, Math::ToRadians(mRotation.x)));
    // rotate Z XY軸適用後に回転
    Vector3 forward = Quaternion::RotateVec(Math::VEC3_UNIT_Z, q);
    q = Quaternion::Concatenate(q, Quaternion(forward, Math::ToRadians(mRotation.z)));
    return q;
}

void Missile::UpdateActor(float deltaTime)
{
    Actor::UpdateActor(deltaTime);

    // 前方へ進む
    Vector3 pos = GetPosition();
    pos += mSpeed * deltaTime * GetForward();
    SetPosition(pos);

    // 一定距離離れたら破棄
    if (pos.Length() > mDistance)
    {
        SetState(EDead);
    }
}

// 上から見た時の角度から位置を設定する
// *正面：0度 右斜め前：30度
void Enemy::SetInitPositionByDegree(float degree)
{
    // Y軸の回転クォータニオン
    Quaternion q(Math::VEC3_UNIT_Y, Math::ToRadians(degree));
    // 正面のベクトルを回転した位置を求める
    Vector3 pos = mAppearDistance * Math::VEC3_UNIT_Z;
    pos = Quaternion::RotateVec(pos, q);
    Actor::SetPosition(pos);
    // 初期位置を保持する
    mInitPosition = Vector3(pos.x, pos.y, pos.z);
    // 中央を向かせる(270-θ)
    float radian = atan2(pos.z, pos.x);
    Vector3 rotation = GetRotation();
    rotation.y += Math::ToDegrees(1.5f*Math::Pi - radian);
    SetRotation(rotation);
}

void Enemy::UpdateActor(float deltaTime)
{
    Actor::UpdateActor(deltaTime);

    // 待機時間分待つ
    mTimeCount += deltaTime;
    if (mTimeCount < mWaitTime) return;

    // プレイヤー位置(0, 0)まで来た場合
    Vector3 pos = GetPosition();
    if (fabs(pos.x) <= 1.0f && fabs(pos.y) <= 1.0f && fabs(pos.z) <= 1.0f)
    {
        // 喜びの舞い
        Vector3 rotation = GetRotation();
        rotation.y += mHappyRotSpeed * deltaTime;
        SetRotation(rotation);
        return;
    }

    // 真ん中に来るまで進む
    if (mTotalMove < mAppearDistance - 0.0f) {
        mTotalMove += (mSpeed * deltaTime * GetForward()).Length();
    }

    // 幅が設定されている場合は揺らす
    Vector3 rightOffset = Math::VEC3_ZERO + cosf(mTimeCount / 0.2f) * mShakeWidth.x * GetRight(); // 横揺れ
    Vector3 upOffset    = Vector3(0.0f, cosf(mTimeCount / 0.2f) * mShakeWidth.y, 0.0f); // 縦揺れ

    // 位置更新
    Vector3 newPos = mInitPosition + (mTotalMove * GetForward() + rightOffset + upOffset);
    SetPosition(newPos);
}

void GameScene::Start()
{
    Scene::Start();

    // エネミー生成
    float tmpDegree = 0.0f;
    for (int i = 0; i < 15; i++)
    {
        auto* enemy = new Enemy(mGame);
        // 前回の出現位置+-60度
        tmpDegree += Math::GetRand(-60.0f, 60.0f);
        enemy->SetInitPositionByDegree(tmpDegree);
        // 速度徐々に速く
        enemy->SetSpeed(Math::GetRand(25.0f, 45.0f) * (1.0f + i*0.02f));
        // 大きさ
        enemy->SetScale(Math::GetRand(1.0f, 3.0f) * Math::VEC3_UNIT);
        // 揺れ幅 基本は横のみ
        enemy->SetShakeWidth(Vector2(Math::GetRand(-7.0f, 7.0f), 0.0f));
        // 数匹ごとに縦揺れも追加
        if (i%3 == 2)
        {
            enemy->SetShakeWidth(Vector2(Math::GetRand(-10.0f, 10.0f), Math::GetRand(-8.5f, 8.5f)));
        }
        // 3匹ずつ出現させる
        enemy->SetWaitTime(i / 3 * Math::GetRand(4.0f, 5.5f));
    }
}

// AABBのMin、Max頂点を更新する
void AABB::UpdatePointMinMax(const Vector3 &point)
{
    mMin.x = std::min(mMin.x, point.x);
    mMin.y = std::min(mMin.y, point.y);
    mMin.z = std::min(mMin.z, point.z);
    mMax.x = std::max(mMax.x, point.x);
    mMax.y = std::max(mMax.y, point.y);
    mMax.z = std::max(mMax.z, point.z);
}

// Actorの更新に合わせてワールド座標変換する
void BoxColliderComponent::OnUpdateWorldTransform()
{
    // オブジェクト座標でリセット
    mWorldAABB = mObjectAABB;
    // scale
    Vector3 scale = mActor->GetScale();
    mWorldAABB.mMin = Vector3(mWorldAABB.mMin.x*scale.x, mWorldAABB.mMin.y*scale.y, mWorldAABB.mMin.z*scale.z);
    mWorldAABB.mMax = Vector3(mWorldAABB.mMax.x*scale.x, mWorldAABB.mMax.y*scale.y, mWorldAABB.mMax.z*scale.z);
    // rotation
    mWorldAABB.Rotate(mActor->GetRotationQuaternion());
    // position
    mWorldAABB.mMin += mActor->GetPosition();
    mWorldAABB.mMax += mActor->GetPosition();
}

// 頂点の回転
void AABB::Rotate(const Quaternion& q)
{
    // AABBの8点を設定
    std::array<Vector3, 8> points;
    points[0] = mMin;
    points[1] = Vector3(mMax.x, mMin.y, mMin.z);
    points[2] = Vector3(mMin.x, mMax.y, mMin.z);
    points[3] = Vector3(mMin.x, mMin.y, mMax.z);
    points[4] = Vector3(mMin.x, mMax.y, mMax.z);
    points[5] = Vector3(mMax.x, mMin.y, mMax.z);
    points[6] = Vector3(mMax.x, mMax.y, mMin.z);
    points[7] = mMax;

    // Min、Max頂点を更新
    Vector3 p = Quaternion::RotateVec(points[0], q);
    mMin = p;
    mMax = p;
    for (int i = 1; i < points.size(); i++)
    {
        p = Quaternion::RotateVec(points[i], q);
        UpdatePointMinMax(p);
    }
}

// 衝突判定処理
// AABB * AABB
bool Intersect(const AABB &a, const AABB &b)
{
    // どれかの辺が重なっているか？
    bool noCollision =
            a.mMax.x < b.mMin.x ||
            a.mMax.y < b.mMin.y ||
            a.mMax.z < b.mMin.z ||
            b.mMax.x < a.mMin.x ||
            b.mMax.y < a.mMin.y ||
            b.mMax.z < a.mMin.z;
    return !noCollision;
}

void Ship::LateUpdateActor(float deltaTime)
{
    // エネミーと衝突したら破壊
    for (auto enemy : GetGame()->GetEnemies())
    {
        if (Intersect(mCollider->GetWorldBox(), enemy->GetCollider()->GetWorldBox()))
        {
            // プレイヤーが消えるため、ダミーのアクタをカメラターゲットに設定す
            auto* dummy = new Actor(GetGame());
            dummy->SetPosition(GetPosition());
            dummy->SetRotation(GetRotation());
            GetGame()->GetRenderer()->GetCamera()->SetTargetActor(dummy);
            // プレイヤー破棄
            SetState(EDead);
            // 爆発エフェクトを生成
            auto* bomb = new Bomb(GetGame());
            Vector3 position = GetPosition();
            position -= 2.0f * GetForward();
            bomb->SetPosition(position);
            // 画面の方を向かせる
            Vector3 rotation = Vector3(-15.0f, GetRotation().y + 180.0f, 0.0f);
            bomb->SetRotation(rotation);
            // ゲーム終了
            GetGame()->SetNextScene(new EndScene(GetGame()));
            break;
        }
    }
}

void EnemyMarker::LateUpdateActor(float deltaTime)
{
    Actor::LateUpdateActor(deltaTime);

    // ターゲットが設定されていない場合
    if (!mTarget) return;

    // 一旦非表示
    SetScale(Math::VEC3_ZERO);

    // viewProjectionMatrix取得
    Matrix4 viewProjection = GetGame()->GetRenderer()->GetProjectionMatrix() * GetGame()->GetRenderer()->GetViewMatrix();
    // エネミーのクリップ座標を求める
    Matrix4 enemyWorld = mTarget->GetWorldTransform();
    Vector3 enemyViewPos = viewProjection * enemyWorld * Math::VEC3_UNIT;
    // プレイヤー取得
    auto* player = GetGame()->GetRenderer()->GetCamera()->GetTargetActor();
    if (!player) return;
    // プレイヤーのクリップ座標を求める
    Matrix4 playerWorld = player->GetWorldTransform();
    Vector3 playerViewPos = viewProjection * playerWorld * Math::VEC3_UNIT;

    // 画面に映っていないエネミーのみマーカーを付ける
    if (enemyViewPos.x < -1.0f || enemyViewPos.x > 1.0f || enemyViewPos.z > 1.0f)
    {
        // 横に範囲がずれているエネミー
        // 見える範囲に調整
        if (enemyViewPos.x < -1.0f) enemyViewPos.x = -0.95f;
        if (enemyViewPos.x > 1.0f)  enemyViewPos.x =  0.95f;

        enemyViewPos.x *= GetGame()->ScreenWidth*0.5f;
        enemyViewPos.y *= GetGame()->ScreenHeight*0.5f;

        // 後ろ側のエネミー
        // XY値を反転してZを0にする
        if (enemyViewPos.z > 1.0f)
        {
            enemyViewPos.x *= -1.0f;
            enemyViewPos.y *= -1.0f;
            enemyViewPos.z = 0.0f;
        }
        SetPosition(enemyViewPos);

        // 向き調整
        Vector3 distance = enemyViewPos - playerViewPos;
        Vector3 rotation = GetRotation();
        rotation.z = Math::ToDegrees(atan2(distance.y, distance.x)-Math::Pi/2.0f); // atan2-90度
        SetRotation(rotation);

        // マーカー表示
        // 距離によってサイズを変える
        float markerScale = 0.0f;
        float enemyDistance = mTarget->GetPosition().Length();
        if (enemyDistance < 75.0f)
        {
            markerScale = 1.0f;
        }
        else if (enemyDistance < 150.0f)
        {
            markerScale = 2.0f - enemyDistance / 75.0f;
        }
        SetScale(Vector3(markerScale, markerScale, markerScale));
    }
}

void Camera::UpdateActor(float deltaTime)
{
    Actor::UpdateActor(deltaTime);

    Vector3 position; // カメラ位置
    Vector3 target;   // ターゲット位置
    Vector3 up = Math::VEC3_UNIT_Y; // 上方向ベクトル
    if (!mTargetActor)
    {
        // ターゲットが設定されていない場合
        position = GetPosition();
        target = GetPosition() + mOffsetLookForward * GetForward();
    }
    else
    {
        // 登場アニメーションが完了していない場合
        if (!mIsAnimFinish)
        {
            // カメラ位置を少しずつずらす
            position = GetPosition();
            position += deltaTime * mAnimLookVec;
            SetPosition(position);
            // 注視点をターゲットの前方に設定
            target = mTargetActor->GetPosition();
            target += mAnimOffsetLookForward * mTargetActor->GetForward();
            // アニメーション時間更新
            mTotalAnimTime += deltaTime;
            if (mTotalAnimTime >= mAnimTime)
            {
                mIsAnimFinish = true;
            }
        }
        else
        {
            // カメラ位置をターゲットの後方に設定
            position = mTargetActor->GetPosition();
            position -= mOffsetPosForward * mTargetActor->GetForward();
            position += mOffsetPosUp * Math::VEC3_UNIT_Y;
            SetPosition(position);
            // 注視点をターゲットの前方に設定
            target = mTargetActor->GetPosition();
            target += mOffsetLookForward * mTargetActor->GetForward();
        }
    }
    Matrix4 viewMatrix = Matrix4::CreateLookAt(position, target, up);
    GetGame()->GetRenderer()->SetViewMatrix(viewMatrix);
}

// アニメーション開始
void Camera::AnimStart()
{
    // アニメーションフラグ初期化
    mTotalAnimTime = 0.0f;
    mIsAnimFinish = false;
    // アニメーション初期位置に設定
    SetPosition(mAnimOffsetInitDistance * mAnimLookVec);
}

void ReadyScene::Start()
{
    Scene::Start();

    // クリアフラグを初期化
    mGame->SetGameClear(false);
    // 宇宙船の作成
    auto* ship = new Ship(mGame);
    ship->SetPosition(Vector3(0.0f, 0.0f, 0.0f));
    // カメラターゲットに設定
    mGame->GetRenderer()->GetCamera()->SetTargetActor(ship);
    // タイトルメッセージを表示
    mTitleMsg = new Actor(mGame);
    mTitleMsg->SetPosition(Vector3(-220.0f, 200.0f, 0.0f));
    auto* titleMsgSprite = new SpriteComponent(mTitleMsg, 200);
    titleMsgSprite->SetTexture(mGame->GetRenderer()->GetTexture(mGame->GetAssetsPath() + "msg_title.png"));
    // 見えやすいようにライティング調整
    mGame->GetRenderer()->SetDirLightDirection(Vector3(0.3f, 0.3f, 0.5f));
    // 登場アニメーション開始
    mGame->GetRenderer()->GetCamera()->AnimStart();
}

void ReadyScene::Update(float deltaTime)
{
    Scene::Update(deltaTime);

    // アニメーションが終わった場合
    if (!mStartMsg && mGame->GetRenderer()->GetCamera()->GetIsAnimFinish())
    {
        // タイトルメッセージを破棄
        mTitleMsg->SetState(Actor::EDead);
        // 開始メッセージを表示
        mStartMsg = new Actor(mGame);
        mStartMsg->SetPosition(Math::VEC3_ZERO);
        auto* startMsgSprite = new SpriteComponent(mStartMsg, 200);
        startMsgSprite->SetTexture(mGame->GetRenderer()->GetTexture(mGame->GetAssetsPath() + "msg_start.png"));
        // 操作説明を表示
        mMenuMsg = new Actor(mGame);
        mMenuMsg->SetPosition(Vector3(0.0f, 210.0f, 0.0f));
        auto* menuMsgSprite = new SpriteComponent(mMenuMsg, 200);
        menuMsgSprite->SetTexture(mGame->GetRenderer()->GetTexture(mGame->GetAssetsPath() + "msg_menu.png"));
        // ライティング元に戻す
        mGame->GetRenderer()->SetDirLightDirection(Vector3(0.5f, -0.35f, 0.35f));
    }
}