4. 三角形へのレンダリングとライティング パート1

此れまでは、シェーダーを画面全体にレンダリングしていました。
此の章では先ず、シェーダーを1つの三角形に描き、次に1つのウィンドウに2つの三角形を、別々のシェーダーで描きます。
其の後、ライティング(光の当たり方の計算)の世界に入ります。
一般的な6種類のライトを紹介し、最初の2つ、アンビエントライトとディレクショナルライトを実装します。

ディレクショナルライトは、線型代数シリーズの第4章の内積がそのまま光の明るさになる、とても分かり易い例です。
3Dゲームで見た事のある「光が当たっている面は明るく、反対側は暗い」と言う見た目は、殆ど全て此の章の式から始まっています。

4.1 三角形へのレンダリング

現在、シェーダーを画面全体にレンダリングしています。
此れは見た目は良いですが、画面上に他に何をレンダリング出来るかという点で非常に制限があります。
先ず其の問題を解決し、シェーダーを三角形にレンダリングしてみましょう。

main.cの頂点データを次の様に変え、描画するインデックスの数を6から3にします:

  // 頂点データ(三角形)を設定
  float vertices[] = {
    -0.5f, -0.5f, 0.0f, 0.0f, // 左下(位置、UV)
     0.5f, -0.5f, 1.0f, 0.0f, // 右下
     0.0f,  0.5f, 0.5f, 1.0f  // 上
  };
  GLuint indices[] = { 0, 1, 2 };
  ...
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0);

glDrawElementsの2番目の引数は「インデックスを何個使うか」です。
GL_TRIANGLESでは3個のインデックスで1つの三角形になるので、四角形の時は6個(2つの三角形)、今回は3個(1つの三角形)です。
glBufferDataはsizeof(vertices)とsizeof(indices)を使っているので、配列を小さくしてもバッファの大きさは自動的に合います。

位置は第3章で説明した正規化デバイス座標(NDC)で、画面の左下が(−1,−1)、右上が(1,1)です。
従って、(−0.5,−0.5)から(0.5,−0.5)の底辺は画面の幅の半分になります。
上の頂点のUVは(0.5,1)なので、三角形の頂点の方はグラデーションの上の辺の中央の色(赤と緑の中間に青を混ぜた色)になります。

結果:

黒い背景の真ん中に、グラデーションで塗られた三角形

三角形の外のピクセルではフラグメントシェーダーは実行されず、glClearColorで指定した黒が残ります。
此れがラスタライザーの「三角形が覆うピクセルだけを探す」と言う仕事の結果です。

試したら、main.cは元に戻しておいて下さい。
此の章の残りではmain.cは其のままにして、新しいファイルで作業します(第5章でmain.cを変更する為です)。

4.2 ライティングの説明

次に、ライティングについて説明します。
重要でない様に思えるかもしれませんが、複雑なモデルを使用する場合、ライティングは非常に重要な概念です。
同じ色の立方体でも、面毎に明るさが違わなければ、画面上ではただの平たい六角形にしか見えません。
一般的な光の種類は6つあり、此の章では其の内の最初の2つを、簡単な物から難しい物の順に説明します。
残りは第9章と第10章で実装します。

此のシリーズでは、ライトの計算に次の記号を使います:

  • 𝐤d:表面の色(マテリアルカラー、拡散反射色)。RGBの3つの値です。
  • 𝐧^:表面の法線。表面から外に向かう、長さ1のベクトルです(線型代数シリーズの第3章の単位ベクトル)。
  • 𝐥^:表面から光源へ向かう、長さ1のベクトル。
  • I:光の強さ(明るさ)。

アンビエントライト

アンビエントライトは理解と実装が最も簡単です。
方向性を持たない均一な光で、方向や距離等の複雑な計算は必要ありません。
簡単に言えば、「アンビエントライト」は「背景光」とも呼ばれます。
現実では、光は壁や床で何度も跳ね返り、直接照らされていない場所も少しは明るくなります。
其れを正確に計算するのは大変なので、「全ての場所に同じだけ光が来る」と近似した物がアンビエントライトです。

𝐜ambient=Ia𝐤d

ディレクショナルライト

ディレクショナルライトは、光の方向と表面の法線という、3Dライティングの基本的な概念を導入します。
此れも比較的簡単です。
太陽光に例える事が出来ます。
太陽はとても遠いので、地上のどの場所でも光は同じ方向から来て、距離による減衰もありません。
明るさは、法線と光源への向きの間の角度θのコサインで決まります(ランバートの余弦則):

𝐜diffuse=I𝐤dmax(𝐧^⋅𝐥^,0)

ポイントライト

ポイントライトは、ディレクショナルライトに位置と減衰を追加し、距離による光の減衰の概念を導入します。
電球に例える事が出来ます。

光の方向は、フラグメント毎に光源の位置𝐩lightとフラグメントの位置𝐩から計算します:

𝐥^=𝐩light−𝐩‖𝐩light−𝐩‖,d=‖𝐩light−𝐩‖

減衰を適用するには、ディレクショナルライトの結果に次の係数を掛けます。
kcは定数項、klは1次(線型)項、kqは2次項です:

attenuation=1kc+kld+kqd2

現実の光は距離の2乗に反比例して弱くなるので(kqの項)、2倍離れると明るさは4分の1になります。

スポットライト

スポットライトは、ポイントライトに方向性と円錐角度を追加した物です。
懐中電灯に例える事が出来ます。
スポットライトの向き𝐬^と「光源からフラグメントへの向き」−𝐥^の内積が、円錐の内側の角度θiと外側の角度θoのコサインの間で滑らかに変わる様にします:

spot=smoothstep(cosθo,cosθi,𝐬^⋅(−𝐥^))

ヘミスフィアライト

ヘミスフィアライトは、アンビエントライトの特殊な形態で、方向性(空と地面)の変化を追加します。
エリアライトよりは複雑ではありませんが、環境に基づくライティングの概念を導入します。
屋外のライティングをシミュレートする為に使用出来ます。
上を向いた面には空の色、下を向いた面には地面の色を、法線のy成分でmixします:

𝐜=𝐤dmix(𝐜ground,𝐜sky,0.5+0.5𝐧^⋅(0,1,0))

エリアライト

エリアライトは最も複雑で、表面全体の積分や近似(複数のポイントライト等)が必要です。
エリアライトは、窓やパネルの様な現実世界の表面をシミュレートします。
大きな光源は柔らかい影と広いハイライトを作ります。

ライト 方向 位置と減衰 例 実装する章
アンビエント 無し 無し 部屋の間接光 第4章
ディレクショナル 一定 無し 太陽 第4章
ポイント フラグメント毎 有り 電球 第9章
スポット フラグメント毎+円錐 有り 懐中電灯 第10章
ヘミスフィア 法線で空と地面を混ぜる 無し 屋外の空 第10章
エリア 面全体 有り 窓、パネル 第10章

光の向きの決まり

ライトの「向き」には2つの流儀があり、此れを混ぜると照らされる面と暗い面が逆になります。

  • 光が進む向き𝐝:光源から表面に向かう向き。太陽が右上に有れば、𝐝は左下を向きます。人間には此方が自然なので、エンジンやエディターのライトの設定は大抵此方です。
  • 光源への向き𝐥^:表面から光源に向かう向き。ランバートの式で使うのは此方です。

2つは丁度反対なので、𝐥^=−𝐝^です。

表面、法線n、光が進む向きd、光源への向きl = −d、nとlの間の角度θ

