Makefile

PY := .venv/bin/python
PYTEST := .venv/bin/pytest
RUFF := .venv/bin/ruff
# Keep native tools consistent with the Python development environment, including sub-makes.
export PATH := $(abspath .venv/bin):$(PATH)
.DEFAULT_GOAL := help

.PHONY: debug-draw
debug-draw:
	MOJIVE_RENDERER=$(BACKEND) $(PY) examples/debug_draw.py $(ARGS)

.PHONY: recording-layers
.PHONY: camera-tracking
.PHONY: keyframe-timeline
.PHONY: take-video

take-video:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.take_video $(ARGS)

keyframe-timeline:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.keyframe_timeline $(ARGS)

.PHONY: timeline-profile
## Profile 100 to 100,000 keys; add ARGS='--capture' for Linux EGL panel captures.
timeline-profile:
	$(PY) -m mojive.tools.timeline_profile $(ARGS)

camera-tracking:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.camera_tracking $(ARGS)

.PHONY: camera-navigation
.PHONY: contact-style
## Capture contact shapes/colors and exercise their settings and scene capture.
contact-style: $(if $(filter bgfx,$(BACKEND)),native-python-build)
	$(if $(filter bgfx,$(BACKEND)),MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))") MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_contact_style.py

## Exercise saved focus/zoom settings and extreme native wheel input.
camera-navigation: camera-focus
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_camera_navigation.py

.PHONY: camera-focus
## Capture object focus from offset/away/below views and verify joint/camera/light focus.
camera-focus:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_camera_tracking.py -k double_click
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_ui_interaction.py -k double_clicking_joint_and_hierarchy
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_joint_focus_readability.py

.PHONY: camera-helpers
## Capture double-click focus on moving and world-attached cameras and lights.
camera-helpers:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m "gpu and physics" tests/gpu/test_camera_tracking.py -k double_click

recording-layers:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.recording_layers $(ARGS)
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_recording_layers.py -k narrow_status

.PHONY: rollout-video
.PHONY: passive-viewer
.PHONY: physics-render-benchmark
.PHONY: physics-concurrency

physics-render-benchmark:
	$(PY) -m mojive.tools.physics_render_benchmark $(ARGS)

HUMANOIDS_MODEL ?= $(firstword $(MUJOCO_MODEL_ROOTS))/humanoid/100_humanoids.xml
physics-concurrency:
	$(PY) -m mojive.tools.physics_render_benchmark --production \
		--workloads joint_types,cloth_stress,humanoids100 --humanoids-model "$(HUMANOIDS_MODEL)" \
		--seconds 6 --warmup 36 --output output/physics-concurrency $(ARGS)

passive-viewer:
	$(PY) examples/passive_viewer.py $(ARGS)

.PHONY: help setup check lint fmt docs docs-check docs-serve examples-check test test-fast test-integration test-physics test-all gpu gpu-bgfx egl p0 p1 renderer-api renderer-benchmark renderer-benchmark-full golden golden-accept parity calibrate gallery ui-feasibility ui-runtime readme-media ui-frame-profile ui-gallery tool-icons mouse-icons gizmo-gallery hidpi-gallery model-loading model-composition mjcf-roundtrip editor-performance stability rpc-soak format-validation scene-io editor-files entity-edit undo-redo remote-authoring additive bench showcase probe reverse viewer egl-viewer hidpi empty editor settings workspace-edit canvas canvas-2d lighting image-light many-lights material-parity material-parity-accept texture-minification local-shadow-precision shadow-quality shadow-scheduling scene-icons scene-entities text-overlay capture record serve attach live-view snapshot-record snapshot-replay camera-state scene-snapshot cli rpc toy-physics adapter-conformance inspector gizmo joint-gizmo primitive-authoring material-authoring contact-authoring body-authoring resource-authoring asset-browser joint-site-authoring model-component-authoring keyframe-authoring batch-editing perturb reflect outline robot mujoco-physics mujoco-audit mujoco-model-suite mujoco-visuals mujoco-debug mujoco-actuators mujoco-slider-crank mujoco-solver-diagnostics mujoco-islands mujoco-bvh mujoco-convex-hull mujoco-rangefinder mujoco-constraints mujoco-editing mujoco-overlays cameras camera-intrinsics geom-groups deformables assets backends doctor clean

