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

figure out why normals weren't correct

Browse source 
turns out i was passing camera transpose instead of entity transpose
This commit is contained in:
lightling 2022-03-19 16:34:55 -04:00
parent cd4ea05aae
commit 9ca7b66945
Signed by: lightling
GPG key ID: 016F11E0AA296B67
6 changed files with 23 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
Game.cpp
View file

@ -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);
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, 0, vertexShader, pixelShader),
std::make_shared<Material>(deeppink, 0, vertexShader, pixelShader),
std::make_shared<Material>(deepcoral, 0, vertexShader, pixelShader),
std::make_shared<Material>(white, 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.Color = XMFLOAT3(0.2f, 0.2f, 1.0f);
directionalLight1.Direction = XMFLOAT3(1, 0, 0);
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();

3
Includes.hlsli
View file

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

6
Material.cpp
View file

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

8
Material.h
View file

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

3
SimplePixelShader.hlsl
View file

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

6
VertexShader.hlsl
View file

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