collada_io 0.1.0

Collada input and output
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use crate::geometry;
use crate::meta;
use crate::scene;

pub static COLLADA_XMLNS: &'static str = "http://www.collada.org/2005/11/COLLADASchema";
pub static COLLADA_XMLNS_XSI: &'static str = "http://www.w3.org/2001/XMLSchema-instance";
pub static COLLADA_VERSION: &'static str = "1.4.1";

use std::io::Write;
use xml::writer::{EmitterConfig, EventWriter, XmlEvent, Result};
use xml::attribute::Attribute;
use xml::common::XmlVersion;
use crate::io::XmlWrite;
use crate::util::*;


pub struct Collada
{
    pub asset: meta::Asset,
    pub geometries: Option<Vec<geometry::Geometry>>,
    pub visual_scenes: Option<Vec<scene::VisualScene>>,
    pub scene: Option<scene::Scene>
}

impl Collada
{
    pub fn write<W: Write>(&self, w: &mut EventWriter<W>) -> Result<()>
    {
        w.write(XmlEvent::StartDocument {
            version: XmlVersion::Version10,
            encoding: Some("utf-8"),
            standalone: None
        })?;

        let attributes = vec!{
            Attribute {
                name: "xmlns".into(),
                value: COLLADA_XMLNS
            },
            Attribute {
                name: "version".into(),
                value: COLLADA_VERSION
            },
            Attribute {
                name: "xmlns:xsi".into(),
                value: COLLADA_XMLNS_XSI
            }
        };
        write_start_element(w, "COLLADA", &attributes)?;

        self.asset.write(w)?;

        match &self.geometries
        {
            Some(geometries) => {
                write_start_element(w, "library_geometries", &Vec::new())?;
                
                for it in geometries 
                { 
                    it.write(w)?;
                }

                write_end_element(w, "library_geometries")?;
            },
            None => {

            }
        }

        match &self.visual_scenes
        {
            Some(visual_scenes) => {
                write_start_element(w, "library_visual_scenes", &Vec::new())?;
                
                for visual_scene in visual_scenes
                {
                    visual_scene.write(w)?;
                }
                
                write_end_element(w, "library_visual_scenes")?;
            }, None => {

            }
        }

        match &self.scene
        {
            Some(scene) => {
                scene.write(w)?;
            }, None => {

            }
        }

        write_end_element(w, "COLLADA")?;

        Ok(())
    }

    pub fn write_to<W: Write>(self, w: &mut W) -> Result<()>
    {
        let mut writer = EmitterConfig::new().perform_indent(true).create_writer(w);   
        
        self.write(&mut writer)?;

        return Ok(());
    }
}