From 6d779d24736ad2ddb2a95e36a4122886308ecf13 Mon Sep 17 00:00:00 2001 From: Treeki Date: Fri, 11 Feb 2011 22:35:05 +0100 Subject: part of a basic collada exporter --- NW4RTools/ColladaWriter.cs | 344 ++ NW4RTools/NW4RTools.csproj | 3 + NW4RTools/NW4RTools.pidb | Bin 78667 -> 524942 bytes NW4RTools/ObjWriter.cs | 4 + NW4RTools/Util/collada_schema_1_4.cs | 9977 +++++++++++++++++++++++++++++++++ NW4RTools/bin/Debug/NW4RTools.dll | Bin 40448 -> 157184 bytes NW4RTools/bin/Debug/NW4RTools.dll.mdb | Bin 13672 -> 87288 bytes 7 files changed, 10328 insertions(+) create mode 100644 NW4RTools/ColladaWriter.cs create mode 100644 NW4RTools/Util/collada_schema_1_4.cs (limited to 'NW4RTools') diff --git a/NW4RTools/ColladaWriter.cs b/NW4RTools/ColladaWriter.cs new file mode 100644 index 0000000..85b6867 --- /dev/null +++ b/NW4RTools/ColladaWriter.cs @@ -0,0 +1,344 @@ +using System; +using System.IO; +using System.Collections.Generic; +using System.Text; +using NW4RTools.Models; +using Collada141; + +namespace NW4RTools { + public class ColladaWriter { + public static void WriteModel(Stream outputStream, ResFile file, string modelName) { + new ColladaWriter(file).SaveModel(outputStream, modelName); + } + + + + ResFile CurrentFile; + Models.Model CurrentModel; + COLLADA Collada; + + library_geometries LibGeometries; + + private ColladaWriter(ResFile file) { + CurrentFile = file; + } + + public void SaveModel(Stream outputStream, string modelName) { + CurrentModel = CurrentFile.GetGroup("3DModels(NW4R)")[modelName]; + Collada = new COLLADA(); + + Collada.asset = new asset(); + + Collada.asset.contributor = new assetContributor[1]; + Collada.asset.contributor[0] = new assetContributor(); + Collada.asset.contributor[0].authoring_tool = "NW4RTools Collada exporter by Treeki"; + Collada.asset.contributor[0].source_data = "NW4R model: " + modelName; + Collada.asset.created = DateTime.Now; + Collada.asset.modified = DateTime.Now; + Collada.asset.unit = new assetUnit(); + Collada.asset.unit.meter = 1.0; + Collada.asset.up_axis = UpAxisType.Y_UP; + + Collada.Items = new object[1]; + Collada.Items[0] = LibGeometries = new library_geometries(); + + LibGeometries.geometry = new geometry[CurrentModel.Shapes.Count]; + + int geoIndex = 0; + foreach (var kv in CurrentModel.Shapes) { + var geo = LibGeometries.geometry[geoIndex] = new geometry(); + Shape shape = kv.Value; + + geo.id = kv.Key + "-lib"; + geo.name = kv.Key + "Mesh"; + + var m = new mesh(); + geo.Item = m; + + // Vertex settings + var firstDL = new InputStream(shape.DisplayList1); + firstDL.Seek(0x0C); + UInt32 vtxDesc1 = firstDL.ReadUInt32(); + firstDL.Seek(0x12); + UInt32 vtxDesc2 = firstDL.ReadUInt32(); + firstDL.Seek(0x22); + UInt32 vtxAttr1 = firstDL.ReadUInt32(); + firstDL.Seek(0x28); + UInt32 vtxAttr2 = firstDL.ReadUInt32(); + firstDL.Seek(0x2E); + UInt32 vtxAttr3 = firstDL.ReadUInt32(); + + var vs = new VertexSettings(); + vs.SetDesc(vtxDesc1, vtxDesc2); + vs.SetAttrFmt(vtxAttr1, vtxAttr2, vtxAttr3); + + // Figure out how many elements we need in the Source array + // Position data ALWAYS exists + int sourceCount = 1; + sourceCount += (shape.NrmData != null) ? 1 : 0; + for (int i = 0; i < 8; i++) + sourceCount += (shape.TexCoordData[i] != null) ? 1 : 0; + + m.source = new source[sourceCount]; + int currentSource = 0; + + // TODO: Refactor this messy code! + + int dest; + + // Write position data + var posData = shape.PosData; + var posSource = new source(); + posSource.id = kv.Key + "-lib-Position"; + m.source[currentSource++] = posSource; + + var posArray = new float_array(); + posArray.id = kv.Key + "-lib-Position-array"; + posArray.count = (ulong)(posData.GetRealCount() * posData.EntryCount); + posArray.Values = new double[posArray.count]; + + dest = 0; + for (int i = 0; i < posData.EntryCount; i++) { + float[] data = posData.GetEntry(i); + for (int j = 0; j < data.Length; j++) { + posArray.Values[dest++] = data[j]; + } + } + + posSource.Item = posArray; + + // Write position technique + posSource.technique_common = new sourceTechnique_common(); + var posAcc = posSource.technique_common.accessor = new accessor(); + posAcc.source = String.Format("#{0}-lib-Position-array", kv.Key); + posAcc.count = posData.EntryCount; + posAcc.stride = (ulong)posData.GetRealCount(); + + posAcc.param = new param[posData.GetRealCount()]; + string[] posParamNames = new string[] { "X", "Y", "Z" }; + + for (int i = 0; i < posAcc.param.Length; i++) { + posAcc.param[i] = new param(); + posAcc.param[i].name = posParamNames[i]; + posAcc.param[i].type = "float"; + } + + + // Write normal data + if (shape.NrmData != null) { + var nrmData = shape.NrmData; + var nrmSource = new source(); + nrmSource.id = kv.Key + "-lib-Normal"; + m.source[currentSource++] = nrmSource; + + var nrmArray = new float_array(); + nrmArray.id = kv.Key + "-lib-Normal-array"; + nrmArray.count = (ulong)(nrmData.GetRealCount() * nrmData.EntryCount); + nrmArray.Values = new double[nrmArray.count]; + + dest = 0; + for (int i = 0; i < nrmData.EntryCount; i++) { + float[] data = nrmData.GetEntry(i); + for (int j = 0; j < data.Length; j++) { + nrmArray.Values[dest++] = data[j]; + } + } + + nrmSource.Item = nrmArray; + + // Write normal technique + nrmSource.technique_common = new sourceTechnique_common(); + var nrmAcc = nrmSource.technique_common.accessor = new accessor(); + nrmAcc.source = String.Format("#{0}-lib-Normal-array", kv.Key); + nrmAcc.count = nrmData.EntryCount; + nrmAcc.stride = (ulong)nrmData.GetRealCount(); + + nrmAcc.param = new param[nrmData.GetRealCount()]; + string[] nrmParamNames = new string[] { "X", "Y", "Z" }; + + for (int i = 0; i < nrmAcc.param.Length; i++) { + nrmAcc.param[i] = new param(); + nrmAcc.param[i].name = nrmParamNames[i]; + nrmAcc.param[i].type = "float"; + } + } + + + // Write TexCoord data + for (int tcIndex = 0; tcIndex < 8; tcIndex++) { + if (shape.TexCoordData[tcIndex] != null) { + var tcData = shape.TexCoordData[tcIndex]; + var tcSource = new source(); + tcSource.id = String.Format("{0}-lib-TexCoord{1}", kv.Key, tcIndex); + m.source[currentSource++] = tcSource; + + var tcArray = new float_array(); + tcArray.id = String.Format("{0}-lib-TexCoord{1}-array", kv.Key, tcIndex); + tcArray.count = (ulong)(tcData.GetRealCount() * tcData.EntryCount); + tcArray.Values = new double[tcArray.count]; + + dest = 0; + for (int i = 0; i < tcData.EntryCount; i++) { + float[] data = tcData.GetEntry(i); + for (int j = 0; j < data.Length; j++) { + tcArray.Values[dest++] = data[j]; + } + } + + tcSource.Item = tcArray; + + // Write texcoord technique + tcSource.technique_common = new sourceTechnique_common(); + var tcAcc = tcSource.technique_common.accessor = new accessor(); + tcAcc.source = String.Format("#{0}-lib-TexCoord{1}-array", kv.Key, tcIndex); + tcAcc.count = tcData.EntryCount; + tcAcc.stride = (ulong)tcData.GetRealCount(); + + tcAcc.param = new param[tcData.GetRealCount()]; + string[] tcParamNames = new string[] { "S", "T" }; + + for (int i = 0; i < tcAcc.param.Length; i++) { + tcAcc.param[i] = new param(); + tcAcc.param[i].name = tcParamNames[i]; + tcAcc.param[i].type = "float"; + } + } + } + + + + // Ok, we've written all the raw float data, now set up vertices + m.vertices = new vertices(); + m.vertices.id = String.Format("{0}-lib-Vertex", kv.Key); + m.vertices.input = new InputLocal[1]; + m.vertices.input[0] = new InputLocal(); + m.vertices.input[0].semantic = "POSITION"; + m.vertices.input[0].source = String.Format("#{0}-lib-Position", kv.Key); + + // And before we finish, write the polygon data of course + var dl = new InputStream(shape.DisplayList2); + + List meshItems = new List(); + + // create the Input array -- we can reuse sourceCount! + var inputArray = new InputLocalOffset[sourceCount]; + currentSource = 0; + + var posInput = inputArray[currentSource] = new InputLocalOffset(); + posInput.semantic = "VERTEX"; + posInput.offset = (ulong)currentSource; + posInput.source = String.Format("#{0}-lib-Vertex", kv.Key); + currentSource++; + + if (shape.NrmData != null) { + var nrmInput = inputArray[currentSource] = new InputLocalOffset(); + nrmInput.semantic = "NORMAL"; + nrmInput.offset = (ulong)currentSource; + nrmInput.source = String.Format("#{0}-lib-Normal", kv.Key); + currentSource++; + } + + for (int i = 0; i < 8; i++) { + if (shape.TexCoordData[i] != null) { + var tcInput = inputArray[currentSource] = new InputLocalOffset(); + tcInput.semantic = "TEXCOORD"; + tcInput.offset = (ulong)currentSource; + tcInput.set = (ulong)i; + tcInput.source = String.Format("#{0}-lib-TexCoord{1}", kv.Key, i); + currentSource++; + } + } + + + // Create a list for tristrips beforehand, because they're THE most common + List triStrips = new List(); + + + // Now go through the display list + while (true) { + if (dl.AtEnd) + break; + + byte cmd = dl.ReadByte(); + if (cmd == 0) + break; + + PrimitiveType prim = (PrimitiveType)((cmd >> 3) & 7); + int vtxCount = dl.ReadUInt16(); + + // first, parse it into a list of vertices + GXIndexedVertex[] vtxs = new GXIndexedVertex[vtxCount]; + string[] pVtxs = new string[vtxCount]; + + for (int i = 0; i < vtxCount; i++) { + vtxs[i].LoadFrom(dl, vs); + + pVtxs[i] = vtxs[i].Position.ToString(); + + if (vs.NormalDesc != VertexSettings.DescType.None) + pVtxs[i] += " " + vtxs[i].Normal.ToString(); + + for (int j = 0; j < 8; j++) { + if (vs.TexCoordDesc[j] != VertexSettings.DescType.None) { + pVtxs[i] += " " + vtxs[i].TexCoords[j].ToString(); + } + } + } + + switch (prim) { + case PrimitiveType.Triangles: + var pTri = new triangles(); + pTri.count = (ulong)(vtxCount / 3); // should be 1? dunno + pTri.input = inputArray; + + StringBuilder pTriData = new StringBuilder(); + + for (int i = 0; i < vtxCount; i++) { + pTriData.AppendFormat("{0} ", pVtxs[i]); + } + + pTri.p = pTriData.ToString(); + + meshItems.Add(pTri); + break; + + case PrimitiveType.TriangleStrip: + StringBuilder pTriStripData = new StringBuilder(); + + for (int i = 0; i < vtxCount; i++) { + pTriStripData.AppendFormat("{0} ", pVtxs[i]); + } + + triStrips.Add(pTriStripData.ToString()); + break; + + default: + + Console.WriteLine("UNIMPLEMENTED PRIMITIVE TYPE"); + return; + } + } + + + // If any tristrips were found, add them! + if (triStrips.Count > 0) { + var pTriStrips = new tristrips(); + pTriStrips.input = inputArray; + pTriStrips.count = (ulong)triStrips.Count; + pTriStrips.p = triStrips.ToArray(); + meshItems.Add(pTriStrips); + } + + + m.Items = meshItems.ToArray(); + + // FINALLY DONE! + + geoIndex += 1; + } + + Collada.Save(outputStream); + } + } +} + diff --git a/NW4RTools/NW4RTools.csproj b/NW4RTools/NW4RTools.csproj index 8f9aa75..6e4bc3e 100644 --- a/NW4RTools/NW4RTools.csproj +++ b/NW4RTools/NW4RTools.csproj @@ -33,6 +33,7 @@ + @@ -56,6 +57,8 @@ + + diff --git a/NW4RTools/NW4RTools.pidb b/NW4RTools/NW4RTools.pidb index 4d58aae..2c749c8 100644 Binary files a/NW4RTools/NW4RTools.pidb and b/NW4RTools/NW4RTools.pidb differ diff --git a/NW4RTools/ObjWriter.cs b/NW4RTools/ObjWriter.cs index 297ae58..592347b 100644 --- a/NW4RTools/ObjWriter.cs +++ b/NW4RTools/ObjWriter.cs @@ -112,6 +112,10 @@ namespace NW4RTools { vs.SetDesc(vtxDesc1, vtxDesc2); vs.SetAttrFmt(vtxAttr1, vtxAttr2, vtxAttr3); + // get the Matrix to use + // todo: how to apply this?! + Matrix m = CurrentModel.Nodes[CurrentModel.MatrixIDtoNodeID[shape.MatrixID]].NodeMatrix; + // now parse the second DisplayList int posOffset = VtxPosOffsets[shape.PosData]; diff --git a/NW4RTools/Util/collada_schema_1_4.cs b/NW4RTools/Util/collada_schema_1_4.cs new file mode 100644 index 0000000..821a87b --- /dev/null +++ b/NW4RTools/Util/collada_schema_1_4.cs @@ -0,0 +1,9977 @@ +//------------------------------------------------------------------------------ +// Collada auto-generated model object from schema 1.4.1 +// This file was patched manually in order to be able to use it +// see http://code4k.blogspot.com/2010/08/import-and-export-3d-collada-files-with.html for more information +// Author: @lx +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.1 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +using System; +using System.CodeDom.Compiler; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics; +using System.Globalization; +using System.IO; +using System.Text; +using System.Text.RegularExpressions; +using System.Xml; +using System.Xml.Serialization; + +namespace Collada141 +{ + // + // This source code was auto-generated by xsd, Version=4.0.30319.1. + // + + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] +// [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public partial class COLLADA + { + private asset assetField; + private extra[] extraField; + + private object[] itemsField; + + private COLLADAScene sceneField; + + private VersionType versionField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("library_animation_clips", typeof (library_animation_clips))] + [XmlElement("library_animations", typeof (library_animations))] + [XmlElement("library_cameras", typeof (library_cameras))] + [XmlElement("library_controllers", typeof (library_controllers))] + [XmlElement("library_effects", typeof (library_effects))] + [XmlElement("library_force_fields", typeof (library_force_fields))] + [XmlElement("library_geometries", typeof (library_geometries))] + [XmlElement("library_images", typeof (library_images))] + [XmlElement("library_lights", typeof (library_lights))] + [XmlElement("library_materials", typeof (library_materials))] + [XmlElement("library_nodes", typeof (library_nodes))] + [XmlElement("library_physics_materials", typeof (library_physics_materials))] + [XmlElement("library_physics_models", typeof (library_physics_models))] + [XmlElement("library_physics_scenes", typeof (library_physics_scenes))] + [XmlElement("library_visual_scenes", typeof (library_visual_scenes))] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + public COLLADAScene scene + { + get { return sceneField; } + set { sceneField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute] + public VersionType version + { + get { return versionField; } + set { versionField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class asset + { + private assetContributor[] contributorField; + + private DateTime createdField; + + private string keywordsField; + + private DateTime modifiedField; + + private string revisionField; + + private string subjectField; + + private string titleField; + + private assetUnit unitField; + + private UpAxisType up_axisField; + + public asset() + { + up_axisField = UpAxisType.Y_UP; + } + + /// + [XmlElement("contributor")] + public assetContributor[] contributor + { + get { return contributorField; } + set { contributorField = value; } + } + + /// + public DateTime created + { + get { return createdField; } + set { createdField = value; } + } + + /// + public string keywords + { + get { return keywordsField; } + set { keywordsField = value; } + } + + /// + public DateTime modified + { + get { return modifiedField; } + set { modifiedField = value; } + } + + /// + public string revision + { + get { return revisionField; } + set { revisionField = value; } + } + + /// + public string subject + { + get { return subjectField; } + set { subjectField = value; } + } + + /// + public string title + { + get { return titleField; } + set { titleField = value; } + } + + /// + public assetUnit unit + { + get { return unitField; } + set { unitField = value; } + } + + /// + [DefaultValue(UpAxisType.Y_UP)] + public UpAxisType up_axis + { + get { return up_axisField; } + set { up_axisField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class assetContributor + { + private string authorField; + + private string authoring_toolField; + + private string commentsField; + + private string copyrightField; + + private string source_dataField; + + /// + public string author + { + get { return authorField; } + set { authorField = value; } + } + + /// + public string authoring_tool + { + get { return authoring_toolField; } + set { authoring_toolField = value; } + } + + /// + public string comments + { + get { return commentsField; } + set { commentsField = value; } + } + + /// + public string copyright + { + get { return copyrightField; } + set { copyrightField = value; } + } + + /// + [XmlElement(DataType = "anyURI")] + public string source_data + { + get { return source_dataField; } + set { source_dataField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_surface_init_from_common + { + private fx_surface_face_enum faceField; + private uint mipField; + + private uint sliceField; + + private string valueField; + + public fx_surface_init_from_common() + { + mipField = ((0)); + sliceField = ((0)); + faceField = fx_surface_face_enum.POSITIVE_X; + } + + /// + [XmlAttribute] + [DefaultValue(typeof (uint), "0")] + public uint mip + { + get { return mipField; } + set { mipField = value; } + } + + /// + [XmlAttribute] + [DefaultValue(typeof (uint), "0")] + public uint slice + { + get { return sliceField; } + set { sliceField = value; } + } + + /// + [XmlAttribute] + [DefaultValue(fx_surface_face_enum.POSITIVE_X)] + public fx_surface_face_enum face + { + get { return faceField; } + set { faceField = value; } + } + + /// + [XmlText(DataType = "IDREF")] + public string Value + { + get { return valueField; } + set { valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum fx_surface_face_enum + { + /// + POSITIVE_X, + + /// + NEGATIVE_X, + + /// + POSITIVE_Y, + + /// + NEGATIVE_Y, + + /// + POSITIVE_Z, + + /// + NEGATIVE_Z, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class common_newparam_type + { + private ItemChoiceType itemElementNameField; + private object itemField; + private string semanticField; + + private string sidField; + + /// + [XmlElement(DataType = "NCName")] + public string semantic + { + get { return semanticField; } + set { semanticField = value; } + } + + /// + [XmlElement("float", typeof (double))] + [XmlElement("float2", typeof (double))] + [XmlElement("float3", typeof (double))] + [XmlElement("float4", typeof (double))] + [XmlElement("sampler2D", typeof (fx_sampler2D_common))] + [XmlElement("surface", typeof (fx_surface_common))] + [XmlChoiceIdentifier("ItemElementName")] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + + /// + [XmlIgnore] + public ItemChoiceType ItemElementName + { + get { return itemElementNameField; } + set { itemElementNameField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_sampler2D_common + { + private string border_colorField; + private extra[] extraField; + private fx_sampler_filter_common magfilterField; + private fx_sampler_filter_common minfilterField; + + private fx_sampler_filter_common mipfilterField; + + private float mipmap_biasField; + private byte mipmap_maxlevelField; + private string sourceField; + + private fx_sampler_wrap_common wrap_sField; + + private fx_sampler_wrap_common wrap_tField; + + public fx_sampler2D_common() + { + wrap_sField = fx_sampler_wrap_common.WRAP; + wrap_tField = fx_sampler_wrap_common.WRAP; + minfilterField = fx_sampler_filter_common.NONE; + magfilterField = fx_sampler_filter_common.NONE; + mipfilterField = fx_sampler_filter_common.NONE; + mipmap_maxlevelField = ((255)); + mipmap_biasField = ((0F)); + } + + /// + [XmlElement(DataType = "NCName")] + public string source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_s + { + get { return wrap_sField; } + set { wrap_sField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_t + { + get { return wrap_tField; } + set { wrap_tField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common minfilter + { + get { return minfilterField; } + set { minfilterField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common magfilter + { + get { return magfilterField; } + set { magfilterField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common mipfilter + { + get { return mipfilterField; } + set { mipfilterField = value; } + } + + /// + public string border_color + { + get { return border_colorField; } + set { border_colorField = value; } + } + + /// + [DefaultValue(typeof (byte), "255")] + public byte mipmap_maxlevel + { + get { return mipmap_maxlevelField; } + set { mipmap_maxlevelField = value; } + } + + /// + [DefaultValue(typeof (float), "0")] + public float mipmap_bias + { + get { return mipmap_biasField; } + set { mipmap_biasField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum fx_sampler_wrap_common + { + /// + NONE, + + /// + WRAP, + + /// + MIRROR, + + /// + CLAMP, + + /// + BORDER, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum fx_sampler_filter_common + { + /// + NONE, + + /// + NEAREST, + + /// + LINEAR, + + /// + NEAREST_MIPMAP_NEAREST, + + /// + LINEAR_MIPMAP_NEAREST, + + /// + NEAREST_MIPMAP_LINEAR, + + /// + LINEAR_MIPMAP_LINEAR, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class extra + { + private asset assetField; + + private string idField; + + private string nameField; + private technique[] techniqueField; + + private string typeField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("technique")] + public technique[] technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute(DataType = "NMTOKEN")] + public string type + { + get { return typeField; } + set { typeField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class technique + { + private XmlElement[] anyField; + + private string profileField; + + /// + [XmlAnyElement] + public XmlElement[] Any + { + get { return anyField; } + set { anyField = value; } + } + + /// + [XmlAttribute(DataType = "NMTOKEN")] + public string profile + { + get { return profileField; } + set { profileField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_surface_common + { + private extra[] extraField; + private string formatField; + + private fx_surface_format_hint_common format_hintField; + private object init_as_nullField; + + private object init_as_targetField; + + private fx_surface_init_cube_common init_cubeField; + + private fx_surface_init_from_common[] init_fromField; + private fx_surface_init_planar_common init_planarField; + private fx_surface_init_volume_common init_volumeField; + + private object itemField; + + private uint mip_levelsField; + + private bool mipmap_generateField; + + private bool mipmap_generateFieldSpecified; + + private fx_surface_type_enum typeField; + + public fx_surface_common() + { + mip_levelsField = ((0)); + } + + /// + public object init_as_null + { + get { return init_as_nullField; } + set { init_as_nullField = value; } + } + + /// + public object init_as_target + { + get { return init_as_targetField; } + set { init_as_targetField = value; } + } + + /// + public fx_surface_init_cube_common init_cube + { + get { return init_cubeField; } + set { init_cubeField = value; } + } + + /// + public fx_surface_init_volume_common init_volume + { + get { return init_volumeField; } + set { init_volumeField = value; } + } + + /// + public fx_surface_init_planar_common init_planar + { + get { return init_planarField; } + set { init_planarField = value; } + } + + /// + [XmlElement("init_from")] + public fx_surface_init_from_common[] init_from + { + get { return init_fromField; } + set { init_fromField = value; } + } + + /// + [XmlElement(DataType = "token")] + public string format + { + get { return formatField; } + set { formatField = value; } + } + + /// + public fx_surface_format_hint_common format_hint + { + get { return format_hintField; } + set { format_hintField = value; } + } + + /// + [XmlElement("size", typeof (long))] + [XmlElement("viewport_ratio", typeof (double))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + + /// + [DefaultValue(typeof (uint), "0")] + public uint mip_levels + { + get { return mip_levelsField; } + set { mip_levelsField = value; } + } + + /// + public bool mipmap_generate + { + get { return mipmap_generateField; } + set { mipmap_generateField = value; } + } + + /// + [XmlIgnore] + public bool mipmap_generateSpecified + { + get { return mipmap_generateFieldSpecified; } + set { mipmap_generateFieldSpecified = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute] + public fx_surface_type_enum type + { + get { return typeField; } + set { typeField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_surface_init_cube_common + { + private object[] itemsField; + + /// + [XmlElement("all", typeof (fx_surface_init_cube_commonAll))] + [XmlElement("face", typeof (fx_surface_init_cube_commonFace))] + [XmlElement("primary", typeof (fx_surface_init_cube_commonPrimary))] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_surface_init_cube_commonAll + { + private string refField; + + /// + [XmlAttribute(DataType = "IDREF")] + public string @ref + { + get { return refField; } + set { refField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_surface_init_cube_commonFace + { + private string refField; + + /// + [XmlAttribute(DataType = "IDREF")] + public string @ref + { + get { return refField; } + set { refField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_surface_init_cube_commonPrimary + { + private fx_surface_face_enum[] orderField; + + private string refField; + + /// + [XmlElement("order")] + public fx_surface_face_enum[] order + { + get { return orderField; } + set { orderField = value; } + } + + /// + [XmlAttribute(DataType = "IDREF")] + public string @ref + { + get { return refField; } + set { refField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_surface_init_volume_common + { + private object itemField; + + /// + [XmlElement("all", typeof (fx_surface_init_volume_commonAll))] + [XmlElement("primary", typeof (fx_surface_init_volume_commonPrimary))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_surface_init_volume_commonAll + { + private string refField; + + /// + [XmlAttribute(DataType = "IDREF")] + public string @ref + { + get { return refField; } + set { refField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_surface_init_volume_commonPrimary + { + private string refField; + + /// + [XmlAttribute(DataType = "IDREF")] + public string @ref + { + get { return refField; } + set { refField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_surface_init_planar_common + { + private fx_surface_init_planar_commonAll itemField; + + /// + [XmlElement("all")] + public fx_surface_init_planar_commonAll Item + { + get { return itemField; } + set { itemField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_surface_init_planar_commonAll + { + private string refField; + + /// + [XmlAttribute(DataType = "IDREF")] + public string @ref + { + get { return refField; } + set { refField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_surface_format_hint_common + { + private fx_surface_format_hint_channels_enum channelsField; + private extra[] extraField; + private fx_surface_format_hint_option_enum[] optionField; + + private fx_surface_format_hint_precision_enum precisionField; + + private bool precisionFieldSpecified; + private fx_surface_format_hint_range_enum rangeField; + + /// + public fx_surface_format_hint_channels_enum channels + { + get { return channelsField; } + set { channelsField = value; } + } + + /// + public fx_surface_format_hint_range_enum range + { + get { return rangeField; } + set { rangeField = value; } + } + + /// + public fx_surface_format_hint_precision_enum precision + { + get { return precisionField; } + set { precisionField = value; } + } + + /// + [XmlIgnore] + public bool precisionSpecified + { + get { return precisionFieldSpecified; } + set { precisionFieldSpecified = value; } + } + + /// + [XmlElement("option")] + public fx_surface_format_hint_option_enum[] option + { + get { return optionField; } + set { optionField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum fx_surface_format_hint_channels_enum + { + /// + RGB, + + /// + RGBA, + + /// + L, + + /// + LA, + + /// + D, + + /// + XYZ, + + /// + XYZW, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum fx_surface_format_hint_range_enum + { + /// + SNORM, + + /// + UNORM, + + /// + SINT, + + /// + UINT, + + /// + FLOAT, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum fx_surface_format_hint_precision_enum + { + /// + LOW, + + /// + MID, + + /// + HIGH, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum fx_surface_format_hint_option_enum + { + /// + SRGB_GAMMA, + + /// + NORMALIZED3, + + /// + NORMALIZED4, + + /// + COMPRESSABLE, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum fx_surface_type_enum + { + /// + UNTYPED, + + /// + [XmlEnum("1D")] Item1D, + + /// + [XmlEnum("2D")] Item2D, + + /// + [XmlEnum("3D")] Item3D, + + /// + RECT, + + /// + CUBE, + + /// + DEPTH, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IncludeInSchema = false)] + public enum ItemChoiceType + { + /// + @float, + + /// + float2, + + /// + float3, + + /// + float4, + + /// + sampler2D, + + /// + surface, + } + + /// + [XmlInclude(typeof (common_transparent_type))] + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class common_color_or_texture_type + { + private object itemField; + + /// + [XmlElement("color", typeof (common_color_or_texture_typeColor))] + [XmlElement("param", typeof (common_color_or_texture_typeParam))] + [XmlElement("texture", typeof (common_color_or_texture_typeTexture))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class common_color_or_texture_typeColor + { + private string sidField; + + private double[] textField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public string _Text_ + { + get { return COLLADA.ConvertFromArray(Values); } + + set { Values = COLLADA.ConvertDoubleArray(value); } + } + + /// + [XmlIgnore] + public double[] Values + { + get { return textField; } + set { textField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class common_color_or_texture_typeParam + { + private string refField; + + /// + [XmlAttribute(DataType = "NCName")] + public string @ref + { + get { return refField; } + set { refField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class common_color_or_texture_typeTexture + { + private extra extraField; + + private string texcoordField; + private string textureField; + + /// + public extra extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string texture + { + get { return textureField; } + set { textureField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string texcoord + { + get { return texcoordField; } + set { texcoordField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class common_transparent_type : common_color_or_texture_type + { + private fx_opaque_enum opaqueField; + + public common_transparent_type() + { + opaqueField = fx_opaque_enum.A_ONE; + } + + /// + [XmlAttribute] + [DefaultValue(fx_opaque_enum.A_ONE)] + public fx_opaque_enum opaque + { + get { return opaqueField; } + set { opaqueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum fx_opaque_enum + { + /// + A_ONE, + + /// + RGB_ZERO, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class common_float_or_param_type + { + private object itemField; + + /// + [XmlElement("float", typeof (common_float_or_param_typeFloat))] + [XmlElement("param", typeof (common_float_or_param_typeParam))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class common_float_or_param_typeFloat + { + private string sidField; + + private double valueField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public double Value + { + get { return valueField; } + set { valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class common_float_or_param_typeParam + { + private string refField; + + /// + [XmlAttribute(DataType = "NCName")] + public string @ref + { + get { return refField; } + set { refField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_include_common + { + private string sidField; + + private string urlField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string url + { + get { return urlField; } + set { urlField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_samplerDEPTH_common + { + private extra[] extraField; + private fx_sampler_filter_common magfilterField; + private fx_sampler_filter_common minfilterField; + private string sourceField; + + private fx_sampler_wrap_common wrap_sField; + + private fx_sampler_wrap_common wrap_tField; + + public fx_samplerDEPTH_common() + { + wrap_sField = fx_sampler_wrap_common.WRAP; + wrap_tField = fx_sampler_wrap_common.WRAP; + minfilterField = fx_sampler_filter_common.NONE; + magfilterField = fx_sampler_filter_common.NONE; + } + + /// + [XmlElement(DataType = "NCName")] + public string source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_s + { + get { return wrap_sField; } + set { wrap_sField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_t + { + get { return wrap_tField; } + set { wrap_tField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common minfilter + { + get { return minfilterField; } + set { minfilterField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common magfilter + { + get { return magfilterField; } + set { magfilterField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_samplerRECT_common + { + private string border_colorField; + private extra[] extraField; + private fx_sampler_filter_common magfilterField; + private fx_sampler_filter_common minfilterField; + + private fx_sampler_filter_common mipfilterField; + + private float mipmap_biasField; + private byte mipmap_maxlevelField; + private string sourceField; + + private fx_sampler_wrap_common wrap_sField; + + private fx_sampler_wrap_common wrap_tField; + + public fx_samplerRECT_common() + { + wrap_sField = fx_sampler_wrap_common.WRAP; + wrap_tField = fx_sampler_wrap_common.WRAP; + minfilterField = fx_sampler_filter_common.NONE; + magfilterField = fx_sampler_filter_common.NONE; + mipfilterField = fx_sampler_filter_common.NONE; + mipmap_maxlevelField = ((255)); + mipmap_biasField = ((0F)); + } + + /// + [XmlElement(DataType = "NCName")] + public string source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_s + { + get { return wrap_sField; } + set { wrap_sField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_t + { + get { return wrap_tField; } + set { wrap_tField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common minfilter + { + get { return minfilterField; } + set { minfilterField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common magfilter + { + get { return magfilterField; } + set { magfilterField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common mipfilter + { + get { return mipfilterField; } + set { mipfilterField = value; } + } + + /// + public string border_color + { + get { return border_colorField; } + set { border_colorField = value; } + } + + /// + [DefaultValue(typeof (byte), "255")] + public byte mipmap_maxlevel + { + get { return mipmap_maxlevelField; } + set { mipmap_maxlevelField = value; } + } + + /// + [DefaultValue(typeof (float), "0")] + public float mipmap_bias + { + get { return mipmap_biasField; } + set { mipmap_biasField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_samplerCUBE_common + { + private string border_colorField; + private extra[] extraField; + private fx_sampler_filter_common magfilterField; + private fx_sampler_filter_common minfilterField; + + private fx_sampler_filter_common mipfilterField; + + private float mipmap_biasField; + private byte mipmap_maxlevelField; + private string sourceField; + private fx_sampler_wrap_common wrap_pField; + private fx_sampler_wrap_common wrap_sField; + + private fx_sampler_wrap_common wrap_tField; + + public fx_samplerCUBE_common() + { + wrap_sField = fx_sampler_wrap_common.WRAP; + wrap_tField = fx_sampler_wrap_common.WRAP; + wrap_pField = fx_sampler_wrap_common.WRAP; + minfilterField = fx_sampler_filter_common.NONE; + magfilterField = fx_sampler_filter_common.NONE; + mipfilterField = fx_sampler_filter_common.NONE; + mipmap_maxlevelField = ((255)); + mipmap_biasField = ((0F)); + } + + /// + [XmlElement(DataType = "NCName")] + public string source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_s + { + get { return wrap_sField; } + set { wrap_sField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_t + { + get { return wrap_tField; } + set { wrap_tField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_p + { + get { return wrap_pField; } + set { wrap_pField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common minfilter + { + get { return minfilterField; } + set { minfilterField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common magfilter + { + get { return magfilterField; } + set { magfilterField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common mipfilter + { + get { return mipfilterField; } + set { mipfilterField = value; } + } + + /// + public string border_color + { + get { return border_colorField; } + set { border_colorField = value; } + } + + /// + [DefaultValue(typeof (byte), "255")] + public byte mipmap_maxlevel + { + get { return mipmap_maxlevelField; } + set { mipmap_maxlevelField = value; } + } + + /// + [DefaultValue(typeof (float), "0")] + public float mipmap_bias + { + get { return mipmap_biasField; } + set { mipmap_biasField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_sampler3D_common + { + private string border_colorField; + private extra[] extraField; + private fx_sampler_filter_common magfilterField; + private fx_sampler_filter_common minfilterField; + + private fx_sampler_filter_common mipfilterField; + + private float mipmap_biasField; + private byte mipmap_maxlevelField; + private string sourceField; + private fx_sampler_wrap_common wrap_pField; + private fx_sampler_wrap_common wrap_sField; + + private fx_sampler_wrap_common wrap_tField; + + public fx_sampler3D_common() + { + wrap_sField = fx_sampler_wrap_common.WRAP; + wrap_tField = fx_sampler_wrap_common.WRAP; + wrap_pField = fx_sampler_wrap_common.WRAP; + minfilterField = fx_sampler_filter_common.NONE; + magfilterField = fx_sampler_filter_common.NONE; + mipfilterField = fx_sampler_filter_common.NONE; + mipmap_maxlevelField = ((255)); + mipmap_biasField = ((0F)); + } + + /// + [XmlElement(DataType = "NCName")] + public string source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_s + { + get { return wrap_sField; } + set { wrap_sField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_t + { + get { return wrap_tField; } + set { wrap_tField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_p + { + get { return wrap_pField; } + set { wrap_pField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common minfilter + { + get { return minfilterField; } + set { minfilterField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common magfilter + { + get { return magfilterField; } + set { magfilterField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common mipfilter + { + get { return mipfilterField; } + set { mipfilterField = value; } + } + + /// + public string border_color + { + get { return border_colorField; } + set { border_colorField = value; } + } + + /// + [DefaultValue(typeof (byte), "255")] + public byte mipmap_maxlevel + { + get { return mipmap_maxlevelField; } + set { mipmap_maxlevelField = value; } + } + + /// + [DefaultValue(typeof (float), "0")] + public float mipmap_bias + { + get { return mipmap_biasField; } + set { mipmap_biasField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_sampler1D_common + { + private string border_colorField; + private extra[] extraField; + private fx_sampler_filter_common magfilterField; + private fx_sampler_filter_common minfilterField; + + private fx_sampler_filter_common mipfilterField; + + private float mipmap_biasField; + private byte mipmap_maxlevelField; + private string sourceField; + + private fx_sampler_wrap_common wrap_sField; + + public fx_sampler1D_common() + { + wrap_sField = fx_sampler_wrap_common.WRAP; + minfilterField = fx_sampler_filter_common.NONE; + magfilterField = fx_sampler_filter_common.NONE; + mipfilterField = fx_sampler_filter_common.NONE; + mipmap_maxlevelField = ((0)); + mipmap_biasField = ((0F)); + } + + /// + [XmlElement(DataType = "NCName")] + public string source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + [DefaultValue(fx_sampler_wrap_common.WRAP)] + public fx_sampler_wrap_common wrap_s + { + get { return wrap_sField; } + set { wrap_sField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common minfilter + { + get { return minfilterField; } + set { minfilterField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common magfilter + { + get { return magfilterField; } + set { magfilterField = value; } + } + + /// + [DefaultValue(fx_sampler_filter_common.NONE)] + public fx_sampler_filter_common mipfilter + { + get { return mipfilterField; } + set { mipfilterField = value; } + } + + /// + public string border_color + { + get { return border_colorField; } + set { border_colorField = value; } + } + + /// + [DefaultValue(typeof (byte), "0")] + public byte mipmap_maxlevel + { + get { return mipmap_maxlevelField; } + set { mipmap_maxlevelField = value; } + } + + /// + [DefaultValue(typeof (float), "0")] + public float mipmap_bias + { + get { return mipmap_biasField; } + set { mipmap_biasField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class InputGlobal + { + private string semanticField; + + private string sourceField; + + /// + [XmlAttribute(DataType = "NMTOKEN")] + public string semantic + { + get { return semanticField; } + set { semanticField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string source + { + get { return sourceField; } + set { sourceField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_newparam_common + { + private fx_annotate_common[] annotateField; + + private string bool2Field; + + private string bool3Field; + + private string bool4Field; + private bool boolField; + private string enumField; + + private double float1x1Field; + + private string float1x2Field; + + private string float1x3Field; + + private string float1x4Field; + private string float2Field; + + private string float2x1Field; + + private string float2x2Field; + + private string float2x3Field; + + private string float2x4Field; + private string float3Field; + + private string float3x1Field; + + private string float3x2Field; + + private string float3x3Field; + + private string float3x4Field; + private string float4Field; + + private string float4x1Field; + + private string float4x2Field; + + private string float4x3Field; + + private string float4x4Field; + private double floatField; + private string int2Field; + + private string int3Field; + + private string int4Field; + private long intField; + private fx_modifier_enum_common modifierField; + + private bool modifierFieldSpecified; + + private fx_sampler1D_common sampler1DField; + + private fx_sampler2D_common sampler2DField; + + private fx_sampler3D_common sampler3DField; + + private fx_samplerCUBE_common samplerCUBEField; + + private fx_samplerDEPTH_common samplerDEPTHField; + private fx_samplerRECT_common samplerRECTField; + private string semanticField; + + private string sidField; + private fx_surface_common surfaceField; + + /// + [XmlElement("annotate")] + public fx_annotate_common[] annotate + { + get { return annotateField; } + set { annotateField = value; } + } + + /// + [XmlElement(DataType = "NCName")] + public string semantic + { + get { return semanticField; } + set { semanticField = value; } + } + + /// + public fx_modifier_enum_common modifier + { + get { return modifierField; } + set { modifierField = value; } + } + + /// + [XmlIgnore] + public bool modifierSpecified + { + get { return modifierFieldSpecified; } + set { modifierFieldSpecified = value; } + } + + /// + public bool @bool + { + get { return boolField; } + set { boolField = value; } + } + + /// + public string bool2 + { + get { return bool2Field; } + set { bool2Field = value; } + } + + /// + public string bool3 + { + get { return bool3Field; } + set { bool3Field = value; } + } + + /// + public string bool4 + { + get { return bool4Field; } + set { bool4Field = value; } + } + + /// + public long @int + { + get { return intField; } + set { intField = value; } + } + + /// + public string int2 + { + get { return int2Field; } + set { int2Field = value; } + } + + /// + public string int3 + { + get { return int3Field; } + set { int3Field = value; } + } + + /// + public string int4 + { + get { return int4Field; } + set { int4Field = value; } + } + + /// + public double @float + { + get { return floatField; } + set { floatField = value; } + } + + /// + public string float2 + { + get { return float2Field; } + set { float2Field = value; } + } + + /// + public string float3 + { + get { return float3Field; } + set { float3Field = value; } + } + + /// + public string float4 + { + get { return float4Field; } + set { float4Field = value; } + } + + /// + public double float1x1 + { + get { return float1x1Field; } + set { float1x1Field = value; } + } + + /// + public string float1x2 + { + get { return float1x2Field; } + set { float1x2Field = value; } + } + + /// + public string float1x3 + { + get { return float1x3Field; } + set { float1x3Field = value; } + } + + /// + public string float1x4 + { + get { return float1x4Field; } + set { float1x4Field = value; } + } + + /// + public string float2x1 + { + get { return float2x1Field; } + set { float2x1Field = value; } + } + + /// + public string float2x2 + { + get { return float2x2Field; } + set { float2x2Field = value; } + } + + /// + public string float2x3 + { + get { return float2x3Field; } + set { float2x3Field = value; } + } + + /// + public string float2x4 + { + get { return float2x4Field; } + set { float2x4Field = value; } + } + + /// + public string float3x1 + { + get { return float3x1Field; } + set { float3x1Field = value; } + } + + /// + public string float3x2 + { + get { return float3x2Field; } + set { float3x2Field = value; } + } + + /// + public string float3x3 + { + get { return float3x3Field; } + set { float3x3Field = value; } + } + + /// + public string float3x4 + { + get { return float3x4Field; } + set { float3x4Field = value; } + } + + /// + public string float4x1 + { + get { return float4x1Field; } + set { float4x1Field = value; } + } + + /// + public string float4x2 + { + get { return float4x2Field; } + set { float4x2Field = value; } + } + + /// + public string float4x3 + { + get { return float4x3Field; } + set { float4x3Field = value; } + } + + /// + public string float4x4 + { + get { return float4x4Field; } + set { float4x4Field = value; } + } + + /// + public fx_surface_common surface + { + get { return surfaceField; } + set { surfaceField = value; } + } + + /// + public fx_sampler1D_common sampler1D + { + get { return sampler1DField; } + set { sampler1DField = value; } + } + + /// + public fx_sampler2D_common sampler2D + { + get { return sampler2DField; } + set { sampler2DField = value; } + } + + /// + public fx_sampler3D_common sampler3D + { + get { return sampler3DField; } + set { sampler3DField = value; } + } + + /// + public fx_samplerCUBE_common samplerCUBE + { + get { return samplerCUBEField; } + set { samplerCUBEField = value; } + } + + /// + public fx_samplerRECT_common samplerRECT + { + get { return samplerRECTField; } + set { samplerRECTField = value; } + } + + /// + public fx_samplerDEPTH_common samplerDEPTH + { + get { return samplerDEPTHField; } + set { samplerDEPTHField = value; } + } + + /// + public string @enum + { + get { return enumField; } + set { enumField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class fx_annotate_common + { + private string bool2Field; + + private string bool3Field; + + private string bool4Field; + private bool boolField; + + private string float2Field; + + private string float2x2Field; + private string float3Field; + + private string float3x3Field; + private string float4Field; + + private string float4x4Field; + private double floatField; + private string int2Field; + + private string int3Field; + + private string int4Field; + private long intField; + + private string nameField; + private string stringField; + + /// + public bool @bool + { + get { return boolField; } + set { boolField = value; } + } + + /// + public string bool2 + { + get { return bool2Field; } + set { bool2Field = value; } + } + + /// + public string bool3 + { + get { return bool3Field; } + set { bool3Field = value; } + } + + /// + public string bool4 + { + get { return bool4Field; } + set { bool4Field = value; } + } + + /// + public long @int + { + get { return intField; } + set { intField = value; } + } + + /// + public string int2 + { + get { return int2Field; } + set { int2Field = value; } + } + + /// + public string int3 + { + get { return int3Field; } + set { int3Field = value; } + } + + /// + public string int4 + { + get { return int4Field; } + set { int4Field = value; } + } + + /// + public double @float + { + get { return floatField; } + set { floatField = value; } + } + + /// + public string float2 + { + get { return float2Field; } + set { float2Field = value; } + } + + /// + public string float3 + { + get { return float3Field; } + set { float3Field = value; } + } + + /// + public string float4 + { + get { return float4Field; } + set { float4Field = value; } + } + + /// + public string float2x2 + { + get { return float2x2Field; } + set { float2x2Field = value; } + } + + /// + public string float3x3 + { + get { return float3x3Field; } + set { float3x3Field = value; } + } + + /// + public string float4x4 + { + get { return float4x4Field; } + set { float4x4Field = value; } + } + + /// + public string @string + { + get { return stringField; } + set { stringField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum fx_modifier_enum_common + { + /// + CONST, + + /// + UNIFORM, + + /// + VARYING, + + /// + STATIC, + + /// + VOLATILE, + + /// + EXTERN, + + /// + SHARED, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class InputLocalOffset + { + private ulong offsetField; + + private string semanticField; + + private ulong setField; + + private bool setFieldSpecified; + private string sourceField; + + /// + [XmlAttribute] + public ulong offset + { + get { return offsetField; } + set { offsetField = value; } + } + + /// + [XmlAttribute(DataType = "NMTOKEN")] + public string semantic + { + get { return semanticField; } + set { semanticField = value; } + } + + /// + [XmlAttribute] + public string source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + [XmlAttribute] + public ulong set + { + get { return setField; } + set { setField = value; } + } + + /// + [XmlIgnore] + public bool setSpecified + { + get { return setFieldSpecified; } + set { setFieldSpecified = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class TargetableFloat + { + private string sidField; + + private double valueField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public double Value + { + get { return valueField; } + set { valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class InputLocal + { + private string semanticField; + + private string sourceField; + + /// + [XmlAttribute(DataType = "NMTOKEN")] + public string semantic + { + get { return semanticField; } + set { semanticField = value; } + } + + /// + [XmlAttribute] + public string source + { + get { return sourceField; } + set { sourceField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class instance_material + { + private instance_materialBind[] bindField; + + private instance_materialBind_vertex_input[] bind_vertex_inputField; + + private extra[] extraField; + private string nameField; + private string sidField; + + private string symbolField; + + private string targetField; + + /// + [XmlElement("bind")] + public instance_materialBind[] bind + { + get { return bindField; } + set { bindField = value; } + } + + /// + [XmlElement("bind_vertex_input")] + public instance_materialBind_vertex_input[] bind_vertex_input + { + get { return bind_vertex_inputField; } + set { bind_vertex_inputField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string symbol + { + get { return symbolField; } + set { symbolField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string target + { + get { return targetField; } + set { targetField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class instance_materialBind + { + private string semanticField; + + private string targetField; + + /// + [XmlAttribute(DataType = "NCName")] + public string semantic + { + get { return semanticField; } + set { semanticField = value; } + } + + /// + [XmlAttribute(DataType = "token")] + public string target + { + get { return targetField; } + set { targetField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class instance_materialBind_vertex_input + { + private string input_semanticField; + + private ulong input_setField; + + private bool input_setFieldSpecified; + private string semanticField; + + /// + [XmlAttribute(DataType = "NCName")] + public string semantic + { + get { return semanticField; } + set { semanticField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string input_semantic + { + get { return input_semanticField; } + set { input_semanticField = value; } + } + + /// + [XmlAttribute] + public ulong input_set + { + get { return input_setField; } + set { input_setField = value; } + } + + /// + [XmlIgnore] + public bool input_setSpecified + { + get { return input_setFieldSpecified; } + set { input_setFieldSpecified = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class assetUnit + { + private double meterField; + + private string nameField; + + public assetUnit() + { + meterField = 1D; + nameField = "meter"; + } + + /// + [XmlAttribute] + [DefaultValue(1D)] + public double meter + { + get { return meterField; } + set { meterField = value; } + } + + /// + [XmlAttribute(DataType = "NMTOKEN")] + [DefaultValue("meter")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum UpAxisType + { + /// + X_UP, + + /// + Y_UP, + + /// + Z_UP, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_animation_clips + { + private animation_clip[] animation_clipField; + private asset assetField; + + private extra[] extraField; + + private string idField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("animation_clip")] + public animation_clip[] animation_clip + { + get { return animation_clipField; } + set { animation_clipField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class animation_clip + { + private asset assetField; + private double endField; + + private bool endFieldSpecified; + + private extra[] extraField; + + private string idField; + private InstanceWithExtra[] instance_animationField; + + private string nameField; + + private double startField; + + public animation_clip() + { + startField = 0D; + } + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("instance_animation")] + public InstanceWithExtra[] instance_animation + { + get { return instance_animationField; } + set { instance_animationField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + [DefaultValue(0D)] + public double start + { + get { return startField; } + set { startField = value; } + } + + /// + [XmlAttribute] + public double end + { + get { return endField; } + set { endField = value; } + } + + /// + [XmlIgnore] + public bool endSpecified + { + get { return endFieldSpecified; } + set { endFieldSpecified = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot("instance_camera", Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class InstanceWithExtra + { + private extra[] extraField; + + private string nameField; + private string sidField; + private string urlField; + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string url + { + get { return urlField; } + set { urlField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_animations + { + private animation[] animationField; + private asset assetField; + + private extra[] extraField; + + private string idField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("animation")] + public animation[] animation + { + get { return animationField; } + set { animationField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class animation + { + private asset assetField; + + private extra[] extraField; + + private string idField; + private object[] itemsField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("animation", typeof (animation))] + [XmlElement("channel", typeof (channel))] + [XmlElement("sampler", typeof (sampler))] + [XmlElement("source", typeof (source))] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class channel + { + private string sourceField; + + private string targetField; + + /// + [XmlAttribute] + public string source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + [XmlAttribute(DataType = "token")] + public string target + { + get { return targetField; } + set { targetField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class sampler + { + private string idField; + private InputLocal[] inputField; + + /// + [XmlElement("input")] + public InputLocal[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class source + { + private asset assetField; + + private string idField; + private object itemField; + + private string nameField; + private technique[] techniqueField; + private sourceTechnique_common technique_commonField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("IDREF_array", typeof (IDREF_array))] + [XmlElement("Name_array", typeof (Name_array))] + [XmlElement("bool_array", typeof (bool_array))] + [XmlElement("float_array", typeof (float_array))] + [XmlElement("int_array", typeof (int_array))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + + /// + public sourceTechnique_common technique_common + { + get { return technique_commonField; } + set { technique_commonField = value; } + } + + /// + [XmlElement("technique")] + public technique[] technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class IDREF_array + { + private ulong countField; + private string idField; + + private string nameField; + + private string valueField; + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlText(DataType = "IDREFS")] + public string Value + { + get { return valueField; } + set { valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class Name_array + { + private ulong countField; + private string idField; + + private string nameField; + + private string[] textField; + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlElement("Name")] + public string _Text_ + { + get { return COLLADA.ConvertFromArray(Values); } + + set { Values = COLLADA.ConvertStringArray(value); } + } + + [XmlIgnore] + public string[] Values + { + get { return textField; } + set { textField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class bool_array + { + private ulong countField; + private string idField; + + private string nameField; + + private bool[] textField; + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlText] + public string _Text_ + { + get { return COLLADA.ConvertFromArray(Values); } + + set { Values = COLLADA.ConvertBoolArray(value); } + } + + [XmlIgnore] + public bool[] Values + { + get { return textField; } + set { textField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + //[DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class float_array + { + private ulong countField; + + private short digitsField; + private string idField; + + private short magnitudeField; + private string nameField; + + private double[] textField; + + public float_array() + { + digitsField = ((6)); + magnitudeField = ((38)); + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlAttribute] + [DefaultValue(typeof (short), "6")] + public short digits + { + get { return digitsField; } + set { digitsField = value; } + } + + /// + [XmlAttribute] + [DefaultValue(typeof (short), "38")] + public short magnitude + { + get { return magnitudeField; } + set { magnitudeField = value; } + } + + /// + [XmlText] + public string _Text_ + { + get { return COLLADA.ConvertFromArray(Values); } + + set { Values = COLLADA.ConvertDoubleArray(value); } + } + + [XmlIgnore] + public double[] Values + { + get { return textField; } + set { textField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class int_array + { + private ulong countField; + private string idField; + + private string maxInclusiveField; + private string minInclusiveField; + private string nameField; + + private int[] textField; + + public int_array() + { + minInclusiveField = "-2147483648"; + maxInclusiveField = "2147483647"; + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlAttribute(DataType = "integer")] + [DefaultValue("-2147483648")] + public string minInclusive + { + get { return minInclusiveField; } + set { minInclusiveField = value; } + } + + /// + [XmlAttribute(DataType = "integer")] + [DefaultValue("2147483647")] + public string maxInclusive + { + get { return maxInclusiveField; } + set { maxInclusiveField = value; } + } + + /// + [XmlText] + public string _Text_ + { + get { return COLLADA.ConvertFromArray(Values); } + + set { Values = COLLADA.ConvertIntArray(value); } + } + + [XmlIgnore] + public int[] Values + { + get { return textField; } + set { textField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class sourceTechnique_common + { + private accessor accessorField; + + /// + public accessor accessor + { + get { return accessorField; } + set { accessorField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class accessor + { + private ulong countField; + + private ulong offsetField; + private param[] paramField; + + private string sourceField; + + private ulong strideField; + + public accessor() + { + offsetField = ((ulong) (0m)); + strideField = ((ulong) (1m)); + } + + /// + [XmlElement("param")] + public param[] param + { + get { return paramField; } + set { paramField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlAttribute] + [DefaultValue(typeof (ulong), "0")] + public ulong offset + { + get { return offsetField; } + set { offsetField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + [XmlAttribute] + [DefaultValue(typeof (ulong), "1")] + public ulong stride + { + get { return strideField; } + set { strideField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class param + { + private string nameField; + + private string semanticField; + private string sidField; + + private string typeField; + + private string valueField; + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute(DataType = "NMTOKEN")] + public string semantic + { + get { return semanticField; } + set { semanticField = value; } + } + + /// + [XmlAttribute(DataType = "NMTOKEN")] + public string type + { + get { return typeField; } + set { typeField = value; } + } + + /// + [XmlText] + public string Value + { + get { return valueField; } + set { valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_cameras + { + private asset assetField; + + private camera[] cameraField; + + private extra[] extraField; + + private string idField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("camera")] + public camera[] camera + { + get { return cameraField; } + set { cameraField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class camera + { + private asset assetField; + + private extra[] extraField; + + private string idField; + private cameraImager imagerField; + + private string nameField; + private cameraOptics opticsField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + public cameraOptics optics + { + get { return opticsField; } + set { opticsField = value; } + } + + /// + public cameraImager imager + { + get { return imagerField; } + set { imagerField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class cameraOptics + { + private extra[] extraField; + private technique[] techniqueField; + private cameraOpticsTechnique_common technique_commonField; + + /// + public cameraOpticsTechnique_common technique_common + { + get { return technique_commonField; } + set { technique_commonField = value; } + } + + /// + [XmlElement("technique")] + public technique[] technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class cameraOpticsTechnique_common + { + private object itemField; + + /// + [XmlElement("orthographic", typeof (cameraOpticsTechnique_commonOrthographic))] + [XmlElement("perspective", typeof (cameraOpticsTechnique_commonPerspective))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class cameraOpticsTechnique_commonOrthographic + { + private ItemsChoiceType[] itemsElementNameField; + private TargetableFloat[] itemsField; + + private TargetableFloat zfarField; + private TargetableFloat znearField; + + /// + [XmlElement("aspect_ratio", typeof (TargetableFloat))] + [XmlElement("xmag", typeof (TargetableFloat))] + [XmlElement("ymag", typeof (TargetableFloat))] + [XmlChoiceIdentifier("ItemsElementName")] + public TargetableFloat[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlElement("ItemsElementName")] + [XmlIgnore] + public ItemsChoiceType[] ItemsElementName + { + get { return itemsElementNameField; } + set { itemsElementNameField = value; } + } + + /// + public TargetableFloat znear + { + get { return znearField; } + set { znearField = value; } + } + + /// + public TargetableFloat zfar + { + get { return zfarField; } + set { zfarField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IncludeInSchema = false)] + public enum ItemsChoiceType + { + /// + aspect_ratio, + + /// + xmag, + + /// + ymag, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class cameraOpticsTechnique_commonPerspective + { + private ItemsChoiceType1[] itemsElementNameField; + private TargetableFloat[] itemsField; + + private TargetableFloat zfarField; + private TargetableFloat znearField; + + /// + [XmlElement("aspect_ratio", typeof (TargetableFloat))] + [XmlElement("xfov", typeof (TargetableFloat))] + [XmlElement("yfov", typeof (TargetableFloat))] + [XmlChoiceIdentifier("ItemsElementName")] + public TargetableFloat[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlElement("ItemsElementName")] + [XmlIgnore] + public ItemsChoiceType1[] ItemsElementName + { + get { return itemsElementNameField; } + set { itemsElementNameField = value; } + } + + /// + public TargetableFloat znear + { + get { return znearField; } + set { znearField = value; } + } + + /// + public TargetableFloat zfar + { + get { return zfarField; } + set { zfarField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IncludeInSchema = false)] + public enum ItemsChoiceType1 + { + /// + aspect_ratio, + + /// + xfov, + + /// + yfov, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class cameraImager + { + private extra[] extraField; + private technique[] techniqueField; + + /// + [XmlElement("technique")] + public technique[] technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_controllers + { + private asset assetField; + + private controller[] controllerField; + + private extra[] extraField; + + private string idField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("controller")] + public controller[] controller + { + get { return controllerField; } + set { controllerField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class controller + { + private asset assetField; + + private extra[] extraField; + + private string idField; + private object itemField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("morph", typeof (morph))] + [XmlElement("skin", typeof (skin))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class morph + { + private extra[] extraField; + + private MorphMethodType methodField; + + private string source1Field; + private source[] sourceField; + + private morphTargets targetsField; + + public morph() + { + methodField = MorphMethodType.NORMALIZED; + } + + /// + [XmlElement("source")] + public source[] source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + public morphTargets targets + { + get { return targetsField; } + set { targetsField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute] + [DefaultValue(MorphMethodType.NORMALIZED)] + public MorphMethodType method + { + get { return methodField; } + set { methodField = value; } + } + + /// + [XmlAttribute("source", DataType = "anyURI")] + public string source1 + { + get { return source1Field; } + set { source1Field = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class morphTargets + { + private extra[] extraField; + private InputLocal[] inputField; + + /// + [XmlElement("input")] + public InputLocal[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum MorphMethodType + { + /// + NORMALIZED, + + /// + RELATIVE, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class skin + { + private string bind_shape_matrixField; + + private extra[] extraField; + private skinJoints jointsField; + + private string source1Field; + private source[] sourceField; + private skinVertex_weights vertex_weightsField; + + /// + public string bind_shape_matrix + { + get { return bind_shape_matrixField; } + set { bind_shape_matrixField = value; } + } + + /// + [XmlElement("source")] + public source[] source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + public skinJoints joints + { + get { return jointsField; } + set { jointsField = value; } + } + + /// + public skinVertex_weights vertex_weights + { + get { return vertex_weightsField; } + set { vertex_weightsField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute("source", DataType = "anyURI")] + public string source1 + { + get { return source1Field; } + set { source1Field = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class skinJoints + { + private extra[] extraField; + private InputLocal[] inputField; + + /// + [XmlElement("input")] + public InputLocal[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class skinVertex_weights + { + private ulong countField; + private extra[] extraField; + private InputLocalOffset[] inputField; + + private string vField; + private string vcountField; + + /// + [XmlElement("input")] + public InputLocalOffset[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + public string vcount + { + get { return vcountField; } + set { vcountField = value; } + } + + /// + public string v + { + get { return vField; } + set { vField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_effects + { + private asset assetField; + + private effect[] effectField; + + private extra[] extraField; + + private string idField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("effect")] + public effect[] effect + { + get { return effectField; } + set { effectField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class effect + { + private fx_annotate_common[] annotateField; + private asset assetField; + + private extra[] extraField; + + private string idField; + private image[] imageField; + private effectFx_profile_abstractProfile_COMMON[] itemsField; + + private string nameField; + private fx_newparam_common[] newparamField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("annotate")] + public fx_annotate_common[] annotate + { + get { return annotateField; } + set { annotateField = value; } + } + + /// + [XmlElement("image")] + public image[] image + { + get { return imageField; } + set { imageField = value; } + } + + /// + [XmlElement("newparam")] + public fx_newparam_common[] newparam + { + get { return newparamField; } + set { newparamField = value; } + } + + /// + [XmlElement("profile_COMMON")] + public effectFx_profile_abstractProfile_COMMON[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class image + { + private asset assetField; + private ulong depthField; + + private extra[] extraField; + + private string formatField; + + private ulong heightField; + + private bool heightFieldSpecified; + private string idField; + private object itemField; + private string nameField; + + private ulong widthField; + + private bool widthFieldSpecified; + + public image() + { + depthField = ((ulong) (1m)); + } + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("data", typeof (byte[]), DataType = "hexBinary")] + [XmlElement("init_from", typeof (string), DataType = "anyURI")] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute(DataType = "token")] + public string format + { + get { return formatField; } + set { formatField = value; } + } + + /// + [XmlAttribute] + public ulong height + { + get { return heightField; } + set { heightField = value; } + } + + /// + [XmlIgnore] + public bool heightSpecified + { + get { return heightFieldSpecified; } + set { heightFieldSpecified = value; } + } + + /// + [XmlAttribute] + public ulong width + { + get { return widthField; } + set { widthField = value; } + } + + /// + [XmlIgnore] + public bool widthSpecified + { + get { return widthFieldSpecified; } + set { widthFieldSpecified = value; } + } + + /// + [XmlAttribute] + [DefaultValue(typeof (ulong), "1")] + public ulong depth + { + get { return depthField; } + set { depthField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot("profile_COMMON", Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class effectFx_profile_abstractProfile_COMMON + { + private asset assetField; + + private extra[] extraField; + + private string idField; + private object[] itemsField; + + private effectFx_profile_abstractProfile_COMMONTechnique techniqueField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("image", typeof (image))] + [XmlElement("newparam", typeof (common_newparam_type))] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + public effectFx_profile_abstractProfile_COMMONTechnique technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class effectFx_profile_abstractProfile_COMMONTechnique + { + private asset assetField; + + private extra[] extraField; + + private string idField; + private object itemField; + private object[] itemsField; + + private string sidField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("image", typeof (image))] + [XmlElement("newparam", typeof (common_newparam_type))] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlElement("blinn", typeof (effectFx_profile_abstractProfile_COMMONTechniqueBlinn))] + [XmlElement("constant", typeof (effectFx_profile_abstractProfile_COMMONTechniqueConstant))] + [XmlElement("lambert", typeof (effectFx_profile_abstractProfile_COMMONTechniqueLambert))] + [XmlElement("phong", typeof (effectFx_profile_abstractProfile_COMMONTechniquePhong))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class effectFx_profile_abstractProfile_COMMONTechniqueBlinn + { + private common_color_or_texture_type ambientField; + + private common_color_or_texture_type diffuseField; + private common_color_or_texture_type emissionField; + private common_float_or_param_type index_of_refractionField; + + private common_color_or_texture_type reflectiveField; + + private common_float_or_param_type reflectivityField; + private common_float_or_param_type shininessField; + private common_color_or_texture_type specularField; + + private common_float_or_param_type transparencyField; + private common_transparent_type transparentField; + + /// + public common_color_or_texture_type emission + { + get { return emissionField; } + set { emissionField = value; } + } + + /// + public common_color_or_texture_type ambient + { + get { return ambientField; } + set { ambientField = value; } + } + + /// + public common_color_or_texture_type diffuse + { + get { return diffuseField; } + set { diffuseField = value; } + } + + /// + public common_color_or_texture_type specular + { + get { return specularField; } + set { specularField = value; } + } + + /// + public common_float_or_param_type shininess + { + get { return shininessField; } + set { shininessField = value; } + } + + /// + public common_color_or_texture_type reflective + { + get { return reflectiveField; } + set { reflectiveField = value; } + } + + /// + public common_float_or_param_type reflectivity + { + get { return reflectivityField; } + set { reflectivityField = value; } + } + + /// + public common_transparent_type transparent + { + get { return transparentField; } + set { transparentField = value; } + } + + /// + public common_float_or_param_type transparency + { + get { return transparencyField; } + set { transparencyField = value; } + } + + /// + public common_float_or_param_type index_of_refraction + { + get { return index_of_refractionField; } + set { index_of_refractionField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class effectFx_profile_abstractProfile_COMMONTechniqueConstant + { + private common_color_or_texture_type emissionField; + private common_float_or_param_type index_of_refractionField; + + private common_color_or_texture_type reflectiveField; + + private common_float_or_param_type reflectivityField; + + private common_float_or_param_type transparencyField; + private common_transparent_type transparentField; + + /// + public common_color_or_texture_type emission + { + get { return emissionField; } + set { emissionField = value; } + } + + /// + public common_color_or_texture_type reflective + { + get { return reflectiveField; } + set { reflectiveField = value; } + } + + /// + public common_float_or_param_type reflectivity + { + get { return reflectivityField; } + set { reflectivityField = value; } + } + + /// + public common_transparent_type transparent + { + get { return transparentField; } + set { transparentField = value; } + } + + /// + public common_float_or_param_type transparency + { + get { return transparencyField; } + set { transparencyField = value; } + } + + /// + public common_float_or_param_type index_of_refraction + { + get { return index_of_refractionField; } + set { index_of_refractionField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class effectFx_profile_abstractProfile_COMMONTechniqueLambert + { + private common_color_or_texture_type ambientField; + + private common_color_or_texture_type diffuseField; + private common_color_or_texture_type emissionField; + private common_float_or_param_type index_of_refractionField; + + private common_color_or_texture_type reflectiveField; + + private common_float_or_param_type reflectivityField; + + private common_float_or_param_type transparencyField; + private common_transparent_type transparentField; + + /// + public common_color_or_texture_type emission + { + get { return emissionField; } + set { emissionField = value; } + } + + /// + public common_color_or_texture_type ambient + { + get { return ambientField; } + set { ambientField = value; } + } + + /// + public common_color_or_texture_type diffuse + { + get { return diffuseField; } + set { diffuseField = value; } + } + + /// + public common_color_or_texture_type reflective + { + get { return reflectiveField; } + set { reflectiveField = value; } + } + + /// + public common_float_or_param_type reflectivity + { + get { return reflectivityField; } + set { reflectivityField = value; } + } + + /// + public common_transparent_type transparent + { + get { return transparentField; } + set { transparentField = value; } + } + + /// + public common_float_or_param_type transparency + { + get { return transparencyField; } + set { transparencyField = value; } + } + + /// + public common_float_or_param_type index_of_refraction + { + get { return index_of_refractionField; } + set { index_of_refractionField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class effectFx_profile_abstractProfile_COMMONTechniquePhong + { + private common_color_or_texture_type ambientField; + + private common_color_or_texture_type diffuseField; + private common_color_or_texture_type emissionField; + private common_float_or_param_type index_of_refractionField; + + private common_color_or_texture_type reflectiveField; + + private common_float_or_param_type reflectivityField; + private common_float_or_param_type shininessField; + private common_color_or_texture_type specularField; + + private common_float_or_param_type transparencyField; + private common_transparent_type transparentField; + + /// + public common_color_or_texture_type emission + { + get { return emissionField; } + set { emissionField = value; } + } + + /// + public common_color_or_texture_type ambient + { + get { return ambientField; } + set { ambientField = value; } + } + + /// + public common_color_or_texture_type diffuse + { + get { return diffuseField; } + set { diffuseField = value; } + } + + /// + public common_color_or_texture_type specular + { + get { return specularField; } + set { specularField = value; } + } + + /// + public common_float_or_param_type shininess + { + get { return shininessField; } + set { shininessField = value; } + } + + /// + public common_color_or_texture_type reflective + { + get { return reflectiveField; } + set { reflectiveField = value; } + } + + /// + public common_float_or_param_type reflectivity + { + get { return reflectivityField; } + set { reflectivityField = value; } + } + + /// + public common_transparent_type transparent + { + get { return transparentField; } + set { transparentField = value; } + } + + /// + public common_float_or_param_type transparency + { + get { return transparencyField; } + set { transparencyField = value; } + } + + /// + public common_float_or_param_type index_of_refraction + { + get { return index_of_refractionField; } + set { index_of_refractionField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_force_fields + { + private asset assetField; + + private extra[] extraField; + private force_field[] force_fieldField; + + private string idField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("force_field")] + public force_field[] force_field + { + get { return force_fieldField; } + set { force_fieldField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class force_field + { + private asset assetField; + + private extra[] extraField; + + private string idField; + + private string nameField; + private technique[] techniqueField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("technique")] + public technique[] technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_geometries + { + private asset assetField; + + private extra[] extraField; + private geometry[] geometryField; + + private string idField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("geometry")] + public geometry[] geometry + { + get { return geometryField; } + set { geometryField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class geometry + { + private asset assetField; + + private extra[] extraField; + + private string idField; + private object itemField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("convex_mesh", typeof (convex_mesh))] + [XmlElement("mesh", typeof (mesh))] + [XmlElement("spline", typeof (spline))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class convex_mesh + { + private string convex_hull_ofField; + private extra[] extraField; + private object[] itemsField; + private source[] sourceField; + + private vertices verticesField; + + /// + [XmlElement("source")] + public source[] source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + public vertices vertices + { + get { return verticesField; } + set { verticesField = value; } + } + + /// + [XmlElement("lines", typeof (lines))] + [XmlElement("linestrips", typeof (linestrips))] + [XmlElement("polygons", typeof (polygons))] + [XmlElement("polylist", typeof (polylist))] + [XmlElement("triangles", typeof (triangles))] + [XmlElement("trifans", typeof (trifans))] + [XmlElement("tristrips", typeof (tristrips))] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string convex_hull_of + { + get { return convex_hull_ofField; } + set { convex_hull_ofField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class vertices + { + private extra[] extraField; + + private string idField; + private InputLocal[] inputField; + + private string nameField; + + /// + [XmlElement("input")] + public InputLocal[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class lines + { + private ulong countField; + private extra[] extraField; + private InputLocalOffset[] inputField; + + private string materialField; + private string nameField; + private string pField; + + /// + [XmlElement("input")] + public InputLocalOffset[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + public string p + { + get { return pField; } + set { pField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string material + { + get { return materialField; } + set { materialField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class linestrips + { + private ulong countField; + private extra[] extraField; + private InputLocalOffset[] inputField; + + private string materialField; + private string nameField; + private string[] pField; + + /// + [XmlElement("input")] + public InputLocalOffset[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + [XmlElement("p")] + public string[] p + { + get { return pField; } + set { pField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string material + { + get { return materialField; } + set { materialField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class polygons + { + private ulong countField; + private extra[] extraField; + private InputLocalOffset[] inputField; + + private object[] itemsField; + + private string materialField; + private string nameField; + + /// + [XmlElement("input")] + public InputLocalOffset[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + [XmlElement("p", typeof (string))] + [XmlElement("ph", typeof (polygonsPH))] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string material + { + get { return materialField; } + set { materialField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class polygonsPH + { + private string[] hField; + private string pField; + + /// + public string p + { + get { return pField; } + set { pField = value; } + } + + /// + [XmlElement("h")] + public string[] h + { + get { return hField; } + set { hField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class polylist + { + private ulong countField; + private extra[] extraField; + private InputLocalOffset[] inputField; + + private string materialField; + private string nameField; + private string pField; + private string vcountField; + + /// + [XmlElement("input")] + public InputLocalOffset[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + public string vcount + { + get { return vcountField; } + set { vcountField = value; } + } + + /// + public string p + { + get { return pField; } + set { pField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string material + { + get { return materialField; } + set { materialField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class triangles + { + private ulong countField; + private extra[] extraField; + private InputLocalOffset[] inputField; + + private string materialField; + private string nameField; + private string pField; + + /// + [XmlElement("input")] + public InputLocalOffset[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + public string p + { + get { return pField; } + set { pField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string material + { + get { return materialField; } + set { materialField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class trifans + { + private ulong countField; + private extra[] extraField; + private InputLocalOffset[] inputField; + + private string materialField; + private string nameField; + private string[] pField; + + /// + [XmlElement("input")] + public InputLocalOffset[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + [XmlElement("p")] + public string[] p + { + get { return pField; } + set { pField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string material + { + get { return materialField; } + set { materialField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class tristrips + { + private ulong countField; + private extra[] extraField; + private InputLocalOffset[] inputField; + + private string materialField; + private string nameField; + private string[] pField; + + /// + [XmlElement("input")] + public InputLocalOffset[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + [XmlElement("p")] + public string[] p + { + get { return pField; } + set { pField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute] + public ulong count + { + get { return countField; } + set { countField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string material + { + get { return materialField; } + set { materialField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class mesh + { + private extra[] extraField; + private object[] itemsField; + private source[] sourceField; + + private vertices verticesField; + + /// + [XmlElement("source")] + public source[] source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + public vertices vertices + { + get { return verticesField; } + set { verticesField = value; } + } + + /// + [XmlElement("lines", typeof (lines))] + [XmlElement("linestrips", typeof (linestrips))] + [XmlElement("polygons", typeof (polygons))] + [XmlElement("polylist", typeof (polylist))] + [XmlElement("triangles", typeof (triangles))] + [XmlElement("trifans", typeof (trifans))] + [XmlElement("tristrips", typeof (tristrips))] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class spline + { + private bool closedField; + private splineControl_vertices control_verticesField; + + private extra[] extraField; + private source[] sourceField; + + public spline() + { + closedField = false; + } + + /// + [XmlElement("source")] + public source[] source + { + get { return sourceField; } + set { sourceField = value; } + } + + /// + public splineControl_vertices control_vertices + { + get { return control_verticesField; } + set { control_verticesField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute] + [DefaultValue(false)] + public bool closed + { + get { return closedField; } + set { closedField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class splineControl_vertices + { + private extra[] extraField; + private InputLocal[] inputField; + + /// + [XmlElement("input")] + public InputLocal[] input + { + get { return inputField; } + set { inputField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_images + { + private asset assetField; + + private extra[] extraField; + + private string idField; + private image[] imageField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("image")] + public image[] image + { + get { return imageField; } + set { imageField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_lights + { + private asset assetField; + + private extra[] extraField; + + private string idField; + private light[] lightField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("light")] + public light[] light + { + get { return lightField; } + set { lightField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class light + { + private asset assetField; + + private extra[] extraField; + + private string idField; + + private string nameField; + private technique[] techniqueField; + private lightTechnique_common technique_commonField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + public lightTechnique_common technique_common + { + get { return technique_commonField; } + set { technique_commonField = value; } + } + + /// + [XmlElement("technique")] + public technique[] technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class lightTechnique_common + { + private object itemField; + + /// + [XmlElement("ambient", typeof (lightTechnique_commonAmbient))] + [XmlElement("directional", typeof (lightTechnique_commonDirectional))] + [XmlElement("point", typeof (lightTechnique_commonPoint))] + [XmlElement("spot", typeof (lightTechnique_commonSpot))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class lightTechnique_commonAmbient + { + private TargetableFloat3 colorField; + + /// + public TargetableFloat3 color + { + get { return colorField; } + set { colorField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot("scale", Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class TargetableFloat3 + { + private string sidField; + + private double[] textField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public string _Text_ + { + get { return COLLADA.ConvertFromArray(Values); } + + set { Values = COLLADA.ConvertDoubleArray(value); } + } + + [XmlIgnore] + public double[] Values + { + get { return textField; } + set { textField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class lightTechnique_commonDirectional + { + private TargetableFloat3 colorField; + + /// + public TargetableFloat3 color + { + get { return colorField; } + set { colorField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class lightTechnique_commonPoint + { + private TargetableFloat3 colorField; + + private TargetableFloat constant_attenuationField; + + private TargetableFloat linear_attenuationField; + + private TargetableFloat quadratic_attenuationField; + + /// + public TargetableFloat3 color + { + get { return colorField; } + set { colorField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='1.0' attribute. + public TargetableFloat constant_attenuation + { + get { return constant_attenuationField; } + set { constant_attenuationField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0' attribute. + public TargetableFloat linear_attenuation + { + get { return linear_attenuationField; } + set { linear_attenuationField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0' attribute. + public TargetableFloat quadratic_attenuation + { + get { return quadratic_attenuationField; } + set { quadratic_attenuationField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class lightTechnique_commonSpot + { + private TargetableFloat3 colorField; + + private TargetableFloat constant_attenuationField; + + private TargetableFloat falloff_angleField; + + private TargetableFloat falloff_exponentField; + private TargetableFloat linear_attenuationField; + + private TargetableFloat quadratic_attenuationField; + + /// + public TargetableFloat3 color + { + get { return colorField; } + set { colorField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='1.0' attribute. + public TargetableFloat constant_attenuation + { + get { return constant_attenuationField; } + set { constant_attenuationField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0' attribute. + public TargetableFloat linear_attenuation + { + get { return linear_attenuationField; } + set { linear_attenuationField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0' attribute. + public TargetableFloat quadratic_attenuation + { + get { return quadratic_attenuationField; } + set { quadratic_attenuationField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='180.0' attribute. + public TargetableFloat falloff_angle + { + get { return falloff_angleField; } + set { falloff_angleField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0' attribute. + public TargetableFloat falloff_exponent + { + get { return falloff_exponentField; } + set { falloff_exponentField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_materials + { + private asset assetField; + + private extra[] extraField; + + private string idField; + private material[] materialField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("material")] + public material[] material + { + get { return materialField; } + set { materialField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class material + { + private asset assetField; + + private extra[] extraField; + + private string idField; + private instance_effect instance_effectField; + + private string nameField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + public instance_effect instance_effect + { + get { return instance_effectField; } + set { instance_effectField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class instance_effect + { + private extra[] extraField; + + private string nameField; + private instance_effectSetparam[] setparamField; + private string sidField; + private instance_effectTechnique_hint[] technique_hintField; + private string urlField; + + /// + [XmlElement("technique_hint")] + public instance_effectTechnique_hint[] technique_hint + { + get { return technique_hintField; } + set { technique_hintField = value; } + } + + /// + [XmlElement("setparam")] + public instance_effectSetparam[] setparam + { + get { return setparamField; } + set { setparamField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string url + { + get { return urlField; } + set { urlField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class instance_effectTechnique_hint + { + private string platformField; + + private string profileField; + + private string refField; + + /// + [XmlAttribute(DataType = "NCName")] + public string platform + { + get { return platformField; } + set { platformField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string profile + { + get { return profileField; } + set { profileField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string @ref + { + get { return refField; } + set { refField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class instance_effectSetparam + { + private string bool2Field; + + private string bool3Field; + + private string bool4Field; + private bool boolField; + private string enumField; + + private double float1x1Field; + + private string float1x2Field; + + private string float1x3Field; + + private string float1x4Field; + private string float2Field; + + private string float2x1Field; + + private string float2x2Field; + + private string float2x3Field; + + private string float2x4Field; + private string float3Field; + + private string float3x1Field; + + private string float3x2Field; + + private string float3x3Field; + + private string float3x4Field; + private string float4Field; + + private string float4x1Field; + + private string float4x2Field; + + private string float4x3Field; + + private string float4x4Field; + private double floatField; + private string int2Field; + + private string int3Field; + + private string int4Field; + private long intField; + private string refField; + + private fx_sampler1D_common sampler1DField; + + private fx_sampler2D_common sampler2DField; + + private fx_sampler3D_common sampler3DField; + + private fx_samplerCUBE_common samplerCUBEField; + + private fx_samplerDEPTH_common samplerDEPTHField; + private fx_samplerRECT_common samplerRECTField; + private fx_surface_common surfaceField; + + /// + public bool @bool + { + get { return boolField; } + set { boolField = value; } + } + + /// + public string bool2 + { + get { return bool2Field; } + set { bool2Field = value; } + } + + /// + public string bool3 + { + get { return bool3Field; } + set { bool3Field = value; } + } + + /// + public string bool4 + { + get { return bool4Field; } + set { bool4Field = value; } + } + + /// + public long @int + { + get { return intField; } + set { intField = value; } + } + + /// + public string int2 + { + get { return int2Field; } + set { int2Field = value; } + } + + /// + public string int3 + { + get { return int3Field; } + set { int3Field = value; } + } + + /// + public string int4 + { + get { return int4Field; } + set { int4Field = value; } + } + + /// + public double @float + { + get { return floatField; } + set { floatField = value; } + } + + /// + public string float2 + { + get { return float2Field; } + set { float2Field = value; } + } + + /// + public string float3 + { + get { return float3Field; } + set { float3Field = value; } + } + + /// + public string float4 + { + get { return float4Field; } + set { float4Field = value; } + } + + /// + public double float1x1 + { + get { return float1x1Field; } + set { float1x1Field = value; } + } + + /// + public string float1x2 + { + get { return float1x2Field; } + set { float1x2Field = value; } + } + + /// + public string float1x3 + { + get { return float1x3Field; } + set { float1x3Field = value; } + } + + /// + public string float1x4 + { + get { return float1x4Field; } + set { float1x4Field = value; } + } + + /// + public string float2x1 + { + get { return float2x1Field; } + set { float2x1Field = value; } + } + + /// + public string float2x2 + { + get { return float2x2Field; } + set { float2x2Field = value; } + } + + /// + public string float2x3 + { + get { return float2x3Field; } + set { float2x3Field = value; } + } + + /// + public string float2x4 + { + get { return float2x4Field; } + set { float2x4Field = value; } + } + + /// + public string float3x1 + { + get { return float3x1Field; } + set { float3x1Field = value; } + } + + /// + public string float3x2 + { + get { return float3x2Field; } + set { float3x2Field = value; } + } + + /// + public string float3x3 + { + get { return float3x3Field; } + set { float3x3Field = value; } + } + + /// + public string float3x4 + { + get { return float3x4Field; } + set { float3x4Field = value; } + } + + /// + public string float4x1 + { + get { return float4x1Field; } + set { float4x1Field = value; } + } + + /// + public string float4x2 + { + get { return float4x2Field; } + set { float4x2Field = value; } + } + + /// + public string float4x3 + { + get { return float4x3Field; } + set { float4x3Field = value; } + } + + /// + public string float4x4 + { + get { return float4x4Field; } + set { float4x4Field = value; } + } + + /// + public fx_surface_common surface + { + get { return surfaceField; } + set { surfaceField = value; } + } + + /// + public fx_sampler1D_common sampler1D + { + get { return sampler1DField; } + set { sampler1DField = value; } + } + + /// + public fx_sampler2D_common sampler2D + { + get { return sampler2DField; } + set { sampler2DField = value; } + } + + /// + public fx_sampler3D_common sampler3D + { + get { return sampler3DField; } + set { sampler3DField = value; } + } + + /// + public fx_samplerCUBE_common samplerCUBE + { + get { return samplerCUBEField; } + set { samplerCUBEField = value; } + } + + /// + public fx_samplerRECT_common samplerRECT + { + get { return samplerRECTField; } + set { samplerRECTField = value; } + } + + /// + public fx_samplerDEPTH_common samplerDEPTH + { + get { return samplerDEPTHField; } + set { samplerDEPTHField = value; } + } + + /// + public string @enum + { + get { return enumField; } + set { enumField = value; } + } + + /// + [XmlAttribute(DataType = "token")] + public string @ref + { + get { return refField; } + set { refField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_nodes + { + private asset assetField; + + private extra[] extraField; + + private string idField; + + private string nameField; + private node[] nodeField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("node")] + public node[] node + { + get { return nodeField; } + set { nodeField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class node + { + private asset assetField; + private extra[] extraField; + + private string idField; + + private InstanceWithExtra[] instance_cameraField; + + private instance_controller[] instance_controllerField; + + private instance_geometry[] instance_geometryField; + + private InstanceWithExtra[] instance_lightField; + + private InstanceWithExtra[] instance_nodeField; + private ItemsChoiceType2[] itemsElementNameField; + private object[] itemsField; + private string[] layerField; + + private string nameField; + private node[] node1Field; + + private string sidField; + + private NodeType typeField; + + public node() + { + typeField = NodeType.NODE; + } + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("lookat", typeof (lookat))] + [XmlElement("matrix", typeof (matrix))] + [XmlElement("rotate", typeof (rotate))] + [XmlElement("scale", typeof (TargetableFloat3))] + [XmlElement("skew", typeof (skew))] + [XmlElement("translate", typeof (TargetableFloat3))] + [XmlChoiceIdentifier("ItemsElementName")] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlElement("ItemsElementName")] + [XmlIgnore] + public ItemsChoiceType2[] ItemsElementName + { + get { return itemsElementNameField; } + set { itemsElementNameField = value; } + } + + /// + [XmlElement("instance_camera")] + public InstanceWithExtra[] instance_camera + { + get { return instance_cameraField; } + set { instance_cameraField = value; } + } + + /// + [XmlElement("instance_controller")] + public instance_controller[] instance_controller + { + get { return instance_controllerField; } + set { instance_controllerField = value; } + } + + /// + [XmlElement("instance_geometry")] + public instance_geometry[] instance_geometry + { + get { return instance_geometryField; } + set { instance_geometryField = value; } + } + + /// + [XmlElement("instance_light")] + public InstanceWithExtra[] instance_light + { + get { return instance_lightField; } + set { instance_lightField = value; } + } + + /// + [XmlElement("instance_node")] + public InstanceWithExtra[] instance_node + { + get { return instance_nodeField; } + set { instance_nodeField = value; } + } + + /// + [XmlElement("node")] + public node[] node1 + { + get { return node1Field; } + set { node1Field = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute] + [DefaultValue(NodeType.NODE)] + public NodeType type + { + get { return typeField; } + set { typeField = value; } + } + + /// + [XmlAttribute(DataType = "Name")] + public string[] layer + { + get { return layerField; } + set { layerField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class lookat + { + private string sidField; + + private double[] textField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public string _Text_ + { + get { return COLLADA.ConvertFromArray(Values); } + + set { Values = COLLADA.ConvertDoubleArray(value); } + } + + [XmlIgnore] + public double[] Values + { + get { return textField; } + set { textField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class matrix + { + private string sidField; + + private double[] textField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public string _Text_ + { + get { return COLLADA.ConvertFromArray(Values); } + + set { Values = COLLADA.ConvertDoubleArray(value); } + } + + [XmlIgnore] + public double[] Values + { + get { return textField; } + set { textField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class rotate + { + private string sidField; + + private double[] textField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public string _Text_ + { + get { return COLLADA.ConvertFromArray(Values); } + + set { Values = COLLADA.ConvertDoubleArray(value); } + } + + [XmlIgnore] + public double[] Values + { + get { return textField; } + set { textField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class skew + { + private string sidField; + + private double[] textField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public string _Text_ + { + get { return COLLADA.ConvertFromArray(Values); } + + set { Values = COLLADA.ConvertDoubleArray(value); } + } + + [XmlIgnore] + public double[] Values + { + get { return textField; } + set { textField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IncludeInSchema = false)] + public enum ItemsChoiceType2 + { + /// + lookat, + + /// + matrix, + + /// + rotate, + + /// + scale, + + /// + skew, + + /// + translate, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class instance_controller + { + private bind_material bind_materialField; + + private extra[] extraField; + + private string nameField; + private string sidField; + private string[] skeletonField; + private string urlField; + + /// + [XmlElement("skeleton", DataType = "anyURI")] + public string[] skeleton + { + get { return skeletonField; } + set { skeletonField = value; } + } + + /// + public bind_material bind_material + { + get { return bind_materialField; } + set { bind_materialField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string url + { + get { return urlField; } + set { urlField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class bind_material + { + private extra[] extraField; + private param[] paramField; + + private technique[] techniqueField; + private instance_material[] technique_commonField; + + /// + [XmlElement("param")] + public param[] param + { + get { return paramField; } + set { paramField = value; } + } + + /// + [XmlArrayItem("instance_material", IsNullable = false)] + public instance_material[] technique_common + { + get { return technique_commonField; } + set { technique_commonField = value; } + } + + /// + [XmlElement("technique")] + public technique[] technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class instance_geometry + { + private bind_material bind_materialField; + + private extra[] extraField; + + private string nameField; + private string sidField; + private string urlField; + + /// + public bind_material bind_material + { + get { return bind_materialField; } + set { bind_materialField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string url + { + get { return urlField; } + set { urlField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum NodeType + { + /// + JOINT, + + /// + NODE, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_physics_materials + { + private asset assetField; + + private extra[] extraField; + + private string idField; + + private string nameField; + private physics_material[] physics_materialField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("physics_material")] + public physics_material[] physics_material + { + get { return physics_materialField; } + set { physics_materialField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class physics_material + { + private asset assetField; + + private extra[] extraField; + + private string idField; + + private string nameField; + private technique[] techniqueField; + private physics_materialTechnique_common technique_commonField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + public physics_materialTechnique_common technique_common + { + get { return technique_commonField; } + set { technique_commonField = value; } + } + + /// + [XmlElement("technique")] + public technique[] technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class physics_materialTechnique_common + { + private TargetableFloat dynamic_frictionField; + + private TargetableFloat restitutionField; + + private TargetableFloat static_frictionField; + + /// + public TargetableFloat dynamic_friction + { + get { return dynamic_frictionField; } + set { dynamic_frictionField = value; } + } + + /// + public TargetableFloat restitution + { + get { return restitutionField; } + set { restitutionField = value; } + } + + /// + public TargetableFloat static_friction + { + get { return static_frictionField; } + set { static_frictionField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_physics_models + { + private asset assetField; + + private extra[] extraField; + + private string idField; + + private string nameField; + private physics_model[] physics_modelField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("physics_model")] + public physics_model[] physics_model + { + get { return physics_modelField; } + set { physics_modelField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class physics_model + { + private asset assetField; + + private extra[] extraField; + + private string idField; + private instance_physics_model[] instance_physics_modelField; + + private string nameField; + private rigid_body[] rigid_bodyField; + + private rigid_constraint[] rigid_constraintField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("rigid_body")] + public rigid_body[] rigid_body + { + get { return rigid_bodyField; } + set { rigid_bodyField = value; } + } + + /// + [XmlElement("rigid_constraint")] + public rigid_constraint[] rigid_constraint + { + get { return rigid_constraintField; } + set { rigid_constraintField = value; } + } + + /// + [XmlElement("instance_physics_model")] + public instance_physics_model[] instance_physics_model + { + get { return instance_physics_modelField; } + set { instance_physics_modelField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class rigid_body + { + private extra[] extraField; + + private string nameField; + private string sidField; + private technique[] techniqueField; + private rigid_bodyTechnique_common technique_commonField; + + /// + public rigid_bodyTechnique_common technique_common + { + get { return technique_commonField; } + set { technique_commonField = value; } + } + + /// + [XmlElement("technique")] + public technique[] technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_bodyTechnique_common + { + private rigid_bodyTechnique_commonDynamic dynamicField; + + private TargetableFloat3 inertiaField; + + private object itemField; + private TargetableFloat massField; + + private object[] mass_frameField; + + private rigid_bodyTechnique_commonShape[] shapeField; + + /// + public rigid_bodyTechnique_commonDynamic dynamic + { + get { return dynamicField; } + set { dynamicField = value; } + } + + /// + public TargetableFloat mass + { + get { return massField; } + set { massField = value; } + } + + /// + [XmlArrayItem("rotate", typeof (rotate), IsNullable = false)] + [XmlArrayItem("translate", typeof (TargetableFloat3), IsNullable = false)] + public object[] mass_frame + { + get { return mass_frameField; } + set { mass_frameField = value; } + } + + /// + public TargetableFloat3 inertia + { + get { return inertiaField; } + set { inertiaField = value; } + } + + /// + [XmlElement("instance_physics_material", typeof (InstanceWithExtra))] + [XmlElement("physics_material", typeof (physics_material))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + + /// + [XmlElement("shape")] + public rigid_bodyTechnique_commonShape[] shape + { + get { return shapeField; } + set { shapeField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_bodyTechnique_commonDynamic + { + private string sidField; + + private bool valueField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public bool Value + { + get { return valueField; } + set { valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_bodyTechnique_commonShape + { + private TargetableFloat densityField; + private extra[] extraField; + private rigid_bodyTechnique_commonShapeHollow hollowField; + + private object item1Field; + private object itemField; + + private object[] itemsField; + private TargetableFloat massField; + + /// + public rigid_bodyTechnique_commonShapeHollow hollow + { + get { return hollowField; } + set { hollowField = value; } + } + + /// + public TargetableFloat mass + { + get { return massField; } + set { massField = value; } + } + + /// + public TargetableFloat density + { + get { return densityField; } + set { densityField = value; } + } + + /// + [XmlElement("instance_physics_material", typeof (InstanceWithExtra))] + [XmlElement("physics_material", typeof (physics_material))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + + /// + [XmlElement("box", typeof (box))] + [XmlElement("capsule", typeof (capsule))] + [XmlElement("cylinder", typeof (cylinder))] + [XmlElement("instance_geometry", typeof (instance_geometry))] + [XmlElement("plane", typeof (plane))] + [XmlElement("sphere", typeof (sphere))] + [XmlElement("tapered_capsule", typeof (tapered_capsule))] + [XmlElement("tapered_cylinder", typeof (tapered_cylinder))] + public object Item1 + { + get { return item1Field; } + set { item1Field = value; } + } + + /// + [XmlElement("rotate", typeof (rotate))] + [XmlElement("translate", typeof (TargetableFloat3))] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_bodyTechnique_commonShapeHollow + { + private string sidField; + + private bool valueField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public bool Value + { + get { return valueField; } + set { valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class box + { + private extra[] extraField; + private string half_extentsField; + + /// + public string half_extents + { + get { return half_extentsField; } + set { half_extentsField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class capsule + { + private extra[] extraField; + private double heightField; + + private string radiusField; + + /// + public double height + { + get { return heightField; } + set { heightField = value; } + } + + /// + public string radius + { + get { return radiusField; } + set { radiusField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class cylinder + { + private extra[] extraField; + private double heightField; + + private string radiusField; + + /// + public double height + { + get { return heightField; } + set { heightField = value; } + } + + /// + public string radius + { + get { return radiusField; } + set { radiusField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class plane + { + private string equationField; + + private extra[] extraField; + + /// + public string equation + { + get { return equationField; } + set { equationField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class sphere + { + private extra[] extraField; + private double radiusField; + + /// + public double radius + { + get { return radiusField; } + set { radiusField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class tapered_capsule + { + private extra[] extraField; + private double heightField; + + private string radius1Field; + + private string radius2Field; + + /// + public double height + { + get { return heightField; } + set { heightField = value; } + } + + /// + public string radius1 + { + get { return radius1Field; } + set { radius1Field = value; } + } + + /// + public string radius2 + { + get { return radius2Field; } + set { radius2Field = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class tapered_cylinder + { + private extra[] extraField; + private double heightField; + + private string radius1Field; + + private string radius2Field; + + /// + public double height + { + get { return heightField; } + set { heightField = value; } + } + + /// + public string radius1 + { + get { return radius1Field; } + set { radius1Field = value; } + } + + /// + public string radius2 + { + get { return radius2Field; } + set { radius2Field = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class rigid_constraint + { + private rigid_constraintAttachment attachmentField; + + private extra[] extraField; + + private string nameField; + private rigid_constraintRef_attachment ref_attachmentField; + private string sidField; + private technique[] techniqueField; + private rigid_constraintTechnique_common technique_commonField; + + /// + public rigid_constraintRef_attachment ref_attachment + { + get { return ref_attachmentField; } + set { ref_attachmentField = value; } + } + + /// + public rigid_constraintAttachment attachment + { + get { return attachmentField; } + set { attachmentField = value; } + } + + /// + public rigid_constraintTechnique_common technique_common + { + get { return technique_commonField; } + set { technique_commonField = value; } + } + + /// + [XmlElement("technique")] + public technique[] technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_constraintRef_attachment + { + private object[] itemsField; + + private string rigid_bodyField; + + /// + [XmlElement("extra", typeof (extra))] + [XmlElement("rotate", typeof (rotate))] + [XmlElement("translate", typeof (TargetableFloat3))] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string rigid_body + { + get { return rigid_bodyField; } + set { rigid_bodyField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_constraintAttachment + { + private object[] itemsField; + + private string rigid_bodyField; + + /// + [XmlElement("extra", typeof (extra))] + [XmlElement("rotate", typeof (rotate))] + [XmlElement("translate", typeof (TargetableFloat3))] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string rigid_body + { + get { return rigid_bodyField; } + set { rigid_bodyField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_constraintTechnique_common + { + private rigid_constraintTechnique_commonEnabled enabledField; + + private rigid_constraintTechnique_commonInterpenetrate interpenetrateField; + + private rigid_constraintTechnique_commonLimits limitsField; + + private rigid_constraintTechnique_commonSpring springField; + + /// + // CODEGEN Warning: DefaultValue attribute on members of type rigid_constraintTechnique_commonEnabled is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='true' attribute. + public rigid_constraintTechnique_commonEnabled enabled + { + get { return enabledField; } + set { enabledField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type rigid_constraintTechnique_commonInterpenetrate is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='false' attribute. + public rigid_constraintTechnique_commonInterpenetrate interpenetrate + { + get { return interpenetrateField; } + set { interpenetrateField = value; } + } + + /// + public rigid_constraintTechnique_commonLimits limits + { + get { return limitsField; } + set { limitsField = value; } + } + + /// + public rigid_constraintTechnique_commonSpring spring + { + get { return springField; } + set { springField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_constraintTechnique_commonEnabled + { + private string sidField; + + private bool valueField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public bool Value + { + get { return valueField; } + set { valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_constraintTechnique_commonInterpenetrate + { + private string sidField; + + private bool valueField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public bool Value + { + get { return valueField; } + set { valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_constraintTechnique_commonLimits + { + private rigid_constraintTechnique_commonLimitsLinear linearField; + private rigid_constraintTechnique_commonLimitsSwing_cone_and_twist swing_cone_and_twistField; + + /// + public rigid_constraintTechnique_commonLimitsSwing_cone_and_twist swing_cone_and_twist + { + get { return swing_cone_and_twistField; } + set { swing_cone_and_twistField = value; } + } + + /// + public rigid_constraintTechnique_commonLimitsLinear linear + { + get { return linearField; } + set { linearField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_constraintTechnique_commonLimitsSwing_cone_and_twist + { + private TargetableFloat3 maxField; + private TargetableFloat3 minField; + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat3 is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0 0.0 0.0' attribute. + public TargetableFloat3 min + { + get { return minField; } + set { minField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat3 is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0 0.0 0.0' attribute. + public TargetableFloat3 max + { + get { return maxField; } + set { maxField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_constraintTechnique_commonLimitsLinear + { + private TargetableFloat3 maxField; + private TargetableFloat3 minField; + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat3 is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0 0.0 0.0' attribute. + public TargetableFloat3 min + { + get { return minField; } + set { minField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat3 is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0 0.0 0.0' attribute. + public TargetableFloat3 max + { + get { return maxField; } + set { maxField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_constraintTechnique_commonSpring + { + private rigid_constraintTechnique_commonSpringAngular angularField; + + private rigid_constraintTechnique_commonSpringLinear linearField; + + /// + public rigid_constraintTechnique_commonSpringAngular angular + { + get { return angularField; } + set { angularField = value; } + } + + /// + public rigid_constraintTechnique_commonSpringLinear linear + { + get { return linearField; } + set { linearField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_constraintTechnique_commonSpringAngular + { + private TargetableFloat dampingField; + private TargetableFloat stiffnessField; + + private TargetableFloat target_valueField; + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='1.0' attribute. + public TargetableFloat stiffness + { + get { return stiffnessField; } + set { stiffnessField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0' attribute. + public TargetableFloat damping + { + get { return dampingField; } + set { dampingField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0' attribute. + public TargetableFloat target_value + { + get { return target_valueField; } + set { target_valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class rigid_constraintTechnique_commonSpringLinear + { + private TargetableFloat dampingField; + private TargetableFloat stiffnessField; + + private TargetableFloat target_valueField; + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='1.0' attribute. + public TargetableFloat stiffness + { + get { return stiffnessField; } + set { stiffnessField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0' attribute. + public TargetableFloat damping + { + get { return dampingField; } + set { dampingField = value; } + } + + /// + // CODEGEN Warning: DefaultValue attribute on members of type TargetableFloat is not supported in this version of the .Net Framework. + // CODEGEN Warning: 'default' attribute supported only for primitive types. Ignoring default='0.0' attribute. + public TargetableFloat target_value + { + get { return target_valueField; } + set { target_valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class instance_physics_model + { + private extra[] extraField; + private InstanceWithExtra[] instance_force_fieldField; + + private instance_rigid_body[] instance_rigid_bodyField; + + private instance_rigid_constraint[] instance_rigid_constraintField; + + private string nameField; + + private string parentField; + private string sidField; + private string urlField; + + /// + [XmlElement("instance_force_field")] + public InstanceWithExtra[] instance_force_field + { + get { return instance_force_fieldField; } + set { instance_force_fieldField = value; } + } + + /// + [XmlElement("instance_rigid_body")] + public instance_rigid_body[] instance_rigid_body + { + get { return instance_rigid_bodyField; } + set { instance_rigid_bodyField = value; } + } + + /// + [XmlElement("instance_rigid_constraint")] + public instance_rigid_constraint[] instance_rigid_constraint + { + get { return instance_rigid_constraintField; } + set { instance_rigid_constraintField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string url + { + get { return urlField; } + set { urlField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string parent + { + get { return parentField; } + set { parentField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class instance_rigid_body + { + private string bodyField; + private extra[] extraField; + + private string nameField; + private string sidField; + + private string targetField; + private technique[] techniqueField; + private instance_rigid_bodyTechnique_common technique_commonField; + + /// + public instance_rigid_bodyTechnique_common technique_common + { + get { return technique_commonField; } + set { technique_commonField = value; } + } + + /// + [XmlElement("technique")] + public technique[] technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string body + { + get { return bodyField; } + set { bodyField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string target + { + get { return targetField; } + set { targetField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class instance_rigid_bodyTechnique_common + { + private string angular_velocityField; + + private instance_rigid_bodyTechnique_commonDynamic dynamicField; + + private TargetableFloat3 inertiaField; + + private object itemField; + private TargetableFloat massField; + + private object[] mass_frameField; + + private instance_rigid_bodyTechnique_commonShape[] shapeField; + private string velocityField; + + public instance_rigid_bodyTechnique_common() + { + angular_velocityField = "0.0 0.0 0.0"; + velocityField = "0.0 0.0 0.0"; + } + + /// + [DefaultValue("0.0 0.0 0.0")] + public string angular_velocity + { + get { return angular_velocityField; } + set { angular_velocityField = value; } + } + + /// + [DefaultValue("0.0 0.0 0.0")] + public string velocity + { + get { return velocityField; } + set { velocityField = value; } + } + + /// + public instance_rigid_bodyTechnique_commonDynamic dynamic + { + get { return dynamicField; } + set { dynamicField = value; } + } + + /// + public TargetableFloat mass + { + get { return massField; } + set { massField = value; } + } + + /// + [XmlArrayItem("rotate", typeof (rotate), IsNullable = false)] + [XmlArrayItem("translate", typeof (TargetableFloat3), IsNullable = false)] + public object[] mass_frame + { + get { return mass_frameField; } + set { mass_frameField = value; } + } + + /// + public TargetableFloat3 inertia + { + get { return inertiaField; } + set { inertiaField = value; } + } + + /// + [XmlElement("instance_physics_material", typeof (InstanceWithExtra))] + [XmlElement("physics_material", typeof (physics_material))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + + /// + [XmlElement("shape")] + public instance_rigid_bodyTechnique_commonShape[] shape + { + get { return shapeField; } + set { shapeField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class instance_rigid_bodyTechnique_commonDynamic + { + private string sidField; + + private bool valueField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public bool Value + { + get { return valueField; } + set { valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class instance_rigid_bodyTechnique_commonShape + { + private TargetableFloat densityField; + private extra[] extraField; + private instance_rigid_bodyTechnique_commonShapeHollow hollowField; + + private object item1Field; + private object itemField; + + private object[] itemsField; + private TargetableFloat massField; + + /// + public instance_rigid_bodyTechnique_commonShapeHollow hollow + { + get { return hollowField; } + set { hollowField = value; } + } + + /// + public TargetableFloat mass + { + get { return massField; } + set { massField = value; } + } + + /// + public TargetableFloat density + { + get { return densityField; } + set { densityField = value; } + } + + /// + [XmlElement("instance_physics_material", typeof (InstanceWithExtra))] + [XmlElement("physics_material", typeof (physics_material))] + public object Item + { + get { return itemField; } + set { itemField = value; } + } + + /// + [XmlElement("box", typeof (box))] + [XmlElement("capsule", typeof (capsule))] + [XmlElement("cylinder", typeof (cylinder))] + [XmlElement("instance_geometry", typeof (instance_geometry))] + [XmlElement("plane", typeof (plane))] + [XmlElement("sphere", typeof (sphere))] + [XmlElement("tapered_capsule", typeof (tapered_capsule))] + [XmlElement("tapered_cylinder", typeof (tapered_cylinder))] + public object Item1 + { + get { return item1Field; } + set { item1Field = value; } + } + + /// + [XmlElement("rotate", typeof (rotate))] + [XmlElement("translate", typeof (TargetableFloat3))] + public object[] Items + { + get { return itemsField; } + set { itemsField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class instance_rigid_bodyTechnique_commonShapeHollow + { + private string sidField; + + private bool valueField; + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlText] + public bool Value + { + get { return valueField; } + set { valueField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class instance_rigid_constraint + { + private string constraintField; + private extra[] extraField; + + private string nameField; + private string sidField; + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string constraint + { + get { return constraintField; } + set { constraintField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string sid + { + get { return sidField; } + set { sidField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_physics_scenes + { + private asset assetField; + + private extra[] extraField; + + private string idField; + + private string nameField; + private physics_scene[] physics_sceneField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("physics_scene")] + public physics_scene[] physics_scene + { + get { return physics_sceneField; } + set { physics_sceneField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class physics_scene + { + private asset assetField; + + private extra[] extraField; + + private string idField; + private InstanceWithExtra[] instance_force_fieldField; + + private instance_physics_model[] instance_physics_modelField; + + private string nameField; + private technique[] techniqueField; + private physics_sceneTechnique_common technique_commonField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("instance_force_field")] + public InstanceWithExtra[] instance_force_field + { + get { return instance_force_fieldField; } + set { instance_force_fieldField = value; } + } + + /// + [XmlElement("instance_physics_model")] + public instance_physics_model[] instance_physics_model + { + get { return instance_physics_modelField; } + set { instance_physics_modelField = value; } + } + + /// + public physics_sceneTechnique_common technique_common + { + get { return technique_commonField; } + set { technique_commonField = value; } + } + + /// + [XmlElement("technique")] + public technique[] technique + { + get { return techniqueField; } + set { techniqueField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class physics_sceneTechnique_common + { + private TargetableFloat3 gravityField; + + private TargetableFloat time_stepField; + + /// + public TargetableFloat3 gravity + { + get { return gravityField; } + set { gravityField = value; } + } + + /// + public TargetableFloat time_step + { + get { return time_stepField; } + set { time_stepField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class library_visual_scenes + { + private asset assetField; + + private extra[] extraField; + + private string idField; + + private string nameField; + private visual_scene[] visual_sceneField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("visual_scene")] + public visual_scene[] visual_scene + { + get { return visual_sceneField; } + set { visual_sceneField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class visual_scene + { + private asset assetField; + + private visual_sceneEvaluate_scene[] evaluate_sceneField; + + private extra[] extraField; + + private string idField; + + private string nameField; + private node[] nodeField; + + /// + public asset asset + { + get { return assetField; } + set { assetField = value; } + } + + /// + [XmlElement("node")] + public node[] node + { + get { return nodeField; } + set { nodeField = value; } + } + + /// + [XmlElement("evaluate_scene")] + public visual_sceneEvaluate_scene[] evaluate_scene + { + get { return evaluate_sceneField; } + set { evaluate_sceneField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + + /// + [XmlAttribute(DataType = "ID")] + public string id + { + get { return idField; } + set { idField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class visual_sceneEvaluate_scene + { + private string nameField; + private visual_sceneEvaluate_sceneRender[] renderField; + + /// + [XmlElement("render")] + public visual_sceneEvaluate_sceneRender[] render + { + get { return renderField; } + set { renderField = value; } + } + + /// + [XmlAttribute(DataType = "NCName")] + public string name + { + get { return nameField; } + set { nameField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class visual_sceneEvaluate_sceneRender + { + private string camera_nodeField; + private instance_effect instance_effectField; + private string[] layerField; + + /// + [XmlElement("layer", DataType = "NCName")] + public string[] layer + { + get { return layerField; } + set { layerField = value; } + } + + /// + public instance_effect instance_effect + { + get { return instance_effectField; } + set { instance_effectField = value; } + } + + /// + [XmlAttribute(DataType = "anyURI")] + public string camera_node + { + get { return camera_nodeField; } + set { camera_nodeField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public class COLLADAScene + { + private extra[] extraField; + private InstanceWithExtra[] instance_physics_sceneField; + + private InstanceWithExtra instance_visual_sceneField; + + /// + [XmlElement("instance_physics_scene")] + public InstanceWithExtra[] instance_physics_scene + { + get { return instance_physics_sceneField; } + set { instance_physics_sceneField = value; } + } + + /// + public InstanceWithExtra instance_visual_scene + { + get { return instance_visual_sceneField; } + set { instance_visual_sceneField = value; } + } + + /// + [XmlElement("extra")] + public extra[] extra + { + get { return extraField; } + set { extraField = value; } + } + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [XmlType(Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + public enum VersionType + { + /// + [XmlEnum("1.4.0")] Item140, + + /// + [XmlEnum("1.4.1")] Item141, + } + + /// + [GeneratedCode("xsd", "4.0.30319.1")] + [Serializable] + [DebuggerStepThrough] + [DesignerCategory("code")] + [XmlType(AnonymousType = true, Namespace = "http://www.collada.org/2005/11/COLLADASchema")] + [XmlRoot(Namespace = "http://www.collada.org/2005/11/COLLADASchema", IsNullable = false)] + public class ellipsoid + { + private string sizeField; + + /// + public string size + { + get { return sizeField; } + set { sizeField = value; } + } + } + + + /// + /// Extend COLLADA class to provide convertion helpers + /// + public partial class COLLADA + { + private static Regex regex = new Regex(@"\s+"); + + public static string ConvertFromArray(IList array) + { + if (array == null) + return null; + + StringBuilder text = new StringBuilder(); + if (typeof (T) == typeof (double)) + { + // If type is double, then use a plain ToString with no exponent + for (int i = 0; i < array.Count; i++) + { + object value1 = array[i]; + double value = (double) value1; + text.Append( + value.ToString( + "0.000000", + NumberFormatInfo.InvariantInfo)); + if ((i + 1) < array.Count) + text.Append(" "); + } + } + else + { + for (int i = 0; i < array.Count; i++) + { + text.Append(Convert.ToString(array[i], NumberFormatInfo.InvariantInfo)); + if ((i + 1) < array.Count) + text.Append(" "); + } + } + return text.ToString(); + } + + internal static string[] ConvertStringArray(string arrayStr) + { + string[] elements = regex.Split(arrayStr.Trim()); + string[] ret = new string[elements.Length]; + for (int i = 0; i < ret.Length; i++) + ret[i] = elements[i]; + return ret; + } + + internal static int[] ConvertIntArray(string arrayStr) + { + string[] elements = regex.Split(arrayStr.Trim()); + int[] ret = new int[elements.Length]; + for (int i = 0; i < ret.Length; i++) + ret[i] = int.Parse(elements[i]); + return ret; + } + + internal static double[] ConvertDoubleArray(string arrayStr) + { + string[] elements = regex.Split(arrayStr.Trim()); + double[] ret = new double[elements.Length]; + try + { + for (int i = 0; i < ret.Length; i++) + ret[i] = double.Parse(elements[i], NumberStyles.Float, CultureInfo.InvariantCulture); + } + catch (Exception ex) + { + Console.WriteLine(ex); + } + return ret; + } + + internal static bool[] ConvertBoolArray(string arrayStr) + { + string[] elements = regex.Split(arrayStr.Trim()); + bool[] ret = new bool[elements.Length]; + for (int i = 0; i < ret.Length; i++) + ret[i] = bool.Parse(elements[i]); + return ret; + } + + + public static COLLADA Load(string fileName) + { + FileStream stream = new FileStream(fileName, FileMode.Open); + COLLADA result; + try + { + result = Load(stream); + } + finally + { + stream.Close(); + } + return result; + } + + public static COLLADA Load(Stream stream) + { + StreamReader str = new StreamReader(stream); + XmlSerializer xSerializer = new XmlSerializer(typeof(COLLADA)); + + return (COLLADA)xSerializer.Deserialize(str); + } + + public void Save(string fileName) + { + FileStream stream = new FileStream(fileName, FileMode.Create); + try + { + Save(stream); + } + finally + { + stream.Close(); + } + } + + public void Save(Stream stream) + { + XmlTextWriter writer = new XmlTextWriter(stream, Encoding.UTF8); + XmlSerializer xSerializer = new XmlSerializer(typeof(COLLADA)); + writer.Formatting = Formatting.Indented; + xSerializer.Serialize(writer, this); + } + } +} \ No newline at end of file diff --git a/NW4RTools/bin/Debug/NW4RTools.dll b/NW4RTools/bin/Debug/NW4RTools.dll index b0fe3d4..5d89012 100755 Binary files a/NW4RTools/bin/Debug/NW4RTools.dll and b/NW4RTools/bin/Debug/NW4RTools.dll differ diff --git a/NW4RTools/bin/Debug/NW4RTools.dll.mdb b/NW4RTools/bin/Debug/NW4RTools.dll.mdb index 9b65235..662ff6c 100644 Binary files a/NW4RTools/bin/Debug/NW4RTools.dll.mdb and b/NW4RTools/bin/Debug/NW4RTools.dll.mdb differ -- cgit v1.2.3