Module Collada
[hide private]
[frames] | no frames]

Source Code for Module Collada

   1  # -------------------------------------------------------------------------
 
   2  # Illusoft Collada 1.4 plugin for Blender version 0.3.89
 
   3  # --------------------------------------------------------------------------
 
   4  # ***** BEGIN GPL LICENSE BLOCK *****
 
   5  #
 
   6  # Copyright (C) 2006: Illusoft - colladablender@illusoft.com
 
   7  #
 
   8  # This program is free software; you can redistribute it and/or modify
 
   9  # it under the terms of the GNU General Public License as published by
 
  10  # the Free Software Foundation; either version 2 of the License,
 
  11  # or (at your option) any later version.
 
  12  #
 
  13  # This program is distributed in the hope that it will be useful,
 
  14  # but WITHOUT ANY WARRANTY; without even the implied warranty of
 
  15  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
  16  # GNU General Public License for more details.
 
  17  #
 
  18  # You should have received a copy of the GNU General Public License
 
  19  # along with this program; if not, write to the Free Software Foundation,
 
  20  # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
  21  #
 
  22  # ***** END GPL LICENCE BLOCK *****
 
  23  # --------------------------------------------------------------------------
 
  24  
 
  25  from xml.dom.minidom import * 
  26  from datetime import * 
  27  
 
  28  # The number of decimals to export floats to
 
  29  ROUND = 5 
  30  
 
  31  #---Functions----
 
  32  
 
  33  angleToRadian = 3.1415926 / 180.0 
  34  radianToAngle = 180.0 / 3.1415926 
  35  
 
  36  # Convert a string to a float if the value exists
 