help:
	@printf '%s\n' \
		'Interactive:' \
		'  make viewer             default MuJoCo scene' \
		'  make native-viewer      build and launch the C++/bgfx Viewer' \
		'  make native-wayland-viewer interactive viewer in a nested Wayland desktop' \
		'  make native-editor      C++/bgfx scene editor' \
		'  make native-parity      compare native/OpenGL render products' \
		'  make native-model-parity verify live rigid, skin, and flex scenes' \
		'  make native-wheel-test  build, install, and verify the native wheel' \
		'  make passive-viewer     independent physics and display rates with captures' \
		'  make viewer-managed     MuJoCo-style managed viewer; Mojive steps physics' \
		'  make viewer-passive     MuJoCo-style passive viewer; caller steps physics' \
		'  make egl-viewer         Linux viewer with a GLFW EGL context' \
		'  make hidpi              viewer with an explicit 200% UI scale' \
		'  make empty              empty viewer; load MJCF or URDF from File menu' \
		'  make editor             empty Mojive workspace; combine MJCF/URDF and entities' \
		'  make settings           editor with the dockable Settings panel open' \
		'  make workspace-edit     workspace, MjSpec topology, camera and light acceptance' \
		'  make model-loading      empty, MJCF, and URDF loading reference images' \
		'  make model-composition  add and remove MJCF/URDF models at runtime' \
		'  make mjcf-roundtrip     export edited workspaces as re-loadable MJCF' \
		'  make editor-performance composition editing performance baseline' \
		'  make editor-soak        sustained hidden editing and recovery measurements' \
		'  make editor-tail-profile attribute slow editing frames and GC pauses' \
		'  make stability          long-frame, large-model, and multi-camera gates' \
		'  make rpc-soak           persistent RPC, concurrency, timeout, and recovery' \
		'  make rpc-benchmark      real socket load, frame budgets, and input latency' \
		'  make format-validation  current scene snapshot and recording formats' \
		'  make robot             Unitree Go2; downloads on first run' \
		'  make outline           selection and antialiased outline' \
		'  make inspector         compact Inspector transform reference image' \
		'  make ui-feasibility    interactive M1-M18 UI feasibility probe' \
		'  make ui-components     compare production widgets and local corner experiments' \
		'  make ui-optical        compare optical offsets across icon sizes and contexts' \
		'  make ui-icon-concepts  production icon family review captures' \
		'  make svg-icons         export production icons to standalone SVG assets' \
		'  make ui-svg-icons      compare production code and SVG files in ImGui' \
		'  make ui-icon-references compare icon outline and filled references' \
		'  make ui-redesign       new layout feasibility capture (--interactive via ARGS)' \
		'  make ui-native-design  live native UI parameter editor and production preview' \
		'  make ui-native-workspace interactive production UI (--float-panel Timeline via ARGS)' \
		'  make ui-native-capture capture production panels and menus' \
		'  make ui-notice-review capture operation notices and file receipts' \
		'  make ui-design-guide  browse the native design specification and panel prototypes' \
		'  make ui-design         serve the browser design reference locally' \
		'  make ui-gallery        deterministic UI feasibility acceptance pages' \
		'  make readme-media      refresh unmodified production screenshots for README' \
		'  make tool-icons        transparent 1024px Tool Column icon sources' \
		'  make mouse-icons       black/transparent 1024px mouse hint sources' \
		'  make gizmo             2D/3D position/rotation gizmo' \
		'  make joint-gizmo       numbered joint-gizmo acceptance scene' \
		'  make primitive-authoring  fixed transforms and primitive dimensions' \
		'  make material-authoring  material creation, binding, and 2D texture import' \
		'  make contact-authoring  geometry contact, mass, group, and fluid properties' \
		'  make body-authoring     body mass, inertia, gravcomp, mocap, and sleep policy' \
		'  make resource-authoring geometry shape, mesh/hfield, cube, and skybox import' \
		'  make asset-browser     model-local files, materials, and height-field dimensions' \
		'  make joint-site-authoring advanced joint and site shape/endpoint properties' \
		'  make model-component-authoring contacts, actuators, sensors, tendons, and equality' \
		'  make keyframe-authoring record/replay take and snapshot Dope Sheet' \
		'  make batch-editing      Ctrl/Cmd multi-select and one-rebuild topology deletion' \
		'  make gizmo-gallery     enlarged 2D/3D gizmo reference images' \
		'  make hidpi-gallery     gizmo references at explicit 200% UI scale' \
		'  make perturb           MuJoCo translation/rotation perturbation' \
		'  make physics-options-check  validate and capture environment physics controls' \
		'  make text-overlay      GPU world-space text' \
		'  make mujoco-visuals    hfield/site/tendon/contact' \
		'  make mujoco-debug      joint/COM/inertia debug visuals' \
		'  make mujoco-actuators  joint/site/body actuator visuals' \
		'  make mujoco-slider-crank  slider-crank linkage reference image' \
		'  make mujoco-solver-diagnostics  contact split and autoconnect images' \
		'  make mujoco-islands     constraint-island color reference images' \
		'  make mujoco-bvh         body, mesh, and flex BVH reference images' \
		'  make mujoco-convex-hull original and collision-hull reference images' \
		'  make geometry-views    visual, collision, and combined geometry images' \
		'  make mujoco-rangefinder site/camera rays, hits, and normals' \
		'  make mujoco-constraints  equality constraint endpoint markers' \
		'  make mujoco-editing     mocap pose and equality controls' \
		'  make mujoco-overlays    flex edges/vertices, labels, and frames' \
		'  make deformables       flex/skin dynamic meshes' \
		'' \
		'Rendering and output:' \
		'  make lighting          editable lights and environment' \
		'  make image-light       MuJoCo cube-map environment light' \
		'  make many-lights       16-light and 24-light reference images' \
		'  make material-parity   texture, transparency, tendon, deformable, and dense scenes' \
		'  make texture-minification  near/far textured-plane filtering acceptance' \
		'  make local-shadow-precision  anymal-c spotlight receiver precision acceptance' \
		'  make shadow-quality    performance/balanced/high shadow comparison' \
		'  make shadow-scheduling deterministic light and shadow-slot report' \
		'  make scene-icons       camera and light scene icons' \
		'  make reflect           multiple planar reflections' \
		'  make additive          standard and additive transparency images' \
		'  make cameras           free, named, and orthographic cameras' \
		'  make capture           write PNG' \
		'  make record            stream MP4' \
		'  make recording-layers  live layers, countdown, and compact joint acceptance' \
		'  make take-video        one-shot take recording, end hold, and copyable save path' \
		'  make rollout-video     offscreen MP4 with simulation-time subtitles' \
		'  make showcase          render feature overview' \
		'' \
		'Backends and remote viewing:' \
		'  make canvas            standalone scene and material editor' \
		'  make canvas-2d         retained 2D physics/geometry debug canvas' \
		'  make scene-io          save, load, and capture a Mojive scene' \
		'  make editor-files      scene document workflow acceptance' \
		'  make entity-edit       Entity lifecycle acceptance' \
		'  make undo-redo        editor history and continuous edit acceptance' \
		'  make toy-physics       minimal independent physics backend' \
		'  make live-view         one publisher and two remote viewers' \
		'  make remote-authoring  runtime entity creation over Live View' \
		'  make snapshot-record   record remote scene snapshots' \
		'  make snapshot-replay   replay recorded snapshots' \
		'' \
		'Verification:' \
		'  make p0                complete Renderer compatibility gate' \
		'  make p1                complete P0 and P1 acceptance gate' \
		'  make test-fast         pure CPU behavior used during iteration' \
		'  make test-integration  file, protocol, and multi-module CPU tests' \
		'  make test-physics      tests that compile or step physics worlds' \
		'  make check             lint plus fast and integration CPU tests' \
		'  make test-all          CPU, physics, and both real GPU backends' \
		'  make gpu               real OpenGL tests' \
		'  make gpu-bgfx          native bgfx GPU tests' \
		'  make egl               Linux EGL Renderer and wireframe contract' \
		'  make scene-renderer    authored RGB, depth, and object-ID images' \
		'  make renderer-api      public Renderer CPU and GPU contract' \
		'  make renderer-benchmark MuJoCo/OpenGL/bgfx public API timing comparison' \
		'  make renderer-benchmark-full complete resolution and output-mode matrix' \
		'  make physics-render-benchmark same-process physics/render concurrency experiment' \
		'  make physics-concurrency default editor runtime, including 100 humanoids' \
		'  make camera-state      camera bookmark serialization and restore' \
		'  make scene-snapshot    complete scene-state serialization and restore' \
		'  make cli               typed local control commands' \
		'  make rpc               local RPC protocol and capture artifacts' \
		'  make agent-control     discover, edit, and verify an authored scene through RPC' \
		'  make agent-viewer      verify RPC edits and presented viewport/window capture' \
		'  make material-parity   material and dense-scene image baselines' \
		'  make shadow-scheduling deterministic light and shadow selection' \
		'  make doctor            window-path smoke test' \
		'  make mujoco-audit      MuJoCo visualization and core schema coverage' \
		'  make mujoco-model-suite compile, adapt, and render MuJoCo model collections' \
		'  make adapter-conformance  adapter contract report' \
		'  make docs              build the API and user guide under output/site' \
		'  make clean             clear test/lint caches; keep builds and captures' \
		'  make clean-output      delete generated captures, recordings and reports' \
		'  make clean-build       delete build dependencies/products; rebuild before use' \
		'  make docs-check        validate public docs, examples, and the strict site build' \
		'  make examples-check    validate the runnable examples without opening a window' \
		'  make docs-serve        serve the documentation locally' \
		'' \
		'Display and backend options:' \
		'  make editor BACKEND=opengl' \
		'  make editor LANGUAGE=zh_CN                 simplified Chinese UI' \
		'  MOJIVE_UI_SCALE=2 make editor' \
		'  MOJIVE_CJK_FONT=/path/font.otf make editor' \
		'  make hidpi BACKEND=opengl UI_SCALE=2' \
		'  MOJIVE_UI_SCALE=1.5 make viewer BACKEND=opengl SCENE=gizmo ARGS="--paused"' \
		'  make egl-viewer                   Linux GLFW EGL context' \
		'' \
		'BACKEND accepts opengl or bgfx (requires native build). Leave UI scale unset for automatic scaling.'

setup:
	uv sync --python 3.11 --extra dev --extra mujoco --extra native
	$(MAKE) setup-imgui
	$(MAKE) native-editable

.PHONY: setup-imgui setup-g3 g3-ui g3-benchmark interaction-benchmark ui-corners ui-corners-gallery
setup-imgui:
	$(PY) -m mojive.tools.build_imgui --install

# Keep the previous setup command working for existing checkouts.
setup-g3: setup-imgui

g3-ui:
	$(PY) -m mojive.tools.tool_icons -o output/g3-ui/tool-icons
	$(PY) -m mojive.tools.mouse_hint_icons -o output/g3-ui/mouse-icons
	$(PY) -m mojive.tools.ui_runtime -o output/g3-ui/runtime

g3-benchmark:
	$(PY) -m mojive.tools.benchmark_g3 $(ARGS)

interaction-benchmark:
	$(PY) -m mojive.tools.benchmark_interaction $(ARGS)

ui-corners:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --interactive --page geometry --geometry-tab corners $(ARGS)

ui-corners-gallery:
	$(PYTEST) -q -m gpu tests/gpu/test_ui_corner_controls.py -k tab_focus
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab corners --smoothing 0 -o output/g3-controls/corners-000.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab corners --smoothing 0.6 -o output/g3-controls/corners-060.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab corners --smoothing 1 -o output/g3-controls/corners-100.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab corners --imgui-radius 0 -o output/g3-controls/radius-00.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab corners --imgui-radius 8 -o output/g3-controls/radius-08.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab corners --imgui-radius 12 -o output/g3-controls/radius-12.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab corners --imgui-radius 16 -o output/g3-controls/radius-16.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab playback -o output/g3-controls/playback-aligned.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab workspaces -o output/g3-controls/workspaces.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page panels -o output/g3-controls/panels.png
	MOJIVE_BACKEND=opengl $(PYTEST) -q -m gpu tests/gpu/test_debugdraw.py -k screen_arrows

## Lint, formatting, and CPU tests.
check: lint test

lint:
	$(RUFF) check python tests examples
	$(RUFF) format --check python tests examples

fmt:
	$(RUFF) check --fix python tests examples
	$(RUFF) format python tests examples

.PHONY: icon-presets fmt-cpp
icon-presets:
	$(PY) -m mojive.tools.generate_icon_presets $(ARGS)

fmt-cpp:
	rg --files cpp -g '*.cpp' -g '*.hpp' | xargs clang-format -i

docs:
	uv run --no-sync mkdocs build --strict --site-dir output/site

docs-check: examples-check
	$(PY) -m mojive.tools.check_docs
	$(MAKE) docs

examples-check:
	$(PY) -m compileall -q examples

docs-serve:
	uv run --no-sync mkdocs serve --strict --open

## Fast tests contain pure CPU behavior and module contracts.
test-fast:
	$(PYTEST) -q -m "not integration and not gpu and not physics and not slow and not golden"

