2. GLSL 概要

GLSLには様々な方言があり、シェーダーの種類も幾つかあります。
此の章の前半では其れらを全て説明します。
其れが分かれば、ネットでシェーダーのコードを見付けた時に、どのGLSLなのかが分かる様になります。

後半の大きな部分は、言語其の物の紹介です。
型、ベクトル、スウィズル、行列、修飾子、関数、制御構文、組み込み変数と組み込み関数、数値の落とし穴、そしてプリプロセッサーを順番に見ていきます。
どの機能にも、第1章のGLSLテスターに貼り付けられる小さなフラグメントシェーダーと、其の描画結果のスクリーンショットを付けます。
第3章からは、構文の説明で立ち止まらずに此れらを全て使っていきます。

2.1 方言

GLSLの場合、異なるプラットフォームが異なる方言を使用します。
言語の中心部分は共通です(2.3節以降の内容は全ての方言で使えます)が、シェーダーの最初の数行と幾つかのルールが違います。

OpenGL Core

OpenGL Core用のシェーダーは、OpenGL 3.2から4.6(実際には3.3以降)を使用するデスクトップで使用される事を目的としています。
此れが此のチュートリアルシリーズで使う方言です。
前章でダウンロードしたGLSLテスターに含まれるシェーダーファイルを自由に確認して下さい。

全てのシェーダーの最初の行で、どのバージョンのGLSLで書かれているかを指定します。
OpenGLの各バージョンには、其れに対応するGLSLのバージョンがあります:

OpenGL GLSL 最初の行
2.0 1.10 #version 110
2.1 1.20 #version 120
3.0 1.30 #version 130
3.1 1.40 #version 140
3.2 1.50 #version 150 core
3.3 3.30 #version 330 core
4.0〜4.6 4.00〜4.60 #version 400 core〜#version 460 core

3.3からは番号が単純に一致します。
coreはコアプロファイル、つまり古い非推奨の機能を含まない物という意味で、省略した場合も此れになります。
もう一つのcompatibilityではgl_FragColorの様な古い組み込み変数がまだ使えますが、macOSでは対応しておらず、此のシリーズでも使いません。

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  out_color = vec4(vUv, 0.0, 1.0);
}

OpenGL ES 及び WebGL

OpenGL ES用のシェーダーは、モバイルデバイスや組み込みシステムで使用される事を目的としており、WebGLはブラウザの中のOpenGL ESです。
此の方言はGLSL ESと呼ばれ、独自のバージョン番号を持ちます:

API GLSL ES 最初の行
OpenGL ES 2.0、WebGL 1 1.00 #version 100
OpenGL ES 3.0、WebGL 2 3.00 #version 300 es
OpenGL ES 3.1 3.10 #version 310 es
OpenGL ES 3.2 3.20 #version 320 es

GLSL ES 3.00はOpenGL Coreの物と僅かに異なるだけです。
主な違いはヘッダー部分、つまり番号の後のesと精度修飾子です:

#version 300 es
precision highp float;

in vec2 vUv;
out vec4 out_color;

void main() {
  out_color = vec4(vUv, 0.0, 1.0);
}

GLSL ESのフラグメントシェーダーではfloatにデフォルトの精度が無いので、自分で選ぶ必要があります(highp、mediump、lowp。2.15節を参照)。
precisionの行を忘れると、コンパイラーは次の様なエラーで止まります:

