lightling/DX11Starter
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #6 from xLightling/a7_lights

Browse source 
A7: Lights
This commit is contained in:
Lightling 2022-03-19 18:16:51 -04:00 • committed by GitHub
commit 434726dffd
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
16 changed files with 462 additions and 181 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.editorconfig Normal file
View file

@ -0,0 +1,3 @@
[*]
indent_style = tab
indent_size = 4

25
DX11Starter.vcxproj
View file

@ -80,6 +80,9 @@
<Link>
<SubSystem>Windows</SubSystem>
</Link>
<FxCompile>
<ShaderModel>5.0</ShaderModel>
</FxCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
@ -91,6 +94,9 @@
<Link>
<SubSystem>Windows</SubSystem>
</Link>
<FxCompile>
<ShaderModel>5.0</ShaderModel>
</FxCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
@ -106,6 +112,9 @@
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
<FxCompile>
<ShaderModel>5.0</ShaderModel>
</FxCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
@ -121,6 +130,9 @@
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
<FxCompile>
<ShaderModel>5.0</ShaderModel>
</FxCompile>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="Camera.cpp" />
@ -140,6 +152,7 @@
<ClInclude Include="Entity.h" />
<ClInclude Include="Game.h" />
<ClInclude Include="Input.h" />
<ClInclude Include="Lights.h" />
<ClInclude Include="Material.h" />
<ClInclude Include="Mesh.h" />
<ClInclude Include="SimpleShader.h" />
@ -167,6 +180,12 @@
<ShaderModel Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">5.0</ShaderModel>
<ShaderModel Condition="'$(Configuration)|$(Platform)'=='Release|x64'">5.0</ShaderModel>
</FxCompile>
<FxCompile Include="SimplePixelShader.hlsl">
<ShaderType Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Pixel</ShaderType>
<ShaderType Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Pixel</ShaderType>
<ShaderType Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Pixel</ShaderType>
<ShaderType Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Pixel</ShaderType>
</FxCompile>
<FxCompile Include="VertexShader.hlsl">
<ShaderType Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Vertex</ShaderType>
<ShaderModel Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">5.0</ShaderModel>
@ -285,6 +304,12 @@
<DestinationFolders Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(OutDir)/Assets/Models</DestinationFolders>
</CopyFileToFolders>
</ItemGroup>
<ItemGroup>
<None Include="Helpers.hlsli" />
<None Include="Defines.hlsli" />
<None Include="Lights.hlsli" />
<None Include="ThirdPartyFunctions.hlsli" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>

20
DX11Starter.vcxproj.filters
View file

@ -86,6 +86,9 @@
<ClInclude Include="Material.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Lights.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<FxCompile Include="PixelShader.hlsl">
@ -97,6 +100,9 @@
<FxCompile Include="RandomPixelShader.hlsl">
<Filter>Shaders</Filter>
</FxCompile>
<FxCompile Include="SimplePixelShader.hlsl">
<Filter>Shaders</Filter>
</FxCompile>
</ItemGroup>
<ItemGroup>
<CopyFileToFolders Include="Assets\Models\cube.obj">
@ -121,4 +127,18 @@
<Filter>Assets\Models</Filter>
</CopyFileToFolders>
</ItemGroup>
<ItemGroup>
<None Include="Helpers.hlsli">
<Filter>Shaders</Filter>
</None>
<None Include="ThirdPartyFunctions.hlsli">
<Filter>Shaders</Filter>
</None>
<None Include="Defines.hlsli">
<Filter>Shaders</Filter>
</None>
<None Include="Lights.hlsli">
<Filter>Shaders</Filter>
</None>
</ItemGroup>
</Project>

35
Defines.hlsli Normal file
View file

@ -0,0 +1,35 @@
#ifndef __SHADER_DEFINES__
#define __SHADER_DEFINES__
#define MAX_SPECULAR_EXPONENT 256.0f
// Struct representing the data we expect to receive from earlier pipeline stages
// - Should match the output of our corresponding vertex shader
struct VertexToPixel
{
// Data type
// |
// | Name Semantic
// | | |
// v v v
float4 screenPosition : SV_POSITION;
float2 uv : TEXCOORD;
float3 normal : NORMAL;
float3 worldPosition : POSITION;
};
// Struct representing a single vertex worth of data
// - This should match Vertex.h
struct VertexShaderInput
{
// Data type
// |
// | Name Semantic
// | | |
// v v v
float3 localPosition : POSITION;
float3 normal : NORMAL;
float2 uv : TEXCOORD;
};
#endif