## Integration tests cover files, protocols, processes, and composed modules.
test-integration:
	$(PYTEST) -q -m "integration and not gpu and not physics and not slow and not golden"

## The default CPU suite excludes real GPU and physics worlds.
test: test-fast test-integration

test-physics:
	$(PYTEST) -q -m physics

test-all: test test-physics gpu gpu-bgfx

mjcf-roundtrip:
	$(PYTEST) -q -m physics tests/test_workspace.py -k 'mjcf_export or exports_formatted or export_current_pose'

## Isolate files because OpenGL and physics libraries own process-global registries.
gpu:
	@for f in $$(ls tests/gpu/test_*.py); do echo "--- $$f"; $(PYTEST) -q -m "gpu or physics" $$f || exit 1; done

.PHONY: gpu-bgfx
gpu-bgfx: native-python-build setup-imgui
	@export MOJIVE_RENDERER=bgfx MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))"; \
	for f in $(wildcard tests/gpu/test_*.py); do $(PYTEST) -q -m "gpu or physics" $$f || exit 1; done

egl:
	@test "$$(uname -s)" = Linux || { echo 'make egl requires Linux'; exit 2; }
	MOJIVE_GL=egl $(PYTEST) -q -m gpu tests/gpu/test_renderer_api.py

.PHONY: scene-renderer
scene-renderer:
	$(PY) examples/offscreen_scene.py

renderer-api:
	$(PYTEST) -q tests/test_renderer_api.py
	$(PYTEST) -q -m gpu tests/gpu/test_renderer_api.py
	$(PY) -m mojive.tools.renderer_api

renderer-benchmark:
	$(PY) -m mojive.tools.renderer_benchmark $(ARGS)

renderer-benchmark-full:
	$(PY) -m mojive.tools.renderer_benchmark --preset full \
		-o output/renderer-benchmark/full-report.json $(ARGS)

p0: renderer-api

p1: check p0 mujoco-physics camera-state scene-snapshot rpc material-parity shadow-scheduling mujoco-audit golden parity reverse gpu gpu-bgfx
	$(MAKE) adapter-conformance ADAPTER=mujoco CONFORMANCE_ASSET=deformables

## Compare golden images. ARGS selects cases; the agent reviews differences before accepting.
golden:
	$(PY) -m mojive.tools.golden $(ARGS)

golden-accept:
	$(PY) -m mojive.tools.golden --accept $(ARGS)

## Render OpenGL and the MuJoCo reference from one camera. The reference uses a subprocess.
parity:
	$(PY) -m mojive.tools.parity $(ARGS)

## Calibrate diffuse, headlight, ambient, and texture lighting against MuJoCo.
calibrate:
	$(PY) -m mojive.tools.calibrate

## Render the scene gallery for visual review.
gallery:
	$(PY) -m mojive.tools.gallery

.PHONY: ui-diagnostics
ui-diagnostics:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab diagnostics -o output/ui-diagnostics.png $(ARGS)

.PHONY: ui-keyframe-follow
ui-keyframe-follow:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab icons --icon-group keyframe-follow -o output/ui-keyframe-follow/family.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --ui-scale 2 --page geometry --geometry-tab icons --icon-group keyframe-follow -o output/ui-keyframe-follow/family-hidpi.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab workspaces -o output/ui-keyframe-follow/keyframes.png

.PHONY: ui-icon-concepts
ui-icon-concepts:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab icons --icon-group overview -o output/ui-icon-concepts/overview.png
	$(MAKE) ui-keyframe-follow
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1100 --page geometry --geometry-tab icons --icon-group ui-context -o output/ui-icon-concepts/ui-context.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1100 --page geometry --geometry-tab icons --icon-group ui-context --icon-alignment box -o output/ui-icon-concepts/ui-context-box.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1100 --ui-scale 2 --page geometry --geometry-tab icons --icon-group ui-context -o output/ui-icon-concepts/ui-context-hidpi.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1400 --page geometry --geometry-tab icons --icon-group capsules -o output/ui-icon-concepts/capsules.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1650 --page geometry --geometry-tab icons --icon-group viewport-tools -o output/ui-icon-concepts/viewport-tools.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1650 --page geometry --geometry-tab icons --icon-group viewport-playback -o output/ui-icon-concepts/viewport-playback.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1800 --page geometry --geometry-tab icons --icon-group keyframe-transport -o output/ui-icon-concepts/keyframe-transport.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 2050 --page geometry --geometry-tab icons --icon-group keyframes -o output/ui-icon-concepts/keyframes.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 2050 --page geometry --geometry-tab icons --icon-group keyframes --icon-alignment box -o output/ui-icon-concepts/keyframes-box.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1650 --page geometry --geometry-tab icons --icon-group panels -o output/ui-icon-concepts/panels.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1650 --page geometry --geometry-tab icons --icon-group scene-helpers -o output/ui-icon-concepts/scene-helpers.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1650 --page geometry --geometry-tab icons --icon-group scene-helpers --icon-alignment box -o output/ui-icon-concepts/scene-helpers-box.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1650 --page geometry --geometry-tab icons --icon-group status-and-input -o output/ui-icon-concepts/status-input.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab tools --tool-stroke 1.46 --rotate-gap-ratio 1.0 -o output/ui-icon-concepts/tools-max-gap.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1850 --page geometry --geometry-tab playback --preview-icon-library --playback-zoom 4 -o output/ui-icon-concepts/playback-layout-4x.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --preview-icon-library --page workspace -o output/ui-icon-concepts/context-workspace.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --preview-icon-library --page panels -o output/ui-icon-concepts/context-panels.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1200 --preview-icon-library --page geometry --geometry-tab hints -o output/ui-icon-concepts/context-hints.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --height 1200 --ui-scale 2 --preview-icon-library --page geometry --geometry-tab hints -o output/ui-icon-concepts/context-hints-hidpi.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --preview-icon-library --page geometry --geometry-tab workspaces -o output/ui-icon-concepts/context-keyframes.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --preview-icon-library --page redesign -o output/ui-icon-concepts/context-redesign.png

.PHONY: ui-icon-scales ui-icon-references
ui-icon-references:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_ui_icon_alignment.py -k reference_styles

ICON_SCALES ?= 0.65 1 1.25 1.5
ICON_SCALE_GROUPS ?= viewport-tools viewport-playback keyframe-transport keyframes
ui-icon-scales:
	@set -e; for scale in $(ICON_SCALES); do \
		for group in $(ICON_SCALE_GROUPS); do \
			MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility \
				--ui-scale $$scale --height 2050 --page geometry --geometry-tab icons \
				--icon-group $$group -o output/ui-icon-scales/$$group-$$scale.png $(ARGS); \
		done; \
	done

.PHONY: ui-reset-heads
ui-reset-heads:
	@set -e; for scale in 0.65 1 1.25 1.5; do \
		for head in 1 1.5 2; do \
			MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility \
				--ui-scale $$scale --height 1850 --page geometry --geometry-tab icons \
				--icon-group viewport-playback --reset-head-scale $$head \
				-o output/ui-reset-heads/scale-$$scale-head-$$head.png; \
		done; \
	done

ui-feasibility:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --interactive $(ARGS)

.PHONY: svg-icons ui-svg-icons ui-svg-icons-gallery
svg-icons:
	$(PY) -m mojive.tools.svg_icons $(ARGS)

ui-svg-icons:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --interactive --page geometry --geometry-tab svg --width 1100 --height 800 $(ARGS)

ui-svg-icons-gallery:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_svg_icons.py

.PHONY: ui-components ui-components-gallery ui-optical ui-optical-gallery
ui-components:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --interactive --page components --width 1100 --height 760 $(ARGS)

ui-components-gallery:
	@set -e; for scale in 1 2.25; do \
		for surface in panel card; do \
			for scene in basic inspector filters actions transform material scene joints capture; do \
				MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility \
					--page components --corner-scene $$scene --corner-surface $$surface --width 1100 --height 800 \
					--ui-scale $$scale -o output/ui-components/$(BACKEND)-$$scene-$$surface-$$scale.png $(ARGS); \
			done; \
		done; \
	done

ui-optical:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --interactive --page components --component-tab optical --width 1100 --height 800 $(ARGS)

ui-optical-gallery:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page components --component-tab optical --width 1100 --height 800 --ui-scale 1 -o output/ui-optical/$(BACKEND)-1.png $(ARGS)
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page components --component-tab optical --width 1100 --height 800 --ui-scale 2.25 -o output/ui-optical/$(BACKEND)-2.25.png $(ARGS)
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page components --component-tab optical --width 1100 --height 800 --auto-align-centroid -o output/ui-optical/$(BACKEND)-auto.png $(ARGS)

