MENU
  1. ホーム
  2. C言語
  3. C言語でOpenGLを使った3Dプログラミング入門：初心者向けガイド

C言語でOpenGLを使った3Dプログラミング入門：初心者向けガイド

C言語

C言語とOpenGLを使用して3Dプログラミングに挑戦しましょう。本記事では、基本概念から具体的なコード例まで、初心者にもわかりやすくステップバイステップで解説します。3Dグラフィックスの世界を理解し、自分のアイデアを実現する第一歩を踏み出しましょう。

目次

3Dプログラミングの基礎知識

3Dプログラミングは、2Dグラフィックスと異なり、立体的なオブジェクトを扱う技術です。ここでは、基本的な3Dグラフィックスの概念とOpenGLの役割について説明します。

3Dグラフィックスの基本概念

3Dグラフィックスでは、オブジェクトは頂点（Vertex）と呼ばれる点の集合で構成されます。これらの頂点は、ポリゴン（通常は三角形）で結ばれ、立体的な形状を形成します。また、各頂点には位置、色、法線ベクトル、テクスチャ座標などの情報が含まれます。

座標系と変換

3D空間では、物体の位置や方向を指定するために座標系が用いられます。一般的には、ワールド座標系、ビュー座標系、スクリーン座標系の3つが使われ、これらの変換を行うためにモデル変換、ビュー変換、プロジェクション変換が用いられます。

OpenGLの役割

OpenGL（Open Graphics Library）は、クロスプラットフォームのグラフィックスAPIであり、2Dおよび3Dグラフィックスを描画するための機能を提供します。OpenGLを使用することで、C言語を用いて高度なグラフィックス処理を実現できます。

OpenGLの基本機能

OpenGLは、頂点の描画、シェーディング、テクスチャマッピング、ライティングなど、3Dグラフィックスの基本機能を提供します。これにより、開発者は低レベルのグラフィックス操作を抽象化し、効率的に描画処理を行うことができます。

このセクションでは、3Dプログラミングの基礎知識とOpenGLの役割を理解するための基本的な概念を紹介しました。次に、開発環境の設定とOpenGLのインストール方法について説明します。

環境設定とOpenGLのインストール

3Dプログラミングを始めるためには、開発環境を適切に設定し、OpenGLライブラリをインストールする必要があります。ここでは、必要なツールのインストール手順と設定方法を説明します。

開発環境の準備

3Dプログラミングに必要な開発環境を整えるために、以下のツールをインストールします。

  • C言語のコンパイラ（例：GCC、Clang）
  • IDE（統合開発環境）またはテキストエディタ（例：Visual Studio Code、CLion）

Windowsの場合

  1. MinGWのインストール：MinGW（Minimalist GNU for Windows）を使用してGCCコンパイラをインストールします。
  2. IDEのインストール：Visual Studio Codeをインストールし、必要なC言語の拡張機能を追加します。

Macの場合

  1. Xcodeのインストール：XcodeをApp Storeからインストールし、Command Line Toolsを有効にします。
  2. Homebrewのインストール：ターミナルを開き、Homebrewをインストールします。
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
  1. ライブラリのインストール：Homebrewを使用して必要なライブラリをインストールします。
brew install gcc

Linuxの場合

  1. GCCのインストール：ターミナルを開き、GCCコンパイラをインストールします。
sudo apt-get update
sudo apt-get install build-essential
  1. IDEのインストール：好みのIDEまたはテキストエディタをインストールします（例：Visual Studio Code、Eclipse）。

OpenGLライブラリのインストール

次に、OpenGLと関連するライブラリをインストールします。

GLFWのインストール

GLFWは、OpenGLコンテキストの管理とマルチプラットフォーム対応のウィンドウライブラリです。

Windowsの場合

  1. GLFWの公式サイトからバイナリをダウンロードします。
  2. ダウンロードしたファイルを適切なディレクトリに解凍し、プロジェクトに追加します。

Macの場合

  1. Homebrewを使用してGLFWをインストールします。
brew install glfw

Linuxの場合

  1. パッケージマネージャを使用してGLFWをインストールします。
sudo apt-get install libglfw3 libglfw3-dev

GLEWのインストール

GLEW（OpenGL Extension Wrangler Library）は、OpenGLの拡張機能を簡単に使用するためのライブラリです。

