Documentation: engine/docs assembles one registry from the script
bindings, the schema, module docs and module-owned script paths; problems
are reported as warnings at build time. Module registries record doc
sources and script module owners; diag.Codes lists every diagnostic code.
Project bootstrap: project.defaultSpace ("2d"/"3d"), EnsureDirs creates
the default folders when the editor opens a project (reported in the
console), prefabs/ is a pipeline root. Native builds drop -trimpath so
binding locations resolve inside native/.
Editor files: create scene/prefab/script from menus, move/rename/duplicate
/delete with undo, script package retargeting on move, open scenes and
script panels follow renames, Save As / Rename Scene prompts, scene
picker, startup scene. Scoped shortcuts fall back to the global command
when disabled; Save As is Ctrl+Shift+S, Save All Ctrl+Alt+S.
Script editor: Go to Implementation (stub → native/ source), host
definitions always resolve to stubs, bracket match/mismatch states,
rainbow brackets (persisted), mono code font (ui-mono atlases, per-command
fonts in draw.List, PushFont/PopFont restored by Mark/Restore).
Tests: langsvc definition/implementation, bracket states, dispatch
fallback, script renames, font stack, editor file-op integration, golden
mono glyph and bracket references; depcheck rule for engine/docs.
Docs pipeline: engine, render2d and script/engine ship their own res/docs;
keyword hover text comes from the registry through manifest.Keywords;
project script symbols join the registry; aego docs export|check|build|
serve, --tool docs in native binaries, aego check --explain; app/docstool
and the tools/gendocs module (goldmark) build the static site.
Playground: app/playground + cmd/aego-playground (js/wasm, 3.3 MB gzip)
compile, highlight and run scripts in the browser; run blocks in the
language docs become examples. engine/builtin/headless is the module set
without render3d; workspace.Config.FS; StubFor/StubPaths; backends and the
script importer drop out of js builds.
VM: one frame pointer in the interpreter loop, direct host calls, panic
recovery once per run instead of per host call (Update2k -19%,
Schedule10k -24% against the previous head). bench-build/compare/profile
run pre-built, pinned, interleaved binaries.
Editor: structural bracket levels and current-block highlight, indent
guides, occurrence highlighting with write marks, multi-format clipboard
(copy/cut/paste assets, paste images as sprites or textures). gl33 probes
a renderable depth format and reports framebuffer failures by stage.
7 E:
- project templates empty/2d/2.5d/3d, app/projects as the single creation path (D148)
- launcher and recent projects (D149)
- orthographic Camera3D and Scene View (D150)
- reference states in the Inspector, ids.Short (D151)
- sceneio remaps node references when loading without KeepIDs (D152)
- exported ComponentRef<T> (D153)
- aego icons via module.Audit (D146)
140 lines
3.3 KiB
Go
140 lines
3.3 KiB
Go
package widgets
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"aego/core/mathx"
|
|
"aego/ui/core"
|
|
)
|
|
|
|
func textY(c *core.Context, r mathx.Rect) float32 {
|
|
h := c.TextSize("M").Y
|
|
return r.Y + (r.H-h)/2
|
|
}
|
|
|
|
func Label(c *core.Context, s string) {
|
|
r := c.Cursor().Next(0)
|
|
c.List().Text(s, mathx.Vec2{X: r.X, Y: textY(c, r)}, c.Theme.Text)
|
|
}
|
|
|
|
func Labelf(c *core.Context, format string, a ...any) {
|
|
Label(c, fmt.Sprintf(format, a...))
|
|
}
|
|
|
|
func LabelDim(c *core.Context, s string) {
|
|
r := c.Cursor().Next(0)
|
|
c.List().Text(s, mathx.Vec2{X: r.X, Y: textY(c, r)}, c.Theme.TextDim)
|
|
}
|
|
|
|
func LabelWrapped(c *core.Context, s string, dim bool) {
|
|
width := c.Cursor().W
|
|
color := c.Theme.Text
|
|
if dim {
|
|
color = c.Theme.TextDim
|
|
}
|
|
for len(s) > 0 {
|
|
line := fitLine(c, s, width)
|
|
r := c.Cursor().Next(0)
|
|
c.List().Text(line, mathx.Vec2{X: r.X, Y: textY(c, r)}, color)
|
|
s = strings.TrimLeft(s[len(line):], " ")
|
|
}
|
|
}
|
|
|
|
func WrapLines(c *core.Context, s string, width float32) []string {
|
|
var out []string
|
|
for len(s) > 0 {
|
|
line := fitLine(c, s, width)
|
|
out = append(out, line)
|
|
s = strings.TrimLeft(s[len(line):], " ")
|
|
}
|
|
return out
|
|
}
|
|
|
|
func fitLine(c *core.Context, s string, width float32) string {
|
|
if c.TextSize(s).X <= width {
|
|
return s
|
|
}
|
|
cut := 0
|
|
for i := 0; i < len(s); i++ {
|
|
if s[i] != ' ' {
|
|
continue
|
|
}
|
|
if c.TextSize(s[:i]).X > width {
|
|
break
|
|
}
|
|
cut = i
|
|
}
|
|
if cut > 0 {
|
|
return s[:cut]
|
|
}
|
|
for i := 1; i <= len(s); i++ {
|
|
if c.TextSize(s[:i]).X > width {
|
|
return s[:max(1, i-1)]
|
|
}
|
|
}
|
|
return s
|
|
}
|
|
|
|
func Separator(c *core.Context) {
|
|
cur := c.Cursor()
|
|
r := cur.Next(c.Theme.Spacing)
|
|
c.List().Rect(mathx.Rect{X: r.X, Y: r.Y + r.H/2, W: r.W, H: 1}, c.Theme.Border)
|
|
}
|
|
|
|
func Button(c *core.Context, label string) bool {
|
|
id := c.ID(label)
|
|
r := c.Cursor().Next(0)
|
|
clicked := c.Clicked(id, r)
|
|
c.List().Rect(r, c.WidgetColor(id))
|
|
c.List().RectOutline(r, c.Theme.Border, 1)
|
|
size := c.TextSize(label)
|
|
c.List().Text(label, mathx.Vec2{X: r.X + (r.W-size.X)/2, Y: textY(c, r)}, c.Theme.Text)
|
|
return clicked
|
|
}
|
|
|
|
func Checkbox(c *core.Context, label string, v *bool) bool {
|
|
id := c.ID(label)
|
|
r := c.Cursor().Next(0)
|
|
box := mathx.Rect{X: r.X, Y: r.Y + 2, W: r.H - 4, H: r.H - 4}
|
|
changed := false
|
|
if c.Clicked(id, r) {
|
|
*v = !*v
|
|
changed = true
|
|
}
|
|
c.List().Rect(box, c.WidgetColor(id))
|
|
c.List().RectOutline(box, c.Theme.Border, 1)
|
|
if *v {
|
|
inner := mathx.Rect{X: box.X + 3, Y: box.Y + 3, W: box.W - 6, H: box.H - 6}
|
|
c.List().Rect(inner, c.Theme.Accent)
|
|
}
|
|
c.List().Text(label, mathx.Vec2{X: r.X + r.H + 4, Y: textY(c, r)}, c.Theme.Text)
|
|
return changed
|
|
}
|
|
|
|
func Slider(c *core.Context, label string, v *float32, lo, hi float32) bool {
|
|
id := c.ID(label)
|
|
r := c.Cursor().Next(0)
|
|
if hi <= lo {
|
|
hi = lo + 1
|
|
}
|
|
changed := false
|
|
if delta, dragging := c.Drag(id, r); dragging {
|
|
if delta.X != 0 {
|
|
*v = mathx.Clamp(*v+delta.X/r.W*(hi-lo), lo, hi)
|
|
changed = true
|
|
}
|
|
}
|
|
t := mathx.Clamp((*v-lo)/(hi-lo), 0, 1)
|
|
c.List().Rect(r, c.Theme.Widget)
|
|
c.List().Rect(mathx.Rect{X: r.X, Y: r.Y, W: r.W * t, H: r.H}, c.WidgetColor(id))
|
|
c.List().RectOutline(r, c.Theme.Border, 1)
|
|
buf := make([]byte, 0, 32)
|
|
buf = append(buf, label...)
|
|
buf = append(buf, ' ')
|
|
buf = strconv.AppendFloat(buf, float64(*v), 'f', 2, 32)
|
|
c.List().Text(string(buf), mathx.Vec2{X: r.X + 4, Y: textY(c, r)}, c.Theme.Text)
|
|
return changed
|
|
}
|