【C++】第四回 C++を使ったゲーム開発 〜3Dゲーム開発基礎 fbx読込とシェーダ編〜

VertexArray::VertexArray(const float *vertices,

                         unsigned int numVertices,
                         const unsigned int *indices,
                         unsigned int numIndices)
:mNumVertices(numVertices)
,mNumIndices(numIndices)
{
    // 頂点配列オブジェクトの作成
    glGenVertexArrays(1, &mVertexArray);
    glBindVertexArray(mVertexArray);

    // 頂点バッファの作成
    glGenBuffers(1, &mVertexBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
    glBufferData(GL_ARRAY_BUFFER,                 // バッファの種類
                 numVertices * 8 * sizeof(float), // コピーするバイト数(位置(xyz), 法線(xyz), u, v)
                 vertices,                        // コピー元
                 GL_STATIC_DRAW);                 // データの利用方法

    // インデックスバッファの作成
    glGenBuffers(1, &mIndexBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER,           // バッファの種類
                 numIndices * sizeof(unsigned int), // コピーするバイト数
                 indices,                           // コピー元
                 GL_STATIC_DRAW);                   // データの利用方法

    // 頂点レイアウトの指定
    // 頂点属性0: 位置(x,y,z)
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 8, 0);
    // 頂点属性1: 法線(x,y,z)
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(float) * 8,
                          reinterpret_cast<void*>(sizeof(float) * 3)); // オフセット値
    // 頂点属性2: u,v
    glEnableVertexAttribArray(2);
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 8,
                          reinterpret_cast<void*>(sizeof(float) * 6)); // オフセット値
}

    // マネージャーの初期化
    FbxManager* manager = FbxManager::Create();

    // インポーターの初期化
    FbxImporter* importer = FbxImporter::Create(manager, "");
    if (!importer->Initialize(filePath.c_str(), -1, manager->GetIOSettings()))
    {
        SDL_Log("failed fbx initialize importer.");
        return false;
    }

    // シーンの作成
    FbxScene* scene = FbxScene::Create(manager, "");
    importer->Import(scene);
    importer->Destroy();

    // 三角ポリゴンへのコンバート
    FbxGeometryConverter geometryConverter(manager);
    if (!geometryConverter.Triangulate(scene, true))
    {
        SDL_Log("failed fbx convert triangle.");
        return false;
    }

    // メッシュ取得
    FbxMesh* mesh = scene->GetSrcObject<FbxMesh>();
    if (!mesh)
    {
        SDL_Log("failed fbx scene get mesh.");
        return false;
    }

    // 頂点座標の読込
    std::vector<std::vector<float>> vertexList;
    for (int i = 0; i < mesh->GetControlPointsCount(); i++)
    {
        FbxVector4 point = mesh->GetControlPointAt(i);
        std::vector<float> vertex;
        vertex.push_back(point[0]);
        vertex.push_back(point[1]);
        vertex.push_back(point[2]);
        vertexList.push_back(vertex);
    }

    // インデックス座標の読込
    std::vector<int> vertexIndexList;
    // ポリゴンごとにループ
    int polCount = mesh->GetPolygonCount();
    for (int polIndex = 0; polIndex < polCount; polIndex++)
    {
        // 頂点ごとにループ
        int polVertexCount = mesh->GetPolygonSize(polIndex);
        for (int polVertexIndex = 0; polVertexIndex < polVertexCount; polVertexIndex++)
        {
            // 頂点インデックスの取得
            int vertexIndex = mesh->GetPolygonVertex(polIndex, polVertexIndex);
            std::vector<float> vertex = vertexList[vertexIndex];

・・・略・・・
            // インデックスバッファを追加
            vertexIndexList.push_back(vertexIndex);
        }
    }

            // 法線座標の取得
            FbxVector4 normalVec4;
            mesh->GetPolygonVertexNormal(polIndex, polVertexIndex, normalVec4);

            // UV座標の取得
            FbxVector2 uvVec2;
            bool isUnMapped;
            mesh->GetPolygonVertexUV(polIndex, polVertexIndex, uvSetName, uvVec2, isUnMapped);

