Some GLSL shader doesn't link

[slipher]

I tried launching 0.56 RC2 with -set r_lazyShaders 0 to verify that all the shaders build. At least one of them doesn't:

Warn: Link log: 
Warn: error: fragment shader input `var_TexCoords' has no matching output in the previous stage
error: fragment shader input `var_Color' has no matching output in the previous stage
 
Warn: Built-in shaders failed: Shader program failed to link! 

I can't tell which one it is, as the logging leaves something to be desired (see #1863).

[illwieckz]

On my end I get this:

Warn: Source for shader program lightMapping:
   0: #version 460 core
   1: 
   2: #define HAVE_EXT_gpu_shader4 1
   3: #define HAVE_ARB_gpu_shader5 1
   4: #define HAVE_ARB_shading_language_420pack 1
   5: #define HAVE_ARB_texture_float 1
   6: #define HAVE_ARB_texture_gather 1
   7: #define HAVE_EXT_texture_integer 1
   8: #define HAVE_ARB_texture_rg 1
   9: #define HAVE_ARB_uniform_buffer_object 1
  10: #extension GL_ARB_shader_draw_parameters : require
  11: #define HAVE_ARB_shader_draw_parameters 1
  12: #define HAVE_ARB_shader_storage_buffer_object 1
  13: #extension GL_KHR_shader_subgroup_basic : require
  14: #define HAVE_KHR_shader_subgroup_basic 1
  15: #extension GL_KHR_shader_subgroup_vote : require
  16: #define HAVE_KHR_shader_subgroup_vote 1
  17: #extension GL_KHR_shader_subgroup_arithmetic : require
  18: #define HAVE_KHR_shader_subgroup_arithmetic 1
  19: #extension GL_KHR_shader_subgroup_ballot : require
  20: #define HAVE_KHR_shader_subgroup_ballot 1
  21: #extension GL_KHR_shader_subgroup_shuffle : require
  22: #define HAVE_KHR_shader_subgroup_shuffle 1
  23: #extension GL_KHR_shader_subgroup_shuffle_relative : require
  24: #define HAVE_KHR_shader_subgroup_shuffle_relative 1
  25: #extension GL_KHR_shader_subgroup_quad : require
  26: #define HAVE_KHR_shader_subgroup_quad 1
  27: 
  28: struct GlobalUniforms {
  29: 	vec3 u_LightGridOrigin;
  30: 	float u_GlobalLightFactor;
  31: 	vec3 u_LightGridScale;
  32: 	bool u_SRGB;
  33: 	uint u_FirstPortalGroup;
  34: 	uint u_TotalPortals;
  35: 	uint u_SurfaceDescriptorsCount;
  36: 	float u_ProfilerZero;
  37: 	vec3 u_blurVec;
  38: 	uint u_Frame;
  39: 	vec4 u_ColorModulate;
  40: 	vec4 u_TonemapParms;
  41: 	bool u_UseFrustumCulling;
  42: 	bool u_UseOcclusionCulling;
  43: 	int u_numLights;
  44: 	float u_InverseGamma;
  45: 	bool u_Tonemap;
  46: 	float u_Exposure;
  47: 	float _pad1;
  48: 	float _pad2;
  49: };
  50: 
  51: layout(std140, binding = 3) uniform globalUBO {
  52: GlobalUniforms globalUniforms;
  53: };
  54: 
  55: #define u_LightGridOrigin globalUniforms.u_LightGridOrigin
  56: #define u_GlobalLightFactor globalUniforms.u_GlobalLightFactor
  57: #define u_LightGridScale globalUniforms.u_LightGridScale
  58: #define u_SRGB globalUniforms.u_SRGB
  59: #define u_FirstPortalGroup globalUniforms.u_FirstPortalGroup
  60: #define u_TotalPortals globalUniforms.u_TotalPortals
  61: #define u_SurfaceDescriptorsCount globalUniforms.u_SurfaceDescriptorsCount
  62: #define u_ProfilerZero globalUniforms.u_ProfilerZero
  63: 
  64: #define u_blurVec globalUniforms.u_blurVec
  65: #define u_Frame globalUniforms.u_Frame
  66: #define u_ColorModulate globalUniforms.u_ColorModulate
  67: #define u_TonemapParms globalUniforms.u_TonemapParms
  68: #define u_UseFrustumCulling globalUniforms.u_UseFrustumCulling
  69: #define u_UseOcclusionCulling globalUniforms.u_UseOcclusionCulling
  70: #define u_numLights globalUniforms.u_numLights
  71: #define u_InverseGamma globalUniforms.u_InverseGamma
  72: #define u_Tonemap globalUniforms.u_Tonemap
  73: #define u_Exposure globalUniforms.u_Exposure
  74: 
  75: #ifndef r_AmbientScale
  76: #define r_AmbientScale 1.00000000e+00
  77: #endif
  78: #ifndef r_SpecularScale
  79: #define r_SpecularScale 1.00000000e+00
  80: #endif
  81: #ifndef r_zNear
  82: #define r_zNear 3.00000000e+00
  83: #endif
  84: #ifndef M_PI
  85: #define M_PI 3.14159274e+00
  86: #endif
  87: #ifndef MAX_REF_LIGHTS
  88: #define MAX_REF_LIGHTS 1024
  89: #endif
  90: #ifndef NUM_LIGHT_LAYERS
  91: #define NUM_LIGHT_LAYERS 4
  92: #endif
  93: #ifndef TILE_SIZE
  94: #define TILE_SIZE 16
  95: #endif
  96: #ifndef r_FBufSize
  97: #define r_FBufSize vec2(2.56000000e+03, 1.44000000e+03)
  98: #endif
  99: #ifndef r_tileStep
 100: #define r_tileStep vec2(6.25000009e-03, 1.11111114e-02)
 101: #endif
 102: #ifndef LIGHTGRID_AVERAGE_COSINE
 103: #define LIGHTGRID_AVERAGE_COSINE 4.00000006e-01
 104: #endif
 105: #ifndef r_realtimeLighting
 106: #define r_realtimeLighting 1
 107: #endif
 108: #ifndef r_vertexSkinning
 109: #define r_vertexSkinning 1
 110: #endif
 111: const int MAX_GLSL_BONES = 256;
 112: #ifndef r_halfLambertLighting
 113: #define r_halfLambertLighting 1
 114: #endif
 115: #ifndef r_accurateSRGB
 116: #define r_accurateSRGB 1
 117: #endif
 118: #ifndef r_normalMapping
 119: #define r_normalMapping 1
 120: #endif
 121: #ifndef r_specularMapping
 122: #define r_specularMapping 1
 123: #endif
 124: #ifndef r_physicalMapping
 125: #define r_physicalMapping 1
 126: #endif
 127: #ifndef r_glowMapping
 128: #define r_glowMapping 1
 129: #endif
 130: #ifndef r_colorGrading
 131: #define r_colorGrading 1
 132: #endif
 133: #ifndef r_highPrecisionRendering
 134: #define r_highPrecisionRendering 1
 135: #endif
 136: #define IN(mode) mode in
 137: #define DECLARE_OUTPUT(type) out type outputColor;
 138: #define textureCube texture
 139: #define texture2D texture
 140: #define texture2DProj textureProj
 141: #define texture3D texture
 142: IN(flat) int in_drawID;
 143: IN(flat) int in_baseInstance;
 144: #define drawID in_drawID
 145: #define baseInstance in_baseInstance
 146: 
 147: #ifndef BIND_LIGHTS
 148: #define BIND_LIGHTS 4
 149: #endif
 150: #ifndef USE_PUSH_BUFFER
 151: #define USE_PUSH_BUFFER 1
 152: #endif
 153: #ifndef USE_GRID_DELUXE_MAPPING
 154: #define USE_GRID_DELUXE_MAPPING 1
 155: #endif
 156: /*
 157: ===========================================================================
 158: Copyright (C) 2006-2011 Robert Beckebans <trebor_7@users.sourceforge.net>
 159: 
 160: This file is part of XreaL source code.
 161: 
 162: XreaL source code is free software; you can redistribute it
 163: and/or modify it under the terms of the GNU General Public License as
 164: published by the Free Software Foundation; either version 2 of the License,
 165: or (at your option) any later version.
 166: 
 167: XreaL source code is distributed in the hope that it will be
 168: useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 169: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 170: GNU General Public License for more details.
 171: 
 172: You should have received a copy of the GNU General Public License
 173: along with XreaL source code; if not, write to the Free Software
 174: Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 175: ===========================================================================
 176: */
 177: 
 178: /* lightMapping_fp.glsl */
 179: 