何故𝐥^の方を使うのでしょうか?
光が正面から当たる時、法線は光源の方を向いています。
内積は同じ方向を向いた単位ベクトル同士で1、直角で0、反対向きで−1になるので(線型代数シリーズの第4章)、𝐧^⋅𝐥^は「正面から当たる時に1」になります。
一方、𝐧^⋅𝐝^は正面から当たる時に−1になってしまいます。

此の章のCコードでは、ライトを「光が進む向き」lightDirectionで渡し、シェーダーの中でマイナスを付けて𝐥^にします。

4.3 新しいファイルの準備

アンビエントライトとディレクショナルライトは、其々別のCファイルにします:

  • main-ambient.c:左にグラデーションの三角形、右にアンビエントライトの三角形。
  • main-directional.c:左にグラデーションの三角形、右にディレクショナルライトの三角形。

どちらもmain.cをコピーして始め、以下の節で変更を加えます。
シェーダーはshaderフォルダに追加し、macOS用に1行目を#version 410 coreにした.mac.glsl版も作ります。

ビルドするファイルの切り替え方は次の通りです。

  • Unix:build-unix.shは、ビルドするファイルを引数で受け取れる様にしました。./build-unix.sh main-ambient.c又は./build-unix.sh main-directional.cで、其のファイルからglsltesterを作って起動します。引数を省略すると今まで通りmain.cです。
  • Windows:ソリューションエクスプローラーで「ソースファイル」を右クリックし、「追加」→「既存の項目」でmain-ambient.cを追加します。次にmain.cを右クリックし、「プロパティ」→「全般」→「ビルドから除外」を「はい」にします。1つのプロジェクトにmain関数が2つ有るとリンクエラーになるので、使うファイル以外は必ず除外して下さい。
  • macOS:main-ambient.cをXcodeのプロジェクトにドラッグし、ファイルインスペクターの「Target Membership」でglsltesterにチェックを入れ、main.cのチェックを外します。新しい.mac.glslファイルもプロジェクトに追加し、ターゲットの「Build Phases」→「Copy Files」(既にvertex.mac.glslとfragment.mac.glslが入っている物)に加えて下さい。此れを忘れると「リソースファイルが見つかりませんでした」と表示されます。

4.4 アンビエントライト

シェーダーディレクトリに新しいファイルfrag_ambient.glslを作成します。

#version 450 core

in vec2 vUv;
out vec4 out_color;

uniform vec3 materialColor;
uniform float ambientIntensity;

void main() {
  vec3 ambient = materialColor * ambientIntensity;
  out_color = vec4(ambient, 1.0);
}

materialColor * ambientIntensityはvec3とfloatの掛け算なので、R、G、Bの全てに同じ数が掛かります。
in vec2 vUv;は此のシェーダーでは使いませんが、頂点シェーダー(vertex.glsl)のout vec2 vUv;と対になる様に宣言しておきます。

元の版では此の行がin vec2 uVu;と打ち間違えられていました。使われていないin変数は、対応するoutが無くてもリンクエラーにならない事が多いので、間違いに気づきにくいのです。然し、後でuVuを使おうとすると「頂点シェーダーが書いていない」と言うリンクエラー(又は値が未定義)になります。inとoutは名前と型を必ず揃えましょう。

簡単そうですね?
Cコードではもっと多くの作業が必要です。
main-ambient.cでは、先ずシェーダーを1つ多く読み込んでコンパイルします:

  // シェーダーファイルを読み込む
#ifdef __APPLE__
  char *vertexShaderSource = readShaderFile("shader/vertex.mac.glsl");
  char *fragmentShaderSource = readShaderFile("shader/fragment.mac.glsl");
  char *fragmentAmbientSource = readShaderFile("shader/frag_ambient.mac.glsl");
#else
  char *vertexShaderSource = readShaderFile("shader/vertex.glsl");
  char *fragmentShaderSource = readShaderFile("shader/fragment.glsl");
  char *fragmentAmbientSource = readShaderFile("shader/frag_ambient.glsl");
#endif
  if (!vertexShaderSource || !fragmentShaderSource || !fragmentAmbientSource) {
    puts("シェーダーファイルの読み込みに失敗しました");
    if (vertexShaderSource) free(vertexShaderSource);
    if (fragmentShaderSource) free(fragmentShaderSource);
    if (fragmentAmbientSource) free(fragmentAmbientSource);
    glfwDestroyWindow(window);
    glfwTerminate();
    return -1;
  }

  // シェーダーをコンパイル
  GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
  glShaderSource(vertexShader, 1, (const char **)&vertexShaderSource, NULL);
  glCompileShader(vertexShader);
  checkShaderCompile(vertexShader);

  GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
  glShaderSource(fragmentShader, 1, (const char **)&fragmentShaderSource, NULL);
  glCompileShader(fragmentShader);
  checkShaderCompile(fragmentShader);

  GLuint fragmentAmbientShader = glCreateShader(GL_FRAGMENT_SHADER);
  glShaderSource(fragmentAmbientShader, 1, (const char **)&fragmentAmbientSource, NULL);
  glCompileShader(fragmentAmbientShader);
  checkShaderCompile(fragmentAmbientShader);

次に、プログラムを2つリンクします。
同じ頂点シェーダーオブジェクトを2つのプログラムにアタッチ出来るので、vertexShaderは2回使います:

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

  // アンビエントシェーダープログラムをリンク(頂点シェーダーは同じ物を使う)
  GLuint ambientShaderProgram = glCreateProgram();
  glAttachShader(ambientShaderProgram, vertexShader);
  glAttachShader(ambientShaderProgram, fragmentAmbientShader);
  glLinkProgram(ambientShaderProgram);
  checkProgramLink(ambientShaderProgram);

  glDeleteShader(vertexShader);
  glDeleteShader(fragmentShader);
  glDeleteShader(fragmentAmbientShader);
  free(vertexShaderSource);
  free(fragmentShaderSource);
  free(fragmentAmbientSource);

リンクが終われば、シェーダーオブジェクトは削除して構いません。
プログラムがコンパイル結果を持っているからです(glDeleteShaderは「もう要らない」と言う印を付けるだけで、プログラムにアタッチされている間は実際には消えません)。

頂点データは三角形を2つ、左右に並べます:

  // 頂点データ(三角形)を設定:グラデーション用(左にオフセット)
  float vertices[] = {
    -0.8f,  -0.5f, 0.0f, 0.0f, // 左下(位置、UV)
    -0.3f,  -0.5f, 1.0f, 0.0f, // 右下
    -0.55f,  0.5f, 0.5f, 1.0f  // 上
  };
  GLuint indices[] = { 0, 1, 2 };

  // 頂点データ(三角形)を設定:アンビエント用(右にオフセット)
  float verticesAmbient[] = {
    0.3f,  -0.5f, 0.0f, 0.0f, // 左下(位置、UV)
    0.8f,  -0.5f, 1.0f, 0.0f, // 右下
    0.55f,  0.5f, 0.5f, 1.0f  // 上
  };

NDCの中の2つの三角形と其の頂点の座標

インデックス{ 0, 1, 2 }は両方の三角形で同じなので、配列は1つで済みます。

三角形毎にVAO(頂点配列オブジェクト)、VBO(頂点バッファ)、EBO(インデックスバッファ)を作ります:

  // VAO、VBO、EBOをアンビエント用に設定
  GLuint VAOAmbient, VBOAmbient, EBOAmbient;
  glGenVertexArrays(1, &VAOAmbient);
  glGenBuffers(1, &VBOAmbient);
  glGenBuffers(1, &EBOAmbient);

  glBindVertexArray(VAOAmbient);
  glBindBuffer(GL_ARRAY_BUFFER, VBOAmbient);
  glBufferData(GL_ARRAY_BUFFER, sizeof(verticesAmbient), verticesAmbient, GL_STATIC_DRAW);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBOAmbient);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

  // 頂点属性はVAO毎に保存されるので、此方でも設定する
  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void *)0);
  glEnableVertexAttribArray(0);
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void *)offset);
  glEnableVertexAttribArray(1);