bool Mesh::Load(const std::string &filePath, Game* game)
{

・・・略・・・

    // インデックス座標の読込
    std::vector<int> vertexIndexList;
    std::vector<std::vector<int>> newVertexIndexList;
    // ポリゴンごとにループ
    int polCount = mesh->GetPolygonCount();
    for (int polIndex = 0; polIndex < polCount; polIndex++)
    {
        // 頂点ごとにループ
        int polVertexCount = mesh->GetPolygonSize(polIndex);
        for (int polVertexIndex = 0; polVertexIndex < polVertexCount; polVertexIndex++)
        {
            // 頂点インデックスの取得
            int vertexIndex = mesh->GetPolygonVertex(polIndex, polVertexIndex);
            std::vector<float> vertex = vertexList[vertexIndex];

            // 法線座標の取得
            FbxVector4 normalVec4;
            mesh->GetPolygonVertexNormal(polIndex, polVertexIndex, normalVec4);

            // UV座標の取得
            FbxVector2 uvVec2;
            bool isUnMapped;
            mesh->GetPolygonVertexUV(polIndex, polVertexIndex, uvSetName, uvVec2, isUnMapped);

            if (vertex.size() == 3)
            {
                // 法線座標とUV座標が未設定の場合、頂点情報に付与して設定
                std::vector<float> vertexInfo = CreateVertexInfo(vertex, normalVec4, uvVec2);
                vertexList[vertexIndex] = vertexInfo;
            }
            else if (!IsEqualNormalUV(vertex, normalVec4, uvVec2))
            {
                // ＊同一頂点インデックスの中で法線座標かUV座標が異なる場合、
                // 新たな頂点インデックスとして作成する

                // 新たな頂点インデックスとして作成済かどうか？
                bool isNewVertexCreated = false;
                for (int i = 0; i < newVertexIndexList.size(); i++)
                {
                    int oldIndex = newVertexIndexList[i][0];
                    int newIndex = newVertexIndexList[i][1];
                    if (oldIndex == vertexIndex
                        && IsEqualNormalUV(vertexList[newIndex], normalVec4, uvVec2))
                    {
                        isNewVertexCreated = true;
                        vertexIndex = newIndex;
                        break;
                    }
                }
                // 作成済でない場合
                if (!isNewVertexCreated)
                {
                    // 新たな頂点インデックスとして作成
                    std::vector<float> vertexInfo = CreateVertexInfo(vertex, normalVec4, uvVec2);
                    vertexList.push_back(vertexInfo);
                    // 作成したインデックス情報を設定
                    int newIndex = vertexList.size() - 1;
                    std::vector<int> newVertexIndex;
                    newVertexIndex.push_back(vertexIndex); // old index
                    newVertexIndex.push_back(newIndex);    // new index
                    newVertexIndexList.push_back(newVertexIndex);
                    vertexIndex = newIndex;
                }
            }
            // インデックスバッファを追加
            vertexIndexList.push_back(vertexIndex);
        }
    }

・・・略・・・

}

// 頂点情報作成処理
std::vector<float> Mesh::CreateVertexInfo(const std::vector<float>& vertex, const FbxVector4& normalVec4,
                         const FbxVector2& uvVec2)
{
    std::vector<float> vertexInfo;
    // 位置座標
    vertexInfo.push_back(vertex[0]);
    vertexInfo.push_back(vertex[1]);
    vertexInfo.push_back(vertex[2]);
    // 法線座標
    vertexInfo.push_back(normalVec4[0]);
    vertexInfo.push_back(normalVec4[1]);
    vertexInfo.push_back(normalVec4[2]);
    // UV座標
    vertexInfo.push_back(uvVec2[0]);
    vertexInfo.push_back(uvVec2[1]);
    return vertexInfo;
}

// vertexInfoに法線、UV座標が設定済かどうか？
bool Mesh::IsEqualNormalUV(const std::vector<float> vertexInfo,
                           const FbxVector4 &normalVec4, const FbxVector2 &uvVec2)
{
    return fabs(vertexInfo[3] - normalVec4[0]) < FLT_EPSILON
            && fabs(vertexInfo[4] - normalVec4[1]) < FLT_EPSILON
            && fabs(vertexInfo[5] - normalVec4[2]) < FLT_EPSILON
            && fabs(vertexInfo[6] - uvVec2[0]) < FLT_EPSILON
            && fabs(vertexInfo[7] - uvVec2[1]) < FLT_EPSILON;
}

#version 330

uniform mat4 uWorldTransform; // ワールド変換座標
uniform mat4 uViewProjection; // ビュー射影行列

in vec3 inPosition;

void main() {
    // w成分を加える
    vec4 pos = vec4(inPosition, 1.0);
    // ローカル座標 * ワールド変換座標 * ビュー射影行列
    // を逆に計算して、クリップ空間座標に変換
    gl_Position = uViewProjection * uWorldTransform * pos;
}

#version 330

out vec4 outColor;

void main() {
    // 青色を出力
    outColor = vec4(0.0, 0.0, 1.0, 1.0);
}

#version 330