84
Game.cpp
View file

@ -60,6 +60,7 @@ void Game::Init()
// geometry to draw and some simple camera matrices.
// - You'll be expanding and/or replacing these later
LoadShaders();
LoadLighting();
CreateBasicGeometry();
// Tell the input assembler stage of the pipeline what kind of
@ -80,17 +81,57 @@ void Game::LoadShaders()
{
vertexShader = std::make_shared<SimpleVertexShader>(device, context, GetFullPathTo_Wide(L"VertexShader.cso").c_str());
pixelShader = //std::make_shared<SimplePixelShader>(device, context, GetFullPathTo_Wide(L"PixelShader.cso").c_str());
std::make_shared<SimplePixelShader>(device, context, GetFullPathTo_Wide(L"RandomPixelShader.cso").c_str());
//std::make_shared<SimplePixelShader>(device, context, GetFullPathTo_Wide(L"RandomPixelShader.cso").c_str());
std::make_shared<SimplePixelShader>(device, context, GetFullPathTo_Wide(L"SimplePixelShader.cso").c_str());
// thanks to https://harry7557558.github.io/tools/colorpicker.html for having the only 0f-1f picker i could find
XMFLOAT4 white = XMFLOAT4(1.0f, 1.0f, 1.0f, 1.0f);
XMFLOAT4 deeppink = XMFLOAT4(1.0f, 0.08f, 0.4f, 1.0f);
XMFLOAT4 deepcoral = XMFLOAT4(1.0f, 0.39f, 0.22f, 1.0f);
XMFLOAT3 white = XMFLOAT3(1.0f, 1.0f, 1.0f);
XMFLOAT3 deeppink = XMFLOAT3(1.0f, 0.08f, 0.4f);
XMFLOAT3 deepcoral = XMFLOAT3(1.0f, 0.39f, 0.22f);
materials = {
std::make_shared<Material>(white, vertexShader, pixelShader),
std::make_shared<Material>(deeppink, vertexShader, pixelShader),
std::make_shared<Material>(deepcoral, vertexShader, pixelShader),
std::make_shared<Material>(white, 0, vertexShader, pixelShader),
std::make_shared<Material>(deeppink, 0, vertexShader, pixelShader),
std::make_shared<Material>(deepcoral, 0, vertexShader, pixelShader),
};
}
void Game::LoadLighting()
{
ambient = XMFLOAT3(0.05f, 0.05f, 0.20f);
Light directionalLight0 = {};
directionalLight0.Type = LIGHT_TYPE_DIRECTIONAL;
directionalLight0.Direction = XMFLOAT3(1, 0, 0);
directionalLight0.Color = XMFLOAT3(1, 0, 0);
directionalLight0.Intensity = 1;
Light directionalLight1 = {};
directionalLight1.Type = LIGHT_TYPE_DIRECTIONAL;
directionalLight1.Direction = XMFLOAT3(0, -1, 0);
directionalLight1.Color = XMFLOAT3(0, 1, 0);
directionalLight1.Intensity = 1;
Light directionalLight2 = {};
directionalLight2.Type = LIGHT_TYPE_DIRECTIONAL;
directionalLight2.Direction = XMFLOAT3(-1, 1, -0.5f);
directionalLight2.Color = XMFLOAT3(0, 0, 1);
directionalLight2.Intensity = 1;
Light pointLight0 = {};
pointLight0.Type = LIGHT_TYPE_POINT;
pointLight0.Position = XMFLOAT3(-2, -2, 0);
pointLight0.Color = XMFLOAT3(1, 1, 0);
pointLight0.Intensity = 1;
pointLight0.Range = 10;
Light pointLight1 = {};
pointLight1.Type = LIGHT_TYPE_POINT;
pointLight1.Position = XMFLOAT3(2, 2, 0);
pointLight1.Color = XMFLOAT3(0, 1, 1);
pointLight1.Intensity = 1;
pointLight1.Range = 10;
lights = {
directionalLight0,
directionalLight1,
directionalLight2,
pointLight0,
pointLight1,
};
}
@ -110,27 +151,27 @@ void Game::CreateBasicGeometry()
std::make_shared<Mesh>(
GetFullPathTo("Assets/Models/helix.obj").c_str(),
device, context),
std::make_shared<Mesh>(
GetFullPathTo("Assets/Models/quad.obj").c_str(),
device, context),
std::make_shared<Mesh>(
GetFullPathTo("Assets/Models/quad_double_sided.obj").c_str(),
device, context),
std::make_shared<Mesh>(
GetFullPathTo("Assets/Models/sphere.obj").c_str(),
device, context),
std::make_shared<Mesh>(
GetFullPathTo("Assets/Models/torus.obj").c_str(),
device, context),
std::make_shared<Mesh>(
GetFullPathTo("Assets/Models/quad.obj").c_str(),
device, context),
std::make_shared<Mesh>(
GetFullPathTo("Assets/Models/quad_double_sided.obj").c_str(),
device, context),
};
entities = {
std::make_shared<Entity>(materials[0], shapes[0]),
std::make_shared<Entity>(materials[1], shapes[1]),
std::make_shared<Entity>(materials[2], shapes[2]),
std::make_shared<Entity>(materials[0], shapes[1]),
std::make_shared<Entity>(materials[0], shapes[2]),
std::make_shared<Entity>(materials[0], shapes[3]),
std::make_shared<Entity>(materials[1], shapes[4]),
std::make_shared<Entity>(materials[2], shapes[5]),
std::make_shared<Entity>(materials[0], shapes[4]),
std::make_shared<Entity>(materials[0], shapes[5]),
std::make_shared<Entity>(materials[0], shapes[6]),
};
@ -168,6 +209,7 @@ void Game::Update(float deltaTime, float totalTime)
for (int i = 0; i < entities.size(); ++i)
{
entities[i]->GetTransform()->SetRotation(1.0f * (i + 1) * sin(totalTime), 1.0f * (i + 1) * sin(totalTime), 1.0f * (i + 1) * sin(totalTime));
entities[i]->GetMaterial()->SetRoughness(sin(totalTime * 4) * 0.5f + 0.49f);
}
}
@ -193,13 +235,17 @@ void Game::Draw(float deltaTime, float totalTime)
{
std::shared_ptr<SimpleVertexShader> vs = entity->GetMaterial()->GetVertexShader();
vs->SetMatrix4x4("world", entity->GetTransform()->GetWorldMatrix());
vs->SetMatrix4x4("worldInvTranspose", entity->GetTransform()->GetWorldMatrixInverseTranspose());
vs->SetMatrix4x4("view", camera->GetViewMatrix());
vs->SetMatrix4x4("projection", camera->GetProjectionMatrix());
vs->CopyAllBufferData();
std::shared_ptr<SimplePixelShader> ps = entity->GetMaterial()->GetPixelShader();
ps->SetFloat4("tint", entity->GetMaterial()->GetTint());
ps->SetFloat("noise", 2.5f + cos(totalTime));
ps->SetFloat3("cameraPosition", camera->GetTransform()->GetPosition());
ps->SetFloat("roughness", entity->GetMaterial()->GetRoughness());
ps->SetFloat3("tint", entity->GetMaterial()->GetTint());
ps->SetFloat3("ambient", ambient);
ps->SetData("lights", &lights[0], sizeof(Light) * (int)lights.size());
ps->CopyAllBufferData();
entity->GetMaterial()->GetVertexShader()->SetShader();

5
Game.h
View file

@ -6,6 +6,7 @@
#include "Entity.h"
#include "SimpleShader.h"
#include "Material.h"
#include "Lights.h"
#include <DirectXMath.h>
#include <wrl/client.h> // Used for ComPtr - a smart pointer for COM objects
#include <memory>
@ -33,6 +34,7 @@ private:
// Initialization helper methods - feel free to customize, combine, etc.
void LoadShaders();
void LoadLighting();
void CreateBasicGeometry();
// Note the usage of ComPtr below
@ -52,6 +54,9 @@ private:
std::shared_ptr<Camera> camera;
// A6 Materials
std::vector<std::shared_ptr<Material>> materials;
// A7 Lights
std::vector<Light> lights;
DirectX::XMFLOAT3 ambient;
Microsoft::WRL::ComPtr<ID3D11Buffer> constantBufferVS;
};

