shaderflow 0.4.0__py2.py3-none-any.whl

ShaderFlow/Common/Notes.py

@@ -0,0 +1,134 @@
+import functools
+import math
+from typing import Any, Self
+
+from attr import define
+
+from Broken import BrokenFluentBuilder
+
+PIANO_NOTES = "C C# D D# E F F# G G# A A# B".split()
+
+@define(eq=False)
+class BrokenPianoNote(BrokenFluentBuilder):
+    note:     int   = 60
+    start:    float = 0
+    end:      float = 0
+    channel:  int   = 0
+    velocity: int   = 100
+    tuning:   float = 440
+
+    def __hash__(self):
+        return hash((self.note, self.start, self.end, self.channel, self.velocity))
+
+    def idk_hash(self):
+        return hash((self.note, self.channel))
+
+    def __eq__(self, other):
+        return hash(self) == hash(other)
+
+    # # Initialization
+
+    @classmethod
+    @functools.lru_cache
+    def from_index(cls, note: int, **kwargs) -> Self:
+        return cls(note=note, **kwargs)
+
+    @classmethod
+    @functools.lru_cache
+    def from_name(cls, name: str, **kwargs) -> Self:
+        return cls(note=BrokenPianoNote.name_to_index(name), **kwargs)
+
+    @classmethod
+    @functools.lru_cache
+    def from_frequency(cls, frequency: float, **kwargs) -> Self:
+        return cls(note=BrokenPianoNote.frequency_to_index(frequency), **kwargs)
+
+    @classmethod
+    @functools.lru_cache
+    def get(cls, object: Any, **kwargs) -> Self:
+        if isinstance(object, BrokenPianoNote):
+            return object(**kwargs)
+        elif isinstance(object, int):
+            return cls.from_index(object, **kwargs)
+        elif isinstance(object, str):
+            return cls.from_name(object, **kwargs)
+        elif isinstance(object, float):
+            return cls.from_frequency(object, **kwargs)
+        return cls(**kwargs)
+
+    # # Conversion
+
+    @staticmethod
+    @functools.lru_cache
+    def index_to_name(index: int) -> str:
+        return f"{PIANO_NOTES[index % 12]}{index//12 - 1}"
+
+    @staticmethod
+    @functools.lru_cache
+    def index_to_frequency(index: int, *, tuning: float=440) -> float:
+        return tuning * 2**((index - 69)/12)
+
+    @staticmethod
+    @functools.lru_cache
+    def name_to_index(name: str) -> int:
+        note, octave = name[:-1].upper(), int(name[-1])
+        return PIANO_NOTES.index(note) + 12*(octave + 1)
+
+    @staticmethod
+    @functools.lru_cache
+    def name_to_frequency(name: str, *, tuning: float=440) -> float:
+        return BrokenPianoNote.index_to_frequency(BrokenPianoNote.name_to_index(name), tuning=tuning)
+
+    @staticmethod
+    @functools.lru_cache
+    def frequency_to_index(frequency: float, *, tuning: float=440) -> int:
+        return round(12*math.log2(frequency/tuning) + 69)
+
+    @staticmethod
+    @functools.lru_cache
+    def frequency_to_name(frequency: float, *, tuning: float=440) -> str:
+        return BrokenPianoNote.index_to_name(BrokenPianoNote.frequency_to_index(frequency, tuning=tuning))
+
+    # # Utilities
+
+    @property
+    def frequency(self) -> float:
+        return BrokenPianoNote.index_to_frequency(self.note, tuning=self.tuning)
+
+    @frequency.setter
+    def frequency(self, value: float):
+        self.note = BrokenPianoNote.frequency_to_index(value, tuning=self.tuning)
+
+    @property
+    def name(self) -> str:
+        return BrokenPianoNote.index_to_name(self.note)
+
+    @name.setter
+    def name(self, value: str):
+        self.note = BrokenPianoNote.name_to_index(value)
+
+    # Black and White
+
+    def is_white(note: int) -> bool:
+        return (note % 12) in {0, 2, 4, 5, 7, 9, 11}
+
+    def is_black(note: int) -> bool:
+        return (note % 12) in {1, 3, 6, 8, 10}
+
+    @property
+    def white(self) -> bool:
+        return BrokenPianoNote.is_white(self.note)
+
+    @property
+    def black(self) -> bool:
+        return BrokenPianoNote.is_black(self.note)
+
+    # Temporal
+
+    @property
+    def duration(self):
+        return self.end - self.start
+
+    @duration.setter
+    def duration(self, value: float):
+        self.end = self.start + value