0:3(1): error: No precision specified in this scope for type `vec2'

古いGLSL ES 1.00(OpenGL ES 2.0及びWebGL 1)は、inとoutが出来る前の物なので、見た目がもっと違います:

#version 100
precision mediump float;

varying vec2 vUv;

void main() {
  gl_FragColor = vec4(vUv, 0.0, 1.0);
}

  • 頂点シェーダーからの入力はvaryingで宣言します(頂点シェーダー側でも出力としてvaryingを使います)。頂点の入力はattributeです。
  • ユーザー定義の出力はありません。フラグメントシェーダーは組み込み変数のgl_FragColorに書き込みます。
  • テクスチャはtexture()ではなくtexture2D()で読みます。
  • forループは定数の範囲でしか動作が保証されず、整数が本物の32ビット整数である保証もありません。

GLSL ES 3.00では、此れらは全てin、out、そしてout_colorの様なユーザー定義の出力に置き換えられました。
直ぐにぶつかる違いがもう一つあります。
GLSL ESは型を自動的に変換しないので、float x = 1;は其処ではエラーになりますが、デスクトップのGLSLでは通ります(2.4節)。

Vulkan

此れはOpenGL Core 4.50以降の修正版で、Vulkan固有のルールが含まれています。
然し、上記とは異なり、VulkanはGLSLのソースを受け取りません。
使用する前に、例えばglslangValidator -V shader.frag -o frag.spv又はglslc shader.frag -o frag.spvでSPIR-Vにコンパイルする必要があります。
興味深い事に、一度コンパイルされると、SPIR-VをGLSLやHLSL、MSLに戻す為のツール(SPIRV-Cross等)も利用可能です。
同じ事を他の2つの主要なシェーディング言語でどう書くのかを見るのに、とても良い方法です。

OpenGL Core:

#version 450 core

in vec2 vUv;
out vec4 out_color;

uniform vec3 colorA;
uniform vec3 colorB;

void main() {
  out_color = vec4(mix(colorA, colorB, vUv.x), 1.0);
}

Vulkan:

#version 450

layout(location = 0) in vec2 vUv;
layout(location = 0) out vec4 out_color;

layout(set = 0, binding = 0) uniform Colors {
  vec3 colorA;
  vec3 colorB;
};

void main() {
  out_color = vec4(mix(colorA, colorB, vUv.x), 1.0);
}

  • 全ての入力と出力に、明示的なlayout(location = N)が必要です。
  • ユニフォームを単独で置く事は出来ません。ディスクリプタのsetとbindingを持つユニフォームブロックの中か、push_constantブロックの中に入れる必要があります。
  • 一部の組み込み変数は名前が違います。例えばgl_VertexIDとgl_InstanceIDの代わりに、gl_VertexIndexとgl_InstanceIndexです。

Vulkan版をあたし達のOpenGLのテスターで読み込むと、error: unrecognized layout identifier 'set'で失敗します。
OpenGLにはディスクリプタセットが存在しないからです。
set = 0を外せば、同じブロックがOpenGL 4.2以降で動きます。

ニンテンドーシステム

残念ながら、NDAの為に此れについて多くを語る事は出来ませんが、あたしの経験では、Vulkanで使用したシェーダーはNintendo Switchで修正せずに動作しました。

2.2 シェーダーの種類

シェーダーの種類は幾つかあります。
何かを描画するには頂点シェーダーとフラグメントシェーダーが必要で、残りは必要に応じて使用されます。

其々がどこで動くのかを理解する為に、Vulkanで使用されるグラフィックスパイプラインの画像を示します(OpenGLでも同じです):

グラフィックスパイプライン

グラフィックスパイプラインは、OpenGLシリーズと、其の後のVulkanシリーズで更に詳しく説明します。

頂点シェーダー

頂点シェーダーは、3Dモデルの各頂点を処理し、其の位置をモデル空間からクリップ空間に変換します(線型代数の第11章と第12章のモデル、ビュー、プロジェクション変換を適用)。
又、後の段階で使用する為の法線、色、テクスチャ座標等の頂点ごとの属性を計算する事も出来ます。

此れにより、3D座標を変換し、頂点ごとのライティングを計算し、テクスチャ座標をフラグメントシェーダーに渡します。
あたし達のテスターの頂点シェーダーは一番簡単な仕事をしていて、四角形の角を其のまま通すだけです。

テッセレーション制御シェーダー

テッセレーション制御シェーダーは、テッセレーションパイプラインの一部です。
パッチ(制御点の集まり)を処理し、テッセレーションのレベルを設定する事で、各パッチをどれだけ細かい三角形に分割するかを決め、テッセレーション評価シェーダーにデータを渡します。

此れにより、曲面(例:ベジェパッチ)や地形レンダリングの詳細レベルを制御します。
カメラに近い所は三角形を多く、遠い所は少なくします。

テッセレーション評価シェーダー

2つのテッセレーションシェーダーの間では、固定のハードウェア(テッセレーター)が新しい頂点を生成します。
テッセレーション評価シェーダーは其の1つ1つに対して実行され、パッチから最終的な位置と属性を計算します。
例えば、ハイトマップで上下に動かす事が出来ます。

此れにより、分割された表面の形状(例:滑らかな曲線や詳細な地形)を定義します。

注:テッセレーションはOpenGL 4.0(2010年)で導入された為、古いハードウェアは対応していません。macOS(4.1)では使えます。

ジオメトリシェーダー

ジオメトリシェーダーは、頂点及びテッセレーションの段階の後に、プリミティブ全体(点、線、三角形)に対して動作し、ジオメトリの修正、作成、又は破棄を可能にします。
新しい頂点を出力したり、プリミティブの種類を変更したり出来ます。

此れにより、点をパーティクル用の四角形に変えたり、シャドウボリュームの為にシルエットを押し出したり、デバッグ用にメッシュの法線を線として描いたりします。
実際のハードウェアでは遅い事が多い為、現代のエンジンは出来るだけ避けます。
其の理由は第15章で説明します。

フラグメントシェーダー

フラグメントシェーダーは、ラスタライゼーションによって生成された各ピクセル(正確には各フラグメント)を処理し、其の最終的な色を、必要なら深度も決定します。
テクスチャリング、ピクセルごとのライティング、後処理効果等のタスクを処理します。

此れにより、テクスチャを適用し、ライティング効果を計算し、色をブレンドし、フォグを適用します。
此のシリーズの殆ど全ては、フラグメントシェーダーの中で行われます。

コンピュートシェーダー

コンピュートシェーダーは、グラフィックスパイプラインに含まれない汎用シェーダーです。
GPU上で任意の計算(物理シミュレーション、画像処理、機械学習タスク等)を行います。

此れにより、パーティクルシミュレーション、流体力学、又はブラー等の後処理効果の様なタスクの並列処理に使用されます。

注:コンピュートシェーダーはOpenGL 4.3(2012年)で導入されました。macOSは4.1までなので、MacのOpenGLではコンピュートシェーダーは使えません。

種類 実行の単位 必要? 導入 macOS 此のシリーズ
頂点 頂点 はい OpenGL 2.0 可 第3、4、13章
テッセレーション制御 出力する制御点 いいえ OpenGL 4.0 可 第15章
テッセレーション評価 生成された頂点 いいえ OpenGL 4.0 可 第15章
ジオメトリ プリミティブ いいえ OpenGL 3.2 可 第15章
フラグメント フラグメント はい OpenGL 2.0 可 全ての章
コンピュート ワークアイテム 別扱い OpenGL 4.3 不可 第15章

新しいAPIには更に多くの段階があります。
メッシュシェーダー(とタスクシェーダー)は、頂点・テッセレーション・ジオメトリの段階をコンピュートに似た1つの段階で置き換え、レイトレーシングシェーダーはシーンの中に光線を飛ばします。
此れらはVulkanとDirectX 12にあり、OpenGLではメッシュシェーダーがNVIDIAの拡張機能として使えるだけなので、此処では扱いません。

2.3 シェーダーの構造

此処からは言語其の物を学びます。
先ずはテスターのフラグメントシェーダーを部分ごとに見てみましょう:

#version 450 core

in vec2 vUv;
out vec4 out_color;

uniform vec3 uColorA;
uniform vec3 uColorB;
uniform vec3 uColorC;

void main() {
  vec3 temp = mix(uColorA, uColorB, vUv.x);
  vec3 blendedColor = mix(temp, uColorC, vUv.y * 0.95);
  out_color = vec4(blendedColor, 1.0);
}

  • #version 450 coreは必ず最初の行でなければなりません(其の前に置けるのはコメントと空行だけです)。
  • in vec2 vUv;は入力です。頂点シェーダーが書き込んだ値を、此のピクセルの為に補間した物です。
  • out vec4 out_color;は出力です。此処に書いた物がピクセルの色になります。
  • uniform vec3 uColorA;はCプログラムから設定される値で、1回の描画呼び出しの中では全てのピクセルで同じです。
  • void main()はエントリーポイントです。どのシェーダーの段階にも、引数も戻り値も無いmainが丁度1つあり、in、out、uniform変数を通してだけやり取りします。

残りはCに似ています。
文は;で終わり、ブロックは{ }を使い、コメントは//と/* */です。
標準のGLSLには#include、ポインタ、文字列、malloc、printfはありません。
シェーダーは何も出力出来ないので、値を見る方法は其れを色にする事です。
此の章ではずっと其れをやっていきます。

例の試し方

以下の例は全て完全なフラグメントシェーダーです。
shader/fragment.glslに貼り付けて(Macの場合はshader/fragment.mac.glslに、最初の行を#version 410 coreにして)、第1章と同じ様にテスターを再起動して下さい。
例ではユニフォームを使いませんが、問題ありません。
第1章で見た通り、存在しないユニフォームを設定しても何も起きないからです。
終わったら、元のシェーダーを戻して下さい(上の2.3節にあります)。

2.4 スカラー型とリテラル

GLSLには5つのスカラー(1つの数値の)型があります:

型 保持する物 リテラルの例
bool true又はfalse true
int 32ビット符号付き整数 7、-3、0x1F
uint 32ビット符号無し整数 7u、0xFFu
float 32ビット浮動小数点数 1.0、0.5、1.5e3、2.0f
double 64ビット浮動小数点数(GLSL 4.00以降) 1.0lf

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  bool  isOn  = true;
  int   count = -3;
  uint  mask  = 255u;
  float speed = 2.5;
  double big  = 1.0lf;
  float e = 1.5e3;  // 1500.0
  out_color = vec4(speed);
}

99%の場合に使う型はfloatです。
doubleもありますが、ゲーム用のGPUではfloatより何倍も遅い事が多く、GLSL ESには存在しません。
小さな罠:Cと同じく、0で始まる整数リテラルは8進数なので、010は10ではなく8です。

整数か浮動小数点数か? 1/2の罠

GLSLでは1と1.0は別物です。
1はint、1.0はfloatで、演算子はCと全く同じ様に、受け取った型で計算します。
次のシェーダーを見て下さい:

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  float a = 1 / 2;      // int / int = 0、其の後0.0に変換
  float b = 1.0 / 2.0;  // float / float = 0.5

  float v = vUv.x < 0.5 ? a : b;  // 左半分:a、右半分:b
  out_color = vec4(v, v, v, 1.0);
}

左半分は黒、右半分は50%の灰色

左半分は灰色ではなく黒です。
1 / 2は余りを捨てる整数の割り算なので、結果は0です。
其の後で初めて、aの為にfloatの0.0に変換されます。
1.0 / 2.0は浮動小数点数の割り算で0.5になり、右側の50%の灰色になります。

デスクトップのGLSLは、必要な時にintをfloatに(及びintをuintに、全てをdoubleに)自動的に変換します。
其の為、float a = 1 / 2;がそもそもコンパイル出来ます。
逆方向には決して変換しないので、int i = 2.5;はエラーになり、int(2.5)と書く必要があります。
GLSL ESは全く変換しません。

目安:floatのつもりの数値は全て小数点付きで書きましょう:1.0、0.5、2.0。そうすれば、シェーダーはどこでも同じ様に動き、1/2の罠にも落ちません。

使えない名前

名前はCと同じく英字、数字、_で出来ていて、数字で始める事は出来ません。
gl_で始まる名前はGLSLの物で、アンダースコアが2つ続く名前も予約されています。
更にGLSLは将来の為に幾つかの単語を予約していて、其の中には使いたくなる単語もあります:filter、input、output、common、active、half、long、short。
(sampleも以前は此の一覧にありましたが、GLSL 4.00からは本物のキーワードなので、変数名には使えません。)
2.7節のカラーフィルターの例を最初に書いた時、あたしは変数をfilterと名付けて、次のエラーを貰いました:

0:8(7): error: illegal use of reserved word `filter'

