glLinkProgram error using subroutines

Dutta · September 1, 2014, 2:06pm

I am currently developing a shader library which utilizes subroutines. Compiling the shaders works fine, although linking them outputs this error:

Internal error: assembly compile error for fragment shader at offset 7617:

-- error message --
line 203, column 13:  error: CBUFFER variables may be used only in LDC instructions
line 204, column 13:  error: CBUFFER variables may be used only in LDC instructions
line 205, column 13:  error: CBUFFER variables may be used only in LDC instructions
line 206, column 13:  error: CBUFFER variables may be used only in LDC instructions

I then get the internal assembly text:

-- internal assembly text --
!!NVfp5.0
OPTION NV_gpu_program_fp64;
OPTION NV_bindless_texture;
OPTION NV_shader_atomic_float;
OPTION ARB_draw_buffers;
# cgc version 3.4.0001, build date Jul  2 2014
# command line args: 
#vendor NVIDIA Corporation
#version 3.4.0.1
#profile gp5fp
#program main
#semantic PerFrame : BUFFER[0]
#semantic ForwardLights : BUFFER[1]
#semantic JointPalette
#semantic JointInstanceTexture
#semantic ModelArray
#semantic LightShadowTexture
#semantic GlobalBackLightColor
#semantic GlobalLightColor
#semantic GlobalAmbientLightColor
#semantic GlobalLightDir
#semantic GlobalBackLightOffset
#semantic Model
#semantic InvModel
#semantic EmitterTransform
#semantic OcclusionConstants
#semantic RenderTargetDimensions
#semantic RepeatIndex
#semantic MatDiffuse
#semantic MatEmissiveIntensity
#semantic MatSpecularIntensity
#semantic AlphaSensitivity
#semantic AlphaBlendFactor
#semantic LightMapIntensity
#semantic FresnelPower
#semantic FresnelStrength
#semantic ObjectId
#semantic TessellationFactor
#semantic MaxDistance
#semantic MinDistance
#semantic HeightScale
#semantic SceneScale
#semantic AnimationDirection
#semantic AnimationAngle
#semantic Time
#semantic Random
#semantic AnimationLinearSpeed
#semantic AnimationAngularSpeed
#semantic NumXTiles
#semantic NumYTiles
#semantic WindWaveSize
#semantic WindSpeed
#semantic WindDirection
#semantic WindIntensity
#semantic WindForce
#semantic ViewMatrixArray
#semantic DiffuseMap
#semantic DisplacementMap
#semantic SpecularMap
#semantic EmissiveMap
#semantic NormalMap
#semantic RoughnessMap
#semantic EnvironmentMap
#semantic calcColor
#semantic calcBump
#semantic calcSpec
#semantic calcDepth
#semantic calcEnv
#var float4x4 View : BUFFER[0] : buffer[0][0], 4 : -1 : 0
#var float4x4 InvView : BUFFER[0] : buffer[0][64], 4 : -1 : 1
#var float4x4 ViewProjection : BUFFER[0] : buffer[0][128], 4 : -1 : 0
#var float4x4 Projection : BUFFER[0] : buffer[0][192], 4 : -1 : 0
#var float4x4 InvProjection : BUFFER[0] : buffer[0][256], 4 : -1 : 0
#var float4x4 InvViewProjection : BUFFER[0] : buffer[0][320], 4 : -1 : 0
#var float4 EyePos : BUFFER[0] : buffer[0][384] : -1 : 1
#var float4 FocalLength : BUFFER[0] : buffer[0][400] : -1 : 0
#var float4x4 LightProjTransformArray[0] :  : buffer[1][0], 4 : -1 : 0
#var float4 LightPositionsArray[0] :  : buffer[1][64] : -1 : 0
#var float4 LightColorArray[0] :  : buffer[1][80] : -1 : 0
#var float4 LightProjMapOffsetArray[0] :  : buffer[1][96] : -1 : 0
#var float4 LightShadowMapOffsetArray[0] :  : buffer[1][112] : -1 : 0
#var float4 LightShadowSizeArray[0] :  : buffer[1][128] : -1 : 0
#var int NumActiveLights : BUFFER[1] : buffer[1][144] : -1 : 0
#var float LightInvRangeArray[0] :  : buffer[1][148] : -1 : 0
#var int LightTypeArray[0] :  : buffer[1][152] : -1 : 0
#var bool LightCastsShadowsArray[0] :  : buffer[1][156] : -1 : 0
#var float4x4 JointPalette[0] :  : , 4 : -1 : 0
#var ulong JointInstanceTexture :  :  : -1 : 0
#var float4x4 ModelArray[0] :  : , 4 : -1 : 0
#var ulong LightShadowTexture :  :  : -1 : 0
#var float4 GlobalBackLightColor :  :  : -1 : 0
#var float4 GlobalLightColor :  :  : -1 : 0
#var float4 GlobalAmbientLightColor :  :  : -1 : 0
#var float4 GlobalLightDir :  :  : -1 : 0
#var float GlobalBackLightOffset :  :  : -1 : 0
#var float4x4 Model :  : , 4 : -1 : 0
#var float4x4 InvModel :  : , 4 : -1 : 0
#var float4x4 EmitterTransform :  : , 4 : -1 : 0
#var float4 OcclusionConstants :  :  : -1 : 0
#var float4 RenderTargetDimensions :  :  : -1 : 0
#var int RepeatIndex :  :  : -1 : 0
#var float4 MatDiffuse :  :  : -1 : 0
#var float MatEmissiveIntensity :  :  : -1 : 0
#var float MatSpecularIntensity :  : c[0] : -1 : 1
#var float AlphaSensitivity :  :  : -1 : 0
#var float AlphaBlendFactor :  : c[1] : -1 : 1
#var float LightMapIntensity :  :  : -1 : 0
#var float FresnelPower :  :  : -1 : 0
#var float FresnelStrength :  :  : -1 : 0
#var int ObjectId :  :  : -1 : 0
#var float TessellationFactor :  :  : -1 : 0
#var float MaxDistance :  :  : -1 : 0
#var float MinDistance :  :  : -1 : 0
#var float HeightScale :  :  : -1 : 0
#var float SceneScale :  :  : -1 : 0
#var float2 AnimationDirection :  :  : -1 : 0
#var float AnimationAngle :  :  : -1 : 0
#var float Time :  :  : -1 : 0
#var float Random :  :  : -1 : 0
#var float AnimationLinearSpeed :  :  : -1 : 0
#var float AnimationAngularSpeed :  :  : -1 : 0
#var int NumXTiles :  :  : -1 : 0
#var int NumYTiles :  :  : -1 : 0
#var float WindWaveSize :  :  : -1 : 0
#var float WindSpeed :  :  : -1 : 0
#var float4 WindDirection :  :  : -1 : 0
#var float WindIntensity :  :  : -1 : 0
#var float WindForce :  :  : -1 : 0
#var float4x4 ViewMatrixArray[0] :  : , 4 : -1 : 0
#var ulong DiffuseMap :  : c[2] : -1 : 1
#var ulong DisplacementMap :  :  : -1 : 0
#var ulong SpecularMap :  : c[3] : -1 : 1
#var ulong EmissiveMap :  :  : -1 : 0
#var ulong NormalMap :  : c[4] : -1 : 1
#var ulong RoughnessMap :  : c[5] : -1 : 1
#var ulong EnvironmentMap :  : c[6] : -1 : 1
#function 5 EnvironmentMapColor(4) () -> ()
#function 6 AlphaColorMultiply(5) () -> ()
#function 7 AlphaColor(6) () -> ()
#function 8 SimpleColorMultiply(7) () -> ()
#function 9 SimpleColor(8) () -> ()
#subroutine 0 calcColor CalculateColor
#function 1 FlatNormalFunctor(0) () -> ()
#function 2 NormalMapFunctor(1) () -> ()
#subroutine 1 calcBump CalculateBump
#function 10 ReflectiveSpecularFunctor(9) () -> ()
#function 11 NonReflectiveSpecularFunctor(10) () -> ()
#subroutine 2 calcSpec CalculateSpecular
#function 12 ViewSpaceDepthFunctor(11) () -> ()
#subroutine 3 calcDepth CalculateDepth
#function 3 NoEnvironment(2) () -> ()
#function 4 EnvironmentPBR(3) () -> ()
#subroutine 4 calcEnv CalculateEnvironment
#var float3 ViewSpacePos : $vin.ATTR0 : ATTR0 : -1 : 1
#var float3 Tangent : $vin.ATTR1 : ATTR1 : -1 : 1
#var float3 Normal : $vin.ATTR2 : ATTR2 : -1 : 1
#var float3 Binormal : $vin.ATTR3 : ATTR3 : -1 : 1
#var float2 UV : $vin.ATTR4 : ATTR4 : -1 : 1
#var float4 Albedo : $vout.COL0 : COL0[0] : -1 : 1
#var float4 Normals : $vout.COL1 : COL1[1] : -1 : 1
#var float Depth : $vout.COL2 : COL2[2] : -1 : 1
#var float4 Specular : $vout.COL3 : COL3[3] : -1 : 1
#var float4 Unshaded : $vout.COL4 : COL4[4] : -1 : 1
PARAM c[7] = { program.local[0..6] };
CBUFFER buf0[] = { program.buffer[0] };
CBUFFER buf1[] = { program.buffer[1] };
ATTRIB fragment_attrib[] = { fragment.attrib[0..4] };
TEMP R0, R1, R2, R3, R4, R5, R6, R7, R8, R9;
LONG TEMP D0, D1;
OUTPUT result_color0 = result.color;
OUTPUT result_color3 = result.color[3];
OUTPUT result_color4 = result.color[4];
OUTPUT result_color2 = result.color[2];
OUTPUT result_color1 = result.color[1];
SUBROUTINETYPE I0 { BB19, BB21, BB23, BB25, BB27 };
SUBROUTINE I0 program_subroutine_0 = program.subroutine[0];
SUBROUTINETYPE I1 { BB11, BB13 };
SUBROUTINE I1 program_subroutine_1 = program.subroutine[1];
SUBROUTINETYPE I2 { BB29, BB31 };
SUBROUTINE I2 program_subroutine_2 = program.subroutine[2];
SUBROUTINETYPE I3 { BB33 };
SUBROUTINE I3 program_subroutine_3 = program.subroutine[3];
SUBROUTINETYPE I4 { BB15, BB17 };
SUBROUTINE I4 program_subroutine_4 = program.subroutine[4];
PK64.U D0.x, c[2];
PK64.U D1.x, c[3];
TEX.F R0, fragment.attrib[4], handle(D0.x), 2D;
TEX.F R1.xyz, fragment.attrib[4], handle(D1.x), 2D;
PK64.U D1.x, c[4];
PK64.U D0.x, c[5];
MOV.F R2.xyz, fragment.attrib[1];
MOV.F R3.xyz, fragment.attrib[3];
MOV.F R4.xyz, fragment.attrib[2];
TEX.F R5.yw, fragment.attrib[4], handle(D1.x), 2D;
TEX.F R5.x, fragment.attrib[4], handle(D0.x), 2D;
CALI  program_subroutine_1;
MOV.F R3.xyz, R1;
MOV.F R1.w, R5.x;
MOV.F R2.xyz, R4;
MOV.F R6.xyz, fragment.attrib[0];
LDC.F32X4 R7.xyz, buf0[384];
PK64.U D0.x, c[6];
MOV.F R8.x, buf0[64];
MOV.F R9.x, buf0[80];
MOV.F R8.w, buf0[96].x;
MOV.F R9.w, buf0[112].x;
CALI  program_subroutine_4;
MOV.F R3, {1, 0, 0, 0}.x;
MOV.F R2.w, R5.x;
MOV.F R4.xyz, R6;
MOV.F R1.w, c[1].x;
CALI  program_subroutine_0;
MOV.F result_color0, R0;
MOV.F R3.xyz, R1;
MOV.F R0.w, R5.x;
MOV.F R1.xyz, R4;
MOV.F R0.x, c[0];
CALI  program_subroutine_2;
MOV.F result_color3, R0;
MOV.F result_color4, {0, 1, 0, 0}.xxxy;
MOV.F R0.xyz, fragment.attrib[0];
CALI  program_subroutine_3;
DP3.F R0.x, R2, R2;
RSQ.F R0.x, R0.x;
MUL.F R1.xyz, R0.x, R2;
ADD.F R0.x, R1.z, {1, 0, 0, 0};
DIV.F R0.xy, R1, R0.x;
MAD.F R0.zw, R0.xyxy, {0.28126231, 0.5, 0, 0}.x, {0.28126231, 0.5, 0, 0}.y;
MAD.F R0.x, R0.w, {0.5, 0, 0, 0}, {0.5, 0, 0, 0};
MUL.F R0.y, R0.x, {255.99609, 0, 0, 0}.x;
MAD.F R0.x, R0.z, {0.5, 0, 0, 0}, {0.5, 0, 0, 0};
FLR.F R0.z, R0.y;
FRC.F result_color1.w, R0.y;
MUL.F R0.y, R0.x, {255.99609, 0, 0, 0}.x;
FLR.F R0.x, R0.y;
MUL.F result_color1.x, R0, {0.00390625, 0, 0, 0};
MUL.F result_color1.z, R0, {0.00390625, 0, 0, 0}.x;
FRC.F result_color1.y, R0;
MOV.F result_color2.x, R1.w;
RET   (TR);
BB11 SUBROUTINENUM(0):
RET   (TR);
BB13 SUBROUTINENUM(1):
MAD.F R5.zw, R5.xywy, {2, -1, 0, 0}.x, {2, -1, 0, 0}.y;
DP3.F R1.w, R3, R3;
RSQ.F R1.w, R1.w;
MUL.F R3.xyz, R1.w, R3;
DP3.F R1.w, R2, R2;
RSQ.F R1.w, R1.w;
MUL.F R2.xyz, R1.w, R2;
MUL.F R3.xyz, R5.w, R3;
DP3.F R1.w, R4, R4;
DP2.F R2.w, R5.zwzw, R5.zwzw;
ADD.F R2.w, -R2, {1, 0, 0, 0}.x;
RSQ.F R2.w, R2.w;
MAD.F R2.xyz, R5.z, R2, R3;
RSQ.F R1.w, R1.w;
RCP.F.SAT R2.w, R2.w;
MUL.F R3.xyz, R1.w, R4;
MAD.F R4.xyz, R2.w, R3, R2;
RET   (TR);
BB15 SUBROUTINENUM(2):
MOV.F R6.xyz, {1, 0, 0, 0}.x;
RET   (TR);
BB17 SUBROUTINENUM(3):
MUL.F R5.yzw, R9.xxyz, R6.y;
MAD.F R5.yzw, R8.xxyz, R6.x, R5;
MAD.F R5.yzw, R8.xwyz, R6.z, R5;
ADD.F R5.yzw, R5, R9.xwyz;
ADD.F R7.xyz, R7, -R5.yzww;
DP3.F R2.w, R7, R7;
RSQ.F R2.w, R2.w;
MUL.F R7.xyz, R2.w, R7;
MUL.F R9.xyz, R4.y, R9;
MAD.F R9.xyz, R4.x, R8, R9;
DP3.F R2.w, R6, R6;
MAD.F R8.xyz, R4.z, R8.wyzw, R9;
RSQ.F R2.w, R2.w;
MUL.F R6.xyz, R2.w, R6;
ADD.F R8.xyz, R8, {0, 0, 0, 0}.x;
DP3.F R2.w, R4, R6;
DP3.F R3.w, R8, -R7;
MUL.F R4.xyz, R8, R3.w;
ADD.F R3.w, -R2, {1, 0, 0, 0}.x;
MAD.F R6.xyz, -R4, {2, 0, 0, 0}.x, -R7;
MAD.F R2.w, -R1, {3, 4, 0, 0}.x, {3, 4, 0, 0}.y;
POW.F R3.w, R3.w, {5, 0, 0, 0}.x;
DIV.F R2.w, R3, R2.w;
MAD.F R4.xyz, -R3, R2.w, R2.w;
ADD.F.SAT R3.xyz, R3, R4;
MAD.F R6.w, -R1, {9, 0, 0, 0}.x, {9, 0, 0, 0}.x;
TXL.F R4.xyz, R6, handle(D0.x), CUBE;
MUL.F R6.xyz, R4, R3;
RET   (TR);
BB19 SUBROUTINENUM(4):
MAD.F R3.xyz, R6, R2.w, -R2.w;
MAD.F R0.xyz, R3, R0, R0;
RET   (TR);
BB21 SUBROUTINENUM(5):
MUL.F R0, R0, R3;
MUL.F R0, R0, R1.w;
RET   (TR);
BB23 SUBROUTINENUM(6):
MUL.F R0, R0, R1.w;
RET   (TR);
BB25 SUBROUTINENUM(7):
MUL.F R0, R0, R3;
RET   (TR);
BB27 SUBROUTINENUM(8):
RET   (TR);
BB29 SUBROUTINENUM(9):
MUL.F R0.xyz, R3, R0.x;
MUL.F R0.xyz, R0, R1;
RET   (TR);
BB31 SUBROUTINENUM(10):
MUL.F R0.xyz, R3, R0.x;
RET   (TR);
BB33 SUBROUTINENUM(11):
DP3.F R0.x, R0, R0;
RSQ.F R0.x, R0.x;
RCP.F R1.w, R0.x;
RET   (TR);
END
# 126 instructions, 10 R-regs, 2 D-regs

