SCHEMAS DOCUMENTATION
Version: 1.14.30.2

Index

Overview
Schemas
Back to top

Overview

These are the data format schemas for content creators to reference when editing or creating new content.
Back to top

Schemas

actor_animation:1.8.0:{
    version "format_version"[0,*]
    object "animations"[0,*]
    {
        object "animation.<identifier>"[0,*]
        {
            bool "loop"[0,*] : opt // should this animation loop or stop playing when finished
            molang "anim_time_update"[0,*] : opt // how does time pass when playing the animation.  Defaults to "query.anim_time + query.delta_time" which means advance in seconds.
            molang "blend_weight"[0,*] : opt
            bool "override_previous_animation"[0,*] : opt // reset bones in this animation to the default pose before applying this animation
            object "bones"[0,*] : opt
            {
                object "<identifier>"[0,*]
                {
                    object "relative_to"[0,*] : opt
                    {
                        string "rotation"[0,*] : opt // if set, makes the bone rotation relative to the entity instead of the bone's parent
                    }
                    molang "position"[0,*] : opt
                    object "position"[0,*] : opt
                    {
                        object "<time_stamp>"[0,*]
                        {
                            enumerated_value "lerp_mode"[0,*] : opt
                            array "pre"[3] : opt
                            {
                                molang "<any array element>"[0,*]
                            }
                            array "post"[3] : opt
                            {
                                molang "<any array element>"[0,*]
                            }
                        }
                        array "<time_stamp>"[3]
                        {
                            molang "<any array element>"[0,*]
                        }
                    }
                    array "position"[0,*] : opt
                    {
                        molang "<any array element>"[0,*]
                    }
                    molang "rotation"[0,*] : opt
                    array "rotation"[0,*] : opt
                    {
                        molang "<any array element>"[0,*]
                        object "<any array element>"[0,*]
                        {
                            molang "[xyz]"[0,*]
                        }
                    }
                    object "rotation"[0,*] : opt
                    {
                        object "<time_stamp>"[0,*]
                        {
                            enumerated_value "lerp_mode"[0,*] : opt
                            array "pre"[3] : opt
                            {
                                molang "<any array element>"[0,*]
                            }
                            array "post"[3] : opt
                            {
                                molang "<any array element>"[0,*]
                            }
                        }
                        array "<time_stamp>"[3]
                        {
                            molang "<any array element>"[0,*]
                        }
                    }
                    molang "scale"[0,*] : opt
                    object "scale"[0,*] : opt
                    {
                        object "<time_stamp>"[0,*]
                        {
                            enumerated_value "lerp_mode"[0,*] : opt
                            array "pre"[3] : opt
                            {
                                molang "<any array element>"[0,*]
                            }
                            array "post"[3] : opt
                            {
                                molang "<any array element>"[0,*]
                            }
                        }
                        array "<time_stamp>"[3]
                        {
                            molang "<any array element>"[0,*]
                        }
                    }
                    array "scale"[0,*] : opt
                    {
                        molang "<any array element>"[0,*]
                    }
                }
            }
            object "particle_effects"[0,*] : opt
            {
                array "<time_stamp>"[0,*] : opt
                {
                    object "<any array element>"[0,*] : opt
                    {
                        string "effect"[0,*] // The name of a particle effect that should be played
                        string "locator"[0,*] : opt // The name of a locator on the actor where the effect should be located
                        molang "pre_effect_script"[0,*] : opt // A molang script that will be run when the particle emitter is initialized
                        bool "bind_to_actor"[0,*] : opt // Set to false to have the effect spawned in the world without being bound to an actor (by default an effect is bound to the actor).
                    }
                }
                object "<time_stamp>"[0,*] : opt
                {
                    string "effect"[0,*] // The name of a particle effect that should be played
                    string "locator"[0,*] : opt // The name of a locator on the actor where the effect should be located
                    molang "pre_effect_script"[0,*] : opt // A molang script that will be run when the particle emitter is initialized
                    bool "bind_to_actor"[0,*] : opt // Set to false to have the effect spawned in the world without being bound to an actor (by default an effect is bound to the actor).
                }
            }
            object "sound_effects"[0,*] : opt // sound effects to trigger as this animation plays, keyed by time
            {
                array "<time_stamp>"[0,*] : opt
                {
                    object "<any array element>"[0,*] : opt
                    {
                        string "effect"[0,*] // Valid sound effect names should be listed in the entity's resource_definition json file.
                    }
                }
                object "<time_stamp>"[0,*] : opt
                {
                    string "effect"[0,*] // Valid sound effect names should be listed in the entity's resource_definition json file.
                }
            }
            object "timeline"[0,*] : opt
            {
                string "<time_stamp>"[0,*] : opt
                array "<time_stamp>"[0,*] : opt
                {
                    string "<any array element>"[0,*] : opt
                }
            }
            float "animation_length"[0,*] : opt // override calculated value (set as the last keyframe time) and set animation length in seconds.
        }
    }
}

