9#include <unordered_map>
17using namespace shader::parser;
18using namespace shader::parser::ast;
29 bool is_trivial()
const
35 auto is_struct_size_known = [&](
Scope attributes) ->
bool {
36 if (attributes.is_invalid()) {
39 bool is_shared =
false;
40 attributes.foreach_attribute([&](
Token attr,
Scope) {
41 if (attr.str() ==
"host_shared") {
52 unordered_map<string, vector<Member>> union_members;
57 body.foreach_match(
"o{..};", [&](
const Tokens &t) {
60 string union_name =
"union" +
to_string(union_index);
61 string union_type = string(struct_name.str()) +
"_" + union_name;
64 vector<Member> members;
65 union_body.foreach_declaration(
67 if (array.is_valid()) {
68 report_error(name,
"Arrays are not supported inside unions.");
71 Member{string(type.str()), string(name.str()), 0, 0, type.prev() ==
Enum});
74 if (members.empty()) {
75 report_error(t[0],
"Empty union");
78 union_members.emplace(union_type, members);
80 string union_member = union_type +
" " + union_name +
";";
81 if (attrs.contains(
"host_shared")) {
82 union_member =
"struct " + union_member;
84 parser.insert_before(t.front(), union_member);
85 parser.erase(t.front(), t.back());
87 string type_decl =
"struct [[host_shared]] " + union_type +
" {\n";
91 type_decl +=
" " + members.front().type +
" " + members.front().name +
";\n";
94 parser.insert_line_number(struct_tok.str_index_start() - 1, t[0].line_number());
95 parser.insert_before(struct_tok, type_decl);
96 parser.insert_line_number(struct_tok.str_index_start() - 1, struct_tok.line_number());
101 parser.apply_mutations();
104 unordered_map<string, vector<Member>> struct_members = {
105 {
"float", {{
"",
"", 0, 4}}},
106 {
"float2", {{
"",
"", 0, 8}}},
107 {
"float4", {{
"",
"", 0, 16}}},
108 {
"bool32_t", {{
"",
"", 0, 4}}},
109 {
"int", {{
"",
"", 0, 4}}},
110 {
"int2", {{
"",
"", 0, 8}}},
111 {
"int4", {{
"",
"", 0, 16}}},
112 {
"uint", {{
"",
"", 0, 4}}},
113 {
"uint2", {{
"",
"", 0, 8}}},
114 {
"uint4", {{
"",
"", 0, 16}}},
115 {
"string_t", {{
"",
"", 0, 4}}},
116 {
"packed_float3", {{
"",
"", 0, 12}}},
117 {
"packed_int3", {{
"",
"", 0, 12}}},
118 {
"packed_uint3", {{
"",
"", 0, 12}}},
119 {
"float2x4", {{
"float4",
"[0]", 0, 16}, {
"float4",
"[1]", 16, 16}}},
121 {{
"float4",
"[0]", 0, 16}, {
"float4",
"[1]", 16, 16}, {
"float4",
"[2]", 32, 16}}},
123 {{
"float4",
"[0]", 0, 16},
124 {
"float4",
"[1]", 16, 16},
125 {
"float4",
"[2]", 32, 16},
126 {
"float4",
"[3]", 48, 16}}},
129 auto type_size_get = [&](
Token type) ->
size_t {
130 auto value = struct_members.find(
string(type.str()));
131 if (value == struct_members.end()) {
136 for (
const Member &member : value->second) {
137 total_size += member.size;
144 if (!is_struct_size_known(attributes)) {
147 vector<Member> members;
152 size_t array_size = 0;
153 if (array.is_valid()) {
155 array_size = static_array_size(array, 0);
161 for (
int i = 0; i < array_size; i++) {
162 string name_str(name.str());
163 if (array.is_valid()) {
166 if (type.prev() !=
Enum) {
167 size = type_size_get(type);
169 members.emplace_back(Member{string(type.str()),
"." + name_str, offset,
size});
173 members.emplace_back(Member{string(type.str()),
"." + name_str, offset,
size,
true});
179 struct_members.emplace(struct_name.str(), members);
183 auto replace_placeholder_member = [&](
Scope body) {
185 size_t size = type_size_get(body.front().next());
187 report_error(body.front().next(),
188 "Can't infer size of member. Type must be defined in this file and have "
189 "the [[host_shared]] attribute.");
191 for (
int i = 0; i <
size; i += 16) {
192 size_t member_size =
size - i;
193 const char *data_type =
"float4";
194 if (member_size == 4) {
197 else if (member_size == 8) {
198 data_type =
"float2";
200 else if (member_size == 12) {
201 data_type =
"float3";
203 parser.insert_after(body.front().str_index_last_no_whitespace(),
204 "\n " +
string(data_type) +
" data" +
to_string(i / 16) +
";");
206 parser.erase(body.front().next(), body.back().prev());
209 auto member_from_float =
210 [&](
const Member &union_member,
const Member &struct_member,
const string &access) {
212 const string &type = struct_member.is_trivial() ? union_member.type : struct_member.type;
213 bool is_enum = struct_member.is_trivial() ? union_member.is_enum : struct_member.is_enum;
216 return struct_member.type +
"(floatBitsToUint(" + access +
"))";
218 if (type.starts_with(
"uint")) {
219 return "floatBitsToUint(" + access +
")";
221 if (type.starts_with(
"int")) {
222 return "floatBitsToInt(" + access +
")";
224 if (type ==
"bool") {
225 return "floatBitsToInt(" + access +
") != 0";
230 auto member_to_float =
231 [&](
const Member &union_member,
const Member &struct_member,
const string &access) {
233 const string &type = struct_member.is_trivial() ? union_member.type : struct_member.type;
234 bool is_enum = struct_member.is_trivial() ? union_member.is_enum : struct_member.is_enum;
237 return "uintBitsToFloat(uint(" + access +
"))";
239 if (type.starts_with(
"uint")) {
240 return "uintBitsToFloat(" + access +
")";
242 if (type.starts_with(
"int")) {
243 return "intBitsToFloat(" + access +
")";
245 if (type ==
"bool") {
246 return "intBitsToFloat(int(" + access +
"))";
251 auto union_data_access = [&](
const Member &struct_member,
size_t union_size) {
252 const size_t offset = struct_member.offset;
253 string access =
".data" +
to_string(offset / 16);
255 if (struct_member.size == 12) {
258 else if (struct_member.size == 8) {
259 access += ((offset % 16) == 0) ?
".xy" :
".zw";
261 else if (struct_member.size == 4) {
262 switch (offset % 16) {
265 access += ((union_size - offset) == 4) ?
"" :
".x";
281 auto member_data_access = [&](
const Member &struct_member) ->
string {
282 return struct_member.is_trivial() ? string() : struct_member.name;
285 auto create_getter = [&](
286 const Token &union_type_tok,
287 const Token &union_var_tok,
289 const Member &union_member,
291 const vector<Member> &struct_members) ->
string {
292 const size_t union_size = type_size_get(union_type_tok);
293 if (union_size == 0) {
294 report_error(union_type_tok,
295 "Can't infer size of member. Type must be defined in this file and have "
296 "the [[host_shared]] attribute.");
299 const Member &last_member = struct_members.back();
300 if (last_member.offset + last_member.size != union_size) {
301 report_error(union_type_tok,
"union has members of different sizes");
305 string fn_body =
"{\n";
307 fn_body +=
" " + union_member.type +
" val;\n";
308 for (
const auto &member : struct_members) {
309 string to_var =
"val" + member_data_access(member);
310 string access =
"this_." + string(union_var_tok.str()) +
311 union_data_access(member, union_size);
312 fn_body +=
" " + to_var +
" = " + member_from_float(union_member, member, access) +
";\n";
314 fn_body +=
" return val;\n";
317 return "\n" + union_member.type +
" " + union_member.name +
"() const " + fn_body;
320 auto create_setter = [&](
321 const Token &union_type_tok,
322 const Token &union_var_tok,
324 const Member &union_member,
326 const vector<Member> &struct_members) ->
string {
327 const size_t union_size = type_size_get(union_type_tok);
328 if (union_size == 0) {
329 report_error(union_type_tok,
330 "Can't infer size of member. Type must be defined in this file and have "
331 "the [[host_shared]] attribute.");
334 const Member &last_member = struct_members.back();
335 if (last_member.offset + last_member.size != union_size) {
336 report_error(union_type_tok,
"union has members of different sizes");
340 string fn_body =
"{\n";
341 for (
const auto &member : struct_members) {
342 string to_var =
"this->" + string(union_var_tok.str()) +
343 union_data_access(member, union_size);
344 string access =
"value" + member_data_access(member);
345 fn_body +=
" " + to_var +
" = " + member_to_float(union_member, member, access) +
";\n";
349 return "\nvoid " + union_member.name +
"_set_(" + union_member.type +
" value) " + fn_body;
352 auto flatten_members = [&](
Token type, vector<Member> &members) {
354 dst.reserve(members.size());
355 bool expanded =
false;
356 for (
const auto &member : members) {
357 if (member.is_trivial() || member.is_enum) {
358 dst.emplace_back(member);
361 if (!struct_members.contains(member.type)) {
364 "Unknown type encountered while unwrapping union. Contained types must be defined "
365 "in this file and decorated with [[host_shared]] attribute.");
369 vector<Member> nested_structure = struct_members.find(member.type)->second;
370 for (Member nested_member : nested_structure) {
371 if (nested_member.is_trivial() || nested_member.is_enum) {
372 dst.emplace_back(member);
376 nested_member.name = member.name + nested_member.name;
377 nested_member.offset = member.offset + nested_member.offset;
378 dst.emplace_back(nested_member);
387 if (union_members.contains(
string(struct_name.str()))) {
388 replace_placeholder_member(body);
393 if (!union_members.contains(
string(type.str()))) {
397 const vector<Member> &members = union_members.find(
string(type.str()))->second;
398 for (
const auto &member : members) {
399 if (!struct_members.contains(member.type)) {
402 "Unknown union member type. Type must be defined in this file and decorated "
403 "with [[host_shared]] attribute.");
406 vector<Member> structure = struct_members.find(member.type)->second;
408 while (flatten_members(type, structure)) {
411 parser.insert_after(body.back().prev(), create_getter(type, name, member, structure));
412 parser.insert_after(body.back().prev(), create_setter(type, name, member, structure));
417 lower_union_setters(parser);
420void SourceProcessor::lower_union_setters(
Parser &
parser)
425 parser().foreach_match(
"A()=", [&](
const Tokens &t) {
426 parser.insert_before(t[1],
"_set_");
427 parser.erase(t[2], t[3]);
428 parser.insert_after(t[3].scope().back(),
")");
431 parser.apply_mutations();
434void SourceProcessor::lower_bitfield_setters(
Parser &
parser)
438 parser().foreach_match(
"A(..)=", [&](
const Tokens &t) {
439 if (t[0].
str() !=
"bitfieldExtract") {
443 string_view value = parser.substr(assign.front().next(), assign.back());
444 parser.replace(t[0],
"bitfieldInsertAssign");
445 parser.insert_after(t[1],
string(value) +
", ");
446 parser.replace(assign,
"");
449 parser.apply_mutations();
459void SourceProcessor::lower_union_accessor_templates(
Parser &
parser)
462 body.foreach_match(
"o{..};", [&](
const Tokens &t) {
463 t[1].scope().foreach_declaration(
465 if (type.str() !=
"union_t") {
468 "All union members must have their type wrapped using the union_t<T> template.");
469 parser.erase(type, type.find_next(
SemiColon));
475 if (template_scope.is_valid()) {
476 parser.erase(template_scope.front());
477 parser.erase(template_scope.back());
482 parser.apply_mutations();
492void SourceProcessor::lower_union_accessor_templates_ast(
Parser &
parser)
494 for (ClassDecl decl : parser.root().descendants_of_type<ClassDecl>()) {
495 if (decl.is_union()) {
496 for (VarDecl var : decl.body().children_of_type<VarDecl>()) {
498 Id name = type.identifier().name();
500 if (type.identifier().name().str() !=
"union_t") {
507 if (param.is_valid()) {
508 parser.erase(param.front());
509 parser.erase(param.back());
515 parser.apply_mutations();
std::vector< parser::Token > Tokens
int size(const AssetLibraryReference *library_reference)
const char * to_string(ShaderStage stage)