From fd730483b0cfeb8051584a25873184639c509c33 Mon Sep 17 00:00:00 2001 From: Noah Petherbridge Date: Sun, 12 Sep 2021 15:26:51 -0700 Subject: [PATCH] Zoom Improvements * Doodad outline while dragging is now sized properly for the zoom level * Make doodad hitboxes for Actor/Link Tool more accurate while zoomed * Fix chunks low on the level not loading while zoomed in * Fix Link lines drawn between doodads while zoomed - they point to the correct position and their DrawLine calls have been optimized so they don't lag out the level when lots of them are drawn at once. --- go.mod | 14 +------------- pkg/editor_ui_doodad.go | 8 +++++++- pkg/uix/canvas_editable.go | 8 ++++---- pkg/uix/canvas_present.go | 9 ++++++--- pkg/uix/canvas_strokes.go | 38 +++++++++++++++++++++++++++++++------- 5 files changed, 49 insertions(+), 28 deletions(-) diff --git a/go.mod b/go.mod index 90e95a3..eeac348 100644 --- a/go.mod +++ b/go.mod @@ -16,22 +16,10 @@ require ( github.com/robertkrimen/otto v0.0.0-20200922221731-ef014fd054ac github.com/tomnomnom/xtermcolor v0.0.0-20160428124646-b78803f00a7e // indirect github.com/urfave/cli/v2 v2.3.0 - github.com/veandco/go-sdl2 v0.4.8 + github.com/veandco/go-sdl2 v0.4.10 github.com/vmihailenco/msgpack v3.3.3+incompatible golang.org/x/image v0.0.0-20210628002857-a66eb6448b8d google.golang.org/appengine v1.6.7 // indirect gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect gopkg.in/sourcemap.v1 v1.0.5 // indirect ) - -// replace git.kirsle.net/go/render => /home/kirsle/SketchyMaze/deps/render - -// replace git.kirsle.net/go/ui => /home/kirsle/SketchyMaze/deps/ui - -// replace git.kirsle.net/go/audio => /home/kirsle/SketchyMaze/deps/audio - -// replace git.kirsle.net/go/render => /run/build/sketchymaze/deps/render - -// replace git.kirsle.net/go/ui => /run/build/sketchymaze/deps/ui - -// replace git.kirsle.net/go/audio => /run/build/sketchymaze/deps/audio diff --git a/pkg/editor_ui_doodad.go b/pkg/editor_ui_doodad.go index b356d22..f3223da 100644 --- a/pkg/editor_ui_doodad.go +++ b/pkg/editor_ui_doodad.go @@ -39,10 +39,16 @@ func (u *EditorUI) startDragActor(doodad *doodads.Doodad, actor *level.Actor) { } } + // Size and scale this doodad according to the zoom level. + size := doodad.Rect() + size.W = u.Canvas.ZoomMultiply(size.W) + size.H = u.Canvas.ZoomMultiply(size.H) + // Create the canvas to render on the mouse cursor. drawing := uix.NewCanvas(doodad.Layers[0].Chunker.Size, false) drawing.LoadDoodad(doodad) - drawing.Resize(doodad.Rect()) + drawing.Resize(size) + drawing.Zoom = u.Canvas.Zoom drawing.SetBackground(render.RGBA(0, 0, 1, 0)) // TODO: invisible becomes white drawing.MaskColor = balance.DragColor // blueprint effect u.DraggableActor = &DraggableActor{ diff --git a/pkg/uix/canvas_editable.go b/pkg/uix/canvas_editable.go index edd20d9..14b1d88 100644 --- a/pkg/uix/canvas_editable.go +++ b/pkg/uix/canvas_editable.go @@ -316,8 +316,8 @@ func (w *Canvas) loopEditable(ev *event.State) error { scrollBias.Y = w.ZoomDivide(scrollBias.Y) } box := render.Rect{ - X: actor.Actor.Point.X - P.X - scrollBias.X, - Y: actor.Actor.Point.Y - P.Y - scrollBias.Y, + X: actor.Actor.Point.X - scrollBias.X - w.ZoomDivide(P.X), + Y: actor.Actor.Point.Y - scrollBias.Y - w.ZoomDivide(P.Y), W: actor.Canvas.Size().W, H: actor.Canvas.Size().H, } @@ -378,8 +378,8 @@ func (w *Canvas) loopEditable(ev *event.State) error { scrollBias.Y = w.ZoomDivide(scrollBias.Y) } box := render.Rect{ - X: actor.Actor.Point.X - P.X - scrollBias.X, - Y: actor.Actor.Point.Y - P.Y - scrollBias.Y, + X: actor.Actor.Point.X - scrollBias.X - w.ZoomDivide(P.X), + Y: actor.Actor.Point.Y - scrollBias.Y - w.ZoomDivide(P.Y), W: actor.Canvas.Size().W, H: actor.Canvas.Size().H, } diff --git a/pkg/uix/canvas_present.go b/pkg/uix/canvas_present.go index 9a801f9..55c6c25 100644 --- a/pkg/uix/canvas_present.go +++ b/pkg/uix/canvas_present.go @@ -43,10 +43,12 @@ func (w *Canvas) Present(e render.Engine, p render.Point) { // Zoomed out (level go tiny) // TODO: seems unstable as shit on Zoom In?? Viewport.W = w.ZoomDivide(Viewport.W) - Viewport.H = w.ZoomDivide(Viewport.W) + Viewport.H = w.ZoomDivide(Viewport.H) if w.Zoom > 0 { - Viewport.X = w.ZoomDivide(w.chunks.Size) - Viewport.Y = w.ZoomDivide(w.chunks.Size) + // Viewport.X = w.ZoomDivide(w.chunks.Size) + // Viewport.Y = w.ZoomDivide(w.chunks.Size) + Viewport.X = w.ZoomDivide(Viewport.X) + Viewport.Y = w.ZoomDivide(Viewport.Y) } } @@ -73,6 +75,7 @@ func (w *Canvas) Present(e render.Engine, p render.Point) { // Viewport.X = w.ZoomDivide(w.chunks.Size) // Viewport.Y = w.ZoomDivide(w.chunks.Size) // } + // Seems resolved now? // Get the chunks in the viewport and cache their textures. for coord := range w.chunks.IterViewportChunks(Viewport) { diff --git a/pkg/uix/canvas_strokes.go b/pkg/uix/canvas_strokes.go index 72c1f07..fc575e8 100644 --- a/pkg/uix/canvas_strokes.go +++ b/pkg/uix/canvas_strokes.go @@ -186,9 +186,14 @@ func (w *Canvas) presentActorLinks(e render.Engine) { bS = actorMap[linkID].Size() ) + // Adapt actor positions per the zoom level. + aP.X = w.ZoomMultiply(aP.X) + aP.Y = w.ZoomMultiply(aP.Y) + bP.X = w.ZoomMultiply(bP.X) + bP.Y = w.ZoomMultiply(bP.Y) + // Draw a line connecting the centers of each actor together. stroke := drawtool.NewStroke(drawtool.Line, color) - stroke.Thickness = 1 stroke.PointA = render.Point{ X: aP.X + (aS.W / 2), Y: aP.Y + (aS.H / 2), @@ -275,13 +280,36 @@ func (w *Canvas) DrawStrokes(e render.Engine, strokes []*drawtool.Stroke) { } } } else { + var color = stroke.Color + if balance.DebugCanvasStrokeColor != render.Invisible { + color = balance.DebugCanvasStrokeColor + } + + // TODO: iterating all the points is very costly! + // Strokes don't properly render your Pattern anyway (glitchy mess), + // so let them just be simple DrawLine etc. calls. + // This optimization specifically speeds up the Actor Link Lines. + if stroke.Shape == drawtool.Line { + var ( + pointA = render.Point{ + X: P.X + w.Scroll.X + w.BoxThickness(1) + stroke.PointA.X, + Y: P.Y + w.Scroll.Y + w.BoxThickness(1) + stroke.PointA.Y, + } + pointB = render.Point{ + X: P.X + w.Scroll.X + w.BoxThickness(1) + stroke.PointB.X, + Y: P.Y + w.Scroll.Y + w.BoxThickness(1) + stroke.PointB.Y, + } + ) + e.DrawLine(color, pointA, pointB) + continue + } + for point := range stroke.IterPoints() { if !point.Inside(VP) { continue } // Does the swatch have a pattern to sample? - color := stroke.Color if stroke.Pattern != "" { color = pattern.SampleColor(stroke.Pattern, color, point) } @@ -291,11 +319,7 @@ func (w *Canvas) DrawStrokes(e render.Engine, strokes []*drawtool.Stroke) { Y: P.Y + w.Scroll.Y + w.BoxThickness(1) + point.Y, } - if balance.DebugCanvasStrokeColor != render.Invisible { - e.DrawPoint(balance.DebugCanvasStrokeColor, dest) - } else { - e.DrawPoint(color, dest) - } + e.DrawPoint(color, dest) } } }