月別アーカイブ: 2013年8月

Adreno 320 の OpenGL ES 3.0 と Uniform Block

前回 Nexus 7 の Adreno 320 で OpenGL ES 3.0 のシェーダーが正しく動作しないと
書いたのですが、条件が絞れてきました。

UniformBlock の変数を直接演算に用いると Shader Compiler の
glLinkProgram() で Internal Error が発生するか直後にクラッシュします。

#version 300 es

// GLSL: VertexShader

precision highp float;

uniform SceneBlock {
    mat4   PView;
    mat4   ViewMatrix;
};

in vec3 POSITION;
in vec3 NORMAL;
in vec2 TEXCOORD;

out vec3 onormal;
out vec2 otexcoord;

void main()
{
    vec4 opos= vec4( POSITION.xyz, 1.0 ) * PView; // ← ここ

    opos.z= 2.0 * opos.z - opos.w;
    gl_Position= opos;
    onormal= vec3( 0.0, 0.0, -1.0 );
    otexcoord= TEXCOORD.xy;
}

下記のように、Uniform Block 内の変数を一旦ローカル変数にコピーすると
問題なく動くようになります。

void main()
{
    mat4 pv= PView;  // Uniform Block の変数をローカルにコピー
    vec4 opos= vec4( POSITION.xyz,1.0 ) * pv;

    opos.z= 2.0 * opos.z - opos.w;
    gl_Position= opos;
    onormal= vec3( 0.0, 0.0, -1.0 );
    otexcoord= TEXCOORD.xy;
}

Fragment Shader も同じです。

OpenGL ES 2.0 では Uniform Block が無いので問題ありません。

OpenGL ES 3.0 でも Uniform Block を使わない ( default Uniform Block だけ使う)
場合も問題ありませんでした。

Adreno 320 以外ではどちらのコードも動きます。
Mali-T604 実機, Adreno SDK の OpenGL ES 3.0 Emulator,
Mali Developer Tools の OpenGL ES 3.0 Emulator いずれも問題ありませんでした。

症状を確認した本体

・Nexus 7 (2013)
・Android 4.3 JSS15Q

GL_VERSION: OpenGL ES 3.0 V@14.0 AU@  (CL@)
GL_RENDERER: Adreno (TM) 320
GL_VENDOR: Qualcomm
GL_SHADING_LANGUAGE_VERSION: OpenGL ES GLSL ES 3.00

購入直後一度システムソフトウエアの更新があり、GL_VERSION の内容が
置き換わっています。上記は更新後です。
更新後も同じ症状が出ています。

回避方法がわかったので、とりあえず Adreno 320 でも OpenGL ES 3.0 用
シェーダーの動作確認ができました。

他に Intel HD 4000 (9.18.10.3165) でも Uniform Block で問題が出ています。
Uniform Block 内で mat3x4 の配列を宣言すると、index の計算を間違えるようです。
(layout std140 指定済み)
すべて vec4 宣言し、自分で matrix に組み立てることで回避できます。

関連エントリ
Nexus 7 (2013) の Adreno 320 と OpenGL ES 3.0 (Android 4.3)

Nexus 7 (2013) の Adreno 320 と OpenGL ES 3.0 (Android 4.3)

Nexus 7 (2013) が発売されたので、
Adreno 320 上でも OpenGL ES 3.0 のテストができるようになりました。
現時点で OpenGL ES 3.0 を走らせるには、
Android 4.3 と OpenGL ES 3.0 対応 GPU が必要です。

                 SoC                 CPU             GPU
---------------------------------------------------------------
Nexus 10         Exynos5 Dual        Cortex-A15 x2   Mali-T604
Nexus 7 (2013)   Snapdragon APQ8064  Krait x4        Adreno 320

現在 OpenGL ES 3.0 + Android 4.3 に対応しているのは上記 2機種です。
(おそらく明後日 30日発売の Nexus 4 も可能だと思われます)

新しい Nexus 7 を下記ページに追加しました。

CPU/GPU OpenGL ES Extension (Mobile GPU)

Qualcomm Snapdragon APQ8064 自体は、昨年末から採用端末が多数
登場しているので、今となってはあまり目新しいものではないかもしれません。
ですが、AQP8064 は CPU core, GPU core の両方が世代交代した
アーキテクチャとなっており、開発用途では非常に興味深い内容となっています。

当初から ETC2 など OpenGL ES 3.0 の仕様が部分的に含まれていましたし、
3DMark でもかなり優秀な成績を収めています。
でもこれはまだ DX10 対応 GPU で DX9 のデモを走らせているようなもの。

Android 4.3 + OpenGL ES 3.0 でようやく GPU の世代に一致したシェーダーを
走らせることができるようになります。

以下 Nexus 7 (2013) からの抜粋L

GL_VERSION: OpenGL ES 3.0 V@14.0 AU@  (CL@)
GL_RENDERER: Adreno (TM) 320
GL_VENDOR: Qualcomm
GL_SHADING_LANGUAGE_VERSION: OpenGL ES GLSL ES 3.00

Extension:
GL_AMD_compressed_ATC_texture
GL_AMD_performance_monitor
GL_AMD_program_binary_Z400
GL_EXT_debug_label
GL_EXT_debug_marker
GL_EXT_robustness
GL_EXT_texture_format_BGRA8888
GL_EXT_texture_type_2_10_10_10_REV
GL_NV_fence
GL_OES_compressed_ETC1_RGB8_texture
GL_OES_depth_texture
GL_OES_depth24
GL_OES_EGL_image
GL_OES_EGL_image_external
GL_OES_element_index_uint
GL_OES_fbo_render_mipmap
GL_OES_fragment_precision_high
GL_OES_get_program_binary
GL_OES_packed_depth_stencil
GL_OES_depth_texture_cube_map
GL_OES_rgb8_rgba8
GL_OES_standard_derivatives
GL_OES_texture_3D
GL_OES_texture_float
GL_OES_texture_half_float
GL_OES_texture_half_float_linear
GL_OES_texture_npot
GL_OES_vertex_half_float
GL_OES_vertex_type_10_10_10_2
GL_OES_vertex_array_object
GL_QCOM_alpha_test
GL_QCOM_binning_control
GL_QCOM_driver_control
GL_QCOM_perfmon_global_mode
GL_QCOM_extended_get
GL_QCOM_extended_get2
GL_QCOM_tiled_rendering
GL_QCOM_writeonly_rendering
GL_EXT_sRGB
GL_EXT_texture_filter_anisotropic
GL_EXT_color_buffer_float
GL_EXT_color_buffer_half_float

下記は Nexus 10 の Mali-T604 との比較

				        Nexus 7 (2013)  Nexus 10
                                         Adreno 320     Mali-T604