VAOは「どのバッファの何処に、どの属性が有るか」を覚えておく入れ物です。
glVertexAttribPointerは、其の時バインドされているVAOに、其の時バインドされているGL_ARRAY_BUFFERを記録します。
其の為、新しいVAOをバインドしたら、属性を設定し直さなければなりません。
元のDIFFファイルでは2つ目のVAOの属性設定が抜けていました。其のままだと右の三角形は描かれません(属性0が無効なので、全ての頂点が同じ位置になり、面積0の三角形になります)。
EBOもVAOに記録されるので、描画時はglBindVertexArrayだけでバッファが全て切り替わります。

メインループでは、三角形毎にプログラムを切り替えて描画します:

    // 左の三角形を描画(グラデーションシェーダー)
    glBindVertexArray(VAO);
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0);

    // アンビエントシェーダープログラムを使用(右の三角形)
    glUseProgram(ambientShaderProgram);

    // ユニフォームを設定(アンビエントシェーダー)
    Vector3 materialColor = { 0.8f, 0.2f, 0.3f }; // 赤みがかった色
    float ambientIntensity = 0.6f; // アンビエント光の強さ(0.0~1.0)

    glUniform3f(glGetUniformLocation(ambientShaderProgram, "materialColor"),
                materialColor.r, materialColor.g, materialColor.b);
    glUniform1f(glGetUniformLocation(ambientShaderProgram, "ambientIntensity"), ambientIntensity);

    // 右の三角形を描画(アンビエントシェーダー)
    glBindVertexArray(VAOAmbient);
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0);

ユニフォームはプログラム毎に別々の値を持つので、materialColorはambientShaderProgramを使っている間に、ambientShaderProgramのロケーションに設定します。
最後に、クリーンアップに新しいVAO、VBO、EBO、プログラムの削除を追加します:

  glDeleteVertexArrays(1, &VAOAmbient);
  glDeleteBuffers(1, &VBOAmbient);
  glDeleteBuffers(1, &EBOAmbient);
  glDeleteProgram(ambientShaderProgram);

結果は次の様になります:

左にグラデーションの三角形、右に暗い赤一色の三角形

計算してみましょう:

0.6×(0.8,0.2,0.3)=(0.48,0.12,0.18)

8ビットにすると(0.48×255,0.12×255,0.18×255)≈(122,31,46)で、スクリーンショットの右の三角形のピクセルと同じです。
アンビエントライトだけでは三角形の全てのピクセルが同じ色になり、形の凹凸は全く分かりません。
次の節で、此れを変えていきます。

4.5 ディレクショナルライト

アンビエントライトは、表面がどちらを向いているかに関係無く同じ明るさでした。
ディレクショナルライトでは、各頂点に法線を持たせ、其の向きによって明るさを変えます。
此の三角形は平らですが、頂点毎に違う法線を与えると、丸みのある表面の一部の様に陰影が付きます。

座標の向きは線型代数シリーズと同じ右手系で、xが右、yが上、zが画面から手前(見ている人の方)です。
従って、z成分が正の法線は手前を向いています。

頂点シェーダー

新しいファイルvertex_directional.glslを作成し、以下を挿入します:

#version 450 core

layout(location = 0) in vec2 aPosition;
layout(location = 1) in vec2 aUv;
layout(location = 2) in vec3 aNormal;

out vec2 vUv;
out vec3 vNormal;

void main() {
  vUv = aUv;
  vNormal = aNormal;
  gl_Position = vec4(aPosition, 0.0, 1.0);
}

layout(location = 2) in vec3 aNormal; は、頂点の法線の為の3Dベクトル入力を定義し、属性2に割り当てます。
法線は頂点が「向いている」方向を示し、光が各頂点にどの様に当たるかを決定します。
vNormal = aNormal; で此の値を変更せずにフラグメントシェーダーに渡します。
vUvと同じ様に、vNormalもラスタライザーで補間されます。

フラグメントシェーダー

新しいファイルfrag_directional.glslを作成し、以下を挿入します:

#version 450 core

in vec2 vUv;
in vec3 vNormal;
out vec4 out_color;

uniform vec3 materialColor;
uniform vec3 lightDirection; // 光が進む向き(光源から表面へ)
uniform float lightIntensity;

void main() {
  // 補間された法線は短くなるので、正規化し直す
  vec3 normal = normalize(vNormal);
  // 表面から光源への向き(光が進む向きの逆)
  vec3 toLight = -normalize(lightDirection);

  float diffuseFactor = max(dot(normal, toLight), 0.0);
  vec3 diffuse = materialColor * diffuseFactor * lightIntensity;
  out_color = vec4(diffuse, 1.0);
}

1行ずつ見ていきましょう。

  • in vec3 vNormal;は、頂点シェーダーから受け取った(補間された)法線ベクトルです。
  • uniform vec3 materialColor;は、三角形の基本色(RGB)を保持します。此れはuniformであり、Cプログラムから設定され、全てのピクセルで同じままです。
  • uniform vec3 lightDirection;は、光が進む方向(XYZ)を保持します。太陽の様に、全てのピクセルで同じ方向です。
  • uniform float lightIntensity;は、光の明るさを保持し、0.0が最も暗く(光無し)、1.0が最も明るいです。
  • vec3 normal = normalize(vNormal);は、補間された法線(vNormal)を取り、長さを1にスケールします(normalize)。此れについては4.6節で詳しく説明します。
  • -normalize(lightDirection)は、光の方向を長さ1にし、マイナスで反転させて「表面から光源への向き」𝐥^にします。
  • dot(normal, toLight)は、法線と光源への向きの間の角度のコサインcosθを計算します。
  • max(..., 0.0)は、結果が負にならない様にします。負の値は光が表面の裏から来ている事を意味するので、0(光が当たらない)にします。

使った組み込み関数の式は次の通りです:

normalize(𝐯)=𝐯‖𝐯‖,dot(𝐚,𝐛)=axbx+ayby+azbz,max(a,b)={aa≥bba<b

元の版のfrag_directional.glslにはin vec3 vNormal;の宣言が無く、vec3 normal = vec3(0.0, 0.0, 1.0);と言う定数の法線を使っていました。此れでは頂点シェーダーが法線を渡しても無視され、三角形全体が同じ明るさになります。4.6節で比べます。

Cのコード

main-directional.cでは、頂点データに法線を追加します。
1つの頂点が7個のfloat(位置2個、UV2個、法線3個)になります:

  // 頂点データ(三角形)を設定:ディレクショナル用(右にオフセット)
  float verticesDirectional[] = {
    // 位置           UV            法線
    0.3f,  -0.5f,   0.0f, 0.0f,   -0.5f, -0.5f, 0.707f, // 左下
    0.8f,  -0.5f,   1.0f, 0.0f,    0.5f, -0.5f, 0.707f, // 右下
    0.55f,  0.5f,   0.5f, 1.0f,    0.0f,  0.5f, 0.707f  // 上
  };

属性 location float数 頂点の先頭からのオフセット
位置 aPosition 0 2 0
UV aUv 1 2 2 × sizeof(float) = 8
法線 aNormal 2 3 4 × sizeof(float) = 16

1頂点の大きさ(ストライド)は7×4=28バイトです。
其れをglVertexAttribPointerに伝えます:

  // VAO、VBO、EBOをディレクショナル用に設定
  GLuint VAODirectional, VBODirectional, EBODirectional;
  glGenVertexArrays(1, &VAODirectional);
  glGenBuffers(1, &VBODirectional);
  glGenBuffers(1, &EBODirectional);

  glBindVertexArray(VAODirectional);
  glBindBuffer(GL_ARRAY_BUFFER, VBODirectional);
  glBufferData(GL_ARRAY_BUFFER, sizeof(verticesDirectional), verticesDirectional, GL_STATIC_DRAW);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBODirectional);
  glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

  // 頂点属性:位置(location 0)、UV(location 1)、法線(location 2)、1頂点 = 7個のfloat
  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (void *)0);
  glEnableVertexAttribArray(0);
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (void *)(2 * sizeof(float)));
  glEnableVertexAttribArray(1);
  glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (void *)(4 * sizeof(float)));
  glEnableVertexAttribArray(2);

