1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 from xml.dom.minidom import *
26 from datetime import *
27
28
29 ROUND = 5
30
31
32
33 angleToRadian = 3.1415926 / 180.0
34 radianToAngle = 180.0 / 3.1415926
35
36
38 if val is None or val == '':
39 return None
40 else:
41 return float(val)
42
43
45 if val is None or val == '':
46 return None
47 else:
48 return int(val)
49
50
52 if stringValue is None:
53 return None
54 split = stringValue.split( )
55 return [ float( split[ 0 ] ), float( split[ 1 ] ), float( split[ 2 ] ) ]
56
57
59 if stringValue is None:
60 return None
61 split = stringValue.split( )
62 try:
63 return [ float( split[ 0 ] ), float( split[ 1 ] )]
64 except IndexError:
65 print 'Error: ' + errorText
66 raise
67
69 result = []
70 if var is None:
71 return result
72
73 split = var.split( )
74 for i in split:
75 result.append(i)
76 return result
77
78
80 result = []
81 if var is None:
82 return result
83
84 if type(var) == list:
85 for i in var:
86 result.append(float(i))
87 else:
88 split = var.split( )
89 for i in split:
90 result.append(float(i))
91 return result
92
94 result = []
95 if lst is None:
96 return result
97 if type(lst) == list:
98 for i in lst:
99 result.append(int(i))
100 else:
101 split = lst.split( )
102 for i in split:
103 result.append(int(i))
104 return result
105
107 result = []
108 if lst is None:
109 return result
110 for i in lst:
111 result.append(bool(i))
112 return result
113
114
116 split = stringValue.split( )
117 return [ float( split[ 0 ] ), float( split[ 1 ] ), float( split[ 2 ] ) , float( split[3])]
118
120 data = stringValue.split( )
121 return [ float(data[0]), float(data[1]), float(data[2]), float(data[3]), float(data[4]), float(data[5]), float(data[6])]
122
124 vector1.x += vector2.x
125 vector1.y += vector2.y
126 vector1.z += vector2.z
127
129 data = matrixElement.split( )
130
131 vec1 = [ float(data[0]), float(data[4]), float(data[8]), float(data[12]) ]
132 vec2 = [ float(data[1]), float(data[5]), float(data[9]), float(data[13]) ]
133 vec3 = [ float(data[2]), float(data[6]), float(data[10]), float(data[14]) ]
134 vec4 = [ float(data[3]), float(data[7]), float(data[11]), float(data[15]) ]
135
136 return [ vec1, vec2, vec3, vec4 ]
137
139 data = matrixElement.split( )
140
141 vec1 = [ float(data[0]), float(data[3]), float(data[6]) ]
142 vec2 = [ float(data[1]), float(data[4]), float(data[7])]
143 vec3 = [ float(data[2]), float(data[5]), float(data[8])]
144
145 return [ vec1, vec2, vec3 ]
146
148 value = [ float( element[ 0 ] ), float( element[ 1 ] ), float( element[ 2 ] ) ]
149 return value
150
152 euler = [ float( rotateElement[ 0 ] ) * float( rotateElement[ 3 ] ) * angleToRadian,
153 float( rotateElement[ 1 ] ) * float( rotateElement[ 3 ] ) * angleToRadian,
154 float( rotateElement[ 2 ] ) * float( rotateElement[ 3 ] ) * angleToRadian ]
155 return euler
156
158 euler1.x += euler2.x
159 euler1.y += euler2.y
160 euler1.z += euler2.z
161
163 result = ''
164 if mat is None:
165 return result
166
167 for vec in mat:
168 result += '\n\t'
169 for i in vec:
170 result += str(round(i, nDigits))+' '
171
172 return result+'\n'
173
175 result = []
176 for i in lst:
177 result.append(round(i, nDigits))
178 return result
179
180
182 val = ''
183 if lst is None:
184 return val
185 else:
186 for i in lst:
187 if type(i) == list:
188 val += ListToString(i)+'\n'
189 else:
190 val += str(i)+' '
191 return val[:-1]
192
193
194
195
197 child = parentNode.firstChild
198 while child != None:
199 if child.localName == type:
200 return child
201 child = child.nextSibling
202
203
204
205 return None
206
208 result = []
209 child = parentNode.firstChild
210 while child != None:
211 if child.localName == type:
212 result.append(child)
213 child = child.nextSibling
214 return result
215
217 if node != None and attributeName != None:
218 attribute = node.getAttribute(attributeName)
219 return attribute
220 return None
221
222 -def ReadContents(node):
223 if node != None:
224 child = node.firstChild
225 if child != None and child.nodeType == child.TEXT_NODE:
226 return child.nodeValue
227 return None
228
233
235 for child in list(parent.childNodes):
236 if child.nodeType==child.TEXT_NODE and child.data.strip()=='':
237 parent.removeChild(child)
238 else:
239 RemoveWhiteSpace(child)
240
242 for child in list(parent.childNodes):
243 if child.nodeType == child.TEXT_NODE and child.data.strip()=='':
244 parent.removeChild(child)
245 return parent
246
247
248
249
250
251
252
253
254
255
256
257
260
261
262
263
264
265
266
267
270
271
273 vals = []
274 if xmlNodes == None:
275 return vals
276 for xmlNode in xmlNodes:
277 stringvals = ReadContents(xmlNode).split( )
278 for string in stringvals:
279 vals.append(string)
280 return vals
281
283 result = []
284 if xmlNodes is None:
285 return result
286
287 for xmlNode in xmlNodes:
288 val = ReadContents(xmlNode).split( )
289 if cast == float:
290 val = ToFloatList(val)
291 elif cast == int:
292 val = ToIntList(val)
293 elif cast == bool:
294 val = ToBoolList(val)
295 result.append(val)
296 return result
297
298
299 -def ToXml(xmlNode, indent='\t', newl='\n'):
300 return '<?xml version="1.0" encoding="utf-8"?>\n%s'%(__ToXml(xmlNode, indent,newl))
301
302 -def __ToXml(xmlNode, indent='\t',newl='\n',totalIndent=''):
303 childs = xmlNode.childNodes
304 if len(childs) > 0:
305 attrs = ''
306 attributes = xmlNode.attributes
307 if attributes != None:
308 for attr in attributes.keys():
309 val = attributes[attr].nodeValue
310 attrs += ' %s="%s"'%(attr,val)
311 result = '%s<%s%s>'%(totalIndent,xmlNode.localName,attrs)
312 tempnewl = newl
313 tempTotIndent = totalIndent
314 for child in childs:
315 if child.nodeType == child.TEXT_NODE:
316 tempnewl = ''
317 tempTotIndent = ''
318
319 result += '%s%s'%(tempnewl,__ToXml(child, indent, newl, totalIndent+indent))
320 result += '%s%s</%s>'%(tempnewl,tempTotIndent,xmlNode.localName)
321 return result
322 else:
323 if xmlNode.nodeType == xmlNode.TEXT_NODE:
324 return xmlNode.toxml().replace('\n','\n'+totalIndent[:-1])
325 else:
326 return totalIndent+xmlNode.toxml()
327
329 if lst is None or syntax is None or xmlNode is None:
330 return
331
332 for i in lst:
333 el = Element(syntax)
334 text = Text()
335 text.data = ListToString(i)
336 el.appendChild(text)
337 xmlNode.appendChild(el)
338
339 return xmlNode
340
341
343
345 global debugMode
346 debugMode = debugM
347
348 self.colladaVersion = '1.4.0'
349 self.version = ''
350 self.xmlns = ''
351 self.asset = DaeAsset()
352 self.extras = []
353
354
355
356 self.animationsLibrary = DaeLibrary(DaeSyntax.LIBRARY_ANIMATIONS,DaeAnimation,DaeSyntax.ANIMATION)
357 self.animationClipsLibrary = DaeLibrary(DaeSyntax.LIBRARY_ANIMATION_CLIPS,DaeAnimationClip,DaeSyntax.ANIMATION_CLIP)
358 self.camerasLibrary = DaeLibrary(DaeSyntax.LIBRARY_CAMERAS,DaeCamera,DaeSyntax.CAMERA)
359 self.controllersLibrary = DaeLibrary(DaeSyntax.LIBRARY_CONTROLLERS,DaeController,DaeSyntax.CONTROLLER)
360 self.effectsLibrary = DaeLibrary(DaeSyntax.LIBRARY_EFFECTS,DaeFxEffect,DaeFxSyntax.EFFECT)
361 self.geometriesLibrary = DaeLibrary(DaeSyntax.LIBRARY_GEOMETRIES,DaeGeometry,DaeSyntax.GEOMETRY)
362 self.imagesLibrary = DaeLibrary(DaeSyntax.LIBRARY_IMAGES, DaeImage, DaeSyntax.IMAGE)
363 self.lightsLibrary = DaeLibrary(DaeSyntax.LIBRARY_LIGHTS,DaeLight,DaeSyntax.LIGHT)
364 self.materialsLibrary = DaeLibrary(DaeSyntax.LIBRARY_MATERIALS,DaeFxMaterial,DaeFxSyntax.MATERIAL)
365 self.nodesLibrary = DaeLibrary(DaeSyntax.LIBRARY_NODES, DaeNode, DaeSyntax.NODE)
366 self.visualScenesLibrary = DaeLibrary(DaeSyntax.LIBRARY_VISUAL_SCENES,DaeVisualScene,DaeSyntax.VISUAL_SCENE)
367
368
369 self.physicsMaterialsLibrary = DaeLibrary(DaeSyntax.LIBRARY_PHYSICS_MATERIALS, DaePhysicsMaterial, DaePhysicsSyntax.PHYSICS_MATERIAL)
370 self.physicsScenesLibrary = DaeLibrary(DaeSyntax.LIBRARY_PHYSICS_SCENES, DaePhysicsScene, DaePhysicsSyntax.PHYSICS_SCENE)
371
372 self.physicsModelsLibrary = DaeLibrary(DaeSyntax.LIBRARY_PHYSICS_MODELS, DaePhysicsModel, DaePhysicsSyntax.PHYSICS_MODEL)
373
374 self.scene = None
375 self.physicsScene = None
376
378 global debugMode
379
380 doc = parse( filename )
381
382
383 colladaNode = doc.documentElement
384
385
386 self.version = colladaNode.getAttribute(DaeSyntax.VERSION)
387
388
389
390
391 self.xmlns = colladaNode.getAttribute(DaeSyntax.XMLNS)
392
393
394 self.asset.LoadFromXml(self,FindElementByTagName(colladaNode,DaeSyntax.ASSET))
395
396
397 self.extras = CreateObjectsFromXml(self,colladaNode,DaeSyntax.EXTRA,DaeExtra)
398
399
400 self.imagesLibrary.LoadFromXml(self,FindElementByTagName(colladaNode,DaeSyntax.LIBRARY_IMAGES))
401 self.animationsLibrary.LoadFromXml(self, FindElementByTagName(colladaNode,DaeSyntax.LIBRARY_ANIMATIONS))
402 self.animationClipsLibrary.LoadFromXml(self,FindElementByTagName(colladaNode,DaeSyntax.LIBRARY_ANIMATION_CLIPS))
403 self.camerasLibrary.LoadFromXml(self,FindElementByTagName(colladaNode,DaeSyntax.LIBRARY_CAMERAS))
404 self.controllersLibrary.LoadFromXml(self,FindElementByTagName(colladaNode,DaeSyntax.LIBRARY_CONTROLLERS))
405 self.effectsLibrary.LoadFromXml(self,FindElementByTagName(colladaNode,DaeSyntax.LIBRARY_EFFECTS))
406 self.geometriesLibrary.LoadFromXml(self,FindElementByTagName(colladaNode,DaeSyntax.LIBRARY_GEOMETRIES))
407 self.lightsLibrary.LoadFromXml(self, FindElementByTagName(colladaNode, DaeSyntax.LIBRARY_LIGHTS))
408 self.materialsLibrary.LoadFromXml(self,FindElementByTagName(colladaNode,DaeSyntax.LIBRARY_MATERIALS))
409 self.nodesLibrary.LoadFromXml(self,FindElementByTagName(colladaNode,DaeSyntax.LIBRARY_NODES))
410 self.visualScenesLibrary.LoadFromXml(self, FindElementByTagName(colladaNode, DaeSyntax.LIBRARY_VISUAL_SCENES))
411
412 self.physicsMaterialsLibrary.LoadFromXml(self, FindElementByTagName(colladaNode, DaeSyntax.LIBRARY_PHYSICS_MATERIALS))
413 self.physicsModelsLibrary.LoadFromXml(self, FindElementByTagName(colladaNode, DaeSyntax.LIBRARY_PHYSICS_MODELS))
414 self.physicsScenesLibrary.LoadFromXml(self, FindElementByTagName(colladaNode, DaeSyntax.LIBRARY_PHYSICS_SCENES))
415
416
417 sceneNodes = colladaNode.getElementsByTagName(DaeSyntax.SCENE)
418
419
420 sceneNode = FindElementByTagName(colladaNode, DaeSyntax.SCENE)
421 if sceneNode != None:
422 scene = DaeScene()
423 scene.LoadFromXml(self, sceneNode)
424 self.scene = scene
425
426 doc.unlink()
427
428 if debugMode:
429 Debug.Debug('Directly exporting this DaeDocument...','DEBUG')
430 self.SaveDocumentToFile(filename+'_out.dae')
431
433 self.version = '1.4.0'
434 self.xmlns = 'http://www.collada.org/2005/11/COLLADASchema'
435 colladaNode = Element(DaeSyntax.COLLADA)
436 colladaNode.setAttribute(DaeSyntax.VERSION, self.version)
437 colladaNode.setAttribute(DaeSyntax.XMLNS, self.xmlns)
438
439 colladaNode.appendChild(self.asset.SaveToXml(self))
440
441
442 AppendChild(self,colladaNode,self.animationsLibrary)
443 AppendChild(self,colladaNode,self.animationClipsLibrary)
444 AppendChild(self,colladaNode,self.camerasLibrary)
445 AppendChild(self,colladaNode,self.controllersLibrary)
446 AppendChild(self,colladaNode,self.effectsLibrary)
447 AppendChild(self,colladaNode,self.geometriesLibrary)
448 AppendChild(self,colladaNode,self.imagesLibrary)
449 AppendChild(self,colladaNode,self.lightsLibrary)
450 AppendChild(self,colladaNode,self.materialsLibrary)
451 AppendChild(self,colladaNode,self.nodesLibrary)
452 AppendChild(self,colladaNode,self.visualScenesLibrary)
453 AppendChild(self,colladaNode,self.physicsMaterialsLibrary)
454 AppendChild(self,colladaNode,self.physicsModelsLibrary)
455 AppendChild(self,colladaNode,self.physicsScenesLibrary)
456
457 AppendChild(self,colladaNode,self.scene)
458
459
460 fileref = open(filename, 'w')
461 fileref.write(ToXml(colladaNode))
462 fileref.flush()
463 fileref.close()
464 colladaNode.unlink()
465
478
480 return '%s version: %s, xmlns: %s, asset: %s, extras: %s, scene: %s'%(type(self), self.version, self.xmlns, self.asset, self.extras, self.scene)
481
484 self.syntax = 'UNKNOWN'
485
487 Debug.Debug('DaeEntity: Override this method for %s'%(type(self)),'WARNING')
488
490 node = Element(self.syntax)
491 return node
492
495
520
521
523 - def __init__(self, syntax, objectType, objectSyntax):
524 super(DaeLibrary,self).__init__()
525
526 self.extras = []
527 self.asset = None
528 self.items = []
529
530 self.__objectSyntax = objectSyntax
531
532 self.syntax = syntax
533 self.__objectType = objectType
534
536 if xmlNode is None:
537 return
538 super(DaeLibrary,self).LoadFromXml(daeDocument, xmlNode)
539
540 self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra)
541 self.asset = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.ASSET, DaeAsset)
542 self.items = CreateObjectsFromXml(daeDocument, xmlNode, self.__objectSyntax, self.__objectType)
543
557 return len(self.items)
558
560 for i in self.items:
561 if i.id == url:
562 return i
563 return None
564
566 self.items.append(item)
567
569 return super(DaeLibrary,self).__str__() + 'extras: %s, asset: %s, items: %s'%(self.extras, self.asset, self.items)
570
573 super(DaeAsset,self).__init__()
574 self.contributors = []
575 self.created = None
576 self.modified = None
577 self.revision = None
578 self.title = None
579 self.subject = None
580 self.keywords = []
581 self.unit = DaeUnit()
582 self.upAxis = 'Y_UP'
583
584 self.syntax = DaeSyntax.ASSET
585
587 if xmlNode is None:
588 return
589
590 self.contributors = CreateObjectsFromXml(daeDocument, xmlNode,DaeSyntax.CONTRIBUTOR,DaeContributor)
591
592 self.created = ReadDateTime(FindElementByTagName(xmlNode,DaeSyntax.CREATED))
593
594 self.modified = ReadDateTime(FindElementByTagName(xmlNode,DaeSyntax.MODIFIED))
595
596 self.revision = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.REVISION))
597
598 self.title = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.TITLE))
599
600 self.subject = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.SUBJECT))
601
602 self.keywords = GetStringArrayFromNodes(xmlNode.getElementsByTagName(DaeSyntax.KEYWORDS))
603
604 self.unit.LoadFromXml(daeDocument, FindElementByTagName(xmlNode, DaeSyntax.UNIT))
605
606 self.upAxis = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.UP_AXIS))
607
609 node = Element(DaeSyntax.ASSET)
610 AppendChilds(daeDocument,node, self.contributors)
611 AppendTextChild(node, DaeSyntax.CREATED, self.created)
612 AppendTextChild(node, DaeSyntax.MODIFIED, self.modified)
613 AppendTextChild(node, DaeSyntax.REVISION, self.revision)
614 AppendTextChild(node, DaeSyntax.TITLE, self.title)
615 AppendTextChild(node, DaeSyntax.SUBJECT, self.subject)
616 AppendChild(daeDocument, node, self.unit)
617 AppendTextChild(node, DaeSyntax.UP_AXIS, self.upAxis)
618
619
620
621 return node
622
623
625 return super(DaeAsset,self).__str__()+'contributors: %s, created: %s, modified: %s, revision: %s, title: %s, subject: %s, keywords: %s, unit: %s, upAxis: %s'%(self.contributors, self.created, self.modified, self.revision, self.title, self.subject, self.keywords, self.unit, self.upAxis)
626
627
630 super(DaeScene,self).__init__()
631 self.extras = []
632 self.iVisualScenes = []
633 self.iPhysicsScenes = []
634
635 self.syntax = DaeSyntax.SCENE
636
642
648
650 result = []
651 for i in self.iVisualScenes:
652 result.append(i.object)
653 return result
654
656 result = []
657 for i in self.iPhysicsScenes:
658 result.append(i.object)
659 return result
660
662 return super(DaeScene,self).__str__()+'extras: %s, visualScenes: %s, physicsScenes: %s'%(self.extras, self.iVisualScenes, self.iPhysicsScenes)
663
664
672
674 if xmlNode is None:
675 return
676 name = xmlNode.getAttribute(DaeSyntax.NAME)
677 if name != '':
678 self.name = name
679
680 meter = xmlNode.getAttribute(DaeSyntax.METER)
681 if meter != '':
682 self.meter = float(meter)
683
689
692
703
710
712 node = super(DaeContributor, self).SaveToXml(daeDocument)
713 AppendTextChild(node, DaeSyntax.AUTHOR, self.author)
714 AppendTextChild(node, DaeSyntax.AUTHORING_TOOL, self.authoringTool)
715 AppendTextChild(node, DaeSyntax.COMMENTS, self.comments)
716 AppendTextChild(node, DaeSyntax.COPYRIGHT, self.copyright)
717 AppendTextChild(node, DaeSyntax.SOURCE_DATA, self.sourceData)
718 return node
719
720
722 return super(DaeContributor,self).__str__() + 'author: %s, authoring_tool: %s, comments: %s, copyright: %s, sourceData: %s'%(self.author, self.authoringTool, self.comments, self.copyright, self.sourceData)
723
731
733 super(DaeAnimation, self).LoadFromXml(daeDocument, xmlNode)
734 self.channels = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.CHANNEL, DaeChannel)
735 self.samplers = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.SAMPLER, DaeSampler)
736 self.sources = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.SOURCE, DaeSource)
737
744
746 for source in self.sources:
747 if source.id == sourceId:
748 return source
749 return None
750
772
775 self.syntax = DaeSyntax.CHANNEL
776 self.source = None
777 self.target = None
778
782
788
799
801 super(DaeCamera, self).LoadFromXml(daeDocument, xmlNode)
802 self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra)
803 self.asset = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.ASSET, DaeAsset)
804 self.optics.LoadFromXml(daeDocument, FindElementByTagName(xmlNode, DaeSyntax.OPTICS))
805 self.imager = CreateObjectFromXml(daeDocument,xmlNode, DaeSyntax.IMAGER,DaeImager)
806
807
819
821 return super(DaeCamera,self).__str__()+'asset: %s, optics: %s, imager: %s, extras: %s'%(self.asset, self.optics, self.imager, self.extras)
822
827 super(DaeImage,self).__init__()
828 self.format = None
829 self.height = None
830 self.width = None
831 self.depth = None
832 self.initFrom = None
833 self.syntax = DaeSyntax.IMAGE
834
842
844 node = super(DaeImage, self).SaveToXml(daeDocument)
845 SetAttribute(node, DaeSyntax.FORMAT, self.format)
846 SetAttribute(node, DaeSyntax.HEIGHT, self.height)
847 SetAttribute(node, DaeSyntax.WIDTH, self.width)
848 SetAttribute(node, DaeSyntax.DEPTH, self.depth)
849 AppendTextChild(node, DaeSyntax.INIT_FROM,self.initFrom, None)
850 return node
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
886
888 super(DaeGeometry, self).LoadFromXml(daeDocument, xmlNode)
889 self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra)
890 self.asset = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.ASSET, DaeAsset)
891
892 self.data = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.MESH, DaeMesh)
893 if self.data is None:
894 self.data = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.CONVEX_MESH, DaeConvexMesh)
895 if self.data is None:
896 self.data = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.SPLINE, DaeSpline)
897
907
909 return super(DaeGeometry,self).__str__()+' assets: %s, data: %s, extras: %s'%(self.asset, self.data, self.extras)
910
924
927 super(DaeMesh, self).__init__()
928 self.sources = []
929 self.vertices = None
930 self.primitives = []
931 self.extras = []
932 self.syntax = DaeSyntax.MESH
933
935 if xmlNode is None:
936 return
937 self.vertices = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.VERTICES, DaeVertices)
938 self.sources = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.SOURCE, DaeSource)
939
940 lines = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.LINES, DaeLines)
941 linestrips = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.LINESTRIPS, DaeLineStrips)
942 polygons = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.POLYGONS, DaePolygons)
943 polylist = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.POLYLIST, DaePolylist)
944 triangles = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.TRIANGLES, DaeTriangles)
945 trifans = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.TRIFANS, DaeTriFans)
946 tristrips = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.TRISTRIPS, DaeTriStrips)
947 if lines != None: self.primitives += lines
948 if linestrips != None: self.primitives += linestrips
949 if polygons != None: self.primitives += polygons
950 if polylist != None: self.primitives += polylist
951 if triangles != None: self.primitives += triangles
952 if trifans != None: self.primitives += trifans
953 if tristrips != None: self.primitives += tristrips
954
955 self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra)
956
958 for s in self.sources:
959 if s.id == input.source:
960 return s
961 return None
962
977
982
988
994
996 return super(DaeVertices,self).__str__() + ' inputs: %s, extras: %s'%(self.inputs, self.extras)
997
1020
1030
1032 super(DaeSource,self).LoadFromXml(daeDocument, xmlNode)
1033 if xmlNode is None:
1034 return
1035 bools = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.BOOL_ARRAY, DaeBoolArray)
1036 floats = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.FLOAT_ARRAY, DaeFloatArray)
1037 ints = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.INT_ARRAY, DaeIntArray)
1038 names = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.NAME_ARRAY, DaeNameArray)
1039 if bools != None:
1040 self.source = bools
1041 elif floats != None:
1042 self.source = floats
1043 elif ints != None:
1044 self.source = ints
1045 elif names != None:
1046 self.source = names
1047
1048 self.techniqueCommon = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.TECHNIQUE_COMMON, DaeSource.DaeTechniqueCommon)
1049 self.techniques = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.TECHNIQUE,DaeTechnique)
1050 if not (self.techniqueCommon is None):
1051 for i in range(0,self.techniqueCommon.accessor.count):
1052 vec = []
1053 for j in range(0,self.techniqueCommon.accessor.stride):
1054 vec.append(self.source.data[i*self.techniqueCommon.accessor.stride+j])
1055 self.vectors.append(vec)
1056
1058 node = super(DaeSource, self).SaveToXml(daeDocument)
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069 AppendChild(daeDocument, node, self.source)
1070
1071 AppendChild(daeDocument,node,self.techniqueCommon)
1072
1073 AppendChilds(daeDocument, node, self.techniques)
1074 return node
1075
1077 return super(DaeSource,self).__str__()+' source: %s, techniqueCommon: %s, techniques: %s'%(self.source, self.techniqueCommon, self.techniques)
1078
1094
1103
1105 super(DaeLight, self).LoadFromXml(daeDocument, xmlNode)
1106 self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra)
1107 self.asset = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.ASSET, DaeAsset)
1108
1109 self.techniques = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.TECHNIQUE,DaeTechnique)
1110
1111 lightSourceNode = RemoveWhiteSpaceNode(FindElementByTagName(xmlNode, DaeSyntax.TECHNIQUE_COMMON)).firstChild
1112 lightSourceName = lightSourceNode.localName
1113 if lightSourceName == DaeSyntax.DIRECTIONAL:
1114 self.techniqueCommon = DaeLight.DaeDirectional()
1115 elif lightSourceName == DaeSyntax.SPOT:
1116 self.techniqueCommon = DaeLight.DaeSpot()
1117 elif lightSourceName == DaeSyntax.AMBIENT:
1118 self.techniqueCommon = DaeLight.DaeAmbient()
1119 elif lightSourceName == DaeSyntax.POINT:
1120 self.techniqueCommon = DaeLight.DaePoint()
1121 self.techniqueCommon.LoadFromXml(daeDocument,lightSourceNode)
1122
1134
1136 return super(DaeLight,self).__str__()+' techniqueCommon: %s, techniques: %s'%(self.techniqueCommon, self.techniques)
1137
1156
1171
1172 - class DaeSpot(DaeTechniqueCommon):
1174 super(DaeLight.DaeSpot,self).__init__()
1175 self.defConstantAttenuation = 0.0
1176 self.defLinearAttenuation = 0.0
1177 self.defQuadraticAttenuation = 0.0
1178 self.defFalloffAngle = 180.0
1179 self.defFalloffExponent = 0.0
1180
1181 self.constantAttenuation = 0.0
1182 self.linearAttenuation = 0.0
1183 self.quadraticAttenuation = 0.0
1184 self.falloffAngle = 180.0
1185 self.falloffExponent = 0.0
1186 self.syntax = DaeSyntax.SPOT
1187
1189 super(DaeLight.DaeSpot,self).LoadFromXml(daeDocument, xmlNode)
1190 self.constantAttenuation = CastFromXml(daeDocument,xmlNode,DaeSyntax.CONSTANT_ATTENUATION, float, self.defConstantAttenuation, 1.0)
1191 self.linearAttenuation = CastFromXml(daeDocument,xmlNode,DaeSyntax.LINEAR_ATTENUATION,float, self.defLinearAttenuation, 0)
1192 self.quadraticAttenuation = CastFromXml(daeDocument, xmlNode,DaeSyntax.QUADRATIC_ATTENUATION, float, self.defQuadraticAttenuation, 0)
1193 self.falloffAngle = CastFromXml(daeDocument, xmlNode, DaeSyntax.FALLOFF_ANGLE, float, self.defFalloffAngle, 180.0)
1194 self.falloffExponent = CastFromXml(daeDocument, xmlNode, DaeSyntax.FALLOFF_EXPONENT, float, self.defFalloffExponent, 0)
1195
1197 node = super(DaeLight.DaeSpot,self).SaveToXml(daeDocument)
1198 AppendTextChild(node.firstChild,DaeSyntax.CONSTANT_ATTENUATION, self.constantAttenuation, self.defConstantAttenuation)
1199 AppendTextChild(node.firstChild,DaeSyntax.LINEAR_ATTENUATION, self.linearAttenuation, self.defLinearAttenuation)
1200 AppendTextChild(node.firstChild,DaeSyntax.QUADRATIC_ATTENUATION, self.quadraticAttenuation, self.defQuadraticAttenuation)
1201 AppendTextChild(node.firstChild,DaeSyntax.FALLOFF_ANGLE, self.falloffAngle, self.defFalloffAngle)
1202 AppendTextChild(node.firstChild,DaeSyntax.FALLOFF_EXPONENT, self.falloffExponent, self.defFalloffExponent)
1203 return node
1204
1206 return super(DaeLight.DaeSpot,self).__str__()+' const.att: %s, lin.att: %s, quad.att: %s, falloffAngle: %s, falloffExponent: %s'%(self.constantAttenuation, self.linearAttenuation, self.quadraticAttenuation, self.falloffAngle, self.falloffExponent)
1207
1224
1232
1234 super(DaeLight.DaePoint,self).LoadFromXml(daeDocument, xmlNode)
1235 self.constantAttenuation = CastFromXml(daeDocument,xmlNode,DaeSyntax.CONSTANT_ATTENUATION, float, 1)
1236 self.linearAttenuation = CastFromXml(daeDocument,xmlNode,DaeSyntax.LINEAR_ATTENUATION,float, 0)
1237 self.quadraticAttenuation = CastFromXml(daeDocument, xmlNode,DaeSyntax.QUADRATIC_ATTENUATION, float, 0)
1238
1245
1247 return super(DaeLight.DaePoint,self).__str__()+' const.att: %s, lin.att: %s, quad.att: %s'%(self.constantAttenuation, self.linearAttenuation, self.quadraticAttenuation)
1248
1256
1258 super(DaeVisualScene, self).LoadFromXml(daeDocument, xmlNode)
1259 self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra)
1260 self.asset = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.ASSET, DaeAsset)
1261 self.nodes = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.NODE, DaeNode)
1262
1272
1274 for n in self.nodes:
1275 if n.id == nodeUrl:
1276 return n
1277 return None
1278
1279
1281 return super(DaeVisualScene,self).__str__()+' asset: %s, nodes: %s, extras: %s'%(self.asset, self.nodes, self.extras)
1282
1284
1285 NODE = 2
1286 JOINT = 1
1287
1289 super(DaeNode,self).__init__()
1290 self.sid = None
1291 self.type = DaeNode.NODE
1292 self.layer = []
1293 self.transforms = []
1294 self.nodes = []
1295
1296 self.iAnimations = []
1297 self.iCameras = []
1298 self.iControllers = []
1299 self.iGeometries = []
1300 self.iLights = []
1301 self.iNodes = []
1302 self.iVisualScenes = []
1303
1304 self.syntax = DaeSyntax.NODE
1305
1307 super(DaeNode, self).LoadFromXml(daeDocument, xmlNode)
1308 self.sid = ReadAttribute(xmlNode, DaeSyntax.SID)
1309 type = ReadAttribute(xmlNode, DaeSyntax.TYPE)
1310 if type == DaeSyntax.TYPE_JOINT:
1311 self.type = DaeNode.JOINT
1312 else:
1313 self.type = DaeNode.NODE
1314 self.layer = ReadAttribute(xmlNode, DaeSyntax.LAYER).split()
1315
1316
1317 RemoveWhiteSpaceNode(xmlNode)
1318 child = xmlNode.firstChild
1319 while child != None:
1320 name = child.localName
1321 sid = ReadAttribute(child, DaeSyntax.SID)
1322 if name == DaeSyntax.TRANSLATE:
1323 self.transforms.append([name,ToFloatList(ReadContents(child)), sid])
1324 elif name == DaeSyntax.ROTATE:
1325 self.transforms.append([name,ToFloatList(ReadContents(child)), sid])
1326 elif name == DaeSyntax.SCALE:
1327 self.transforms.append([name,ToFloatList(ReadContents(child)), sid])
1328 elif name == DaeSyntax.SKEW:
1329 self.transforms.append([name,ToFloatList(ReadContents(child)), sid])
1330 elif name == DaeSyntax.LOOKAT:
1331 self.transforms.append([name,ToFloatList(ReadContents(child)), sid])
1332 elif name == DaeSyntax.MATRIX:
1333 self.transforms.append([name,ToMatrix4(ReadContents(child)), sid])
1334
1335 child = child.nextSibling
1336
1337
1338 self.iAnimations = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INSTANCE_ANIMATION, DaeAnimationInstance)
1339 self.iCameras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INSTANCE_CAMERA, DaeCameraInstance)
1340 self.iControllers = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INSTANCE_CONTROLLER, DaeControllerInstance)
1341 self.iGeometries = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INSTANCE_GEOMETRY, DaeGeometryInstance)
1342 self.iLights = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INSTANCE_LIGHT, DaeLightInstance)
1343 self.iNodes = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INSTANCE_NODE, DaeNodeInstance)
1344 self.iVisualScenes = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INSTANCE_VISUAL_SCENE, DaeVisualSceneInstance)
1345
1346
1347 self.nodes = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.NODE, DaeNode)
1348
1350 node = super(DaeNode, self).SaveToXml(daeDocument)
1351 SetAttribute(node, DaeSyntax.SID, self.sid)
1352 if self.type == DaeSyntax.TYPE_JOINT:
1353 SetAttribute(node, DaeSyntax.TYPE, DaeNode.GetType(self.type))
1354
1355
1356 SetAttribute(node, DaeSyntax.LAYER, ListToString(self.layer))
1357 for i in self.transforms:
1358 writeTransform = False
1359 el = Element(i[0])
1360 val = i[1]
1361 if i[0] == DaeSyntax.MATRIX:
1362 val = MatrixToString(val,ROUND)
1363 AppendTextChild(node,i[0],val)
1364 else:
1365 orgval = val
1366 val = ListToString(RoundList(val, 5))
1367 if i[0] == DaeSyntax.SCALE:
1368
1369 SetAttribute(AppendTextChild(node,i[0],val,None), DaeSyntax.SID, DaeSyntax.SCALE)
1370 elif i[0] == DaeSyntax.TRANSLATE:
1371
1372 SetAttribute(AppendTextChild(node,i[0],val,None), DaeSyntax.SID, DaeSyntax.TRANSLATE)
1373 elif i[0] == DaeSyntax.ROTATE:
1374
1375 axis = None
1376 if orgval[0] == 1 and orgval[1] == 0 and orgval[2] == 0:
1377 axis = "X"
1378 elif orgval[0] == 0 and orgval[1] == 1 and orgval[2] == 0:
1379 axis = "Y"
1380 elif orgval[0] == 0 and orgval[1] == 0 and orgval[2] == 1:
1381 axis = "Z"
1382 no = AppendTextChild(node,i[0],val,None)
1383 if axis != None:
1384 SetAttribute(no, DaeSyntax.SID, DaeSyntax.ROTATE+axis)
1385
1386 elif i[0] == DaeSyntax.SKEW:
1387 AppendTextChild(node,i[0],val)
1388 elif i[0] == DaeSyntax.MATRIX or i[0] == DaeSyntax.LOOKAT:
1389 AppendTextChild(node,i[0],val)
1390
1391 AppendChilds(daeDocument, node, self.nodes)
1392
1393 AppendChilds(daeDocument, node, self.iAnimations)
1394 AppendChilds(daeDocument, node, self.iCameras)
1395 AppendChilds(daeDocument, node, self.iControllers)
1396 AppendChilds(daeDocument, node, self.iGeometries)
1397 AppendChilds(daeDocument, node, self.iLights)
1398 AppendChilds(daeDocument, node, self.iNodes)
1399 AppendChilds(daeDocument, node, self.iVisualScenes)
1400
1401 return node
1402
1405
1411 GetType = staticmethod(GetType)
1412
1414 return []+self.iAnimations+self.iCameras+self.iControllers+self.iGeometries+self.iLights+self.iNodes
1415
1416
1417
1418
1435
1443
1456
1466
1468 return super(DaeOptics,self).__str__()+' extras: %s, techniqueCommon: %s, techniques: %s'%(self.extras, self.techniqueCommon, self.techniques)
1469
1496
1499
1521
1542
1549
1554
1562
1564 return super(DaeImager,self).__str__()+' extras: %s, techniques: %s'%(self.techniqueCommon, self.techniques)
1565
1566
1573
1577
1582
1583
1585 return super(DaeExtra,self).__str__()+'techniques: %s'%(self.techniques)
1586
1589 super(DaeAccessor,self).__init__()
1590 self.count = 0
1591 self.offset = None
1592 self.source = ''
1593 self.__stride = None
1594
1595 self.params = []
1596
1597 self.syntax = DaeSyntax.ACCESSOR
1598
1600 self.count = CastAttributeFromXml(xmlNode, DaeSyntax.COUNT,int,0)
1601 self.offset = CastAttributeFromXml(xmlNode, DaeSyntax.OFFSET,int)
1602 self.source = ReadAttribute(xmlNode, DaeSyntax.SOURCE)
1603 self.stride = CastAttributeFromXml(xmlNode, DaeSyntax.STRIDE,int)
1604 self.params = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.PARAM, DaeParam)
1605
1614
1616 param = DaeParam()
1617 param.name = name
1618 param.type = type
1619 self.params.append(param)
1620
1622 if self.__stride is None:
1623 return len(self.params)
1624 else:
1625 return self.__stride
1626
1629
1631 return paramName in [param.name for param in self.params]
1632
1633
1634 stride = property(GetStride, SetStride)
1635
1658
1678
1679
1688
1689
1698
1707
1715
1716
1724
1725
1726
1727
1730 super(DaePrimitive, self).__init__()
1731 self.name = None
1732 self.count = 0
1733 self.material = ''
1734 self.inputs = []
1735
1740
1747
1749 if self.inputs != []:
1750 return max([i.offset for i in self.inputs])
1751 else:
1752 return None
1753
1759
1777
1785
1786
1787
1805
1813
1830
1838
1846
1849 super(DaeInstance, self).__init__()
1850 self.url = ''
1851 self.extras = []
1852 self.object = None
1853
1857
1863
1876
1889
1908
1909
1923
1939
1952
1965
1978
1979
1992
1993
2174
2180
2183
2188
2193
2196
2201
2204
2205
2227
2235
2237 super(DaeFxMaterial, self).LoadFromXml(daeDocument, xmlNode)
2238 self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra)
2239 self.asset = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.ASSET, DaeAsset)
2240 self.iEffects = CreateObjectsFromXml(daeDocument,xmlNode, DaeFxSyntax.INSTANCE_EFFECT, DaeFxEffectInstance)
2241
2251
2253 return super(DaeFxMaterial,self).__str__()+' assets: %s, iEffects: %s, extras: %s'%(self.asset, self.iEffects, self.extras)
2254
2269
2275
2276
2280
2285
2287 return super(DaeFxEffect, self).__str__() + ', profileCommon: %s' % (self.profileCommon)
2288
2290 self.profileCommon.technique.shader = daeShader
2291
2299
2300
2305
2312
2314 return super(DaeFxProfileCommon, self).__str__() + ', technique: %s, images: %s, newParams: %s' % (self.technique, self.images, self.newParams)
2315
2327
2339
2346
2348
2349 self.sid = ReadAttribute(xmlNode, DaeFxSyntax.SID)
2350 lightSourceNode = FindElementByTagName(xmlNode, DaeFxSyntax.CONSTANT)
2351 if lightSourceNode:
2352 self.shader = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.CONSTANT, DaeFxShadeConstant)
2353 else:
2354 lightSourceNode = FindElementByTagName(xmlNode, DaeFxSyntax.LAMBERT)
2355 if lightSourceNode:
2356 self.shader = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.LAMBERT, DaeFxShadeLambert)
2357 else:
2358 lightSourceNode = FindElementByTagName(xmlNode, DaeFxSyntax.BLINN)
2359 if lightSourceNode:
2360 self.shader = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.BLINN, DaeFxShadeBlinn)
2361 else:
2362 lightSourceNode = FindElementByTagName(xmlNode, DaeFxSyntax.PHONG)
2363 self.shader = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.PHONG, DaeFxShadePhong)
2364
2365
2371
2374
2375
2378 super(DaeFxShadeConstant, self).__init__()
2379 self.emission = None
2380 self.reflective = None
2381 self.reflectivity = None
2382 self.transparent = None
2383 self.transparency = None
2384 self.indexOfRefraction = None
2385
2386 self.syntax = DaeFxSyntax.CONSTANT
2387
2389 self.emission = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.EMISSION, DaeFxCommonColorAndTextureContainer, True)
2390 self.reflective = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.REFLECTIVE, DaeFxCommonColorAndTextureContainer, True)
2391 self.reflectivity = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.REFLECTIVITY, DaeFxCommonFloatAndParamContainer, True)
2392 self.transparent = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.TRANSPARENT, DaeFxCommonColorAndTextureContainer, True)
2393 self.transparency = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.TRANSPARENCY, DaeFxCommonFloatAndParamContainer, True)
2394 self.indexOfRefraction = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.INDEXOFREFRACTION, DaeFxCommonFloatAndParamContainer, True)
2395
2397 node = super(DaeFxShadeConstant,self).SaveToXml(daeDocument)
2398 AppendChild(daeDocument, node, self.emission)
2399 if isinstance(self, DaeFxShadeLambert):
2400 AppendChild(daeDocument, node, self.ambient)
2401 AppendChild(daeDocument, node, self.diffuse)
2402 if isinstance(self,DaeFxShadeBlinn):
2403 AppendChild(daeDocument, node, self.specular)
2404 AppendChild(daeDocument, node, self.shininess)
2405 AppendChild(daeDocument, node, self.reflective)
2406 AppendChild(daeDocument, node, self.reflectivity)
2407 AppendChild(daeDocument, node, self.transparent)
2408 AppendChild(daeDocument, node, self.transparency)
2409 AppendChild(daeDocument, node, self.indexOfRefraction)
2410 return node
2411
2441
2442
2443
2450
2452 super(DaeFxShadeLambert, self).LoadFromXml(daeDocument, xmlNode)
2453 self.ambient = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.AMBIENT, DaeFxCommonColorAndTextureContainer, True)
2454 self.diffuse = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.DIFFUSE, DaeFxCommonColorAndTextureContainer, True)
2455
2456
2462
2479
2486
2488 super(DaeFxShadeBlinn, self).LoadFromXml(daeDocument, xmlNode)
2489 self.specular = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.SPECULAR, DaeFxCommonColorAndTextureContainer, True)
2490 self.shininess = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.SHININESS, DaeFxCommonFloatAndParamContainer, True)
2491
2492
2498
2512
2517
2519 - def __init__(self, syntax='UNKNOWN'):
2520 super(DaeFxCommonColorAndTextureContainer, self).__init__()
2521 self.color = None
2522 self.texture = None
2523 self.syntax = syntax
2524
2525 - def LoadFromXml(self, daeDocument, xmlNode):
2528
2529 - def SaveToXml(self, daeDocument):
2530 node = super(DaeFxCommonColorAndTextureContainer,self).SaveToXml(daeDocument)
2531 AppendChild(daeDocument, node, self.color)
2532 AppendChild(daeDocument, node, self.texture)
2533 return node
2534
2536 - def __init__(self, syntax = 'UNKNOWN'):
2541
2544
2545
2551
2568
2569 -class DaeFxTexture(DaeEntity):
2570 - def __init__(self):
2571 super(DaeFxTexture, self).__init__()
2572 self.texture = ''
2573 self.textCoord = ''
2574 self.syntax = DaeFxSyntax.TEXTURE
2575
2576 - def LoadFromXml(self, daeDocument, xmlNode):
2577 self.texture = daeDocument.imagesLibrary.FindObject(ReadAttribute(xmlNode, DaeFxSyntax.TEXTURE))
2578 self.textCoord = ReadAttribute(xmlNode, DaeFxSyntax.TEXCOORD)
2579
2580 - def SaveToXml(self, daeDocument):
2581 node = super(DaeFxTexture,self).SaveToXml(daeDocument)
2582 SetAttribute(node, DaeFxSyntax.TEXTURE, StripString(self.texture))
2583 SetAttribute(node, DaeFxSyntax.TEXCOORD, self.textCoord)
2584 return node
2585
2626
2634
2636 super(DaePhysicsScene, self).LoadFromXml(daeDocument, xmlNode)
2637 self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra)
2638 self.asset = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.ASSET, DaeAsset)
2639 self.iPhysicsModels = CreateObjectsFromXml(daeDocument, xmlNode, DaePhysicsSyntax.INSTANCE_PHYSICS_MODEL, DaePhysicsModelInstance)
2640
2650
2652 return super(DaePhysicsScene,self).__str__()+' asset: %s, iPhysicsModels: %s, extras: %s'%(self.asset, self.iPhysicsModels, self.extras)
2653
2686
2687
2700
2709
2713
2714 -class DaeRigidBodyInstance(DaeEntity):
2715 - def __init__(self):
2716 super(DaeRigidBodyInstance, self).__init__()
2717 self.syntax = DaePhysicsSyntax.INSTANCE_RIGID_BODY
2718 self.body = None
2719 self.target = None
2720 self.bodyString = ''
2721 self.targetString = ''
2722
2723 - def LoadFromXml(self, daeDocument, xmlNode):
2724 self.bodyString = ReadAttribute(xmlNode, DaeSyntax.BODY)
2725 self.targetString = ReadAttribute(xmlNode, DaeSyntax.TARGET)[1:]
2726
2727 - def SaveToXml(self, daeDocument):
2728 node = super(DaeRigidBodyInstance,self).SaveToXml(daeDocument)
2729 SetAttribute(node, DaeSyntax.BODY, self.body.sid)
2730 SetAttribute(node, DaeSyntax.TARGET, StripString('#'+self.target.id))
2731 return node
2732
2738
2742
2748
2749 - def FindRigidBody(self, url):
2750 for rigidBody in self.rigidBodies:
2751 if rigidBody.sid == url:
2752 return rigidBody
2753 return None
2754
2760
2764
2769
2777
2779 self.dynamicFriction = CastFromXml(daeDocument, xmlNode, DaePhysicsSyntax.DYNAMIC_FRICTION, float, 0)
2780 self.restitution = CastFromXml(daeDocument, xmlNode, DaePhysicsSyntax.RESTITUTION, float, 0)
2781 self.staticFriction = CastFromXml(daeDocument, xmlNode, DaePhysicsSyntax.STATIC_FRICTION, float, 0)
2782
2784 node = super(DaePhysicsMaterial.DaeTechniqueCommon,self).SaveToXml(daeDocument)
2785 AppendTextChild(node, DaePhysicsSyntax.DYNAMIC_FRICTION, self.dynamicFriction, None)
2786 AppendTextChild(node, DaePhysicsSyntax.RESTITUTION, self.restitution, None)
2787 AppendTextChild(node, DaePhysicsSyntax.STATIC_FRICTION, self.staticFriction, None)
2788 return node
2789
2792
2793 -class DaeRigidBody(DaeEntity):
2794 - def __init__(self):
2795 super(DaeRigidBody, self).__init__()
2796 self.syntax = DaePhysicsSyntax.RIGID_BODY
2797 self.name = ''
2798 self.sid = ''
2799 self.techniqueCommon = DaeRigidBody.DaeTechniqueCommon()
2800
2801 - def LoadFromXml(self, daeDocument, xmlNode):
2802 self.name = xmlNode.getAttribute(DaeSyntax.NAME)
2803 self.sid = xmlNode.getAttribute(DaeSyntax.SID)
2804 self.techniqueCommon = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.TECHNIQUE_COMMON, DaeRigidBody.DaeTechniqueCommon)
2805
2806 - def SaveToXml(self, daeDocument):
2807 node = super(DaeRigidBody, self).SaveToXml(daeDocument)
2808 SetAttribute(node,DaeSyntax.NAME, StripString(self.name))
2809 SetAttribute(node,DaeSyntax.SID, StripString(self.sid))
2810 AppendChild(daeDocument,node,self.techniqueCommon)
2811 return node
2812
2813 - class DaeTechniqueCommon(DaeEntity):
2814 - def __init__(self):
2815 super(DaeRigidBody.DaeTechniqueCommon, self).__init__()
2816 self.syntax = DaeSyntax.TECHNIQUE_COMMON
2817 self.iPhysicsMaterial = None
2818 self.physicsMaterial = None
2819 self.dynamic = True
2820 self.mass = None
2821 self.inertia = None
2822 self.shapes = []
2823
2824 - def LoadFromXml(self, daeDocument, xmlNode):
2825 self.iPhysicsMaterial = CreateObjectFromXml(daeDocument, xmlNode, DaePhysicsSyntax.INSTANCE_PHYSICS_MATERIAL, DaePhysicsMaterialInstance)
2826 self.physicsMaterial = CreateObjectFromXml(daeDocument, xmlNode, DaePhysicsSyntax.PHYSICS_MATERIAL, DaePhysicsMaterial)
2827 self.dynamic = CastFromXml(daeDocument, xmlNode, DaePhysicsSyntax.DYNAMIC,bool,True)
2828 self.mass = CastFromXml(daeDocument, xmlNode, DaePhysicsSyntax.MASS, float, 1)
2829 self.inertia = ToFloat3(ReadContents(FindElementByTagName(xmlNode,DaePhysicsSyntax.INERTIA)))
2830
2831 shapeNodes = FindElementsByTagName(xmlNode, DaePhysicsSyntax.SHAPE)
2832 for shapeNode in shapeNodes:
2833 s = FindElementByTagName(shapeNode, DaePhysicsSyntax.BOX)
2834 b = None
2835 if not (s is None):
2836 b = DaeBoxShape()
2837 else:
2838 s = FindElementByTagName(shapeNode, DaePhysicsSyntax.SPHERE)
2839 if not (s is None):
2840 b = DaeSphereShape()
2841 else:
2842 s = FindElementByTagName(shapeNode, DaePhysicsSyntax.PLANE)
2843 if not (s is None):
2844 b = DaePlaneShape()
2845 else:
2846 s = FindElementByTagName(shapeNode, DaeSyntax.INSTANCE_GEOMETRY)
2847 if not (s is None):
2848 b = DaeGeometryShape()
2849 else:
2850 s = FindElementByTagName(shapeNode, DaePhysicsSyntax.CYLINDER)
2851 if not (s is None):
2852 b = DaeCylinderShape()
2853 else:
2854 s = FindElementByTagName(shapeNode, DaePhysicsSyntax.TAPERED_CYLINDER)
2855 if not (s is None):
2856 b = DaeTaperedCylinderShape()
2857 else:
2858 s = FindElementByTagName(shapeNode, DaePhysicsSyntax.CAPSULE)
2859 if not (s is None):
2860 b = DaeCapsule()
2861 else:
2862 b = DaeTaperedCapsuleShape()
2863 b.LoadFromXml(daeDocument, s)
2864 self.shapes.append(b)
2865
2866 - def SaveToXml(self, daeDocument):
2867 node = super(DaeRigidBody.DaeTechniqueCommon,self).SaveToXml(daeDocument)
2868 AppendChild(daeDocument,node,self.iPhysicsMaterial)
2869 AppendChild(daeDocument,node,self.physicsMaterial)
2870 shapes = Element(DaePhysicsSyntax.SHAPE)
2871 AppendChilds(daeDocument, shapes, self.shapes)
2872 node.appendChild(shapes)
2873 AppendTextChild(node, DaePhysicsSyntax.DYNAMIC, self.dynamic, None)
2874 AppendTextChild(node, DaePhysicsSyntax.MASS, self.mass, None)
2875 AppendTextChild(node, DaePhysicsSyntax.INERTIA, self.inertia, None)
2876 return node
2877
2879 if not (self.physicsMaterial is None):
2880 return self.physicsMaterial
2881 else:
2882 return self.iPhysicsMaterial.object
2883
2884 - def __str__(self):
2886
2893
2895 self.iGeometry = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.INSTANCE_GEOMETRY,DaeGeometryInstance)
2896 self.mass = CastFromXml(daeDocument, xmlNode, DaePhysicsSyntax.MASS, float, None)
2897 self.density = CastFromXml(daeDocument, xmlNode, DaePhysicsSyntax.DENSITY, float, None)
2898
2904
2919
2934
2952
2973
2988
3006
3011
3016
3017
3018
3019
3021
3022
3023 return self.iGeometry.SaveToXml(daeDocument)
3024
3059
3060
3062 if xmlNode is None:
3063 return None
3064 objects = []
3065 nodes = FindElementsByTagName(xmlNode,nodeType)
3066 for node in nodes:
3067 object = objectType()
3068 object.LoadFromXml(colladaDocument, node)
3069 objects.append(object)
3070 return objects
3071
3073 if xmlNode is None:
3074 return None
3075 node = FindElementByTagName(xmlNode, nodeType)
3076 object = None
3077 if setSyntax:
3078 object = objectType(nodeType)
3079 else:
3080 object = objectType()
3081 if node != None:
3082 object.LoadFromXml(colladaDocument, node)
3083 return object
3084 return None
3085
3086 -def CastFromXml(colladaDocument, xmlNode, nodeType, cast, default=None):
3087 if xmlNode is None:
3088 return default
3089 node = FindElementByTagName(xmlNode, nodeType)
3090 if node != None:
3091 textValue = ReadContents(node)
3092 if cast == bool:
3093 if textValue.lower() == 'false':
3094 return False
3095 else:
3096 return True
3097 return cast(textValue)
3098 return default
3099
3101 if xmlNode is None:
3102 return default
3103 val = ReadAttribute(xmlNode, nodeType)
3104 if val != None and val != '':
3105 return cast(val)
3106 return default
3107
3109 if daeEntity is None or xmlNode is None:
3110 return
3111 else:
3112 child = daeEntity.SaveToXml(daeDocument)
3113 if child is None:
3114 return
3115 else :
3116 xmlNode.appendChild(child)
3117
3119 if daeEntities is None or xmlNode is None:
3120 return
3121
3122 else:
3123 for daeEntity in daeEntities:
3124 AppendChild(daeDocument, xmlNode, daeEntity)
3125
3126 -def AppendTextChild(xmlNode,syntax, object, default = None):
3127 if object is None:
3128 return
3129 if default != None and object == default:
3130 return
3131 node = Element(syntax)
3132 xmlNode.appendChild(node)
3133 return AppendTextInChild(node, object)
3134
3135 -def AppendTextInChild(xmlNode, object):
3136 if object is None:
3137 return
3138 text = Text()
3139 if type(object) == datetime:
3140 text.data = object.isoformat()
3141 elif type(object) == list:
3142 if len(object) == 0: return
3143 if object[0] is not None and type(object[0]) == float:
3144 object = RoundList(object, ROUND)
3145 text.data = ListToString(object)
3146 elif type(object) == float:
3147 text.data = round(object, ROUND)
3148 elif type(object) == bool:
3149 text.data = str(object).lower()
3150 else:
3151 text.data = str(object)
3152 xmlNode.appendChild(text)
3153 return xmlNode
3154
3156 if xmlNode is None or object is None or str(object) == '':
3157 return
3158 xmlNode.setAttribute(syntax,str(object))
3159
3161 attribute = ReadAttribute(node,DaeSyntax.URL)
3162 if attribute == None: return None
3163 else :
3164 attribute = str(attribute)
3165 if attribute.startswith('#'):
3166 return attribute[1:]
3167 return None
3168
3171
3173 versionAr = version.split('.')
3174 curVersionAr = curVersion.split('.')
3175 for i in range(len(curVersionAr)):
3176 if versionAr[i] != curVersionAr[i]:
3177 return False
3178 return True
3179
3181 return text.replace(' ','_').replace('.','_')
3182