Windowsの場合

  1. GLEWの公式サイトからバイナリをダウンロードし、適切なディレクトリに解凍してプロジェクトに追加します。

Macの場合

  1. Homebrewを使用してGLEWをインストールします。
brew install glew

Linuxの場合

  1. パッケージマネージャを使用してGLEWをインストールします。
sudo apt-get install libglew2.1 libglew-dev

このセクションでは、開発環境の設定とOpenGLライブラリのインストール手順を説明しました。次は、最初の3Dプログラムの作成方法について解説します。

最初の3Dプログラムの作成

ここでは、基本的な3Dプログラムのコード例を紹介し、その解説を行います。このプログラムでは、簡単な3Dオブジェクト（例えば三角形）を描画します。

基本的な3Dプログラムの構造

以下のコードは、C言語とOpenGLを用いた最初の3Dプログラムの例です。このプログラムはGLFWとGLEWを使用して、ウィンドウを作成し、三角形を描画します。

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdio.h>

void init() {
    // 三角形の頂点データ
    GLfloat vertices[] = {
        0.0f,  0.5f, 0.0f,
       -0.5f, -0.5f, 0.0f,
        0.5f, -0.5f, 0.0f
    };

    // バッファの生成
    GLuint VBO;
    glGenBuffers(1, &VBO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
}

void display() {
    // 画面をクリア
    glClear(GL_COLOR_BUFFER_BIT);

    // 頂点配列を有効化
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);

    // 三角形を描画
    glDrawArrays(GL_TRIANGLES, 0, 3);

    // 頂点配列を無効化
    glDisableVertexAttribArray(0);
}

int main() {
    // GLFWの初期化
    if (!glfwInit()) {
        fprintf(stderr, "Failed to initialize GLFW\n");
        return -1;
    }

    // ウィンドウの作成
    GLFWwindow* window = glfwCreateWindow(640, 480, "Simple 3D Program", NULL, NULL);
    if (!window) {
        fprintf(stderr, "Failed to open GLFW window\n");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);

    // GLEWの初期化
    glewExperimental = GL_TRUE;
    if (glewInit() != GLEW_OK) {
        fprintf(stderr, "Failed to initialize GLEW\n");
        return -1;
    }

    // 初期化関数の呼び出し
    init();

    // メインループ
    while (!glfwWindowShouldClose(window)) {
        // 描画関数の呼び出し
        display();

        // バッファのスワップ
        glfwSwapBuffers(window);

        // イベントのポーリング
        glfwPollEvents();
    }

    // 終了処理
    glfwTerminate();
    return 0;
}

コードの解説

GLFWとGLEWの初期化

プログラムの最初の部分では、GLFWとGLEWの初期化を行います。glfwInit()関数はGLFWの初期化を行い、成功しなければエラーメッセージを表示してプログラムを終了します。ウィンドウの作成にはglfwCreateWindow()関数を使用し、コンテキストを作成します。GLEWの初期化はglewInit()関数を使用します。

三角形の頂点データの定義

init()関数では、三角形の頂点データを定義し、OpenGLのバッファに転送します。glGenBuffers()関数でバッファを生成し、glBindBuffer()関数でバインドします。glBufferData()関数で頂点データをバッファにコピーします。

描画処理

display()関数では、画面をクリアし、頂点配列を有効化して三角形を描画します。glEnableVertexAttribArray()関数とglVertexAttribPointer()関数を使用して、頂点データを設定します。glDrawArrays()関数で三角形を描画し、最後に頂点配列を無効化します。

このセクションでは、基本的な3Dプログラムの作成方法とそのコードの解説を行いました。次は、頂点バッファとシェーダの基本について詳しく説明します。

頂点バッファとシェーダの基本

頂点バッファとシェーダは、3Dプログラミングにおいて非常に重要な役割を果たします。このセクションでは、頂点バッファとシェーダの基礎知識と実装方法について詳しく説明します。

頂点バッファオブジェクト（VBO）

頂点バッファオブジェクト（VBO）は、頂点データをGPUメモリに保存し、効率的に描画するための仕組みです。これにより、CPUとGPU間のデータ転送が最小限に抑えられます。

VBOの生成とバインド

VBOの生成とバインドは以下の手順で行います。

GLuint VBO;
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);

glGenBuffers関数でバッファを生成し、glBindBuffer関数でバインドします。このバッファに頂点データを転送します。

頂点データの転送

頂点データの転送にはglBufferData関数を使用します。

GLfloat vertices[] = {
    0.0f,  0.5f, 0.0f,
   -0.5f, -0.5f, 0.0f,
    0.5f, -0.5f, 0.0f
};
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

ここでは、三角形の頂点データをバッファに転送しています。

シェーダプログラム

シェーダは、頂点データやピクセルデータを処理するためのプログラムです。OpenGLでは、頂点シェーダとフラグメントシェーダの2つが主に使用されます。

頂点シェーダの作成

頂点シェーダは、頂点データを処理し、クリッピング座標系に変換します。以下は、簡単な頂点シェーダの例です。

const char* vertexShaderSource = "#version 330 core\n"
    "layout(location = 0) in vec3 aPos;\n"
    "void main()\n"
    "{\n"
    "   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
    "}\0";

フラグメントシェーダの作成

フラグメントシェーダは、ピクセルごとの色を計算します。以下は、簡単なフラグメントシェーダの例です。

const char* fragmentShaderSource = "#version 330 core\n"
    "out vec4 FragColor;\n"
    "void main()\n"
    "{\n"
    "   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
    "}\n\0";

シェーダプログラムのコンパイルとリンク

シェーダプログラムのコンパイルとリンクは以下の手順で行います。

// 頂点シェーダのコンパイル
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
glCompileShader(vertexShader);

// フラグメントシェーダのコンパイル
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
glCompileShader(fragmentShader);

// シェーダプログラムのリンク
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);

// シェーダの削除
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);

コンパイル後、glCreateProgram関数でシェーダプログラムを作成し、glAttachShader関数でシェーダをアタッチします。glLinkProgram関数でプログラムをリンクし、不要になったシェーダを削除します。

このセクションでは、頂点バッファとシェーダの基礎について説明しました。次は、3D空間でのカメラ操作と視点の設定方法について学びます。

カメラと視点の設定

3Dプログラミングにおいて、カメラと視点の設定は非常に重要です。このセクションでは、3D空間でのカメラ操作と視点の設定方法について詳しく説明します。

カメラの基本概念

3Dシーンを見るための仮想カメラは、現実世界のカメラと同様に、位置、方向、視野角などのパラメータで構成されます。OpenGLでは、カメラの設定を行うためにビュー変換とプロジェクション変換を使用します。

ビュー変換

ビュー変換は、カメラの位置と方向を設定し、ワールド座標系からビュー座標系への変換を行います。これにより、カメラの位置から見たシーンを描画できます。ビュー変換には通常、gluLookAt関数を使用します。

視点の設定

視点を設定するためには、カメラの位置、注視点、上方向を指定します。以下のコード例では、glm::lookAt関数を使用してビュー行列を設定します。

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

// カメラの位置
glm::vec3 cameraPos   = glm::vec3(0.0f, 0.0f, 3.0f);
// 注視点
glm::vec3 cameraTarget = glm::vec3(0.0f, 0.0f, 0.0f);
glm::vec3 cameraDirection = glm::normalize(cameraPos - cameraTarget);
// 上方向
glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f);
glm::vec3 cameraRight = glm::normalize(glm::cross(up, cameraDirection));
glm::vec3 cameraUp = glm::cross(cameraDirection, cameraRight);

// ビュー行列の設定
glm::mat4 view = glm::lookAt(cameraPos, cameraTarget, cameraUp);

プロジェクション変換

プロジェクション変換は、3D座標を2Dスクリーン座標に変換するための行列です。透視投影と平行投影の2種類があります。ここでは、透視投影について説明します。

透視投影

透視投影は、遠近感を表現するために使用されます。glm::perspective関数を使用して透視投影行列を設定します。

float fov = 45.0f; // 視野角
float aspectRatio = 800.0f / 600.0f; // アスペクト比
float nearPlane = 0.1f; // ニアクリップ面
float farPlane = 100.0f; // ファークリップ面

glm::mat4 projection = glm::perspective(glm::radians(fov), aspectRatio, nearPlane, farPlane);

ビューとプロジェクション行列の統合

ビュー行列とプロジェクション行列を組み合わせて使用することで、カメラの設定が完了します。これらの行列をシェーダに渡して使用します。

// シェーダプログラムの使用
glUseProgram(shaderProgram);

// ビュー行列とプロジェクション行列をシェーダに渡す
GLuint viewLoc = glGetUniformLocation(shaderProgram, "view");
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));

GLuint projectionLoc = glGetUniformLocation(shaderProgram, "projection");
glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));

このセクションでは、3D空間でのカメラ操作と視点の設定方法について学びました。次は、モデルの変換とアニメーションの実装方法について説明します。

モデルの変換とアニメーション

3Dプログラミングでは、モデルの変換（移動、回転、拡大縮小）とアニメーションを適用して、動的なシーンを作成することが重要です。このセクションでは、モデル変換の基礎とアニメーションの実装方法について解説します。

モデル変換の基礎

モデル変換は、オブジェクトの位置、方向、サイズを変更するための操作です。これらの変換は、モデル行列を使用して実現されます。モデル行列は、オブジェクト空間からワールド空間への変換を行います。

モデル行列の構築

以下のコード例では、glmライブラリを使用してモデル行列を構築します。

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

glm::mat4 model = glm::mat4(1.0f); // 単位行列で初期化

// 移動
model = glm::translate(model, glm::vec3(1.0f, 0.0f, 0.0f));

// 回転
model = glm::rotate(model, glm::radians(45.0f), glm::vec3(0.0f, 0.0f, 1.0f));

// 拡大縮小
model = glm::scale(model, glm::vec3(0.5f, 0.5f, 0.5f));

シェーダへのモデル行列の送信

作成したモデル行列をシェーダに送信して使用します。

GLuint modelLoc = glGetUniformLocation(shaderProgram, "model");
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));

アニメーションの実装

アニメーションは、時間に応じてモデル行列を変化させることで実現されます。例えば、オブジェクトを回転させるアニメーションを実装する場合、毎フレームごとに回転角度を更新します。

回転アニメーションの例

以下のコード例では、glfwGetTime関数を使用して経過時間を取得し、その時間に基づいてオブジェクトを回転させます。

while (!glfwWindowShouldClose(window)) {
    // 経過時間を取得
    float timeValue = glfwGetTime();
    float angle = timeValue * glm::radians(50.0f); // 1秒間に50度回転

    // モデル行列を更新
    glm::mat4 model = glm::mat4(1.0f);
    model = glm::rotate(model, angle, glm::vec3(0.0f, 0.0f, 1.0f));

    // シェーダに送信
    GLuint modelLoc = glGetUniformLocation(shaderProgram, "model");
    glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));

    // 描画処理
    display();

    // バッファのスワップとイベントのポーリング
    glfwSwapBuffers(window);
    glfwPollEvents();
}

この例では、経過時間に基づいてモデル行列の回転部分を更新し、シェーダに送信することで、オブジェクトが回転するアニメーションを実現しています。

このセクションでは、モデルの変換とアニメーションの基礎について説明しました。次は、光と影の基本について学びます。

光と影の基本

光と影は3Dグラフィックスにおいて、オブジェクトのリアリティを高めるために重要な要素です。このセクションでは、基本的なライティングとシャドウの概念とその実装方法について説明します。

ライティングの基本

ライティングは、光源からの光がオブジェクトに当たって反射する様子をシミュレートします。OpenGLでは、シェーディングモデルを使用してライティングを実装します。代表的なシェーディングモデルには、フラットシェーディング、グーローシェーディング、フォンシェーディングがあります。

フラットシェーディング

フラットシェーディングは、各ポリゴンの色を一様にする簡単なシェーディングモデルです。光の当たり方を計算するポイントは、ポリゴンの中心や頂点の一つです。

グーローシェーディング

グーローシェーディングは、頂点ごとに色を計算し、ポリゴン内を線形補間します。これにより、より滑らかな見た目になります。

フォンシェーディング

フォンシェーディングは、各ピクセルごとに法線を補間し、光の反射を計算することで、非常に滑らかな表面を表現します。

基本的なライティングの実装

以下のコードは、簡単なディレクショナルライト（平行光源）の例です。

頂点シェーダ

