vrm-runtime 0.1.0

Renderer-agnostic VRM 1.0 loader, validator, animation system, and runtime
Documentation
#![deny(missing_docs)]
#![deny(rustdoc::broken_intra_doc_links)]
#![doc = include_str!("../README.md")]

/// VRMA loading, typed animation tracks, sampling, and retargeting metadata.
pub mod animation;
/// Immutable VRM assets and strict or permissive file loading.
pub mod avatar;
/// Validated construction of complete programmatic avatar assets.
pub mod builder;
/// VRM node-constraint data and low-level constraint evaluation.
pub mod constraint;
/// Loader capabilities, validation modes, and recoverable diagnostics.
pub mod diagnostic;
/// Errors produced while loading or constructing assets.
pub mod error;
/// Renderer-ready material values after expressions and UV animation.
pub mod evaluated_material;
/// VRM expressions, binds, overrides, and evaluated updates.
pub mod expressions;
mod extension_declarations;
/// First-person visibility annotations and automatic mesh separation.
pub mod first_person;
/// Humanoid bone definitions and validated node mappings.
pub mod humanoid;
/// Type-safe identifiers for objects stored in an avatar asset.
pub mod id;
/// Encoded PNG and JPEG image data retained by the loader.
pub mod image;
/// Low-level mutable avatar controls and frame evaluation results.
pub mod instance;
/// LookAt configuration and gaze-angle conversion.
pub mod look_at;
/// glTF, unlit, and MToon material and texture data.
pub mod material;
/// VRM authorship, licensing, and usage-permission metadata.
pub mod meta;
/// Morph-target vertex deltas.
pub mod morph_target;
/// Avatar node transforms and low-level world or joint matrix calculation.
pub mod node;
/// Canonical renderer geometry and validated primitive construction.
pub mod primitive;
/// CPU-side deformation output.
pub mod render;
/// High-level animation, expression, constraint, and SpringBone evaluation.
pub mod runtime;
/// Skin joints and inverse-bind matrices.
pub mod skin;
/// SpringBone colliders, chains, validation, and simulation.
pub mod spring_bone;
/// Renderer-independent translation, rotation, and scale values.
pub mod transform;

pub use animation::{
    AnimationLoadError, AnimationLoadOutcome, BoneTrack, Interpolation, Keyframe,
    SourceBoneRestPose, Track, TrackValue, VrmAnimation,
};
pub(crate) use avatar::AvatarAsset as Avatar;
pub use avatar::{AvatarAsset, LoadOutcome};
pub use builder::AvatarAssetBuilder;
pub use constraint::{
    AimAxis, AimConstraint, NodeConstraint, NodeConstraintKind, RollAxis, RollConstraint,
    RotationConstraint, solve_constraints,
};
pub use diagnostic::{Capabilities, Diagnostic, DiagnosticSeverity, LoadOptions, ValidationMode};
pub use error::{BuildError, LoadError};
pub use evaluated_material::{EvaluatedMaterial, UvAnimationState};
pub use expressions::{
    Expression, ExpressionEvaluation, ExpressionOverrideType, Expressions, MaterialColorBind,
    MaterialColorType, MaterialColorUpdate, MorphTargetBind, MorphTargetUpdate,
    TextureTransformBind, TextureTransformUpdate,
};
pub use first_person::{AutoSplit, CameraMode, FirstPerson, FirstPersonFlag, MeshAnnotation};
pub use humanoid::{HumanBone, HumanBoneNode, Humanoid};
pub use id::{ImageId, MaterialId, NodeId, PrimitiveId, SkinId, TextureId};
pub use image::AvatarImage;
pub use instance::{AvatarEvaluation, AvatarInstance, BoneUpdate};
pub use look_at::{LookAt, LookAtRangeMap, LookAtType, calc_yaw_pitch};
pub use material::{
    AlphaMode, AvatarTexture, EmissiveStrengthSource, MToonMaterial, MagFilter, Material,
    MaterialShadingModel, MinFilter, NormalTextureInfo, OcclusionTextureInfo, OutlineWidthMode,
    TextureInfo, TextureSampler, TextureTransform, WrapMode,
};
pub use meta::{
    AvatarMeta, AvatarPermission, AvatarPermissions, CommercialUsage, CreditNotation,
    ModificationPermission,
};
pub use morph_target::MorphTarget;
pub use node::{AvatarNode, compute_joint_matrices, compute_world_matrices};
pub use primitive::{
    MorphedVertices, PrimitiveTopology, RenderPrimitive, RenderPrimitiveBuilder, SkinningSet,
};
pub use render::CpuMesh;
pub use runtime::{
    AvatarRuntime, ControlError, FrameSnapshot, FrameView, GpuDraw, GpuFrameView, PlaybackMode,
    PlaybackOptions, RuntimeError, RuntimeOptions, SkinningPalette,
};
pub use skin::Skin;
pub use spring_bone::{
    ColliderShape, SpringBone, SpringBoneSimulator, SpringChain, SpringCollider,
    SpringColliderGroup, SpringJoint,
};
pub use transform::Transform;

#[cfg(test)]
mod tests {
    use super::*;
    use vrm_spec::vrmc_vrm_1_0::VRMCVrmSchema;

    #[test]
    fn test_avatar_default() {
        let avatar = Avatar::new();
        assert_eq!(avatar.meta().name(), "");
        assert_eq!(avatar.meta().version(), None);
        assert!(avatar.meta().authors().is_empty());
    }

    #[test]
    fn test_avatar_from_invalid_bytes() {
        let result = Avatar::from_bytes(&[]);
        assert!(result.is_err());
    }

    #[test]
    fn test_corrupted_meta_json_deserialization() {
        let invalid_meta_json = serde_json::json!({
            "specVersion": "1.0",
            "meta": {
                "copyrightInformation": "invalid meta without name and authors"
            }
        });

        let parsed: Result<VRMCVrmSchema, _> = serde_json::from_value(invalid_meta_json);
        assert!(
            parsed.is_err(),
            "malformed meta JSON must fail deserialization"
        );
    }
}