-----------------------------------------------------------------
=== GL3:texture
GL_MAX_3D_TEXTURE_SIZE                      1024          4096
GL_MAX_TEXTURE_SIZE                         4096          4096
GL_MAX_ARRAY_TEXTURE_LAYERS                 256           4096
GL_MAX_TEXTURE_LOD_BIAS                     15.984375     255.996094
GL_MAX_CUBE_MAP_TEXTURE_SIZE                4096          4096
GL_MAX_RENDERBUFFER_SIZE                    4096          4096
GL_MAX_DRAW_BUFFERS                         4             4
GL_MAX_COLOR_ATTACHMENTS                    4             4
GL_MAX_VIEWPORT_DIMS                        4096          4096
=== GL3:elements
GL_MAX_ELEMENTS_INDICES                     -1            16777216
GL_MAX_ELEMENTS_VERTICES                    -1            16777216
=== GL3:vertex
GL_MAX_VERTEX_ATTRIBS                       16            16
GL_MAX_VERTEX_OUTPUT_COMPONENTS             69            64
=== GL3:pixel
GL_MAX_FRAGMENT_INPUT_COMPONENTS            71            60
=== GL3:program
GL_MIN_PROGRAM_TEXEL_OFFSET                 -8            -8
GL_MAX_PROGRAM_TEXEL_OFFSET                 7             7
GL_MAX_VARYING_COMPONENTS                   64            60
GL_MAX_VARYING_VECTORS                      16            15
=== GL3:output stream
GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 64       64
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS       4        4
GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS    4        4
GL_MAX_SAMPLES                                   4        4
=== GL3:uniform block
GL_MAX_VERTEX_UNIFORM_COMPONENTS            1024          1024
GL_MAX_VERTEX_UNIFORM_VECTORS               256           256
GL_MAX_VERTEX_UNIFORM_BLOCKS                12            12
GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS   --            50176
GL_MAX_FRAGMENT_UNIFORM_COMPONENTS          896           4096
GL_MAX_FRAGMENT_UNIFORM_VECTORS             224           1024
GL_MAX_FRAGMENT_UNIFORM_BLOCKS              12
GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 197504        53248
GL_MAX_UNIFORM_BUFFER_BINDINGS              24            36
GL_MAX_UNIFORM_BLOCK_SIZE                   65536         16384
GL_MAX_COMBINED_UNIFORM_BLOCKS              24            24
=== GL3:tex
GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS           16            16
GL_MAX_TEXTURE_IMAGE_UNITS                  16            16
GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS         32            32

Mali では Fragment で使える Uniform 数の方が Vertex よりも多いですが
Adreno では少なくなっているようです。
少々特殊な 896 / 224 という数値は OpenGL ES 3.0 の仕様を満たしています。
むしろ Adreno に合わせた数値(仕様)だと思われます。

実際にプログラムを走らせてみたのですが、残念ながら
Adreno 320 の OpenGL ES 3.0 ではまだ複雑なシェーダーが正しく動いていません。
簡単なシェーダーと、OpenGL ES 2.0 互換モードでは動作を確認できました。
Shader の Link 時に Internal error が発生しているので、
原因を調べているところです。

関連エントリ
Android 4.3 と OpenGL ES 3.0
Nexus 10 CPU Cortex-A15 の速度
Nexus 10 GPU Mali-T604
3DMark Android 版の結果から

OpenGL 3.x/4.x のシェーダー GLSL とメモリアクセス命令

OpenGL のシェーダーはバージョンごとに機能が拡張されています。
バッファやメモリ周りの命令は似たようなものが複数存在しており、
複雑なのでまとめてみました。

● texelFetch()

OpenGL 3.0 以降対応。OpenGL ES 3.0 対応。

指定は通常の glBindTexture() と sampler 宣言ですが、
読み取り命令が違います。

// OpenGL
glActiveTexture( GL_TEXTURE0 );
glBindTexture( GL_TEXTURE_2D, Texture );
#version 430
// GLSL: fsh
layout(binding=0) uniform sampler2D ColorMap;

in vec2  otexcoord;
out vec4 out_FragColor;

void main()
{
    ivec2 iuv= ivec2( otexcoord.x * 255, otexcoord.y * 255 );
    vec4  color= texelFetch( ColorMap, iuv, 0 );
    out_FragColor= color;
}

uv ではなく整数座標で直接画素値を読み取ります。
圧縮テクスチャを bind した場合は展開後の画素を読み取ります。
Texture と同じ bind point を使います。
Direct3D HLSL で Sampler を指定しない Load 系命令に相当します。

● Uniform Block

OpenGL 3.1 以降対応。OpenGL ES 3.0 でも利用できます。

GLSL の Uniform 変数を buffer として割り当てます。
詳しくは下記でまとめています。

OpenGL ES 3.0/OpenGL 4.x Uniform Block

// OpenGL
glBindBufferBase( GL_UNIFORM_BUFFER, 0, Uniform );
glUniformBlockBinding( program, 0, 0 );
#version 430
// GLSL: vsh

layout(std140,column_major) uniform MatData {
    mat4x4  PVW;
};
in vec3 POSITION;

void main()
{
    vec4  opos= vec4( POSITION.xyz, 1.0f ) * PVW;
    opos.z= 2.0f * opos.z - opos.w;
    gl_Position= opos;
}

Uniform Block は専用の bind point が割り当てられています。

● Texture Buffer

OpenGL 3.1 以降対応です。
OpenGL ES 3.0 では利用できません。

Buffer を Texture として bind できるようにします。
例えば Transform Feedback (Stream Output) の結果をシェーダーから参照する
場合などに利用できます。

// OpenGL init
struct MatData {
    math::Matrix4  PView;
    math::Matrix4  World;
    math::Vect4    UVOffset;
};
// Uniform Buffer を作る
GLuint  MatData_Uniform= 0;
glGenBuffers( 1, &MatData_Uniform );
glBindBuffer( GL_UNIFORM_BUFFER, sizeof(MatData), NULL, GL_DYNAMIC_DRAW );

// Texture Buffer を作る
GLuint  MatData_Texture= 0;
glGenTextures( 1, &MatData_Texture );
glBindTexture( GL_TEXTURE_BUFFER, MatData_Texture );
glTexBuffer( GL_TEXTURE_BUFFER, GL_RGBA32F, MatData_Uniform );
glUniformBlockBinding( program, 0, 0 );
// OpenGL render
// uniform の更新
MatData data;
data.PView.MulCopy( GetProjectionMatrix(), GetViewMatrix() );
data.Wrold.SetIdentity();
data.Wrold.RotationY( rotate_angle );
data.UVOffset.Set( 0.5f, 0.7f, 0.0f, 0.0f );
glBindBuffer( GL_UNIFORM_BUFFER, MatData_Uniform );
glBufferSubData( GL_UNIFORM_BUFFER, 0, sizeof(MatData), &data );

glUserProgram( program );
glBindVertexArray( input_layout );

