figure out why normals weren't correct

turns out i was passing camera transpose instead of entity transpose

Game.cpp

@@ -85,14 +85,14 @@ void Game::LoadShaders()
 		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, 0, vertexShader, pixelShader),
-		std::make_shared<Material>(deeppink, 0, vertexShader, pixelShader),
+		std::make_shared<Material>(white, 0, vertexShader, pixelShader),
-		std::make_shared<Material>(deepcoral, 0, vertexShader, pixelShader),
+		std::make_shared<Material>(white, 0, vertexShader, pixelShader),
 	};
 }
 
@@ -100,8 +100,8 @@ void Game::LoadLighting()
 {
 	directionalLight1 = {};
 	directionalLight1.Type = LIGHT_TYPE_DIRECTIONAL;
-	directionalLight1.Direction = XMFLOAT3(1, -1, 0);
+	directionalLight1.Direction = XMFLOAT3(1, 0, 0);
-	directionalLight1.Color = XMFLOAT3(0.2f, 0.2f, 1.0f);
+	directionalLight1.Color = XMFLOAT3(1.0f, 0, 0);
 	directionalLight1.Intensity = 1.0f;
 }
 
@@ -206,14 +206,15 @@ 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->SetMatrix4x4("worldInvTranspose", camera->GetTransform()->GetWorldMatrixInverseTranspose());
 		vs->CopyAllBufferData();
 
 		std::shared_ptr<SimplePixelShader> ps = entity->GetMaterial()->GetPixelShader();
 		ps->SetFloat3("cameraPosition", camera->GetTransform()->GetPosition());
 		ps->SetFloat("roughness", entity->GetMaterial()->GetRoughness());
+		ps->SetFloat3("tint", entity->GetMaterial()->GetTint());
 		ps->SetFloat3("ambient", ambient);
 		ps->SetData("directionalLight1", &directionalLight1, sizeof(Light));
 		ps->CopyAllBufferData();

Includes.hlsli

@@ -7,6 +7,7 @@
 
 #define MAX_SPECULAR_EXPONENT 256.0f
 
+// Struct representing the data stored in the Lights.h struct Light
 struct Light
 {
 	int		Type;
@@ -54,7 +55,7 @@ struct VertexShaderInput
     //  v    v                v
     float3 localPosition	: POSITION;
     float3 normal			: NORMAL;
-    float2 uv				: UV;
+    float2 uv				: TEXCOORD;
 };
 
 /// BEGIN THIRD PARTY ///

Material.cpp

@@ -1,7 +1,7 @@
 #include "Material.h"
 
 Material::Material(
-	DirectX::XMFLOAT4 _tint,
+	DirectX::XMFLOAT3 _tint,
 	float _roughness,
 	std::shared_ptr<SimpleVertexShader> _vertexShader,
 	std::shared_ptr<SimplePixelShader> _pixelShader)
@@ -16,7 +16,7 @@ Material::~Material()
 {
 }
 
-DirectX::XMFLOAT4 Material::GetTint()
+DirectX::XMFLOAT3 Material::GetTint()
 {
 	return tint;
 }
@@ -36,7 +36,7 @@ std::shared_ptr<SimplePixelShader> Material::GetPixelShader()
 	return pixelShader;
 }
 
-void Material::SetTint(DirectX::XMFLOAT4 _tint)
+void Material::SetTint(DirectX::XMFLOAT3 _tint)
 {
 	tint = _tint;
 }

Material.h

@@ -8,24 +8,24 @@ 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;

SimplePixelShader.hlsl

@@ -5,11 +5,12 @@ cbuffer ExternalData : register(b0)
 	float3 cameraPosition;
 	float roughness;
 	float3 ambient;
+	float3 tint;
 	Light directionalLight1;
 }
 
 float4 main(VertexToPixel input) : SV_TARGET
 {
 	input.normal = normalize(input.normal);
-	return float4(directionalLight1.Color, 1);
+	return float4(input.normal, 1);
 }

VertexShader.hlsl

@@ -3,9 +3,9 @@
 cbuffer ExternalData : register(b0)
 {
 	matrix world;
+	matrix worldInvTranspose;
 	matrix view;
 	matrix projection;
-	matrix worldInvTranspose;
 }
 
 // --------------------------------------------------------
@@ -21,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.  
@@ -39,7 +39,7 @@ VertexToPixel main( VertexShaderInput input )
 	output.uv = input.uv;
 
 	// Pass normal and world position throuh
-	output.normal = mul((float3x3)worldInvTranspose, input.normal);
+	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