47
Helpers.hlsli Normal file
View file

@ -0,0 +1,47 @@
#ifndef __SHADER_HELPERS__
#define __SHADER_HELPERS__
// gets view vector, needed once per shader
float3 getView(float3 cameraPosition, float3 pixelWorldPosition)
{
return normalize(cameraPosition - pixelWorldPosition);
}
// gets reflection vector, needed per light
float3 getReflection(float3 direction, float3 normal)
{
return reflect(direction, normal);
}
// gets specular exponent: (1-roughness) * max
float getSpecularExponent(float roughness, float max)
{
return (1.0f - roughness) * max;
}
// gets specular value: clamp(dot(r,v))^e
float getSpecular(float3 view, float3 reflection, float exponent)
{
float specular = 0;
if (exponent > 0.05f)
{
specular = pow(saturate(dot(reflection, view)), exponent);
}
return specular;
}
// gets diffuse value: clamp(dot(n,d))
float getDiffuse(float3 normal, float3 direction)
{
return saturate(dot(normal, direction));
}
// gets attenuation: clamp(1 - (distance^2 / range^2))^2
float getAttenuation(float3 pointPosition, float3 worldPosition, float3 range)
{
float dist = distance(pointPosition, worldPosition);
float attn = saturate(1.0f - (dist * dist / (range * range)));
return attn * attn;
}
#endif