2.5 ベクトルとコンストラクター

ベクトルはGLSLの心臓部です。
ベクトルは1つの値として扱う2つ、3つ、又は4つの数値の並びで、線型代数の第2章のベクトルと全く同じ物です。
位置、方向、色、UV座標は全てベクトルです。

成分の数 float int uint bool double
2 vec2 ivec2 uvec2 bvec2 dvec2
3 vec3 ivec3 uvec3 bvec3 dvec3
4 vec4 ivec4 uvec4 bvec4 dvec4

ベクトルはコンストラクター、つまり関数の様に使う型名で作ります。
引数は左から順に成分を埋めるのに使われ、引数の中のベクトルは展開されます:

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  vec3 a = vec3(1.0);                 // (1, 1, 1)
  vec3 b = vec3(1.0, 2.0, 3.0);       // (1, 2, 3)
  vec4 c = vec4(b, 1.0);              // (1, 2, 3, 1)
  vec4 d = vec4(vUv, 0.0, 1.0);       // (u, v, 0, 1)
  vec2 e = vec2(c);                   // (1, 2):zとwは捨てられる
  ivec2 f = ivec2(2.7, -2.7);         // (2, -2):0の方向に切り捨て
  bvec3 g = bvec3(0.0, 1.0, 5.0);     // (false, true, true)
  out_color = d;
}

  • 数値が1つだけなら全ての成分を埋めます:vec3(1.0)は(1, 1, 1)です。
  • 其れ以外の場合、成分の数が丁度足りなければなりません。vec4(vUv, 0.0)は3つしか無いのでエラー(「too few components」)、vec2(1.0, 2.0, 3.0)もエラー(「too many parameters」)です。
  • 大きなベクトルが1つだけなら短く出来ます:vec2(c)は最初の2つの成分を残します。
  • コンストラクターは変換も行います:int(2.7)は2、int(-2.7)は−2(小数部分を0の方向に切り捨て)、float(3)は3.0、bool(0.0)はfalseで其れ以外は全てtrueです。

此のシェーダーはd、つまりUV座標其の物を色として書き込みます。
赤がu(左が0、右が1)、緑がv(下が0、上が1)です:

色にしたUV:左下は黒、右下は赤、左上は緑、右上は黄色

此れがシェーダープログラミングで一番役に立つデバッグ用の画像です。
値がどうなっているか分からない時は、何時でも其れを色にしましょう。
黒が(0, 0)、赤が(1, 0)、緑が(0, 1)、そして赤と緑を足した黄色が(1, 1)です。

2.6 スウィズル

ベクトルの成分を読むには、ドットと成分の名前を書きます。
同じ4つの成分に3組の名前があるので、コードでベクトルの意味を表す事が出来ます:

  • 位置と方向にはx y z w
  • 色にはr g b a
  • テクスチャ座標にはs t p q

面白いのは、複数の成分を好きな順番で、しかも繰り返して一度に選べる事です。
此れをスウィズルと言い、結果は新しいベクトルになります:

スウィズル:v.bgrは最初の3つの成分を逆にし、v.wwはwを繰り返す

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  vec4 v = vec4(1.0, 2.0, 3.0, 4.0);
  vec3 a = v.xyz;    // (1, 2, 3)
  vec3 b = v.bgr;    // (3, 2, 1)
  vec2 c = v.ww;     // (4, 4)
  vec4 d = v.xxyy;   // (1, 1, 2, 2)
  float e = v.q;     // 4
  out_color = d;
}

ルールは短いです:

  • 名前は最大4つで、全て同じ組から選びます:v.xgはエラー(「invalid swizzle」)です。
  • 存在する成分だけ:vec2に.zはありません。
  • 読む時は同じ成分を繰り返せます(v.xxx)が、書く時は出来ません:v.xx = vec2(2.0);はエラーです。どちらの値を残すべきか決まらないからです。

本物の画像でスウィズルしてみましょう。
此れはテスターの最初の版にあった、左が赤で右が緑の2色のグラデーションです:

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  vec3 red = vec3(1.0, 0.0, 0.0);
  vec3 green = vec3(0.0, 1.0, 0.0);
  vec3 col = mix(red, green, vUv.x);

  out_color = vec4(col, 1.0);
}

mix(a, b, t)はaからbへ混ぜ合わせます:mix(𝐚,𝐛,t)=𝐚(1−t)+𝐛t。
従ってt = 0ならa、t = 1ならbになります(詳しくは第3章で見ます)。
では、最後の行だけを変えて、赤と青を入れ替えてみましょう:

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  vec3 red = vec3(1.0, 0.0, 0.0);
  vec3 green = vec3(0.0, 1.0, 0.0);
  vec3 col = mix(red, green, vUv.x);

  out_color = vec4(col.bgr, 1.0);  // 逆順:(b, g, r)
}

左:赤から緑へのグラデーション。右:同じ物に.bgrを付けた、青から緑へのグラデーション

左の色は(1−u,u,0)です。
col.bgrは其れを逆から読んで(0,u,1−u)になるので、赤の部分が青のチャンネルに移り、左側が青くなります。

書き込みマスク