37 -def ToFloat(val):
38 if val is None or val == '': 39 return None 40 else: 41 return float(val)
42 43 # Convert a string to a int if the value exists
44 -def ToInt(val):
45 if val is None or val == '': 46 return None 47 else: 48 return int(val)
49 50 # Convert a string to a list of 3 floats e.g '1.0 2.0 3.0' -> [1.0, 2.0, 3.0]
51 -def ToFloat3(stringValue):
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 # Convert a string to a list of 2 floats e.g '1.0 2.0' -> [1.0, 2.0]
58 -def ToFloat2(stringValue, errorText=''):
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
68 -def ToList(var):
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 # Convert a string or list to a list of floats
79 -def ToFloatList(var):
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
93 -def ToIntList(lst):
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
106 -def ToBoolList(lst):
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 # Convert a string to a list of 4 floats e.g '1.0 2.0 3.0 4.0' -> [1.0, 2.0, 3.0, 4.0]
115 -def ToFloat4(stringValue):
116 split = stringValue.split( ) 117 return [ float( split[ 0 ] ), float( split[ 1 ] ), float( split[ 2 ] ) , float( split[3])]
118
119 -def ToFloat7(stringValue):
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
123 -def AddVec3( vector1, vector2 ):
124 vector1.x += vector2.x 125 vector1.y += vector2.y 126 vector1.z += vector2.z
127
128 -def ToMatrix4( matrixElement ):
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
138 -def ToMatrix3(matrixElement):
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
147 -def GetVector3( element ):
148 value = [ float( element[ 0 ] ), float( element[ 1 ] ), float( element[ 2 ] ) ] 149 return value
150
151 -def GetEuler( rotateElement ):
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
157 -def AddEuler(euler1, euler2):
158 euler1.x += euler2.x 159 euler1.y += euler2.y 160 euler1.z += euler2.z
161
162 -def MatrixToString(mat, nDigits):
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
174 -def RoundList(lst, nDigits):
175 result = [] 176 for i in lst: 177 result.append(round(i, nDigits)) 178 return result
179 180
181 -def ListToString(lst):
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 #---XML Utils--- 194 195 # Returns the first child of the specified type in node
196 -def FindElementByTagName(parentNode, type):
197 child = parentNode.firstChild 198 while child != None: 199 if child.localName == type: 200 return child 201 child = child.nextSibling 202 ## childs = parentNode.getElementsByTagName(type) 203 ## if len(childs) > 0: 204 ## return childs[0] 205 return None
206
207 -def FindElementsByTagName(parentNode, type):
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
216 -def ReadAttribute(node,attributeName):
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
229 -def ReadDateTime(node):
230 if node == None: 231 return None 232 return GetDateTime(ReadContents(node))
233
234 -def RemoveWhiteSpace(parent):
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
241 -def RemoveWhiteSpaceNode(parent):
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 ##def RemoveWhiteSpace(node): 248 ## removeList = [] 249 ## for child in node.childNodes: 250 ## if child.nodeType == child.TEXT_NODE and not child.data.strip(): 251 ## removeList.append(child) 252 ## elif child.hasChildNodes(): 253 ## RemoveWhiteSpace(child) 254 ## 255 ## for node in removeList: 256 ## node.parentNode.removeChild(node) 257
258 -def GetDateTime(xmlvalue):
259 return xmlvalue
260 #vals = xmlvalue.split('T') 261 #datestr = vals[0] 262 #timestr = vals[1] 263 #date = datestr.split('-') 264 #time = timestr.split(':') 265 #time[2]=time[2].rstrip('Z') 266 #return datetime(int(date[0]), int(date[1]), int(date[2]),int(time[0]), int(time[1]), int(float(time[2]))) 267
268 -def ToDateTime(val):
269 return val
270 #return '%s-%s-%sT%s:%s:%sZ'%(val.year,str(val.month).zfill(2),str(val.day).zfill(2), str(val.hour).zfill(2), str(val.minute).zfill(2),str(val.second).zfill(2)) 271
272 -def GetStringArrayFromNodes(xmlNodes):
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
282 -def GetListFromNodes(xmlNodes, cast=None):
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
328 -def AppendChilds(xmlNode, syntax, lst):
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 # TODO: Collada API: finish DaeDocument
342 -class DaeDocument(object):
343
344 - def __init__(self, debugM = False):
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 # create all the libraries 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 # Physics Support 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
377 - def LoadDocumentFromFile(self, filename):
378 global debugMode 379 # Build DOM tree 380 doc = parse( filename ) 381 382 # Get COLLADA element 383 colladaNode = doc.documentElement 384 385 # Get Attributes 386 self.version = colladaNode.getAttribute(DaeSyntax.VERSION) 387 #if not IsVersionOk(self.version, self.colladaVersion): 388 # Debug.Debug('The version of the file (%s) is older then the version supported by this plugin(%s).'%(self.version, self.colladaVersion),'ERROR') 389 # doc.unlink() 390 # return 391 self.xmlns = colladaNode.getAttribute(DaeSyntax.XMLNS) 392 393 # get the assets element 394 self.asset.LoadFromXml(self,FindElementByTagName(colladaNode,DaeSyntax.ASSET)) 395 396 # get the extra elements 397 self.extras = CreateObjectsFromXml(self,colladaNode,DaeSyntax.EXTRA,DaeExtra) 398 399 # parse all the libraries 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 # Get the sceneNodes 417 sceneNodes = colladaNode.getElementsByTagName(DaeSyntax.SCENE) 418 419 # Get the scene 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
432 - def SaveDocumentToFile(self, filename):
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 # add the labraries 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 # write xml to the file 460 fileref = open(filename, 'w') 461 fileref.write(ToXml(colladaNode)) 462 fileref.flush() 463 fileref.close() 464 colladaNode.unlink()
465
466 - def GetItemCount(self):
467 return (##self.animationClipsLibrary.GetItemCount()+ 468 ##self.animationsLibrary.GetItemCount()+ 469 ##self.camerasLibrary.GetItemCount()+ 470 ##self.controllersLibrary.GetItemCount()+ 471 ##self.effectsLibrary.GetItemCount()+ 472 self.geometriesLibrary.GetItemCount()+ 473 self.lightsLibrary.GetItemCount()+ 474 ##self.materialsLibrary.GetItemCount()+ 475 self.nodesLibrary.GetItemCount()##+ 476 ##self.visualScenesLibrary.GetItemCount() 477 )
478
479 - def __str__(self):
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
482 -class DaeEntity(object):
483 - def __init__(self):
484 self.syntax = 'UNKNOWN'
485
486 - def LoadFromXml(self, daeDocument, xmlNode):
487 Debug.Debug('DaeEntity: Override this method for %s'%(type(self)),'WARNING')
488
489 - def SaveToXml(self, daeDocument):
490 node = Element(self.syntax) 491 return node
492
493 - def GetType(self):
494 return self.syntax
495
496 -class DaeElement(DaeEntity):
497
498 - def __init__(self):
499 super(DaeElement,self).__init__() 500 501 self.id = '' 502 self.name = ''
503 504
505 - def LoadFromXml(self,daeDocument, xmlNode):
506 if xmlNode is None: 507 return 508 509 self.id = xmlNode.getAttribute(DaeSyntax.ID) 510 self.name = xmlNode.getAttribute(DaeSyntax.NAME)
511
512 - def SaveToXml(self, daeDocument):
513 node = super(DaeElement,self).SaveToXml(daeDocument) 514 SetAttribute(node,DaeSyntax.ID,StripString(self.id)) 515 SetAttribute(node,DaeSyntax.NAME, StripString(self.name)) 516 return node
517
518 - def __str__(self):
519 return super(DaeElement,self).__str__()+'id: %s, name: %s'%(self.id, self.name)
520 521 # TODO: Collada API: finish DaeLibrary
522 -class DaeLibrary(DaeElement):
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
535 - def LoadFromXml(self,daeDocument, xmlNode):
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
544 - def SaveToXml(self,daeDocument):
545 if len(self.items) > 0: 546 node = super(DaeLibrary,self).SaveToXml(daeDocument) 547 # Add the assets 548 AppendChild(daeDocument,node,self.asset) 549 # Add the library_items 550 AppendChilds(daeDocument,node,self.items) 551 # Add the extra's 552 AppendChilds(self,node,self.extras) 553 return node 554 else: 555 return None
556 - def GetItemCount(self):
557 return len(self.items)
558
559 - def FindObject(self,url):
560 for i in self.items: 561 if i.id == url: 562 return i 563 return None
564
565 - def AddItem(self,item):
566 self.items.append(item)
567
568 - def __str__(self):
569 return super(DaeLibrary,self).__str__() + 'extras: %s, asset: %s, items: %s'%(self.extras, self.asset, self.items)
570
571 -class DaeAsset(DaeEntity):
572 - def __init__(self):
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
586 - def LoadFromXml(self, daeDocument, xmlNode):
587 if xmlNode is None: 588 return 589 # Get the contributor(s) 590 self.contributors = CreateObjectsFromXml(daeDocument, xmlNode,DaeSyntax.CONTRIBUTOR,DaeContributor) 591 # Get created 592 self.created = ReadDateTime(FindElementByTagName(xmlNode,DaeSyntax.CREATED)) 593 # Get modified 594 self.modified = ReadDateTime(FindElementByTagName(xmlNode,DaeSyntax.MODIFIED)) 595 # Get revision 596 self.revision = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.REVISION)) 597 # Get title 598 self.title = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.TITLE)) 599 # Get subject 600 self.subject = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.SUBJECT)) 601 # Get keywords 602 self.keywords = GetStringArrayFromNodes(xmlNode.getElementsByTagName(DaeSyntax.KEYWORDS)) 603 # Get Unit 604 self.unit.LoadFromXml(daeDocument, FindElementByTagName(xmlNode, DaeSyntax.UNIT)) 605 # Get upAxis 606 self.upAxis = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.UP_AXIS))
607
608 - def SaveToXml(self, daeDocument):
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
624 - def __str__(self):
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 # TODO: Collada API: finish DaeScene
628 -class DaeScene(DaeEntity):
629 - def __init__(self):
630 super(DaeScene,self).__init__() 631 self.extras = [] 632 self.iVisualScenes = [] 633 self.iPhysicsScenes = [] 634 635 self.syntax = DaeSyntax.SCENE
636
637 - def LoadFromXml(self, daeDocument, xmlNode):
638 if xmlNode is None: 639 return 640 self.iVisualScenes = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INSTANCE_VISUAL_SCENE, DaeVisualSceneInstance) 641 self.iPhysicsScenes = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INSTANCE_PHYSICS_SCENE, DaePhysicsSceneInstance)
642
643 - def SaveToXml(self, daeDocument):
644 node = super(DaeScene,self).SaveToXml(daeDocument) 645 AppendChilds(daeDocument, node, self.iVisualScenes) 646 AppendChilds(daeDocument, node, self.iPhysicsScenes) 647 return node
648
649 - def GetVisualScenes(self):
650 result = [] 651 for i in self.iVisualScenes: 652 result.append(i.object) 653 return result
654
655 - def GetPhysicsScenes(self):
656 result = [] 657 for i in self.iPhysicsScenes: 658 result.append(i.object) 659 return result
660
661 - def __str__(self):
662 return super(DaeScene,self).__str__()+'extras: %s, visualScenes: %s, physicsScenes: %s'%(self.extras, self.iVisualScenes, self.iPhysicsScenes)
663 664
665 -class DaeUnit(DaeEntity):
666 - def __init__(self):
667 super(DaeUnit,self).__init__() 668 self.name = 'meter' 669 self.meter = 1.0 670 671 self.syntax = DaeSyntax.UNIT
672
673 - def LoadFromXml(self, daeDocument, xmlNode):
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
684 - def SaveToXml(self,daeDocument):
685 node = super(DaeUnit, self).SaveToXml(daeDocument) 686 SetAttribute(node, DaeSyntax.METER, self.meter) 687 SetAttribute(node, DaeSyntax.NAME, self.name) 688 return node
689
690 - def __str__(self):
691 return super(DaeUnit, self).__str__()+' name: %s, meter: %s'%(self.name, self.meter)
692
693 -class DaeContributor(DaeEntity):
694 - def __init__(self):
695 super(DaeContributor, self).__init__() 696 self.author = '' 697 self.authoringTool = '' 698 self.comments = '' 699 self.copyright = '' 700 self.sourceData = '' 701 702 self.syntax = DaeSyntax.CONTRIBUTOR
703
704 - def LoadFromXml(self, daeDocument, xmlNode):
705 self.author = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.AUTHOR)) 706 self.authoringTool = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.AUTHORING_TOOL)) 707 self.comments = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.COMMENTS)) 708 self.copyright = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.COPYRIGHT)) 709 self.sourceData = ReadContents(FindElementByTagName(xmlNode,DaeSyntax.SOURCE_DATA))
710
711 - def SaveToXml(self, daeDocument):
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
721 - def __str__(self):
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
724 -class DaeAnimation(DaeElement):
725 - def __init__(self):
726 super(DaeAnimation, self).__init__() 727 self.sources = [] 728 self.samplers = [] 729 self.channels = [] 730 self.syntax = DaeSyntax.ANIMATION
731
732 - def LoadFromXml(self, daeDocument, xmlNode):
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
738 - def SaveToXml(self, daeDocument):
739 node = super(DaeAnimation, self).SaveToXml(daeDocument) 740 AppendChilds(daeDocument, node, self.sources) 741 AppendChilds(daeDocument, node, self.samplers) 742 AppendChilds(daeDocument, node, self.channels) 743 return node
744
745 - def GetSource(self, sourceId):
746 for source in self.sources: 747 if source.id == sourceId: 748 return source 749 return None
750
751 -class DaeSampler(DaeEntity):
752 - def __init__(self):
753 self.syntax = DaeSyntax.SAMPLER 754 self.id = None 755 self.inputs = []
756
757 - def LoadFromXml(self, daeDocument, xmlNode):
758 self.id = ReadAttribute(xmlNode, DaeSyntax.ID) 759 self.inputs = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INPUT, DaeInput)
760
761 - def SaveToXml(self, daeDocument):
762 node = super(DaeSampler, self).SaveToXml(daeDocument) 763 AppendChilds(daeDocument, node, self.inputs) 764 SetAttribute(node, DaeSyntax.ID, StripString(self.id)) 765 return node
766
767 - def GetInput(self, semantic):
768 for input in self.inputs: 769 if input.semantic == semantic: 770 return input 771 return None
772
773 -class DaeChannel(DaeEntity):
774 - def __init__(self):
775 self.syntax = DaeSyntax.CHANNEL 776 self.source = None 777 self.target = None
778
779 - def LoadFromXml(self, daeDocument, xmlNode):
780 self.source = ReadAttribute(xmlNode, DaeSyntax.SOURCE) 781 self.target = ReadAttribute(xmlNode, DaeSyntax.TARGET)
782
783 - def SaveToXml(self, daeDocument):
784 node = super(DaeChannel, self).SaveToXml(daeDocument) 785 SetAttribute(node, DaeSyntax.SOURCE, StripString('#'+self.source.id)) 786 SetAttribute(node, DaeSyntax.TARGET, self.target) 787 return node
788
789 -class DaeAnimationClip(DaeElement):
790 pass
791 -class DaeCamera(DaeElement):
792 - def __init__(self):
793 super(DaeCamera,self).__init__() 794 self.asset = None 795 self.extras = [] 796 self.optics = DaeOptics() 797 self.imager = None 798 self.syntax = DaeSyntax.CAMERA
799
800 - def LoadFromXml(self, daeDocument, xmlNode):
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
808 - def SaveToXml(self, daeDocument):
809 node = super(DaeCamera, self).SaveToXml(daeDocument) 810 # Add the assets 811 AppendChild(daeDocument,node,self.asset) 812 # Add the optics 813 node.appendChild(self.optics.SaveToXml(daeDocument)) 814 # Add the imager 815 AppendChild(daeDocument,node,self.imager) 816 # Add the extra's 817 AppendChilds(self,node,self.extras) 818 return node
819
820 - def __str__(self):
821 return super(DaeCamera,self).__str__()+'asset: %s, optics: %s, imager: %s, extras: %s'%(self.asset, self.optics, self.imager, self.extras)
822
823 -class DaeController(DaeElement):
824 pass
825 -class DaeImage(DaeElement):
826 - def __init__(self):
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
835 - def LoadFromXml(self, daeDocument, xmlNode):
836 super(DaeImage, self).LoadFromXml(daeDocument, xmlNode) 837 self.format = ReadAttribute(xmlNode, DaeSyntax.FORMAT) 838 self.height = ReadAttribute(xmlNode, DaeSyntax.HEIGHT) 839 self.width = ReadAttribute(xmlNode, DaeSyntax.WIDTH) 840 self.depth = ReadAttribute(xmlNode, DaeSyntax.DEPTH) 841 self.initFrom = ReadContents(FindElementByTagName(xmlNode, DaeSyntax.INIT_FROM))
842
843 - def SaveToXml(self, daeDocument):
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 ##class DaeMaterial(DaeElement): 853 ## def __init__(self): 854 ## super(DaeMaterial,self).__init__() 855 ## self.asset = None 856 ## self.iEffects = [] 857 ## self.extras = None 858 ## self.syntax = DaeSyntax.MATERIAL 859 ## 860 ## def LoadFromXml(self, daeDocument, xmlNode): 861 ## super(DaeMaterial, self).LoadFromXml(daeDocument, xmlNode) 862 ## self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra) 863 ## self.asset = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.ASSET, DaeAsset) 864 ## self.iEffects = CreateObjectsFromXml(daeDocument,xmlNode, DaeSyntax.INSTANCE_EFFECT, DaeEffectInstance) 865 ## 866 ## def SaveToXml(self, daeDocument): 867 ## node = super(DaeMaterial, self).SaveToXml(daeDocument) 868 ## # Add the assets 869 ## AppendChild(daeDocument,node,self.asset) 870 ## # Add the effect instances 871 ## AppendChilds(daeDocument, node, self.iEffects) 872 ## # Add the extra's 873 ## AppendChilds(self,node,self.extras) 874 ## return node 875 ## 876 ## def __str__(self): 877 ## return super(DaeLight,self).__str__()+' assets: %s, data: %s, extras: %s'%(self.asset, self.data, self.extras) 878
879 -class DaeGeometry(DaeElement):
880 - def __init__(self):
881 super(DaeGeometry,self).__init__() 882 self.asset = None 883 self.data = None 884 self.extras = None 885 self.syntax = DaeSyntax.GEOMETRY
886
887 - def LoadFromXml(self, daeDocument, xmlNode):
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
898 - def SaveToXml(self, daeDocument):
899 node = super(DaeGeometry, self).SaveToXml(daeDocument) 900 # Add the assets 901 AppendChild(daeDocument,node,self.asset) 902 # Add the data 903 AppendChild(daeDocument, node, self.data) 904 # Add the extra's 905 AppendChilds(self,node,self.extras) 906 return node
907
908 - def __str__(self):
909 return super(DaeGeometry,self).__str__()+' assets: %s, data: %s, extras: %s'%(self.asset, self.data, self.extras)
910
911 -class DaeConvexMesh(DaeEntity):
912 - def __init__(self):
913 super(DaeConvexMesh, self).__init__() 914 self.syntax = DaeSyntax.CONVEX_MESH 915 self.convexHullOf = None
916
917 - def LoadFromXml(self, daeDocument, xmlNode):
918 self.convexHullOf = ReadAttribute(xmlNode, DaeSyntax.CONVEX_HULL_OF)
919
920 - def SaveToXml(self, daeDocument):
921 node = super(DaeConvexMesh, self).SaveToXml(daeDocument) 922 SetAttribute(node, DaeSyntax.CONVEX_HULL_OF, StripString(self.convexHullOf)) 923 return node
924
925 -class DaeMesh(DaeEntity):
926 - def __init__(self):
927 super(DaeMesh, self).__init__() 928 self.sources = [] 929 self.vertices = None 930 self.primitives = [] 931 self.extras = [] 932 self.syntax = DaeSyntax.MESH
933
934 - def LoadFromXml(self, daeDocument, xmlNode):
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
957 - def FindSource(self,input):
958 for s in self.sources: 959 if s.id == input.source: 960 return s 961 return None
962
963 - def SaveToXml(self, daeDocument):
964 node = super(DaeMesh, self).SaveToXml(daeDocument) 965 AppendChilds(daeDocument, node, self.sources) 966 AppendChild(daeDocument, node, self.vertices) 967 AppendChilds(daeDocument, node, self.primitives) 968 AppendChilds(daeDocument, node, self.extras) 969 return node
970 -class DaeVertices(DaeElement):
971 - def __init__(self):
972 super(DaeVertices,self).__init__() 973 self.inputs = [] 974 self.extras = [] 975 976 self.syntax = DaeSyntax.VERTICES
977
978 - def LoadFromXml(self, daeDocument, xmlNode):
979 super(DaeVertices,self).LoadFromXml(daeDocument, xmlNode) 980 self.inputs = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INPUT, DaeInput) 981 self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra)
982
983 - def SaveToXml(self, daeDocument):
984 node = super(DaeVertices, self).SaveToXml(daeDocument) 985 AppendChilds(daeDocument, node, self.inputs) 986 AppendChilds(daeDocument, node, self.extras) 987 return node
988
989 - def FindInput(self, semantic):
990 for i in self.inputs: 991 if i.semantic == semantic: 992 return i 993 return None
994
995 - def __str__(self):
996 return super(DaeVertices,self).__str__() + ' inputs: %s, extras: %s'%(self.inputs, self.extras)
997
998 -class DaeInput(DaeEntity):
999 - def __init__(self):
1000 super(DaeInput, self).__init__() 1001 self.offset = None 1002 self.semantic = '' 1003 self.source = '' 1004 self.set = '' 1005 self.syntax = DaeSyntax.INPUT
1006
1007 - def LoadFromXml(self, daeDocument, xmlNode):
1008 self.offset = CastAttributeFromXml(xmlNode, DaeSyntax.OFFSET, int) 1009 self.semantic = ReadAttribute(xmlNode, DaeSyntax.SEMANTIC) 1010 self.source = ReadAttribute(xmlNode, DaeSyntax.SOURCE)[1:] 1011 self.set = ReadAttribute(xmlNode, DaeSyntax.SET)
1012
1013 - def SaveToXml(self, daeDocument):
1014 node = super(DaeInput, self).SaveToXml(daeDocument) 1015 SetAttribute(node,DaeSyntax.OFFSET, self.offset) 1016 SetAttribute(node,DaeSyntax.SEMANTIC, self.semantic) 1017 SetAttribute(node,DaeSyntax.SOURCE, StripString('#'+self.source)) 1018 SetAttribute(node,DaeSyntax.SET, self.set) 1019 return node
1020
1021 -class DaeSource(DaeElement):
1022 - def __init__(self):
1023 super(DaeSource, self).__init__() 1024 self.source = DaeArray() 1025 self.vectors = [] 1026 self.techniqueCommon = None 1027 self.techniques = [] 1028 1029 self.syntax = DaeSyntax.SOURCE
1030
1031 - def LoadFromXml(self, daeDocument, xmlNode):
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
1057 - def SaveToXml(self, daeDocument):
1058 node = super(DaeSource, self).SaveToXml(daeDocument) 1059 ## if len(self.vectors) > 0: 1060 ## if type(self.vectors[0][0]) == float: 1061 ## self.source = DaeFloatArray() 1062 ## self.source.id = self.id+'-array' 1063 ## 1064 ## for i in range(len(self.vectors)): 1065 ## for j in range(len(self.vectors[i])): 1066 ## self.source.data.append(self.vectors[i][j]) 1067 1068 # Add the source 1069 AppendChild(daeDocument, node, self.source) 1070 # Add the technique common 1071 AppendChild(daeDocument,node,self.techniqueCommon) 1072 # Add the techniques 1073 AppendChilds(daeDocument, node, self.techniques) 1074 return node
1075
1076 - def __str__(self):
1077 return super(DaeSource,self).__str__()+' source: %s, techniqueCommon: %s, techniques: %s'%(self.source, self.techniqueCommon, self.techniques)
1078
1079 - class DaeTechniqueCommon(DaeEntity):
1080 - def __init__(self):
1081 self.accessor = None 1082 self.syntax = DaeSyntax.TECHNIQUE_COMMON
1083
1084 - def LoadFromXml(self, daeDocument, xmlNode):
1085 self.accessor = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.ACCESSOR, DaeAccessor)
1086
1087 - def SaveToXml(self, daeDocument):
1088 node = super(DaeSource.DaeTechniqueCommon,self).SaveToXml(daeDocument) 1089 AppendChild(daeDocument,node, self.accessor) 1090 return node
1091
1092 - def __str__(self):
1093 return super(DaeSource.DaeTechniqueCommon,self).__str__()+' accessor: %s'%(self.accessor)
1094
1095 -class DaeLight(DaeElement):
1096 - def __init__(self):
1097 super(DaeLight,self).__init__() 1098 self.asset = None 1099 self.techniqueCommon = DaeLight.DaeTechniqueCommon() 1100 self.techniques = [] 1101 self.extras = None 1102 self.syntax = DaeSyntax.LIGHT
1103
1104 - def LoadFromXml(self, daeDocument, xmlNode):
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 ##self.techniqueCommon.LoadFromXml(daeDocument, FindElementByTagName(xmlNode, DaeSyntax.TECHNIQUE_COMMON)) 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
1123 - def SaveToXml(self, daeDocument):
1124 node = super(DaeLight, self).SaveToXml(daeDocument) 1125 # Add the assets 1126 AppendChild(daeDocument,node,self.asset) 1127 # Add the technique common 1128 AppendChild(daeDocument,node,self.techniqueCommon) 1129 # Add the techniques 1130 AppendChilds(daeDocument, node, self.techniques) 1131 # Add the extra's 1132 AppendChilds(self,node,self.extras) 1133 return node
1134
1135 - def __str__(self):
1136 return super(DaeLight,self).__str__()+' techniqueCommon: %s, techniques: %s'%(self.techniqueCommon, self.techniques)
1137
1138 - class DaeTechniqueCommon(DaeEntity):
1139 - def __init__(self):
1140 self.color = [] 1141 self.lightSource = None 1142 self.syntax = DaeSyntax.TECHNIQUE_COMMON
1143
1144 - def LoadFromXml(self, daeDocument, xmlNode):
1146
1147 - def SaveToXml(self, daeDocument):
1148 node = Element(DaeSyntax.TECHNIQUE_COMMON) 1149 child = super(DaeLight.DaeTechniqueCommon,self).SaveToXml(daeDocument) 1150 AppendTextChild(child,DaeSyntax.COLOR, self.color) 1151 node.appendChild(child) 1152 return node
1153
1154 - def __str__(self):
1155 return super(DaeLight.DaeTechniqueCommon,self).__str__()+' color: %s'%(self.color)
1156
1157 - class DaeAmbient(DaeTechniqueCommon):
1158 - def __init__(self):
1159 super(DaeLight.DaeAmbient,self).__init__() 1160 self.syntax = DaeSyntax.AMBIENT
1161
1162 - def LoadFromXml(self, daeDocument, xmlNode):
1163 super(DaeLight.DaeAmbient,self).LoadFromXml(daeDocument, xmlNode)
1164
1165 - def SaveToXml(self, daeDocument):
1166 node = super(DaeLight.DaeAmbient,self).SaveToXml(daeDocument) 1167 return node
1168
1169 - def __str__(self):
1170 return super(DaeLight.DaeAmbient,self).__str__()
1171
1172 - class DaeSpot(DaeTechniqueCommon):
1173 - def __init__(self):
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
1188 - def LoadFromXml(self, daeDocument, xmlNode):
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
1196 - def SaveToXml(self, daeDocument):
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
1205 - def __str__(self):
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
1208 - class DaeDirectional(DaeTechniqueCommon):
1209 # default direction is [0,0,-1] pointing down the -Z axis. 1210 # To change the direction, change the transform of the parent DaeNode
1211 - def __init__(self):
1212 super(DaeLight.DaeDirectional,self).__init__() 1213 self.syntax = DaeSyntax.DIRECTIONAL
1214
1215 - def LoadFromXml(self, daeDocument, xmlNode):
1216 super(DaeLight.DaeDirectional,self).LoadFromXml(daeDocument, xmlNode)
1217
1218 - def SaveToXml(self, daeDocument):
1219 node = super(DaeLight.DaeDirectional,self).SaveToXml(daeDocument) 1220 return node
1221
1222 - def __str__(self):
1223 return super(DaeLight.DaeDirectional,self).__str__()
1224
1225 - class DaePoint(DaeTechniqueCommon):
1226 - def __init__(self):
1227 super(DaeLight.DaePoint,self).__init__() 1228 self.constantAttenuation = 0.0 1229 self.linearAttenuation = 0.0 1230 self.quadraticAttenuation = 0.0 1231 self.syntax = DaeSyntax.POINT
1232
1233 - def LoadFromXml(self, daeDocument, xmlNode):
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
1239 - def SaveToXml(self, daeDocument):
1240 node = super(DaeLight.DaePoint,self).SaveToXml(daeDocument) 1241 AppendTextChild(node.firstChild,DaeSyntax.CONSTANT_ATTENUATION, self.constantAttenuation) 1242 AppendTextChild(node.firstChild,DaeSyntax.LINEAR_ATTENUATION, self.linearAttenuation) 1243 AppendTextChild(node.firstChild,DaeSyntax.QUADRATIC_ATTENUATION, self.quadraticAttenuation) 1244 return node
1245
1246 - def __str__(self):
1247 return super(DaeLight.DaePoint,self).__str__()+' const.att: %s, lin.att: %s, quad.att: %s'%(self.constantAttenuation, self.linearAttenuation, self.quadraticAttenuation)
1248
1249 -class DaeVisualScene(DaeElement):
1250 - def __init__(self):
1251 super(DaeVisualScene,self).__init__() 1252 self.asset = None 1253 self.extras = None 1254 self.nodes = [] 1255 self.syntax = DaeSyntax.VISUAL_SCENE
1256
1257 - def LoadFromXml(self, daeDocument, xmlNode):
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
1263 - def SaveToXml(self, daeDocument):
1264 node = super(DaeVisualScene, self).SaveToXml(daeDocument) 1265 # Add the assets 1266 AppendChild(daeDocument,node,self.asset) 1267 # Add the nodes 1268 AppendChilds(daeDocument, node, self.nodes) 1269 # Add the extra's 1270 AppendChilds(self,node,self.extras) 1271 return node
1272
1273 - def FindNode(self, nodeUrl):
1274 for n in self.nodes: 1275 if n.id == nodeUrl: 1276 return n 1277 return None
1278 1279
1280 - def __str__(self):
1281 return super(DaeVisualScene,self).__str__()+' asset: %s, nodes: %s, extras: %s'%(self.asset, self.nodes, self.extras)
1282
1283 -class DaeNode(DaeElement):
1284 1285 NODE = 2 1286 JOINT = 1 1287
1288 - def __init__(self):
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
1306 - def LoadFromXml(self, daeDocument, xmlNode):
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 # Get transforms 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 # Get the instances 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 # Get childs nodes 1347 self.nodes = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.NODE, DaeNode)
1348
1349 - def SaveToXml(self, daeDocument):
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 # Add the layers 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 ##AppendTextChild(node,i[0],val,"1.0 1.0 1.0") 1369 SetAttribute(AppendTextChild(node,i[0],val,None), DaeSyntax.SID, DaeSyntax.SCALE) 1370 elif i[0] == DaeSyntax.TRANSLATE: 1371 ##AppendTextChild(node,i[0],val,"0.0 0.0 0.0") 1372 SetAttribute(AppendTextChild(node,i[0],val,None), DaeSyntax.SID, DaeSyntax.TRANSLATE) 1373 elif i[0] == DaeSyntax.ROTATE: 1374 ##AppendTextChild(node,i[0],val,"0.0 0.0 0.0 0.0") 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
1403 - def IsJoint(self):
1404 return self.type == DaeNode.JOINT
1405
1406 - def GetType(type):
1407 if type == DaeNode.JOINT: 1408 return DaeSyntax.TYPE_JOINT 1409 else: 1410 return DaeSyntax.TYPE_NODE
1411 GetType = staticmethod(GetType) 1412
1413 - def GetInstances(self):
1414 return []+self.iAnimations+self.iCameras+self.iControllers+self.iGeometries+self.iLights+self.iNodes
1415 1416 1417 1418 # TODO: Collada API: finish DaeTechnique
1419 -class DaeTechnique(DaeEntity):
1420 - def __init__(self):
1421 super(DaeTechnique,self).__init__() 1422 self.profile = '' 1423 self.xmlns = '' 1424 self.syntax = DaeSyntax.TECHNIQUE
1425
1426 - def LoadFromXml(self, daeDocument, xmlNode):
1427 self.profile = xmlNode.getAttribute(DaeSyntax.PROFILE) 1428 self.xmlns = xmlNode.getAttribute(DaeSyntax.XMLNS)
1429
1430 - def SaveToXml(self, daeDocument):
1431 node = super(DaeTechnique,self).SaveToXml(daeDocument) 1432 node.setAttribute(DaeSyntax.PROFILE, self.profile) 1433 SetAttribute(node, DaeSyntax.XMLNS, self.xmlns) 1434 return node
1435
1436 -class DaeOptics(DaeEntity):
1437 - def __init__(self):
1438 super(DaeOptics,self).__init__() 1439 self.techniqueCommon = DaeOptics.DaeTechniqueCommon() 1440 self.techniques = [] 1441 self.extras = None 1442 self.syntax = DaeSyntax.OPTICS
1443
1444 - def LoadFromXml(self, daeDocument, xmlNode):
1445 self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra) 1446 #self.techniqueCommon.LoadFromXml(daeDocument, FindElementByTagName(xmlNode, DaeSyntax.TECHNIQUE_COMMON)) 1447 self.techniques = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.TECHNIQUE,DaeTechnique) 1448 1449 opticsSourceNode = RemoveWhiteSpaceNode(FindElementByTagName(xmlNode, DaeSyntax.TECHNIQUE_COMMON)).firstChild 1450 opticsSourceName = opticsSourceNode.localName 1451 if opticsSourceName == DaeSyntax.PERSPECTIVE: 1452 self.techniqueCommon = DaeOptics.DaePerspective() 1453 elif opticsSourceName == DaeSyntax.ORTHOGRAPHIC: 1454 self.techniqueCommon = DaeOptics.DaeOrthoGraphic() 1455 self.techniqueCommon.LoadFromXml(daeDocument,opticsSourceNode)
1456
1457 - def SaveToXml(self, daeDocument):
1458 node = super(DaeOptics, self).SaveToXml(daeDocument) 1459 # Add the technique common 1460 AppendChild(daeDocument,node,self.techniqueCommon) 1461 # Add the techniques 1462 AppendChilds(daeDocument, node, self.techniques) 1463 # Add the extra's 1464 AppendChilds(self,node,self.extras) 1465 return node
1466
1467 - def __str__(self):
1468 return super(DaeOptics,self).__str__()+' extras: %s, techniqueCommon: %s, techniques: %s'%(self.extras, self.techniqueCommon, self.techniques)
1469
1470 - class DaeTechniqueCommon(DaeEntity):
1471 - def __init__(self):
1472 self.znear = 0.0 1473 self.zfar = 0.0 1474 self.aspectRatio = None 1475 1476 self.syntax = DaeSyntax.TECHNIQUE_COMMON
1477
1478 - def LoadFromXml(self, daeDocument, xmlNode):
1482
1483 - def SaveToXml(self, daeDocument):
1484 node = Element(DaeSyntax.TECHNIQUE_COMMON) 1485 child = super(DaeOptics.DaeTechniqueCommon,self).SaveToXml(daeDocument) 1486 ## AppendTextChild(child,DaeSyntax.ZNEAR, self.znear) 1487 ## AppendTextChild(child,DaeSyntax.ZFAR, self.zfar) 1488 ## AppendTextChild(child,DaeSyntax.ASPECT_RATIO, self.aspectRatio) 1489 node.appendChild(child) 1490 return node
1491
1492 - def SavePropertiesToXml(self, daeDocument, node):
1493 AppendTextChild(node,DaeSyntax.ZNEAR, self.znear) 1494 AppendTextChild(node,DaeSyntax.ZFAR, self.zfar) 1495 AppendTextChild(node,DaeSyntax.ASPECT_RATIO, self.aspectRatio)
1496
1497 - def __str__(self):
1498 return super(DaeOptics.DaeTechniqueCommon,self).__str__()+' znear: %s, zfar: %s, aspectRatio: %s'%(self.znear, self.zfar, self.aspectRatio)
1499
1500 - class DaePerspective(DaeTechniqueCommon):
1501 - def __init__(self):
1502 super(DaeOptics.DaePerspective,self).__init__() 1503 self.xfov = None 1504 self.yfov = None 1505 self.syntax = DaeSyntax.PERSPECTIVE
1506
1507 - def LoadFromXml(self, daeDocument, xmlNode):
1508 super(DaeOptics.DaePerspective,self).LoadFromXml(daeDocument, xmlNode) 1509 self.xfov = ToFloat(ReadContents(FindElementByTagName(xmlNode,DaeSyntax.XFOV))) 1510 self.yfov = ToFloat(ReadContents(FindElementByTagName(xmlNode,DaeSyntax.YFOV)))
1511
1512 - def SaveToXml(self, daeDocument):
1513 node = super(DaeOptics.DaePerspective,self).SaveToXml(daeDocument) 1514 AppendTextChild(node.firstChild,DaeSyntax.XFOV, self.xfov) 1515 AppendTextChild(node.firstChild,DaeSyntax.YFOV, self.yfov) 1516 super(DaeOptics.DaePerspective,self).SavePropertiesToXml(daeDocument, node.firstChild) 1517 return node
1518
1519 - def __str__(self):
1520 return super(DaeOptics.DaePerspective,self).__str__()+' xfov: %s, yfov: %s'%(self.xfov, self.yfov)
1521
1522 - class DaeOrthoGraphic(DaeTechniqueCommon):
1523 - def __init__(self):
1524 super(DaeOptics.DaeOrthoGraphic,self).__init__() 1525 self.xmag = None 1526 self.ymag = None 1527 self.syntax = DaeSyntax.ORTHOGRAPHIC
1528
1529 - def LoadFromXml(self, daeDocument, xmlNode):
1530 super(DaeOptics.DaeOrthoGraphic,self).LoadFromXml(daeDocument, xmlNode) 1531 self.xmag = ToFloat(ReadContents(FindElementByTagName(xmlNode,DaeSyntax.XMAG))) 1532 self.ymag = ToFloat(ReadContents(FindElementByTagName(xmlNode,DaeSyntax.YMAG)))
1533
1534 - def SaveToXml(self, daeDocument):
1535 node = super(DaeOptics.DaeOrthoGraphic,self).SaveToXml(daeDocument) 1536 AppendTextChild(node.firstChild,DaeSyntax.XMAG, self.xmag) 1537 AppendTextChild(node.firstChild,DaeSyntax.YMAG, self.ymag) 1538 return node
1539
1540 - def __str__(self):
1541 return super(DaeOptics.DaeOrthoGraphic,self).__str__()+ 'xmag: %s, ymag: %s'%(self.xmag, self.ymag)
1542
1543 -class DaeImager(DaeEntity):
1544 - def __init__(self):
1545 super(DaeImager,self).__init__() 1546 self.techniques = [] 1547 self.extras = None 1548 self.syntax = DaeSyntax.IMAGER
1549
1550 - def LoadFromXml(self, daeDocument, xmlNode):
1551 super(DaeImager, self).LoadFromXml(daeDocument, xmlNode) 1552 self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra) 1553 self.techniques = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.TECHNIQUE,DaeTechnique)
1554
1555 - def SaveToXml(self, daeDocument):
1556 node = super(DaeOptics, self).SaveToXml(daeDocument) 1557 # Add the techniques 1558 AppendChilds(daeDocument, node, self.techniques) 1559 # Add the extra's 1560 AppendChilds(self,node,self.extras) 1561 return node
1562
1563 - def __str__(self):
1564 return super(DaeImager,self).__str__()+' extras: %s, techniques: %s'%(self.techniqueCommon, self.techniques)
1565 1566
1567 -class DaeExtra(DaeEntity):
1568 - def __init__(self):
1569 super(DaeExtra,self).__init__() 1570 self.type = None 1571 self.techniques = [] 1572 self.syntax = DaeSyntax.EXTRA
1573
1574 - def LoadFromXml(self, daeDocument, xmlNode):
1575 self.type = xmlNode.getAttribute(DaeSyntax.TYPE) 1576 self.techniques = CreateObjectsFromXml(daeDocument, xmlNode,DaeSyntax.TECHNIQUE,DaeTechnique)
1577
1578 - def SaveToXml(self, daeDocument):
1579 node = super(DaeExtra,self).SaveToXml(daeDocument) 1580 AppendChilds(daeDocument, node, self.techniques) 1581 return node
1582 1583
1584 - def __str__(self):
1585 return super(DaeExtra,self).__str__()+'techniques: %s'%(self.techniques)
1586
1587 -class DaeAccessor(DaeEntity):
1588 - def __init__(self):
1589 super(DaeAccessor,self).__init__() 1590 self.count = 0 1591 self.offset = None 1592 self.source = '' 1593 self.__stride = None 1594 ## self.stride = property(self.GetStride) 1595 self.params = [] 1596 1597 self.syntax = DaeSyntax.ACCESSOR
1598
1599 - def LoadFromXml(self,daeDocument, xmlNode):
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
1606 - def SaveToXml(self, daeDocument):
1607 node = super(DaeAccessor,self).SaveToXml(daeDocument) 1608 node.setAttribute(DaeSyntax.COUNT, str(self.count)) 1609 SetAttribute(node,DaeSyntax.OFFSET, self.offset) 1610 node.setAttribute(DaeSyntax.SOURCE, StripString('#'+self.source)) 1611 SetAttribute(node, DaeSyntax.STRIDE, self.stride) 1612 AppendChilds(daeDocument, node, self.params) 1613 return node
1614
1615 - def AddParam(self, name, type):
1616 param = DaeParam() 1617 param.name = name 1618 param.type = type 1619 self.params.append(param)
1620
1621 - def GetStride(self):
1622 if self.__stride is None: 1623 return len(self.params) 1624 else: 1625 return self.__stride
1626
1627 - def SetStride(self, val):
1628 self.__stride = val
1629
1630 - def HasParam(self, paramName):
1631 return paramName in [param.name for param in self.params]
1632 1633 1634 stride = property(GetStride, SetStride)
1635
1636 -class DaeParam(DaeEntity):
1637 - def __init__(self):
1638 super(DaeParam,self).__init__() 1639 self.name = None 1640 self.semantic = None 1641 self.sid = None 1642 self.type = '' 1643 self.syntax = DaeSyntax.PARAM
1644
1645 - def LoadFromXml(self, daeDocument, xmlNode):
1646 self.semantic = ReadAttribute(xmlNode, DaeSyntax.SEMANTIC) 1647 self.sid = ReadAttribute(xmlNode, DaeSyntax.SID) 1648 self.name = ReadAttribute(xmlNode, DaeSyntax.NAME) 1649 self.type = xmlNode.getAttribute(DaeSyntax.TYPE)
1650
1651 - def SaveToXml(self, daeDocument):
1652 node = super(DaeParam,self).SaveToXml(daeDocument) 1653 SetAttribute(node, DaeSyntax.SEMANTIC, self.semantic) 1654 SetAttribute(node, DaeSyntax.SID, self.sid) 1655 SetAttribute(node, DaeSyntax.NAME, self.name) 1656 node.setAttribute(DaeSyntax.TYPE, self.type) 1657 return node
1658
1659 -class DaeArray(DaeElement):
1660 - def __init__(self):
1661 super(DaeArray, self).__init__() 1662 self.count = 0 1663 self.data = []
1664
1665 - def LoadFromXml(self, daeDocument, xmlNode):
1666 super(DaeArray, self).LoadFromXml(daeDocument, xmlNode) 1667 self.count = ToInt(ReadAttribute(xmlNode, DaeSyntax.COUNT)) 1668 self.data = ToList(ReadContents(xmlNode))
1669
1670 - def SaveToXml(self, daeDocument):
1671 node = super(DaeArray,self).SaveToXml(daeDocument) 1672 SetAttribute(node, DaeSyntax.COUNT, len(self.data)) 1673 AppendTextInChild(node, self.data) 1674 return node
1675
1676 - def __str__(self):
1677 return super(DaeArray,self).__str__()+' count: %s'%(self.count)
1678 1679
1680 -class DaeFloatArray(DaeArray):
1681 - def __init__(self):
1682 super(DaeFloatArray, self).__init__() 1683 self.syntax = DaeSyntax.FLOAT_ARRAY
1684
1685 - def LoadFromXml(self, daeDocument, xmlNode):
1686 super(DaeFloatArray, self).LoadFromXml(daeDocument, xmlNode) 1687 self.data = ToFloatList(self.data)
1688 1689
1690 -class DaeIntArray(DaeArray):
1691 - def __init__(self):
1692 super(DaeIntArray, self).__init__() 1693 self.syntax = DaeSyntax.INT_ARRAY
1694
1695 - def LoadFromXml(self, daeDocument, xmlNode):
1696 super(DaeIntArray, self).LoadFromXml(daeDocument, xmlNode) 1697 self.data = ToIntList(self.data)
1698
1699 -class DaeBoolArray(DaeArray):
1700 - def __init__(self):
1701 super(DaeBoolArray, self).__init__() 1702 self.syntax = DaeSyntax.BOOL_ARRAY
1703
1704 - def LoadFromXml(self, daeDocument, xmlNode):
1705 super(DaeBoolArray, self).LoadFromXml(daeDocument, xmlNode) 1706 self.data = ToBoolList(self.data)
1707
1708 -class DaeNameArray(DaeArray):
1709 - def __init__(self):
1710 super(DaeNameArray, self).__init__() 1711 self.syntax = DaeSyntax.NAME_ARRAY
1712
1713 - def LoadFromXml(self, daeDocument, xmlNode):
1714 super(DaeNameArray, self).LoadFromXml(daeDocument, xmlNode)
1715 ##self.data = ToFloatList(self.data) 1716
1717 -class DaeIDREFArray(DaeArray):
1718 - def __init__(self):
1719 super(DaeIDREFArray, self).__init__() 1720 self.syntax = DaeSyntax.IDREF_ARRAY
1721
1722 - def LoadFromXml(self, daeDocument, xmlNode):
1723 super(DaeIDREFArray, self).LoadFromXml(daeDocument, xmlNode)
1724 ##self.data = ToFloatList(self.data) 1725 1726 1727 #---Primitive Classes---
1728 -class DaePrimitive(DaeEntity):
1729 - def __init__(self):
1730 super(DaePrimitive, self).__init__() 1731 self.name = None 1732 self.count = 0 1733 self.material = '' 1734 self.inputs = []
1735
1736 - def LoadFromXml(self, daeDocument, xmlNode):
1737 self.name = ReadAttribute(xmlNode, DaeSyntax.NAME) 1738 self.count = int(ReadAttribute(xmlNode, DaeSyntax.COUNT)) 1739 self.material = ReadAttribute(xmlNode, DaeSyntax.MATERIAL)
1740
1741 - def SaveToXml(self, daeDocument):
1742 node = super(DaePrimitive, self).SaveToXml(daeDocument) 1743 SetAttribute(node, DaeSyntax.NAME, self.name) 1744 SetAttribute(node, DaeSyntax.MATERIAL, StripString(self.material)) 1745 node.setAttribute(DaeSyntax.COUNT, str(self.count)) 1746 return node
1747
1748 - def GetMaxOffset(self):
1749 if self.inputs != []: 1750 return max([i.offset for i in self.inputs]) 1751 else: 1752 return None
1753
1754 - def FindInput(self, semantic):
1755 for i in self.inputs: 1756 if i.semantic == semantic: 1757 return i 1758 return None
1759
1760 -class DaeLines(DaePrimitive):
1761 - def __init__(self):
1762 super(DaeLines, self).__init__() 1763 self.syntax = DaeSyntax.LINES 1764 self.lines = []
1765
1766 - def LoadFromXml(self, daeDocument, xmlNode):
1767 super(DaeLines,self).LoadFromXml(daeDocument, xmlNode) 1768 self.syntax = DaeSyntax.LINES 1769 self.inputs = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INPUT, DaeInput) 1770 self.lines = ToIntList(ReadContents(FindElementByTagName(xmlNode,DaeSyntax.P)))
1771
1772 - def SaveToXml(self, daeDocument):
1773 node = super(DaeLines,self).SaveToXml(daeDocument) 1774 AppendChilds(daeDocument, node, self.inputs) 1775 AppendTextChild(node, DaeSyntax.P, self.lines) 1776 return node
1777
1778 -class DaeLineStrips(DaePrimitive):
1779 - def __init__(self):
1780 super(DaeLineStrips, self).__init__() 1781 self.syntax = DaeSyntax.LINESTRIPS
1782
1783 - def LoadFromXml(self, daeDocument, xmlNode):
1784 super(DaeLineStrips,self).LoadFromXml(daeDocument, xmlNode)
1785 1786 1787
1788 -class DaePolygons(DaePrimitive):
1789 - def __init__(self):
1790 super(DaePolygons, self).__init__() 1791 self.syntax = DaeSyntax.POLYGONS 1792 self.polygons = [] 1793 self.holedPolygons = []
1794
1795 - def LoadFromXml(self, daeDocument, xmlNode):
1796 super(DaePolygons,self).LoadFromXml(daeDocument, xmlNode) 1797 self.polygons = GetListFromNodes(xmlNode.getElementsByTagName(DaeSyntax.P), int) 1798 self.inputs = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INPUT, DaeInput)
1799
1800 - def SaveToXml(self, daeDocument):
1801 node = super(DaePolygons,self).SaveToXml(daeDocument) 1802 AppendChilds(daeDocument, node, self.inputs) 1803 AppendChilds(node, DaeSyntax.P, self.polygons) 1804 return node
1805
1806 -class DaePolylist(DaePrimitive):
1807 - def __init__(self):
1808 super(DaePolylist, self).__init__() 1809 self.syntax = DaeSyntax.POLYLIST
1810
1811 - def LoadFromXml(self, daeDocument, xmlNode):
1812 super(DaePolylist,self).LoadFromXml(daeDocument, xmlNode)
1813
1814 -class DaeTriangles(DaePrimitive):
1815 - def __init__(self):
1816 super(DaeTriangles, self).__init__() 1817 self.triangles = [] 1818 self.syntax = DaeSyntax.TRIANGLES
1819
1820 - def LoadFromXml(self, daeDocument, xmlNode):
1821 super(DaeTriangles,self).LoadFromXml(daeDocument, xmlNode) 1822 self.triangles = ToIntList(ReadContents(FindElementByTagName(xmlNode,DaeSyntax.P))) 1823 self.inputs = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INPUT, DaeInput)
1824
1825 - def SaveToXml(self, daeDocument):
1826 node = super(DaeTriangles,self).SaveToXml(daeDocument) 1827 AppendChilds(daeDocument, node, self.inputs) 1828 AppendTextChild(node, DaeSyntax.P, self.triangles) 1829 return node
1830
1831 -class DaeTriFans(DaePrimitive):
1832 - def __init__(self):
1833 super(DaeTriFans, self).__init__() 1834 self.syntax = DaeSyntax.TRIFANS
1835
1836 - def LoadFromXml(self, daeDocument, xmlNode):
1837 super(DaeTriFans,self).LoadFromXml(daeDocument, xmlNode)
1838
1839 -class DaeTriStrips(DaePrimitive):
1840 - def __init__(self):
1841 super(DaeTriStrips, self).__init__() 1842 self.syntax = DaeSyntax.TRISTRIPS
1843
1844 - def LoadFromXml(self, daeDocument, xmlNode):
1845 super(DaeTriStrips,self).LoadFromXml(daeDocument, xmlNode)
1846 #---instance Classes---
1847 -class DaeInstance(DaeEntity):
1848 - def __init__(self):
1849 super(DaeInstance, self).__init__() 1850 self.url = '' 1851 self.extras = [] 1852 self.object = None
1853
1854 - def LoadFromXml(self, daeDocument, xmlNode):
1855 self.url = ReadNodeUrl(xmlNode) 1856 self.extras = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.EXTRA, DaeExtra)
1857
1858 - def SaveToXml(self, daeDocument):
1859 node = super(DaeInstance,self).SaveToXml(daeDocument) 1860 AppendChilds(daeDocument, node, self.extras) 1861 WriteNodeUrl(node, self.object.id) 1862 return node
1863
1864 -class DaeAnimationInstance(DaeInstance):
1865 - def __init__(self):
1866 super(DaeAnimationInstance, self).__init__() 1867 self.syntax = DaeSyntax.INSTANCE_ANIMATION
1868
1869 - def LoadFromXml(self, daeDocument, xmlNode):
1870 super(DaeAnimationInstance,self).LoadFromXml(daeDocument, xmlNode) 1871 self.object = daeDocument.animationsLibrary.FindObject(self.url)
1872
1873 - def SaveToXml(self, daeDocument):
1874 node = super(DaeAnimationInstance,self).SaveToXml(daeDocument) 1875 return node
1876
1877 -class DaeCameraInstance(DaeInstance):
1878 - def __init__(self):
1879 super(DaeCameraInstance, self).__init__() 1880 self.syntax = DaeSyntax.INSTANCE_CAMERA
1881
1882 - def LoadFromXml(self, daeDocument, xmlNode):
1883 super(DaeCameraInstance,self).LoadFromXml(daeDocument, xmlNode) 1884 self.object = daeDocument.camerasLibrary.FindObject(self.url)
1885
1886 - def SaveToXml(self, daeDocument):
1887 node = super(DaeCameraInstance,self).SaveToXml(daeDocument) 1888 return node
1889
1890 -class DaeControllerInstance(DaeInstance):
1891 - def __init__(self):
1892 super(DaeControllerInstance, self).__init__() 1893 self.skeletons = [] 1894 self.bindMaterials = [] 1895 self.syntax = DaeSyntax.INSTANCE_CONTROLLER
1896
1897 - def LoadFromXml(self, daeDocument, xmlNode):
1898 super(DaeControllerInstance,self).LoadFromXml(daeDocument, xmlNode) 1899 self.skeletons = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.SKELETON, DaeSkeleton) 1900 self.bindMaterials = CreateObjectsFromXml(daeDocument, xmlNode, DaeFxSyntax.BIND_MATERIAL, DaeFxBindMaterial) 1901 self.object = daeDocument.controllersLibrary.FindObject(self.url)
1902
1903 - def SaveToXml(self, daeDocument):
1904 node = super(DaeControllerInstance,self).SaveToXml(daeDocument) 1905 AppendChilds(daeDocument, node, self.skeletons) 1906 AppendChilds(daeDocument, node, self.bindMaterials) 1907 return node
1908 1909 # TODO: Collada API: finish DaeEffectInstance
1910 -class DaeEffectInstance(DaeInstance):
1911 - def __init__(self):
1912 super(DaeEffectInstance, self).__init__() 1913 1914 self.syntax = DaeSyntax.INSTANCE_EFFECT
1915
1916 - def LoadFromXml(self, daeDocument, xmlNode):
1917 super(DaeEffectInstance,self).LoadFromXml(daeDocument, xmlNode) 1918 self.object = daeDocument.effectsLibrary.FindObject(self.url)
1919
1920 - def SaveToXml(self, daeDocument):
1921 node = super(DaeEffectInstance,self).SaveToXml(daeDocument) 1922 return node
1923
1924 -class DaeGeometryInstance(DaeInstance):
1925 - def __init__(self):
1926 super(DaeGeometryInstance, self).__init__() 1927 self.bindMaterials = [] 1928 self.syntax = DaeSyntax.INSTANCE_GEOMETRY
1929
1930 - def LoadFromXml(self, daeDocument, xmlNode):
1931 super(DaeGeometryInstance,self).LoadFromXml(daeDocument, xmlNode) 1932 self.bindMaterials = CreateObjectsFromXml(daeDocument, xmlNode, DaeFxSyntax.BIND_MATERIAL, DaeFxBindMaterial) 1933 self.object = daeDocument.geometriesLibrary.FindObject(self.url)
1934
1935 - def SaveToXml(self, daeDocument):
1936 node = super(DaeGeometryInstance,self).SaveToXml(daeDocument) 1937 AppendChilds(daeDocument, node, self.bindMaterials) 1938 return node
1939
1940 -class DaeLightInstance(DaeInstance):
1941 - def __init__(self):
1942 super(DaeLightInstance, self).__init__() 1943 self.syntax = DaeSyntax.INSTANCE_LIGHT
1944
1945 - def LoadFromXml(self, daeDocument, xmlNode):
1946 super(DaeLightInstance,self).LoadFromXml(daeDocument, xmlNode) 1947 self.object = daeDocument.lightsLibrary.FindObject(self.url)
1948
1949 - def SaveToXml(self, daeDocument):
1950 node = super(DaeLightInstance,self).SaveToXml(daeDocument) 1951 return node
1952
1953 -class DaeNodeInstance(DaeInstance):
1954 - def __init__(self):
1955 super(DaeNodeInstance, self).__init__() 1956 self.syntax = DaeSyntax.INSTANCE_NODE
1957
1958 - def LoadFromXml(self, daeDocument, xmlNode):
1959 super(DaeNodeInstance,self).LoadFromXml(daeDocument, xmlNode) 1960 self.object = daeDocument.nodesLibrary.FindObject(self.url)
1961
1962 - def SaveToXml(self, daeDocument):
1963 node = super(DaeNodeInstance,self).SaveToXml(daeDocument) 1964 return node
1965
1966 -class DaeVisualSceneInstance(DaeInstance):
1967 - def __init__(self):
1968 super(DaeVisualSceneInstance, self).__init__() 1969 self.syntax = DaeSyntax.INSTANCE_VISUAL_SCENE
1970
1971 - def LoadFromXml(self, daeDocument, xmlNode):
1972 super(DaeVisualSceneInstance,self).LoadFromXml(daeDocument, xmlNode) 1973 self.object = daeDocument.visualScenesLibrary.FindObject(self.url)
1974
1975 - def SaveToXml(self, daeDocument):
1976 node = super(DaeVisualSceneInstance,self).SaveToXml(daeDocument) 1977 return node
1978 1979
1980 -class DaeSkeleton(DaeEntity):
1981 - def __init__(self):
1982 super(DaeSkeleton,self).__init__() 1983 self.iControllers = []
1984
1985 - def LoadFromXml(self, daeDocument, xmlNode):
1986 self.iControllers = CreateObjectsFromXml(daeDocument, xmlNode, DaeSyntax.INSTANCE_CONTROLLER, DaeControllerInstance)
1987
1988 - def SaveToXml(self, daeDocument):
1989 node = super(DaeSkeleton, self).SaveToXml(daeDocument) 1990 AppendChilds(daeDocument, node, self.iControllers) 1991 return node
1992 1993
1994 -class DaeSyntax(object):
1995 1996 #---collada--- 1997 COLLADA = 'COLLADA' 1998 VERSION = 'version' 1999 XMLNS = 'xmlns' 2000 2001 BODY = 'body' 2002 TARGET = 'target' 2003 2004 ASSET = 'asset' 2005 2006 ID = 'id' 2007 NAME = 'name' 2008 URL = 'url' 2009 2010 COUNT = 'count' 2011 OFFSET = 'offset' 2012 STRIDE = 'stride' 2013 2014 METER = 'meter' 2015 SID = 'sid' 2016 SEMANTIC = 'semantic' 2017 PARAM = 'param' 2018 2019 PROFILE = 'profile' 2020 TECHNIQUE = 'technique' 2021 TECHNIQUE_COMMON = 'technique_common' 2022 2023 ##BIND_MATERIAL = 'bind_material' 2024 SKELETON = 'skeleton' 2025 2026 P = 'p' 2027 PH = 'ph' 2028 H = 'h' 2029 2030 2031 INPUT = 'input' 2032 SET = 'set' 2033 2034 #---light--- 2035 COLOR = 'color' 2036 AMBIENT = 'ambient' 2037 SPOT = 'spot' 2038 DIRECTIONAL = 'directional' 2039 POINT = 'point' 2040 2041 CONSTANT_ATTENUATION = 'constant_attenuation' 2042 LINEAR_ATTENUATION = 'linear_attenuation' 2043 QUADRATIC_ATTENUATION = 'quadratic_attenuation' 2044 2045 FALLOFF_ANGLE = 'falloff_angle' 2046 FALLOFF_EXPONENT = 'falloff_exponent' 2047 2048 #---camera-- 2049 OPTICS = 'optics' 2050 PERSPECTIVE = 'perspective' 2051 ORTHOGRAPHIC = 'orthographic' 2052 IMAGER = 'imager' 2053 ZNEAR = 'znear' 2054 ZFAR = 'zfar' 2055 XFOV = 'xfov' 2056 YFOV = 'yfov' 2057 XMAG = 'xmag' 2058 YMAG ='ymag' 2059 ASPECT_RATIO = 'aspect_ratio' 2060 2061 #---geometry--- 2062 MESH = 'mesh' 2063 CONVEX_MESH ='convex_mesh' 2064 SPLINE = 'spline' 2065 SOURCE ='source' 2066 VERTICES = 'vertices' 2067 ACCESSOR = 'accessor' 2068 2069 CONVEX_HULL_OF = 'convex_hull_of' 2070 2071 #---primitives--- 2072 LINES = 'lines' 2073 LINESTRIPS = 'linestrips' 2074 POLYGONS = 'polygons' 2075 POLYLIST = 'polylist' 2076 TRIANGLES = 'triangles' 2077 TRIFANS = 'trifans' 2078 TRISTRIPS = 'tristrips' 2079 2080 #---libraries--- 2081 LIBRARY_ANIMATIONS = 'library_animations' 2082 LIBRARY_ANIMATION_CLIPS = 'library_animation_clips' 2083 LIBRARY_CAMERAS = 'library_cameras' 2084 LIBRARY_CONTROLLERS = 'library_controllers' 2085 LIBRARY_EFFECTS = 'library_effects' 2086 LIBRARY_FORCE_FIELDS = 'library_force_fields' 2087 LIBRARY_GEOMETRIES = 'library_geometries' 2088 LIBRARY_IMAGES = 'library_images' 2089 LIBRARY_LIGHTS = 'library_lights' 2090 LIBRARY_MATERIALS = 'library_materials' 2091 LIBRARY_NODES = 'library_NODES' 2092 LIBRARY_PHYSICS_MATERIALS = 'library_physics_materials' 2093 LIBRARY_PHYSICS_MODELS = 'library_physics_models' 2094 LIBRARY_PHYSICS_SCENES = 'library_physics_scenes' 2095 LIBRARY_VISUAL_SCENES = 'library_visual_scenes' 2096 2097 SCENE = 'scene' 2098 EXTRA = 'extra' 2099 TYPE = 'type' 2100 LIGHT = 'light' 2101 CAMERA = 'camera' 2102 ANIMATION = 'animation' 2103 ANIMATION_CLIP = 'animation_clip' 2104 GEOMETRY = 'geometry' 2105 IMAGE = 'image' 2106 ##EFFECT = 'effect' 2107 VISUAL_SCENE = 'visual_scene' 2108 CONTROLLER = 'controller' 2109 MATERIAL = 'material' 2110 2111 #---asset--- 2112 CONTRIBUTOR = 'contributor' 2113 CREATED = 'created' 2114 MODIFIED = 'modified' 2115 REVISION = 'revision' 2116 TITLE = 'title' 2117 SUBJECT = 'subject' 2118 KEYWORDS = 'keywords' 2119 UNIT = 'unit' 2120 UP_AXIS = 'up_axis' 2121 2122 Y_UP = 'Y_UP' 2123 Z_UP = 'Z_UP' 2124 2125 #---contributor--- 2126 AUTHOR = 'author' 2127 AUTHORING_TOOL = 'authoring_tool' 2128 COMMENTS = 'comments' 2129 COPYRIGHT = 'copyright' 2130 SOURCE_DATA = 'source_data' 2131 2132 #---array--- 2133 FLOAT_ARRAY = 'float_array' 2134 NAME_ARRAY = 'Name_array' 2135 BOOL_ARRAY = 'bool_array' 2136 INT_ARRAY = 'int_array' 2137 IDREF_ARRAY = 'IDREF_array' 2138 2139 #---node--- 2140 NODE = 'node' 2141 TYPE_JOINT = 'JOINT' 2142 TYPE_NODE = 'NODE' 2143 LAYER = 'layer' 2144 2145 #---transforms--- 2146 TRANSLATE = 'translate' 2147 ROTATE = 'rotate' 2148 SCALE = 'scale' 2149 SKEW = 'skew' 2150 MATRIX = 'matrix' 2151 LOOKAT = 'lookat' 2152 2153 #---instances--- 2154 INSTANCE_ANIMATION = 'instance_animation' 2155 INSTANCE_CAMERA = 'instance_camera' 2156 INSTANCE_CONTROLLER = 'instance_controller' 2157 ##INSTANCE_EFFECT = 'instance_effect' 2158 INSTANCE_GEOMETRY = 'instance_geometry' 2159 INSTANCE_LIGHT = 'instance_light' 2160 INSTANCE_NODE = 'instance_node' 2161 INSTANCE_VISUAL_SCENE = 'instance_visual_scene' 2162 INSTANCE_PHYSICS_SCENE = 'instance_physics_scene' 2163 2164 #---image--- 2165 FORMAT = 'format' 2166 DEPTH = 'depth' 2167 HEIGHT = 'height' 2168 WIDTH = 'width' 2169 INIT_FROM = 'init_from' 2170 2171 #---animation--- 2172 SAMPLER = 'sampler' 2173 CHANNEL = 'channel'
2174
2175 -class DaeFxBindMaterial(DaeEntity):
2176 - def __init__(self):
2177 super(DaeFxBindMaterial, self).__init__() 2178 self.syntax = DaeFxSyntax.BIND_MATERIAL 2179 self.techniqueCommon = DaeFxBindMaterial.DaeFxTechniqueCommon()
2180
2181 - def LoadFromXml(self, daeDocument, xmlNode):
2182 self.techniqueCommon = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.TECHNIQUE_COMMON, DaeFxBindMaterial.DaeFxTechniqueCommon)
2183
2184 - def SaveToXml(self, daeDocument):
2185 node = super(DaeFxBindMaterial,self).SaveToXml(daeDocument) 2186 AppendChild(daeDocument, node, self.techniqueCommon) 2187 return node
2188
2189 - class DaeFxTechniqueCommon(DaeEntity):
2190 - def __init__(self):
2191 self.syntax = DaeFxSyntax.TECHNIQUE_COMMON 2192 self.iMaterials = []
2193
2194 - def LoadFromXml(self, daeDocument, xmlNode):
2195 self.iMaterials = CreateObjectsFromXml(daeDocument, xmlNode, DaeFxSyntax.INSTANCE_MATERIAL, DaeFxMaterialInstance)
2196
2197 - def SaveToXml(self, daeDocument):
2198 node = super(DaeFxBindMaterial.DaeFxTechniqueCommon,self).SaveToXml(daeDocument) 2199 AppendChilds(daeDocument, node, self.iMaterials) 2200 return node
2201
2202 - def __str__(self):
2204 2205
2206 -class DaeFxMaterialInstance(DaeEntity):
2207 - def __init__(self):
2208 super(DaeFxMaterialInstance, self).__init__() 2209 self.target = '' 2210 self.symbol = '' 2211 self.object = None 2212 self.syntax = DaeFxSyntax.INSTANCE_MATERIAL
2213
2214 - def LoadFromXml(self, daeDocument, xmlNode):
2215 self.target = ReadAttribute(xmlNode, DaeFxSyntax.TARGET)[1:] 2216 self.symbol = ReadAttribute(xmlNode, DaeFxSyntax.SYMBOL) 2217 self.object = daeDocument.materialsLibrary.FindObject(self.target)
2218
2219 - def SaveToXml(self, daeDocument):
2220 node = super(DaeFxMaterialInstance,self).SaveToXml(daeDocument) 2221 SetAttribute(node, DaeFxSyntax.TARGET, StripString('#'+self.object.id)) 2222 SetAttribute(node, DaeFxSyntax.SYMBOL, StripString(self.object.id)) 2223 return node
2224
2225 - def __str__(self):
2226 return super(DaeFxMaterialInstance,self).__str__()+' target: %s, symbol: %s'%(self.target, self.symbol)
2227
2228 -class DaeFxMaterial(DaeElement):
2229 - def __init__(self):
2230 super(DaeFxMaterial, self).__init__() 2231 self.asset = None 2232 self.iEffects = [] 2233 self.extras = None 2234 self.syntax = DaeFxSyntax.MATERIAL
2235
2236 - def LoadFromXml(self, daeDocument, xmlNode):
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
2242 - def SaveToXml(self, daeDocument):
2243 node = super(DaeFxMaterial,self).SaveToXml(daeDocument) 2244 # Add the assets 2245 AppendChild(daeDocument,node,self.asset) 2246 # Add the effect instances 2247 AppendChilds(daeDocument, node, self.iEffects) 2248 # Add the extra's 2249 AppendChilds(self,node,self.extras) 2250 return node
2251
2252 - def __str__(self):
2253 return super(DaeFxMaterial,self).__str__()+' assets: %s, iEffects: %s, extras: %s'%(self.asset, self.iEffects, self.extras)
2254
2255 -class DaeFxEffectInstance(DaeEntity):
2256 - def __init__(self):
2257 super(DaeFxEffectInstance, self).__init__() 2258 self.url = '' 2259 self.syntax = DaeFxSyntax.INSTANCE_EFFECT
2260
2261 - def LoadFromXml(self, daeDocument, xmlNode):
2262 self.url = ReadAttribute(xmlNode, DaeFxSyntax.URL)[1:] 2263 self.object = daeDocument.effectsLibrary.FindObject(self.url)
2264
2265 - def SaveToXml(self, daeDocument):
2266 node = super(DaeFxEffectInstance,self).SaveToXml(daeDocument) 2267 SetAttribute(node, DaeFxSyntax.URL, StripString('#'+self.object.id)) 2268 return node
2269
2270 -class DaeFxEffect(DaeElement):
2271 - def __init__(self):
2272 super(DaeFxEffect, self).__init__() 2273 self.profileCommon = DaeFxProfileCommon() 2274 self.syntax = DaeFxSyntax.EFFECT
2275 2276
2277 - def LoadFromXml(self, daeDocument, xmlNode):
2278 super(DaeFxEffect, self).LoadFromXml(daeDocument, xmlNode) 2279 self.profileCommon = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.PROFILE_COMMON, DaeFxProfileCommon)
2280
2281 - def SaveToXml(self, daeDocument):
2282 node = super(DaeFxEffect,self).SaveToXml(daeDocument) 2283 AppendChild(daeDocument, node, self.profileCommon) 2284 return node
2285
2286 - def __str__(self):
2287 return super(DaeFxEffect, self).__str__() + ', profileCommon: %s' % (self.profileCommon)
2288
2289 - def AddShader(self, daeShader):
2290 self.profileCommon.technique.shader = daeShader
2291
2292 -class DaeFxProfileCommon(DaeEntity):
2293 - def __init__(self):
2294 super(DaeFxProfileCommon, self).__init__() 2295 self.technique = DaeFxTechnique() 2296 self.images = [] 2297 self.newParams = [] 2298 self.syntax = DaeFxSyntax.PROFILE_COMMON
2299 2300
2301 - def LoadFromXml(self, daeDocument, xmlNode):
2302 self.images = CreateObjectsFromXml(daeDocument, xmlNode, DaeFxSyntax.IMAGE, DaeFxImage) 2303 self.newParams = CreateObjectsFromXml(daeDocument, xmlNode, DaeFxSyntax.NEWPARAM, DaeFxNewParam) 2304 self.technique = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.TECHNIQUE, DaeFxTechnique)
2305
2306 - def SaveToXml(self, daeDocument):
2307 node = super(DaeFxProfileCommon,self).SaveToXml(daeDocument) 2308 AppendChilds(daeDocument, node, self.images) 2309 AppendChilds(daeDocument, node, self.newParams) 2310 AppendChild(daeDocument, node, self.technique) 2311 return node
2312
2313 - def __str__(self):
2314 return super(DaeFxProfileCommon, self).__str__() + ', technique: %s, images: %s, newParams: %s' % (self.technique, self.images, self.newParams)
2315
2316 -class DaeFxImage(DaeEntity):
2317 - def __init__(self):
2318 super(DaeFxImage, self).__init__() 2319 self.syntax = DaeFxSyntax.IMAGE
2320
2321 - def LoadFromXml(self, daeDocument, xmlNode):
2322 super(DaeFxImage, self).LoadFromXml(daeDocument, xmlNode)
2323
2324 - def SaveToXml(self, daeDocument):
2325 node = super(DaeFxImage,self).SaveToXml(daeDocument) 2326 return node
2327
2328 -class DaeFxNewParam(DaeEntity):
2329 - def __init__(self):
2330 super(DaeFxNewParam, self).__init__() 2331 self.syntax = DaeFxSyntax.NEWPARAM
2332
2333 - def LoadFromXml(self, daeDocument, xmlNode):
2334 super(DaeFxNewParam, self).LoadFromXml(daeDocument, xmlNode)
2335
2336 - def SaveToXml(self, daeDocument):
2337 node = super(DaeFxNewParam,self).SaveToXml(daeDocument) 2338 return node
2339
2340 -class DaeFxTechnique(DaeEntity):
2341 - def __init__(self):
2342 super(DaeFxTechnique, self).__init__() 2343 self.syntax = DaeFxSyntax.TECHNIQUE 2344 self.shader = DaeFxShadeConstant() 2345 self.sid = ''
2346
2347 - def LoadFromXml(self, daeDocument, xmlNode):
2348 # TODO: Collada API: add asset and extra? 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
2366 - def SaveToXml(self, daeDocument):
2367 node = super(DaeFxTechnique,self).SaveToXml(daeDocument) 2368 node.setAttribute(DaeFxSyntax.SID, self.sid) 2369 AppendChild(daeDocument, node, self.shader) 2370 return node
2371
2372 - def __str__(self):
2373 return super(DaeFxTechnique,self).__str__()+' shader: %s'%(self.shader)
2374 2375
2376 -class DaeFxShadeConstant(DaeEntity):
2377 - def __init__(self):
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
2388 - def LoadFromXml(self, daeDocument, xmlNode):
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
2396 - def SaveToXml(self, daeDocument):
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
2412 - def AddValue(self, type, val):
2413 col = DaeFxColor() 2414 col.rgba = val 2415 if type == DaeFxSyntax.EMISSION: 2416 if not self.emission: 2417 self.emission = DaeFxCommonColorAndTextureContainer(type) 2418 self.emission.color = col 2419 elif type == DaeFxSyntax.REFLECTIVE: 2420 if not self.reflective: 2421 self.reflective = DaeFxCommonColorAndTextureContainer(type) 2422 self.reflective.color = col 2423 elif type == DaeFxSyntax.REFLECTIVITY: 2424 if not self.reflectivity: 2425 self.reflectivity = DaeFxCommonFloatAndParamContainer(type) 2426 self.reflectivity.float = val 2427 elif type == DaeFxSyntax.TRANSPARENT: 2428 if not self.transparent: 2429 self.transparent = DaeFxCommonColorAndTextureContainer(type) 2430 self.transparent.color = col 2431 elif type == DaeFxSyntax.TRANSPARENCY: 2432 if not self.transparency: 2433 self.transparency = DaeFxCommonFloatAndParamContainer(type) 2434 self.transparency.float = val 2435 elif type == DaeFxSyntax.INDEXOFREFRACTION: 2436 if not self.indexOfRefraction: 2437 self.indexOfRefraction = DaeFxCommonFloatAndParamContainer(type) 2438 self.indexOfRefraction.float = val 2439 else: 2440 Debug.Debug('DaeFxShadeConstant: type: %s not recognised'%(type),'ERROR')
2441 2442 2443
2444 -class DaeFxShadeLambert(DaeFxShadeConstant):
2445 - def __init__(self):
2446 super(DaeFxShadeLambert, self).__init__() 2447 self.ambient = None 2448 self.diffuse = None 2449 self.syntax = DaeFxSyntax.LAMBERT
2450
2451 - def LoadFromXml(self, daeDocument, xmlNode):
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
2457 - def SaveToXml(self, daeDocument):
2458 node = super(DaeFxShadeLambert,self).SaveToXml(daeDocument) 2459 #AppendChild(daeDocument, node, self.ambient) 2460 #AppendChild(daeDocument, node, self.diffuse) 2461 return node
2462
2463 - def AddValue(self, type, val):
2464 col = DaeFxColor() 2465 col.rgba = val 2466 if type == DaeFxSyntax.DIFFUSE: 2467 if not self.diffuse: 2468 self.diffuse = DaeFxCommonColorAndTextureContainer(type) 2469 if isinstance(val, DaeFxTexture): # its a texture 2470 self.diffuse.texture = val 2471 else: # it's a color 2472 self.diffuse.color = col 2473 elif type == DaeFxSyntax.AMBIENT: 2474 if not self.ambient: 2475 self.ambient = DaeFxCommonColorAndTextureContainer(type) 2476 self.ambient.color = col 2477 else: 2478 super(DaeFxShadeLambert,self).AddValue(type, val)
2479
2480 -class DaeFxShadeBlinn(DaeFxShadeLambert):
2481 - def __init__(self):
2482 super(DaeFxShadeBlinn, self).__init__() 2483 self.specular = None 2484 self.shininess = None 2485 self.syntax = DaeFxSyntax.BLINN
2486
2487 - def LoadFromXml(self, daeDocument, xmlNode):
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
2493 - def SaveToXml(self, daeDocument):
2494 node = super(DaeFxShadeBlinn,self).SaveToXml(daeDocument) 2495 #AppendChild(daeDocument, node, self.specular) 2496 #AppendChild(daeDocument, node, self.shininess) 2497 return node
2498
2499 - def AddValue(self, type, val):
2500 col = DaeFxColor() 2501 col.rgba = val 2502 if type == DaeFxSyntax.SPECULAR: 2503 if not self.specular: 2504 self.specular = DaeFxCommonColorAndTextureContainer(type) 2505 self.specular.color = col 2506 elif type == DaeFxSyntax.SHININESS: 2507 if not self.shininess: 2508 self.shininess = DaeFxCommonFloatAndParamContainer(type) 2509 self.shininess.float = val 2510 else: 2511 super(DaeFxShadeBlinn,self).AddValue(type, val)
2512
2513 -class DaeFxShadePhong(DaeFxShadeBlinn):
2514 - def __init__(self):
2515 super(DaeFxShadePhong, self).__init__() 2516 self.syntax = DaeFxSyntax.PHONG
2517
2518 -class DaeFxCommonColorAndTextureContainer(DaeEntity):
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):
2526 self.color = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.COLOR, DaeFxColor) 2527 self.texture = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.TEXTURE, DaeFxTexture)
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
2535 -class DaeFxCommonFloatAndParamContainer(DaeEntity):
2536 - def __init__(self, syntax = 'UNKNOWN'):
2537 super(DaeFxCommonFloatAndParamContainer, self).__init__() 2538 self.float = None 2539 self.param = None 2540 self.syntax = syntax
2541
2542 - def LoadFromXml(self, daeDocument, xmlNode):
2543 self.float = CastFromXml(daeDocument, xmlNode, DaeFxSyntax.FLOAT, float)
2544 ##self.param = CreateObjectFromXml(daeDocument, xmlNode, DaeFxSyntax.PARAM, DaeFxParam) 2545
2546 - def SaveToXml(self, daeDocument):
2547 node = super(DaeFxCommonFloatAndParamContainer,self).SaveToXml(daeDocument) 2548 AppendTextChild(node, DaeFxSyntax.FLOAT, self.float) 2549 AppendChild(daeDocument, node, self.param) 2550 return node
2551
2552 -class DaeFxColor(DaeEntity):
2553 - def __init__(self):
2554 super(DaeFxColor, self).__init__() 2555 self.sid = '' 2556 self.rgba = [] 2557 self.syntax = DaeFxSyntax.COLOR
2558
2559 - def LoadFromXml(self, daeDocument, xmlNode):
2560 self.sid = ReadAttribute(xmlNode, DaeFxSyntax.SID) 2561 self.rgba = ToFloatList(ReadContents(xmlNode))
2562
2563 - def SaveToXml(self, daeDocument):
2564 node = super(DaeFxColor,self).SaveToXml(daeDocument) 2565 SetAttribute(node, DaeFxSyntax.SID, self.sid) 2566 AppendTextInChild(node, self.rgba) 2567 return node
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
2586 -class DaeFxSyntax(object):
2587 COLOR = 'color' 2588 INSTANCE_MATERIAL = 'instance_material' 2589 INSTANCE_EFFECT = 'instance_effect' 2590 TECHNIQUE_COMMON = 'technique_common' 2591 SID = 'sid' 2592 EMISSION = 'emission' 2593 REFLECTIVE ='reflective' 2594 REFLECTIVITY = 'reflectivity' 2595 TRANSPARENT = 'transparent' 2596 TRANSPARENCY = 'transparency' 2597 INDEXOFREFRACTION = 'index_of_refraction' 2598 TEXTURE = 'texture' 2599 TEXCOORD = 'texcoord' 2600 AMBIENT = 'ambient' 2601 DIFFUSE = 'diffuse' 2602 2603 BIND_MATERIAL ='bind_material' 2604 PROFILE_COMMON = 'profile_COMMON' 2605 SYMBOL = 'symbol' 2606 MATERIAL = 'material' 2607 EFFECT = 'effect' 2608 2609 TARGET = 'target' 2610 URL = 'url' 2611 SYMBOL = 'symbol' 2612 2613 BLINN = 'blinn' 2614 SHININESS = 'shininess' 2615 SPECULAR = 'specular' 2616 PHONG = 'phong' 2617 2618 IMAGE = 'image' 2619 NEWPARAM = 'newparam' 2620 TECHNIQUE = 'technique' 2621 2622 CONSTANT = 'constant' 2623 LAMBERT = 'lambert' 2624 2625 FLOAT ='float'
2626 #---COLLADA PHYSICS---
2627 -class DaePhysicsScene(DaeElement):
2628 - def __init__(self):
2629 super(DaePhysicsScene,self).__init__() 2630 self.asset = None 2631 self.extras = None 2632 self.iPhysicsModels = [] 2633 self.syntax = DaePhysicsSyntax.PHYSICS_SCENE
2634
2635 - def LoadFromXml(self, daeDocument, xmlNode):
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
2641 - def SaveToXml(self, daeDocument):
2642 node = super(DaePhysicsScene, self).SaveToXml(daeDocument) 2643 # Add the assets 2644 AppendChild(daeDocument,node,self.asset) 2645 # Add the phyics models 2646 AppendChilds(daeDocument, node, self.iPhysicsModels) 2647 # Add the extra's 2648 AppendChilds(self,node,self.extras) 2649 return node
2650
2651 - def __str__(self):
2652 return super(DaePhysicsScene,self).__str__()+' asset: %s, iPhysicsModels: %s, extras: %s'%(self.asset, self.iPhysicsModels, self.extras)
2653
2654 -class DaePhysicsModelInstance(DaeInstance):
2655 - def __init__(self):
2656 super(DaePhysicsModelInstance, self).__init__() 2657 self.syntax = DaePhysicsSyntax.INSTANCE_PHYSICS_MODEL 2658 self.iRigidBodies = []
2659
2660 - def LoadFromXml(self, daeDocument, xmlNode):
2661 super(DaePhysicsModelInstance,self).LoadFromXml(daeDocument, xmlNode) 2662 self.object = daeDocument.physicsModelsLibrary.FindObject(self.url) 2663 self.iRigidBodies = self.CreateInstanceRigidBodies(daeDocument, xmlNode, self.object)
2664
2665 - def SaveToXml(self, daeDocument):
2666 node = super(DaePhysicsModelInstance,self).SaveToXml(daeDocument) 2667 AppendChilds(daeDocument, node, self.iRigidBodies) 2668 return node
2669
2670 - def CreateInstanceRigidBodies(self, daeDocument, xmlNode, physicsModel):
2671 objects = [] 2672 CreateObjectsFromXml(daeDocument, xmlNode, DaePhysicsSyntax.INSTANCE_RIGID_BODY, DaeRigidBodyInstance) 2673 nodes = FindElementsByTagName(xmlNode,DaePhysicsSyntax.INSTANCE_RIGID_BODY) 2674 for node in nodes: 2675 object = DaeRigidBodyInstance() 2676 object.LoadFromXml(daeDocument, node) 2677 object.body = physicsModel.FindRigidBody(object.bodyString) 2678 n = None 2679 for visualScene in daeDocument.visualScenesLibrary.items: 2680 n = visualScene.FindNode(object.targetString) 2681 if not (n is None): 2682 break 2683 object.target = n 2684 objects.append(object) 2685 return objects
2686 2687
2688 -class DaePhysicsSceneInstance(DaeInstance):
2689 - def __init__(self):
2690 super(DaePhysicsSceneInstance, self).__init__() 2691 self.syntax = DaeSyntax.INSTANCE_PHYSICS_SCENE
2692
2693 - def LoadFromXml(self, daeDocument, xmlNode):
2694 super(DaePhysicsSceneInstance,self).LoadFromXml(daeDocument, xmlNode) 2695 self.object = daeDocument.physicsScenesLibrary.FindObject(self.url)
2696
2697 - def SaveToXml(self, daeDocument):
2698 node = super(DaePhysicsSceneInstance,self).SaveToXml(daeDocument) 2699 return node
2700
2701 -class DaePhysicsMaterialInstance(DaeInstance):
2702 - def __init__(self):
2705
2706 - def LoadFromXml(self, daeDocument, xmlNode):
2707 super(DaePhysicsMaterialInstance,self).LoadFromXml(daeDocument, xmlNode) 2708 self.object = daeDocument.physicsMaterialsLibrary.FindObject(self.url)
2709
2710 - def SaveToXml(self, daeDocument):
2711 node = super(DaePhysicsMaterialInstance,self).SaveToXml(daeDocument) 2712 return node
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
2733 -class DaePhysicsModel(DaeElement):
2734 - def __init__(self):
2735 super(DaePhysicsModel,self).__init__() 2736 self.syntax = DaePhysicsSyntax.PHYSICS_MODEL 2737 self.rigidBodies = []
2738
2739 - def LoadFromXml(self, daeDocument, xmlNode):
2740 super(DaePhysicsModel, self).LoadFromXml(daeDocument, xmlNode) 2741 self.rigidBodies = CreateObjectsFromXml(daeDocument, xmlNode, DaePhysicsSyntax.RIGID_BODY, DaeRigidBody)
2742
2743 - def SaveToXml(self, daeDocument):
2744 node = super(DaePhysicsModel, self).SaveToXml(daeDocument) 2745 # Add the rigid bodies 2746 AppendChilds(daeDocument, node, self.rigidBodies) 2747 return node
2748
2749 - def FindRigidBody(self, url):
2750 for rigidBody in self.rigidBodies: 2751 if rigidBody.sid == url: 2752 return rigidBody 2753 return None
2754
2755 -class DaePhysicsMaterial(DaeElement):
2756 - def __init__(self):
2757 super(DaePhysicsMaterial,self).__init__() 2758 self.syntax = DaePhysicsSyntax.PHYSICS_MATERIAL 2759 self.techniqueCommon = DaePhysicsMaterial.DaeTechniqueCommon()
2760
2761 - def LoadFromXml(self, daeDocument, xmlNode):
2762 super(DaePhysicsMaterial, self).LoadFromXml(daeDocument, xmlNode) 2763 self.techniqueCommon = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.TECHNIQUE_COMMON, DaePhysicsMaterial.DaeTechniqueCommon)
2764
2765 - def SaveToXml(self, daeDocument):
2766 node = super(DaePhysicsMaterial, self).SaveToXml(daeDocument) 2767 AppendChild(daeDocument,node,self.techniqueCommon) 2768 return node
2769
2770 - class DaeTechniqueCommon(DaeEntity):
2771 - def __init__(self):
2772 super(DaePhysicsMaterial.DaeTechniqueCommon,self).__init__() 2773 self.syntax = DaeSyntax.TECHNIQUE_COMMON 2774 self.dynamicFriction = 0 2775 self.restitution = 0 2776 self.staticFriction = 0
2777
2778 - def LoadFromXml(self, daeDocument, xmlNode):
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
2783 - def SaveToXml(self, daeDocument):
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
2790 - def __str__(self):
2791 return super(DaePhysicsMaterial.DaeTechniqueCommon,self).__str__()
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: # TAPERED_CAPSULE 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
2878 - def GetPhysicsMaterial(self):
2879 if not (self.physicsMaterial is None): 2880 return self.physicsMaterial 2881 else: 2882 return self.iPhysicsMaterial.object
2883
2884 - def __str__(self):
2885 return super(DaeRigidBody.DaeTechniqueCommon,self).__str__()
2886
2887 -class DaeShape(DaeEntity):
2888 - def __init__(self):
2889 super(DaeShape, self).__init__() 2890 self.mass = None 2891 self.density = None 2892 self.syntax = DaePhysicsSyntax.SHAPE
2893
2894 - def LoadFromXml(self, daeDocument, xmlNode):
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
2899 - def SaveToXml(self, daeDocument):
2900 node = super(DaeShape, self).SaveToXml(daeDocument) 2901 AppendTextChild(node, DaePhysicsSyntax.MASS, self.mass, None) 2902 AppendTextChild(node, DaePhysicsSyntax.DENSITY, self.density, None) 2903 return node
2904
2905 -class DaeBoxShape(DaeShape):
2906 - def __init__(self):
2907 super(DaeBoxShape, self).__init__() 2908 self.halfExtents = [] 2909 self.syntax = DaePhysicsSyntax.BOX
2910
2911 - def LoadFromXml(self, daeDocument, xmlNode):
2912 super(DaeBoxShape, self).LoadFromXml(daeDocument, xmlNode) 2913 self.halfExtents = ToFloat3(ReadContents(FindElementByTagName(xmlNode,DaePhysicsSyntax.HALF_EXTENTS)))
2914
2915 - def SaveToXml(self, daeDocument):
2916 node = super(DaeBoxShape, self).SaveToXml(daeDocument) 2917 AppendTextChild(node, DaePhysicsSyntax.HALF_EXTENTS, self.halfExtents) 2918 return node
2919
2920 -class DaeSphereShape(DaeShape):
2921 - def __init__(self):
2922 super(DaeSphereShape, self).__init__() 2923 self.radius = None 2924 self.syntax = DaePhysicsSyntax.SPHERE
2925
2926 - def LoadFromXml(self, daeDocument, xmlNode):
2927 super(DaeSphereShape, self).LoadFromXml(daeDocument, xmlNode) 2928 self.radius = CastFromXml(daeDocument, xmlNode, DaePhysicsSyntax.RADIUS, float)
2929
2930 - def SaveToXml(self, daeDocument):
2931 node = super(DaeSphereShape, self).SaveToXml(daeDocument) 2932 AppendTextChild(node, DaePhysicsSyntax.RADIUS, self.radius) 2933 return node
2934
2935 -class DaeCylinderShape(DaeShape):
2936 - def __init__(self):
2937 super(DaeCylinderShape, self).__init__() 2938 self.radius = [1 , 1] 2939 self.height = None 2940 self.syntax = DaePhysicsSyntax.CYLINDER
2941
2942 - def LoadFromXml(self, daeDocument, xmlNode):
2943 super(DaeCylinderShape, self).LoadFromXml(daeDocument, xmlNode) 2944 self.radius = ToFloat2(ReadContents(FindElementByTagName(xmlNode, DaePhysicsSyntax.RADIUS)),'Not a valid radius found. Must consist of 2 floats') 2945 self.height = CastFromXml(daeDocument, xmlNode, DaeSyntax.HEIGHT, float)
2946
2947 - def SaveToXml(self, daeDocument):
2948 node = super(DaeCylinderShape, self).SaveToXml(daeDocument) 2949 AppendTextChild(node, DaePhysicsSyntax.RADIUS, self.radius) 2950 AppendTextChild(node, DaeSyntax.HEIGHT, self.height) 2951 return node
2952
2953 -class DaeTaperedCylinderShape(DaeShape):
2954 - def __init__(self):
2955 super(DaeTaperedCylinderShape, self).__init__() 2956 self.radius1 = [1 , 1] 2957 self.radius2 = [1 , 1] 2958 self.height = None 2959 self.syntax = DaePhysicsSyntax.TAPERED_CYLINDER
2960
2961 - def LoadFromXml(self, daeDocument, xmlNode):
2962 super(DaeTaperedCylinderShape, self).LoadFromXml(daeDocument, xmlNode) 2963 self.radius1 = ToFloat2(ReadContents(FindElementByTagName(xmlNode, DaePhysicsSyntax.RADIUS1)),'Not a valid radius found. Must consist of 2 floats') 2964 self.radius2 = ToFloat2(ReadContents(FindElementByTagName(xmlNode, DaePhysicsSyntax.RADIUS2)), 'Not a valid radius found. Must consist of 2 floats') 2965 self.height = CastFromXml(daeDocument, xmlNode, DaeSyntax.HEIGHT, float)
2966
2967 - def SaveToXml(self, daeDocument):
2968 node = super(DaeTaperedCylinderShape, self).SaveToXml(daeDocument) 2969 AppendTextChild(node, DaePhysicsSyntax.RADIUS1, self.radius1) 2970 AppendTextChild(node, DaePhysicsSyntax.RADIUS2, self.radius2) 2971 AppendTextChild(node, DaeSyntax.HEIGHT, self.height) 2972 return node
2973
2974 -class DaePlaneShape(DaeShape):
2975 - def __init__(self):
2976 super(DaePlaneShape, self).__init__() 2977 self.equation = [] 2978 self.syntax = DaePhysicsSyntax.PLANE
2979
2980 - def LoadFromXml(self, daeDocument, xmlNode):
2981 super(DaePlaneShape, self).LoadFromXml(daeDocument, xmlNode) 2982 self.equation = ToFloat4(ReadContents(FindElementByTagName(xmlNode,DaePhysicsSyntax.EQUATION)))
2983
2984 - def SaveToXml(self, daeDocument):
2985 node = super(DaePlaneShape, self).SaveToXml(daeDocument) 2986 AppendTextChild(node, DaePhysicsSyntax.EQUATION, self.equation) 2987 return node
2988
2989 -class DaeCapsuleShape(DaeShape):
2990 - def __init__(self):
2991 super(DaeCapsuleShape, self).__init__() 2992 self.radius = None 2993 self.height = None 2994 self.syntax = DaePhysicsSyntax.CAPSULE
2995
2996 - def LoadFromXml(self, daeDocument, xmlNode):
2997 super(DaeCapsuleShape, self).LoadFromXml(daeDocument, xmlNode) 2998 self.radius = CastFromXml(daeDocument, xmlNode, DaePhysicsSyntax.RADIUS, float) 2999 self.height = CastFromXml(daeDocument, xmlNode, DaeSyntax.HEIGHT, float)
3000
3001 - def SaveToXml(self, daeDocument):
3002 node = super(DaeCapsuleShape, self).SaveToXml(daeDocument) 3003 AppendTextChild(node, DaePhysicsSyntax.RADIUS, self.radius) 3004 AppendTextChild(node, DaeSyntax.HEIGHT, self.height) 3005 return node
3006
3007 -class DaeGeometryShape(DaeShape):
3008 - def __init__(self):
3009 super(DaeGeometryShape, self).__init__() 3010 self.iGeometry = None
3011
3012 - def LoadFromXml(self, daeDocument, xmlNode):
3013 super(DaeGeometryShape, self).LoadFromXml(daeDocument, xmlNode) 3014 self.iGeometry = DaeGeometryInstance() 3015 self.iGeometry.LoadFromXml(daeDocument, xmlNode)
3016 #self.iGeometry = CreateObjectFromXml(daeDocument, xmlNode, DaeSyntax.INSTANCE_GEOMETRY, DaeGeometryInstance) 3017 #print self.iGeometry 3018 #print xmlNode.toxml() 3019
3020 - def SaveToXml(self, daeDocument):
3021 #node = super(DaeGeometryShape, self).SaveToXml(daeDocument) 3022 #AppendChild(daeDocument, node, self.iGeometry) 3023 return self.iGeometry.SaveToXml(daeDocument)
3024
3025 -class DaePhysicsSyntax(object):
3026 PHYSICS_SCENE = 'physics_scene' 3027 PHYSICS_MODEL = 'physics_model' 3028 PHYSICS_MATERIAL = 'physics_material' 3029 3030 RIGID_BODY = 'rigid_body' 3031 3032 INSTANCE_PHYSICS_MODEL = 'instance_physics_model' 3033 INSTANCE_PHYSICS_MATERIAL = 'instance_physics_material' 3034 INSTANCE_RIGID_BODY = 'instance_rigid_body' 3035 3036 RESTITUTION = 'restitution' 3037 STATIC_FRICTION = 'static_friction' 3038 DYNAMIC_FRICTION = 'dynamic_friction' 3039 3040 DYNAMIC = 'dynamic' 3041 MASS = 'mass' 3042 INERTIA = 'inertia' 3043 SHAPE = 'shape' 3044 DENSITY = 'density' 3045 RADIUS = 'radius' 3046 RADIUS1 = 'radius1' 3047 RADIUS2 = 'radius2' 3048 3049 3050 BOX = 'box' 3051 PLANE = 'plane' 3052 CYLINDER = 'cylinder' 3053 SPHERE = 'sphere' 3054 CAPSULE = 'capsule' 3055 TAPERED_CAPSULE ='tapered_capsule' 3056 TAPERED_CYLINDER = 'tapered_cylinder' 3057 3058 HALF_EXTENTS = 'half_extents'
3059 3060 #---Functions---
3061 -def CreateObjectsFromXml(colladaDocument, xmlNode, nodeType, objectType):
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
3072 -def CreateObjectFromXml(colladaDocument, xmlNode, nodeType, objectType, setSyntax = False):
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
3100 -def CastAttributeFromXml(xmlNode, nodeType, cast, default=None):
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
3108 -def AppendChild(daeDocument, xmlNode, daeEntity):
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
3118 -def AppendChilds(daeDocument, xmlNode, daeEntities):
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()##ToDateTime(object) 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
3155 -def SetAttribute(xmlNode,syntax, object):
3156 if xmlNode is None or object is None or str(object) == '': 3157 return 3158 xmlNode.setAttribute(syntax,str(object))
3159
3160 -def ReadNodeUrl(node):
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
3169 -def WriteNodeUrl(node, url):
3170 node.setAttribute(DaeSyntax.URL, StripString('#'+url))
3171
3172 -def IsVersionOk(version, curVersion):
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
3180 -def StripString(text):
3181 return text.replace(' ','_').replace('.','_')
3182