add dataclass

Author: Vipitis

wgpu_shadertoy/imgui.py

@@ -2,14 +2,36 @@
 from imgui_bundle import imgui as ig #TODO: rename (git mv) the file instead.
 from .utils import UniformArray
 from wgpu.utils.imgui import ImguiWgpuBackend
+from dataclasses import dataclass
 
 
 # could imgui become just another RenderPass after Image? I got to understand backend vs renderer first.
 # make become part of .passes??
 # todo: raise error if imgui isn't installed (only if this module is required?)
 
 
-def parse_constants(code:str, common_code) -> list[tuple[int, str, int|float, str]]:
+@dataclass
+class ShaderConstant:
+    renderpass_pass: str #maybe this is a RenderPass pointer?
+    line_number: int
+    original_line: str
+    name: str
+    value: int | float
+    shader_dtype: str # float, int, vec2, vec3, bool etc.
+
+    def c_type_format(self) -> str:
+        # based on these for the memoryview cast:
+        # https://docs.python.org/3/library/struct.html#format-characters
+        if self.shader_dtype == "float":
+            return "f"
+        elif self.shader_dtype == "int":
+            return "i"
+        elif self.shader_dtype == "uint":
+            return "I"
+        # add more types as needed
+        return "?"
+
+def parse_constants(code:str, common_code) -> list[ShaderConstant]:
     # todo:
     # WGSL variants??
     # re/tree-sitter/loops and functions?
@@ -22,12 +44,12 @@ def parse_constants(code:str, common_code) -> list[tuple[int, str, int|float, st
     # mataches the macro: #define NAME VALUE
     # TODO there can be characters in numerical literals, such as x and o for hex and octal representation or e for scientific notation
     # technically the macros can also be an expression that is evaluated to be a number... such as # define DOF 10..0/30.0 - so how do we deal with that?
-    define_pattern = re.compile(r"#define\s+(\w+)\s+([\d.]+)")
+    define_pattern = re.compile(r"#\s*define\s+(\w+)\s+([\d.]+)") #for numerical literals right now.
     if_def_template = r"#(el)?if\s+" #preprocessor ifdef blocks can't become uniforms. replacing these dynamically will be difficult.
 
     constants = []
     for li, line in enumerate(code.splitlines()):
-        match = define_pattern.match(line.rstrip())
+        match = define_pattern.match(line.strip())
         if match:
             name, value = match.groups()
             if_def_pattern = re.compile(if_def_template + name)
@@ -38,17 +60,26 @@ def parse_constants(code:str, common_code) -> list[tuple[int, str, int|float, st
 
             if "." in value: #value.isdecimal?
                 # TODO: wgsl needs to be more specific (f32 for example?) - but there is no preprocessor anyways...
-                dtype = "f" #default float (32bit)
+                dtype = "float" #default float (32bit)
                 value = float(value)
-            elif value.isdecimal: # value.isalum?
-                dtype = "I" # "big I (32bit)"
+            elif value.isdecimal(): # value.isnumeric?
+                dtype = "int" # "big I (32bit)"
                 value = int(value)
             else:
                 # TODO complexer types?
                 print(f"can't parse type for constant {name} with value {value}, skipping")
                 continue
+
+            constant = ShaderConstant(
+                renderpass_pass="image",  # TODO: shouldn't be names.
+                line_number=li,
+                original_line=line.strip(),
+                name=name,
+                value=value,
+                shader_dtype=dtype
+            )
             # todo: remove lines here? (comment out better)
-            constants.append((li, name, value, dtype)) # what about line to remove?
+            constants.append(constant)
             print(f"In line {li} found constant: {name} with value: {value} of dtype {dtype}")
 
     # maybe just named tuple instead of dataclass?
@@ -57,23 +88,21 @@ def parse_constants(code:str, common_code) -> list[tuple[int, str, int|float, st
 def make_uniform(constants) -> UniformArray:
     arr_data = []
     for constant in constants:
-        _, name, value, dtype = constant
-        arr_data.append(tuple([name, dtype, 1]))
+        arr_data.append(tuple([constant.name, constant.c_type_format(), 1]))
     data = UniformArray(*arr_data)
 
     # init data
     for constant in constants:
-        _, name, value, dtype = constant
-        data[name] = value
-    
+        data[constant.name] = constant.value
+
     # TODO:
     # is there issues with padding? (maybe solve in the class)
     # figure out order due to padding/alignment: https://www.w3.org/TR/WGSL/#alignment-and-size
     # return a UniformArray object (cycling import?)
     # (does this need to be a class to update the values?)
     return data
 
-def construct_imports(constants, constant_binding_idx=10) -> str:
+def construct_imports(constants: list[ShaderConstant], constant_binding_idx=10) -> str:
     # codegen the import block for this uniform (including binding? - which number?)
     # could be part of the UniformArray class maybe?
     # to be pasted near the top of the fragment shader code.
@@ -84,17 +113,8 @@ def construct_imports(constants, constant_binding_idx=10) -> str:
     var_init_lines = []
     var_mapping_lines = []
     for const in constants:
-        _, name, value, dtype = const
-        # TODO: refactor to dtype map or something more useful -.-
-        if dtype == "f":
-            dtype = "float"
-        elif dtype == "I":
-            dtype = "int"
-        else:
-            # shouldn't happen
-            continue
-        var_init_lines.append(f"{dtype} {name};")
-        var_mapping_lines.append(f"# define {name} const_input.{name}")
+        var_init_lines.append(f"{const.shader_dtype} {const.name};")
+        var_mapping_lines.append(f"# define {const.name} const_input.{const.name}")
 
     code_construct = f"""
     uniform struct ConstantInput {{
@@ -114,7 +134,7 @@ def update_gui():
     pass
 
 
-def gui(constants, constants_data):
+def gui(constants: list[ShaderConstant], constants_data: UniformArray):
     ig.new_frame()
     ig.set_next_window_pos((0, 0), ig.Cond_.appearing)
     ig.set_next_window_size((400, 0), ig.Cond_.appearing)
@@ -126,11 +146,10 @@ def gui(constants, constants_data):
 
     # create the sliders?
     for const in constants:
-        li, name, value, dtype = const
-        if dtype == "f":
-            _, constants_data[name] = ig.slider_float(name, constants_data[name], 0, value*2.0)
-        elif dtype == "I":
-            _, constants_data[name] = ig.slider_int(name, constants_data[name], 0, value*2)
+        if const.shader_dtype == "float":
+            _, constants_data[const.name] = ig.slider_float(const.name, constants_data[const.name], 0, const.value*2.0)
+        elif const.shader_dtype == "int":
+            _, constants_data[const.name] = ig.slider_int(const.name, constants_data[const.name], 0, const.value*2)
             # TODO: improve min/max for negatives
 
     ig.end()

wgpu_shadertoy/passes.py

@@ -387,8 +387,7 @@ def construct_code(self) -> tuple[str, str]:
                 # comment out existing constants
                 shader_code_lines = self.shader_code.splitlines()
                 for const in self.main._constants:
-                    line_number = const[0]
-                    shader_code_lines[line_number] = "// " + shader_code_lines[line_number]
+                    shader_code_lines[const.line_number] = "// " + shader_code_lines[const.line_number]
                 self._shader_code = "\n".join(shader_code_lines)
 
                 constant_headers = construct_imports(self.main._constants)