const char* vertexShaderSource = "#version 330 core\n"
    "layout(location = 0) in vec3 aPos;\n"
    "layout(location = 1) in vec3 aNormal;\n"
    "out vec3 FragPos;\n"
    "out vec3 Normal;\n"
    "uniform mat4 model;\n"
    "uniform mat4 view;\n"
    "uniform mat4 projection;\n"
    "void main()\n"
    "{\n"
    "   FragPos = vec3(model * vec4(aPos, 1.0));\n"
    "   Normal = mat3(transpose(inverse(model))) * aNormal;\n"
    "   gl_Position = projection * view * vec4(FragPos, 1.0);\n"
    "}\0";

フラグメントシェーダ

const char* fragmentShaderSource = "#version 330 core\n"
    "in vec3 FragPos;\n"
    "in vec3 Normal;\n"
    "out vec4 FragColor;\n"
    "uniform vec3 lightDir;\n"
    "uniform vec3 lightColor;\n"
    "uniform vec3 objectColor;\n"
    "void main()\n"
    "{\n"
    "   float ambientStrength = 0.1;\n"
    "   vec3 ambient = ambientStrength * lightColor;\n"
    "   vec3 norm = normalize(Normal);\n"
    "   float diff = max(dot(norm, normalize(-lightDir)), 0.0);\n"
    "   vec3 diffuse = diff * lightColor;\n"
    "   vec3 result = (ambient + diffuse) * objectColor;\n"
    "   FragColor = vec4(result, 1.0);\n"
    "}\n\0";

シェーダプログラムの設定

以下のコードで、シェーダプログラムに光源とオブジェクトの色を設定します。

GLuint lightDirLoc = glGetUniformLocation(shaderProgram, "lightDir");
glUniform3f(lightDirLoc, -0.2f, -1.0f, -0.3f);

GLuint lightColorLoc = glGetUniformLocation(shaderProgram, "lightColor");
glUniform3f(lightColorLoc, 1.0f, 1.0f, 1.0f);

GLuint objectColorLoc = glGetUniformLocation(shaderProgram, "objectColor");
glUniform3f(objectColorLoc, 1.0f, 0.5f, 0.31f);

シャドウの実装

シャドウは、光が遮られることで生じる影の部分です。シャドウの実装には、シャドウマッピング技法を使用します。

シャドウマッピングの基本

シャドウマッピングは、光源からの視点でシーンを描画し、深度マップ（シャドウマップ）を生成します。次に、カメラからの視点でシーンを描画する際に、この深度マップを使用してシャドウを計算します。

シャドウマッピングの実装

シャドウマッピングの基本的な手順は以下の通りです。

  1. 光源からの視点でシーンを描画し、深度マップを生成する。
  2. 深度マップをテクスチャとして使用し、カメラからの視点でシーンを描画する。
  3. 各ピクセルについて、深度マップを参照してシャドウを計算する。

このセクションでは、光と影の基本概念とその実装方法について説明しました。次は、これまでの内容を応用して簡単な3Dゲームの作成手順を紹介します。

応用例：簡単な3Dゲームの作成

ここでは、これまで学んだ内容を応用して、簡単な3Dゲームを作成する手順を紹介します。このセクションでは、3Dオブジェクトの操作、カメラの制御、基本的なゲームロジックの実装を行います。

ゲームの概要

このゲームでは、プレイヤーが操作するキャラクターを3D空間内で移動させ、簡単な障害物を避けながらゴールを目指します。

ステップ1: 基本的なセットアップ

まず、前のセクションで説明した開発環境とOpenGLのセットアップを行います。必要なライブラリ（GLFW、GLEW、GLM）をインストールし、基本的なウィンドウとOpenGLコンテキストを作成します。

ステップ2: 3Dモデルの読み込みと描画

次に、3Dモデルを読み込み、シーンに描画します。ここでは、簡単な立方体をプレイヤーキャラクターとして使用します。

// 立方体の頂点データ
GLfloat vertices[] = {
    // 座標          // 法線
    -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
     0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
     0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
     0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
    -0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
    -0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,

    // その他の面も同様に定義
};

// VBOとVAOの設定
GLuint VBO, VAO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);

glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

// 頂点属性の設定
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
glEnableVertexAttribArray(1);

ステップ3: カメラの制御

プレイヤーキャラクターを3D空間内で移動させるために、カメラを制御します。glm::lookAt関数を使用してカメラのビュー行列を設定します。

glm::mat4 view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);

プレイヤーの入力に応じてカメラの位置を更新します。