// Uniform Buffer
glBindBufferBase( GL_UNIFORM_BUFFER, 0, MatData_Uniform );

// Texture
glActiveTexture( GL_TEXTURE0 );
glBindTexture( GL_TEXTURE_2D, Texture1 );

// Texture Buffer
glActiveTexture( GL_TEXTURE1 );
glBindTexture( GL_TEXTURE_BUFFER, MatData_Texture );

glDrawElements( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0 );

Vertex Shader にはそのまま Uniform Block を割り当てます。

#version 430
// GLSL: vsh
layout(std140,column_major,binding=0) uniform MatData {
    mat4x4  PView;
    mat4x4  World;
    vec4    UVOffset;
};

in vec3 POSITION;
in vec3 NORMAL;
in vec2 TEXCOORD;
out vec3 onormal;
out vec2 otexcoord;

void main()
{
    vec4  opos= vec4( POSITION.xyz, 1.0f ) * (World * PView);
    opos.z= 2.0f * opos.z - opos.w;
    gl_Position= opos;
    onormal= NORMAL.xyz * mat3x3( World );
    otexcoord= TEXCOORD.xy + UVOffset.xy;
}

Fragment Shader には Uniform Block を Texture Buffer として渡してみます。

#version 430
// GLSL: fsh

in vec3 onormal;
in vec2 otexcoord;
out vec4 out_FragColor;

layout(binding=0) uniform sampler2D     ColorMap;
layout(binding=1) uniform samplerBuffer BufferMap;

void main()
{
    float  diff= clamp( dot( vec3( 0.0f, 0.0f, -1.0f ), normalize( onormal.xyz ) ), 0.0f, 1.0f );
    vec4   uvoffset= texelFetch( BufferMap, 8 );
    vec2   uv= otexcoord.xy - uvoffset.xy;
    out_FragColor.xyz= texture( ColorMap, uv ).xyz * diff;
    out_FragColor.w= 1.0f;
}

全く同じバッファの値を、Vertex Shader は Uniform としてアクセスし、
Fragment Shader は texelFetch() を使って読み取っています。
Texture と同じ bind point です。

● Atomic Counter Buffer

OpenGL 4.2 以降で使えます。

uniform 変数のように宣言しますが特殊な型です。バッファを割り当てて使います。
この型にアクセスできるのは組み込みの関数だけです。
下記でページでも解説しています。

OpenGL 4.2/4.3 Shader Resource と Buffer API

// OpenGL init
glBindBuffer( GL_ATOMIC_COUNTER_BUFFER, CounterBlock );
glBufferData( GL_ATOMIC_COUNTER_BUFFER, sizeof(CounterData), NULL, GL_DYNAMIC_DRAW );
// OpenGL render
CounterData data;
memset( &data, 0, sizeof(CounterData) );
glBindBuffer( GL_ATOMIC_COUNTER_BUFFER, CounterBlock );
glBufferSubData( GL_ATOMIC_COUNTER_BUFFER, 0, sozeof(CounterData), &data );
~
glBindBufferBase( GL_ATOMIC_COUNTER_BUFFER, 0, CounterBlock );
~
// GLSL: psh
layout(binding=0, offset=0) uniform atomic_uint  Counter;

void main()
{
    uint  c= atomicCounter( Counter );
    ~
    atomicCounterIncrement( Counter );
}

利用可能なカウンタの個数はハードウエアで決められています。
他の書き込み可能なリソースにも atomic なオペレーション命令が複数存在しますが、
Counter は increment/decrement に特化した機能となっているようです。
専用の bind point です。

● Texture Image Load and Store

OpenGL 4.2 以降での対応です。

読み書き可能なテクスチャ命令です。

GLSL の sampler* の代わりに image* 宣言を用い、
専用の imageLoad() / imageStore() 命令で読み書きします。
Direct3D の UAV に相当します。

#version 430
// GLSL: psh

in vec2   otexcoord;
out vec4  out_FragColor;

layout(binding=3,rgba8) uniform readonly image2D  ColorMap2;

void main()
{
    ivec2 iuv= ivec2( otexcoord.x * 255, otexcoord.y * 255 );
    out_FragColor= imageLoad( ColorMap2, ivec2( xp, yp ) );
}
// OpenGL render
glUseProgram( program1 );
glBindVertexArray( input_layout );
~

glBindImageTexture( 3, texture1, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8 );

glDrawElements( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0 );

Texture Object の生成や初期化は通常のテクスチャと全く同じです。
Bind のみ専用の glBindImageTexture() 命令を使います。
Bind Point は新規に用意されており、通常の画像テクスチャとは別の
番号付けが行われます。

Image Load/Store が利用できる Unit の数は GL_MAX_IMAGE_UNITS です。
これまでの Texture で使われていた Texture Image Unit
(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS) とよく似ていますが別のものです。

GL_MAX_*_IMAGE_UNIFORMS
                           vsh  fsh tcsh tesh  gsh  csh combined unit
---------------------------------------------------------------------
GeForce GTX 650      4.4    8    8    8    8    8    8    48      8
RADEON HD7750(GCN)   4.3    0   32    0    0    0   32    32     32
RADEON HD6750M(VLIW) 4.3    0    8    0    0    0    8     8      8

画素フォーマットを指定するので、メモリ配置と一致しない場合は正しく読み取る
ことが出来ないようです。
texelFetch() では圧縮テクスチャの展開が可能でしたが、
image 系命令ではそのままでは出来ませんでした。
メモリイメージがそのまま読み込まれているのかもしれません。
RADEON では bind error となります。

● Shader Storage Buffer

OpenGL 4.3 以降に対応します。

読み書き可能な点では Texture Image Load and Store によく似ていますが、
Uniform Block のように変数としてアクセスすることができます。

#version 430
// GLSL: csh
layout(std140,binding=0) buffer CopyBlock {
    writeonly uint   Color[];
};

layout(binding=3,rgba8) uniform readonly image2D   ColorMap2;

layout(local_size_x=1,local_size_y=1) in;

void main()
{
    uvec2   pos= gl_GlobalInvocationID.xy;
    vec4    param= imageLoad( ColorMap2, ivec2( pos.x, pos.y ) );
    uint    index= gl_GlobalInvocationID.y * 256 + gl_GlobalInvocationID.x;
    param.xyzw= param.yxzw;
    Color[index]= packUnorm4x8( param );
}
#version 430
// GLSL: psh

in vec3   onormal;
in vec2	  otexcoord;
out vec4  out_FragColor;

layout(std140,binding=0) buffer CopyBlock {
    readonly uint   Color[];
};

