Trait gltf_json::validation::Validate

pub trait Validate {
    fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R)
    where
        P: Fn() -> Path,
        R: FnMut(&dyn Fn() -> Path, Error),
    { ... }
    fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R)
    where
        P: Fn() -> Path,
        R: FnMut(&dyn Fn() -> Path, Error),
    { ... }
}

Trait for validating glTF JSON data against the 2.0 specification.

Provided methods

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

Validates only the invariants required for the library to function safely.

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

Validates the data against the glTF 2.0 specification.

Notes

The caller must also call validate_minimally() for full validation.

Loading content...

Implementations on Foreign Types

impl<K: Eq + Hash + ToString + Validate, V: Validate> Validate for HashMap<K, V>

fn validate_minimally<P, R>(&self, root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl<T: Validate> Validate for Option<T>

fn validate_minimally<P, R>(&self, root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl<T: Validate> Validate for Vec<T>

fn validate_minimally<P, R>(&self, root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for bool

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for u32

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for i32

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for f32

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for [f32; 3]

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for [f32; 4]

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for [f32; 16]

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for ()

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for String

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

Loading content...

Implementors

impl Validate for Value

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::accessor::sparse::Indices

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::accessor::sparse::Sparse

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::accessor::sparse::Values

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::accessor::Accessor

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for Animation

fn validate_minimally<P, R>(&self, root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::animation::Sampler

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::animation::Target

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::asset::Asset

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::buffer::Buffer

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for ByteStride

fn validate_completely<P, R>(&self, _: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::buffer::View

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::camera::Camera

fn validate_minimally<P, R>(&self, root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::camera::Orthographic

fn validate_completely<P, R>(&self, root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::camera::Perspective

fn validate_completely<P, R>(&self, root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::accessor::sparse::Indices

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::accessor::sparse::Sparse

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::accessor::sparse::Values

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::accessor::Accessor

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::animation::Sampler

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::animation::Target

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::asset::Asset

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::buffer::Buffer

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::buffer::View

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::camera::Camera

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::camera::Orthographic

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::camera::Perspective

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::image::Image

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::material::Material

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::material::NormalTexture

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::material::OcclusionTexture

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::material::PbrMetallicRoughness

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::mesh::Mesh

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::mesh::Primitive

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::root::Root

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::scene::Node

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::scene::Scene

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::skin::Skin

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::texture::Info

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::texture::Sampler

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::extensions::texture::Texture

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for Void

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::image::Image

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for MimeType

fn validate_completely<P, R>(&self, _: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for AlphaCutoff

fn validate_completely<P, R>(&self, _: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for EmissiveFactor

fn validate_completely<P, R>(&self, _: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::material::Material

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::material::NormalTexture

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::material::OcclusionTexture

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for PbrBaseColorFactor

fn validate_completely<P, R>(&self, _: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::material::PbrMetallicRoughness

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for StrengthFactor

fn validate_completely<P, R>(&self, _: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::mesh::Mesh

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for MorphTarget

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::mesh::Primitive

fn validate_minimally<P, R>(&self, root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::root::Root

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::scene::Node

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::scene::Scene

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for UnitQuaternion

fn validate_completely<P, R>(&self, _: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::skin::Skin

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::texture::Info

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::texture::Sampler

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl Validate for gltf_json::texture::Texture

fn validate_minimally<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl<T> Validate for Checked<T>

fn validate_minimally<P, R>(&self, _root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

impl<T: Validate> Validate for Index<T> where
    Root: Get<T>, 

fn validate_minimally<P, R>(&self, root: &Root, path: P, report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

fn validate_completely<P, R>(&self, _root: &Root, _path: P, _report: &mut R) where
    P: Fn() -> Path,
    R: FnMut(&dyn Fn() -> Path, Error), 

Loading content...