=の左側のスウィズルは、其の成分だけに書き込み、他の成分には触りません。
此れを書き込みマスクと言います:

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  vec4 c = vec4(0.0);  // (0, 0, 0, 0)
  c.rg = vUv;          // 赤と緑だけに書き込む
  c.b = 1.0 - vUv.x;   // 青は左に行く程明るくなる
  c.a = 1.0;
  out_color = c;
}

書き込みマスク:左下は青、右下は赤、左上はシアン、右上は黄色

vUv = (0.25, 0.5)のピクセルでは、cは(0, 0, 0, 0)から(0.25, 0.5, 0, 0)、次に(0.25, 0.5, 0.75, 0)、最後に(0.25, 0.5, 0.75, 1)になります。
マスクも好きな順番で書けます:v.zy = vec2(3.0, 2.0);はzに3、yに2を書き込みます。

2.7 演算子

GLSLにはCの演算子があり、ベクトルに対しては成分ごとに計算します:

[123]+[456]=[579][123]∗[456]=[1⋅42⋅53⋅6]=[41018]

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  vec3 a = vec3(1.0, 2.0, 3.0);
  vec3 b = vec3(4.0, 5.0, 6.0);
  vec3 s = a + b;      // (5, 7, 9)
  vec3 p = a * b;      // (4, 10, 18):成分ごと!
  vec3 k = a * 2.0;    // (2, 4, 6)
  vec3 q = b / a;      // (4, 2.5, 2)
  vec3 n = -a;         // (-1, -2, -3)
  bool same = (a == b);              // false:ベクトル全体で1つのbool
  bvec3 less = lessThan(a, b);       // (true, true, true)
  bool anyBig = any(greaterThan(b, vec3(5.5)));  // true
  bool allPos = all(greaterThan(a, vec3(0.0)));  // true
  out_color = vec4(p, 1.0);
}

2つのベクトルのa * bは、線型代数の内積でも外積でもない事に注意して下さい。
此れは成分ごとの積(アダマール積とも言います)です。
内積と外積は関数で、dot(a, b)とcross(a, b)です。
ベクトルとスカラーを組み合わせると、スカラーが全ての成分に適用されるので、a * 2.0は全てを2倍にします。

成分ごとの積は、色の為に丁度欲しい物です。
色に別の色を掛けると、ランプの前のカラーフィルターの様に働き、各チャンネルが別々に拡大縮小されます。

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  vec3 col = vec3(vUv, 0.0);              // UVの色
  vec3 tint = vec3(1.0, 0.5, 1.0);        // 緑のチャンネルを半分に
  col = col * tint + vec3(0.0, 0.0, 0.3);  // そして青を少し足す

  out_color = vec4(col, 1.0);
}

半分の緑と少しの青を足したUVの色:左下は暗い青、右上はサーモン色

vUv = (0.5, 0.8)では、colは(0.5, 0.8, 0)で、(1, 0.5, 1)を掛けると(0.5, 0.4, 0)、(0, 0, 0.3)を足すと(0.5, 0.4, 0.3)のくすんだ茶色になります。
2.5節のUVの画像と比べると、緑の角はずっと暗くなり、全てのピクセルに少し青が入っています。

比較

<、>、<=、>=はスカラーにしか使えません。
2つのベクトルのa < bはエラー(「operands to relational operators must be scalar」)です。
==と!=はベクトルにも使えますが、ベクトル全体で1つのboolを返し、全ての成分が等しい時だけtrueになります。
成分ごとの比較には、bvecを返す関数があります:

  • lessThan、lessThanEqual、greaterThan、greaterThanEqual、equal、notEqualは成分ごとに比較します。
  • any(bv)は少なくとも1つの成分がtrueならtrue、all(bv)は全てがtrueならtrue、not(bv)は其々を反転します。

整数の演算子

intとuint(及び其のベクトル)には、Cと同じく幾つかの演算子が追加されています:

  • %は余りです:7 % 3は1です。整数にしか使えず(7.0 % 2.0はエラーです。floatにはmod関数があります、第7章)、負の数での結果は未定義なので、両辺を正に保ちましょう。
  • &、|、^、~、<<、>>はビット演算子です(論理積、論理和、排他的論理和、否定、シフト)。第8章のハッシュで必要になります。
  • 整数の割り算は0の方向に切り捨てます:7 / 2は3、-7 / 2は−3です。

boolには&&、||、!と、Cには無い^^(論理の排他的論理和)があります。

2.8 行列

行列はもう一つの大きな部品で、線型代数の第6章と全く同じ様に動きます:

  • mat2、mat3、mat4は、2行2列、3行3列、4行4列のfloatの正方行列です。
  • matCxRはC列R行です:mat2x3は2列3行です。順番に注意して下さい:列が先です。(mat4x4はmat4と同じです。)
  • dmat2からdmat4はdoubleを持ちます。整数の行列はありません。

列優先:コンストラクターは列を埋める

GLSLは行列を列ごとに保存し、コンストラクターも其の順番で埋めます。
mat3のコンストラクターの3つずつの数値の組は、行ではなく1つの列です:

mat3のコンストラクターは行列を列ごとに埋める:m[0]は(1, 2, 3)

従って、mat3(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0)は次の行列です:

𝐌=[147258369]

頭の中の行列の形のまま(1行ずつ改行して)数値を書くと、其の転置行列が出来てしまいます。
此れがGLSLで一番よくある行列のバグです。

添字も同じ順番です:m[i]はベクトルとしての列iで、m[col][row]が1つの数値です:

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  mat3 m = mat3(
    1.0, 2.0, 3.0,  // 列0
    4.0, 5.0, 6.0,  // 列1
    7.0, 8.0, 9.0   // 列2
  );
  vec3 c1 = m[1];     // 列1:(4, 5, 6)
  float e = m[1][0];  // 列1、行0:4
  m[2][2] = 0.0;      // 列2、行2:9が0になる

  mat4 I = mat4(1.0);            // 単位行列(対角成分が1)
  mat3 r = mat3(I);              // Iの左上の3x3
  mat2x3 t = mat2x3(1.0);        // 2列3行
  vec3 v = vec3(1.0, 0.0, 0.0);
  vec3 a = m * v;                // 行列とベクトルの積:列0 = (1, 2, 3)
  vec3 b = v * m;                // 行ベクトルと行列の積:(1, 4, 7)
  mat3 mm = m * m;               // 行列の積
  mat3 cw = matrixCompMult(m, m);  // 要素ごとの積
  out_color = vec4(a + b, 1.0);
}

数学の記法での要素m12(1から数えて1行2列)は、GLSLではm[1][0]です。
列の添字が先で、どちらも0から数えます。
数値が1つなら対角行列になり(mat4(1.0)は単位行列)、大きな行列から作ると其の左上の部分を取ります。

掛け算は本物の行列の積

ベクトルとは違い、行列の*は成分ごとではなく、線型代数の本物の行列の積です:

  • m * v:行列と列ベクトルの積、𝐌𝐯。変換に使うのは此れです。
  • v * m:ベクトルを行ベクトルとして行列に掛けた物で、𝐌⊤𝐯と同じです(線型代数の第7章)。
  • m * m:行列の積。
  • matrixCompMult(a, b):要素ごとの積。必要になる事があれば。