actor_animation_controller:1.10.0:{
    version "format_version"[0,*]
    object "animation_controllers"[0,*]
    {
        object "controller.animation.<identifier>"[0,*]
        {
            object "states"[0,*]
            {
                object "<identifier>"[0,*]
                {
                    object "variables"[0,*] : opt
                    {
                        object "<identifier>"[0,*]
                        {
                            molang "input"[0,*]
                            object "remap_curve"[0,*] : opt
                            {
                                float "<time_stamp>"[0,*]
                            }
                        }
                    }
                    array "animations"[0,*] : opt
                    {
                        string "<any array element>"[0,*]
                        object "<any array element>"[0,*]
                        {
                            molang "<identifier>"[0,*]
                        }
                    }
                    array "transitions"[0,*] : opt
                    {
                        object "<any array element>" : opt
                        {
                            string "<identifier>"[0,*]
                        }
                    }
                    bool "blend_via_shortest_path"[0,*] : opt // When blending a transition to another state, animate each euler axis through the shortest rotation, instead of by value
                    object "blend_transition"[0,*] : opt // Specifies the cross-fade time in seconds when transitioning to another state
                    {
                        float "<identifier>"[0,*] // Mapping of time since the animation was canceled, to the blend value at that time.  A default key of time=0 to a blend value of 1.0 is provided if any other key is set and a blend value at time=0 hasn't already been set.
                    }
                    float "blend_transition"[0,*] : opt // A short-hand version of blend_out that simply sets the amount of time to fade out if the animation is interrupted
                    array "particle_effects"[0,*] : opt
                    {
                        object "<any array element>"[0,*] : opt
                        {
                            string "effect"[0,*] // The name of a particle effect that should be played
                            string "locator"[0,*] : opt // The name of a locator on the actor where the effect should be located
                            string "pre_effect_script"[0,*] : opt // A molang script that will be run when the particle emitter is initialized
                            bool "bind_to_actor"[0,*] : opt // Set to false to have the effect spawned in the world without being bound to an actor (by default an effect is bound to the actor).
                        }
                    }
                    array "on_entry"[0,*] : opt
                    {
                        string "<any array element>"[0,*] : opt
                    }
                    array "on_exit"[0,*] : opt
                    {
                        string "<any array element>"[0,*] : opt
                    }
                    array "sound_effects"[0,*] : opt // Collection of sounds to trigger on entry to this animation state.
                    {
                        object "<any array element>"[0,*] : opt
                        {
                            string "effect"[0,*] // Valid sound effect names should be listed in the entity's resource_definition json file.
                        }
                    }
                }
            }
            string "initial_state"[0,*] : opt
        }
    }
}

block_reference:1.10.0:{
    string "name"[0,*]
    object "states"[0,*]
    {
        bool "\w*:?\w+"[0,*] : opt
        int "\w*:?\w+"[0,*] : opt
        string "\w*:?\w+"[0,*] : opt
    }
}

