Files
aego/art/model.go
T
sanspie 50be5c04bc
ci-platforms / darwin amd64 smoke (push) Skipped
GitHub / linux amd64 native GitHub-hosted native CI: success
ci-platforms / windows amd64 smoke (push) Skipped
GitHub / windows amd64 native GitHub-hosted native CI: success
GitHub / darwin arm64 native GitHub-hosted native CI: success
GitHub / darwin amd64 native GitHub-hosted native CI: success
ci / checks (push) Failing after 1h21m34s
ci / native-authoring (push) Skipped
ci-platforms / darwin arm64 smoke (push) Skipped
github-native / gitea-pending (push) Skipped
github-native / darwin amd64 native (push) Skipped
github-native / linux amd64 native (push) Skipped
github-native / windows amd64 native (push) Skipped
github-native / darwin arm64 native (push) Skipped
github-native / gitea-result (push) Skipped
ci / build (amd64, linux, ubuntu-24.04) (push) Successful in 12m4s
ci / release (push) Skipped
Stage 12.5: Art Workspace and asset authoring
Add dockable Art tools, animation and previews, guarded asset workflows,
and the Web Asset Studio built on the shared Art Core. Expand English and
Russian documentation, interactive Try scenes, examples and editor icons.

Add audio waveform navigation, source analysis, guarded previews and a
browser Worker mixer. Preserve source changes and recovery with bounded
checks, and strengthen native, browser and interoperability CI.

Prepare version 0.12.5 and manually built native artifact candidates.
Fix the production site image demo build dependency.
Reuse immutable scene indices when capturing keyframes.
Wait for real Persist save/load completion in component tests.
Stabilize browser Game View captures outside pointer hover.
Aseprite interchange and persistent Audio EDL recovery remain limited;
the artifact workflow does not publish releases or change stable.
2026-11-15 10:37:50 +03:00

479 lines
14 KiB
Go