ui-runtime:
	$(PY) -m mojive.tools.ui_runtime $(ARGS)

.PHONY: viewport-resize
## Verify current-frame viewport sizing during native and dock-splitter resizing.
viewport-resize:
	$(PY) -m mojive.tools.viewport_resize --backend $(BACKEND) $(ARGS)

.PHONY: ui-default-layout
ui-default-layout:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m "gpu or physics" tests/gpu/test_default_layout.py $(ARGS)

.PHONY: ui-layout-audit
ui-layout-audit:
	$(PY) -m mojive.tools.ui_layout_audit $(ARGS)

.PHONY: ui-redesign
ui-redesign:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page redesign -o output/ui-redesign/overview.png $(ARGS)

## Refresh README images with unmodified production UI and renderer captures.
readme-media:
	$(PY) -m mojive.tools.build_readme_media \
		--output output/readme-media --publish docs/images/readme $(ARGS)

## Export production Tool Column geometry on transparent 1024px canvases.
tool-icons:
	$(PY) -m mojive.tools.tool_icons $(ARGS)

## Export production mouse hint geometry with black and transparent shells.
mouse-icons:
	$(PY) -m mojive.tools.mouse_hint_icons $(ARGS)

## Measure fresh-process startup and first presentation across render backends.
.PHONY: startup-profile
startup-profile:
	$(PY) -m mojive.tools.startup_profile $(ARGS)

## Profile production viewport chrome and enforce its incremental frame budget.
ui-frame-profile:
	$(PY) -m mojive.tools.ui_frame_profile $(ARGS)

.PHONY: editor-profile
editor-profile:
	$(PY) -m mojive.tools.editor_profile --renderer $(BACKEND) $(ARGS)

.PHONY: inspector-profile
inspector-profile:
	$(PY) -m mojive.tools.inspector_profile --renderer $(BACKEND) $(ARGS)

.PHONY: editor-soak
editor-soak:
	$(PY) -m mojive.tools.editor_soak --renderer $(BACKEND) $(ARGS)

.PHONY: editor-tail-profile
editor-tail-profile:
	$(PY) -m mojive.tools.editor_tail_profile --renderer $(BACKEND) $(ARGS)

.PHONY: hierarchy-benchmark
hierarchy-benchmark:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.hierarchy_benchmark $(ARGS)

.PHONY: timeline-benchmark
timeline-benchmark:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.timeline_benchmark $(ARGS)

.PHONY: recording-benchmark
recording-benchmark:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.recording_benchmark $(ARGS)

.PHONY: joint-gizmo-profile
joint-gizmo-profile:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.joint_gizmo_profile $(ARGS)

ui-gallery:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page workspace -o output/ui-workspace.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab playback -o output/ui-geometry-playback.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab tools -o output/ui-geometry-tools.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab icons --icon-group overview -o output/ui-icon-concepts/overview.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab hints -o output/ui-geometry-hints.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab gizmos -o output/ui-geometry-transform-gizmos.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab helpers -o output/ui-geometry-joint-helpers.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab status -o output/ui-geometry-status.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab diagnostics -o output/ui-diagnostics.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab shell -o output/ui-geometry-shell.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab panels -o output/ui-geometry-panels.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab workspaces -o output/ui-geometry-workspaces.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --page geometry --geometry-tab workspaces --preview-icon-library -o output/ui-geometry-workspaces-preview.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --ui-scale 4 --page workspace -o output/ui-workspace-hidpi.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --ui-scale 4 --page panels -o output/ui-panels-hidpi.png
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.ui_feasibility --ui-scale 4 --page geometry --geometry-tab helpers -o output/ui-geometry-joint-helpers-hidpi.png
	$(PY) -m mojive.tools.ui_runtime -o output/ui-runtime

gizmo-gallery:
	$(PY) -m mojive.tools.gizmo_gallery $(ARGS)

hidpi-gallery:
	MOJIVE_UI_SCALE=$(UI_SCALE) $(PY) -m mojive.tools.gizmo_gallery \
		-o output/gizmo-gallery-hidpi $(ARGS)

model-loading:
	$(PY) -m mojive.tools.model_loading $(ARGS)

model-composition:
	$(PYTEST) -q -m physics tests/test_adapter.py -k 'mjspec_model_composition'
	$(PY) -m mojive.tools.model_composition $(ARGS)

editor-performance:
	$(PYTEST) -q -m physics tests/test_editor_performance.py
	$(PY) -m mojive.tools.editor_performance $(ARGS)

stability: rpc-soak format-validation
	$(PYTEST) -q -m physics tests/test_stability.py
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_renderer_api.py -k 'multi_camera_concurrency'
	$(PY) -m mojive.tools.stability $(ARGS)

rpc-soak:
	$(PYTEST) -q -m physics tests/test_control_rpc.py -k 'reuses_one_connection or recovers_after_invalid or idle_connection or reconnects_on_the_call'

.PHONY: rpc-benchmark
rpc-benchmark:
	$(PY) -m mojive.tools.benchmark_rpc --backend $(BACKEND) $(ARGS)

format-validation:
	$(PYTEST) -q tests/test_recording.py
	$(PYTEST) -q -m physics tests/test_scene_state.py -k 'version or current or future'

scene-io:
	$(PY) -m mojive.tools.scene_io $(ARGS)

editor-files:
	$(PYTEST) -q tests/test_static_scene.py -k 'document_commands'
	$(PY) -m mojive.tools.scene_io $(ARGS)

entity-edit:
	$(PYTEST) -q tests/test_static_scene.py -k 'entity_lifecycle'
	$(PYTEST) -q -m gpu tests/gpu/test_static_viewer.py -k 'editor_actions'

undo-redo:
	$(PYTEST) -q tests/test_static_scene.py -k 'undo_redo or history or edit_transaction'
	$(PYTEST) -q -m gpu tests/gpu/test_static_viewer.py -k 'undo_redo'

remote-authoring:
	$(PY) -m mojive.tools.remote_authoring $(ARGS)

additive:
	$(PY) -m mojive.tools.additive $(ARGS)

bench:
	$(PY) -m mojive.tools.bench

showcase:
	$(PY) -m mojive.tools.showcase

## Probe current OpenGL platform capabilities.
probe:
	$(PY) -m mojive.tools.probe_gl

## Apply registered mutations and confirm their regression checks fail.
reverse:
	$(PY) -m mojive.tools.reverse_verify

## Open an asset. Pass viewer flags through ARGS.
SCENE ?= test_scene
ARGS  ?=
BACKEND ?= opengl
LANGUAGE ?= $(MOJIVE_LANGUAGE)
viewer:
	MOJIVE_RENDERER=$(BACKEND) MOJIVE_LANGUAGE=$(LANGUAGE) $(PY) -m mojive.cli view $(SCENE) $(ARGS)

egl-viewer:
	@test "$$(uname -s)" = Linux || { echo 'make egl-viewer requires Linux'; exit 2; }
	MOJIVE_GL=egl PYOPENGL_PLATFORM=egl $(PY) -m mojive.cli view $(SCENE) $(ARGS)

UI_SCALE ?= 2
hidpi:
	MOJIVE_RENDERER=$(BACKEND) MOJIVE_LANGUAGE=$(LANGUAGE) MOJIVE_UI_SCALE=$(UI_SCALE) $(PY) -m mojive.cli view gizmo --paused $(ARGS)

## Open an empty MuJoCo scene and load MJCF or URDF from File > Open Model.
empty:
	MOJIVE_RENDERER=$(BACKEND) MOJIVE_LANGUAGE=$(LANGUAGE) $(PY) -m mojive.cli view empty --paused $(ARGS)

## Empty authored scene with New/Open/Save and Entity creation workflows.
editor:
	MOJIVE_RENDERER=$(BACKEND) MOJIVE_LANGUAGE=$(LANGUAGE) $(PY) -m mojive.cli editor $(ARGS)

workspace-edit:
	$(PYTEST) -q tests/test_workspace.py tests/test_scene_entities.py
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor $(ARGS)

## Programmatic scene, OpenGL rendering, and the standard UI.
canvas:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli canvas $(ARGS)

canvas-2d:
	MOJIVE_RENDERER=$(BACKEND) $(PY) examples/canvas2d.py $(ARGS)

## Independent physics adapter with gravity, collision, controls, and pose editing.
toy-physics:
	$(PY) -m mojive.cli toy $(ARGS)

ADAPTER ?= toy
CONFORMANCE_ASSET ?=
## Headless contract report for third-party adapters. MuJoCo example:
## make adapter-conformance ADAPTER=mujoco CONFORMANCE_ASSET=test_scene
adapter-conformance:
	$(PY) -m mojive.cli conformance $(ADAPTER) $(if $(CONFORMANCE_ASSET),--asset $(CONFORMANCE_ASSET),) $(ARGS)