actor_resource_definition:1.8.0:{
    version "format_version"[0,*]
    object "minecraft:(client_entity|attachable)"[0,*]
    {
        object "description"[0,*]
        {
            string "identifier"[0,*]
            version "min_engine_version"[0,*] : opt
            object "materials"[0,*] : opt
            {
                string "<identifier>"[0,*]
            }
            object "textures"[0,*] : opt
            {
                string "<identifier>"[0,*]
            }
            object "geometry"[0,*]
            {
                string "<identifier>"[0,*]
            }
            object "spawn_egg"[0,*] : opt
            {
                string "texture"[0,*] : opt
                string "base_color"[0,*] : opt
                string "overlay_color"[0,*] : opt
                int "texture_index"[0,*] : opt
            }
            object "scripts"[0,*] : opt
            {
                array "pre_animation"[0,*] : opt
                {
                    molang "<any array element>"[0,*]
                }
                molang "scale"[0,*] : opt
                molang "scale[xX]"[0,*] : opt
                molang "scale[yY]"[0,*] : opt
                molang "scale[zZ]"[0,*] : opt
                molang "parent_setup"[0,*] : opt
            }
            object "particle_effects" : opt
            {
                string "<identifier>"[0,*] : opt
            }
            object "particle_emitters" : opt
            {
                string "<identifier>"[0,*] : opt
            }
            object "animations" : opt
            {
                string "<identifier>"[0,*] : opt
            }
            array "animation_controllers" : opt
            {
                object "<any array element>"[0,*] : opt
                {
                    string "<identifier>"[0,*] : opt
                }
            }
            array "render_controllers" : opt
            {
                string "<any array element>"[0,*] : opt
            }
            object "sound_effects" : opt
            {
                string "<identifier>"[0,*] : opt
            }
            bool "enable_attachables"[0,*] : opt
        }
    }
}

actor_resource_definition:1.10.0:{
    version "format_version"[0,*]
    object "minecraft:client_entity"[0,*] : opt
    {
        object "description"[0,*]
        {
            string "identifier"[0,*]
            version "min_engine_version"[0,*] : opt
            object "materials"[0,*] : opt
            {
                string "<identifier>"[0,*]
            }
            object "textures"[0,*] : opt
            {
                string "<identifier>"[0,*]
            }
            object "geometry"[0,*]
            {
                string "<identifier>"[0,*]
            }
            object "spawn_egg"[0,*] : opt
            {
                string "texture"[0,*] : opt
                string "base_color"[0,*] : opt
                string "overlay_color"[0,*] : opt
                int "texture_index"[0,*] : opt
            }
            object "scripts"[0,*] : opt
            {
                array "initialize"[0,*] : opt
                {
                    molang "<any array element>"[0,*]
                }
                array "pre_animation"[0,*] : opt
                {
                    molang "<any array element>"[0,*]
                }
                molang "scale"[0,*] : opt
                molang "scale[xX]"[0,*] : opt
                molang "scale[yY]"[0,*] : opt
                molang "scale[zZ]"[0,*] : opt
                molang "parent_setup"[0,*] : opt
                array "animate" : opt
                {
                    string "<any array element>"[0,*] : opt
                    object "<any array element>" : opt
                    {
                        molang "<scope_identifier>"[0,*] : opt
                    }
                }
            }
            object "particle_effects" : opt
            {
                string "<identifier>"[0,*] : opt
            }
            object "particle_emitters" : opt
            {
                string "<identifier>"[0,*] : opt
            }
            object "animations" : opt
            {
                string "<identifier>"[0,*] : opt
            }
            array "render_controllers" : opt
            {
                string "<any array element>"[0,*] : opt
                object "<any array element>" : opt
                {
                    molang "<scope_identifier>"[0,*] : opt
                }
            }
            object "sound_effects" : opt
            {
                string "<identifier>"[0,*] : opt
            }
            bool "enable_attachables"[0,*] : opt
        }
    }
    object "minecraft:attachable"[0,*] : opt
    {
        object "description"[0,*]
        {
            string "identifier"[0,*]
            version "min_engine_version"[0,*] : opt
            object "materials"[0,*] : opt
            {
                string "<identifier>"[0,*]
            }
            object "textures"[0,*] : opt
            {
                string "<identifier>"[0,*]
            }
            object "geometry"[0,*]
            {
                string "<identifier>"[0,*]
            }
            object "spawn_egg"[0,*] : opt
            {
                string "texture"[0,*] : opt
                string "base_color"[0,*] : opt
                string "overlay_color"[0,*] : opt
                int "texture_index"[0,*] : opt
            }
            object "scripts"[0,*] : opt
            {
                array "initialize"[0,*] : opt
                {
                    molang "<any array element>"[0,*]
                }
                array "pre_animation"[0,*] : opt
                {
                    molang "<any array element>"[0,*]
                }
                molang "scale"[0,*] : opt
                molang "scale[xX]"[0,*] : opt
                molang "scale[yY]"[0,*] : opt
                molang "scale[zZ]"[0,*] : opt
                molang "parent_setup"[0,*] : opt
                array "animate" : opt
                {
                    string "<any array element>"[0,*] : opt
                    object "<any array element>" : opt
                    {
                        molang "<scope_identifier>"[0,*] : opt
                    }
                }
            }
            object "particle_effects" : opt
            {
                string "<identifier>"[0,*] : opt
            }
            object "particle_emitters" : opt
            {
                string "<identifier>"[0,*] : opt
            }
            object "animations" : opt
            {
                string "<identifier>"[0,*] : opt
            }
            array "render_controllers" : opt
            {
                string "<any array element>"[0,*] : opt
                object "<any array element>" : opt
                {
                    molang "<scope_identifier>"[0,*] : opt
                }
            }
            object "sound_effects" : opt
            {
                string "<identifier>"[0,*] : opt
            }
            bool "enable_attachables"[0,*] : opt
            string "item"[0,*] : opt
            object "item" : opt
            {
                molang "<scope_identifier>"[0,*]
            }
        }
    }
}