void main()
{
    float diff= clamp( dot( vec3( 0.0f, 0.0f, -1.0f ), normalize( onormal.xyz ) ), 0.0f, 1.0f );
    vec2  uv= otexcoord.xy;
    uint  xp= uint( uv.x * 255.0f );
    uint  yp= uint( uv.y * 255.0f );
    uint  index= yp * 256 + xp;
    vec4  color2= unpackUnorm4x8( Color[index] );
    out_FragColor.xyz= color2.xyz * diff;
    out_FragColor.w= 1.0f;
}
// OpenGL init
struct Packed8888 {
    unsigned char  color[4];
};
glGenBuffers( 1, &Color_SSB );
glBindBuffer( GL_SHADER_STORAGE_BUFFER, Color_SSB );
glBufferData( GL_SHADER_STORAGE_BUFFER, sizeof(Packed8888) * 256 * 256 * 4, NULL, GL_DYNAMIC_DRAW );
// OpenGL render

// Compute Shader
glUseProgram( csh_program );

glBindImageTexture( 3, texture1, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8 );
glBindBufferBase( GL_SHADER_STORAGE_BUFFER, 0, Color_SSB );

glDispatchCompute( 256, 256, 1 );


// Render
glUseProgram( program1 );
glBindVertexArray( input_layout );
glBindBufferBase( GL_UNIFORM_BUFFER, 2, MatData_Uniform );
glBindBufferBase( GL_SHADER_STORAGE_BUFFER, 0, Color_SSB );

glDrawElements( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0 );

Compute Shader を使って、Image (Texture Image Load and Store) から
Shader Storage Buffer に画像をコピーしてるだけです。

Fragment Shader では Shader Storage Buffer の内容をテクスチャとして描画します。
少々手抜きで、Shader Storage Buffer は 4倍のメモリを確保していることになります。

RADEON の場合 Image 命令と Shader Storage Buffer の共存がうまくいっておりません。

過去記事 でも書いたように bind point は独自のものになっています。

GL_MAX_*_SHADER_STORAGE_BLOCKS
                           vsh  fsh tcsh tesh  gsh  csh combined size
----------------------------------------------------------------------
GeForce GTX 650      4.4   16   16   16   16   16   16    96      2GB
RADEON HD7750(GCN)   4.3   16   16   16   16   16   16    16     16MB
RADEON HD6750M(VLIW) 4.3    8    8    8    8    8    8     8     16MB

Texture Image Load and Store と機能が似ていますが上記のように違いが見られます。
RADEON の場合 Image Unit は fsh/csh だけでした。
Shader Storage はどのシェーダーでも有効になっています。

● Shared Memory

OpenGL 4.3 以降で利用できます。

Shared Memory は Compute Shader だけが利用できるローカルメモリです。
GLSL 内で shared 宣言します。

#version 430
// GLSL: csh
~
shared uint flags[1024];
GL_COMPUTE_SHARED_MEMORY_SIZE
                             csh
---------------------------------------
GeForce GTX 650      4.4     49152 byte
RADEON HD7750(GCN)   4.3     32768 byte
RADEON HD6750M(VLIW) 4.3     32768 byte

種類も多いので、機能の違いや使い方を理解するまでは大変かもしれません。
実際に使ってみると思ったよりも扱いやすい印象でした。
特に OpenGL 4.3 以降は bind 値を全部 Shader 側で指定できるので
手間がかなり減っています。

関連エントリ
OpenGL 4.x Program Pipeline Object (Separate Shader Object)
OpenGL 4.2/4.3 Shader Resource と Buffer API
OpenGL ES 3.0/OpenGL 4.x Uniform Block
OpenGL の各バージョンと GLSL の互換性
OpenGL のエラー判定と OpenGL 4.3 Debug Output
OpenGL ES 3.0/OpenGL 4.4 Texture Object と Sampler Object
OpenGL ES 3.0 と Vertex Array Object

OpenGL 4.x Program Pipeline Object (Separate Shader Object)

OpenGL のシェーダーは Direct3D と違い、API レベルでシンボル管理が行われます。

Direct3D の Native な API では、Vertex Shader, Pixel Shader,
Geometry Shader などの、各シェーダー毎に Object が分かれています。
ステートやバインド情報もそれぞれ別で、レンダリングのタイミングで
必要な情報を Direct3D の DeviceContext に割り当てます。
Constant (Unifrom) の管理も各シェーダー毎に別空間です。

例えば Camera 座標など、Vertex Shader, Pixel Shader 両方が
アクセセスするパラメータがあった場合は
PSSetConstantBuffers(), VSSetConstantBuffers()
両方に設定しなければなりません。
これはプログラマの仕事です。

OpenGL の場合 Vertex Shader, Fragment Shader, Geometry Shader など、
描画に必要なシェーダーを集めて最初に Program Object を作っておきます。
同時に Uniform や Block 等のシンボルの共有化が行われており、
どのシェーダーから参照されているのか情報が保持されます。

各シンボルの参照状態は OpenGL 4.3 以降は
glGetProgramResourceiv( GL_REFERENCED_BY_*_SHADER )
を使って調べることが出来ます。

プログラマはどのシェーダーで使われているのか意識することなく
単一のシンボルに対して設定すればよいだけです。
もちろん Vertex Shader, Fragment Shader 両方から参照されているなら
両方とも同じ値に更新されます。

OpenGL 4.1 から利用可能となった Program Pipeline Object は、
このような OpenGL Program Object の一括管理とは正反対のものです。
OpenGL 上で Direct3D のような、より低レベルだけど自由度の高い
シェーダー管理を可能にします。

GPU 周りの進化は非常に速いので、単一の仕組みだけでは様々な
要求に応えることが難しくなってきているのかもしれません。

●Shader の組み合わせ

レンダリングに使われるシェーダーのバリエーションはかなり膨大な量になります。
手で管理することは不可能なので、描画用のエンジン開発では
最初にシェーダー管理の仕組みを構築することになります。

ある程度の組み合わせに融通は利くので、用途に応じて
Pixel Shader (Fragment Shader) だけ変えたり、
部分的に使いまわしたりすることがありました。

OpenGL の場合 Shader Object レベルでは組み合わせを作ることが出来ます。
実際の利用時は Program Object が必要となるので、組み合わせの数だけ
Program Object が出来上がります。

Program Pipeline Object は、既存の OpenGL API の仕組みを利用したまま
動的に Shader を入れ替えられるようにしています。

 1. Shader 単独の Program Object を作る
 2. Pipeline Object にそれぞれ登録する
 3. 描画時に glUseProgram() の代わりに glBindProgramPipeline() を使う

//● 通常のシェーダーの場合

// Vertex Shader
GLuint vsh_obj= glCreateShader( GL_VERTEX_SHADER );
glShaderSource( vsh_obj, 1, &vsh_source_text );
glCompileShader( vsh_obj );

// Fragment Shader
GLuint fsh_obj= glCreateShader( GL_FRAGMENT_SHADER );
glShaderSource( fsh_obj, 1, &fsh_source_text );
glCompileShader( fsh_obj );

// Program Object を作成 (Link)
GLuint program_obj= glCreateProgram();
glAttachShader( program_obj, vsh_obj );
glAttachShader( program_obj, fsh_obj );
glLinkProgram( program_obj );

// 利用時
glUseProgram( program_obj );

Pipeline Object を利用する場合は下記の通り。

//● Pipeline Object を使う場合

// Vertex Shader
GLuint vsh_obj= glCreateShader( GL_VERTEX_SHADER );
glShaderSource( vsh_obj, 1, &vsh_source_text );
glCompileShader( vsh_obj );

// 単独の Vertex Shader Program に変換
GLuint vsh_program= glCreateProgram();
glProgramParameteri( vsh_program, GL_PROGRAM_SEPARABLE, GL_TURE );
glAttachShader( vsh_program, vsh_obj );
glLinkProgram( vsh_program );


// Fragment Shader
GLuint fsh_obj= glCreateShader( GL_FRAGMENT_SHADER );
glShaderSource( fsh_obj, 1, &fsh_source_text );
glCompileShader( fsh_obj );

// 単独の Fragment Shader Program に変換
GLuint fsh_program= glCreateProgram();
glProgramParameteri( fsh_program, GL_PROGRAM_SEPARABLE, GL_TURE );
glAttachShader( fsh_program, fsh_obj );
glLinkProgram( fsh_program );


// Pipeline Object
GLuint pipeline= 0;
glGenPipelineObjects( 1, &pipeline );
glGenProgramPipelines( 1, &pipeline );
glUseProgramStages( pipeline, GL_VERTEX_SHADER_BIT, vsh_program );
glUseProgramStages( pipeline, GL_FRAGMENT_SHADER_BIT, fsh_program );


// 利用時
glUseProgram( 0 );
glBindProgramPipeline( pipeline );

↑一見複雑ですが、Program Object を作るための便利な命令↓が増えています。

//● Pipeline Object を使う場合
GLuint vsh_program= glCreateShaderProgramv( GL_VERTEX_SHADER, 1, &vsh_source_text );
GLuint psh_program= glCreateShaderProgramv( GL_FRAGMENT_SHADER, 1, &fsh_source_text );

// Pipeline Object
GLuint pipeline= 0;
glGenPipelineObjects( 1, &pipeline );
glGenProgramPipelines( 1, &pipeline );
glUseProgramStages( pipeline, GL_VERTEX_SHADER_BIT, vsh_program );
glUseProgramStages( pipeline, GL_FRAGMENT_SHADER_BIT, fsh_program );


// 利用時
glUseProgram( 0 );
glBindProgramPipeline( pipeline );

↑簡単になりました。

●情報アクセス

Pipeline Object は複数の Program Object を取りまとめる器に過ぎず、
いつでも Program Object の追加と削除ができます。

Link のように大掛かりなデータ共有は行わず、入出力など最低限の
マッチングだけ行います。
入出力のマッチングはシンボル名または Location を元に行われるようです。

Program Object が持っていた情報もシェーダー個別に扱うことになります。
例えば Attribute の Location、Default Uniform Block などがそうです。

もともと Program Object のアクセス API は OpenGL の他の API と構造が
異なっており、多くのケースで Bind を必要としていませんでした。
引数として Program Object を取るものが多いのですが、唯一
glUniform() 系の API だけが glUseProgram() に依存しています。

方法は 3通り

1. Default Uniform Block を使わない

2. 直接 Program Object を引数にとる新しい API を使う

glUseProgram( vsh_program );
glUniform4fv( location, 1, vect );
 ↓
glProgramUniform4fv( vsh_program, location, 1, vect );

3. glActiveShaderProgram() を使う

glActiveShaderProgram() を使うと従来の Uniform 命令を使うことができます。

glUseProgram( program );
glUniform4fv( location, 1, vect );
 ↓
glUseProgram( 0 );
glBindProgramPipeline( pipeline );
glActiveShaderProgram( pipeline, vsh_program );
glUniform4fv( location, 1, vect );

●Bind Point

Pipeline Object は今までの OpenGL API にできるだけ影響を与えないように
作られています。
Bind Point は新たに追加されており、他のステートにも干渉しません。

例えば glUseProgram() が有効な場合、glUseProgram() が優先され
glBindProgramPipeline() は無視します。
Pipeline Object を有効にするにはこれまでの例で示したように
glUseProgram( 0 ) が必要です。

●実際のシェーダーと最適化の違い

Pipeline Object を使う場合、gl_Position も自分で定義しておきます。

#version 430

// Vertex Shader

uniform mat4	PView;
uniform mat4	World;
uniform vec4	UVOffset;

layout(location=0) in vec3 POSITION;
layout(location=1) in vec3 NORMAL;
layout(location=2) in vec2 TEXCOORD;

out vec3 onormal;
out vec2 otexcoord;

out gl_PerVertex {
    vec4 gl_Position;
};

void main()
{
    mat4  pview= World * PView;
    vec4  opos= vec4( POSITION.xyz, 1.0 ) * pview;
    opos.z= 2.0 * opos.z - opos.w;
    gl_Position= opos;
    onormal= NORMAL.xyz * mat3x3( World );
    otexcoord= TEXCOORD.xy + UVOffset.xy;
}
#version 430

// Fragment Shader

out vec4  out_FragColor;
uniform vec4   UVOffset;

in vec3	  onormal;
in vec2   otexcoord;
layout(binding=0) uniform sampler2D  ColorMap;

void main()
{
    float   diff= clamp( dot( vec3( 0, 0, -1 ), normalize( onormal.xyz ) ), 0.0, 1.0 );
    vec2    texcoord= otexcoord.xy - UVOffset.xy;
    vec4    color= texture( ColorMap, texcoord.xy );
    out_FragColor.xyz= color.xyz * diff;
    out_FragColor.w= 1.0;
}

UVOffset は Vertex と Fragment で同名です。
Pipeline Object を使った場合は異なる値に設定することが可能です。

上のコードのシンボル情報を調べてみます。
前回の API を使って情報を取り出したのが下記の結果です。
GeForce もほぼ同じでした。

// ●テクスチャあり Pipeline Object

// RADEON 4.3 : Vertex Shader
 Prg: 0011   Del=0 Link=1 Vali=1 Separable=1
Resource [Uniform]
  0: FLOAT_MAT4  Array=0 Loc=0 V_____  "PView"
  1: FLOAT_VEC4  Array=0 Loc=1 V_____  "UVOffset"
  2: FLOAT_MAT4  Array=0 Loc=2 V_____  "World"
Resource [Input]
  0: FLOAT_VEC3  Array=0       V_____  "NORMAL"
  1: FLOAT_VEC3  Array=0       V_____  "POSITION"
  2: FLOAT_VEC2  Array=0       V_____  "TEXCOORD"