19
Lights.h Normal file
View file

@ -0,0 +1,19 @@
#pragma once
#include <DirectXMath.h>
#define LIGHT_TYPE_DIRECTIONAL 0
#define LIGHT_TYPE_POINT 1
#define LIGHT_TYPE_SPOT 2
struct Light
{
int Type;
DirectX::XMFLOAT3 Direction;
float Range;
DirectX::XMFLOAT3 Position;
float Intensity;
DirectX::XMFLOAT3 Color;
float SpotFalloff;
DirectX::XMFLOAT3 Padding;
};

25
Lights.hlsli Normal file
View file

@ -0,0 +1,25 @@
#ifndef __SHADER_LIGHTS__
#define __SHADER_LIGHTS__
#define LIGHT_TYPE_DIRECTIONAL 0
#define LIGHT_TYPE_POINT 1
#define LIGHT_TYPE_SPOT 2
// Struct representing light data
// - This should match Lights.h
struct Light
{
int Type;
float3 Direction;
float Range;
float3 Position;
float Intensity;
float3 Color;
float SpotFalloff;
float3 Padding;
};
#endif

32
Material.cpp
View file

@ -1,8 +1,13 @@
#include "Material.h"
Material::Material(DirectX::XMFLOAT4 _tint, std::shared_ptr<SimpleVertexShader> _vertexShader, std::shared_ptr<SimplePixelShader> _pixelShader)
Material::Material(
DirectX::XMFLOAT3 _tint,
float _roughness,
std::shared_ptr<SimpleVertexShader> _vertexShader,
std::shared_ptr<SimplePixelShader> _pixelShader)
{
tint = _tint;
roughness = _roughness;
vertexShader = _vertexShader;
pixelShader = _pixelShader;
}
@ -11,11 +16,16 @@ Material::~Material()
{
}
DirectX::XMFLOAT4 Material::GetTint()
DirectX::XMFLOAT3 Material::GetTint()
{
return tint;
}
float Material::GetRoughness()
{
return roughness;
}
std::shared_ptr<SimpleVertexShader> Material::GetVertexShader()
{
return vertexShader;
@ -26,11 +36,27 @@ std::shared_ptr<SimplePixelShader> Material::GetPixelShader()
return pixelShader;
}
void Material::SetTint(DirectX::XMFLOAT4 _tint)
void Material::SetTint(DirectX::XMFLOAT3 _tint)
{
tint = _tint;
}
void Material::SetRoughness(float _roughness)
{
if (_roughness > 1)
{
roughness = 1;
}
else if (_roughness < 0)
{
roughness = 0;
}
else
{
roughness = _roughness;
}
}
void Material::SetVertexShader(std::shared_ptr<SimpleVertexShader> _vertexShader)
{
vertexShader = _vertexShader;

12
Material.h
View file

@ -8,21 +8,25 @@ class Material
{
public:
Material(
DirectX::XMFLOAT4 _tint,
DirectX::XMFLOAT3 _tint,
float _roughness,
std::shared_ptr<SimpleVertexShader> _vertexShader,
std::shared_ptr<SimplePixelShader> _pixelShader);
~Material();
DirectX::XMFLOAT4 GetTint();
DirectX::XMFLOAT3 GetTint();
float GetRoughness();
std::shared_ptr<SimpleVertexShader> GetVertexShader();
std::shared_ptr<SimplePixelShader> GetPixelShader();
void SetTint(DirectX::XMFLOAT4 _tint);
void SetTint(DirectX::XMFLOAT3 _tint);
void SetRoughness(float _roughness);
void SetVertexShader(std::shared_ptr<SimpleVertexShader> _vertexShader);
void SetPixelShader(std::shared_ptr<SimplePixelShader> _pixelShader);
private:
DirectX::XMFLOAT4 tint;
DirectX::XMFLOAT3 tint;
float roughness;
std::shared_ptr<SimpleVertexShader> vertexShader;
std::shared_ptr<SimplePixelShader> pixelShader;
};

18
PixelShader.hlsl
View file

@ -1,24 +1,10 @@
#include "Defines.hlsli"
cbuffer ExternalData : register(b0)
{
float4 tint;
}
// Struct representing the data we expect to receive from earlier pipeline stages
// - Should match the output of our corresponding vertex shader
// - The name of the struct itself is unimportant
// - The variable names don't have to match other shaders (just the semantics)
// - Each variable must have a semantic, which defines its usage
struct VertexToPixel
{
// Data type
// |
// | Name Semantic
// | | |
// v v v
float4 screenPosition : SV_POSITION;
float2 uv : TEXCOORD;
};
// --------------------------------------------------------
// The entry point (main method) for our pixel shader
//

104
RandomPixelShader.hlsl
View file

@ -1,89 +1,5 @@
/// BEGIN THIRD PARTY ///
/// SOURCE: https://thebookofshaders.com/edit.php#11/2d-snoise-clear.frag ///
// Some useful functions
float3 mod289(float3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
float2 mod289(float2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
float3 permute(float3 x) { return mod289(((x * 34.0) + 1.0) * x); }
//
// Description : GLSL 2D simplex noise function
// Author : Ian McEwan, Ashima Arts
// Maintainer : ijm
// Lastmod : 20110822 (ijm)
// License :
// Copyright (C) 2011 Ashima Arts. All rights reserved.
// Distributed under the MIT License. See LICENSE file.
// https://github.com/ashima/webgl-noise
//
float snoise(float2 v)
{
// Precompute values for skewed triangular grid
const float4 C = float4(0.211324865405187,
// (3.0-sqrt(3.0))/6.0
0.366025403784439,
// 0.5*(sqrt(3.0)-1.0)
-0.577350269189626,
// -1.0 + 2.0 * C.x
0.024390243902439);
// 1.0 / 41.0
// First corner (x0)
float2 i = floor(v + dot(v, C.yy));
float2 x0 = v - i + dot(i, C.xx);
// Other two corners (x1, x2)
float2 i1 = float2(0, 0);
i1 = (x0.x > x0.y) ? float2(1.0, 0.0) : float2(0.0, 1.0);
float2 x1 = x0.xy + C.xx - i1;
float2 x2 = x0.xy + C.zz;
// Do some permutations to avoid
// truncation effects in permutation
i = mod289(i);
float3 p = permute(
permute(i.y + float3(0.0, i1.y, 1.0))
+ i.x + float3(0.0, i1.x, 1.0));
float3 m = max(0.5 - float3(
dot(x0, x0),
dot(x1, x1),
dot(x2, x2)
), 0.0);
m = m * m;
m = m * m;
// Gradients:
// 41 pts uniformly over a line, mapped onto a diamond
// The ring size 17*17 = 289 is close to a multiple
// of 41 (41*7 = 287)
float3 x = 2.0 * frac(p * C.www) - 1.0;
float3 h = abs(x) - 0.5;
float3 ox = floor(x + 0.5);
float3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt(a0*a0 + h*h);
m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
// Compute final noise value at P
float3 g = float3(0, 0, 0);
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * float2(x1.x, x2.x) + h.yz * float2(x1.y, x2.y);
return 130.0 * dot(m, g);
}
/// SOURCE: https://thebookofshaders.com/10/ ///
float random(float2 st)
{
return frac(sin(dot(st.xy,
float2(12.9898, 78.233))) *
43758.5453123);
}
/// END THIRD PARTY ///
#include "Defines.hlsli"
#include "ThirdPartyFunctions.hlsli"
cbuffer ExternalData : register(b0)
{
@ -91,22 +7,6 @@ cbuffer ExternalData : register(b0)
float noise;
}
// Struct representing the data we expect to receive from earlier pipeline stages
// - Should match the output of our corresponding vertex shader
// - The name of the struct itself is unimportant
// - The variable names don't have to match other shaders (just the semantics)
// - Each variable must have a semantic, which defines its usage
struct VertexToPixel
{
// Data type
// |
// | Name Semantic
// | | |
// v v v
float4 screenPosition : SV_POSITION;
float2 uv : TEXCOORD;
};
// --------------------------------------------------------
// The entry point (main method) for our pixel shader
//

75
SimplePixelShader.hlsl Normal file
View file

@ -0,0 +1,75 @@
#include "Defines.hlsli"
#include "Helpers.hlsli"
#include "Lights.hlsli"
// temporary
#define LIGHT_COUNT 5
cbuffer ExternalData : register(b0)
{
float3 cameraPosition;
float roughness;
float3 ambient;
float3 tint;
Light lights[LIGHT_COUNT];
}
// Gets the specular value for any light
float calculateSpecular(float3 normal, float3 direction, float3 view, float roughness)
{
return getSpecular(
view,
getReflection(direction, normal),
getSpecularExponent(roughness, MAX_SPECULAR_EXPONENT)
);
}
// Gets the RGB value of a pixel with a directional light
float3 calculateDirectionalLight(Light light, float3 normal, float3 view, float roughness, float3 surfaceColor)
{
float3 lightDirection = normalize(light.Direction);
float diffuse = getDiffuse(normal, -lightDirection);
float specular = calculateSpecular(normal, lightDirection, view, roughness);
return (diffuse * surfaceColor + specular) * light.Intensity * light.Color;
}
// Gets the RGB value of a pixel with a point light
float3 calculatePointLight(Light light, float3 normal, float3 view, float3 worldPosition, float roughness, float3 surfaceColor)
{
float3 lightDirection = normalize(worldPosition - light.Position);
float attenuation = getAttenuation(light.Position, worldPosition, light.Range);
float diffuse = getDiffuse(normal, -lightDirection);
float specular = calculateSpecular(normal, lightDirection, view, roughness);
return (diffuse * surfaceColor + specular) * attenuation * light.Intensity * light.Color;
}
// shader entry point
float4 main(VertexToPixel input) : SV_TARGET
{
// ensure input normals are normalized
input.normal = normalize(input.normal);
// view only needs calculated once, so pre-calculate here and pass it to lights
float3 view = getView(cameraPosition, input.worldPosition);
// start with ambient light and material tint
float3 light = ambient * tint;
// loop through lights
for (int i = 0; i < LIGHT_COUNT; i++)
{
switch (lights[i].Type)
{
case LIGHT_TYPE_DIRECTIONAL:
light += calculateDirectionalLight(lights[i], input.normal, view, roughness, tint);
break;
case LIGHT_TYPE_POINT:
light += calculatePointLight(lights[i], input.normal, view, input.worldPosition, roughness, tint);
break;
}
}
return float4(light, 1);
}

91
ThirdPartyFunctions.hlsli Normal file
View file

@ -0,0 +1,91 @@
#ifndef __SHADER_THIRD_PARTY_FUNCTIONS__
#define __SHADER_THIRD_PARTY_FUNCTIONS__
/// BEGIN THIRD PARTY ///
/// SOURCE: https://thebookofshaders.com/edit.php#11/2d-snoise-clear.frag ///
// Some useful functions
float3 mod289(float3 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
float2 mod289(float2 x) { return x - floor(x * (1.0 / 289.0)) * 289.0; }
float3 permute(float3 x) { return mod289(((x * 34.0) + 1.0) * x); }
//
// Description : GLSL 2D simplex noise function
// Author : Ian McEwan, Ashima Arts
// Maintainer : ijm
// Lastmod : 20110822 (ijm)
// License :
// Copyright (C) 2011 Ashima Arts. All rights reserved.
// Distributed under the MIT License. See LICENSE file.
// https://github.com/ashima/webgl-noise
//
float snoise(float2 v)
{
// Precompute values for skewed triangular grid
const float4 C = float4(0.211324865405187,
// (3.0-sqrt(3.0))/6.0
0.366025403784439,
// 0.5*(sqrt(3.0)-1.0)
-0.577350269189626,
// -1.0 + 2.0 * C.x
0.024390243902439);
// 1.0 / 41.0
// First corner (x0)
float2 i = floor(v + dot(v, C.yy));
float2 x0 = v - i + dot(i, C.xx);
// Other two corners (x1, x2)
float2 i1 = float2(0, 0);
i1 = (x0.x > x0.y) ? float2(1.0, 0.0) : float2(0.0, 1.0);
float2 x1 = x0.xy + C.xx - i1;
float2 x2 = x0.xy + C.zz;
// Do some permutations to avoid
// truncation effects in permutation
i = mod289(i);
float3 p = permute(
permute(i.y + float3(0.0, i1.y, 1.0))
+ i.x + float3(0.0, i1.x, 1.0));
float3 m = max(0.5 - float3(
dot(x0, x0),
dot(x1, x1),
dot(x2, x2)
), 0.0);
m = m * m;
m = m * m;
// Gradients:
// 41 pts uniformly over a line, mapped onto a diamond
// The ring size 17*17 = 289 is close to a multiple
// of 41 (41*7 = 287)
float3 x = 2.0 * frac(p * C.www) - 1.0;
float3 h = abs(x) - 0.5;
float3 ox = floor(x + 0.5);
float3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversesqrt(a0*a0 + h*h);
m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
// Compute final noise value at P
float3 g = float3(0, 0, 0);
g.x = a0.x * x0.x + h.x * x0.y;
g.yz = a0.yz * float2(x1.x, x2.x) + h.yz * float2(x1.y, x2.y);
return 130.0 * dot(m, g);
}
/// SOURCE: https://thebookofshaders.com/10/ ///
float random(float2 st)
{
return frac(sin(dot(st.xy,
float2(12.9898, 78.233))) *
43758.5453123);
}
/// END THIRD PARTY ///
#endif

42
VertexShader.hlsl
View file

@ -1,43 +1,13 @@
#include "Defines.hlsli"
cbuffer ExternalData : register(b0)
{
matrix world;
matrix worldInvTranspose;
matrix view;
matrix projection;
}
// Struct representing a single vertex worth of data
// - This should match the vertex definition in our C++ code
// - By "match", I mean the size, order and number of members
// - The name of the struct itself is unimportant, but should be descriptive
// - Each variable must have a semantic, which defines its usage
struct VertexShaderInput
{
// Data type
// |
// | Name Semantic
// | | |
// v v v
float3 localPosition : POSITION;
float3 normal : NORMAL;
float2 uv : UV;
};
// Struct representing the data we're sending down the pipeline
// - Should match our pixel shader's input (hence the name: Vertex to Pixel)
// - At a minimum, we need a piece of data defined tagged as SV_POSITION
// - The name of the struct itself is unimportant, but should be descriptive
// - Each variable must have a semantic, which defines its usage
struct VertexToPixel
{
// Data type
// |
// | Name Semantic
// | | |
// v v v
float4 screenPosition : SV_POSITION;
float2 uv : TEXCOORD;
};
// --------------------------------------------------------
// The entry point (main method) for our vertex shader
//
@ -51,7 +21,7 @@ VertexToPixel main( VertexShaderInput input )
VertexToPixel output;
// Convert vertex to world view projection
matrix worldViewProjection = mul(mul(projection, view), world);
matrix worldViewProjection = mul(projection, mul(view, world));
// Here we're essentially passing the input position directly through to the next
// stage (rasterizer), though it needs to be a 4-component vector now.
@ -68,6 +38,10 @@ VertexToPixel main( VertexShaderInput input )
// - We don't need to alter it here, but we do need to send it to the pixel shader
output.uv = input.uv;
// Pass normal and world position throuh
output.normal = normalize(mul((float3x3)worldInvTranspose, input.normal));
output.worldPosition = mul(world, float4(input.localPosition, 1)).xyz;
// Whatever we return will make its way through the pipeline to the
// next programmable stage we're using (the pixel shader for now)
return output;