I have tested this on an ATI 7970 and it works fine.

My setup is W7 with a GTX 690 using the 340.52 driver.

Dutta · October 11, 2014, 11:23am

I forgot to post the GLSL code used to generate the error.

#version 440
subroutine vec4 CalculateColor(vec4 albedoColor, vec3 environmentColor, vec4 color, float alphaBlend);
#line 55 1
subroutine (CalculateColor) vec4
SimpleColor(vec4 albedoColor, vec3 environmentColor, vec4 color, float alphaBlend)
{
#line 61 1
return albedoColor;
}
#line 64 2
subroutine (CalculateColor) vec4
SimpleColorMultiply(vec4 albedoColor, vec3 environmentColor, vec4 color, float alphaBlend)
{
#line 70 2
return albedoColor * color;
}
#line 73 3
subroutine (CalculateColor) vec4
AlphaColor(vec4 albedoColor, vec3 environmentColor, vec4 color, float alphaBlend)
{
#line 79 3
return albedoColor * alphaBlend;
}
#line 82 4
subroutine (CalculateColor) vec4
AlphaColorMultiply(vec4 albedoColor, vec3 environmentColor, vec4 color, float alphaBlend)
{
#line 88 4
return albedoColor * color * alphaBlend;
}
#line 91 5
subroutine (CalculateColor) vec4
EnvironmentMapColor(vec4 albedoColor, vec3 environmentColor, vec4 color, float alphaBlend)
{
#line 97 5
vec4 result = albedoColor;
	result.rgb *= environmentColor;
	return result;
}
subroutine vec3 CalculateBump(in vec3 tangent, in vec3 binormal, in vec3 normal, in vec4 bump);
#line 106 7
subroutine (CalculateBump) vec3
NormalMapFunctor(vec3 tangent, vec3 binormal, vec3 normal, vec4 bumpData)
{
#line 112 7
mat3 tangentViewMatrix = mat3(normalize(tangent.xyz), normalize(binormal.xyz), normalize(normal.xyz));
	vec3 tNormal = vec3(0,0,0);
	tNormal.xy = (bumpData.ag * 2.0f) - 1.0f;
	tNormal.z =  clamp(sqrt(1.0f - dot(tNormal.xy, tNormal.xy)), 0, 1) ;
	return tangentViewMatrix * tNormal;
}
#line 119 8
subroutine (CalculateBump) vec3
FlatNormalFunctor(vec3 tangent, vec3 binormal, vec3 normal, vec4 bumpData)
{
#line 125 8
return normal;
}
subroutine vec4 CalculateSpecular(in vec3 specularColor, in float specularIntensity, in vec3 environmentColor, in float roughness);
#line 131 10
subroutine (CalculateSpecular) vec4
NonReflectiveSpecularFunctor(vec3 specularColor, float specularIntensity, vec3 environmentColor, float roughness)
{
#line 137 10
return vec4(specularColor * specularIntensity, roughness);
}
#line 140 11
subroutine (CalculateSpecular) vec4
ReflectiveSpecularFunctor(vec3 specularColor, float specularIntensity, vec3 environmentColor, float roughness)
{
#line 146 11
return vec4(specularColor * specularIntensity * environmentColor, roughness);
}
subroutine float CalculateDepth(in vec3 viewSpacePosition);
#line 154 13
subroutine (CalculateDepth) float
ViewSpaceDepthFunctor(vec3 viewSpacePosition)
{
#line 156 13
return length(viewSpacePosition);
}
subroutine vec3 CalculateEnvironment(in vec3 specularColor, in samplerCube environmentMap, in vec3 viewSpaceNormal, in vec3 viewSpacePos, in vec4 eyePos, in mat4x4 invView, in float roughness);
#line 163 15
subroutine (CalculateEnvironment) vec3
EnvironmentPBR(vec3 specularColor, samplerCube environmentMap, vec3 viewSpaceNormal, vec3 viewSpacePos, vec4 eyePos, mat4x4 invView, float roughness)
{
#line 172 15
vec3 worldViewVec = normalize(eyePos.xyz - (invView * vec4(viewSpacePos, 1)).xyz);
	vec3 reflectVec = reflect(-worldViewVec, (invView * vec4(viewSpaceNormal, 0)).xyz);
	float  x = dot(viewSpaceNormal, normalize(viewSpacePos.xyz));
	vec3 rim = specularColor + (1 - specularColor) * (pow((1 - x), 5) / (4 - 3 * roughness));
	vec3 envColor = textureLod(environmentMap, reflectVec, (1 - roughness) * 9).rgb *  clamp(rim, 0, 1) ;
	return envColor;
}
#line 180 16
subroutine (CalculateEnvironment) vec3
NoEnvironment(vec3 specularColor, samplerCube environmentMap, vec3 viewSpaceNormal, vec3 viewSpacePos, vec4 eyePos, mat4x4 invView, float roughness)
{
#line 189 16
return vec3(1);
}
uniform sampler2D JointInstanceTexture;
uniform sampler2D LightShadowTexture;
uniform vec4 GlobalLightDir;
uniform vec4 GlobalLightColor;
uniform vec4 GlobalBackLightColor;
uniform vec4 GlobalAmbientLightColor;
uniform float GlobalBackLightOffset;
uniform mat4x4 EmitterTransform;
uniform vec4 RenderTargetDimensions;
uniform vec4 MatDiffuse;
uniform float LightMapIntensity;
uniform float AlphaSensitivity;
uniform float AlphaBlendFactor;
uniform float MatSpecularIntensity;
uniform float FresnelPower;
uniform float FresnelStrength;
uniform float TessellationFactor;
uniform float MaxDistance;
uniform float MinDistance;
uniform float HeightScale;
uniform float SceneScale;
uniform vec2 AnimationDirection;
uniform float AnimationAngle;
uniform float AnimationLinearSpeed;
uniform float AnimationAngularSpeed;
uniform int NumXTiles;
uniform int NumYTiles;
uniform vec4 WindDirection;
uniform float WindWaveSize;
uniform float WindSpeed;
uniform float WindIntensity;
uniform float WindForce;
uniform sampler2D DiffuseMap;
uniform sampler2D DisplacementMap;
uniform sampler2D SpecularMap;
uniform sampler2D EmissiveMap;
uniform sampler2D NormalMap;
uniform sampler2D RoughnessMap;
uniform samplerCube EnvironmentMap;
subroutine uniform CalculateColor calcColor;
subroutine uniform CalculateBump calcBump;
subroutine uniform CalculateSpecular calcSpec;
subroutine uniform CalculateDepth calcDepth;
subroutine uniform CalculateEnvironment calcEnv;

layout(shared) uniform Joints
{
    mat4x4 JointPalette[96];
};

layout(shared) uniform PerBatch
{
    mat4x4 ModelArray[128];
};

layout(shared) uniform PerFrame
{
    mat4x4 View;
    mat4x4 InvView;
    mat4x4 ViewProjection;
    mat4x4 Projection;
    mat4x4 InvProjection;
    mat4x4 InvViewProjection;
    vec4 EyePos;
    vec4 FocalLength;
    vec4 TimeAndRandom;
};

layout(shared) uniform ForwardLights
{
    mat4x4 LightProjTransformArray[16];
    vec4 LightPositionsArray[16];
    vec4 LightColorArray[16];
    vec4 LightProjMapOffsetArray[16];
    vec4 LightShadowMapOffsetArray[16];
    vec4 LightShadowSizeArray[16];
    int NumActiveLights;
    float LightInvRangeArray[16];
    int LightTypeArray[16];
    bool LightCastsShadowsArray[16];
};

layout(shared) uniform PerObject
    {
    mat4x4 Model;
    mat4x4 InvModel;
    int ObjectId;
};

layout(shared) uniform ViewMatrices
{
    mat4x4 ViewMatrixArray[6];
};

layout(location = 0) in vec3 ViewSpacePos;
layout(location = 1) in vec3 Tangent;
layout(location = 2) in vec3 Normal;
layout(location = 3) in vec3 Binormal;
layout(location = 4) in vec2 UV;
layout(location = 0) out vec4 Albedo;
layout(location = 1) out vec4 Normals;
layout(location = 2) out float Depth;
layout(location = 3) out vec4 Specular;

