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::Material> material = Nz::Graphics::Instance()->GetDefaultMaterials().pbrMaterial;
std::shared_ptr<Nz::MaterialInstance> materialInstance = std::make_shared<Nz::MaterialInstance>(material);
std::shared_ptr<Nz::MaterialInstance> materialInstance = Nz::MaterialInstance::Instantiate(Nz::MaterialType::PhysicallyBased);
materialInstance->SetTextureProperty("AlphaMap", Nz::Texture::LoadFromFile(resourceDir / "alphatile.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));

4
examples/Physics2DDemo/main.cpp
View File

@ -56,7 +56,7 @@ int main(int argc, char* argv[])
texParams.renderDevice = device;
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));
Nz::ChipmunkRigidBody2DComponent::DynamicSettings boxSettings;
@ -89,7 +89,7 @@ int main(int argc, char* argv[])
tilemap->SetOrigin({ 0.5f, 0.5f });
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));
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.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" })
{
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)
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->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());
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->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();
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->UpdatePassesStates([](Nz::RenderStates& states)
{
@ -77,7 +77,7 @@ int main(int argc, char* argv[])
planeSampler.wrapModeU = 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->DisablePass("ShadowPass");
boxMat->UpdatePassesStates([&](Nz::RenderStates& states)
@ -168,7 +168,7 @@ int main(int argc, char* argv[])
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));
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();
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));
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;
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;
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::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->UpdatePassesStates([](Nz::RenderStates& states)
{
@ -155,14 +155,14 @@ int main(int argc, char* argv[])
if (!matPath.empty())
{
Nz::MaterialInstanceParams params;
params.lightingType = Nz::MaterialLightingType::Phong;
params.materialType = Nz::MaterialType::Phong;
if (alphaMaterials.test(i))
params.custom.SetParameter("EnableAlphaBlending", true);
materials[i] = Nz::MaterialInstance::LoadFromFile(matPath, params);
}
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)
@ -246,7 +246,7 @@ int main(int argc, char* argv[])
Nz::TextureParams srgbTexParams;
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));
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)
{
renderStates.faceCulling = Nz::FaceCulling::None;
@ -338,7 +338,7 @@ int main(int argc, char* argv[])
planeSampler.wrapModeU = 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);
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::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->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));
});
std::shared_ptr<Nz::Material> material = Nz::Graphics::Instance()->GetDefaultMaterials().basicMaterial;
Nz::TextureSamplerInfo samplerInfo;
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"));
Nz::ImageWidget* imageWidget = canvas2D.Add<Nz::ImageWidget>(materialInstance);

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

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

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

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

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

