@lovelace_lol/polymer 0.0.1

package/src/polymer/gaze/state.cljs

@@ -0,0 +1,202 @@
+(ns polymer.gaze.state
+  (:require [polymer.gaze.domain :as domain]))
+
+;; Gaze state is a local ledger of attention targets and accepted look requests.
+;; It is serializable diagnostic data; high-frequency eye/head execution belongs
+;; in the downstream movement agency that consumes Gaze requests.
+
+(def default-config
+  {:enabled true
+   :eyesEnabled true
+   :headEnabled true
+   :headFollowEyes true
+   :mirrored false
+   :smoothFactor 0.25
+   :minDelta 0.01
+   :transitionDurationMs 300
+   :eyeIntensity 1.0
+   :headIntensity 0.5
+   :coalesceMs 16})
+
+(defn input-value
+  [input camel-key kebab-key fallback]
+  (let [camel (get input camel-key ::missing)
+        kebab (get input kebab-key ::missing)]
+    (cond
+      (not= camel ::missing) camel
+      (not= kebab ::missing) kebab
+      :else fallback)))
+
+(defn normalize-config
+  [config]
+  (let [input (merge default-config (domain/data-map config))]
+    {:enabled (boolean (input-value input :enabled :enabled (:enabled default-config)))
+     :eyesEnabled (boolean (input-value input :eyesEnabled :eyes-enabled (:eyesEnabled default-config)))
+     :headEnabled (boolean (input-value input :headEnabled :head-enabled (:headEnabled default-config)))
+     :headFollowEyes (boolean (input-value input :headFollowEyes :head-follow-eyes (:headFollowEyes default-config)))
+     :mirrored (boolean (input-value input :mirrored :mirrored (:mirrored default-config)))
+     :smoothFactor (domain/clamp 0 1
+                                 (domain/number-or (input-value input :smoothFactor :smooth-factor nil)
+                                                   (:smoothFactor default-config)))
+     :minDelta (domain/clamp 0 1
+                             (domain/number-or (input-value input :minDelta :min-delta nil)
+                                               (:minDelta default-config)))
+     :transitionDurationMs (int (domain/clamp 50 3000
+                                              (domain/number-or
+                                               (input-value input :transitionDurationMs :transition-duration-ms nil)
+                                               (:transitionDurationMs default-config))))
+     :eyeIntensity (domain/clamp 0 2
+                                 (domain/number-or (input-value input :eyeIntensity :eye-intensity nil)
+                                                   (:eyeIntensity default-config)))
+     :headIntensity (domain/clamp 0 2
+                                  (domain/number-or (input-value input :headIntensity :head-intensity nil)
+                                                    (:headIntensity default-config)))
+     :coalesceMs (int (domain/clamp 0 1000
+                                    (domain/number-or (input-value input :coalesceMs :coalesce-ms nil)
+                                                      (:coalesceMs default-config))))}))
+
+(defn default-state
+  [config]
+  {:agency "gaze"
+   :status "idle"
+   :mode "manual"
+   :active false
+   :rawTarget domain/zero-target
+   :target domain/zero-target
+   :baseTarget domain/zero-target
+   :cameraRelativeOffset domain/zero-target
+   :lastCameraFact nil
+   :lastRequestedTarget domain/zero-target
+   :pendingRequest nil
+   :lastRequest nil
+   :lastIgnored nil
+   :lastPlan nil
+   :lastEvent nil
+   :receivedCount 0
+   :plannedCount 0
+   :requestedCount 0
+   :ignoredCount 0
+   :resetCount 0
+   :cancelCount 0
+   :config (normalize-config config)})
+
+(defn config->state
+  [config]
+  (default-state config))
+
+(defn visible-state
+  [state]
+  (clj->js state))
+
+(defn configure
+  [state config]
+  (assoc state :config (normalize-config (merge (:config state)
+                                                (domain/data-map config)))))
+
+(defn reset-state
+  [state]
+  (default-state (:config state)))
+
+(defn set-mode
+  [state mode now-ms]
+  (assoc state
+         :mode (or mode "manual")
+         :lastEvent {:type "gaze.status"
+                     :status (:status state)
+                     :mode (or mode "manual")
+                     :at now-ms}))
+
+(defn set-active
+  [state active now-ms]
+  (assoc state
+         :active (boolean active)
+         :lastEvent {:type "gaze.status"
+                     :status (:status state)
+                     :active (boolean active)
+                     :at now-ms}))
+
+(defn set-enabled
+  [state enabled now-ms]
+  (assoc-in (assoc state
+                   :lastEvent {:type "gaze.status"
+                               :status (if enabled "enabled" "disabled")
+                               :at now-ms})
+            [:config :enabled]
+            (boolean enabled)))
+
+(defn record-plan
+  [state plan]
+  (-> state
+      (assoc :status "planning"
+             :rawTarget (:rawTarget plan)
+             :target (:target plan)
+             :baseTarget (or (:baseTarget plan) (:target plan))
+             :cameraRelativeOffset (or (:cameraRelativeOffset plan)
+                                       (:cameraRelativeOffset state))
+             :lastCameraFact (or (:cameraFact plan)
+                                 (:lastCameraFact state))
+             :lastPlan plan
+             :lastEvent {:type "gaze.targetPlanned"
+                         :requestId (:requestId plan)
+                         :at (:createdAt plan)})
+      (update :receivedCount inc)
+      (update :plannedCount inc)))
+
+(defn record-pending
+  [state request]
+  (assoc state
+         :status "pending"
+         :pendingRequest request
+         :lastEvent {:type "gaze.requestQueued"
+                     :requestId (:requestId request)
+                     :at (:queuedAt request)}))
+
+(defn record-requested
+  [state request published-at]
+  (-> state
+      (assoc :status "requested"
+             :pendingRequest nil
+             :lastRequest (assoc request :publishedAt published-at)
+             :lastRequestedTarget (:target request)
+             :lastEvent {:type "eyeHeadTracking.requestGaze"
+                         :requestId (:requestId request)
+                         :at published-at})
+      (update :requestedCount inc)))
+
+(defn record-ignored
+  [state ignored]
+  (-> state
+      (assoc :status "ignored"
+             :lastIgnored ignored
+             :lastEvent {:type "gaze.targetIgnored"
+                         :reason (:reason ignored)
+                         :requestId (:requestId ignored)
+                         :at (:ignoredAt ignored)})
+      (update :ignoredCount inc)))
+
+(defn record-reset
+  [state request]
+  (-> state
+      (assoc :status "reset"
+             :rawTarget domain/zero-target
+             :target domain/zero-target
+             :baseTarget domain/zero-target
+             :cameraRelativeOffset domain/zero-target
+             :lastCameraFact nil
+             :lastRequestedTarget domain/zero-target
+             :pendingRequest nil
+             :lastRequest request
+             :lastEvent {:type "eyeHeadTracking.requestReset"
+                         :requestId (:requestId request)
+                         :at (:requestedAt request)})
+      (update :resetCount inc)))
+
+(defn record-cancel
+  [state request]
+  (-> state
+      (assoc :status "cancelled"
+             :pendingRequest nil
+             :lastEvent {:type "eyeHeadTracking.requestCancel"
+                         :requestId (:requestId request)
+                         :at (:requestedAt request)})
+      (update :cancelCount inc)))

