@gripforgeai/mcp 0.1.10 → 0.1.12

package/runtime/unreal_scene_math.py

@@ -0,0 +1,96 @@
+"""Renderer-independent scene transforms used by the Unreal scene worker (metres, Y up)."""
+import math
+
+
+def exposure_brightness(ev100, extended_range):
+    """UE's same property means EV100 in extended projects, luminance in legacy projects."""
+    return ev100 if extended_range else 2.0 ** ev100
+
+
+def identity():
+    return [[1 if i == j else 0 for j in range(4)] for i in range(4)]
+
+
+def multiply(a, b):
+    return [[sum(a[i][k] * b[k][j] for k in range(4)) for j in range(4)] for i in range(4)]
+
+
+def matrix(transform):
+    t, q, s = (transform[k] for k in ('translation', 'rotation', 'scale'))
+    x, y, z, w = (q[k] for k in 'xyzw')
+    length = math.sqrt(x*x + y*y + z*z + w*w)
+    if length < 1e-9:
+        raise ValueError('Zero scene quaternion')
+    x, y, z, w = (v / length for v in (x, y, z, w))
+    r = [[1-2*(y*y+z*z), 2*(x*y-z*w), 2*(x*z+y*w), t['x']],
+         [2*(x*y+z*w), 1-2*(x*x+z*z), 2*(y*z-x*w), t['y']],
+         [2*(x*z-y*w), 2*(y*z+x*w), 1-2*(x*x+y*y), t['z']], [0, 0, 0, 1]]
+    for i in range(3):
+        for j, key in enumerate('xyz'):
+            r[i][j] *= s[key]
+    return r
+
+
+def world_matrices(nodes):
+    by_id, done, visiting = {n['id']: n for n in nodes}, {}, set()
+    def visit(key):
+        if key in done:
+            return done[key]
+        if key in visiting:
+            raise ValueError('Cyclic scene hierarchy at ' + key)
+        visiting.add(key)
+        node = by_id[key]
+        parent = visit(node['parentId']) if node.get('parentId') else identity()
+        done[key] = multiply(parent, matrix(node['transform']))
+        visiting.remove(key)
+        return done[key]
+    for node in nodes:
+        visit(node['id'])
+    return done
+
+
+def point(m, p):
+    return [sum(m[i][j] * p[j] for j in range(3)) + m[i][3] for i in range(3)]
+
+
+def ue_matrix(m):
+    # Same axis conversion as Unreal's GLTFCore importer: (x, y, z) -> (x, z, y).
+    order = [0, 2, 1, 3]
+    converted = [[m[order[i]][order[j]] for j in range(4)] for i in range(4)]
+    for i in range(3):
+        converted[i][3] *= 100
+    return converted
+
+
+def decompose(m):
+    s = [math.sqrt(sum(m[i][j]**2 for i in range(3))) for j in range(3)]
+    if min(s) < 1e-8:
+        raise ValueError('Zero-scale scene instance')
+    det = (m[0][0]*(m[1][1]*m[2][2]-m[1][2]*m[2][1])
+           - m[0][1]*(m[1][0]*m[2][2]-m[1][2]*m[2][0])
+           + m[0][2]*(m[1][0]*m[2][1]-m[1][1]*m[2][0]))
+    if det < 0:
+        s[0] *= -1
+    r = [[m[i][j] / s[j] for j in range(3)] for i in range(3)]
+    if any(abs(sum(r[k][i]*r[k][j] for k in range(3))) > 1e-4 for i in range(3) for j in range(i+1, 3)):
+        raise ValueError('Sheared hierarchy requires baking geometry before Unreal import')
+    trace = sum(r[i][i] for i in range(3))
+    if trace > 0:
+        k = math.sqrt(trace+1)*2
+        q = [(r[2][1]-r[1][2])/k, (r[0][2]-r[2][0])/k, (r[1][0]-r[0][1])/k, k/4]
+    else:
+        i = max(range(3), key=lambda a: r[a][a]); j, h = (i+1)%3, (i+2)%3
+        k = math.sqrt(1+r[i][i]-r[j][j]-r[h][h])*2
+        q = [0, 0, 0, (r[h][j]-r[j][h])/k]
+        q[i], q[j], q[h] = k/4, (r[j][i]+r[i][j])/k, (r[h][i]+r[i][h])/k
+    return [m[i][3] for i in range(3)], q, s
+
+
+def native_transform(scene_matrix, source=None):
+    m = ue_matrix(scene_matrix)
+    if source and source.get('pivot') == 'bounds_base':
+        origin, extent = source['origin'], source['extent']
+        anchor = [origin[0], origin[1], origin[2]-extent[2]]
+        for i in range(3):
+            m[i][3] -= sum(m[i][j] * anchor[j] for j in range(3))
+    return decompose(m)

package/runtime/unreal_spawn_review.py

