@lovelace_lol/polymer 0.0.1

package/src/polymer/runtime/embody.cljs

@@ -0,0 +1,117 @@
+(ns polymer.runtime.embody
+  (:require ["@lovelace_lol/embody" :as embody]
+            [polymer.runtime.rust-embody-host :as rust-host]))
+
+;; Polymer is the package boundary for character runtime APIs. LoomLarge imports
+;; these helpers from Polymer, while Polymer remains free to change the concrete
+;; Embody/Three.js implementation behind this boundary later.
+;; scripts/embody-export-contract.mjs is the canonical public export list; CI
+;; verifies this namespace, shadow-cljs, dist JS, declarations, and the pinned
+;; Embody package against that one contract.
+
+(def Embody (aget embody "Embody"))
+(def BLENDING_MODES (or (.-BLENDING_MODES embody)
+                        (.-THREE_BLENDING_MODES embody)))
+(def THREE_BLENDING_MODES (.-THREE_BLENDING_MODES embody))
+(def collectMorphMeshes (.-collectMorphMeshes embody))
+
+(def analyzeModel (.-analyzeModel embody))
+(def extractModelData (.-extractModelData embody))
+(def getPreset (.-getPreset embody))
+(def validateMappings (.-validateMappings embody))
+(def extendCharacterConfigWithPreset (.-extendCharacterConfigWithPreset embody))
+(def extractProfileOverrides (.-extractProfileOverrides embody))
+(def mergeCharacterRegionsByName (.-mergeCharacterRegionsByName embody))
+
+(def applyAUBoneBindingUpdate (.-applyAUBoneBindingUpdate embody))
+(def applyBilateralAxisBindingUpdate (.-applyBilateralAxisBindingUpdate embody))
+(def applyBoneAxisBindingUpdate (.-applyBoneAxisBindingUpdate embody))
+(def buildBoneAuOptions (.-buildBoneAuOptions embody))
+(def classifyAuAsJointControl (.-classifyAuAsJointControl embody))
+(def createBilateralBoneAxisAu (.-createBilateralBoneAxisAu embody))
+(def createBoneAxisAu (.-createBoneAxisAu embody))
+(def DEFAULT_AXIS_TO_CHANNEL (.-DEFAULT_AXIS_TO_CHANNEL embody))
+(def DEFAULT_BONE_MAX_DEGREES (.-DEFAULT_BONE_MAX_DEGREES embody))
+(def ensureBilateralBoneNodeKeys (.-ensureBilateralBoneNodeKeys embody))
+(def ensureBoneNodeKey (.-ensureBoneNodeKey embody))
+(def findNodeKeyForBone (.-findNodeKeyForBone embody))
+(def formatAxisDirectionLabel (.-formatAxisDirectionLabel embody))
+(def formatAxisLabel (.-formatAxisLabel embody))
+(def getAUBoneBindingState (.-getAUBoneBindingState embody))
+(def getAxisFromChannel (.-getAxisFromChannel embody))
+(def getBilateralAxisBindingState (.-getBilateralAxisBindingState embody))
+(def getBoneAxisBindingState (.-getBoneAxisBindingState embody))
+(def inferChiralBoneNamePair (.-inferChiralBoneNamePair embody))
+(def inferEyeControlFamily (.-inferEyeControlFamily embody))
+(def inferEyeControlScope (.-inferEyeControlScope embody))
+(def isJointControlAuInfo (.-isJointControlAuInfo embody))
+(def isMaxDegreesOnlyAxisBindingUpdate (.-isMaxDegreesOnlyAxisBindingUpdate embody))
+(def JOINT_CONTROL_SECTION (.-JOINT_CONTROL_SECTION embody))
+(def resolveBoneAxisChannel (.-resolveBoneAxisChannel embody))
+(def resolveBoneNameForNodeKey (.-resolveBoneNameForNodeKey embody))
+(def resolveContinuumDisplayLabel (.-resolveContinuumDisplayLabel embody))
+(def stripConfiguredBoneAffixes (.-stripConfiguredBoneAffixes embody))
+
+(def computeCameraRelativeGazeOffset (.-computeCameraRelativeGazeOffset embody))
+(def detectAnnotationLaterality (.-detectAnnotationLaterality embody))
+(def fuzzyNameMatch (.-fuzzyNameMatch embody))
+(def getDefaultAnnotationLaterality (.-getDefaultAnnotationLaterality embody))
+(def getMeshNamesForAUProfile (.-getMeshNamesForAUProfile embody))
+(def getModelLocalOrbitAngle (.-getModelLocalOrbitAngle embody))
+(def getSemanticHorizontalSign (.-getSemanticHorizontalSign embody))
+(def getSemanticHorizontalSignForSide (.-getSemanticHorizontalSignForSide embody))
+(def getWorldDirectionForCameraAngle (.-getWorldDirectionForCameraAngle embody))
+(def hasLeftRightMorphs (.-hasLeftRightMorphs embody))
+(def isMixedAU (.-isMixedAU embody))
+(def passesMarkerCameraAngleGate (.-passesMarkerCameraAngleGate embody))
+(def resolveBoneNames (.-resolveBoneNames embody))
+(def resolveFaceCenter (.-resolveFaceCenter embody))
+(def resolveRegionCameraAngle (.-resolveRegionCameraAngle embody))
+(def resolveRegionVisibilityCameraAngle (.-resolveRegionVisibilityCameraAngle embody))
+(def toWorldDirection (.-toWorldDirection embody))
+(def RustAnnotationCameraCore (.-RustAnnotationCameraCore embody))
+(def createRustAnnotationCameraCore (.-createRustAnnotationCameraCore embody))
+
+(def CC4_BONES (or (aget embody "CC4_BONES")
+                   (aget embody "CC4_BONE_NODES")))
+(def VISEME_KEYS (.-VISEME_KEYS embody))
+
+;; Hair appearance/materials are Embody runtime APIs (not a Polymer agency).
+;; Re-export so hosts can import presets/helpers from Polymer without depending
+;; on @lovelace_lol/embody directly.
+(def HAIR_COLOR_PRESETS (.-HAIR_COLOR_PRESETS embody))
+(def DEFAULT_HAIR_COLOR_APPEARANCE (.-DEFAULT_HAIR_COLOR_APPEARANCE embody))
+(def normalizeHairColorAppearance (.-normalizeHairColorAppearance embody))
+
+(def HUMANOID_SKELETON_TEMPLATES (.-HUMANOID_SKELETON_TEMPLATES embody))
+(def JONATHAN_HUMANOID_SKELETON_TEMPLATE (.-JONATHAN_HUMANOID_SKELETON_TEMPLATE embody))
+(def getHumanoidSkeletonTemplate (.-getHumanoidSkeletonTemplate embody))
+(def getHumanoidSkeletonTemplateBoneNames (.-getHumanoidSkeletonTemplateBoneNames embody))
+(def createValidationSkeletonFromHumanoidTemplate (.-createValidationSkeletonFromHumanoidTemplate embody))
+(def computeHumanoidSkeletonTemplateRestBounds (.-computeHumanoidSkeletonTemplateRestBounds embody))
+(def extractHumanoidSkeletonTemplateFromModel (.-extractHumanoidSkeletonTemplateFromModel embody))
+
+(def createCharacterHost (.-createCharacterHost embody))
+
+;; Polymer owns the CLJS host boundary and talks directly to RuntimeCore. Embody
+;; contributes only the Wasm ABI and reusable Three.js inspection/application
+;; utilities.
+(def createRustEmbodyHost rust-host/createRustEmbodyHost)
+(def createRustEmbodyHostUnbound rust-host/createRustEmbodyHostUnbound)
+(def supportsRustEmbodyPreset rust-host/supportsRustEmbodyPreset)
+
+(def createDefaultCharacterScene (.-createDefaultCharacterScene embody))
+(def createDefaultCharacterLighting (.-createDefaultCharacterLighting embody))
+(def createShadowPlane (.-createShadowPlane embody))
+(def loadCharacterModel (.-loadCharacterModel embody))
+(def parseCharacterModel (.-parseCharacterModel embody))
+(def applyCharacterModelTransform (.-applyCharacterModelTransform embody))
+(def disposeCharacterModel (.-disposeCharacterModel embody))
+(def DEFAULT_CHARACTER_LIGHTING_PRESET_ID (.-DEFAULT_CHARACTER_LIGHTING_PRESET_ID embody))
+(def DEFAULT_CHARACTER_LIGHTING_PRESET_IDS (.-DEFAULT_CHARACTER_LIGHTING_PRESET_IDS embody))
+(def DEFAULT_CHARACTER_LIGHTING_PRESETS (.-DEFAULT_CHARACTER_LIGHTING_PRESETS embody))
+(def DEFAULT_CHARACTER_LIGHTING_SETTINGS (.-DEFAULT_CHARACTER_LIGHTING_SETTINGS embody))
+(def normalizeDefaultCharacterLightingSettings (.-normalizeDefaultCharacterLightingSettings embody))
+(def CHARACTER_SCENE_TYPES (.-CHARACTER_SCENE_TYPES embody))
+(def CHARACTER_SCENE_TYPE_IDS (.-CHARACTER_SCENE_TYPE_IDS embody))
+(def DEFAULT_CHARACTER_SCENE_TYPE_ID (.-DEFAULT_CHARACTER_SCENE_TYPE_ID embody))

