@lovelace_lol/polymer 0.0.7 → 0.0.8

package/src/polymer/runtime/rust_embody_host.cljs

@@ -1,647 +0,0 @@
-(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)))]
-    (if (or (nil? normalized) (= "" normalized))
-      "cc4"
-      normalized)))
-
-(defn- normalize-profile-mode
-  [profile-mode]
-  (let [normalized (when (string? profile-mode)
-                     (.toLowerCase (.trim profile-mode)))]
-    (case normalized
-      (nil "" "preset" "embedded-preset") "preset"
-      ("profile" "resolved-profile" "exact" "exact-profile") "profile"
-      (throw (js/Error.
-              (str "Unknown Rust Embody profileMode \"" profile-mode
-                   "\". Expected \"preset\" or \"profile\"."))))))
-
-(defn- profile-json
-  [profile required?]
-  (cond
-    (nil? profile)
-    (if required?
-      (throw (js/Error. "Rust Embody profile mode requires a resolved 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"))
-         resolved-profile? (= profile-mode "profile")
-         preset-id (normalize-preset-id
-                    (or (aget config "presetId") (aget config "presetType")))
-         _ (when (and (not resolved-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") resolved-profile?))
-         profile (atom (if resolved-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 resolved-profile?
-                       (js-call core
-                                "configure_with_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 resolved-profile?))
-               (reset! profile
-                       (if resolved-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 "getPresetId" (fn [] (when-not resolved-profile? preset-id)))
-       (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)