Lightling
21b7cecab1
- somehow texturecube was getting sent to toon shader at some point down the line, simply defined register for it for now, don't know where it's getting sent - pbr was expected Sampler not BasicSampler
352 lines
9.5 KiB
C++
352 lines
9.5 KiB
C++
#include "Material.h"
|
|
|
|
Material::Material(
|
|
int _mode,
|
|
DirectX::XMFLOAT3 _tint,
|
|
float _roughness,
|
|
std::shared_ptr<SimpleVertexShader> _vertexShader,
|
|
std::shared_ptr<SimplePixelShader> _pixelShader)
|
|
{
|
|
mode = _mode;
|
|
tint = _tint;
|
|
roughness = _roughness;
|
|
normalIntensity = 1.f;
|
|
alpha = 1;
|
|
cutoff = 0;
|
|
vertexShader = _vertexShader;
|
|
pixelShader = _pixelShader;
|
|
uvOffset = DirectX::XMFLOAT2(0, 0);
|
|
uvScale = DirectX::XMFLOAT2(1, 1);
|
|
emitAmount = DirectX::XMFLOAT3(0, 0, 0);
|
|
hasAlbedoMap = false;
|
|
hasEmissiveMap = false;
|
|
hasSpecularMap = false;
|
|
hasNormalMap = false;
|
|
hasReflectionMap = false;
|
|
hasRampDiffuse = false;
|
|
hasRampSpecular = false;
|
|
outlineThickness = 1;
|
|
rimCutoff = 0.075f;
|
|
rimTint = DirectX::XMFLOAT3(0.5f, 0.5f, 0.5f);
|
|
}
|
|
|
|
Material::~Material()
|
|
{
|
|
}
|
|
|
|
void Material::Activate(Transform* _transform, std::shared_ptr<Camera> _camera, DirectX::XMFLOAT3 _ambient, std::vector<Light> _lights)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case MATTYPE_PBR:
|
|
ActivatePBR(_transform, _camera, _ambient, _lights);
|
|
break;
|
|
case MATTYPE_TOON:
|
|
ActivateToon(_transform, _camera, _ambient, _lights);
|
|
break;
|
|
case MATTYPE_STANDARD:
|
|
default:
|
|
ActivateStandard(_transform, _camera, _ambient, _lights);
|
|
break;
|
|
}
|
|
}
|
|
|
|
#pragma region Getters
|
|
DirectX::XMFLOAT3 Material::GetTint()
|
|
{
|
|
return tint;
|
|
}
|
|
|
|
DirectX::XMFLOAT2 Material::GetUVScale()
|
|
{
|
|
return uvScale;
|
|
}
|
|
|
|
DirectX::XMFLOAT2 Material::GetUVOffset()
|
|
{
|
|
return uvOffset;
|
|
}
|
|
|
|
float Material::GetRoughness()
|
|
{
|
|
return roughness;
|
|
}
|
|
|
|
float Material::GetAlpha()
|
|
{
|
|
return alpha;
|
|
}
|
|
|
|
float Material::GetCutoff()
|
|
{
|
|
return cutoff;
|
|
}
|
|
|
|
float Material::GetNormalIntensity()
|
|
{
|
|
return normalIntensity;
|
|
}
|
|
|
|
float Material::GetRimCutoff()
|
|
{
|
|
return rimCutoff;
|
|
}
|
|
|
|
float Material::GetOutlineThickness()
|
|
{
|
|
return outlineThickness;
|
|
}
|
|
|
|
DirectX::XMFLOAT3 Material::GetEmitAmount()
|
|
{
|
|
return emitAmount;
|
|
}
|
|
|
|
DirectX::XMFLOAT3 Material::GetOutlineTint()
|
|
{
|
|
return outlineTint;
|
|
}
|
|
|
|
DirectX::XMFLOAT3 Material::GetRimTint()
|
|
{
|
|
return rimTint;
|
|
}
|
|
|
|
std::shared_ptr<SimpleVertexShader> Material::GetVertexShader()
|
|
{
|
|
return vertexShader;
|
|
}
|
|
|
|
std::shared_ptr<SimplePixelShader> Material::GetPixelShader()
|
|
{
|
|
return pixelShader;
|
|
}
|
|
#pragma endregion
|
|
|
|
#pragma region Setters
|
|
void Material::SetTint(DirectX::XMFLOAT3 _tint)
|
|
{
|
|
tint = _tint;
|
|
}
|
|
|
|
void Material::SetUVScale(DirectX::XMFLOAT2 _scale)
|
|
{
|
|
uvScale = _scale;
|
|
}
|
|
|
|
void Material::SetUVOffset(DirectX::XMFLOAT2 _offset)
|
|
{
|
|
uvOffset = _offset;
|
|
}
|
|
|
|
void Material::SetRoughness(float _roughness)
|
|
{
|
|
if (_roughness > 1)
|
|
{
|
|
roughness = 1;
|
|
}
|
|
else if (_roughness < 0)
|
|
{
|
|
roughness = 0;
|
|
}
|
|
else
|
|
{
|
|
roughness = _roughness;
|
|
}
|
|
}
|
|
|
|
void Material::SetAlpha(float _alpha)
|
|
{
|
|
alpha = _alpha;
|
|
}
|
|
|
|
void Material::SetCutoff(float _cutoff)
|
|
{
|
|
cutoff = _cutoff;
|
|
}
|
|
|
|
void Material::SetNormalIntensity(float _intensity)
|
|
{
|
|
normalIntensity = _intensity;
|
|
}
|
|
|
|
void Material::SetRimCutoff(float _cutoff)
|
|
{
|
|
rimCutoff = _cutoff;
|
|
}
|
|
|
|
void Material::SetOutlineThickness(float _thickness)
|
|
{
|
|
outlineThickness = _thickness;
|
|
}
|
|
|
|
void Material::SetEmitAmount(DirectX::XMFLOAT3 _emit)
|
|
{
|
|
emitAmount = _emit;
|
|
}
|
|
|
|
void Material::SetOutlineTint(DirectX::XMFLOAT3 _tint)
|
|
{
|
|
outlineTint = _tint;
|
|
}
|
|
|
|
void Material::SetRimTint(DirectX::XMFLOAT3 _tint)
|
|
{
|
|
rimTint = _tint;
|
|
}
|
|
|
|
void Material::SetVertexShader(std::shared_ptr<SimpleVertexShader> _vertexShader)
|
|
{
|
|
vertexShader = _vertexShader;
|
|
}
|
|
|
|
void Material::SetPixelShader(std::shared_ptr<SimplePixelShader> _pixelShader)
|
|
{
|
|
pixelShader = _pixelShader;
|
|
}
|
|
#pragma endregion
|
|
|
|
#pragma region Utility
|
|
void Material::LoadTexture(const wchar_t* _path, const char* _type, ID3D11Device* _device, ID3D11DeviceContext* _context)
|
|
{
|
|
Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> shaderResourceView;
|
|
DirectX::CreateWICTextureFromFile(_device, _context, DXCore::GetFullPathTo_Wide(_path).c_str(), 0, shaderResourceView.GetAddressOf());
|
|
PushTexture(_type, shaderResourceView);
|
|
|
|
if (_type == TEXTYPE_ALBEDO) hasAlbedoMap = true;
|
|
else if (_type == TEXTYPE_EMISSIVE) hasEmissiveMap = true;
|
|
else if (_type == TEXTYPE_SPECULAR) hasSpecularMap = true;
|
|
else if (_type == TEXTYPE_NORMAL) hasNormalMap = true;
|
|
else if (_type == TEXTYPE_REFLECTION) hasReflectionMap = true;
|
|
else if (_type == TEXTYPE_RAMPDIFFUSE) hasRampDiffuse = true;
|
|
else if (_type == TEXTYPE_RAMPSPECULAR) hasRampSpecular = true;
|
|
}
|
|
|
|
void Material::PushSampler(std::string _name, Microsoft::WRL::ComPtr<ID3D11SamplerState> _sampler)
|
|
{
|
|
samplers.insert({ _name, _sampler });
|
|
}
|
|
|
|
void Material::PushTexture(std::string _name, Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> _texture)
|
|
{
|
|
textures.insert({ _name, _texture });
|
|
}
|
|
|
|
void Material::SwapTexture(std::string _name, Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> _newTexture)
|
|
{
|
|
textures[_name] = _newTexture;
|
|
}
|
|
#pragma endregion
|
|
|
|
#pragma region Internal Material Activation
|
|
void Material::ActivateStandard(Transform* _transform, std::shared_ptr<Camera> _camera, DirectX::XMFLOAT3 _ambient, std::vector<Light> _lights)
|
|
{
|
|
vertexShader->SetMatrix4x4("world", _transform->GetWorldMatrix());
|
|
vertexShader->SetMatrix4x4("worldInvTranspose", _transform->GetWorldMatrixInverseTranspose());
|
|
vertexShader->SetMatrix4x4("view", _camera->GetViewMatrix());
|
|
vertexShader->SetMatrix4x4("projection", _camera->GetProjectionMatrix());
|
|
vertexShader->CopyAllBufferData();
|
|
vertexShader->SetShader();
|
|
|
|
pixelShader->SetFloat3("cameraPosition", _camera->GetTransform()->GetPosition());
|
|
pixelShader->SetFloat("roughness", GetRoughness());
|
|
pixelShader->SetFloat("normalIntensity", GetNormalIntensity());
|
|
pixelShader->SetFloat("alpha", GetAlpha());
|
|
pixelShader->SetFloat("cutoff", GetCutoff());
|
|
pixelShader->SetFloat2("scale", GetUVScale());
|
|
pixelShader->SetFloat2("offset", GetUVOffset());
|
|
pixelShader->SetFloat3("ambient", _ambient);
|
|
pixelShader->SetFloat3("emitAmount", GetEmitAmount());
|
|
pixelShader->SetFloat3("tint", GetTint());
|
|
pixelShader->SetFloat("lightCount", (int)_lights.size());
|
|
pixelShader->SetInt("hasAlbedoMap", (int)hasAlbedoMap);
|
|
pixelShader->SetInt("hasEmissiveMap", (int)hasEmissiveMap);
|
|
pixelShader->SetInt("hasSpecularMap", (int)hasSpecularMap);
|
|
pixelShader->SetInt("hasNormalMap", (int)hasNormalMap);
|
|
pixelShader->SetInt("hasReflectionMap", (int)hasReflectionMap);
|
|
pixelShader->SetData("lights", &_lights[0], sizeof(Light) * (int)_lights.size());
|
|
pixelShader->CopyAllBufferData();
|
|
pixelShader->SetShader();
|
|
|
|
for (auto& t : textures)
|
|
{
|
|
pixelShader->SetShaderResourceView(t.first.c_str(), t.second.Get());
|
|
}
|
|
for (auto& s : samplers)
|
|
{
|
|
pixelShader->SetSamplerState(s.first.c_str(), s.second.Get());
|
|
}
|
|
}
|
|
|
|
void Material::ActivatePBR(Transform* _transform, std::shared_ptr<Camera> _camera, DirectX::XMFLOAT3 _ambient, std::vector<Light> _lights)
|
|
{
|
|
vertexShader->SetMatrix4x4("world", _transform->GetWorldMatrix());
|
|
vertexShader->SetMatrix4x4("worldInvTranspose", _transform->GetWorldMatrixInverseTranspose());
|
|
vertexShader->SetMatrix4x4("view", _camera->GetViewMatrix());
|
|
vertexShader->SetMatrix4x4("projection", _camera->GetProjectionMatrix());
|
|
vertexShader->CopyAllBufferData();
|
|
vertexShader->SetShader();
|
|
|
|
pixelShader->SetFloat2("scale", GetUVScale());
|
|
pixelShader->SetFloat2("offset", GetUVOffset());
|
|
pixelShader->SetFloat3("cameraPosition", _camera->GetTransform()->GetPosition());
|
|
pixelShader->SetFloat("normalIntensity", GetNormalIntensity());
|
|
pixelShader->SetFloat("lightCount", (int)_lights.size());
|
|
pixelShader->SetData("lights", &_lights[0], sizeof(Light) * (int)_lights.size());
|
|
pixelShader->CopyAllBufferData();
|
|
pixelShader->SetShader();
|
|
|
|
for (auto& t : textures)
|
|
{
|
|
pixelShader->SetShaderResourceView(t.first.c_str(), t.second.Get());
|
|
}
|
|
for (auto& s : samplers)
|
|
{
|
|
pixelShader->SetSamplerState(s.first.c_str(), s.second.Get());
|
|
}
|
|
}
|
|
|
|
void Material::ActivateToon(Transform* _transform, std::shared_ptr<Camera> _camera, DirectX::XMFLOAT3 _ambient, std::vector<Light> _lights)
|
|
{
|
|
vertexShader->SetMatrix4x4("world", _transform->GetWorldMatrix());
|
|
vertexShader->SetMatrix4x4("worldInvTranspose", _transform->GetWorldMatrixInverseTranspose());
|
|
vertexShader->SetMatrix4x4("view", _camera->GetViewMatrix());
|
|
vertexShader->SetMatrix4x4("projection", _camera->GetProjectionMatrix());
|
|
vertexShader->CopyAllBufferData();
|
|
vertexShader->SetShader();
|
|
|
|
pixelShader->SetFloat3("cameraPosition", _camera->GetTransform()->GetPosition());
|
|
pixelShader->SetFloat("roughness", GetRoughness());
|
|
pixelShader->SetFloat("normalIntensity", GetNormalIntensity());
|
|
pixelShader->SetFloat("alpha", GetAlpha());
|
|
pixelShader->SetFloat("cutoff", GetCutoff());
|
|
pixelShader->SetFloat2("scale", GetUVScale());
|
|
pixelShader->SetFloat2("offset", GetUVOffset());
|
|
pixelShader->SetFloat3("ambient", _ambient);
|
|
pixelShader->SetFloat3("emitAmount", GetEmitAmount());
|
|
pixelShader->SetFloat3("tint", GetTint());
|
|
pixelShader->SetFloat3("rimTint", GetRimTint());
|
|
pixelShader->SetFloat3("outlineTint", GetOutlineTint());
|
|
pixelShader->SetFloat("outlineThickness", GetOutlineThickness());
|
|
pixelShader->SetFloat("rimCutoff", GetRimCutoff());
|
|
pixelShader->SetFloat("lightCount", (int)_lights.size());
|
|
pixelShader->SetInt("hasAlbedoMap", (int)hasAlbedoMap);
|
|
pixelShader->SetInt("hasEmissiveMap", (int)hasEmissiveMap);
|
|
pixelShader->SetInt("hasSpecularMap", (int)hasSpecularMap);
|
|
pixelShader->SetInt("hasNormalMap", (int)hasNormalMap);
|
|
pixelShader->SetInt("hasRampDiffuse", (int)hasRampDiffuse);
|
|
pixelShader->SetInt("hasRampSpecular", (int)hasRampSpecular);
|
|
pixelShader->SetData("lights", &_lights[0], sizeof(Light) * (int)_lights.size());
|
|
pixelShader->CopyAllBufferData();
|
|
pixelShader->SetShader();
|
|
|
|
for (auto& t : textures)
|
|
{
|
|
pixelShader->SetShaderResourceView(t.first.c_str(), t.second.Get());
|
|
}
|
|
for (auto& s : samplers)
|
|
{
|
|
pixelShader->SetSamplerState(s.first.c_str(), s.second.Get());
|
|
}
|
|
}
|
|
#pragma endregion
|