@ -65,6 +65,7 @@ namespace Nz
std::shared_ptr<MaterialInstance> Instantiate() const;
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> LoadFromMemory(const void* data, std::size_t size, 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
{
MaterialLightingType lightingType = MaterialLightingType::None;
MaterialType materialType = MaterialType::Basic;
bool IsValid() const;
};
@ -115,9 +115,11 @@ namespace Nz
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> 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> Instantiate(MaterialType materialType, MaterialInstancePreset preset = MaterialInstancePreset::Default);
NazaraSignal(OnMaterialInstancePipelineInvalidated, const MaterialInstance* /*matInstance*/, std::size_t /*passIndex*/);
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
image.reset();
std::shared_ptr<MaterialInstance> materialInstance;
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();
std::shared_ptr<MaterialInstance> materialInstance = MaterialInstance::Instantiate(parameters.materialType);
if (enableAlphaTest && hasAlpha)
materialInstance->SetValueProperty("AlphaTest", true);

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

@ -251,7 +251,7 @@ namespace Nz
shadowPass.states.faceCulling = FaceCulling::Front;
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
@ -273,7 +273,7 @@ namespace Nz
shadowPass.states.faceCulling = FaceCulling::Front;
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
@ -298,35 +298,38 @@ namespace Nz
shadowPass.states.depthBiasSlopeFactor = 0.05f;
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();
m_defaultMaterials.basicNoDepth = m_defaultMaterials.basicMaterial->Instantiate();
m_defaultMaterials.basicNoDepth->DisablePass(depthPassIndex);
m_defaultMaterials.basicNoDepth->DisablePass(shadowPassIndex);
m_defaultMaterials.basicNoDepth->UpdatePassStates(forwardPassIndex, [](RenderStates& states)
for (auto&& [materialType, materialData] : m_defaultMaterials.materials.iter_kv())
{
states.depthBuffer = false;
});
materialData.presets[MaterialInstancePreset::Default] = materialData.material->GetDefaultInstance();
m_defaultMaterials.basicTransparent = m_defaultMaterials.basicMaterial->Instantiate();
m_defaultMaterials.basicTransparent->DisablePass(depthPassIndex);
m_defaultMaterials.basicTransparent->DisablePass(shadowPassIndex);
m_defaultMaterials.basicTransparent->UpdatePassFlags(forwardPassIndex, MaterialPassFlag::SortByDistance);
m_defaultMaterials.basicTransparent->UpdatePassStates(forwardPassIndex, [](RenderStates& renderStates)
{
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;
});
materialData.presets[MaterialInstancePreset::NoDepth] = materialData.material->Instantiate();
materialData.presets[MaterialInstancePreset::NoDepth]->DisablePass(depthPassIndex);
materialData.presets[MaterialInstancePreset::NoDepth]->DisablePass(shadowPassIndex);
materialData.presets[MaterialInstancePreset::NoDepth]->UpdatePassStates(forwardPassIndex, [](RenderStates& states)
{
states.depthBuffer = false;
});
materialData.presets[MaterialInstancePreset::Transparent] = materialData.material->Instantiate();
materialData.presets[MaterialInstancePreset::Transparent]->DisablePass(depthPassIndex);
materialData.presets[MaterialInstancePreset::Transparent]->DisablePass(shadowPassIndex);
materialData.presets[MaterialInstancePreset::Transparent]->UpdatePassFlags(forwardPassIndex, MaterialPassFlag::SortByDistance);
materialData.presets[MaterialInstancePreset::Transparent]->UpdatePassStates(forwardPassIndex, [](RenderStates& renderStates)
{
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()

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

@ -192,6 +192,14 @@ namespace Nz
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)
{
Graphics* graphics = Graphics::Instance();

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

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

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

@ -4,7 +4,6 @@
#include <Nazara/Graphics/TextSprite.hpp>
#include <Nazara/Graphics/ElementRendererRegistry.hpp>
#include <Nazara/Graphics/Graphics.hpp>
#include <Nazara/Graphics/MaterialInstance.hpp>
#include <Nazara/Graphics/RenderSpriteChain.hpp>
#include <Nazara/Graphics/WorldInstance.hpp>
@ -19,7 +18,7 @@ namespace Nz
m_material(std::move(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

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

@ -4,7 +4,6 @@
#include <Nazara/Graphics/Tilemap.hpp>
#include <Nazara/Graphics/ElementRendererRegistry.hpp>
#include <Nazara/Graphics/Graphics.hpp>
#include <Nazara/Graphics/RenderSpriteChain.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_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)
layer.material = defaultMaterialInstance;

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

@ -132,7 +132,7 @@ namespace Nz
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->UpdatePassStates(forwardPassIndex, [](RenderStates& renderStates)
{

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

@ -22,35 +22,18 @@ namespace Nz
void Widgets::CreateDefaultMaterials()
{
const auto& defaultMaterials = Graphics::Instance()->GetDefaultMaterials();
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 = MaterialInstance::Instantiate(MaterialType::Basic);
m_opaqueMaterial->UpdatePassesStates([](RenderStates& renderStates)
{
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;
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::Material> material = Nz::Graphics::Instance()->GetDefaultMaterials().basicMaterial;
std::shared_ptr<Nz::MaterialInstance> materialInstance = std::make_shared<Nz::MaterialInstance>(material);
std::shared_ptr<Nz::MaterialInstance> materialInstance = Nz::MaterialInstance::Instantiate(Nz::MaterialType::Basic);
materialInstance->SetTextureProperty(0, diffuseTexture);
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());
Nz::Model model(std::move(gfxMesh));