サイズは合っていなければなりません:mat3とvec4の積はエラー(「size mismatch for matrix multiplication」)です。
線型代数の第6章で見た様に、𝐌𝐯は𝐯の成分で重み付けした列の和です:

𝐌𝐯=vx𝐜0+vy𝐜1+vz𝐜2

つまり、列0はx成分の行き先、列1はyの行き先、列2はzの行き先を表します。
色の場合、x、y、zは赤、緑、青なので、面白い実験が出来ます。
赤を緑へ、緑を青へ、青を赤へ移すカラー行列です。

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  vec3 red = vec3(1.0, 0.0, 0.0);
  vec3 green = vec3(0.0, 1.0, 0.0);
  vec3 col = mix(red, green, vUv.x);

  // 3つずつの数値の組が1つの「列」
  mat3 m = mat3(
    0.0, 1.0, 0.0,  // 列0:赤の行き先(緑へ)
    0.0, 0.0, 1.0,  // 列1:緑の行き先(青へ)
    1.0, 0.0, 0.0   // 列2:青の行き先(赤へ)
  );

  if (vUv.y > 0.5) {
    col = m * col;  // 上半分:行列と列ベクトルの積
  } else {
    col = col * m;  // 下半分:行ベクトルと行列の積
  }
  out_color = vec4(col, 1.0);
}

上半分は緑から青、下半分は青から赤

colが純粋な赤(1, 0, 0)になる左端を確かめてみましょう。
上半分:𝐌𝐯=1⋅𝐜0+0⋅𝐜1+0⋅𝐜2=(0,1,0)で、列0の通り緑です。
下半分:col * mは𝐌⊤𝐯で、其の成分はcolと各列の内積です:(𝐯⋅𝐜0,𝐯⋅𝐜1,𝐯⋅𝐜2)=(0,0,1)で、青です。
2つの順番は本当に違う結果になります。
其の為、第13章の変換行列では「正しい順番で掛ける」事がとても大事になります。

2.9 配列と構造体

配列はCと同じく固定サイズで、コンストラクターでも作れます。
.length()で要素の数が分かります:

#version 450 core

in vec2 vUv;
out vec4 out_color;

const vec3 palette[4] = vec3[4](
  vec3(0.91, 0.12, 0.39),  // ピンク
  vec3(1.00, 0.76, 0.03),  // 黄色
  vec3(0.30, 0.69, 0.31),  // 緑
  vec3(0.13, 0.59, 0.95)   // 青
);

void main() {
  int i = int(vUv.x * 4.0);  // 0、1、2、又は3
  i = min(i, 3);             // 絶対に末尾を超えて読まない
  out_color = vec4(palette[i], 1.0);
}

4本の縦の縞:ピンク、黄色、緑、青

vUv.x * 4.0は0から4未満まで変わり、int()が小数部分を切り捨てるので、ウィンドウの4分の1ごとに1つの添字が割り当てられます。
例えばvUv.x = 0.3では0.3×4=1.2、int(1.2)は1で、黄色です。
min(a, b)は2つの値の小さい方を返すので、min(i, 3)はvUv.xが丁度1.0になったとしても添字が4にならない様にします。
配列の外を読んでもシェーダーはクラッシュしません。
結果は未定義で、ゴミか0が返るので、見付けるのがずっと難しくなります。

構造体はCと同じく値をまとめ、コンストラクターが自動的に付いてきます:

#version 450 core

in vec2 vUv;
out vec4 out_color;

struct Light {
  vec3 color;
  float intensity;
};

void main() {
  float weights[3] = float[3](0.25, 0.5, 0.25);
  float w[] = float[](1.0, 2.0);   // サイズは初期化子から決まる
  int n = weights.length();        // 3

  Light sun = Light(vec3(1.0, 0.9, 0.7), 2.0);
  vec3 lit = sun.color * sun.intensity;

  Light lights[2];
  lights[0] = sun;
  lights[1].color = vec3(0.2, 0.3, 1.0);
  lights[1].intensity = 0.5;
  out_color = vec4(lit * weights[1], 1.0);
}

第10章の複数の光源では、丁度此の様な構造体の配列を使います。

2.10 修飾子

変数の前の修飾子は、其の値がどこから来て、誰が変更出来るかを表します。
此のシリーズで出てくるのは次の物です:

修飾子 意味
(無し) 普通のローカル変数又はグローバル変数
const 定数:初期化が必須で、決して変更出来ない
in 此の段階の入力:頂点シェーダーでは頂点属性、フラグメントシェーダーでは頂点シェーダーから補間された値
out 此の段階の出力:次の段階へ、フラグメントシェーダーではフレームバッファに行く色
uniform Cプログラムから設定され、1回の描画呼び出しの全ての頂点とピクセルで同じ、読み取り専用
layout(location = N) in又はoutに固定の番号を付ける
flat、smooth、noperspective 頂点シェーダーのoutをどう補間するか

#version 450 core

in vec2 vUv;
layout(location = 0) out vec4 out_color;

const float PI = 3.14159265;
uniform float uTime;
uniform vec3 uTint = vec3(1.0);   // デフォルト値(デスクトップのGLSLのみ)

layout(location = 1) out vec4 out_extra;

void main() {
  const int steps = 4;
  out_color = vec4(uTint * PI, 1.0);
  out_extra = vec4(float(steps));
}

  • 頂点入力のlayout(location = N)は、CでglVertexAttribPointerに渡す番号です。あたし達の頂点シェーダーにはlayout(location = 0) in vec2 aPosition;とlayout(location = 1) in vec2 aUv;があり、main.cの0と1に一致します。
  • フラグメントシェーダーの出力では、どのカラーバッファに書くかを選びます。出力が1つなら、ロケーション0(デフォルト)がウィンドウです。上のout_extraの様な追加の出力は、複数の画像に同時に描画する時にだけ意味があります。
  • constやuniformに代入するとコンパイルエラー(「assignment to read-only variable」)になります。
  • ユニフォームにはデフォルト値を付けられ、Cプログラムが設定するまで其の値が使われます。此れはデスクトップのGLSLだけで、GLSL ESとVulkanでは出来ません。
  • デフォルト(smooth)では、ラスタライザーは頂点シェーダーの全てのoutを三角形全体に渡って補間します。flatは補間を止めて1つの頂点の値を使います。補間された整数には意味が無いので、intとuintの出力はflatでなければなりません。補間については第3章で詳しく見ます。

2.11 関数

関数はCの関数と同じ見た目です。
使う前に宣言されている必要があり、上で定義するか、プロトタイプを書きます:

#version 450 core

in vec2 vUv;
out vec4 out_color;

float brightness(vec3 c);   // プロトタイプ:後で定義する

void split(in vec3 c, out float lo, out float hi) {
  lo = min(c.r, min(c.g, c.b));
  hi = max(c.r, max(c.g, c.b));
}

void clampInPlace(inout vec3 c) {
  c = clamp(c, 0.0, 1.0);
}

float twice(float x) { return 2.0 * x; }
vec3 twice(vec3 v) { return 2.0 * v; }   // オーバーロード