## Editable lights and Environment controls for ambient light, fog, haze, and headlight.
lighting:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli canvas --demo lighting $(ARGS)

image-light:
	$(PY) -m mojive.cli view assets/image_light.xml --paused $(ARGS)

many-lights:
	$(PY) -m mojive.tools.mujoco_many_lights $(ARGS)

material-parity:
	$(PYTEST) -q tests/test_builder.py tests/test_scene.py
	$(PY) -m mojive.tools.material_parity $(ARGS)

material-parity-accept:
	$(PY) -m mojive.tools.material_parity --accept $(ARGS)

shadow-scheduling:
	$(PYTEST) -q tests/test_light_schedule.py
	$(PYTEST) -q -m gpu tests/gpu/test_shadows.py -k 'eight_local or local_light_indices'
	$(PY) -m mojive.tools.shadow_scheduling $(ARGS)

scene-icons:
	$(PY) -m mojive.cli canvas --demo lighting \
		--enable-render camera --enable-render light $(ARGS)

scene-entities:
	$(PYTEST) -q tests/test_scene_entities.py
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.scene_entities $(ARGS)

## World anchors, screen offsets, alignment, and depth modes with the UI font.
text-overlay:
	$(PY) -m mojive.cli canvas --demo text $(ARGS)

OUTPUT ?= output/recording.mp4
SCREENSHOT ?= output/capture.png
## Capture at any resolution. Example: make capture SCENE=test_scene ARGS="--width 1920 --height 1080".
capture:
	$(PY) -m mojive.cli capture $(SCENE) -o $(SCREENSHOT) $(ARGS)

## Stream video encoding. Example: make record SCENE=test_scene ARGS="--frames 120".
record:
	$(PY) -m mojive.cli record $(SCENE) -o $(OUTPUT) $(ARGS)

## End-to-end Renderer + VideoRecorder + Pillow acceptance, without editor UI.
rollout-video:
	$(PY) examples/mujoco_video.py assets/test_scene.xml --label "Mojive rollout" \
		--output output/examples/rollout.mp4 $(ARGS)

LIVE_HOST ?= 127.0.0.1
LIVE_PORT ?= 47650
LIVE_SCENE ?= gizmo
## Run physics headlessly and publish the latest snapshot.
serve:
	$(PY) -m mojive.cli serve $(LIVE_SCENE) --host $(LIVE_HOST) --port $(LIVE_PORT) $(ARGS)

## Open an independent remote viewer.
attach:
	$(PY) -m mojive.cli attach --host $(LIVE_HOST) --port $(LIVE_PORT) $(ARGS)

## Start one physics publisher, one effect viewer, and one normal-debug viewer.
live-view:
	@$(PY) -m mojive.cli serve $(LIVE_SCENE) --host $(LIVE_HOST) --port $(LIVE_PORT) $(ARGS) & server=$$!; \
	$(PY) -m mojive.cli attach --host $(LIVE_HOST) --port $(LIVE_PORT) --title "Mojive effect" & effect=$$!; \
	$(PY) -m mojive.cli attach --host $(LIVE_HOST) --port $(LIVE_PORT) --title "Mojive debug" --debug-view normal & debug=$$!; \
	trap 'kill $$effect $$debug $$server 2>/dev/null || true' EXIT INT TERM; \
	wait $$effect; wait $$debug

SNAPSHOT ?= output/session.fvs
## Record structure revisions, physics frames, and debug commands.
snapshot-record:
	$(PY) -m mojive.cli serve $(LIVE_SCENE) --host $(LIVE_HOST) --port $(LIVE_PORT) --record-snapshot $(SNAPSHOT) $(ARGS)

## Replay a snapshot loop through the remote protocol.
snapshot-replay:
	@$(PY) -m mojive.cli replay $(SNAPSHOT) --host $(LIVE_HOST) --port $(LIVE_PORT) --loop & server=$$!; \
	trap 'kill $$server 2>/dev/null || true' EXIT INT TERM; \
	$(PY) -m mojive.cli attach --host $(LIVE_HOST) --port $(LIVE_PORT) --title "Mojive replay" $(ARGS)

camera-state:
	$(PY) -m pytest -q -m physics tests/test_scene_state.py -k camera
	$(PY) -m mojive.tools.scene_state $(ARGS)

scene-snapshot:
	$(PY) -m pytest -q -m physics tests/test_scene_state.py
	$(PY) -m mojive.tools.scene_state $(ARGS)

cli:
	$(PYTEST) -q -m physics tests/test_control_rpc.py

rpc: cli
	$(PYTEST) -q -m "gpu or physics" tests/gpu/test_control_rpc_capture.py
	$(PY) -m mojive.tools.control_rpc

.PHONY: agent-control agent-viewer
agent-control:
	$(PY) examples/agent_inspection.py $(ARGS)

agent-viewer:
	$(PY) examples/agent_inspection.py --viewer $(ARGS)

## Compact Inspector transform acceptance image.
inspector:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.inspector $(ARGS)
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_inspector_solver.py

## Native gizmo acceptance: G position, R rotation, T frame, F9 settings.
gizmo:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli view gizmo --paused $(ARGS)

## Numbered revolute, prismatic, ball, free, multi-joint, and compact-range acceptance.
joint-gizmo:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor joint_gizmo $(ARGS)

## Fixed-body transform and sphere/box/cylinder/capsule dimension authoring acceptance.
primitive-authoring:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor test_scene $(ARGS)

.PHONY: scene-editing-audit
scene-editing-audit:
	$(PY) -m mojive.tools.scene_editing_audit $(ARGS)

.PHONY: material-workflow
## Offscreen public API acceptance for box/floor materials, skybox, and editable grid.
material-workflow:
	$(PY) -m mojive.tools.material_workflow $(ARGS)

.PHONY: viewer-compat
viewer-compat:
	$(PY) examples/mujoco_viewer.py $(ARGS)

.PHONY: viewer-managed viewer-passive
viewer-managed:
	$(PY) examples/viewer_managed.py $(ARGS)

viewer-passive:
	$(PY) examples/viewer_passive.py $(ARGS)

## Material creation/copy/binding and 2D image import acceptance.
material-authoring:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor test_scene $(ARGS)

## Geometry contact, solver, surface, mass, group, inertia, and fluid acceptance.
contact-authoring:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor test_scene $(ARGS)

## Body auto/explicit inertia, gravcomp, mocap, and sleep-policy acceptance.
body-authoring:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor test_scene $(ARGS)

## Geometry shape switching plus mesh, height-field, cube, and skybox import acceptance.
resource-authoring:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor test_scene $(ARGS)

## Model-local files, materials, and height-field physical-dimension acceptance.
asset-browser:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor test_scene $(ARGS)

## Joint dynamics/solver/force limits and site shape/group/endpoints acceptance.
joint-site-authoring:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor joint_gizmo $(ARGS)

## Contact, actuator, sensor, tendon, and equality component acceptance.
model-component-authoring:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor test_scene $(ARGS)

## Simulation-take transport plus model-local snapshot Dope Sheet acceptance.
keyframe-authoring:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor test_scene $(ARGS)

## Ctrl/Cmd multi-selection and one-rebuild model topology deletion acceptance.
batch-editing:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor test_scene $(ARGS)

## Dockable non-modal Settings acceptance.
settings:
	MOJIVE_OPEN_SETTINGS=1 MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli editor $(ARGS)

## Perturbation acceptance: Ctrl+left translates and Ctrl+right rotates a selected free body.
perturb:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.cli view gizmo $(ARGS)

.PHONY: physics-options-check
## Exercise live physics options and capture localized Inspector controls.
physics-options-check:
	$(PYTEST) -q -m physics tests/test_physics_options.py
	MOJIVE_PHYSICS_OPTIONS_CAPTURE=output/physics-options $(PYTEST) -q -m gpu tests/gpu/test_physics_options.py

.PHONY: perturb-check
## Force parity, passive write-back, strength settings, and held Control drags.
perturb-check:
	$(PYTEST) -q -m physics tests/test_mujoco_perturb.py tests/test_passive.py tests/test_mujoco_viewer.py
	MOJIVE_PERTURB_CAPTURE=output/perturb-check $(PYTEST) -q -m gpu tests/gpu/test_perturb_drag.py

## Selection outline acceptance across multiple geoms and occlusion.
outline:
	$(PY) -m mojive.cli view outline --paused

## Multiple planar reflection acceptance for height, clipping, and winding.
reflect:
	$(PY) -m mojive.cli view reflection_multiple --paused