Resource [Output]
  0: FLOAT_VEC4  Array=0       V_____  "gl_PerVertex.gl_Position"
  1: FLOAT_VEC3  Array=0       V_____  "onormal"
  2: FLOAT_VEC2  Array=0       V_____  "otexcoord"


// RADEON 4.3 : Fragment Shader
 Prg: 0012   Del=0 Link=1 Vali=1 Separable=1
Resource [Uniform]
  0: FLOAT_VEC4  Array=0 Loc=0 ____F_  "UVOffset"
  1: SAMPLER_2D  Array=0 Loc=1 ____F_  "ColorMap"
Resource [Input]
  0: FLOAT_VEC3  Array=0       ____F_  "onormal"
  1: FLOAT_VEC2  Array=0       ____F_  "otexcoord"
Resource [Output]
  0: FLOAT_VEC4  Array=0       ____F_  "out_FragColor"

次に Fragment Shader の texture 命令を削除してみます。

#version 430

// Fragment Shader

out vec4  out_FragColor;
uniform vec4   UVOffset;

in vec3	  onormal;
in vec2   otexcoord;

layout(binding=0) uniform sampler2D  ColorMap;

void main()
{
    float   diff= clamp( dot( vec3( 0, 0, -1 ), normalize( onormal.xyz ) ), 0.0, 1.0 );
    vec2    texcoord= otexcoord.xy - UVOffset.xy;
    //vec4    color= texture( ColorMap, texcoord.xy ); //** 削除
    vec4    color= vec4( 1.0, 1.0, 0.2, 1.0 );
    out_FragColor.xyz= color.xyz * diff;
    out_FragColor.w= 1.0;
}

↓VertexShader の方は変化していませんが、Fragment Shader の出力が
大きく減っていることがわかります。
texture()が無いので不要と判断され UVOffset も消えました。

// ●テクスチャ無し Pipeline Object

// GeForce 4.4 : Vertex Shader
 Prg: 0011   Del=0 Link=1 Vali=1 Separable=1
Resource [Uniform]
  0: FLOAT_MAT4  Array=0 Loc=0 V_____  "PView"
  1: FLOAT_VEC4  Array=0 Loc=1 V_____  "UVOffset"
  2: FLOAT_MAT4  Array=0 Loc=2 V_____  "World"
Resource [Input]
  0: FLOAT_VEC3  Array=0       V_____  "NORMAL"
  1: FLOAT_VEC3  Array=0       V_____  "POSITION"
  2: FLOAT_VEC2  Array=0       V_____  "TEXCOORD"
Resource [Output]
  0: FLOAT_VEC3  Array=0       V_____  "onormal"
  1: FLOAT_VEC2  Array=0       V_____  "otexcoord"
  2: FLOAT_VEC4  Array=0       V_____  "gl_Position"


// GeForce 4.4 : Fragment Shader
Resource [Input]
  0: FLOAT_VEC3  Array=0       ____F_  "onormal"
Resource [Output]
  0: FLOAT_VEC4  Array=0       ____F_  "out_FragColor"

↓RADEON はちょっとだけ違います。

// RADEON 4.3 : Fragment Shader
Resource [Input]
  0: FLOAT_VEC3  Array=0       ____F_  "onormal"
  1: FLOAT_VEC2  Array=0       ____F_  "otexcoord"
Resource [Output]
  0: FLOAT_VEC4  Array=0       ____F_  "out_FragColor"

↓同じシェーダーを Pipeline Object を使わずに作ってみます。
Separable (GL_PROGRAM_SEPARABLE) の値で区別できます。

// ●テクスチャあり Program Object

// GeForce 4.4 : Vertex + Fragment Shader
 Prg: 0014   Del=0 Link=1 Vali=1 Separable=0
  [0] 0012 VERTEX_SHADER           Del=1 Compile=1
  [1] 0013 FRAGMENT_SHADER         Del=1 Compile=1
Resource [Uniform]
  0: SAMPLER_2D  Array=0 Loc=0 ____F_  "ColorMap"
  1: FLOAT_MAT4  Array=0 Loc=1 V_____  "PView"
  2: FLOAT_VEC4  Array=0 Loc=2 V___F_  "UVOffset"
  3: FLOAT_MAT4  Array=0 Loc=3 V_____  "World"
Resource [Input]
  0: FLOAT_VEC3  Array=0       V_____  "NORMAL"
  1: FLOAT_VEC3  Array=0       V_____  "POSITION"
  2: FLOAT_VEC2  Array=0       V_____  "TEXCOORD"
Resource [Output]
  0: FLOAT_VEC4  Array=0       ____F_  "out_FragColor"

texture() を削除したものが下記の通り。

// ●テクスチャ無し Program Object

// GeForce 4.4 : Vertex + Fragment Shader
 Prg: 0014   Del=0 Link=1 Vali=1 Separable=0
  [0] 0012 VERTEX_SHADER           Del=1 Compile=1
  [1] 0013 FRAGMENT_SHADER         Del=1 Compile=1
Resource [Uniform]
  0: FLOAT_MAT4  Array=0 Loc=0 V_____  "PView"
  1: FLOAT_MAT4  Array=0 Loc=1 V_____  "World"
Resource [Input]
  0: FLOAT_VEC3  Array=0       V_____  "NORMAL"
  1: FLOAT_VEC3  Array=0       V_____  "POSITION"
Resource [Output]
  0: FLOAT_VEC4  Array=0       ____F_  "out_FragColor"

↑Fragment Shader の最適化が Vertex Shader まで派生していることがわかります。
Fragment Vertex 双方から不要と判断され UVOffset が消えました。
GeForce に至っては Attribute の TEXCOORD まで無くなっています。

// RADEON 4.3 : Vertex + Fragment Shader
 Prg: 0014   Del=0 Link=1 Vali=1 Separable=0
  [0] 0010 VERTEX_SHADER           Del=1 Compile=1
  [1] 0013 FRAGMENT_SHADER         Del=1 Compile=1
Resource [Uniform]
  0: FLOAT_MAT4  Array=0 Loc=0 V_____  "PView"
  1: FLOAT_MAT4  Array=0 Loc=1 V_____  "World"
Resource [Input]
  0: FLOAT_VEC3  Array=0       V_____  "NORMAL"
  1: FLOAT_VEC3  Array=0       V_____  "POSITION"
  2: FLOAT_VEC2  Array=0       V_____  "TEXCOORD"
Resource [Output]
  0: FLOAT_VEC4  Array=0       ____F_  "out_FragColor"

このように、今までどおり Link して単一の Program Object に変換する方が
最適化の面ではメリットがあることがわかります。

実パフォーマンスでどの程度影響が生じるかどうかは未確認です。
Direct3D で開発し、すでにシェーダー管理の仕組みができている場合は
互換性の意味でも便利な機能です。
自由な組み合わせが必要な場合とそうでない場合の使い分けが必要かもしれません。