左のグラデーションの三角形は今まで通り4個のfloatのストライドで、右の三角形だけが7個です。
属性の形はVAO毎に記録されるので、2つの三角形で頂点の形が違っても問題ありません。

シェーダーの読み込み、コンパイル、リンクはアンビエントの時と同じ形で、今回は頂点シェーダーも新しい物(vertex_directional.glsl)を使います:

  // ディレクショナルシェーダープログラムをリンク
  GLuint directionalShaderProgram = glCreateProgram();
  glAttachShader(directionalShaderProgram, vertexDirectionalShader);
  glAttachShader(directionalShaderProgram, fragmentDirectionalShader);
  glLinkProgram(directionalShaderProgram);
  checkProgramLink(directionalShaderProgram);

メインループでユニフォームを設定して描画します:

    // ディレクショナルシェーダープログラムを使用(右の三角形)
    glUseProgram(directionalShaderProgram);

    // ユニフォームを設定(ディレクショナルシェーダー)
    Vector3 materialColor = { 0.8f, 0.2f, 0.3f }; // 赤みがかった色
    Vector3 lightDirection = { -0.5f, -0.5f, -0.707f }; // 光が進む向き(右上手前から左下奥へ)
    float lightIntensity = 1.0f; // ライトの強さ(0.0~1.0)

    glUniform3f(glGetUniformLocation(directionalShaderProgram, "materialColor"),
                materialColor.r, materialColor.g, materialColor.b);
    glUniform3f(glGetUniformLocation(directionalShaderProgram, "lightDirection"),
                lightDirection.x, lightDirection.y, lightDirection.z);
    glUniform1f(glGetUniformLocation(directionalShaderProgram, "lightIntensity"), lightIntensity);

    // 右の三角形を描画(ディレクショナルシェーダー)
    glBindVertexArray(VAODirectional);
    glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0);

全体は記事の最後のDIFFで確認出来ます。
結果は次の様になります:

左にグラデーションの三角形、右に右上が明るく左下が暗い赤い三角形

数字で確かめる

光が進む向きは𝐝=(−0.5,−0.5,−0.707)で、長さは0.25+0.25+0.5≈1です。
従って、光源への向きは𝐥^=−𝐝=(0.5,0.5,0.707)、右上手前です。

各頂点の明るさmax(𝐧^⋅𝐥^,0)を計算してみましょう。

  • 左下𝐧=(−0.5,−0.5,0.707):長さは1。−0.25−0.25+0.5=0。光に対して真横を向いているので、真っ黒です。
  • 右下𝐧=(0.5,−0.5,0.707):長さは1。0.25−0.25+0.5=0.5。半分の明るさで、色は0.5×(0.8,0.2,0.3)=(0.4,0.1,0.15)、8ビットで(102,25,38)です。
  • 上𝐧=(0,0.5,0.707):長さは0.25+0.5=0.866で、1ではありません。正規化すると(0,0.577,0.816)になり、0.289+0.577=0.866。一番明るく、8ビットで(177,44,66)です。

スクリーンショットの頂点付近のピクセルは、丁度此れらの値になっています。
上の頂点の法線は長さが1ではありませんが、シェーダーでnormalizeしているので正しい明るさになります。
「データの法線が単位ベクトルである事を当てにしない」のは、シェーダーを書く時の良い習慣です。

4.6 よくある間違い

ライティングのバグは、コンパイルエラーにならず、「何となく見た目がおかしい」だけである事が多いです。
此処で3つの典型的な間違いを見ておきましょう。

法線を使っていない

元の版の様にvec3 normal = vec3(0.0, 0.0, 1.0);と書くと、三角形の全てのピクセルの法線が同じになります。
𝐧^⋅𝐥^=0.707なので、三角形は一様に0.707×(0.8,0.2,0.3)、8ビットで(144,36,54)になります。
アンビエントライトと同じ様に、陰影が全く有りません。
平らな三角形が正面を向いているなら物理的には正しいのですが、頂点の法線を渡している意味が無くなります。

補間された法線を正規化していない

ラスタライザーは法線を、他の値と同じ様に成分毎に線型補間します。
長さ1の2つのベクトルの平均は、一般に長さが1より短くなります。

長さ1の法線n0とn1の平均は長さ0.6になり、正規化すると長さ1に戻る

図の𝐧0=(−0.8,0.6)と𝐧1=(0.8,0.6)は両方とも長さ1ですが、平均(0,0.6)の長さは0.6です。
内積は長さに比例するので、正規化しないと三角形の内側が暗くなります。
此の章の三角形の重心では、3つの法線の平均は(0,−0.167,0.707)で、長さは0.727です。
正規化しないと明るさは0.417(8ビットの赤で85)、正規化すると0.417/0.727=0.573(117)です。

左:定数の法線。中:正規化しない法線。右:正規化した法線

光の向きの符号

-normalize(lightDirection)のマイナスを忘れると、照らされる面と暗い面が全部入れ替わります。
此の三角形では3つの頂点全てで内積が0以下になるので、maxで全て0になり、三角形全体が真っ黒になります(実際に試すと、右の三角形は背景に溶けて見えなくなります)。
ライトの向きをCでどちらの流儀で持っているのかを、コメントに必ず書いておきましょう。

4.7 此の章で使ったGLSLとOpenGLの機能

  • normalize(v):𝐯/‖𝐯‖。長さ0のベクトルを正規化すると結果は未定義(NaN等)になるので注意して下さい。
  • dot(a, b):内積。単位ベクトル同士なら間の角度のコサインです。
  • max(a, b):大きい方。max(x, 0.0)は負の値を0にする定番の書き方です。
  • vec3 * float:全ての成分に同じ数を掛けます。vec3 * vec3は成分毎の掛け算です(色にライトの色を掛ける時に使います)。
  • layout(location = 2) in vec3:3つ目の頂点属性。CのglVertexAttribPointer(2, 3, ...)と対応します。
  • 1つのシェーダーオブジェクトを複数のプログラムにアタッチ出来ます。
  • VAOは頂点属性の設定とEBOを記録します。VAOを作る度に属性を設定し直します。
  • ユニフォームの値はプログラム毎に別々です。