@@ -0,0 +1,135 @@
+"""Bounded PIE spawn review. Importable without Unreal for report regression tests."""
+import math
+import time
+
+
+def assess_spawn_samples(starts, samples, duration=6, tolerance_cm=200, require_grounded=True):
+    """Native centimetres, simulation seconds; never infer collision from a mesh flag."""
+    report = dict(status='failed', expected_starts=starts, samples=samples, issues=[],
+                  checks=['spawn_position', 'fall_distance'] + (['character_grounding'] if require_grounded else []))
+    issues = report['issues']
+    if not starts:
+        issues.append('no_authored_player_start')
+    if not samples:
+        issues.append('no_player_pawn')
+        return report
+    first, last = samples[0], samples[-1]
+    nearest = min(starts, key=lambda s: math.dist(s['position'], first['position'])) if starts else None
+    if nearest:
+        report['matched_start'] = nearest['id']
+        report['initial_distance_cm'] = math.dist(nearest['position'], first['position'])
+        if report['initial_distance_cm'] > tolerance_cm:
+            issues.append('game_mode_ignored_player_start')
+        if min(s['position'][2] for s in samples) < nearest['position'][2] - tolerance_cm:
+            issues.append('fell_below_spawn')
+    if last['time'] - first['time'] < duration - .05:
+        issues.append('observation_incomplete')
+    if len({s['pawn'] for s in samples}) != 1:
+        issues.append('pawn_replaced_during_review')
+    if require_grounded:
+        tail = [s for s in samples if s['time'] >= last['time'] - 1]
+        if any(s.get('grounded') is None for s in samples):
+            issues.append('ground_check_requires_character')
+        elif len(tail) < 2 or tail[-1]['time'] - tail[0]['time'] < .5 or not all(s['grounded'] and not s['falling'] for s in tail):
+            issues.append('character_not_stably_grounded')
+    report['status'] = 'failed' if issues else 'passed'
+    return report
+
+
+class SpawnReview:
+    """Owns only the PIE session it starts. Caller polls from a Slate tick."""
+
+    def __init__(self, starts, duration=6, tolerance_cm=200, require_grounded=True):
+        import unreal
+        self.ue = unreal
+        self.levels = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
+        self.editor = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
+        self.starts, self.duration, self.tolerance = starts, duration, tolerance_cm
+        self.require_grounded = require_grounded
+        self.samples, self.settings_before = [], {}
+        self.started_at = None
+        self.owns_session = False
+        self.result = None
+        self.settings = None
+        self.world_path = None
+
+    def start(self):
+        if self.levels.is_in_play_in_editor() or self.editor.get_game_world():
+            return False  # Never take over or stop the user's play session.
+        ue = self.ue
+        # This editor-only class is not exported as unreal.LevelEditorPlaySettings
+        # in every UE distribution. Resolve its reflected native class explicitly.
+        self.settings = ue.get_default_object(ue.load_class(None, '/Script/UnrealEd.LevelEditorPlaySettings'))
+        # UE 5.7 does not expose EPlayNetMode to Python. Preserve that setting
+        # and check the resulting world's mode instead of guessing its value.
+        values = dict(PlayNumberOfClients=1,
+                      RunUnderOneProcess=True, bLaunchSeparateServer=False,
+                      GameGetsMouseControl=False, AutoRecompileBlueprints=False)
+        try:
+            for key, value in values.items():
+                self.settings_before[key] = self.settings.get_editor_property(key)
+                self.settings.set_editor_property(key, value)
+            # LevelEditorSubsystem requests the default PlayerStart, with no
+            # camera-location override. This must exercise the real GameMode.
+            self.levels.editor_request_begin_play()
+            self.owns_session = True
+            self.started_at = time.monotonic()
+        except Exception:
+            self.close()
+            raise
+        return True
+
+    def close(self):
+        if self.owns_session:
+            self.levels.editor_request_end_play()
+            self.owns_session = False
+        if self.settings:
+            for key, value in self.settings_before.items():
+                self.settings.set_editor_property(key, value)
+        self.settings_before.clear()
+
+    def finish(self, extra_issue=None):
+        self.result = assess_spawn_samples(self.starts, self.samples, self.duration, self.tolerance, self.require_grounded)
+        if extra_issue:
+            self.result['issues'].append(extra_issue)
+            self.result['status'] = 'failed'
+        self.result['world'] = self.world_path
+        self.close()
+        return self.result
+
+    def poll(self):
+        if self.result is not None:
+            return self.result
+        if self.started_at is None:
+            raise RuntimeError('Start the spawn review before polling.')
+        if time.monotonic() - self.started_at > 60:
+            return self.finish('pie_review_timeout')
+        world = self.editor.get_game_world()
+        if not world:
+            return self.finish('play_session_ended_early') if self.world_path else None
+        self.world_path = world.get_path_name()
+        ue = self.ue
+        if not ue.SystemLibrary.is_standalone(world):
+            return self.finish('standalone_play_mode_required')
+        pawn = ue.GameplayStatics.get_player_pawn(world, 0)
+        if not pawn:
+            return self.finish('player_pawn_disappeared') if self.samples else None
+        sim_time = ue.GameplayStatics.get_time_seconds(world)
+        if self.samples and sim_time - self.samples[-1]['time'] < .2:
+            return None
+        position = pawn.get_actor_location()
+        movement = pawn.get_component_by_class(ue.CharacterMovementComponent)
+        sample = dict(time=sim_time, pawn=pawn.get_path_name(), position=[position.x, position.y, position.z],
+                      grounded=movement.is_moving_on_ground() if movement else None,
+                      falling=movement.is_falling() if movement else None)
+        self.samples.append(sample)
+        if len(self.samples) == 1:
+            mode = ue.GameplayStatics.get_game_mode(world)
+            self.game_mode = mode.get_class().get_path_name() if mode else None
+        complete = sim_time - self.samples[0]['time'] >= self.duration
+        wrong_spawn = min(math.dist(s['position'], self.samples[0]['position']) for s in self.starts) > self.tolerance
+        if complete or wrong_spawn:
+            result = self.finish()
+            result['game_mode'] = self.game_mode
+            return result
+        return None