## Sparse checkout of one Google DeepMind MuJoCo Menagerie model.
ROBOT ?= unitree_go2
MENAGERIE_DIR ?= build/mujoco_menagerie
robot:
	@if [ ! -d "$(MENAGERIE_DIR)/.git" ]; then \
		git clone --depth 1 --filter=blob:none --sparse \
			https://github.com/google-deepmind/mujoco_menagerie.git "$(MENAGERIE_DIR)"; \
	fi
	@git -C "$(MENAGERIE_DIR)" sparse-checkout add assets "$(ROBOT)"
	$(PY) -m mojive.cli view "$(MENAGERIE_DIR)/$(ROBOT)/scene.xml" $(ARGS)

TEXTURE_MINIFICATION_SCENE ?= $(MENAGERIE_DIR)/anybotics_anymal_c/scene.xml
texture-minification:
	@test -f "$(TEXTURE_MINIFICATION_SCENE)" || { \
		echo "missing scene: $(TEXTURE_MINIFICATION_SCENE)"; \
		echo "set TEXTURE_MINIFICATION_SCENE=/path/to/anybotics_anymal_c/scene.xml"; \
		exit 2; \
	}
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.texture_minification \
		"$(TEXTURE_MINIFICATION_SCENE)"

LOCAL_SHADOW_SCENE ?= $(MENAGERIE_DIR)/anybotics_anymal_c/scene.xml
local-shadow-precision:
	@test -f "$(LOCAL_SHADOW_SCENE)" || { \
		echo "missing scene: $(LOCAL_SHADOW_SCENE)"; \
		echo "set LOCAL_SHADOW_SCENE=/path/to/anybotics_anymal_c/scene.xml"; \
		exit 2; \
	}
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.local_shadow_precision \
		"$(LOCAL_SHADOW_SCENE)"

shadow-quality:
	$(PYTEST) -q tests/test_cascades.py tests/test_panels.py -k shadow_quality
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.shadow_quality $(ARGS)

AUDIT_SCENE ?= mujoco_visuals
## Full MuJoCo adapter and simulation regression suite.
mujoco-physics:
	$(PYTEST) -q -m physics

## Headless MuJoCo visualization and exact linked-schema coverage report.
mujoco-audit:
	$(PY) -m mojive.cli audit $(AUDIT_SCENE) --strict

MUJOCO_MODEL_ROOTS ?= $(HOME)/Downloads/mujoco/model $(HOME)/Projects/PhysicsEngines/mujoco/model
MUJOCO_MODEL_REPORT ?= output/mujoco-model-suite.json
MUJOCO_MODEL_JOBS ?= 4
## Compile, adapt, and render every XML below the configured MuJoCo model roots.
mujoco-model-suite:
	$(PY) -m mojive.tools.mujoco_model_suite $(MUJOCO_MODEL_ROOTS) \
		--jobs $(MUJOCO_MODEL_JOBS) --report $(MUJOCO_MODEL_REPORT) $(ARGS)

## Interactive heightfield, site, tendon, and contact scene.
mujoco-visuals:
	$(PY) -m mojive.cli view mujoco_visuals \
		--enable-render tendon --enable-render contactpoint --enable-render contactforce $(ARGS)

## MuJoCo joint markers, root subtree COM and body inertia boxes.
mujoco-debug:
	$(PY) -m mojive.cli view joint_types --paused \
		--enable-render joint --enable-render com --enable-render inertia $(ARGS)

mujoco-actuators:
	$(PY) -m mojive.cli view actuator_visuals --paused \
		--camera overview --enable-render actuator --enable-render activation $(ARGS)

mujoco-slider-crank:
	$(PY) -m mojive.tools.mujoco_slider_crank

mujoco-solver-diagnostics:
	$(PY) -m mojive.tools.mujoco_solver_diagnostics

mujoco-islands:
	$(PY) -m mojive.tools.mujoco_islands

mujoco-bvh:
	$(PY) -m mojive.tools.mujoco_bvh $(ARGS)

mujoco-convex-hull:
	$(PY) -m mojive.tools.mujoco_convex_hull $(ARGS)

.PHONY: geometry-views geometry-ui
geometry-views:
	$(PY) -m mojive.tools.geometry_views $(ARGS)

geometry-ui:
	$(PY) -m mojive.tools.geometry_views_ui $(ARGS)

mujoco-rangefinder:
	$(PY) -m mojive.cli view rangefinder --paused \
		--enable-render rangefinder $(ARGS)

mujoco-constraints:
	$(PY) -m mojive.cli view constraints --paused \
		--camera overview --enable-render constraint $(ARGS)

mujoco-editing:
	$(PY) -m mojive.cli view mocap_equality --paused $(ARGS)

## Open Camera with F6; calibrated_shift demonstrates an off-center principal point.
cameras:
	$(PY) -m mojive.cli view mujoco_visuals $(ARGS)

camera-intrinsics:
	$(PY) -m mojive.cli capture mujoco_visuals --camera calibrated_shift \
		--width 1600 --height 1000 -o output/cameras/calibrated-shift.png $(ARGS)

## Inspect MuJoCo visual groups and synchronized picking filters in Settings.
geom-groups:
	$(PY) -m mojive.cli view mujoco_visuals --paused $(ARGS)

## Inspect 1D, 2D, and 3D flex geometry plus skinned meshes.
deformables:
	$(PY) -m mojive.cli view deformables --paused $(ARGS)

## Capture flex topology, scene labels, and coordinate-frame overlays.
mujoco-overlays:
	$(PY) -m mojive.tools.mujoco_overlays $(ARGS)

## List assets, free-body metadata, and optional dependency status.
assets:
	$(PY) -m mojive.cli assets

backends:
	$(PY) -m mojive.cli backends

doctor:
	$(PY) -m mojive.cli doctor $(SCENE) $(ARGS)

.PHONY: clean-output clean-build
# Default cleanup preserves both the installed runtime and user captures.
clean:
	rm -rf .pytest_cache .ruff_cache

clean-output:
	rm -rf output

clean-build:
	rm -rf build

# Optional native renderer; OpenGL remains the default Python backend.
NATIVE_BUILD ?= build/native
NATIVE_BACKEND ?= bgfx
NATIVE_OUTPUT ?= output/native-probe/$(NATIVE_BACKEND)
NATIVE_BINDINGS_BUILD ?= build/bindings
NATIVE_JOBS ?= 4
NATIVE_SCENE ?= output/native-probe/humanoids100.mjvp
NATIVE_FONT_CACHE = $(shell $(PY) -c 'from mojive.text.sources import cache_dir; print(cache_dir())')
NATIVE_FONT_LATIN ?= $(NATIVE_FONT_CACHE)/JetBrainsMono-Regular.ttf
NATIVE_FONT_CJK ?= $(or $(firstword $(wildcard $(NATIVE_FONT_CACHE)/NotoSansSC-Regular.otf /usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc)),$(NATIVE_FONT_CACHE)/NotoSansSC-Regular.otf)

.PHONY: native-build native-test native-probe native-fixture native-gallery native-benchmark
native-build:
	cmake -S cpp -B $(NATIVE_BUILD) -G Ninja -DCMAKE_BUILD_TYPE=Release -DMOJIVE_BUILD_SDL=$(if $(filter sdl,$(NATIVE_BACKEND)),ON,OFF) $(NATIVE_CMAKE_ARGS)
	cmake --build $(NATIVE_BUILD) --parallel $(NATIVE_JOBS)

native-test:
	$(PY) -m mojive.tools.check_native_layers
	cmake -S cpp -B build/core -G Ninja -DCMAKE_BUILD_TYPE=Release -DMOJIVE_BUILD_BGFX=OFF -DMOJIVE_BUILD_SDL=OFF -DMOJIVE_BUILD_BINDINGS=OFF -DMOJIVE_BUILD_PYTHON=OFF
	cmake --build build/core --parallel $(NATIVE_JOBS)
	ctest --test-dir build/core --output-on-failure

native-probe: native-build
	$(NATIVE_BUILD)/mojive_native_probe $(NATIVE_BUILD)/shaders $(NATIVE_OUTPUT) $(NATIVE_BACKEND)

native-fixture:
	$(if $(HUMANOIDS_MODEL),,$(error Set HUMANOIDS_MODEL to the official humanoid/100_humanoids.xml))
	$(PY) -m mojive.tools.export_native_probe "$(HUMANOIDS_MODEL)" --output "$(NATIVE_SCENE)"

native-gallery: native-build native-fixture
	$(NATIVE_BUILD)/mojive_native_gallery $(NATIVE_BUILD)/shaders "$(NATIVE_SCENE)" $(NATIVE_OUTPUT) "$(NATIVE_FONT_LATIN)" "$(NATIVE_FONT_CJK)" $(NATIVE_BACKEND)