render_controller:1.8.0:{
    version "format_version"[0,*]
    object "render_controllers"[0,*]
    {
        object "controller.render.<scope_identifier>"[0,*]
        {
            bool "rebuild_animation_matrices"[0,*] : opt
            object "arrays"[0,*] : opt
            {
                object "geometries"[0,*] : opt
                {
                    array "array.<scope_identifier>"[0,*]
                    {
                        string "<any array element>"[0,*]
                    }
                }
                object "materials"[0,*] : opt
                {
                    array "array.<scope_identifier>"[0,*]
                    {
                        string "<any array element>"[0,*]
                    }
                }
                object "textures"[0,*] : opt
                {
                    array "array.<scope_identifier>"[0,*]
                    {
                        string "<any array element>"[0,*]
                    }
                }
            }
            string "geometry"[0,*]
            array "part_visibility"[0,*] : opt
            {
                object "<any array element>"[0,*]
                {
                    molang "[a-zA-Z0-9_.:*]+"[0,*]
                }
            }
            array "materials"[0,*] : opt
            {
                object "<any array element>"[0,*]
                {
                    molang "[a-zA-Z0-9_.:*]+"[0,*]
                }
            }
            array "textures"[0,*] : opt
            {
                string "<any array element>"[0,*]
            }
            object "color"[0,*] : opt
            {
                molang "r"[0,*] : opt
                molang "g"[0,*] : opt
                molang "b"[0,*] : opt
                molang "a"[0,*] : opt
            }
            object "overlay_color"[0,*] : opt
            {
                molang "r"[0,*] : opt
                molang "g"[0,*] : opt
                molang "b"[0,*] : opt
                molang "a"[0,*] : opt
            }
            object "uv_anim"[0,*] : opt
            {
                array "offset"[2]
                {
                    molang "<any array element>"[0,*]
                }
                array "scale"[2]
                {
                    molang "<any array element>"[0,*]
                }
            }
            molang "light_color_multiplier"[0,*] : opt
            bool "ignore_lighting"[0,*] : opt
            bool "filter_lighting"[0,*] : opt
        }
    }
}

