Basic Lighting Models
The Three Illumination Models:
- ambient: color of objects in the scene with no direct light on it (When it is in shadow). It's not black, it has some hue associated with it. We don't want black, if anything goes to 0,0,0 information is clipped off and lost.
- Diffuse: color of an object when a light is shining on it
- Specular: the hot spot on the object. The reflection of the light on the surface of the object that you're casting on. (PBR does it differently)
- Combined (Phong): the final combined light with all three lighting models.
Constant Buffer or Cbuffer: a group of memory for the frame.
The view direction is equal to the camera position subtracted by the object position. The Light Drection is the light position minus the object position
Ambient Lighting
/********** Constants ********************/
cbuffer CBufferPerFrame
{
float4 AmbientColor;
float4 LightColor;
float3 LightDirection;
float3 CameraPosition;
}
cbuffer CBufferPerObject
{
float4 SpecularColor;
float SpecularPower;
}
Pixel Shader of ambient Color:
float4 ambientPixelShader(VS_OUTPUT IN): SV_Target
{
float4 OUT = (float4)0;
OUT = ColorTexture.Sample(ColorSampler, IN.TextureCoordinate);
OUT.rgb *= AmbientColor.rgb * AmbientColor.a;
return OUT;
}
The Ambient Color is the color of the shadows. Here it is similar from last weeks, but we added in the extra line of multiplying it by the ambient color rgb and the alpha as well. We multiply the alpha seperately because when things are transparent, it becomes even darker because it's letting less light through. It is ultimately just an offset for your light, to push it up just a bit to make sure it's not totally black. (the vertex shader doesn't do anything special)
Diffuse Lighting
Simplest shading Model. Where ambient light is flat and is the minimum amount of color everywhere. Diffuse light uses the normal of the object to determine the gradient of how light the object appears. If the normal is pointed directly at the light, the angle between the light and the normal is 0 degrees. Cosine at 0 degrees is 1 and so that point will receive the greatest amount of light. If the normal is orthogonal to the light, that means the angle between will be 90 and receive the least amount of light (cosine of 90 is 0).
Lambert's cosine law: "Brightness of a surface is directly proportional to the cosine of the angle between the Light vector and the surface normal.
Light Bounces irregularly off the 'microfacets' in the material.
Dot Product Reminder
Lambert's Cosine Law uses the Dot Product to find cosine of angle between light vector and surface normal.
Assuming a Directional Light: a light source infinitely far away, all light reaching the surface are parallel, so its just a directional vector. D=L-O
Vertex Shader Lambert
VS_OUTPUT lambertVertexShader(VS_INPUT IN)
{
VS_OUTPUT OUT = (VS_OUTPUT)0;
OUT.Position = mul(mul(mul(IN.ObjectPosition, World), View), Projection); // Flip the coordinates if in HLSL
OUT.TextureCoordinate = get_corrected_texture_coordinates(IN.TextureCoordinate);
OUT.Normal = normalize(mul(float4(IN.Normal, 0.0), World).xyz); // remember that a 0 at the end makes it a direction, 1 is a point
OUT.LightDirection = normalize(-LightDirection);
return OUT;
}
Pixel Shader Lambert
float4 lambertPixelShader(VS_OUTPUT IN): SV_Target
{
float4 OUT = (float4)0;
float3 normal = normalize(IN.Normal); //we renormalize because the rasterization stage flattened everything so it's probably not normal again
float3 lightDirection = normalize(IN.LightDirection);
float n_dot_l = dot(lightDirection, normal);
float4 color = ColorTexture.Sample(ColorSampler, IN.TextureCoordinate);
float3 ambient = AmbientColor.rgb * AmbientColor.a * color.rgb;
float3 diffuse = (float3)0;
if (n_dot_l > 0)
{
diffuse = LightColor.rgb * LightColor.a * n_dot_l * color.rgb;
}
OUT.rgb = ambient + diffuse;
OUT.a = color.a;
return OUT;
}
Specular (Phong Shading)
The Reflection angle is going to be the exact same angle the light angle is, just reflected. You take the dot product of the view angle and the reflection angle to find how bright the hot spot is.
The blin phong shader is the optimized version.
The Specular Component is added to ambient and diffuse.
Now you need the camera position in the CBufferPerFrame in order to calculate the view and reflection vector.
You also need to include the CBufferPerObject because different objects have different specular colors and power.
Vertex Shader Phong
VS_OUTPUT phongVertexShader(VS_INPUT IN)
{
VS_OUTPUT OUT = (VS_OUTPUT)0;
OUT.Position = mul(mul(mul(IN.ObjectPosition, World), View), Projection); // Flip the coordinates if in HLSL
OUT.TextureCoordinate = get_corrected_texture_coordinates(IN.TextureCoordinate);
OUT.Normal = normalize(mul(float4(IN.Normal, 0.0), World).xyz);
OUT.LightDirection = normalize(-LightDirection);
float3 worldPosition = mul(IN.ObjectPosition, World).xyz;
OUT.ViewDirection = normalize(CameraPosition - worldPosition);
return OUT;
}
Pixel Shader Phong
float4 phongPixelShader(VS_OUTPUT IN): SV_Target
{
float4 OUT = (float4)0;
float3 normal = normalize(IN.Normal);
float3 lightDirection = normalize(IN.LightDirection);
float n_dot_l = dot(lightDirection, normal);
float4 color = ColorTexture.Sample(ColorSampler, IN.TextureCoordinate);
float3 ambient = AmbientColor.rgb * AmbientColor.a * color.rgb;
float3 diffuse = (float3)0;
float3 viewDirection = normalize(IN.ViewDirection);
float3 specular = (float3)0;
if (n_dot_l > 0)
{
diffuse = LightColor.rgb * LightColor.a * n_dot_l * color.rgb;
float3 reflectionVector = normalize(2*n_dot_l*normal-lightDirection);
float specDot = dot(reflectionVector, viewDirection);
float specSat = saturate(specDot);
float specPow = pow(specSat, SpecularPower);
float specMin = min(specPow, color.a);
specular = SpecularColor.rgb * SpecularColor.a*specMin;
}
OUT.rgb = ambient + diffuse + specular;
OUT.a = color.a;
return OUT;
}
Blinn Phong Modification
You can replace the Reflection Vector with a 'half-vector'
Pixel Shader BlinnPhong
float4 blinnPhongPixelShader(VS_OUTPUT IN): SV_Target
{
float4 OUT = (float4)0;
float3 normal = normalize(IN.Normal);
float3 lightDirection = normalize(IN.LightDirection);
float n_dot_l = dot(lightDirection, normal);
float4 color = ColorTexture.Sample(ColorSampler, IN.TextureCoordinate);
float3 ambient = AmbientColor.rgb * AmbientColor.a * color.rgb;
float3 diffuse = (float3)0;
float3 viewDirection = normalize(IN.ViewDirection);
float3 specular = (float3)0;
if (n_dot_l > 0)
{
diffuse = LightColor.rgb * LightColor.a * n_dot_l * color.rgb;
float3 halfVector = normalize(lightDirection + IN.ViewDirection);
float specDot = dot(normal, halfVector);
float specSat = saturate(specDot);
float specPow = pow(specSat, SpecularPower);
float specMin = min(specPow, color.a);
specular = SpecularColor.rgb * SpecularColor.a*specMin;
}
OUT.rgb = ambient + diffuse + specular;
OUT.a = color.a;
return OUT;
}
Changing between the two of these, you'll notice that the specular hot spot is just a bit bigger than the phong shader. You can adjust the size of the specular power to change this.
HLSL intrinsic
Since people do this so often, there is a function in hlsl that calculates the light for you, taking in the light dot product, the half vector dot product, and the specular power.
Pixel Shader blinn phong intrinics
float4 bfIntrinsicsPixelShader(VS_OUTPUT IN): SV_Target
{
float4 OUT = (float4)0;
float3 normal = normalize(IN.Normal);
float3 lightDirection = normalize(IN.LightDirection);
float3 viewDirection = normalize(IN.ViewDirection);
float n_dot_l = dot(lightDirection, normal);
float3 halfVector = normalize(lightDirection + viewDirection);
float n_dot_h = dot(normal, halfVector);
float4 color = ColorTexture.Sample(ColorSampler, IN.TextureCoordinate);
float4 lightCoefficients = lit(n_dot_l, n_dot_h, SpecularPower);
float3 ambient = get_vector_color_contribution(AmbientColor, color.rgb);
float3 diffuse = get_vector_color_contribution(LightColor, lightCoefficients.y*color.rgb);
float3 specular = get_scalar_color_contribution(SpecularColor, min(lightCoefficients.z, color.w));
OUT.rgb = ambient + diffuse + specular;
OUT.a = color.a;
return OUT;
}
Gives you back a float4. The y component has the diffuse value and the z value has the specular component.
Those get_vector_color_contribution and get_scalar_color_contribution functions come from the 'Common.fxh' file we included in the folder (we have a #include "Common.fxh at the top of the file).
#ifndef _COMMON_FXH //if not defined, define it
#define _COMMON_FXH
/**********Resources****************/
#define FLIP_TEXTURE_Y 1
/* Globals tobe defined by user */
matrix World;
matrix View;
matrix Projection;
/********** Utility Functions ************/
float2 get_corrected_texture_coordinates(float2 textureCoordinate)
{
#if FLIP_TEXTURE_Y
return float2(textureCoordinate.x, 1.0 - textureCoordinate.y);
#else
return textureCoordinate;
#endif
}
float3 get_vector_color_contribution(float4 light, float3 color)
{
return light.rgb * light.a *color;
}
float3 get_scalar_color_contribution(float4 light, float color)
{
return light.rgb * light.a *color;
}
#endif
Types of Light
Point Light
The position of the point light is what matters. Your basic Lightbulb, gives off rays in all directions. Deals with attenuation radius, how the light falls off. Usually its inverse squared for the attenuation curve.
Light Attenuation is computed with this equation:
The vertex shader is similar to what we've done before. Except this time to get the light direction, we first subtract the world position from it and normalize it (we don't need to make it negative like in the directional one). Then the attenuation ratio is light direction divided by light radius.
/*************** Vertex SHader **********/
VS_OUTPUT pointVertexShader(VS_INPUT IN)
{
VS_OUTPUT OUT = (VS_OUTPUT)0;
matrix WorldViewProjection = mul(mul(World, View), Projection);
OUT.Position = mul(IN.ObjectPosition, WorldViewProjection);
OUT.TextureCoordinate = get_corrected_texture_coordinates(IN.TextureCoordinate);
OUT.Normal = normalize(mul(float4(IN.Normal, 0), World).xyz);
float3 worldPosition = mul(IN.ObjectPosition, World).xyz;
float3 lightDirection = LightPosition - worldPosition;
OUT.LightDirection.xyz = normalize(lightDirection);
float attenuationRatio = length(OUT.LightDirection.xyz)/LightRadius;
OUT.LightDirection.w = saturate(1.0 - attenuationRatio);
OUT.ViewDirection = normalize(CameraPosition - worldPosition);
return OUT;
}
For the pixel shader, using the lit function, you use the y value for the diffuse, and the z value for the specular. you don't need the x or w value. Why it gives you these I don't know.
/*************** Pixel SHader ***********/
float4 pointPixelShader(VS_OUTPUT IN):SV_Target
{
float4 OUT = (float4)0;
float3 normal = normalize(IN.Normal);
float4 lightDirection = normalize(IN.LightDirection);
float3 viewDirection = normalize(IN.ViewDirection);
float n_dot_l = dot(lightDirection.xyz, normal);
float3 halfVector = normalize(lightDirection.xyz + viewDirection);
float n_dot_h = dot(normal, halfVector);
float4 color = ColorTexture.Sample(ColorSampler, IN.TextureCoordinate);
float4 lightCoefficients = lit(n_dot_l, n_dot_h, SpecularPower);
float3 ambient = get_vector_color_contribution(AmbientColor, color.rgb);
float3 diffuse = IN.LightDirection.w * get_vector_color_contribution(LightColor, lightCoefficients.y * color.rgb);
float3 specular = IN.LightDirection.w * get_scalar_color_contribution(SpecularColor, min(lightCoefficients.z, color.w));
OUT.rgb = ambient + diffuse + specular;
OUT.a = color.a;
return OUT;
}
However you might notice that you get some clipping with the specular hot spot.
This is due to the rasterization part of the pipeline clipping off some values of the light direction. You need to calculate the light direction and attenuation ratio is again in the pixel shader.
You need to have a new struct output for the vertex shader to include the attenuation ratio
struct VS_POUTPUT
{
float4 Position : SV_Position;
float3 Normal:NORMAL;
float2 TextureCoordinate : TEXCOORD0;
float3 WorldPosition : TEXCOORD1;
float Attenuation
: TEXCOORD2;
};
Pixel Shader:
float4 pixelPointPixelShader(VS_POUTPUT IN):SV_Target
{
float4 OUT = (float4)0;
float3 lightDirection = normalize(LightPosition - IN.WorldPosition);
float3 viewDirection = normalize(CameraPosition - IN.WorldPosition);
float3 normal = normalize(IN.Normal);
float n_dot_l = dot(lightDirection, normal);
float3 halfVector = normalize(lightDirection + viewDirection);
float n_dot_h = dot(normal, halfVector);
float4 color = ColorTexture.Sample(ColorSampler, IN.TextureCoordinate);
float4 lightCoefficients = lit(n_dot_l, n_dot_h, SpecularPower);
float3 ambient = get_vector_color_contribution(AmbientColor, color.rgb);
float3 diffuse = IN.Attenuation * get_vector_color_contribution(LightColor, lightCoefficients.y * color.rgb);
float3 specular = IN.Attenuation * get_scalar_color_contribution(SpecularColor, min(lightCoefficients.z, color.w));
OUT.rgb = ambient + diffuse + specular;
OUT.a = color.a;
return OUT;
}
Spotlight
A spotlight has an inner radius and an outer radius. Anything outside of the cone has a value of 0. Anything inside the inner radius as a value of 1. So you're dealing with location, direction, outer angle, and inner angle.
For the struct:
struct VS_SOUTPUT
{
float4 Position : SV_Position;
float3 Normal:NORMAL;
float2 TextureCoordinate : TEXCOORD0;
float3 WorldPosition : TEXCOORD1;
float Attenuation: TEXCOORD2;
float3 LightLookAt:TEXCOORD3;
};
For the vertex shader:VS_SOUTPUT spotVertexShader(VS_INPUT IN)
{
VS_SOUTPUT OUT = (VS_SOUTPUT)0;
matrix WorldViewProjection = mul(mul(World, View), Projection);
OUT.Position = mul(IN.ObjectPosition, WorldViewProjection);
OUT.WorldPosition = mul(IN.ObjectPosition, World).xyz;
OUT.TextureCoordinate = get_corrected_texture_coordinates(IN.TextureCoordinate);
OUT.Normal = normalize(mul(float4(IN.Normal, 0), World).xyz);
float3 lightDirection = LightPosition - OUT.WorldPosition;
float3 nLightDirection = normalize(lightDirection);
OUT.Attenuation = saturate(1.0 - (length(nLightDirection)/LightRadius)); //using the normal lightdirection to get amplitude, for the attenuation
OUT.LightLookAt = -LightLookAt;
return OUT;
}
Pixel Shader:
float4 spotPixelShader(VS_SOUTPUT IN):SV_Target
{
float4 OUT = (float4)0;
float3 lightDirection = normalize(LightPosition - IN.WorldPosition);
float3 viewDirection = normalize(CameraPosition - IN.WorldPosition);
float3 normal = normalize(IN.Normal);
float n_dot_l = dot(lightDirection, normal);
float3 halfVector = normalize(lightDirection + viewDirection);
float n_dot_h = dot(normal, halfVector);
float4 color = ColorTexture.Sample(ColorSampler, IN.TextureCoordinate);
float4 lightCoefficients = lit(n_dot_l, n_dot_h, SpecularPower);
float3 ambient = get_vector_color_contribution(AmbientColor, color.rgb);
float3 diffuse = IN.Attenuation * get_vector_color_contribution(LightColor, lightCoefficients.y * color.rgb);
float3 specular = IN.Attenuation * get_scalar_color_contribution(SpecularColor, min(lightCoefficients.z, color.w));
float3 lightLookAt = normalize(IN.LightLookAt);
float spotFactor = 0.0;
float lightAngle = dot(LightLookAt, lightDirection);
if(lightAngle > 0.0)
{
spotFactor = smoothstep(SpotLightInnerAngle, SpotLightOuterAngle, lightAngle);
}
OUT.rgb = ambient + spotFactor*(diffuse + specular);
OUT.a = color.a;
return OUT;
}
There is an intrinsic data type in hlsl called LIGHT_CONTRIBUTION_DATA that holds all the information necessary to do the lighting calculations. It helps when you have multiple lights since you need to calculate it for every light.