4.8 ゲームやエンジンでの使い方

  • 太陽光:屋外のシーンは、殆ど必ず1つのディレクショナルライトを太陽として持っています。UnityやUnreal Engineの「Directional Light」がそうで、エディターでは「光が進む向き」として回転を設定します。シェーダーに渡す前にエンジンが符号を反転させています。
  • アンビエント:昔のゲームでは、此の章と同じ一定のアンビエント色で、影の中が真っ黒になるのを防いでいました。今のエンジンでは、空の色の分布(環境マップや球面調和関数)から方向によって変わる環境光を計算しますが、考え方の出発点は同じです。
  • ハーフランバート:Valveが『Half-Life 2』等で使った、(0.5+0.5𝐧^⋅𝐥^)2で暗い側を柔らかくする手法です。キャラクターの影の側が真っ黒にならず、アニメ調やスタイライズされたゲームでもよく使われます。
  • トゥーンシェーディング:𝐧^⋅𝐥^をstepで2〜3段階に区切ると、セル画の様な陰影になります。
  • 法線の正規化:エンジンのシェーダーは、補間された法線を必ずnormalizeし直します。法線マップ(第12章)を使う場合も同じです。

4.9 まとめ

  • glDrawElementsのインデックス数を変えると、描く三角形の数が変わります。三角形の外のピクセルではフラグメントシェーダーは実行されません。
  • 1つのウィンドウに、別々のプログラムとVAOで複数の物を描けます。VAO毎に頂点属性を設定し直します。
  • アンビエントライト:Ia𝐤d。全てのピクセルが同じ色になります。
  • ディレクショナルライト:I𝐤dmax(𝐧^⋅𝐥^,0)。法線と光源への向きの内積で明るさが決まります。
  • 光が進む向き𝐝と光源への向き𝐥^は反対:𝐥^=−𝐝^。
  • 補間された法線は短くなるので、フラグメントシェーダーでnormalizeし直します。
  • 他のライト(ポイント、スポット、ヘミスフィア、エリア)は第9章と第10章で実装します。

4.10 課題

  1. ★ ambientIntensity = 0.25、materialColor = (0.8, 0.4, 1.0)の時、アンビエントの三角形の色を0〜1と8ビットの両方で計算して下さい。
  2. ★ 光が進む向き𝐝=(0,0,−1)(真っ直ぐ画面の奥へ)の時、此の章の3つの頂点の明るさを計算して下さい。上の頂点は正規化してから計算します。
  3. ★★ main-directional.cのlightDirectionを{ 0.5f, -0.5f, -0.707f }(左上手前から)に変えて下さい。今度は左下の頂点が0.5、右下の頂点が0になり、左右の明るさが入れ替わる筈です。
  4. ★★ アンビエントとディレクショナルを1つのシェーダーで組み合わせて下さい:𝐤d(Ia+Imax(𝐧^⋅𝐥^,0))。ambientIntensity = 0.2なら、左下の頂点は真っ黒ではなく0.2×(0.8,0.2,0.3)、8ビットで約(41,10,15)になる筈です。
  5. ★★ main-directional.cで、glfwGetTime()を使ってライトを回転させて下さい(例:lightDirection = { -cos(time), -sin(time), -0.707f })。明るい所が三角形の周りをぐるぐる回る筈です。
  6. ★★ frag_directional.glslで、明るさをstep(0.5, diffuseFactor)に置き換えて、トゥーンシェーディングにして下さい。三角形が明るい部分と真っ黒な部分の2色にくっきり分かれる筈です。
  7. ★★★ ハーフランバート(0.5+0.5𝐧^⋅𝐥^)2を実装し、普通のランバートと比べて下さい。何故2乗するのか、𝐧^⋅𝐥^=−1,0,1の時の値を計算して考えて下さい。又、此の式は物理的に正しいでしょうか?

DIFFをダウンロード

ファイル: a/build-unix.sh | b/build-unix.sh

前新
@@ -1,6 +1,9 @@
1 #!/bin/sh 1 #!/bin/sh
2   2  
3 cc main.c src/glad.c -o glsltester\ 3 # 使い方:./build-unix.sh [ソースファイル](省略するとmain.c)
    4 SRC=${1:-main.c}
    5  
    6 cc "$SRC" src/glad.c -o glsltester\
4 -I./include -I/usr/include -I/usr/X11R6/include -I/usr/X11R7/include\ 7 -I./include -I/usr/include -I/usr/X11R6/include -I/usr/X11R7/include\
5 -I/usr/local/include\ 8 -I/usr/local/include\
6 -L/usr/lib -L/usr/X11R6/lib -L/usr/X11R7/lib -L/usr/local/lib\ 9 -L/usr/lib -L/usr/X11R6/lib -L/usr/X11R7/lib -L/usr/local/lib\

ファイル: a/main.c | b/main-ambient.c

