🥮 mooncakes.io

    moonbvhkit

    MoonBit-native BVH motion capture parser, validator, analysis helpers, and asset pipeline toolkit.

    bvh
    mocap
    animation
    gamedev
    moonbit
    Download zip
    Version
    0.2.0
    License
    MIT
    Repository
    Last updated
    last month
    Downloads
    13

    #MoonBVHKit

    简体中文

    CI Mooncakes License: MIT

    MoonBVHKit is a MoonBit-native BVH motion capture parser, validator, analysis helper library, and asset-pipeline reporting toolkit.

    #Status

    Version 0.2.0 is published on Mooncakes. The release contains a reusable library, multi-mode CLI, basic example, 90 tests, complete documentation, strict CI, and Mooncakes metadata for zhangbowen2006/moonbvhkit.

    Repository target: https://github.com/zhangbowen2006/MoonBVHKit.git.

    Author/submission: 张博文.

    #Supported Scope

    • ASCII BVH HIERARCHY parsing for ROOT, nested JOINT, and End Site.
    • OFFSET, standard position channels, and standard rotation channels.
    • MOTION parsing with Frames: and Frame Time:.
    • Fixed-width frame data as Array[Array[Double]].
    • Query helpers for joint names, paths, channel order, per-joint frame values, root position, and root motion.
    • Skeleton summaries, signatures, compatibility diffs, and name-based retarget maps.
    • Motion slicing, frame lookup by time, root-speed sampling, root teleport detection, and root-origin normalization.
    • Duration-preserving nearest-neighbor resampling and root-motion spatial bounds.
    • Validation for malformed source, channel offsets, unknown channels, frame counts, frame widths, and importer-oriented warnings.
    • Import quality scoring with severity signals and recommended CI actions.
    • Unity, Blender, strict CI, and preview import profiles for reusable asset-gate decisions.
    • Named multi-asset gates with aggregate decisions and per-asset results.
    • Text, JSON, CSV, and JUnit XML reporting for automation.
    • Unity and Blender integration metadata plans, without depending on either application.

    #Not Supported in 0.2

    • Blender Python add-on or Unity Editor plug-in.
    • Binary/private BVH variants.
    • Rotation baking, retargeting, IK, skeleton solving, or coordinate-system conversion.
    • Reading external files from the CLI. The CLI uses a built-in fixture so it is deterministic in CI.
    • GLTF, FBX, USD, or other model formats.

    #Install

    moon add zhangbowen2006/moonbvhkit@0.2.0

    For local development, clone the repository and run the commands below from the project root.

    moon check
moon build
moon test
moon run cmd/main
moon run cmd/main -- --json
moon run cmd/main -- --csv
moon run cmd/main -- --quality --json
moon run cmd/main -- --profiles --csv
moon run cmd/main -- --bounds --json
moon run cmd/main -- --resample 12
moon run cmd/main -- --batch --profile strict-ci --csv
moon run cmd/main -- --junit
moon run examples/basic

    On Windows, the complete acceptance sequence can also be reproduced with:

    powershell -ExecutionPolicy Bypass -File scripts/verify_acceptance.ps1

    #Minimal Example

    test "parse a BVH clip" {
      let parsed = @moonbvhkit.parse_bvh(@moonbvhkit.fixture_walk_bvh())
      assert_true(parsed.ok)
      let doc = parsed.document
      let stats = @moonbvhkit.analyze_bvh(doc)
      assert_eq(stats.joint_count, 4)
      assert_eq(stats.channel_count, 15)
    }

    #CLI

    The CLI parses the built-in walk fixture and prints a deterministic report.

    moon run cmd/main
