1132 lines
36 KiB
C++
1132 lines
36 KiB
C++
#include <XCEngine/Resources/Material/Material.h>
|
|
#include <XCEngine/Resources/Shader/Shader.h>
|
|
#include <XCEngine/Core/Asset/ResourceManager.h>
|
|
|
|
#include <algorithm>
|
|
#include <cctype>
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace XCEngine {
|
|
namespace Resources {
|
|
|
|
namespace {
|
|
|
|
constexpr size_t kMaterialConstantSlotSize = 16;
|
|
|
|
bool HasVirtualPathScheme(const Containers::String& path) {
|
|
return std::string(path.CStr()).find("://") != std::string::npos;
|
|
}
|
|
|
|
bool IsPackedMaterialPropertyType(MaterialPropertyType type) {
|
|
switch (type) {
|
|
case MaterialPropertyType::Float:
|
|
case MaterialPropertyType::Float2:
|
|
case MaterialPropertyType::Float3:
|
|
case MaterialPropertyType::Float4:
|
|
case MaterialPropertyType::Int:
|
|
case MaterialPropertyType::Int2:
|
|
case MaterialPropertyType::Int3:
|
|
case MaterialPropertyType::Int4:
|
|
case MaterialPropertyType::Bool:
|
|
return true;
|
|
case MaterialPropertyType::Texture:
|
|
case MaterialPropertyType::Cubemap:
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
Core::uint32 GetPackedMaterialPropertySize(MaterialPropertyType type) {
|
|
switch (type) {
|
|
case MaterialPropertyType::Float:
|
|
case MaterialPropertyType::Int:
|
|
case MaterialPropertyType::Bool:
|
|
return sizeof(Core::uint32);
|
|
case MaterialPropertyType::Float2:
|
|
case MaterialPropertyType::Int2:
|
|
return sizeof(Core::uint32) * 2;
|
|
case MaterialPropertyType::Float3:
|
|
case MaterialPropertyType::Int3:
|
|
return sizeof(Core::uint32) * 3;
|
|
case MaterialPropertyType::Float4:
|
|
case MaterialPropertyType::Int4:
|
|
return sizeof(Core::uint32) * 4;
|
|
case MaterialPropertyType::Texture:
|
|
case MaterialPropertyType::Cubemap:
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void RemoveTextureBindingByName(
|
|
Containers::Array<MaterialTextureBinding>& textureBindings,
|
|
const Containers::String& name) {
|
|
for (size_t bindingIndex = 0; bindingIndex < textureBindings.Size(); ++bindingIndex) {
|
|
if (textureBindings[bindingIndex].name == name) {
|
|
if (bindingIndex != textureBindings.Size() - 1) {
|
|
textureBindings[bindingIndex] = std::move(textureBindings.Back());
|
|
textureBindings[bindingIndex].slot = static_cast<Core::uint32>(bindingIndex);
|
|
}
|
|
textureBindings.PopBack();
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (size_t bindingIndex = 0; bindingIndex < textureBindings.Size(); ++bindingIndex) {
|
|
textureBindings[bindingIndex].slot = static_cast<Core::uint32>(bindingIndex);
|
|
}
|
|
}
|
|
|
|
void EnsureTextureProperty(Containers::HashMap<Containers::String, MaterialProperty>& properties,
|
|
const Containers::String& name,
|
|
MaterialPropertyType type = MaterialPropertyType::Texture) {
|
|
MaterialProperty prop;
|
|
prop.name = name;
|
|
prop.type = type;
|
|
prop.refCount = 1;
|
|
properties.Insert(name, prop);
|
|
}
|
|
|
|
bool IsTextureMaterialPropertyType(MaterialPropertyType type) {
|
|
return type == MaterialPropertyType::Texture || type == MaterialPropertyType::Cubemap;
|
|
}
|
|
|
|
MaterialPropertyType GetMaterialPropertyTypeForShaderProperty(ShaderPropertyType type) {
|
|
switch (type) {
|
|
case ShaderPropertyType::Float:
|
|
case ShaderPropertyType::Range:
|
|
return MaterialPropertyType::Float;
|
|
case ShaderPropertyType::Int:
|
|
return MaterialPropertyType::Int;
|
|
case ShaderPropertyType::Vector:
|
|
case ShaderPropertyType::Color:
|
|
return MaterialPropertyType::Float4;
|
|
case ShaderPropertyType::TextureCube:
|
|
return MaterialPropertyType::Cubemap;
|
|
case ShaderPropertyType::Texture2D:
|
|
default:
|
|
return MaterialPropertyType::Texture;
|
|
}
|
|
}
|
|
|
|
bool IsMaterialPropertyCompatibleWithShaderProperty(
|
|
MaterialPropertyType materialType,
|
|
ShaderPropertyType shaderType) {
|
|
switch (shaderType) {
|
|
case ShaderPropertyType::Float:
|
|
case ShaderPropertyType::Range:
|
|
return materialType == MaterialPropertyType::Float;
|
|
case ShaderPropertyType::Int:
|
|
return materialType == MaterialPropertyType::Int;
|
|
case ShaderPropertyType::Vector:
|
|
case ShaderPropertyType::Color:
|
|
return materialType == MaterialPropertyType::Float4;
|
|
case ShaderPropertyType::Texture2D:
|
|
return materialType == MaterialPropertyType::Texture;
|
|
case ShaderPropertyType::TextureCube:
|
|
return materialType == MaterialPropertyType::Texture ||
|
|
materialType == MaterialPropertyType::Cubemap;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
std::string TrimCopy(const std::string& text) {
|
|
const auto begin = std::find_if_not(text.begin(), text.end(), [](unsigned char ch) {
|
|
return std::isspace(ch) != 0;
|
|
});
|
|
if (begin == text.end()) {
|
|
return std::string();
|
|
}
|
|
|
|
const auto end = std::find_if_not(text.rbegin(), text.rend(), [](unsigned char ch) {
|
|
return std::isspace(ch) != 0;
|
|
}).base();
|
|
return std::string(begin, end);
|
|
}
|
|
|
|
bool TryParseFloatList(const Containers::String& value,
|
|
float* outValues,
|
|
size_t maxValues,
|
|
size_t& outCount) {
|
|
outCount = 0;
|
|
std::string text = TrimCopy(std::string(value.CStr()));
|
|
if (text.empty()) {
|
|
return false;
|
|
}
|
|
|
|
if ((text.front() == '(' && text.back() == ')') ||
|
|
(text.front() == '[' && text.back() == ']') ||
|
|
(text.front() == '{' && text.back() == '}')) {
|
|
text = text.substr(1, text.size() - 2);
|
|
}
|
|
|
|
const char* cursor = text.c_str();
|
|
char* endPtr = nullptr;
|
|
while (*cursor != '\0' && outCount < maxValues) {
|
|
while (*cursor != '\0' &&
|
|
(std::isspace(static_cast<unsigned char>(*cursor)) != 0 || *cursor == ',')) {
|
|
++cursor;
|
|
}
|
|
if (*cursor == '\0') {
|
|
break;
|
|
}
|
|
|
|
const float parsed = std::strtof(cursor, &endPtr);
|
|
if (endPtr == cursor) {
|
|
return false;
|
|
}
|
|
|
|
outValues[outCount++] = parsed;
|
|
cursor = endPtr;
|
|
}
|
|
|
|
while (*cursor != '\0') {
|
|
if (std::isspace(static_cast<unsigned char>(*cursor)) == 0 && *cursor != ',') {
|
|
return false;
|
|
}
|
|
++cursor;
|
|
}
|
|
|
|
return outCount > 0;
|
|
}
|
|
|
|
bool TryParseFloatDefault(const Containers::String& value, float& outValue) {
|
|
float values[4] = {};
|
|
size_t count = 0;
|
|
if (!TryParseFloatList(value, values, 4, count)) {
|
|
return false;
|
|
}
|
|
|
|
outValue = values[0];
|
|
return true;
|
|
}
|
|
|
|
bool TryParseIntDefault(const Containers::String& value, Core::int32& outValue) {
|
|
const std::string text = TrimCopy(std::string(value.CStr()));
|
|
if (text.empty()) {
|
|
return false;
|
|
}
|
|
|
|
char* endPtr = nullptr;
|
|
const long parsed = std::strtol(text.c_str(), &endPtr, 10);
|
|
if (endPtr == text.c_str()) {
|
|
return false;
|
|
}
|
|
|
|
while (*endPtr != '\0') {
|
|
if (std::isspace(static_cast<unsigned char>(*endPtr)) == 0) {
|
|
return false;
|
|
}
|
|
++endPtr;
|
|
}
|
|
|
|
outValue = static_cast<Core::int32>(parsed);
|
|
return true;
|
|
}
|
|
|
|
bool TryBuildDefaultMaterialProperty(const ShaderPropertyDesc& shaderProperty,
|
|
MaterialProperty& outProperty) {
|
|
outProperty = MaterialProperty();
|
|
outProperty.name = shaderProperty.name;
|
|
outProperty.type = GetMaterialPropertyTypeForShaderProperty(shaderProperty.type);
|
|
outProperty.refCount = 1;
|
|
|
|
switch (shaderProperty.type) {
|
|
case ShaderPropertyType::Float:
|
|
case ShaderPropertyType::Range:
|
|
TryParseFloatDefault(shaderProperty.defaultValue, outProperty.value.floatValue[0]);
|
|
return true;
|
|
case ShaderPropertyType::Int:
|
|
TryParseIntDefault(shaderProperty.defaultValue, outProperty.value.intValue[0]);
|
|
return true;
|
|
case ShaderPropertyType::Vector:
|
|
case ShaderPropertyType::Color: {
|
|
float values[4] = {};
|
|
size_t count = 0;
|
|
if (TryParseFloatList(shaderProperty.defaultValue, values, 4, count)) {
|
|
for (size_t index = 0; index < count && index < 4; ++index) {
|
|
outProperty.value.floatValue[index] = values[index];
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
case ShaderPropertyType::Texture2D:
|
|
case ShaderPropertyType::TextureCube:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void WritePackedMaterialProperty(Core::uint8* destination, const MaterialProperty& property) {
|
|
std::memset(destination, 0, kMaterialConstantSlotSize);
|
|
|
|
switch (property.type) {
|
|
case MaterialPropertyType::Float:
|
|
std::memcpy(destination, property.value.floatValue, sizeof(float));
|
|
break;
|
|
case MaterialPropertyType::Float2:
|
|
std::memcpy(destination, property.value.floatValue, sizeof(float) * 2);
|
|
break;
|
|
case MaterialPropertyType::Float3:
|
|
std::memcpy(destination, property.value.floatValue, sizeof(float) * 3);
|
|
break;
|
|
case MaterialPropertyType::Float4:
|
|
std::memcpy(destination, property.value.floatValue, sizeof(float) * 4);
|
|
break;
|
|
case MaterialPropertyType::Int:
|
|
std::memcpy(destination, property.value.intValue, sizeof(Core::int32));
|
|
break;
|
|
case MaterialPropertyType::Int2:
|
|
std::memcpy(destination, property.value.intValue, sizeof(Core::int32) * 2);
|
|
break;
|
|
case MaterialPropertyType::Int3:
|
|
std::memcpy(destination, property.value.intValue, sizeof(Core::int32) * 3);
|
|
break;
|
|
case MaterialPropertyType::Int4:
|
|
std::memcpy(destination, property.value.intValue, sizeof(Core::int32) * 4);
|
|
break;
|
|
case MaterialPropertyType::Bool: {
|
|
const Core::uint32 boolValue = property.value.boolValue ? 1u : 0u;
|
|
std::memcpy(destination, &boolValue, sizeof(boolValue));
|
|
break;
|
|
}
|
|
case MaterialPropertyType::Texture:
|
|
case MaterialPropertyType::Cubemap:
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
Material::Material() = default;
|
|
|
|
Material::~Material() {
|
|
// Imported materials can own nested handles and container state; explicitly
|
|
// resetting them here avoids teardown-order issues during destruction.
|
|
m_shader.Reset();
|
|
m_tags = Containers::Array<MaterialTagEntry>();
|
|
m_keywordSet = ShaderKeywordSet();
|
|
m_properties = Containers::HashMap<Containers::String, MaterialProperty>();
|
|
m_constantLayout = Containers::Array<MaterialConstantFieldDesc>();
|
|
m_constantBufferData = Containers::Array<Core::uint8>();
|
|
m_textureBindings = Containers::Array<MaterialTextureBinding>();
|
|
}
|
|
|
|
void Material::Release() {
|
|
m_shader.Reset();
|
|
m_renderQueue = static_cast<Core::int32>(MaterialRenderQueue::Geometry);
|
|
m_renderState = MaterialRenderState();
|
|
m_hasRenderStateOverride = false;
|
|
m_tags.Clear();
|
|
m_keywordSet.enabledKeywords.Clear();
|
|
m_properties.Clear();
|
|
m_constantLayout.Clear();
|
|
m_textureBindings.Clear();
|
|
m_constantBufferData.Clear();
|
|
m_changeVersion = 1;
|
|
m_isValid = false;
|
|
UpdateMemorySize();
|
|
}
|
|
|
|
void Material::SetShader(const ResourceHandle<Shader>& shader) {
|
|
m_shader = shader;
|
|
SyncShaderSchemaProperties(true);
|
|
SyncShaderSchemaKeywords(true);
|
|
MarkChanged(true);
|
|
}
|
|
|
|
void Material::SetRenderQueue(Core::int32 renderQueue) {
|
|
m_renderQueue = renderQueue;
|
|
MarkChanged(false);
|
|
}
|
|
|
|
void Material::SetRenderQueue(MaterialRenderQueue renderQueue) {
|
|
SetRenderQueue(static_cast<Core::int32>(renderQueue));
|
|
}
|
|
|
|
void Material::SetRenderState(const MaterialRenderState& renderState) {
|
|
m_renderState = renderState;
|
|
m_hasRenderStateOverride = true;
|
|
MarkChanged(false);
|
|
}
|
|
|
|
void Material::SetRenderStateOverrideEnabled(bool enabled) {
|
|
m_hasRenderStateOverride = enabled;
|
|
MarkChanged(false);
|
|
}
|
|
|
|
void Material::SetTag(const Containers::String& name, const Containers::String& value) {
|
|
for (MaterialTagEntry& tag : m_tags) {
|
|
if (tag.name == name) {
|
|
tag.value = value;
|
|
MarkChanged(false);
|
|
return;
|
|
}
|
|
}
|
|
|
|
MaterialTagEntry tag;
|
|
tag.name = name;
|
|
tag.value = value;
|
|
m_tags.PushBack(tag);
|
|
MarkChanged(false);
|
|
}
|
|
|
|
Containers::String Material::GetTag(const Containers::String& name) const {
|
|
for (const MaterialTagEntry& tag : m_tags) {
|
|
if (tag.name == name) {
|
|
return tag.value;
|
|
}
|
|
}
|
|
|
|
return Containers::String();
|
|
}
|
|
|
|
bool Material::HasTag(const Containers::String& name) const {
|
|
for (const MaterialTagEntry& tag : m_tags) {
|
|
if (tag.name == name) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void Material::RemoveTag(const Containers::String& name) {
|
|
for (size_t tagIndex = 0; tagIndex < m_tags.Size(); ++tagIndex) {
|
|
if (m_tags[tagIndex].name == name) {
|
|
if (tagIndex != m_tags.Size() - 1) {
|
|
m_tags[tagIndex] = std::move(m_tags.Back());
|
|
}
|
|
m_tags.PopBack();
|
|
MarkChanged(false);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Material::ClearTags() {
|
|
m_tags.Clear();
|
|
MarkChanged(false);
|
|
}
|
|
|
|
Containers::String Material::GetTagName(Core::uint32 index) const {
|
|
return index < m_tags.Size() ? m_tags[index].name : Containers::String();
|
|
}
|
|
|
|
Containers::String Material::GetTagValue(Core::uint32 index) const {
|
|
return index < m_tags.Size() ? m_tags[index].value : Containers::String();
|
|
}
|
|
|
|
void Material::EnableKeyword(const Containers::String& keyword) {
|
|
const Containers::String normalizedKeyword = NormalizeShaderKeywordToken(keyword);
|
|
if (normalizedKeyword.Empty()) {
|
|
return;
|
|
}
|
|
|
|
if (m_shader.Get() != nullptr && !m_shader->DeclaresKeyword(normalizedKeyword)) {
|
|
return;
|
|
}
|
|
|
|
for (const Containers::String& existingKeyword : m_keywordSet.enabledKeywords) {
|
|
if (existingKeyword == normalizedKeyword) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
m_keywordSet.enabledKeywords.PushBack(normalizedKeyword);
|
|
std::sort(
|
|
m_keywordSet.enabledKeywords.begin(),
|
|
m_keywordSet.enabledKeywords.end(),
|
|
CompareShaderKeywordTokens);
|
|
MarkChanged(false);
|
|
}
|
|
|
|
void Material::DisableKeyword(const Containers::String& keyword) {
|
|
const Containers::String normalizedKeyword = NormalizeShaderKeywordToken(keyword);
|
|
if (normalizedKeyword.Empty()) {
|
|
return;
|
|
}
|
|
|
|
for (size_t keywordIndex = 0; keywordIndex < m_keywordSet.enabledKeywords.Size(); ++keywordIndex) {
|
|
if (m_keywordSet.enabledKeywords[keywordIndex] == normalizedKeyword) {
|
|
if (keywordIndex != m_keywordSet.enabledKeywords.Size() - 1) {
|
|
m_keywordSet.enabledKeywords[keywordIndex] = std::move(m_keywordSet.enabledKeywords.Back());
|
|
}
|
|
m_keywordSet.enabledKeywords.PopBack();
|
|
std::sort(
|
|
m_keywordSet.enabledKeywords.begin(),
|
|
m_keywordSet.enabledKeywords.end(),
|
|
CompareShaderKeywordTokens);
|
|
MarkChanged(false);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Material::SetKeywordEnabled(const Containers::String& keyword, bool enabled) {
|
|
if (enabled) {
|
|
EnableKeyword(keyword);
|
|
} else {
|
|
DisableKeyword(keyword);
|
|
}
|
|
}
|
|
|
|
bool Material::IsKeywordEnabled(const Containers::String& keyword) const {
|
|
const Containers::String normalizedKeyword = NormalizeShaderKeywordToken(keyword);
|
|
if (normalizedKeyword.Empty()) {
|
|
return false;
|
|
}
|
|
|
|
for (const Containers::String& existingKeyword : m_keywordSet.enabledKeywords) {
|
|
if (existingKeyword == normalizedKeyword) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void Material::ClearKeywords() {
|
|
if (m_keywordSet.enabledKeywords.Empty()) {
|
|
return;
|
|
}
|
|
|
|
m_keywordSet.enabledKeywords.Clear();
|
|
MarkChanged(false);
|
|
}
|
|
|
|
Containers::String Material::GetKeyword(Core::uint32 index) const {
|
|
return index < m_keywordSet.enabledKeywords.Size()
|
|
? m_keywordSet.enabledKeywords[index]
|
|
: Containers::String();
|
|
}
|
|
|
|
void Material::SetFloat(const Containers::String& name, float value) {
|
|
if (!CanAssignPropertyType(name, MaterialPropertyType::Float)) {
|
|
return;
|
|
}
|
|
|
|
RemoveTextureBindingByName(m_textureBindings, name);
|
|
MaterialProperty prop;
|
|
prop.name = name;
|
|
prop.type = MaterialPropertyType::Float;
|
|
prop.value.floatValue[0] = value;
|
|
prop.refCount = 1;
|
|
m_properties.Insert(name, prop);
|
|
MarkChanged(true);
|
|
}
|
|
|
|
void Material::SetFloat2(const Containers::String& name, const Math::Vector2& value) {
|
|
if (!CanAssignPropertyType(name, MaterialPropertyType::Float2)) {
|
|
return;
|
|
}
|
|
|
|
RemoveTextureBindingByName(m_textureBindings, name);
|
|
MaterialProperty prop;
|
|
prop.name = name;
|
|
prop.type = MaterialPropertyType::Float2;
|
|
prop.value.floatValue[0] = value.x;
|
|
prop.value.floatValue[1] = value.y;
|
|
prop.refCount = 1;
|
|
m_properties.Insert(name, prop);
|
|
MarkChanged(true);
|
|
}
|
|
|
|
void Material::SetFloat3(const Containers::String& name, const Math::Vector3& value) {
|
|
if (!CanAssignPropertyType(name, MaterialPropertyType::Float3)) {
|
|
return;
|
|
}
|
|
|
|
RemoveTextureBindingByName(m_textureBindings, name);
|
|
MaterialProperty prop;
|
|
prop.name = name;
|
|
prop.type = MaterialPropertyType::Float3;
|
|
prop.value.floatValue[0] = value.x;
|
|
prop.value.floatValue[1] = value.y;
|
|
prop.value.floatValue[2] = value.z;
|
|
prop.refCount = 1;
|
|
m_properties.Insert(name, prop);
|
|
MarkChanged(true);
|
|
}
|
|
|
|
void Material::SetFloat4(const Containers::String& name, const Math::Vector4& value) {
|
|
if (!CanAssignPropertyType(name, MaterialPropertyType::Float4)) {
|
|
return;
|
|
}
|
|
|
|
RemoveTextureBindingByName(m_textureBindings, name);
|
|
MaterialProperty prop;
|
|
prop.name = name;
|
|
prop.type = MaterialPropertyType::Float4;
|
|
prop.value.floatValue[0] = value.x;
|
|
prop.value.floatValue[1] = value.y;
|
|
prop.value.floatValue[2] = value.z;
|
|
prop.value.floatValue[3] = value.w;
|
|
prop.refCount = 1;
|
|
m_properties.Insert(name, prop);
|
|
MarkChanged(true);
|
|
}
|
|
|
|
void Material::SetInt(const Containers::String& name, Core::int32 value) {
|
|
if (!CanAssignPropertyType(name, MaterialPropertyType::Int)) {
|
|
return;
|
|
}
|
|
|
|
RemoveTextureBindingByName(m_textureBindings, name);
|
|
MaterialProperty prop;
|
|
prop.name = name;
|
|
prop.type = MaterialPropertyType::Int;
|
|
prop.value.intValue[0] = value;
|
|
prop.refCount = 1;
|
|
m_properties.Insert(name, prop);
|
|
MarkChanged(true);
|
|
}
|
|
|
|
void Material::SetBool(const Containers::String& name, bool value) {
|
|
if (!CanAssignPropertyType(name, MaterialPropertyType::Bool)) {
|
|
return;
|
|
}
|
|
|
|
RemoveTextureBindingByName(m_textureBindings, name);
|
|
MaterialProperty prop;
|
|
prop.name = name;
|
|
prop.type = MaterialPropertyType::Bool;
|
|
prop.value.boolValue = value;
|
|
prop.refCount = 1;
|
|
m_properties.Insert(name, prop);
|
|
MarkChanged(true);
|
|
}
|
|
|
|
void Material::SetTexture(const Containers::String& name, const ResourceHandle<Texture>& texture) {
|
|
const ShaderPropertyDesc* shaderProperty = FindShaderPropertyDesc(name);
|
|
const MaterialPropertyType propertyType =
|
|
shaderProperty != nullptr
|
|
? GetMaterialPropertyTypeForShaderProperty(shaderProperty->type)
|
|
: MaterialPropertyType::Texture;
|
|
if (!CanAssignPropertyType(name, propertyType)) {
|
|
return;
|
|
}
|
|
|
|
EnsureTextureProperty(m_properties, name, propertyType);
|
|
|
|
AssetRef textureRef;
|
|
Containers::String texturePath = texture.Get() != nullptr ? texture->GetPath() : Containers::String();
|
|
if (!texturePath.Empty() && !HasVirtualPathScheme(texturePath)) {
|
|
ResourceManager::Get().TryGetAssetRef(texturePath, ResourceType::Texture, textureRef);
|
|
}
|
|
|
|
for (auto& binding : m_textureBindings) {
|
|
if (binding.name == name) {
|
|
binding.texture = texture;
|
|
binding.textureRef = textureRef;
|
|
binding.texturePath = texturePath;
|
|
binding.pendingLoad.reset();
|
|
MarkChanged(false);
|
|
return;
|
|
}
|
|
}
|
|
|
|
MaterialTextureBinding binding;
|
|
binding.name = name;
|
|
binding.slot = static_cast<Core::uint32>(m_textureBindings.Size());
|
|
binding.texture = texture;
|
|
binding.textureRef = textureRef;
|
|
binding.texturePath = texturePath;
|
|
m_textureBindings.PushBack(binding);
|
|
MarkChanged(false);
|
|
}
|
|
|
|
void Material::SetTextureAssetRef(const Containers::String& name,
|
|
const AssetRef& textureRef,
|
|
const Containers::String& texturePath) {
|
|
if (!textureRef.IsValid() && texturePath.Empty()) {
|
|
RemoveProperty(name);
|
|
return;
|
|
}
|
|
|
|
const ShaderPropertyDesc* shaderProperty = FindShaderPropertyDesc(name);
|
|
const MaterialPropertyType propertyType =
|
|
shaderProperty != nullptr
|
|
? GetMaterialPropertyTypeForShaderProperty(shaderProperty->type)
|
|
: MaterialPropertyType::Texture;
|
|
if (!CanAssignPropertyType(name, propertyType)) {
|
|
return;
|
|
}
|
|
|
|
EnsureTextureProperty(m_properties, name, propertyType);
|
|
|
|
for (auto& binding : m_textureBindings) {
|
|
if (binding.name == name) {
|
|
binding.texture.Reset();
|
|
binding.textureRef = textureRef;
|
|
binding.texturePath = texturePath;
|
|
binding.pendingLoad.reset();
|
|
MarkChanged(false);
|
|
return;
|
|
}
|
|
}
|
|
|
|
MaterialTextureBinding binding;
|
|
binding.name = name;
|
|
binding.slot = static_cast<Core::uint32>(m_textureBindings.Size());
|
|
binding.textureRef = textureRef;
|
|
binding.texturePath = texturePath;
|
|
m_textureBindings.PushBack(binding);
|
|
MarkChanged(false);
|
|
}
|
|
|
|
void Material::SetTexturePath(const Containers::String& name, const Containers::String& texturePath) {
|
|
if (texturePath.Empty()) {
|
|
RemoveProperty(name);
|
|
return;
|
|
}
|
|
|
|
const ShaderPropertyDesc* shaderProperty = FindShaderPropertyDesc(name);
|
|
const MaterialPropertyType propertyType =
|
|
shaderProperty != nullptr
|
|
? GetMaterialPropertyTypeForShaderProperty(shaderProperty->type)
|
|
: MaterialPropertyType::Texture;
|
|
if (!CanAssignPropertyType(name, propertyType)) {
|
|
return;
|
|
}
|
|
|
|
EnsureTextureProperty(m_properties, name, propertyType);
|
|
|
|
for (auto& binding : m_textureBindings) {
|
|
if (binding.name == name) {
|
|
binding.texture.Reset();
|
|
binding.textureRef.Reset();
|
|
binding.texturePath = texturePath;
|
|
binding.pendingLoad.reset();
|
|
MarkChanged(false);
|
|
return;
|
|
}
|
|
}
|
|
|
|
MaterialTextureBinding binding;
|
|
binding.name = name;
|
|
binding.slot = static_cast<Core::uint32>(m_textureBindings.Size());
|
|
binding.textureRef.Reset();
|
|
binding.texturePath = texturePath;
|
|
m_textureBindings.PushBack(binding);
|
|
MarkChanged(false);
|
|
}
|
|
|
|
float Material::GetFloat(const Containers::String& name) const {
|
|
auto* prop = m_properties.Find(name);
|
|
if (prop && prop->type == MaterialPropertyType::Float) {
|
|
return prop->value.floatValue[0];
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
Math::Vector2 Material::GetFloat2(const Containers::String& name) const {
|
|
auto* prop = m_properties.Find(name);
|
|
if (prop && prop->type == MaterialPropertyType::Float2) {
|
|
return Math::Vector2(prop->value.floatValue[0], prop->value.floatValue[1]);
|
|
}
|
|
return Math::Vector2::Zero();
|
|
}
|
|
|
|
Math::Vector3 Material::GetFloat3(const Containers::String& name) const {
|
|
auto* prop = m_properties.Find(name);
|
|
if (prop && prop->type == MaterialPropertyType::Float3) {
|
|
return Math::Vector3(prop->value.floatValue[0], prop->value.floatValue[1], prop->value.floatValue[2]);
|
|
}
|
|
return Math::Vector3::Zero();
|
|
}
|
|
|
|
Math::Vector4 Material::GetFloat4(const Containers::String& name) const {
|
|
auto* prop = m_properties.Find(name);
|
|
if (prop && prop->type == MaterialPropertyType::Float4) {
|
|
return Math::Vector4(prop->value.floatValue[0], prop->value.floatValue[1],
|
|
prop->value.floatValue[2], prop->value.floatValue[3]);
|
|
}
|
|
return Math::Vector4::Zero();
|
|
}
|
|
|
|
Core::int32 Material::GetInt(const Containers::String& name) const {
|
|
auto* prop = m_properties.Find(name);
|
|
if (prop && prop->type == MaterialPropertyType::Int) {
|
|
return prop->value.intValue[0];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool Material::GetBool(const Containers::String& name) const {
|
|
auto* prop = m_properties.Find(name);
|
|
if (prop && prop->type == MaterialPropertyType::Bool) {
|
|
return prop->value.boolValue;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
ResourceHandle<Texture> Material::GetTexture(const Containers::String& name) const {
|
|
Material* material = const_cast<Material*>(this);
|
|
material->ResolvePendingTextureBindings();
|
|
for (Core::uint32 bindingIndex = 0; bindingIndex < material->m_textureBindings.Size(); ++bindingIndex) {
|
|
MaterialTextureBinding& binding = material->m_textureBindings[bindingIndex];
|
|
if (binding.name == name) {
|
|
if (binding.texture.Get() == nullptr &&
|
|
binding.pendingLoad == nullptr &&
|
|
(!binding.texturePath.Empty() || binding.textureRef.IsValid())) {
|
|
material->BeginAsyncTextureLoad(bindingIndex);
|
|
}
|
|
return binding.texture;
|
|
}
|
|
}
|
|
return ResourceHandle<Texture>();
|
|
}
|
|
|
|
Containers::String Material::GetTextureBindingName(Core::uint32 index) const {
|
|
return index < m_textureBindings.Size() ? m_textureBindings[index].name : Containers::String();
|
|
}
|
|
|
|
AssetRef Material::GetTextureBindingAssetRef(Core::uint32 index) const {
|
|
return index < m_textureBindings.Size() ? m_textureBindings[index].textureRef : AssetRef();
|
|
}
|
|
|
|
Containers::String Material::GetTextureBindingPath(Core::uint32 index) const {
|
|
return index < m_textureBindings.Size() ? m_textureBindings[index].texturePath : Containers::String();
|
|
}
|
|
|
|
ResourceHandle<Texture> Material::GetTextureBindingLoadedTexture(Core::uint32 index) const {
|
|
return index < m_textureBindings.Size() ? m_textureBindings[index].texture : ResourceHandle<Texture>();
|
|
}
|
|
|
|
ResourceHandle<Texture> Material::GetTextureBindingTexture(Core::uint32 index) const {
|
|
Material* material = const_cast<Material*>(this);
|
|
material->ResolvePendingTextureBinding(index);
|
|
if (index < material->m_textureBindings.Size()) {
|
|
MaterialTextureBinding& binding = material->m_textureBindings[index];
|
|
if (binding.texture.Get() == nullptr &&
|
|
binding.pendingLoad == nullptr &&
|
|
(!binding.texturePath.Empty() || binding.textureRef.IsValid())) {
|
|
material->BeginAsyncTextureLoad(index);
|
|
}
|
|
return binding.texture;
|
|
}
|
|
|
|
return ResourceHandle<Texture>();
|
|
}
|
|
|
|
std::vector<MaterialProperty> Material::GetProperties() const {
|
|
std::vector<MaterialProperty> properties;
|
|
const auto pairs = m_properties.GetPairs();
|
|
properties.reserve(pairs.Size());
|
|
for (const auto& pair : pairs) {
|
|
properties.push_back(pair.second);
|
|
}
|
|
return properties;
|
|
}
|
|
|
|
const MaterialConstantFieldDesc* Material::FindConstantField(const Containers::String& name) const {
|
|
for (const MaterialConstantFieldDesc& field : m_constantLayout) {
|
|
if (field.name == name) {
|
|
return &field;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void Material::UpdateConstantBuffer() {
|
|
std::vector<MaterialProperty> packedProperties;
|
|
if (m_shader.Get() != nullptr && !m_shader->GetProperties().Empty()) {
|
|
packedProperties.reserve(m_shader->GetProperties().Size());
|
|
for (const ShaderPropertyDesc& shaderProperty : m_shader->GetProperties()) {
|
|
const MaterialProperty* property = m_properties.Find(shaderProperty.name);
|
|
if (property == nullptr ||
|
|
!IsPackedMaterialPropertyType(property->type) ||
|
|
!IsMaterialPropertyCompatibleWithShaderProperty(property->type, shaderProperty.type)) {
|
|
continue;
|
|
}
|
|
|
|
packedProperties.push_back(*property);
|
|
}
|
|
} else {
|
|
const auto pairs = m_properties.GetPairs();
|
|
packedProperties.reserve(pairs.Size());
|
|
for (const auto& pair : pairs) {
|
|
if (IsPackedMaterialPropertyType(pair.second.type)) {
|
|
packedProperties.push_back(pair.second);
|
|
}
|
|
}
|
|
|
|
std::sort(
|
|
packedProperties.begin(),
|
|
packedProperties.end(),
|
|
[](const MaterialProperty& left, const MaterialProperty& right) {
|
|
return std::strcmp(left.name.CStr(), right.name.CStr()) < 0;
|
|
});
|
|
}
|
|
|
|
m_constantLayout.Clear();
|
|
m_constantLayout.Reserve(packedProperties.size());
|
|
Core::uint32 currentOffset = 0;
|
|
for (const MaterialProperty& property : packedProperties) {
|
|
MaterialConstantFieldDesc field;
|
|
field.name = property.name;
|
|
field.type = property.type;
|
|
field.offset = currentOffset;
|
|
field.size = GetPackedMaterialPropertySize(property.type);
|
|
field.alignedSize = static_cast<Core::uint32>(kMaterialConstantSlotSize);
|
|
m_constantLayout.PushBack(field);
|
|
currentOffset += field.alignedSize;
|
|
}
|
|
|
|
m_constantBufferData.Clear();
|
|
m_constantBufferData.Resize(static_cast<size_t>(currentOffset));
|
|
if (!packedProperties.empty()) {
|
|
std::memset(m_constantBufferData.Data(), 0, m_constantBufferData.Size());
|
|
}
|
|
|
|
for (size_t propertyIndex = 0; propertyIndex < packedProperties.size(); ++propertyIndex) {
|
|
WritePackedMaterialProperty(
|
|
m_constantBufferData.Data() + propertyIndex * kMaterialConstantSlotSize,
|
|
packedProperties[propertyIndex]);
|
|
}
|
|
UpdateMemorySize();
|
|
}
|
|
|
|
void Material::RecalculateMemorySize() {
|
|
UpdateMemorySize();
|
|
}
|
|
|
|
void Material::BeginAsyncTextureLoad(Core::uint32 index) {
|
|
if (index >= m_textureBindings.Size()) {
|
|
return;
|
|
}
|
|
|
|
MaterialTextureBinding& binding = m_textureBindings[index];
|
|
if (binding.texture.Get() != nullptr || binding.pendingLoad != nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (binding.texturePath.Empty() && binding.textureRef.IsValid()) {
|
|
ResourceManager::Get().TryResolveAssetPath(binding.textureRef, binding.texturePath);
|
|
}
|
|
|
|
if (binding.texturePath.Empty()) {
|
|
return;
|
|
}
|
|
|
|
binding.pendingLoad = std::make_shared<PendingTextureLoadState>();
|
|
std::weak_ptr<PendingTextureLoadState> weakState = binding.pendingLoad;
|
|
const Containers::String texturePath = binding.texturePath;
|
|
ResourceManager::Get().LoadAsync(
|
|
texturePath,
|
|
ResourceType::Texture,
|
|
[weakState](LoadResult result) {
|
|
if (std::shared_ptr<PendingTextureLoadState> state = weakState.lock()) {
|
|
state->resource = result.resource;
|
|
state->errorMessage = result.errorMessage;
|
|
state->completed = true;
|
|
}
|
|
});
|
|
}
|
|
|
|
void Material::ResolvePendingTextureBinding(Core::uint32 index) {
|
|
if (index >= m_textureBindings.Size()) {
|
|
return;
|
|
}
|
|
|
|
MaterialTextureBinding& binding = m_textureBindings[index];
|
|
if (!binding.pendingLoad || !binding.pendingLoad->completed) {
|
|
return;
|
|
}
|
|
|
|
std::shared_ptr<PendingTextureLoadState> completedLoad = std::move(binding.pendingLoad);
|
|
binding.pendingLoad.reset();
|
|
if (completedLoad->resource == nullptr) {
|
|
return;
|
|
}
|
|
|
|
binding.texture = ResourceHandle<Texture>(static_cast<Texture*>(completedLoad->resource));
|
|
if (binding.texture.Get() != nullptr) {
|
|
if (binding.texturePath.Empty()) {
|
|
binding.texturePath = binding.texture->GetPath();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Material::ResolvePendingTextureBindings() {
|
|
for (Core::uint32 bindingIndex = 0; bindingIndex < m_textureBindings.Size(); ++bindingIndex) {
|
|
ResolvePendingTextureBinding(bindingIndex);
|
|
}
|
|
}
|
|
|
|
bool Material::HasProperty(const Containers::String& name) const {
|
|
return m_properties.Contains(name);
|
|
}
|
|
|
|
void Material::RemoveProperty(const Containers::String& name) {
|
|
if (ResetPropertyToShaderDefault(name)) {
|
|
MarkChanged(true);
|
|
return;
|
|
}
|
|
|
|
const MaterialProperty* property = m_properties.Find(name);
|
|
const bool removeTextureBinding =
|
|
property != nullptr &&
|
|
(property->type == MaterialPropertyType::Texture || property->type == MaterialPropertyType::Cubemap);
|
|
|
|
m_properties.Erase(name);
|
|
|
|
if (removeTextureBinding) {
|
|
RemoveTextureBindingByName(m_textureBindings, name);
|
|
}
|
|
|
|
MarkChanged(true);
|
|
}
|
|
|
|
void Material::ClearAllProperties() {
|
|
m_properties.Clear();
|
|
m_constantLayout.Clear();
|
|
m_textureBindings.Clear();
|
|
m_constantBufferData.Clear();
|
|
SyncShaderSchemaProperties(false);
|
|
MarkChanged(true);
|
|
}
|
|
|
|
const ShaderPropertyDesc* Material::FindShaderPropertyDesc(const Containers::String& name) const {
|
|
if (m_shader.Get() == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
return m_shader->FindProperty(name);
|
|
}
|
|
|
|
bool Material::CanAssignPropertyType(const Containers::String& name, MaterialPropertyType type) const {
|
|
const ShaderPropertyDesc* shaderProperty = FindShaderPropertyDesc(name);
|
|
if (shaderProperty == nullptr) {
|
|
return m_shader.Get() == nullptr;
|
|
}
|
|
|
|
return IsMaterialPropertyCompatibleWithShaderProperty(type, shaderProperty->type);
|
|
}
|
|
|
|
bool Material::ResetPropertyToShaderDefault(const Containers::String& name) {
|
|
const ShaderPropertyDesc* shaderProperty = FindShaderPropertyDesc(name);
|
|
if (shaderProperty == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
MaterialProperty defaultProperty;
|
|
if (!TryBuildDefaultMaterialProperty(*shaderProperty, defaultProperty)) {
|
|
return false;
|
|
}
|
|
|
|
RemoveTextureBindingByName(m_textureBindings, name);
|
|
m_properties.Insert(name, defaultProperty);
|
|
return true;
|
|
}
|
|
|
|
void Material::SyncShaderSchemaProperties(bool removeUnknownProperties) {
|
|
if (m_shader.Get() == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (removeUnknownProperties) {
|
|
std::vector<Containers::String> unknownProperties;
|
|
const auto pairs = m_properties.GetPairs();
|
|
unknownProperties.reserve(pairs.Size());
|
|
for (const auto& pair : pairs) {
|
|
if (FindShaderPropertyDesc(pair.first) == nullptr) {
|
|
unknownProperties.push_back(pair.first);
|
|
}
|
|
}
|
|
|
|
for (const Containers::String& propertyName : unknownProperties) {
|
|
m_properties.Erase(propertyName);
|
|
RemoveTextureBindingByName(m_textureBindings, propertyName);
|
|
}
|
|
}
|
|
|
|
for (const ShaderPropertyDesc& shaderProperty : m_shader->GetProperties()) {
|
|
const MaterialProperty* property = m_properties.Find(shaderProperty.name);
|
|
if (property == nullptr ||
|
|
!IsMaterialPropertyCompatibleWithShaderProperty(property->type, shaderProperty.type)) {
|
|
ResetPropertyToShaderDefault(shaderProperty.name);
|
|
continue;
|
|
}
|
|
|
|
if (!IsTextureMaterialPropertyType(property->type)) {
|
|
RemoveTextureBindingByName(m_textureBindings, shaderProperty.name);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Material::SyncShaderSchemaKeywords(bool removeUnknownKeywords) {
|
|
if (m_shader.Get() == nullptr || !removeUnknownKeywords) {
|
|
return;
|
|
}
|
|
|
|
for (size_t keywordIndex = 0; keywordIndex < m_keywordSet.enabledKeywords.Size();) {
|
|
if (m_shader->DeclaresKeyword(m_keywordSet.enabledKeywords[keywordIndex])) {
|
|
++keywordIndex;
|
|
continue;
|
|
}
|
|
|
|
if (keywordIndex != m_keywordSet.enabledKeywords.Size() - 1) {
|
|
m_keywordSet.enabledKeywords[keywordIndex] = std::move(m_keywordSet.enabledKeywords.Back());
|
|
}
|
|
m_keywordSet.enabledKeywords.PopBack();
|
|
}
|
|
|
|
std::sort(
|
|
m_keywordSet.enabledKeywords.begin(),
|
|
m_keywordSet.enabledKeywords.end(),
|
|
CompareShaderKeywordTokens);
|
|
}
|
|
|
|
void Material::MarkChanged(bool updateConstantBuffer) {
|
|
if (updateConstantBuffer) {
|
|
UpdateConstantBuffer();
|
|
} else {
|
|
UpdateMemorySize();
|
|
}
|
|
|
|
++m_changeVersion;
|
|
}
|
|
|
|
void Material::UpdateMemorySize() {
|
|
m_memorySize = m_constantBufferData.Size() +
|
|
m_constantLayout.Size() * sizeof(MaterialConstantFieldDesc) +
|
|
sizeof(MaterialRenderState) +
|
|
m_tags.Size() * sizeof(MaterialTagEntry) +
|
|
m_keywordSet.enabledKeywords.Size() * sizeof(Containers::String) +
|
|
m_textureBindings.Size() * sizeof(MaterialTextureBinding) +
|
|
m_properties.Size() * sizeof(MaterialProperty) +
|
|
m_name.Length() +
|
|
m_path.Length();
|
|
|
|
for (const MaterialTagEntry& tag : m_tags) {
|
|
m_memorySize += tag.name.Length();
|
|
m_memorySize += tag.value.Length();
|
|
}
|
|
|
|
for (const Containers::String& keyword : m_keywordSet.enabledKeywords) {
|
|
m_memorySize += keyword.Length();
|
|
}
|
|
|
|
for (const MaterialConstantFieldDesc& field : m_constantLayout) {
|
|
m_memorySize += field.name.Length();
|
|
}
|
|
|
|
for (const auto& binding : m_textureBindings) {
|
|
m_memorySize += binding.name.Length();
|
|
m_memorySize += binding.texturePath.Length();
|
|
}
|
|
}
|
|
|
|
} // namespace Resources
|
|
} // namespace XCEngine
|