sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Graphics: Add new functions to get default material types/presets

This commit is contained in:
SirLynix 2023-08-08 18:17:58 +02:00
parent 32f8141bd8
commit cf6fdf258f
20 changed files with 111 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/PhysicallyBasedRendering/main.cpp
View File

@ -46,9 +46,7 @@ int main(int argc, char* argv[])
std::shared_ptr<Nz::Texture> normalMap = Nz::Texture::LoadFromFile(resourceDir / "Rusty/rustediron2_normal.png", texParams); std::shared_ptr<Nz::Texture> normalMap = Nz::Texture::LoadFromFile(resourceDir / "Rusty/rustediron2_normal.png", texParams);
std::shared_ptr<Nz::Material> material = Nz::Graphics::Instance()->GetDefaultMaterials().pbrMaterial; std::shared_ptr<Nz::MaterialInstance> materialInstance = Nz::MaterialInstance::Instantiate(Nz::MaterialType::PhysicallyBased);
std::shared_ptr<Nz::MaterialInstance> materialInstance = std::make_shared<Nz::MaterialInstance>(material);
materialInstance->SetTextureProperty("AlphaMap", Nz::Texture::LoadFromFile(resourceDir / "alphatile.png", texParams)); materialInstance->SetTextureProperty("AlphaMap", Nz::Texture::LoadFromFile(resourceDir / "alphatile.png", texParams));
materialInstance->SetTextureProperty("BaseColorMap", Nz::Texture::LoadFromFile(resourceDir / "Rusty/rustediron2_basecolor.png", texParams)); materialInstance->SetTextureProperty("BaseColorMap", Nz::Texture::LoadFromFile(resourceDir / "Rusty/rustediron2_basecolor.png", texParams));
materialInstance->SetTextureProperty("MetallicMap", Nz::Texture::LoadFromFile(resourceDir / "Rusty/rustediron2_metallic.png", texParams)); materialInstance->SetTextureProperty("MetallicMap", Nz::Texture::LoadFromFile(resourceDir / "Rusty/rustediron2_metallic.png", texParams));

4
examples/Physics2DDemo/main.cpp
View File