uniform mat4 uWorldTransform; // ワールド変換座標
uniform mat4 uViewProjection; // ビュー射影行列

layout(location = 0) in vec3 inPosition; // 位置座標
layout(location = 1) in vec3 inNormal;   // 法線座標
layout(location = 2) in vec2 inTexCoord; // UV座標

out vec2 fragTexCoord;

void main() {
    // w成分を加える
    vec4 pos = vec4(inPosition, 1.0);
    // ローカル座標 * ワールド変換座標 * ビュー射影行列
    // を逆に計算して、クリップ空間座標に変換
    gl_Position = uViewProjection * uWorldTransform * pos;
    // テクスチャ座標を設定
    fragTexCoord = inTexCoord;
}

#version 330

uniform sampler2D uTexture; // テクスチャ（自動で設定される）

in vec2 fragTexCoord;

out vec4 outColor;

void main() {
    // テクスチャを出力
    outColor = texture(uTexture, fragTexCoord);
}

bool Texture::Load(const std::string &filePath)
{
    // ファイル読込
    mTexture = IMG_Load(filePath.c_str());
    if (!mTexture)
    {
        SDL_Log("Failed load texture.");
        return false;
    }

    // RGBフォーマットの指定
    int rgbFormat = GL_RGB;
    if (mTexture->format->BitsPerPixel >= 4) rgbFormat = GL_RGBA;

    // テクスチャオブジェクトの作成
    glGenTextures(1, &mTextureID);
    glBindTexture(GL_TEXTURE_2D, mTextureID);
    glTexImage2D(GL_TEXTURE_2D, 0, rgbFormat, mTexture->w, mTexture->h, 0, rgbFormat,
                 GL_UNSIGNED_BYTE, mTexture->pixels);

    // バイリニアフィルタを有効にする
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    return true;
}

void Texture::Unload()
{
    glDeleteTextures(1, &mTextureID);
}

void Texture::SetActive()
{
    glBindTexture(GL_TEXTURE_2D, mTextureID);
}

#version 330

uniform mat4 uWorldTransform; // ワールド変換座標
uniform mat4 uViewProjection; // ビュー射影行列

layout(location = 0) in vec3 inPosition; // 位置座標
layout(location = 1) in vec3 inNormal;   // 法線座標
layout(location = 2) in vec2 inTexCoord; // UV座標

// テクスチャ情報
out vec2 fragTexCoord; // 位置座標
out vec3 fragNormal;   // 法線座標
out vec3 fragWorldPos; // ワールド座標

void main() {
    // w成分を加える
    vec4 pos = vec4(inPosition, 1.0);
    // クリップ空間座標に変換して設定
    gl_Position = uViewProjection * uWorldTransform * pos;

    // テクスチャ情報を設定
    fragTexCoord = inTexCoord;
    // ワールド座標に変換する
    fragNormal = (uWorldTransform * vec4(inNormal, 0.0f)).xyz;
}

#version 330

uniform sampler2D uTexture; // テクスチャ（自動で設定される）
uniform vec3 uAmbientColor; // 環境色 ka

// 平行光源
struct DirectionalLight
{
    vec3 mDirection;    // 向き
    vec3 mDiffuseColor; // 拡散反射色 kd
};
uniform DirectionalLight uDirLight;

in vec2 fragTexCoord; // 位置座標
in vec3 fragNormal;   // 法線座標

out vec4 outColor;

void main() {
    // 計算に必要な向きを正規化して求める
    vec3 N = normalize(fragNormal);                // 法線
    vec3 L = normalize(-uDirLight.mDirection);     // 表面→光源

    // 反射色の計算
    // ベースとなる環境色を設定
    vec3 Lambert = uAmbientColor; // ka
    // N・Lが0より大きい場合
    float NdotL = dot(N, L);
    if (NdotL > 0)
    {
        // 拡散反射色を加える
        vec3 Diffuse = uDirLight.mDiffuseColor * NdotL; // kd * N・L
        Lambert += Diffuse;
    }
    // テクスチャ色 * 反射色
    outColor = texture(uTexture, fragTexCoord) * vec4(Lambert, 1.0f);
}

bool Renderer::LoadData()
{

・・・略・・・

    // ライティングパラメータ設定
    mAmbientLight = Vector3(0.35f, 0.35f, 0.35f);
    mDirLightDirection = Vector3(0.3f, 0.3f, 0.8f);
    mDirLightDiffuseColor = Vector3(0.8f, 0.9f, 1.0f);

・・・略・・・

}

// ライティングuniform設定
void Shader::SetLightingUniform(const Renderer* renderer)
{
    switch (mType) {
・・・略・・・
        case ShaderType::LAMBERT:
            SetVectorUniform(UNIFORM_AMBIENT_COLOR, renderer->GetAmbientLight());
            SetVectorUniform(UNIFORM_DIR_LIGHT_DIRECTION, renderer->GetDirLightDirection());
            SetVectorUniform(UNIFORM_DIR_LIGHT_DIFFUSE_COLOR, renderer->GetDirLightDiffuseColor());
            break;
・・・略・・・
    }
}

#version 330

uniform mat4 uWorldTransform; // ワールド変換座標
uniform mat4 uViewProjection; // ビュー射影行列

layout(location = 0) in vec3 inPosition; // 位置座標
layout(location = 1) in vec3 inNormal;   // 法線座標
layout(location = 2) in vec2 inTexCoord; // UV座標

// テクスチャ情報
out vec2 fragTexCoord; // 位置座標
out vec3 fragNormal;   // 法線座標
out vec3 fragWorldPos; // ワールド座標

void main() {
    // w成分を加える
    vec4 pos = vec4(inPosition, 1.0);
    // クリップ空間座標に変換して設定
    gl_Position = uViewProjection * uWorldTransform * pos;

    // テクスチャ情報を設定
    fragTexCoord = inTexCoord;
    // ワールド座標に変換する
    fragNormal = (uWorldTransform * vec4(inNormal, 0.0f)).xyz;
    fragWorldPos = (uWorldTransform * pos).xyz;
}

#version 330

uniform sampler2D uTexture; // テクスチャ（自動で設定される）
uniform vec3 uCameraPos;    // カメラ座標
uniform float uSpecPower;   // 鏡面反射指数 a
uniform vec3 uAmbientColor; // 環境色 ka

// 平行光源
struct DirectionalLight
{
    vec3 mDirection;    // 向き
    vec3 mDiffuseColor; // 拡散反射色 kd
    vec3 mSpecColor;    // 鏡面反射色 ks
};
uniform DirectionalLight uDirLight;

in vec2 fragTexCoord; // 位置座標
in vec3 fragNormal;   // 法線座標
in vec3 fragWorldPos; // ワールド座標

out vec4 outColor;

void main() {
    // 計算に必要な向きを正規化して求める
    vec3 N = normalize(fragNormal);                // 法線
    vec3 L = normalize(-uDirLight.mDirection);     // 表面→光源
    vec3 V = normalize(uCameraPos - fragWorldPos); // 表面→視点
    vec3 R = normalize(reflect(-L, N));            // Nを軸としてLを反射させたもの

    // 反射色の計算
    // ベースとなる環境色を設定
    vec3 Phong = uAmbientColor; // ka
    // N・Lが0より大きい場合
    float NdotL = dot(N, L);
    if (NdotL > 0)
    {
        // 拡散反射色、鏡面反射色を加える
        vec3 Diffuse = uDirLight.mDiffuseColor * NdotL; // kd * N・L
        vec3 Specular = uDirLight.mSpecColor * pow(max(0.0, dot(R, V)), uSpecPower); // ks * (R・V)^a
        Phong += Diffuse + Specular;
    }
    // テクスチャ色 * 反射色
    outColor = texture(uTexture, fragTexCoord) * vec4(Phong, 1.0f);
}

bool Renderer::LoadData()
{

・・・略・・・

    // ライティングパラメータ設定
    mAmbientLight = Vector3(0.35f, 0.35f, 0.35f);
    mDirLightDirection = Vector3(0.3f, 0.3f, 0.8f);
    mDirLightDiffuseColor = Vector3(0.8f, 0.9f, 1.0f);
    mDirLightSpecColor = Vector3(0.8f, 0.8f, 0.8f); // 追加

・・・略・・・

}

// ライティングuniform設定
void Shader::SetLightingUniform(const Renderer* renderer)
{
・・・略・・・
        case ShaderType::PHONG:
            SetVectorUniform(UNIFORM_CAMERA_POS, renderer->GetCamera()->GetPosition());
            SetVectorUniform(UNIFORM_AMBIENT_COLOR, renderer->GetAmbientLight());
            SetVectorUniform(UNIFORM_DIR_LIGHT_DIRECTION, renderer->GetDirLightDirection());
            SetVectorUniform(UNIFORM_DIR_LIGHT_DIFFUSE_COLOR, renderer->GetDirLightDiffuseColor());
            SetVectorUniform(UNIFORM_DIR_LIGHT_SPEC_COLOR, renderer->GetDirLightSpecColor());
            SetFloatUniform(UNIFORM_SPEC_POWER, mSpecPower);
            break;
    }
}