feat: primitive styling

client/world/renderer_draw.go

@@ -0,0 +1,165 @@
+package world
+
+import (
+	"sort"
+
+	"github.com/google/uuid"
+)
+
+// drawKind is used only for stable tie-breaking when priorities are equal.
+type drawKind int
+
+const (
+	drawKindLine drawKind = iota
+	drawKindCircle
+	drawKindPoint
+)
+
+type drawItem struct {
+	kind     drawKind
+	priority int
+	id       uuid.UUID
+	styleID  StyleID
+
+	// Exactly one of these is set.
+	p *Point
+	c *Circle
+	l *Line
+}
+
+// drawPlanSinglePass renders a plan using a single ordered pass per tile.
+// Items in each tile are sorted by (Priority asc, Kind asc, ID asc) for determinism.
+//
+// allowWrap controls torus behavior:
+// - true: circles/points produce wrap copies, lines use torus-shortest segments
+// - false: no copies, lines drawn directly as stored
+func (w *World) drawPlanSinglePass(drawer PrimitiveDrawer, plan RenderPlan, allowWrap bool) {
+	var lastStyleID StyleID = StyleIDInvalid
+	var lastStyle Style
+
+	applyStyle := func(styleID StyleID) {
+		if styleID == lastStyleID {
+			return
+		}
+		s, ok := w.styles.Get(styleID)
+		if !ok {
+			// Unknown style ID is a programming/config error.
+			panic("render: unknown style ID")
+		}
+
+		// Apply style state. Some fields may be nil intentionally.
+		if s.FillColor != nil {
+			drawer.SetFillColor(s.FillColor)
+		}
+		if s.StrokeColor != nil {
+			drawer.SetStrokeColor(s.StrokeColor)
+		}
+		drawer.SetLineWidth(s.StrokeWidthPx)
+		if len(s.StrokeDashes) > 0 {
+			drawer.SetDash(s.StrokeDashes...)
+		} else {
+			// Ensure solid line when switching from dashed style.
+			drawer.SetDash()
+		}
+		drawer.SetDashOffset(s.StrokeDashOffset)
+
+		lastStyleID = styleID
+		lastStyle = s
+	}
+
+	for _, td := range plan.Tiles {
+		if td.ClipW <= 0 || td.ClipH <= 0 {
+			continue
+		}
+
+		// Collect items for this tile.
+		items := make([]drawItem, 0, len(td.Candidates))
+
+		for _, it := range td.Candidates {
+			switch v := it.(type) {
+			case Point:
+				vv := v
+				items = append(items, drawItem{
+					kind:     drawKindPoint,
+					priority: vv.Priority,
+					id:       vv.Id,
+					styleID:  vv.StyleID,
+					p:        &vv,
+				})
+			case Circle:
+				vv := v
+				items = append(items, drawItem{
+					kind:     drawKindCircle,
+					priority: vv.Priority,
+					id:       vv.Id,
+					styleID:  vv.StyleID,
+					c:        &vv,
+				})
+			case Line:
+				vv := v
+				items = append(items, drawItem{
+					kind:     drawKindLine,
+					priority: vv.Priority,
+					id:       vv.Id,
+					styleID:  vv.StyleID,
+					l:        &vv,
+				})
+			default:
+				// Unknown map items should not exist.
+				panic("render: unknown map item type")
+			}
+		}
+
+		if len(items) == 0 {
+			continue
+		}
+
+		sort.Slice(items, func(i, j int) bool {
+			a, b := items[i], items[j]
+			if a.priority != b.priority {
+				return a.priority < b.priority
+			}
+			if a.kind != b.kind {
+				return a.kind < b.kind
+			}
+			return uuidLess(a.id, b.id)
+		})
+
+		drawer.Save()
+		drawer.ClipRect(float64(td.ClipX), float64(td.ClipY), float64(td.ClipW), float64(td.ClipH))
+
+		for _, di := range items {
+			applyStyle(di.styleID)
+
+			switch di.kind {
+			case drawKindPoint:
+				w.drawPointInTile(drawer, plan, td, *di.p, allowWrap, lastStyle)
+
+			case drawKindCircle:
+				w.drawCircleInTile(drawer, plan, td, *di.c, allowWrap, lastStyle)
+
+			case drawKindLine:
+				w.drawLineInTile(drawer, plan, td, *di.l, allowWrap)
+
+			default:
+				panic("render: unknown draw kind")
+			}
+		}
+
+		drawer.Restore()
+	}
+}
+
+func uuidLess(a, b uuid.UUID) bool {
+	aa := a[:]
+	bb := b[:]
+	for i := 0; i < len(aa); i++ {
+		if aa[i] < bb[i] {
+			return true
+		}
+		if aa[i] > bb[i] {
+			return false
+		}
+	}
+	return false
+}