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.
514 lines
14 KiB
Go
514 lines
14 KiB
Go
package art
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"image"
|
|
"reflect"
|
|
|
|
"aego/art/internal/aseprite"
|
|
)
|
|
|
|
// ImportDiagnostic identifies discarded non-pixel metadata. Unsupported visual
|
|
// semantics are errors, not a best-effort image presented as a lossless import.
|
|
type ImportDiagnostic struct {
|
|
Code string `json:"code"`
|
|
Frame int `json:"frame"`
|
|
Chunk uint16 `json:"chunk"`
|
|
Message string `json:"message"`
|
|
}
|
|
|
|
// Keep parsing vocabulary local to the Art adapter while wire mechanics live
|
|
// in the internal codec; no Art document or state crosses that boundary.
|
|
type aseReader struct{ *aseprite.Reader }
|
|
|
|
func (r *aseReader) take(n int) []byte { return r.Take(n) }
|
|
func (r *aseReader) u8() uint8 { return r.U8() }
|
|
func (r *aseReader) u16() uint16 { return r.U16() }
|
|
func (r *aseReader) u32() uint32 { return r.U32() }
|
|
func (r *aseReader) i16() int { return r.I16() }
|
|
func (r *aseReader) i32() int { return r.I32() }
|
|
func (r *aseReader) text() string { return r.Text() }
|
|
|
|
type aseLayer struct {
|
|
flags uint16
|
|
kind, level int
|
|
blend Blend
|
|
opacity uint8
|
|
name string
|
|
}
|
|
type aseCel struct {
|
|
layer, frame, x, y, w, h, link int
|
|
opacity uint8
|
|
raw []byte
|
|
image ID
|
|
resolving bool
|
|
}
|
|
type aseTag struct {
|
|
name string
|
|
from, to int
|
|
direction Direction
|
|
}
|
|
type aseSlice struct {
|
|
name string
|
|
frame int
|
|
rect image.Rectangle
|
|
pivot image.Point
|
|
global bool
|
|
}
|
|
type aseImport struct {
|
|
layers []aseLayer
|
|
cels []*aseCel
|
|
frames []int
|
|
tags []aseTag
|
|
slices []aseSlice
|
|
palette []Swatch
|
|
modernPalette bool
|
|
paletteSeen bool
|
|
decoded int64
|
|
diagnostics []ImportDiagnostic
|
|
flags uint32
|
|
depth int
|
|
lim Limits
|
|
}
|
|
|
|
func (a *aseImport) note(frame int, chunk uint16, code, msg string) {
|
|
if len(a.diagnostics) < 512 {
|
|
a.diagnostics = append(a.diagnostics, ImportDiagnostic{code, frame, chunk, msg})
|
|
}
|
|
}
|
|
|
|
// ImportAseprite supports raster/group/reference layers, raw/compressed/linked
|
|
// cels, RGBA/grayscale/indexed pixels, static palettes, tags and basic slices.
|
|
// Tilemaps, ICC profiles, animated palettes, nonzero cel z-index and unsupported
|
|
// blend modes fail explicitly. It never executes external links or extracts files.
|
|
func ImportAseprite(data []byte, limits Limits) (*Document, []ImportDiagnostic, error) {
|
|
l := limitsOrDefault(limits)
|
|
a := &aseImport{lim: l}
|
|
fail := func(err error) (*Document, []ImportDiagnostic, error) {
|
|
return nil, a.diagnostics, fmt.Errorf("art: Aseprite import: %w", err)
|
|
}
|
|
if len(data) < aseprite.HeaderSize || int64(len(data)) > l.MaxFileBytes {
|
|
return fail(ErrLimit)
|
|
}
|
|
h, err := aseprite.ReadHeader(data)
|
|
if err != nil {
|
|
return fail(err)
|
|
}
|
|
frames, w, hei := int(h.Frames), int(h.Width), int(h.Height)
|
|
a.depth, a.flags = int(h.Depth), h.Flags
|
|
speed, transparent, colors := int(h.Speed), int(h.Transparent), int(h.Colors)
|
|
if int64(h.FileSize) != int64(len(data)) || h.Magic != aseprite.FileMagic {
|
|
return fail(fmt.Errorf("invalid header or file size"))
|
|
}
|
|
if frames < 1 || frames > l.MaxFrames || w < 1 || hei < 1 || w > l.MaxDimension || hei > l.MaxDimension || int64(w)*int64(hei) > int64(l.MaxCanvasPixels) {
|
|
return fail(ErrLimit)
|
|
}
|
|
mode := RGBA
|
|
switch a.depth {
|
|
case 32:
|
|
mode = RGBA
|
|
case 16:
|
|
mode = Grayscale
|
|
case 8:
|
|
mode = Indexed
|
|
default:
|
|
return fail(fmt.Errorf("unsupported color depth %d", a.depth))
|
|
}
|
|
if colors == 0 {
|
|
colors = 256
|
|
}
|
|
if colors > 256 {
|
|
return fail(fmt.Errorf("palette exceeds 256 entries"))
|
|
}
|
|
a.palette = make([]Swatch, colors)
|
|
for i := range a.palette {
|
|
a.palette[i].Color.A = 255
|
|
}
|
|
if err := aseprite.ReadFrames(data, frames, speed, func(duration int) {
|
|
a.frames = append(a.frames, duration)
|
|
}, a.chunk); err != nil {
|
|
return fail(err)
|
|
}
|
|
if len(a.layers) == 0 {
|
|
return fail(fmt.Errorf("no layers"))
|
|
}
|
|
if mode == Indexed && (!a.paletteSeen || transparent >= len(a.palette)) {
|
|
return fail(fmt.Errorf("indexed import requires an explicit valid palette"))
|
|
}
|
|
d, err := New(w, hei, mode, l)
|
|
if err != nil {
|
|
return fail(err)
|
|
}
|
|
s := &state{Canvas: Canvas{w, hei, mode, "srgb"}, Palette: a.palette, Images: make(map[ID]*pixels), Properties: make(map[string]string)}
|
|
if mode != Indexed && !a.paletteSeen {
|
|
s.Palette = DefaultPalette()
|
|
}
|
|
if mode == Indexed {
|
|
s.Palette[0], s.Palette[transparent] = s.Palette[transparent], s.Palette[0]
|
|
s.Palette[0].Color.A = 0
|
|
}
|
|
parents := []ID{}
|
|
for _, v := range a.layers {
|
|
if v.level > len(parents) {
|
|
return fail(fmt.Errorf("invalid layer hierarchy"))
|
|
}
|
|
if mode == Indexed && v.flags&8 != 0 {
|
|
return fail(fmt.Errorf("indexed background layer is not supported; convert it to a normal raster layer"))
|
|
}
|
|
parents = parents[:v.level]
|
|
parent := ID("")
|
|
if v.level > 0 {
|
|
parent = parents[v.level-1]
|
|
}
|
|
kind := Raster
|
|
if v.kind == 1 {
|
|
kind = Group
|
|
} else if v.flags&64 != 0 {
|
|
kind = Reference
|
|
}
|
|
layer := Layer{ID: d.allocate(), Parent: parent, Name: v.name, Kind: kind, Visible: v.flags&1 != 0, Locked: v.flags&2 == 0, Opacity: v.opacity, Blend: v.blend}
|
|
s.Layers = append(s.Layers, layer)
|
|
if kind == Group {
|
|
parents = append(parents, layer.ID)
|
|
}
|
|
}
|
|
for _, duration := range a.frames {
|
|
s.Frames = append(s.Frames, Frame{d.allocate(), duration})
|
|
}
|
|
cells := make(map[[2]int]*aseCel)
|
|
for _, c := range a.cels {
|
|
if c.layer < 0 || c.layer >= len(s.Layers) || s.Layers[c.layer].Kind == Group {
|
|
return fail(fmt.Errorf("invalid cel layer"))
|
|
}
|
|
key := [2]int{c.frame, c.layer}
|
|
if cells[key] != nil {
|
|
return fail(fmt.Errorf("duplicate cel"))
|
|
}
|
|
cells[key] = c
|
|
}
|
|
var resolve func(*aseCel) (ID, error)
|
|
resolve = func(c *aseCel) (ID, error) {
|
|
if c.image != "" {
|
|
return c.image, nil
|
|
}
|
|
if c.resolving {
|
|
return "", fmt.Errorf("linked cel cycle")
|
|
}
|
|
c.resolving = true
|
|
if c.link >= 0 {
|
|
target := cells[[2]int{c.link, c.layer}]
|
|
if target == nil {
|
|
return "", fmt.Errorf("linked cel target is missing")
|
|
}
|
|
id, err := resolve(target)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
c.image = id
|
|
c.resolving = false
|
|
return id, nil
|
|
}
|
|
p := newPixels(c.w, c.h)
|
|
for y := 0; y < c.h; y++ {
|
|
for x := 0; x < c.w; x++ {
|
|
at := (y*c.w + x) * (a.depth / 8)
|
|
var value uint32
|
|
switch mode {
|
|
case RGBA:
|
|
value = binary.LittleEndian.Uint32(c.raw[at:])
|
|
case Grayscale:
|
|
g := c.raw[at]
|
|
value = Color{g, g, g, c.raw[at+1]}.packed()
|
|
case Indexed:
|
|
idx := int(c.raw[at])
|
|
if idx >= len(s.Palette) {
|
|
return "", fmt.Errorf("pixel refers to missing palette entry")
|
|
}
|
|
if idx == transparent {
|
|
idx = 0
|
|
} else if idx == 0 {
|
|
idx = transparent
|
|
}
|
|
value = uint32(idx)
|
|
}
|
|
if value != 0 {
|
|
key := tileKey{x / TileSize, y / TileSize}
|
|
t := p.Tiles[key]
|
|
if t == nil {
|
|
t = new(tile)
|
|
p.Tiles[key] = t
|
|
}
|
|
t[(y%TileSize)*TileSize+x%TileSize] = value
|
|
}
|
|
}
|
|
}
|
|
c.image = d.allocate()
|
|
s.Images[c.image] = p
|
|
c.raw = nil
|
|
c.resolving = false
|
|
return c.image, nil
|
|
}
|
|
for _, c := range a.cels {
|
|
id, err := resolve(c)
|
|
if err != nil {
|
|
return fail(err)
|
|
}
|
|
s.Cels = append(s.Cels, Cel{ID: d.allocate(), Layer: s.Layers[c.layer].ID, Frame: s.Frames[c.frame].ID, Image: id, Channel: Albedo, X: c.x, Y: c.y, Opacity: c.opacity})
|
|
}
|
|
for _, v := range a.tags {
|
|
if v.from < 0 || v.to >= len(s.Frames) || v.from > v.to {
|
|
return fail(fmt.Errorf("invalid tag range"))
|
|
}
|
|
s.Tags = append(s.Tags, Tag{d.allocate(), v.name, s.Frames[v.from].ID, s.Frames[v.to].ID, v.direction})
|
|
}
|
|
for _, v := range a.slices {
|
|
if v.frame < 0 || v.frame >= len(s.Frames) {
|
|
return fail(fmt.Errorf("invalid slice frame"))
|
|
}
|
|
frame := ID("")
|
|
if !v.global {
|
|
frame = s.Frames[v.frame].ID
|
|
}
|
|
s.Slices = append(s.Slices, Slice{d.allocate(), v.name, frame, v.rect, v.pivot})
|
|
}
|
|
if err = s.validate(l); err != nil {
|
|
return fail(err)
|
|
}
|
|
d.current = s
|
|
return d, a.diagnostics, nil
|
|
}
|
|
func (a *aseImport) chunk(frame int, kind uint16, b []byte) error {
|
|
r := aseReader{aseprite.NewReader(b)}
|
|
switch kind {
|
|
case 0x2004:
|
|
if frame != 0 {
|
|
return fmt.Errorf("animated layer definitions are unsupported")
|
|
}
|
|
if len(a.layers) >= a.lim.MaxLayers {
|
|
return ErrLimit
|
|
}
|
|
v := aseLayer{flags: r.u16(), kind: int(r.u16()), level: int(r.u16())}
|
|
r.take(4)
|
|
blend := r.u16()
|
|
v.opacity = r.u8()
|
|
r.take(3)
|
|
v.name = r.text()
|
|
if v.kind > 1 {
|
|
return fmt.Errorf("tilemap layers are unsupported")
|
|
}
|
|
switch blend {
|
|
case 0:
|
|
v.blend = BlendNormal
|
|
case 1:
|
|
v.blend = BlendMultiply
|
|
case 2:
|
|
v.blend = BlendScreen
|
|
case 16:
|
|
v.blend = BlendAdd
|
|
default:
|
|
return fmt.Errorf("blend mode %d is unsupported", blend)
|
|
}
|
|
if a.flags&1 == 0 {
|
|
v.opacity = 255
|
|
}
|
|
if v.kind == 1 && a.flags&2 == 0 {
|
|
v.blend = BlendNormal
|
|
v.opacity = 255
|
|
}
|
|
if a.flags&4 != 0 {
|
|
r.take(16)
|
|
a.note(frame, kind, "layer-uuid", "Aseprite UUID is replaced by a stable Art Document entity ID")
|
|
}
|
|
a.layers = append(a.layers, v)
|
|
case 0x2005:
|
|
if len(a.cels) >= a.lim.MaxCels {
|
|
return ErrLimit
|
|
}
|
|
c := &aseCel{layer: int(r.u16()), frame: frame, x: r.i16(), y: r.i16(), opacity: r.u8(), link: -1}
|
|
typ := r.u16()
|
|
z := r.i16()
|
|
r.take(5)
|
|
if z != 0 {
|
|
return fmt.Errorf("per-cel z-index is unsupported")
|
|
}
|
|
switch typ {
|
|
case 1:
|
|
c.link = int(r.u16())
|
|
case 0, 2:
|
|
c.w, c.h = int(r.u16()), int(r.u16())
|
|
n := int64(c.w) * int64(c.h) * int64(a.depth/8)
|
|
if c.w < 1 || c.h < 1 || c.w > a.lim.MaxDimension || c.h > a.lim.MaxDimension || int64(c.w)*int64(c.h) > int64(a.lim.MaxCanvasPixels) || n > a.lim.MaxPixelBytes-a.decoded {
|
|
return ErrLimit
|
|
}
|
|
a.decoded += n
|
|
if r.Err() != nil {
|
|
return r.Err()
|
|
}
|
|
raw := r.take(len(b) - r.Offset())
|
|
if typ == 0 {
|
|
if int64(len(raw)) != n {
|
|
return fmt.Errorf("raw cel size mismatch")
|
|
}
|
|
c.raw = append([]byte(nil), raw...)
|
|
} else {
|
|
var err error
|
|
c.raw, err = aseprite.InflateExact(raw, n)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
default:
|
|
return fmt.Errorf("cel type %d is unsupported", typ)
|
|
}
|
|
a.cels = append(a.cels, c)
|
|
case 0x2019:
|
|
size, first, last := int64(r.u32()), int64(r.u32()), int64(r.u32())
|
|
r.take(8)
|
|
if size < 1 || size > 256 || first < 0 || last < first || last >= size {
|
|
return fmt.Errorf("invalid palette range")
|
|
}
|
|
p := make([]Swatch, int(size))
|
|
copy(p, a.palette)
|
|
for i := first; i <= last; i++ {
|
|
flags := r.u16()
|
|
color := Color{r.u8(), r.u8(), r.u8(), r.u8()}
|
|
name := ""
|
|
if flags&1 != 0 {
|
|
name = r.text()
|
|
}
|
|
if flags&^uint16(1) != 0 {
|
|
return fmt.Errorf("unknown palette flags")
|
|
}
|
|
p[i] = Swatch{color, name}
|
|
}
|
|
if frame > 0 && !reflect.DeepEqual(p, a.palette) {
|
|
return fmt.Errorf("animated palettes are unsupported")
|
|
}
|
|
a.palette = p
|
|
a.modernPalette = true
|
|
a.paletteSeen = true
|
|
case 0x0004, 0x0011:
|
|
count := int(r.u16())
|
|
index := 0
|
|
p := append([]Swatch(nil), a.palette...)
|
|
for n := 0; n < count; n++ {
|
|
index += int(r.u8())
|
|
colors := int(r.u8())
|
|
if colors == 0 {
|
|
colors = 256
|
|
}
|
|
if index+colors > len(p) {
|
|
return fmt.Errorf("legacy palette exceeds bounds")
|
|
}
|
|
for j := 0; j < colors; j++ {
|
|
c := Color{r.u8(), r.u8(), r.u8(), 255}
|
|
if kind == 0x0011 {
|
|
if c.R > 63 || c.G > 63 || c.B > 63 {
|
|
return fmt.Errorf("invalid six-bit palette")
|
|
}
|
|
c.R = uint8((int(c.R)*255 + 31) / 63)
|
|
c.G = uint8((int(c.G)*255 + 31) / 63)
|
|
c.B = uint8((int(c.B)*255 + 31) / 63)
|
|
}
|
|
p[index+j].Color = c
|
|
}
|
|
index += colors
|
|
}
|
|
if !a.modernPalette {
|
|
if frame > 0 && !reflect.DeepEqual(p, a.palette) {
|
|
return fmt.Errorf("animated palettes are unsupported")
|
|
}
|
|
a.palette = p
|
|
a.paletteSeen = true
|
|
}
|
|
case 0x2018:
|
|
count := int(r.u16())
|
|
r.take(8)
|
|
if count > a.lim.MaxFrames-len(a.tags) {
|
|
return ErrLimit
|
|
}
|
|
for i := 0; i < count; i++ {
|
|
v := aseTag{from: int(r.u16()), to: int(r.u16())}
|
|
dir := r.u8()
|
|
repeat := r.u16()
|
|
r.take(6)
|
|
r.take(4)
|
|
v.name = r.text()
|
|
switch dir {
|
|
case 0:
|
|
v.direction = Forward
|
|
case 1:
|
|
v.direction = Reverse
|
|
case 2:
|
|
v.direction = PingPong
|
|
default:
|
|
return fmt.Errorf("ping-pong reverse tags are unsupported")
|
|
}
|
|
if repeat != 0 {
|
|
a.note(frame, kind, "tag-repeat", "Finite tag repeat count is not retained; imported tag loops")
|
|
}
|
|
a.tags = append(a.tags, v)
|
|
}
|
|
case 0x2007:
|
|
typ, flags := r.u16(), r.u16()
|
|
gamma := r.u32()
|
|
r.take(8)
|
|
if typ > 1 || flags&1 != 0 && gamma != 0 {
|
|
return fmt.Errorf("ICC/custom gamma color profiles are unsupported")
|
|
}
|
|
case 0x2022:
|
|
count, flags := int64(r.u32()), r.u32()
|
|
r.take(4)
|
|
name := r.text()
|
|
if count > int64(a.lim.MaxFrames-len(a.slices)) || flags&^uint32(3) != 0 {
|
|
return ErrLimit
|
|
}
|
|
for i := int64(0); i < count; i++ {
|
|
v := aseSlice{name: name, frame: int(r.u32())}
|
|
v.global = count == 1 && v.frame == 0
|
|
x, y := r.i32(), r.i32()
|
|
w, h := int64(r.u32()), int64(r.u32())
|
|
if w > int64(a.lim.MaxDimension) || h > int64(a.lim.MaxDimension) || x < -a.lim.MaxDimension || y < -a.lim.MaxDimension || x > a.lim.MaxDimension || y > a.lim.MaxDimension {
|
|
return ErrLimit
|
|
}
|
|
v.rect = image.Rect(x, y, x+int(w), y+int(h))
|
|
if flags&1 != 0 {
|
|
r.take(16)
|
|
}
|
|
if flags&2 != 0 {
|
|
// Aseprite pivots are relative to the slice origin; Aego's
|
|
// frame pivot is in canvas coordinates. Bound the sum even on
|
|
// 32-bit hosts before converting it back to an int.
|
|
px, py := int64(x)+int64(r.i32()), int64(y)+int64(r.i32())
|
|
if px < -1<<31 || px > 1<<31-1 || py < -1<<31 || py > 1<<31-1 {
|
|
return ErrLimit
|
|
}
|
|
v.pivot = image.Pt(int(px), int(py))
|
|
}
|
|
a.slices = append(a.slices, v)
|
|
}
|
|
if count > 1 || count == 1 && a.slices[len(a.slices)-1].frame != 0 {
|
|
a.note(frame, kind, "slice-keyframe-timing", "Aseprite slice keys persist until the next key; Aego currently retains each key only on its specified frame")
|
|
}
|
|
if flags&1 != 0 {
|
|
a.note(frame, kind, "slice-ninepatch", "Nine-patch center is not retained; slice bounds and pivot are retained")
|
|
}
|
|
case 0x2006, 0x2008, 0x2016, 0x2017, 0x2020:
|
|
// These chunks do not replace raster pixels. Keep the loss visible to users.
|
|
a.note(frame, kind, "metadata-skipped", fmt.Sprintf("Chunk %#x metadata is not imported", kind))
|
|
r.take(len(b))
|
|
case 0x2023:
|
|
return fmt.Errorf("tile sets are unsupported")
|
|
default:
|
|
return fmt.Errorf("unsupported chunk %#x", kind)
|
|
}
|
|
if r.Err() != nil {
|
|
return r.Err()
|
|
}
|
|
if r.Offset() != len(b) {
|
|
return fmt.Errorf("unexpected chunk trailing data")
|
|
}
|
|
return nil
|
|
}
|