unitytk 0.2.1__tar.gz → 0.3.0__tar.gz

{unitytk-0.2.1/unitytk.egg-info → unitytk-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitytk
-Version: 0.2.1
+Version: 0.3.0
 Summary: A modular Python toolkit for Unity interaction.
 Author-email: Ryan Simpson <m3trik@outlook.com>
 License: MIT

{unitytk-0.2.1 → unitytk-0.3.0}/test/test_articulated_rig_runtime.py

@@ -1671,7 +1671,7 @@ def _run_unity(test, temp_dir, execute_method, prepare, timeout=600):
     verifier; returns the parsed results (or skips on the license wall)."""
     editor = os.environ.get("UNITYTK_TEST_EDITOR")
     launcher = UnityLauncher(editor) if editor else UnityLauncher()
-    project_path = os.path.join(temp_dir, "UnityProject")
+    project_path = TempProjects.project(temp_dir)
     if not launcher.create_project(project_path, batch_mode=True):
         test.skipTest(UnityEnv.project_creation_reason())
     results_path = os.path.join(temp_dir, "unity_results.json")
@@ -1865,9 +1865,7 @@ class TestArticulatedRigRuntime(unittest.TestCase):
             for name in _bundle_assets()
         }
         self.assertEqual(got, expected, "Unity named a deployed asset differently")
-        package = TemplateDeployer.package_dir(
-            os.path.join(self.temp_dir, "UnityProject")
-        )
+        package = TemplateDeployer.package_dir(TempProjects.project(self.temp_dir))
         rewritten = []
         for name in _bundle_assets():
             path = os.path.join(package, *name.split("/")) + ".meta"

{unitytk-0.2.1 → unitytk-0.3.0}/test/test_asset_delivery.py

@@ -1,6 +1,7 @@
 # !/usr/bin/python
 # coding=utf-8
 """Tests for unitytk.CopyToAssetsDeliverer -- copy-to-Assets hand-off Strategy (no DCC)."""
+
 import json
 import os
 import struct
@@ -20,6 +21,7 @@ class _Logger:
         self.errors = []
         self.warnings = []
         self.infos = []
+        self.debugs = []
 
     def error(self, m, *args):
         self.errors.append(m % args if args else m)
@@ -30,6 +32,9 @@ class _Logger:
     def info(self, m, *args):
         self.infos.append(m % args if args else m)
 
+    def debug(self, m, *args):
+        self.debugs.append(m % args if args else m)
+
 
 def _carrier_fbx(path: str, channels) -> str:
     """A binary FBX (7700 layout) whose ``data_export`` carrier holds
@@ -108,7 +113,9 @@ def _payload(fbx, default_name="Export"):
 
 class SanitizeTest(unittest.TestCase):
     def test_strips_invalid_and_paths(self):
-        self.assertEqual(CopyToAssetsDeliverer.sanitize_asset_name("my/model:v2"), "my_model_v2")
+        self.assertEqual(
+            CopyToAssetsDeliverer.sanitize_asset_name("my/model:v2"), "my_model_v2"
+        )
 
     def test_collapses_and_trims(self):
         self.assertEqual(CopyToAssetsDeliverer.sanitize_asset_name("  a   b  "), "a b")
@@ -193,7 +200,9 @@ class DeliveryTest(unittest.TestCase):
         )
 
     def test_explicit_asset_name_overrides_and_sanitizes(self):
-        _bridge, result = self._deliver({"ASSET_NAME": "Hero/Mesh:01"}, default_name="Cube")
+        _bridge, result = self._deliver(
+            {"ASSET_NAME": "Hero/Mesh:01"}, default_name="Cube"
+        )
         self.assertEqual(os.path.basename(result["asset"]), "Hero_Mesh_01.fbx")
 
     def test_launch_mode_open_invokes_windowed_launch(self):
@@ -282,6 +291,7 @@ class DeliveryTest(unittest.TestCase):
         orig = ad.CopyToAssetsDeliverer._launch_editor
         # Patch UnityLauncher inside the real hook (deferred import target).
         import unitytk.launcher as launcher_mod
