WIP: fix(perf): perf samples follow the camera, land in the relay's own cells, and skip cutscenes and the title #1502
No reviewers
Labels
No labels
area/accessibility
area/audio
area/input
area/install
area/menu
area/renderer
area/saves
area/tooling
area/upscaling
beanstalk: approved
beanstalk: failed
beanstalk: needs approval
beanstalk: running
beanstalk: tested
ci: approved
good first issue
gpu/amd
gpu/igpu
gpu/intel
gpu/nvidia
help wanted
kind
bug
kind
chore
kind
docs
kind
feature
kind
performance
kind
question
needs measurements
platform/linux
platform/macos
platform/steam-deck
platform/windows
preview
priority
critical
priority
high
priority
low
regression
risk
high
risk
low
risk
medium
status
blocked
status
confirmed
status
duplicate
status
invalid
status
needs-info
status
wontfix
ci: approved
No milestone
No project
No assignees
2 participants
Notifications
Due date
No due date set.
Dependencies
No dependencies set
Reference
MagicBeanDev/Longshot!1502
Loading…
Reference in a new issue
No description provided.
Delete branch "mooki/Longshot:fix/perf-pose-bins-1383"
Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?
Type: fix · Risk: low · Tested on: Linux (Arch, kernel 7.2.15), RTX 4090 (NVIDIA 615.78.08), windowless in the game; game-free checks; the relay's rules by a Python port of its public source · Needs: Windows, any GPU; the real relay (not reachable from the test PC)
TL;DR
The performance statistics merged in #1383 sent every camera angle as 0, filed half the positions one relay cell off, and still sampled cutscenes. This PR takes yaw and pitch from the camera's eye and target, sends positions as the relay's own cells, and sends no sample in a cutscene, at the title or across a map change. In a ten-minute Linux run all 299 samples were in the relay's range and on its cells; 84 % matched the camera's bins, 98 % the relay's cell of the real position, and 4 fell in cutscenes (102 of 278 before). Windows and the real relay are untested.
Breakdown
Why
dyst's #1383 (on top of #1372 by gab9281) made the opt-in performance summaries fit the sender's limit, took the pose from Link at most four times a second, and left out stale ones. Our review of #1383 found three more problems in how the position and the view are sent and sampled; a Linux run of the merged code (its head,
36de9b0ce, which is main's code in these files) confirmed them with the game's own numbers. This PR fixes them and adds the tests that would have caught them; the size fitting, the best part of #1383, is untouched.Refs #1383. Follows our review of #1383 (review 1676).
How to reproduce
Seen on: Linux (Arch), RTX 4090, NVIDIA 615.78.08, windowless; the build of #1383's head (
v3.0.0-rc.7-5-g36de9b0ce), the same code as main in these filesSettings and switches: Send performance statistics ticked (
send=1inlongshot_perf.ini),RX_VK_PERF_INTERVAL=60(a summary every minute),HOS_CONTROLon for the bridge's cameraSteps: start a save in Kokiri Forest, turn the camera with the right stick, walk, let a cutscene play; read the
samplesof the summaries inperf_pending/(orperf_sent/), besidestatus.game.cameraandstatus.game.posof the control bridge (docs/control.md)Expected: yaw follows the camera (the bridge's
camerain degrees, times pi/180), pitch follows the stick, x, y and z are the relay's cell of Link's place, and a cutscene's seconds have no sampleActual: on main every sample has yaw 0.393 and pitch 0.262 whatever the camera does; x, y and z are 50 mod 100 (an exact position of (-46.09, 118.44, 15.39) is sent as (-50, 150, 50), which the relay files under x=-100, y=200, z=100 instead of x=0, y=100, z=0: 0 of 263 and 0 of 176 aligned samples in two runs landed in the cell the relay gives the exact place); in the review's runs the cutscene seconds were sampled in four of six
What changed
The pose now follows the camera and is sent in the relay's own terms, and a second that has no honest pose has no sample. The yaw and pitch come from the gameplay view's eye and target the way
oot_state_tap.c'sstate_cameramakes the bridge's camera; positions go out as the relay's own cell; and the host stops giving a pose during an event, at the title and across a map change.host/hos_main.c:oot_camera_angles()(new) takes yaw and pitch from the view's eye (+96) and target (+120), three doubles each: yaw isatan2(dx, dz)(0 toward +z, pi/2 toward +x, sostatus.game.camerain radians), pitch isatan2(dy, hypot(dx, dz))(positive looking up).oot_float_within()keeps the stored float no further from 0 than the double, so pi is never stored as a float above it. A view that has no direction (looking straight up or down, the eye on the target) or a value that is not a number gives no pose. The old guard of 64 on the angles is gone.oot_perf_pose(): no pose whileoot_event_playing()(as the flight andoot_fov.cdo), then the view's type check, the angles, and Link's place;lastis documented as Link's update, which holdscheats_lock.hos_perf_info(): no pose while the map is empty (the title).oot_inventory_refresh(): the pose is cleared where the map line changes (as it is at the title).gpu/vk/perf_report.h:cell_of()sends a position asround(v / 100) * 100(no negative zero);yaw_bin_middle()wraps a yaw of pi into the first bin as the relay'sfmoddoes;pitch_bin_middle()puts straight up in the top bin, so every sent angle is inside the relay's range.bin_middle()is removed with its callers.tests/test_perf_pose.pyandtests/perf_pose_test.c(new) cutoot_perf_pose,hos_perf_info,oot_event_playing,oot_gameplay_viewandoot_inventory_refreshout ofhost/hos_main.cand run them on a made-up guest: 41 checks.tests/test_perf_report.cpp: the cells and bins by name (ties, negative zero, pi, straight up, a sweep of every angle), and it writes the size cases and 20,363 exact places and views with what was sent for each.tests/test_perf_report.py: re-encodes every size case the way the sender does (json.dumps), sends them with the sender, and judges the pairs by the relay's rules (a short statement of the relay's cell, view bins and range, from its public source);-D_CRT_SECURE_NO_WARNINGSon the compile line lets the Windows-target syntax check pass for this fixture (it failed on main).docs/performance-statistics.md, the README's paragraph and theperf_infocomment ingpu/vk/vk_api.hsay what is sent now (they said the relay rounds, and "floor", which was wrong for positions). A comment only:MKWVK_API_VERSIONis unchanged.Unchanged:
nx2/perf_report.py(its "64 KiB" comment is stale since the relay took 192 KiB; the sender'sMAX_BODYstays 60 KiB as #1383 set it), the thinning, the one-second sample clock.Measurements
Verdict: it helps, and the game shows it: in a ten-minute run of this build every one of the 299 samples is inside the relay's range and on its cells (the first version sent one yaw and one pitch value and cells on the relay's ties), the angles follow the camera (251 of 298 aligned samples share the relay's yaw and pitch bins with the camera of that second, 89 of 108 where the camera was steady; the alignment is good to about a second), the sent cell is the relay's cell of the bridge's position for 292 of 298 samples, and cutscene seconds are left out (4 of 299 samples near an event window, against 102 of 278 before). It is not clean: the 47 samples whose bins differ and the 6 whose cell differs all sit at a camera command, a map change or an event edge, where a one-second alignment cannot settle them; the way back to the title, Windows and the real relay were not exercised.
Hardware: Linux (Arch), kernel 7.2.15, RTX 4090 (NVIDIA 615.78.08), i9-13900K, 94 GB; windowless, ordinary class, other sessions on the machine (load average 8.7 at the start of the run, 45.7 at its end)
Scene: Kokiri Forest and Hyrule Field (child), a kept save that starts in Link's house; camera turned with the right stick; Saria's scene as the cutscene; two debug teleports between the two areas; a pause
Method: the performance statistics ticked, a summary every 60 s and one at the end; the control bridge polled four times a second for
camera,pos,map,eventandloading, and the gameplay view's eye and target read from guest memory (read-only); the samples aligned to the polls by counting the seconds Link was updated; every summary judged by a Python port of the relay's validation and binning, and sent by the real sender to a collector on this PC inside a network namespace with no route outHow to reproduce: as in "How it was tested" below
Baseline: the "Before" column is the Linux run of #1383's head (
36de9b0ce) by our review, because that code is main's in these files (git diff 36de9b0ce c14641a6ftouches none ofgpu/vk/perf_report.*,host/oot_state_tap.c, the pose code ofhost/hos_main.c); main @c14641a6fitself was not run.36de9b0ce9dd58d631Flags and settings
None.
Testing
Tested:
Environment: Arch Linux (Omarchy), kernel 7.2.15-1, RTX 4090 with NVIDIA 615.78.08, i9-13900K, 94 GB, clang 23.1.3, g++ 16.2.1, the project's pinned Python 3.12 for the suite; the tests, the mutants and the game run are of this PR's head
9dd58d631on mainc14641a6f, where the game run was made; the whole suite was also run onde69ec582, its rebased twin on current main310e7c9df(52 commits afterc14641a6f; some, such as #1299 and #1459, touchtests/test_perf_report.py's docstring andhost/hos_main.celsewhere), whose code is identical:git range-diff 9dd58d631~1..9dd58d631 310e7c9df..de69ec582shows only the context of that test file's docstring and imports changed; 17 Nov 2026; the game windowless at 1280x720 pictures; load average 9 to 84 across the checks (the machine is shared).How each check was made, step by step:
python -I -B tests/test_perf_report.py --cxx g++: 92 checks pass. It compilestests/test_perf_report.cppagainstgpu/vk/perf_report.h(buckets, hitches, pacing, the JSON, the cells and bins by name, what a frame costs to add) and runs it with a folder: the C++ test writes there the eight size cases (16 maps with every count set and a sample a second for 840 s with names of 1, 2, 3 and 4 UTF-8 bytes a character, the widest numbers, one map for five and for 14 minutes) andpairs.tsv, 20,363 exact places and views (every multiple of 25, 20,000 random places and views, every edge of the yaw and pitch bins and the floats beside it, pi and pi/2) beside the JSON the game makes of each. Python then (a) re-encodes each size case the way the sender does (json.dumps(..., separators=(",", ":")), whatnx2/perf_report.pysends), checks it is at mostMAX_BODY, and has the sender itself send all eight to a stand-in relay (none refused and deleted); (b) judges each pair by the relay's rules, a short statement written from the relay's public source (totals.go: the cell ismath.Round(v / 100) * 100; summary.go:|yaw| <= pi,|pitch| <= pi/2, else the whole summary is refused with a 400): the sent sample must be one the relay takes, and be filed under the same cell and view bins as the exact one (the cell compared as a number: the relay's own label of an exact place in (-50, 0) isx=-0, Go printing a negative zero).python -I -B tests/test_perf_pose.py: 41 checks pass. The Python driver cuts the real functions out ofhost/hos_main.cby their text (tests/srccut.py, as many tests here do) into a header and compiles it withtests/perf_pose_test.c, which makes up the rest: the camera manager's pointer chain to the gameplay view, its eye and target, the event manager, Link's place, the clock, the locks (a lock taken twice or released unheld is counted) and what the save says (the map, loaded or not). Nothing is taken from a dump. It checks the yaw and pitch over a whole turn at three heights against the bridge's camera (the same arithmetic asoot_state_tap.c, which the driver also asserts is the one in the file), the relay's range for every direction (3,601 yaws at 61 pitches, straight behind from either side of the axis included), no pose for straight up or down, an eye on the target, a value that is not a number or infinite, a stray place, another kind of camera object, an event playing (the pose before it goes too), an update less than 250 ms after the last, 999 ms and 1001 ms after the last update, unticked, the map line changing, and the title (no map: no pose, even for a Link update just after the clear).git archiveofc14641a6f, the new test files copied in):test_perf_report.pyfails 6 checks (one of them a consequence: the C++ test stops at its first failing check), among them "per-second position and view, as cells and bins" (-150 where the nearest 100 is -100), "the relay files each sample under the cell it files the exact place under (17,854 of 20,363 differ)" and "the relay takes every sample the game sends (4 of 20,363 are out of range: pi and pi/2 edges)";test_perf_pose.pyfails 19 of 41 (yaw and pitch that do not follow the camera, no event, title and map-change handling, straight up). The output of both is attached to the first comment.sent_sizecounting no escapes,kMaxBodyat 64 KiB, thinning taking the first N) are all killed. (On #1383's tests thesent_sizemutant survived: its size test measured with the function under test.)HOME:python -I -B tests/run_all.py --jobs 6 --strict: 671 passed, 37 failed, 17 skipped in 276 s. That run is of9dd58d631. The same 37 names fail with the same messages on main @c14641a6fon this PC (run on a cleangit archiveof main), so none is this PR's; main's own suite is red (for exampletests/test_fsr_uniform_ownership.pycuts code that usesFpsRtWaitwithout its header). Onde69ec582, the rebased twin of this PR on main310e7c9df(code identical, range-diff above), it gave 708 passed, 43 failed, 17 skipped in 555 s. Those 43 were then run on a cleangit archiveof main310e7c9df(18 Nov):0 passed, 43 failed, the same 43 names with the same first error line each, among them the nine that were not in the first list (test_compute_warm_apart,test_dev_packs,test_draw_stream_visibility,test_fsr_image_retirement,test_invalidate_quick,test_libc_hooks,test_log_open_failure,test_psychov35_fsr3_fg,test_switch_table: for example an unused variable under-Werror, a fixture that useshost_read_barrierorhos_log_redact_filebefore main has them in its header). None of the 43 is a perf check, and none passes on main. The 37 that fail on this PR's own basec14641a6f, also failing there on main with the same messages, are:test_bug_report_defaults,test_cpu_report,test_crt_options,test_damage_debug_menu,test_display_startup_failure,test_dlss_feature_size,test_failed_compile_keeps_objects,test_framegen_preset,test_fsr_uniform_ownership,test_guest_imported,test_hud_layout_row,test_import_reach,test_invalidate_vcore,test_linux_preflight,test_linux_pressure,test_linux_update,test_mirror_budget,test_missing_nup,test_mods_size_table,test_nonuniform_image_arrays,test_parallel_init_order,test_pending_guest_import,test_pipeline_play_cache,test_present_thread,test_profiling_mode,test_readback_timeout_source,test_replay_write_order,test_rumble_menu,test_run_all_changed,test_slow_frames,test_staging_burst,test_target_image_pool,test_upscaler_round_trip,test_upscaler_rows,test_vcore_escape,test_vk_occlusion_queries,test_walk_key. The lists are attached to the first comment.tests/test_perf_report.cpppasses (-D_CRT_SECURE_NO_WARNINGSwas needed and is now on its compile line);tests/test_perf_pose.pyskips Windows (its locks and Interlocked calls are made up for POSIX). Syntax is not Windows execution.9dd58d631(the game logsv3.0.0-rc.7-10-g9dd58d631, sourcef4165d7a), compiled with clang 23.1.3 in 4 min 51 s (compile 1 min 42 s); the object store of the earlier build of #1383's head was reused (the lifted code is identical,nx2/being unchanged between the two) so only the units whose source changed were compiled. The game run is of this build; the rebase ontodcb7b47c2changed no line of the patch (so the run is carried, not rerun, and the game's version line names9dd58d631). The shader caches of that build were reused too: the translator's inputs are unchanged between the two commits (git diffof the files the stamp holds is empty).longshot_perf.iniwithsend=1in the game folder,RX_VK_PERF_INTERVAL=60, read-only guest reads on for the camera probe (HOS_CONTROL_MEM=ro, neverrw).docs/control.md): a short stand, then the chain's own connection to the bridge's socket: the right stick held and released for the camera (stick), the house door and Saria's arrival scene and her talk (the pilot's proven route: an event,status.game.eventtrue), a 6-second pause (press PLUS), ten debug teleports between the two areas (!cheat 1000and1001through the live input file; nine arrived, one was refused while a conversation held Link), with four camera turns after each; Saria's conversation that starts at the arrival point in the forest is answered with A, and finallyquit, the only exit that writes the last summary. Four times a second the chain readstatus(frame,camerain degrees,pos,map,event,loading) and the gameplay view's eye and target (mem_readat the camera manager's first camera's view), and kept every reply.kmemsysDoCacheOpline in the kernel log over the run, and no core dump of the game (the journal has qemu-aarch64-static crashes of another job 35 s before the hold started).perf_pending/) were read by a script that (a) judges each with the relay port, (b) aligns the samples to the polls by counting the seconds Link was being updated inside each summary's own window (a sample is a second of frames with a pose and the samples have no clock; a summary's file name is its end time and its maps' seconds its length, so the count restarts at each summary; a first version counted over the whole run and was seconds off, and its 89 of 294 is not reported), (c) compares each sample's yaw and pitch bins with the bins of the cameras read from guest memory within 1.5 s of it, and where the camera was steady for three seconds (so the alignment cannot matter), (d) compares the relay's cell of each sample with the relay's cells of the bridge's positions within 1.5 s, (e) counts the samples whose aligned time falls in an event window the bridge reported, (f) lists the gaps (pause, loads). Of the 298 samples with polls around them, 47 differ in a bin from the camera within 1.5 s and 6 in the cell, all of them at a camera command, a map change or an event edge (the chain commands the camera every 5 to 10 s, so that alone is not a proof of cause); none is more than a bin or a cell off.nx2/perf_report.pyof this commit) to a collector on 127.0.0.1 in a network namespace with no route out (unshare -Urn; the script refuses to start when a route out exists). The collector is a Python port of the relay's validation and binning; its self-test is the relay's own test expectation.perf_pending/;python -I nx2/perf_report.py <game folder>prints what would be sent.Not tested:
host/hos_main.c(the new code usesatan2,hypot,nextafterfandfabsonly, all in the C runtime), and no Windows execution oftests/test_perf_report.cpportests/perf_pose_test.c(only the syntax check of the first).eadbca4(Go is not installed on the test PC); its own tests and a real POST were not run.de69ec582(main310e7c9df): none; its code is identical to the tested head's and it is kept local until it has had its own run.Not testable by hand: the relay's side. Whether the real relay takes these summaries and files them under the cells and bins shown can't be run from the test PC (the relay is not reachable from it, and nothing may be sent to it from a test); a Python port of its public validation and binning, applied to every summary the game wrote and to 20,363 exact places and views, stands in for it. A tester with the real relay (the team) can read the dashboard's cells after the first summaries of a build with this change.
Must be tested:
perf_sent/(orperf_pending/), expecting everyx,yandza multiple of 100 with 0 among them,yawandpitchchanging with the camera, none outside -pi..pi and -pi/2..pi/2, and no sample from the cutscene's seconds (by hand: a Windows player; or the Test Farm: @Beanstalk windows, the opt-in on, five minutes of play with camera turns and a cutscene).Risks
What could break: a second without a pose has no sample, so a camera looking exactly straight up or down, an event, a pause longer than a second and the first quarter second after a door or a teleport leave a gap in the one-second samples (they never carried a place before for those seconds that was right); the position's cell is the nearest 100, so a place just beside a cell's edge is in the neighbour cell, as it is for the relay's own rounding of the exact place; a pose could pair a new map's place with the old map's name for up to half a second after a door (the map line is read twice a second; the pose is cleared where the line changes, not before it does). The wrong guesses would show as the first yaw bin again, a cell off, or a sample in a cutscene, all of which the new tests check.
Cost: none that I know of, but not measured, so the checklist's "Nothing gets worse that I know of ... measured and in Risks" box is left unticked: a speed measurement needs a quiet-machine hold I did not have. What the change adds, with the option ticked, at most four times a second: one event-manager read, six doubles loaded and an
atan2/hypotpair (the first version already read the view and the place);add_frameand the frame path are untouched. The frame times of the run above (mean 54.9 fps, 1% low 12.9 fps on a PC at load 8 to 46) are an ordinary loaded run, not a measurement. With the option off nothing is read. Measured: not yet. A paired exclusive timing, mainc14641a6fagainst this head9dd58d631(the PR's own base, both with the option ticked, the same save and scene, main, head, main, head in one 470 s hold of the shared worker), is planned for the night of 18 to 19 Nov in the main lane (its warm-up run is queued first). This paragraph and the box are updated with its numbers, or with the reason it was not accepted (a run that is not valid or not quiet gives no number). What it can show is small: the pose is read at most four times a second, so a difference inside the run-to-run spread is the expected result, and it is not a measurement of the opt-in's whole cost on a player's PC.Turning it off: untick the option (the pose is not read while it is off), or revert the commit.
Compatibility: nothing changes for a player's files, saves or settings; the summary's format is the relay's version 1 as before; a build before this PR sends its angles in the first bins and its places on the relay's ties, so the relay's old data for those fields is not comparable with the new.
Overlaps
Of the 338 open pull requests, 107 change one of the files this PR touches (mostly
README.md,gpu/vk/vk_api.handhost/hos_main.c, which are everyone's). The scan and the trial merges were made with main atc14641a6f; the PR head9dd58d631merges with main310e7c9dfwithout a conflict (trial merge). A trial merge (git merge-tree) of each head against this branch and against main gives the same conflicts as main for all of them except #1372 (the stack base of #1383, whose commits are in main since #1383), which also conflicts with this branch inREADME.md, the paragraph this PR rewrites. The pull requests that change the performance statistics' files: #1368 (the sender's send lock, issue #1265) is based on a commit before #1383 and conflicts with main already indocs/performance-statistics.md, the same file with this branch, whiletests/test_perf_report.pymerges cleanly; #1299 (nx2/perf_report.pyand its test) has since merged into main and the rebase took it without a conflict; #206 (the first version of the statistics) conflicts with main already.Issues
See #1383.
Checklist
Everyone
type(scope): description) of the status line's type.can't be run by hand is in Testing's Not testable by hand, with why.
in Risks.
main: on main @c14641a6f, where the game run was made; merges with main @310e7c9dfwithout a conflict; a rebased twin is ready once it has had its own game run.python -I -B tests/run_all.pypasses (any failure that also fails onmainis named).third_party/untouched (a new folder with aPROVENANCE.mdinstead).When it applies
Assisted-by:/Co-Authored-By:trailers.mainand passing here.tests/that reads changed source updated in this PR, not weakened.New on this forge; not opened on GitHub.
Independent Windows evidence for the camera-angle defect this PR covers: a nightly-455-b8f3d547 gameplay session on Windows 11 / RTX 4070 / NVIDIA 621.01 contained 945 position samples, all with yaw 0.393 and pitch 0.262. The raw session artifacts remain local.
I independently traced this to
oot_perf_posereading controller float offsets from the rendered LookAtCamera. A Windows llvm-mingw fixture exercising the actual function over synthetic guest memory fails on unchanged main310e7c9dwhen a view looking along +X returns yaw zero instead of pi/2. A small local repair using target minus eye passes cardinal/diagonal/tilt and invalid/opt-out cases, and rejects deliberately broken variants.That is corroboration of the baseline defect and the direction convention, not a test or review of this PR's head. I have not built or run
9dd58d631on Windows, exercised the real relay, or measured overhead. This PR already covers the same repair plus cell/bin and cutscene handling, so I will not open a competing camera PR. The remaining useful Windows check is this head's in-game camera rotation and elevation, with summary samples checked against the bridge and relay rules, including map/event edges.Thank you: a second platform's evidence for the defect is exactly what I could not get. 945 samples at yaw 0.393 and pitch 0.262 on Windows 11 / RTX 4070 matches what I saw on Linux before the fix (all 1,443 samples of six runs at the same two values), and your fixture agrees with the direction convention this PR uses: yaw 0 looking along +z, pi/2 looking along +x, the bridge's
camerain radians.Where this head stands. Linux only. One game run of
9dd58d631on Linux (the numbers are in the description): angles follow the camera, positions are the relay's cells, no samples in cutscenes. On Windows I have only the syntax check of the changed C++ fixture with llvm-mingw.tests/test_perf_pose.py(the stub test of the real pose functions) skips Windows because its locks are made up for POSIX, so on Windows your fixture is the only thing that runs the actual function. I have not run this head in a Windows game, and nothing was sent anywhere: the game never sends, the launcher does.What I can do.
longshot_perf.iniwithsend=1),RX_VK_PERF_INTERVAL=60, the control bridge on; the right stick held in each direction, a cutscene, a door and a map change; the game closed from its window so the last summary is written; the summaries inperf_pending/read offline againststatus.game.cameraandstatus.game.posof the bridge, with the relay's rules (range, cells, bins) applied by a script. The analysis is the one used for the Linux run.What would help from you, if you can. You said the useful remaining Windows check is this head's camera rotation and elevation in the game. If you build
9dd58d631(or take a nightly that has it once it is merged) and do the same by hand (tick the option, turn the camera in all four directions and up and down for a minute or two, a door, then read thex,y,z,yawandpitchinperf_pending/*.json): expected are x, y and z multiples of 100, yaw between -3.14 and 3.14 and following the camera (0 looking along +z, about 1.57 along +x), pitch between -1.57 and 1.57 (below 0 looking down), no sample in the seconds of a cutscene, and a summary that your relay rules accept. Your fixture run against this head'soot_camera_anglesandoot_perf_pose(not main's) would also tell whether the Windows compile of the new code behaves as the Linux one does. The stub test's own fixture (tests/perf_pose_test.c, with the functions cut out ofhost/hos_main.cbytests/test_perf_pose.py) compiles cleanly here forx86_64-w64-mingw32with-Wall -Wextra -Werror(compile only: I cannot link or run it on this PC), so running it natively on Windows is possible too, and a pass there would be the Windows execution of this head's pose code that I do not have. A differing number, with the camera angle beside it, is what I would want to see; please keep the raw session local, as you did.View command line instructions
Checkout
From your project repository, check out a new branch and test the changes.