ShaderFlow/Message.py

@@ -0,0 +1,147 @@
+from typing import Any
+
+from attr import define
+
+
+class ShaderMessage:
+
+    # # Special
+
+    class Custom:
+        """Any data type"""
+        data: Any
+
+    # # Mouse
+
+    class Mouse:
+
+        @define
+        class Position:
+            # Real
+            x:  int = 0
+            y:  int = 0
+            dx: int = 0
+            dy: int = 0
+
+            # Normalized
+            u:  float = 0.0
+            v:  float = 0.0
+            du: float = 0.0
+            dv: float = 0.0
+
+        @define
+        class Press:
+            button: int = 0
+
+            # Real
+            x: int = 0
+            y: int = 0
+
+            # Normalized
+            u: float = 0.0
+            v: float = 0.0
+
+        @define
+        class Release:
+            button: int = 0
+
+            # Real
+            x: int = 0
+            y: int = 0
+
+            # Normalized
+            u: float = 0.0
+            v: float = 0.0
+
+        @define
+        class Drag:
+            # Real
+            x:  int = 0
+            y:  int = 0
+            dx: int = 0
+            dy: int = 0
+
+            # Normalized
+            u:  float = 0.0
+            v:  float = 0.0
+            du: float = 0.0
+            dv: float = 0.0
+
+        @define
+        class Scroll:
+            # Real
+            dx: int = 0
+            dy: int = 0
+
+            # Normalized
+            du: float = 0.0
+            dv: float = 0.0
+
+        @define
+        class Enter:
+            state: bool
+
+    # # Window
+
+    class Window:
+
+        @define
+        class Resize:
+            width:  int = None
+            height: int = None
+
+            @property
+            def size(self) -> tuple[int, int]:
+                return self.width, self.height
+
+        @define
+        class Iconify:
+            state: bool = None
+
+        @define
+        class FileDrop:
+            files: list[str] = None
+
+        @define
+        class Close:
+            ...
+
+    # # Shader
+
+    class Shader:
+
+        @define
+        class RecreateTextures:
+            ...
+
+        @define
+        class Compile:
+            ...
+
+        @define
+        class Render:
+            ...
+
+    # # Keyboard
+
+    class Keyboard:
+
+        @define
+        class Press:
+            key:       int = None
+            action:    int = None
+            modifiers: int = None
+
+        @define
+        class KeyDown:
+            key:       int = None
+            modifiers: int = None
+
+        @define
+        class KeyUp:
+            key:       int = None
+            modifiers: int = None
+
+        @define
+        class Unicode:
+            char: str = None