2014/06/23訂正: glPipelineObjects を glProgramPipelines に修正しました。間違った記載をしており申し訳ありませんでした。
小川さんご指摘ありがとうございます。

関連エントリ
OpenGL 4.2/4.3 Shader Resource と Buffer API
OpenGL ES 3.0/OpenGL 4.x Uniform Block
OpenGL の各バージョンと GLSL の互換性
OpenGL のエラー判定と OpenGL 4.3 Debug Output
OpenGL ES 3.0/OpenGL 4.4 Texture Object と Sampler Object
OpenGL ES 3.0 と Vertex Array Object

OpenGL 4.2/4.3 Shader Resource と Buffer API

OpenGL 3.1 以降や OpenGL ES 3.0 ではシェーダーが Uniform Buffer に
アクセスすることが出来ます。
OpenGL 4.2 以降はさらにシェーダーが利用できる Buffer Type が増えています。

OpenGL の API は基本的に下記の構造になっています。

●(1) Object を生成したり情報にアクセスするための Bind Point
  ・(A) (1) に Bind するための命令
  ・(B) (1) の Bind Point を使った設定や情報アクセス API

●(2) シェーダーに渡すための Bind Point の配列 (Table)
  ・(C) (2) に Bind するための専用命令
  ・(D) シェーダーのシンボルが (2) の Table のどこを見るか関連付ける命令

Texture Object は (A) と (C) の Bind 命令が共通なので、
glActiveTexture() で Bind Point ごと切り替えています。
切り替えるだけなので (1) と (2) のエリアが分かれていません。(詳細)

 (A) = glBindTexture()
 (C) = glActiveTexture() + glBindTexture()
 (D) = glUseProgram() + glUniform1i() ( 4.2 以降 layout(binding=n) )

Vertex Buffer (GL_ARRAY_BUFFER) は glVertexAttribPointer() 命令が
内部で (C) を暗黙のうちに行います。
その後 OpenGL 4.3 で明示的に割り付ける命令が追加されました。
(C) の命令は (1) に影響を与えません。(詳細)

 (A) = glBindBuffer( GL_ARRAY_BUFFER )
 (C) = glBindVertexBuffer()
 (D) = glVertexAttribBinding()

Uniform Buffer は 前回 のとおりです。
(1) と (2) は別の領域ですが、(C) の命令は (1)/(2) の両方に設定を行います。

 (A) = glBindBuffer( GL_UNIFORM_BUFFER )
 (C) = glBindBufferBase( GL_UNIFORM_BUFFER )
 (D) = glUniformBlockBinding() ( 4.2 以降 layout(binding=n) )

OpenGL 4.2 以降は Bind Point を Shader 内に記述できるので、
いくつかのケースでは (D) を用いなくても良くなっています。
OpenGL 4.2 で追加された Atomic Counter Buffer も Shader 側で指定します。

● Atomic Counter Buffer (4.2)

Atomic Counter Buffer (GL_ATOMIC_COUNTER_BUFFER) は Uniform として宣言
しますが、シェーダーが値を更新することができます。

// Init
struct CounterData {
  unsigned int Counter1;
  unsigned int Counter2;
};
CounterData  counter;
memset( &counter, 0, sizeof(CounterData) );
GLuint CounterBlock= 0;
glGenBuffers( 1, &CounterBlock );
glBindBuffer( GL_ATOMIC_COUNTER_BUFFER, CounterBlock );
glBufferData( GL_ATOMIC_COUNTER_BUFFER, sizeof(CounterData), &counter, GL_DYNAMIC_DRAW );
// Render
// 初期化
CounterData counter;
memset( &counter, 0, sizeof(CounterData) );
glBindBuffer( GL_ATOMIC_COUNTER_BUFFER, CounterBlock );
glBufferSubData( GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(CounterData), &counter );
glBindBuffer( GL_ATOMIC_COUNTER_BUFFER, 0 );

~
glBindBufferBase( GL_ATOMIC_COUNTER_BUFFER, 3, CounterBlock ); // Bind
glDrawElements( GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0 );

API の構造は Uniform Block と同じです。
atomic_uint は特殊な型で、アクセスには専用の命令が必要となります。

// GLSL : vsh
uniform mat4  PVW;
uniform mat4  World;

layout(binding=3, offset=0) uniform atomic_uint  Counter1;

in vec3 POSITION;
in vec3 NORMAL;

out vec3 onormal;

void main()
{
    vec4  opos= vec4( POSITION.xyz, 1.0 ) * PVW;
    opos.z= 2.0 * opos.z - opos.w;
    gl_Position= opos;

    atomicCounterIncrement( Counter1 );

    onormal= NORMAL.xyz * mat3x3( World );
}

Vertex / Fragment それぞれ実行回数を数えているだけです。

// GLSL : fsh
in vec3  onormal;

layout(binding=3, offset=4) uniform atomic_uint	Counter2;

void main()
{
    uint   param= atomicCounterIncrement( Counter2 ) & 0xffff;
    float  color= clamp( float( param ) * 0.001, 0.0, 1.0 );
    float  diff= clamp( dot( vec3( 0.0, 0.0, 1.0 ), normalize( onormal.xyz ) ), 0.0, 1.0 );
    out_FragColor.xyz= vec3( color, 1.0, color ) * diff;
    out_FragColor.w= 1.0;
}

RADEON (13.8beta) では Beta 版 Drive のせいか若干挙動に問題がありました。
vsh/fsh のカウンタが加算された値が返ってきます。
また API の Bind Point の構造が Uniform Block と異なっているようで
GL_ATOMIC_COUNTER_BUFFER_BINDING を glGetIntegeri_v() で取るとエラーでした。

GL_SHADER_STORAGE_BUFFER_BINDING の方も、
(1) の Bind が (2) の 0番と共有されているか、もしくは
glGetIntegerv( GL_SHADER_STORAGE_BUFFER_BINDING ) が (2) の
0 番の内容を返しているように見えます。

● Shader Storage Buffer (4.3)

OpenGL 4.3 の GLSL 4.3 では、Uniform Block 同様の構文で buffer 宣言が
追加されています。
当初 Direct3D の HLSL でいう cbuffer に対する tbuffer のことだと
思っていたのですが、直接データを書き換えることもできるようです。
つまり Direct3D の UnorderedAccessView (UAV) に相当する役目も持っています。

// GLSL
layout(std140, binding=3) buffer MatBlock {
    layout(column_major) readonly mat4	MatData1;
    layout(column_major) readonly mat4	MatData2;
};

こちらも簡単な動作を確認したのですが、GeForce では意図したとおりに
動くものの RADEON HD7750 の 13.8beta ではまだ少々不安定でした。
(使い方に問題があった可能性もあります)

● GL_ARB_program_interface_query