moon run cmd/main -- --json
moon run cmd/main -- --csv
moon run cmd/main -- --quality
moon run cmd/main -- --quality --json
moon run cmd/main -- --profile unity
moon run cmd/main -- --profile blender --json
moon run cmd/main -- --profile strict-ci --csv
moon run cmd/main -- --profiles
moon run cmd/main -- --bounds --json
moon run cmd/main -- --resample 12
moon run cmd/main -- --batch --profile strict-ci --json
moon run cmd/main -- --junit
moon run cmd/main -- --help

    Supported profiles are unity, blender, strict-ci, and preview.

    #API Summary

    AreaPublic API
    Parsetokenize_bvh, parse_bvh, parse_bvh_or_empty
    ModelBvhDocument, BvhJoint, BvhMotion, BvhChannel, BvhVec3
    Queryjoint_names, joint_paths, find_joint, find_joint_by_path, channels_in_motion_order
    Framesframe_values_for_joint, frame_values_for_joint_name, root_position_at, joint_rotation_at
    Analysisanalyze_bvh, channel_ranges, widest_channel_range, detect_static_channels, sample_root_motion
    Skeletonskeleton_bones, summarize_skeleton, compare_skeletons, build_name_based_retarget_map
    Motion Toolsslice_document, resample_document_nearest, frame_at_time, root_motion_bounds, root_speed_samples, detect_root_teleports, normalize_root_origin
    Validationvalidate_bvh, validate_document, validation_summary
    Qualityquality_report, quality_report_from_bvh, quality_report_to_text, quality_report_to_json, quality_report_to_csv, quality_report_to_junit_xml, quality_action_for_bvh
    Import Profilesunity_import_profile, blender_import_profile, strict_ci_import_profile, evaluate_import_profile, evaluate_bvh_batch, import_decision_to_json
    Exportdocument_to_json, joint_table_csv, channel_range_csv, root_motion_csv
    Integrationbuild_unity_clip_plan, build_blender_import_plan, bvh_runtime_manifest
    Reportbuild_report, format_report, bvh_fixture_report

    #Project Positioning

    MoonBVHKit fills a MoonBit ecosystem gap for motion-capture asset inspection. It is useful for game developers, tool authors, and CI pipelines that need to inspect BVH clips before importing them into Unity, Blender, Godot, or custom runtimes.

    The project deliberately does not bind to Unity or Blender. Instead, it provides portable validation and metadata that those workflows can consume.

    No functionally equivalent MoonBit BVH or motion-capture asset-gate package was found in the Mooncakes ecosystem during the final project review on 2026-08-18.

    #Documentation

    #Originality and References

    This is an original MoonBit implementation. It references the public BVH text format structure commonly used by motion-capture tools, but does not copy code from another project.

    All fixtures in this repository are handwritten synthetic data and do not contain third-party motion-capture assets.

    See Source and Provenance for dependency, generated-file, fixture, and AI-assistance disclosure. The project is maintained by 张博文 through the GitHub account zhangbowen2006; author information is recorded in AUTHORS.md.

    #License

    MIT.

    BvhBatchAssetDecision

    source
    pub(all) struct BvhBatchAssetDecision {
      asset_name : String
      decision : BvhImportDecision
    } derive(Eq, 
    Debug    )

    BvhBatchImportReport

    source
    pub(all) struct BvhBatchImportReport {
      profile_name : String
      asset_count : Int
      accepted_count : Int
      blocked_count : Int
      assets : Array[BvhBatchAssetDecision]
    } derive(Eq, 
    Debug    )

    BvhBatchImportReport::all_accepted

    source
    fn BvhBatchImportReport::all_accepted(self : BvhBatchImportReport) -> Bool

    BvhBlenderImportPlan

    source
    pub(all) struct BvhBlenderImportPlan {
      armature_name : String
      bone_count : Int
      leaf_count : Int
      frame_start : Int
      frame_end : Int
      fps : Double
      preserve_root_motion : Bool
      axis_notes : Array[String]
    } derive(Eq, 
    Debug    )

    BvhChannel

    source
    pub(all) enum BvhChannel {
      ChannelXPosition
      ChannelYPosition
      ChannelZPosition
      ChannelXRotation
      ChannelYRotation
      ChannelZRotation
      ChannelUnknown(String)
    } derive(Eq, 
    Debug    )

    BvhChannel::axis

    source
    fn BvhChannel::axis(self : BvhChannel) -> String

    BvhChannel::from_string

    source
    fn BvhChannel::from_string(name : String) -> BvhChannel

    BvhChannel::is_known

    source
    fn BvhChannel::is_known(self : BvhChannel) -> Bool

    BvhChannel::is_position

    source
    fn BvhChannel::is_position(self : BvhChannel) -> Bool

    BvhChannel::is_rotation

    source
    fn BvhChannel::is_rotation(self : BvhChannel) -> Bool

    BvhChannel::to_string

    source
    fn BvhChannel::to_string(self : BvhChannel) -> String

    BvhChannelMean

    source
    pub(all) struct BvhChannelMean {
      index : Int
      name : String
      mean : Double
      sample_count : Int
    } derive(Eq, 
    Debug    )

    BvhChannelMean::new

    source
    fn BvhChannelMean::new(index : Int, name : String, mean : Double, sample_count : Int) -> BvhChannelMean

    BvhChannelRange

    source
    pub(all) struct BvhChannelRange {
      path : String
      channel : String
      index : Int
      min : Double
      max : Double
      span : Double
    } derive(Eq, 
    Debug    )

    BvhChannelRange::new

    source
    fn BvhChannelRange::new(path : String, channel : String, index : Int, min : Double, max : Double) -> BvhChannelRange

    BvhDocument

    source
    pub(all) struct BvhDocument {
      root : BvhJoint
      motion : BvhMotion
      source_length : Int
      token_count : Int
    } derive(Eq, 
    Debug    )

    BvhDocument::channel_count

    source
    fn BvhDocument::channel_count(self : BvhDocument) -> Int

    BvhDocument::duration_seconds

    source
    fn BvhDocument::duration_seconds(self : BvhDocument) -> Double

    BvhDocument::empty

    source
    fn BvhDocument::empty() -> BvhDocument

    BvhDocument::end_site_count

    source
    fn BvhDocument::end_site_count(self : BvhDocument) -> Int

    BvhDocument::is_complete

    source
    fn BvhDocument::is_complete(self : BvhDocument) -> Bool

    BvhDocument::joint_count

    source
    fn BvhDocument::joint_count(self : BvhDocument) -> Int

    BvhEndSite

    source
    pub(all) struct BvhEndSite {
      path : String
      offset : BvhVec3
      depth : Int
    } derive(Eq, 
    Debug    )

    BvhEndSite::empty

    source
    fn BvhEndSite::empty() -> BvhEndSite

    BvhEndSite::new

    source
    fn BvhEndSite::new(path : String, offset : BvhVec3, depth : Int) -> BvhEndSite

    BvhError

    source
    pub(all) struct BvhError {
      kind : BvhErrorKind
      line : Int
      column : Int
      token : String
      message : String
    } derive(Eq, 
    Debug    )

    BvhError::code

    source
    fn BvhError::code(self : BvhError) -> String

    BvhError::is_error

    source
    fn BvhError::is_error(self : BvhError) -> Bool

    BvhError::new

    source
    fn BvhError::new(kind : BvhErrorKind, message : String, line? : Int, column? : Int, token? : String) -> BvhError

    BvhError::none

    source
    fn BvhError::none() -> BvhError

    BvhErrorKind

    source
    pub(all) enum BvhErrorKind {
      ErrorNone
      ErrorEmptyInput
      ErrorUnexpectedToken
      ErrorUnexpectedEof
      ErrorInvalidNumber
      ErrorInvalidHierarchy
      ErrorInvalidMotion
      ErrorFrameWidthMismatch
      ErrorUnsupportedFeature
    } derive(Eq, 
    Debug    )

    Error categories returned by the tokenizer, parser, validator, and report API.

    BvhErrorKind::code

    source
    fn BvhErrorKind::code(self : BvhErrorKind) -> String

    BvhFrameWindow

    source
    pub(all) struct BvhFrameWindow {
      start_frame : Int
      end_frame : Int
      frame_count : Int
      duration_seconds : Double
    } derive(Eq, 
    Debug    )

    BvhFrameWindow::new

    source
    fn BvhFrameWindow::new(start_frame : Int, end_frame : Int, frame_time : Double) -> BvhFrameWindow

    BvhImportDecision

    source
    pub(all) struct BvhImportDecision {
      profile_name : String
      accepted : Bool
      action : String
      quality : BvhQualityReport
      issues : Array[BvhValidationIssue]
    } derive(Eq, 
    Debug    )

    BvhImportDecision::error_count

    source
    fn BvhImportDecision::error_count(self : BvhImportDecision) -> Int

    BvhImportDecision::issue_count

    source
    fn BvhImportDecision::issue_count(self : BvhImportDecision) -> Int

    BvhImportDecision::ok

    source
    fn BvhImportDecision::ok(self : BvhImportDecision) -> Bool

    BvhImportDecision::warning_count

    source
    fn BvhImportDecision::warning_count(self : BvhImportDecision) -> Int

    BvhImportProfile

    source
    pub(all) struct BvhImportProfile {
      kind : BvhImportProfileKind
      name : String
      max_joint_count : Int
      max_depth : Int
      max_duration_seconds : Double
      min_frame_rate : Double
      max_frame_rate : Double
      max_root_speed : Double
      max_root_teleport : Double
      min_quality_score : Int
      require_root_position : Bool
      allow_unknown_channels : Bool
      allow_child_position_channels : Bool
      require_loop_closure : Bool
    } derive(Eq, 
    Debug    )

    BvhImportProfile::new

    source
    fn BvhImportProfile::new(kind : BvhImportProfileKind, name : String, max_joint_count? : Int, max_depth? : Int, max_duration_seconds? : Double, min_frame_rate? : Double, max_frame_rate? : Double, max_root_speed? : Double, max_root_teleport? : Double, min_quality_score? : Int, require_root_position? : Bool, allow_unknown_channels? : Bool, allow_child_position_channels? : Bool, require_loop_closure? : Bool) -> BvhImportProfile

    BvhImportProfileKind

    source
    pub(all) enum BvhImportProfileKind {
      ProfileUnity
      ProfileBlender
      ProfileStrictCI
      ProfilePreview
    } derive(Eq, 
    Debug    )

    BvhImportProfileKind::to_string

    source
    fn BvhImportProfileKind::to_string(self : BvhImportProfileKind) -> String

    BvhIssueSeverity

    source
    pub(all) enum BvhIssueSeverity {
      IssueError
      IssueWarning
      IssueInfo
    } derive(Eq, 
    Debug    )

    BvhIssueSeverity::to_string

    source
    fn BvhIssueSeverity::to_string(self : BvhIssueSeverity) -> String

    BvhJoint

    source
    pub(all) struct BvhJoint {
      name : String
      path : String
      kind : BvhJointKind
      offset : BvhVec3
      channels : Array[BvhChannel]
      channel_start : Int
      channel_count : Int
      depth : Int
      children : Array[BvhJoint]
      end_sites : Array[BvhEndSite]
    } derive(Eq, 
    Debug    )

    BvhJoint::empty

    source
    fn BvhJoint::empty() -> BvhJoint

    BvhJoint::has_channel

    source
    fn BvhJoint::has_channel(self : BvhJoint, channel : BvhChannel) -> Bool

    BvhJoint::is_root

    source
    fn BvhJoint::is_root(self : BvhJoint) -> Bool

    BvhJoint::position_channel_count

    source
    fn BvhJoint::position_channel_count(self : BvhJoint) -> Int

    BvhJoint::rotation_channel_count

    source
    fn BvhJoint::rotation_channel_count(self : BvhJoint) -> Int

    BvhJointKind

    source
    pub(all) enum BvhJointKind {
      JointRoot
      JointRegular
    } derive(Eq, 
    Debug    )

    BvhJointKind::to_string

    source
    fn BvhJointKind::to_string(self : BvhJointKind) -> String

    BvhMotion

    source
    pub(all) struct BvhMotion {
      frame_count : Int
      frame_time : Double
      channel_count : Int
      frames : Array[Array[Double]]
    } derive(Eq, 
    Debug    )

    BvhMotion::duration_seconds

    source
    fn BvhMotion::duration_seconds(self : BvhMotion) -> Double

    BvhMotion::empty

    source
    fn BvhMotion::empty() -> BvhMotion

    BvhMotion::is_empty

    source
    fn BvhMotion::is_empty(self : BvhMotion) -> Bool

    BvhNamedAsset

    source
    pub(all) struct BvhNamedAsset {
      name : String
      source : String
    } derive(Eq, 
    Debug    )

    BvhNamedAsset::new

    source
    fn BvhNamedAsset::new(name : String, source : String) -> BvhNamedAsset

    BvhParseResult

    source
    pub(all) struct BvhParseResult {
      ok : Bool
      document : BvhDocument
      error : BvhError
    } derive(Eq, 
    Debug    )

    BvhParseResult::failure

    source
    fn BvhParseResult::failure(error : BvhError) -> BvhParseResult

    BvhParseResult::is_ok

    source
    fn BvhParseResult::is_ok(self : BvhParseResult) -> Bool

    BvhParseResult::success

    source
    fn BvhParseResult::success(document : BvhDocument) -> BvhParseResult

    BvhPoseSample

    source
    pub(all) struct BvhPoseSample {
      frame_index : Int
      root_position : BvhVec3
      root_delta_from_first : BvhVec3
    } derive(Eq, 
    Debug    )

    BvhPoseSample::new

    source
    fn BvhPoseSample::new(frame_index : Int, root_position : BvhVec3, root_delta_from_first : BvhVec3) -> BvhPoseSample

    BvhQualityGrade

    source
    pub(all) enum BvhQualityGrade {
      QualityExcellent
      QualityUsable
      QualityNeedsReview
      QualityBlocked
    } derive(Eq, 
    Debug    )

    BvhQualityGrade::recommended_action

    source
    fn BvhQualityGrade::recommended_action(self : BvhQualityGrade) -> String

    BvhQualityGrade::to_string

    source
    fn BvhQualityGrade::to_string(self : BvhQualityGrade) -> String

    BvhQualityReport

    source
    pub(all) struct BvhQualityReport {
      grade : BvhQualityGrade
      score : Int
      signals : Array[BvhQualitySignal]
      recommended_action : String
    } derive(Eq, 
    Debug    )

    BvhQualityReport::new

    source
    fn BvhQualityReport::new(score : Int, signals : Array[BvhQualitySignal]) -> BvhQualityReport

    BvhQualityReport::ok_for_import

    source
    fn BvhQualityReport::ok_for_import(self : BvhQualityReport) -> Bool

    BvhQualitySignal

    source
    pub(all) struct BvhQualitySignal {
      severity : BvhIssueSeverity
      code : String
      score_delta : Int
      message : String
    } derive(Eq, 
    Debug    )

    BvhQualitySignal::new

    source
    fn BvhQualitySignal::new(severity : BvhIssueSeverity, code : String, score_delta : Int, message : String) -> BvhQualitySignal

    BvhReport

    source
    pub(all) struct BvhReport {
      ok : Bool
      summary : String
      stats : BvhStats
      validation : BvhValidationReport
      error_code : String
    } derive(Eq, 
    Debug    )

    BvhReport::failure

    source
    fn BvhReport::failure(error : BvhError) -> BvhReport

    BvhReport::success

    source
    fn BvhReport::success(summary : String, stats : BvhStats, validation : BvhValidationReport) -> BvhReport

    BvhReportFormat

    source
    pub(all) enum BvhReportFormat {
      ReportText
      ReportJson
      ReportCsv
    } derive(Eq, 
    Debug    )

    BvhRetargetMapEntry

    source
    pub(all) struct BvhRetargetMapEntry {
      source_path : String
      target_path : String
      source_channel_count : Int
      target_channel_count : Int
      channel_compatible : Bool
      notes : String
    } derive(Eq, 
    Debug    )

    BvhRetargetMapEntry::new

    source
    fn BvhRetargetMapEntry::new(source_path : String, target_path : String, source_channel_count : Int, target_channel_count : Int) -> BvhRetargetMapEntry

    BvhRootMotionBounds

    source
    pub(all) struct BvhRootMotionBounds {
      min_position : BvhVec3
      max_position : BvhVec3
      size : BvhVec3
      sample_count : Int
    } derive(Eq, 
    Debug    )

    BvhRootMotionBounds::empty

    source

    BvhRootTeleport

    source
    pub(all) struct BvhRootTeleport {
      frame_index : Int
      distance : Double
      threshold : Double
    } derive(Eq, 
    Debug    )

    BvhRootTeleport::new

    source
    fn BvhRootTeleport::new(frame_index : Int, distance : Double, threshold : Double) -> BvhRootTeleport

    BvhRuntimeManifest

    source
    pub(all) struct BvhRuntimeManifest {
      package_name : String
      version : String
      supported_format : String
      entries : Array[BvhSupportEntry]
    } derive(Eq, 
    Debug    )

    BvhSkeletonBone

    source
    pub(all) struct BvhSkeletonBone {
      path : String
      parent_path : String
      name : String
      depth : Int
      offset : BvhVec3
      offset_length : Double
      channel_count : Int
      has_end_site : Bool
    } derive(Eq, 
    Debug    )

    BvhSkeletonBone::new

    source
    fn BvhSkeletonBone::new(path : String, parent_path : String, name : String, depth : Int, offset : BvhVec3, channel_count : Int, has_end_site : Bool) -> BvhSkeletonBone

    BvhSkeletonDiff

    source
    pub(all) struct BvhSkeletonDiff {
      compatible : Bool
      matched_paths : Array[String]
      missing_paths : Array[String]
      extra_paths : Array[String]
      channel_mismatch_paths : Array[String]
      offset_warning_paths : Array[String]
    } derive(Eq, 
    Debug    )

    BvhSkeletonDiff::issue_count

    source
    fn BvhSkeletonDiff::issue_count(self : BvhSkeletonDiff) -> Int

    BvhSkeletonDiff::new

    source
    fn BvhSkeletonDiff::new(matched_paths : Array[String], missing_paths : Array[String], extra_paths : Array[String], channel_mismatch_paths : Array[String], offset_warning_paths : Array[String]) -> BvhSkeletonDiff

    BvhSkeletonSummary

    source
    pub(all) struct BvhSkeletonSummary {
      root_name : String
      bone_count : Int
      leaf_count : Int
      end_site_count : Int
      max_depth : Int
      total_offset_length : Double
      signature : String
    } derive(Eq, 
    Debug    )

    BvhSkeletonSummary::empty

    source

    BvhSpeedSample

    source
    pub(all) struct BvhSpeedSample {
      frame_index : Int
      seconds : Double
      distance_from_previous : Double
      speed_units_per_second : Double
    } derive(Eq, 
    Debug    )

    BvhSpeedSample::new

    source
    fn BvhSpeedSample::new(frame_index : Int, seconds : Double, distance_from_previous : Double, speed_units_per_second : Double) -> BvhSpeedSample

    BvhStats

    source
    pub(all) struct BvhStats {
      joint_count : Int
      end_site_count : Int
      max_depth : Int
      channel_count : Int
      frame_count : Int
      frame_time : Double
      duration_seconds : Double
      root_motion_distance : Double
    } derive(Eq, 
    Debug    )

    BvhStats::empty

    source
    fn BvhStats::empty() -> BvhStats

    BvhSupportEntry

    source
    pub(all) struct BvhSupportEntry {
      feature : String
      status : String
      notes : String
    } derive(Eq, 
    Debug    )

    BvhSupportEntry::new

    source
    fn BvhSupportEntry::new(feature : String, status : String, notes : String) -> BvhSupportEntry

    BvhToken

    source
    pub(all) struct BvhToken {
      kind : BvhTokenKind
      text : String
      line : Int
      column : Int
    } derive(Eq, 
    Debug    )

    BvhToken::is_text

    source
    fn BvhToken::is_text(self : BvhToken, text : String) -> Bool

    BvhToken::new

    source
    fn BvhToken::new(kind : BvhTokenKind, text : String, line : Int, column : Int) -> BvhToken

    BvhTokenKind

    source
    pub(all) enum BvhTokenKind {
      TokenWord
      TokenOpenBrace
      TokenCloseBrace
    } derive(Eq, 
    Debug    )

    BvhTokenizeResult

    source
    pub(all) struct BvhTokenizeResult {
      ok : Bool
      tokens : Array[BvhToken]
      error : BvhError
    } derive(Eq, 
    Debug    )

    BvhTokenizeResult::failure

    source

    BvhTokenizeResult::success

    source

    BvhUnityClipPlan

    source
    pub(all) struct BvhUnityClipPlan {
      clip_name : String
      frame_rate : Double
      duration_seconds : Double
      root_joint : String
      joint_paths : Array[String]
      root_motion_delta : BvhVec3
      warnings : Array[String]
    } derive(Eq, 
    Debug    )

    BvhValidationIssue

    source
    pub(all) struct BvhValidationIssue {
      severity : BvhIssueSeverity
      path : String
      code : String
      message : String
    } derive(Eq, 
    Debug    )

    BvhValidationIssue::error

    source
    fn BvhValidationIssue::error(code : String, message : String, path? : String) -> BvhValidationIssue

    BvhValidationIssue::info

    source
    fn BvhValidationIssue::info(code : String, message : String, path? : String) -> BvhValidationIssue

    BvhValidationIssue::new

    source
    fn BvhValidationIssue::new(severity : BvhIssueSeverity, code : String, message : String, path? : String) -> BvhValidationIssue

    BvhValidationIssue::warning

    source
    fn BvhValidationIssue::warning(code : String, message : String, path? : String) -> BvhValidationIssue

    BvhValidationReport

    source
    pub(all) struct BvhValidationReport {
      issues : Array[BvhValidationIssue]
      error_count : Int
      warning_count : Int
      info_count : Int
    } derive(Eq, 
    Debug    )

    BvhValidationReport::new

    source

    BvhValidationReport::ok

    source

    BvhVec3

    source
    pub(all) struct BvhVec3 {
      x : Double
      y : Double
      z : Double
    } derive(Eq, 
    Debug    )

    BvhVec3::add

    source
    fn BvhVec3::add(self : BvhVec3, other : BvhVec3) -> BvhVec3

    BvhVec3::magnitude

    source
    fn BvhVec3::magnitude(self : BvhVec3) -> Double

    BvhVec3::new

    source
    fn BvhVec3::new(x : Double, y : Double, z : Double) -> BvhVec3

    BvhVec3::scale

    source
    fn BvhVec3::scale(self : BvhVec3, factor : Double) -> BvhVec3

    BvhVec3::sub

    source
    fn BvhVec3::sub(self : BvhVec3, other : BvhVec3) -> BvhVec3

    BvhVec3::to_csv

    source
    fn BvhVec3::to_csv(self : BvhVec3) -> String

    BvhVec3::zero

    source
    fn BvhVec3::zero() -> BvhVec3

    analyze_bvh

    source
    fn analyze_bvh(document : BvhDocument) -> BvhStats

    average_root_speed

    source
    fn average_root_speed(document : BvhDocument) -> Double

    batch_import_report_to_csv

    source
    fn batch_import_report_to_csv(report : BvhBatchImportReport) -> String

    batch_import_report_to_json

    source
    fn batch_import_report_to_json(report : BvhBatchImportReport) -> String

    blender_import_plan_to_json

    source
    fn blender_import_plan_to_json(plan : BvhBlenderImportPlan) -> String

    blender_import_profile

    source
    fn blender_import_profile() -> BvhImportProfile

    build_blender_import_plan

    source
    fn build_blender_import_plan(document : BvhDocument, armature_name? : String) -> BvhBlenderImportPlan

    build_name_based_retarget_map

    source
    fn build_name_based_retarget_map(source : BvhDocument, target : BvhDocument) -> Array[BvhRetargetMapEntry]

    build_report

    source
    fn build_report(input : String) -> BvhReport

    build_unity_clip_plan

    source
    fn build_unity_clip_plan(document : BvhDocument, clip_name? : String) -> BvhUnityClipPlan

    bvh_fixture_report

    source
    fn bvh_fixture_report(format? : BvhReportFormat) -> String

    bvh_runtime_manifest

    source
    fn bvh_runtime_manifest() -> BvhRuntimeManifest

    bvh_summary_line

    source
    fn bvh_summary_line(document : BvhDocument) -> String

    bvh_tokens_to_text

    source
    fn bvh_tokens_to_text(tokens : Array[BvhToken]) -> String

    channel_index_for_path

    source
    fn channel_index_for_path(document : BvhDocument, path : String, channel : BvhChannel) -> Int

    channel_names

    source
    fn channel_names(channels : Array[BvhChannel]) -> Array[String]

    channel_range_csv

    source
    fn channel_range_csv(document : BvhDocument) -> String

    channel_ranges

    source
    fn channel_ranges(document : BvhDocument) -> Array[BvhChannelRange]

    channels_in_motion_order

    source
    fn channels_in_motion_order(document : BvhDocument) -> Array[String]

    channels_to_json

    source
    fn channels_to_json(channels : Array[BvhChannel]) -> String

    clamp_frame_index

    source
    fn clamp_frame_index(document : BvhDocument, frame_index : Int) -> Int

    compare_skeletons

    source
    fn compare_skeletons(reference : BvhDocument, candidate : BvhDocument, offset_epsilon? : Double) -> BvhSkeletonDiff

    contains_unknown_channels

    source
    fn contains_unknown_channels(joint : BvhJoint) -> Bool

    default_import_profiles

    source
    fn default_import_profiles() -> Array[BvhImportProfile]

    detect_root_teleports

    source
    fn detect_root_teleports(document : BvhDocument, threshold : Double) -> Array[BvhRootTeleport]

    detect_static_channels

    source
    fn detect_static_channels(document : BvhDocument, epsilon? : Double) -> Array[BvhChannelRange]

    document_frame_rate

    source
    fn document_frame_rate(document : BvhDocument) -> Double

    document_to_json

    source
    fn document_to_json(document : BvhDocument) -> String

    end_site_paths

    source
    fn end_site_paths(document : BvhDocument) -> Array[String]

    evaluate_bvh_batch

    source
    fn evaluate_bvh_batch(assets : Array[BvhNamedAsset], profile : BvhImportProfile) -> BvhBatchImportReport

    evaluate_bvh_import_profile

    source
    fn evaluate_bvh_import_profile(input : String, profile : BvhImportProfile) -> BvhImportDecision

    evaluate_default_import_profiles

    source
    fn evaluate_default_import_profiles(document : BvhDocument) -> Array[BvhImportDecision]

    evaluate_import_profile

    source
    fn evaluate_import_profile(document : BvhDocument, profile : BvhImportProfile) -> BvhImportDecision

    find_joint

    source
    fn find_joint(document : BvhDocument, name : String) -> BvhJoint?

    find_joint_by_path

    source
    fn find_joint_by_path(document : BvhDocument, path : String) -> BvhJoint?

    first_frame

    source
    fn first_frame(document : BvhDocument) -> Array[Double]

    fixture_empty_bvh

    source
    fn fixture_empty_bvh() -> String

    fixture_invalid_frame_width

    source
    fn fixture_invalid_frame_width() -> String

    fixture_invalid_missing_motion

    source
    fn fixture_invalid_missing_motion() -> String

    fixture_static_pose_bvh

    source
    fn fixture_static_pose_bvh() -> String

    fixture_unknown_channel

    source
    fn fixture_unknown_channel() -> String

    fixture_walk_bvh

    source
    fn fixture_walk_bvh() -> String

    format_report

    source
    fn format_report(report : BvhReport, format? : BvhReportFormat) -> String

    frame_at

    source
    fn frame_at(document : BvhDocument, frame_index : Int) -> Array[Double]

    frame_at_time

    source
    fn frame_at_time(document : BvhDocument, seconds : Double) -> Array[Double]

    frame_values_for_joint

    source
    fn frame_values_for_joint(document : BvhDocument, joint : BvhJoint, frame_index : Int) -> Array[Double]

    frame_values_for_joint_name

    source
    fn frame_values_for_joint_name(document : BvhDocument, name : String, frame_index : Int) -> Array[Double]

    frame_window

    source
    fn frame_window(document : BvhDocument, start_frame : Int, end_frame : Int) -> BvhFrameWindow

    has_joint

    source
    fn has_joint(document : BvhDocument, name : String) -> Bool

    import_decision_to_json

    source
    fn import_decision_to_json(decision : BvhImportDecision) -> String

    import_decision_to_text

    source
    fn import_decision_to_text(decision : BvhImportDecision) -> String

    import_decisions_to_csv

    source
    fn import_decisions_to_csv(decisions : Array[BvhImportDecision]) -> String

    import_profile_by_name

    source
    fn import_profile_by_name(name : String) -> BvhImportProfile

    import_profile_issues

    source
    fn import_profile_issues(document : BvhDocument, profile : BvhImportProfile) -> Array[BvhValidationIssue]

    import_profile_to_json

    source
    fn import_profile_to_json(profile : BvhImportProfile) -> String

    import_profiles_to_csv

    source
    fn import_profiles_to_csv(profiles : Array[BvhImportProfile]) -> String

    joint_channel_names

    source
    fn joint_channel_names(joint : BvhJoint) -> Array[String]

    joint_names

    source
    fn joint_names(document : BvhDocument) -> Array[String]

    joint_paths

    source
    fn joint_paths(document : BvhDocument) -> Array[String]

    joint_rotation_at

    source
    fn joint_rotation_at(document : BvhDocument, joint : BvhJoint, frame_index : Int) -> BvhVec3

    joint_table_csv

    source
    fn joint_table_csv(document : BvhDocument) -> String

    joint_to_json

    source
    fn joint_to_json(joint : BvhJoint) -> String

    last_frame

    source
    fn last_frame(document : BvhDocument) -> Array[Double]

    leaf_joint_paths

    source
    fn leaf_joint_paths(document : BvhDocument) -> Array[String]

    loop_closure_error

    source
    fn loop_closure_error(document : BvhDocument) -> Double

    manifest_to_json

    source
    fn manifest_to_json(manifest : BvhRuntimeManifest) -> String

    manifest_to_text

    source
    fn manifest_to_text(manifest : BvhRuntimeManifest) -> String

    max_joint_depth

    source
    fn max_joint_depth(joint : BvhJoint) -> Int

    max_root_speed

    source
    fn max_root_speed(document : BvhDocument) -> Double

    motion_channel_means

    source
    fn motion_channel_means(document : BvhDocument) -> Array[BvhChannelMean]

    nearest_frame_index_at_time

    source
    fn nearest_frame_index_at_time(document : BvhDocument, seconds : Double) -> Int

    normalize_root_origin

    source
    fn normalize_root_origin(document : BvhDocument) -> BvhDocument

    parse_bvh

    source
    fn parse_bvh(input : String) -> BvhParseResult

    Parse ASCII BVH source into hierarchy and motion data.

    parse_bvh_or_empty

    source
    fn parse_bvh_or_empty(input : String) -> BvhDocument

    preview_import_profile

    source
    fn preview_import_profile() -> BvhImportProfile

    quality_action_for_bvh

    source
    fn quality_action_for_bvh(input : String) -> String

    quality_report

    source
    fn quality_report(document : BvhDocument) -> BvhQualityReport

    quality_report_from_bvh

    source
    fn quality_report_from_bvh(input : String) -> BvhQualityReport

    quality_report_to_csv

    source
    fn quality_report_to_csv(report : BvhQualityReport) -> String

    quality_report_to_json

    source
    fn quality_report_to_json(report : BvhQualityReport) -> String

    quality_report_to_junit_xml

    source
    fn quality_report_to_junit_xml(report : BvhQualityReport, suite_name? : String) -> String

    quality_report_to_text

    source
    fn quality_report_to_text(report : BvhQualityReport) -> String

    quality_signal_to_json

    source
    fn quality_signal_to_json(signal : BvhQualitySignal) -> String

    report_to_csv

    source
    fn report_to_csv(report : BvhReport) -> String

    report_to_json

    source
    fn report_to_json(report : BvhReport) -> String

    report_to_text

    source
    fn report_to_text(report : BvhReport) -> String

    resample_document_nearest

    source
    fn resample_document_nearest(document : BvhDocument, target_frame_count : Int) -> BvhDocument

    resample_motion_nearest

    source
    fn resample_motion_nearest(motion : BvhMotion, target_frame_count : Int) -> BvhMotion

    retarget_map_to_csv

    source
    fn retarget_map_to_csv(entries : Array[BvhRetargetMapEntry]) -> String

    root_motion_bounds

    source
    fn root_motion_bounds(document : BvhDocument) -> BvhRootMotionBounds

    root_motion_bounds_to_csv

    source
    fn root_motion_bounds_to_csv(bounds : BvhRootMotionBounds) -> String

    root_motion_bounds_to_json

    source
    fn root_motion_bounds_to_json(bounds : BvhRootMotionBounds) -> String

    root_motion_csv

    source
    fn root_motion_csv(document : BvhDocument) -> String

    root_motion_delta

    source
    fn root_motion_delta(document : BvhDocument) -> BvhVec3

    root_motion_distance

    source
    fn root_motion_distance(document : BvhDocument) -> Double

    root_position_at

    source
    fn root_position_at(document : BvhDocument, frame_index : Int) -> BvhVec3

    root_speed_samples

    source
    fn root_speed_samples(document : BvhDocument) -> Array[BvhSpeedSample]

    sample_root_motion

    source
    fn sample_root_motion(document : BvhDocument, max_samples? : Int) -> Array[BvhPoseSample]

    skeleton_bones

    source
    fn skeleton_bones(document : BvhDocument) -> Array[BvhSkeletonBone]

    skeleton_bones_csv

    source
    fn skeleton_bones_csv(document : BvhDocument) -> String

    skeleton_diff_to_json

    source
    fn skeleton_diff_to_json(diff : BvhSkeletonDiff) -> String

    skeleton_signature

    source
    fn skeleton_signature(document : BvhDocument) -> String

    skeleton_summary_to_json

    source
    fn skeleton_summary_to_json(summary : BvhSkeletonSummary) -> String

    slice_document

    source
    fn slice_document(document : BvhDocument, start_frame : Int, end_frame : Int) -> BvhDocument

    slice_motion

    source
    fn slice_motion(motion : BvhMotion, start_frame : Int, end_frame : Int) -> BvhMotion

    speed_samples_to_csv

    source
    fn speed_samples_to_csv(samples : Array[BvhSpeedSample]) -> String

    stats_to_json

    source
    fn stats_to_json(stats : BvhStats) -> String

    strict_ci_import_profile

    source
    fn strict_ci_import_profile() -> BvhImportProfile

    summarize_skeleton

    source
    fn summarize_skeleton(document : BvhDocument) -> BvhSkeletonSummary

    tokenize_bvh

    source
    fn tokenize_bvh(input : String) -> BvhTokenizeResult

    Split ASCII BVH source into words and braces while preserving token position.

    unity_clip_plan_to_json

    source
    fn unity_clip_plan_to_json(plan : BvhUnityClipPlan) -> String

    unity_import_profile

    source
    fn unity_import_profile() -> BvhImportProfile

    validate_bvh

    source
    fn validate_bvh(input : String) -> BvhValidationReport

    validate_document

    source
    fn validate_document(document : BvhDocument) -> BvhValidationReport

    validation_summary

    source
    fn validation_summary(report : BvhValidationReport) -> String

    validation_to_json

    source
    fn validation_to_json(report : BvhValidationReport) -> String

    vec3_to_json

    source
    fn vec3_to_json(vec : BvhVec3) -> String

    widest_channel_range

    source
    fn widest_channel_range(document : BvhDocument) -> BvhChannelRange?

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io