ogre-glslwright 0.1.1__py3-none-any.whl

glslwright/__init__.py

@@ -0,0 +1,165 @@
+"""Pure-python shader-graph core: data model and codegen."""
+
+from pathlib import Path
+from ._version import __version__
+
+import Ogre
+
+from .grapheditor import GraphEditor
+
+# Generated files default to a local output dir next to the package;
+# callers (e.g. the editor app) are expected to pass an explicit outDir.
+DEFAULT_OUTPUT_DIR = Path.cwd() / "shadergen"
+
+# The resource group actually used by the last initResourceDir() call -
+# may differ from the requested *groupname* (see rename below), so
+# callers that parse/open generated resources must use this, not a
+# hardcoded name, or #include lookups scoped to that group will fail.
+RESOURCE_GROUP = None
+
+# Other resource groups whose textures/materials should also be visible
+# to generated shader materials (e.g. a host app's own asset group) -
+# set via initResourceDir()'s extraGroups, kept generic so this library
+# stays agnostic of any particular host application.
+EXTRA_RESOURCE_GROUPS = ()
+
+
+def initResourceDir(output='./glslwright', groupname='glslwright',
+                     extraGroups=()):
+    """Initialize the resource directory for GLSL WRIGHT.
+
+    Arguments
+    ---------
+    output (str):
+        The output directory for generated material and graph files.
+    groupname (str):
+        The resource group name to use.
+    extraGroups (tuple[str]):
+        Other already-registered resource groups (e.g. the host app's
+        own asset group) whose locations are mirrored into *groupname*,
+        so generated materials can reference their textures by filename.
+
+    Returns the actual resource group name used (see RESOURCE_GROUP).
+    """
+
+    rgMgr = Ogre.ResourceGroupManager.getSingleton()
+    if rgMgr.resourceGroupExists(groupname) and rgMgr.isResourceGroupInitialised(
+        groupname
+    ):
+        # Can't force a re-parse of new locations on an already-initialised
+        # group (unload/reinit doesn't reset Ogre's internal parsed flag, and
+        # the bindings don't expose a script-only reparse call) - use our own
+        # group instead. findMaterial() falls back to an autodetect lookup
+        # across groups, so this is still discoverable under *groupname*.
+        groupname = f"{groupname}_glslwright"
+
+    if not rgMgr.resourceGroupExists(groupname):
+        rgMgr.createResourceGroup(groupname)
+
+    outputPath = Path(output).resolve()
+    outputPath.mkdir(parents=True, exist_ok=True)
+
+    print(f"Initializing resource directory at: {outputPath}")
+    global DEFAULT_OUTPUT_DIR, RESOURCE_GROUP, EXTRA_RESOURCE_GROUPS
+    DEFAULT_OUTPUT_DIR = outputPath
+    RESOURCE_GROUP = groupname
+    EXTRA_RESOURCE_GROUPS = tuple(extraGroups)
+
+    # Track locations already added to *groupname* in this call so
+    # mirrored extraGroup locations that coincide with ones added above
+    # (or with each other, e.g. two groups sharing Ogre's media dir)
+    # aren't parsed twice - that triggers a "Skipping ... already exists"
+    # warning per script file for every duplicate.
+    addedLocations = set()
+
+    def _addLocation(location):
+        location = str(location)
+        # Normalize so a relative string and Ogre's own (resolved) path
+        # for the same directory are recognized as the same location -
+        # otherwise it gets parsed twice into *groupname*, which Ogre
+        # reports as a "Skipping ... already exists" warning per file.
+        key = str(Path(location).resolve())
+        if key in addedLocations:
+            return
+        addedLocations.add(key)
+        rgMgr.addResourceLocation(location, "FileSystem", groupname)
+
+    _addLocation(outputPath)
+    _addLocation(Path(__file__).parent / "material")
+    # shaderNodes.glsl #includes Ogre's RTShaderSystem lib (RTSLib_*/
+    # FFPLib_*/SGXLib_*) - #include lookups are scoped to the program's
+    # own resource group, so that media dir must be added here too
+    _addLocation(
+        Ogre.Bites.ApplicationContextBase.getDefaultMediaDir() + "/RTShaderLib"
+    )
+
+    # Some runtimes place RTShaderLib next to the app/resources.cfg
+    # instead of under Ogre's default media dir.
+    for candidate in (
+        Path.cwd() / "RTShaderLib",
+        Path(__file__).resolve().parents[4] / "RTShaderLib",
+    ):
+        if (candidate / "RTSLib_Colour.glsl").exists():
+            _addLocation(candidate)
+    # OgreUnifiedShader.h, included by every generated program, usually
+    # lives in Ogre's shared media dir.
+    _addLocation(
+        Ogre.Bites.ApplicationContextBase.getDefaultMediaDir() + "/Main"
+    )
+
+    # Some packagings (including OpenGate's assets) ship this header in
+    # project-local materials dirs instead of Ogre's default media path.
+    # Mirror any known local location into *groupname* so #include lookup
+    # in generated programs still resolves.
+    for candidate in (
+        Path.cwd() / "assets" / "materials",
+        Path(__file__).resolve().parents[4] / "assets" / "materials",
+    ):
+        if (candidate / "OgreUnifiedShader.h").exists():
+            _addLocation(candidate)
+
+    # generated materials reference project textures (e.g. via the
+    # shader graph's Texture node) by filename only - mirror each extra
+    # group's locations here too, or lookups fail with "Cannot locate
+    # resource" since a material's own resource group is searched, not
+    # RGN_AUTODETECT
+    # Mirror Ogre's internal group by default so any RTShaderLib
+    # location discovered by host app bootstrap is visible here too.
+    allExtraGroups = list(EXTRA_RESOURCE_GROUPS)
+    internalGroup = Ogre.RGN_INTERNAL
+    if internalGroup not in allExtraGroups:
+        allExtraGroups.append(internalGroup)
+
+    for extraGroup in allExtraGroups:
+        if not rgMgr.resourceGroupExists(extraGroup):
+            continue
+        locations = rgMgr.listResourceLocations(extraGroup)
+        for i in range(locations.size()):
+            _addLocation(locations.__getitem__(i))
+
+    if not rgMgr.isResourceGroupInitialised(groupname):
+        try:
+            rgMgr.initialiseResourceGroup(groupname)
+        except RuntimeError as e:
+            # Samplers/global objects from RTShaderLib's own scripts are
+            # shared across groups and already exist once the main
+            # "Opengate" group has initialised them - harmless here.
+            if "already exists" not in str(e):
+                raise
+
+    return groupname
+
+def _r(*message):
+    print(f"[ERROR glslwright] {' '.join(str(m) for m in message)}")
+
+def _y(*message):
+    print(f"[WARNING glslwright] {' '.join(str(m) for m in message)}")
+
+def _b(*message):
+    print(f"[DEBUG glslwright] {' '.join(str(m) for m in message)}")
+
+def _g(*message):
+    print(f"[INFO glslwright] {' '.join(str(m) for m in message)}")
+
+
+__all__ = ["__version__", "GraphEditor", "_r", "_y", "_b", "_g"]