package/src/polymer/runtime/embody_wasm.cljs

@@ -0,0 +1,177 @@
+(ns polymer.runtime.embody-wasm
+  "Direct CLJS access to the Embody Rust/Wasm core.
+
+  Agencies and LoomLarge tooling should load numeric kernels through this
+  namespace rather than going through the TypeScript Embody facade. The Three.js
+  adapter (polymer.runtime.embody / Embody class) remains responsible for scene
+  graph mutation, AnimationMixer, and host writes."
+  (:require ["@lovelace_lol/embody/wasm" :as wasm]))
+
+;; Public aliases in this namespace are listed in
+;; scripts/embody-export-contract.mjs and validated across source, shadow-cljs,
+;; checked-in dist JS, declarations, and the pinned upstream Wasm entry.
+
+(def ^:private *core (atom nil))
+(def ^:private *init-promise (atom nil))
+
+(defn- js-call
+  [obj method & args]
+  (let [f (aget obj method)]
+    (when-not (fn? f)
+      (throw (js/Error. (str "Embody Wasm module is missing method: " method))))
+    (apply f args)))
+
+(defn core-ready?
+  "True when init-core! has resolved a Wasm module."
+  []
+  (some? @*core))
+
+(defn get-core
+  "Return the initialized Wasm module or throw."
+  []
+  (or @*core
+      (throw (js/Error. "Embody Wasm core is not initialized. Call initEmbodyCore / init-core! first."))))
+
+(defn init-core!
+  "Initialize the Embody Wasm core via @lovelace_lol/embody/wasm.
+
+  Returns a Promise that resolves to the Wasm module. Subsequent calls reuse
+  the same in-flight or completed initialization."
+  []
+  (if-let [pending @*init-promise]
+    pending
+    (let [pending
+          (-> (wasm/initEmbodyCore)
+              (.then
+               (fn [mod]
+                 (let [expected (or (.-EMBODY_CORE_ABI_VERSION wasm) 1)
+                       actual (js-call mod "core_abi_version")]
+                   (when (not= actual expected)
+                     (throw (js/Error.
+                             (str "Embody Wasm ABI mismatch: runtime=" actual
+                                  " expected=" expected))))
+                   (reset! *core mod)
+                   mod)))
+              (.catch
+               (fn [err]
+                 (reset! *init-promise nil)
+                 (throw err))))]
+      (reset! *init-promise pending)
+      pending)))
+
+;; JS-friendly aliases for shadow-cljs / TypeScript consumers
+(def initEmbodyCore init-core!)
+(def isEmbodyCoreReady core-ready?)
+(def getEmbodyCore get-core)
+
+(defn core-abi-version
+  []
+  (js-call (get-core) "core_abi_version"))
+
+(def coreAbiVersion core-abi-version)
+
+(defn pack-morph-frame-delta
+  [mesh-ids morph-target-ids values modes]
+  (js-call (get-core) "pack_morph_frame_delta" mesh-ids morph-target-ids values modes))
+
+(def packMorphFrameDelta pack-morph-frame-delta)
+
+(defn solve-bilateral-values
+  [base balance]
+  (js-call (get-core) "solve_bilateral_values" base balance))
+
+(def solveBilateralValues solve-bilateral-values)
+
+(defn solve-morph-batch
+  [values balances mix-weights]
+  (js-call (get-core) "solve_morph_batch" values balances mix-weights))
+
+(def solveMorphBatch solve-morph-batch)
+
+(defn solve-axis-quaternion
+  [axis degrees value scale]
+  (js-call (get-core) "solve_axis_quaternion" axis degrees value scale))
+
+(def solveAxisQuaternion solve-axis-quaternion)
+
+(defn analyze-mesh-proportions
+  [vertices vertical-axis]
+  (js-call (get-core) "analyze_mesh_proportions" vertices vertical-axis))
+
+(def analyzeMeshProportions analyze-mesh-proportions)
+
+(defn solve-template-skeleton-fit
+  [mesh-vertices template-bounds vertical-axis vertical-anchor]
+  (js-call (get-core)
+           "solve_template_skeleton_fit"
+           mesh-vertices
+           template-bounds
+           vertical-axis
+           vertical-anchor))
+
+(def solveTemplateSkeletonFit solve-template-skeleton-fit)
+
+(defn compose-template-fit-adjustment
+  [fit scale-multiplier offset-x offset-y offset-z]
+  (js-call (get-core)
+           "compose_template_fit_adjustment"
+           fit
+           scale-multiplier
+           offset-x
+           offset-y
+           offset-z))
+
+(def composeTemplateFitAdjustment compose-template-fit-adjustment)
+
+(defn compose-template-skeleton-fit-transform
+  [fit-scale fit-translation manual-scale manual-translation]
+  (js-call (get-core)
+           "compose_template_skeleton_fit_transform"
+           fit-scale
+           fit-translation
+           manual-scale
+           manual-translation))
+
+(def composeTemplateSkeletonFitTransform compose-template-skeleton-fit-transform)
+
+(defn default-hair-physics-config-values
+  []
+  (js-call (get-core) "default_hair_physics_config_values"))
+
+(def defaultHairPhysicsConfigValues default-hair-physics-config-values)
+
+(defn create-hair-physics-solver
+  "Construct a Wasm HairPhysicsSolver from optional packed config values."
+  ([]
+   (create-hair-physics-solver (default-hair-physics-config-values)))
+  ([config-values]
+   (let [Ctor (aget (get-core) "HairPhysicsSolver")]
+     (when-not Ctor
+       (throw (js/Error. "Embody Wasm module does not export HairPhysicsSolver")))
+     (new Ctor config-values))))
+
+(def createHairPhysicsSolver create-hair-physics-solver)
+
+(defn create-runtime-core
+  "Construct the Wasm live morph RuntimeCore (AU/viseme state -> packed
+  morph FrameDelta rows). Load bindings with load_au_morph_bindings /
+  load_viseme_morph_bindings before evaluating."
+  [viseme-slot-count]
+  (let [Ctor (aget (get-core) "RuntimeCore")]
+    (when-not Ctor
+      (throw (js/Error. "Embody Wasm module does not export RuntimeCore")))
+    (new Ctor viseme-slot-count)))
+
+(def createRuntimeCore create-runtime-core)
+
+;; Re-export ABI constants from the JS wasm entry for consumers that need them
+;; before init completes.
+(def EMBODY_CORE_ABI_VERSION (or (.-EMBODY_CORE_ABI_VERSION wasm) 1))
+(def PACKED_MORPH_FRAME_DELTA_STRIDE (.-PACKED_MORPH_FRAME_DELTA_STRIDE wasm))
+(def HAIR_CONFIG_STRIDE (.-HAIR_CONFIG_STRIDE wasm))
+(def HAIR_STATE_STRIDE (.-HAIR_STATE_STRIDE wasm))
+(def HAIR_HEAD_STATE_STRIDE (.-HAIR_HEAD_STATE_STRIDE wasm))
+(def HAIR_MORPH_OUTPUT_STRIDE (.-HAIR_MORPH_OUTPUT_STRIDE wasm))
+(def MESH_PROPORTIONS_STRIDE (.-MESH_PROPORTIONS_STRIDE wasm))
+(def TEMPLATE_SKELETON_FIT_SOLUTION_STRIDE (.-TEMPLATE_SKELETON_FIT_SOLUTION_STRIDE wasm))
+(def TEMPLATE_SKELETON_FIT_TRANSFORM_STRIDE (.-TEMPLATE_SKELETON_FIT_TRANSFORM_STRIDE wasm))