native-benchmark: native-build native-fixture
	$(PY) -m mojive.tools.run_native_benchmark --build $(NATIVE_BUILD) --scene "$(NATIVE_SCENE)" --backends "$(NATIVE_BACKEND)" $(ARGS)

.PHONY: native-bindings native-bindings-test native-bindings-benchmark
native-bindings:
	cmake -S cpp -B $(NATIVE_BINDINGS_BUILD) -G Ninja -DCMAKE_BUILD_TYPE=Release -DMOJIVE_BUILD_BGFX=OFF -DMOJIVE_BUILD_SDL=OFF -DMOJIVE_BUILD_BINDINGS=ON -DPython_EXECUTABLE="$(abspath $(PY))" $(NATIVE_BINDINGS_CMAKE_ARGS)
	cmake --build $(NATIVE_BINDINGS_BUILD) --parallel $(NATIVE_JOBS)

native-bindings-test: native-bindings
	PYTHONPATH="$(NATIVE_BINDINGS_BUILD)/bindings" $(PYTEST) -q tests/native/test_bindings.py

native-bindings-benchmark: native-bindings native-fixture
	$(PY) -m mojive.tools.benchmark_native_bindings --modules "$(NATIVE_BINDINGS_BUILD)/bindings" --model "$(HUMANOIDS_MODEL)" --scene "$(NATIVE_SCENE)" $(ARGS)

.PHONY: native-composition native-windows native-runtime
native-composition: native-build
	$(NATIVE_BUILD)/mojive_native_composition $(NATIVE_BUILD)/shaders $(NATIVE_OUTPUT) $(NATIVE_BACKEND)

native-windows: native-build
	$(NATIVE_BUILD)/mojive_native_windows $(NATIVE_BUILD)/shaders $(NATIVE_OUTPUT) $(NATIVE_BACKEND)

native-runtime: native-build native-fixture
	$(PY) -m mojive.tools.run_native_runtime --build $(NATIVE_BUILD) --scene "$(NATIVE_SCENE)" --model "$(HUMANOIDS_MODEL)" $(ARGS)

.PHONY: native-scene-capture
native-scene-capture: native-build native-fixture
	$(NATIVE_BUILD)/mojive_native_scene_capture $(NATIVE_BUILD)/shaders "$(NATIVE_SCENE)" $(NATIVE_OUTPUT) $(NATIVE_BACKEND)

# C++ development entry points; native-* targets remain available for prior scripts.
.PHONY: cpp-deps cpp-build cpp-test cpp-probe cpp-gallery
cpp-deps:
	git submodule update --init --depth 1
	$(PY) -m mojive.tools.check_dependencies

cpp-build: native-build
cpp-test: native-test
cpp-probe: native-probe
cpp-gallery: native-gallery

# Native extension acceptance; production OpenGL remains the default backend.
CPP_PYTHON_BUILD ?= build/python
CPP_PYTHON_BGFX ?= OFF
.PHONY: cpp-python cpp-python-test
.PHONY: native-editable
native-editable: native-python-build
	MOJIVE_NATIVE_EDITABLE_BUILD="$(abspath $(NATIVE_BUILD))" uv pip install --no-deps --python "$(abspath $(PY))" -e .

cpp-python:
	cmake -S cpp -B $(CPP_PYTHON_BUILD) -G Ninja -DCMAKE_BUILD_TYPE=Release -DMOJIVE_BUILD_BGFX=$(CPP_PYTHON_BGFX) -DMOJIVE_BUILD_SDL=OFF -DMOJIVE_BUILD_PYTHON=ON -DPython_EXECUTABLE="$(abspath $(PY))"
	cmake --build $(CPP_PYTHON_BUILD) --target _native --parallel $(NATIVE_JOBS)

cpp-python-test: cpp-python
	cmake --build $(CPP_PYTHON_BUILD) --target mojive_geometry2d_test mojive_tessellator_test --parallel $(NATIVE_JOBS)
	ctest --test-dir $(CPP_PYTHON_BUILD) -R '^geometry2d' --output-on-failure
	MOJIVE_NATIVE_TEST_BUILD="$(abspath $(CPP_PYTHON_BUILD))" $(PYTEST) -q tests/native/test_native.py tests/native/test_native_mesh_processing.py tests/native/test_native_geometry2d.py tests/native/test_native_tessellation.py tests/native/test_native_stroke.py

.PHONY: cpp-python-gpu
cpp-python-gpu:
	$(MAKE) cpp-python CPP_PYTHON_BGFX=ON CPP_PYTHON_BUILD=$(NATIVE_BUILD)
	MOJIVE_NATIVE_TEST_BUILD="$(abspath $(NATIVE_BUILD))" MOJIVE_NATIVE_SHADER_DIR="$(abspath $(NATIVE_BUILD)/shaders)" MOJIVE_NATIVE_SCENE="$(abspath $(NATIVE_SCENE))" $(PYTEST) -q tests/native/test_native.py tests/native/test_native_render.py tests/native/test_native_lod.py

# Opt-in native development entry points use the existing Python Viewer and tools.
.PHONY: native-python-build native-viewer native-editor native-viewer-test
native-python-build:
	$(MAKE) cpp-python CPP_PYTHON_BGFX=ON CPP_PYTHON_BUILD=$(NATIVE_BUILD)

native-viewer: native-python-build setup-imgui
	PYTHONPATH="$(abspath .)$(if $(PYTHONPATH),:$(PYTHONPATH))" MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(MAKE) viewer BACKEND=bgfx

native-editor: native-python-build setup-imgui
	PYTHONPATH="$(abspath .)$(if $(PYTHONPATH),:$(PYTHONPATH))" MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(MAKE) editor BACKEND=bgfx

native-viewer-test: native-python-build setup-imgui
	PYTHONPATH="$(abspath .)" MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" MOJIVE_HUMANOIDS_MODEL="$(HUMANOIDS_MODEL)" $(PYTEST) -q tests/native/test_native_viewer.py

.PHONY: native-wayland-test native-wayland-viewer
native-wayland-test: native-python-build setup-imgui
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.run_wayland_acceptance --prepare $(ARGS)

native-wayland-viewer: native-python-build setup-imgui
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.run_wayland_viewer --prepare --scene "$(SCENE)" $(ARGS)

# Matched visual products and native-only feature regression checks.
.PHONY: native-parity native-features-test native-spirv
native-parity: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.native_parity --check $(ARGS)

native-features-test: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PYTEST) -q tests/native/test_native_features.py tests/native/test_native_shader_reload.py

native-spirv: native-build
	$(PY) -m mojive.tools.check_native_shaders --build $(NATIVE_BUILD)

.PHONY: native-wheel
native-wheel: native-python-build
	MOJIVE_NATIVE_WHEEL_BUILD="$(abspath $(NATIVE_BUILD))" uv build --wheel --python "$(abspath $(PY))" -o dist

