anki-3d-engine/programs/DeferredShading.ankiprog

<!-- 
Copyright (C) 2009-2017, Panagiotis Christopoulos Charitos and contributors.
All rights reserved.
Code licensed under the BSD License.
http://www.anki3d.org/LICENSE
-->

<!-- Classic deferred lighting shader -->

<shaderProgram>
	<mutators>
		<mutator name="LIGHT_TYPE" values="0 1"/>
	</mutators>

	<shaders>
		<shader type="vert">
			<source><![CDATA[
#include "shaders/Common.glsl"

layout(location = 0) in vec3 in_position;

out gl_PerVertex
{
	vec4 gl_Position;
};

layout(ANKI_UBO_BINDING(0, 0), row_major) uniform u0_
{
	mat4 u_mvp;
};

void main()
{
	gl_Position = u_mvp * vec4(in_position, 1.0);
}
			]]></source>
		</shader>

		<shader type="frag">
			<inputs>
				<input name="FB_SIZE" type="uvec2" const="1" />
			</inputs>

			<source><![CDATA[
#include "shaders/Pack.glsl"
#include "shaders/LightFunctions.glsl"

#define POINT_LIGHT_TYPE 0
#define SPOT_LIGHT_TYPE 1

layout(location = 0) out vec3 out_color;

// Point light
struct PointLight
{
	vec4 projectionParams;
	vec4 posRadius; // xyz: Light pos in eye space. w: The -1/radius
	vec4 diffuseColorPad1; // xyz: diff color
	vec4 specularColorPad1; // xyz: spec color
};

// Spot light
struct SpotLight
{
	vec4 projectionParams;
	vec4 posRadius; // xyz: Light pos in eye space. w: The -1/radius
	vec4 diffuseColorOuterCos; // xyz: diff color, w: outer cosine of spot
	vec4 specularColorInnerCos; // xyz: spec color, w: inner cosine of spot
	vec4 lightDirPad1;
};

layout(ANKI_TEX_BINDING(0, 0)) uniform sampler2D u_msRt0;
layout(ANKI_TEX_BINDING(0, 1)) uniform sampler2D u_msRt1;
layout(ANKI_TEX_BINDING(0, 2)) uniform sampler2D u_msRt2;
layout(ANKI_TEX_BINDING(0, 3)) uniform sampler2D u_msDepthRt;

layout(ANKI_UBO_BINDING(0, 1)) uniform u1_
{
	vec4 u_inputTexUvScaleAndOffset; // Use this to get the correct face UVs
#if LIGHT_TYPE == POINT_LIGHT_TYPE
	PointLight u_light;
#elif LIGHT_TYPE == SPOT_LIGHT_TYPE
	SpotLight u_light;
#else
#error See file
#endif
};

#if LIGHT_TYPE == POINT_LIGHT_TYPE
#define u_ldiff u_light.diffuseColorPad1.xyz
#define u_lspec u_light.specularColorPad1.xyz
#else
#define u_ldiff u_light.diffuseColorOuterCos.xyz
#define u_lspec u_light.specularColorInnerCos.xyz
#endif

void main()
{
	// Compute UV coordinates
	vec2 uv = vec2(gl_FragCoord.xy) / vec2(FB_SIZE.x, FB_SIZE.y);
	vec2 uvToRead = fma(uv, u_inputTexUvScaleAndOffset.xy, u_inputTexUvScaleAndOffset.zw);

	// Do manual depth test
	float depth = texture(u_msDepthRt, uvToRead).r;
	if(gl_FragCoord.z < depth)
	{
		discard;
	}

	GbufferInfo gbuffer;
	readGBuffer(u_msRt0, u_msRt1, u_msRt2, uvToRead, 0.0, gbuffer);
	float a2 = pow(gbuffer.roughness, 2.0);

	// Calculate the light color
	vec3 fragPos;
	fragPos.z = u_light.projectionParams.z / (u_light.projectionParams.w + depth);
	fragPos.xy = UV_TO_NDC(uv) * u_light.projectionParams.xy * fragPos.z;

	vec3 viewDir = normalize(-fragPos);
	vec3 frag2Light = u_light.posRadius.xyz - fragPos;
	vec3 l = normalize(frag2Light);
	float nol = max(0.0, dot(gbuffer.normal, l));

	vec3 specC = computeSpecularColorBrdf(viewDir, l, gbuffer.normal, gbuffer.specular, u_lspec, a2, nol);

	vec3 diffC = computeDiffuseColor(gbuffer.diffuse, u_ldiff);

	float att = computeAttenuationFactor(u_light.posRadius.w, frag2Light);
	float lambert = nol;

#if LIGHT_TYPE == POINT_LIGHT_TYPE
	out_color = (specC + diffC) * (att * max(lambert, gbuffer.subsurface));
#else
	float spot =
		computeSpotFactor(l, u_light.diffuseColorOuterCos.w, u_light.specularColorInnerCos.w, u_light.lightDirPad1.xyz);

	out_color = (diffC + specC) * (att * spot * max(lambert, gbuffer.subsurface));
#endif
}
			]]></source>
		</shader>
	</shaders>
</shaderProgram>