前新
@@ -159,14 +159,17 @@ int main(int argc, char **argv) {
159 #ifdef __APPLE__ 159 #ifdef __APPLE__
160 char *vertexShaderSource = readShaderFile("shader/vertex.mac.glsl"); 160 char *vertexShaderSource = readShaderFile("shader/vertex.mac.glsl");
161 char *fragmentShaderSource = readShaderFile("shader/fragment.mac.glsl"); 161 char *fragmentShaderSource = readShaderFile("shader/fragment.mac.glsl");
    162 char *fragmentAmbientSource = readShaderFile("shader/frag_ambient.mac.glsl");
162 #else 163 #else
163 char *vertexShaderSource = readShaderFile("shader/vertex.glsl"); 164 char *vertexShaderSource = readShaderFile("shader/vertex.glsl");
164 char *fragmentShaderSource = readShaderFile("shader/fragment.glsl"); 165 char *fragmentShaderSource = readShaderFile("shader/fragment.glsl");
    166 char *fragmentAmbientSource = readShaderFile("shader/frag_ambient.glsl");
165 #endif 167 #endif
166 if (!vertexShaderSource || !fragmentShaderSource) { 168 if (!vertexShaderSource || !fragmentShaderSource || !fragmentAmbientSource) {
167 puts("シェーダーファイルの読み込みに失敗しました"); 169 puts("シェーダーファイルの読み込みに失敗しました");
168 if (vertexShaderSource) free(vertexShaderSource); 170 if (vertexShaderSource) free(vertexShaderSource);
169 if (fragmentShaderSource) free(fragmentShaderSource); 171 if (fragmentShaderSource) free(fragmentShaderSource);
    172 if (fragmentAmbientSource) free(fragmentAmbientSource);
170 glfwDestroyWindow(window); 173 glfwDestroyWindow(window);
171 glfwTerminate(); 174 glfwTerminate();
172 return -1; 175 return -1;
@@ -183,27 +186,48 @@ int main(int argc, char **argv) {
183 glCompileShader(fragmentShader); 186 glCompileShader(fragmentShader);
184 checkShaderCompile(fragmentShader); 187 checkShaderCompile(fragmentShader);
185   188  
186 // シェーダープログラムをリンク 189 GLuint fragmentAmbientShader = glCreateShader(GL_FRAGMENT_SHADER);
    190 glShaderSource(fragmentAmbientShader, 1, (const char **)&fragmentAmbientSource, NULL);
    191 glCompileShader(fragmentAmbientShader);
    192 checkShaderCompile(fragmentAmbientShader);
    193  
    194 // 三角形のシェーダープログラムをリンク
187 GLuint shaderProgram = glCreateProgram(); 195 GLuint shaderProgram = glCreateProgram();
188 glAttachShader(shaderProgram, vertexShader); 196 glAttachShader(shaderProgram, vertexShader);
189 glAttachShader(shaderProgram, fragmentShader); 197 glAttachShader(shaderProgram, fragmentShader);
190 glLinkProgram(shaderProgram); 198 glLinkProgram(shaderProgram);
191 checkProgramLink(shaderProgram); 199 checkProgramLink(shaderProgram);
192   200  
    201 // アンビエントシェーダープログラムをリンク(頂点シェーダーは同じ物を使う)
    202 GLuint ambientShaderProgram = glCreateProgram();
    203 glAttachShader(ambientShaderProgram, vertexShader);
    204 glAttachShader(ambientShaderProgram, fragmentAmbientShader);
    205 glLinkProgram(ambientShaderProgram);
    206 checkProgramLink(ambientShaderProgram);
    207  
193 glDeleteShader(vertexShader); 208 glDeleteShader(vertexShader);
194 glDeleteShader(fragmentShader); 209 glDeleteShader(fragmentShader);
    210 glDeleteShader(fragmentAmbientShader);
195 free(vertexShaderSource); 211 free(vertexShaderSource);
196 free(fragmentShaderSource); 212 free(fragmentShaderSource);
    213 free(fragmentAmbientSource);
197   214  
198 // 頂点データ(フルスクリーンクアッド)を設定 215 // 頂点データ(三角形)を設定:グラデーション用(左にオフセット)
199 float vertices[] = { 216 float vertices[] = {
200 -1.0f, -1.0f, 0.0f, 0.0f, // 左下(位置、UV) 217 -0.8f, -0.5f, 0.0f, 0.0f, // 左下(位置、UV)
201 1.0f, -1.0f, 1.0f, 0.0f, // 右下 218 -0.3f, -0.5f, 1.0f, 0.0f, // 右下
202 1.0f, 1.0f, 1.0f, 1.0f, // 右上 219 -0.55f, 0.5f, 0.5f, 1.0f // 上
203 -1.0f, 1.0f, 0.0f, 1.0f // 左上 220 };
    221 GLuint indices[] = { 0, 1, 2 };
    222  
    223 // 頂点データ(三角形)を設定:アンビエント用(右にオフセット)
    224 float verticesAmbient[] = {
    225 0.3f, -0.5f, 0.0f, 0.0f, // 左下(位置、UV)
    226 0.8f, -0.5f, 1.0f, 0.0f, // 右下
    227 0.55f, 0.5f, 0.5f, 1.0f // 上
204 }; 228 };
205 GLuint indices[] = { 0, 1, 2, 2, 3, 0 };    
206   229  
    230 // VAO、VBO、EBOをグラデーション用に設定
207 GLuint VAO, VBO, EBO; 231 GLuint VAO, VBO, EBO;
208 glGenVertexArrays(1, &VAO); 232 glGenVertexArrays(1, &VAO);
209 glGenBuffers(1, &VBO); 233 glGenBuffers(1, &VBO);
@@ -222,6 +246,24 @@ int main(int argc, char **argv) {
222 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void *)offset); 246 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void *)offset);
223 glEnableVertexAttribArray(1); 247 glEnableVertexAttribArray(1);
224   248  
    249 // VAO、VBO、EBOをアンビエント用に設定
    250 GLuint VAOAmbient, VBOAmbient, EBOAmbient;
    251 glGenVertexArrays(1, &VAOAmbient);
    252 glGenBuffers(1, &VBOAmbient);
    253 glGenBuffers(1, &EBOAmbient);
    254  
    255 glBindVertexArray(VAOAmbient);
    256 glBindBuffer(GL_ARRAY_BUFFER, VBOAmbient);
    257 glBufferData(GL_ARRAY_BUFFER, sizeof(verticesAmbient), verticesAmbient, GL_STATIC_DRAW);
    258 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBOAmbient);
    259 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    260  
    261 // 頂点属性はVAO毎に保存されるので、此方でも設定する
    262 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void *)0);
    263 glEnableVertexAttribArray(0);
    264 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void *)offset);
    265 glEnableVertexAttribArray(1);
    266  
225 // メインレンダリングループ 267 // メインレンダリングループ
226 while (!glfwWindowShouldClose(window)) { 268 while (!glfwWindowShouldClose(window)) {
227 // 画面をクリア 269 // 画面をクリア
@@ -259,9 +301,24 @@ int main(int argc, char **argv) {
259 glUniform3f(glGetUniformLocation(shaderProgram, "uColorB"), colorB.r, colorB.g, colorB.b); // 緑 301 glUniform3f(glGetUniformLocation(shaderProgram, "uColorB"), colorB.r, colorB.g, colorB.b); // 緑
260 glUniform3f(glGetUniformLocation(shaderProgram, "uColorC"), colorC.r, colorC.g, colorC.b); // 青 302 glUniform3f(glGetUniformLocation(shaderProgram, "uColorC"), colorC.r, colorC.g, colorC.b); // 青
261   303  
262 // クアッドを描画 304 // 左の三角形を描画(グラデーションシェーダー)
263 glBindVertexArray(VAO); 305 glBindVertexArray(VAO);
264 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); 306 glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0);
    307  
    308 // アンビエントシェーダープログラムを使用(右の三角形)
    309 glUseProgram(ambientShaderProgram);
    310  
    311 // ユニフォームを設定(アンビエントシェーダー)
    312 Vector3 materialColor = { 0.8f, 0.2f, 0.3f }; // 赤みがかった色
    313 float ambientIntensity = 0.6f; // アンビエント光の強さ(0.0~1.0)
    314  
    315 glUniform3f(glGetUniformLocation(ambientShaderProgram, "materialColor"),
    316 materialColor.r, materialColor.g, materialColor.b);
    317 glUniform1f(glGetUniformLocation(ambientShaderProgram, "ambientIntensity"), ambientIntensity);
    318  
    319 // 右の三角形を描画(アンビエントシェーダー)
    320 glBindVertexArray(VAOAmbient);
    321 glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0);