10000: #line 10000 // common.glsl
10001: /*
10002: ===========================================================================
10003: 
10004: Daemon BSD Source Code
10005: Copyright (c) 2024-2025 Daemon Developers
10006: All rights reserved.
10007: 
10008: This file is part of the Daemon BSD Source Code (Daemon Source Code).
10009: 
10010: Redistribution and use in source and binary forms, with or without
10011: modification, are permitted provided that the following conditions are met:
10012: 	* Redistributions of source code must retain the above copyright
10013: 	  notice, this list of conditions and the following disclaimer.
10014: 	* Redistributions in binary form must reproduce the above copyright
10015: 	  notice, this list of conditions and the following disclaimer in the
10016: 	  documentation and/or other materials provided with the distribution.
10017: 	* Neither the name of the Daemon developers nor the
10018: 	  names of its contributors may be used to endorse or promote products
10019: 	  derived from this software without specific prior written permission.
10020: 
10021: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
10022: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
10023: WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
10024: DISCLAIMED. IN NO EVENT SHALL DAEMON DEVELOPERS BE LIABLE FOR ANY
10025: DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
10026: (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
10027: LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
10028: ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
10029: (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
10030: SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
10031: 
10032: ===========================================================================
10033: */
10034: 
10035: /* common.glsl */
10036: 
10037: /* Common defines */
10038: 
10039: /* Allows accessing each element of a uvec4 array with a singular ID
10040: Useful to avoid wasting memory due to alignment requirements
10041: array must be in the form of uvec4 array[] */
10042: 
10043: #define UINT_FROM_UVEC4_ARRAY( array, id ) ( ( array )[( id ) / 4][( id ) % 4] )
10044: #define UVEC2_FROM_UVEC4_ARRAY( array, id ) ( ( id ) % 2 == 0 ? ( array )[( id ) / 2].xy : ( array )[( id ) / 2].zw )
10045: 
10046: // Common functions
10047: 
10048: #if defined(HAVE_EXT_gpu_shader4)
10049: 	#define colorPack uint
10050: 	#define colorModulatePack uint
10051: #else
10052: 	#define colorPack vec4
10053: 	#define colorModulatePack vec4
10054: #endif
10055: 
10056: vec4 UnpackColor( const in colorPack packedColor )
10057: {
10058: #if defined(HAVE_EXT_gpu_shader4)
10059: 	return unpackUnorm4x8( packedColor );
10060: #else
10061: 	return packedColor;
10062: #endif
10063: }
10064: 
10065: /* colorMod uint format:
10066: 
10067: colorMod << 0: color * 1
10068: colorMod << 1: color * ( -1 )
10069: colorMod << 2: alpha * 1
10070: colorMod << 3: alpha * ( -1 )
10071: colorMod << 4-27: available for future usage
10072: colorMod << 28-31: lightFactor
10073: 
10074: colorMod float format:
10075: 
10076: colorMod[ 0 ]: color * f
10077: colorMod[ 1 ]: lightFactor
10078: colorMod[ 3 ]: alpha * f */
10079: 
10080: vec4 ColorModulateToColor( const in colorModulatePack colorMod )
10081: {
10082: #if defined(HAVE_EXT_gpu_shader4)
10083: 	vec3 colorModArray = vec3( 0.0f, 1.0f, -1.0f );
10084: 
10085: 	uint rgbIndex = colorMod & 3u;
10086: 	uint alphaIndex = ( colorMod >> 2u ) & 3u;
10087: 
10088: 	float rgb = colorModArray[ rgbIndex ];
10089: 	float alpha = colorModArray[ alphaIndex ];
10090: #else
10091: 	float rgb = colorMod.r;
10092: 	float alpha = colorMod.a;
10093: #endif
10094: 
10095: 	return vec4( rgb, rgb, rgb, alpha );
10096: }
10097: 
10098: float ColorModulateToLightFactor( const in colorModulatePack colorMod )
10099: {
10100: #if defined(HAVE_EXT_gpu_shader4)
10101: 	return float( colorMod >> 28u );
10102: #else
10103: 	return colorMod.g;
10104: #endif
10105: }
10106: 
10107: void ModulateColor(
10108: 	const in vec4 colorModulation,
10109: 	const in vec4 unpackedColor,
10110: 	inout vec4 color )
10111: {
10112: 	color *= colorModulation;
10113: 	color += unpackedColor;
10114: }
10115: 
10116: void ColorModulateColor(
10117: 	const in colorModulatePack colorMod,
10118: 	const in colorPack packedColor,
10119: 	inout vec4 color )
10120: {
10121: 	vec4 colorModulation = ColorModulateToColor( colorMod );
10122: 
10123: 	vec4 unpackedColor = UnpackColor( packedColor );
10124: 
10125: 	ModulateColor( colorModulation, unpackedColor, color );
10126: }
10127: 
10128: void ColorModulateColor_lightFactor(
10129: 	const in colorModulatePack colorMod,
10130: 	const in colorPack packedColor,
10131: 	inout vec4 color )
10132: {
10133: 	vec4 colorModulation = ColorModulateToColor( colorMod );
10134: 	float lightFactor = ColorModulateToLightFactor( colorMod );
10135: 
10136: 	vec4 unpackedColor = UnpackColor( packedColor );
10137: 
10138: 	unpackedColor.rgb *= lightFactor;
10139: 
10140: 	ModulateColor( colorModulation, unpackedColor, color );
10141: }
 133: #line 133