@ -56,7 +56,7 @@ int main(int argc, char* argv[])
texParams.renderDevice = device; texParams.renderDevice = device;
texParams.loadFormat = Nz::PixelFormat::RGBA8; texParams.loadFormat = Nz::PixelFormat::RGBA8;
std::shared_ptr<Nz::MaterialInstance> spriteMaterial = Nz::Graphics::Instance()->GetDefaultMaterials().phongMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> spriteMaterial = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Phong);
spriteMaterial->SetTextureProperty("BaseColorMap", Nz::Texture::LoadFromFile(resourceDir / "box.png", texParams)); spriteMaterial->SetTextureProperty("BaseColorMap", Nz::Texture::LoadFromFile(resourceDir / "box.png", texParams));
Nz::ChipmunkRigidBody2DComponent::DynamicSettings boxSettings; Nz::ChipmunkRigidBody2DComponent::DynamicSettings boxSettings;
@ -89,7 +89,7 @@ int main(int argc, char* argv[])
tilemap->SetOrigin({ 0.5f, 0.5f }); tilemap->SetOrigin({ 0.5f, 0.5f });
for (std::size_t i = 0; i < 18; ++i) for (std::size_t i = 0; i < 18; ++i)
{ {
std::shared_ptr<Nz::MaterialInstance> tileMaterial = Nz::Graphics::Instance()->GetDefaultMaterials().basicTransparent->Clone(); std::shared_ptr<Nz::MaterialInstance> tileMaterial = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Basic, Nz::MaterialInstancePreset::Transparent);
tileMaterial->SetTextureProperty("BaseColorMap", Nz::Texture::LoadFromFile(resourceDir / "tiles" / (std::to_string(i + 1) + ".png"), texParams)); tileMaterial->SetTextureProperty("BaseColorMap", Nz::Texture::LoadFromFile(resourceDir / "tiles" / (std::to_string(i + 1) + ".png"), texParams));
tilemap->SetMaterial(i, tileMaterial); tilemap->SetMaterial(i, tileMaterial);

6
examples/PhysicsDemo/main.cpp
View File

@ -60,7 +60,7 @@ int main(int argc, char* argv[])
texParams.renderDevice = device; texParams.renderDevice = device;
texParams.loadFormat = Nz::PixelFormat::RGBA8_SRGB; texParams.loadFormat = Nz::PixelFormat::RGBA8_SRGB;
std::shared_ptr<Nz::MaterialInstance> material = Nz::Graphics::Instance()->GetDefaultMaterials().phongMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> material = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Phong);
for (std::string_view passName : { "DepthPass", "ForwardPass" }) for (std::string_view passName : { "DepthPass", "ForwardPass" })
{ {
material->UpdatePassStates(passName, [](Nz::RenderStates& states) material->UpdatePassStates(passName, [](Nz::RenderStates& states)
@ -77,7 +77,7 @@ int main(int argc, char* argv[])
for (std::size_t i = 0; i < model->GetSubMeshCount(); ++i) for (std::size_t i = 0; i < model->GetSubMeshCount(); ++i)
model->SetMaterial(i, material); model->SetMaterial(i, material);
std::shared_ptr<Nz::MaterialInstance> textMaterial = Nz::Graphics::Instance()->GetDefaultMaterials().basicTransparent->Clone(); std::shared_ptr<Nz::MaterialInstance> textMaterial = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Basic, Nz::MaterialInstancePreset::Transparent);
textMaterial->UpdatePassFlags("ForwardPass", Nz::MaterialPassFlag::SortByDistance); textMaterial->UpdatePassFlags("ForwardPass", Nz::MaterialPassFlag::SortByDistance);
textMaterial->UpdatePassStates("ForwardPass", [](Nz::RenderStates& states) textMaterial->UpdatePassStates("ForwardPass", [](Nz::RenderStates& states)
{ {
@ -103,7 +103,7 @@ int main(int argc, char* argv[])
auto shipCollider = std::make_shared<Nz::BulletConvexCollider3D>(vertices, vertexMapper.GetVertexCount()); auto shipCollider = std::make_shared<Nz::BulletConvexCollider3D>(vertices, vertexMapper.GetVertexCount());
std::shared_ptr<Nz::MaterialInstance> colliderMat = Nz::Graphics::Instance()->GetDefaultMaterials().basicMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> colliderMat = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Basic);
colliderMat->SetValueProperty("BaseColor", Nz::Color::Green()); colliderMat->SetValueProperty("BaseColor", Nz::Color::Green());
colliderMat->UpdatePassesStates([](Nz::RenderStates& states) colliderMat->UpdatePassesStates([](Nz::RenderStates& states)
{ {

10
examples/PhysicsPlayground/main.cpp
View File

@ -60,7 +60,7 @@ int main(int argc, char* argv[])
Nz::Vector3f target = Nz::Vector3f::Zero(); Nz::Vector3f target = Nz::Vector3f::Zero();
std::shared_ptr<Nz::MaterialInstance> colliderMat = Nz::Graphics::Instance()->GetDefaultMaterials().basicMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> colliderMat = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Basic);
colliderMat->SetValueProperty("BaseColor", Nz::Color::Green()); colliderMat->SetValueProperty("BaseColor", Nz::Color::Green());
colliderMat->UpdatePassesStates([](Nz::RenderStates& states) colliderMat->UpdatePassesStates([](Nz::RenderStates& states)
{ {
@ -77,7 +77,7 @@ int main(int argc, char* argv[])
planeSampler.wrapModeU = Nz::SamplerWrap::Repeat; planeSampler.wrapModeU = Nz::SamplerWrap::Repeat;
planeSampler.wrapModeV = Nz::SamplerWrap::Repeat; planeSampler.wrapModeV = Nz::SamplerWrap::Repeat;
std::shared_ptr<Nz::MaterialInstance> boxMat = Nz::Graphics::Instance()->GetDefaultMaterials().phongMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> boxMat = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Phong);
boxMat->SetTextureProperty("BaseColorMap", fs.Load<Nz::Texture>("assets/dev_grey.png"), planeSampler); boxMat->SetTextureProperty("BaseColorMap", fs.Load<Nz::Texture>("assets/dev_grey.png"), planeSampler);
boxMat->DisablePass("ShadowPass"); boxMat->DisablePass("ShadowPass");
boxMat->UpdatePassesStates([&](Nz::RenderStates& states) boxMat->UpdatePassesStates([&](Nz::RenderStates& states)
@ -168,7 +168,7 @@ int main(int argc, char* argv[])
entt::handle ballEntity = world.CreateEntity(); entt::handle ballEntity = world.CreateEntity();
std::shared_ptr<Nz::MaterialInstance> ballMaterial = Nz::Graphics::Instance()->GetDefaultMaterials().phongMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> ballMaterial = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Phong);
ballMaterial->SetValueProperty("BaseColor", Nz::Color::FromHSV(colorDis(rd), 1.f, 1.f)); ballMaterial->SetValueProperty("BaseColor", Nz::Color::FromHSV(colorDis(rd), 1.f, 1.f));
std::shared_ptr<Nz::Model> sphereModel = std::make_shared<Nz::Model>(sphereMesh); std::shared_ptr<Nz::Model> sphereModel = std::make_shared<Nz::Model>(sphereMesh);
@ -208,7 +208,7 @@ int main(int argc, char* argv[])
entt::handle boxEntity = world.CreateEntity(); entt::handle boxEntity = world.CreateEntity();
std::shared_ptr<Nz::MaterialInstance> boxMaterial = Nz::Graphics::Instance()->GetDefaultMaterials().phongMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> boxMaterial = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Phong);
boxMaterial->SetValueProperty("BaseColor", Nz::Color::FromHSV(colorDis(rd), 1.f, 1.f)); boxMaterial->SetValueProperty("BaseColor", Nz::Color::FromHSV(colorDis(rd), 1.f, 1.f));
std::shared_ptr<Nz::Model> sphereModel = std::make_shared<Nz::Model>(boxMesh); std::shared_ptr<Nz::Model> sphereModel = std::make_shared<Nz::Model>(boxMesh);
@ -264,7 +264,7 @@ int main(int argc, char* argv[])
Nz::TextureSamplerInfo samplerInfo; Nz::TextureSamplerInfo samplerInfo;
samplerInfo.anisotropyLevel = 8; samplerInfo.anisotropyLevel = 8;
std::shared_ptr<Nz::MaterialInstance> material = Nz::Graphics::Instance()->GetDefaultMaterials().phongMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> material = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Phong);
Nz::TextureParams texParams; Nz::TextureParams texParams;
texParams.loadFormat = Nz::PixelFormat::RGBA8_SRGB; texParams.loadFormat = Nz::PixelFormat::RGBA8_SRGB;

14
examples/Showcase/main.cpp
View File

@ -83,7 +83,7 @@ int main(int argc, char* argv[])
std::shared_ptr<Nz::Mesh> colliderMesh = Nz::Mesh::Build(playerCollider->GenerateDebugMesh()); std::shared_ptr<Nz::Mesh> colliderMesh = Nz::Mesh::Build(playerCollider->GenerateDebugMesh());
std::shared_ptr<Nz::GraphicalMesh> colliderGraphicalMesh = Nz::GraphicalMesh::BuildFromMesh(*colliderMesh); std::shared_ptr<Nz::GraphicalMesh> colliderGraphicalMesh = Nz::GraphicalMesh::BuildFromMesh(*colliderMesh);
std::shared_ptr<Nz::MaterialInstance> colliderMat = Nz::Graphics::Instance()->GetDefaultMaterials().basicMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> colliderMat = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Basic);
colliderMat->SetValueProperty("BaseColor", Nz::Color::Green()); colliderMat->SetValueProperty("BaseColor", Nz::Color::Green());
colliderMat->UpdatePassesStates([](Nz::RenderStates& states) colliderMat->UpdatePassesStates([](Nz::RenderStates& states)
{ {
@ -155,14 +155,14 @@ int main(int argc, char* argv[])
if (!matPath.empty()) if (!matPath.empty())
{ {
Nz::MaterialInstanceParams params; Nz::MaterialInstanceParams params;
params.lightingType = Nz::MaterialLightingType::Phong; params.materialType = Nz::MaterialType::Phong;
if (alphaMaterials.test(i)) if (alphaMaterials.test(i))
params.custom.SetParameter("EnableAlphaBlending", true); params.custom.SetParameter("EnableAlphaBlending", true);
materials[i] = Nz::MaterialInstance::LoadFromFile(matPath, params); materials[i] = Nz::MaterialInstance::LoadFromFile(matPath, params);
} }
else else
materials[i] = Nz::Graphics::Instance()->GetDefaultMaterials().basicDefault; materials[i] = Nz::MaterialInstance::GetDefault(Nz::MaterialType::Basic);
} }
for (std::size_t i = 0; i < bobMesh->GetSubMeshCount(); ++i) for (std::size_t i = 0; i < bobMesh->GetSubMeshCount(); ++i)
@ -246,7 +246,7 @@ int main(int argc, char* argv[])
Nz::TextureParams srgbTexParams; Nz::TextureParams srgbTexParams;
srgbTexParams.loadFormat = Nz::PixelFormat::RGBA8_SRGB; srgbTexParams.loadFormat = Nz::PixelFormat::RGBA8_SRGB;
std::shared_ptr<Nz::MaterialInstance> sphereMat = Nz::Graphics::Instance()->GetDefaultMaterials().phongMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> sphereMat = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Phong);
sphereMat->SetTextureProperty("BaseColorMap", fs.Load<Nz::Texture>("assets/Rusty/rustediron2_basecolor.png", srgbTexParams)); sphereMat->SetTextureProperty("BaseColorMap", fs.Load<Nz::Texture>("assets/Rusty/rustediron2_basecolor.png", srgbTexParams));
std::shared_ptr<Nz::Model> sphereModel = std::make_shared<Nz::Model>(std::move(gfxMesh)); std::shared_ptr<Nz::Model> sphereModel = std::make_shared<Nz::Model>(std::move(gfxMesh));
@ -288,7 +288,7 @@ int main(int argc, char* argv[])
} }
} }
std::shared_ptr<Nz::MaterialInstance> textMat = Nz::Graphics::Instance()->GetDefaultMaterials().phongMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> textMat = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Phong);
textMat->UpdatePassesStates([](Nz::RenderStates& renderStates) textMat->UpdatePassesStates([](Nz::RenderStates& renderStates)
{ {
renderStates.faceCulling = Nz::FaceCulling::None; renderStates.faceCulling = Nz::FaceCulling::None;
@ -338,7 +338,7 @@ int main(int argc, char* argv[])
planeSampler.wrapModeU = Nz::SamplerWrap::Repeat; planeSampler.wrapModeU = Nz::SamplerWrap::Repeat;
planeSampler.wrapModeV = Nz::SamplerWrap::Repeat; planeSampler.wrapModeV = Nz::SamplerWrap::Repeat;
std::shared_ptr<Nz::MaterialInstance> planeMat = Nz::Graphics::Instance()->GetDefaultMaterials().phongMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> planeMat = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Phong);
planeMat->SetTextureProperty("BaseColorMap", fs.Load<Nz::Texture>("assets/dev_grey.png"), planeSampler); planeMat->SetTextureProperty("BaseColorMap", fs.Load<Nz::Texture>("assets/dev_grey.png"), planeSampler);
std::shared_ptr<Nz::Model> planeModel = std::make_shared<Nz::Model>(std::move(planeMeshGfx)); std::shared_ptr<Nz::Model> planeModel = std::make_shared<Nz::Model>(std::move(planeMeshGfx));
@ -369,7 +369,7 @@ int main(int argc, char* argv[])
std::shared_ptr<Nz::Model> colliderModel; std::shared_ptr<Nz::Model> colliderModel;
{ {
std::shared_ptr<Nz::MaterialInstance> colliderMat = Nz::Graphics::Instance()->GetDefaultMaterials().basicMaterial->Instantiate(); std::shared_ptr<Nz::MaterialInstance> colliderMat = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Basic);
colliderMat->SetValueProperty("BaseColor", Nz::Color::Green()); colliderMat->SetValueProperty("BaseColor", Nz::Color::Green());
colliderMat->UpdatePassesStates([](Nz::RenderStates& states) colliderMat->UpdatePassesStates([](Nz::RenderStates& states)
{ {

4
examples/WidgetDemo/main.cpp
View File

@ -52,12 +52,10 @@ int main(int argc, char* argv[])
labelWidget->UpdateText(Nz::SimpleTextDrawer::Draw("You clicked the button " + std::to_string(++clickCount) + " times", 72)); labelWidget->UpdateText(Nz::SimpleTextDrawer::Draw("You clicked the button " + std::to_string(++clickCount) + " times", 72));
}); });
std::shared_ptr<Nz::Material> material = Nz::Graphics::Instance()->GetDefaultMaterials().basicMaterial;
Nz::TextureSamplerInfo samplerInfo; Nz::TextureSamplerInfo samplerInfo;
samplerInfo.anisotropyLevel = 8; samplerInfo.anisotropyLevel = 8;
std::shared_ptr<Nz::MaterialInstance> materialInstance = material->Instantiate(); std::shared_ptr<Nz::MaterialInstance> materialInstance = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Basic);
materialInstance->SetTextureProperty("BaseColorMap", fs.Load<Nz::Texture>("assets/lynix.jpg")); materialInstance->SetTextureProperty("BaseColorMap", fs.Load<Nz::Texture>("assets/lynix.jpg"));
Nz::ImageWidget* imageWidget = canvas2D.Add<Nz::ImageWidget>(materialInstance); Nz::ImageWidget* imageWidget = canvas2D.Add<Nz::ImageWidget>(materialInstance);

17
include/Nazara/Graphics/Enums.hpp
View File

@ -62,11 +62,22 @@ namespace Nz
UInt4 UInt4
}; };
enum class MaterialLightingType enum class MaterialInstancePreset
{ {
None, Default,
NoDepth,
Transparent,
Max = Transparent
};
enum class MaterialType
{
Basic,
Phong, Phong,
PhysicallyBased PhysicallyBased,
Max = PhysicallyBased
}; };
enum class MaterialPassFlag enum class MaterialPassFlag

12
include/Nazara/Graphics/Graphics.hpp
View File

@ -70,13 +70,13 @@ namespace Nz
struct DefaultMaterials struct DefaultMaterials
{ {
std::shared_ptr<Material> basicMaterial; struct MaterialData
std::shared_ptr<Material> phongMaterial; {
std::shared_ptr<Material> pbrMaterial; std::shared_ptr<Material> material;
EnumArray<MaterialInstancePreset, std::shared_ptr<MaterialInstance>> presets;
};
std::shared_ptr<MaterialInstance> basicDefault; EnumArray<MaterialType, MaterialData> materials;
std::shared_ptr<MaterialInstance> basicNoDepth;
std::shared_ptr<MaterialInstance> basicTransparent;
}; };
struct DefaultTextures struct DefaultTextures

1
include/Nazara/Graphics/Material.hpp
View File

@ -65,6 +65,7 @@ namespace Nz
std::shared_ptr<MaterialInstance> Instantiate() const; std::shared_ptr<MaterialInstance> Instantiate() const;
static std::shared_ptr<Material> Build(const ParameterList& materialData); static std::shared_ptr<Material> Build(const ParameterList& materialData);
static std::shared_ptr<Material> Get(MaterialType lightingType);
static std::shared_ptr<Material> LoadFromFile(const std::filesystem::path& filePath, const MaterialParams& params = MaterialParams()); static std::shared_ptr<Material> LoadFromFile(const std::filesystem::path& filePath, const MaterialParams& params = MaterialParams());
static std::shared_ptr<Material> LoadFromMemory(const void* data, std::size_t size, const MaterialParams& params = MaterialParams()); static std::shared_ptr<Material> LoadFromMemory(const void* data, std::size_t size, const MaterialParams& params = MaterialParams());
static std::shared_ptr<Material> LoadFromStream(Stream& stream, const MaterialParams& params = MaterialParams()); static std::shared_ptr<Material> LoadFromStream(Stream& stream, const MaterialParams& params = MaterialParams());

4
include/Nazara/Graphics/MaterialInstance.hpp
View File

@ -24,7 +24,7 @@ namespace Nz
{ {
struct NAZARA_GRAPHICS_API MaterialInstanceParams : ResourceParameters struct NAZARA_GRAPHICS_API MaterialInstanceParams : ResourceParameters
{ {
MaterialLightingType lightingType = MaterialLightingType::None; MaterialType materialType = MaterialType::Basic;
bool IsValid() const; bool IsValid() const;
}; };
@ -115,9 +115,11 @@ namespace Nz
static constexpr std::size_t InvalidPropertyIndex = MaterialSettings::InvalidPropertyIndex; static constexpr std::size_t InvalidPropertyIndex = MaterialSettings::InvalidPropertyIndex;
static std::shared_ptr<MaterialInstance> GetDefault(MaterialType materialType, MaterialInstancePreset preset = MaterialInstancePreset::Default);
static std::shared_ptr<MaterialInstance> LoadFromFile(const std::filesystem::path& filePath, const MaterialInstanceParams& params = MaterialInstanceParams()); static std::shared_ptr<MaterialInstance> LoadFromFile(const std::filesystem::path& filePath, const MaterialInstanceParams& params = MaterialInstanceParams());
static std::shared_ptr<MaterialInstance> LoadFromMemory(const void* data, std::size_t size, const MaterialInstanceParams& params = MaterialInstanceParams()); static std::shared_ptr<MaterialInstance> LoadFromMemory(const void* data, std::size_t size, const MaterialInstanceParams& params = MaterialInstanceParams());
static std::shared_ptr<MaterialInstance> LoadFromStream(Stream& stream, const MaterialInstanceParams& params = MaterialInstanceParams()); static std::shared_ptr<MaterialInstance> LoadFromStream(Stream& stream, const MaterialInstanceParams& params = MaterialInstanceParams());
static std::shared_ptr<MaterialInstance> Instantiate(MaterialType materialType, MaterialInstancePreset preset = MaterialInstancePreset::Default);
NazaraSignal(OnMaterialInstancePipelineInvalidated, const MaterialInstance* /*matInstance*/, std::size_t /*passIndex*/); NazaraSignal(OnMaterialInstancePipelineInvalidated, const MaterialInstance* /*matInstance*/, std::size_t /*passIndex*/);
NazaraSignal(OnMaterialInstanceShaderBindingInvalidated, const MaterialInstance* /*matInstance*/); NazaraSignal(OnMaterialInstanceShaderBindingInvalidated, const MaterialInstance* /*matInstance*/);

18
src/Nazara/Graphics/Formats/TextureLoader.cpp
View File

@ -47,23 +47,7 @@ namespace Nz
// Delete image to free memory // Delete image to free memory
image.reset(); image.reset();
std::shared_ptr<MaterialInstance> materialInstance; std::shared_ptr<MaterialInstance> materialInstance = MaterialInstance::Instantiate(parameters.materialType);
switch (parameters.lightingType)
{
case MaterialLightingType::Phong:
materialInstance = Graphics::Instance()->GetDefaultMaterials().phongMaterial->Instantiate();
break;
case MaterialLightingType::PhysicallyBased:
materialInstance = Graphics::Instance()->GetDefaultMaterials().pbrMaterial->Instantiate();
break;
case MaterialLightingType::None:
break;
}
if (!materialInstance)
materialInstance = Graphics::Instance()->GetDefaultMaterials().basicMaterial->Instantiate();
if (enableAlphaTest && hasAlpha) if (enableAlphaTest && hasAlpha)
materialInstance->SetValueProperty("AlphaTest", true); materialInstance->SetValueProperty("AlphaTest", true);

57
src/Nazara/Graphics/Graphics.cpp
View File

@ -251,7 +251,7 @@ namespace Nz
shadowPass.states.faceCulling = FaceCulling::Front; shadowPass.states.faceCulling = FaceCulling::Front;
settings.AddPass(shadowPassIndex, shadowPass); settings.AddPass(shadowPassIndex, shadowPass);
m_defaultMaterials.basicMaterial = std::make_shared<Material>(std::move(settings), "BasicMaterial"); m_defaultMaterials.materials[MaterialType::Basic].material = std::make_shared<Material>(std::move(settings), "BasicMaterial");
} }
// PbrMaterial // PbrMaterial
@ -273,7 +273,7 @@ namespace Nz
shadowPass.states.faceCulling = FaceCulling::Front; shadowPass.states.faceCulling = FaceCulling::Front;
settings.AddPass(shadowPassIndex, shadowPass); settings.AddPass(shadowPassIndex, shadowPass);
m_defaultMaterials.pbrMaterial = std::make_shared<Material>(std::move(settings), "PhysicallyBasedMaterial"); m_defaultMaterials.materials[MaterialType::PhysicallyBased].material = std::make_shared<Material>(std::move(settings), "PhysicallyBasedMaterial");
} }
// PhongMaterial // PhongMaterial
@ -298,35 +298,38 @@ namespace Nz
shadowPass.states.depthBiasSlopeFactor = 0.05f; shadowPass.states.depthBiasSlopeFactor = 0.05f;
settings.AddPass(shadowPassIndex, shadowPass); settings.AddPass(shadowPassIndex, shadowPass);
m_defaultMaterials.phongMaterial = std::make_shared<Material>(std::move(settings), "PhongMaterial"); m_defaultMaterials.materials[MaterialType::Phong].material = std::make_shared<Material>(std::move(settings), "PhongMaterial");
} }
m_defaultMaterials.basicDefault = m_defaultMaterials.basicMaterial->GetDefaultInstance(); for (auto&& [materialType, materialData] : m_defaultMaterials.materials.iter_kv())
m_defaultMaterials.basicNoDepth = m_defaultMaterials.basicMaterial->Instantiate();
m_defaultMaterials.basicNoDepth->DisablePass(depthPassIndex);
m_defaultMaterials.basicNoDepth->DisablePass(shadowPassIndex);
m_defaultMaterials.basicNoDepth->UpdatePassStates(forwardPassIndex, [](RenderStates& states)
{ {
states.depthBuffer = false; materialData.presets[MaterialInstancePreset::Default] = materialData.material->GetDefaultInstance();
});
m_defaultMaterials.basicTransparent = m_defaultMaterials.basicMaterial->Instantiate(); materialData.presets[MaterialInstancePreset::NoDepth] = materialData.material->Instantiate();
m_defaultMaterials.basicTransparent->DisablePass(depthPassIndex); materialData.presets[MaterialInstancePreset::NoDepth]->DisablePass(depthPassIndex);
m_defaultMaterials.basicTransparent->DisablePass(shadowPassIndex); materialData.presets[MaterialInstancePreset::NoDepth]->DisablePass(shadowPassIndex);
m_defaultMaterials.basicTransparent->UpdatePassFlags(forwardPassIndex, MaterialPassFlag::SortByDistance); materialData.presets[MaterialInstancePreset::NoDepth]->UpdatePassStates(forwardPassIndex, [](RenderStates& states)
m_defaultMaterials.basicTransparent->UpdatePassStates(forwardPassIndex, [](RenderStates& renderStates) {
{ states.depthBuffer = false;
renderStates.depthBuffer = true; });
renderStates.depthWrite = false;
renderStates.blending = true; materialData.presets[MaterialInstancePreset::Transparent] = materialData.material->Instantiate();
renderStates.blend.modeColor = BlendEquation::Add; materialData.presets[MaterialInstancePreset::Transparent]->DisablePass(depthPassIndex);
renderStates.blend.modeAlpha = BlendEquation::Add; materialData.presets[MaterialInstancePreset::Transparent]->DisablePass(shadowPassIndex);
renderStates.blend.srcColor = BlendFunc::SrcAlpha; materialData.presets[MaterialInstancePreset::Transparent]->UpdatePassFlags(forwardPassIndex, MaterialPassFlag::SortByDistance);
renderStates.blend.dstColor = BlendFunc::InvSrcAlpha; materialData.presets[MaterialInstancePreset::Transparent]->UpdatePassStates(forwardPassIndex, [](RenderStates& renderStates)
renderStates.blend.srcAlpha = BlendFunc::One; {
renderStates.blend.dstAlpha = BlendFunc::One; renderStates.depthBuffer = true;
}); renderStates.depthWrite = false;
renderStates.blending = true;
renderStates.blend.modeColor = BlendEquation::Add;
renderStates.blend.modeAlpha = BlendEquation::Add;
renderStates.blend.srcColor = BlendFunc::SrcAlpha;
renderStates.blend.dstColor = BlendFunc::InvSrcAlpha;
renderStates.blend.srcAlpha = BlendFunc::One;
renderStates.blend.dstAlpha = BlendFunc::One;
});
}
} }
void Graphics::BuildDefaultTextures() void Graphics::BuildDefaultTextures()

8
src/Nazara/Graphics/Material.cpp
View File

@ -192,6 +192,14 @@ namespace Nz
return std::shared_ptr<Material>(); return std::shared_ptr<Material>();
} }
std::shared_ptr<Material> Material::Get(MaterialType lightingType)
{
Graphics* graphics = Graphics::Instance();
NazaraAssert(graphics, "Utility module has not been initialized");
return graphics->GetDefaultMaterials().materials[lightingType].material;
}
std::shared_ptr<Material> Material::LoadFromFile(const std::filesystem::path& filePath, const MaterialParams& params) std::shared_ptr<Material> Material::LoadFromFile(const std::filesystem::path& filePath, const MaterialParams& params)
{ {
Graphics* graphics = Graphics::Instance(); Graphics* graphics = Graphics::Instance();

13
src/Nazara/Graphics/MaterialInstance.cpp
View File

@ -345,6 +345,14 @@ namespace Nz
OnTransferRequired(this); OnTransferRequired(this);
} }
std::shared_ptr<MaterialInstance> MaterialInstance::GetDefault(MaterialType materialType, MaterialInstancePreset preset)
{
Graphics* graphics = Graphics::Instance();
NazaraAssert(graphics, "Utility module has not been initialized");
return graphics->GetDefaultMaterials().materials[materialType].presets[preset];
}
std::shared_ptr<MaterialInstance> MaterialInstance::LoadFromFile(const std::filesystem::path& filePath, const MaterialInstanceParams& params) std::shared_ptr<MaterialInstance> MaterialInstance::LoadFromFile(const std::filesystem::path& filePath, const MaterialInstanceParams& params)
{ {
Graphics* graphics = Graphics::Instance(); Graphics* graphics = Graphics::Instance();
@ -368,4 +376,9 @@ namespace Nz
return graphics->GetMaterialInstanceLoader().LoadFromStream(stream, params); return graphics->GetMaterialInstanceLoader().LoadFromStream(stream, params);
} }
std::shared_ptr<MaterialInstance> MaterialInstance::Instantiate(MaterialType materialType, MaterialInstancePreset preset)
{
return GetDefault(materialType, preset)->Clone();
}
} }

