@bendyline/molen-client 0.0.12 → 0.0.15
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -1
- package/dist/aircraft.d.mts +16 -6
- package/dist/aircraft.mjs +627 -20
- package/dist/camera-track.d.mts +1 -1
- package/dist/glass.mjs +2 -1
- package/dist/index.d.mts +31 -3
- package/dist/index.mjs +578 -105
- package/dist/{input-BliZYUY1.mjs → input-CzlS1f2N.mjs} +5 -3
- package/dist/instance-batch-CO4YD6rd.d.mts +69 -0
- package/dist/instance-batch-Ds-oKQW4.mjs +222 -0
- package/dist/instancing.d.mts +2 -0
- package/dist/instancing.mjs +2 -0
- package/dist/navigation.d.mts +12 -3
- package/dist/navigation.mjs +25 -7
- package/dist/{renderer-DAk7C8jH.d.mts → renderer-4kSVioiH.d.mts} +95 -3
- package/dist/snow-cover-Bh0woabf.mjs +218 -0
- package/dist/snow-cover-tEG1uO98.d.mts +67 -0
- package/dist/snow.d.mts +2 -0
- package/dist/snow.mjs +2 -0
- package/dist/{vehicle-interior-CeyzF5El.mjs → vehicle-interior-CNLLi38s.mjs} +22 -1
- package/dist/vehicle-interior-XC2tAySI.d.mts +232 -0
- package/dist/vehicles.d.mts +43 -3
- package/dist/vehicles.mjs +595 -5
- package/dist/{webgpu-clouds-H03g7ID1.mjs → webgpu-clouds-DwSBoV8A.mjs} +15 -11
- package/dist/{webgpu-driver-BQnmPRqs.mjs → webgpu-driver-YWVTLOY7.mjs} +103 -4
- package/dist/webgpu-snow-cover-CiqYhvPq.mjs +55 -0
- package/package.json +11 -3
- package/dist/vehicle-interior-B8TpzTAx.d.mts +0 -56
package/dist/aircraft.mjs
CHANGED
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
import { t as createModelSignalVisual } from "./model-signals-DLgvjBeZ.mjs";
|
|
2
2
|
import { t as applyLivery } from "./livery-qcDLzbU9.mjs";
|
|
3
|
-
import {
|
|
3
|
+
import { a as createAircraftDamageVisual, i as aircraftObstacleContacts, n as drawGlassInOnePass, r as isGlass, t as createVehicleInteriorVisual } from "./vehicle-interior-CNLLi38s.mjs";
|
|
4
|
+
import { boostSpeedMultiplier } from "@bendyline/molen-schema";
|
|
4
5
|
import * as THREE from "three";
|
|
5
6
|
//#region src/aircraft-controls.ts
|
|
6
7
|
/** Discover moving controls from their authored input bindings, never from instrument needles. */
|
|
@@ -342,15 +343,17 @@ function createAircraftPropellers(model, spec) {
|
|
|
342
343
|
disk,
|
|
343
344
|
blades: blades.map(({ mesh }) => {
|
|
344
345
|
const original = mesh.material;
|
|
346
|
+
const faded = (Array.isArray(original) ? original : [original]).map((m) => {
|
|
347
|
+
const clone = m.clone();
|
|
348
|
+
clone.transparent = true;
|
|
349
|
+
clone.depthWrite = false;
|
|
350
|
+
return clone;
|
|
351
|
+
});
|
|
352
|
+
mesh.userData.materialVariants = [...Array.isArray(original) ? original : [original], ...faded];
|
|
345
353
|
return {
|
|
346
354
|
mesh,
|
|
347
355
|
original,
|
|
348
|
-
faded
|
|
349
|
-
const clone = m.clone();
|
|
350
|
-
clone.transparent = true;
|
|
351
|
-
clone.depthWrite = false;
|
|
352
|
-
return clone;
|
|
353
|
-
}),
|
|
356
|
+
faded,
|
|
354
357
|
shadow: mesh.castShadow
|
|
355
358
|
};
|
|
356
359
|
})
|
|
@@ -359,7 +362,7 @@ function createAircraftPropellers(model, spec) {
|
|
|
359
362
|
}
|
|
360
363
|
}
|
|
361
364
|
return {
|
|
362
|
-
update(state) {
|
|
365
|
+
update(state, castShadows = true) {
|
|
363
366
|
for (const prop of propellers) {
|
|
364
367
|
const rpm = (prop.engine === void 0 ? void 0 : state.engines?.[prop.engine])?.rpm ?? state.rpm;
|
|
365
368
|
const blend = prop.parts.some((part) => state.damage?.[part]?.detached) || !Number.isFinite(rpm) ? 0 : THREE.MathUtils.smoothstep(Math.abs(rpm * prop.speed), 20, 60);
|
|
@@ -372,8 +375,10 @@ function createAircraftPropellers(model, spec) {
|
|
|
372
375
|
material.opacity = source.opacity * (1 - blend);
|
|
373
376
|
material.visible = source.visible && blend < 1;
|
|
374
377
|
}
|
|
375
|
-
|
|
376
|
-
|
|
378
|
+
const ready = mesh.userData.materialReady;
|
|
379
|
+
const fading = blend > 0 && (ready === void 0 || faded.filter((material) => !ready(material)).length === 0);
|
|
380
|
+
mesh.material = !fading ? original : Array.isArray(original) ? faded : faded[0];
|
|
381
|
+
mesh.castShadow = shadow && !fading && castShadows;
|
|
377
382
|
}
|
|
378
383
|
}
|
|
379
384
|
},
|
|
@@ -674,7 +679,522 @@ function bindActiveCockpitPointer(options) {
|
|
|
674
679
|
};
|
|
675
680
|
}
|
|
676
681
|
//#endregion
|
|
682
|
+
//#region src/pilot-motion.ts
|
|
683
|
+
/**
|
|
684
|
+
* The tuned defaults, sized to be felt more than seen. Flown through the kernel's flight model:
|
|
685
|
+
* a 6 g pull in the P-51 lowers the eye 3 cm, presses it over 1 cm back and drops the chin 1.5°,
|
|
686
|
+
* and on release the pilot comes up nearly 1 cm past rest before settling; 8.5 g in an F-16
|
|
687
|
+
* sinks 3.8 cm. Full brakes at 0.75 g throw the pilot nearly 3 cm forward, half of which they
|
|
688
|
+
* recover as they brace; full power presses them 1 cm back. A 60° bank tilts the head 3° toward
|
|
689
|
+
* the horizon.
|
|
690
|
+
*/
|
|
691
|
+
const DEFAULT_PILOT_MOTION = {
|
|
692
|
+
enabled: true,
|
|
693
|
+
intensity: 1,
|
|
694
|
+
maxLoad: 12,
|
|
695
|
+
braceTime: 1.2,
|
|
696
|
+
heave: {
|
|
697
|
+
travel: .008,
|
|
698
|
+
limit: [.045, .025],
|
|
699
|
+
frequency: 2.6,
|
|
700
|
+
damping: .5,
|
|
701
|
+
brace: .3
|
|
702
|
+
},
|
|
703
|
+
surge: {
|
|
704
|
+
travel: .025,
|
|
705
|
+
limit: [.015, .06],
|
|
706
|
+
frequency: 1.8,
|
|
707
|
+
damping: .55,
|
|
708
|
+
brace: .5
|
|
709
|
+
},
|
|
710
|
+
sway: {
|
|
711
|
+
travel: .03,
|
|
712
|
+
limit: [.05, .05],
|
|
713
|
+
frequency: 1.6,
|
|
714
|
+
damping: .55,
|
|
715
|
+
brace: .6
|
|
716
|
+
},
|
|
717
|
+
head: {
|
|
718
|
+
nod: .006,
|
|
719
|
+
surgeNod: .04,
|
|
720
|
+
swayTilt: .05,
|
|
721
|
+
lag: .004,
|
|
722
|
+
horizonLean: .12,
|
|
723
|
+
limit: .1,
|
|
724
|
+
neck: .12,
|
|
725
|
+
frequency: 2.4,
|
|
726
|
+
damping: .6
|
|
727
|
+
}
|
|
728
|
+
};
|
|
729
|
+
/** A {@link PilotMotionSample} from a vehicle's transform and state. */
|
|
730
|
+
function pilotMotionSample(time, transform, state) {
|
|
731
|
+
return {
|
|
732
|
+
time,
|
|
733
|
+
position: transform.pos,
|
|
734
|
+
rotation: transform.rot,
|
|
735
|
+
velocity: state.velocity,
|
|
736
|
+
travelScale: boostSpeedMultiplier(state.boosted)
|
|
737
|
+
};
|
|
738
|
+
}
|
|
739
|
+
const G = 9.81;
|
|
740
|
+
/** Longest integration step, seconds: several per cycle of the stiffest spring. */
|
|
741
|
+
const MAX_STEP = 1 / 120;
|
|
742
|
+
/** A gap this long between samples (a pause, a tab in the background) starts afresh. */
|
|
743
|
+
const MAX_GAP = .5;
|
|
744
|
+
/** Turn rates beyond this, rad/s, are a respawn or a reset rather than a maneuver. */
|
|
745
|
+
const MAX_TURN_RATE = 25;
|
|
746
|
+
/** Angular acceleration, rad/s², beyond which the head's lag is clipped. */
|
|
747
|
+
const MAX_TURN_ACCELERATION = 40;
|
|
748
|
+
/** `value` held within `-negative..positive`, easing into either end. */
|
|
749
|
+
function soften(value, negative, positive) {
|
|
750
|
+
const limit = value < 0 ? negative : positive;
|
|
751
|
+
return limit > 0 ? limit * Math.tanh(value / limit) : 0;
|
|
752
|
+
}
|
|
753
|
+
const clamp = (value, limit) => Math.max(-limit, Math.min(limit, value));
|
|
754
|
+
/** A damped spring's next `[value, rate]` after `h` seconds of pulling toward `target`. */
|
|
755
|
+
function spring(value, rate, target, frequency, damping, h) {
|
|
756
|
+
const stiffness = 2 * Math.PI * frequency;
|
|
757
|
+
const next = rate + h * (stiffness * stiffness * (target - value) - 2 * damping * stiffness * rate);
|
|
758
|
+
return [value + h * next, next];
|
|
759
|
+
}
|
|
760
|
+
/** World vector `v` as the frame with orientation `q` sees it: `v` rotated by `q`'s inverse. */
|
|
761
|
+
function intoFrame(q, v) {
|
|
762
|
+
const [x, y, z, w] = q;
|
|
763
|
+
const cx = y * v[2] - z * v[1], cy = z * v[0] - x * v[2], cz = x * v[1] - y * v[0];
|
|
764
|
+
return [
|
|
765
|
+
v[0] - 2 * (w * cx - (y * cz - z * cy)),
|
|
766
|
+
v[1] - 2 * (w * cy - (z * cx - x * cz)),
|
|
767
|
+
v[2] - 2 * (w * cz - (x * cy - y * cx))
|
|
768
|
+
];
|
|
769
|
+
}
|
|
770
|
+
/** The rotation from `a` to `b` as a rotation vector in `a`'s own frame (radians). */
|
|
771
|
+
function turnBetween(a, b) {
|
|
772
|
+
let x = a[3] * b[0] - a[0] * b[3] - a[1] * b[2] + a[2] * b[1];
|
|
773
|
+
let y = a[3] * b[1] + a[0] * b[2] - a[1] * b[3] - a[2] * b[0];
|
|
774
|
+
let z = a[3] * b[2] - a[0] * b[1] + a[1] * b[0] - a[2] * b[3];
|
|
775
|
+
let w = a[3] * b[3] + a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
|
|
776
|
+
if (w < 0) {
|
|
777
|
+
x = -x;
|
|
778
|
+
y = -y;
|
|
779
|
+
z = -z;
|
|
780
|
+
w = -w;
|
|
781
|
+
}
|
|
782
|
+
const sine = Math.hypot(x, y, z);
|
|
783
|
+
if (sine < 1e-9) return [
|
|
784
|
+
2 * x,
|
|
785
|
+
2 * y,
|
|
786
|
+
2 * z
|
|
787
|
+
];
|
|
788
|
+
const scale = 2 * Math.atan2(sine, w) / sine;
|
|
789
|
+
return [
|
|
790
|
+
x * scale,
|
|
791
|
+
y * scale,
|
|
792
|
+
z * scale
|
|
793
|
+
];
|
|
794
|
+
}
|
|
795
|
+
/**
|
|
796
|
+
* A complete tuning: `base` (the defaults when omitted) with `settings` over it. `true` and
|
|
797
|
+
* `false` only switch the effect; an object changes the fields it names.
|
|
798
|
+
*/
|
|
799
|
+
function pilotMotionTuning(settings = {}, base = DEFAULT_PILOT_MOTION) {
|
|
800
|
+
const overrides = typeof settings === "boolean" ? { enabled: settings } : settings;
|
|
801
|
+
return {
|
|
802
|
+
enabled: overrides.enabled ?? base.enabled,
|
|
803
|
+
intensity: overrides.intensity ?? base.intensity,
|
|
804
|
+
maxLoad: overrides.maxLoad ?? base.maxLoad,
|
|
805
|
+
braceTime: overrides.braceTime ?? base.braceTime,
|
|
806
|
+
heave: {
|
|
807
|
+
...base.heave,
|
|
808
|
+
...overrides.heave
|
|
809
|
+
},
|
|
810
|
+
surge: {
|
|
811
|
+
...base.surge,
|
|
812
|
+
...overrides.surge
|
|
813
|
+
},
|
|
814
|
+
sway: {
|
|
815
|
+
...base.sway,
|
|
816
|
+
...overrides.sway
|
|
817
|
+
},
|
|
818
|
+
head: {
|
|
819
|
+
...base.head,
|
|
820
|
+
...overrides.head
|
|
821
|
+
}
|
|
822
|
+
};
|
|
823
|
+
}
|
|
824
|
+
/** The body's axes in seat order: X (left), Y (up), Z (forward). */
|
|
825
|
+
const AXES = [
|
|
826
|
+
"sway",
|
|
827
|
+
"heave",
|
|
828
|
+
"surge"
|
|
829
|
+
];
|
|
830
|
+
const XYZ = [
|
|
831
|
+
0,
|
|
832
|
+
1,
|
|
833
|
+
2
|
|
834
|
+
];
|
|
835
|
+
/**
|
|
836
|
+
* The pilot's body in the seat. Feed it the vehicle's motion once a frame with {@link update}
|
|
837
|
+
* and pass the pose it returns to `aircraftCameraPose` as `motion`.
|
|
838
|
+
*
|
|
839
|
+
* What the pilot feels is the specific force in the seat frame: the vehicle's acceleration less
|
|
840
|
+
* gravity, 1 g straight up through the seat when parked or in level flight. The body is three
|
|
841
|
+
* damped springs driven by how far that is from 1 g up, and the head three more.
|
|
842
|
+
*/
|
|
843
|
+
var PilotMotion = class {
|
|
844
|
+
/** Live tuning: change a field and the next {@link update} uses it. */
|
|
845
|
+
tuning;
|
|
846
|
+
/**
|
|
847
|
+
* The load last felt, in g, in the seat frame (+X left, +Y up, +Z forward): [0, 1, 0] parked
|
|
848
|
+
* or in level flight, [0, 4, 0] in a 4 g pull. For a HUD or for tuning.
|
|
849
|
+
*/
|
|
850
|
+
load = [
|
|
851
|
+
0,
|
|
852
|
+
1,
|
|
853
|
+
0
|
|
854
|
+
];
|
|
855
|
+
current = {
|
|
856
|
+
offset: [
|
|
857
|
+
0,
|
|
858
|
+
0,
|
|
859
|
+
0
|
|
860
|
+
],
|
|
861
|
+
pitch: 0,
|
|
862
|
+
yaw: 0,
|
|
863
|
+
roll: 0
|
|
864
|
+
};
|
|
865
|
+
previous;
|
|
866
|
+
travel = [
|
|
867
|
+
0,
|
|
868
|
+
0,
|
|
869
|
+
0
|
|
870
|
+
];
|
|
871
|
+
travelRate = [
|
|
872
|
+
0,
|
|
873
|
+
0,
|
|
874
|
+
0
|
|
875
|
+
];
|
|
876
|
+
braced = [
|
|
877
|
+
0,
|
|
878
|
+
0,
|
|
879
|
+
0
|
|
880
|
+
];
|
|
881
|
+
head = [
|
|
882
|
+
0,
|
|
883
|
+
0,
|
|
884
|
+
0
|
|
885
|
+
];
|
|
886
|
+
headRate = [
|
|
887
|
+
0,
|
|
888
|
+
0,
|
|
889
|
+
0
|
|
890
|
+
];
|
|
891
|
+
constructor(settings = {}) {
|
|
892
|
+
this.tuning = pilotMotionTuning(settings);
|
|
893
|
+
}
|
|
894
|
+
/** Change some of the tuning; `true` and `false` switch the whole effect. */
|
|
895
|
+
configure(settings) {
|
|
896
|
+
this.tuning = pilotMotionTuning(settings, this.tuning);
|
|
897
|
+
}
|
|
898
|
+
/** The pose as of the last {@link update}. */
|
|
899
|
+
get pose() {
|
|
900
|
+
return this.current;
|
|
901
|
+
}
|
|
902
|
+
/** Forget the motion so far: for a new seat. The next sample starts settled in it. */
|
|
903
|
+
reset() {
|
|
904
|
+
this.previous = void 0;
|
|
905
|
+
for (const values of [
|
|
906
|
+
this.travel,
|
|
907
|
+
this.travelRate,
|
|
908
|
+
this.braced,
|
|
909
|
+
this.head,
|
|
910
|
+
this.headRate
|
|
911
|
+
]) values.fill(0);
|
|
912
|
+
this.load[0] = 0;
|
|
913
|
+
this.load[1] = 1;
|
|
914
|
+
this.load[2] = 0;
|
|
915
|
+
this.write();
|
|
916
|
+
}
|
|
917
|
+
/** Advance to `sample.time` and return where the pilot's eyes now are. */
|
|
918
|
+
update(sample) {
|
|
919
|
+
if (!this.tuning.enabled) {
|
|
920
|
+
if (this.previous !== void 0) this.reset();
|
|
921
|
+
return this.current;
|
|
922
|
+
}
|
|
923
|
+
const scale = sample.travelScale && sample.travelScale > 0 ? sample.travelScale : 1;
|
|
924
|
+
const velocity = [
|
|
925
|
+
sample.velocity[0] / scale,
|
|
926
|
+
sample.velocity[1] / scale,
|
|
927
|
+
sample.velocity[2] / scale
|
|
928
|
+
];
|
|
929
|
+
const position = [...sample.position];
|
|
930
|
+
const rotation = [...sample.rotation];
|
|
931
|
+
const upward = intoFrame(rotation, [
|
|
932
|
+
0,
|
|
933
|
+
1,
|
|
934
|
+
0
|
|
935
|
+
]);
|
|
936
|
+
const last = this.previous;
|
|
937
|
+
const dt = last === void 0 ? 0 : sample.time - last.time;
|
|
938
|
+
if (last !== void 0 && dt === 0) return this.current;
|
|
939
|
+
let turn;
|
|
940
|
+
let fresh = last === void 0 || dt < 0 || dt > MAX_GAP;
|
|
941
|
+
if (last !== void 0 && !fresh) {
|
|
942
|
+
const moved = Math.hypot(position[0] - last.position[0], position[1] - last.position[1], position[2] - last.position[2]);
|
|
943
|
+
const reach = Math.max(Math.hypot(...velocity), Math.hypot(...last.velocity)) * scale * dt;
|
|
944
|
+
turn = turnBetween(last.rotation, rotation).map((v) => v / dt);
|
|
945
|
+
if (moved > 2 * reach + 3 || Math.hypot(...turn) > MAX_TURN_RATE) fresh = true;
|
|
946
|
+
}
|
|
947
|
+
if (last === void 0 || fresh) {
|
|
948
|
+
this.reset();
|
|
949
|
+
this.previous = {
|
|
950
|
+
time: sample.time,
|
|
951
|
+
position,
|
|
952
|
+
rotation,
|
|
953
|
+
velocity,
|
|
954
|
+
turn: void 0
|
|
955
|
+
};
|
|
956
|
+
const deviation = [
|
|
957
|
+
upward[0],
|
|
958
|
+
upward[1] - 1,
|
|
959
|
+
upward[2]
|
|
960
|
+
];
|
|
961
|
+
this.load[0] = upward[0];
|
|
962
|
+
this.load[1] = upward[1];
|
|
963
|
+
this.load[2] = upward[2];
|
|
964
|
+
const targets = this.targets(deviation, deviation, upward, [
|
|
965
|
+
0,
|
|
966
|
+
0,
|
|
967
|
+
0
|
|
968
|
+
]);
|
|
969
|
+
for (const i of XYZ) {
|
|
970
|
+
this.braced[i] = deviation[i];
|
|
971
|
+
this.travel[i] = targets.travel[i];
|
|
972
|
+
this.head[i] = targets.head[i];
|
|
973
|
+
}
|
|
974
|
+
this.write();
|
|
975
|
+
return this.current;
|
|
976
|
+
}
|
|
977
|
+
const felt = intoFrame(rotation, [
|
|
978
|
+
(velocity[0] - last.velocity[0]) / dt / G,
|
|
979
|
+
(velocity[1] - last.velocity[1]) / dt / G + 1,
|
|
980
|
+
(velocity[2] - last.velocity[2]) / dt / G
|
|
981
|
+
]);
|
|
982
|
+
this.load[0] = felt[0];
|
|
983
|
+
this.load[1] = felt[1];
|
|
984
|
+
this.load[2] = felt[2];
|
|
985
|
+
const limit = Math.max(0, this.tuning.maxLoad);
|
|
986
|
+
const deviation = [
|
|
987
|
+
clamp(felt[0], limit),
|
|
988
|
+
clamp(felt[1] - 1, limit),
|
|
989
|
+
clamp(felt[2], limit)
|
|
990
|
+
];
|
|
991
|
+
const turning = turn ?? [
|
|
992
|
+
0,
|
|
993
|
+
0,
|
|
994
|
+
0
|
|
995
|
+
];
|
|
996
|
+
const before = last.turn;
|
|
997
|
+
const spin = before === void 0 ? [
|
|
998
|
+
0,
|
|
999
|
+
0,
|
|
1000
|
+
0
|
|
1001
|
+
] : [
|
|
1002
|
+
clamp((turning[0] - before[0]) / dt, MAX_TURN_ACCELERATION),
|
|
1003
|
+
clamp((turning[1] - before[1]) / dt, MAX_TURN_ACCELERATION),
|
|
1004
|
+
clamp((turning[2] - before[2]) / dt, MAX_TURN_ACCELERATION)
|
|
1005
|
+
];
|
|
1006
|
+
this.previous = {
|
|
1007
|
+
time: sample.time,
|
|
1008
|
+
position,
|
|
1009
|
+
rotation,
|
|
1010
|
+
velocity,
|
|
1011
|
+
turn: turning
|
|
1012
|
+
};
|
|
1013
|
+
const steps = Math.max(1, Math.ceil(dt / MAX_STEP));
|
|
1014
|
+
const h = dt / steps;
|
|
1015
|
+
const { head } = this.tuning;
|
|
1016
|
+
const bracing = 1 - Math.exp(-h / Math.max(.001, this.tuning.braceTime));
|
|
1017
|
+
for (let n = 0; n < steps; n++) {
|
|
1018
|
+
const targets = this.targets(deviation, this.braced, upward, spin);
|
|
1019
|
+
for (const i of XYZ) {
|
|
1020
|
+
const axis = this.tuning[AXES[i]];
|
|
1021
|
+
[this.travel[i], this.travelRate[i]] = spring(this.travel[i], this.travelRate[i], targets.travel[i], axis.frequency, axis.damping, h);
|
|
1022
|
+
[this.head[i], this.headRate[i]] = spring(this.head[i], this.headRate[i], targets.head[i], head.frequency, head.damping, h);
|
|
1023
|
+
this.braced[i] += bracing * (deviation[i] - this.braced[i]);
|
|
1024
|
+
}
|
|
1025
|
+
}
|
|
1026
|
+
this.write();
|
|
1027
|
+
return this.current;
|
|
1028
|
+
}
|
|
1029
|
+
/**
|
|
1030
|
+
* Where the springs are heading: body travel per axis and the head's rotation vector, for a
|
|
1031
|
+
* load `deviation` from 1 g up of which the pilot has `braced` against a share.
|
|
1032
|
+
*/
|
|
1033
|
+
targets(deviation, braced, upward, spin) {
|
|
1034
|
+
const { head, sway, heave, surge } = this.tuning;
|
|
1035
|
+
const held = [
|
|
1036
|
+
deviation[0] - sway.brace * braced[0],
|
|
1037
|
+
deviation[1] - heave.brace * braced[1],
|
|
1038
|
+
deviation[2] - surge.brace * braced[2]
|
|
1039
|
+
];
|
|
1040
|
+
return {
|
|
1041
|
+
travel: [
|
|
1042
|
+
-sway.travel * held[0],
|
|
1043
|
+
-heave.travel * held[1],
|
|
1044
|
+
-surge.travel * held[2]
|
|
1045
|
+
],
|
|
1046
|
+
head: [
|
|
1047
|
+
head.nod * held[1] - head.surgeNod * Math.min(0, held[2]) - head.lag * spin[0],
|
|
1048
|
+
-head.lag * spin[1],
|
|
1049
|
+
head.swayTilt * held[0] - head.horizonLean * upward[0] * Math.max(0, upward[1]) - head.lag * spin[2]
|
|
1050
|
+
]
|
|
1051
|
+
};
|
|
1052
|
+
}
|
|
1053
|
+
write() {
|
|
1054
|
+
const { intensity, head } = this.tuning;
|
|
1055
|
+
const turn = this.head.map((v) => soften(v * intensity, head.limit, head.limit));
|
|
1056
|
+
const pose = this.current;
|
|
1057
|
+
for (const i of XYZ) {
|
|
1058
|
+
const axis = this.tuning[AXES[i]];
|
|
1059
|
+
pose.offset[i] = soften(this.travel[i] * intensity, axis.limit[0], axis.limit[1]);
|
|
1060
|
+
}
|
|
1061
|
+
pose.offset[0] -= head.neck * Math.sin(turn[2]);
|
|
1062
|
+
pose.offset[2] += head.neck * Math.sin(turn[0]);
|
|
1063
|
+
pose.pitch = -turn[0];
|
|
1064
|
+
pose.yaw = turn[1];
|
|
1065
|
+
pose.roll = turn[2];
|
|
1066
|
+
}
|
|
1067
|
+
};
|
|
1068
|
+
//#endregion
|
|
1069
|
+
//#region src/rotor-blur.ts
|
|
1070
|
+
/**
|
|
1071
|
+
* Blades turn faster than a display can sample them. A C182 at 2400 rpm moves 240 degrees between
|
|
1072
|
+
* 60 Hz frames, exactly two blade spacings of its three-blade propeller, so drawn blades look
|
|
1073
|
+
* stopped at full power. An eye sees a faint disc instead, so draw one: below these speeds the
|
|
1074
|
+
* blades stay crisp, and between them the blades cross-fade into the disc. In radians per second,
|
|
1075
|
+
* about 20 and 45 degrees per frame at 60 Hz.
|
|
1076
|
+
*/
|
|
1077
|
+
const BLUR_START = 35;
|
|
1078
|
+
const BLUR_FULL = 78;
|
|
1079
|
+
const DISC_OPACITY = .09;
|
|
1080
|
+
const TIP_OPACITY = .14;
|
|
1081
|
+
/** A mesh reaching past this share of the radius is a blade; anything shorter is hub or spinner. */
|
|
1082
|
+
const HUB_SHARE = .4;
|
|
1083
|
+
const ACROSS = {
|
|
1084
|
+
x: [1, 2],
|
|
1085
|
+
y: [0, 2],
|
|
1086
|
+
z: [0, 1]
|
|
1087
|
+
};
|
|
1088
|
+
const ALONG = {
|
|
1089
|
+
x: 0,
|
|
1090
|
+
y: 1,
|
|
1091
|
+
z: 2
|
|
1092
|
+
};
|
|
1093
|
+
/**
|
|
1094
|
+
* Prepares one rotor node. It reads the blades' real extent from the model, so nothing in the spec
|
|
1095
|
+
* needs a radius or blade count. Returns undefined for a node with no geometry. The disc and the
|
|
1096
|
+
* cloned blade materials join the model, so the visual's dispose releases them.
|
|
1097
|
+
*/
|
|
1098
|
+
function createRotorBlur(node, axis) {
|
|
1099
|
+
node.updateWorldMatrix(true, true);
|
|
1100
|
+
const toNode = node.matrixWorld.clone().invert();
|
|
1101
|
+
const [u, v] = ACROSS[axis];
|
|
1102
|
+
const along = ALONG[axis];
|
|
1103
|
+
const reach = /* @__PURE__ */ new Map();
|
|
1104
|
+
const point = new THREE.Vector3();
|
|
1105
|
+
let radius = 0;
|
|
1106
|
+
let plane = 0;
|
|
1107
|
+
let vertices = 0;
|
|
1108
|
+
node.traverse((object) => {
|
|
1109
|
+
if (!(object instanceof THREE.Mesh)) return;
|
|
1110
|
+
const position = object.geometry.getAttribute("position");
|
|
1111
|
+
if (position === void 0) return;
|
|
1112
|
+
const toRotor = toNode.clone().multiply(object.matrixWorld);
|
|
1113
|
+
let furthest = 0;
|
|
1114
|
+
for (let i = 0; i < position.count; i++) {
|
|
1115
|
+
point.fromBufferAttribute(position, i).applyMatrix4(toRotor);
|
|
1116
|
+
furthest = Math.max(furthest, Math.hypot(point.getComponent(u), point.getComponent(v)));
|
|
1117
|
+
}
|
|
1118
|
+
reach.set(object, furthest);
|
|
1119
|
+
radius = Math.max(radius, furthest);
|
|
1120
|
+
});
|
|
1121
|
+
if (radius === 0) return void 0;
|
|
1122
|
+
const blades = [];
|
|
1123
|
+
const copies = /* @__PURE__ */ new Map();
|
|
1124
|
+
for (const [mesh, furthest] of reach) {
|
|
1125
|
+
if (furthest < radius * HUB_SHARE || Array.isArray(mesh.material)) continue;
|
|
1126
|
+
const original = mesh.material;
|
|
1127
|
+
let copy = copies.get(original);
|
|
1128
|
+
if (copy === void 0) {
|
|
1129
|
+
copy = original.clone();
|
|
1130
|
+
copy.transparent = true;
|
|
1131
|
+
copies.set(original, copy);
|
|
1132
|
+
blades.push(copy);
|
|
1133
|
+
}
|
|
1134
|
+
mesh.material = copy;
|
|
1135
|
+
const position = mesh.geometry.getAttribute("position");
|
|
1136
|
+
const toRotor = toNode.clone().multiply(mesh.matrixWorld);
|
|
1137
|
+
for (let i = 0; i < position.count; i++) {
|
|
1138
|
+
plane += point.fromBufferAttribute(position, i).applyMatrix4(toRotor).getComponent(along);
|
|
1139
|
+
vertices++;
|
|
1140
|
+
}
|
|
1141
|
+
}
|
|
1142
|
+
const height = vertices === 0 ? 0 : plane / vertices;
|
|
1143
|
+
const ring = (inner, outer) => {
|
|
1144
|
+
const geometry = new THREE.RingGeometry(inner, outer, 48);
|
|
1145
|
+
if (axis === "x") geometry.rotateY(Math.PI / 2);
|
|
1146
|
+
if (axis === "y") geometry.rotateX(Math.PI / 2);
|
|
1147
|
+
const disc = new THREE.Mesh(geometry, new THREE.MeshBasicMaterial({
|
|
1148
|
+
color: 3422268,
|
|
1149
|
+
transparent: true,
|
|
1150
|
+
opacity: 0,
|
|
1151
|
+
side: THREE.DoubleSide,
|
|
1152
|
+
depthWrite: false
|
|
1153
|
+
}));
|
|
1154
|
+
disc.position.setComponent(along, height);
|
|
1155
|
+
disc.visible = false;
|
|
1156
|
+
disc.castShadow = false;
|
|
1157
|
+
disc.receiveShadow = false;
|
|
1158
|
+
disc.userData.vehicleGeometry = true;
|
|
1159
|
+
node.add(disc);
|
|
1160
|
+
return disc;
|
|
1161
|
+
};
|
|
1162
|
+
const disc = ring(radius * .12, radius * .94);
|
|
1163
|
+
const tip = ring(radius * .94, radius);
|
|
1164
|
+
return { update(angularSpeed) {
|
|
1165
|
+
const t = THREE.MathUtils.clamp((Math.abs(angularSpeed) - BLUR_START) / (BLUR_FULL - BLUR_START), 0, 1);
|
|
1166
|
+
const blur = t * t * (3 - 2 * t);
|
|
1167
|
+
for (const material of blades) {
|
|
1168
|
+
material.opacity = 1 - blur;
|
|
1169
|
+
material.depthWrite = blur < .5;
|
|
1170
|
+
}
|
|
1171
|
+
for (const [mesh, opacity] of [[disc, DISC_OPACITY], [tip, TIP_OPACITY]]) {
|
|
1172
|
+
mesh.visible = blur > 0;
|
|
1173
|
+
mesh.material.opacity = opacity * blur;
|
|
1174
|
+
}
|
|
1175
|
+
for (const mesh of reach.keys()) if (blades.includes(mesh.material)) mesh.visible = blur < 1;
|
|
1176
|
+
} };
|
|
1177
|
+
}
|
|
1178
|
+
//#endregion
|
|
677
1179
|
//#region src/aircraft.ts
|
|
1180
|
+
/** The group the cockpit-controls generator adds beside a model's cockpit: levers and legends. */
|
|
1181
|
+
const FLIGHT_CONTROLS_NODE = "flight-controls";
|
|
1182
|
+
/**
|
|
1183
|
+
* Angular radius (radians) below which a cabin part is left out of the frame: under four pixels
|
|
1184
|
+
* across in a 1080p view with a 60° field of view. From a chase camera fifteen meters back,
|
|
1185
|
+
* gauges, needles and switches are each smaller than that behind the canopy, and each was a draw:
|
|
1186
|
+
* the P-51's cockpit, 415 meshes, was a quarter of a takeoff's draws in chase view.
|
|
1187
|
+
*/
|
|
1188
|
+
const CABIN_DETAIL_ANGLE = .002;
|
|
1189
|
+
/**
|
|
1190
|
+
* Sun shadow-map texel (meters) beyond which the map no longer resolves an aircraft's own canopy
|
|
1191
|
+
* frame, seat and panels. Coarser, their shadows on the aircraft fall in blocks that jump as it
|
|
1192
|
+
* slides across the map's texel grid: at 0.2 m (100 m above the ground on High) about 1% of an
|
|
1193
|
+
* F-15C's cockpit view changed from frame to frame in straight flight, at 0.8 m 10%, a cockpit
|
|
1194
|
+
* flickering in the sun. It comes back once texels are SELF_SHADOW_RETURN or finer.
|
|
1195
|
+
*/
|
|
1196
|
+
const SELF_SHADOW_TEXEL = .15;
|
|
1197
|
+
const SELF_SHADOW_RETURN = .12;
|
|
678
1198
|
/**
|
|
679
1199
|
* Takes ownership of a loaded library GLB. The named nodes remain editable in a DCC.
|
|
680
1200
|
*
|
|
@@ -690,8 +1210,9 @@ function createAircraftVisual(model, spec, livery) {
|
|
|
690
1210
|
model.traverse((o) => {
|
|
691
1211
|
o.userData.vehicleGeometry = true;
|
|
692
1212
|
if (o instanceof THREE.Mesh) {
|
|
693
|
-
o.castShadow = !o.name.includes("canopy") && !o.name.includes("bubble");
|
|
1213
|
+
o.castShadow = !o.name.includes("canopy") && !o.name.includes("bubble") && !isGlass(o);
|
|
694
1214
|
o.receiveShadow = true;
|
|
1215
|
+
drawGlassInOnePass(o);
|
|
695
1216
|
}
|
|
696
1217
|
const list = moving.get(o.name) ?? [];
|
|
697
1218
|
list.push(o);
|
|
@@ -701,21 +1222,75 @@ function createAircraftVisual(model, spec, livery) {
|
|
|
701
1222
|
for (const node of moving.get(name) ?? []) node.rotation[axis] = angle;
|
|
702
1223
|
};
|
|
703
1224
|
let appearance = livery === void 0 ? void 0 : applyLivery(model, livery);
|
|
704
|
-
const cabin =
|
|
1225
|
+
const cabin = [...spec.visual.interior?.nodes ?? [], FLIGHT_CONTROLS_NODE].flatMap((name) => moving.get(name) ?? []);
|
|
705
1226
|
for (const node of cabin) node.traverse((object) => {
|
|
706
1227
|
if (object.isMesh) object.userData.walkIgnore = true;
|
|
707
1228
|
});
|
|
708
1229
|
const cabinRange = Math.max(60, 3 * Math.max(spec.length, spec.span));
|
|
709
1230
|
const damage = createAircraftDamageVisual(model, spec);
|
|
710
1231
|
let propellers = createAircraftPropellers(model, spec);
|
|
1232
|
+
const rotorEngines = spec.engines ?? (spec.engine ? [{
|
|
1233
|
+
...spec.engine,
|
|
1234
|
+
id: "main"
|
|
1235
|
+
}] : []);
|
|
1236
|
+
const ownPropeller = (binding) => {
|
|
1237
|
+
if (spec.model !== "airplane") return false;
|
|
1238
|
+
const engine = binding.engine === void 0 ? rotorEngines[0] : rotorEngines.find((e) => e.id === binding.engine);
|
|
1239
|
+
return engine !== void 0 && engine.propulsion !== "jet";
|
|
1240
|
+
};
|
|
1241
|
+
const blurs = /* @__PURE__ */ new Map();
|
|
1242
|
+
for (const binding of spec.visual.rotors) {
|
|
1243
|
+
if (ownPropeller(binding)) continue;
|
|
1244
|
+
const prepared = (moving.get(binding.node) ?? []).flatMap((node) => createRotorBlur(node, binding.axis) ?? []);
|
|
1245
|
+
if (prepared.length > 0) blurs.set(binding, prepared);
|
|
1246
|
+
}
|
|
1247
|
+
const shaftSpeed = (id) => (id === void 0 ? void 0 : spec.engines?.find((engine) => engine.id === id)?.rotorAngularSpeed) ?? spec.engine?.rotorAngularSpeed ?? spec.engines?.[0]?.rotorAngularSpeed ?? 0;
|
|
711
1248
|
let cabinShown = true;
|
|
1249
|
+
model.updateMatrixWorld(true);
|
|
1250
|
+
const modelScale = model.matrixWorld.getMaxScaleOnAxis();
|
|
1251
|
+
const details = [];
|
|
1252
|
+
const listed = /* @__PURE__ */ new Set();
|
|
1253
|
+
for (const node of cabin) node.traverse((object) => {
|
|
1254
|
+
const mesh = object;
|
|
1255
|
+
if (!mesh.isMesh || listed.has(mesh)) return;
|
|
1256
|
+
listed.add(mesh);
|
|
1257
|
+
if (mesh.geometry.boundingSphere === null) mesh.geometry.computeBoundingSphere();
|
|
1258
|
+
const radius = (mesh.geometry.boundingSphere?.radius ?? 0) * mesh.matrixWorld.getMaxScaleOnAxis() / modelScale;
|
|
1259
|
+
details.push({
|
|
1260
|
+
mesh,
|
|
1261
|
+
reach: radius / CABIN_DETAIL_ANGLE,
|
|
1262
|
+
layers: mesh.layers.mask
|
|
1263
|
+
});
|
|
1264
|
+
});
|
|
1265
|
+
details.sort((a, b) => b.reach - a.reach);
|
|
1266
|
+
let detailed = details.length;
|
|
1267
|
+
const eye = new THREE.Vector3();
|
|
1268
|
+
let shadowsOut = false;
|
|
1269
|
+
const unshadowed = [];
|
|
1270
|
+
const castShadows = (cast) => {
|
|
1271
|
+
shadowsOut = !cast;
|
|
1272
|
+
if (cast) {
|
|
1273
|
+
for (const mesh of unshadowed) mesh.castShadow = true;
|
|
1274
|
+
unshadowed.length = 0;
|
|
1275
|
+
return;
|
|
1276
|
+
}
|
|
1277
|
+
model.traverse((object) => {
|
|
1278
|
+
const mesh = object;
|
|
1279
|
+
if (!mesh.isMesh || !mesh.castShadow) return;
|
|
1280
|
+
mesh.castShadow = false;
|
|
1281
|
+
unshadowed.push(mesh);
|
|
1282
|
+
});
|
|
1283
|
+
};
|
|
712
1284
|
return {
|
|
713
1285
|
setLivery(data) {
|
|
1286
|
+
const out = shadowsOut;
|
|
1287
|
+
if (out) castShadows(true);
|
|
714
1288
|
propellers.dispose();
|
|
715
1289
|
appearance?.dispose();
|
|
716
1290
|
damage.reset();
|
|
717
1291
|
appearance = data === void 0 ? void 0 : applyLivery(model, data);
|
|
718
1292
|
propellers = createAircraftPropellers(model, spec);
|
|
1293
|
+
if (out) castShadows(false);
|
|
719
1294
|
},
|
|
720
1295
|
object: model,
|
|
721
1296
|
cockpit,
|
|
@@ -727,6 +1302,8 @@ function createAircraftVisual(model, spec, livery) {
|
|
|
727
1302
|
for (const binding of spec.visual.rotors) {
|
|
728
1303
|
const engine = binding.engine === void 0 ? void 0 : state.engines?.[binding.engine];
|
|
729
1304
|
turn(binding.node, binding.axis, (engine?.rotorAngle ?? state.rotorAngle) * binding.multiplier);
|
|
1305
|
+
const speed = Math.min(1, engine?.rpm ?? state.rpm ?? 0) * shaftSpeed(binding.engine) * binding.multiplier;
|
|
1306
|
+
for (const blur of blurs.get(binding) ?? []) blur.update(speed);
|
|
730
1307
|
}
|
|
731
1308
|
for (const name of spec.visual.gearNodes) {
|
|
732
1309
|
if (articulatedGear.has(name)) continue;
|
|
@@ -813,16 +1390,33 @@ function createAircraftVisual(model, spec, livery) {
|
|
|
813
1390
|
});
|
|
814
1391
|
interior?.update(telemetry, timeSeconds);
|
|
815
1392
|
animation?.update(telemetry, timeSeconds);
|
|
816
|
-
propellers.update(state);
|
|
1393
|
+
propellers.update(state, !shadowsOut);
|
|
817
1394
|
damage.update(state);
|
|
818
1395
|
},
|
|
1396
|
+
updateShadows(texel) {
|
|
1397
|
+
const out = texel !== void 0 && texel > (shadowsOut ? SELF_SHADOW_RETURN : SELF_SHADOW_TEXEL);
|
|
1398
|
+
if (out !== shadowsOut) castShadows(!out);
|
|
1399
|
+
},
|
|
819
1400
|
updateView(camera) {
|
|
820
1401
|
if (cabin.length === 0) return;
|
|
821
1402
|
const p = model.position;
|
|
822
1403
|
const shown = Math.hypot(p.x - camera[0], p.y - camera[1], p.z - camera[2]) < cabinRange * (cabinShown ? 1.1 : 1);
|
|
823
|
-
if (shown
|
|
824
|
-
|
|
825
|
-
|
|
1404
|
+
if (shown !== cabinShown) {
|
|
1405
|
+
cabinShown = shown;
|
|
1406
|
+
for (const node of cabin) node.visible = shown;
|
|
1407
|
+
}
|
|
1408
|
+
if (!shown) return;
|
|
1409
|
+
eye.fromArray(spec.pilotEye).applyQuaternion(model.quaternion).add(p);
|
|
1410
|
+
const near = Math.hypot(eye.x - camera[0], eye.y - camera[1], eye.z - camera[2]);
|
|
1411
|
+
for (let next = details[detailed]; next !== void 0 && near < next.reach;) {
|
|
1412
|
+
next.mesh.layers.mask = next.layers;
|
|
1413
|
+
next = details[++detailed];
|
|
1414
|
+
}
|
|
1415
|
+
for (let last = details[detailed - 1]; last !== void 0 && near > last.reach * 1.1;) {
|
|
1416
|
+
last.layers = last.mesh.layers.mask;
|
|
1417
|
+
last.mesh.layers.mask = 0;
|
|
1418
|
+
last = details[--detailed - 1];
|
|
1419
|
+
}
|
|
826
1420
|
},
|
|
827
1421
|
dispose() {
|
|
828
1422
|
damage.reset();
|
|
@@ -845,10 +1439,23 @@ function aircraftCameraPose(transform, spec, options) {
|
|
|
845
1439
|
const q = new THREE.Quaternion().fromArray(transform.rot);
|
|
846
1440
|
const origin = new THREE.Vector3().fromArray(transform.pos);
|
|
847
1441
|
const look = new THREE.Quaternion().setFromEuler(new THREE.Euler(-(options.lookPitch ?? 0), -(options.lookYaw ?? 0), 0, "YXZ"));
|
|
848
|
-
const
|
|
849
|
-
|
|
1442
|
+
const motion = options.view === "chase" ? void 0 : options.motion;
|
|
1443
|
+
const seat = motion ? q.clone().multiply(new THREE.Quaternion().setFromEuler(new THREE.Euler(-motion.pitch, motion.yaw, motion.roll, "YXZ"))) : q;
|
|
1444
|
+
const direction = new THREE.Vector3(0, 0, 1).applyQuaternion(look).applyQuaternion(seat);
|
|
1445
|
+
const eye = new THREE.Vector3().fromArray(spec.pilotEye);
|
|
1446
|
+
if (motion) eye.add(new THREE.Vector3().fromArray(motion.offset));
|
|
1447
|
+
let position = eye.applyQuaternion(q).add(origin);
|
|
850
1448
|
let target = position.clone().add(direction);
|
|
851
|
-
let up = new THREE.Vector3(0, 1, 0).applyQuaternion(
|
|
1449
|
+
let up = new THREE.Vector3(0, 1, 0).applyQuaternion(seat);
|
|
1450
|
+
const shake = options.view === "chase" ? 0 : Math.min(1, options.shake?.amount ?? 0);
|
|
1451
|
+
if (shake > 0) {
|
|
1452
|
+
const time = options.shake?.time ?? 0;
|
|
1453
|
+
const wobble = (rate, phase) => Math.sin(time * rate + phase) + .5 * Math.sin(time * rate * 1.73 + phase * 2.1);
|
|
1454
|
+
const left = new THREE.Vector3(1, 0, 0).applyQuaternion(q);
|
|
1455
|
+
position.addScaledVector(up, .0085 * shake * wobble(64, 0)).addScaledVector(left, .0035 * shake * wobble(47, 1));
|
|
1456
|
+
target = position.clone().add(direction).addScaledVector(up, .0028 * shake * wobble(58, 2)).addScaledVector(left, .0014 * shake * wobble(49, .7));
|
|
1457
|
+
up = up.addScaledVector(left, .0042 * shake * wobble(67, 3)).normalize();
|
|
1458
|
+
}
|
|
852
1459
|
if (options.view === "chase") {
|
|
853
1460
|
target = origin.clone().add(new THREE.Vector3(0, 1.5, 0));
|
|
854
1461
|
position = target.clone().addScaledVector(direction, -spec.length * 1.5).add(new THREE.Vector3(0, 4.5, 0));
|
|
@@ -871,4 +1478,4 @@ function aircraftCameraPose(transform, spec, options) {
|
|
|
871
1478
|
};
|
|
872
1479
|
}
|
|
873
1480
|
//#endregion
|
|
874
|
-
export { AircraftPointerAxes, aircraftCameraPose, aircraftControlValue, aircraftObstacleContacts, applyAircraftControl, bindAircraftCockpitPointer, createAircraftCockpit, createAircraftVisual };
|
|
1481
|
+
export { AircraftPointerAxes, DEFAULT_PILOT_MOTION, PilotMotion, aircraftCameraPose, aircraftControlValue, aircraftObstacleContacts, applyAircraftControl, bindAircraftCockpitPointer, createAircraftCockpit, createAircraftVisual, pilotMotionSample, pilotMotionTuning };
|