20000: #line 20000 // computeLight_fp.glsl
20001: /*
20002: ===========================================================================
20003: Copyright (C) 2009-2011 Robert Beckebans <trebor_7@users.sourceforge.net>
20004: 
20005: This file is part of XreaL source code.
20006: 
20007: XreaL source code is free software; you can redistribute it
20008: and/or modify it under the terms of the GNU General Public License as
20009: published by the Free Software Foundation; either version 2 of the License,
20010: or (at your option) any later version.
20011: 
20012: XreaL source code is distributed in the hope that it will be
20013: useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
20014: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20015: GNU General Public License for more details.
20016: 
20017: You should have received a copy of the GNU General Public License
20018: along with XreaL source code; if not, write to the Free Software
20019: Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20020: ===========================================================================
20021: */
20022: // computeLight_fp.glsl - Light computing helper functions
20023: 
20024: #define COMPUTELIGHT_GLSL
20025: 
20026: #if !defined(USE_BSP_SURFACE)
20027: 	#define USE_MODEL_SURFACE
20028: #endif
20029: 
20030: #if !defined(USE_GRID_LIGHTING)
20031: 	#define USE_LIGHT_MAPPING
20032: #endif
20033: 
20034: #if defined(USE_REFLECTIVE_SPECULAR)
20035: uniform samplerCube u_EnvironmentMap0;
20036: uniform samplerCube u_EnvironmentMap1;
20037: uniform float u_EnvironmentInterpolation;
20038: 
20039: // Only the RGB components are meaningful
20040: // FIXME: using reflective specular will always globally decrease the scene brightness
20041: // because we're multiplying with something that can only be less than 1.
20042: vec4 EnvironmentalSpecularFactor( vec3 viewDir, vec3 normal )
20043: {
20044: 	vec4 envColor0 = textureCube(u_EnvironmentMap0, reflect( -viewDir, normal ) );
20045: 	vec4 envColor1 = textureCube(u_EnvironmentMap1, reflect( -viewDir, normal ) );
20046: 	return mix( envColor0, envColor1, u_EnvironmentInterpolation );
20047: }
20048: #endif // USE_REFLECTIVE_SPECULAR
20049: 
20050: // lighting helper functions
20051: 
20052: #if defined(USE_GRID_LIGHTING) || defined(USE_GRID_DELUXE_MAPPING)
20053: 	void ReadLightGrid( in vec4 texel1, in vec4 texel2, in float lightFactor, out vec3 lightDir, out vec3 ambientColor, out vec3 lightColor ) {
20054: 		vec3 totalColor = (1.0 + LIGHTGRID_AVERAGE_COSINE) * texel1.rgb;
20055: 		float total1Norm = totalColor.r + totalColor.g + totalColor.b;
20056: 		vec3 scaledLightDir = 2.0 * (texel2.xyz - (128.0 / 255.0));
20057: 		float directed1Norm = 3.0 * length(scaledLightDir);
20058: 		float directedFraction = clamp((LIGHTGRID_AVERAGE_COSINE * directed1Norm) / total1Norm, 0.0, 1.0);
20059: 		float directedScale = directedFraction / LIGHTGRID_AVERAGE_COSINE;
20060: 		float ambientScale = 1.0 - directedFraction;
20061: 		ambientColor = ambientScale * totalColor;
20062: 		lightColor = directedScale * totalColor;
20063: 		ambientColor *= lightFactor;
20064: 		lightColor *= lightFactor;
20065: 		lightDir = normalize(scaledLightDir);
20066: 	}
20067: #endif
20068: 
20069: #if defined(USE_DELUXE_MAPPING) || defined(USE_GRID_DELUXE_MAPPING) || defined(r_realtimeLighting)
20070: 	#if !defined(USE_PHYSICAL_MAPPING) && defined(r_specularMapping)
20071: 		uniform vec2 u_SpecularExponent;
20072: 
20073: 		vec3 computeSpecularity( vec3 lightColor, vec4 materialColor, float NdotH ) {
20074: 			return lightColor * materialColor.rgb * pow(NdotH, u_SpecularExponent.x * materialColor.a + u_SpecularExponent.y) * r_SpecularScale;
20075: 		}
20076: 	#endif
20077: #endif
20078: 
20079: #if defined(USE_DELUXE_MAPPING) || defined(USE_GRID_DELUXE_MAPPING) || defined(r_realtimeLighting)
20080: void computeDeluxeLight( vec3 lightDir, vec3 normal, vec3 viewDir, vec3 lightColor,
20081: 	vec4 diffuseColor, vec4 materialColor,
20082: 	inout vec4 color )
20083: {
20084: 	vec3 H = normalize( lightDir + viewDir );
20085: 
20086: 	#if defined(USE_PHYSICAL_MAPPING) || defined(r_specularMapping)
20087: 		float NdotH = clamp( dot( normal, H ), 0.0, 1.0 );
20088: 	#endif // USE_PHYSICAL_MAPPING || r_specularMapping
20089: 
20090: 	// clamp( NdotL, 0.0, 1.0 ) is done below
20091: 	float NdotL = dot( normal, lightDir );
20092: 
20093: 	#if !defined(USE_BSP_SURFACE) && defined(r_halfLambertLighting)
20094: 		// http://developer.valvesoftware.com/wiki/Half_Lambert
20095: 		NdotL = NdotL * 0.5 + 0.5;
20096: 		NdotL *= NdotL;
20097: 	#endif
20098: 
20099: 	NdotL = clamp( NdotL, 0.0, 1.0 );
20100: 
20101: 	#if defined(USE_PHYSICAL_MAPPING)
20102: 		// Daemon PBR packing defaults to ORM like glTF 2.0 defines
20103: 		// https://www.khronos.org/blog/art-pipeline-for-gltf
20104: 		// > ORM texture for Occlusion, Roughness, and Metallic
20105: 		// https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/material.pbrMetallicRoughness.schema.json
20106: 		// > The metalness values are sampled from the B channel. The roughness values are sampled from the G channel.
20107: 		// > These values are linear. If other channels are present (R or A), they are ignored for metallic-roughness calculations.
20108: 		// https://docs.blender.org/manual/en/2.80/addons/io_scene_gltf2.html
20109: 		// > glTF stores occlusion in the red (R) channel, allowing it to optionally share the same image
20110: 		// > with the roughness and metallic channels.
20111: 		float roughness = materialColor.g;
20112: 		float metalness = materialColor.b;
20113: 
20114: 		float NdotV = clamp( dot( normal, viewDir ), 0.0, 1.0);
20115: 		float VdotH = clamp( dot( viewDir, H ), 0.0, 1.0);
20116: 
20117: 		float alpha = roughness * roughness;
20118: 		float k = 0.125 * ( roughness + 1.0 ) * ( roughness + 1.0 );
20119: 
20120: 		float D = alpha / ( ( NdotH * NdotH ) * (alpha * alpha - 1.0 ) + 1.0 );
20121: 		D *= D;
20122: 
20123: 		float FexpNH = pow( 1.0 - NdotH, 5.0 );
20124: 		float FexpNV = pow( 1.0 - NdotV, 5.0 );
20125: 		vec3 F = mix( vec3( 0.04 ), diffuseColor.rgb, metalness );
20126: 		F += ( 1.0 - F ) * FexpNH;
20127: 
20128: 		float G = NdotL / (NdotL * ( 1.0 - k ) + k );
20129: 		G *= NdotV / ( NdotV * ( 1.0 - k ) + k );
20130: 
20131: 		vec3 diffuseBRDF = NdotL * diffuseColor.rgb * ( 1.0 - metalness );
20132: 		vec3 specularBRDF = vec3( ( D * F * G ) / max( 4.0 * NdotL * NdotV, 0.0001f ) );
20133: 		color.rgb += ( diffuseBRDF + specularBRDF ) * lightColor.rgb * NdotL;
20134: 		color.a = mix( diffuseColor.a, 1.0, FexpNV );
20135: 
20136: 	#else // !USE_PHYSICAL_MAPPING
20137: 		color.rgb += lightColor.rgb * NdotL * diffuseColor.rgb;
20138: 		#if defined(r_specularMapping)
20139: 			color.rgb += computeSpecularity(lightColor.rgb, materialColor, NdotH);
20140: 		#endif // r_specularMapping
20141: 	#endif // !USE_PHYSICAL_MAPPING
20142: }
20143: #endif // defined(USE_DELUXE_MAPPING) || defined(USE_GRID_DELUXE_MAPPING) defined(r_realtimeLighting)
20144: 
20145: #if !defined(USE_DELUXE_MAPPING) && !defined(USE_GRID_DELUXE_MAPPING)
20146: 	void computeLight( in vec3 lightColor, vec4 diffuseColor, inout vec4 color ) {
20147: 		color.rgb += lightColor.rgb * diffuseColor.rgb;
20148: 	}
20149: #endif // !defined(USE_DELUXE_MAPPING) && !defined(USE_GRID_DELUXE_MAPPING)
20150: 
20151: #if defined(r_realtimeLighting)
20152: 
20153: struct Light {
20154: 	vec3 center;
20155: 	float radius;
20156: 	vec3 color;
20157: 	float type;
20158: 	vec3 direction;
20159: 	float angle;
20160: };
20161: 
20162: #if defined( HAVE_ARB_shading_language_420pack )
20163: layout(std140, binding = BIND_LIGHTS) uniform u_Lights {
20164: #else
20165: layout(std140) uniform u_Lights {
20166: #endif
20167: 	Light lights[MAX_REF_LIGHTS];
20168: };
20169: 
20170: #define GetLight( idx ) lights[idx]
20171: 
20172: 
20173: void computeDynamicLight( uint idx, vec3 P, vec3 normal, vec3 viewDir, vec4 diffuse,
20174: 	vec4 material, inout vec4 color )
20175: {
20176: 	Light light = GetLight( idx );
20177: 	vec3 L;
20178: 	float attenuation;
20179: 
20180: 	if( light.type == 0.0 ) {
20181: 		// point light
20182: 		L = light.center.xyz - P;
20183: 		// 2.57 ~= 8.0 ^ ( 1.0 / 2.2 ), adjusted after overbright changes
20184: 		float t = 1.0 + 2.57 * length( L ) / light.radius;
20185: 		// Quadratic attenuation function instead of linear because of overbright changes
20186: 		attenuation = 1.0 / ( t * t );
20187: 		L = normalize( L );
20188: 	} else if( light.type == 1.0 ) {
20189: 		// spot light
20190: 		L = light.center - P;
20191: 		// 2.57 ~= 8.0 ^ ( 1.0 / 2.2 ), adjusted after overbright changes
20192: 		float t = 1.0 + 2.57 * length( L ) / light.radius;
20193: 		// Quadratic attenuation function instead of linear because of overbright changes
20194: 		attenuation = 1.0 / ( t * t );
20195: 		L = normalize( L );
20196: 
20197: 		if( dot( L, light.direction ) <= light.angle ) {
20198: 			attenuation = 0.0;
20199: 		}
20200: 	} else if( light.type == 2.0 ) {
20201: 		// sun (directional) light
20202: 		L = light.direction;
20203: 		attenuation = 1.0;
20204: 	}
20205: 
20206: 	computeDeluxeLight(
20207: 		L, normal, viewDir, attenuation * attenuation * light.color,
20208: 		diffuse, material, color );
20209: }
20210: 
20211: const uint lightsPerLayer = 16u;
20212: 
20213: #define idxs_t uvec4
20214: 
20215: uniform usampler3D u_LightTiles;
20216: 
20217: const vec3 tileScale = vec3( r_tileStep, 1.0 / float( NUM_LIGHT_LAYERS ) );
20218: 
20219: idxs_t fetchIdxs( in vec3 coords, in usampler3D u_LightTiles ) {
20220: 	return texture3D( u_LightTiles, coords );
20221: }
20222: 
20223: // 8 bits per light ID
20224: uint nextIdx( in uint count, in idxs_t idxs ) {
20225: 	return ( idxs[count / 4u] >> ( 8u * ( count % 4u ) ) ) & 0xFFu;
20226: }
20227: 
20228: void computeDynamicLights( vec3 P, vec3 normal, vec3 viewDir, vec4 diffuse, vec4 material,
20229: 	inout vec4 color, in usampler3D u_LightTiles )
20230: {
20231: 	if( u_numLights == 0 ) {
20232: 		return;
20233: 	}
20234: 
20235: 	#if defined(r_showLightTiles)
20236: 		uint totalLights = 0u;
20237: 	#endif
20238: 
20239: 	vec2 tile = floor( gl_FragCoord.xy * ( 1.0 / float( TILE_SIZE ) ) ) + 0.5;
20240: 
20241: 	for( uint layer = 0u; layer < uint( NUM_LIGHT_LAYERS ); layer++ ) {
20242: 		uint lightCount = 0u;
20243: 		idxs_t idxs = fetchIdxs( tileScale * vec3( tile, float( layer ) + 0.5 ), u_LightTiles );
20244: 
20245: 		for( uint i = 0u; i < lightsPerLayer; i++ ) {
20246: 			uint idx = nextIdx( lightCount, idxs );
20247: 
20248: 			if( idx == 0u ) {
20249: 				break;
20250: 			}
20251: 
20252: 			/* Light IDs are stored relative to the layer
20253: 			Subtract 1 because 0 means there's no light */
20254: 			idx = ( idx - 1u ) * uint( NUM_LIGHT_LAYERS ) + layer;
20255: 
20256: 			computeDynamicLight( idx, P, normal, viewDir, diffuse, material, color );
20257: 			lightCount++;
20258: 		}
20259: 		#if defined(r_showLightTiles)
20260: 			totalLights += lightCount;
20261: 		#endif
20262: 	}
20263: 
20264: 	#if defined(r_showLightTiles)
20265: 		if ( totalLights > 0 ) {
20266: 			color = vec4( float( totalLights ) / u_numLights, float( totalLights ) / u_numLights,
20267: 				float( totalLights ) / u_numLights, 1.0 );
20268: 		}
20269: 	#endif
20270: }
20271: 
20272: #endif // defined(r_realtimeLighting)
 134: #line 134
30000: #line 30000 // reliefMapping_fp.glsl
30001: /*
30002: ===========================================================================
30003: Copyright (C) 2009-2011 Robert Beckebans <trebor_7@users.sourceforge.net>
30004: 
30005: This file is part of XreaL source code.
30006: 
30007: XreaL source code is free software; you can redistribute it
30008: and/or modify it under the terms of the GNU General Public License as
30009: published by the Free Software Foundation; either version 2 of the License,
30010: or (at your option) any later version.
30011: 
30012: XreaL source code is distributed in the hope that it will be
30013: useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
30014: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
30015: GNU General Public License for more details.
30016: 
30017: You should have received a copy of the GNU General Public License
30018: along with XreaL source code; if not, write to the Free Software
30019: Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
30020: ===========================================================================
30021: */
30022: // reliefMapping_fp.glsl - Relief mapping helper functions
30023: 
30024: #define RELIEFMAPPING_GLSL
30025: 
30026: #if defined(r_normalMapping) || defined(USE_HEIGHTMAP_IN_NORMALMAP)
30027: uniform sampler2D	u_NormalMap;
30028: #endif // r_normalMapping || USE_HEIGHTMAP_IN_NORMALMAP
30029: 
30030: #if defined(r_normalMapping)
30031: uniform vec3        u_NormalScale;
30032: #endif // r_normalMapping
30033: 
30034: #if defined(USE_RELIEF_MAPPING)
30035: #if !defined(USE_HEIGHTMAP_IN_NORMALMAP)
30036: uniform sampler2D	u_HeightMap;
30037: #endif // !USE_HEIGHTMAP_IN_NORMALMAP
30038: uniform float       u_ReliefDepthScale;
30039: uniform float       u_ReliefOffsetBias;
30040: #endif // USE_RELIEF_MAPPING
30041: 
30042: // compute normal in tangent space
30043: #if defined(r_normalMapping)
30044: vec3 NormalInTangentSpace(vec2 texNormal, in sampler2D u_NormalMap)
30045: #else // !r_normalMapping
30046: vec3 NormalInTangentSpace(vec2 texNormal)
30047: #endif // !r_normalMapping
30048: {
30049: 	vec3 normal;
30050: 
30051: #if defined(r_normalMapping)
30052: #if defined(USE_HEIGHTMAP_IN_NORMALMAP)
30053: 	// alpha channel contains the height map so do not try to reconstruct normal map from it
30054: 	normal = texture2D(u_NormalMap, texNormal).rgb;
30055: 	normal = 2.0 * normal - 1.0;
30056: #else // !USE_HEIGHTMAP_IN_NORMALMAP
30057: 	// the Capcom trick abusing alpha channel of DXT1/5 formats to encode normal map
30058: 	// https://github.com/DaemonEngine/Daemon/issues/183#issuecomment-473691252
30059: 	//
30060: 	// the algorithm also works with normal maps in rgb format without alpha channel
30061: 	// but we still must be sure there is no height map in alpha channel hence the test
30062: 	//
30063: 	// crunch -dxn seems to produce such files, since alpha channel is abused such format
30064: 	// is unsuitable to embed height map, then height map must be distributed as loose file
30065: 	normal = texture2D(u_NormalMap, texNormal).rga;
30066: 	normal.x *= normal.z;
30067: 	normal.xy = 2.0 * normal.xy - 1.0;
30068: 	// In a perfect world this code must be enough:
30069: 	// normal.z = sqrt(1.0 - dot(normal.xy, normal.xy));
30070: 	//
30071: 	// Unvanquished texture known to trigger black normalmap artifacts
30072: 	// when doing Z reconstruction:
30073: 	//   textures/shared_pk02_src/rock01_n
30074: 	//
30075: 	// Although the normal vector is supposed to have a length of 1,
30076: 	// dot(normal.xy, normal.xy) may be greater than 1 due to compression
30077: 	// artifacts: values as large as 1.27 have been observed with crunch -dxn.
30078: 	// https://github.com/DaemonEngine/Daemon/pull/260#issuecomment-571010935
30079: 	//
30080: 	// This might happen with other formats too. So we must take care not to
30081: 	// take the square root of a negative number here.
30082: 	normal.z = sqrt(max(0, 1.0 - dot(normal.xy, normal.xy)));
30083: #endif // !USE_HEIGHTMAP_IN_NORMALMAP
30084: 	/* Disable normal map scaling when normal Z scale is set to zero.
30085: 
30086: 	This happens when r_normalScale is set to zero because
30087: 	u_NormalScale.z is premultiplied with r_normalScale. User can
30088: 	disable normal map scaling by setting r_normalScale to zero.
30089: 
30090: 	Normal Z component equal to zero would be wrong anyway.
30091: 	*/
30092: 	if (u_NormalScale.z != 0)
30093: 	{
30094: 		normal *= u_NormalScale;
30095: 	}
30096: 
30097: 	// HACK: the GLSL code is currently assuming
30098: 	// DirectX normal map format (+X -Y +Z) 318: 		vec3 emission = ambientColor * rim * rim * 0.2;
 319: 		color.rgb += 0.7 * emission;
 320: 	#endif
 321: 
 322: 	#if defined(r_glowMapping)
 323: 		// Blend glow map.
 324: 		vec3 glow = texture2D(u_GlowMap, texCoords).rgb;
 325: 
 326: 		color.rgb += glow;
 327: 	#endif
 328: 	
 329: 	SHADER_PROFILER_SET( color )
 330: 
 331: 	outputColor = color;
 332: 
 333: 
 334: 	// Debugging.
 335: 	#if defined(r_showNormalMaps)
 336: 		// Convert normal to [0,1] color space.
 337: 		normal = normal * 0.5 + 0.5;
 338: 		outputColor = vec4(normal, 1.0);
 339: 	#elif defined(r_showMaterialMaps)
 340: 		outputColor = material;
 341: 	#elif defined(r_showLightMaps) && defined(USE_LIGHT_MAPPING)
 342: 		outputColor = texture2D(u_LightMap, var_TexLight);
 343: 	#elif defined(r_showDeluxeMaps) && defined(USE_DELUXE_MAPPING)
 344: 		outputColor = texture2D(u_DeluxeMap, var_TexLight);
 345: 	#elif defined(USE_REFLECTIVE_SPECULAR) && defined(r_showReflectionMaps)
 346: 		vec4 envColor0 = textureCube(u_EnvironmentMap0, reflect(-viewDir, normal));
 347: 		vec4 envColor1 = textureCube(u_EnvironmentMap1, reflect(-viewDir, normal));
 348: 
 349: 		outputColor = vec4( mix(envColor0, envColor1, u_EnvironmentInterpolation).rgb, 1.0 );
 350: 	#elif defined(r_showVertexColors)
 351: 		/* We need to keep the texture alpha channel so impact
 352: 		marks like creep don't fully overwrite the world texture. */
 353: 		#if defined(USE_BSP_SURFACE)
 354: 			outputColor.rgb = vec3(1.0, 1.0, 1.0);
 355: 			outputColor *= var_Color;
 356: 		#else
 357: 			outputColor.rgb = vec3(0.0, 0.0, 0.0);
 358: 		#endif
 359: 	#elif defined(USE_MATERIAL_SYSTEM) && defined(r_showGlobalMaterials)
 360: 		outputColor.rgb = u_MaterialColour + lightColor.rgb * u_MaterialColour;
 361: 	#endif
 362: }
 
Warn: Compile log:
0:303(21): error: `lightDir' undeclared
0:303(2): error: no matching function for call to `computeDeluxeLight(error, vec3, vec3, vec3, vec4, vec4, vec4)'; candidates are:
0:303(2): error:    void computeDeluxeLight(vec3, vec3, vec3, vec3, vec4, vec4, vec4)
 
Warn: Built-in shaders failed: Couldn't compile fragment shader: lightMapping 

[illwieckz]

OK, I now fixed the lightDir error, because the permutation with both deluxegrid and lightmap was attempted to be built (it should not), now that I fixed that, I get the link error:

Debug: Building lightMapping shader permutation with macro: USE_VERTEX_ANIMATION USE_GRID_LIGHTING USE_GRID_DELUXE_MAPPING USE_HEIGHTMAP_IN_NORMALMAP USE_RELIEF_MAPPING USE_PHYSICAL_MAPPING  
Debug: Program creation + linking: 36 
Debug: Built in: 43 ms 
Debug: Building proxy shader permutation with macro: none 
Debug: Compilation: 1 
Debug: Compilation: 0 
Warn: Link log: 
Warn: error: fragment shader input `var_TexCoords' has no matching output in the previous stage
error: fragment shader input `var_Color' has no matching output in the previous stage

[illwieckz]

The shader that fails to link is “proxy”.

[illwieckz]

The comment says:

	/* HACK: A GLShader* is required to initialise uniforms,
	but we don't need the GLSL shader itself, so we won't actually build it */