5
src/Nazara/Graphics/Model.cpp
View File

@ -5,7 +5,6 @@
#include <Nazara/Graphics/Model.hpp> #include <Nazara/Graphics/Model.hpp>
#include <Nazara/Graphics/ElementRendererRegistry.hpp> #include <Nazara/Graphics/ElementRendererRegistry.hpp>
#include <Nazara/Graphics/GraphicalMesh.hpp> #include <Nazara/Graphics/GraphicalMesh.hpp>
#include <Nazara/Graphics/Graphics.hpp>
#include <Nazara/Graphics/MaterialInstance.hpp> #include <Nazara/Graphics/MaterialInstance.hpp>
#include <Nazara/Graphics/RenderSubmesh.hpp> #include <Nazara/Graphics/RenderSubmesh.hpp>
#include <Nazara/Graphics/WorldInstance.hpp> #include <Nazara/Graphics/WorldInstance.hpp>
@ -17,13 +16,11 @@ namespace Nz
Model::Model(std::shared_ptr<GraphicalMesh> graphicalMesh) : Model::Model(std::shared_ptr<GraphicalMesh> graphicalMesh) :
m_graphicalMesh(std::move(graphicalMesh)) m_graphicalMesh(std::move(graphicalMesh))
{ {
Graphics* graphics = Graphics::Instance();
m_submeshes.reserve(m_graphicalMesh->GetSubMeshCount()); m_submeshes.reserve(m_graphicalMesh->GetSubMeshCount());
for (std::size_t i = 0; i < m_graphicalMesh->GetSubMeshCount(); ++i) for (std::size_t i = 0; i < m_graphicalMesh->GetSubMeshCount(); ++i)
{ {
auto& subMeshData = m_submeshes.emplace_back(); auto& subMeshData = m_submeshes.emplace_back();
subMeshData.material = graphics->GetDefaultMaterials().basicDefault; subMeshData.material = MaterialInstance::GetDefault(MaterialType::Basic);
subMeshData.vertexBufferData = { subMeshData.vertexBufferData = {
{ {
0, 0,

3
src/Nazara/Graphics/TextSprite.cpp
View File

@ -4,7 +4,6 @@
#include <Nazara/Graphics/TextSprite.hpp> #include <Nazara/Graphics/TextSprite.hpp>
#include <Nazara/Graphics/ElementRendererRegistry.hpp> #include <Nazara/Graphics/ElementRendererRegistry.hpp>
#include <Nazara/Graphics/Graphics.hpp>
#include <Nazara/Graphics/MaterialInstance.hpp> #include <Nazara/Graphics/MaterialInstance.hpp>
#include <Nazara/Graphics/RenderSpriteChain.hpp> #include <Nazara/Graphics/RenderSpriteChain.hpp>
#include <Nazara/Graphics/WorldInstance.hpp> #include <Nazara/Graphics/WorldInstance.hpp>
@ -19,7 +18,7 @@ namespace Nz
m_material(std::move(material)) m_material(std::move(material))
{ {
if (!m_material) if (!m_material)
m_material = Graphics::Instance()->GetDefaultMaterials().basicTransparent; m_material = MaterialInstance::GetDefault(MaterialType::Basic, MaterialInstancePreset::Transparent);
} }
void TextSprite::BuildElement(ElementRendererRegistry& registry, const ElementData& elementData, std::size_t passIndex, std::vector<RenderElementOwner>& elements) const void TextSprite::BuildElement(ElementRendererRegistry& registry, const ElementData& elementData, std::size_t passIndex, std::vector<RenderElementOwner>& elements) const

3
src/Nazara/Graphics/Tilemap.cpp
View File

@ -4,7 +4,6 @@
#include <Nazara/Graphics/Tilemap.hpp> #include <Nazara/Graphics/Tilemap.hpp>
#include <Nazara/Graphics/ElementRendererRegistry.hpp> #include <Nazara/Graphics/ElementRendererRegistry.hpp>
#include <Nazara/Graphics/Graphics.hpp>
#include <Nazara/Graphics/RenderSpriteChain.hpp> #include <Nazara/Graphics/RenderSpriteChain.hpp>
#include <Nazara/Graphics/Debug.hpp> #include <Nazara/Graphics/Debug.hpp>
@ -35,7 +34,7 @@ namespace Nz
NazaraAssert(m_tileSize.x > 0 && m_tileSize.y > 0, "Invalid tile size"); NazaraAssert(m_tileSize.x > 0 && m_tileSize.y > 0, "Invalid tile size");
NazaraAssert(m_layers.size() != 0U, "Invalid material count"); NazaraAssert(m_layers.size() != 0U, "Invalid material count");
std::shared_ptr<MaterialInstance> defaultMaterialInstance = Graphics::Instance()->GetDefaultMaterials().basicDefault; std::shared_ptr<MaterialInstance> defaultMaterialInstance = MaterialInstance::GetDefault(MaterialType::Basic);
for (auto& layer : m_layers) for (auto& layer : m_layers)
layer.material = defaultMaterialInstance; layer.material = defaultMaterialInstance;

2
src/Nazara/Widgets/DefaultWidgetTheme.cpp
View File

@ -132,7 +132,7 @@ namespace Nz
auto CreateMaterialFromTexture = [&](std::shared_ptr<Texture> texture) auto CreateMaterialFromTexture = [&](std::shared_ptr<Texture> texture)
{ {
std::shared_ptr<MaterialInstance> material = defaultBasicMaterial.basicMaterial->Instantiate(); std::shared_ptr<MaterialInstance> material = MaterialInstance::Instantiate(MaterialType::Basic);
material->DisablePass(depthPassIndex); material->DisablePass(depthPassIndex);
material->UpdatePassStates(forwardPassIndex, [](RenderStates& renderStates) material->UpdatePassStates(forwardPassIndex, [](RenderStates& renderStates)
{ {

37
src/Nazara/Widgets/Widgets.cpp
View File

@ -22,35 +22,18 @@ namespace Nz
void Widgets::CreateDefaultMaterials() void Widgets::CreateDefaultMaterials()
{ {
const auto& defaultMaterials = Graphics::Instance()->GetDefaultMaterials(); m_opaqueMaterial = MaterialInstance::Instantiate(MaterialType::Basic);
m_opaqueMaterial->UpdatePassesStates([](RenderStates& renderStates)
const MaterialPassRegistry& materialPassRegistry = Graphics::Instance()->GetMaterialPassRegistry();
std::size_t depthPassIndex = materialPassRegistry.GetPassIndex("DepthPass");
std::size_t forwardPassIndex = materialPassRegistry.GetPassIndex("ForwardPass");
m_opaqueMaterial = defaultMaterials.basicMaterial->Instantiate();
for (std::size_t passIndex : { depthPassIndex, forwardPassIndex })
{ {
m_opaqueMaterial->UpdatePassStates(passIndex, [](RenderStates& renderStates)
{
renderStates.scissorTest = true;
});
}
m_transparentMaterial = defaultMaterials.basicMaterial->Instantiate();
m_transparentMaterial->DisablePass(depthPassIndex);
m_transparentMaterial->UpdatePassStates(forwardPassIndex, [](RenderStates& renderStates)
{
renderStates.blending = true;
renderStates.blend.modeColor = BlendEquation::Add;
renderStates.blend.modeAlpha = BlendEquation::Add;
renderStates.blend.srcColor = BlendFunc::SrcAlpha;
renderStates.blend.dstColor = BlendFunc::InvSrcAlpha;
renderStates.blend.srcAlpha = BlendFunc::One;
renderStates.blend.dstAlpha = BlendFunc::One;
renderStates.depthWrite = false;
renderStates.scissorTest = true; renderStates.scissorTest = true;
return true;
});
m_transparentMaterial = MaterialInstance::Instantiate(MaterialType::Basic, MaterialInstancePreset::Transparent);
m_transparentMaterial->UpdatePassesStates([](RenderStates& renderStates)
{
renderStates.scissorTest = true;
return true;
}); });
} }

6
tests/GraphicsTest/main.cpp
View File

@ -63,13 +63,11 @@ int main()
std::shared_ptr<Nz::Texture> diffuseTexture = Nz::Texture::LoadFromFile(resourceDir / "Spaceship/Texture/diffuse.png", texParams); std::shared_ptr<Nz::Texture> diffuseTexture = Nz::Texture::LoadFromFile(resourceDir / "Spaceship/Texture/diffuse.png", texParams);
std::shared_ptr<Nz::Material> material = Nz::Graphics::Instance()->GetDefaultMaterials().basicMaterial; std::shared_ptr<Nz::MaterialInstance> materialInstance = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Basic);
std::shared_ptr<Nz::MaterialInstance> materialInstance = std::make_shared<Nz::MaterialInstance>(material);
materialInstance->SetTextureProperty(0, diffuseTexture); materialInstance->SetTextureProperty(0, diffuseTexture);
materialInstance->SetValueProperty(0, Nz::Color::White()); materialInstance->SetValueProperty(0, Nz::Color::White());
std::shared_ptr<Nz::MaterialInstance> materialInstance2 = std::make_shared<Nz::MaterialInstance>(material); std::shared_ptr<Nz::MaterialInstance> materialInstance2 = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Basic);
materialInstance2->SetValueProperty(0, Nz::Color::Green()); materialInstance2->SetValueProperty(0, Nz::Color::Green());
Nz::Model model(std::move(gfxMesh)); Nz::Model model(std::move(gfxMesh));