.PHONY: native-wheel-test
native-wheel-test: native-wheel
	$(PY) -m mojive.tools.check_native_wheel $$(ls -t dist/*.whl | head -1)

.PHONY: native-model-parity
native-model-parity: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.native_model_parity $(if $(HUMANOIDS_MODEL),--humanoids-model "$(HUMANOIDS_MODEL)") $(ARGS)

.PHONY: native-motion-parity native-corpus-parity
native-motion-parity: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.native_motion_parity $(ARGS)

native-corpus-parity: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.native_corpus_parity assets $(if $(MENAGERIE_ROOT),"$(MENAGERIE_ROOT)") $(ARGS)

.PHONY: native-window-benchmark
native-window-benchmark: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.native_window_benchmark $(ARGS)

.PHONY: native-ui-parity
native-ui-parity: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.native_ui_parity $(ARGS)

.PHONY: viewcube-transitions
viewcube-transitions:
	$(PY) -m mojive.tools.viewcube_transitions --renderer $(BACKEND) $(ARGS)

.PHONY: camera-selection
camera-selection:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_viewcube.py -k scene_camera

.PHONY: file-receipt
file-receipt:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_ui_layout_input.py -k saved_file_receipt

.PHONY: native-load-benchmark
native-load-benchmark: native-python-build
	MOJIVE_NATIVE_BUILD="$(NATIVE_BUILD)" $(PY) -m mojive.tools.native_load_benchmark --root "$(MENAGERIE_ROOT)" $(ARGS)

.PHONY: native-editor-benchmark
native-editor-benchmark: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.native_editor_benchmark --root "$(MENAGERIE_ROOT)" $(ARGS)

# Reproducible monitoring stress: pinned motion, independent worlds, shared resources.
G1_MODEL ?= $(MENAGERIE_ROOT)/unitree_g1/scene.xml
G1_WORLDS ?= 16
.PHONY: g1-worlds g1-worlds-benchmark g1-worlds-transport mesh-lod mesh-lod-example shadow-visibility
shadow-visibility: native-python-build
	cmake --build $(NATIVE_BUILD) --target mojive_native_visibility_test --parallel $(NATIVE_JOBS)
	ctest --test-dir $(NATIVE_BUILD) -R '^native_visibility$$' --output-on-failure
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PYTEST) -q tests/native/test_native_visibility.py

mesh-lod: native-python-build
	cmake --build $(NATIVE_BUILD) --target mojive_native_lod_test mojive_native_visibility_test --parallel $(NATIVE_JOBS)
	ctest --test-dir $(NATIVE_BUILD) -R 'native_(lod|visibility)$$' --output-on-failure
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PYTEST) -q tests/native/test_native_lod.py
mesh-lod-example: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) examples/mesh_lod.py $(ARGS)
g1-worlds: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.g1_worlds --model "$(G1_MODEL)" --download --view --count $(G1_WORLDS) $(ARGS)

g1-worlds-benchmark: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.g1_worlds --model "$(G1_MODEL)" --download $(ARGS)

.PHONY: g1-geometry-views
g1-geometry-views: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.g1_worlds --model "$(G1_MODEL)" --download --worker $(BACKEND) --geometry-switches --camera detail --count $(G1_WORLDS) --output output/g1-geometry-views $(ARGS)

.PHONY: g1-replay-generate g1-replay g1-replay-check
G1_REPLAY_ARCHIVE ?= output/g1-replay/archive
G1_REPLAY_WORLDS ?= 64
G1_REPLAY_PREVIEW_WORLDS ?= 4
g1-replay-generate:
	$(PY) -m mojive.tools.g1_replay generate --model "$(G1_MODEL)" --worlds $(G1_REPLAY_WORLDS) --archive "$(G1_REPLAY_ARCHIVE)" $(ARGS)

g1-replay:
	$(PY) -m mojive.cli replay-joints "$(G1_REPLAY_ARCHIVE)" $(ARGS)

g1-replay-check: native-python-build
	$(PY) -m mojive.tools.g1_replay check --archive "$(G1_REPLAY_ARCHIVE)" --worlds $(G1_REPLAY_PREVIEW_WORLDS) $(ARGS)

.PHONY: world-selection-check
world-selection-check:
	$(PY) -m mojive.tools.world_selection "$(G1_REPLAY_ARCHIVE)" $(ARGS)

.PHONY: rollout-preview-check
rollout-preview-check:
	MOJIVE_RENDERER=$(BACKEND) $(PY) -m mojive.tools.rollout_preview "$(G1_REPLAY_ARCHIVE)" $(ARGS)

g1-worlds-transport:
	$(PY) -m mojive.tools.g1_worlds --model "$(G1_MODEL)" --download --transport-only $(ARGS)

.PHONY: g1-worlds-monitor-benchmark
g1-worlds-monitor-benchmark: native-python-build
	MOJIVE_NATIVE_BUILD="$(abspath $(NATIVE_BUILD))" $(PY) -m mojive.tools.g1_worlds --model "$(G1_MODEL)" --download --monitor --output output/g1-worlds-monitor $(ARGS)

.PHONY: canvas-2d-gallery canvas-2d-test
canvas-2d-gallery:
	$(PY) -m mojive.tools.canvas_gallery --backend $(BACKEND) $(ARGS)

canvas-2d-test:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_canvas2d.py

.PHONY: ui-design-native ui-native-design ui-native-workspace ui-native-capture ui-notice-review ui-design-native-check ui-design-icons ui-design-gizmos ui-design-runtime ui-design-reference ui-design-profile

## Compatibility alias for the native parameter editor.
ui-design-native: ui-native-design

## Edit native component parameters in a separate window attached to the actual workspace.
ui-native-design:
	$(PY) -m mojive.tools.design_workbench --backend $(BACKEND) $(ARGS)

## Inspect ordinary production panels in the actual native window.
ui-native-workspace:
	$(PY) -m mojive.tools.native_workspace --interactive --backend $(BACKEND) $(ARGS)

## Capture production panels and menus, then exit.
ui-native-capture:
	$(PY) -m mojive.tools.native_workspace --capture --backend $(BACKEND) --output output/ui_design/native/$(BACKEND) $(ARGS)

.PHONY: ui-theme-review
## Verify persisted themes and operation Undo through hidden production windows.
ui-theme-review:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_workspace_themes.py $(ARGS)

.PHONY: ui-status-mouse
## Capture muted mouse contrast without changing input geometry or status typography.
ui-status-mouse:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_status_mouse_hints.py $(ARGS)

.PHONY: ui-interaction-guide
## Capture shared keyboard/mouse indicators and complete scrolling guide content.
ui-interaction-guide:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_interaction_guide.py $(ARGS)

.PHONY: ui-control-review
## Verify filters, focus, side panels and About through hidden production windows.
ui-control-review:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_control_consistency.py $(ARGS)

.PHONY: ui-menu-review
## Verify mode captions, semantic menu groups and helper/outline overlap in hidden windows.
ui-menu-review:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_menu_density.py tests/gpu/test_outline.py $(ARGS)

## Capture complete production notice surfaces and inline/stacked file actions.
ui-notice-review:
	$(PY) -m mojive.tools.native_notice_review --backend $(BACKEND) --output output/ui_design/notices/$(BACKEND) $(ARGS)

.PHONY: ui-design-guide
## Browse typography, palettes, spacing and independent panel-group prototypes.
ui-design-guide:
	$(PY) -m examples.ui_design.native.design_guide --backend $(BACKEND) $(ARGS)

## Retain the standalone design study for typography/icon galleries and the prototype workbench.
ui-design-reference:
	$(PY) -m examples.ui_design.native.docking_study --backend $(BACKEND) --output output/ui_design/reference/$(BACKEND) $(ARGS)

ui-design-native-check:
	$(PYTEST) -q -m 'not gpu' tests/test_ui_design.py tests/test_ui_design_fonts.py tests/test_ui_design_icons.py tests/test_ui_design_icon_roles.py tests/test_ui_design_controls.py tests/test_ui_design_runtime.py tests/test_ui_design_numeric.py tests/test_ui_design_output.py tests/test_ui_design_navigation.py tests/test_ui_design_pose.py tests/test_ui_design_settings.py tests/test_ui_design_components.py tests/test_ui_design_menus.py tests/test_ui_design_timeline.py tests/test_ui_design_timeline_details.py tests/test_ui_design_camera.py tests/test_ui_design_color.py

## Verify native scene interactions, flat gizmos and settings; capture representative states.
ui-design-gizmos:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_ui_design_gizmos.py tests/gpu/test_value_rails.py

## Verify scaled panels, scene selection, numeric edits, timeline and file actions.
ui-design-runtime:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_native_workspace.py tests/gpu/test_design_workbench.py tests/gpu/test_menu_bar_interaction.py tests/gpu/test_design_audit_draw.py

ui-design-profile:
	$(PY) -m mojive.tools.design_profile --backend $(BACKEND) $(ARGS)

.PHONY: ui-native-audit ui-native-pick-check
UI_AUDIT_SCALE ?= 1
## Edit and reset every component field against the production workspace.
ui-native-audit:
	$(PY) -m mojive.tools.design_audit --backend $(BACKEND) --scale $(UI_AUDIT_SCALE) --output output/design-parameter-audit/$(BACKEND)-$(UI_AUDIT_SCALE)x/audit.json $(ARGS)

## Alt-click each visible production instance and check its component groups.
ui-native-pick-check:
	$(PY) -m mojive.tools.design_audit --pick --backend $(BACKEND) --scale $(UI_AUDIT_SCALE) --output output/design-picking-audit/$(BACKEND)-$(UI_AUDIT_SCALE)x/audit.json $(ARGS)

## Recompile tracked icon contours after editing the SVG masters.
ui-design-icons:
	$(PY) -m examples.ui_design.native.compile_icons

UI_DESIGN_PORT ?= 8768
.PHONY: ui-design ui-design-check
## Open /examples/ui_design/web/ on the local server to review the web reference.
ui-design:
	@echo 'Open http://127.0.0.1:$(UI_DESIGN_PORT)/examples/ui_design/web/'
	$(PY) -m http.server $(UI_DESIGN_PORT) --bind 127.0.0.1 --directory .

ui-design-check: ui-design-native-check
	node examples/ui_design/web/model.test.mjs

.PHONY: ui-floating ui-inspector-tabs
## Capture Inspector tabs and verify distinct geometry, physics and material controls.
ui-inspector-tabs:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_native_workspace.py -k inspector_tabs_keep

## Capture floating forms and verify selection, focus, closing, dragging and edits.
ui-floating:
	MOJIVE_RENDERER=$(BACKEND) $(PYTEST) -q -m gpu tests/gpu/test_floating_surfaces.py $(ARGS)