Window and Events

.editorconfig

@@ -15,6 +15,18 @@ indent_size = 4
 cpp_indent_access_specifiers = false
 end_of_line = lf
 
+[*.py]
+charset = utf-8
+indent_style = tab
+indent_size = 4
+end_of_line = lf
+
+[*.json]
+charset = utf-8
+indent_style = space
+indent_size = 4
+end_of_line = lf
+
 [*.yaml]
 charset = utf-8
 indent_style = space

.gitignore

@@ -1,3 +1,4 @@
 .vs
 build
 out
+__pycache__

CMakeLists.txt

@@ -18,6 +18,8 @@ project(ProjectDelta LANGUAGES CXX)
 get_filename_component(DLT_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}" ABSOLUTE)
 get_filename_component(DLT_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}" ABSOLUTE)
 
+include(cmake/DeltaCodegen.cmake)
+
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_CXX_EXTENSIONS False)

CodeGen/emitters/buffer.py

@@ -0,0 +1,30 @@
+class CodeBuffer:
+    def __init__(self, indent_string="  "):
+        self.lines = []
+        self._indent_string = indent_string
+        self._current_indent = 0
+
+    def indent(self):
+        self._current_indent += 1
+
+    def dedent(self):
+        self._current_indent = max(0, self._current_indent - 1)
+
+    def write_line(self, text=""):
+        if (text.strip() == ""):
+            self.lines.append("")
+        else:
+            spacing = self._indent_string * self._current_indent
+            self.lines.append(f"{spacing}{text}")
+
+    def open_block(self, prefix_text=""):
+        if prefix_text:
+            self.write_line(prefix_text)
+        self.indent()
+
+    def close_block(self, suffix_text="};"):
+        self.dedent()
+        self.write_line(suffix_text)
+
+    def render(self) -> str:
+        return "\n".join(self.lines)

CodeGen/emitters/engine_emitters.py

@@ -0,0 +1,124 @@
+from .buffer import CodeBuffer
+
+class EngineEmitter:
+    def __init__(self, structures, primitives_registry, namespace=None):
+        self.structures = structures
+        self.primitives = primitives_registry
+        self.namespace = namespace
+        self.buf = CodeBuffer()
+
+    def emit_all(self, output_filepath):
+        self.buf.write_line("// AUTOMATICALLY GENERATED FILE - DO NOT MODIFY")
+        self.buf.write_line("#pragma once")
+        self.buf.write_line("#include <cstdint>")
+        self.buf.write_line()
+
+        if self.namespace:
+            self.buf.open_block(f"namespace {self.namespace} {{")
+            self.buf.write_line()
+
+        for struct in self.structures:
+            self._emit_aos(struct)
+            self.buf.write_line()
+
+        for struct in self.structures:
+            self._emit_soa(struct)
+            self.buf.write_line()
+
+        for struct in self.structures:
+            self._emit_view(struct)
+            self.buf.write_line()
+
+        if self.namespace:
+            self.buf.close_block(f"}}; // namespace {self.namespace}")
+
+        new_content = self.buf.render()
+        self._write_if_changed(output_filepath, new_content)
+
+    def _get_type_name(self, field, target_track):
+        if target_track == "aos":
+            suffix = "AoS"
+        elif target_track == "soa":
+            suffix = "SoA"
+        else:
+            suffix = "View"
+
+        return f"{field.type_name}{suffix}"
+
+    def _get_field_type(self, field, target_track):
+        if field.is_primitive:
+            return self.primitives[field.type_name][target_track]
+        else:
+            if target_track == "aos":
+                suffix = "AoS"
+            elif target_track == "soa":
+                suffix = "SoA"
+            else:
+                suffix = "View"
+
+            return f"{field.type_name}{suffix}"
+
+    def _emit_aos(self, struct):
+        align_prefix = f"alignas({struct.alignment}) " if struct.alignment else ""
+
+        self.buf.open_block(f"struct {align_prefix}{struct.name}AoS {{")
+        for field in struct.fields:
+            ftype = self._get_field_type(field, "aos")
+            self.buf.write_line(f"{ftype} {field.name};")
+        self.buf.close_block()
+
+    def _emit_soa(self, struct):
+        align_prefix = f"alignas({struct.alignment}) " if struct.alignment else ""
+
+        self.buf.open_block(f"struct {align_prefix}{struct.name}SoA {{")
+        for field in struct.fields:
+            ftype = self._get_field_type(field, "soa")
+            self.buf.write_line(f"{ftype} {field.name};")
+        self.buf.close_block()
+
+    def _emit_view(self, struct):
+        self.buf.open_block(f"struct {struct.name}View {{")
+
+        # Write references
+        for field in struct.fields:
+            ftype = self._get_field_type(field, "view")
+            self.buf.write_line(f"{ftype} {field.name};")
+        self.buf.write_line()
+
+        # FromAoS factory initialization
+        self.buf.open_block(f"[[nodiscard]] static inline {struct.name}View FromAoS({struct.name}AoS& instance) noexcept {{")
+        self.buf.open_block(f"return {struct.name}View {{")
+
+        for field in struct.fields:
+            if field.is_primitive:
+                self.buf.write_line(f".{field.name} = instance.{field.name},")
+            else:
+                self.buf.write_line(f".{field.name} = {field.type_name}View::FromAoS(instance.{field.name}),")
+
+        self.buf.close_block("};")
+        self.buf.close_block("}")
+
+        # FromSoA factory initialization
+        self.buf.open_block(f"[[nodiscard]] static inline {struct.name}View FromSoA({struct.name}SoA& instance, uint32_t ix) noexcept {{")
+        self.buf.open_block(f"return {struct.name}View {{")
+
+        for field in struct.fields:
+            if field.is_primitive:
+                self.buf.write_line(f".{field.name} = instance.{field.name}[ix],")
+            else:
+                self.buf.write_line(f".{field.name} = {field.type_name}View::FromSoA(instance.{field.name}, ix),")
+
+        self.buf.close_block("};")
+        self.buf.close_block("}")
+
+        # end structure
+        self.buf.close_block()
+
+    def _write_if_changed(self, filepath, content):
+        import os
+        if os.path.exists(filepath):
+            with open(filepath, "r") as f:
+                if f.read() == content:
+                    return
+        with open(filepath, "w") as f:
+            f.write(content)

