Files
aego/art/session.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

572 lines
14 KiB
Go

package art
import (
"context"
"fmt"
"image"
)
// HistoryHost makes the same interaction controller usable with the editor's
// history.History or the standalone Journal. There is never a second active
// undo stack for a native document.
type HistoryHost interface {
Exec(*Change) error
Undo() error
Redo() error
Counts() (int, int)
}
type Session struct {
Document *Document
History HistoryHost
Layer, Frame ID
IsolatedLayer ID
Channel Channel
Selection *Selection
Clipboard *Clipboard
customBrush *Clipboard
brushRevision uint64
saved Checkpoint
draft *Edit
gesture *Gesture
tool string
start image.Point
brush Brush
filled bool
gestureRevision uint64
shapePoints int
preview previewCache
}
type SessionInfo struct {
Document Info `json:"document"`
Layer ID `json:"layer"`
Frame ID `json:"frame"`
Channel Channel `json:"channel"`
Undo int `json:"undo"`
Redo int `json:"redo"`
Dirty bool `json:"dirty"`
Gesture bool `json:"gesture"`
Selection image.Rectangle `json:"selection"`
SelectedPixels int `json:"selectedPixels"`
BrushWidth int `json:"brushWidth,omitempty"`
BrushHeight int `json:"brushHeight,omitempty"`
Isolation ID `json:"isolation,omitempty"`
}
func NewSession(d *Document, h HistoryHost) (*Session, error) {
if d == nil || h == nil {
return nil, fmt.Errorf("art: document and history host are required")
}
i := d.Info()
saved, err := d.Checkpoint(i.Revision)
if err != nil {
return nil, err
}
return &Session{Document: d, History: h, Layer: i.Layers[0].ID, Frame: i.Frames[0].ID, Channel: Albedo, saved: saved}, nil
}
func (s *Session) Info() SessionInfo {
u, r := s.History.Counts()
b := s.BrushSize()
return SessionInfo{Document: s.Document.Info(), Layer: s.Layer, Frame: s.Frame, Channel: s.Channel, Undo: u, Redo: r, Dirty: s.Document.DirtySince(s.saved), Gesture: s.draft != nil, Selection: s.Selection.Bounds(), SelectedPixels: s.Selection.Count(), BrushWidth: b.X, BrushHeight: b.Y, Isolation: s.IsolatedLayer}
}
func (s *Session) MarkSaved(expected uint64) error {
cp, err := s.Document.Checkpoint(expected)
if err != nil {
return err
}
s.saved = cp
return nil
}
// MarkUnsaved marks a recovered/new source as needing an explicit save.
func (s *Session) MarkUnsaved() { s.saved = Checkpoint{} }
func (s *Session) ActiveCel() ID {
i := s.Document.Info()
for _, c := range i.Cels {
if c.Layer == s.Layer && c.Frame == s.Frame && c.Channel == s.Channel {
return c.ID
}
}
return ""
}
func (s *Session) Select(layer, frame ID, ch Channel) error {
if s.draft != nil {
return fmt.Errorf("art: finish or cancel the current gesture")
}
i := s.Document.Info()
if layer != "" {
ok := false
for _, v := range i.Layers {
if v.ID == layer {
ok = true
break
}
}
if !ok {
return fmt.Errorf("art: missing layer")
}
}
if frame != "" {
ok := false
for _, v := range i.Frames {
if v.ID == frame {
ok = true
break
}
}
if !ok {
return fmt.Errorf("art: missing frame")
}
}
if ch != "" && !validChannel(ch) {
return fmt.Errorf("art: invalid channel")
}
if layer != "" {
s.Layer = layer
}
if frame != "" {
s.Frame = frame
}
if ch != "" {
s.Channel = ch
}
return nil
}
func (s *Session) BeginGesture(tool string, p image.Point, b Brush, filled bool) error {
if s.draft != nil {
return fmt.Errorf("art: a gesture is already active")
}
if tool != "pencil" && tool != "eraser" && tool != "line" && tool != "rectangle" && tool != "ellipse" && tool != "gradient" && tool != "curve" && tool != "polygon" {
return fmt.Errorf("art: unsupported pointer tool")
}
var err error
b, err = s.resolveBrush(b)
if err != nil {
return err
}
e, err := s.Document.Begin(s.Document.Revision(), tool)
if err != nil {
return err
}
s.draft = e
s.gestureRevision = e.revision
s.start = p
s.brush = b
s.filled = filled
s.tool = tool
s.shapePoints = 0
cel, err := e.EnsureCel(s.Layer, s.Frame, s.Channel)
if err != nil {
s.CancelGesture()
return err
}
if tool == "pencil" || tool == "eraser" {
b.Erase = tool == "eraser"
s.gesture, err = e.Stroke(cel, b, s.Selection)
if err == nil {
err = s.gesture.Point(p)
}
} else if tool != "curve" && tool != "polygon" {
err = s.previewShape(p)
}
if err != nil {
s.CancelGesture()
}
return err
}
func (s *Session) previewShape(p image.Point) error {
if s.draft != nil {
s.draft.Cancel()
}
e, err := s.Document.Begin(s.gestureRevision, s.tool)
if err != nil {
return err
}
s.draft = e
cel, err := e.EnsureCel(s.Layer, s.Frame, s.Channel)
if err != nil {
return err
}
if s.tool == "gradient" {
return e.Gradient(context.Background(), cel, s.start, p, s.brush.Paint, s.brush.Background, s.Selection, s.brush.Dither > 0)
}
return e.Shape(cel, s.tool, s.start, p, s.brush, s.Selection, s.filled)
}
func (s *Session) MoveGesture(points []image.Point) error {
if s.draft == nil {
return fmt.Errorf("art: no active gesture")
}
if len(points) > 65536 {
return ErrLimit
}
if len(points) == 0 {
return nil
}
if s.tool == "curve" || s.tool == "polygon" {
return s.PreviewGesturePoints(points)
}
var err error
if s.gesture != nil {
for _, p := range points {
if err = s.gesture.Point(p); err != nil {
break
}
}
} else {
err = s.previewShape(points[len(points)-1])
}
if err != nil {
s.CancelGesture()
}
return err
}
// PreviewGesturePoints replaces an uncommitted multi-point shape using the
// same drawing operations and revision as the eventual history command. The
// host supplies the complete cubic curve (four points) or polygon (at least
// three points), rather than committing each pointer movement separately.
func (s *Session) PreviewGesturePoints(points []image.Point) error {
if s.draft == nil || (s.tool != "curve" && s.tool != "polygon") {
return fmt.Errorf("art: no active multi-point shape")
}
if (s.tool == "curve" && len(points) != 4) || (s.tool == "polygon" && len(points) < 3) {
return fmt.Errorf("art: incomplete shape points")
}
if len(points) > 65536 {
return ErrLimit
}
s.draft.Cancel()
e, err := s.Document.Begin(s.gestureRevision, s.tool)
if err != nil {
s.CancelGesture()
return err
}
s.draft = e
cel, err := e.EnsureCel(s.Layer, s.Frame, s.Channel)
if err == nil {
if s.tool == "curve" {
err = e.Curve(cel, points[0], points[1], points[2], points[3], s.brush, s.Selection)
} else {
err = e.Polygon(cel, points, s.brush, s.Selection, s.filled)
}
}
if err != nil {
s.CancelGesture()
return err
}
s.shapePoints = len(points)
return nil
}
func (s *Session) EndGesture() error {
if s.draft == nil {
return nil
}
if (s.tool == "curve" || s.tool == "polygon") && s.shapePoints == 0 {
s.CancelGesture()
return fmt.Errorf("art: incomplete shape points")
}
e := s.draft
s.draft = nil
s.gesture = nil
s.shapePoints = 0
c, err := e.Prepare()
if err != nil {
e.Cancel()
return err
}
return s.History.Exec(c)
}
func (s *Session) CancelGesture() {
if s.draft != nil {
s.draft.Cancel()
}
s.draft = nil
s.gesture = nil
s.shapePoints = 0
}
// SamplePaint samples the selected layer, frame and channel, not onion skin,
// reference overlays or the other composited layers.
func (s *Session) SamplePaint(p image.Point) (Paint, error) {
if s.draft != nil {
return Paint{}, fmt.Errorf("art: finish or cancel the current gesture")
}
return s.Document.SamplePaint(s.ActiveCel(), s.Channel, p.X, p.Y)
}
func (s *Session) Execute(ctx context.Context, op Operation) (ID, error) {
if s.draft != nil {
return "", fmt.Errorf("art: a gesture is active")
}
if op.Layer == "" {
op.Layer = s.Layer
}
if op.Frame == "" {
op.Frame = s.Frame
}
if op.Channel == "" {
op.Channel = s.Channel
}
switch op.Kind {
case "stroke", "fill", "line", "rectangle", "ellipse", "gradient", "polygon", "curve":
var err error
op.Brush, err = s.resolveBrush(op.Brush)
if err != nil {
return "", err
}
default:
if op.Cel == "" {
op.Cel = s.ActiveCel()
}
}
e, err := s.Document.Begin(s.Document.Revision(), op.Kind)
if err != nil {
return "", err
}
id, err := e.Execute(ctx, op, s.Selection)
if err != nil {
e.Cancel()
return "", err
}
c, err := e.Prepare()
if err != nil {
e.Cancel()
return "", err
}
if err = s.History.Exec(c); err != nil {
return "", err
}
switch op.Kind {
case "add-layer", "duplicate-layer", "merge-down":
s.Layer = id
case "add-frame", "duplicate-frame":
s.Frame = id
}
s.repairSelection()
return id, nil
}
func (s *Session) repairSelection() {
i := s.Document.Info()
found := false
isolated := false
for _, l := range i.Layers {
if l.ID == s.Layer {
found = true
}
if l.ID == s.IsolatedLayer {
isolated = true
}
}
if !isolated {
s.IsolatedLayer = ""
}
if !found {
s.Layer = i.Layers[0].ID
}
found = false
for _, f := range i.Frames {
if f.ID == s.Frame {
found = true
}
}
if !found {
s.Frame = i.Frames[0].ID
}
}
// SetIsolation is a view operation; it does not change visibility, revisions,
// exports or the document's undo stack.
func (s *Session) SetIsolation(layer ID) error {
if layer != "" {
found := false
for _, candidate := range s.Document.Info().Layers {
if candidate.ID == layer {
found = true
break
}
}
if !found {
return fmt.Errorf("art: missing isolated layer")
}
}
s.IsolatedLayer = layer
return nil
}
func (s *Session) Undo() error {
if s.draft != nil {
s.CancelGesture()
return nil
}
if err := s.History.Undo(); err != nil {
return err
}
s.repairSelection()
return nil
}
func (s *Session) Redo() error {
if s.draft != nil {
return fmt.Errorf("art: a gesture is active")
}
if err := s.History.Redo(); err != nil {
return err
}
s.repairSelection()
return nil
}
func (s *Session) SetSelection(kind string, points []image.Point, tolerance int) error {
if s.draft != nil {
return fmt.Errorf("art: a gesture is active")
}
i := s.Document.Info()
var selection *Selection
var err error
switch kind {
case "none":
s.Selection = nil
return nil
case "all":
selection, err = RectSelection(i.Canvas.Width, i.Canvas.Height, image.Rect(0, 0, i.Canvas.Width, i.Canvas.Height), false)
case "rectangle", "ellipse":
if len(points) != 2 {
return fmt.Errorf("art: selection needs two points")
}
a, b := points[0], points[1]
r := image.Rect(min(a.X, b.X), min(a.Y, b.Y), max(a.X, b.X)+1, max(a.Y, b.Y)+1)
selection, err = RectSelection(i.Canvas.Width, i.Canvas.Height, r, kind == "ellipse")
case "lasso":
selection, err = LassoSelection(i.Canvas.Width, i.Canvas.Height, points)
case "wand":
if len(points) != 1 {
return fmt.Errorf("art: wand needs one point")
}
selection, err = s.Document.Wand(s.ActiveCel(), points[0].X, points[0].Y, tolerance, true)
default:
return fmt.Errorf("art: unsupported selection")
}
if err != nil {
return err
}
s.Selection = selection
return nil
}
func (s *Session) Copy() error {
clip, err := s.Document.Copy(s.ActiveCel(), s.Selection)
if err != nil {
return err
}
s.Clipboard = clip
return nil
}
// CaptureBrush uses the existing cel/selection copier. Tool state is local to
// this session and never makes the document dirty or adds an Undo entry.
func (s *Session) CaptureBrush() error {
if s.draft != nil {
return fmt.Errorf("art: finish or cancel the current gesture")
}
if s.Selection == nil || s.Selection.Count() == 0 {
return fmt.Errorf("art: select a brush region first")
}
r := s.Selection.Bounds()
if r.Dx() > 128 || r.Dy() > 128 {
return fmt.Errorf("art: custom brushes are limited to 128 by 128 pixels")
}
clip, err := s.Document.Copy(s.ActiveCel(), s.Selection)
if err != nil {
return err
}
s.customBrush = clip
s.brushRevision++
return nil
}
func (s *Session) ClearBrush() {
s.customBrush = nil
s.brushRevision++
}
// BrushRevision changes when a captured custom brush changes, without marking
// document pixels dirty. Presentation caches can use it to invalidate samples.
func (s *Session) BrushRevision() uint64 { return s.brushRevision }
// PreviewBrush resolves a detached copy using the same rules as painting. The
// caller may render it in a scratch document without exposing session-owned data.
func (s *Session) PreviewBrush(b Brush) (Brush, error) {
b, err := s.resolveBrush(b)
if err != nil || b.Pattern == nil {
return b, err
}
clip := *b.Pattern
clip.Pixels = append([]Color(nil), clip.Pixels...)
clip.Mask = append([]bool(nil), clip.Mask...)
b.Pattern = &clip
return b, nil
}
func (s *Session) BrushSize() image.Point {
if s.customBrush == nil {
return image.Point{}
}
return image.Pt(s.customBrush.Width, s.customBrush.Height)
}
func (s *Session) resolveBrush(b Brush) (Brush, error) {
if b.Source != "stamp" && b.Source != "pattern" {
return b, nil
}
if s.customBrush == nil {
return b, fmt.Errorf("art: capture a brush from a selection first")
}
b.Pattern = s.customBrush
b.Stamp = b.Source == "stamp"
if b.Stamp {
b.Size = max(b.Pattern.Width, b.Pattern.Height)
b.Round = false
b.PixelPerfect = false
}
return b, nil
}
func (s *Session) Paste(at image.Point) error {
if s.draft != nil {
return fmt.Errorf("art: a gesture is active")
}
if s.Clipboard == nil {
return fmt.Errorf("art: clipboard is empty")
}
e, err := s.Document.Begin(s.Document.Revision(), "Paste")
if err != nil {
return err
}
cel, err := e.EnsureCel(s.Layer, s.Frame, s.Channel)
if err != nil {
e.Cancel()
return err
}
if err = e.Paste(cel, s.Clipboard, at, s.Selection); err != nil {
e.Cancel()
return err
}
ch, err := e.Prepare()
if err != nil {
e.Cancel()
return err
}
return s.History.Exec(ch)
}
func (s *Session) Preview(frame ID, onion bool, references bool) (*image.NRGBA, error) {
if frame == "" {
frame = s.Frame
}
o := RenderOptions{Channel: s.Channel, References: references, Isolate: s.IsolatedLayer}
im, err := s.previewImage(frame, o)
if err != nil || !onion {
return im, err
}
ghost, err := s.Document.Onion(frame, 1, 1, o)
if err != nil {
return nil, err
}
for i := 0; i < len(im.Pix); i += 4 {
v := blendPixel(Color{ghost.Pix[i], ghost.Pix[i+1], ghost.Pix[i+2], ghost.Pix[i+3]}, Color{im.Pix[i], im.Pix[i+1], im.Pix[i+2], im.Pix[i+3]}, 255, BlendNormal)
im.Pix[i], im.Pix[i+1], im.Pix[i+2], im.Pix[i+3] = v.R, v.G, v.B, v.A
}
return im, nil
}