void processInput(GLFWwindow *window) {
    float cameraSpeed = 2.5f * deltaTime;
    if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
        cameraPos += cameraSpeed * cameraFront;
    if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
        cameraPos -= cameraSpeed * cameraFront;
    if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
        cameraPos -= glm::normalize(glm::cross(cameraFront, cameraUp)) * cameraSpeed;
    if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
        cameraPos += glm::normalize(glm::cross(cameraFront, cameraUp)) * cameraSpeed;
}

ステップ4: ゲームロジックの実装

基本的なゲームループを設定し、ゲームのロジックを実装します。プレイヤーの位置を更新し、障害物との衝突を検出します。

while (!glfwWindowShouldClose(window)) {
    float currentFrame = glfwGetTime();
    deltaTime = currentFrame - lastFrame;
    lastFrame = currentFrame;

    processInput(window);

    // 描画処理
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // シェーダプログラムの使用
    glUseProgram(shaderProgram);

    // ビュー行列とプロジェクション行列を設定
    glm::mat4 view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
    glm::mat4 projection = glm::perspective(glm::radians(fov), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
    glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
    glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));

    // モデルの描画
    glm::mat4 model = glm::mat4(1.0f);
    glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
    glBindVertexArray(VAO);
    glDrawArrays(GL_TRIANGLES, 0, 36);

    // バッファのスワップとイベントのポーリング
    glfwSwapBuffers(window);
    glfwPollEvents();
}

このコードでは、プレイヤーの入力を処理し、カメラの位置を更新してシーンを描画します。各フレームでプレイヤーの位置と視点を更新し、ゲームの進行を制御します。

このセクションでは、簡単な3Dゲームの作成手順を紹介しました。次は、理解を深めるための演習問題とその解説を提供します。

演習問題と解説

このセクションでは、理解を深めるための演習問題とその解説を提供します。これらの演習を通じて、3Dプログラミングの知識を実践的に身につけましょう。

演習問題1: 追加の3Dオブジェクトを描画する

課題: 既存の立方体に加えて、別の3Dオブジェクト（例えば、ピラミッド）をシーンに追加して描画してください。

ヒント: 立方体と同様に頂点データを定義し、VBOとVAOを使用して描画します。

解説

  1. ピラミッドの頂点データを定義します。
  2. 新しいVBOとVAOを生成し、頂点データをバッファに転送します。
  3. 描画ループ内で、立方体とピラミッドの両方を描画します。
// ピラミッドの頂点データ
GLfloat pyramidVertices[] = {
    // 底面
    -0.5f, 0.0f, -0.5f,  0.0f, -1.0f, 0.0f,
     0.5f, 0.0f, -0.5f,  0.0f, -1.0f, 0.0f,
     0.5f, 0.0f,  0.5f,  0.0f, -1.0f, 0.0f,
    -0.5f, 0.0f,  0.5f,  0.0f, -1.0f, 0.0f,
    // 頂点
     0.0f, 1.0f,  0.0f,  0.0f,  1.0f, 0.0f
};

// ピラミッドのVBOとVAOの設定
GLuint pyramidVBO, pyramidVAO;
glGenVertexArrays(1, &pyramidVAO);
glGenBuffers(1, &pyramidVBO);

glBindVertexArray(pyramidVAO);
glBindBuffer(GL_ARRAY_BUFFER, pyramidVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(pyramidVertices), pyramidVertices, GL_STATIC_DRAW);

// 頂点属性の設定
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
glEnableVertexAttribArray(1);

// 描画ループ内でピラミッドを描画
while (!glfwWindowShouldClose(window)) {
    // 描画処理
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // シェーダプログラムの使用
    glUseProgram(shaderProgram);

    // ビュー行列とプロジェクション行列を設定
    glm::mat4 view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
    glm::mat4 projection = glm::perspective(glm::radians(fov), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
    glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
    glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));

    // 立方体の描画
    glm::mat4 model = glm::mat4(1.0f);
    glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
    glBindVertexArray(VAO);
    glDrawArrays(GL_TRIANGLES, 0, 36);

    // ピラミッドの描画
    model = glm::translate(model, glm::vec3(2.0f, 0.0f, 0.0f));
    glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
    glBindVertexArray(pyramidVAO);
    glDrawArrays(GL_TRIANGLES, 0, 18);

    // バッファのスワップとイベントのポーリング
    glfwSwapBuffers(window);
    glfwPollEvents();
}