glslwright/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.1'
+__version_tuple__ = version_tuple = (0, 1, 1)
+
+__commit_id__ = commit_id = None

glslwright/app.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python
+"""Standalone glslwright main window, built on ogre-meshviewer.
+
+Reuses MeshViewer's Ogre/ApplicationContext/ImGui boilerplate (render
+window, camera, resource groups, ...) as the host render environment,
+without modifying the ogre-meshviewer checkout, and overlays the
+shader node-graph editor on top of it.
+"""
+
+import os
+from pathlib import Path
+from .meshviewerloader import loadMeshViewerModule
+from .grapheditor import GraphEditor
+
+
+def _set_windows_dpi_awareness():
+    """Enable best-available Windows DPI-awareness before SDL/Ogre windowing."""
+    if os.name != "nt":
+        return
+
+    # Let SDL opt into per-monitor-v2 awareness where supported.
+    os.environ.setdefault("SDL_WINDOWS_DPI_AWARENESS", "permonitorv2")
+
+    try:
+        import ctypes
+
+        # Windows 10/11: Per-Monitor v2 (best quality on mixed-DPI setups).
+        user32 = ctypes.windll.user32
+        if user32.SetProcessDpiAwarenessContext(ctypes.c_void_p(-4)):
+            return
+    except Exception:
+        pass
+
+    try:
+        import ctypes
+
+        # Windows 8.1 fallback: Per-Monitor.
+        ctypes.windll.shcore.SetProcessDpiAwareness(2)
+        return
+    except Exception:
+        pass
+
+    try:
+        import ctypes
+
+        # Legacy fallback.
+        ctypes.windll.user32.SetProcessDPIAware()
+    except Exception:
+        pass
+
+
+_set_windows_dpi_awareness()
+
+_mv = loadMeshViewerModule()
+
+
+class GlslWrightGui(_mv.MeshViewerGui):
+    """MeshViewerGui plus the glslwright shader node-graph panel."""
+
+    def __init__(self, app, graphEditor):
+        super().__init__(app)
+        self.graphEditor = graphEditor
+
+    def preRenderTargetUpdate(self, evt):
+        super().preRenderTargetUpdate(evt)
+        if self.graphEditor.isVisible():
+            self.graphEditor.renderImGui()
+
+
+class _PropOverlayStub:
+    """Minimal stand-in for Opengate's propOverlay: exposes `.item` only."""
+
+    def __init__(self, item=None):
+        self.item = item
+
+
+class GlslWrightApp(_mv.MeshViewer):
+    """MeshViewer subclass hosting the glslwright node editor."""
+
+    def __init__(
+        self,
+        infile=None,
+        rescfg=None,
+        outputPath="./examples",
+        materialName=None,
+    ):
+        self.outputPath = outputPath
+        if materialName is not None and materialName.endswith(".toml"):
+            materialName = Path(materialName).stem
+
+        self.materialName = materialName
+        super().__init__(infile, rescfg)
+
+    def setup(self):
+        super().setup()
+
+        self.graphEditor = GraphEditor(outputPath=self.outputPath)
+        self.graphEditor.app = self
+        self.graphEditor.registerInput(self)
+        self.sm = self.scn_mgr
+        if self.materialName:
+            self.graphEditor.selectMaterial(self.materialName)
+
+        # swap in our GUI subclass, reusing MeshViewer's public
+        # listener API instead of touching its internals
+        self.getRenderWindow().removeListener(self.gui)
+        self.gui = GlslWrightGui(self, self.graphEditor)
+        self.getRenderWindow().addListener(self.gui)
+
+        # Without a tracked MaterialListener, live-reload falls back to
+        # reloadMaterial(sm=None), which unloads/reparses the material
+        # but can't repoint the previewed entity's SubEntity at the new
+        # instance -- it's left referencing a freed Material/GpuProgram
+        # and segfaults on the next render. Assign to the meshviewer
+        # preview's own SubEntity up front, so it's always the live
+        # assign/supervision target, matching ogre-meshviewer's SubMesh
+        # preview.
+        materialListener = self._previewMaterialListener()
+        if materialListener is not None:
+            self.propOverlay = _PropOverlayStub(materialListener)
+            self.graphEditor._assignToMaterialListener(materialListener)
+
+    def _previewMaterialListener(self):
+        """Return the loaded preview mesh's first SubEntity, if any."""
+        if self.entity is None:
+            return None
+        subEntities = self.entity.getSubEntities()
+        return subEntities[0] if subEntities else None
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="GLSL Wright")
+    parser.add_argument(
+        "infile",
+        nargs="?",
+        help="preview mesh/scene for the shader (opens a file picker if omitted)",
+    )
+    parser.add_argument(
+        "materialName",
+        nargs="?",
+        help="materialName to load into the graph editor on startup",
+    )
+    parser.add_argument("-c", "--rescfg", help="path to the resources.cfg")
+    args = parser.parse_args()
+
+    app = GlslWrightApp(
+        args.infile, args.rescfg, materialName=args.materialName
+    )
+    # ogre_mesh_viewer.py reads/writes a module-level "app" global
+    # instead of self.app in several places; mirror its own __main__
+    # guard here since we don't run that guard.
+    _mv.app = app
+
+    while True:  # allow auto restart (e.g. render system change)
+        try:
+            app.initApp()
+            app.getRoot().startRendering()
+            app.closeApp()
+        except RuntimeError as e:
+            raise SystemExit(e) from e
+
+        if not app.restart:
+            break
+
+
+if __name__ == "__main__":
+    main()