mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-04-29 16:25:42 +00:00
gl conversion WIP. general notes: mSamplerNames[#]/samplerNames[#] entry explicitly corresponds to the order of definition GL side.
shifted the colorbuffer slot over to S1 in keeping with the gbuffer layout for consistency completed converts: brdf, lighting, torque. nonvisually verified convert: vectorlight noncompiling due to tripping on deferredUncondition: reflectionprobe
This commit is contained in:
Azaezel
parent
73b08ae80d
commit
7160882bd2
7 changed files with 372 additions and 439 deletions
98
Templates/Full/game/shaders/common/gl/brdf.glsl
Normal file
98
Templates/Full/game/shaders/common/gl/brdf.glsl
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
// Copyright (c) 2018 GarageGames, LLC
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to
|
||||
// deal in the Software without restriction, including without limitation the
|
||||
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
// sell copies of the Software, and to permit persons to whom the Software is
|
||||
// furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in
|
||||
// all copies or substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||||
// IN THE SOFTWARE.
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
#ifndef BRDF_HLSL
|
||||
#define BRDF_HLSL
|
||||
|
||||
#include "./torque.glsl"
|
||||
|
||||
// BRDF from Frostbite presentation:
|
||||
// Moving Frostbite to Physically Based Rendering
|
||||
// S´ebastien Lagarde - Electronic Arts Frostbite
|
||||
// Charles de Rousiers - Electronic Arts Frostbite
|
||||
// SIGGRAPH 2014
|
||||
|
||||
vec3 F_Schlick(in vec3 f0, in float f90, in float u)
|
||||
{
|
||||
return f0 + (f90 - f0) * pow(1.f - u, 5.f);
|
||||
}
|
||||
|
||||
vec3 F_Fresnel(vec3 SpecularColor, float VoH)
|
||||
{
|
||||
vec3 SpecularColorSqrt = sqrt(min(SpecularColor, vec3(0.99, 0.99, 0.99)));
|
||||
vec3 n = (1 + SpecularColorSqrt) / (1 - SpecularColorSqrt);
|
||||
vec3 g = sqrt(n*n + VoH*VoH - 1);
|
||||
return 0.5 * sqr((g - VoH) / (g + VoH)) * (1 + sqr(((g + VoH)*VoH - 1) / ((g - VoH)*VoH + 1)));
|
||||
}
|
||||
|
||||
vec3 FresnelSchlickRoughness(float cosTheta, vec3 F0, float roughness)
|
||||
{
|
||||
vec3 ret = vec3(0.0, 0.0, 0.0);
|
||||
float powTheta = pow(1.0 - cosTheta, 5.0);
|
||||
float invRough = float(1.0 - roughness);
|
||||
|
||||
ret.x = F0.x + (max(invRough, F0.x) - F0.x) * powTheta;
|
||||
ret.y = F0.y + (max(invRough, F0.y) - F0.y) * powTheta;
|
||||
ret.z = F0.z + (max(invRough, F0.z) - F0.z) * powTheta;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
float Fr_DisneyDiffuse(float NdotV, float NdotL, float LdotH, float linearRoughness)
|
||||
{
|
||||
float energyBias = lerp(0, 0.5, linearRoughness);
|
||||
float energyFactor = lerp(1.0, 1.0 / 1.51, linearRoughness);
|
||||
float fd90 = energyBias + 2.0 * LdotH*LdotH * linearRoughness;
|
||||
vec3 f0 = vec3(1.0f, 1.0f, 1.0f);
|
||||
float lightScatter = F_Schlick(f0, fd90, NdotL).r;
|
||||
float viewScatter = F_Schlick(f0, fd90, NdotV).r;
|
||||
|
||||
return lightScatter * viewScatter * energyFactor;
|
||||
}
|
||||
|
||||
float V_SmithGGXCorrelated(float NdotL, float NdotV, float alphaG2)
|
||||
{
|
||||
// Original formulation of G_SmithGGX Correlated
|
||||
// lambda_v = (-1 + sqrt(alphaG2 * (1 - NdotL2) / NdotL2 + 1)) * 0.5f;
|
||||
// lambda_l = (-1 + sqrt(alphaG2 * (1 - NdotV2) / NdotV2 + 1)) * 0.5f;
|
||||
// G_SmithGGXCorrelated = 1 / (1 + lambda_v + lambda_l);
|
||||
// V_SmithGGXCorrelated = G_SmithGGXCorrelated / (4.0f * NdotL * NdotV);
|
||||
|
||||
|
||||
// This is the optimized version
|
||||
//float alphaG2 = alphaG * alphaG;
|
||||
|
||||
// Caution: the "NdotL *" and "NdotV *" are explicitely inversed , this is not a mistake.
|
||||
float Lambda_GGXV = NdotL * sqrt((-NdotV * alphaG2 + NdotV) * NdotV + alphaG2);
|
||||
float Lambda_GGXL = NdotV * sqrt((-NdotL * alphaG2 + NdotL) * NdotL + alphaG2);
|
||||
|
||||
return 0.5f / (Lambda_GGXV + Lambda_GGXL);
|
||||
}
|
||||
|
||||
float D_GGX(float NdotH, float m2)
|
||||
{
|
||||
// Divide by PI is apply later
|
||||
//float m2 = m * m;
|
||||
float f = (NdotH * m2 - NdotH) * NdotH + 1;
|
||||
return m2 / (f * f);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -21,7 +21,7 @@
|
|||
//-----------------------------------------------------------------------------
|
||||
|
||||
#include "./torque.glsl"
|
||||
|
||||
#include "./brdf.glsl"
|
||||
#ifndef TORQUE_SHADERGEN
|
||||
|
||||
// These are the uniforms used by most lighting shaders.
|
||||
|
|
@ -44,132 +44,21 @@ uniform vec4 albedo;
|
|||
|
||||
#endif // !TORQUE_SHADERGEN
|
||||
|
||||
|
||||
vec3 F_schlick( in vec3 f0, in vec3 f90, in float u )
|
||||
vec3 getDistanceVectorToPlane( vec3 origin, vec3 direction, vec4 plane )
|
||||
{
|
||||
//
|
||||
// F( v, h ) = F0 + ( 1.0 - F0 ) * pow( 1.0f - HdotV, 5.0f )
|
||||
//
|
||||
//
|
||||
// where
|
||||
//
|
||||
// F0 = BaseColor * nDotL
|
||||
//
|
||||
// Dielectric materials always have a range of 0.02 < F0 < 0.05 , use a stock value of 0.04 ( roughly plastics )
|
||||
//
|
||||
float denum = dot( plane.xyz, direction.xyz );
|
||||
float num = dot( plane, vec4( origin, 1.0 ) );
|
||||
float t = -num / denum;
|
||||
|
||||
return f0 + ( f90 - f0 ) * pow( 1.0f - u , 5.0f );
|
||||
return direction.xyz * t;
|
||||
}
|
||||
|
||||
float Fr_DisneyDiffuse ( float NdotV , float NdotL , float LdotH , float linearRoughness )
|
||||
vec3 getDistanceVectorToPlane( float negFarPlaneDotEye, vec3 direction, vec4 plane )
|
||||
{
|
||||
float energyBias = mix (0 , 0.5 , linearRoughness );
|
||||
float energyFactor = mix (1.0 , 1.0 / 1.51 , linearRoughness );
|
||||
float fd90 = energyBias + 2.0 * LdotH * LdotH * linearRoughness ;
|
||||
vec3 f0 = vec3 ( 1.0f , 1.0f , 1.0f );
|
||||
float lightScatter = F_schlick( f0 , vec3(fd90), NdotL ).r;
|
||||
float viewScatter = F_schlick(f0 , vec3(fd90), NdotV ).r;
|
||||
float denum = dot( plane.xyz, direction.xyz );
|
||||
float t = negFarPlaneDotEye / denum;
|
||||
|
||||
return lightScatter * viewScatter * energyFactor ;
|
||||
}
|
||||
|
||||
float SmithGGX( float NdotL, float NdotV, float alpha )
|
||||
{
|
||||
//
|
||||
// G( L, V, h ) = G( L ) G( V )
|
||||
//
|
||||
// nDotL
|
||||
// G( L ) = _________________________
|
||||
// nDotL ( 1 - k ) + k
|
||||
//
|
||||
//
|
||||
// NdotV
|
||||
// G( V ) = _________________________
|
||||
// NdotV ( 1 - k ) + k
|
||||
//
|
||||
//
|
||||
// pow( ( Roughness + 1 ), 2)
|
||||
// , Where k = __________________________ ( unreal 4 )
|
||||
// 8
|
||||
//
|
||||
|
||||
float alphaSqr = alpha * alpha;
|
||||
|
||||
//float GGX_V = NdotL * sqrt ( ( - NdotV * alphaSqr + NdotV ) * NdotV + alphaSqr );
|
||||
//float GGX_L = NdotV * sqrt ( ( - NdotL * alphaSqr + NdotL ) * NdotL + alphaSqr );
|
||||
|
||||
float GGX_V = NdotL + sqrt ( ( - NdotV * alphaSqr + NdotV ) * NdotV + alphaSqr );
|
||||
float GGX_L = NdotV + sqrt ( ( - NdotL * alphaSqr + NdotL ) * NdotL + alphaSqr );
|
||||
|
||||
return 1.0/( GGX_V + GGX_L );
|
||||
//return 0.5f / ( GGX_V + GGX_L );
|
||||
}
|
||||
|
||||
float D_GGX( float NdotH , float alpha )
|
||||
{
|
||||
//
|
||||
// or GGX ( disney / unreal 4 )
|
||||
//
|
||||
// alpha = pow( roughness, 2 );
|
||||
//
|
||||
// pow( alpha, 2 )
|
||||
// D( h ) = ________________________________________________________________
|
||||
// PI pow( pow( NdotH , 2 ) ( pow( alpha, 2 ) - 1 ) + 1 ), 2 )
|
||||
//
|
||||
|
||||
float alphaSqr = alpha*alpha;
|
||||
float f = ( NdotH * alphaSqr - NdotH ) * NdotH + 1;
|
||||
return alphaSqr / ( M_PI_F * (f * f) );
|
||||
}
|
||||
|
||||
vec4 EvalBDRF( vec3 baseColor, vec3 lightColor, vec3 toLight, vec3 position, vec3 normal, float roughness, float metallic )
|
||||
{
|
||||
//
|
||||
// Microfacet Specular Cook-Torrance
|
||||
//
|
||||
// D( h ) F( v, h ) G( l, v, h )
|
||||
// f( l, v ) = ____________________________
|
||||
// 4 ( dot( n, l ) dot( n, v )
|
||||
//
|
||||
//
|
||||
|
||||
vec3 L = normalize( toLight );
|
||||
vec3 V = normalize( -position );
|
||||
vec3 H = normalize( L + V );
|
||||
vec3 N = normal;
|
||||
|
||||
float NdotV = abs( dot( N, V ) ) + 1e-5f;
|
||||
float NdotH = saturate( dot( N, H ) );
|
||||
float NdotL = saturate( dot( N, L ) );
|
||||
float LdotH = saturate( dot( L, H ) );
|
||||
|
||||
float VdotH = saturate( dot( V, H ) );
|
||||
|
||||
if ( NdotL == 0 )
|
||||
return vec4( 0.0f, 0.0f, 0.0f, 0.0f );
|
||||
|
||||
float alpha = roughness;
|
||||
float visLinAlpha = alpha * alpha;
|
||||
|
||||
vec3 f0 = baseColor;
|
||||
float metal = metallic;
|
||||
|
||||
vec3 F_conductor= F_schlick( f0, vec3( 1.0, 1.0, 1.0 ), VdotH );
|
||||
vec3 F_dielec = F_schlick( vec3( 0.04, 0.04, 0.04 ), vec3( 1.0, 1.0, 1.0 ), VdotH );
|
||||
float Vis = SmithGGX( NdotL, NdotV, visLinAlpha );
|
||||
float D = D_GGX( NdotH, visLinAlpha );
|
||||
|
||||
vec3 Fr_dielec = D * F_dielec * Vis;
|
||||
vec3 Fr_conductor = D * F_conductor * Vis;
|
||||
|
||||
vec3 Fd = vec3(Fr_DisneyDiffuse( NdotV , NdotL , LdotH , visLinAlpha ) / M_PI_F);
|
||||
vec3 specular = ( 1.0f - metal ) * Fr_dielec + metal * Fr_conductor;
|
||||
vec3 diffuse = ( 1.0f - metal ) * Fd * f0;
|
||||
|
||||
vec3 ret = ( diffuse + specular + lightColor) * vec3(NdotL);
|
||||
|
||||
float FR = saturate(length(specular));
|
||||
return vec4(ret,FR);
|
||||
return direction.xyz * t;
|
||||
}
|
||||
|
||||
void compute4Lights( vec3 wsView,
|
||||
|
|
@ -194,81 +83,152 @@ void compute4Lights( vec3 wsView,
|
|||
out vec4 outDiffuse,
|
||||
out vec4 outSpecular )
|
||||
{
|
||||
// NOTE: The light positions and spotlight directions
|
||||
// are stored in SoA order, so inLightPos[0] is the
|
||||
// x coord for all 4 lights... inLightPos[1] is y... etc.
|
||||
//
|
||||
// This is the key to fully utilizing the vector units and
|
||||
// saving a huge amount of instructions.
|
||||
//
|
||||
// For example this change saved more than 10 instructions
|
||||
// over a simple for loop for each light.
|
||||
|
||||
int i;
|
||||
outDiffuse = vec4(0,0,0,0);
|
||||
outSpecular = vec4(0,0,0,0);
|
||||
}
|
||||
|
||||
vec4 lightVectors[3];
|
||||
for ( i = 0; i < 3; i++ )
|
||||
lightVectors[i] = wsPosition[i] - inLightPos[i];
|
||||
struct Surface
|
||||
{
|
||||
vec3 P; // world space position
|
||||
vec3 N; // world space normal
|
||||
vec3 V; // world space view vector
|
||||
vec4 baseColor; // base color [0 -> 1] (rgba)
|
||||
float metalness; // metalness [0:dielectric -> 1:metal]
|
||||
float roughness; // roughness: [0:smooth -> 1:rough] (linear)
|
||||
float roughness_brdf; // roughness remapped from linear to BRDF
|
||||
float depth; // depth: [0:near -> 1:far] (linear)
|
||||
float ao; // ambient occlusion [0 -> 1]
|
||||
float matFlag; // material flag - use getFlag to retreive
|
||||
|
||||
float NdotV; // cos(angle between normal and view vector)
|
||||
vec3 f0; // fresnel value (rgb)
|
||||
vec3 albedo; // diffuse light absorbtion value (rgb)
|
||||
vec3 R; // reflection vector
|
||||
vec3 F; // fresnel term computed from f0, N and V
|
||||
void Update();
|
||||
};
|
||||
|
||||
// Accumulate the dot product between the light
|
||||
// vector and the normal.
|
||||
//
|
||||
// The normal is negated because it faces away from
|
||||
// the surface and the light faces towards the
|
||||
// surface... this keeps us from needing to flip
|
||||
// the light vector direction which complicates
|
||||
// the spot light calculations.
|
||||
//
|
||||
// We normalize the result a little later.
|
||||
//
|
||||
vec4 nDotL = vec4(0);
|
||||
for ( i = 0; i < 3; i++ )
|
||||
nDotL += lightVectors[i] * -wsNormal[i];
|
||||
|
||||
vec4 squareDists = vec4(0);
|
||||
for ( i = 0; i < 3; i++ )
|
||||
squareDists += lightVectors[i] * lightVectors[i];
|
||||
half4 correction = half4(inversesqrt( squareDists ));
|
||||
nDotL = saturate( nDotL * correction );
|
||||
void Surface::Update()
|
||||
{
|
||||
NdotV = abs(dot(N, V)) + 1e-5f; // avoid artifact
|
||||
|
||||
// First calculate a simple point light linear
|
||||
// attenuation factor.
|
||||
//
|
||||
// If this is a directional light the inverse
|
||||
// radius should be greater than the distance
|
||||
// causing the attenuation to have no affect.
|
||||
//
|
||||
vec4 atten = saturate( 1.0 - ( squareDists * inLightInvRadiusSq ) );
|
||||
albedo = baseColor.rgb * (1.0 - metalness);
|
||||
f0 = lerp(vec3(0.04), baseColor.rgb, metalness);
|
||||
R = -reflect(V, N);
|
||||
float f90 = saturate(50.0 * dot(f0, vec3(0.33,0.33,0.33)));
|
||||
F = F_Schlick(f0, f90, NdotV);
|
||||
}
|
||||
|
||||
Surface createSurface(vec4 gbuffer0, sampler2D gbufferTex1, sampler2D gbufferTex2, in vec2 uv, in vec3 wsEyePos, in vec3 wsEyeRay, in mat4 invView)
|
||||
{
|
||||
Surface surface;// = Surface();
|
||||
|
||||
#ifndef TORQUE_BL_NOSPOTLIGHT
|
||||
vec4 gbuffer1 = texture(gbufferTex1, uv);
|
||||
vec4 gbuffer2 = texture(gbufferTex2, uv);
|
||||
surface.depth = gbuffer0.a;
|
||||
surface.P = wsEyePos + wsEyeRay * surface.depth;
|
||||
surface.N = tMul(invView, vec4(gbuffer0.xyz,0)).xyz; //TODO move t3d to use WS normals
|
||||
surface.V = normalize(wsEyePos - surface.P);
|
||||
surface.baseColor = gbuffer1;
|
||||
const float minRoughness=1e-4;
|
||||
surface.roughness = clamp(1.0 - gbuffer2.b, minRoughness, 1.0); //t3d uses smoothness, so we convert to roughness.
|
||||
surface.roughness_brdf = surface.roughness * surface.roughness;
|
||||
surface.metalness = gbuffer2.a;
|
||||
surface.ao = gbuffer2.g;
|
||||
surface.matFlag = gbuffer2.r;
|
||||
surface.Update();
|
||||
return surface;
|
||||
}
|
||||
|
||||
// The spotlight attenuation factor. This is really
|
||||
// fast for what it does... 6 instructions for 4 spots.
|
||||
struct SurfaceToLight
|
||||
{
|
||||
vec3 L; // surface to light vector
|
||||
vec3 Lu; // un-normalized surface to light vector
|
||||
vec3 H; // half-vector between view vector and light vector
|
||||
float NdotL; // cos(angle between N and L)
|
||||
float HdotV; // cos(angle between H and V) = HdotL = cos(angle between H and L)
|
||||
float NdotH; // cos(angle between N and H)
|
||||
|
||||
vec4 spotAtten = vec4(0);
|
||||
for ( i = 0; i < 3; i++ )
|
||||
spotAtten += lightVectors[i] * inLightSpotDir[i];
|
||||
};
|
||||
|
||||
vec4 cosAngle = ( spotAtten * correction ) - inLightSpotAngle;
|
||||
atten *= saturate( cosAngle * inLightSpotFalloff );
|
||||
SurfaceToLight createSurfaceToLight(in Surface surface, in vec3 L)
|
||||
{
|
||||
SurfaceToLight surfaceToLight;// = SurfaceToLight();
|
||||
surfaceToLight.Lu = L;
|
||||
surfaceToLight.L = normalize(L);
|
||||
surfaceToLight.H = normalize(surface.V + surfaceToLight.L);
|
||||
surfaceToLight.NdotL = saturate(dot(surfaceToLight.L, surface.N));
|
||||
surfaceToLight.HdotV = saturate(dot(surfaceToLight.H, surface.V));
|
||||
surfaceToLight.NdotH = saturate(dot(surfaceToLight.H, surface.N));
|
||||
return surfaceToLight;
|
||||
}
|
||||
|
||||
#endif
|
||||
vec3 BRDF_GetSpecular(in Surface surface, in SurfaceToLight surfaceToLight)
|
||||
{
|
||||
float f90 = saturate(50.0 * dot(surface.f0, vec3(0.33,0.33,0.33)));
|
||||
vec3 F = F_Schlick(surface.f0, f90, surfaceToLight.HdotV);
|
||||
float Vis = V_SmithGGXCorrelated(surface.NdotV, surfaceToLight.NdotL, surface.roughness_brdf);
|
||||
float D = D_GGX(surfaceToLight.NdotH, surface.roughness_brdf);
|
||||
vec3 Fr = D * F * Vis / M_PI_F;
|
||||
return Fr;
|
||||
}
|
||||
|
||||
// Get the final light intensity.
|
||||
vec4 intensity = nDotL * atten;
|
||||
|
||||
// Combine the light colors for output.
|
||||
vec4 lightColor = vec4(0);
|
||||
for ( i = 0; i < 4; i++ )
|
||||
lightColor += intensity[i] * inLightColor[i];
|
||||
|
||||
vec3 toLight = vec3(0);
|
||||
for ( i = 0; i < 3; i++ )
|
||||
toLight += lightVectors[i].rgb;
|
||||
|
||||
outDiffuse = vec4(albedo.rgb*(1.0-metalness),albedo.a);
|
||||
outSpecular = EvalBDRF( vec3( 1.0, 1.0, 1.0 ), lightColor.rgb, toLight, wsPosition, wsNormal, smoothness, metalness );
|
||||
vec3 BRDF_GetDiffuse(in Surface surface, in SurfaceToLight surfaceToLight)
|
||||
{
|
||||
//getting some banding with disney method, using lambert instead - todo futher testing
|
||||
float Fd = 1.0 / M_PI_F;
|
||||
//energy conservation - remove this if reverting back to disney method
|
||||
vec3 kD = vec3(1.0) - surface.F;
|
||||
kD *= 1.0 - surface.metalness;
|
||||
vec3 diffuse = kD * surface.baseColor.rgb * Fd;
|
||||
return diffuse;
|
||||
}
|
||||
|
||||
//attenuations functions from "moving frostbite to pbr paper"
|
||||
//https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
|
||||
float smoothDistanceAtt ( float squaredDistance , float invSqrAttRadius )
|
||||
{
|
||||
float factor = squaredDistance * invSqrAttRadius ;
|
||||
float smoothFactor = saturate (1.0f - factor * factor );
|
||||
return sqr(smoothFactor);
|
||||
}
|
||||
|
||||
float getDistanceAtt( vec3 unormalizedLightVector , float invSqrAttRadius )
|
||||
{
|
||||
float sqrDist = dot ( unormalizedLightVector , unormalizedLightVector );
|
||||
float attenuation = 1.0 / (max ( sqrDist , 0.01*0.01) );
|
||||
attenuation *= smoothDistanceAtt ( sqrDist , invSqrAttRadius );
|
||||
return attenuation;
|
||||
}
|
||||
|
||||
float getSpotAngleAtt( vec3 normalizedLightVector , vec3 lightDir , vec2 lightSpotParams )
|
||||
{
|
||||
float cd = dot ( lightDir , normalizedLightVector );
|
||||
float attenuation = saturate ( ( cd - lightSpotParams.x ) / lightSpotParams.y );
|
||||
// smooth the transition
|
||||
return sqr(attenuation);
|
||||
}
|
||||
|
||||
vec3 getDirectionalLight(in Surface surface, in SurfaceToLight surfaceToLight, vec3 lightColor, float lightIntensity, float shadow)
|
||||
{
|
||||
vec3 factor = lightColor * max(surfaceToLight.NdotL, 0) * shadow * lightIntensity;
|
||||
vec3 diffuse = BRDF_GetDiffuse(surface,surfaceToLight) * factor;
|
||||
vec3 spec = BRDF_GetSpecular(surface,surfaceToLight) * factor;
|
||||
|
||||
vec3 final = max(vec3(0.0f), diffuse + spec * surface.ao);
|
||||
return final;
|
||||
}
|
||||
|
||||
vec3 getPunctualLight(in Surface surface, in SurfaceToLight surfaceToLight, vec3 lightColor, float lightIntensity, float radius, float shadow)
|
||||
{
|
||||
float attenuation = getDistanceAtt(surfaceToLight.Lu, radius);
|
||||
vec3 factor = lightColor * max(surfaceToLight.NdotL, 0) * shadow * lightIntensity * attenuation;
|
||||
|
||||
vec3 diffuse = BRDF_GetDiffuse(surface,surfaceToLight) * factor;
|
||||
vec3 spec = BRDF_GetSpecular(surface,surfaceToLight) * factor;
|
||||
|
||||
vec3 final = max(vec3(0.0f), diffuse + spec * surface.ao * surface.F);
|
||||
return final;
|
||||
}
|
||||
|
||||
float G1V(float dotNV, float k)
|
||||
|
|
|
|||
|
|
@ -383,4 +383,6 @@ vec3 getCubeDir(int face, vec2 uv)
|
|||
|
||||
return normalize(dir);
|
||||
}
|
||||
|
||||
#define sqr(a) ((a)*(a))
|
||||
#endif // _TORQUE_GLSL_
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue