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 TextureDimensions dimensions = TextureDimensions::Texture2D;
331 switch (code) {
332 case Cogs::hash("Texture1D"): dimensions = TextureDimensions::Texture2D; break;
333 case Cogs::hash("Texture2D"): dimensions = TextureDimensions::Texture2D; break;
334 case Cogs::hash("Texture2DArray"): dimensions = TextureDimensions::Texture2DArray; break;
335 case Cogs::hash("Texture3D"): dimensions = TextureDimensions::Texture3D; break;
336 case Cogs::hash("TextureCube"): dimensions = TextureDimensions::TexureCube; break;
337 default:
338 LOG_ERROR(logger, "Unsupported property type '%s'", propertyType.c_str());
339 return false;
340 }
341 materialProperties.textures.emplace_back(MaterialTextureDefinition{
342 .name = propertyName,
343 .precision = MaterialTypePrecision::Default,
344 .isPerInstance = !isShared,
345 .isSrgb = false,
346 .isArray = is_array,
347 .arraySize = arr_size,
348 .dimensions = dimensions
349 });
350
351 if (value.IsArray()) {
352
353 MaterialTextureDefinition& textureDefinition = materialProperties.textures.back();
354 for (const auto& item : value.GetArray()) {
355 if (!item.IsString()) {
356 LOG_WARNING(logger, "Non-string texture options encountered.");
357 continue;
358 }
359
360 switch (Cogs::hashLowercase(item.GetString())) {
361
362 // Texture dimension already handled, just skip
363 case Cogs::hash("texture1d"): [[fallthrough]];
364 case Cogs::hash("texture2d"): [[fallthrough]];
365 case Cogs::hash("texture2darray"): [[fallthrough]];
366 case Cogs::hash("texture3d"): [[fallthrough]];
367 case Cogs::hash("texturecube"):
368 continue;
369
370 // Enable sRGB
371 case Cogs::hash("srgb"):
372 textureDefinition.isSrgb = true;
373 break;
374
375 // OpenGL ES precision specifiers
376 case Cogs::hash("lowp"):
377 textureDefinition.precision = MaterialTypePrecision::Low;
378 break;
379 case Cogs::hash("mediump"):
380 textureDefinition.precision = MaterialTypePrecision::Medium;
381 break;
382 case Cogs::hash("highp"):
383 textureDefinition.precision = MaterialTypePrecision::High;
384 break;
385
386 // Optional specification of texture format
387 case Cogs::hash("float"):
388 textureDefinition.format = MaterialDataType::Float;
389 break;
390 case Cogs::hash("float2"):
391 textureDefinition.format = MaterialDataType::Float2;
392 break;
393 case Cogs::hash("float3"):
394 textureDefinition.format = MaterialDataType::Float3;
395 break;
396 case Cogs::hash("float4"):
397 textureDefinition.format = MaterialDataType::Float4;
398 break;
399 case Cogs::hash("int"):
400 textureDefinition.format = MaterialDataType::Int;
401 break;
402 case Cogs::hash("int2"):
403 textureDefinition.format = MaterialDataType::Int2;
404 break;
405 case Cogs::hash("int3"):
406 textureDefinition.format = MaterialDataType::Int3;
407 break;
408 case Cogs::hash("int4"):
409 textureDefinition.format = MaterialDataType::Int4;
410 break;
411 case Cogs::hash("uint"):
412 textureDefinition.format = MaterialDataType::UInt;
413 break;
414 case Cogs::hash("uint2"):
415 textureDefinition.format = MaterialDataType::UInt2;
416 break;
417 case Cogs::hash("uint3"):
418 textureDefinition.format = MaterialDataType::UInt3;
419 break;
420 case Cogs::hash("uint4"):
421 textureDefinition.format = MaterialDataType::UInt4;
422 break;
423
424 default:
425 LOG_WARNING(logger, "Unrecognized texture option '%s' encountered.", item.GetString());
426 break;
427 }
428 }
429 }
430
431 return true;
432 }
433
434 [[nodiscard]] bool parseInterpolationModifier(const Value& jsonObject, ShaderInterfaceMemberDefinition& memberDefinition)
435 {
436 if (!jsonObject.IsString()) {
437 LOG_ERROR(logger, "Interpolation modifier is not a JSON string");
438 return false;
439 }
440
441 Cogs::StringView value = toView(jsonObject);
442 switch (value.hash()) {
443 case Cogs::hash("linear"):
444 memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::LinearModifier);
445 break;
446 case Cogs::hash("centroid"):
447 memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::CentroidModifier);
448 break;
449 case Cogs::hash("nointerpolation"):
450 memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::NointerpolationModifier);
451 break;
452 case Cogs::hash("noperspective"):
453 memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::NoperspectiveModifier);
454 break;
455 case Cogs::hash("sample"):
456 memberDefinition.modifiers = static_cast<ShaderInterfaceMemberDefinition::InterpolationModifiers>(memberDefinition.modifiers | ShaderInterfaceMemberDefinition::SampleModifier);
457 break;
458 default:
459 LOG_ERROR(logger, "Unrecognized interpolation modifier '%.*s'", StringViewFormat(value));
460 return false;
461 }
462 return true;
463 }
464
465 [[nodiscard]] bool addVariantFlag(Cogs::Core::ShaderVarientFlags& flags, const Cogs::StringView& name)
466 {
467 switch (name.hash()) {
468 case Cogs::hash("DepthOnly"): flags |= ShaderVarientFlags::DepthOnly; break;
469 case Cogs::hash("NoShading"): flags |= ShaderVarientFlags::NoShading; break;
470 case Cogs::hash("ReverseDepth"): flags |= ShaderVarientFlags::ReverseDepth; break;
471 default:
472 LOG_ERROR(logger, "Unrecognized variant flag '%.*s'", StringViewFormat(name));
473 return false;
474 }
475 return true;
476 }
477
478 [[nodiscard]] bool parseShaderInterface(const Value& jsonObject, ShaderInterfaceDefinition& interfaceDefinition, uint8_t inheritanceLevel, bool allowFormat)
479 {
480 if (!jsonObject.IsObject()) {
481 LOG_ERROR(logger, "Shader interface is not an JSON object");
482 return false;
483 }
484
485 for (auto& m : jsonObject.GetObject()) {
486 Cogs::StringView name = toView(m.name);
487 auto& obj = m.value;
488
489 ShaderInterfaceMemberDefinition value;
490
491 if (obj.IsArray()) {
492 auto arr = obj.GetArray();
493
494
495
496 if (!parseType(toKey(arr[0]), value, allowFormat)) return false;
497
498 if (value.dimension == size_t(-1)) {
499 if (arr[1].IsString()) {
500 value.dimensionString = toString(arr[1]);
501 }
502 else {
503 value.dimension = arr[1].GetInt();
504 }
505 }
506 else {
507 if (arr.Size() >= 2) {
508 if (arr[1].IsString()) {
509 value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::None;
510 value.semantic.slot = 0;
511 Cogs::StringView semanticName(arr[1].GetString(), arr[1].GetStringLength());
512
513 // Check for trailing digits, interpreted and chomp semanticName.
514 for (size_t i = 0; i < semanticName.size(); i++) {
515 if ('0' <= semanticName[i] && semanticName[i] <= '9') {
516 value.semantic.slot = semanticName[i] - '0';
517 size_t k = i + 1;
518 while ((k < semanticName.size()) &&
519 ('0' <= semanticName[k]) &&
520 (semanticName[k] <= '9'))
521 {
522 value.semantic.slot = uint8_t(10u * value.semantic.slot + (semanticName[k] - '0'));
523 }
524 semanticName = semanticName.substr(0, i);
525 break;
526 }
527 }
528 switch (semanticName.hashLowercase()) {
529 case Cogs::hash("position"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Position; break;
530 case Cogs::hash("normal"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Normal; break;
531 case Cogs::hash("color"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Color; break;
532 case Cogs::hash("texcoord"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Texcoord; break;
533 case Cogs::hash("tangent"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::Tangent; break;
534 case Cogs::hash("instancevector"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::InstanceVector; break;
535 case Cogs::hash("instancematrix"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::InstanceMatrix; break;
536 case Cogs::hash("sv_position"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_Position; break;
537 case Cogs::hash("sv_vertexid"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_VertexID; break;
538 case Cogs::hash("sv_instanceid"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_InstanceID; break;
539 case Cogs::hash("sv_clipdistance"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_ClipDistance; break;
540 case Cogs::hash("sv_vface"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_VFace; break;
541 case Cogs::hash("sv_isfrontface"): value.semantic.name = ShaderInterfaceMemberDefinition::SemanticName::SV_IsFrontFace; break;
542 default:
543 LOG_ERROR(logger, "Unrecognized semantic '%.*s'", StringViewFormat(semanticName));
544 return false;
545 }
546 }
547 else {
548 LOG_ERROR(logger, "Semantic is not a string");
549 return false;
550 }
551 }
552
553 if (arr.Size() >= 3) {
554 auto& modifiers = arr[2];
555 if (modifiers.IsString()) {
556 if (!parseInterpolationModifier(modifiers, value)) return false;
557 }
558 else if (modifiers.IsArray()) {
559 for (auto& modifier : modifiers.GetArray()) {
560 if (!parseInterpolationModifier(modifier, value)) return false;
561 }
562 }
563 }
564 }
565 }
566 else if (obj.IsString()) {
567 if (!parseType(toKey(obj), value, allowFormat)) return false;
568 }
569
570 value.name = name.to_string();
571 value.inheritanceLevel = inheritanceLevel;
572
573 interfaceDefinition.members.push_back(value);
574 }
575
576 return true;
577 }
578
579 [[nodiscard]] bool parseRequiresStatement(const Value& requiresStatement, std::vector<ShaderVariantRequirement>& requirements, const Cogs::StringView& name)
580 {
581 if (requiresStatement.IsString()) {
582 requirements.push_back(ShaderVariantRequirement{ toString(requiresStatement), {} });
583 }
584 else if (requiresStatement.IsArray()) {
585 for (auto& item : requiresStatement.GetArray()) {
586 if (item.IsString()) {
587 requirements.push_back(ShaderVariantRequirement{ toString(item), {} });
588 }
589 else {
590 LOG_ERROR(logger, "Material %.*s has non-string element in requires array.", StringViewFormat(name));
591 return false;
592 }
593 }
594 }
595 else if (requiresStatement.IsObject()) {
596 for (auto& item : requiresStatement.GetObject()) {
597 if (item.value.IsString()) {
598 requirements.push_back(ShaderVariantRequirement{ toString(item.name), toString(item.value) });
599 }
600 else {
601 LOG_ERROR(logger, "Material %.*s has non-string value in requires object.", StringViewFormat(name));
602 return false;
603 }
604 }
605 }
606 else {
607 LOG_ERROR(logger, "Material %.*s has unexpected value in requires object.", StringViewFormat(name));
608 return false;
609 }
610 return true;
611 }
612
613 [[nodiscard]] bool parseTriggersStatement(const Value& triggersStatement, ShaderVariantDefinition& variant)
614 {
615 if (triggersStatement.IsString()) {
616 variant.triggers.push_back(ShaderVariantRequirement{ toString(triggersStatement), {} });
617 }
618 else if (triggersStatement.IsArray()) {
619 for (auto& item : triggersStatement.GetArray()) {
620 if (item.IsString()) {
621 variant.triggers.push_back(ShaderVariantRequirement{ toString(item), {} });
622 }
623 else {
624 LOG_ERROR(logger, "Material variant %s has non-string element in triggers array.", variant.name.c_str());
625 return false;
626 }
627 }
628 }
629 else if (triggersStatement.IsObject()) {
630 for (auto& item : triggersStatement.GetObject()) {
631 if (item.value.IsString()) {
632 variant.triggers.push_back(ShaderVariantRequirement{ toString(item.name), toString(item.value) });
633 }
634 else {
635 LOG_ERROR(logger, "Material variant %s has non-string value in triggers object.", variant.name.c_str());
636 return false;
637 }
638 }
639 }
640 else {
641 LOG_ERROR(logger, "Material variant %s has unexpected value in triggers object.", variant.name.c_str());
642 return false;
643 }
644 return true;
645 }
646
647 [[nodiscard]] bool parseDefaultValueStatement(const Value& defaultValue, ShaderVariantDefinition& variant)
648 {
649 switch (variant.type) {
650
651 case ShaderVariantType::Bool:
652 if (!defaultValue.IsBool()) {
653 LOG_ERROR(logger, "Variant %s defaultValue property is not a bool", variant.name.c_str());
654 return false;
655 }
656 variant.defaultValue = defaultValue.GetBool();
657 break;
658
659 case ShaderVariantType::Int:
660 if (!defaultValue.IsInt()) {
661 LOG_ERROR(logger, "Variant %s defaultValue property is not an int", variant.name.c_str());
662 return false;
663 }
664 variant.defaultValue = defaultValue.GetInt();
665 break;
666
667 case ShaderVariantType::Enum:
668 if (!defaultValue.IsString()) {
669 LOG_ERROR(logger, "Variant %s defaultValue property is not a string", variant.name.c_str());
670 return false;
671 }
672 else {
673 Cogs::StringView val = toView(defaultValue);
674 for (size_t i = 0; i < variant.values.size(); ++i) {
675 if (variant.values[i].key == val) {
676 variant.defaultValue = static_cast<int>(i);
677 goto found;
678 }
679 }
680 LOG_ERROR(logger, "Variant %s defaultValue '%.*s' is not a valid enum value", variant.name.c_str(), StringViewFormat(val));
681 return false;
682 found:
683 ;
684 }
685 break;
686
687 case ShaderVariantType::Format:
688 if (!defaultValue.IsString()) {
689 LOG_ERROR(logger, "Variant %s defaultValue property is not a string", variant.name.c_str());
690 return false;
691 }
692 else {
693 Cogs::StringView value_ = toView(defaultValue);
694 Cogs::DataFormat parsedValue = Cogs::parseDataFormat(value_);
695 if (parsedValue == Cogs::DataFormat::Unknown) {
696 LOG_ERROR(logger, "Failed to parse format '%.*s'", StringViewFormat(value_));
697 return false;
698 }
699 variant.defaultValue = size_t(parsedValue);
700 }
701 break;
702 case ShaderVariantType::String:
703 if (!defaultValue.IsString()) {
704 LOG_ERROR(logger, "Variant %s defaultValue property is not a string", variant.name.c_str());
705 return false;
706 }
707 variant.defaultString = toString(defaultValue);
708 break;
709 default:
710 assert(false);
711 }
712
713 return true;
714 }
715
716 [[nodiscard]] bool readMaterialVariant(const Value& variantObject, ShaderVariantDefinition& variant)
717 {
718 auto it = variantObject.FindMember("type");
719 if (it == variantObject.MemberEnd()) {
720 LOG_ERROR(logger, "Material variant %s missing type.", variant.name.c_str());
721 return false;
722 }
723
724 bool acceptValueString = false;
725 bool acceptValues = false;
726 bool acceptRequires = false;
727 bool acceptTriggers = false;
728 Cogs::StringView type = toView(it->value);
729 switch (type.hash()) {
730 case Cogs::hash("bool"):
731 variant.type = ShaderVariantType::Bool;
732 variant.defaultValue = 0;
733 acceptValueString = true;
734 acceptRequires = true;
735 acceptTriggers = true;
736 break;
737
738 case Cogs::hash("int"):
739 variant.type = ShaderVariantType::Int;
740 variant.defaultValue = 0;
741 acceptValueString = true;
742 break;
743
744 case Cogs::hash("format"):
745 variant.type = ShaderVariantType::Format;
746 variant.defaultValue = 0;
747 acceptValueString = true;
748 break;
749
750 case Cogs::hash("enum"):
751 variant.type = ShaderVariantType::Enum;
752 acceptValues = true;
753 break;
754
755 case Cogs::hash("string"):
756 variant.type = ShaderVariantType::String;
757 variant.defaultValue = -1;
758 acceptValueString = true;
759 break;
760
761 default:
762 LOG_ERROR(logger, "Unknown variant type %.*s.", StringViewFormat(type));
763 return false;
764 }
765
766 bool hasValueString = false;
767 variant.flags = ShaderVarientFlags::None;
768 for (auto& variantItem : variantObject.GetObject()) {
769 Cogs::StringView keyword = toView(variantItem.name);
770 switch (keyword.hashLowercase()) {
771
772 case Cogs::hash("type"): break;
773
774 case Cogs::hash("defaultvalue"):
775 if (!parseDefaultValueStatement(variantItem.value, variant)) return false;
776 break;
777
778 case Cogs::hash("value"):
779 if (!acceptValueString) {
780 LOG_ERROR(logger, "Variant type does not support value keyword");
781 return false;
782 }
783 if (!variantItem.value.IsString()) {
784 LOG_ERROR(logger, "Variant value is not a string");
785 return false;
786 }
787 variant.value = toString(variantItem.value);
788 hasValueString = true;
789 break;
790
791 case Cogs::hash("values"):
792 if (!acceptValues) {
793 LOG_ERROR(logger, "Variant type does not support value keyword");
794 return false;
795 }
796 for (auto& v : variantItem.value.GetObject()) {
797 if (!v.value.IsString()) {
798 LOG_ERROR(logger, "Variant %s values contains a non-string item", variant.name.c_str());
799 return false;
800 }
801 variant.values.emplace_back(ShaderVariantEnum{ variant.values.size(), toString(v.name), toString(v.value) });
802 }
803 break;
804
805 case Cogs::hash("require"):
806 case Cogs::hash("requires"):
807 if (!acceptRequires) {
808 LOG_ERROR(logger, "Variant type does not support requires keyword");
809 return false;
810 }
811 if (!parseRequiresStatement(variantItem.value, variant.requirements, variant.name)) return false;
812 break;
813 case Cogs::hash("trigger"):
814 case Cogs::hash("triggers"):
815 if (!acceptTriggers) {
816 LOG_ERROR(logger, "Variant type does not support triggers keyword");
817 return false;
818 }
819 if (!parseTriggersStatement(variantItem.value, variant)) return false;
820 break;
821 case Cogs::hash("vertexinterface"):
822 if (!parseShaderInterface(variantItem.value, variant.vertexInterface, 0, variant.type == ShaderVariantType::Format)) return false;
823 break;
824 case Cogs::hash("geometryinterface"):
825 if (!parseShaderInterface(variantItem.value, variant.geometryInterface, 0, false)) return false;
826 break;
827 case Cogs::hash("surfaceinterface"):
828 if (!parseShaderInterface(variantItem.value, variant.surfaceInterface, 0, false)) return false;
829 break;
830 case Cogs::hash("flags"):
831 if (variantItem.value.IsString()) {
832 if (!addVariantFlag(variant.flags, toView(variantItem.value))) return false;
833 }
834 else if (variantItem.value.IsArray()) {
835 for (auto& element : variantItem.value.GetArray()) {
836 if (!element.IsString()) {
837 LOG_ERROR(logger, "Variant flag is not a string");
838 return false;
839 }
840 if (!addVariantFlag(variant.flags, toView(element))) return false;
841 }
842 }
843 else {
844 LOG_ERROR(logger, "Variant flag is neither string nor array");
845 return false;
846 }
847 break;
848 default:
849 LOG_ERROR(logger, "Unexpected variant keyword %.*s", StringViewFormat(keyword));
850 break;
851 }
852 }
853
854 switch (variant.type) {
855 case ShaderVariantType::Bool:
856 case ShaderVariantType::Int:
857 case ShaderVariantType::Format:
858 case ShaderVariantType::String:
859 if (!hasValueString) {
860 LOG_ERROR(logger, "Variant is missing value keyword");
861 return false;
862 }
863 break;
864 case ShaderVariantType::Enum:
865 if (variant.values.empty()) {
866 LOG_ERROR(logger, "Variant enum type has no values");
867 return false;
868 }
869 break;
870 default:
871 assert(false);
872 }
873
874 return true;
875 }
876
877 [[nodiscard]] bool readMaterialOptions(const Value& jsonMaterialOptions, MaterialDefinition& materialDefinition)
878 {
879 if (jsonMaterialOptions.IsObject()) {
880 for (auto& o : jsonMaterialOptions.GetObject()) {
881 if (o.value.IsString()) {
882 materialDefinition.options[toString(o.name)] = toString(o.value);
883 }
884 else {
885 LOG_ERROR(logger, "readMaterialOptions: Item value is not a JSON string");
886 return false;
887 }
888 }
889 return true;
890 }
891 else {
892 LOG_ERROR(logger, "readMaterialOptions: value is not a JSON object");
893 return false;
894 }
895 }
896
897 [[nodiscard]] bool matchGraphicsType(bool& include, Cogs::GraphicsDeviceType deviceType, const Value& jsonDeviceType)
898 {
899 if (!jsonDeviceType.IsString()) {
900 LOG_ERROR(logger, "matchGraphicsType: device type is not a JSON string");
901 return false;
902 }
903
904 switch (toView(jsonDeviceType).hash())
905 {
906 case Cogs::hash("D3D11"):
907 case Cogs::hash("Direct3D11"):
908 include = include || (deviceType == Cogs::GraphicsDeviceType::Direct3D11);
909 return true;
910 case Cogs::hash("D3D12"):
911 case Cogs::hash("Direct3D12"):
912 include = include || (deviceType == Cogs::GraphicsDeviceType::Direct3D12);
913 return true;
914 case Cogs::hash("Vulkan"):
915 include = include || (deviceType == Cogs::GraphicsDeviceType::Vulkan);
916 return true;
917 case Cogs::hash("GL20"):
918 case Cogs::hash("OpenGL20"):
919 include = include || (deviceType == Cogs::GraphicsDeviceType::OpenGL20);
920 return true;
921 case Cogs::hash("ES30"):
922 case Cogs::hash("OpenGLES30"):
923 include = include || (deviceType == Cogs::GraphicsDeviceType::OpenGLES30);
924 return true;
925 case Cogs::hash("WebGPU"):
926 include = include || (deviceType == Cogs::GraphicsDeviceType::WebGPU);
927 return true;
928 default:
929 LOG_ERROR(logger, "matchGraphicsType: Unknown device type \"%s\"", jsonDeviceType.GetString());
930 break;
931 }
932 return false;
933 }
934
935 [[nodiscard]] bool readShaderDefinition(const Value& jsonObject, ShaderDefinition& shaderDefinition)
936 {
937 if (!jsonObject.IsObject()) {
938 LOG_ERROR(logger, "readShaderDefinition: value is not a JSON object");
939 return false;
940 }
941 for (auto& m : jsonObject.GetObject()) {
942 Cogs::StringView key = toView(m.name);
943 switch (key.hash()) {
944 case Cogs::hash("entryPoint"):
945 shaderDefinition.entryPoint = toString(m.value);
946 break;
947 case Cogs::hash("file"):
948 shaderDefinition.customSourcePath = toString(m.value);
949 break;
950 case Cogs::hash("attributes"):
951 if (m.value.IsObject()) {
952 for (auto& a : m.value.GetObject()) {
953 shaderDefinition.attributes.emplace_back(AttributeDefinition{ toString(a.name), toString(a.value) });
954 }
955 }
956 else {
957 LOG_ERROR(logger, "readShaderDefinition: attributes value is not a JSON array");
958 return false;
959 }
960 break;
961 default:
962 LOG_ERROR(logger, "readShaderDefinition: Unrecognized key '%.*s'", StringViewFormat(key));
963 return false;
964 }
965 }
966 return true;
967 }
968
969 [[nodiscard]] bool readMaterialMetadata(Context* context, const Value& jsonMaterial, MaterialDefinition& materialDefinition);
970
971 [[nodiscard]] bool readMaterialEffect(const Value& jsonMaterial, EffectDefinition& effectDefinition);
972
973 [[nodiscard]] bool readPermutation(Context* context, bool& included, Cogs::GraphicsDeviceType deviceType, const Value& jsonPermuation, MaterialDefinition& materialDefinition, const std::string& permutationName)
974 {
975 included = false;
976 if (!jsonPermuation.IsObject()) {
977 LOG_ERROR(logger, "readPermutation: %s/%s: Permutation is not an JSON object", materialDefinition.name.c_str(), permutationName.c_str());
978 return false;
979 }
980 if (jsonPermuation.HasMember("devices")) {
981 auto& jsonDeviceType = jsonPermuation["devices"];
982 bool include = false;
983 if (jsonDeviceType.IsString()) {
984
985 if (!matchGraphicsType(include, deviceType, jsonDeviceType)) return false;
986 }
987 else if (jsonDeviceType.IsArray()) {
988 include = false;
989 for (auto& item : jsonDeviceType.GetArray()) {
990 if (!item.IsString()) {
991 LOG_ERROR(logger, "readPermuation: %s/%s: Devices array item is not a JSON string", materialDefinition.name.c_str(), permutationName.c_str());
992 return false;
993 }
994 if (!matchGraphicsType(include, deviceType, item)) return false;
995 }
996 }
997 else {
998 LOG_ERROR(logger, "readPermuation: %s@%s: Devices are neither JSON string nor array", materialDefinition.name.c_str(), permutationName.c_str());
999 return false;
1000 }
1001 if (!include) {
1002 included = false;
1003 return true;
1004 }
1005 }
1006
1007 static int matId = 0;
1008
1009 materialDefinition.permutations.emplace_back();
1010 MaterialDefinition& permutationDefinition = materialDefinition.permutations.back();
1011 permutationDefinition.name = materialDefinition.name + std::to_string(matId++) + permutationName;
1012 permutationDefinition.permutationIndex = materialDefinition.permutations.size() - 1;
1013 permutationDefinition.permutationName = permutationName;
1014
1015 if (!readMaterialMetadata(context, jsonPermuation, permutationDefinition)) return false;
1016 if (!readMaterialEffect(jsonPermuation, permutationDefinition.effect)) return false;
1017
1018 included = true;
1019 return true;
1020 }
1021
1022 [[nodiscard]] bool readMaterialMetadata(Context* context, const Value& jsonMaterial, MaterialDefinition& materialDefinition)
1023 {
1024 if (!jsonMaterial.IsObject()) {
1025 LOG_ERROR(logger, "readMaterialMetadata: Material is not an JSON object");
1026 return false;
1027 }
1028
1029 for (auto& m : jsonMaterial.GetObject()) {
1030
1031 Cogs::StringView memberKey = toView(m.name);
1032 switch (memberKey.hash()) {
1033
1034 case Cogs::hash("name"):
1035 if (m.value.IsString()) {
1036 materialDefinition.name = toString(m.value);
1037 if (traceParsing) LOG_DEBUG(logger, "Found new material definition %s.", materialDefinition.name.c_str());
1038 }
1039 else {
1040 LOG_ERROR(logger, "readMaterialMetadata: Material name value is not an JSON string");
1041 }
1042 break;
1043
1044 case Cogs::hash("flags"):
1045 if (m.value.IsString()) {
1046 Cogs::StringView flagsString = toView(m.value);
1047 LOG_WARNING(logger, "readMaterialMetadata: %s: Unrecognized flag '%.*s'", materialDefinition.name.c_str(), StringViewFormat(flagsString));
1048 }
1049 else {
1050 LOG_ERROR(logger, "readMaterialMetadata: %s: Material flags value is not an JSON string", materialDefinition.name.c_str());
1051 }
1052 break;
1053
1054 case Cogs::hash("inherits"):
1055 if (m.value.IsString()) {
1056 materialDefinition.inherits = toString(m.value);
1057 if (traceParsing) LOG_DEBUG(logger, "Found material base type %s.", materialDefinition.inherits.c_str());
1058 }
1059 else {
1060 LOG_ERROR(logger, "readMaterialMetadata: %s: Material inherits value is not an JSON string", materialDefinition.name.c_str());
1061 }
1062 break;
1063
1064 case Cogs::hash("require"):
1065 case Cogs::hash("requires"):
1066 if (!parseRequiresStatement(m.value, materialDefinition.requirements, materialDefinition.name)) return false;
1067 break;
1068
1069 case Cogs::hash("variants"):
1070 if (traceParsing) LOG_DEBUG(logger, "Found material variants.");
1071 if (!readMaterialVariants(context, m.value, materialDefinition.variants, false)) return false;
1072 break;
1073
1074 case Cogs::hash("sharedVariants"):
1075 if (traceParsing) LOG_DEBUG(logger, "Found material variants.");
1076 if (!readMaterialVariants(context, m.value, materialDefinition.variants, true)) return false;
1077 break;
1078
1079 case Cogs::hash("options"):
1080 if (traceParsing) LOG_DEBUG(logger, "Found material options.");
1081 if (!readMaterialOptions(m.value, materialDefinition)) return false;
1082 break;
1083
1084 case Cogs::hash("properties"):
1085 if (traceParsing) LOG_DEBUG(logger, "Found material properties.");
1086 if (!readMaterialProperties(context, m.value, materialDefinition.properties, false)) return false;
1087 break;
1088
1089 case Cogs::hash("sharedProperties"):
1090 if (traceParsing) LOG_DEBUG(logger, "Found shared material properties.");
1091 if (!readMaterialProperties(context, m.value, materialDefinition.properties, true)) return false;
1092 break;
1093
1094 case Cogs::hash("permutations"):
1095 if (traceParsing) LOG_DEBUG(logger, "Found effect permutations.");
1096 if (m.value.IsObject()) {
1097 Cogs::GraphicsDeviceType deviceType = context->renderer->getDevice()->getType();
1098
1099 for (auto& p : m.value.GetObject()) {
1100 auto permutationName = toString(p.name);
1101
1102 if (traceParsing) LOG_DEBUG(logger, "Found effect permutation %s.", permutationName.c_str());
1103
1104 if (p.value.IsArray()) {
1105 for (auto& profile : p.value.GetArray()) {
1106 bool included = false;
1107 if (!readPermutation(context, included, deviceType, profile, materialDefinition, permutationName)) return false;
1108 if (included) break; // Found a device match.
1109 }
1110 }
1111 else {
1112 bool included = false;
1113 if (!readPermutation(context, included, deviceType, p.value, materialDefinition, permutationName)) return false;
1114 }
1115 }
1116 }
1117 else {
1118 LOG_ERROR(logger, "readMaterialMetadata: %s: Material permutations value is not an JSON object", materialDefinition.name.c_str());
1119 return false;
1120 }
1121 break;
1122
1123 case Cogs::hash("enginePermutations"):
1124 if (m.value.IsArray()) {
1125
1126 for (auto& element : m.value.GetArray()) {
1127
1128 if (element.IsString()) {
1129 Cogs::StringView str = toView(element);
1130 const EnginePermutation* enginePermutation = context->renderer->getEnginePermutations().get(str);
1131 if (enginePermutation) {
1132 materialDefinition.enginePermutationMask |= size_t(1) << enginePermutation->getIndex();
1133 }
1134 else {
1135 LOG_ERROR(logger, "readMaterialMetadata: %s: unrecognized engine permutation '%.*s'", materialDefinition.name.c_str(), StringViewFormat(str));
1136 return false;
1137 }
1138 }
1139 else {
1140 LOG_ERROR(logger, "readMaterialMetadata: %s: Material enginePermutations item is not an JSON string", materialDefinition.name.c_str());
1141 return false;
1142 }
1143 }
1144 }
1145 else {
1146 LOG_ERROR(logger, "readMaterialMetadata: %s: Material enginePermutations value is not an JSON array", materialDefinition.name.c_str());
1147 return false;
1148 }
1149 break;
1150
1151 case Cogs::hash("vertexInterface"):
1152 case Cogs::hash("vertexFunction"):
1153 case Cogs::hash("hullInterface"):
1154 case Cogs::hash("hullFunction"):
1155 case Cogs::hash("domainInterface"):
1156 case Cogs::hash("domainFunction"):
1157 case Cogs::hash("geometryInterface"):
1158 case Cogs::hash("geometryFunction"):
1159 case Cogs::hash("surfaceInterface"):
1160 case Cogs::hash("surfaceFunction"):
1161 case Cogs::hash("definitions"):
1162 case Cogs::hash("defines"):
1163 // parsed by readMaterialEffect
1164 break;
1165 case Cogs::hash("devices"):
1166 // parsed by readPermutation
1167 break;
1168
1169 default:
1170 LOG_ERROR(logger, "readMaterialMetadata: %s: Unrecognized key '%.*s'", materialDefinition.name.c_str(), StringViewFormat(memberKey));
1171 return false;
1172 }
1173 }
1174 return true;
1175 }
1176
1177 [[nodiscard]] bool readMaterialEffect(const Value& jsonMaterial, EffectDefinition& effectDefinition)
1178 {
1179 if (!jsonMaterial.IsObject()) {
1180 LOG_ERROR(logger, "readMaterialEffect: Material is not an JSON object");
1181 return false;
1182 }
1183
1184 for (auto& m : jsonMaterial.GetObject()) {
1185
1186 Cogs::StringView memberKey = toView(m.name);
1187 switch (memberKey.hash()) {
1188
1189 case Cogs::hash("vertexInterface"):
1190 if (traceParsing) LOG_DEBUG(logger, "Found vertex interface.");
1191 if (!parseShaderInterface(m.value, effectDefinition.vertexShader.shaderInterface, 1, false)) return false;
1192 break;
1193
1194 case Cogs::hash("vertexFunction"):
1195 if (traceParsing) LOG_DEBUG(logger, "Found vertex function.");
1196 if (!readShaderDefinition(m.value, effectDefinition.vertexShader)) return false;
1197 break;
1198
1199 case Cogs::hash("hullInterface"):
1200 if (traceParsing) LOG_DEBUG(logger, "Found hull interface.");
1201 if (!parseShaderInterface(m.value, effectDefinition.hullShader.shaderInterface, 1, false)) return false;
1202 break;
1203
1204 case Cogs::hash("hullFunction"):
1205 if (traceParsing) LOG_DEBUG(logger, "Found hull function.");
1206 if (!readShaderDefinition(m.value, effectDefinition.hullShader)) return false;
1207 break;
1208
1209 case Cogs::hash("domainInterface"):
1210 if (traceParsing) LOG_DEBUG(logger, "Found domain interface.");
1211 if (!parseShaderInterface(m.value, effectDefinition.domainShader.shaderInterface, 1, false)) return false;
1212 break;
1213
1214 case Cogs::hash("domainFunction"):
1215 if (traceParsing) LOG_DEBUG(logger, "Found domain function.");
1216 if (!readShaderDefinition(m.value, effectDefinition.domainShader)) return false;
1217 break;
1218
1219 case Cogs::hash("geometryInterface"):
1220 if (traceParsing) LOG_DEBUG(logger, "Found geometry interface.");
1221 if (!parseShaderInterface(m.value, effectDefinition.geometryShader.shaderInterface, 1, false)) return false;
1222 break;
1223
1224 case Cogs::hash("geometryFunction"):
1225 if (traceParsing) LOG_DEBUG(logger, "Found geometry function.");
1226 if (!readShaderDefinition(m.value, effectDefinition.geometryShader)) return false;
1227 break;
1228
1229 case Cogs::hash("surfaceInterface"):
1230 if (traceParsing) LOG_DEBUG(logger, "Found surface interface.");
1231 if (!parseShaderInterface(m.value, effectDefinition.pixelShader.shaderInterface, 1, false)) return false;
1232 break;
1233
1234 case Cogs::hash("surfaceFunction"):
1235 if (traceParsing) LOG_DEBUG(logger, "Found surface function.");
1236 if (!readShaderDefinition(m.value, effectDefinition.pixelShader)) return false;
1237 break;
1238
1239 case Cogs::hash("definitions"):
1240 case Cogs::hash("defines"):
1241 if (m.value.IsObject()) {
1242 for (auto& d : m.value.GetObject()) {
1243 if (d.value.IsString()) {
1244 effectDefinition.definitions.push_back(Cogs::PreprocessorDefinition{ toString(d.name), toString(d.value) });
1245 }
1246 else {
1247 LOG_ERROR(logger, "readMaterialEffect: %.*s item %.*s value is not a JSON string", StringViewFormat(memberKey), StringViewFormat(toView(d.name)));
1248 return false;
1249 }
1250 }
1251 }
1252 else {
1253 LOG_ERROR(logger, "readMaterialEffect: %.*s is not a JSON object", StringViewFormat(memberKey));
1254 return false;
1255 }
1256 break;
1257
1258 case Cogs::hash("name"):
1259 case Cogs::hash("flags"):
1260 case Cogs::hash("inherits"):
1261 case Cogs::hash("variants"):
1262 case Cogs::hash("sharedVariants"):
1263 case Cogs::hash("options"):
1264 case Cogs::hash("require"):
1265 case Cogs::hash("requires"):
1266 case Cogs::hash("properties"):
1267 case Cogs::hash("sharedProperties"):
1268 case Cogs::hash("permutations"):
1269 case Cogs::hash("enginePermutations"):
1270 // parsed by readMaterialMetadata
1271 break;
1272 case Cogs::hash("devices"):
1273 // parsed by readPermutation
1274 break;
1275
1276 default:
1277 LOG_ERROR(logger, "readMaterialEffect: Unrecognized key '%.*s'", StringViewFormat(memberKey));
1278 return false;
1279 }
1280 }
1281 return true;
1282 }
1283
1284 void inheritShaderDefinition(const ShaderDefinition& source, ShaderDefinition& definition)
1285 {
1286 // Resolving of conflicts are handled in \ref addShaderStageInterfaceMembersFromVariants in MaterialManager.
1287 for (const ShaderInterfaceMemberDefinition& sourceMember : source.shaderInterface.members) {
1288 definition.shaderInterface.members.emplace_back(sourceMember);
1289 definition.shaderInterface.members.back().inheritanceLevel += 2;
1290 }
1291
1292 if (definition.entryPoint.empty()) {
1293 definition.customSourcePath = source.customSourcePath;
1294 definition.loadPath = source.loadPath;
1295 definition.entryPoint = source.entryPoint;
1296 definition.attributes = source.attributes;
1297 }
1298 }
1299
1300 [[nodiscard]] bool inheritDefinition(const MaterialDefinitionBase& source, MaterialDefinitionBase& definition, bool properties = true)
1301 {
1302 //TODO: Validate fallback status of material definitions.
1303 definition.flags &= source.flags;
1304
1305 if (properties) {
1306 for (auto& buffer : source.properties.buffers) {
1307 definition.properties.buffers.push_back(buffer);
1308 }
1309
1310 for (auto& texture : source.properties.textures) {
1311 definition.properties.textures.push_back(texture);
1312 }
1313 }
1314
1315 definition.requirements.insert(definition.requirements.end(),
1316 source.requirements.begin(),
1317 source.requirements.end());
1318
1319 if (!inheritMaterialVariants(definition.variants, source.variants, definition.name, source.name, properties)) return false;
1320
1321 //auto & effect = definition.effect;
1322 const EffectDefinition& parentEffect = source.effect;
1323
1324 inheritShaderDefinition(parentEffect.vertexShader, definition.effect.vertexShader);
1325 inheritShaderDefinition(parentEffect.hullShader, definition.effect.hullShader);
1326 inheritShaderDefinition(parentEffect.domainShader, definition.effect.domainShader);
1327 inheritShaderDefinition(parentEffect.geometryShader, definition.effect.geometryShader);
1328 inheritShaderDefinition(parentEffect.pixelShader, definition.effect.pixelShader);
1329
1330 return true;
1331 }
1332
1333 void orderInterfaces(MaterialDefinitionBase& definition)
1334 {
1335 for (auto& buffer : definition.properties.buffers) {
1336 std::sort(buffer.values.begin(), buffer.values.end(), [](const auto& a, const auto& b)
1337 {
1338 return DataTypeSizes[(size_t)a.type] > DataTypeSizes[(size_t)b.type];
1339 });
1340 }
1341
1342 auto& pixelShaderInterface = definition.effect.pixelShader.shaderInterface;
1343
1344 std::sort(pixelShaderInterface.members.begin(), pixelShaderInterface.members.end(), [](const auto& a, const auto& b)
1345 {
1346 return DataTypeSizes[(size_t)a.type] > DataTypeSizes[(size_t)b.type];
1347 });
1348 }
1349
1350 [[nodiscard]] bool applyParent(Context* context, MaterialDefinition& definition)
1351 {
1352 if (definition.name == "MaterialBase") return true;
1353
1354 if (definition.inherits.empty()) {
1355 definition.inherits = "MaterialBase";
1356 }
1357
1358 const MaterialDefinition* parent = context->materialDefinitionManager->get(definition.inherits);
1359 if (!parent) {
1360 LOG_ERROR(logger, "Invalid parent material: %s.", definition.inherits.c_str());
1361 return false;
1362 }
1363
1364 if (!inheritDefinition(*parent, definition)) return false;
1365
1366 for (MaterialDefinition& p : definition.permutations) {
1367 if (!inheritDefinition(definition, p)) return false;
1368
1369 if (p.permutationName.size()) {
1370 const MaterialDefinition* parentPermutation = nullptr;
1371
1372 for (auto& pp : parent->permutations) {
1373 if (pp.permutationName == p.permutationName) {
1374 parentPermutation = &pp;
1375 }
1376 }
1377
1378 if (parentPermutation) {
1379 if (!inheritDefinition(*parentPermutation, p, false)) return false;
1380 }
1381 }
1382
1383 orderInterfaces(p);
1384 }
1385
1386 return true;
1387 }
1388
1389}
1390
1391
1392bool Cogs::Core::readMaterialProperties(Context* /*context*/, const Value& jsonValue, MaterialProperties& materialProperties, bool isShared)
1393{
1394 if (!jsonValue.IsObject()) {
1395 LOG_ERROR(logger, "readMaterialProperties: Material properties is not a JSON object");
1396 return false;
1397 }
1398 for (auto& m : jsonValue.GetObject()) {
1399 if (!readMaterialProperty(toString(m.name), m.value, materialProperties, isShared)) {
1400 return false;
1401 }
1402 }
1403
1404 return true;
1405}
1406
1407bool Cogs::Core::readMaterialVariants(Context* /*context*/, const Value& value, std::vector<ShaderVariantDefinition>& variants, bool isShared)
1408{
1409 if (!value.IsObject()) {
1410 LOG_ERROR(logger, "readMaterialVariants: Variant value is not an object");
1411 return false;
1412 }
1413
1414 for (auto& o : value.GetObject()) {
1415 ShaderVariantDefinition& variant = variants.emplace_back();
1416 variant.index = variants.size() - 1;
1417 variant.name = toString(o.name);
1418 variant.isShared = isShared;
1419
1420 if (o.value.IsObject()) {
1421 if (!readMaterialVariant(o.value, variant)) {
1422 return false;
1423 }
1424 }
1425 else {
1426 if (o.value.IsString()) {
1427 variant.value = o.value.GetString();
1428 }
1429 else if (o.value.IsBool()) {
1430 variant.value = o.value.GetBool() ? "true" : "false";
1431 }
1432 else {
1433 LOG_ERROR(logger, "readMaterialVariants: Variant %s value is neither object, string nor bool.", variant.name.c_str());
1434 return false;
1435 }
1436 variant.valueOnly = true;
1437 }
1438 }
1439 return true;
1440}
1441
1442bool Cogs::Core::parseMaterial(Context * context, const StringView & path, MaterialDefinition & definition)
1443{
1444 Document document = parseJson(context, path, JsonParseFlags::None);
1445
1446 if (!document.IsObject()) {
1447 LOG_ERROR(logger, "Cannot read invalid material.");
1448 return false;
1449 }
1450
1451 bool isDefined = false;
1452 for (auto & m : document.GetObject()) {
1453 auto & jsonValue = m.value;
1454
1455 switch (toView(m.name).hash())
1456 {
1457 case Cogs::hash("Material"):
1458 if (isDefined) {
1459 LOG_ERROR(logger, "Material already defined.");
1460 return false;
1461 }
1462 isDefined = true;
1463
1464 if (!readMaterialMetadata(context, jsonValue, definition)) return false;
1465
1466 if (!definition.permutations.empty()) {
1467 if (!readMaterialEffect(jsonValue, definition.effect)) return false;
1468 }
1469 else {
1470 definition.permutations.emplace_back();
1471 MaterialDefinition& p = definition.permutations.back();
1472 p.name = definition.name;
1473 if (!readMaterialEffect(jsonValue, p.effect)) return false;
1474 }
1475 break;
1476
1477 case Cogs::hash("MaterialTemplate"):
1478 if (isDefined) {
1479 LOG_ERROR(logger, "Material already defined.");
1480 return false;
1481 }
1482 isDefined = true;
1483
1484 if (!readMaterialMetadata(context, jsonValue, definition)) return false;
1485 if (!readMaterialEffect(jsonValue, definition.effect)) return false;
1486 definition.flags |= MaterialDefinitionFlags::IsTemplate;
1487 break;
1488 }
1489 }
1490
1491 if (!isDefined) {
1492 LOG_ERROR(logger, "No material or material template defined.");
1493 return false;
1494 }
1495
1496 if (!applyParent(context, definition)) return false;
1497 orderInterfaces(definition);
1498
1499 context->materialDefinitionManager->add(MaterialDefinition(definition));
1500
1501 return true;
1502}
1503
1504bool Cogs::Core::inheritMaterialVariants(std::vector<ShaderVariantDefinition> & definitionVariants,
1505 std::span<const ShaderVariantDefinition> sourceVariants,
1506 const Cogs::StringView& definitionName,
1507 const Cogs::StringView& sourceName,
1508 bool errorOnExisting)
1509{
1510 if (!sourceVariants.empty()) {
1511 std::vector<ShaderVariantDefinition> oldVariants = std::move(definitionVariants);
1512
1513 definitionVariants.assign(sourceVariants.begin(), sourceVariants.end());
1514 for (ShaderVariantDefinition& newVariant : definitionVariants) {
1515 // Record inheritance level
1516 for (auto& member : newVariant.vertexInterface.members) { member.inheritanceLevel += 2; }
1517 for (auto& member : newVariant.geometryInterface.members) { member.inheritanceLevel += 2; }
1518 for (auto& member : newVariant.surfaceInterface.members) { member.inheritanceLevel += 2; }
1519 }
1520
1521 for (ShaderVariantDefinition& variant : oldVariants) {
1522
1523 if (variant.valueOnly) {
1524 bool found = false;
1525 for (ShaderVariantDefinition& inheritedVariant : definitionVariants) {
1526 if (variant.name == inheritedVariant.name) {
1527 if (inheritedVariant.type == ShaderVariantType::Enum) {
1528 for (auto& v : inheritedVariant.values) {
1529 if (v.key == variant.value) {
1530 inheritedVariant.defaultValue = static_cast<int>(v.index);
1531 found = true;
1532 break;
1533 }
1534 }
1535 }
1536 else if (inheritedVariant.type == ShaderVariantType::Bool) {
1537 found = true;
1538 inheritedVariant.defaultValue = parseBool(variant.value);
1539 }
1540
1541 if (!found) {
1542 LOG_ERROR(logger, "Variant '%s' set from derived '%.*s', but enum '%s' invalid.", variant.name.c_str(), StringViewFormat(definitionName), variant.value.c_str());
1543 return false;
1544 }
1545
1546 break;
1547 }
1548 }
1549
1550 if (!found) {
1551 LOG_ERROR(logger, "Variant '%s' set from derived but no matching variant found in base '%.*s'",
1552 variant.name.c_str(),
1553 StringViewFormat(sourceName));
1554 return false;
1555 }
1556 }
1557 else {
1558 bool found = false;
1559 for (auto& v : definitionVariants) {
1560 if (variant.name == v.name) {
1561 found = true;
1562
1563 if (errorOnExisting) {
1564 LOG_ERROR(logger, "Variant '%s' already exists in '%.*s'", variant.name.c_str(), StringViewFormat(definitionName));
1565 return false;
1566 }
1567 }
1568 }
1569
1570 if (!found) {
1571 definitionVariants.emplace_back(std::move(variant));
1572 definitionVariants.back().index = definitionVariants.size() - 1;
1573 }
1574 }
1575 }
1576 }
1577 return true;
1578}
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:140
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:181
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:100
Cogs::Core::EffectDefinition::definitions
PreprocessorDefinitions definitions
Preprocessor definitions.
Definition: EffectDefinition.h:125
Generated by doxygen 1.9.6