@glassly/engine 0.1.0-dev.105 → 0.1.0-dev.109

package/src/types/hardware.ts

@@ -56,11 +56,18 @@ export interface DisplayCapabilities {
   maxImageElements?: number
   /** Per-image dimension cap (box-level), when the firmware has one. */
   maxImagePx?: {width: number; height: number}
-  shapes?: "rect"[]
+  shapes?: DisplayShape[]
+  /** True ⇒ the device animates element transitions itself. */
+  animation?: boolean
   intensityLevels?: number
   partialUpdate?: boolean
 }
 
+export type DisplayShape = "rect" | "circle" | "arc" | "pie" | "line" | "triangle" | "quad" | "bezier"
+
+/** Every vector shape the Glassly CFW rasterizes on the glasses. */
+export const ALL_DISPLAY_SHAPES: DisplayShape[] = ["rect", "circle", "arc", "pie", "line", "triangle", "quad", "bezier"]
+
 /**
  * Microphone capabilities
  */

package/src/types/index.ts

@@ -17,6 +17,7 @@ export type {
   PowerCapabilities,
   Capabilities,
 } from "./hardware"
+export {ALL_DISPLAY_SHAPES} from "./hardware"
 
 export {
   HARDWARE_CAPABILITIES,

package/src/utils/display/scene/degrade.ts

@@ -37,6 +37,9 @@ export function degradeScene(input: readonly SceneElementInput[]): DegradedScene
 
   const texts: TextEl[] = []
   input.forEach((el, index) => {
+    if (el && typeof el === "object" && Array.isArray((el as {points?: unknown}).points)) {
+      return // vector shapes: decoration on a text wall
+    }
     if (!el || typeof el !== "object" || !el.box) {
       // Malformed element — report it like the positioning pipeline does
       // instead of silently pretending the render was clean.
@@ -50,7 +53,7 @@ export function degradeScene(input: readonly SceneElementInput[]): DegradedScene
       dropped.push(el.id ?? `image[${index}]`)
       degraded = true
     }
-    // rects: silent drop — pure decoration on a text wall.
+    // rects and other shapes: silent drop — pure decoration on a text wall.
   })
 
   if (texts.length === 0) {

package/src/utils/display/scene/differ.ts

@@ -15,7 +15,7 @@
  * prefixed "~" so they can never collide with app-supplied ids.
  */
 
-import type {FrameElement, SceneBox, SceneChange, SceneElementType} from "./types"
+import type {FrameElement, SceneBox, SceneChange, SceneElementType, ScenePoint, SceneTransition} from "./types"
 import {boxesEqual} from "./types"
 
 /** A processed (clamped/wrapped) element, pre-diff: id optional, no annotation yet. */
@@ -26,6 +26,10 @@ export interface DiffableElement {
   text?: string
   data?: string
   style?: FrameElement["style"]
+  points?: ScenePoint[]
+  startDeg?: number
+  endDeg?: number
+  transition?: SceneTransition
   contentHash: string
 }
 
@@ -54,6 +58,10 @@ function buildFrameElement(el: DiffableElement, id: string, change: SceneChange)
   if (el.text !== undefined) out.text = el.text
   if (el.data !== undefined) out.data = el.data
   if (el.style !== undefined) out.style = el.style
+  if (el.points !== undefined) out.points = el.points
+  if (el.startDeg !== undefined) out.startDeg = el.startDeg
+  if (el.endDeg !== undefined) out.endDeg = el.endDeg
+  if (el.transition !== undefined) out.transition = el.transition
   return out
 }
 

package/src/utils/display/scene/process.ts

@@ -12,8 +12,16 @@ import {TextMeasurer} from "../measurer/TextMeasurer"
 import {TextWrapper} from "../wrapper/TextWrapper"
 import type {DisplayProfile} from "../profiles/types"
 import type {DiffableElement} from "./differ"
-import type {SceneBox, SceneDisplayCapabilities, SceneElementInput, SceneTextStyle} from "./types"
-import {elementContentHash} from "./types"
+import type {
+  SceneBox,
+  SceneBoxInput,
+  SceneDisplayCapabilities,
+  SceneElementInput,
+  ScenePoint,
+  SceneTextStyle,
+  SceneTransition,
+} from "./types"
+import {POINT_SHAPE_ARITY, POINT_SHAPE_TYPES, elementContentHash} from "./types"
 
 export interface ProcessedScene {
   elements: DiffableElement[]
@@ -35,6 +43,35 @@ function clampBox(box: SceneBox, width: number, height: number): SceneBox | null
   return {x: x1, y: y1, w: x2 - x1, h: y2 - y1}
 }
 
+const isFinite = (n: unknown): n is number => typeof n === "number" && Number.isFinite(n)
+
+/** Integer points, or null when the count/values are invalid for the type. */
+function validPoints(el: SceneElementInput): ScenePoint[] | null {
+  const raw = (el as {points?: unknown}).points
+  if (!Array.isArray(raw) || !(POINT_SHAPE_ARITY[el.type] ?? []).includes(raw.length)) return null
+  const points: ScenePoint[] = []
+  for (const p of raw) {
+    if (!p || typeof p !== "object" || !isFinite((p as ScenePoint).x) || !isFinite((p as ScenePoint).y)) return null
+    points.push({x: Math.floor((p as ScenePoint).x), y: Math.floor((p as ScenePoint).y)})
+  }
+  return points
+}
+
+function pointsBox(points: ScenePoint[]): SceneBox {
+  const xs = points.map((p) => p.x)
+  const ys = points.map((p) => p.y)
+  const x = Math.min(...xs)
+  const y = Math.min(...ys)
+  return {x, y, w: Math.max(...xs) - x + 1, h: Math.max(...ys) - y + 1}
+}
+
+function validTransition(t: unknown): SceneTransition | undefined {
+  if (!t || typeof t !== "object") return undefined
+  const {durationMs, easing} = t as SceneTransition
+  if (!isFinite(durationMs) || durationMs <= 0) return undefined
+  return easing ? {durationMs, easing} : {durationMs}
+}
+
 function boxShrunk(orig: SceneBox, clamped: SceneBox): boolean {
   return (
     clamped.x !== Math.floor(orig.x) ||
@@ -77,17 +114,38 @@ export function processScene(
 
   // Validate + dedupe explicit ids (first occurrence wins; dupes are dev error).
   const seenIds = new Set<string>()
-  const valid: {el: SceneElementInput; index: number}[] = []
+  const valid: {el: SceneElementInput; index: number; box: SceneBoxInput; points?: ScenePoint[]}[] = []
   input.forEach((raw, index) => {
-    if (!raw || typeof raw !== "object" || !raw.box) {
+    if (!raw || typeof raw !== "object") {
       dropped.push(reportId(raw ?? ({type: "text"} as SceneElementInput), index))
       degraded = true
       return
     }
+    let points: ScenePoint[] | undefined
+    if (POINT_SHAPE_TYPES.includes(raw.type)) {
+      const valid = validPoints(raw)
+      if (!valid) {
+        dropped.push(reportId(raw, index))
+        degraded = true
+        return
+      }
+      points = valid
+      raw = {...raw, box: pointsBox(valid)} as SceneElementInput
+    }
+    if (!raw.box) {
+      dropped.push(reportId(raw, index))
+      degraded = true
+      return
+    }
     // Non-finite box numbers (NaN/±Infinity/non-number) would survive the
     // Math.* clamp below and poison the frame all the way to native ints.
     const b = raw.box
-    if (![b.x, b.y, b.w, b.h].every((n) => typeof n === "number" && Number.isFinite(n))) {
+    if (![b.x, b.y, b.w, b.h].every(isFinite)) {
+      dropped.push(reportId(raw, index))
+      degraded = true
+      return
+    }
+    if ((raw.type === "arc" || raw.type === "pie") && !(isFinite(raw.startDeg) && isFinite(raw.endDeg))) {
       dropped.push(reportId(raw, index))
       degraded = true
       return
@@ -105,7 +163,7 @@ export function processScene(
       }
       seenIds.add(key)
     }
-    valid.push({el, index})
+    valid.push({el, index, box: el.box as SceneBoxInput, points})
   })
 
   // Clamp + per-type limits, then budget in array order.
@@ -113,16 +171,40 @@ export function processScene(
   let imageBudget = caps.maxImageElements
   const out: DiffableElement[] = []
 
-  for (const {el, index} of valid) {
-    const clamped = clampBox(el.box, caps.width, caps.height)
+  for (const {el, index, box, points} of valid) {
+    const transition = validTransition((el as {transition?: unknown}).transition)
+    const clamped = clampBox(box, caps.width, caps.height)
     if (!clamped) {
       dropped.push(reportId(el, index))
       degraded = true
       continue
     }
-    const shrunk = boxShrunk(el.box, clamped)
+    const shrunk = boxShrunk(box, clamped)
     if (shrunk) degraded = true
 
+    if (el.type !== "text" && el.type !== "image" && el.type !== "rect") {
+      // Vector shapes: only devices that draw them get them; the device clips
+      // point shapes itself, so an off-canvas point is not a drop.
+      if (!caps.shapes.includes(el.type) || textBudget <= 0) {
+        dropped.push(reportId(el, index))
+        degraded = true
+        continue
+      }
+      textBudget--
+      const angles = el.type === "arc" || el.type === "pie" ? {startDeg: el.startDeg, endDeg: el.endDeg} : {}
+      out.push({
+        id: el.id,
+        type: el.type,
+        box: clamped,
+        style: el.style,
+        ...(points ? {points} : {}),
+        ...angles,
+        ...(transition ? {transition} : {}),
+        contentHash: elementContentHash({type: el.type, style: el.style, points, ...angles}),
+      })
+      continue
+    }
+
     if (el.type === "image") {
       // Images: a shrunk box can't be honored (we don't crop pixels host-side)
       // and per-image device limits are box-level (the firmware allocates the
@@ -148,6 +230,7 @@ export function processScene(
         type: "image",
         box: clamped,
         data: el.data,
+        ...(transition ? {transition} : {}),
         contentHash: elementContentHash({type: "image", data: el.data}),
       })
       continue
@@ -167,6 +250,7 @@ export function processScene(
         type: "rect",
         box: clamped,
         style: el.style,
+        ...(transition ? {transition} : {}),
         contentHash: elementContentHash({type: "rect", style: el.style}),
       })
       continue
@@ -188,6 +272,7 @@ export function processScene(
         box: clamped,
         text: monoText,
         style: el.style,
+        ...(transition ? {transition} : {}),
         contentHash: elementContentHash({type: "text", text: monoText, style: el.style}),
       })
       continue
@@ -221,6 +306,7 @@ export function processScene(
       box: clamped,
       text: wrappedText,
       style: el.style,
+      ...(transition ? {transition} : {}),
       contentHash: elementContentHash({type: "text", text: wrappedText, style: el.style}),
     })
   }