@lovelace_lol/polymer 0.0.1

package/src/polymer/runtime/rust_embody_host.cljs

@@ -0,0 +1,645 @@
+(ns polymer.runtime.rust-embody-host
+  "Polymer-owned CLJS host for Embody's Rust/Wasm RuntimeCore.
+
+  Rust owns profile/preset intake, binding compilation, control state, and
+  packed frame evaluation. This namespace owns the JavaScript object exposed to
+  hosts and the narrow Three.js inspection/application boundary."
+  (:require ["@lovelace_lol/embody" :as embody]
+            [polymer.runtime.embody-wasm :as embody-wasm]))
+
+(def ThreeModelInspector (aget embody "ThreeModelInspector"))
+(def ThreeFrameApplier (aget embody "ThreeFrameApplier"))
+(def ThreeAnimationRuntime (aget embody "ThreeAnimationRuntime"))
+(def ThreeAnimationSystem (aget embody "ThreeAnimationSystem"))
+(def HairPhysicsController (aget embody "HairPhysicsController"))
+(def build-frame-applier-bindings (aget embody "buildFrameApplierBindings"))
+(def get-mesh-names-for-au-profile (aget embody "getMeshNamesForAUProfile"))
+(def get-mesh-names-for-viseme-profile (aget embody "getMeshNamesForVisemeProfile"))
+
+(defn- js-call
+  [target method & args]
+  (let [f (when target (aget target method))]
+    (when-not (fn? f)
+      (throw (js/Error. (str "Character host is missing method: " method))))
+    (.apply f target (to-array args))))
+
+(defn- js-new
+  [ctor & args]
+  (when-not ctor
+    (throw (js/Error. "The installed Embody package is missing a required Three.js adapter export.")))
+  (.construct js/Reflect ctor (to-array args)))
+
+(defn- js-values
+  [value]
+  (if (array? value) (array-seq value) ()))
+
+(defn- clamp01
+  [value]
+  (max 0 (min 1 (if (and (number? value) (js/isFinite value)) value 0))))
+
+(defn- normalize-preset-id
+  [preset-id]
+  (let [normalized (when (string? preset-id) (.toLowerCase (.trim preset-id)))]
+    (case normalized
+      (nil "" "default" "human") "cc4"
+      normalized)))
+
+(defn- normalize-profile-mode
+  [profile-mode]
+  (let [normalized (when (string? profile-mode)
+                     (.toLowerCase (.trim profile-mode)))]
+    (case normalized
+      (nil "" "preset" "embedded-preset") "embedded-preset"
+      ("exact" "exact-profile") "exact-profile"
+      (throw (js/Error.
+              (str "Unknown Rust Embody profileMode \"" profile-mode
+                   "\". Expected \"embedded-preset\" or \"exact-profile\"."))))))
+
+(defn- profile-json
+  [profile required?]
+  (cond
+    (nil? profile)
+    (if required?
+      (throw (js/Error. "Rust Embody exact-profile mode requires a profile object."))
+      "")
+
+    (or (array? profile) (not= "object" (goog/typeOf profile)))
+    (throw (js/Error. "Rust Embody profile must be a JSON object."))
+
+    :else
+    (.stringify js/JSON profile)))
+
+(defn supports-preset?
+  "True when the initialized Rust/Wasm registry contains the requested preset."
+  [preset-id]
+  (let [wasm (embody-wasm/get-core)]
+    (boolean (js-call wasm "has_preset" (normalize-preset-id preset-id)))))
+
+(def supportsRustEmbodyPreset supports-preset?)
+
+(defn- profile-map
+  [profile key]
+  (or (when profile (aget profile key)) #js {}))
+
+(defn- profile-array
+  [profile key]
+  (let [value (when profile (aget profile key))]
+    (if (array? value) value #js [])))
+
+(defn- resolved-meshes
+  [meshes mesh-by-name profile mesh-names]
+  (let [requested (if (and (array? mesh-names) (pos? (.-length mesh-names)))
+                    mesh-names
+                    (let [face (aget (profile-map profile "morphToMesh") "face")]
+                      (if (and (array? face) (pos? (.-length face)))
+                        face
+                        (.map meshes (fn [mesh] (.-name mesh))))))]
+    (keep (fn [name] (.get mesh-by-name name)) (js-values requested))))
+
+(defn- resolve-morph-targets
+  [meshes mesh-by-name profile morph-key mesh-names]
+  (reduce
+   (fn [targets mesh]
+     (let [dictionary (aget mesh "morphTargetDictionary")
+           influences (aget mesh "morphTargetInfluences")
+           index (cond
+                   (number? morph-key) morph-key
+                   dictionary (aget dictionary morph-key)
+                   :else nil)]
+       (if (and influences (number? index) (<= 0 index) (< index (.-length influences)))
+         (conj targets #js {:infl influences :idx index})
+         targets)))
+   []
+   (resolved-meshes meshes mesh-by-name profile mesh-names)))
+
+(defn- current-morph-value
+  [meshes mesh-by-name profile morph-key mesh-names]
+  (reduce
+   (fn [current target]
+     (max current (or (aget (aget target "infl") (aget target "idx")) 0)))
+   0
+   (resolve-morph-targets meshes mesh-by-name profile morph-key mesh-names)))
+
+(defn- mixed-au?
+  [profile au-id]
+  (let [morphs (aget (profile-map profile "auToMorphs") (str au-id))
+        bones (aget (profile-map profile "auToBones") (str au-id))
+        has-morphs (and morphs
+                        (some #(pos? (.-length (or (aget morphs %) #js [])))
+                              ["left" "right" "center"]))]
+    (boolean (and has-morphs (array? bones) (pos? (.-length bones))))))
+
+(defn- animation-method!
+  [host animation-system method]
+  (aset host method
+        (fn [& args]
+          (apply js-call @animation-system method args))))
+
+(def animation-methods
+  ["loadAnimationClips"
+   "getAnimationClips"
+   "removeAnimationClip"
+   "playAnimation"
+   "stopAnimation"
+   "stopAllAnimations"
+   "pauseAnimation"
+   "resumeAnimation"
+   "pauseAllAnimations"
+   "resumeAllAnimations"
+   "setAnimationSpeed"
+   "setAnimationIntensity"
+   "setAnimationLoopMode"
+   "setAnimationRepeatCount"
+   "setAnimationReverse"
+   "setAnimationBlendMode"
+   "seekAnimation"
+   "setAnimationTimeScale"
+   "getAnimationState"
+   "getPlayingAnimations"
+   "crossfadeTo"
+   "snippetToClip"
+   "playClip"
+   "playSnippet"
+   "typedSnippetToClip"
+   "playTypedSnippet"
+   "buildClip"
+   "buildTypedClip"
+   "updateClipParams"
+   "cleanupSnippet"
+   "supportsClipCurves"])
+
+(defn create-rust-embody-host-unbound
+  "Create Polymer's synchronous CLJS host after initEmbodyCore has completed."
+  ([]
+   (create-rust-embody-host-unbound #js {}))
+  ([config]
+   (let [config (or config #js {})
+         wasm (embody-wasm/get-core)
+         profile-mode (normalize-profile-mode (aget config "profileMode"))
+         exact-profile? (= profile-mode "exact-profile")
+         preset-id (normalize-preset-id (aget config "presetType"))
+         _ (when (and (not exact-profile?)
+                      (not (js-call wasm "has_preset" preset-id)))
+             (throw (js/Error.
+                     (str "Rust Embody preset \"" preset-id
+                          "\" is not embedded. Known presets: "
+                          (.join (js-call wasm "list_presets") ", ") "."))))
+         profile-source-json (atom (profile-json (aget config "profile") exact-profile?))
+         profile (atom (if exact-profile?
+                         (.parse js/JSON @profile-source-json)
+                         (.parse js/JSON
+                                 (js-call wasm
+                                          "merge_embedded_preset"
+                                          preset-id
+                                          @profile-source-json))))
+         RuntimeCore (aget wasm "RuntimeCore")
+         core (js-new RuntimeCore 0)
+         inspector (js-new ThreeModelInspector)
+         applier (js-new ThreeFrameApplier)
+         morph-transitions (js-new ThreeAnimationRuntime)
+         model (atom nil)
+         meshes (atom #js [])
+         all-meshes (atom #js [])
+         mesh-by-name (atom (js/Map.))
+         bones (atom #js {})
+         inspection (atom nil)
+         animation-system (atom nil)
+         hair-runtime (atom nil)
+         viseme-values (atom #js [])
+         mix-weights (atom {})
+         running? (atom false)
+         raf-id (atom nil)
+         last-frame-ms (atom nil)
+         host (js-obj)]
+     (letfn [(apply-frame! []
+               (let [morph-frame (js-call core "evaluate_morph_frame_delta")
+                     bone-frame (js-call core "evaluate_bone_frame_delta")]
+                 (when (pos? (.-length morph-frame))
+                   (js-call applier "applyPackedMorphFrameDelta" morph-frame))
+                 (when (pos? (.-length bone-frame))
+                   (js-call applier "applyPackedBoneFrameDelta" bone-frame)
+                   (when @model
+                     (js-call @model "updateMatrixWorld" true)))))
+
+             (bind-model! [mesh-overrides]
+               (when @model
+                 (let [options (if mesh-overrides
+                                 #js {:profile @profile :meshes mesh-overrides}
+                                 #js {:profile @profile})
+                       result (js-call inspector "inspectModel" @model options)
+                       model-meshes (aget result "allMeshes")
+                       runtime-meshes (let [morph-meshes (aget result "morphMeshes")]
+                                        (if (and morph-meshes (pos? (.-length morph-meshes)))
+                                          morph-meshes
+                                          model-meshes))]
+                   (reset! inspection result)
+                   (reset! meshes runtime-meshes)
+                   (reset! all-meshes model-meshes)
+                   (reset! mesh-by-name (aget result "meshByName"))
+                   (reset! bones (aget result "bones"))
+                   (aset host "meshes" runtime-meshes)
+                   (aset host "meshByName" @mesh-by-name)
+                   (aset host "bones" @bones)
+                   (js-call applier "setBindings" (build-frame-applier-bindings result))
+                   (js-call applier
+                            "applyMeshMaterialConfigs"
+                            @model
+                            (profile-map @profile "meshes"))
+                   (when @hair-runtime
+                     (js-call @hair-runtime "registerHairObjects" (to-array (hair-meshes)))
+                     (js-call @hair-runtime
+                              "setHairPhysicsProfileConfig"
+                              (aget @profile "hairPhysics")))
+                   (let [descriptor-json (.stringify js/JSON (aget result "descriptor"))]
+                     (if exact-profile?
+                       (js-call core
+                                "configure_exact_profile"
+                                @profile-source-json
+                                descriptor-json)
+                       (js-call core
+                                "configure_with_preset"
+                                preset-id
+                                @profile-source-json
+                                descriptor-json)))
+                   (apply-frame!))))
+
+             (set-profile! [next-profile]
+               (js-call core "clear")
+               (js-call morph-transitions "clearTransitions")
+               (apply-frame!)
+               (reset! viseme-values #js [])
+               (reset! mix-weights {})
+               (reset! profile-source-json (profile-json next-profile exact-profile?))
+               (reset! profile
+                       (if exact-profile?
+                         (.parse js/JSON @profile-source-json)
+                         (.parse js/JSON
+                                 (js-call wasm
+                                          "merge_embedded_preset"
+                                          preset-id
+                                          @profile-source-json))))
+               (bind-model! @meshes))
+
+             (get-au-mix-weight [au-id]
+               (or (get @mix-weights au-id)
+                   (aget (profile-map @profile "auMixDefaults") (str au-id))
+                   1))
+
+             (set-morph! [morph-key value mesh-names]
+               (let [targets (resolve-morph-targets
+                              @meshes @mesh-by-name @profile morph-key mesh-names)
+                     normalized (clamp01 value)]
+                 (doseq [target targets]
+                   (aset (aget target "infl") (aget target "idx") normalized))))
+
+             (transition-morph! [morph-key value duration-ms mesh-names]
+               (let [targets (resolve-morph-targets
+                              @meshes @mesh-by-name @profile morph-key mesh-names)
+                     from (reduce
+                           (fn [current target]
+                             (max current
+                                  (or (aget (aget target "infl") (aget target "idx")) 0)))
+                           0
+                           targets)
+                     target (clamp01 value)
+                     mesh-key (if (and (array? mesh-names) (pos? (.-length mesh-names)))
+                                (.join mesh-names ",")
+                                "*")]
+                 (js-call morph-transitions
+                          "addTransition"
+                          (str "morph:" mesh-key ":" morph-key)
+                          from
+                          target
+                          (or duration-ms 120)
+                          (fn [next-value]
+                            (doseq [resolved targets]
+                              (aset (aget resolved "infl")
+                                    (aget resolved "idx")
+                                    (clamp01 next-value)))))))
+
+             (update! [dt-seconds]
+               (let [dt (max 0 (if (and (number? dt-seconds) (js/isFinite dt-seconds))
+                                 dt-seconds
+                                 0))]
+                 (when (pos? dt)
+                   (let [active-before (js-call core "active_transition_count")
+                         active-after (js-call core "update" dt)]
+                     (js-call morph-transitions "tick" dt)
+                     (when (or (pos? active-before) (pos? active-after))
+                       (apply-frame!))
+                     (when @animation-system
+                       (js-call @animation-system "update" dt))
+                     (when @hair-runtime
+                       (js-call @hair-runtime "update" dt))))))
+
+             (request-next-frame! []
+               (when @running?
+                 (when-let [request-frame (aget js/globalThis "requestAnimationFrame")]
+                   (reset! raf-id
+                           (.call request-frame
+                                  js/globalThis
+                                  (fn [now-ms]
+                                    (let [previous @last-frame-ms
+                                          dt (if previous
+                                               (/ (max 0 (- now-ms previous)) 1000)
+                                               0)]
+                                      (reset! last-frame-ms now-ms)
+                                      (update! dt)
+                                      (request-next-frame!))))))))
+
+             (stop! []
+               (reset! running? false)
+               (reset! last-frame-ms nil)
+               (when (some? @raf-id)
+                 (when-let [cancel-frame (aget js/globalThis "cancelAnimationFrame")]
+                   (.call cancel-frame js/globalThis @raf-id))
+                 (reset! raf-id nil)))
+
+             (hair-meshes []
+               (filter
+                (fn [mesh]
+                  (let [info (aget (profile-map @profile "meshes") (.-name mesh))
+                        category (when info (aget info "category"))]
+                    (or (= category "hair") (= category "eyebrow"))))
+                (js-values @all-meshes)))]
+       (let [animation-host
+             #js {:getModel (fn [] @model)
+                  :getMeshes (fn [] @meshes)
+                  :getMeshByName (fn [name] (.get @mesh-by-name name))
+                  :getMeshNamesForAU
+                  (fn [au-id] (get-mesh-names-for-au-profile @profile au-id))
+                  :getMeshNamesForViseme
+                  (fn [] (get-mesh-names-for-viseme-profile @profile))
+                  :getCurrentAUValue (fn [au-id] (js-call core "get_au" au-id))
+                  :getCurrentVisemeValue
+                  (fn [index] (or (aget @viseme-values index) 0))
+                  :getCurrentMorphValue
+                  (fn [morph-key mesh-names]
+                    (current-morph-value
+                     @meshes @mesh-by-name @profile morph-key mesh-names))
+                  :getCurrentMorphIndexValue
+                  (fn [morph-index mesh-names]
+                    (current-morph-value
+                     @meshes @mesh-by-name @profile morph-index mesh-names))
+                  :getCurrentBoneQuaternion
+                  (fn [node-key]
+                    (some-> (aget @bones node-key) (aget "obj") (aget "quaternion") (.clone)))
+                  :getCurrentBonePositionValue
+                  (fn [node-key axis]
+                    (some-> (aget @bones node-key) (aget "obj") (aget "position") (aget axis)))
+                  :getBones (fn [] @bones)
+                  :getConfig (fn [] @profile)
+                  :getCompositeRotations
+                  (fn [] (profile-array @profile "compositeRotations"))
+                  :computeSideValues
+                  (fn [base balance]
+                    (let [packed (embody-wasm/solve-bilateral-values base (or balance 0))]
+                      #js {:left (aget packed 0) :right (aget packed 1)}))
+                  :getAUMixWeight get-au-mix-weight
+                  :isMixedAU (fn [au-id] (mixed-au? @profile au-id))
+                  :reapplyProceduralState apply-frame!}]
+         (reset! animation-system (js-new ThreeAnimationSystem animation-host)))
+
+       (let [hair-host
+             #js {:getMeshByName (fn [name] (.get @mesh-by-name name))
+                  :getSelectedHairMeshNames
+                  (fn []
+                    (to-array
+                     (map #(aget % "name")
+                          (filter
+                           (fn [mesh]
+                             (= "hair"
+                                (some-> (aget (profile-map @profile "meshes")
+                                             (aget mesh "name"))
+                                        (aget "category"))))
+                           (js-values @all-meshes)))))
+                  :buildClip
+                  (fn [clip-name curves options]
+                    (js-call @animation-system "buildClip" clip-name curves options))
+                  :cleanupSnippet
+                  (fn [clip-name]
+                    (js-call @animation-system "cleanupSnippet" clip-name))}
+             controller (js-new HairPhysicsController hair-host)]
+         (js-call controller "setCore" wasm)
+         (reset! hair-runtime controller))
+
+       (aset host "onReady"
+             (fn [options]
+               (reset! model (aget options "model"))
+               (bind-model! (aget options "meshes"))))
+       (aset host "bindModel" bind-model!)
+       (aset host "setProfile" set-profile!)
+       (aset host "getProfile" (fn [] @profile))
+       (aset host "getProfileMode" (fn [] profile-mode))
+       (aset host "supportsPreset" (fn [id] (supports-preset? id)))
+       (aset host "setAU"
+             (fn [id value balance]
+               (js-call core "set_au_signed" id value (if (number? balance) balance js/NaN))
+               (apply-frame!)))
+       (aset host "getAU" (fn [id] (js-call core "get_au" id)))
+       (aset host "setContinuum"
+             (fn [negative-au positive-au value balance]
+               (js-call core
+                        "set_continuum"
+                        negative-au
+                        positive-au
+                        value
+                        (if (number? balance) balance js/NaN))
+               (apply-frame!)))
+       (aset host "getContinuum"
+             (fn [negative-au positive-au]
+               (js-call core "get_continuum" negative-au positive-au)))
+       (aset host "transitionAU"
+             (fn [id value duration-ms balance]
+               (js-call core
+                        "transition_au"
+                        id
+                        value
+                        (or duration-ms 200)
+                        (if (number? balance) balance js/NaN))))
+       (aset host "transitionViseme"
+             (fn [index value duration-ms jaw-scale]
+               (js-call core
+                        "transition_viseme"
+                        index
+                        value
+                        (or duration-ms 80)
+                        (or jaw-scale 1))))
+       (aset host "setViseme"
+             (fn [index value jaw-scale]
+               (js-call core "set_viseme" index value)
+               (js-call core "set_viseme_jaw_scale" index (or jaw-scale 1))
+               (aset @viseme-values index value)
+               (apply-frame!)))
+       (aset host "setVisemeById"
+             (fn [slot-id value jaw-scale]
+               (let [index (js-call core "viseme_slot_index" slot-id)]
+                 (when (<= 0 index)
+                   (js-call host "setViseme" index value (or jaw-scale 1))))))
+       (aset host "transitionVisemeById"
+             (fn [slot-id value duration-ms jaw-scale]
+               (let [index (js-call core "viseme_slot_index" slot-id)]
+                 (when (<= 0 index)
+                   (js-call host
+                            "transitionViseme"
+                            index
+                            value
+                            (or duration-ms 80)
+                            (or jaw-scale 1))))))
+       (aset host "setAUMixWeight"
+             (fn [id weight]
+               (swap! mix-weights assoc id weight)
+               (js-call core "set_au_mix_weight" id weight)
+               (apply-frame!)))
+       (aset host "getAUMixWeight" get-au-mix-weight)
+       (aset host "hasLeftRightBones"
+             (fn [au-id]
+               (let [bindings (aget (profile-map @profile "auToBones") (str au-id))
+                     sides (set (map #(aget % "side") (js-values bindings)))]
+                 (and (contains? sides "left") (contains? sides "right")))))
+       (aset host "setMorph"
+             (fn
+               ([morph-key value] (set-morph! morph-key value nil))
+               ([morph-key value mesh-names] (set-morph! morph-key value mesh-names))))
+       (aset host "setMorphOnMeshes"
+             (fn [mesh-names morph-key value]
+               (set-morph! morph-key value mesh-names)))
+       (aset host "transitionMorph"
+             (fn
+               ([morph-key value] (transition-morph! morph-key value 120 nil))
+               ([morph-key value duration-ms]
+                (transition-morph! morph-key value duration-ms nil))
+               ([morph-key value duration-ms mesh-names]
+                (transition-morph! morph-key value duration-ms mesh-names))))
+       (aset host "getMorphTargets"
+             (fn []
+                 (let [result (js-obj)]
+                   (doseq [mesh (js-values @meshes)]
+                   (when-let [dictionary (aget mesh "morphTargetDictionary")]
+                     (aset result
+                           (aget mesh "name")
+                           (.sort (.keys js/Object dictionary)))))
+                 result)))
+       (aset host "getMorphTargetIndices"
+             (fn []
+                 (let [result (js-obj)]
+                   (doseq [mesh (js-values @meshes)]
+                   (when-let [dictionary (aget mesh "morphTargetDictionary")]
+                     (let [entries (.map
+                                    (.entries js/Object dictionary)
+                                    (fn [entry]
+                                      #js {:name (aget entry 0) :index (aget entry 1)}))]
+                       (.sort entries (fn [a b] (- (.-index a) (.-index b))))
+                       (aset result (aget mesh "name") entries))))
+                 result)))
+       (aset host "getHairMorphTargets"
+             (fn
+               ([] (js-call @hair-runtime "getHairMorphTargets"))
+               ([mesh-name] (js-call @hair-runtime "getHairMorphTargets" mesh-name))))
+       (aset host "getMeshList"
+             (fn []
+               (.map
+                @all-meshes
+                (fn [mesh]
+                  (let [mesh-name (aget mesh "name")
+                        info (aget (profile-map @profile "meshes") mesh-name)]
+                    #js {:name mesh-name
+                         :visible (aget mesh "visible")
+                         :morphCount (.-length (or (aget mesh "morphTargetInfluences") #js []))
+                         :category (or (when info (aget info "category")) "other")})))))
+       (aset host "getBones" (fn [] @bones))
+       (aset host "setMeshVisible"
+             (fn [mesh-name visible]
+               (when @model
+                 (js-call applier "setMeshVisible" @model mesh-name visible))))
+       (aset host "highlightMesh"
+             (fn
+               ([mesh-name]
+                (when @model (js-call applier "highlightMesh" @model mesh-name)))
+               ([mesh-name color]
+                (when @model (js-call applier "highlightMesh" @model mesh-name color)))
+               ([mesh-name color intensity]
+                (when @model
+                  (js-call applier "highlightMesh" @model mesh-name color intensity)))))
+       (aset host "getMeshMaterialConfig"
+             (fn [mesh-name]
+               (when @model
+                 (js-call applier "getMeshMaterialConfig" @model mesh-name))))
+       (aset host "setMeshMaterialConfig"
+             (fn [mesh-name material-config]
+               (when @model
+                 (js-call applier
+                          "setMeshMaterialConfig"
+                          @model
+                          mesh-name
+                          material-config))))
+       (doseq [method ["registerHairObjects"
+                       "getRegisteredHairObjects"
+                       "getHairAppearance"
+                       "setHairColor"
+                       "setEyebrowColor"
+                       "setHairBaseColor"
+                       "setEyebrowBaseColor"
+                       "setHairGlow"
+                       "setEyebrowGlow"
+                       "setHairOutline"
+                       "setHairPhysicsEnabled"
+                       "isHairPhysicsEnabled"
+                       "setHairPhysicsConfig"
+                       "getHairPhysicsConfig"
+                       "validateHairMorphTargets"
+                       "applyHairStateToObject"]]
+         (aset host method
+               (fn [& args]
+                 (apply js-call @hair-runtime method args))))
+       (aset host "updateHairPhysics"
+             (fn [dt-seconds]
+               (js-call @hair-runtime "update" dt-seconds)))
+       (aset host "update" update!)
+       (aset host "start"
+             (fn []
+               (when-not @running?
+                 (reset! running? true)
+                 (reset! last-frame-ms nil)
+                 (request-next-frame!))))
+       (aset host "stop" stop!)
+       (aset host "clear"
+             (fn []
+               (js-call core "clear")
+               (js-call morph-transitions "clearTransitions")
+               (apply-frame!)))
+       (aset host "resetToNeutral" (aget host "clear"))
+       (aset host "dispose"
+             (fn []
+               (stop!)
+               (when @animation-system
+                 (js-call @animation-system "dispose"))
+               (when @hair-runtime
+                 (js-call @hair-runtime "clearRegisteredHairObjects"))
+               (when-let [free (aget core "free")]
+                 (.call free core))
+               (reset! model nil)
+               (reset! meshes #js [])
+               (reset! all-meshes #js [])
+               (reset! mesh-by-name (js/Map.))
+               (reset! bones #js {})))
+
+       (doseq [method animation-methods]
+         (animation-method! host animation-system method))
+       host))))
+
+(def createRustEmbodyHostUnbound create-rust-embody-host-unbound)
+
+(defn create-rust-embody-host
+  "Create a Polymer CLJS host and bind an already-loaded Three.js model."
+  ([model]
+   (create-rust-embody-host model #js {}))
+  ([model config]
+   (-> (embody-wasm/init-core!)
+       (.then
+        (fn [_]
+          (let [host (create-rust-embody-host-unbound config)]
+            (js-call host "onReady" #js {:model model :meshes (aget config "meshes")})
+            host))))))
+
+(def createRustEmbodyHost create-rust-embody-host)