void
main()
{
#line 555 63
vec4 diffColor = texture(DiffuseMap, UV);
	float  roughness = texture(RoughnessMap, UV).r;
	vec4 emsvColor = texture(EmissiveMap, UV);
	vec4 specColor = texture(SpecularMap, UV);

	vec4 normals = texture(NormalMap, UV);
	vec3 bumpNormal = calcBump(Tangent, Binormal, Normal, normals);

	vec3 environment = calcEnv(specColor.rgb, EnvironmentMap, bumpNormal, ViewSpacePos, EyePos, InvView, roughness);
	Albedo = calcColor(diffColor, environment, vec4(1), AlphaBlendFactor);

	Specular = calcSpec(specColor.rgb, MatSpecularIntensity, environment, roughness);
	Depth = calcDepth(ViewSpacePos);
	Normals = PackViewSpaceNormal(bumpNormal);
}

Topic		Replies	Views
Internal error: assembly compile error for tessellation evaluation shader at offset OpenGL	1	1170	March 29, 2016
OpenGL - Cannot link stereo VTG program with geometry shader. (Edit - LINKED, but NANS in Geometry Shader Output) Linux	3	206	May 26, 2023
Bug Arrays Nvidia OpenGL GLSL compiler crash on this shader OpenGL	1	1415	May 11, 2021
Invalid vertex program header Vulkan	5	1922	February 10, 2017
Error with Texture CUDA Programming and Performance	0	663	August 26, 2018
VisionWorks Render make Error Compile Jetson Xavier NX compile , visionworks	7	1074	October 18, 2021
ovxio::RENDER - Undefined reference to symbol cudaGraphicsMapResources Jetson Xavier NX cuda , visionworks	6	1350	October 18, 2021
[BUG] Compiler issues internal error: "offset for relative array access outside supported range" OpenGL	4	1752	May 8, 2021
cudaGraphicsGLRegisterBuffer and unspecified driver error CUDA Programming and Performance	5	4609	September 22, 2011
GL_ARB_gpu_shader_int64 compiler breaks code logic. Linux	0	729	November 23, 2017

glLinkProgram error using subroutines

Related topics