Merge pull request #6 from xLightling/a7_lights

A7: Lights

.editorconfig

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

DX11Starter.vcxproj

@@ -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>

DX11Starter.vcxproj.filters

@@ -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>

Defines.hlsli

@@ -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

Game.cpp

@@ -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);
+	XMFLOAT3 white = XMFLOAT3(1.0f, 1.0f, 1.0f);
-	XMFLOAT4 deeppink = XMFLOAT4(1.0f, 0.08f, 0.4f, 1.0f);
+	XMFLOAT3 deeppink = XMFLOAT3(1.0f, 0.08f, 0.4f);
-	XMFLOAT4 deepcoral = XMFLOAT4(1.0f, 0.39f, 0.22f, 1.0f);
+	XMFLOAT3 deepcoral = XMFLOAT3(1.0f, 0.39f, 0.22f);
 
 	materials = {
-		std::make_shared<Material>(white, vertexShader, pixelShader),
+		std::make_shared<Material>(white, 0, vertexShader, pixelShader),
-		std::make_shared<Material>(deeppink, vertexShader, pixelShader),
+		std::make_shared<Material>(deeppink, 0, vertexShader, pixelShader),
-		std::make_shared<Material>(deepcoral, 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[0], shapes[1]),
-		std::make_shared<Entity>(materials[2], shapes[2]),
+		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[0], shapes[4]),
-		std::make_shared<Entity>(materials[2], shapes[5]),
+		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->SetFloat3("cameraPosition", camera->GetTransform()->GetPosition());
-		ps->SetFloat("noise", 2.5f + cos(totalTime));
+		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();

Game.h

@@ -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;
 };

Helpers.hlsli

@@ -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

Lights.h

@@ -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;
+};

Lights.hlsli

@@ -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

Material.cpp

@@ -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;

Material.h

@@ -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;
 };

PixelShader.hlsl

@@ -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
 // 
@@ -35,4 +21,4 @@ float4 main(VertexToPixel input) : SV_TARGET
 	//   interpolated for each pixel between the corresponding vertices 
 	//   of the triangle we're rendering
 	return tint;
-}
+}

RandomPixelShader.hlsl

@@ -1,89 +1,5 @@
-/// BEGIN THIRD PARTY ///
+#include "Defines.hlsli"
-/// SOURCE: https://thebookofshaders.com/edit.php#11/2d-snoise-clear.frag ///
+#include "ThirdPartyFunctions.hlsli"
-
-// 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 ///
 
 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
 // 
@@ -127,4 +27,4 @@ float4 main(VertexToPixel input) : SV_TARGET
         sin(snoise(input.uv * noise) + tint.g - random(input.uv)) + (tint.g * 0.5),
         sin(snoise(input.uv * noise) + tint.b - random(input.uv)) + (tint.b * 0.5),
         cos(random(input.screenPosition)));
-}
+}

SimplePixelShader.hlsl

@@ -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);
+}

ThirdPartyFunctions.hlsli

@@ -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

VertexShader.hlsl

@@ -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,7 +38,11 @@ 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;
-}
+}