演習問題2: 簡単な衝突判定を実装する

課題: プレイヤーキャラクターが障害物に衝突したかどうかを判定し、衝突した場合はゲームオーバーのメッセージを表示するようにしてください。

ヒント: オブジェクトの位置とサイズを比較して、衝突を検出します。

解説

  1. プレイヤーと障害物の位置を管理します。
  2. 簡単なAABB（軸に平行な境界ボックス）衝突判定を実装します。
  3. 衝突が検出された場合にゲームオーバーのメッセージを表示します。
// プレイヤーと障害物の位置
glm::vec3 playerPos = glm::vec3(0.0f, 0.0f, 0.0f);
glm::vec3 obstaclePos = glm::vec3(2.0f, 0.0f, 0.0f);
float playerSize = 1.0f;
float obstacleSize = 1.0f;

// 衝突判定関数
bool checkCollision(glm::vec3 pos1, float size1, glm::vec3 pos2, float size2) {
    return (abs(pos1.x - pos2.x) * 2 < (size1 + size2)) &&
           (abs(pos1.y - pos2.y) * 2 < (size1 + size2)) &&
           (abs(pos1.z - pos2.z) * 2 < (size1 + size2));
}

// 描画ループ内で衝突判定
while (!glfwWindowShouldClose(window)) {
    // プレイヤーの入力処理
    processInput(window);

    // 衝突判定
    if (checkCollision(playerPos, playerSize, obstaclePos, obstacleSize)) {
        std::cout << "Game Over!" << std::endl;
        glfwSetWindowShouldClose(window, true);
    }

    // 描画処理
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // シェーダプログラムの使用
    glUseProgram(shaderProgram);

    // ビュー行列とプロジェクション行列を設定
    glm::mat4 view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
    glm::mat4 projection = glm::perspective(glm::radians(fov), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);
    glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
    glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));

    // プレイヤーの描画
    glm::mat4 model = glm::translate(glm::mat4(1.0f), playerPos);
    glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
    glBindVertexArray(VAO);
    glDrawArrays(GL_TRIANGLES, 0, 36);

    // 障害物の描画
    model = glm::translate(glm::mat4(1.0f), obstaclePos);
    glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
    glBindVertexArray(pyramidVAO);
    glDrawArrays(GL_TRIANGLES, 0, 18);

    // バッファのスワップとイベントのポーリング
    glfwSwapBuffers(window);
    glfwPollEvents();
}

演習問題3: ライティングの改善

課題: シーンにスポットライトを追加し、プレイヤーキャラクターに追従するように実装してください。

ヒント: スポットライトの位置と方向をプレイヤーキャラクターの位置と連動させます。

解説

  1. スポットライトのシェーダコードを追加します。
  2. プレイヤーの位置に基づいてスポットライトの位置と方向を更新します。

“`c
// フラグメントシェーダにスポットライトのコードを追加
const char* fragmentShaderSource = “#version 330 core\n”
“in vec3 FragPos;\n”
“in vec3 Normal;\n”
“out vec4 FragColor;\n”
“uniform vec3 lightPos;\n”
“uniform vec3 lightDir;\n”
“uniform float cutOff;\n”
“uniform vec3 lightColor;\n”

まとめ

本記事では、C言語とOpenGLを使用した3Dプログラミングの基礎から応用までをステップバイステップで解説しました。3Dグラフィックスの基本概念、環境設定、最初の3Dプログラムの作成、頂点バッファとシェーダ、カメラ操作、モデル変換とアニメーション、光と影の実装、そして簡単な3Dゲームの作成までの手順を学びました。

これらの知識を活用して、自分自身の3Dプロジェクトに挑戦してみてください。継続的に学習し、練習を積み重ねることで、さらに高度な3Dグラフィックスの技術を習得できます。次のステップとして、複雑なシェーダの作成や物理エンジンの導入、リアルタイムレンダリング技術の習得を目指しましょう。

3Dプログラミングの世界は広大で奥深いものですが、一歩一歩確実に進めることで、驚くべき成果を得ることができます。今後のプロジェクトでの成功を祈っています。

C言語
C言語 OpenGL グラフィックス 3Dプログラミング コンピュータサイエンス

コメント

コメントする

目次