ShaderFlow/Module.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import itertools
+from abc import abstractmethod
+from typing import TYPE_CHECKING, Iterable, Self, Type, Union
+
+from attr import Factory, define, field
+
+from Broken import BrokenAttrs, BrokenFluentBuilder, log
+from Broken.Externals.FFmpeg import BrokenFFmpeg
+from ShaderFlow.Message import ShaderMessage
+from ShaderFlow.Variable import ShaderVariable
+
+
+@define
+class ShaderModule(BrokenFluentBuilder, BrokenAttrs):
+    scene: ShaderScene = field(default=None, repr=False)
+    """The ShaderScene this module belongs to. Must be set on initialization of any module with
+    `ShaderModule(scene=...)` even though marked as `default=None` to make flexible MRO parenting"""
+
+    uuid: int = Factory(itertools.count(1).__next__)
+    """A module identifier, mostly used for differentiating log statements of same type modules"""
+
+    name: str = None
+    """The base name for exported GLSL variables, textures, etc. It is technically optional, but
+    it's not a bad idea for all modules to have a default value for this attribute than None"""
+
+    @property
+    def who(self) -> str:
+        return f"({self.uuid:>2}) {type(self).__name__[:18].ljust(18)} │ ▸"
+
+    def __post__(self):
+        # Post-import for type checking to avoid circular reference
+        from ShaderFlow.Scene import ShaderScene
+
+        # The module can be a ShaderScene itself
+        self.scene = self.scene or self
+
+        # Module must be part of a 'scene=instance(ShaderScene)'
+        if not isinstance(self.scene, ShaderScene):
+            raise RuntimeError(log.error('\n'.join((
+                f"Module of type '{type(self).__name__}' must be added to a 'ShaderScene' instance",
+                f"• Initialize it with {type(self).__name__}(scene='instance(ShaderScene)', ...)",
+            ))))
+
+        log.trace(f"{self.who} Module added to the Scene")
+        self.scene.modules.append(self)
+        self.commands()
+
+    @abstractmethod
+    def commands(self) -> None:
+        """Add commands to the scene with `self.scene.typer.command(target=..., ...)`"""
+        ...
+
+    # # Messaging
+
+    def relay(self, message: Union[ShaderMessage, Type[ShaderMessage]]) -> Self:
+        """Send a message to all modules in the scene. Handle it defining a `self.handle(message)`"""
+        if isinstance(message, type):
+            message = message()
+        for module in self.scene.modules:
+            module.handle(message)
+        return self
+
+    @abstractmethod
+    def handle(self, message: ShaderMessage) -> None:
+        """Whenever a module relays a message on the scene, all modules are signaled via this method
+        for potentially acting on it. A Camera might move on WASD keys, for example"""
+        ...
+
+    def find(self, type: Type[ShaderModule]) -> Iterable[ShaderModule]:
+        for module in self.scene.modules:
+            if isinstance(module, type):
+                yield module
+
+    @property
+    @abstractmethod
+    def duration(self) -> float:
+        """Self-reported 'time to render' until the module is finished. A ShaderAudio shall export
+        the input audio duration, for example"""
+        return 0.0
+
+    @abstractmethod
+    def build(self) -> None:
+        """Create Textures, child ShaderModules, load base shaders, etc. Happens only once, and it's
+        a good place to set default values for attributes, such as a background image that can be
+        later changed on `self.setup()` or, better yet, on the CLI of the module/custom Scene"""
+        pass
+
+    @abstractmethod
+    def setup(self) -> None:
+        """Called every time before the initialization (rendering) of the Scene. Useful for managing
+        the behavior of batch exporting per export index; also a good place to reset values to their
+        defaults or create procedural objects (seeds) after `self.build()`"""
+        pass
+
+    @abstractmethod
+    def pipeline(self) -> Iterable[ShaderVariable]:
+        """Returns the list of variables that will be exported to all Shaders of the scene. The
+        first compilation happens after `self.build()`, where all variables are metaprogrammed into
+        the GLSL code. Subsequent calls happens after all `self.update()` on every frame and the
+        variables are updated to the yielded values here"""
+        return []
+
+    @abstractmethod
+    def update(self) -> None:
+        """Called every frame. This defines the main behavior of the module inside the event loop.
+        All non-ShaderModules are called first, then the former ones. Access state data directly
+        on the Scene with `self.scene.{dt,time,width,height,...}`"""
+        pass
+
+    @abstractmethod
+    def ffmpeg(self, ffmpeg: BrokenFFmpeg) -> None:
+        """When exporting the Scene, after the initial CLI configuration of FFmpeg by the Scene's
+        `self.main` method, all modules have an option to change the FFmpeg settings on the fly.
+        Note that this can also be implemented on a custom Scene itself, and behavior _can_ be
+        changed per batch exporting"""
+        pass
+
+    # ------------------------------------------|
+    # Stuff pending a remaster
+
+    def __process_include__(self, include: str) -> str:
+        return include.format({f"${k}": v for k, v in vars(self).items()})
+
+    @abstractmethod
+    def includes(self) -> Iterable[str]:
+        yield ""
+
+    @abstractmethod
+    def defines(self) -> Iterable[str]:
+        yield None
+
+    # # User interface
+
+    def __shaderflow_ui__(self) -> None:
+        """Basic info of a Module"""
+        # Todo: Make automatic Imgui methods
+
+        # Module - self.__ui__ must be implemented
+        if not getattr(self.__ui__, "__isabstractmethod__", False):
+            self.__ui__()
+
+        # Module - self.ui must be implemented
+        if not getattr(self.ui, "__isabstractmethod__", False):
+            self.ui()
+
+    @abstractmethod
+    def __ui__(self) -> None:
+        """Internal method for self.ui"""
+        pass
+
+    @abstractmethod
+    def ui(self) -> None:
+        """
+        Draw the UI for this module
+        """
+        pass
+
+# Avoid circular reference on Module importing partial Scene
+if TYPE_CHECKING:
+    from ShaderFlow.Scene import ShaderScene