package/src/polymer/gesture/agency.cljs

@@ -0,0 +1,185 @@
+(ns polymer.gesture.agency
+  (:require [polymer.gesture.goap :as goap]
+            [polymer.gesture.scheduler :as scheduler]
+            [polymer.gesture.snippet :as snippet]
+            [polymer.gesture.state :as state]
+            [polymer.stream :as stream]))
+
+;; Gesture consumes authored arm/hand gesture snapshots and emits animation
+;; intent. It does not own host persistence, host UI state, scene bones, or the
+;; animation runtime.
+
+(defn js-command [type value]
+  #js {:type type :value value})
+
+(defn plan-error-message [plan]
+  (let [step (or (some #(when (= "fail" (:op %)) %) (:steps plan))
+                 (first (:steps plan)))]
+    (case (:reason step)
+      "unsupported-command" (str "Gesture plan failed: unsupported command " (:commandType step))
+      "missing-emoji" "Gesture playEmoji command requires emoji"
+      "missing-gesture" "Gesture command requires gestureId"
+      "missing-goal" "Gesture goal command requires a gesture goal, intent, tag, scope, emoji, or effector constraint"
+      "unknown-gesture" (str "Unknown gesture: " (:gestureId step))
+      "gesture-has-no-motion" (str "Gesture has no bone motion: " (:gestureId step))
+      "empty-library" "Gesture plan failed: gesture library is empty"
+      "no-gesture-candidate" "Gesture plan failed: no gesture matched the goal"
+      (str "Gesture plan failed: " (:reason step)))))
+
+(defn should-emit-plan? [plan]
+  (or (false? (:ok plan))
+      (not (:noop plan))
+      (contains? goap/playable-command-types (get-in plan [:goal :type]))))
+
+(defn public-plan [plan]
+  (-> plan
+      (dissoc :gesture)
+      (update :goal dissoc :gesture :activeSnippets :config)))
+
+(defn create-gesture-agency [config]
+  (let [input-stream (stream/create-stream)
+        event-stream (stream/create-stream)
+        state-atom (atom (state/config->state config))
+        disposed? (atom false)
+        agency-scheduler (atom nil)
+        emit-input (:emit input-stream)
+        emit-event (:emit event-stream)]
+    (letfn [(complete-active! [name]
+              (when (get-in @state-atom [:activeSnippets name])
+                (remove-active! [name] "completed")))
+
+            (emit-plan! [plan]
+              (when (should-emit-plan? plan)
+                (emit-event {:type "gesturePlanCreated"
+                             :agency "gesture"
+                             :plan (public-plan plan)})))
+
+            (remove-active! [names reason]
+              (let [removed-at (state/now-ms)]
+                ((:remove-many @agency-scheduler) names reason)
+                (doseq [name names]
+                  (swap! state-atom state/record-remove name reason removed-at)
+                  (emit-event {:type "gestureRemoved"
+                               :agency "gesture"
+                               :name name
+                               :reason reason
+                               :removedAt removed-at}))))
+
+            (schedule-gesture! [gesture context]
+              (let [context (or context {})
+                    snippet-data (snippet/build-gesture-snippet gesture
+                                                                (:config @state-atom)
+                                                                context)]
+                (if snippet-data
+                  (do
+                    ((:schedule @agency-scheduler) snippet-data {:autoPlay true})
+                    (let [scheduled-at (state/now-ms)]
+                      (swap! state-atom state/record-schedule gesture snippet-data scheduled-at)
+                      (emit-event {:type "gestureScheduled"
+                                   :agency "gesture"
+                                   :gestureId (:id gesture)
+                                   :gestureName (:name gesture)
+                                   :emoji (:emoji gesture)
+                                   :scope (:scope gesture)
+                                   :affectedBones (:affectedBones gesture)
+                                   :name (:name snippet-data)
+                                   :trigger (:trigger context)
+                                   :intent (:intent context)
+                                   :scheduledAt scheduled-at}))
+                    snippet-data)
+                  (emit-event {:type "error"
+                               :agency "gesture"
+                               :message (str "Gesture produced no animation channels: " (:id gesture))}))))
+
+            (dispatch! [command]
+              (when-not @disposed?
+                (let [payload (state/js-data command)
+                      type (:type payload)
+                      now (state/now-ms)
+                      plan (goap/plan-command payload @state-atom now)]
+                  (emit-input {:type "command"
+                               :agency "gesture"
+                               :command payload})
+                  (emit-plan! plan)
+                  (if (false? (:ok plan))
+                    (emit-event {:type "error"
+                                 :agency "gesture"
+                                 :message (plan-error-message plan)})
+                    (case type
+                      "configure"
+                      (do
+                        (swap! state-atom state/configure (:config payload))
+                        (emit-event {:type "gestureConfigChanged"
+                                     :agency "gesture"
+                                     :state (state/visible-state-map @state-atom)}))
+
+                      "loadGestures"
+                      (let [loaded-at (state/now-ms)]
+                        (swap! state-atom state/load-gestures
+                               (or (:gestures payload)
+                                   (:characterGestures payload)
+                                   (:gestureLibrary payload))
+                               (or (:emojiMappings payload) (:gestureEmojiMappings payload))
+                               loaded-at)
+                        (emit-event {:type "gestureLibraryUpdated"
+                                     :agency "gesture"
+                                     :gestureCount (count (:gestures @state-atom))
+                                     :emojiCount (count (:emojiMappings @state-atom))
+                                     :updatedAt loaded-at}))
+
+                      ("playGesture" "playEmoji" "gesture.goal" "performGestureGoal" "playGoal")
+                      (when-not (:noop plan)
+                        (doseq [step (:steps plan)]
+                          (when (= "remove-active-gestures" (:op step))
+                            (remove-active! (:names step) (:reason step))))
+                        (schedule-gesture! (:gesture plan) (merge payload (:context plan))))
+
+                      "stopGesture"
+                      (remove-active! (:removeNames plan) (:removeReason plan))
+
+                      "stopAll"
+                      (remove-active! (:removeNames plan) (:removeReason plan))
+
+                      "reset"
+                      (do
+                        (remove-active! (:removeNames plan) (:removeReason plan))
+                        (reset! state-atom (state/config->state nil))
+                        (emit-event {:type "gestureConfigChanged"
+                                     :agency "gesture"
+                                     :state (state/visible-state-map @state-atom)}))
+
+                      (emit-event {:type "error"
+                                   :agency "gesture"
+                                   :message (str "Unknown Gesture command: " type)}))))))]
+      (reset! agency-scheduler
+              (scheduler/create-scheduler
+               {:emit-event emit-event
+                :on-complete complete-active!}))
+      #js {:dispatch dispatch!
+           :snapshot (fn [] (state/visible-state @state-atom))
+           :schedulerQueue (fn [] (clj->js ((:queue @agency-scheduler))))
+           :input (stream/writable-port input-stream dispatch!)
+           :events (stream/readable-port event-stream)
+           :subscribeInput (fn [listener] ((:subscribe input-stream) listener))
+           :subscribeEvents (fn [listener] ((:subscribe event-stream) listener))
+           :subscribe (fn [listener] ((:subscribe event-stream) listener))
+           :subscribeStatus (fn [listener] ((:subscribe event-stream) listener))
+           :configure (fn [next-config] (dispatch! #js {:type "configure" :config next-config}))
+           :loadGestures (fn
+                           ([gestures] (dispatch! #js {:type "loadGestures" :gestures gestures}))
+                           ([gestures emoji-mappings]
+                            (dispatch! #js {:type "loadGestures"
+                                            :gestures gestures
+                                            :emojiMappings emoji-mappings})))
+           :playGesture (fn [gesture-id] (dispatch! #js {:type "playGesture" :gestureId gesture-id}))
+           :playEmoji (fn [emoji] (dispatch! #js {:type "playEmoji" :emoji emoji}))
+           :performGoal (fn [goal] (dispatch! #js {:type "gesture.goal" :goal goal}))
+           :stopGesture (fn [gesture-id] (dispatch! #js {:type "stopGesture" :gestureId gesture-id}))
+           :stopAll (fn [] (dispatch! #js {:type "stopAll"}))
+           :reset (fn [] (dispatch! #js {:type "reset"}))
+           :dispose (fn []
+                      (when-not @disposed?
+                        (reset! disposed? true)
+                        ((:dispose @agency-scheduler))
+                        ((:dispose input-stream))
+                        ((:dispose event-stream))))})))