Cogs.Core
MaterialReader.cpp
1#include "MaterialReader.h"
2
3#include <glm/gtc/type_ptr.hpp>
4
5#include "Foundation/Logging/Logger.h"
6
7#include "JsonParser.h"
8
9#include "Context.h"
10#include "Resources/ResourceStore.h"
11#include "Resources/MaterialManager.h"
12
13#include "Utilities/Parsing.h"
14
15#include "Renderer/IRenderer.h"
16
17namespace
18{
19 using namespace Cogs::Core;
20
21 Cogs::Logging::Log logger = Cogs::Logging::getLogger("MaterialReader");
22
23 bool traceParsing = false;
24
25 [[nodiscard]] bool parseType(Cogs::StringView valueString, ValueDefinition& value, bool allowFormat)
26 {
27 const size_t spaceIndex = valueString.find(" ");
28 const Cogs::StringView typeString = (spaceIndex != Cogs::StringView::NoPosition) ? valueString.substr(spaceIndex) : valueString;
29
30 // Magic hook for when type is format
31 if (allowFormat && typeString.hash() == Cogs::hash("format")) {
32 value.type = MaterialDataType::Unknown;
33 return true;
34 }
35
36 switch (typeString.hash()) {
37 case Cogs::hash("float"): value.type = MaterialDataType::Float; break;
38 case Cogs::hash("float2"): value.type = MaterialDataType::Float2; break;
39 case Cogs::hash("float3"): value.type = MaterialDataType::Float3; break;
40 case Cogs::hash("float4"): value.type = MaterialDataType::Float4; break;
41 case Cogs::hash("float4x4"): value.type = MaterialDataType::Float4x4; break;
42 case Cogs::hash("float4[]"): value.type = MaterialDataType::Float4Array; value.dimension = (size_t)-1; break;
43 case Cogs::hash("float4x4[]"): value.type = MaterialDataType::Float4x4Array; value.dimension = (size_t)-1; break;
44 case Cogs::hash("bool"): value.type = MaterialDataType::Bool; break;
45 case Cogs::hash("uint"): value.type = MaterialDataType::UInt; break;
46 case Cogs::hash("uint2"): value.type = MaterialDataType::UInt2; break;
47 case Cogs::hash("uint3"): value.type = MaterialDataType::UInt3; break;
48 case Cogs::hash("uint4"): value.type = MaterialDataType::UInt4; break;
49 case Cogs::hash("int"): value.type = MaterialDataType::Int; break;
50 case Cogs::hash("int2"): value.type = MaterialDataType::Int2; break;
51 case Cogs::hash("int3"): value.type = MaterialDataType::Int3; break;
52 case Cogs::hash("int4"): value.type = MaterialDataType::Int4; break;
53 case Cogs::hash("VFACE"): value.type = MaterialDataType::VFACE; break;
54 case Cogs::hash("SV_IsFrontFace"): value.type = MaterialDataType::SV_IsFrontFace; break;
55 case Cogs::hash("SV_InstanceID"): value.type = MaterialDataType::SV_InstanceID; break;
56 case Cogs::hash("SV_ClipDistance"): value.type = MaterialDataType::ClipDistance; break;
57 case Cogs::hash("SV_Position"): value.type = MaterialDataType::Position; break;
58 default:
59
60 // Try to match (.*)[d+] where first match gets checked against float4 and float4x4
61 for (size_t i = 0; i + 1 < typeString.size(); i++) {
62 if ((typeString[i] == '[') && ('0' <= typeString[i + 1]) && (typeString[i + 1] <= '9')) {
63
64 size_t dimension = typeString[i + 1] - '0';
65 for (size_t j = i + 2; j < typeString.size(); j++) {
66 if ('0' <= typeString[j] && typeString[j] <= '9') {
67 dimension = 10 * dimension + (typeString[j] - '0');
68 }
69 else if ((typeString[j] == ']') && (j + 1 == typeString.size())) {
70 switch (typeString.substr(0, i).hash()) {
71
72 case Cogs::hash("float4"):
73 value.type = MaterialDataType::Float4Array;
74 value.dimension = dimension;
75 value.dimensionString = typeString.substr(i + 1, j - i - 1).to_string();
76 return true;
77
78 case Cogs::hash("float4x4"):
79 value.type = MaterialDataType::Float4x4Array;
80 value.dimension = dimension;
81 value.dimensionString = typeString.substr(i + 1, j - i - 1).to_string();
82 return true;
83
84 default:
85 break;
86 }
87 }
88 else {
89 break;
90 }
91 }
92 break;
93 }
94 }
95 LOG_ERROR(logger, "Failed to parse datatype '%.*s'", StringViewFormat(valueString));
96 return false;
97 }
98 return true;
99 }
100
101 [[nodiscard]] bool parsePropertyValue(Cogs::StringView valueString, ConstantBufferVariableDefinition& value)
102 {
103 thread_local static std::vector<Cogs::StringView> tokens;
104 tokens.clear();
105
106 tokenize(valueString, tokens);
107
108 if (tokens.empty()) {
109 LOG_ERROR(logger, "Empty property value");
110 return false;
111 }
112
113 if (!parseType(tokens[0], value, false)) {
114 return false;
115 }
116
117 tokens.erase(tokens.begin());
118
119 value.flags = MaterialPropertyFlags::None;
120 while (!tokens.empty()) {
121 if (tokens[0] == "srgb") {
122 value.flags = value.flags | MaterialPropertyFlags::sRGB;
123 }
124 else if (tokens[0] == "normalized") {
125 value.flags = value.flags | MaterialPropertyFlags::Normalized;
126 }
127 else if (tokens[0] == "partitionOfUnity") {
128 value.flags = value.flags | MaterialPropertyFlags::PartitionOfUnity;
129 }
130 else {
131 break;
132 }
133 tokens.erase(tokens.begin());
134 }
135
136 switch (value.type) {
137 case MaterialDataType::Float:
138 value.floatValue = float(0.f);
139 if (!tokens.empty()) {
140 parseValues(&value.floatValue, tokens, 1);
141 }
142 break;
143 case MaterialDataType::Float2:
144 value.float2Value = glm::vec2();
145 if (!tokens.empty()) {
146 parseValues(glm::value_ptr(value.float2Value), tokens, 2);
147 }
148 break;
149 case MaterialDataType::Float3:
150 value.float3Value = glm::vec3();
151 if (!tokens.empty()) {
152 parseValues(glm::value_ptr(value.float3Value), tokens, 3);
153 }
154 break;
155 case MaterialDataType::Float4:
156 value.float4Value = glm::vec4();
157 if (!tokens.empty()) {
158 parseValues(glm::value_ptr(value.float4Value), tokens, 4);
159 }
160 break;
161 case MaterialDataType::Float4x4:
162 value.float4x4Value = glm::mat4();
163 if (!tokens.empty()) {
164 parseValues(glm::value_ptr(value.float4x4Value), tokens, 16);
165 }
166 break;
167
168 case MaterialDataType::Float4Array:
169 if (value.dimension == size_t(-1)) {
170 LOG_ERROR(logger, "Property buffer Float4Array element without known size");
171 return false;
172 }
173 value.float4Value = glm::vec4();
174 if (!tokens.empty()) { // For now, allow one element that gets replicated
175 parseValues(glm::value_ptr(value.float4Value), tokens, 4);
176 }
177 break;
178 case MaterialDataType::Float4x4Array:
179 if (value.dimension == size_t(-1)) {
180 LOG_ERROR(logger, "Property buffer Float4x4Array element without known size");
181 return false;
182 }
183 value.float4x4Value = glm::mat4();
184 if (!tokens.empty()) { // For now, allow one element that gets replicated
185 parseValues(glm::value_ptr(value.float4x4Value), tokens, 16);
186 }
187 break;
188
189 case MaterialDataType::UInt:
190 value.uintValue = 0;
191 if (!tokens.empty()) {
192 parseValues(&value.uintValue, tokens, 1);
193 }
194 break;
195 case MaterialDataType::UInt2:
196 value.uint2Value = glm::ivec2();
197 if (!tokens.empty()) {
198 parseValues(glm::value_ptr(value.uint2Value), tokens, 2);
199 }
200 break;
201 case MaterialDataType::UInt3:
202 value.uint3Value = glm::ivec3();
203 if (!tokens.empty()) {
204 parseValues(glm::value_ptr(value.uint3Value), tokens, 3);
205 }
206 break;
207 case MaterialDataType::UInt4:
208 value.uint4Value = glm::ivec4();
209 if (!tokens.empty()) {
210 parseValues(glm::value_ptr(value.uint4Value), tokens, 4);
211 }
212 break;
213 case MaterialDataType::Int:
214 value.intValue = int(0);
215 if (!tokens.empty()) {
216 parseValues(&value.intValue, tokens, 1);
217 }
218 break;
219 case MaterialDataType::Int2:
220 value.int2Value = glm::ivec2();
221 if (!tokens.empty()) {
222 parseValues(glm::value_ptr(value.int2Value), tokens, 2);
223 }
224 break;
225 case MaterialDataType::Int3:
226 value.int3Value = glm::ivec3();
227 if (!tokens.empty()) {
228 parseValues(glm::value_ptr(value.int3Value), tokens, 3);
229 }
230 break;
231 case MaterialDataType::Int4:
232 value.int4Value = glm::ivec4();
233 if (!tokens.empty()) {
234 parseValues(glm::value_ptr(value.int4Value), tokens, 4);
235 }
236 break;
237
238 case MaterialDataType::Bool:
239 value.boolValue = false;
240 if (!tokens.empty()) {
241 parseValues(&value.boolValue, tokens, 1);
242 }
243 break;
244 default:
245 LOG_ERROR(logger, "Property buffer does not support %s elements", DataTypeNames[size_t(value.type)]);
246 return false;
247 }
248
249 return true;
250 }
251
252 [[nodiscard]] bool readMaterialBuffer(const Value& jsonBuffer, ConstantBufferDefinition& buffer)
253 {
254 for (auto& m : jsonBuffer.GetObject()) {
255 auto propertyKey = toKey(m.name);
256
257 ConstantBufferVariableDefinition parsedValue;
258 parsedValue.name = propertyKey.to_string();
259
260 if (m.value.IsString()) {
261 if (!parsePropertyValue(toKey(m.value), parsedValue)) {
262 return false;
263 }
264 }
265 else {
266 LOG_ERROR(logger, "Material property %.*s must be specified as strings.", StringViewFormat(propertyKey));
267 return false;
268 }
269
270 buffer.values.push_back(parsedValue);
271 }
272 return true;
273 }
274
275 [[nodiscard]] bool readMaterialProperty(const std::string& propertyName,
276 const Value& value,
277 MaterialProperties& materialProperties,
278 bool isShared)
279 {
280 std::string propertyType;
281
282 switch (value.GetType())
283 {
284 case kObjectType:
285 {
286 if (traceParsing) LOG_DEBUG(logger, " Found buffer %s.", propertyName.c_str());
287
288 materialProperties.buffers.emplace_back();
289 auto& buffer = materialProperties.buffers.back();
290 buffer.name = propertyName;
291 buffer.isPerInstance = !isShared;
292 return readMaterialBuffer(value, buffer);
293 }
294 case kStringType:
295 {
296 propertyType = toString(value);
297 break;
298 }
299
300 case kArrayType:
301 {
302 auto arr = value.GetArray();
303
304 if (arr.Empty()) {
305 LOG_ERROR(logger, "Property array cannot be empty %s.", propertyName.c_str());
306 return false;
307 }
308
309 propertyType = toString(arr[0]);
310 break;
311 }
312 default:
313 break;
314 }
315
316 // Check for arrays of textures properties ("Texture2D[24]")
317 bool is_array = false;
318 uint32_t arr_size = 0;
319 auto arr_i = propertyType.find('[');
320 if (arr_i != std::string::npos) {
321 is_array = true;
322 auto arr_ii = propertyType.find(']');
323 auto n = propertyType.substr(arr_i + 1, arr_ii);
324 arr_size = std::stoul(n);
325 propertyType = propertyType.substr(0, arr_i);
326 }
327
328 const size_t code = Cogs::StringView(propertyType).hash();
329
330 switch (code)
331 {
332 case Cogs::hash("Texture1D"):
333 materialProperties.textures.emplace_back(MaterialTextureDefinition{ propertyName, !isShared, false, is_array, arr_size, TextureDimensions::Texture2D });
334 break;
335 case Cogs::hash("Texture2D"):
336 materialProperties.textures.emplace_back(MaterialTextureDefinition{ propertyName, !isShared, false, is_array, arr_size, TextureDimensions::Texture2D });
337 break;
338 case Cogs::hash("Texture2DArray"):
339 materialProperties.textures.emplace_back(MaterialTextureDefinition{ propertyName, !isShared, false, is_array, arr_size, TextureDimensions::Texture2DArray });
340 break;
341 case Cogs::hash("Texture3D"):
342 materialProperties.textures.emplace_back(MaterialTextureDefinition{ propertyName, !isShared, false, is_array, arr_size, TextureDimensions::Texture3D });
343 break;
344 case Cogs::hash("TextureCube"):
345 materialProperties.textures.emplace_back(MaterialTextureDefinition{ propertyName, !isShared, false, is_array, arr_size, TextureDimensions::TexureCube });
346 break;
347 default:
348 LOG_ERROR(logger, "Unsupported property type '%s'", propertyType.c_str());
349 return false;
350 }
351
352 if (value.IsArray()) {
353
354 MaterialTextureDefinition& textureDefinition = materialProperties.textures.back();
355 for (const auto& item : value.GetArray()) {
356 if (!item.IsString()) {
357 LOG_WARNING(logger, "Non-string texture options encountered.");
358 continue;
359 }
360
361 switch (Cogs::hashLowercase(item.GetString())) {
362
363 // Texture dimension already handled, just skip
364 case Cogs::hash("texture1d"): [[fallthrough]];
365 case Cogs::hash("texture2d"): [[fallthrough]];
366 case Cogs::hash("texture2darray"): [[fallthrough]];
367 case Cogs::hash("texture3d"): [[fallthrough]];
368 case Cogs::hash("texturecube"):
369 continue;
370
371 // Enable sRGB
372 case Cogs::hash("srgb"):
373 textureDefinition.isSrgb = true;
374 break;
375
376 // Optional specification of texture format
377 case Cogs::hash("float"):
378 textureDefinition.format = MaterialDataType::Float;
379 break;
380 case Cogs::hash("float2"):
381 textureDefinition.format = MaterialDataType::Float2;
382 break;
383 case Cogs::hash("float3"):
384 textureDefinition.format = MaterialDataType::Float3;
385 break;
386 case Cogs::hash("float4"):
387 textureDefinition.format = MaterialDataType::Float4;
388 break;
389 case Cogs::hash("int"):
390 textureDefinition.format = MaterialDataType::Int;
391 break;
392 case Cogs::hash("int2"):
393 textureDefinition.format = MaterialDataType::Int2;
394 break;
395 case Cogs::hash("int3"):
396 textureDefinition.format = MaterialDataType::Int3;
397 break;
398 case Cogs::hash("int4"):
399 textureDefinition.format = MaterialDataType::Int4;
400 break;
401 case Cogs::hash("uint"):
402 textureDefinition.format = MaterialDataType::UInt;
403 break;
404 case Cogs::hash("uint2"):
405 textureDefinition.format = MaterialDataType::UInt2;
406 break;
407 case Cogs::hash("uint3"):
408 textureDefinition.format = MaterialDataType::UInt3;
409 break;
410 case Cogs::hash("uint4"):
411 textureDefinition.format = MaterialDataType::UInt4;
412 break;
413
414 default:
415 LOG_WARNING(logger, "Unrecognized texture option '%s' encountered.", item.GetString());
416 break;
417 }
418 }
419 }
420
421 return true;
422 }
423
424 [[nodiscard]] bool parseInterpolationModifier(const Value& jsonObject, ShaderInterfaceMemberDefinition& memberDefinition)
425 {
426 if (!jsonObject.IsString()) {
427 LOG_ERROR(logger, "Interpolation modifier is not a JSON string");
428 return false;
429 }
430
431 Cogs::StringView value = toView(jsonObject);
432 switch (value.hash()) {
433 case Cogs::hash("linear"):
434 memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::LinearModifier);
435 break;
436 case Cogs::hash("centroid"):
437 memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::CentroidModifier);
438 break;
439 case Cogs::hash("nointerpolation"):
440 memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::NointerpolationModifier);
441 break;
442 case Cogs::hash("noperspective"):
443 memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::NoperspectiveModifier);
444 break;
445 case Cogs::hash("sample"):
446 memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::SampleModifier);
447 break;
448 default:
449 LOG_ERROR(logger, "Unrecognized interpolation modifier '%.*s'", StringViewFormat(value));
450 return false;
451 }
452 return true;
453 }
454
455 [[nodiscard]] bool addVariantFlag(Cogs::Core::ShaderVarientFlags& flags, const Cogs::StringView& name)
456 {
457 switch (name.hash()) {
458 case Cogs::hash("DepthOnly"): flags |= ShaderVarientFlags::DepthOnly; break;
459 case Cogs::hash("NoShading"): flags |= ShaderVarientFlags::NoShading; break;
460 case Cogs::hash("ReverseDepth"): flags |= ShaderVarientFlags::ReverseDepth; break;
461 default:
462 LOG_ERROR(logger, "Unrecognized variant flag '%.*s'", StringViewFormat(name));
463 return false;
464 }
465 return true;
466 }
467
468 [[nodiscard]] bool parseShaderInterface(const Value& jsonObject, ShaderInterfaceDefinition& interfaceDefinition, uint8_t inheritanceLevel, bool allowFormat)
469 {
470 if (!jsonObject.IsObject()) {
471 LOG_ERROR(logger, "Shader interface is not an JSON object");
472 return false;
473 }
474
475 for (auto& m : jsonObject.GetObject()) {
476 Cogs::StringView name = toView(m.name);
477 auto& obj = m.value;
478
479 ShaderInterfaceMemberDefinition value;
480
481 if (obj.IsArray()) {
482 auto arr = obj.GetArray();
483
484
485
486 if (!parseType(toKey(arr[0]), value, allowFormat)) return false;
487
488 if (value.dimension == size_t(-1)) {
489 if (arr[1].IsString()) {
490 value.dimensionString = toString(arr[1]);
491 }
492 else {
493 value.dimension = arr[1].GetInt();
494 }
495 }
496 else {
497 if (arr.Size() >= 2) {
498 if (arr[1].IsString()) {
499 value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::None;
500 value.semantic.slot = 0;
501 Cogs::StringView semanticName(arr[1].GetString(), arr[1].GetStringLength());
502
503 // Check for trailing digits, interpreted and chomp semanticName.
504 for (size_t i = 0; i < semanticName.size(); i++) {
505 if ('0' <= semanticName[i] && semanticName[i] <= '9') {
506 value.semantic.slot = semanticName[i] - '0';
507 size_t k = i + 1;
508 while ((k < semanticName.size()) &&
509 ('0' <= semanticName[k]) &&
510 (semanticName[k] <= '9'))
511 {
512 value.semantic.slot = uint8_t(10u * value.semantic.slot + (semanticName[k] - '0'));
513 }
514 semanticName = semanticName.substr(0, i);
515 break;
516 }
517 }
518 switch (semanticName.hashLowercase()) {
519 case Cogs::hash("position"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Position; break;
520 case Cogs::hash("normal"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Normal; break;
521 case Cogs::hash("color"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Color; break;
522 case Cogs::hash("texcoord"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Texcoord; break;
523 case Cogs::hash("tangent"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Tangent; break;
524 case Cogs::hash("instancevector"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::InstanceVector; break;
525 case Cogs::hash("instancematrix"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::InstanceMatrix; break;
526 case Cogs::hash("sv_position"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_Position; break;
527 case Cogs::hash("sv_vertexid"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_VertexID; break;
528 case Cogs::hash("sv_instanceid"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_InstanceID; break;
529 case Cogs::hash("sv_clipdistance"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_ClipDistance; break;
530 case Cogs::hash("sv_vface"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_VFace; break;
531 case Cogs::hash("sv_isfrontface"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_IsFrontFace; break;
532 default:
533 LOG_ERROR(logger, "Unrecognized semantic '%.*s'", StringViewFormat(semanticName));
534 return false;
535 }
536 }
537 else {
538 LOG_ERROR(logger, "Semantic is not a string");
539 return false;
540 }
541 }
542
543 if (arr.Size() >= 3) {
544 auto& modifiers = arr[2];
545 if (modifiers.IsString()) {
546 if (!parseInterpolationModifier(modifiers, value)) return false;
547 }
548 else if (modifiers.IsArray()) {
549 for (auto& modifier : modifiers.GetArray()) {
550 if (!parseInterpolationModifier(modifier, value)) return false;
551 }
552 }
553 }
554 }
555 }
556 else if (obj.IsString()) {
557 if (!parseType(toKey(obj), value, allowFormat)) return false;
558 }
559
560 value.name = name.to_string();
561 value.inheritanceLevel = inheritanceLevel;
562
563 interfaceDefinition.members.push_back(value);
564 }
565
566 return true;
567 }
568
569 [[nodiscard]] bool parseRequiresStatement(const Value& requiresStatement, std::vector<ShaderVariantRequirement>& requirements, const Cogs::StringView& name)
570 {
571 if (requiresStatement.IsString()) {
572 requirements.push_back(ShaderVariantRequirement{ toString(requiresStatement), {} });
573 }
574 else if (requiresStatement.IsArray()) {
575 for (auto& item : requiresStatement.GetArray()) {
576 if (item.IsString()) {
577 requirements.push_back(ShaderVariantRequirement{ toString(item), {} });
578 }
579 else {
580 LOG_ERROR(logger, "Material %.*s has non-string element in requires array.", StringViewFormat(name));
581 return false;
582 }
583 }
584 }
585 else if (requiresStatement.IsObject()) {
586 for (auto& item : requiresStatement.GetObject()) {
587 if (item.value.IsString()) {
588 requirements.push_back(ShaderVariantRequirement{ toString(item.name), toString(item.value) });
589 }
590 else {
591 LOG_ERROR(logger, "Material %.*s has non-string value in requires object.", StringViewFormat(name));
592 return false;
593 }
594 }
595 }
596 else {
597 LOG_ERROR(logger, "Material %.*s has unexpected value in requires object.", StringViewFormat(name));
598 return false;
599 }
600 return true;
601 }
602
603 [[nodiscard]] bool parseTriggersStatement(const Value& triggersStatement, ShaderVariantDefinition& variant)
604 {
605 if (triggersStatement.IsString()) {
606 variant.triggers.push_back(ShaderVariantRequirement{ toString(triggersStatement), {} });
607 }
608 else if (triggersStatement.IsArray()) {
609 for (auto& item : triggersStatement.GetArray()) {
610 if (item.IsString()) {
611 variant.triggers.push_back(ShaderVariantRequirement{ toString(item), {} });
612 }
613 else {
614 LOG_ERROR(logger, "Material variant %s has non-string element in triggers array.", variant.name.c_str());
615 return false;
616 }
617 }
618 }
619 else if (triggersStatement.IsObject()) {
620 for (auto& item : triggersStatement.GetObject()) {
621 if (item.value.IsString()) {
622 variant.triggers.push_back(ShaderVariantRequirement{ toString(item.name), toString(item.value) });
623 }
624 else {
625 LOG_ERROR(logger, "Material variant %s has non-string value in triggers object.", variant.name.c_str());
626 return false;
627 }
628 }
629 }
630 else {
631 LOG_ERROR(logger, "Material variant %s has unexpected value in triggers object.", variant.name.c_str());
632 return false;
633 }
634 return true;
635 }
636
637 [[nodiscard]] bool parseDefaultValueStatement(const Value& defaultValue, ShaderVariantDefinition& variant)
638 {
639 switch (variant.type) {
640
641 case ShaderVariantType::Bool:
642 if (!defaultValue.IsBool()) {
643 LOG_ERROR(logger, "Variant %s defaultValue property is not a bool", variant.name.c_str());
644 return false;
645 }
646 variant.defaultValue = defaultValue.GetBool();
647 break;
648
649 case ShaderVariantType::Int:
650 if (!defaultValue.IsInt()) {
651 LOG_ERROR(logger, "Variant %s defaultValue property is not an int", variant.name.c_str());
652 return false;
653 }
654 variant.defaultValue = defaultValue.GetInt();
655 break;
656
657 case ShaderVariantType::Enum:
658 if (!defaultValue.IsString()) {
659 LOG_ERROR(logger, "Variant %s defaultValue property is not a string", variant.name.c_str());
660 return false;
661 }
662 else {
663 Cogs::StringView val = toView(defaultValue);
664 for (size_t i = 0; i < variant.values.size(); ++i) {
665 if (variant.values[i].key == val) {
666 variant.defaultValue = static_cast<int>(i);
667 goto found;
668 }
669 }
670 LOG_ERROR(logger, "Variant %s defaultValue '%.*s' is not a valid enum value", variant.name.c_str(), StringViewFormat(val));
671 return false;
672 found:
673 ;
674 }
675 break;
676
677 case ShaderVariantType::Format:
678 if (!defaultValue.IsString()) {
679 LOG_ERROR(logger, "Variant %s defaultValue property is not a string", variant.name.c_str());
680 return false;
681 }
682 else {
683 Cogs::StringView value_ = toView(defaultValue);
684 Cogs::DataFormat parsedValue = Cogs::parseDataFormat(value_);
685 if (parsedValue == Cogs::DataFormat::Unknown) {
686 LOG_ERROR(logger, "Failed to parse format '%.*s'", StringViewFormat(value_));
687 return false;
688 }
689 variant.defaultValue = size_t(parsedValue);
690 }
691 break;
692 case ShaderVariantType::String:
693 if (!defaultValue.IsString()) {
694 LOG_ERROR(logger, "Variant %s defaultValue property is not a string", variant.name.c_str());
695 return false;
696 }
697 variant.defaultString = toString(defaultValue);
698 break;
699 default:
700 assert(false);
701 }
702
703 return true;
704 }
705
706 [[nodiscard]] bool readMaterialVariant(const Value& variantObject, ShaderVariantDefinition& variant)
707 {
708 auto it = variantObject.FindMember("type");
709 if (it == variantObject.MemberEnd()) {
710 LOG_ERROR(logger, "Material variant %s missing type.", variant.name.c_str());
711 return false;
712 }
713
714 bool acceptValueString = false;
715 bool acceptValues = false;
716 bool acceptRequires = false;
717 bool acceptTriggers = false;
718 Cogs::StringView type = toView(it->value);
719 switch (type.hash()) {
720 case Cogs::hash("bool"):
721 variant.type = ShaderVariantType::Bool;
722 variant.defaultValue = 0;
723 acceptValueString = true;
724 acceptRequires = true;
725 acceptTriggers = true;
726 break;
727
728 case Cogs::hash("int"):
729 variant.type = ShaderVariantType::Int;
730 variant.defaultValue = 0;
731 acceptValueString = true;
732 break;
733
734 case Cogs::hash("format"):
735 variant.type = ShaderVariantType::Format;
736 variant.defaultValue = 0;
737 acceptValueString = true;
738 break;
739
740 case Cogs::hash("enum"):
741 variant.type = ShaderVariantType::Enum;
742 acceptValues = true;
743 break;
744
745 case Cogs::hash("string"):
746 variant.type = ShaderVariantType::String;
747 variant.defaultValue = -1;
748 acceptValueString = true;
749 break;
750
751 default:
752 LOG_ERROR(logger, "Unknown variant type %.*s.", StringViewFormat(type));
753 return false;
754 }
755
756 bool hasValueString = false;
757 variant.flags = ShaderVarientFlags::None;
758 for (auto& variantItem : variantObject.GetObject()) {
759 Cogs::StringView keyword = toView(variantItem.name);
760 switch (keyword.hashLowercase()) {
761
762 case Cogs::hash("type"): break;
763
764 case Cogs::hash("defaultvalue"):
765 if (!parseDefaultValueStatement(variantItem.value, variant)) return false;
766 break;
767
768 case Cogs::hash("value"):
769 if (!acceptValueString) {
770 LOG_ERROR(logger, "Variant type does not support value keyword");
771 return false;
772 }
773 if (!variantItem.value.IsString()) {
774 LOG_ERROR(logger, "Variant value is not a string");
775 return false;
776 }
777 variant.value = toString(variantItem.value);
778 hasValueString = true;
779 break;
780
781 case Cogs::hash("values"):
782 if (!acceptValues) {
783 LOG_ERROR(logger, "Variant type does not support value keyword");
784 return false;
785 }
786 for (auto& v : variantItem.value.GetObject()) {
787 if (!v.value.IsString()) {
788 LOG_ERROR(logger, "Variant %s values contains a non-string item", variant.name.c_str());
789 return false;
790 }
791 variant.values.emplace_back(ShaderVariantEnum{ variant.values.size(), toString(v.name), toString(v.value) });
792 }
793 break;
794
795 case Cogs::hash("require"):
796 case Cogs::hash("requires"):
797 if (!acceptRequires) {
798 LOG_ERROR(logger, "Variant type does not support requires keyword");
799 return false;
800 }
801 if (!parseRequiresStatement(variantItem.value, variant.requirements, variant.name)) return false;
802 break;
803 case Cogs::hash("trigger"):
804 case Cogs::hash("triggers"):
805 if (!acceptTriggers) {
806 LOG_ERROR(logger, "Variant type does not support triggers keyword");
807 return false;
808 }
809 if (!parseTriggersStatement(variantItem.value, variant)) return false;
810 break;
811 case Cogs::hash("vertexinterface"):
812 if (!parseShaderInterface(variantItem.value, variant.vertexInterface, 0, variant.type == ShaderVariantType::Format)) return false;
813 break;
814 case Cogs::hash("geometryinterface"):
815 if (!parseShaderInterface(variantItem.value, variant.geometryInterface, 0, false)) return false;
816 break;
817 case Cogs::hash("surfaceinterface"):
818 if (!parseShaderInterface(variantItem.value, variant.surfaceInterface, 0, false)) return false;
819 break;
820 case Cogs::hash("flags"):
821 if (variantItem.value.IsString()) {
822 if (!addVariantFlag(variant.flags, toView(variantItem.value))) return false;
823 }
824 else if (variantItem.value.IsArray()) {
825 for (auto& element : variantItem.value.GetArray()) {
826 if (!element.IsString()) {
827 LOG_ERROR(logger, "Variant flag is not a string");
828 return false;
829 }
830 if (!addVariantFlag(variant.flags, toView(element))) return false;
831 }
832 }
833 else {
834 LOG_ERROR(logger, "Variant flag is neither string nor array");
835 return false;
836 }
837 break;
838 default:
839 LOG_ERROR(logger, "Unexpected variant keyword %.*s", StringViewFormat(keyword));
840 break;
841 }
842 }
843
844 switch (variant.type) {
845 case ShaderVariantType::Bool:
846 case ShaderVariantType::Int:
847 case ShaderVariantType::Format:
848 case ShaderVariantType::String:
849 if (!hasValueString) {
850 LOG_ERROR(logger, "Variant is missing value keyword");
851 return false;
852 }
853 break;
854 case ShaderVariantType::Enum:
855 if (variant.values.empty()) {
856 LOG_ERROR(logger, "Variant enum type has no values");
857 return false;
858 }
859 break;
860 default:
861 assert(false);
862 }
863
864 return true;
865 }
866
867 [[nodiscard]] bool readMaterialOptions(const Value& jsonMaterialOptions, MaterialDefinition& materialDefinition)
868 {
869 if (jsonMaterialOptions.IsObject()) {
870 for (auto& o : jsonMaterialOptions.GetObject()) {
871 if (o.value.IsString()) {
872 materialDefinition.options[toString(o.name)] = toString(o.value);
873 }
874 else {
875 LOG_ERROR(logger, "readMaterialOptions: Item value is not a JSON string");
876 return false;
877 }
878 }
879 return true;
880 }
881 else {
882 LOG_ERROR(logger, "readMaterialOptions: value is not a JSON object");
883 return false;
884 }
885 }
886
887 [[nodiscard]] bool matchGraphicsType(bool& include, Cogs::GraphicsDeviceType deviceType, const Value& jsonDeviceType)
888 {
889 if (!jsonDeviceType.IsString()) {
890 LOG_ERROR(logger, "matchGraphicsType: device type is not a JSON string");
891 return false;
892 }
893
894 switch (toView(jsonDeviceType).hash())
895 {
896 case Cogs::hash("D3D11"):
897 case Cogs::hash("Direct3D11"):
898 include = include || (deviceType == Cogs::GraphicsDeviceType::Direct3D11);
899 return true;
900 case Cogs::hash("D3D12"):
901 case Cogs::hash("Direct3D12"):
902 include = include || (deviceType == Cogs::GraphicsDeviceType::Direct3D12);
903 return true;
904 case Cogs::hash("Vulkan"):
905 include = include || (deviceType == Cogs::GraphicsDeviceType::Vulkan);
906 return true;
907 case Cogs::hash("GL20"):
908 case Cogs::hash("OpenGL20"):
909 include = include || (deviceType == Cogs::GraphicsDeviceType::OpenGL20);
910 return true;
911 case Cogs::hash("ES30"):
912 case Cogs::hash("OpenGLES30"):
913 include = include || (deviceType == Cogs::GraphicsDeviceType::OpenGLES30);
914 return true;
915 case Cogs::hash("WebGPU"):
916 include = include || (deviceType == Cogs::GraphicsDeviceType::WebGPU);
917 return true;
918 default:
919 LOG_ERROR(logger, "matchGraphicsType: Unknown device type \"%s\"", jsonDeviceType.GetString());
920 break;
921 }
922 return false;
923 }
924
925 [[nodiscard]] bool readShaderDefinition(const Value& jsonObject, ShaderDefinition& shaderDefinition)
926 {
927 if (!jsonObject.IsObject()) {
928 LOG_ERROR(logger, "readShaderDefinition: value is not a JSON object");
929 return false;
930 }
931 for (auto& m : jsonObject.GetObject()) {
932 Cogs::StringView key = toView(m.name);
933 switch (key.hash()) {
934 case Cogs::hash("entryPoint"):
935 shaderDefinition.entryPoint = toString(m.value);
936 break;
937 case Cogs::hash("file"):
938 shaderDefinition.customSourcePath = toString(m.value);
939 break;
940 case Cogs::hash("attributes"):
941 if (m.value.IsObject()) {
942 for (auto& a : m.value.GetObject()) {
943 shaderDefinition.attributes.emplace_back(AttributeDefinition{ toString(a.name), toString(a.value) });
944 }
945 }
946 else {
947 LOG_ERROR(logger, "readShaderDefinition: attributes value is not a JSON array");
948 return false;
949 }
950 break;
951 default:
952 LOG_ERROR(logger, "readShaderDefinition: Unrecognized key '%.*s'", StringViewFormat(key));
953 return false;
954 }
955 }
956 return true;
957 }
958
959 [[nodiscard]] bool readMaterialMetadata(Context* context, const Value& jsonMaterial, MaterialDefinition& materialDefinition);
960
961 [[nodiscard]] bool readMaterialEffect(const Value& jsonMaterial, EffectDefinition& effectDefinition);
962
963 [[nodiscard]] bool readPermutation(Context* context, bool& included, Cogs::GraphicsDeviceType deviceType, const Value& jsonPermuation, MaterialDefinition& materialDefinition, const std::string& permutationName)
964 {
965 included = false;
966 if (!jsonPermuation.IsObject()) {
967 LOG_ERROR(logger, "readPermutation: %s/%s: Permutation is not an JSON object", materialDefinition.name.c_str(), permutationName.c_str());
968 return false;
969 }
970 if (jsonPermuation.HasMember("devices")) {
971 auto& jsonDeviceType = jsonPermuation["devices"];
972 bool include = false;
973 if (jsonDeviceType.IsString()) {
974
975 if (!matchGraphicsType(include, deviceType, jsonDeviceType)) return false;
976 }
977 else if (jsonDeviceType.IsArray()) {
978 include = false;
979 for (auto& item : jsonDeviceType.GetArray()) {
980 if (!item.IsString()) {
981 LOG_ERROR(logger, "readPermuation: %s/%s: Devices array item is not a JSON string", materialDefinition.name.c_str(), permutationName.c_str());
982 return false;
983 }
984 if (!matchGraphicsType(include, deviceType, item)) return false;
985 }
986 }
987 else {
988 LOG_ERROR(logger, "readPermuation: %s@%s: Devices are neither JSON string nor array", materialDefinition.name.c_str(), permutationName.c_str());
989 return false;
990 }
991 if (!include) {
992 included = false;
993 return true;
994 }
995 }
996
997 static int matId = 0;
998
999 materialDefinition.permutations.emplace_back();
1000 MaterialDefinition& permutationDefinition = materialDefinition.permutations.back();
1001 permutationDefinition.name = materialDefinition.name + std::to_string(matId++) + permutationName;
1002 permutationDefinition.permutationIndex = materialDefinition.permutations.size() - 1;
1003 permutationDefinition.permutationName = permutationName;
1004
1005 if (!readMaterialMetadata(context, jsonPermuation, permutationDefinition)) return false;
1006 if (!readMaterialEffect(jsonPermuation, permutationDefinition.effect)) return false;
1007
1008 included = true;
1009 return true;
1010 }
1011
1012 [[nodiscard]] bool readMaterialMetadata(Context* context, const Value& jsonMaterial, MaterialDefinition& materialDefinition)
1013 {
1014 if (!jsonMaterial.IsObject()) {
1015 LOG_ERROR(logger, "readMaterialMetadata: Material is not an JSON object");
1016 return false;
1017 }
1018
1019 for (auto& m : jsonMaterial.GetObject()) {
1020
1021 Cogs::StringView memberKey = toView(m.name);
1022 switch (memberKey.hash()) {
1023
1024 case Cogs::hash("name"):
1025 if (m.value.IsString()) {
1026 materialDefinition.name = toString(m.value);
1027 if (traceParsing) LOG_DEBUG(logger, "Found new material definition %s.", materialDefinition.name.c_str());
1028 }
1029 else {
1030 LOG_ERROR(logger, "readMaterialMetadata: Material name value is not an JSON string");
1031 }
1032 break;
1033
1034 case Cogs::hash("flags"):
1035 if (m.value.IsString()) {
1036 Cogs::StringView flagsString = toView(m.value);
1037 LOG_WARNING(logger, "readMaterialMetadata: %s: Unrecognized flag '%.*s'", materialDefinition.name.c_str(), StringViewFormat(flagsString));
1038 }
1039 else {
1040 LOG_ERROR(logger, "readMaterialMetadata: %s: Material flags value is not an JSON string", materialDefinition.name.c_str());
1041 }
1042 break;
1043
1044 case Cogs::hash("inherits"):
1045 if (m.value.IsString()) {
1046 materialDefinition.inherits = toString(m.value);
1047 if (traceParsing) LOG_DEBUG(logger, "Found material base type %s.", materialDefinition.inherits.c_str());
1048 }
1049 else {
1050 LOG_ERROR(logger, "readMaterialMetadata: %s: Material inherits value is not an JSON string", materialDefinition.name.c_str());
1051 }
1052 break;
1053
1054 case Cogs::hash("require"):
1055 case Cogs::hash("requires"):
1056 if (!parseRequiresStatement(m.value, materialDefinition.requirements, materialDefinition.name)) return false;
1057 break;
1058
1059 case Cogs::hash("variants"):
1060 if (traceParsing) LOG_DEBUG(logger, "Found material variants.");
1061 if (!readMaterialVariants(context, m.value, materialDefinition.variants, false)) return false;
1062 break;
1063
1064 case Cogs::hash("sharedVariants"):
1065 if (traceParsing) LOG_DEBUG(logger, "Found material variants.");
1066 if (!readMaterialVariants(context, m.value, materialDefinition.variants, true)) return false;
1067 break;
1068
1069 case Cogs::hash("options"):
1070 if (traceParsing) LOG_DEBUG(logger, "Found material options.");
1071 if (!readMaterialOptions(m.value, materialDefinition)) return false;
1072 break;
1073
1074 case Cogs::hash("properties"):
1075 if (traceParsing) LOG_DEBUG(logger, "Found material properties.");
1076 if (!readMaterialProperties(context, m.value, materialDefinition.properties, false)) return false;
1077 break;
1078
1079 case Cogs::hash("sharedProperties"):
1080 if (traceParsing) LOG_DEBUG(logger, "Found shared material properties.");
1081 if (!readMaterialProperties(context, m.value, materialDefinition.properties, true)) return false;
1082 break;
1083
1084 case Cogs::hash("permutations"):
1085 if (traceParsing) LOG_DEBUG(logger, "Found effect permutations.");
1086 if (m.value.IsObject()) {
1087 Cogs::GraphicsDeviceType deviceType = context->renderer->getDevice()->getType();
1088
1089 for (auto& p : m.value.GetObject()) {
1090 auto permutationName = toString(p.name);
1091
1092 if (traceParsing) LOG_DEBUG(logger, "Found effect permutation %s.", permutationName.c_str());
1093
1094 if (p.value.IsArray()) {
1095 for (auto& profile : p.value.GetArray()) {
1096 bool included = false;
1097 if (!readPermutation(context, included, deviceType, profile, materialDefinition, permutationName)) return false;
1098 if (included) break; // Found a device match.
1099 }
1100 }
1101 else {
1102 bool included = false;
1103 if (!readPermutation(context, included, deviceType, p.value, materialDefinition, permutationName)) return false;
1104 }
1105 }
1106 }
1107 else {
1108 LOG_ERROR(logger, "readMaterialMetadata: %s: Material permutations value is not an JSON object", materialDefinition.name.c_str());
1109 return false;
1110 }
1111 break;
1112
1113 case Cogs::hash("enginePermutations"):
1114 if (m.value.IsArray()) {
1115
1116 for (auto& element : m.value.GetArray()) {
1117
1118 if (element.IsString()) {
1119 Cogs::StringView str = toView(element);
1120 const EnginePermutation* enginePermutation = context->renderer->getEnginePermutations().get(str);
1121 if (enginePermutation) {
1122 materialDefinition.enginePermutationMask |= size_t(1) << enginePermutation->getIndex();
1123 }
1124 else {
1125 LOG_ERROR(logger, "readMaterialMetadata: %s: unrecognized engine permutation '%.*s'", materialDefinition.name.c_str(), StringViewFormat(str));
1126 return false;
1127 }
1128 }
1129 else {
1130 LOG_ERROR(logger, "readMaterialMetadata: %s: Material enginePermutations item is not an JSON string", materialDefinition.name.c_str());
1131 return false;
1132 }
1133 }
1134 }
1135 else {
1136 LOG_ERROR(logger, "readMaterialMetadata: %s: Material enginePermutations value is not an JSON array", materialDefinition.name.c_str());
1137 return false;
1138 }
1139 break;
1140
1141 case Cogs::hash("vertexInterface"):
1142 case Cogs::hash("vertexFunction"):
1143 case Cogs::hash("hullInterface"):
1144 case Cogs::hash("hullFunction"):
1145 case Cogs::hash("domainInterface"):
1146 case Cogs::hash("domainFunction"):
1147 case Cogs::hash("geometryInterface"):
1148 case Cogs::hash("geometryFunction"):
1149 case Cogs::hash("surfaceInterface"):
1150 case Cogs::hash("surfaceFunction"):
1151 case Cogs::hash("definitions"):
1152 case Cogs::hash("defines"):
1153 // parsed by readMaterialEffect
1154 break;
1155 case Cogs::hash("devices"):
1156 // parsed by readPermutation
1157 break;
1158
1159 default:
1160 LOG_ERROR(logger, "readMaterialMetadata: %s: Unrecognized key '%.*s'", materialDefinition.name.c_str(), StringViewFormat(memberKey));
1161 return false;
1162 }
1163 }
1164 return true;
1165 }
1166
1167 [[nodiscard]] bool readMaterialEffect(const Value& jsonMaterial, EffectDefinition& effectDefinition)
1168 {
1169 if (!jsonMaterial.IsObject()) {
1170 LOG_ERROR(logger, "readMaterialEffect: Material is not an JSON object");
1171 return false;
1172 }
1173
1174 for (auto& m : jsonMaterial.GetObject()) {
1175
1176 Cogs::StringView memberKey = toView(m.name);
1177 switch (memberKey.hash()) {
1178
1179 case Cogs::hash("vertexInterface"):
1180 if (traceParsing) LOG_DEBUG(logger, "Found vertex interface.");
1181 if (!parseShaderInterface(m.value, effectDefinition.vertexShader.shaderInterface, 1, false)) return false;
1182 break;
1183
1184 case Cogs::hash("vertexFunction"):
1185 if (traceParsing) LOG_DEBUG(logger, "Found vertex function.");
1186 if (!readShaderDefinition(m.value, effectDefinition.vertexShader)) return false;
1187 break;
1188
1189 case Cogs::hash("hullInterface"):
1190 if (traceParsing) LOG_DEBUG(logger, "Found hull interface.");
1191 if (!parseShaderInterface(m.value, effectDefinition.hullShader.shaderInterface, 1, false)) return false;
1192 break;
1193
1194 case Cogs::hash("hullFunction"):
1195 if (traceParsing) LOG_DEBUG(logger, "Found hull function.");
1196 if (!readShaderDefinition(m.value, effectDefinition.hullShader)) return false;
1197 break;
1198
1199 case Cogs::hash("domainInterface"):
1200 if (traceParsing) LOG_DEBUG(logger, "Found domain interface.");
1201 if (!parseShaderInterface(m.value, effectDefinition.domainShader.shaderInterface, 1, false)) return false;
1202 break;
1203
1204 case Cogs::hash("domainFunction"):
1205 if (traceParsing) LOG_DEBUG(logger, "Found domain function.");
1206 if (!readShaderDefinition(m.value, effectDefinition.domainShader)) return false;
1207 break;
1208
1209 case Cogs::hash("geometryInterface"):
1210 if (traceParsing) LOG_DEBUG(logger, "Found geometry interface.");
1211 if (!parseShaderInterface(m.value, effectDefinition.geometryShader.shaderInterface, 1, false)) return false;
1212 break;
1213
1214 case Cogs::hash("geometryFunction"):
1215 if (traceParsing) LOG_DEBUG(logger, "Found geometry function.");
1216 if (!readShaderDefinition(m.value, effectDefinition.geometryShader)) return false;
1217 break;
1218
1219 case Cogs::hash("surfaceInterface"):
1220 if (traceParsing) LOG_DEBUG(logger, "Found surface interface.");
1221 if (!parseShaderInterface(m.value, effectDefinition.pixelShader.shaderInterface, 1, false)) return false;
1222 break;
1223
1224 case Cogs::hash("surfaceFunction"):
1225 if (traceParsing) LOG_DEBUG(logger, "Found surface function.");
1226 if (!readShaderDefinition(m.value, effectDefinition.pixelShader)) return false;
1227 break;
1228
1229 case Cogs::hash("definitions"):
1230 case Cogs::hash("defines"):
1231 if (m.value.IsObject()) {
1232 for (auto& d : m.value.GetObject()) {
1233 if (d.value.IsString()) {
1234 effectDefinition.definitions.push_back(Cogs::PreprocessorDefinition{ toString(d.name), toString(d.value) });
1235 }
1236 else {
1237 LOG_ERROR(logger, "readMaterialEffect: %.*s item %.*s value is not a JSON string", StringViewFormat(memberKey), StringViewFormat(toView(d.name)));
1238 return false;
1239 }
1240 }
1241 }
1242 else {
1243 LOG_ERROR(logger, "readMaterialEffect: %.*s is not a JSON object", StringViewFormat(memberKey));
1244 return false;
1245 }
1246 break;
1247
1248 case Cogs::hash("name"):
1249 case Cogs::hash("flags"):
1250 case Cogs::hash("inherits"):
1251 case Cogs::hash("variants"):
1252 case Cogs::hash("sharedVariants"):
1253 case Cogs::hash("options"):
1254 case Cogs::hash("require"):
1255 case Cogs::hash("requires"):
1256 case Cogs::hash("properties"):
1257 case Cogs::hash("sharedProperties"):
1258 case Cogs::hash("permutations"):
1259 case Cogs::hash("enginePermutations"):
1260 // parsed by readMaterialMetadata
1261 break;
1262 case Cogs::hash("devices"):
1263 // parsed by readPermutation
1264 break;
1265
1266 default:
1267 LOG_ERROR(logger, "readMaterialEffect: Unrecognized key '%.*s'", StringViewFormat(memberKey));
1268 return false;
1269 }
1270 }
1271 return true;
1272 }
1273
1274 void inheritShaderDefinition(const ShaderDefinition& source, ShaderDefinition& definition)
1275 {
1276 // Resolving of conflicts are handled in \ref addShaderStageInterfaceMembersFromVariants in MaterialManager.
1277 for (const ShaderInterfaceMemberDefinition& sourceMember : source.shaderInterface.members) {
1278 definition.shaderInterface.members.emplace_back(sourceMember);
1279 definition.shaderInterface.members.back().inheritanceLevel += 2;
1280 }
1281
1282 if (definition.entryPoint.empty()) {
1283 definition.customSourcePath = source.customSourcePath;
1284 definition.loadPath = source.loadPath;
1285 definition.entryPoint = source.entryPoint;
1286 definition.attributes = source.attributes;
1287 }
1288 }
1289
1290 [[nodiscard]] bool inheritDefinition(const MaterialDefinitionBase& source, MaterialDefinitionBase& definition, bool properties = true)
1291 {
1292 //TODO: Validate fallback status of material definitions.
1293 definition.flags &= source.flags;
1294
1295 if (properties) {
1296 for (auto& buffer : source.properties.buffers) {
1297 definition.properties.buffers.push_back(buffer);
1298 }
1299
1300 for (auto& texture : source.properties.textures) {
1301 definition.properties.textures.push_back(texture);
1302 }
1303 }
1304
1305 definition.requirements.insert(definition.requirements.end(),
1306 source.requirements.begin(),
1307 source.requirements.end());
1308
1309 if (!inheritMaterialVariants(definition.variants, source.variants, definition.name, source.name, properties)) return false;
1310
1311 //auto & effect = definition.effect;
1312 const EffectDefinition& parentEffect = source.effect;
1313
1314 inheritShaderDefinition(parentEffect.vertexShader, definition.effect.vertexShader);
1315 inheritShaderDefinition(parentEffect.hullShader, definition.effect.hullShader);
1316 inheritShaderDefinition(parentEffect.domainShader, definition.effect.domainShader);
1317 inheritShaderDefinition(parentEffect.geometryShader, definition.effect.geometryShader);
1318 inheritShaderDefinition(parentEffect.pixelShader, definition.effect.pixelShader);
1319
1320 return true;
1321 }
1322
1323 void orderInterfaces(MaterialDefinitionBase& definition)
1324 {
1325 for (auto& buffer : definition.properties.buffers) {
1326 std::sort(buffer.values.begin(), buffer.values.end(), [](const auto& a, const auto& b)
1327 {
1328 return DataTypeSizes[(size_t)a.type] > DataTypeSizes[(size_t)b.type];
1329 });
1330 }
1331
1332 auto& pixelShaderInterface = definition.effect.pixelShader.shaderInterface;
1333
1334 std::sort(pixelShaderInterface.members.begin(), pixelShaderInterface.members.end(), [](const auto& a, const auto& b)
1335 {
1336 return DataTypeSizes[(size_t)a.type] > DataTypeSizes[(size_t)b.type];
1337 });
1338 }
1339
1340 [[nodiscard]] bool applyParent(Context* context, MaterialDefinition& definition)
1341 {
1342 if (definition.name == "MaterialBase") return true;
1343
1344 if (definition.inherits.empty()) {
1345 definition.inherits = "MaterialBase";
1346 }
1347
1348 const MaterialDefinition* parent = context->materialDefinitionManager->get(definition.inherits);
1349 if (!parent) {
1350 LOG_ERROR(logger, "Invalid parent material: %s.", definition.inherits.c_str());
1351 return false;
1352 }
1353
1354 if (!inheritDefinition(*parent, definition)) return false;
1355
1356 for (MaterialDefinition& p : definition.permutations) {
1357 if (!inheritDefinition(definition, p)) return false;
1358
1359 if (p.permutationName.size()) {
1360 const MaterialDefinition* parentPermutation = nullptr;
1361
1362 for (auto& pp : parent->permutations) {
1363 if (pp.permutationName == p.permutationName) {
1364 parentPermutation = &pp;
1365 }
1366 }
1367
1368 if (parentPermutation) {
1369 if (!inheritDefinition(*parentPermutation, p, false)) return false;
1370 }
1371 }
1372
1373 orderInterfaces(p);
1374 }
1375
1376 return true;
1377 }
1378
1379}
1380
1381
1382bool Cogs::Core::readMaterialProperties(Context* /*context*/, const Value& jsonValue, MaterialProperties& materialProperties, bool isShared)
1383{
1384 if (!jsonValue.IsObject()) {
1385 LOG_ERROR(logger, "readMaterialProperties: Material properties is not a JSON object");
1386 return false;
1387 }
1388 for (auto& m : jsonValue.GetObject()) {
1389 if (!readMaterialProperty(toString(m.name), m.value, materialProperties, isShared)) {
1390 return false;
1391 }
1392 }
1393
1394 return true;
1395}
1396
1397bool Cogs::Core::readMaterialVariants(Context* /*context*/, const Value& value, std::vector<ShaderVariantDefinition>& variants, bool isShared)
1398{
1399 if (!value.IsObject()) {
1400 LOG_ERROR(logger, "readMaterialVariants: Variant value is not an object");
1401 return false;
1402 }
1403
1404 for (auto& o : value.GetObject()) {
1405 ShaderVariantDefinition& variant = variants.emplace_back();
1406 variant.index = variants.size() - 1;
1407 variant.name = toString(o.name);
1408 variant.isShared = isShared;
1409
1410 if (o.value.IsObject()) {
1411 if (!readMaterialVariant(o.value, variant)) {
1412 return false;
1413 }
1414 }
1415 else {
1416 if (o.value.IsString()) {
1417 variant.value = o.value.GetString();
1418 }
1419 else if (o.value.IsBool()) {
1420 variant.value = o.value.GetBool() ? "true" : "false";
1421 }
1422 else {
1423 LOG_ERROR(logger, "readMaterialVariants: Variant %s value is neither object, string nor bool.", variant.name.c_str());
1424 return false;
1425 }
1426 variant.valueOnly = true;
1427 }
1428 }
1429 return true;
1430}
1431
1432bool Cogs::Core::parseMaterial(Context * context, const StringView & path, MaterialDefinition & definition)
1433{
1434 Document document = parseJson(context, path, JsonParseFlags::None);
1435
1436 if (!document.IsObject()) {
1437 LOG_ERROR(logger, "Cannot read invalid material.");
1438 return false;
1439 }
1440
1441 bool isDefined = false;
1442 for (auto & m : document.GetObject()) {
1443 auto & jsonValue = m.value;
1444
1445 switch (toView(m.name).hash())
1446 {
1447 case Cogs::hash("Material"):
1448 if (isDefined) {
1449 LOG_ERROR(logger, "Material already defined.");
1450 return false;
1451 }
1452 isDefined = true;
1453
1454 if (!readMaterialMetadata(context, jsonValue, definition)) return false;
1455
1456 if (!definition.permutations.empty()) {
1457 if (!readMaterialEffect(jsonValue, definition.effect)) return false;
1458 }
1459 else {
1460 definition.permutations.emplace_back();
1461 MaterialDefinition& p = definition.permutations.back();
1462 p.name = definition.name;
1463 if (!readMaterialEffect(jsonValue, p.effect)) return false;
1464 }
1465 break;
1466
1467 case Cogs::hash("MaterialTemplate"):
1468 if (isDefined) {
1469 LOG_ERROR(logger, "Material already defined.");
1470 return false;
1471 }
1472 isDefined = true;
1473
1474 if (!readMaterialMetadata(context, jsonValue, definition)) return false;
1475 if (!readMaterialEffect(jsonValue, definition.effect)) return false;
1476 definition.flags |= MaterialDefinitionFlags::IsTemplate;
1477 break;
1478 }
1479 }
1480
1481 if (!isDefined) {
1482 LOG_ERROR(logger, "No material or material template defined.");
1483 return false;
1484 }
1485
1486 if (!applyParent(context, definition)) return false;
1487 orderInterfaces(definition);
1488
1489 context->materialDefinitionManager->add(MaterialDefinition(definition));
1490
1491 return true;
1492}
1493
1494bool Cogs::Core::inheritMaterialVariants(std::vector<ShaderVariantDefinition> & definitionVariants,
1495 std::span<const ShaderVariantDefinition> sourceVariants,
1496 const Cogs::StringView& definitionName,
1497 const Cogs::StringView& sourceName,
1498 bool errorOnExisting)
1499{
1500 if (!sourceVariants.empty()) {
1501 std::vector<ShaderVariantDefinition> oldVariants = std::move(definitionVariants);
1502
1503 definitionVariants.assign(sourceVariants.begin(), sourceVariants.end());
1504 for (ShaderVariantDefinition& newVariant : definitionVariants) {
1505 // Record inheritance level
1506 for (auto& member : newVariant.vertexInterface.members) { member.inheritanceLevel += 2; }
1507 for (auto& member : newVariant.geometryInterface.members) { member.inheritanceLevel += 2; }
1508 for (auto& member : newVariant.surfaceInterface.members) { member.inheritanceLevel += 2; }
1509 }
1510
1511 for (ShaderVariantDefinition& variant : oldVariants) {
1512
1513 if (variant.valueOnly) {
1514 bool found = false;
1515 for (ShaderVariantDefinition& inheritedVariant : definitionVariants) {
1516 if (variant.name == inheritedVariant.name) {
1517 if (inheritedVariant.type == ShaderVariantType::Enum) {
1518 for (auto& v : inheritedVariant.values) {
1519 if (v.key == variant.value) {
1520 inheritedVariant.defaultValue = static_cast<int>(v.index);
1521 found = true;
1522 break;
1523 }
1524 }
1525 }
1526 else if (inheritedVariant.type == ShaderVariantType::Bool) {
1527 found = true;
1528 inheritedVariant.defaultValue = parseBool(variant.value);
1529 }
1530
1531 if (!found) {
1532 LOG_ERROR(logger, "Variant '%s' set from derived '%.*s', but enum '%s' invalid.", variant.name.c_str(), StringViewFormat(definitionName), variant.value.c_str());
1533 return false;
1534 }
1535
1536 break;
1537 }
1538 }
1539
1540 if (!found) {
1541 LOG_ERROR(logger, "Variant '%s' set from derived but no matching variant found in base '%.*s'",
1542 variant.name.c_str(),
1543 StringViewFormat(sourceName));
1544 return false;
1545 }
1546 }
1547 else {
1548 bool found = false;
1549 for (auto& v : definitionVariants) {
1550 if (variant.name == v.name) {
1551 found = true;
1552
1553 if (errorOnExisting) {
1554 LOG_ERROR(logger, "Variant '%s' already exists in '%.*s'", variant.name.c_str(), StringViewFormat(definitionName));
1555 return false;
1556 }
1557 }
1558 }
1559
1560 if (!found) {
1561 definitionVariants.emplace_back(std::move(variant));
1562 definitionVariants.back().index = definitionVariants.size() - 1;
1563 }
1564 }
1565 }
1566 }
1567 return true;
1568}
Cogs::Core::Context
A Context instance contains all the services, systems and runtime components needed to use Cogs.
Definition: Context.h:83
Cogs::Core::Context::renderer
class IRenderer * renderer
Renderer.
Definition: Context.h:228
Cogs::Core::IRenderer::getDevice
virtual IGraphicsDevice * getDevice()=0
Get the graphics device used by the renderer.
Cogs::Core::IRenderer::getEnginePermutations
virtual EnginePermutations & getEnginePermutations()=0
Get the reference to the EnginePermutations structure.
Cogs::IGraphicsDevice::getType
virtual GraphicsDeviceType getType() const
Get the type of the graphics device.
Definition: IGraphicsDevice.h:234
Cogs::Logging::Log
Log implementation class.
Definition: LogManager.h:139
Cogs::StringView
Provides a weakly referenced view over the contents of a string.
Definition: StringView.h:24
Cogs::StringView::size
constexpr size_t size() const noexcept
Get the size of the string.
Definition: StringView.h:178
Cogs::StringView::substr
constexpr StringView substr(size_t offset, size_t count=NoPosition) const noexcept
Get the given sub string.
Definition: StringView.h:258
Cogs::StringView::hashLowercase
size_t hashLowercase(size_t hashValue=Cogs::hash()) const noexcept
Get the hash code of the string converted to lowercase.
Definition: StringView.cpp:13
Cogs::StringView::NoPosition
static constexpr size_t NoPosition
No position.
Definition: StringView.h:43
Cogs::StringView::find
size_t find(const StringView &other, size_t offset=0) const noexcept
Find the given string segment inside the string.
Definition: StringView.cpp:18
Cogs::StringView::to_string
std::string to_string() const
String conversion method.
Definition: StringView.cpp:9
Cogs::StringView::hash
constexpr size_t hash() const noexcept
Get the hash code of the string.
Definition: StringView.h:200
Cogs::Core
Contains the Engine, Renderer, resource managers and other systems needed to run Cogs....
Definition: ComponentFunctions.h:10
Cogs::Core::RenderMode::Normal
@ Normal
Regular shaded rendering.
Cogs::Core::TextureDimensions
TextureDimensions
Texture dimensions.
Definition: MaterialProperty.h:84
Cogs::Core::MaterialDataType
MaterialDataType
Defines available data types for material properties.
Definition: MaterialTypes.h:20
Cogs::Core::PotreeColoring::Color
@ Color
Use color property from point set if present, fallback to basecolor.
Cogs::Logging::getLogger
constexpr Log getLogger(const char(&name)[LEN]) noexcept
Definition: LogManager.h:180
Cogs
Contains all Cogs related functionality.
Definition: FieldSetter.h:23
Cogs::GraphicsDeviceType
GraphicsDeviceType
Contains types of graphics devices that may be supported.
Definition: Base.h:48
Cogs::GraphicsDeviceType::Direct3D12
@ Direct3D12
Graphics device using the Direct3D 12 API.
Cogs::GraphicsDeviceType::OpenGLES30
@ OpenGLES30
Graphics device using the OpenGLES 3.0 API.
Cogs::GraphicsDeviceType::Vulkan
@ Vulkan
Graphics device using the Vulkan API.
Cogs::GraphicsDeviceType::Direct3D11
@ Direct3D11
Graphics device using the Direct3D 11 API.
Cogs::GraphicsDeviceType::OpenGL20
@ OpenGL20
Graphics device using OpenGL, supporting at least OpenGL 2.0.
Cogs::GraphicsDeviceType::WebGPU
@ WebGPU
Graphics device using the WebGPU API Backend.
Cogs::hash
constexpr size_t hash() noexcept
Simple getter function that returns the initial value for fnv1a hashing.
Definition: HashFunctions.h:62
Cogs::hashLowercase
COGSFOUNDATION_API size_t hashLowercase(std::string_view str, size_t hashValue=Cogs::hash()) noexcept
Get the hash code of the string converted to lowercase.
Definition: HashFunctions.cpp:57
Cogs::PreprocessorDefinition
std::pair< std::string, std::string > PreprocessorDefinition
Preprocessor definition.
Definition: IEffects.h:10
Cogs::Core::EffectDefinition
Defines a loadable effect.
Definition: EffectDefinition.h:87
Cogs::Core::EffectDefinition::definitions
PreprocessorDefinitions definitions
Preprocessor definitions.
Definition: EffectDefinition.h:112
Generated by doxygen 1.9.6