void main() {
  vec3 col = vec3(vUv, 0.5);
  float lo, hi;
  split(col, lo, hi);
  clampInPlace(col);
  out_color = vec4(twice(col) * brightness(col), 1.0);
}

float brightness(vec3 c) {
  return (c.r + c.g + c.b) / 3.0;
}

GLSLにはポインタも参照も無いので、引数はコピーで渡され、修飾子が其の方向を決めます:

  • in(デフォルト):値が関数の中にコピーされます。中で変更しても呼び出し側の変数は変わりません。
  • out:何も入って来ず(最初の値は未定義)、関数が戻る時に最後の値が呼び出し側にコピーされます。上のloとhiの様に、関数が複数の値を返す方法です。
  • inout:コピーされて入り、コピーされて戻るので、関数が呼び出し側の変数を変更出来ます。

関数はオーバーロード出来ます。
引数の型が違う2つのtwice関数は問題無く、コンパイラーは引数の型で選びます。
組み込み関数がfloat、vec2、vec3、vec4で動くのも同じ仕組みです。
出来ないのは再帰です。
関数は自分自身を、直接でも他の関数を通してでも呼び出せません(「function has static recursion」)。
GPUには其の為のコールスタックが無いからです。

max(a, b)はminの逆で、2つの値の大きい方です。
clamp(x, a, b)はxをaとbの間に収めます:clamp(x,a,b)=min(max(x,a),b)。
どちらもベクトルでは成分ごとに動きます。

inout引数を使った、目に見える小さな例です:

#version 450 core

in vec2 vUv;
out vec4 out_color;

// aとbの間の色を返す
vec3 gradient(vec3 a, vec3 b, float t) {
  return mix(a, b, t);
}

// cを其の場で変更する:amountが0なら其のまま、1なら黒
void darken(inout vec3 c, float amount) {
  c = c * (1.0 - amount);
}

void main() {
  vec3 col = gradient(vec3(1.0, 0.0, 0.0), vec3(0.0, 1.0, 0.0), vUv.x);
  darken(col, vUv.y);  // 上に行く程暗くなる
  out_color = vec4(col, 1.0);
}

赤から緑へのグラデーションが上に向かって黒くなる

一番下(vUv.y = 0)では色は其のままで、一番上では殆ど0が掛けられます。
ウィンドウの真ん中では(0.5,0.5,0)×(1−0.5)=(0.25,0.25,0)の暗いオリーブ色です。

2.12 制御構文

if/else、for、while、do/while、switch、break、continue、returnはCと同じ様に動き、?:演算子も同じです。
gotoはありません。
そして、フラグメントシェーダーにだけある文が1つあります。
discardは今のフラグメントを捨てるので、此のピクセルには何も書き込まれません。

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  int bar = int(vUv.x * 10.0);  // 10本の棒のどれか:0から9

  float height = 0.0;
  for (int i = 0; i <= bar; i++) {
    height += 0.1;  // 棒0:0.1、棒1:0.2、…棒9:1.0
  }

  if (vUv.y > height) {
    discard;  // 棒より上:何も書かない
  }

  vec3 col;
  if (bar % 2 == 0) {
    col = vec3(1.0, 0.85, 0.3);
  } else {
    col = vec3(0.95, 0.45, 0.2);
  }
  out_color = vec4(col, 1.0);
}

左から右へ階段の様に高くなる10本の棒、黄色とオレンジが交互、上は黒

各ピクセルは自分がどの棒にいるかを計算し、自分の棒まで1本ごとに0.1を足し、棒より上なら自分を捨てます。
棒の上の黒は、あたし達が描いた物ではありません。
main.cのglClearColorで設定したクリアカラーで、discardした所に見えています。
bar % 2で色が交互になります。

switchは整数に使い、Cと同じくbreakが必要です:

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  vec3 col = vec3(0.0);

  if (vUv.x < 0.5) {
    col.r = 1.0;
  } else if (vUv.y < 0.5) {
    col.g = 1.0;
  } else {
    col.b = 1.0;
  }

  for (int i = 0; i < 4; i++) {
    if (i == 2) continue;  // i = 2を飛ばす
    col *= 0.9;
  }

  int k = 0;
  while (k < 3) {
    k++;
  }

  do {
    k--;
  } while (k > 0);

  int mode = int(vUv.y * 3.0);
  switch (mode) {
    case 0:
      col += vec3(0.1);
      break;
    case 1:
      col += vec3(0.2);
      break;
    default:
      col += vec3(0.3);
      break;
  }

  float v = vUv.x > 0.5 ? 1.0 : 0.0;  // 三項演算子
  out_color = vec4(col * v, 1.0);
}

GPUでの分岐

GPUは各ピクセルを完全に別々に実行している訳ではありません。
ピクセルをグループ(通常32又は64個で、ワープやウェーブフロントと呼ばれます)にまとめて、同じ命令を同時に実行します。
グループの全てのピクセルがifの同じ側を通るなら、全て速いです。
一部が片方へ、残りがもう片方へ行くと、グループは両方の側を実行し、各ピクセルは自分が通らなかった側を無視します。
従って、近くのピクセルの結果が揃っていれば分岐はタダで(条件が棒の境目でしか変わらない、あたし達の棒の例の様に)、揃っていなければ倍の時間が掛かる事もあります。
シェーダーのifを恐れる必要はありませんが、両側の分の仕事を払う事があるのは覚えておいて下さい。

2.13 組み込み変数

自分のinとout変数の他に、各段階にはgl_で始まる組み込み変数が幾つかあります:

変数 段階 型 意味
gl_Position 頂点、出力 vec4 クリップ空間での頂点の位置(必ず書き込む)
gl_VertexID 頂点、入力 int 今の頂点の番号
gl_InstanceID 頂点、入力 int 複数のコピーを描く時の、今のインスタンスの番号
gl_PointSize 頂点、出力 float 点を描く時の点のサイズ
gl_FragCoord フラグメント、入力 vec4 x、y:ウィンドウ内のピクセルの位置、z:深度、w:クリップ空間のwの逆数
gl_FrontFacing フラグメント、入力 bool 三角形がカメラの方を向いていればtrue
gl_FragDepth フラグメント、出力 float フラグメントの深度を上書きする
gl_PointCoord フラグメント、入力 vec2 点の中での位置、0から1

あたし達の頂点シェーダーはgl_Position = vec4(aPosition, 0.0, 1.0);と書き込みます。
クリップ空間とw成分は線型代数の第12章で見た物です。
w = 1.0なので、書き込んだxとyは其のまま−1から1の正規化デバイス座標になります。
フラグメントシェーダーのgl_FragColorは此の表にありません。
コアプロファイルから削除された為、代わりに自分のout vec4 out_colorに書き込みます。
gl_FragDepthへの書き込みは動きますが、大抵GPUの早期深度テストを無効にしてしまうので、必要な時だけにしましょう。

あたし達にとって一番役に立つのはgl_FragCoordです。
其のxyはウィンドウ内のピクセルの位置をピクセル単位で表し、vUvと同じく(0, 0)は左下の角です。
ピクセルの中心を指すので、左下のピクセルは(0.5, 0.5)、800 × 600のウィンドウの右上のピクセルは(799.5, 599.5)です:

vUvはウィンドウ全体で0から1、gl_FragCoordは0から800と0から600ピクセル、ピクセルの中心は.5

vUvは描く四角形に依存し、gl_FragCoordはウィンドウだけに依存します。
ピクセル単位なので、市松模様の様な、ピクセルで決まったサイズの模様に打って付けです:

#version 450 core

in vec2 vUv;
out vec4 out_color;

void main() {
  ivec2 cell = ivec2(gl_FragCoord.xy) / 50;  // 50x50ピクセルのマス
  bool even = (cell.x + cell.y) % 2 == 0;

  vec3 col = even ? vec3(0.95) : vec3(0.15);
  out_color = vec4(col, 1.0);
}

16 × 12マスの市松模様、1マス50ピクセル

(125.5, 75.5)のピクセルはivec2(125, 75)になり、整数の割り算でマス(2, 1)になります。
2+1=3は奇数なので暗い色です。
隣のマスとはxかyが必ず1違うので、色は両方向に交互になります。

注:RetinaディスプレイのMacでは、ウィンドウのフレームバッファはウィンドウのサイズの2倍のピクセルを持つので、gl_FragCoordは1600 × 1200まで行き、マスは半分の大きさに見えます。其の対処法は第5章で説明します。

2.14 組み込み関数

GLSLには大きな数学関数のライブラリが付いていて、殆ど全てがfloatと、成分ごとにvec2、vec3、vec4で動きます。
速い(多くはGPUの1命令)ので、自分で書かずに此れらを使いましょう。
一番大事な物と、其れを最初に使う章を挙げます。
其の章で、絵と一緒にもう一度説明します。

関数 計算する物 説明する章
min(a, b)、max(a, b) 小さい方/大きい方の値 2
clamp(x, a, b) min(max(x,a),b)、xをaとbの間に収める 2
mix(a, b, t) a(1−t)+bt、aからbへ混ぜる 2、3
abs(x)、sign(x) |x|、及び−1、0、1 3、6
floor(x)、ceil(x) ⌊x⌋、⌈x⌉ 7
fract(x) x−⌊x⌋、小数点以下の部分 5、7
mod(x, y) x−y⌊x/y⌋ 7
step(e, x) xがeより小さければ0、其れ以外は1 6
smoothstep(e0, e1, x) t2(3−2t)、但しt=clamp(x−e0e1−e0,0,1) 3、6
sin、cos、tan、asin、acos、atan 三角関数、ラジアン 3、7
radians(d)、degrees(r) π180dと180πr 3
pow(x, y)、sqrt(x)、inversesqrt(x) xy、x、1/x 9、10
exp、log、exp2、log2 ex、lnx、2x、log2x 6、14
length(v)、distance(a, b) ‖𝐯‖、‖𝐚−𝐛‖ 3、6
dot(a, b) 𝐚⋅𝐛 3、4
cross(a, b) 𝐚×𝐛(vec3のみ) 12、14
normalize(v) 𝐯/‖𝐯‖ 4
reflect(i, n) 𝐢−2(𝐧⋅𝐢)𝐧 9
transpose(m)、inverse(m)、determinant(m) 𝐌⊤、𝐌−1、det𝐌 13
lessThan、equal、any、all等 成分ごとの比較 2
texture(s, uv)、texelFetch、textureSize テクスチャから読む 11
dFdx、dFdy、fwidth 隣のピクセルとの間で値がどれだけ変わるか 6、12
floatBitsToUint、uintBitsToFloat 数値のビットを別の型として解釈し直す —

数学は線型代数シリーズと同じなので、length、dot、cross、normalizeは線型代数の第3章から第5章の説明通りに動きます。
lengthは関数でlength(v)ですが、配列の.length()は要素の数である事に注意して下さい。

2.15 精度と数値の落とし穴

精度修飾子

GLSL ESでは全てのfloatに精度があります:highp(本物の32ビットfloat)、mediump(多くのモバイルGPUでは10進数で約3桁の16ビットfloat)、lowp(0から1の色には十分)。
mediumpは速くて電力も少なく、スマホでは大事ですが、直ぐに足りなくなります。
16ビットfloatは65504より大きな数を保持出来ず、1000の次に保存出来る数は1000.5です。
デスクトップのGLSLでは、同じコードがコンパイル出来る様に此れらの修飾子を書く事は出来ますが、何もしません:

#version 450 core

in vec2 vUv;
out vec4 out_color;

precision highp float;   // デスクトップでは書けるが、何もしない
highp vec2 hp;
mediump float mp;
lowp vec4 lp;

void main() {
  out_color = vec4(vUv, 0.0, 1.0);
}

floatは正確ではない

32ビットのfloatの有効数字は10進数で約7桁です。
シェーダープログラマーが何時もぶつかる結果が2つあります:

  • 和はずれていきます。 上の棒のシェーダーで0.1を10回足すと、1.0ではなく1.0000001になります。0.1を正確に保存出来ないからです。floatを==で比較せず、小さな範囲で比較しましょう。
  • 大きな数では小さな刻みが消えます。 65536より上では、隣り合う2つのfloatの間隔は2−7=0.0078125です。ゲームが時間を秒で渡していて、1日(86,400秒)動き続けていると、時間は約0.008の刻みでしか変われず、sin(time * 20.0)の様なアニメーションがカクカクし始めます。其の為、ゲームは時間の値をリセットしたり一周させたりします。第8章の乱数でも同じ問題に出会います。

其の他の未定義の物

  • 0で割ってもシェーダーはクラッシュしませんが、結果は未定義です。floatでは大抵無限大かNaN(「not a number」、非数)、整数ではゴミになります。
  • 負の数のsqrt、0以下のlog、xが負のpow(x, y)、−1から1の外でのasin/acosも未定義です。NaNは触れた全ての計算に広がり、黒やチラつくピクセルとして現れる事が多いです。
  • 負の数での%と、32ビット以上のシフトは未定義です。

シェーダーに黒い点が出たりチラついたりしたら、先ずNaNか0での割り算を疑いましょう。

2.16 プリプロセッサー

GLSLはコンパイルの前に、Cと同じ様に動くプリプロセッサーを実行します:

  • #define NAME valueと引数付きのマクロ、#undef。
  • コードを含めたり外したりする#if、#ifdef、#ifndef、#elif、#else、#endif。
  • メッセージ付きで止める#error、#pragma、#line、そして拡張機能を有効にする#extension。
  • 定義済みの物:__VERSION__(例:450)、__LINE__、コアプロファイルでのGL_core_profile、GLSL ESでのGL_ES。

標準のGLSLには#includeは無く(glslangの様な一部のコンパイラーは拡張機能として提供しています)、文字列もありません。

#version 450 core
#define STRIPES 8
#define USE_UV_COLOR 1

in vec2 vUv;
out vec4 out_color;

void main() {
#if USE_UV_COLOR
  vec3 col = vec3(vUv, 0.0);
#else
  vec3 col = vec3(1.0);
#endif

  int stripe = int(vUv.x * float(STRIPES));
  if (stripe % 2 == 1) {
    col *= 0.3;
  }
  out_color = vec4(col, 1.0);
}