+
         real = launcher_mod.UnityLauncher
         launcher_mod.UnityLauncher = _FakeLauncher
         try:
@@ -344,15 +354,14 @@ class DeliveryTest(unittest.TestCase):
             )
             # Genuinely under Assets/ (no drive escape).
             assets = os.path.realpath(os.path.join(self.project, "Assets"))
-            self.assertTrue(
-                os.path.realpath(dest).startswith(assets), f"raw={raw!r}"
-            )
+            self.assertTrue(os.path.realpath(dest).startswith(assets), f"raw={raw!r}")
 
     def test_explicit_subdir_reducing_to_nothing_drops_into_assets_root(self):
         for raw in (".", "/", "../.."):
             _bridge, result = self._deliver({"ASSETS_SUBDIR": raw}, default_name="Cube")
             self.assertEqual(
-                result["asset"], os.path.join(self.project, "Assets", "Cube.fbx"),
+                result["asset"],
+                os.path.join(self.project, "Assets", "Cube.fbx"),
                 f"raw={raw!r}",
             )
             self.assertEqual(result["subdir"], "")
@@ -388,7 +397,11 @@ class SelfContainedDeliveryTest(unittest.TestCase):
         "lightmap_metadata": {
             "version": 1,
             "objects": [{"name": "Crate", "map": "Crate_Lightmap.exr", "uvIndex": 1}],
-            "probe": {"map": "Room_Probe.exr", "position": [0, 0, 0], "unit_scale": 0.01},
+            "probe": {
+                "map": "Room_Probe.exr",
+                "position": [0, 0, 0],
+                "unit_scale": 0.01,
+            },
         },
         "shadow_metadata": {
             "version": 2,
@@ -411,7 +424,12 @@ class SelfContainedDeliveryTest(unittest.TestCase):
         self.maps = os.path.join(self.tmp, "sourceimages")
         os.makedirs(self.maps)
         self.bytes = {}
-        for name in ("Crate_Lightmap.exr", "Room_Probe.exr", "Crate_shadow.png", "Crate_horizon.png"):
+        for name in (
+            "Crate_Lightmap.exr",
+            "Room_Probe.exr",
+            "Crate_shadow.png",
+            "Crate_horizon.png",
+        ):
             self.bytes[name] = name.encode() * 8
             with open(os.path.join(self.maps, name), "wb") as fh:
                 fh.write(self.bytes[name])

{unitytk-0.2.1 → unitytk-0.3.0}/test/test_audio_events_integration.py

@@ -24,6 +24,7 @@ Requires:
     - Maya 2025 installed (mayapy.exe)
     - Unity Hub with at least one editor installed
 """
+
 import os
 import json
 import shutil
@@ -34,7 +35,15 @@ import logging
 logger = logging.getLogger(__name__)
 
 import base_test  # noqa: F401 — sys.path bootstrap for the sibling repos
-from base_test import EnvSkip, MayaEnv, TempProjects, UnityEnv, UserPropsProbe
+from base_test import (
+    BlenderEnv,
+    CarrierFbx,
+    EnvSkip,
+    MayaEnv,
+    TempProjects,
+    UnityEnv,
+    UserPropsProbe,
+)
 
 scripts_dir = base_test.SCRIPTS_ROOT
 
@@ -471,9 +480,7 @@ class TestAudioEventsIntegration(unittest.TestCase):
             events,
             {("", 9, "footstep"), ("", 29, "jump"), ("", 44, "land")},
         )
-        self.assertEqual(
-            sorted(r["tracks"]), ["footstep", "jump", "land"]
-        )
+        self.assertEqual(sorted(r["tracks"]), ["footstep", "jump", "land"])
 
     # ------------------------------------------------------------------
     # Step 2: Unity import and readback
@@ -492,7 +499,7 @@ class TestAudioEventsIntegration(unittest.TestCase):
         # as the sibling integration tests.
         editor = os.environ.get("UNITYTK_TEST_EDITOR")
         launcher = UnityLauncher(editor) if editor else UnityLauncher()
-        project_path = os.path.join(self.temp_dir, "UnityProject")
+        project_path = TempProjects.project(self.temp_dir)
 
         logger.info(f"Creating Unity project: {project_path}")
         if not launcher.create_project(project_path, batch_mode=True):
@@ -552,17 +559,26 @@ class TestAudioEventsIntegration(unittest.TestCase):
                 full_log = f.read()
             # Surface AudioEvent / error / warning lines for analysis
             relevant = [
-                ln for ln in full_log.splitlines()
-                if any(s in ln for s in (
-                    "AudioEvent", "ERROR", "Error", "Warning",
-                    "NullReferenceException", "Failed",
-                ))
+                ln
+                for ln in full_log.splitlines()
+                if any(
+                    s in ln
+                    for s in (
+                        "AudioEvent",
+                        "ERROR",
+                        "Error",
+                        "Warning",
+                        "NullReferenceException",
+                        "Failed",
+                    )
+                )
             ]
             self.__class__.unity_log_relevant = relevant
             if relevant:
                 logger.info(
                     "Unity log relevant lines (%d):\n  %s",
-                    len(relevant), "\n  ".join(relevant[-40:])
+                    len(relevant),
+                    "\n  ".join(relevant[-40:]),
                 )
             else:
                 logger.info("Unity log: no AudioEvent/Warning/Error lines.")
@@ -571,8 +587,7 @@ class TestAudioEventsIntegration(unittest.TestCase):
         with open(results_path) as f:
             self.__class__.unity_results = json.load(f)
 
-        postproc_path = os.path.join(
-            self.temp_dir, UserPropsProbe.RESULTS_FILENAME)
+        postproc_path = os.path.join(self.temp_dir, UserPropsProbe.RESULTS_FILENAME)
         if os.path.exists(postproc_path):
             with open(postproc_path) as f:
                 self.__class__.postproc = json.load(f)
@@ -608,7 +623,8 @@ class TestAudioEventsIntegration(unittest.TestCase):
             f"in postprocessor results: {list(postproc)}",
         )
         self.assertIn(
-            "audio_manifest", props,
+            "audio_manifest",
+            props,
             f"audio_manifest user-property missing on {name}; saw: {list(props)}",
         )
         manifest = props["audio_manifest"]
@@ -655,7 +671,8 @@ class TestAudioEventsIntegration(unittest.TestCase):
 
         # (d) AnimationEvents injected on the imported clip
         self.assertGreaterEqual(
-            unity.get("clip_count", 0), 1,
+            unity.get("clip_count", 0),
+            1,
             "Expected at least one AnimationClip in the imported FBX",
         )
         events = unity.get("animation_events", [])
@@ -676,8 +693,8 @@ class TestAudioEventsIntegration(unittest.TestCase):
         # In Unity-frame terms the events are at clip-relative frames 9,
         # 29, 44 — which is what AnimationEvent.time * frameRate yields.
         self.assertEqual(events_by_name.get("footstep"), 9)
-        self.assertEqual(events_by_name.get("jump"),    29)
-        self.assertEqual(events_by_name.get("land"),    44)
+        self.assertEqual(events_by_name.get("jump"), 29)
+        self.assertEqual(events_by_name.get("land"), 44)
 
         # (e) Reimport idempotency.  Two probes injected before the
         # reimport tell us about both correctness and Unity behavior:
@@ -721,6 +738,140 @@ class TestAudioEventsIntegration(unittest.TestCase):
             )
 
 
+# ======================================================================
+# Carrier precedence: one audio_manifest per model, the scene's own first
+# ======================================================================
+
+CARRIER_VERIFIER_CS = r"""
+using UnityEngine;
+using UnityEditor;
+using System;
+using System.IO;
+using System.Linq;
+using System.Collections.Generic;
+
+public class AudioCarrierVerifier
+{
+    static string Q(string s) { return "\"" + (s ?? "").Replace("\\", "\\\\").Replace("\"", "\\\"") + "\""; }
+
+    public static void Verify()
+    {
+        var o = new List<string>();
+        try
+        {
+            // Again, now the clips are in the database: the startup import
+            // may have met the model before the audio.
+            AssetDatabase.ImportAsset("__FBX__",
+                ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
+            AssetDatabase.Refresh();
+            var prefab = AssetDatabase.LoadAssetAtPath<GameObject>("__FBX__");
+            o.Add("\"prefab\":" + (prefab != null ? "true" : "false"));
+            var nodes = prefab != null
+                ? prefab.GetComponentsInChildren<Transform>(true).Select(t => Q(t.name))
+                : Enumerable.Empty<string>();
+            o.Add("\"nodes\":[" + string.Join(",", nodes) + "]");
+            var ctrl = prefab != null ? prefab.GetComponent<AudioEventController>() : null;
+            o.Add("\"controller\":" + (ctrl != null ? "true" : "false"));
+            var clips = ctrl != null ? ctrl.clips : new List<AudioClip>();
+            o.Add("\"clips\":[" + string.Join(",", clips.Select(c => Q(c != null ? c.name : ""))) + "]");
+        }
+        catch (Exception e) { o.Add("\"error\":" + Q(e.GetType().Name + ": " + e.Message)); }
+        File.WriteAllText(@"__RESULTS__", "{" + string.Join(",\n", o) + "}");
+        EditorApplication.Exit(0);
+    }
+}
+"""
+
+
+class TestAudioCarrierPrecedence(unittest.TestCase):
+    """An FBX carrying ``audio_manifest`` on several carriers plays the
+    scene's own only.
+
+    An assembly ships a stray ``data_export1`` (and a module's
+    ``NS:data_export``) beside the scene's own, each holding the events as
+    last exported alone -- measured on an assembly, 2026-10-13. The scene's
+    own record is re-derived from the whole merged scene, so every reader
+    takes ONE carrier per channel, the scene's own first: the other
+    importers (``CarrierImport.Collect``), the GLB applier, and pythontk's
+    ``FbxMedia.audio_events``. The audio importer concatenated every
+    carrier's events instead, so the stray's stale event was bound and fired.
+
+    The fixture is a real FBX with both carriers (``base_test.CarrierFbx``,
+    written by a fresh Blender); pythontk's ``FbxMedia.audio_events`` pins the
+    same rule on the same shape (``test_fbx_media``).
+    """
+
+    FBX = "Assets/Delivered/assembly.fbx"
+
+    @classmethod
+    def setUpClass(cls):
+        cls.temp_dir = TempProjects.allocate("carrier_precedence")
+
+    @BlenderEnv.skip_unless_available()
+    @EnvSkip.unless(_unity_available(), "no Unity editor found")
+    def test_the_scenes_own_carrier_wins(self):
+        own = {"version": 2, "events": [{"clip": "", "frame": 0, "name": "footstep"}]}
+        stray = {"version": 2, "events": [{"clip": "", "frame": 3, "name": "door"}]}
+        fixture = CarrierFbx.build(
+            os.path.join(self.temp_dir, "assembly.fbx"),
+            {
+                "data_export": {"audio_manifest": own},
+                "data_export1": {"audio_manifest": stray},
+            },
+        )
+
+        launcher = UnityLauncher()
+        project = TempProjects.project(self.temp_dir)
+        if not launcher.create_project(project, batch_mode=True):
+            self.skipTest(UnityEnv.project_creation_reason())
+        delivered = os.path.join(project, "Assets", "Delivered")
+        os.makedirs(delivered, exist_ok=True)
+        shutil.copy2(fixture, os.path.join(delivered, "assembly.fbx"))
+        # Both tracks resolve, so only the carrier rule decides what binds.
+        for name in ("footstep", "door"):
+            CarrierFbx.wav(
+                os.path.join(project, "Assets", "Audio", f"{name}.wav"), name.encode()
+            )
+        TemplateDeployer.deploy_package(project, components=["audio_event"])
+        results = os.path.join(self.temp_dir, "unity_results.json")
+        editor_dir = os.path.join(project, "Assets", "Editor")
+        os.makedirs(editor_dir, exist_ok=True)
+        with open(
+            os.path.join(editor_dir, "AudioCarrierVerifier.cs"), "w", encoding="utf-8"
+        ) as fh:
+            fh.write(
+                CARRIER_VERIFIER_CS.replace("__FBX__", self.FBX).replace(
+                    "__RESULTS__", results
+                )
+            )
+        log = os.path.join(self.temp_dir, "unity_log.txt")
+        launcher.project_path = project
+        proc = launcher.launch_editor(
+            batch_mode=True,
+            execute_method="AudioCarrierVerifier.Verify",
+            log_file=log,
+            extra_args=["-quit"],
+            detached=False,
+        )
+        returncode = None
+        if proc:
+            try:
+                returncode = proc.wait(timeout=900)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                raise TimeoutError("Unity timed out")
+        UnityEnv.require_results(self, results, returncode, log)
+        with open(results) as fh:
+            unity = json.load(fh)
+        logger.info(f"Unity results:\n{json.dumps(unity, indent=2)}")
+        self.assertNotIn("error", unity, unity.get("error"))
+        self.assertTrue(unity["prefab"], unity)
+        # Premise: both carriers reached the import.
+        self.assertTrue({"data_export", "data_export1"} <= set(unity["nodes"]), unity)
+        self.assertTrue(unity["controller"], unity)
+        self.assertEqual(unity["clips"], ["footstep"], unity)
+
+
 if __name__ == "__main__":
     logging.basicConfig(level=logging.INFO)
     unittest.main()

{unitytk-0.2.1 → unitytk-0.3.0}/test/test_base_test.py

@@ -42,6 +42,7 @@ from base_test import (
     MayaEnv,
     SuiteOptions,
     TemplateSources,
+    TempProjects,
     TestAssets,
     UnityEnv,
     UserPropsProbe,
@@ -486,6 +487,83 @@ class UnityEnvTest(unittest.TestCase):
         self.assertEqual(result.errors, [])
         self.assertEqual(result.testsRun, 3)
 
+    def test_make_urp_fails_fast_on_a_project_too_deep_for_the_editor(self):
+        """The editor is not long-path aware: past MAX_PATH its package imports
+        fail, URP's Autodesk Interactive graph resolves to nothing, and the
+        material suite read the fallback pick as a product bug (2026-10-19)."""
+        deep = "C:\\" + "d" * (260 - UnityEnv.URP_IMPORT_DEPTH - 3)  # one past the limit
+
+        class Case(unittest.TestCase):
+            def test_deep(self):
+                UnityEnv.make_urp(self, None, deep, "unused.log")
+
+        result = _run_case(Case)
+        self.assertEqual(result.errors, [])
+        self.assertEqual(len(result.failures), 1)
+        self.assertIn("UNITYTK_TEMP_PROJECTS", result.failures[0][1])
+
+    def test_the_depth_gate_covers_every_shader_graph_urp_ships(self):
+        """The gate measured the Autodesk Interactive graph; URP's Arnold
+        transparent graph sits 25 characters deeper, so a 107-character project
+        passed it, that graph failed to import, URP's Arnold mapper left
+        aiStandardSurface on plain Lit and the material suite failed on every
+        run from the in-repo base (2026-10-19). Measured against each installed
+        editor's bundled URP, not a list of the graphs the suites use today."""
+        from unitytk import UnityFinder
+
+        packages = [
+            p
+            for p in map(UnityEnv.bundled_urp, UnityFinder.find_editors().values())
+            if os.path.isdir(p)
+        ]
+        if not packages:
+            self.skipTest(EnvSkip.reason(UnityEnv.NO_BUNDLED_URP))
+        deepest = UnityEnv.URP_IMPORT_DEPTH - len(UnityEnv.URP_PACKAGE_CACHE)
+        for package in packages:
+            for dirpath, dirnames, filenames in os.walk(package):
+                # A folder ending "~" (samples, docs) or hidden is never imported.
+                dirnames[:] = [d for d in dirnames if not d.endswith("~") and not d.startswith(".")]
+                for name in filenames:
+                    if name.endswith((".shadergraph", ".shadersubgraph")):
+                        below = os.path.join(dirpath, name)[len(package):]
+                        self.assertLessEqual(len(below), deepest, below)
+
+    @unittest.skipUnless(
+        os.name == "nt", "MAX_PATH is the Windows editor's limit; no Unity runs here"
+    )
+    def test_every_suite_fits_a_urp_project_under_the_default_base(self):
+        """A plain ``run_tests.py --all`` builds its projects under the in-repo
+        base, where ``<run>\\urp\\UnityProject`` put the material suite's URP
+        project at 107 characters: past the gate, so every URP suite failed at
+        once (2026-10-19). Every suite's prefix, not only today's URP suites:
+        any of them may call ``make_urp`` on its project, or add a ``"urp"`` one."""
+        prefixes = set()
+        # The allocator's own tests allocate into a sandboxed base, retired prefixes included.
+        for path in _source_files(".py", exclude=("test_temp_projects.py", "test_run_tests.py")):
+            with open(path, encoding="utf-8", errors="replace") as fh:
+                tree = ast.parse(fh.read(), filename=path)
+            for node in ast.walk(tree):
+                if (
+                    isinstance(node, ast.Call)
+                    and isinstance(node.func, ast.Attribute)
+                    and node.func.attr == "allocate"
+                    and getattr(node.func.value, "id", None) == "TempProjects"
+                    and node.args
+                    and isinstance(node.args[0], ast.Constant)
+                    and isinstance(node.args[0].value, str)
+                ):
+                    prefixes.add(node.args[0].value)
+        self.assertGreater(len(prefixes), 10, "the suites' allocations were not found")
+        # TempArtifacts' tag: the clock (16 hex digits), the pid in hex (6: Linux's
+        # pid_max ceiling; Windows ids run below it) and 4 random digits.
+        tag = "f" * (16 + 6 + 4)
+        budget = 259 - UnityEnv.URP_IMPORT_DEPTH
+        for prefix in sorted(prefixes):
+            run = os.path.join(TempProjects.DEFAULT_BASE, f"{prefix}_{tag}")
+            for project in (TempProjects.project(run), TempProjects.project(run, "urp")):
+                with self.subTest(project=project):
+                    self.assertLessEqual(len(project), budget, project)
+
 
 class SuiteOptionsTest(unittest.TestCase):
     """The opt-in switches are named once, neutrally."""

{unitytk-0.2.1 → unitytk-0.3.0}/test/test_blender_render_effects_e2e.py

@@ -351,7 +351,7 @@ class TestBlenderRenderEffectsE2E(unittest.TestCase):
             self.skipTest("Blender results not available -- test_01 must run first")
         editor = os.environ.get("UNITYTK_TEST_EDITOR")
         launcher = UnityLauncher(editor) if editor else UnityLauncher()
-        project_path = os.path.join(self.temp_dir, "UnityProject")
+        project_path = TempProjects.project(self.temp_dir)
         if not launcher.create_project(project_path, batch_mode=True):
             self.skipTest(UnityEnv.project_creation_reason())
         assets_path = os.path.join(project_path, "Assets")

{unitytk-0.2.1 → unitytk-0.3.0}/test/test_blender_shadow_plane_integration.py

@@ -606,7 +606,7 @@ class TestBlenderShadowPlaneIntegration(unittest.TestCase):
         blender = self._blender()
         editor = os.environ.get("UNITYTK_TEST_EDITOR")
         launcher = UnityLauncher(editor) if editor else UnityLauncher()
-        project_path = os.path.join(self.temp_dir, "UnityProject")
+        project_path = TempProjects.project(self.temp_dir)
         if not launcher.create_project(project_path, batch_mode=True):
             self.skipTest(UnityEnv.project_creation_reason())
 

{unitytk-0.2.1 → unitytk-0.3.0}/test/test_blender_shot_metadata_integration.py

@@ -232,7 +232,7 @@ class TestBlenderShotMetadataIntegration(unittest.TestCase):
             self.skipTest("Blender results not available -- test_01 must run first")
         editor = os.environ.get("UNITYTK_TEST_EDITOR")
         launcher = UnityLauncher(editor) if editor else UnityLauncher()
-        project_path = os.path.join(self.temp_dir, "UnityProject")
+        project_path = TempProjects.project(self.temp_dir)
         if not launcher.create_project(project_path, batch_mode=True):
             self.skipTest(UnityEnv.project_creation_reason())
 

{unitytk-0.2.1 → unitytk-0.3.0}/test/test_clip_name_contract_integration.py

@@ -264,7 +264,7 @@ class TestClipNameContract(unittest.TestCase):
 
         editor = os.environ.get("UNITYTK_TEST_EDITOR")
         launcher = UnityLauncher(editor) if editor else UnityLauncher()
-        project_path = os.path.join(self.temp_dir, "UnityProject")
+        project_path = TempProjects.project(self.temp_dir)
         if not launcher.create_project(project_path, batch_mode=True):
             self.skipTest(UnityEnv.project_creation_reason())
 

{unitytk-0.2.1 → unitytk-0.3.0}/test/test_controller_runtime_integration.py

@@ -181,7 +181,7 @@ class TestControllerRuntimeIntegration(unittest.TestCase):
         """Drive both controllers in a real Unity; capture the readback."""
         editor = os.environ.get("UNITYTK_TEST_EDITOR")
         launcher = UnityLauncher(editor) if editor else UnityLauncher()
-        project_path = os.path.join(self.temp_dir, "UnityProject")
+        project_path = TempProjects.project(self.temp_dir)
         if not launcher.create_project(project_path, batch_mode=True):
             self.skipTest(UnityEnv.project_creation_reason())
 

{unitytk-0.2.1 → unitytk-0.3.0}/test/test_deploy_templates.py

@@ -127,6 +127,12 @@ class DeployTemplateTest(unittest.TestCase):
                 "EmissiveGroup/EmissiveGroupController.cs",
                 "EmissiveGroup/EmissiveGroups.hlsl",
                 "EmissiveGroup/EmissiveGroupsLit.shader",
+                "LightmapMetadata/DeliverableCubeUV.hlsl",
+                "LightmapMetadata/DeliverableLit.shader",
+                "LightmapMetadata/DeliverablePmrem.cs",
+                "LightmapMetadata/DeliverableShading.cs",
+                "LightmapMetadata/DeliverableToneMap.shader",
+                "LightmapMetadata/DeliverableToneMapFeature.cs",
                 "LightmapMetadata/LightmapMetadataController.cs",
                 "M3trik.Unitytk.asmdef",
                 "MayaSurface/MayaSurfaceMaterialImporter.cs",
@@ -182,6 +188,63 @@ class DeployTemplateTest(unittest.TestCase):
                 f"{include} is not beside {shader}",
             )
 
+    @staticmethod
+    def _shader_pass(text, name):
+        """The ``Pass { ... }`` block of shader *text* named *name*, or None."""
+        at = text.find(f'Name "{name}"')
+        if at < 0:
+            return None
+        start = [m.start() for m in re.finditer(r"\bPass\s*\{", text[:at])][-1]
+        depth = 0
+        for i in range(text.index("{", start), len(text)):
+            depth += {"{": 1, "}": -1}.get(text[i], 0)
+            if depth == 0:
+                return text[start : i + 1]
+        return None
+
+    def test_forward_only_urp_shaders_draw_in_both_prepasses(self):
+        """A URP shader drawn by a ``UniversalForwardOnly`` pass also draws in
+        the depth prepass and the depth-normals prepass (SSAO, any feature
+        asking for normals), as URP's Unlit does: under depth priming the
+        forward pass tests depth for equality, so a shader missing the prepass's
+        pass drew nothing there. Each carries the instance and eye macros
+        single-pass instanced XR needs (its own, or those of URP's own pass it
+        includes); the normals pass writes the packed normals a Deferred
+        renderer asks for."""
+        def walk(ref, prefix=""):
+            for child in ref.iterdir():
+                if child.is_dir():
+                    yield from walk(child, prefix + child.name + "/")
+                elif child.name.endswith(".shader"):
+                    yield prefix + child.name, child.read_text(encoding="utf-8")
+
+        forward_only = {
+            name: text
+            for name, text in walk(resources.files(TEMPLATE_PACKAGE))
+            if re.search(r'"LightMode"\s*=\s*"UniversalForwardOnly"', text)
+        }
+        self.assertEqual(
+            sorted(forward_only),
+            ["EmissiveGroup/EmissiveGroupsLit.shader", "LightmapMetadata/DeliverableLit.shader"],
+        )
+        for name, text in forward_only.items():
+            for prepass in ("DepthOnly", "DepthNormalsOnly"):
+                block = self._shader_pass(text, prepass)
+                self.assertIsNotNone(block, f"{name} has no {prepass} pass")
+                self.assertRegex(block, rf'"LightMode"\s*=\s*"{prepass}"', f"{name} {prepass}")
+                self.assertRegex(block, r"ZWrite\s+On", f"{name} {prepass}")
+                if "universal/Shaders/UnlitDepthNormalsPass.hlsl" in block:
+                    continue  # URP's own pass, macros and all
+                for macro in (
+                    "UNITY_VERTEX_INPUT_INSTANCE_ID",
+                    "UNITY_VERTEX_OUTPUT_STEREO",
+                    "UNITY_SETUP_INSTANCE_ID",
+                    "UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO",
+                ):
+                    self.assertIn(macro, block, f"{name} {prepass}: no {macro}")
+            normals = self._shader_pass(text, "DepthNormalsOnly")
+            self.assertIn("_GBUFFER_NORMALS_OCT", normals, f"{name} DepthNormalsOnly")
+
     # ---------------------------------------------------------------- components
     def test_components_derive_from_the_bundle(self):
         """One required core plus one optional component per top-level folder,
@@ -366,6 +429,42 @@ class DeployTemplateTest(unittest.TestCase):
         self.assertIn("M3trik.Unitytk", data["references"])
         self.assertEqual(data["defineConstraints"], ["UNITYTK_XRI"])
 
+    def test_the_urp_define_starts_where_the_full_screen_pass_can_run_the_look(self):
+        """``UNITYTK_URP`` compiles ``DeliverableLook``, which sets
+        ``FullScreenPassRendererFeature.fetchColorBuffer`` and draws through
+        core's ``Blit.hlsl`` ``Vert``. Both arrived with URP 2022.3's backport
+        of the feature's fixes (in 14.0.9; 14.0.0-14.0.7 have no such field and
+        never set the ``_BlitScaleBias`` that vertex reads). A lower floor fails
+        the whole package's compile on those versions, not just the look."""
+        data = json.loads(bundle_ref("M3trik.Unitytk.asmdef").read_text(encoding="utf-8"))
+        urp = [d for d in data["versionDefines"] if d["define"] == "UNITYTK_URP"]
+        self.assertEqual(len(urp), 1, data["versionDefines"])
+        self.assertEqual(urp[0]["name"], "com.unity.render-pipelines.universal")
+        self.assertEqual(urp[0]["expression"], "14.0.9")
+        # A reference URP does not have is skipped: a Built-in project compiles.
+        self.assertIn("Unity.RenderPipelines.Universal.Runtime", data["references"])
+
+    def test_the_full_screen_pass_is_named_as_both_urps_declare_it(self):
+        """URP 14 declares ``FullScreenPassRendererFeature`` in the global
+        namespace, URP 17 in ``UnityEngine.Rendering.Universal`` (its
+        ``[MovedFrom("")]``). Only the short name, under a ``using`` of that
+        namespace, compiles on both: the qualified name failed the whole
+        package's compile on URP 14, where ``UNITYTK_URP`` starts."""
+        def walk(ref, prefix=""):
+            for child in ref.iterdir():
+                if child.is_dir():
+                    yield from walk(child, prefix + child.name + "/")
+                elif child.name.endswith(".cs"):
+                    yield prefix + child.name, child.read_text(encoding="utf-8")
+
+        named = []
+        for name, text in walk(resources.files(TEMPLATE_PACKAGE)):
+            self.assertNotIn("Universal.FullScreenPassRendererFeature", text, name)
+            if re.search(r"\bFullScreenPassRendererFeature\b", text):
+                named.append(name)
+                self.assertIn("using UnityEngine.Rendering.Universal;", text, name)
+        self.assertEqual(named, ["LightmapMetadata/DeliverableToneMapFeature.cs"])
+
     def test_status_sees_subfolder_files(self):
         """A missing file inside a component's subfolder is a partial deploy
         of that component, named by its bundle-relative name."""