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
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.
479 lines
14 KiB
Go
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
|
|
}
|