8本の縞に分けたUVの色、1本おきに暗くしてある

USE_UV_COLORを0にすると縞は白と暗い灰色になり、STRIPESを4にすると4本の太い縞になります。
float(STRIPES)に注意して下さい。
STRIPESはintである8という文字に置き換えられるので、floatと掛ける前に変換しています(デスクトップのGLSLなら自動で変換しますが、GLSL ESはしません)。

他の書き方も幾つか挙げます。
全て有効です:

#version 450 core
#define PI 3.14159265
#define SQUARE(x) ((x) * (x))
#define QUALITY 2

in vec2 vUv;
out vec4 out_color;

void main() {
#ifdef GL_core_profile
  float a = 1.0;
#else
  float a = 0.0;
#endif

#if QUALITY >= 2
  float s = SQUARE(vUv.x + 1.0);
#elif QUALITY == 1
  float s = vUv.x;
#else
  float s = 0.0;
#endif

#if __VERSION__ < 410
#error "This shader needs GLSL 4.10 or newer"
#endif
  out_color = vec4(s * a / PI);
}

Cと同じく、マクロの引数は括弧で囲みましょう。
括弧が無いと、SQUARE(vUv.x + 1.0)はvUv.x + 1.0 * vUv.x + 1.0になってしまいます。

2.17 実際のゲームではどう使われているか

  • ウーバーシェーダーとパーミュテーション。 エンジンは沢山の#ifブロック(法線マップの有無、影の有無、光源の数等)を持つ1つの大きなシェーダーを書き、C++のコードがソースの前に追加する#defineを変えて何度もコンパイルします。其の結果の1つ1つがシェーダーパーミュテーションで、大きなゲームには何万個もあり、シェーダーのコンパイルに時間が掛かる大きな理由の1つです。
  • ベクトルのチャンネルにデータを詰める。 スウィズルのお陰で、1つのvec4に複数の値を安く保存出来ます。よくあるテクスチャの構成では、アンビエントオクルージョン、ラフネス、メタルネスを1枚のテクスチャのr、g、bチャンネルに入れ(ORMテクスチャと呼ばれる事が多いです)、シェーダーは.r、.g、.bで読みます。
  • カラー行列。 カラーグレーディング、色覚特性のシミュレーション、ゲームの「セピア」や「暗視」のフィルターは、2.8節の様に色にmat3やmat4を掛けるだけの事が多いです。
  • クロスコンパイル。 複数のAPIに対応するエンジンは、1つのシェーディング言語で書いて翻訳します。glslangはGLSLをSPIR-Vに、SPIRV-CrossはSPIR-VをGLSL ES、HLSL、MSLに変換します。其の為、1つしか書かない場合でも2.1節の方言の違いを知っておくと役に立ちます。
  • モバイルの精度。 モバイルゲームは速度と電池の為に出来るだけmediumpを使い、桁が足りないと揺れやぼやけたテクスチャとして現れる位置とテクスチャ座標にはhighpを残します。

2.18 まとめ

  • 方言:デスクトップのGLSL(#version 450 core、此のシリーズで使う物。macOSでは410)、GLSL ES(in/outと必須のfloatの精度を持つ#version 300 es、attribute/varying/gl_FragColorを使う#version 100)、Vulkan GLSL(明示的なロケーションとsetとbindingを持つユニフォームブロックを使う#version 450、SPIR-Vにコンパイル)。
  • 段階:描画には頂点とフラグメントが必要で、テッセレーション(4.0)、ジオメトリ(3.2)、コンピュート(4.3、macOSでは不可)は任意です。
  • スカラー:bool、int、uint、float、double。1 / 2は0です。floatは小数点付きで書きましょう。デスクトップのGLSLはintをfloatに自動で変換し、GLSL ESは決して変換しません。
  • ベクトル:vec2/vec3/vec4とivec、uvec、bvec。コンストラクターは左から順に成分を埋め、数値が1つなら全てを埋めます。
  • スウィズル:.xyzw、.rgba、.stpqを好きな順番で。読む時は繰り返せ、書く時は書き込みマスクになります。
  • ベクトルの演算子は成分ごとに動きます。vec * vecは内積ではありません。ベクトルの比較にはlessThan等とany/allを使います。
  • 行列は列優先です:コンストラクターは列を埋め、m[col][row]、m * vは𝐌𝐯、v * mは𝐌⊤𝐯です。
  • 修飾子:const、in、out、uniform、layout(location = N)、flat/smooth。関数は引数をコピーし(in、out、inout)、オーバーロード出来、再帰は出来ません。
  • 制御構文はCと同じで、フラグメントシェーダーにはdiscardもあります。ピクセルのグループの中で分岐が分かれると、両側が実行されます。
  • 一番大事な組み込み変数はgl_Position(頂点)とgl_FragCoord(フラグメント、ピクセル単位、中心は.5、原点は左下)です。
  • floatは正確ではありません:==で比較せず、長く動いた時間の様な大きな値に注意しましょう。
  • プリプロセッサー(#define、#if)は、エンジンがシェーダーパーミュテーションを作る方法です。

2.19 課題

  1. ★ vec4 v = vec4(1.0, 2.0, 3.0, 4.0);の時、v.wzyx、v.xxw、v.ga、vec3(v.zw, v.x)は何ですか?又、次の内エラーになるのはどれですか:v.xyzx、v.rgz、v.xx = vec2(0.0)、v.yx = vec2(5.0, 6.0)。
  2. ★ 7 / 2、7.0 / 2.0、int(-3.9)、010 + 1、mod(7.0, 3.0)(表の式を使って下さい)は幾つですか?一目見て予想した値と違うのはどれでしょうか?
  3. ★ mat3 m = mat3(2.0, 0.0, 0.0, 1.0, 3.0, 0.0, 0.0, 0.0, 1.0);を行と列の形で書き、m * vec3(1.0, 1.0, 1.0)とvec3(1.0, 1.0, 1.0) * mを計算して下さい。m[1]とm[1][0]は何ですか?
  4. ★★ スウィズルだけを使って、2.5節のUVの画像の赤と緑を入れ替えたフラグメントシェーダーを書いて下さい。緑が右下、赤が左上になり、黄色は右上のままのはずです。
  5. ★★ 3つの列が全てvec3(0.3333)のmat3を使って、2.6節の赤から緑へのグラデーションをグレースケールにして下さい。全てのピクセルが元の色の平均の明るさの灰色になり、此のグラデーションではどこでも同じ、約33%の一様な灰色になるはずです。𝐌𝐯の列の見方を使って理由を説明して下さい。
  6. ★★ 2.13節の市松模様を、マスが100 × 100ピクセルで、明るいマスに白ではなく2.5節のUVの色が出る様に変更して下さい。次に、gl_FragCoordの代わりにvUvを使って8 × 8マスにして下さい。ウィンドウのサイズを変えた時、何が違いますか?
  7. ★★★ switchで4つの色の1つを返すvec3 palette(int i)関数を書き、forループと一緒に使って、2.12節の棒を4色の繰り返しで描いて下さい。次に棒の数を#defineにして、5本、10本、20本のどれでもウィンドウを丁度埋める事を確かめて下さい。


コメント(0)

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