CodeGen/main.py

@@ -0,0 +1,43 @@
+import os
+import sys
+import json
+from model import load_schemas_tree
+from emitters.engine_emitters import EngineEmitter
+
+def main():
+    if len(sys.argv) < 3:
+        print("Error: Missing output file path argument from CMake.", file=sys.stderr)
+        sys.exit(1)
+
+    input_schema_path = sys.argv[1]
+    output_filepath = sys.argv[2]
+
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    core_types_path = os.path.join(script_dir, "schemas", "core_types.json")
+    output_directory, _ = os.path.split(output_filepath)
+
+    print(output_directory)
+    os.makedirs(output_directory, exist_ok=True)
+
+    if not os.path.exists(core_types_path):
+        print(f"Error: Missing core types registry at {core_types_path}", file=sys.stderr)
+        sys.exit(1)
+
+    with open(core_types_path, "r") as f:
+        core_data = json.load(f)
+
+    primitives_map = {}
+    for p in core_data.get("primitives", []) + core_data.get("opaque_engine_types", []):
+        primitives_map[p["name"]] = p
+
+    if not os.path.exists(input_schema_path):
+        print(f"Error: Structural schema missing at {input_schema_path}", file=sys.stderr)
+        sys.exit(1)
+
+    parsed_structures, target_namespace = load_schemas_tree([input_schema_path], primitives_map)
+
+    emitter = EngineEmitter(parsed_structures, primitives_map, target_namespace)
+    emitter.emit_all(output_filepath)
+
+if __name__ == "__main__":
+    main()

CodeGen/model.py

@@ -0,0 +1,40 @@
+import json
+
+class Field:
+	def __init__(self, type_name, name, is_primitive):
+		self.type_name = type_name
+		self.name = name
+		self.is_primitive = is_primitive
+
+class Structure:
+	def __init__(self, name, raw_fields, primitives_registry, custom_types, alignment = None):
+		self.name = name
+		self.fields = []
+		self.alignment = int(alignment) if alignment is not None else None
+
+		for f in raw_fields:
+			is_prim = f["type"] in primitives_registry
+			self.fields.append(Field(f["type"], f["name"], is_prim))
+
+def load_schemas_tree(schema_files, primitives_registry):
+	custom_types = set()
+	raw_structs = []
+	target_namespace = None
+
+	for file_path in schema_files:
+		with open(file_path, "r") as f:
+			data = json.load(f)
+
+			if "namespace" in data:
+				target_namespace = data["namespace"]
+
+			for s in data["structures"]:
+				custom_types.add(s["name"])
+				raw_structs.append(s)
+
+	parsed_structures = [
+		Structure(s["name"], s["fields"], primitives_registry, custom_types, s.get("alignment"))
+		for s in raw_structs
+	]
+
+	return parsed_structures, target_namespace

CodeGen/schemas/core_types.json

@@ -0,0 +1,46 @@
+{
+    "primitives": [
+        {
+            "name": "uint8_t",
+            "alignment": 1,
+            "aos": "uint8_t",
+            "soa": "uint8_t*",
+            "view": "uint8_t&"
+        },
+        {
+            "name": "uint16_t",
+            "alignment": 2,
+            "aos": "uint16_t",
+            "soa": "uint16_t*",
+            "view": "uint16_t&"
+        },
+        {
+            "name": "uint32_t",
+            "alignment": 4,
+            "aos": "uint32_t",
+            "soa": "uint32_t*",
+            "view": "uint32_t&"
+        },
+        {
+            "name": "uint64_t",
+            "alignment": 8,
+            "aos": "uint64_t",
+            "soa": "uint64_t*",
+            "view": "uint64_t&"
+        },
+        {
+            "name": "size_t",
+            "alignment": 8,
+            "aos": "size_t",
+            "soa": "size_t*",
+            "view": "size_t&"
+        },
+        {
+            "name": "uintptr_t",
+            "alignment": 8,
+            "aos": "uintptr_t",
+            "soa": "uintptr_t*",
+            "view": "uintptr_t&"
+        }
+    ]
+}