@algorisys/tinyfly 0.108.0 → 0.110.0
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 +10 -5
- package/docs/character-appearance.md +5 -2
- package/docs/cricket.md +181 -0
- package/docs/editor-guide.md +1 -1
- package/docs/examples.md +1 -1
- package/docs/getting-started.md +1 -1
- package/docs/gsap-compat.md +1 -1
- package/docs/llm-guide.md +44 -0
- package/docs/maps.md +2 -2
- package/docs/teaching.md +1 -1
- package/lib/addons/characters.js +4830 -8847
- package/lib/addons/cricket-camera-tMg3Ag3F.js +4221 -0
- package/lib/addons/scene-3d.js +436 -540
- package/lib/addons/shots-DR_ViiAC.js +125 -0
- package/lib/addons/sports.js +445 -0
- package/lib/browser/tinyfly.iife.js +12 -12
- package/lib/browser/tinyfly.js +8253 -7707
- package/lib/browser/tinyfly.umd.js +12 -12
- package/lib/types/browser/index.d.ts +1 -0
- package/lib/types/characters/capabilities.d.ts +14 -0
- package/lib/types/sports/ball-flight.d.ts +22 -0
- package/lib/types/sports/cricket/cricket-action.d.ts +7 -0
- package/lib/types/sports/cricket/cricket-camera.d.ts +15 -0
- package/lib/types/sports/cricket/cricket-field.d.ts +13 -0
- package/lib/types/sports/cricket/cricket-motion.d.ts +43 -0
- package/lib/types/sports/cricket/cricket-types.d.ts +98 -0
- package/lib/types/sports/cricket/index.d.ts +5 -0
- package/lib/types/sports/index.d.ts +3 -0
- package/llms-full.txt +268 -10
- package/llms.txt +30 -29
- package/package.json +5 -1
- package/skills/tinyfly/SKILL.md +40 -0
|
@@ -46,6 +46,7 @@ export * from '../player';
|
|
|
46
46
|
export * from '../drivers';
|
|
47
47
|
export * from '../interaction';
|
|
48
48
|
export * from '../characters';
|
|
49
|
+
export * from '../sports';
|
|
49
50
|
export { tf, live, createLive, Stage, LiveTimeline, CompatTimeline, quickPlay, mapEase, CustomEase, CustomBounce, CustomWiggle, } from '../compat/gsap';
|
|
50
51
|
export { applyBloom } from '../adapters/canvas/bloom';
|
|
51
52
|
export type { BloomOptions } from '../adapters/canvas/bloom';
|
|
@@ -1,7 +1,21 @@
|
|
|
1
1
|
import { type PropertyInfo } from '../adapters/canvas/target-properties';
|
|
2
2
|
import type { SurfaceAbout } from './surface/surface';
|
|
3
3
|
import type { Cast } from './acting/custom';
|
|
4
|
+
import { CRICKET_CASTS, CRICKET_FORMATS, CRICKET_FIELDING_POSITIONS } from '../sports/cricket/cricket-types';
|
|
5
|
+
import { CRICKET_VIEWS } from '../sports/cricket/cricket-camera';
|
|
4
6
|
export interface Capabilities {
|
|
7
|
+
sports: {
|
|
8
|
+
cricket: {
|
|
9
|
+
actions: Record<string, {
|
|
10
|
+
name: string;
|
|
11
|
+
summary: string;
|
|
12
|
+
}>;
|
|
13
|
+
formats: typeof CRICKET_FORMATS;
|
|
14
|
+
casts: typeof CRICKET_CASTS;
|
|
15
|
+
fieldingPositions: typeof CRICKET_FIELDING_POSITIONS;
|
|
16
|
+
cameras: typeof CRICKET_VIEWS;
|
|
17
|
+
};
|
|
18
|
+
};
|
|
5
19
|
version?: string;
|
|
6
20
|
timing: string;
|
|
7
21
|
easings: {
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
import type { Track } from '../engine/types';
|
|
2
|
+
import type { Vec3 } from '../engine/math';
|
|
3
|
+
export interface BallFlightOptions {
|
|
4
|
+
target: string;
|
|
5
|
+
id?: string;
|
|
6
|
+
start: number;
|
|
7
|
+
end: number;
|
|
8
|
+
from: Vec3;
|
|
9
|
+
to: Vec3;
|
|
10
|
+
/** Height above the straight chord at halfway, in scene units. */
|
|
11
|
+
arc?: number;
|
|
12
|
+
/** Sideways displacement at halfway, in scene units. */
|
|
13
|
+
curve?: number;
|
|
14
|
+
/** Key spacing in ms, default 40. Contact endpoints are always included. */
|
|
15
|
+
every?: number;
|
|
16
|
+
}
|
|
17
|
+
export declare function finiteVector(value: Vec3, name: string): void;
|
|
18
|
+
export declare function sampleTimes(start: number, end: number, every?: number, contacts?: number[]): number[];
|
|
19
|
+
/** A pedagogical arc, not a physics simulation. Pure and suitable for any sport. */
|
|
20
|
+
export declare function ballFlightPoint(options: BallFlightOptions, time: number): Vec3;
|
|
21
|
+
/** Ordinary numeric tracks. Use several flights with shared endpoints for bounces/throws. */
|
|
22
|
+
export declare function ballFlightTracks(options: BallFlightOptions): Track[];
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
import { type CricketActionOptions, type CricketActionResult, type CricketClip, type CricketEvent, type CricketField, type CricketFieldOptions } from './cricket-types';
|
|
2
|
+
/** Compile an authored play on a cricketField into JSON tracks and narration events. No renderer or clock. */
|
|
3
|
+
export declare function cricketAction(field: CricketField, options?: CricketActionOptions): CricketActionResult;
|
|
4
|
+
/** An owned scene and timeline ready for browser/Worker/Node consumers. */
|
|
5
|
+
export declare function cricketClip(options?: CricketFieldOptions & CricketActionOptions): CricketClip;
|
|
6
|
+
/** Event/caption selection is time based, so seeking and reverse playback work too. */
|
|
7
|
+
export declare function cricketEventAt(events: readonly CricketEvent[], time: number): CricketEvent | undefined;
|
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
import type { Track } from '../../engine/types';
|
|
2
|
+
import { type CricketClip } from './cricket-types';
|
|
3
|
+
export type CricketView = 'pitch' | 'batter' | 'bowler' | 'keeper' | 'field' | 'overhead' | 'orbit' | 'follow-ball';
|
|
4
|
+
export declare const CRICKET_VIEWS: Readonly<Record<CricketView, string>>;
|
|
5
|
+
export declare const CRICKET_CAMERA_ANGLES: Readonly<Record<CricketView, number>>;
|
|
6
|
+
export interface CricketCameraOptions {
|
|
7
|
+
view?: CricketView;
|
|
8
|
+
/** Any azimuth, degrees; orbit adds one complete revolution to this angle. */
|
|
9
|
+
yaw?: number;
|
|
10
|
+
/** Optical magnification, 0.25–4; 1 preserves the view's default framing. */
|
|
11
|
+
zoom?: number;
|
|
12
|
+
every?: number;
|
|
13
|
+
}
|
|
14
|
+
/** Public scene camera tracks; UI controls merely select these builder inputs. */
|
|
15
|
+
export declare function cricketCameraTracks(clip: CricketClip, options?: CricketCameraOptions): Track[];
|
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
import { type CricketField, type CricketFieldOptions, type CricketPlayer, type CricketPlayerOptions } from './cricket-types';
|
|
2
|
+
export declare const CRICKET_PITCH: Readonly<{
|
|
3
|
+
length: 20.12;
|
|
4
|
+
width: 3.05;
|
|
5
|
+
poppingCrease: 1.22;
|
|
6
|
+
returnCrease: 1.32;
|
|
7
|
+
stumpHeight: 0.711;
|
|
8
|
+
wicketWidth: 0.2286;
|
|
9
|
+
}>;
|
|
10
|
+
/** An owned JSON character object, on the existing organic rig. */
|
|
11
|
+
export declare function cricketPlayer(options: CricketPlayerOptions): CricketPlayer;
|
|
12
|
+
/** Standard pitch/creases; illustrative field positions and circular boundary. All units are metres. */
|
|
13
|
+
export declare function cricketField(options?: CricketFieldOptions): CricketField;
|
|
@@ -0,0 +1,43 @@
|
|
|
1
|
+
import { type Character } from '../../characters/character';
|
|
2
|
+
import { HAND_SHAPES } from '../../characters/hands/hand-rig';
|
|
3
|
+
import type { Pose } from '../../characters/rig/body-plan';
|
|
4
|
+
import { type Quat, type Vec3 } from '../../engine/math';
|
|
5
|
+
import type { CharacterObject3D, Scene3D } from '../../scene-3d/scene-types';
|
|
6
|
+
export interface CricketActor {
|
|
7
|
+
object: CharacterObject3D;
|
|
8
|
+
who: Character;
|
|
9
|
+
}
|
|
10
|
+
export interface BatFrame {
|
|
11
|
+
grip: Vec3;
|
|
12
|
+
axis: Vec3;
|
|
13
|
+
scale: number;
|
|
14
|
+
}
|
|
15
|
+
export interface CricketSample {
|
|
16
|
+
position: Vec3;
|
|
17
|
+
pose: Pose;
|
|
18
|
+
bat?: BatFrame;
|
|
19
|
+
}
|
|
20
|
+
export declare const progress: (time: number, start: number, end: number) => number;
|
|
21
|
+
export declare const smooth: (t: number) => number;
|
|
22
|
+
export declare const add: (a: Vec3, b: Vec3) => Vec3;
|
|
23
|
+
export declare const scale: (a: Vec3, b: number) => Vec3;
|
|
24
|
+
/** The nearest equivalent body yaw, in quarter turns, without a wrap-around spin. */
|
|
25
|
+
export declare function turnNear(turn: number, reference: number): number;
|
|
26
|
+
export declare function turnToward(from: Vec3, to: Vec3, reference?: number): number;
|
|
27
|
+
/** Right-handed guard: left shoulder/front foot toward the bowler, soft knees. */
|
|
28
|
+
export declare function battingStance(): Pose;
|
|
29
|
+
export declare function cricketActor(scene: Scene3D, id: string): CricketActor;
|
|
30
|
+
export declare function restSample(actor: CricketActor): CricketSample;
|
|
31
|
+
/** Actual native wrist/elbow/leg points in world space, including grounding and body yaw. */
|
|
32
|
+
export declare function cricketJoint(actor: CricketActor, sample: CricketSample, chain: string, index: number): Vec3;
|
|
33
|
+
export declare function cricketPalm(actor: CricketActor, sample: CricketSample, side: 'left' | 'right'): Vec3;
|
|
34
|
+
/** Aim the head in the rig's own neck frame, including a bent/leaning torso. */
|
|
35
|
+
export declare function cricketLook(actor: CricketActor, sample: CricketSample, target: Vec3): CricketSample;
|
|
36
|
+
/** Solve to the rendered palm rather than snapping an unattached prop to a desired hand point. */
|
|
37
|
+
export declare function cricketReach(actor: CricketActor, sample: CricketSample, side: 'left' | 'right', target: Vec3, shape?: keyof typeof HAND_SHAPES): CricketSample;
|
|
38
|
+
export declare function gripBat(actor: CricketActor, sample: CricketSample, target: Vec3, axis: Vec3): CricketSample;
|
|
39
|
+
export declare function batSweetSpot(bat: BatFrame): Vec3;
|
|
40
|
+
/** Rotation from a mesh's +y axis to a world direction. Written as slerp keyframe data. */
|
|
41
|
+
export declare function alignCricketEquipment(direction: Vec3): Quat;
|
|
42
|
+
export declare function blendPose(a: Pose, b: Pose, t: number): Pose;
|
|
43
|
+
export declare function poseSequence(time: number, keys: Array<[number, Pose]>): Pose;
|
|
@@ -0,0 +1,98 @@
|
|
|
1
|
+
import type { TimelineDefinition } from '../../engine/types';
|
|
2
|
+
import type { Vec3 } from '../../engine/math';
|
|
3
|
+
import type { CharacterObject3D, Scene3D } from '../../scene-3d/scene-types';
|
|
4
|
+
import type { CharacterOptions } from '../../characters/character';
|
|
5
|
+
import type { SoftCartoonName } from '../../characters/soft-cartoon-cast';
|
|
6
|
+
export type CricketFormat = 'test' | 'odi' | 't20';
|
|
7
|
+
export type CricketRole = 'batter' | 'bowler' | 'keeper' | 'fielder' | 'umpire';
|
|
8
|
+
export type CricketCast = 'adults' | 'men' | 'children' | 'mixed';
|
|
9
|
+
export type CricketAction = 'bowling' | 'spin' | 'batting' | 'defend' | 'running' | 'four' | 'six' | 'catch' | 'fielding' | 'throw' | 'bowled' | 'lbw' | 'stumping' | 'run-out' | 'no-ball' | 'wide';
|
|
10
|
+
export interface CricketFormatInfo {
|
|
11
|
+
name: string;
|
|
12
|
+
inningsPerSide: number;
|
|
13
|
+
oversPerInnings: number | null;
|
|
14
|
+
ballsPerOver: number;
|
|
15
|
+
freeHitAfterNoBall: boolean;
|
|
16
|
+
summary: string;
|
|
17
|
+
}
|
|
18
|
+
/** Basic international format facts, not a full set of competition playing conditions. */
|
|
19
|
+
export declare const CRICKET_FORMATS: Readonly<Record<CricketFormat, Readonly<CricketFormatInfo>>>;
|
|
20
|
+
export declare const CRICKET_CASTS: Readonly<Record<CricketCast, string>>;
|
|
21
|
+
export declare const CRICKET_FIELDING_POSITIONS: Readonly<{
|
|
22
|
+
bowler: "Bowler";
|
|
23
|
+
keeper: "Wicketkeeper";
|
|
24
|
+
fielder: "Extra cover";
|
|
25
|
+
slip: "Slip";
|
|
26
|
+
point: "Point";
|
|
27
|
+
cover: "Cover";
|
|
28
|
+
'mid-off': "Mid-off";
|
|
29
|
+
'mid-on': "Mid-on";
|
|
30
|
+
'square-leg': "Square leg";
|
|
31
|
+
'fine-leg': "Fine leg";
|
|
32
|
+
'third-man': "Third man";
|
|
33
|
+
}>;
|
|
34
|
+
export interface CricketPlayerOptions {
|
|
35
|
+
id: string;
|
|
36
|
+
role: CricketRole;
|
|
37
|
+
preset?: SoftCartoonName;
|
|
38
|
+
format?: CricketFormat;
|
|
39
|
+
height?: number;
|
|
40
|
+
position?: Vec3;
|
|
41
|
+
color?: string;
|
|
42
|
+
/** Optional headwear; bare heads keep expressive faces clear in tutorial close-ups. */
|
|
43
|
+
headwear?: 'none' | 'cap' | 'sun-hat';
|
|
44
|
+
/** JSON appearance settings; canvas hooks and custom rig callbacks are deliberately excluded. */
|
|
45
|
+
appearance?: Pick<CharacterOptions, 'skin' | 'ink' | 'hair' | 'face' | 'body' | 'headSize' | 'shoulderWidth' | 'hipWidth' | 'armLength' | 'legLength' | 'handSize'>;
|
|
46
|
+
}
|
|
47
|
+
export interface CricketFieldOptions {
|
|
48
|
+
id?: string;
|
|
49
|
+
format?: CricketFormat;
|
|
50
|
+
cast?: CricketCast;
|
|
51
|
+
/** Circular illustrative boundary in metres, default 64; venues choose their own boundaries. */
|
|
52
|
+
boundaryRadius?: number;
|
|
53
|
+
battingColor?: string;
|
|
54
|
+
fieldingColor?: string;
|
|
55
|
+
}
|
|
56
|
+
export interface CricketField {
|
|
57
|
+
scene: Scene3D;
|
|
58
|
+
format: CricketFormat;
|
|
59
|
+
boundaryRadius: number;
|
|
60
|
+
landmarks: Record<string, Vec3>;
|
|
61
|
+
}
|
|
62
|
+
export interface CricketEvent {
|
|
63
|
+
id: string;
|
|
64
|
+
time: number;
|
|
65
|
+
kind: 'setup' | 'release' | 'bounce' | 'contact' | 'collect' | 'throw' | 'wicket' | 'boundary' | 'signal' | 'result';
|
|
66
|
+
label: string;
|
|
67
|
+
caption: string;
|
|
68
|
+
}
|
|
69
|
+
export interface CricketResult {
|
|
70
|
+
runs: number;
|
|
71
|
+
extras: number;
|
|
72
|
+
wickets: number;
|
|
73
|
+
legalBall: boolean;
|
|
74
|
+
freeHitNext: boolean;
|
|
75
|
+
dismissal?: 'caught' | 'bowled' | 'lbw' | 'stumped' | 'run-out';
|
|
76
|
+
}
|
|
77
|
+
export interface CricketActionOptions {
|
|
78
|
+
action?: CricketAction;
|
|
79
|
+
/** Complete clip length, default 6000 ms, 4000..60000. */
|
|
80
|
+
duration?: number;
|
|
81
|
+
every?: number;
|
|
82
|
+
}
|
|
83
|
+
export interface CricketActionResult {
|
|
84
|
+
action: CricketAction;
|
|
85
|
+
duration: number;
|
|
86
|
+
timeline: TimelineDefinition;
|
|
87
|
+
events: CricketEvent[];
|
|
88
|
+
/** Authored example outcome; no automatic scoring or umpiring is inferred from geometry. */
|
|
89
|
+
result: CricketResult;
|
|
90
|
+
}
|
|
91
|
+
export interface CricketClip extends CricketField, CricketActionResult {
|
|
92
|
+
}
|
|
93
|
+
export type CricketPlayer = CharacterObject3D;
|
|
94
|
+
export declare const CRICKET_ACTIONS: Readonly<Record<CricketAction, Readonly<{
|
|
95
|
+
name: string;
|
|
96
|
+
summary: string;
|
|
97
|
+
}>>>;
|
|
98
|
+
export declare function cricketChoice<T extends string>(choices: Readonly<Record<T, unknown>>, value: T, name: string): T;
|
|
@@ -0,0 +1,5 @@
|
|
|
1
|
+
export { cricketPlayer, cricketField, CRICKET_PITCH } from './cricket-field';
|
|
2
|
+
export { cricketAction, cricketClip, cricketEventAt } from './cricket-action';
|
|
3
|
+
export { cricketCameraTracks, CRICKET_VIEWS, CRICKET_CAMERA_ANGLES, type CricketView, type CricketCameraOptions } from './cricket-camera';
|
|
4
|
+
export { CRICKET_FORMATS, CRICKET_ACTIONS, CRICKET_CASTS, CRICKET_FIELDING_POSITIONS } from './cricket-types';
|
|
5
|
+
export type { CricketFormat, CricketRole, CricketCast, CricketAction, CricketFormatInfo, CricketPlayerOptions, CricketFieldOptions, CricketField, CricketEvent, CricketResult, CricketActionOptions, CricketActionResult, CricketClip, CricketPlayer } from './cricket-types';
|
package/llms-full.txt
CHANGED
|
@@ -15,6 +15,192 @@ Key facts:
|
|
|
15
15
|
|
|
16
16
|
---
|
|
17
17
|
|
|
18
|
+
<!-- docs/cricket.md -->
|
|
19
|
+
|
|
20
|
+
# Cricket stories
|
|
21
|
+
|
|
22
|
+
Build a cricket scene and a play as JSON with `@algorisys/tinyfly/sports`.
|
|
23
|
+
The same data runs in a browser, Worker or Node. Players use tinyfly's
|
|
24
|
+
existing organic adult and child rig. Try the [interactive cricket example](https://tinyfly.app/examples/live-cricket-story)
|
|
25
|
+
or its [full-page view](https://tinyfly.app/examples/live-cricket-story/full).
|
|
26
|
+
|
|
27
|
+
```ts
|
|
28
|
+
import { Timeline } from '@algorisys/tinyfly'
|
|
29
|
+
import { cricketClip, cricketCameraTracks, cricketEventAt } from '@algorisys/tinyfly/sports'
|
|
30
|
+
import { characterObjects } from '@algorisys/tinyfly/characters'
|
|
31
|
+
import { loadScene3D, drawScene3D } from '@algorisys/tinyfly/scene-3d'
|
|
32
|
+
|
|
33
|
+
const clip = cricketClip({ format: 't20', action: 'stumping', cast: 'mixed' })
|
|
34
|
+
const tracks = [...clip.timeline.tracks, ...cricketCameraTracks(clip, { view: 'keeper' })]
|
|
35
|
+
const timeline = new Timeline({ ...clip.timeline, tracks })
|
|
36
|
+
const scene = loadScene3D(clip.scene, { kinds: [characterObjects] })
|
|
37
|
+
// Your explicit clock supplies time in milliseconds.
|
|
38
|
+
function draw(ctx, time) {
|
|
39
|
+
drawScene3D(ctx, scene, timeline.getStateAtTime(time).values,
|
|
40
|
+
{ width: 1280, height: 720, time })
|
|
41
|
+
const caption = cricketEventAt(clip.events, time)?.caption
|
|
42
|
+
return caption
|
|
43
|
+
}
|
|
44
|
+
const json = JSON.stringify({ ...clip, timeline: { ...clip.timeline, tracks } })
|
|
45
|
+
```
|
|
46
|
+
|
|
47
|
+
With script tags, load `tinyfly.iife.js` and the scene-3d add-on. Sports builders
|
|
48
|
+
and characters are available on `tinyfly`; scene rendering uses the add-on.
|
|
49
|
+
See [getting started](getting-started.md) for the versioned CDN URLs.
|
|
50
|
+
|
|
51
|
+
## Builders
|
|
52
|
+
|
|
53
|
+
| API | Result |
|
|
54
|
+
| --- | --- |
|
|
55
|
+
| `cricketPlayer({ id, role, preset?, format?, height?, position?, color?, headwear?, appearance? })` | An owned JSON `character` scene object. Roles: batter, bowler, keeper, fielder, umpire. Presets include youngMan, youngWoman, childBoy, childGirl. |
|
|
56
|
+
| `cricketField({ id?, format?, cast?, boundaryRadius?, battingColor?, fieldingColor? })` | `scene`, `format`, `boundaryRadius`, `landmarks`; stock fielders have human-readable JSON `name` labels. A 20.12 × 3.05 metre pitch, standard creases, wickets/bails, two bats, ball, boundary, eleven fielding players, two batters and two umpires. |
|
|
57
|
+
| `cricketAction(field, { action?, duration?, every? })` | A JSON timeline, timed events/captions and declared example result. Does not modify the field. |
|
|
58
|
+
| `cricketClip(options)` | Combines field and action; default T20, adult cast, pace bowling, 6000 ms. |
|
|
59
|
+
| `cricketCameraTracks(clip, { view?, yaw?, every? })` | Ordinary scene camera tracks. Merge these with the action tracks. |
|
|
60
|
+
| `cricketEventAt(events, time)` | Most recent event at that time, including when seeking backward. |
|
|
61
|
+
| `ballFlightPoint(options, time)`, `ballFlightTracks(options)` | Shared sampled arcs for other sports too. `from`, `to`, `arc`, `curve`, `start`, `end`, `target`; exact endpoints. |
|
|
62
|
+
|
|
63
|
+
Units are metres, milliseconds and degrees. `cast` is `adults`, `men`, `children` or
|
|
64
|
+
`mixed`; `CRICKET_CASTS` exports their labels. `men` uses the existing youngMan
|
|
65
|
+
organic preset for every role; adults/children/mixed retain their varied casts; `format` is `test`, `odi` or `t20`. `boundaryRadius` defaults to 64 m
|
|
66
|
+
and accepts 24–250 m. A boundary is venue dependent. Sampling defaults to 40 ms,
|
|
67
|
+
accepts 16–1000 ms and always includes play contact events. Durations accept
|
|
68
|
+
4000–60000 ms; changing duration scales the whole play. Player height accepts
|
|
69
|
+
0.5–3 m. Bare heads are the default; optional `headwear` is `none`, `cap` or
|
|
70
|
+
`sun-hat`. Appearance is JSON data, without canvas hooks or rig callbacks.
|
|
71
|
+
|
|
72
|
+
The standard action builder expects the named actors/equipment from
|
|
73
|
+
`cricketField`; required actors must be unparented with no object rotation or
|
|
74
|
+
scale. It owns poses and paths for that layout. Customize appearance and
|
|
75
|
+
uniforms before compiling; author your own scene tracks for a different layout.
|
|
76
|
+
|
|
77
|
+
Fielders watch the bowler during the run-up, smoothly pick up the moving ball
|
|
78
|
+
after release, track its flight and bounce, then follow it after contact or a miss. Head turns
|
|
79
|
+
use the rig's neck frame, including torso lean, and are independent of the
|
|
80
|
+
camera. Stationary fielders turn their bodies toward the play; running players
|
|
81
|
+
face their travel and collectors keep their catch/throw poses. The striker uses
|
|
82
|
+
a side-on right-handed guard: left shoulder and front foot toward the bowler,
|
|
83
|
+
soft knees, both feet supported, left hand above the right on the handle and a
|
|
84
|
+
bat resting near the back foot. These authored poses also fit the child rig.
|
|
85
|
+
|
|
86
|
+
The live example keeps cast/action/camera selection and playback/scrubbing in a
|
|
87
|
+
panel beside the scene, or above it on narrow screens. Select **Men** in Cast for
|
|
88
|
+
the male team; individual players remain editable through `cricketPlayer`.
|
|
89
|
+
|
|
90
|
+
## Teams and stock field positions
|
|
91
|
+
|
|
92
|
+
Each team has eleven players. `cricketField` shows all eleven of the fielding
|
|
93
|
+
XI, two on-field batters (striker and non-striker) and two umpires. The other
|
|
94
|
+
nine members of the batting XI wait off-field.
|
|
95
|
+
|
|
96
|
+
`CRICKET_FIELDING_POSITIONS` exports the stock actor IDs and labels as plain
|
|
97
|
+
JSON data. Each corresponding scene object also carries the label in `name`:
|
|
98
|
+
Bowler, Wicketkeeper, Extra cover (`fielder`, the collecting actor), Slip,
|
|
99
|
+
Point, Cover, Mid-off, Mid-on, Square leg, Fine leg and Third man. IDs used by
|
|
100
|
+
action tracks remain stable. These are illustrative placements, not a roster
|
|
101
|
+
or automatic field-setting system.
|
|
102
|
+
|
|
103
|
+
For this right-handed striker, the off side is in front of the chest (+x),
|
|
104
|
+
and the on or leg side is behind the back (−x). Mid-on stands on the leg side
|
|
105
|
+
closer to the pitch toward the bowler; long-on is its deeper boundary
|
|
106
|
+
alternative. Long-on is not an additional stock fielder. Choose a different
|
|
107
|
+
layout by authoring your own scene and tracks.
|
|
108
|
+
|
|
109
|
+
Wicketkeeper and slip stand behind the striker. Their attention follows the
|
|
110
|
+
actual delivery through its flight and bounce rather than turning to the batter
|
|
111
|
+
before the ball arrives. Their native head poses aim at world targets,
|
|
112
|
+
independently of their body yaw and camera selection. The live example's
|
|
113
|
+
**Teams and field positions** disclosure uses the scene's JSON labels.
|
|
114
|
+
|
|
115
|
+
## Review zoom
|
|
116
|
+
|
|
117
|
+
Pass `zoom` to `cricketCameraTracks(clip, { view: 'batter', zoom: 2 })` for
|
|
118
|
+
2× magnification. All eight views support 0.25–4 (default 1), including orbit
|
|
119
|
+
and ball follow. Zoom changes the field of view while preserving camera position,
|
|
120
|
+
look target, clipping distances, player motion and current story time. Invalid
|
|
121
|
+
or non-finite zoom values throw. The generated camera tracks are ordinary JSON.
|
|
122
|
+
|
|
123
|
+
The example provides a 25%–400% slider, zoom-in/out buttons and **Reset**.
|
|
124
|
+
Zoom persists while choosing another play, cast or view, and downloaded story
|
|
125
|
+
JSON includes the selected magnification. Native range controls support keyboard
|
|
126
|
+
and touch review; zooming does not seek, pause or restart playback.
|
|
127
|
+
|
|
128
|
+
## Plays and cameras
|
|
129
|
+
|
|
130
|
+
`CRICKET_ACTIONS` contains sixteen plays:
|
|
131
|
+
|
|
132
|
+
- `bowling`, `spin`: run-up, delivery, bounce and keeper collection.
|
|
133
|
+
- `batting`, `defend`: drive or block with two hands gripping the bat.
|
|
134
|
+
- `running`: batters change ends for one illustrated run.
|
|
135
|
+
- `four`, `six`: grounded boundary or boundary crossed in the air, with signals.
|
|
136
|
+
- `catch`, `fielding`, `throw`: aerial catch, ground collection or return throw.
|
|
137
|
+
- `bowled`, `lbw`, `stumping`, `run-out`: distinct authored dismissal examples.
|
|
138
|
+
- `no-ball`, `wide`: extra, umpire signal and an uncounted delivery.
|
|
139
|
+
|
|
140
|
+
The ball releases from a rendered palm, meets the blade at contact, and follows
|
|
141
|
+
the collecting hand. Bails move after the relevant wicket break. Bats scale
|
|
142
|
+
with child proportions. Events carry `id`, `time`, `kind`, `label`, `caption`;
|
|
143
|
+
the timeline also contains matching markers and English captions.
|
|
144
|
+
Drive and ground-fielding plays use distinct collection positions, with the
|
|
145
|
+
ball and fielder keyed to the same palm contact.
|
|
146
|
+
Defensive blocks retain their downward two-hand bat pose and emit the `contact`
|
|
147
|
+
event with the “Bat contact” label. Pace, spin, no-ball and stumping deliveries
|
|
148
|
+
pass outside the off stump on the side away from the batter, allowing for the
|
|
149
|
+
displayed ball and stump radii before collection. Their positive-x clearance
|
|
150
|
+
path also avoids both native legs throughout the delivery, including the
|
|
151
|
+
striker’s movement during stumping. Bowled keeps its intentional
|
|
152
|
+
wicket collision; stumping keeps the later hand-held wicket break.
|
|
153
|
+
|
|
154
|
+
`CRICKET_VIEWS` offers `pitch`, `batter`, `bowler`, `keeper`, `field`, `overhead`,
|
|
155
|
+
`orbit` and `follow-ball`. `yaw` chooses any azimuth; `orbit` adds a complete
|
|
156
|
+
360° revolution over the play. `CRICKET_CAMERA_ANGLES` provides suggested
|
|
157
|
+
starting angles. Equivalent azimuths such as 0° and 360° use identical geometry.
|
|
158
|
+
The field camera's clipping range scales with the boundary radius so wide views
|
|
159
|
+
include the full supported ground. Following the ball samples only its three
|
|
160
|
+
position channels with forward keyframe cursors, using the requested camera
|
|
161
|
+
spacing without evaluating actor tracks.
|
|
162
|
+
|
|
163
|
+
Development full-page previews load the local browser API and scene add-ons;
|
|
164
|
+
production previews and copied HTML retain the versioned CDN bundles.
|
|
165
|
+
|
|
166
|
+
## Teaching scope
|
|
167
|
+
|
|
168
|
+
These are authored visual demonstrations. Arcs, the enlarged ball, timings,
|
|
169
|
+
field placements and results are illustrative. The API does not infer a
|
|
170
|
+
cricket decision from collisions, enforce every law, simulate ball physics,
|
|
171
|
+
manage an innings or supply lesson navigation/quizzes. `result` declares
|
|
172
|
+
`runs`, `extras`, `wickets`, `legalBall`, `freeHitNext` and optional `dismissal`.
|
|
173
|
+
Use it with your own tutorial, narration, scoring or lesson system.
|
|
174
|
+
|
|
175
|
+
`CRICKET_FORMATS` records basic Test, ODI and T20 differences. Test has two
|
|
176
|
+
innings per side and no innings over limit; ODI/T20 have one innings per side
|
|
177
|
+
and maximum 50/20 overs respectively. See the [ICC format overview](https://www.icc-cricket.com/about/cricket/game-formats/the-three-formats).
|
|
178
|
+
No-balls and wides each add one extra and do not count as legal over balls.
|
|
179
|
+
The stumping example uses a legal delivery and a batter outside their ground,
|
|
180
|
+
without an attempted run. The LBW caption explicitly leaves a full decision's
|
|
181
|
+
pitching, impact and bat-contact checks to the author. Consult the
|
|
182
|
+
[MCC Laws, 2026 edition](https://www.lords.org/getmedia/a4ef9f77-2a25-4f5b-a286-4601f08e6334/Laws-of-Cricket-2017-Code-4th-Edition-(2026)_5.pdf).
|
|
183
|
+
ODI/T20 no-balls lead to a free hit on the next legitimate delivery; Test
|
|
184
|
+
does not add this automatically. Competition rules and effective dates matter:
|
|
185
|
+
see [ICC playing conditions](https://www.icc-cricket.com/about/cricket/rules-and-regulations/playing-conditions)
|
|
186
|
+
and the [October 2026 changes](https://www.icc-cricket.com/news/key-changes-across-formats-with-new-icc-playing-conditions).
|
|
187
|
+
|
|
188
|
+
## Headless video
|
|
189
|
+
|
|
190
|
+
After `npm run build:libs`:
|
|
191
|
+
|
|
192
|
+
```sh
|
|
193
|
+
node bin/tinyfly.mjs video examples/headless-video/cricket-story.mjs --stills /tmp/cricket-story
|
|
194
|
+
node bin/tinyfly.mjs video examples/headless-video/cricket-story.mjs -o /tmp/cricket-story.mp4
|
|
195
|
+
```
|
|
196
|
+
|
|
197
|
+
The example consumes the same public clip, camera and scene APIs. JSON download
|
|
198
|
+
in the interactive example includes the selected camera tracks, ready to sample
|
|
199
|
+
again after parsing. Other sports can reuse `ballFlightTracks`, character rigs
|
|
200
|
+
and scene cameras; cricket-specific motion remains in the sports add-on.
|
|
201
|
+
|
|
202
|
+
---
|
|
203
|
+
|
|
18
204
|
<!-- docs/getting-started.md -->
|
|
19
205
|
|
|
20
206
|
# Getting Started with tinyfly
|
|
@@ -204,7 +390,7 @@ with a GSAP-style call (durations are in seconds here):
|
|
|
204
390
|
```html
|
|
205
391
|
<div class="box" style="width:60px;height:60px;background:#4a9eff"></div>
|
|
206
392
|
|
|
207
|
-
<script src="https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.
|
|
393
|
+
<script src="https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.110.0/cdn/tinyfly.iife.js"></script>
|
|
208
394
|
<script>
|
|
209
395
|
tinyfly.to('.box', { x: 200, duration: 1 })
|
|
210
396
|
</script>
|
|
@@ -412,7 +598,7 @@ Without a build step, the all-in-one bundle exposes the same functions on a
|
|
|
412
598
|
global — `tinyfly.to()`, `tinyfly.timeline()` and so on:
|
|
413
599
|
|
|
414
600
|
```html
|
|
415
|
-
<script src="https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.
|
|
601
|
+
<script src="https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.110.0/cdn/tinyfly.iife.js"></script>
|
|
416
602
|
<script>
|
|
417
603
|
tinyfly.to('.box', { x: 200, duration: 1 })
|
|
418
604
|
</script>
|
|
@@ -2327,7 +2513,7 @@ For simple website embedding without a build system.
|
|
|
2327
2513
|
</html>
|
|
2328
2514
|
```
|
|
2329
2515
|
|
|
2330
|
-
Build the player with `npm run build:player` to generate `lib/player/tinyfly-player.iife.js`, or load it from the CDN: `https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.
|
|
2516
|
+
Build the player with `npm run build:player` to generate `lib/player/tinyfly-player.iife.js`, or load it from the CDN: `https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.110.0/cdn/tinyfly-player.iife.js`.
|
|
2331
2517
|
|
|
2332
2518
|
---
|
|
2333
2519
|
|
|
@@ -6680,7 +6866,7 @@ The dialog shows the generated HTML/JavaScript code with a **Copy Code** button.
|
|
|
6680
6866
|
**Steps to embed:**
|
|
6681
6867
|
1. Build the player: `npm run build:player`
|
|
6682
6868
|
2. Copy `lib/player/tinyfly-player.iife.js` to your project (or load
|
|
6683
|
-
`https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.
|
|
6869
|
+
`https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.110.0/cdn/tinyfly-player.iife.js`
|
|
6684
6870
|
instead; see [Deployment](DEPLOYMENT.md))
|
|
6685
6871
|
3. Copy the generated code into your HTML
|
|
6686
6872
|
4. Adjust the script `src` path if needed
|
|
@@ -7921,6 +8107,47 @@ bakes. See `docs/dance.md`.
|
|
|
7921
8107
|
|
|
7922
8108
|
## Characters with a look
|
|
7923
8109
|
|
|
8110
|
+
For cricket tutorials, import `cricketClip`, `cricketCameraTracks` and
|
|
8111
|
+
`cricketEventAt` from `@algorisys/tinyfly/sports`. The clip is an owned scene,
|
|
8112
|
+
JSON timeline, timed captions and declared result. Choose `test | odi | t20`,
|
|
8113
|
+
`adults | men | children | mixed`, and a play from `CRICKET_ACTIONS`. Merge camera
|
|
8114
|
+
tracks with action tracks; render with scene-3d plus `[characterObjects]`.
|
|
8115
|
+
The UI is a consumer of these APIs. `orbit` covers the full ground in 360°;
|
|
8116
|
+
`follow-ball` keys against the same ball tracks. Contacts are sampled exactly,
|
|
8117
|
+
including two-hand bat grip, release, catch and wicket break. These are authored
|
|
8118
|
+
demonstrations, not collision-based umpiring or an innings simulator. Do not
|
|
8119
|
+
infer new outcomes from the illustrative arcs. See `docs/cricket.md` and
|
|
8120
|
+
`examples/headless-video/cricket-story.mjs`; `/examples/live-cricket-story`
|
|
8121
|
+
has event seeking and downloadable scene/action/camera JSON.
|
|
8122
|
+
`CRICKET_FIELDING_POSITIONS` maps the eleven stock fielding IDs to public labels;
|
|
8123
|
+
scene objects carry them in `name`. `fielder` is Extra cover. Keep eleven fielders,
|
|
8124
|
+
two on-field batters and two umpires; nine batting teammates wait off-field.
|
|
8125
|
+
Mid-on is closer to the pitch; long-on is its deeper boundary alternative, not
|
|
8126
|
+
an extra stock player. For the right-handed striker, +x is off side and −x is
|
|
8127
|
+
on/leg side. Keeper/slip stand behind the striker; track the actual incoming delivery,
|
|
8128
|
+
never force their heads toward a screen direction or the camera.
|
|
8129
|
+
`cricketCameraTracks(clip, { view, zoom })` supports optical zoom 0.25–4
|
|
8130
|
+
(default 1) for every view, preserving the camera path and story state. Merge
|
|
8131
|
+
the returned field-of-view track into exported JSON; do not CSS-scale the canvas.
|
|
8132
|
+
In camera-sorted character rendering, rear hair and hats belong to the head
|
|
8133
|
+
pass; attaching them to the final body part lets the skin paint over them.
|
|
8134
|
+
`CRICKET_CASTS` supplies cast labels; `men` uses the existing youngMan organic
|
|
8135
|
+
preset for every role. Standard actions include camera-independent fielding
|
|
8136
|
+
attention: bowler during run-up, moving delivery after release and through the
|
|
8137
|
+
bounce, then the ball after contact/miss. Do not switch to the batter early.
|
|
8138
|
+
The right-handed guard is side-on with the left hand above the right; preserve
|
|
8139
|
+
these world-facing poses instead of rotating players toward the camera.
|
|
8140
|
+
Keeper-bound misses pass on positive x, clear of the native legs and stumps
|
|
8141
|
+
through every ball segment, including sparse keys and scaled durations. Keep
|
|
8142
|
+
keeper palm contacts and intentional LBW pad contact.
|
|
8143
|
+
Wide cameras support the full 24–250 m boundary range; equivalent yaw angles
|
|
8144
|
+
use identical geometry. Ball-follow cameras sample only ball position channels.
|
|
8145
|
+
Render the headless example with `tinyfly video <scene.mjs> -o <output.mp4>`.
|
|
8146
|
+
Preserve the defensive block's two-hand blade contact and `contact` event.
|
|
8147
|
+
Keeper-bound pace/spin/no-ball/stumping paths clear the off stump with the
|
|
8148
|
+
displayed ball radius included, before palm collection. Keep bowled contact
|
|
8149
|
+
and the later stumping wicket break intentional when editing these paths.
|
|
8150
|
+
|
|
7924
8151
|
For original soft cartoon story characters, opt into `figure: 'organic'`.
|
|
7925
8152
|
Its default `face.projection: 'volume'` moves eyes/mouth around the head and
|
|
7926
8153
|
lets hair occlude them, with a flatter profile facial plane and a nose above
|
|
@@ -8162,6 +8389,9 @@ new-tab player using the same standalone HTML as Copy code. Live demos,
|
|
|
8162
8389
|
timeline examples and editable sample scenes play with their own controls
|
|
8163
8390
|
and scrolling, without the gallery panels. Use these URLs when sharing an
|
|
8164
8391
|
example for visual review.
|
|
8392
|
+
Development live previews load the local browser API and required add-ons, so
|
|
8393
|
+
unpublished APIs work before release. Production previews and copied pages
|
|
8394
|
+
keep the versioned CDN URLs.
|
|
8165
8395
|
|
|
8166
8396
|
---
|
|
8167
8397
|
|
|
@@ -8194,7 +8424,7 @@ path for all of that:
|
|
|
8194
8424
|
</figure>
|
|
8195
8425
|
|
|
8196
8426
|
<!-- once, anywhere on the page (a site-wide footer is fine) -->
|
|
8197
|
-
<script src="https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.
|
|
8427
|
+
<script src="https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.110.0/cdn/tinyfly-embed.iife.js" data-tinyfly-auto></script>
|
|
8198
8428
|
```
|
|
8199
8429
|
|
|
8200
8430
|
Every `[data-tinyfly-embed]` mounts when the page is ready, with no per-post
|
|
@@ -9466,8 +9696,8 @@ On a page with no build step, load the maps add-on after the browser bundle; it
|
|
|
9466
9696
|
adds to the same `tinyfly` global:
|
|
9467
9697
|
|
|
9468
9698
|
```html
|
|
9469
|
-
<script src="https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.
|
|
9470
|
-
<script src="https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.
|
|
9699
|
+
<script src="https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.110.0/cdn/tinyfly.iife.js"></script>
|
|
9700
|
+
<script src="https://cdn.jsdelivr.net/gh/algorisys-oss/tinyfly@v0.110.0/cdn/tinyfly-maps.iife.js"></script>
|
|
9471
9701
|
```
|
|
9472
9702
|
|
|
9473
9703
|
It is a separate script because the offline world map it carries adds about
|
|
@@ -9861,8 +10091,11 @@ off the head, how far it hangs), drawn wherever the head's `turn`, `head.turn`,
|
|
|
9861
10091
|
shoulders seen from the front, and a bob shows beside the face;
|
|
9862
10092
|
- the part facing the viewer is drawn over the head, so a fringe crosses the
|
|
9863
10093
|
forehead and, from behind, the hair covers the whole head;
|
|
9864
|
-
- turned away (past about `turn` 1.2),
|
|
9865
|
-
over an arm at the side;
|
|
10094
|
+
- in a whole-figure 2D draw, turned away (past about `turn` 1.2), hair is
|
|
10095
|
+
drawn after the body, over an arm at the side;
|
|
10096
|
+
- in a camera-sorted 3D scene, rear hair and hats draw with the head's own
|
|
10097
|
+
part, after its skin. They remain attached through independent head turns
|
|
10098
|
+
and nods, without another body's draw order exposing the scalp;
|
|
9866
10099
|
- a parting, a side ponytail or a braid stays on the character's own side
|
|
9867
10100
|
through a turn: left and right are the character's, never mirrored.
|
|
9868
10101
|
|
|
@@ -14642,7 +14875,7 @@ magnet.addEventListener('pointerleave', () => {
|
|
|
14642
14875
|
|
|
14643
14876
|
<!-- capabilities: generated from the library -->
|
|
14644
14877
|
|
|
14645
|
-
# tinyfly capabilities (v0.
|
|
14878
|
+
# tinyfly capabilities (v0.110.0)
|
|
14646
14879
|
|
|
14647
14880
|
Generated from the library itself: every name below is accepted, and names not listed are rejected (beat scripts, code panels and `checkTracks` say which name was probably meant).
|
|
14648
14881
|
|
|
@@ -15057,6 +15290,31 @@ Edits:
|
|
|
15057
15290
|
- `move`: a part; { at, to: an anchor name or { x, y }, duration? }: carry the part there, loose
|
|
15058
15291
|
- `fling`: a part; { at, velocity?, spin?, gravity?, duration? }: knock the part off on a spinning arc
|
|
15059
15292
|
|
|
15293
|
+
## Cricket stories (`@algorisys/tinyfly/sports`)
|
|
15294
|
+
|
|
15295
|
+
`cricketClip({ format, action, cast })` returns an organic-player scene, JSON tracks, timed events/captions and a declared result. `cricketField`, `cricketPlayer` and `cricketAction` compose separately; `cricketCameraTracks` adds camera tracks. These are authored tutorial plays, not physics or automatic umpiring. See docs/cricket.md.
|
|
15296
|
+
|
|
15297
|
+
- `bowling`: Run up, deliver with a straight arm, bounce and follow through.
|
|
15298
|
+
- `spin`: A shorter approach and a curved illustrative flight before the bounce.
|
|
15299
|
+
- `batting`: Two hands on the bat, a backlift, contact and a follow-through.
|
|
15300
|
+
- `defend`: Meet the ball with a controlled bat and keep it close.
|
|
15301
|
+
- `running`: Both batters make the opposite ground to complete one run.
|
|
15302
|
+
- `four`: A struck ball reaches the boundary after touching the ground.
|
|
15303
|
+
- `six`: A struck ball clears the boundary before touching the ground.
|
|
15304
|
+
- `catch`: A fielder controls the struck ball before it touches the ground.
|
|
15305
|
+
- `fielding`: A fielder moves to the ball, bends and gathers it.
|
|
15306
|
+
- `throw`: Gather, wind up, release and return the ball to the keeper.
|
|
15307
|
+
- `bowled`: A legal delivery hits the wicket and removes a bail.
|
|
15308
|
+
- `lbw`: Pad contact and a projected path to the stumps illustrate an authored LBW decision.
|
|
15309
|
+
- `stumping`: The keeper holds the ball and breaks the wicket while the striker is out of ground, not attempting a run.
|
|
15310
|
+
- `run-out`: A direct throw breaks the wicket before the running batter makes that ground.
|
|
15311
|
+
- `no-ball`: The landing front foot oversteps the popping crease at release; one extra, no legal ball.
|
|
15312
|
+
- `wide`: An untouched delivery passes beyond reach for a normal stroke; one extra, no legal ball.
|
|
15313
|
+
|
|
15314
|
+
Formats: `test`, `odi`, `t20`. Casts: `adults`, `men`, `children`, `mixed`. Cameras: `pitch`, `batter`, `bowler`, `keeper`, `field`, `overhead`, `orbit`, `follow-ball`. Orbit turns 360° around the whole ground. `cricketCameraTracks(clip, { view, zoom })` supports 0.25–4× optical magnification (default 1) in every view.
|
|
15315
|
+
|
|
15316
|
+
Stock fielding labels (`CRICKET_FIELDING_POSITIONS`): `bowler`: Bowler, `keeper`: Wicketkeeper, `fielder`: Extra cover, `slip`: Slip, `point`: Point, `cover`: Cover, `mid-off`: Mid-off, `mid-on`: Mid-on, `square-leg`: Square leg, `fine-leg`: Fine leg, `third-man`: Third man. Eleven fielders, two on-field batters and two umpires; nine batting teammates wait off-field. Mid-on is closer to the pitch; long-on is its deeper boundary alternative, not an extra stock fielder. For the right-handed striker, +x is off side and -x is on/leg side.
|
|
15317
|
+
|
|
15060
15318
|
## Camera shots (`cameraTracks(shots, { stage })`)
|
|
15061
15319
|
|
|
15062
15320
|
- **frame**: `{ at, duration?, easing?, frame: { focus?: { x, y }, scale?, rotate? } }: push in, pull out, or cut (duration 0)`
|