265   322  
266 // バッファをスワップし、イベントを処理 323 // バッファをスワップし、イベントを処理
267 glfwSwapBuffers(window); 324 glfwSwapBuffers(window);
@@ -272,7 +329,11 @@ int main(int argc, char **argv) {
272 glDeleteVertexArrays(1, &VAO); 329 glDeleteVertexArrays(1, &VAO);
273 glDeleteBuffers(1, &VBO); 330 glDeleteBuffers(1, &VBO);
274 glDeleteBuffers(1, &EBO); 331 glDeleteBuffers(1, &EBO);
    332 glDeleteVertexArrays(1, &VAOAmbient);
    333 glDeleteBuffers(1, &VBOAmbient);
    334 glDeleteBuffers(1, &EBOAmbient);
275 glDeleteProgram(shaderProgram); 335 glDeleteProgram(shaderProgram);
    336 glDeleteProgram(ambientShaderProgram);
276 glfwDestroyWindow(window); 337 glfwDestroyWindow(window);
277 glfwTerminate(); 338 glfwTerminate();
278   339  

ファイル: a/main.c | b/main-directional.c

前新
@@ -158,15 +158,21 @@ int main(int argc, char **argv) {
158 // シェーダーファイルを読み込む 158 // シェーダーファイルを読み込む
159 #ifdef __APPLE__ 159 #ifdef __APPLE__
160 char *vertexShaderSource = readShaderFile("shader/vertex.mac.glsl"); 160 char *vertexShaderSource = readShaderFile("shader/vertex.mac.glsl");
    161 char *vertexDirectionalSource = readShaderFile("shader/vertex_directional.mac.glsl");
161 char *fragmentShaderSource = readShaderFile("shader/fragment.mac.glsl"); 162 char *fragmentShaderSource = readShaderFile("shader/fragment.mac.glsl");
    163 char *fragmentDirectionalSource = readShaderFile("shader/frag_directional.mac.glsl");
162 #else 164 #else
163 char *vertexShaderSource = readShaderFile("shader/vertex.glsl"); 165 char *vertexShaderSource = readShaderFile("shader/vertex.glsl");
    166 char *vertexDirectionalSource = readShaderFile("shader/vertex_directional.glsl");
164 char *fragmentShaderSource = readShaderFile("shader/fragment.glsl"); 167 char *fragmentShaderSource = readShaderFile("shader/fragment.glsl");
    168 char *fragmentDirectionalSource = readShaderFile("shader/frag_directional.glsl");
165 #endif 169 #endif
166 if (!vertexShaderSource || !fragmentShaderSource) { 170 if (!vertexShaderSource || !vertexDirectionalSource || !fragmentShaderSource || !fragmentDirectionalSource) {
167 puts("シェーダーファイルの読み込みに失敗しました"); 171 puts("シェーダーファイルの読み込みに失敗しました");
168 if (vertexShaderSource) free(vertexShaderSource); 172 if (vertexShaderSource) free(vertexShaderSource);
    173 if (vertexDirectionalSource) free(vertexDirectionalSource);
169 if (fragmentShaderSource) free(fragmentShaderSource); 174 if (fragmentShaderSource) free(fragmentShaderSource);
    175 if (fragmentDirectionalSource) free(fragmentDirectionalSource);
170 glfwDestroyWindow(window); 176 glfwDestroyWindow(window);
171 glfwTerminate(); 177 glfwTerminate();
172 return -1; 178 return -1;
@@ -178,32 +184,61 @@ int main(int argc, char **argv) {
178 glCompileShader(vertexShader); 184 glCompileShader(vertexShader);
179 checkShaderCompile(vertexShader); 185 checkShaderCompile(vertexShader);
180   186  
    187 GLuint vertexDirectionalShader = glCreateShader(GL_VERTEX_SHADER);
    188 glShaderSource(vertexDirectionalShader, 1, (const char **)&vertexDirectionalSource, NULL);
    189 glCompileShader(vertexDirectionalShader);
    190 checkShaderCompile(vertexDirectionalShader);
    191  
181 GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); 192 GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
182 glShaderSource(fragmentShader, 1, (const char **)&fragmentShaderSource, NULL); 193 glShaderSource(fragmentShader, 1, (const char **)&fragmentShaderSource, NULL);
183 glCompileShader(fragmentShader); 194 glCompileShader(fragmentShader);
184 checkShaderCompile(fragmentShader); 195 checkShaderCompile(fragmentShader);
185   196  
186 // シェーダープログラムをリンク 197 GLuint fragmentDirectionalShader = glCreateShader(GL_FRAGMENT_SHADER);
    198 glShaderSource(fragmentDirectionalShader, 1, (const char **)&fragmentDirectionalSource, NULL);
    199 glCompileShader(fragmentDirectionalShader);
    200 checkShaderCompile(fragmentDirectionalShader);
    201  
    202 // 三角形のシェーダープログラムをリンク
187 GLuint shaderProgram = glCreateProgram(); 203 GLuint shaderProgram = glCreateProgram();
188 glAttachShader(shaderProgram, vertexShader); 204 glAttachShader(shaderProgram, vertexShader);
189 glAttachShader(shaderProgram, fragmentShader); 205 glAttachShader(shaderProgram, fragmentShader);
190 glLinkProgram(shaderProgram); 206 glLinkProgram(shaderProgram);
191 checkProgramLink(shaderProgram); 207 checkProgramLink(shaderProgram);
192   208  
    209 // ディレクショナルシェーダープログラムをリンク
    210 GLuint directionalShaderProgram = glCreateProgram();
    211 glAttachShader(directionalShaderProgram, vertexDirectionalShader);
    212 glAttachShader(directionalShaderProgram, fragmentDirectionalShader);
    213 glLinkProgram(directionalShaderProgram);
    214 checkProgramLink(directionalShaderProgram);
    215  
193 glDeleteShader(vertexShader); 216 glDeleteShader(vertexShader);
    217 glDeleteShader(vertexDirectionalShader);
194 glDeleteShader(fragmentShader); 218 glDeleteShader(fragmentShader);
    219 glDeleteShader(fragmentDirectionalShader);
195 free(vertexShaderSource); 220 free(vertexShaderSource);
    221 free(vertexDirectionalSource);
196 free(fragmentShaderSource); 222 free(fragmentShaderSource);
    223 free(fragmentDirectionalSource);
197   224  
198 // 頂点データ(フルスクリーンクアッド)を設定 225 // 頂点データ(三角形)を設定:グラデーション用(左にオフセット)
199 float vertices[] = { 226 float vertices[] = {
200 -1.0f, -1.0f, 0.0f, 0.0f, // 左下(位置、UV) 227 -0.8f, -0.5f, 0.0f, 0.0f, // 左下(位置、UV)
201 1.0f, -1.0f, 1.0f, 0.0f, // 右下 228 -0.3f, -0.5f, 1.0f, 0.0f, // 右下
202 1.0f, 1.0f, 1.0f, 1.0f, // 右上 229 -0.55f, 0.5f, 0.5f, 1.0f // 上
203 -1.0f, 1.0f, 0.0f, 1.0f // 左上 230 };
    231 GLuint indices[] = { 0, 1, 2 };
    232  
    233 // 頂点データ(三角形)を設定:ディレクショナル用(右にオフセット)
    234 float verticesDirectional[] = {
    235 // 位置 UV 法線
    236 0.3f, -0.5f, 0.0f, 0.0f, -0.5f, -0.5f, 0.707f, // 左下
    237 0.8f, -0.5f, 1.0f, 0.0f, 0.5f, -0.5f, 0.707f, // 右下
    238 0.55f, 0.5f, 0.5f, 1.0f, 0.0f, 0.5f, 0.707f // 上
204 }; 239 };
205 GLuint indices[] = { 0, 1, 2, 2, 3, 0 };    
206   240  
    241 // VAO、VBO、EBOをグラデーション用に設定
207 GLuint VAO, VBO, EBO; 242 GLuint VAO, VBO, EBO;
208 glGenVertexArrays(1, &VAO); 243 glGenVertexArrays(1, &VAO);
209 glGenBuffers(1, &VBO); 244 glGenBuffers(1, &VBO);
@@ -222,6 +257,26 @@ int main(int argc, char **argv) {
222 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void *)offset); 257 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void *)offset);
223 glEnableVertexAttribArray(1); 258 glEnableVertexAttribArray(1);
224   259  
    260 // VAO、VBO、EBOをディレクショナル用に設定
    261 GLuint VAODirectional, VBODirectional, EBODirectional;
    262 glGenVertexArrays(1, &VAODirectional);
    263 glGenBuffers(1, &VBODirectional);
    264 glGenBuffers(1, &EBODirectional);
    265  
    266 glBindVertexArray(VAODirectional);
    267 glBindBuffer(GL_ARRAY_BUFFER, VBODirectional);
    268 glBufferData(GL_ARRAY_BUFFER, sizeof(verticesDirectional), verticesDirectional, GL_STATIC_DRAW);
    269 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBODirectional);
    270 glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    271  
    272 // 頂点属性:位置(location 0)、UV(location 1)、法線(location 2)、1頂点 = 7個のfloat
    273 glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (void *)0);
    274 glEnableVertexAttribArray(0);
    275 glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (void *)(2 * sizeof(float)));
    276 glEnableVertexAttribArray(1);
    277 glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 7 * sizeof(float), (void *)(4 * sizeof(float)));
    278 glEnableVertexAttribArray(2);
    279  