// Package art owns CPU pixel documents and reversible authoring operations.
// It has no dependency on an editor, graphics API, browser, or file system.
package art
import (
"crypto/rand"
"encoding/hex"
"errors"
"fmt"
"image"
"sync"
)
const TileSize = 16
type ID string
type Mode string
type Channel string
type LayerKind string
type Blend string
type Direction string
const (
RGBA Mode = "rgba"
Grayscale Mode = "grayscale"
Indexed Mode = "indexed"
Albedo Channel = "albedo"
Normal Channel = "normal"
Height Channel = "height"
Emission Channel = "emission"
Raster LayerKind = "raster"
Group LayerKind = "group"
Reference LayerKind = "reference"
BlendNormal Blend = "normal"
BlendMultiply Blend = "multiply"
BlendScreen Blend = "screen"
BlendAdd Blend = "add"
Forward Direction = "forward"
Reverse Direction = "reverse"
PingPong Direction = "ping-pong"
)
var (
ErrConflict = errors.New("art: document revision changed")
ErrClosed = errors.New("art: document is closed")
ErrLocked = errors.New("art: layer is locked")
ErrLimit = errors.New("art: document limit exceeded")
ErrDone = errors.New("art: operation is already finished")
)
type Color struct{ R, G, B, A uint8 }
func (c Color) packed() uint32 {
return uint32(c.R) | uint32(c.G)<<8 | uint32(c.B)<<16 | uint32(c.A)<<24
}
func unpack(v uint32) Color { return Color{uint8(v), uint8(v >> 8), uint8(v >> 16), uint8(v >> 24)} }
type Swatch struct {
Color Color `json:"color"`
Name string `json:"name,omitempty"`
}
type Canvas struct {
Width int `json:"width"`
Height int `json:"height"`
Mode Mode `json:"mode"`
Profile string `json:"profile"`
}
type Layer struct {
ID ID `json:"id"`
Parent ID `json:"parent,omitempty"`
Name string `json:"name"`
Kind LayerKind `json:"kind"`
Visible bool `json:"visible"`
Locked bool `json:"locked"`
AlphaLock bool `json:"alphaLock"`
Opacity uint8 `json:"opacity"`
Blend Blend `json:"blend"`
}
type Frame struct {
ID ID `json:"id"`
DurationMS int `json:"durationMS"`
}
type Cel struct {
ID ID `json:"id"`
Layer ID `json:"layer"`
Frame ID `json:"frame"`
Image ID `json:"image"`
Channel Channel `json:"channel"`
X int `json:"x"`
Y int `json:"y"`
Opacity uint8 `json:"opacity"`
}
type Tag struct {
ID ID `json:"id"`
Name string `json:"name"`
From ID `json:"from"`
To ID `json:"to"`
Direction Direction `json:"direction"`
}
type Slice struct {
ID ID `json:"id"`
Name string `json:"name"`
Frame ID `json:"frame,omitempty"`
Rect image.Rectangle `json:"rect"`
Pivot image.Point `json:"pivot"`
}
type Limits struct {
MaxDimension int
MaxCanvasPixels int
MaxLayers int
MaxFrames int
MaxCels int
MaxPixelBytes int64
MaxFileBytes int64
MaxHistoryBytes int64
MaxHistorySteps int
}
func DefaultLimits() Limits {
return Limits{4096, 4194304, 256, 1024, 262144, 256 << 20, 64 << 20, 64 << 20, 256}
}
func limitsOrDefault(l Limits) Limits {
d := DefaultLimits()
if l.MaxDimension > 0 {
d.MaxDimension = l.MaxDimension
}
if l.MaxCanvasPixels > 0 {
d.MaxCanvasPixels = l.MaxCanvasPixels
}
if l.MaxLayers > 0 {
d.MaxLayers = l.MaxLayers
}
if l.MaxFrames > 0 {
d.MaxFrames = l.MaxFrames
}
if l.MaxCels > 0 {
d.MaxCels = l.MaxCels
}
if l.MaxPixelBytes > 0 {
d.MaxPixelBytes = l.MaxPixelBytes
}
if l.MaxFileBytes > 0 {
d.MaxFileBytes = l.MaxFileBytes
}
if l.MaxHistoryBytes > 0 {
d.MaxHistoryBytes = l.MaxHistoryBytes
}
if l.MaxHistorySteps > 0 {
d.MaxHistorySteps = l.MaxHistorySteps
}
return d
}
type tile [TileSize * TileSize]uint32
type tileKey struct{ X, Y int }
type pixels struct {
Width, Height int
Tiles map[tileKey]*tile
}
func newPixels(w, h int) *pixels { return &pixels{w, h, make(map[tileKey]*tile)} }
func (p *pixels) at(x, y int) uint32 {
if x < 0 || y < 0 || x >= p.Width || y >= p.Height {
return 0
}
t := p.Tiles[tileKey{x / TileSize, y / TileSize}]
if t == nil {
return 0
}
return t[(y%TileSize)*TileSize+x%TileSize]
}
func (p *pixels) clone() *pixels {
q := newPixels(p.Width, p.Height)
for k, t := range p.Tiles {
q.Tiles[k] = t
}
return q
}
type state struct {
Canvas Canvas
Palette []Swatch
Layers []Layer
Frames []Frame
Cels []Cel
Tags []Tag
Slices []Slice
Images map[ID]*pixels
Properties map[string]string
}
func (s *state) clone() *state {
q := *s
q.Palette = append([]Swatch(nil), s.Palette...)
q.Layers = append([]Layer(nil), s.Layers...)
q.Frames = append([]Frame(nil), s.Frames...)
q.Cels = append([]Cel(nil), s.Cels...)
q.Tags = append([]Tag(nil), s.Tags...)
q.Slices = append([]Slice(nil), s.Slices...)
q.Images = make(map[ID]*pixels, len(s.Images))
for id, p := range s.Images {
q.Images[id] = p
}
q.Properties = make(map[string]string, len(s.Properties))
for k, v := range s.Properties {
q.Properties[k] = v
}
return &q
}
// Info is a detached metadata snapshot. IDs are strings, so the JS bridge cannot
// round an entity ID through an IEEE-754 number.
type Info struct {
ID string `json:"id"`
Revision uint64 `json:"revision"`
Canvas Canvas `json:"canvas"`
Palette []Swatch `json:"palette"`
Layers []Layer `json:"layers"`
Frames []Frame `json:"frames"`
Cels []Cel `json:"cels"`
Tags []Tag `json:"tags"`
Slices []Slice `json:"slices"`
Properties map[string]string `json:"properties"`
}
// FramePivot resolves the existing named pivot slices. A frame-specific pivot
// overrides the document-wide pivot regardless of their serialized order.
func (i Info) FramePivot(frame ID) (image.Point, bool) {
var global, specific image.Point
hasGlobal, hasSpecific := false, false
for _, slice := range i.Slices {
if slice.Name != "pivot" {
continue
}
if slice.Frame == "" {
global, hasGlobal = slice.Pivot, true
} else if slice.Frame == frame {
specific, hasSpecific = slice.Pivot, true
}
}
if hasSpecific {
return specific, true
}
return global, hasGlobal
}
type Document struct {
mu sync.Mutex
id string
revision uint64
next uint64
closed bool
limits Limits
current *state
}
func New(w, h int, mode Mode, lim Limits) (*Document, error) {
lim = limitsOrDefault(lim)
if w < 1 || h < 1 || w > lim.MaxDimension || h > lim.MaxDimension || int64(w)*int64(h) > int64(lim.MaxCanvasPixels) {
return nil, ErrLimit
}
if mode != RGBA && mode != Grayscale && mode != Indexed {
return nil, fmt.Errorf("art: unsupported color mode %q", mode)
}
var id [16]byte
if _, err := rand.Read(id[:]); err != nil {
return nil, err
}
s := &state{Canvas: Canvas{w, h, mode, "srgb"}, Palette: DefaultPalette(), Images: make(map[ID]*pixels), Properties: make(map[string]string)}
d := &Document{id: hex.EncodeToString(id[:]), revision: 1, limits: lim, current: s}
layer, frame, im, cel := d.allocate(), d.allocate(), d.allocate(), d.allocate()
s.Layers = []Layer{{ID: layer, Name: "Layer 1", Kind: Raster, Visible: true, Opacity: 255, Blend: BlendNormal}}
s.Frames = []Frame{{frame, 100}}
s.Images[im] = newPixels(w, h)
s.Cels = []Cel{{ID: cel, Layer: layer, Frame: frame, Image: im, Channel: Albedo, Opacity: 255}}
return d, nil
}
func DefaultPalette() []Swatch {
colors := []Color{{0, 0, 0, 0}, {24, 28, 42, 255}, {52, 62, 85, 255}, {98, 111, 137, 255}, {174, 187, 204, 255}, {240, 244, 248, 255}, {255, 105, 110, 255}, {232, 57, 81, 255}, {255, 174, 91, 255}, {255, 219, 110, 255}, {160, 220, 130, 255}, {64, 166, 131, 255}, {77, 195, 209, 255}, {70, 120, 208, 255}, {139, 116, 221, 255}, {224, 137, 207, 255}}
out := make([]Swatch, len(colors))
for i, c := range colors {
out[i] = Swatch{Color: c}
}
return out
}
func (d *Document) allocate() ID { d.next++; return ID(fmt.Sprintf("%016x", d.next)) }
func (d *Document) newID() ID { d.mu.Lock(); defer d.mu.Unlock(); return d.allocate() }
func (d *Document) Revision() uint64 { d.mu.Lock(); defer d.mu.Unlock(); return d.revision }
func info(id string, rev uint64, s *state) Info {
properties := make(map[string]string, len(s.Properties))
for key, value := range s.Properties {
properties[key] = value
}
return Info{id, rev, s.Canvas, append([]Swatch{}, s.Palette...),
append([]Layer{}, s.Layers...), append([]Frame{}, s.Frames...),
append([]Cel{}, s.Cels...), append([]Tag{}, s.Tags...),
append([]Slice{}, s.Slices...), properties}
}
func (d *Document) Info() Info {
d.mu.Lock()
defer d.mu.Unlock()
return info(d.id, d.revision, d.current)
}
func (d *Document) Close() { d.mu.Lock(); defer d.mu.Unlock(); d.closed = true; d.revision++ }
func (s *state) layer(id ID) (int, bool) {
for i := range s.Layers {
if s.Layers[i].ID == id {
return i, true
}
}
return 0, false
}
func (s *state) frame(id ID) (int, bool) {
for i := range s.Frames {
if s.Frames[i].ID == id {
return i, true
}
}
return 0, false
}
func (s *state) cel(id ID) (int, bool) {
for i := range s.Cels {
if s.Cels[i].ID == id {
return i, true
}
}
return 0, false
}
func (s *state) findCel(layer, frame ID, ch Channel) (int, bool) {
for i, c := range s.Cels {
if c.Layer == layer && c.Frame == frame && c.Channel == ch {
return i, true
}
}
return 0, false
}
func (s *state) isLocked(layer ID) bool {
for n := 0; layer != "" && n <= len(s.Layers); n++ {
i, ok := s.layer(layer)
if !ok {
return true
}
if s.Layers[i].Locked {
return true
}
layer = s.Layers[i].Parent
}
return layer != ""
}
func validChannel(ch Channel) bool {
return ch == Albedo || ch == Normal || ch == Height || ch == Emission
}
func validBlend(b Blend) bool {
return b == BlendNormal || b == BlendMultiply || b == BlendScreen || b == BlendAdd
}
func (s *state) validate(l Limits) error {
c := s.Canvas
if c.Width < 1 || c.Height < 1 || c.Width > l.MaxDimension || c.Height > l.MaxDimension || int64(c.Width)*int64(c.Height) > int64(l.MaxCanvasPixels) {
return ErrLimit
}
if c.Mode != RGBA && c.Mode != Grayscale && c.Mode != Indexed {
return fmt.Errorf("art: invalid color mode")
}
if c.Profile != "srgb" {
return fmt.Errorf("art: unsupported color profile %q", c.Profile)
}
if len(s.Layers) < 1 || len(s.Layers) > l.MaxLayers || len(s.Frames) < 1 || len(s.Frames) > l.MaxFrames || len(s.Cels) > l.MaxCels {
return ErrLimit
}
if len(s.Palette) < 1 || len(s.Palette) > 256 {
return fmt.Errorf("art: palette needs 1..256 entries")
}
if c.Mode == Indexed && s.Palette[0].Color.A != 0 {
return fmt.Errorf("art: indexed entry zero is reserved for transparency")
}
ids := make(map[ID]bool)
add := func(id ID) bool {
if id == "" || ids[id] {
return false
}
ids[id] = true
return true
}
for _, v := range s.Layers {
if !add(v.ID) || len(v.Name) > 1024 || !validBlend(v.Blend) || (v.Kind != Raster && v.Kind != Group && v.Kind != Reference) {
return fmt.Errorf("art: invalid layer")
}
p := v.Parent
for n := 0; p != ""; n++ {
if n >= len(s.Layers) || p == v.ID {
return fmt.Errorf("art: cyclic layer group")
}
i, ok := s.layer(p)
if !ok || s.Layers[i].Kind != Group {
return fmt.Errorf("art: invalid layer parent")
}
p = s.Layers[i].Parent
}
}
for _, v := range s.Frames {
if !add(v.ID) || v.DurationMS < 1 || v.DurationMS > 600000 {
return fmt.Errorf("art: invalid frame")
}
}
unique := make(map[[3]string]bool)
used := make(map[ID]bool)
imageChannels := make(map[ID]Channel)
for _, v := range s.Cels {
li, ok := s.layer(v.Layer)
if !ok || s.Layers[li].Kind == Group {
return fmt.Errorf("art: invalid cel layer")
}
if _, ok = s.frame(v.Frame); !ok {
return fmt.Errorf("art: invalid cel frame")
}
key := [3]string{string(v.Layer), string(v.Frame), string(v.Channel)}
if !add(v.ID) || !validChannel(v.Channel) || unique[key] || s.Images[v.Image] == nil {
return fmt.Errorf("art: invalid or duplicate cel")
}
unique[key] = true
if old, ok := imageChannels[v.Image]; ok && old != v.Channel {
return fmt.Errorf("art: one image cannot link different surface channels")
}
imageChannels[v.Image] = v.Channel
used[v.Image] = true
if v.X < -l.MaxDimension || v.X > l.MaxDimension || v.Y < -l.MaxDimension || v.Y > l.MaxDimension {
return ErrLimit
}
}
for _, v := range s.Tags {
a, ok := s.frame(v.From)
b, ok2 := s.frame(v.To)
if !add(v.ID) || !ok || !ok2 || a > b || len(v.Name) == 0 || len(v.Name) > 1024 || (v.Direction != Forward && v.Direction != Reverse && v.Direction != PingPong) {
return fmt.Errorf("art: invalid animation tag")
}
}
for _, v := range s.Slices {
if !add(v.ID) || len(v.Name) > 1024 {
return fmt.Errorf("art: invalid slice")
}
if v.Frame != "" {
if _, ok := s.frame(v.Frame); !ok {
return fmt.Errorf("art: invalid slice frame")
}
}
}
seenTiles := make(map[*tile]bool)
var bytes int64
for id, p := range s.Images {
if !add(id) || !used[id] {
return fmt.Errorf("art: invalid or orphan image")
}
if p.Width < 1 || p.Height < 1 || p.Width > l.MaxDimension || p.Height > l.MaxDimension || int64(p.Width)*int64(p.Height) > int64(l.MaxCanvasPixels) {
return ErrLimit
}
for key, t := range p.Tiles {
if t == nil || key.X < 0 || key.Y < 0 || key.X*TileSize >= p.Width || key.Y*TileSize >= p.Height {
return fmt.Errorf("art: invalid pixel tile")
}
if !seenTiles[t] {
seenTiles[t] = true
bytes += TileSize * TileSize * 4
if bytes > l.MaxPixelBytes {
return ErrLimit
}
}
}
}
if len(s.Properties) > 256 {
return ErrLimit
}
for k, v := range s.Properties {
if len(k) > 1024 || len(v) > 65536 {
return ErrLimit
}
}
return nil
}