geometry:1.8.0:{
    version "format_version"[0,*]
    object "geometry.[a-zA-Z0-9_.'-:]+"[0,*]
    {
        float "visible_bounds_width"[0,*] : opt
        float "visible_bounds_height"[0,*] : opt
        array "visible_bounds_offset"[3] : opt
        {
            float "<any array element>"[0,*]
        }
        int "texturewidth"[0,*] : opt
        int "textureheight"[0,*] : opt
        string "cape"[0,*] : opt
        array "bones"[0,*] : opt
        {
            object "<any array element>"[0,*] : opt
            {
                string "name"[0,*]
                bool "reset"[0,*] : opt
                bool "neverRender"[0,*] : opt
                string "parent"[0,*] : opt
                array "pivot"[3] : opt
                {
                    float "<any array element>"[0,*]
                }
                array "rotation"[3] : opt
                {
                    float "<any array element>"[0,*]
                }
                array "bind_pose_rotation"[3] : opt
                {
                    float "<any array element>"[0,*] : opt
                }
                bool "mirror"[0,*] : opt
                float "inflate"[0,*] : opt
                bool "debug"[0,*] : opt
                int "render_group_id"[0,*] : opt
                array "cubes"[0,*] : opt
                {
                    object "<any array element>"[0,*] : opt
                    {
                        array "origin"[3] : opt
                        {
                            float "<any array element>"[0,*]
                        }
                        array "size"[3] : opt
                        {
                            float "<any array element>"[0,*]
                        }
                        array "uv"[2] : opt
                        {
                            float "<any array element>"[0,*]
                        }
                        float "inflate"[0,*] : opt
                        bool "mirror"[0,*] : opt
                    }
                }
                object "locators"[0,*] : opt
                {
                    array "<identifier>"[0,*] : opt
                    {
                        float "<any array element>"[0,*] : opt
                    }
                }
                object "poly_mesh"[0,*] : opt
                {
                    bool "normalized_uvs"[0,*] : opt
                    array "positions"[0,*] : opt
                    {
                        array "<any array element>"[3] : opt
                        {
                            float "<any array element>"[0,*]
                        }
                    }
                    array "normals"[0,*] : opt
                    {
                        array "<any array element>"[3] : opt
                        {
                            float "<any array element>"[0,*]
                        }
                    }
                    array "uvs"[0,*] : opt
                    {
                        array "<any array element>"[2] : opt
                        {
                            float "<any array element>"[0,*]
                        }
                    }
                    array "polys"[0,*]
                    {
                        array "<any array element>"[3,4] : opt
                        {
                            array "<any array element>"[3]
                            {
                                float "<any array element>"[0,*]
                            }
                        }
                    }
                    string "polys"[0,*]
                }
                array "texture_meshes"[0,*] : opt
                {
                    object "<any array element>"[0,*]
                    {
                        string "texture"[0,*]
                        array "position"[3] : opt
                        {
                            float "<any array element>"[0,*]
                        }
                        array "local_pivot"[3] : opt
                        {
                            float "<any array element>"[0,*]
                        }
                        array "rotation"[3] : opt
                        {
                            float "<any array element>"[0,*]
                        }
                        array "scale"[3] : opt
                        {
                            float "<any array element>"[0,*]
                        }
                    }
                }
            }
        }
    }
}

