Preview the shared practice figure live on Kryon
design/figure-preview is a small native project that pins Kryon 199b51c9 and practices b38054fc. It plays Breeze's own Tai Chi, Sun Salutation, Workout and astral choreography on the practices figure, with practice and item pickers, play, pause, scrub, speed, orbit and zoom, the watercolor finish and its settings. It can also show the current flat figure for the same moment. Breeze's pose folders are module paths, so no pose code is copied. --capture writes the review frames, painted, bare and current. prepare-practice-human.py now applies MakeHuman's CC0 young-adult female macro targets. It smooths the hip and shoulder weights, keeps thigh weights below the hip crease, cuts a curved hairline, and adds the hair shell, bun, eyeballs, brows and lips.
This commit is contained in:
1 parent
685dd672e9
commit
48373814bc
13 files changed
+1616
-55
No files matched your search
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -6,5 +6,12 @@
|
||||
"licence_evidence": "https://github.com/makehumancommunity/makehuman/blob/a8bc2d54ff0ac92e78ff71431b1023eda42bf482/LICENSE.md",
|
||||
"weights": "makehuman/data/rigs/default_weights.mhw",
|
||||
"weights_sha256": "0f3641d651ae3d00ad6b4ccee43142edb109d3bd909d27d9e4139ef1beed8625",
|
||||
"weights_licence": "CC0-1.0 (declared in the file header)"
|
||||
"weights_licence": "CC0-1.0 (declared in the file header)",
|
||||
"shape": "young adult female: makehuman/data/targets/macrodetails/{african,asian,caucasian}-female-young.target, one third each",
|
||||
"shape_files": {
|
||||
"makehuman-african-female-young.target.gz": "92d61eeb3c164b421fd5a7c3537ee45e7e1a51de4d49bf312e19c3df2be1d8fc",
|
||||
"makehuman-asian-female-young.target.gz": "095fe79694fa19e1fe98d93009ec116199bd524e081c640351a10eccf2cca1eb",
|
||||
"makehuman-caucasian-female-young.target.gz": "118379f6e8ba9266247fdb8788a20e1df40a239f97ced0b9905bcbcc74f6e820"
|
||||
},
|
||||
"shape_licence": "CC0-1.0 (declared in each target file header)"
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
# Figure preview
|
||||
|
||||
A native window for judging and tuning the shared practice figure. It plays
|
||||
each practice's own choreography on the character from the practices
|
||||
package (`figure/`): Tai Chi forms, two rounds of Sun Salutation, the
|
||||
Workout's twelve exercises and the six astral techniques. It runs on Ziran
|
||||
and Kryon's SDL/Cairo desktop host, without raylib.
|
||||
|
||||
The panel picks the practice and item, plays, pauses, scrubs and slows the
|
||||
clock. It switches the watercolor finish off to show the bare surface, and
|
||||
can show Breeze's current flat figure for the same moment. It also tunes
|
||||
edge pooling, pencil contour and paper grain. Drag over her to turn around
|
||||
her; scroll to zoom.
|
||||
|
||||
This is its own small project so it can pin the Kryon that has
|
||||
`scene_skin` and `watercolor`, and the practices commit that has the figure,
|
||||
while Breeze's app still pins older ones. The poses are Breeze's own: the
|
||||
build adds Breeze's Tai Chi, Sun Salutation and practice folders as module
|
||||
folders, so nothing is copied.
|
||||
|
||||
## Build and run
|
||||
|
||||
From this folder, through the build queue:
|
||||
|
||||
```sh
|
||||
build-queue -- ziran build --project --target=c --exe \
|
||||
--module-path ../../src/practices/tai_chi \
|
||||
--module-path ../../src/practices/sun_salutation \
|
||||
--module-path ../../apps/practice \
|
||||
--entry figure_preview:main -o build/app figure_preview.zi
|
||||
./build/app/figure_preview
|
||||
```
|
||||
|
||||
The preview asks `ziran pkg path practices --locked` beside this manifest
|
||||
for its media. `FIGURE_PRACTICES=/path/to/practices` uses a working
|
||||
checkout instead, for trying figure changes before they are pushed (add
|
||||
`--module-path ../../../../modules/practices/figure` to the build to compile
|
||||
that checkout's figure code too).
|
||||
|
||||
`./build/app/figure_preview --capture DIR` writes review frames to `DIR` and
|
||||
exits without a window. Each frame is written three ways: the painted figure
|
||||
(`NAME.png`), her bare surface (`NAME-bare.png`) and Breeze's current flat
|
||||
figure for the same moment and camera (`NAME-current.png`). The frames cover
|
||||
Tai Chi's deepest stance, Sun Salutation's fold, lunge, plank, cobra and
|
||||
downward dog, the Workout's lowest squat and lunge, and the astral exits.
|
||||
|
||||
## Known limits
|
||||
|
||||
- At the pinned Kryon, the desktop loop stops showing frames that arrive
|
||||
with no input, so hands-off playback freezes until the pointer moves over
|
||||
the window. The bug is reported to Kryon with a minimal repro.
|
||||
- Practices commits without `astral_projection/sessions/` play the astral
|
||||
techniques with steps evenly 20 seconds apart, and the panel says so.
|
||||
@@ -0,0 +1,411 @@
|
||||
// A live preview of the shared practice figure: pick a practice and one of
|
||||
// its items, play, pause, scrub or slow it down, turn and zoom around her,
|
||||
// and switch the watercolor finish off to judge the bare surface. The poses
|
||||
// are the practices' own (preview_practices.zi); the character is the
|
||||
// practices package's figure.
|
||||
//
|
||||
// figure_preview opens the window
|
||||
// figure_preview --capture DIR writes the review frames to DIR and exits
|
||||
//
|
||||
// FIGURE_PRACTICES names a practices checkout; otherwise the preview asks
|
||||
// `ziran pkg path practices --locked` beside its own manifest.
|
||||
#import "figure_math"
|
||||
#import "figure_joints"
|
||||
#import "figure_paint"
|
||||
#import "preview_practices"
|
||||
#import "preview_capture"
|
||||
#import "preview_flat"
|
||||
#import "kryon/scene"
|
||||
#import "kryon/session"
|
||||
#import "kryon/geometry"
|
||||
#import "kryon/frame_snapshot"
|
||||
#import "kryon/style_sheet"
|
||||
#import "kryon/bitmap_image"
|
||||
#import "kryon/desktop_runtime"
|
||||
#import "kryon/watercolor"
|
||||
#import "kryon/drawing_props"
|
||||
Desktop :: #import "kryon/desktop_loop";
|
||||
Box :: #import "kryon/box";
|
||||
Button :: #import "kryon/button";
|
||||
Dropdown :: #import "kryon/dropdown";
|
||||
Image :: #import "kryon/image";
|
||||
Segmented :: #import "kryon/segmented_control";
|
||||
Slider :: #import "kryon/slider";
|
||||
Text :: #import "kryon/text";
|
||||
Toggle :: #import "kryon/toggle";
|
||||
Raster :: #import "std/image";
|
||||
Timer :: #import "std/timer_linux";
|
||||
#import "std/c_string"
|
||||
#import "std/byte_text_linux"
|
||||
#import "std/math"
|
||||
#import "std/number_text"
|
||||
#import "std/process_capture_linux"
|
||||
#import "std/vec"
|
||||
|
||||
libc :: #system_library "libc";
|
||||
PreviewGetEnvironment :: (name: *u8) -> *u8 #foreign libc "getenv";
|
||||
PreviewWorkingDirectory :: (output: *u8, size: usize) -> *u8 #foreign libc "getcwd";
|
||||
PreviewChangeDirectory :: (path: *u8) -> s32 #foreign libc "chdir";
|
||||
|
||||
PreviewState :: struct {
|
||||
practice: s32
|
||||
item: s32
|
||||
seconds: float64
|
||||
playing: bool
|
||||
speed: float64
|
||||
watercolor: bool
|
||||
// Shows Breeze's current flat figure instead, for comparison.
|
||||
current: bool
|
||||
turn: float64
|
||||
lift: float64
|
||||
zoom: float64
|
||||
dragging: bool
|
||||
drag_x: float32
|
||||
drag_y: float32
|
||||
pooling: float32
|
||||
contour: float32
|
||||
grain: float32
|
||||
}
|
||||
|
||||
preview_state: PreviewState = .{playing = true, speed = 1.0, watercolor = true, zoom = 1.0,
|
||||
pooling = 0.6, contour = 0.7, grain = 0.3};
|
||||
preview_media: FigureMedia;
|
||||
preview_library: PreviewLibrary;
|
||||
preview_body: FigurePainter;
|
||||
preview_twin: FigurePainter;
|
||||
preview_picture: Raster.Image;
|
||||
// Two textures, used in turn: Kryon redraws an image when its texture
|
||||
// changes, not when the same texture's pixels are updated.
|
||||
preview_textures: [2]Texture2D;
|
||||
preview_shown: s32;
|
||||
preview_owner: Session;
|
||||
preview_painted_key: u64;
|
||||
preview_failed: bool;
|
||||
preview_clock: s64;
|
||||
// Changing labels alternate between two buffers, so each frame's text is
|
||||
// its own and never an edit of the last frame's.
|
||||
preview_page: s32;
|
||||
preview_time_text: [2][32]u8;
|
||||
preview_status_text: [2][96]u8;
|
||||
preview_frame_ms: float64;
|
||||
preview_practices_path: [1024]u8;
|
||||
preview_practices_length: s64;
|
||||
|
||||
main :: (argc: s32, argv: **u8) -> s32 {
|
||||
practices := PreviewPracticesPath()
|
||||
if practices.count == 0 {
|
||||
print("figure preview: no practices checkout; set FIGURE_PRACTICES or lock the package\n")
|
||||
return 1
|
||||
}
|
||||
media: [1100]u8
|
||||
preview_media = FigureMediaLoad(PreviewJoin(media[:], practices, "/shared/watercolor"))
|
||||
if !FigureMediaReady(*preview_media) || !PreviewLibraryLoad(*preview_library, practices) {
|
||||
print("figure preview: could not read the figure media or the practices in %\n", practices)
|
||||
return 1
|
||||
}
|
||||
preview_state.item = PreviewDefaultItem(*preview_library, preview_state.practice)
|
||||
if argc >= 3 && TextFromCString(argv[1]) == "--capture" {
|
||||
return PreviewCapture(*preview_media, *preview_library, TextFromCString(argv[2]))
|
||||
}
|
||||
return Desktop.RunTitled(PreviewDraw, 1360, 900, "Figure preview")
|
||||
}
|
||||
|
||||
PreviewDraw :: (session: Session, viewport: Rectangle) -> s32 {
|
||||
input := CaptureFrameInput(session)
|
||||
state := *preview_state
|
||||
panel_width: float32 = 360.0
|
||||
area := Rectangle.{viewport.x, viewport.y, viewport.width - panel_width, viewport.height}
|
||||
panel := Rectangle.{viewport.x + area.width, viewport.y, panel_width, viewport.height}
|
||||
Box.Draw(session, Box.Props.{.key = 1, .bounds = area, .fill = .{243, 237, 225, 255}})
|
||||
Box.Draw(session, Box.Props.{.key = 2, .bounds = panel, .fill = .{232, 225, 211, 255}})
|
||||
|
||||
duration := PreviewDuration(*preview_library, state.practice, state.item)
|
||||
now := Timer.MonotonicMilliseconds()
|
||||
elapsed := ifx preview_clock == 0 then 0 else now - preview_clock
|
||||
preview_clock = now
|
||||
if elapsed > 0 {
|
||||
preview_frame_ms = preview_frame_ms * 0.9 + cast(float64)elapsed * 0.1
|
||||
}
|
||||
if state.playing {
|
||||
// A stalled frame never jumps the figure ahead by more than a moment.
|
||||
state.seconds += cast(float64)FigureClamp(cast(float64)elapsed, 0.0, 250.0) / 1000.0 * state.speed
|
||||
if state.seconds >= duration {
|
||||
state.seconds -= duration * cast(float64)cast(s64)(state.seconds / duration)
|
||||
}
|
||||
DesktopRequestFrame()
|
||||
}
|
||||
// Turn and tilt by dragging over her; zoom with the wheel.
|
||||
pointer := input.pointer
|
||||
inside := pointer.x >= area.x && pointer.x < area.x + area.width && pointer.y >= area.y &&
|
||||
pointer.y < area.y + area.height
|
||||
if pointer.pressed && inside {
|
||||
state.dragging = true
|
||||
state.drag_x = pointer.x
|
||||
state.drag_y = pointer.y
|
||||
}
|
||||
if state.dragging {
|
||||
state.turn -= cast(float64)(pointer.x - state.drag_x) * 0.008
|
||||
state.lift = FigureClamp(state.lift + cast(float64)(pointer.y - state.drag_y) * 0.006, -1.2, 1.45)
|
||||
state.drag_x = pointer.x
|
||||
state.drag_y = pointer.y
|
||||
DesktopRequestFrame()
|
||||
if !pointer.down {
|
||||
state.dragging = false
|
||||
}
|
||||
}
|
||||
if inside && input.wheel != 0.0 {
|
||||
state.zoom = FigureClamp(state.zoom * Pow(0.88, cast(float64)input.wheel), 0.25, 3.0)
|
||||
}
|
||||
|
||||
PreviewPaintFigure(session, area)
|
||||
|
||||
x := panel.x + 20.0
|
||||
width := panel.width - 40.0
|
||||
y := panel.y + 18.0
|
||||
Text.Draw(session, Text.Props.{.key = 10, .bounds = .{x, y, width, 30.0}, .text = "Figure preview",
|
||||
.size = 22})
|
||||
y += 42.0
|
||||
options: [4]Segmented.SegmentOption
|
||||
options[0].label = "Tai Chi"
|
||||
options[1].label = "Sun"
|
||||
options[2].label = "Workout"
|
||||
options[3].label = "Astral"
|
||||
chosen := Segmented.Draw(session, Segmented.Props.{.key = 11, .bounds = .{x, y, width, 40.0},
|
||||
.selected_index = state.practice, .has_selection = true}, options[:]).selected_index
|
||||
if chosen != state.practice && chosen >= 0 && chosen <= 3 {
|
||||
state.practice = chosen
|
||||
state.item = PreviewDefaultItem(*preview_library, chosen)
|
||||
state.seconds = 0.0
|
||||
}
|
||||
y += 52.0
|
||||
items: [PREVIEW_ITEM_LIMIT]Dropdown.Option
|
||||
count := PreviewItemCount(*preview_library, state.practice)
|
||||
for index: cast(s32)0..count - 1 {
|
||||
items[index].label = PreviewItemName(*preview_library, state.practice, index)
|
||||
}
|
||||
picked := Dropdown.Draw(session, Dropdown.Props.{.key = 12, .bounds = .{x, y, width, 40.0},
|
||||
.selected_index = state.item}, items[0:count]).selected_index
|
||||
if picked != state.item && picked >= 0 && picked < count {
|
||||
state.item = picked
|
||||
state.seconds = 0.0
|
||||
}
|
||||
y += 54.0
|
||||
if Button.Draw(session, Button.Props.{.key = 13, .bounds = .{x, y, width * 0.48, 40.0},
|
||||
.label = ifx state.playing then "Pause" else "Play"}) != 0 {
|
||||
state.playing = !state.playing
|
||||
}
|
||||
if Button.Draw(session, Button.Props.{.key = 14, .bounds = .{x + width * 0.52, y, width * 0.48, 40.0},
|
||||
.label = "Front view"}) != 0 {
|
||||
state.turn = 0.0
|
||||
state.lift = 0.0
|
||||
state.zoom = 1.0
|
||||
}
|
||||
y += 54.0
|
||||
preview_page = 1 - preview_page
|
||||
at := Slider.Draw(session, Slider.Props.{.key = cast(u64)(15 + preview_page * 1000), .bounds = .{x, y, width, 64.0},
|
||||
.label = "Time", .value_text = PreviewSeconds(state.seconds, duration, preview_time_text[preview_page][:]), .value = cast(float32)state.seconds,
|
||||
.min = 0.0, .max = cast(float32)duration})
|
||||
if at.changed {
|
||||
state.seconds = cast(float64)at.value
|
||||
state.playing = false
|
||||
}
|
||||
y += 72.0
|
||||
speed_digits: [32]u8
|
||||
speed := Slider.Draw(session, Slider.Props.{.key = 16, .bounds = .{x, y, width, 64.0}, .label = "Speed",
|
||||
.value_text = FormatDecimal(state.speed, 2, speed_digits[:]), .value = cast(float32)state.speed,
|
||||
.min = 0.05, .max = 2.0})
|
||||
if speed.changed {
|
||||
state.speed = cast(float64)speed.value
|
||||
}
|
||||
y += 72.0
|
||||
state.watercolor = Toggle.Draw(session, Toggle.Props.{.key = 17, .bounds = .{x, y, width, 40.0},
|
||||
.label = "Watercolor finish", .value = state.watercolor}).value
|
||||
y += 46.0
|
||||
state.current = Toggle.Draw(session, Toggle.Props.{.key = 23, .bounds = .{x, y, width, 40.0},
|
||||
.label = "Current flat figure", .value = state.current}).value
|
||||
y += 50.0
|
||||
state.pooling = Slider.Draw(session, Slider.Props.{.key = 18, .bounds = .{x, y, width, 64.0},
|
||||
.label = "Edge pooling", .value = state.pooling, .max = 1.0}).value
|
||||
y += 70.0
|
||||
state.contour = Slider.Draw(session, Slider.Props.{.key = 19, .bounds = .{x, y, width, 64.0},
|
||||
.label = "Pencil contour", .value = state.contour, .max = 1.0}).value
|
||||
y += 70.0
|
||||
state.grain = Slider.Draw(session, Slider.Props.{.key = 20, .bounds = .{x, y, width, 64.0},
|
||||
.label = "Paper grain", .value = state.grain, .max = 1.0}).value
|
||||
y += 76.0
|
||||
status := "CPU"
|
||||
if preview_failed {
|
||||
status = "The figure could not be painted"
|
||||
} else if preview_body.accelerated {
|
||||
status = "GPU"
|
||||
}
|
||||
rate: [16]u8
|
||||
first_line: [96]u8
|
||||
labelled := PreviewJoin(first_line[:], status, ", frame ms ")
|
||||
status = PreviewJoin(preview_status_text[preview_page][:], labelled, FormatDecimal(preview_frame_ms, 0, rate[:]))
|
||||
Text.Draw(session, Text.Props.{.key = 21, .bounds = .{x, y, width, 24.0}, .text = status, .size = 14})
|
||||
y += 26.0
|
||||
Text.Draw(session, Text.Props.{.key = 22, .bounds = .{x, y, width, 44.0},
|
||||
.text = "Drag over her to turn around her; scroll to zoom.", .size = 14})
|
||||
if state.practice == PREVIEW_ASTRAL && preview_library.astral_even {
|
||||
y += 46.0
|
||||
Text.Draw(session, Text.Props.{.key = 24, .bounds = .{x, y, width, 44.0},
|
||||
.text = "These practices have no astral session timings yet; steps are 20 s apart.", .size = 14})
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
PreviewStyle :: () -> FigureStyle {
|
||||
style := FigureStyleDefault()
|
||||
style.watercolor = preview_state.watercolor
|
||||
style.finish.pooling_strength = cast(float64)preview_state.pooling
|
||||
style.finish.contour_strength = cast(float64)preview_state.contour
|
||||
style.finish.grain_strength = cast(float64)preview_state.grain
|
||||
return style
|
||||
}
|
||||
|
||||
PreviewPaintFigure :: (session: Session, area: Rectangle) {
|
||||
state := *preview_state
|
||||
// Paint at most 760 pixels tall; the image scales smoothly to the area.
|
||||
scale := FigureClamp(760.0 / cast(float64)area.height, 0.2, 1.0)
|
||||
width := cast(s32)(cast(float64)area.width * scale)
|
||||
height := cast(s32)(cast(float64)area.height * scale)
|
||||
if width < 16 || height < 16 {
|
||||
return
|
||||
}
|
||||
key := PreviewKey(width, height)
|
||||
if key != preview_painted_key || preview_textures[preview_shown].id == 0 {
|
||||
moment := PreviewSample(*preview_library, state.practice, state.item, state.seconds)
|
||||
view := PreviewViewOf(*moment, state.turn, state.lift, state.zoom)
|
||||
if state.current {
|
||||
camera := PreviewFlatOf(*moment, view)
|
||||
preview_failed = !PreviewFlatRender(camera, view, width, height, *preview_picture)
|
||||
} else {
|
||||
preview_failed = !PreviewCompose(*preview_body, *preview_twin, *preview_media, *moment, view,
|
||||
PreviewStyle(), width, height, *preview_picture)
|
||||
}
|
||||
if !preview_failed {
|
||||
next := 1 - preview_shown
|
||||
texture := preview_textures[next]
|
||||
if texture.id != 0 && (texture.width != width || texture.height != height ||
|
||||
preview_owner.slot != session.slot || preview_owner.epoch != session.epoch) {
|
||||
BitmapImageRelease(preview_owner, texture)
|
||||
texture = .{}
|
||||
}
|
||||
if texture.id == 0 {
|
||||
texture = BitmapImageCreate(session, width, height, preview_picture.pixels[:])
|
||||
preview_owner = session
|
||||
} else if !BitmapImageUpdate(session, texture, preview_picture.pixels[:]) {
|
||||
preview_failed = true
|
||||
}
|
||||
preview_textures[next] = texture
|
||||
if texture.id != 0 && !preview_failed {
|
||||
preview_shown = next
|
||||
}
|
||||
preview_painted_key = key
|
||||
}
|
||||
}
|
||||
shown := preview_textures[preview_shown]
|
||||
if shown.id != 0 {
|
||||
// A new key with each new picture: Kryon's retained frames compare
|
||||
// an image by its node and texture, not by the pixels behind it.
|
||||
Image.Draw(session, Image.Props.{.key = cast(u64)(3 + preview_shown * 1000), .bounds = area,
|
||||
.texture = shown, .smooth = true, .alt_text = "The practice figure"})
|
||||
}
|
||||
}
|
||||
|
||||
// Everything the picture depends on.
|
||||
PreviewKey :: (width: s32, height: s32) -> u64 {
|
||||
state := *preview_state
|
||||
digest: u64 = 1469598103934665603
|
||||
values: [13]float64 = .[cast(float64)state.practice, cast(float64)state.item, state.seconds,
|
||||
state.turn, state.lift, state.zoom, ifx state.watercolor then 1.0 else 0.0,
|
||||
ifx state.current then 1.0 else 0.0,
|
||||
cast(float64)state.pooling, cast(float64)state.contour, cast(float64)state.grain,
|
||||
cast(float64)width, cast(float64)height]
|
||||
for value: values {
|
||||
bits := cast(u64)(value * 1000003.0 + 0.5)
|
||||
digest = digest * 1099511628211 + bits
|
||||
}
|
||||
return digest
|
||||
}
|
||||
|
||||
PreviewSeconds :: (seconds: float64, duration: float64, output: []u8) -> string {
|
||||
first: [16]u8
|
||||
second: [16]u8
|
||||
a := FormatDecimal(seconds, 1, first[:])
|
||||
b := FormatDecimal(duration, 1, second[:])
|
||||
length: s64
|
||||
for byte: a {
|
||||
if length < output.count {
|
||||
output[length] = byte
|
||||
length += 1
|
||||
}
|
||||
}
|
||||
joiner := " / "
|
||||
for byte: joiner {
|
||||
if length < output.count {
|
||||
output[length] = byte
|
||||
length += 1
|
||||
}
|
||||
}
|
||||
for byte: b {
|
||||
if length < output.count {
|
||||
output[length] = byte
|
||||
length += 1
|
||||
}
|
||||
}
|
||||
return TextView(output[0:length])
|
||||
}
|
||||
|
||||
PreviewPracticesPath :: () -> string {
|
||||
variable: [32]u8
|
||||
unused CopyCString("FIGURE_PRACTICES", variable[:])
|
||||
named := PreviewGetEnvironment(*variable[0])
|
||||
if named != null {
|
||||
text := TextFromCString(named)
|
||||
if text.count > 0 && text.count < 1024 {
|
||||
return PreviewKeepPath(text)
|
||||
}
|
||||
}
|
||||
// Ask beside the manifest, so the lock names the pinned checkout, then
|
||||
// come back: capture paths stay relative to where the preview started.
|
||||
started: [4096]u8
|
||||
here := PreviewWorkingDirectory(*started[0], 4096)
|
||||
unused Desktop.DesktopStartBeside("preview_practices.zi")
|
||||
output: [1100]u8
|
||||
arguments: [5]string = .["ziran", "pkg", "path", "practices", "--locked"]
|
||||
result := CaptureOutput(arguments[:], output[:])
|
||||
// A desktop launcher's PATH may not include the user's own commands.
|
||||
home_name: [8]u8
|
||||
unused CopyCString("HOME", home_name[:])
|
||||
home := PreviewGetEnvironment(*home_name[0])
|
||||
installed: [1100]u8
|
||||
if (result.error || result.code != 0) && home != null {
|
||||
arguments[0] = PreviewJoin(installed[:], TextFromCString(home), "/.local/bin/ziran")
|
||||
result = CaptureOutput(arguments[:], output[:])
|
||||
}
|
||||
if here != null {
|
||||
unused PreviewChangeDirectory(*started[0])
|
||||
}
|
||||
if result.error || result.code != 0 || result.length <= 1 {
|
||||
return ""
|
||||
}
|
||||
length := result.length
|
||||
while length > 0 && (output[length - 1] == 10 || output[length - 1] == 13) {
|
||||
length -= 1
|
||||
}
|
||||
return PreviewKeepPath(TextView(output[0:length]))
|
||||
}
|
||||
|
||||
#scope_file
|
||||
PreviewKeepPath :: (text: string) -> string {
|
||||
if text.count >= 1024 {
|
||||
return ""
|
||||
}
|
||||
for index: 0..text.count - 1 {
|
||||
preview_practices_path[index] = text[index]
|
||||
}
|
||||
preview_practices_length = text.count
|
||||
return TextView(preview_practices_path[0:preview_practices_length])
|
||||
}
|
||||
@@ -0,0 +1,214 @@
|
||||
// Composing a moment's picture, and the fixed review frames the capture
|
||||
// mode writes: each practice's hardest poses for the figure, painted and
|
||||
// bare, on paper.
|
||||
#import "figure_math"
|
||||
#import "figure_joints"
|
||||
#import "figure_paint"
|
||||
#import "preview_practices"
|
||||
#import "preview_flat"
|
||||
#import "kryon/scene"
|
||||
#import "sun_salutation_rules"
|
||||
#import "workout_rules"
|
||||
#import "std/file"
|
||||
#import "std/png_linux"
|
||||
#import "std/vec"
|
||||
Raster :: #import "std/image";
|
||||
|
||||
// The body, and an astral twin over it, into OUT.
|
||||
PreviewCompose :: (body: *FigurePainter, twin: *FigurePainter, media: *FigureMedia,
|
||||
moment: *PreviewMoment, view: FigureView, style: FigureStyle, width: s32, height: s32,
|
||||
out: *Raster.Image) -> bool {
|
||||
still: FigureEffect
|
||||
if !FigurePaint(body, media, *moment.body, moment.look, view, style, still, width, height) {
|
||||
return false
|
||||
}
|
||||
if out.width != width || out.height != height || out.pixels.count != cast(s64)width * height * 4 {
|
||||
if !VecResize(out.pixels, cast(s64)width * height * 4) {
|
||||
return false
|
||||
}
|
||||
out.width = width
|
||||
out.height = height
|
||||
}
|
||||
for index: 0..out.pixels.count - 1 {
|
||||
out.pixels[index] = body.pixels.pixels[index]
|
||||
}
|
||||
if !moment.twin_visible {
|
||||
return true
|
||||
}
|
||||
glow := style
|
||||
glow.luminous = true
|
||||
glow.opacity = 0.58
|
||||
if !FigurePaint(twin, media, *moment.twin, PreviewLuminous(), view, glow, moment.twin_effect,
|
||||
width, height) {
|
||||
return false
|
||||
}
|
||||
for index: 0..cast(s64)width * height - 1 {
|
||||
at := index * 4
|
||||
a := cast(float64)twin.pixels.pixels[at + 3] / 255.0
|
||||
if a <= 0.0 {
|
||||
continue
|
||||
}
|
||||
under := cast(float64)out.pixels[at + 3] / 255.0
|
||||
alpha := a + under * (1.0 - a)
|
||||
for channel: 0..2 {
|
||||
top := cast(float64)twin.pixels.pixels[at + channel]
|
||||
bottom := cast(float64)out.pixels[at + channel]
|
||||
out.pixels[at + channel] = cast(u8)((top * a + bottom * under * (1.0 - a)) / alpha + 0.5)
|
||||
}
|
||||
out.pixels[at + 3] = cast(u8)(alpha * 255.0 + 0.5)
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
PreviewShot :: struct {
|
||||
practice: s32
|
||||
item: s32
|
||||
seconds: float64
|
||||
name: string
|
||||
}
|
||||
|
||||
PreviewCapture :: (media: *FigureMedia, library: *PreviewLibrary, directory: string) -> s32 {
|
||||
shots: [24]PreviewShot
|
||||
count: s32
|
||||
full := PreviewDefaultItem(library, PREVIEW_TAI_CHI)
|
||||
shots[count] = .{PREVIEW_TAI_CHI, full, 9.0, "tai-chi-9s"}
|
||||
count += 1
|
||||
shots[count] = .{PREVIEW_TAI_CHI, full, 131.0, "tai-chi-131s"}
|
||||
count += 1
|
||||
shots[count] = .{PREVIEW_TAI_CHI, full, PreviewLowest(library, PREVIEW_TAI_CHI, full), "tai-chi-deepest-stance"}
|
||||
count += 1
|
||||
// The Sun Salutation's folds and floor poses, each once it is reached.
|
||||
names: [5]string = .["sun-forward-fold", "sun-lunge", "sun-plank", "sun-cobra", "sun-downward-dog"]
|
||||
steps: [5]s32 = .[2, 3, 4, 6, 7]
|
||||
for index: 0..4 {
|
||||
shots[count] = .{PREVIEW_SUN_SALUTATION, 0, PreviewSunHeld(steps[index]), names[index]}
|
||||
count += 1
|
||||
}
|
||||
shots[count] = .{PREVIEW_WORKOUT, WORKOUT_SQUATS, PreviewLowest(library, PREVIEW_WORKOUT, WORKOUT_SQUATS),
|
||||
"workout-squat"}
|
||||
count += 1
|
||||
shots[count] = .{PREVIEW_WORKOUT, WORKOUT_LUNGES, PreviewLowest(library, PREVIEW_WORKOUT, WORKOUT_LUNGES),
|
||||
"workout-lunge"}
|
||||
count += 1
|
||||
shots[count] = .{PREVIEW_WORKOUT, WORKOUT_PUSH_UPS, 1.0, "workout-push-up"}
|
||||
count += 1
|
||||
shots[count] = .{PREVIEW_WORKOUT, WORKOUT_JUMPING_JACKS, 0.0, "workout-ready"}
|
||||
count += 1
|
||||
shots[count] = .{PREVIEW_ASTRAL, 0, 60.0, "astral-60s"}
|
||||
count += 1
|
||||
shots[count] = .{PREVIEW_ASTRAL, 4, PreviewDoubleTime(library, 4), "astral-rope-exit"}
|
||||
count += 1
|
||||
shots[count] = .{PREVIEW_ASTRAL, 5, PreviewDoubleTime(library, 5), "astral-roll-out"}
|
||||
count += 1
|
||||
body: FigurePainter
|
||||
twin: FigurePainter
|
||||
picture: Raster.Image
|
||||
defer {
|
||||
FigurePainterRelease(*body)
|
||||
FigurePainterRelease(*twin)
|
||||
VecFree(picture.pixels)
|
||||
}
|
||||
failed: s32
|
||||
for index: 0..count - 1 {
|
||||
shot := shots[index]
|
||||
moment := PreviewSample(library, shot.practice, shot.item, shot.seconds)
|
||||
// Lying figures need a landscape picture.
|
||||
width: s32 = ifx shot.practice == PREVIEW_ASTRAL then 900 else 600
|
||||
height: s32 = ifx shot.practice == PREVIEW_ASTRAL then 600 else 800
|
||||
view := PreviewViewOf(*moment, 0.0, 0.0, 1.0)
|
||||
for variant: 0..2 {
|
||||
style := FigureStyleDefault()
|
||||
style.watercolor = variant == 0
|
||||
suffix := ".png"
|
||||
if variant == 1 {
|
||||
suffix = "-bare.png"
|
||||
} else if variant == 2 {
|
||||
suffix = "-current.png"
|
||||
}
|
||||
stem: [1024]u8
|
||||
named: [1024]u8
|
||||
path: [1024]u8
|
||||
name := PreviewJoin(stem[:], directory, "/")
|
||||
name = PreviewJoin(named[:], name, shot.name)
|
||||
final := PreviewJoin(path[:], name, suffix)
|
||||
painted := false
|
||||
if variant == 2 {
|
||||
camera := PreviewFlatOf(*moment, view)
|
||||
painted = PreviewFlatRender(camera, view, width, height, *picture)
|
||||
} else {
|
||||
painted = PreviewCompose(*body, *twin, media, *moment, view, style, width, height, *picture)
|
||||
}
|
||||
if !painted {
|
||||
print("figure capture: % could not be painted\n", final)
|
||||
failed += 1
|
||||
continue
|
||||
}
|
||||
PreviewOnPaper(*picture)
|
||||
if !WritePNGFile(final, *picture, false) {
|
||||
print("figure capture: could not write %\n", final)
|
||||
failed += 1
|
||||
}
|
||||
}
|
||||
}
|
||||
print("figure capture: % frames, gpu=% %\n", count * 3, body.accelerated, body.diagnostic)
|
||||
return failed
|
||||
}
|
||||
|
||||
#scope_file
|
||||
// Lays the picture on the preview's paper colour.
|
||||
PreviewOnPaper :: (picture: *Raster.Image) {
|
||||
paper: [3]float64 = .[243.0, 237.0, 225.0]
|
||||
for index: 0..cast(s64)picture.width * picture.height - 1 {
|
||||
at := index * 4
|
||||
a := cast(float64)picture.pixels[at + 3] / 255.0
|
||||
for channel: 0..2 {
|
||||
value := cast(float64)picture.pixels[at + channel] * a + paper[channel] * (1.0 - a)
|
||||
picture.pixels[at + channel] = cast(u8)(value + 0.5)
|
||||
}
|
||||
picture.pixels[at + 3] = 255
|
||||
}
|
||||
}
|
||||
|
||||
// The second of the item where her pelvis is lowest: the deepest stance.
|
||||
PreviewLowest :: (library: *PreviewLibrary, practice: s32, item: s32) -> float64 {
|
||||
duration := PreviewDuration(library, practice, item)
|
||||
best: float64
|
||||
lowest: float64 = 1000.0
|
||||
seconds: float64
|
||||
while seconds < duration {
|
||||
moment := PreviewSample(library, practice, item, seconds)
|
||||
if moment.body.pelvis.y < lowest {
|
||||
lowest = moment.body.pelvis.y
|
||||
best = seconds
|
||||
}
|
||||
seconds += 0.25
|
||||
}
|
||||
return best
|
||||
}
|
||||
|
||||
// The first second the astral twin is out beside the body, a little on.
|
||||
PreviewDoubleTime :: (library: *PreviewLibrary, item: s32) -> float64 {
|
||||
duration := PreviewDuration(library, PREVIEW_ASTRAL, item)
|
||||
seconds: float64
|
||||
while seconds < duration {
|
||||
if PreviewSample(library, PREVIEW_ASTRAL, item, seconds).twin_visible {
|
||||
return FigureClamp(seconds + 4.0, 0.0, duration)
|
||||
}
|
||||
seconds += 1.0
|
||||
}
|
||||
return duration * 0.5
|
||||
}
|
||||
|
||||
// Half a second before the first round's STEP ends: its pose reached.
|
||||
PreviewSunHeld :: (step: s32) -> float64 {
|
||||
total: float64
|
||||
for at: cast(s32)0..step {
|
||||
state: SunSalutationPracticeState
|
||||
state.repetitions = 2
|
||||
state.step = at
|
||||
state.start_seconds = SUN_SALUTATION_DEFAULT_START_SECONDS
|
||||
state.end_seconds = SUN_SALUTATION_DEFAULT_END_SECONDS
|
||||
total += cast(float64)SalutationStepSeconds(state)
|
||||
}
|
||||
return total - 0.5
|
||||
}
|
||||
@@ -0,0 +1,159 @@
|
||||
// Breeze's current flat figure (tai_chi_flat.zi) for the same moment, so the
|
||||
// preview can show it beside the new character. The flat painter emits
|
||||
// filled shapes and stroked lines in the picture plane; this lays them on
|
||||
// pixels with four rows of coverage per pixel row.
|
||||
#import "figure_math"
|
||||
#import "figure_paint"
|
||||
#import "kryon/scene"
|
||||
#import "tai_chi_math"
|
||||
#import "tai_chi_view"
|
||||
#import "tai_chi_flat"
|
||||
#import "std/math"
|
||||
#import "std/vec"
|
||||
Raster :: #import "std/image";
|
||||
|
||||
preview_flat_frame: TaiChiFlatFrame;
|
||||
preview_flat_edges: [512]float64;
|
||||
preview_flat_shape: [256]TaiChiVector2;
|
||||
|
||||
// Draws preview_flat_frame, painted for CAMERA, into OUT as VIEW frames the
|
||||
// scene.
|
||||
PreviewFlatRender :: (camera: TaiChiCamera, view: FigureView, width: s32, height: s32,
|
||||
out: *Raster.Image) -> bool {
|
||||
frame := *preview_flat_frame
|
||||
if width < 1 || height < 1 || !VecResize(out.pixels, cast(s64)width * height * 4) {
|
||||
return false
|
||||
}
|
||||
out.width = width
|
||||
out.height = height
|
||||
for index: 0..out.pixels.count - 1 {
|
||||
out.pixels[index] = 0
|
||||
}
|
||||
flat: TaiChiFlatView
|
||||
TaiChiFlatViewSet(*flat, camera)
|
||||
target := TaiChiProject(*flat, TaiChiV3(view.center.x, view.center.y, view.center.z))
|
||||
scale := cast(float64)height / view.height
|
||||
for index: cast(s32)0..frame.op_count - 1 {
|
||||
op := frame.ops[index]
|
||||
if op.kind == TAI_CHI_FLAT_FILL {
|
||||
count := TaiChiMin(cast(float64)op.count, 256.0)
|
||||
for at: cast(s32)0..cast(s32)count - 1 {
|
||||
preview_flat_shape[at] = PreviewFlatPixel(frame.points[op.first + at], target, scale, width, height)
|
||||
}
|
||||
PreviewFlatFill(out, preview_flat_shape[0:cast(s32)count], op.color, op.alpha)
|
||||
} else {
|
||||
half := op.width * scale * 0.5
|
||||
if half < 0.5 {
|
||||
half = 0.5
|
||||
}
|
||||
for at: cast(s32)0..op.count - 2 {
|
||||
a := PreviewFlatPixel(frame.points[op.first + at], target, scale, width, height)
|
||||
b := PreviewFlatPixel(frame.points[op.first + at + 1], target, scale, width, height)
|
||||
along := TaiChiUnit2(TaiChiSub2(b, a), TaiChiV2(1.0, 0.0))
|
||||
side := TaiChiScale2(TaiChiV2(-along.y, along.x), half)
|
||||
preview_flat_shape[0] = TaiChiAdd2(a, side)
|
||||
preview_flat_shape[1] = TaiChiAdd2(b, side)
|
||||
preview_flat_shape[2] = TaiChiSub2(b, side)
|
||||
preview_flat_shape[3] = TaiChiSub2(a, side)
|
||||
PreviewFlatFill(out, preview_flat_shape[0:4], op.color, op.alpha)
|
||||
}
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
#scope_file
|
||||
PreviewFlatPixel :: (point: TaiChiVector2, target: TaiChiVector2, scale: float64, width: s32,
|
||||
height: s32) -> TaiChiVector2 {
|
||||
return TaiChiV2(cast(float64)width * 0.5 + (point.x - target.x) * scale,
|
||||
cast(float64)height * 0.5 - (point.y - target.y) * scale)
|
||||
}
|
||||
|
||||
// Even-odd fill with sixteen coverage samples per pixel: four rows, and
|
||||
// exact horizontal span ends within each.
|
||||
PreviewFlatFill :: (out: *Raster.Image, shape: []TaiChiVector2, color: u32, alpha: float64) {
|
||||
if shape.count < 3 || alpha <= 0.0 {
|
||||
return
|
||||
}
|
||||
top: float64 = 1000000.0
|
||||
bottom: float64 = -1000000.0
|
||||
for point: shape {
|
||||
top = TaiChiMin(top, point.y)
|
||||
bottom = TaiChiMax(bottom, point.y)
|
||||
}
|
||||
first := cast(s32)TaiChiMax(0.0, top)
|
||||
last := cast(s32)TaiChiMin(cast(float64)out.height - 1.0, bottom)
|
||||
red := cast(float64)((color >> 16) & 255)
|
||||
green := cast(float64)((color >> 8) & 255)
|
||||
blue := cast(float64)(color & 255)
|
||||
coverage: [4096]float64
|
||||
for row: first..last {
|
||||
left: s32 = out.width
|
||||
right: s32 = -1
|
||||
for sample: 0..3 {
|
||||
y := cast(float64)row + (cast(float64)sample + 0.5) / 4.0
|
||||
crossings: s32
|
||||
for at: 0..shape.count - 1 {
|
||||
a := shape[at]
|
||||
b := shape[(at + 1) % shape.count]
|
||||
if (a.y <= y && b.y > y) || (b.y <= y && a.y > y) {
|
||||
if crossings < 512 {
|
||||
preview_flat_edges[crossings] = a.x + (y - a.y) * (b.x - a.x) / (b.y - a.y)
|
||||
crossings += 1
|
||||
}
|
||||
}
|
||||
}
|
||||
// Sort the few crossings in place.
|
||||
for i: 1..crossings - 1 {
|
||||
value := preview_flat_edges[i]
|
||||
j := i - 1
|
||||
while j >= 0 && preview_flat_edges[j] > value {
|
||||
preview_flat_edges[j + 1] = preview_flat_edges[j]
|
||||
j -= 1
|
||||
}
|
||||
preview_flat_edges[j + 1] = value
|
||||
}
|
||||
pair: s32
|
||||
while pair + 1 < crossings {
|
||||
start := TaiChiMax(0.0, preview_flat_edges[pair])
|
||||
end := TaiChiMin(cast(float64)out.width, preview_flat_edges[pair + 1])
|
||||
pair += 2
|
||||
if end <= start {
|
||||
continue
|
||||
}
|
||||
low := cast(s32)start
|
||||
high := cast(s32)TaiChiMin(cast(float64)out.width - 1.0, end)
|
||||
left = cast(s32)TaiChiMin(cast(float64)left, cast(float64)low)
|
||||
right = cast(s32)TaiChiMax(cast(float64)right, cast(float64)high)
|
||||
for x: low..high {
|
||||
if x >= 4096 {
|
||||
break
|
||||
}
|
||||
cell := TaiChiMin(end, cast(float64)x + 1.0) - TaiChiMax(start, cast(float64)x)
|
||||
if cell > 0.0 {
|
||||
coverage[x] += cell * 0.25
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for x: left..right {
|
||||
if x < 0 || x >= 4096 {
|
||||
continue
|
||||
}
|
||||
a := TaiChiMin(1.0, coverage[x]) * alpha
|
||||
coverage[x] = 0.0
|
||||
if a <= 0.0 {
|
||||
continue
|
||||
}
|
||||
at := (cast(s64)row * out.width + x) * 4
|
||||
under := cast(float64)out.pixels[at + 3] / 255.0
|
||||
total := a + under * (1.0 - a)
|
||||
source: [3]float64 = .[red, green, blue]
|
||||
for channel: 0..2 {
|
||||
value := (source[channel] * a + cast(float64)out.pixels[at + channel] * under * (1.0 - a)) / total
|
||||
out.pixels[at + channel] = cast(u8)(value + 0.5)
|
||||
}
|
||||
out.pixels[at + 3] = cast(u8)(total * 255.0 + 0.5)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,384 @@
|
||||
// The four practices' own choreography, sampled at any second and turned
|
||||
// into the shared figure's joints. The pose code is Breeze's own: the build
|
||||
// adds src/practices/tai_chi, src/practices/sun_salutation and apps/practice
|
||||
// as module folders, so the preview shows exactly what the app plays.
|
||||
#import "figure_math"
|
||||
#import "figure_joints"
|
||||
#import "figure_paint"
|
||||
#import "kryon/scene"
|
||||
#import "tai_chi_math"
|
||||
#import "tai_chi_course"
|
||||
#import "tai_chi_timeline"
|
||||
#import "tai_chi_solve"
|
||||
#import "tai_chi_view"
|
||||
#import "tai_chi_flat"
|
||||
#import "tai_chi_rules"
|
||||
#import "workout_rules"
|
||||
#import "workout_moves"
|
||||
#import "sun_salutation_rules"
|
||||
#import "sun_salutation_pose"
|
||||
#import "astral_projection_rules"
|
||||
#import "astral_technique"
|
||||
#import "sun_salutation_artwork"
|
||||
#import "preview_flat"
|
||||
#import "std/file"
|
||||
#import "std/math"
|
||||
|
||||
PREVIEW_TAI_CHI :: 0
|
||||
PREVIEW_SUN_SALUTATION :: 1
|
||||
PREVIEW_WORKOUT :: 2
|
||||
PREVIEW_ASTRAL :: 3
|
||||
|
||||
PREVIEW_ITEM_LIMIT :: 64
|
||||
|
||||
// What one moment of a practice shows: the figure, and for an astral exit
|
||||
// the translucent twin beside the still physical body.
|
||||
PreviewMoment :: struct {
|
||||
body: FigureJoints
|
||||
look: FigureLook
|
||||
// The practice's own camera and framing, which the flat figure shares.
|
||||
camera: TaiChiCamera
|
||||
target: Vector3
|
||||
height: float64
|
||||
solved: TaiChiSolved
|
||||
rig: TaiChiRig
|
||||
flat_look: TaiChiFlatLook
|
||||
twin_visible: bool
|
||||
twin: FigureJoints
|
||||
twin_effect: FigureEffect
|
||||
}
|
||||
|
||||
PreviewLibrary :: struct {
|
||||
ready: bool
|
||||
tai_chi_items: [PREVIEW_ITEM_LIMIT]s32
|
||||
tai_chi_count: s32
|
||||
timeline_item: s32
|
||||
timeline: TaiChiTimeline
|
||||
astral: [6]AstralCourse
|
||||
astral_ready: [6]bool
|
||||
astral_even: bool
|
||||
}
|
||||
|
||||
preview_astral_ids: [6]string = .["bruce_foundation_touch", "bruce_full_body_current",
|
||||
"bruce_elevator_trance", "bruce_spin_loosening", "bruce_rope_exit", "bruce_roll_out_exit"];
|
||||
preview_astral_names: [6]string = .["Foundation touch", "Full-body current", "Elevator trance",
|
||||
"Spin loosening", "Rope exit", "Roll-out exit"];
|
||||
preview_workout_names: [12]string = .["Jumping jacks", "Wall sit", "Push-ups", "Crunches",
|
||||
"Step-ups", "Squats", "Triceps dips", "Plank", "High knees", "Lunges", "Push-up rotation",
|
||||
"Side plank"];
|
||||
|
||||
// PRACTICES is the practices package checkout (its taichi/ and
|
||||
// astral_projection/ folders).
|
||||
PreviewLibraryLoad :: (library: *PreviewLibrary, practices: string) -> bool {
|
||||
path: [1024]u8
|
||||
course, found := ReadEntireFile(PreviewJoin(path[:], practices, "/taichi/course.tch"))
|
||||
if !found || !TaiChiCourseParse(*tai_chi_course, course) {
|
||||
return false
|
||||
}
|
||||
library.tai_chi_count = 0
|
||||
// Breakdown and follow-along items replay a demo's choreography slower.
|
||||
for index: cast(s32)0..tai_chi_course.item_count - 1 {
|
||||
id := TaiChiCourseString(tai_chi_course.items[index].id)
|
||||
if PreviewEndsWith(id, "/breakdown") || PreviewEndsWith(id, "/follow") {
|
||||
continue
|
||||
}
|
||||
if library.tai_chi_count < PREVIEW_ITEM_LIMIT {
|
||||
library.tai_chi_items[library.tai_chi_count] = index
|
||||
library.tai_chi_count += 1
|
||||
}
|
||||
}
|
||||
library.timeline_item = -1
|
||||
for technique: 0..5 {
|
||||
name: [128]u8
|
||||
file := PreviewJoin(name[:], "/astral_projection/sessions/", preview_astral_ids[technique])
|
||||
full: [1024]u8
|
||||
relative := PreviewJoin(full[:], practices, file)
|
||||
tail: [1100]u8
|
||||
data, ok := ReadEntireFile(PreviewJoin(tail[:], relative, ".json"))
|
||||
library.astral_ready[technique] = ok && AstralCourseParse(data, *library.astral[technique])
|
||||
if !library.astral_ready[technique] {
|
||||
// A practices checkout without the session timings still plays
|
||||
// each technique, with its steps evenly twenty seconds apart.
|
||||
PreviewAstralEven(*library.astral[technique])
|
||||
library.astral_ready[technique] = true
|
||||
library.astral_even = true
|
||||
}
|
||||
}
|
||||
library.ready = library.tai_chi_count > 0
|
||||
return library.ready
|
||||
}
|
||||
|
||||
PreviewItemCount :: (library: *PreviewLibrary, practice: s32) -> s32 {
|
||||
if practice == PREVIEW_TAI_CHI {
|
||||
return library.tai_chi_count
|
||||
}
|
||||
if practice == PREVIEW_SUN_SALUTATION {
|
||||
return 1
|
||||
}
|
||||
if practice == PREVIEW_WORKOUT {
|
||||
return WORKOUT_EXERCISE_COUNT
|
||||
}
|
||||
return 6
|
||||
}
|
||||
|
||||
PreviewItemName :: (library: *PreviewLibrary, practice: s32, item: s32) -> string {
|
||||
if practice == PREVIEW_TAI_CHI && item >= 0 && item < library.tai_chi_count {
|
||||
return TaiChiCourseString(tai_chi_course.items[library.tai_chi_items[item]].id)
|
||||
}
|
||||
if practice == PREVIEW_SUN_SALUTATION {
|
||||
return "Two rounds, both legs"
|
||||
}
|
||||
if practice == PREVIEW_WORKOUT && item >= 0 && item < 12 {
|
||||
return preview_workout_names[item]
|
||||
}
|
||||
if practice == PREVIEW_ASTRAL && item >= 0 && item < 6 {
|
||||
return preview_astral_names[item]
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// The item the practice opens on: Tai Chi's full form, the Workout's squat.
|
||||
PreviewDefaultItem :: (library: *PreviewLibrary, practice: s32) -> s32 {
|
||||
if practice == PREVIEW_TAI_CHI {
|
||||
for index: cast(s32)0..library.tai_chi_count - 1 {
|
||||
if PreviewItemName(library, practice, index) == "full/normal" {
|
||||
return index
|
||||
}
|
||||
}
|
||||
}
|
||||
if practice == PREVIEW_WORKOUT {
|
||||
return WORKOUT_SQUATS
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// Seconds the item plays before it starts again.
|
||||
PreviewDuration :: (library: *PreviewLibrary, practice: s32, item: s32) -> float64 {
|
||||
if practice == PREVIEW_TAI_CHI {
|
||||
if !PreviewTimeline(library, item) {
|
||||
return 1.0
|
||||
}
|
||||
return library.timeline.duration
|
||||
}
|
||||
if practice == PREVIEW_SUN_SALUTATION {
|
||||
total: float64
|
||||
for round: cast(s32)0..1 {
|
||||
for step: cast(s32)0..SUN_SALUTATION_STEP_COUNT - 1 {
|
||||
total += cast(float64)SalutationStepSeconds(PreviewSunState(round, step))
|
||||
}
|
||||
}
|
||||
return total
|
||||
}
|
||||
if practice == PREVIEW_WORKOUT {
|
||||
return cast(float64)WORKOUT_WORK_MS / 1000.0
|
||||
}
|
||||
if item >= 0 && item < 6 && library.astral_ready[item] {
|
||||
return cast(float64)library.astral[item].duration
|
||||
}
|
||||
return 60.0
|
||||
}
|
||||
|
||||
PreviewSample :: (library: *PreviewLibrary, practice: s32, item: s32, seconds: float64) -> PreviewMoment {
|
||||
moment: PreviewMoment
|
||||
if practice == PREVIEW_TAI_CHI {
|
||||
moment.rig = TaiChiRigFor(0)
|
||||
moment.flat_look = TaiChiFlatLookFor(0)
|
||||
if PreviewTimeline(library, item) {
|
||||
pose := TaiChiTimelineSample(*library.timeline, seconds)
|
||||
moment.solved = TaiChiSolvePose(*pose, *moment.rig)
|
||||
}
|
||||
// The forms travel; the camera follows the pelvis over the floor.
|
||||
moment.camera.yaw = 0.42
|
||||
moment.camera.tilt = 0.12
|
||||
moment.camera.center = TaiChiV3(moment.solved.pelvis.x, 0.0, moment.solved.pelvis.z)
|
||||
PreviewAim(*moment, 2.3, moment.rig.height * 0.5)
|
||||
} else if practice == PREVIEW_SUN_SALUTATION {
|
||||
moment.rig = WorkoutRig()
|
||||
state := PreviewSunAt(seconds)
|
||||
pose := SunSalutationPoseAt(state, *moment.rig)
|
||||
moment.solved = WorkoutSolve(*pose, *moment.rig)
|
||||
moment.flat_look = SunSalutationWomanLook()
|
||||
framing := SunSalutationPaintPose(*preview_flat_frame, 0, pose, SunSalutationViewAt(state), 600.0, 800.0)
|
||||
moment.camera = framing.camera
|
||||
PreviewAim(*moment, framing.view_height, framing.view_center)
|
||||
} else if practice == PREVIEW_WORKOUT {
|
||||
moment.rig = WorkoutRig()
|
||||
pose := WorkoutPoseAt(item, cast(s64)(seconds * 1000.0), *moment.rig)
|
||||
moment.solved = WorkoutSolve(*pose, *moment.rig)
|
||||
moment.flat_look = TaiChiFlatLookNamed("jadeWoman")
|
||||
framing := WorkoutFramingFor(item)
|
||||
moment.camera = framing.camera
|
||||
PreviewAim(*moment, framing.view_height, framing.view_center)
|
||||
} else {
|
||||
moment.rig = WorkoutRig()
|
||||
moment.flat_look = TaiChiFlatLookNamed("jadeWoman")
|
||||
moment.flat_look.top = 0x597888
|
||||
moment.flat_look.pants = 0x384d65
|
||||
if item >= 0 && item <= 5 && library.astral_ready[item] {
|
||||
scene := AstralTechniqueAt(preview_astral_ids[item], *library.astral[item], cast(s64)(seconds * 1000.0))
|
||||
moment.solved = WorkoutSolve(*scene.physical, *moment.rig)
|
||||
moment.camera = scene.camera
|
||||
PreviewAim(*moment, 2.15, 0.35)
|
||||
moment.twin_visible = scene.double_visible
|
||||
if scene.double_visible {
|
||||
awareness := WorkoutSolve(*scene.awareness, *moment.rig)
|
||||
moment.twin = PreviewJoints(*awareness, *moment.rig)
|
||||
moment.twin_effect.offset = FigureV3(scene.double_offset.x, scene.double_offset.y,
|
||||
scene.double_offset.z)
|
||||
moment.twin_effect.pivot = FigureV3(moment.solved.pelvis.x, moment.solved.pelvis.y,
|
||||
moment.solved.pelvis.z)
|
||||
moment.twin_effect.roll = scene.double_roll
|
||||
}
|
||||
} else {
|
||||
resting := AstralRestingPose()
|
||||
moment.solved = WorkoutSolve(*resting, *moment.rig)
|
||||
}
|
||||
}
|
||||
moment.body = PreviewJoints(*moment.solved, *moment.rig)
|
||||
moment.look = .{skin = moment.flat_look.skin, top = moment.flat_look.top,
|
||||
trousers = moment.flat_look.pants, hair = moment.flat_look.hair}
|
||||
return moment
|
||||
}
|
||||
|
||||
// The view of MOMENT turned TURN and lifted LIFT radians from the practice's
|
||||
// own camera and zoomed ZOOM times, and the flat figure's camera to match.
|
||||
PreviewViewOf :: (moment: *PreviewMoment, turn: float64, lift: float64, zoom: float64) -> FigureView {
|
||||
view: FigureView
|
||||
view.yaw = moment.camera.yaw + turn
|
||||
view.pitch = FigureClamp(moment.camera.tilt + lift, -1.4, 1.5)
|
||||
view.height = moment.height / zoom
|
||||
view.center = moment.target
|
||||
return view
|
||||
}
|
||||
|
||||
PreviewFlatOf :: (moment: *PreviewMoment, view: FigureView) -> TaiChiCamera {
|
||||
camera := moment.camera
|
||||
camera.yaw = view.yaw
|
||||
camera.tilt = view.pitch
|
||||
TaiChiFlatPaintLook(*preview_flat_frame, *moment.solved, *moment.rig, moment.flat_look, camera)
|
||||
return camera
|
||||
}
|
||||
|
||||
PreviewLuminous :: () -> FigureLook {
|
||||
return .{skin = 0xb2d8df, top = 0x7db7d5, trousers = 0x7a8fca, hair = 0x7ca1bc}
|
||||
}
|
||||
|
||||
PreviewJoints :: (solved: *TaiChiSolved, rig: *TaiChiRig) -> FigureJoints {
|
||||
joints: FigureJoints
|
||||
joints.height = rig.height
|
||||
joints.pelvis = PreviewVector(solved.pelvis)
|
||||
joints.spine = PreviewVector(solved.spine1)
|
||||
joints.chest = PreviewVector(solved.chest)
|
||||
joints.neck = PreviewVector(solved.neck_base)
|
||||
joints.pelvis_turn = PreviewQuat(solved.pelvis_quat)
|
||||
joints.chest_turn = PreviewQuat(solved.chest_quat)
|
||||
joints.head_turn = PreviewQuat(solved.head_quat)
|
||||
for side: 0..1 {
|
||||
joints.shoulders[side] = PreviewVector(solved.shoulders[side])
|
||||
joints.elbows[side] = PreviewVector(solved.elbows[side])
|
||||
joints.wrists[side] = PreviewVector(solved.wrists[side])
|
||||
joints.hands[side] = PreviewQuat(solved.hand_quats[side])
|
||||
joints.fist[side] = solved.hand_shapes[side][1]
|
||||
joints.hook[side] = solved.hand_shapes[side][2]
|
||||
joints.hips[side] = PreviewVector(solved.hips[side])
|
||||
joints.knees[side] = PreviewVector(solved.knees[side])
|
||||
joints.ankles[side] = PreviewVector(solved.ankles[side])
|
||||
joints.toes[side] = PreviewVector(solved.toes[side])
|
||||
joints.feet[side] = PreviewQuat(solved.foot_quats[side])
|
||||
}
|
||||
return joints
|
||||
}
|
||||
|
||||
PreviewAstralEven :: (course: *AstralCourse) {
|
||||
course.count = 16
|
||||
course.duration = 330
|
||||
stem := "astral_text_preview_"
|
||||
for index: cast(s32)0..15 {
|
||||
cue := *course.cues[index]
|
||||
cue.second = index * 20
|
||||
for at: 0..stem.count - 1 {
|
||||
cue.key[at] = stem[at]
|
||||
}
|
||||
cue.key[stem.count] = cast(u8)(48 + index / 10)
|
||||
cue.key[stem.count + 1] = cast(u8)(48 + index % 10)
|
||||
cue.key[stem.count + 2] = 0
|
||||
}
|
||||
}
|
||||
|
||||
PreviewEndsWith :: (text: string, suffix: string) -> bool {
|
||||
return text.count >= suffix.count && text[text.count - suffix.count:text.count] == suffix
|
||||
}
|
||||
|
||||
PreviewJoin :: (buffer: []u8, a: string, b: string) -> string {
|
||||
if a.count + b.count > buffer.count {
|
||||
return ""
|
||||
}
|
||||
for index: 0..a.count - 1 {
|
||||
buffer[index] = a[index]
|
||||
}
|
||||
for index: 0..b.count - 1 {
|
||||
buffer[a.count + index] = b[index]
|
||||
}
|
||||
return TextView(buffer[0:a.count + b.count])
|
||||
}
|
||||
|
||||
#scope_file
|
||||
PreviewVector :: (value: TaiChiVector3) -> Vector3 {
|
||||
return .{value.x, value.y, value.z}
|
||||
}
|
||||
|
||||
PreviewQuat :: (value: TaiChiQuaternion) -> FigureQuat {
|
||||
return .{value.x, value.y, value.z, value.w}
|
||||
}
|
||||
|
||||
// Frames the practice's camera as its painter does: VIEW_HEIGHT metres tall,
|
||||
// centred UP metres above the camera's floor point along its up direction.
|
||||
PreviewAim :: (moment: *PreviewMoment, view_height: float64, up: float64) {
|
||||
flat: TaiChiFlatView
|
||||
TaiChiFlatViewSet(*flat, moment.camera)
|
||||
target := TaiChiAddScaled3(flat.center, flat.up, up)
|
||||
moment.target = FigureV3(target.x, target.y, target.z)
|
||||
moment.height = view_height
|
||||
}
|
||||
|
||||
PreviewTimeline :: (library: *PreviewLibrary, item: s32) -> bool {
|
||||
if item < 0 || item >= library.tai_chi_count {
|
||||
return false
|
||||
}
|
||||
if library.timeline_item == item {
|
||||
return true
|
||||
}
|
||||
if !TaiChiTimelineForItem(*library.timeline, tai_chi_course.items[library.tai_chi_items[item]]) {
|
||||
library.timeline_item = -1
|
||||
return false
|
||||
}
|
||||
library.timeline_item = item
|
||||
return true
|
||||
}
|
||||
|
||||
PreviewSunState :: (round: s32, step: s32) -> SunSalutationPracticeState {
|
||||
state: SunSalutationPracticeState
|
||||
state.repetitions = 2
|
||||
state.repetition = round
|
||||
state.step = step
|
||||
state.start_seconds = SUN_SALUTATION_DEFAULT_START_SECONDS
|
||||
state.end_seconds = SUN_SALUTATION_DEFAULT_END_SECONDS
|
||||
return state
|
||||
}
|
||||
|
||||
// Two full rounds, the second leading with the other leg.
|
||||
PreviewSunAt :: (seconds: float64) -> SunSalutationPracticeState {
|
||||
left := seconds
|
||||
for round: cast(s32)0..1 {
|
||||
for step: cast(s32)0..SUN_SALUTATION_STEP_COUNT - 1 {
|
||||
state := PreviewSunState(round, step)
|
||||
length := cast(float64)SalutationStepSeconds(state)
|
||||
if left < length || (round == 1 && step == SUN_SALUTATION_STEP_COUNT - 1) {
|
||||
state.step_ticks = cast(s32)(FigureClamp(left, 0.0, length) * 60.0)
|
||||
return state
|
||||
}
|
||||
left -= length
|
||||
}
|
||||
}
|
||||
return PreviewSunState(0, 0)
|
||||
}
|
||||
@@ -0,0 +1,149 @@
|
||||
{
|
||||
"format": 1,
|
||||
"packages": [
|
||||
{
|
||||
"commit": "c96f5e3de9c4488f4e6c97f59f5245f22fda22f7",
|
||||
"dependencies": {},
|
||||
"id": "p0dd67588478f9a3e",
|
||||
"name": "libsamplerate",
|
||||
"ref": "c96f5e3de9c4488f4e6c97f59f5245f22fda22f7",
|
||||
"source": true,
|
||||
"url": "https://github.com/libsndfile/libsamplerate.git"
|
||||
},
|
||||
{
|
||||
"commit": "829a65d769d935c4852f8159e964312c0957260a",
|
||||
"dependencies": {},
|
||||
"id": "p16cd0434af3dff7b",
|
||||
"name": "sdl3",
|
||||
"ref": "829a65d769d935c4852f8159e964312c0957260a",
|
||||
"source": true,
|
||||
"url": "https://github.com/libsdl-org/SDL.git"
|
||||
},
|
||||
{
|
||||
"commit": "199b51c97c2aba67367308c3dc98126692b476a8",
|
||||
"dependencies": {"audio": "p59deb49c7f103127", "avif": "pb203529d803e73a4", "image_codec": "p69c0e968ae5735d9", "libaom": "p74ab3cb6eb3b86fa", "libavif": "p57c0272208aae8db", "libwebp": "p3b3c785a0e17e605", "raylib": "pcc7aa76725f2fb2f", "sdl3": "p16cd0434af3dff7b", "webp": "p2af20e0c835b1c63"},
|
||||
"dependency_refs": {"audio": "1b2f35b7b39df6fb9af7a52324b4b7cf18e98df2", "avif": "2611e727e226a2af22dfb7f10bf224bd2f1a3d30", "image_codec": "360553150917f352e49e1beb78917370792ccaef", "libaom": "b141d9c45db236335351c8a4b2a14b3ade27c937", "libavif": "1aadfad932c98c069a1204261b1856f81f3bc199", "libwebp": "1844042d1ca751e62e61df7617dba19c98588339", "raylib": "fafa2cea97d0cb379d832086ba45a989fa6f9c8e", "sdl3": "829a65d769d935c4852f8159e964312c0957260a", "webp": "ec6ed304767e10c125ab2820f3b01d6fd773e147"},
|
||||
"id": "p1e41122208040e0f",
|
||||
"name": "kryon",
|
||||
"ref": "199b51c97c2aba67367308c3dc98126692b476a8",
|
||||
"url": "https://github.com/kryonlabs/kryon.git"
|
||||
},
|
||||
{
|
||||
"commit": "ec6ed304767e10c125ab2820f3b01d6fd773e147",
|
||||
"dependencies": {"image_codec": "p69c0e968ae5735d9", "libwebp": "p3b3c785a0e17e605"},
|
||||
"dependency_refs": {"image_codec": "360553150917f352e49e1beb78917370792ccaef", "libwebp": "1844042d1ca751e62e61df7617dba19c98588339"},
|
||||
"id": "p2af20e0c835b1c63",
|
||||
"name": "webp",
|
||||
"ref": "ec6ed304767e10c125ab2820f3b01d6fd773e147",
|
||||
"url": "https://github.com/ziranlang/webp.git"
|
||||
},
|
||||
{
|
||||
"commit": "1844042d1ca751e62e61df7617dba19c98588339",
|
||||
"dependencies": {},
|
||||
"id": "p3b3c785a0e17e605",
|
||||
"name": "libwebp",
|
||||
"ref": "1844042d1ca751e62e61df7617dba19c98588339",
|
||||
"source": true,
|
||||
"url": "https://github.com/webmproject/libwebp.git"
|
||||
},
|
||||
{
|
||||
"commit": "1aadfad932c98c069a1204261b1856f81f3bc199",
|
||||
"dependencies": {},
|
||||
"id": "p57c0272208aae8db",
|
||||
"name": "libavif",
|
||||
"ref": "1aadfad932c98c069a1204261b1856f81f3bc199",
|
||||
"source": true,
|
||||
"url": "https://github.com/AOMediaCodec/libavif.git"
|
||||
},
|
||||
{
|
||||
"commit": "1b2f35b7b39df6fb9af7a52324b4b7cf18e98df2",
|
||||
"dependencies": {"libopus": "pe1fe9bbe80bf1d6d", "libsamplerate": "p0dd67588478f9a3e"},
|
||||
"dependency_refs": {"libopus": "ddbe48383984d56acd9e1ab6a090c54ca6b735a6", "libsamplerate": "c96f5e3de9c4488f4e6c97f59f5245f22fda22f7"},
|
||||
"id": "p59deb49c7f103127",
|
||||
"name": "audio",
|
||||
"ref": "1b2f35b7b39df6fb9af7a52324b4b7cf18e98df2",
|
||||
"url": "https://github.com/ziranlang/audio.git"
|
||||
},
|
||||
{
|
||||
"commit": "bd278217e2bac754d868b3d6502eac4257658d4b",
|
||||
"dependencies": {"dav1d": "pb24767b9eb34d961", "image_codec": "p69c0e968ae5735d9", "libaom": "p74ab3cb6eb3b86fa"},
|
||||
"dependency_refs": {"dav1d": "54706fc6bc0cdecab7e9593974a4039cc038fca7", "image_codec": "360553150917f352e49e1beb78917370792ccaef", "libaom": "b141d9c45db236335351c8a4b2a14b3ade27c937"},
|
||||
"id": "p5d7d12505a42f7b3",
|
||||
"name": "av1",
|
||||
"ref": "bd278217e2bac754d868b3d6502eac4257658d4b",
|
||||
"url": "https://github.com/ziranlang/av1.git"
|
||||
},
|
||||
{
|
||||
"commit": "b38054fcb0afd699c8442d050b323e361b90f027",
|
||||
"dependencies": {"kryon": "p1e41122208040e0f"},
|
||||
"dependency_refs": {"kryon": "199b51c97c2aba67367308c3dc98126692b476a8"},
|
||||
"id": "p60c5d0ebd34a5724",
|
||||
"name": "practices",
|
||||
"ref": "b38054fcb0afd699c8442d050b323e361b90f027",
|
||||
"url": "https://github.com/waozixyz/practices.git"
|
||||
},
|
||||
{
|
||||
"commit": "360553150917f352e49e1beb78917370792ccaef",
|
||||
"dependencies": {},
|
||||
"id": "p69c0e968ae5735d9",
|
||||
"name": "image-codec",
|
||||
"ref": "360553150917f352e49e1beb78917370792ccaef",
|
||||
"url": "https://github.com/ziranlang/image-codec.git"
|
||||
},
|
||||
{
|
||||
"commit": "b141d9c45db236335351c8a4b2a14b3ade27c937",
|
||||
"dependencies": {},
|
||||
"id": "p74ab3cb6eb3b86fa",
|
||||
"name": "libaom",
|
||||
"ref": "b141d9c45db236335351c8a4b2a14b3ade27c937",
|
||||
"source": true,
|
||||
"url": "https://aomedia.googlesource.com/aom"
|
||||
},
|
||||
{
|
||||
"commit": "2611e727e226a2af22dfb7f10bf224bd2f1a3d30",
|
||||
"dependencies": {"av1": "p5d7d12505a42f7b3", "dav1d": "pb24767b9eb34d961", "image_codec": "p69c0e968ae5735d9", "libaom": "p74ab3cb6eb3b86fa", "libavif": "p57c0272208aae8db"},
|
||||
"dependency_refs": {"av1": "bd278217e2bac754d868b3d6502eac4257658d4b", "dav1d": "54706fc6bc0cdecab7e9593974a4039cc038fca7", "image_codec": "360553150917f352e49e1beb78917370792ccaef", "libaom": "b141d9c45db236335351c8a4b2a14b3ade27c937", "libavif": "1aadfad932c98c069a1204261b1856f81f3bc199"},
|
||||
"id": "pb203529d803e73a4",
|
||||
"name": "avif",
|
||||
"ref": "2611e727e226a2af22dfb7f10bf224bd2f1a3d30",
|
||||
"url": "https://github.com/ziranlang/avif.git"
|
||||
},
|
||||
{
|
||||
"commit": "54706fc6bc0cdecab7e9593974a4039cc038fca7",
|
||||
"dependencies": {},
|
||||
"id": "pb24767b9eb34d961",
|
||||
"name": "dav1d",
|
||||
"ref": "54706fc6bc0cdecab7e9593974a4039cc038fca7",
|
||||
"source": true,
|
||||
"url": "https://github.com/videolan/dav1d.git"
|
||||
},
|
||||
{
|
||||
"commit": "fafa2cea97d0cb379d832086ba45a989fa6f9c8e",
|
||||
"dependencies": {},
|
||||
"id": "pcc7aa76725f2fb2f",
|
||||
"name": "raylib",
|
||||
"ref": "fafa2cea97d0cb379d832086ba45a989fa6f9c8e",
|
||||
"source": true,
|
||||
"url": "https://github.com/raysan5/raylib.git"
|
||||
},
|
||||
{
|
||||
"commit": "ddbe48383984d56acd9e1ab6a090c54ca6b735a6",
|
||||
"dependencies": {},
|
||||
"id": "pe1fe9bbe80bf1d6d",
|
||||
"name": "libopus",
|
||||
"ref": "ddbe48383984d56acd9e1ab6a090c54ca6b735a6",
|
||||
"source": true,
|
||||
"url": "https://github.com/xiph/opus.git"
|
||||
}
|
||||
],
|
||||
"root": {
|
||||
"dependencies": {"kryon": "p1e41122208040e0f", "practices": "p60c5d0ebd34a5724"},
|
||||
"dependency_refs": {"kryon": "199b51c97c2aba67367308c3dc98126692b476a8", "practices": "b38054fcb0afd699c8442d050b323e361b90f027"},
|
||||
"name": "figure_preview"
|
||||
},
|
||||
"toolchain": {
|
||||
"commit": "2313b49cb005610853faeec46447fc38578a2a15",
|
||||
"ref": "2313b49cb005610853faeec46447fc38578a2a15",
|
||||
"url": "https://github.com/ziranlang/ziran.git"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
[package]
|
||||
name = "figure_preview"
|
||||
entry = "figure_preview.zi"
|
||||
module_roots = ["."]
|
||||
links = ["SDL2", "pangocairo-1.0", "pango-1.0", "cairo", "fontconfig", "freetype", "gio-2.0", "gobject-2.0", "glib-2.0", "X11", "EGL", "GLESv2", "GLX", "z", "m", "pthread"]
|
||||
|
||||
[toolchain]
|
||||
git = "https://github.com/ziranlang/ziran.git"
|
||||
ref = "2313b49cb005610853faeec46447fc38578a2a15"
|
||||
|
||||
[dependencies.kryon]
|
||||
git = "https://github.com/kryonlabs/kryon.git"
|
||||
ref = "199b51c97c2aba67367308c3dc98126692b476a8"
|
||||
|
||||
# The shared figure and its media (anatomy, textures, Tai Chi course).
|
||||
[dependencies.practices]
|
||||
git = "https://github.com/waozixyz/practices.git"
|
||||
ref = "b38054fcb0afd699c8442d050b323e361b90f027"
|
||||
@@ -1,47 +1,53 @@
|
||||
# Open practice figure work — 2026-11-17
|
||||
|
||||
The owner asked for the anatomical watercolor figures in the real Breeze app
|
||||
(Ziran + Kryon, no raylib) for Tai Chi, Workout and astral practice. The
|
||||
three.js studies in `design/astral-projection/three/` are the look reference
|
||||
only. The shared figure media is in practices `shared/watercolor/`:
|
||||
MakeHuman CC0 surface, MakeHuman CC0 default rig weights folded onto 46
|
||||
bones, clean plane-cut hems, and paper/pigment/wash textures.
|
||||
The owner wants one perfected character used everywhere: Tai Chi, Sun
|
||||
Salutation, Workout and astral projection, native on Ziran and Kryon
|
||||
without raylib. The character is the practices package's `figure/` (pinned
|
||||
practices b38054fc: female MakeHuman CC0 surface, dual-quaternion rig,
|
||||
watercolor painter, floor shadow, Ziran tests). The live tuning tool is
|
||||
`design/figure-preview/` (see its README). The three.js studies in
|
||||
`design/astral-projection/three/` are look references only.
|
||||
|
||||
- Shared Kryon repin. Breeze pins Kryon 3f724419, which has no
|
||||
`kryon/scene_skin` or `kryon/watercolor`. The repin must move plot, entity,
|
||||
game2d, css and apps to the same Kryon, and move
|
||||
`src/platform/audio_runtime.zi` and `radio_native.zi` from Kryon's removed
|
||||
mixer/sink/decoders to Ziran std audio. It is coordinated with the
|
||||
raylib-free desktop work (`plans/2026-11-15-breeze-desktop-without-raylib.md`).
|
||||
The coordinator decides who owns that switch.
|
||||
- Connect the painters after the repin, all under `DESKTOP_HOST`:
|
||||
- Tai Chi: `TaiChiPaintFlat` call sites in `tai_chi_draw.zi`, through
|
||||
`PracticeWatercolorDraw`.
|
||||
- Workout: its solved pose through the same painter.
|
||||
- Astral: `AstralSceneDraw`/`AstralPreviewDraw` through
|
||||
`AstralWatercolorDraw` (`apps/practice/astral_watercolor_view.zi`), which
|
||||
composes the still physical body, translucent double, cord, rope and
|
||||
attention marks from `astral_technique.zi`.
|
||||
Keep existing timelines, cues, narration, pause/resume and history.
|
||||
- Native after frames on private Xvfb, matching `build/practice-compare/before/`
|
||||
(Tai Chi 9 s, full form 131 s, astral 60 s, Workout ready). Then labelled
|
||||
`side-by-side/` images, own inspection, and Gwenview for the owner. Retake
|
||||
the full-form before frame, which shows the voice-guidance offer instead of
|
||||
the figure.
|
||||
- Local suites on the integrated build: `make astral-projection-test` (now
|
||||
includes `tests/astral_technique_test.sh`), Tai Chi and Workout tests,
|
||||
`tests/practice_human_test.sh`, build laws, package/size checks, chooser
|
||||
previews, captions and cue boundaries. Bundled delivery of
|
||||
`assets/practices/shared/watercolor/` from the common Practices pack is
|
||||
configured in `scripts/prepare-package-assets.py`; verify it in the
|
||||
built app.
|
||||
- Performance: the painter re-renders and re-finishes the body on every pose
|
||||
change. Measure on a real phone GPU; shell GL here is llvmpipe.
|
||||
- Owner review of the native characters, watercolor look, Tai Chi motion and
|
||||
the six astral techniques.
|
||||
- Narration: the initial audit found all 88 cue texts in each of ten locales
|
||||
but only 407/880 female clips (cs 6, de 86, en 86, es 78, fr 37, ja 5,
|
||||
ko 6, pt 88, ru 10, zh 5). Complete and listen through the owning
|
||||
- Kryon desktop presentation: at Kryon 199b51c9 the desktop loop keeps
|
||||
drawing requested frames, but stops showing them once there is no input
|
||||
(a 24-line repro was sent to the coordinator for the Kryon lane). The
|
||||
preview's hands-off playback freezes until the pointer moves. Repin the
|
||||
preview once Kryon is fixed. The same Kryon compares images by texture id
|
||||
only, so `BitmapImageUpdate` on one texture never repaints; the preview
|
||||
alternates two textures.
|
||||
- Owner review of the live preview and of
|
||||
`build/practice-compare/side-by-side/` (current flat figure beside the new
|
||||
character, same moments and cameras), then tune from that feedback.
|
||||
- Character work still open:
|
||||
- The top and trousers hug the body; the flat figure's loose tunic needs
|
||||
cloth geometry (a skirted tunic shell over the hips).
|
||||
- Relaxed and open hands still read as claws in some Tai Chi palms.
|
||||
- The face is plain at practice sizes.
|
||||
- Each practice's look colours come from its flat look; settle one
|
||||
palette.
|
||||
- Astral session timings: practices' `astral_projection/sessions/*.json`
|
||||
are another task's uncommitted files. Until they are pushed, a pinned
|
||||
preview plays the six techniques with steps evenly 20 seconds apart.
|
||||
- Breeze adoption, after the shared Kryon repin (lane -7, plot, entity,
|
||||
game2d, css and apps on one Kryon; Breeze audio on Ziran std audio):
|
||||
- Make Breeze's `practices` dependency a package pinned at or after
|
||||
b38054fc.
|
||||
- Move `PreviewJoints` (solver joints to `FigureJoints`) beside the
|
||||
solver.
|
||||
- Paint Tai Chi, Sun Salutation, Workout and astral with `FigurePaint`
|
||||
under `DESKTOP_HOST`, keeping timelines, cues, narration, pause/resume
|
||||
and history. Bundle `assets/practices/shared/watercolor/` from the
|
||||
common Practices pack (the `scripts/prepare-package-assets.py` hunk is
|
||||
ready).
|
||||
- Native app after-frames for those painters, matching
|
||||
`build/practice-compare/before/`. Retake the full-form before frame: it
|
||||
shows the voice-guidance offer instead of the figure.
|
||||
- Performance: the painter re-skins and re-finishes on every pose change
|
||||
(watercolor finish and shadow on the CPU). Measure on a real phone GPU;
|
||||
shell GL here is llvmpipe.
|
||||
- Narration: the initial audit found all 88 cue texts in each of ten
|
||||
locales but only 407/880 female clips (cs 6, de 86, en 86, es 78, fr 37,
|
||||
ja 5, ko 6, pt 88, ru 10, zh 5). Complete and listen through the owning
|
||||
narration task; legacy cues do not fill the new exercise keys.
|
||||
- Refresh the three.js caption snapshot if the practices task changes session
|
||||
cues or text. Keep `build/astral-compare/before/` as the baseline.
|
||||
- Refresh the three.js caption snapshot if the practices task changes
|
||||
session cues or text. Keep `build/astral-compare/before/` as the baseline.
|
||||
@@ -23,6 +23,15 @@ for line in gzip.open(source_file, 'rt'):
|
||||
elif line.startswith('f '):
|
||||
groups[group].append([int(item.split('/')[0]) - 1 for item in line.split()[1:]])
|
||||
all_vertices = np.asarray(vertices, dtype=np.float64)
|
||||
# MakeHuman's base mesh is its gender-neutral average. Her body and face take
|
||||
# MakeHuman's own CC0 young-adult female macro shape: the three ethnic
|
||||
# female-young targets in equal shares, as MakeHuman mixes them by default.
|
||||
for race in ('african', 'asian', 'caucasian'):
|
||||
target = ROOT / f'design/astral-projection/three/assets/makehuman-{race}-female-young.target.gz'
|
||||
for line in gzip.open(target, 'rt'):
|
||||
if line.strip() and not line.startswith('#'):
|
||||
index, dx, dy, dz = line.split()
|
||||
all_vertices[int(index)] += np.array([float(dx), float(dy), float(dz)])/3
|
||||
ids = sorted({index for face in groups['body'] for index in face})
|
||||
lookup = {old: index for index, old in enumerate(ids)}
|
||||
body = all_vertices[ids]
|
||||
@@ -158,6 +167,56 @@ for index, influence in enumerate(gathered):
|
||||
joints[index, slot] = target
|
||||
weights[index, slot] = weight/total
|
||||
|
||||
# MakeHuman hands the groin and buttock from pelvis to thigh within a few
|
||||
# millimetres, which tears the surface open in a forward fold or a deep
|
||||
# stance. Diffuse that hand-over across the surface around the hips, and the
|
||||
# shoulder's chest-to-arm hand-over the same way for arms raised overhead;
|
||||
# other bones' shares, the hands and the fingers stay as rigged.
|
||||
face_triangles = np.array([[lookup[face[0]], lookup[face[at]], lookup[face[at+1]]]
|
||||
for face in groups['body'] for at in range(1, len(face)-1)], dtype=np.int64)
|
||||
pairs = np.concatenate([face_triangles[:, [0, 1]], face_triangles[:, [1, 2]], face_triangles[:, [2, 0]]])
|
||||
pairs = np.unique(np.concatenate([pairs, pairs[:, ::-1]]), axis=0)
|
||||
degree = np.bincount(pairs[:, 0], minlength=len(ids)).astype(np.float64)
|
||||
dense = np.zeros((len(ids), len(bones)))
|
||||
for slot in range(4):
|
||||
np.add.at(dense, (np.arange(len(ids)), joints[:, slot]), weights[:, slot])
|
||||
arm_share = dense[:, [at for at, item in enumerate(bones) if 5 <= item['role'] <= 7]].sum(axis=1)
|
||||
|
||||
def diffuse(members, zone, steps):
|
||||
shares = dense[:, members]
|
||||
mass = shares.sum(axis=1)
|
||||
active = zone & (mass > 0.02)
|
||||
for _ in range(steps):
|
||||
total = np.zeros_like(shares)
|
||||
np.add.at(total, pairs[:, 0], shares[pairs[:, 1]])
|
||||
mean = total/np.maximum(degree, 1)[:, None]
|
||||
mixed = shares*0.5+mean*0.5
|
||||
scale = mass/np.maximum(mixed.sum(axis=1), 1e-12)
|
||||
shares[active] = mixed[active]*scale[active, None]
|
||||
dense[:, members] = shares
|
||||
|
||||
hips_y = (joint('l-upper-leg')[1]+joint('r-upper-leg')[1])/2
|
||||
hip_zone = (positions[:, 1] > hips_y-0.24) & (positions[:, 1] < hips_y+0.07) & (arm_share < 0.01)
|
||||
thighs = [4+18, 4+21+18]
|
||||
diffuse([0]+thighs, hip_zone, 120)
|
||||
# The thighs never reach above the hip crease: a lifted or spread leg must
|
||||
# not drag the waist out with it.
|
||||
fade = np.clip((hips_y+0.07-positions[:, 1])/0.09, 0, 1)
|
||||
for thigh in thighs:
|
||||
removed = dense[:, thigh]*(1-fade)
|
||||
dense[:, thigh] -= removed
|
||||
dense[:, 0] += removed
|
||||
for side in (0, 1):
|
||||
shoulder = joint(('l' if side == 0 else 'r')+'-shoulder')
|
||||
near = np.linalg.norm(positions-shoulder, axis=1) < 0.16
|
||||
diffuse([1, 2, 4+side*21], near & (arm_share < 0.01), 40)
|
||||
for index in range(len(ids)):
|
||||
strongest = np.argsort(-dense[index])[:4]
|
||||
shares = dense[index, strongest]
|
||||
shares[shares < 0.004] = 0.0
|
||||
joints[index] = strongest
|
||||
weights[index] = shares/shares.sum()
|
||||
|
||||
# The middle waist belongs to the trunk even when a hand passes near it.
|
||||
waist = (positions[:, 1] > joint('pelvis')[1]+0.06) & (positions[:, 1] < joint('spine-3')[1]) & (np.abs(positions[:, 0]) < 0.25)
|
||||
arm_roles = np.array([4 <= item['role'] <= 7 for item in bones])
|
||||
@@ -186,6 +245,21 @@ head = joint('head')
|
||||
cuffs = [abs(joint(prefix+'-hand')[0])-0.025 for prefix in ('l', 'r')]
|
||||
ankles = [joint(prefix+'-ankle')[1]+0.02 for prefix in ('l', 'r')]
|
||||
|
||||
eye_height = joint('l-eye')[1]
|
||||
|
||||
def hairline(points):
|
||||
"""Positive on the hair: a hairline high on the forehead, lower over
|
||||
the temples, behind the ears and down to the nape; the ears stay bare."""
|
||||
points = np.atleast_2d(points)
|
||||
x, y, z = points[:, 0], points[:, 1], points[:, 2]
|
||||
turn = np.degrees(np.arctan2(np.abs(x), z-0.02))
|
||||
height = eye_height+np.interp(turn, [0, 20, 45, 65, 85, 105, 125, 180],
|
||||
[0.064, 0.062, 0.052, 0.034, 0.008, -0.014, -0.045, -0.080])
|
||||
value = y-height
|
||||
ears = (y < eye_height+0.002) & (np.abs(x) > 0.070)
|
||||
value = np.where(ears, np.minimum(value, 0.070-np.abs(x)), value)
|
||||
return np.where(y < 1.44, -1.0, value)
|
||||
|
||||
def region_of(points):
|
||||
points = np.atleast_2d(points)
|
||||
x, y, z = points[:, 0], points[:, 1], points[:, 2]
|
||||
@@ -199,23 +273,26 @@ def region_of(points):
|
||||
# Hands hang below the hips in the bind pose; only arms reach this wide.
|
||||
regions[(np.abs(x) > cuff) & (y > 0.5)] = 0
|
||||
regions[y < ankle] = 0
|
||||
regions[(y > head[1]+0.055) | ((y > head[1]-0.015) & (z < head[2]-0.015))] = 3
|
||||
regions[hairline(points) > 0] = 3
|
||||
return regions
|
||||
|
||||
# Clean painted hems: split each triangle that crosses a region boundary
|
||||
# exactly along the boundary's plane, then give every region its own copy
|
||||
# of the shared hem vertices. Surface and skin stay continuous.
|
||||
cuts = [(1, hip_height-0.04), (1, neck_height-0.04), (1, neck_height+0.025),
|
||||
(0, 0.115), (0, -0.115), (1, head[1]+0.055), (1, head[1]-0.015), (2, head[2]-0.015)]
|
||||
cuts += [(0, cuff) for cuff in cuffs] + [(0, -cuff) for cuff in cuffs] + [(1, ankle) for ankle in ankles]
|
||||
def plane(axis, value):
|
||||
return lambda points: np.atleast_2d(points)[:, axis]-value
|
||||
|
||||
planes = [(1, hip_height-0.04), (1, neck_height-0.04), (1, neck_height+0.025), (0, 0.115), (0, -0.115)]
|
||||
planes += [(0, cuff) for cuff in cuffs] + [(0, -cuff) for cuff in cuffs] + [(1, ankle) for ankle in ankles]
|
||||
cuts = [(('plane',)+item, plane(*item)) for item in planes] + [(('hairline',), hairline)]
|
||||
points, skin_joints, skin_weights = list(positions), list(joints), list(weights)
|
||||
surface_normals = list(normals)
|
||||
edges = {}
|
||||
|
||||
def hem_point(a, b, axis, value):
|
||||
key = (min(a, b), max(a, b), axis, value)
|
||||
def hem_point(a, b, name, cut):
|
||||
key = (min(a, b), max(a, b), name)
|
||||
if key not in edges:
|
||||
da, db = points[a][axis]-value, points[b][axis]-value
|
||||
da, db = float(cut(points[a])[0]), float(cut(points[b])[0])
|
||||
t = da/(da-db)
|
||||
points.append(points[a]+(points[b]-points[a])*t)
|
||||
normal = surface_normals[a]*(1-t)+surface_normals[b]*t
|
||||
@@ -232,11 +309,11 @@ def hem_point(a, b, axis, value):
|
||||
return edges[key]
|
||||
|
||||
faces = [list(face) for face in triangles]
|
||||
for axis, value in cuts:
|
||||
for name, cut in cuts:
|
||||
split = []
|
||||
for face in faces:
|
||||
corners = np.array([points[at] for at in face])
|
||||
distance = corners[:, axis]-value
|
||||
distance = cut(corners)
|
||||
if len(set(region_of(corners))) == 1 or not (np.any(distance > 1e-7) and np.any(distance < -1e-7)):
|
||||
split.append(face)
|
||||
continue
|
||||
@@ -245,12 +322,12 @@ for axis, value in cuts:
|
||||
# One corner lies on the plane: cut the opposite edge once.
|
||||
on = int(np.where(side == 0)[0][0])
|
||||
a, b, c = face[on], face[(on+1) % 3], face[(on+2) % 3]
|
||||
middle = hem_point(b, c, axis, value)
|
||||
middle = hem_point(b, c, name, cut)
|
||||
split += [[a, b, middle], [a, middle, c]]
|
||||
continue
|
||||
lone = int([at for at in range(3) if list(side).count(side[at]) == 1][0])
|
||||
a, b, c = face[lone], face[(lone+1) % 3], face[(lone+2) % 3]
|
||||
ab, ac = hem_point(a, b, axis, value), hem_point(a, c, axis, value)
|
||||
ab, ac = hem_point(a, b, name, cut), hem_point(a, c, name, cut)
|
||||
split += [[a, ab, ac], [ab, b, c], [ab, c, ac]]
|
||||
faces = split
|
||||
points = np.array(points)
|
||||
@@ -279,6 +356,89 @@ joints = np.array(skin_joints)[source]
|
||||
weights = np.array(skin_weights)[source]
|
||||
uvs = np.column_stack((positions[:, 0]*3+0.5, positions[:, 1]*3))
|
||||
triangles = np.array(faces, dtype=np.int64)
|
||||
# The head. MakeHuman's own eyeballs sit in the sockets; a hair shell rises
|
||||
# from nothing at the hairline to a centimetre over the crown; a low bun sits
|
||||
# at the back. All follow the head bone alone. Beyond the four washes the
|
||||
# regions are 4 iris, 5 eye white, 6 lips and 7 brows.
|
||||
def outward_faces(vertices, faces, center):
|
||||
faces = np.array(faces, dtype=np.int64)
|
||||
normal = np.cross(vertices[faces[:, 1]]-vertices[faces[:, 0]], vertices[faces[:, 2]]-vertices[faces[:, 0]])
|
||||
flip = np.einsum('ij,ij->i', normal, vertices[faces].mean(axis=1)-center) < 0
|
||||
faces[flip] = faces[flip][:, ::-1]
|
||||
return faces
|
||||
|
||||
def vertex_normals(vertices, faces):
|
||||
result = np.zeros_like(vertices)
|
||||
face = np.cross(vertices[faces[:, 1]]-vertices[faces[:, 0]], vertices[faces[:, 2]]-vertices[faces[:, 0]])
|
||||
for corner in range(3):
|
||||
np.add.at(result, faces[:, corner], face)
|
||||
return result/np.maximum(np.linalg.norm(result, axis=1)[:, None], 1e-12)
|
||||
|
||||
extras = []
|
||||
hair_faces = triangles[np.all(regions[triangles] == 3, axis=1)]
|
||||
used = np.unique(hair_faces)
|
||||
depth = hairline(positions[used])
|
||||
crown = np.clip((positions[used, 1]-eye_height-0.02)/0.08, 0, 1)
|
||||
sides = np.clip(np.abs(positions[used, 0])/0.07, 0, 1)
|
||||
thickness = (0.008+0.006*crown+0.005*sides)*np.clip(depth/0.025, 0, 1)**0.6
|
||||
shell = positions[used]+normals[used]*thickness[:, None]
|
||||
remap = np.full(len(positions), -1, dtype=np.int64)
|
||||
remap[used] = np.arange(len(used))
|
||||
shell_faces = remap[hair_faces]
|
||||
extras.append((shell, vertex_normals(shell, shell_faces), np.full(len(shell), 3), shell_faces))
|
||||
rings, segments = 10, 18
|
||||
bun_center = np.array([0.0, eye_height+0.078, -0.056])
|
||||
bun_radii = np.array([0.040, 0.036, 0.033])
|
||||
units = np.array([[np.sin(np.pi*ring/rings)*np.cos(2*np.pi*at/segments), np.cos(np.pi*ring/rings),
|
||||
np.sin(np.pi*ring/rings)*np.sin(2*np.pi*at/segments)]
|
||||
for ring in range(rings+1) for at in range(segments)])
|
||||
bun = bun_center+units*bun_radii
|
||||
bun_faces = []
|
||||
for ring in range(rings):
|
||||
for at in range(segments):
|
||||
a, b = ring*segments+at, ring*segments+(at+1) % segments
|
||||
c, d = a+segments, b+segments
|
||||
if ring > 0:
|
||||
bun_faces.append([a, b, d])
|
||||
if ring < rings-1:
|
||||
bun_faces.append([a, d, c])
|
||||
bun_faces = outward_faces(bun, bun_faces, bun_center)
|
||||
extras.append((bun, vertex_normals(bun, bun_faces), np.full(len(bun), 3), bun_faces))
|
||||
for prefix in ('l', 'r'):
|
||||
indices = sorted({index for face in groups[f'helper-{prefix}-eye'] for index in face})
|
||||
eye_lookup = {old: at for at, old in enumerate(indices)}
|
||||
eye = (all_vertices[indices]-origin)*scale
|
||||
center = eye.mean(axis=0)
|
||||
eye_faces = outward_faces(eye, [[eye_lookup[face[0]], eye_lookup[face[at]], eye_lookup[face[at+1]]]
|
||||
for face in groups[f'helper-{prefix}-eye'] for at in range(1, len(face)-1)], center)
|
||||
gaze = joint(f'{prefix}-eye-target')-joint(f'{prefix}-eye')
|
||||
gaze /= np.linalg.norm(gaze)
|
||||
facing = (eye-center)/np.linalg.norm(eye-center, axis=1)[:, None] @ gaze
|
||||
extras.append((eye, vertex_normals(eye, eye_faces), np.where(facing > np.cos(np.radians(32)), 4, 5), eye_faces))
|
||||
# Brows arch over the eyes and the lips fill the mouth; both are painted on
|
||||
# the skin's own vertices, so their edges stay soft.
|
||||
x, y, z = positions[:, 0], positions[:, 1], positions[:, 2]
|
||||
for prefix in ('l', 'r'):
|
||||
eye = joint(prefix+'-eye')
|
||||
across = (x-eye[0])/0.023
|
||||
middle = eye[1]+0.017+0.004*(1-across**2)-0.002*np.sign(eye[0])*across
|
||||
brow = (np.abs(across) < 1) & (np.abs(y-middle) < 0.0024*(1.25-0.6*np.abs(across))) & (z > eye[2]-0.005)
|
||||
regions[brow & (regions == 0)] = 7
|
||||
mouth = joint('mouth')
|
||||
# MakeHuman's mouth joint is the jaw's pivot, level with the nose tip.
|
||||
lip_height = mouth[1]-0.027
|
||||
lips = ((x/0.021)**2+((y-lip_height)/0.0088)**2 < 1) & (z > 0.145)
|
||||
regions[lips & (regions == 0)] = 6
|
||||
head_index = [at for at, item in enumerate(bones) if item['role'] == 3][0]
|
||||
for vertices, vertex_normal, vertex_region, faces_of in extras:
|
||||
base = len(positions)
|
||||
positions = np.vstack([positions, vertices])
|
||||
normals = np.vstack([normals, vertex_normal])
|
||||
joints = np.vstack([joints, np.tile(np.array([head_index, 0, 0, 0], dtype=np.uint8), (len(vertices), 1))])
|
||||
weights = np.vstack([weights, np.tile(np.array([1.0, 0.0, 0.0, 0.0]), (len(vertices), 1))])
|
||||
regions = np.concatenate([regions, np.asarray(vertex_region, dtype=np.uint8)])
|
||||
triangles = np.vstack([triangles, np.asarray(faces_of, dtype=np.int64)+base])
|
||||
uvs = np.column_stack((positions[:, 0]*3+0.5, positions[:, 1]*3))
|
||||
quantized = np.rint(weights*65535).astype(np.int64)
|
||||
quantized[:, 0] += 65535-quantized.sum(axis=1)
|
||||
assert np.all(quantized >= 0) and np.all(quantized <= 65535)
|
||||
|
||||
Reference in new issue
Block a user