225 // メインレンダリングループ 280 // メインレンダリングループ
226 while (!glfwWindowShouldClose(window)) { 281 while (!glfwWindowShouldClose(window)) {
227 // 画面をクリア 282 // 画面をクリア
@@ -259,9 +314,27 @@ int main(int argc, char **argv) {
259 glUniform3f(glGetUniformLocation(shaderProgram, "uColorB"), colorB.r, colorB.g, colorB.b); // 緑 314 glUniform3f(glGetUniformLocation(shaderProgram, "uColorB"), colorB.r, colorB.g, colorB.b); // 緑
260 glUniform3f(glGetUniformLocation(shaderProgram, "uColorC"), colorC.r, colorC.g, colorC.b); // 青 315 glUniform3f(glGetUniformLocation(shaderProgram, "uColorC"), colorC.r, colorC.g, colorC.b); // 青
261   316  
262 // クアッドを描画 317 // 左の三角形を描画(グラデーションシェーダー)
263 glBindVertexArray(VAO); 318 glBindVertexArray(VAO);
264 glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); 319 glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0);
    320  
    321 // ディレクショナルシェーダープログラムを使用(右の三角形)
    322 glUseProgram(directionalShaderProgram);
    323  
    324 // ユニフォームを設定(ディレクショナルシェーダー)
    325 Vector3 materialColor = { 0.8f, 0.2f, 0.3f }; // 赤みがかった色
    326 Vector3 lightDirection = { -0.5f, -0.5f, -0.707f }; // 光が進む向き(右上手前から左下奥へ)
    327 float lightIntensity = 1.0f; // ライトの強さ(0.0~1.0)
    328  
    329 glUniform3f(glGetUniformLocation(directionalShaderProgram, "materialColor"),
    330 materialColor.r, materialColor.g, materialColor.b);
    331 glUniform3f(glGetUniformLocation(directionalShaderProgram, "lightDirection"),
    332 lightDirection.x, lightDirection.y, lightDirection.z);
    333 glUniform1f(glGetUniformLocation(directionalShaderProgram, "lightIntensity"), lightIntensity);
    334  
    335 // 右の三角形を描画(ディレクショナルシェーダー)
    336 glBindVertexArray(VAODirectional);
    337 glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, 0);
265   338  
266 // バッファをスワップし、イベントを処理 339 // バッファをスワップし、イベントを処理
267 glfwSwapBuffers(window); 340 glfwSwapBuffers(window);
@@ -272,7 +345,11 @@ int main(int argc, char **argv) {
272 glDeleteVertexArrays(1, &VAO); 345 glDeleteVertexArrays(1, &VAO);
273 glDeleteBuffers(1, &VBO); 346 glDeleteBuffers(1, &VBO);
274 glDeleteBuffers(1, &EBO); 347 glDeleteBuffers(1, &EBO);
    348 glDeleteVertexArrays(1, &VAODirectional);
    349 glDeleteBuffers(1, &VBODirectional);
    350 glDeleteBuffers(1, &EBODirectional);
275 glDeleteProgram(shaderProgram); 351 glDeleteProgram(shaderProgram);
    352 glDeleteProgram(directionalShaderProgram);
276 glfwDestroyWindow(window); 353 glfwDestroyWindow(window);
277 glfwTerminate(); 354 glfwTerminate();
278   355  

ファイル: /dev/null | b/shader/frag_ambient.glsl

前新
@@ -0,0 +1,12 @@
    1 #version 450 core
    2  
    3 in vec2 vUv;
    4 out vec4 out_color;
    5  
    6 uniform vec3 materialColor;
    7 uniform float ambientIntensity;
    8  
    9 void main() {
    10 vec3 ambient = materialColor * ambientIntensity;
    11 out_color = vec4(ambient, 1.0);
    12 }

ファイル: /dev/null | b/shader/frag_ambient.mac.glsl

前新
@@ -0,0 +1,12 @@
    1 #version 410 core
    2  
    3 in vec2 vUv;
    4 out vec4 out_color;
    5  
    6 uniform vec3 materialColor;
    7 uniform float ambientIntensity;
    8  
    9 void main() {
    10 vec3 ambient = materialColor * ambientIntensity;
    11 out_color = vec4(ambient, 1.0);
    12 }

ファイル: /dev/null | b/shader/frag_directional.glsl

前新
@@ -0,0 +1,20 @@
    1 #version 450 core
    2  
    3 in vec2 vUv;
    4 in vec3 vNormal;
    5 out vec4 out_color;
    6  
    7 uniform vec3 materialColor;
    8 uniform vec3 lightDirection; // 光が進む向き(光源から表面へ)
    9 uniform float lightIntensity;
    10  
    11 void main() {
    12 // 補間された法線は短くなるので、正規化し直す
    13 vec3 normal = normalize(vNormal);
    14 // 表面から光源への向き(光が進む向きの逆)
    15 vec3 toLight = -normalize(lightDirection);
    16  
    17 float diffuseFactor = max(dot(normal, toLight), 0.0);
    18 vec3 diffuse = materialColor * diffuseFactor * lightIntensity;
    19 out_color = vec4(diffuse, 1.0);
    20 }

ファイル: /dev/null | b/shader/frag_directional.mac.glsl

前新
@@ -0,0 +1,20 @@
    1 #version 410 core
    2  
    3 in vec2 vUv;
    4 in vec3 vNormal;
    5 out vec4 out_color;
    6  
    7 uniform vec3 materialColor;
    8 uniform vec3 lightDirection; // 光が進む向き(光源から表面へ)
    9 uniform float lightIntensity;
    10  
    11 void main() {
    12 // 補間された法線は短くなるので、正規化し直す
    13 vec3 normal = normalize(vNormal);
    14 // 表面から光源への向き(光が進む向きの逆)
    15 vec3 toLight = -normalize(lightDirection);
    16  
    17 float diffuseFactor = max(dot(normal, toLight), 0.0);
    18 vec3 diffuse = materialColor * diffuseFactor * lightIntensity;
    19 out_color = vec4(diffuse, 1.0);
    20 }

ファイル: a/shader/vertex.glsl | b/shader/vertex_directional.glsl

前新
@@ -2,9 +2,13 @@
2   2  
3 layout(location = 0) in vec2 aPosition; 3 layout(location = 0) in vec2 aPosition;
4 layout(location = 1) in vec2 aUv; 4 layout(location = 1) in vec2 aUv;
    5 layout(location = 2) in vec3 aNormal;
    6  
5 out vec2 vUv; 7 out vec2 vUv;
    8 out vec3 vNormal;
6   9  
7 void main() { 10 void main() {
8 vUv = aUv; 11 vUv = aUv;
    12 vNormal = aNormal;
9 gl_Position = vec4(aPosition, 0.0, 1.0); 13 gl_Position = vec4(aPosition, 0.0, 1.0);
10 } 14 }

ファイル: a/shader/vertex.mac.glsl | b/shader/vertex_directional.mac.glsl

前新
@@ -2,9 +2,13 @@
2   2  
3 layout(location = 0) in vec2 aPosition; 3 layout(location = 0) in vec2 aPosition;
4 layout(location = 1) in vec2 aUv; 4 layout(location = 1) in vec2 aUv;
    5 layout(location = 2) in vec3 aNormal;
    6  
5 out vec2 vUv; 7 out vec2 vUv;
    8 out vec3 vNormal;
6   9  
7 void main() { 10 void main() {
8 vUv = aUv; 11 vUv = aUv;
    12 vNormal = aNormal;
9 gl_Position = vec4(aPosition, 0.0, 1.0); 13 gl_Position = vec4(aPosition, 0.0, 1.0);
10 } 14 }


コメント(0)

まだコメントはありません。