geometry:1.12.0:{
    version "format_version"[0,*]
    array "minecraft:geometry"
    {
        object "<any array element>"[0,*]
        {
            object "description"[0,*]
            {
                string "identifier"[0,*] // Entity definition and Client Block definition files refer to this geometry via this identifier.
                float "visible_bounds_width"[0,*] : opt // Width of the visibility bounding box (in model space units).
                float "visible_bounds_height"[0,*] : opt // Height of the visible bounding box (in model space units).
                array "visible_bounds_offset"[3] : opt
                {
                    float "<any array element>"[0,*] // Offset of the visibility bounding box from the entity location point (in model space units).
                }
                int "texture_width"[0,*] : opt // Assumed width in texels of the texture that will be bound to this geometry.
                int "texture_height"[0,*] : opt // Assumed height in texels of the texture that will be bound to this geometry.
            }
            string "cape"[0,*] : opt
            array "bones"[0,*] : opt // Bones define the 'skeleton' of the mob: the parts that can be animated, and to which geometry and other bones are attached.
            {
                object "<any array element>"[0,*] : opt
                {
                    string "name"[0,*] // Animation files refer to this bone via this identifier.
                    string "parent"[0,*] : opt // Bone that this bone is relative to.  If the parent bone moves, this bone will move along with it.
                    array "pivot"[3] : opt
                    {
                        float "<any array element>"[0,*] // The bone pivots around this point (in model space units).
                    }
                    array "rotation"[3] : opt
                    {
                        float "<any array element>"[0,*] // This is the initial rotation of the bone around the pivot, pre-animation (in degrees, x-then-y-then-z order).
                    }
                    bool "mirror"[0,*] : opt // Mirrors the UV's of the unrotated cubes along the x axis, also causes the east/west faces to get flipped.
                    float "inflate"[0,*] : opt // Grow this box by this additive amount in all directions (in model space units).
                    bool "debug"[0,*] : opt
                    int "render_group_id"[0,*] : opt
                    array "cubes"[0,*] : opt // This is the list of cubes associated with this bone.
                    {
                        object "<any array element>"[0,*] : opt
                        {
                            array "origin"[3] : opt
                            {
                                float "<any array element>"[0,*] // This point declares the unrotated lower corner of cube (smallest x/y/z value in model space units).
                            }
                            array "size"[3] : opt
                            {
                                float "<any array element>"[0,*] // The cube extends this amount relative to its origin (in model space units).
                            }
                            array "rotation"[3] : opt
                            {
                                float "<any array element>"[0,*] // The cube is rotated by this amount (in degrees, x-then-y-then-z order) around the pivot.
                            }
                            array "pivot"[3] : opt
                            {
                                float "<any array element>"[0,*] // If this field is specified, rotation of this cube occurs around this point, otherwise its rotation is around the center of the box.
                            }
                            float "inflate"[0,*] : opt // Grow this box by this additive amount in all directions (in model space units), this field overrides the bone's inflate field for this cube only.
                            bool "mirror"[0,*] : opt // Mirrors this cube about the unrotated x axis (effectively flipping the east / west faces), overriding the bone's 'mirror' setting for this cube.
                            object "uv"[0,*] : opt // This is an alternate per-face uv mapping which specifies each face of the cube.  Omitting a face will cause that face to not get drawn.
                            {
                                object "north"[0,*] : opt // Specifies the UV's for the face that stretches along the x and y axes, and faces the -z axis.
                                {
                                    array "uv"[2]
                                    {
                                        float "<any array element>"[0,*] // Specifies the uv origin for the face. For this face, it is the upper-left corner, when looking at the face with y being up.
                                    }
                                    array "uv_size"[2] : opt
                                    {
                                        float "<any array element>"[0,*] // The face maps this many texels from the uv origin. If not specified, the box dimensions are used instead.
                                    }
                                    string "material_instance"[0,*] : opt
                                }
                                object "south"[0,*] : opt // Specifies the UV's for the face that stretches along the x and y axes, and faces the z axis
                                {
                                    array "uv"[2]
                                    {
                                        float "<any array element>"[0,*] // Specifies the uv origin for the face. For this face, it is the upper-left corner, when looking at the face with y being up.
                                    }
                                    array "uv_size"[2] : opt
                                    {
                                        float "<any array element>"[0,*] // The face maps this many texels from the uv origin. If not specified, the box dimensions are used instead.
                                    }
                                    string "material_instance"[0,*] : opt
                                }
                                object "east"[0,*] : opt // Specifies the UV's for the face that stretches along the z and y axes, and faces the x axis
                                {
                                    array "uv"[2]
                                    {
                                        float "<any array element>"[0,*] // Specifies the uv origin for the face. For this face, it is the upper-left corner, when looking at the face with y being up.
                                    }
                                    array "uv_size"[2] : opt
                                    {
                                        float "<any array element>"[0,*] // The face maps this many texels from the uv origin. If not specified, the box dimensions are used instead.
                                    }
                                    string "material_instance"[0,*] : opt
                                }
                                object "west"[0,*] : opt // Specifies the UV's for the face that stretches along the z and y axes, and faces the -x axis
                                {
                                    array "uv"[2]
                                    {
                                        float "<any array element>"[0,*] // Specifies the uv origin for the face. For this face, it is the upper-left corner, when looking at the face with y being up.
                                    }
                                    array "uv_size"[2] : opt
                                    {
                                        float "<any array element>"[0,*] // The face maps this many texels from the uv origin. If not specified, the box dimensions are used instead.
                                    }
                                    string "material_instance"[0,*] : opt
                                }
                                object "up"[0,*] : opt // Specifies the UV's for the face that stretches along the x and z axes, and faces the y axis
                                {
                                    array "uv"[2]
                                    {
                                        float "<any array element>"[0,*] // Specifies the uv origin for the face. For this face, it is the back-upper-left corner, assuming you're facing 'north' relative to the cube.
                                    }
                                    array "uv_size"[2] : opt
                                    {
                                        float "<any array element>"[0,*] // The face maps this many texels from the uv origin. If not specified, the box dimensions are used instead.
                                    }
                                    string "material_instance"[0,*] : opt
                                }
                                object "down"[0,*] : opt // Specifies the UV's for the face that stretches along the x and z axes, and faces the -y axis
                                {
                                    array "uv"[2]
                                    {
                                        float "<any array element>"[0,*] // Specifies the uv origin for the face. For this face, it is the back-down-right corner, assuming you're facing 'north' relative to the cube.
                                    }
                                    array "uv_size"[2] : opt
                                    {
                                        float "<any array element>"[0,*] // The face maps this many texels from the uv origin. If not specified, the box dimensions are used instead.
                                    }
                                    string "material_instance"[0,*] : opt
                                }
                            }
                            array "uv"[2] : opt
                            {
                                float "<any array element>"[0,*] // Specifies the upper-left corner on the texture for the start of the texture mapping for this box.
                            }
                        }
                    }
                    object "locators"[0,*] : opt
                    {
                        object "<identifier>"[0,*] : opt // This is a list of locators associated with this bone.  A locator is a point in model space that tracks a particular bone as the bone animates (by maintaining it's relationship to the bone through the animation).
                        {
                            array "offset"[0,*]
                            {
                                float "<any array element>"[0,*] : opt // Position of the locator in model space.
                            }
                            array "rotation"[0,*]
                            {
                                float "<any array element>"[0,*] : opt // Rotation of the locator in model space.
                            }
                        }
                        array "<identifier>"[0,*] : opt // This is a list of locators associated with this bone.  A locator is a point in model space that tracks a particular bone as the bone animates (by maintaining it's relationship to the bone through the animation).
                        {
                            float "<any array element>"[0,*] : opt // Position of the locator in model space.
                        }
                    }
                    object "poly_mesh"[0,*] : opt // ***EXPERIMENTAL*** A triangle or quad mesh object.  Can be used in conjunction with cubes and texture geometry.
                    {
                        bool "normalized_uvs"[0,*] : opt // If true, UVs are assumed to be [0-1].  If false, UVs are assumed to be [0-texture_width] and [0-texture_height] respectively.
                        array "positions"[0,*] : opt
                        {
                            array "<any array element>"[3] : opt
                            {
                                float "<any array element>"[0,*] // Vertex positions for the mesh.  Can be either indexed via the "polys" section, or be a quad-list if mapped 1-to-1 to the normals and UVs sections.
                            }
                        }
                        array "normals"[0,*] : opt
                        {
                            array "<any array element>"[3] : opt
                            {
                                float "<any array element>"[0,*] // Vertex normals.  Can be either indexed via the "polys" section, or be a quad-list if mapped 1-to-1 to the positions and UVs sections.
                            }
                        }
                        array "uvs"[0,*] : opt
                        {
                            array "<any array element>"[2] : opt
                            {
                                float "<any array element>"[0,*] // Vertex UVs.  Can be either indexed via the "polys" section, or be a quad-list if mapped 1-to-1 to the positions and normals sections.
                            }
                        }
                        array "polys"[0,*]
                        {
                            array "<any array element>"[3,4] : opt
                            {
                                array "<any array element>"[3]
                                {
                                    float "<any array element>"[0,*] // Poly element indices, as an array of polygons, each an array of either three or four vertices, each an array of indices into positions, normals, and UVs (in that order).
                                }
                            }
                        }
                        string "polys"[0,*] // If not specifying vertex indices, arrays of data must be a list of tris or quads, set by making this property either "tri_list" or "quad_list"
                    }
                    array "texture_meshes"[0,*] : opt // ***EXPERIMENTAL*** Adds a mesh to the bone's geometry by converting texels in a texture into boxes
                    {
                        object "<any array element>"[0,*]
                        {
                            string "texture"[0,*] // The friendly-named texture to use.
                            array "position"[3] : opt
                            {
                                float "<any array element>"[0,*] // The position of the pivot point after rotation (in *entity space* not texture or bone space) of the texture geometry
                            }
                            array "local_pivot"[3] : opt
                            {
                                float "<any array element>"[0,*] // The pivot point on the texture (in *texture space* not entity or bone space) of the texture geometry
                            }
                            array "rotation"[3] : opt
                            {
                                float "<any array element>"[0,*] // The rotation (in degrees) of the texture geometry relative to the offset
                            }
                            array "scale"[3] : opt
                            {
                                float "<any array element>"[0,*] // The scale (in degrees) of the texture geometry relative to the offset
                            }
                        }
                    }
                }
            }
        }
    }
}


Back to top