Uniform Block には Bind したり Program から情報を得るための専用の API がありました。
OpenGL 4.3 では Buffer Type も増えていることから、
専用の API を増やす代わりにより一般的な API が用意されています。

新しい Shader Storage Buffer だけでなく、Atomic Counter Buffer や
従来の Uniform Block, Uniform, Attribute などもこの API に統合されています。
Uniform Block も下記の通り。

glGetProgramiv( program, GL_ACTIVE_UNIFORM_BLOCKS )
↓
glGetProgramInterfaceiv( program, GL_UNIFORM_BLOCK, GL_ACTIVE_RESOURCES )

glGetActiveUniformBlockiv( program, index, ~ );
↓
glGetProgramResourceiv( program, GL_UNIFORM_BLOCK, index, ~ );

下記は実際にいろいろ情報を取り出してみた結果です。
少々わかりにくいですが、Atomic Counter Buffer や Shader Storage Buffer
だけでなく、同じ API で Attribute や出力変数も取り出すことが出来ます。

// RADEON
Resource [Uniform] 92e1: 5 (Prog=0012)
  0: Loc=0000 FLOAT_MAT4  (8b5c) Array=0 BL=-1 off=-1 ast=-1 mst=-1 RM=0 AC=-1 V_____ "World"
  1: Loc=ffff FLOAT_MAT4  (8b5c) Array=0 BL= 0 off= 0 ast= 0 mst=16 RM=0 AC=-1 V_____ "Projection"
  2: Loc=ffff FLOAT_MAT4  (8b5c) Array=0 BL= 0 off=64 ast= 0 mst=16 RM=0 AC=-1 V_____ "ViewMatrix"
  3: Loc=ffff UNSIGNED_INT_ATOMIC_COUNTER(92db) Array=0 BL=-1 off=-1 ast=-1 mst=-1 RM=0 AC= 0 V_____ "Counter"
  4: Loc=ffff UNSIGNED_INT_ATOMIC_COUNTER(92db) Array=0 BL=-1 off=-1 ast=-1 mst=-1 RM=0 AC= 1 ____F_ "Counter2"
Resource [Atomic] 92c0: 2 (Prog=0012)
  0: Bind=0000 Size=    4 Uni=1 Ind=2 V_____ ""
  1: Bind=0001 Size=    4 Uni=1 Ind=3 ____F_ ""
Resource [UniformBlock] 92e2: 1 (Prog=0012)
  0: Bind=0000 Size=  128 Uni=2 Ind=1 V_____ "Scene"
Resource [ShaderStorage] 92e6: 1 (Prog=0012)
  0: Bind=0003 Size=  128 Uni=2 Ind=0 ____F_ "MatBlock"
Resource [Input] 92e3: 3 (Prog=0012)
  0: Loc=ffff FLOAT_VEC3  (8b51) Array=0 BL=899973093 off=53214 ast= 3 mst=128 RM=2 AC= 0 V_____ "NORMAL"
  1: Loc=ffff FLOAT_VEC3  (8b51) Array=0 BL=899973093 off=53214 ast= 3 mst=128 RM=2 AC= 0 V_____ "POSITION"
  2: Loc=ffff FLOAT_VEC2  (8b50) Array=0 BL=899973093 off=53214 ast= 3 mst=128 RM=2 AC= 0 V_____ "TEXCOORD"
Resource [Output] 92e4: 1 (Prog=0012)
  0: Loc=ffff FLOAT_VEC4  (8b52) Array=0 BL=899973093 off=53214 ast= 3 mst=128 RM=2 AC= 0 ____F_ "out_FragColor"
Resource [Variable] 92e5: 2 (Prog=0012)
  0: Loc=ffff FLOAT_MAT4  (8b5c) Array=0 BL= 0 off= 0 ast= 0 mst=16 RM=0 AC= 1 ____F_ "Projection2"
  1: Loc=ffff FLOAT_MAT4  (8b5c) Array=0 BL= 0 off=64 ast= 0 mst=16 RM=0 AC= 1 ____F_ "ViewMatrix2"
// GeForce
Resource [Uniform] 92e1: 5 (Prog=0012)
  0: Loc=ffff UNSIGNED_INT_ATOMIC_COUNTER(92db) Array=0 BL= 0 off= 0 ast= 0 mst= 0 RM=0 AC= 0 V_____ "Counter"
  1: Loc=ffff UNSIGNED_INT_ATOMIC_COUNTER(92db) Array=0 BL= 0 off= 4 ast= 0 mst= 0 RM=0 AC= 0 ____F_ "Counter2"
  2: Loc=ffff FLOAT_MAT4  (8b5c) Array=0 BL= 0 off= 0 ast= 0 mst=16 RM=0 AC=-1 V_____ "Projection"
  3: Loc=ffff FLOAT_MAT4  (8b5c) Array=0 BL= 0 off=64 ast= 0 mst=16 RM=0 AC=-1 V_____ "ViewMatrix"
  4: Loc=0004 FLOAT_MAT4  (8b5c) Array=0 BL=-1 off=-1 ast=-1 mst=-1 RM=0 AC=-1 V_____ "World"
Resource [Atomic] 92c0: 1 (Prog=0012)
  0: Bind=0000 Size=    8 Uni=2 Ind=0 V___F_ ""
Resource [UniformBlock] 92e2: 1 (Prog=0012)
  0: Bind=0004 Size=  128 Uni=2 Ind=2 V_____ "Scene"
Resource [ShaderStorage] 92e6: 1 (Prog=0012)
  0: Bind=0003 Size=  128 Uni=1 Ind=0 V_____ "MatBlock"
Resource [Input] 92e3: 2 (Prog=0012)
  0: Loc=ffff FLOAT_VEC3  (8b51) Array=0 BL=-212702986 off=38875 ast= 3 mst=128 RM=1 AC= 0 V_____ "NORMAL"
  1: Loc=ffff FLOAT_VEC3  (8b51) Array=0 BL=-212702986 off=38875 ast= 3 mst=128 RM=1 AC= 0 V_____ "POSITION"
Resource [Output] 92e4: 1 (Prog=0012)
  0: Loc=ffff FLOAT_VEC4  (8b52) Array=0 BL=-212702986 off=38875 ast= 3 mst=128 RM=1 AC= 0 ____F_ "out_FragColor"
Resource [Variable] 92e5: 1 (Prog=0012)
  0: Loc=ffff FLOAT_MAT4  (8b5c) Array=0 BL= 0 off=64 ast= 0 mst=16 RM=0 AC=-1 V_____ "ViewMatrix2"

関連エントリ
OpenGL ES 3.0/OpenGL 4.x Uniform Block
OpenGL の各バージョンと GLSL の互換性
OpenGL のエラー判定と OpenGL 4.3 Debug Output
OpenGL ES 3.0/OpenGL 4.4 Texture Object と Sampler Object
OpenGL ES 3.0 と Vertex Array Object