Merge with 2.5 -r 22173:22620.
authorArystanbek Dyussenov <arystan.d@gmail.com>
Wed, 19 Aug 2009 09:04:49 +0000 (09:04 +0000)
committerArystanbek Dyussenov <arystan.d@gmail.com>
Wed, 19 Aug 2009 09:04:49 +0000 (09:04 +0000)
26 files changed:
1  2 
SConstruct
config/linuxcross-config.py
release/io/export_fbx.py
release/ui/buttons_data_empty.py
release/ui/space_info.py
source/blender/blenkernel/SConscript
source/blender/blenkernel/intern/image.c
source/blender/makesdna/DNA_object_types.h
source/blender/makesrna/RNA_types.h
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_access.c
source/blender/makesrna/intern/rna_armature.c
source/blender/makesrna/intern/rna_define.c
source/blender/makesrna/intern/rna_image.c
source/blender/makesrna/intern/rna_internal.h
source/blender/makesrna/intern/rna_material.c
source/blender/makesrna/intern/rna_mesh.c
source/blender/makesrna/intern/rna_object.c
source/blender/makesrna/intern/rna_pose.c
source/blender/makesrna/intern/rna_scene.c
source/blender/python/intern/bpy_interface.c
source/blender/python/intern/bpy_rna.c
source/blender/python/intern/bpy_util.c
source/creator/creator.c
tools/Blender.py
tools/btools.py

diff --cc SConstruct
Simple merge
Simple merge
index 2a3ea5f,0000000..3515170
mode 100644,000000..100644
--- /dev/null
@@@ -1,3457 -1,0 +1,3457 @@@
-       start_time = bpy.sys.time()
 +#!BPY
 +"""
 +Name: 'Autodesk FBX (.fbx)...'
 +Blender: 249
 +Group: 'Export'
 +Tooltip: 'Selection to an ASCII Autodesk FBX '
 +"""
 +__author__ = "Campbell Barton"
 +__url__ = ['www.blender.org', 'blenderartists.org']
 +__version__ = "1.2"
 +
 +__bpydoc__ = """\
 +This script is an exporter to the FBX file format.
 +
 +http://wiki.blender.org/index.php/Scripts/Manual/Export/autodesk_fbx
 +"""
 +# --------------------------------------------------------------------------
 +# FBX Export v0.1 by Campbell Barton (AKA Ideasman)
 +# --------------------------------------------------------------------------
 +# ***** BEGIN GPL LICENSE BLOCK *****
 +#
 +# This program is free software; you can redistribute it and/or
 +# modify it under the terms of the GNU General Public License
 +# as published by the Free Software Foundation; either version 2
 +# of the License, or (at your option) any later version.
 +#
 +# This program is distributed in the hope that it will be useful,
 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +# GNU General Public License for more details.
 +#
 +# You should have received a copy of the GNU General Public License
 +# along with this program; if not, write to the Free Software Foundation,
 +# Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 +#
 +# ***** END GPL LICENCE BLOCK *****
 +# --------------------------------------------------------------------------
 +
 +import os
 +import time
 +import math # math.pi
 +import shutil # for file copying
 +
 +# try:
 +#     import time
 +#     # import os # only needed for batch export, nbot used yet
 +# except:
 +#     time = None # use this to check if they have python modules installed
 +
 +# for python 2.3 support
 +try:
 +      set()
 +except:
 +      try:
 +              from sets import Set as set
 +      except:
 +              set = None # so it complains you dont have a !
 +
 +# # os is only needed for batch 'own dir' option
 +# try:
 +#     import os
 +# except:
 +#     os = None
 +
 +# import Blender
 +import bpy
 +import Mathutils
 +# from Blender.Mathutils import Matrix, Vector, RotationMatrix
 +
 +# import BPyObject
 +# import BPyMesh
 +# import BPySys
 +# import BPyMessages
 +
 +## This was used to make V, but faster not to do all that
 +##valid = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_,.()[]{}'
 +##v = range(255)
 +##for c in valid: v.remove(ord(c))
 +v = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,42,43,47,58,59,60,61,62,63,64,92,94,96,124,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254]
 +invalid = ''.join([chr(i) for i in v])
 +def cleanName(name):
 +      for ch in invalid:      name = name.replace(ch, '_')
 +      return name
 +# del v, i
 +
 +
 +def copy_file(source, dest):
 +      file = open(source, 'rb')
 +      data = file.read()
 +      file.close()
 +      
 +      file = open(dest, 'wb')
 +      file.write(data)
 +      file.close()
 +
 +
 +def copy_images(dest_dir, textures):
 +      if not dest_dir.endswith(os.sep):
 +              dest_dir += os.sep
 +      
 +      image_paths = set()
 +      for tex in textures:
 +              image_paths.add(Blender.sys.expandpath(tex.filename))
 +      
 +      # Now copy images
 +      copyCount = 0
 +      for image_path in image_paths:
 +              if Blender.sys.exists(image_path):
 +                      # Make a name for the target path.
 +                      dest_image_path = dest_dir + image_path.split('\\')[-1].split('/')[-1]
 +                      if not Blender.sys.exists(dest_image_path): # Image isnt alredy there
 +                              print('\tCopying "%s" > "%s"' % (image_path, dest_image_path))
 +                              try:
 +                                      copy_file(image_path, dest_image_path)
 +                                      copyCount+=1
 +                              except:
 +                                      print('\t\tWarning, file failed to copy, skipping.')
 +      
 +      print('\tCopied %d images' % copyCount)
 +
 +# I guess FBX uses degrees instead of radians (Arystan).
 +# Call this function just before writing to FBX.
 +def eulerRadToDeg(eul):
 +      ret = Mathutils.Euler()
 +
 +      ret.x = 180 / math.pi * eul[0]
 +      ret.y = 180 / math.pi * eul[1]
 +      ret.z = 180 / math.pi * eul[2]
 +
 +      return ret
 +
 +mtx4_identity = Mathutils.Matrix()
 +
 +# testing
 +mtx_x90               = Mathutils.RotationMatrix( math.pi/2, 3, 'x') # used
 +#mtx_x90n     = RotationMatrix(-90, 3, 'x')
 +#mtx_y90      = RotationMatrix( 90, 3, 'y')
 +#mtx_y90n     = RotationMatrix(-90, 3, 'y')
 +#mtx_z90      = RotationMatrix( 90, 3, 'z')
 +#mtx_z90n     = RotationMatrix(-90, 3, 'z')
 +
 +#mtx4_x90     = RotationMatrix( 90, 4, 'x')
 +mtx4_x90n     = Mathutils.RotationMatrix(-math.pi/2, 4, 'x') # used
 +#mtx4_y90     = RotationMatrix( 90, 4, 'y')
 +mtx4_y90n     = Mathutils.RotationMatrix(-math.pi/2, 4, 'y') # used
 +mtx4_z90      = Mathutils.RotationMatrix( math.pi/2, 4, 'z') # used
 +mtx4_z90n     = Mathutils.RotationMatrix(-math.pi/2, 4, 'z') # used
 +
 +# def strip_path(p):
 +#     return p.split('\\')[-1].split('/')[-1]
 +
 +# Used to add the scene name into the filename without using odd chars        
 +sane_name_mapping_ob = {}
 +sane_name_mapping_mat = {}
 +sane_name_mapping_tex = {}
 +sane_name_mapping_take = {}
 +sane_name_mapping_group = {}
 +
 +# Make sure reserved names are not used
 +sane_name_mapping_ob['Scene'] = 'Scene_'
 +sane_name_mapping_ob['blend_root'] = 'blend_root_'
 +
 +def increment_string(t):
 +      name = t
 +      num = ''
 +      while name and name[-1].isdigit():
 +              num = name[-1] + num
 +              name = name[:-1]
 +      if num: return '%s%d' % (name, int(num)+1)      
 +      else:   return name + '_0'
 +
 +
 +
 +# todo - Disallow the name 'Scene' and 'blend_root' - it will bugger things up.
 +def sane_name(data, dct):
 +      #if not data: return None
 +      
 +      if type(data)==tuple: # materials are paired up with images
 +              data, other = data
 +              use_other = True
 +      else:
 +              other = None
 +              use_other = False
 +      
 +      if data:        name = data.name
 +      else:           name = None
 +      orig_name = name
 +      
 +      if other:
 +              orig_name_other = other.name
 +              name = '%s #%s' % (name, orig_name_other)
 +      else:
 +              orig_name_other = None
 +      
 +      # dont cache, only ever call once for each data type now,
 +      # so as to avoid namespace collision between types - like with objects <-> bones
 +      #try:           return dct[name]
 +      #except:                pass
 +      
 +      if not name:
 +              name = 'unnamed' # blank string, ASKING FOR TROUBLE!
 +      else:
 +              #name = BPySys.cleanName(name)
 +              name = cleanName(name) # use our own
 +      
 +      while name in iter(dct.values()):       name = increment_string(name)
 +      
 +      if use_other: # even if other is None - orig_name_other will be a string or None
 +              dct[orig_name, orig_name_other] = name
 +      else:
 +              dct[orig_name] = name
 +              
 +      return name
 +
 +def sane_obname(data):                return sane_name(data, sane_name_mapping_ob)
 +def sane_matname(data):               return sane_name(data, sane_name_mapping_mat)
 +def sane_texname(data):               return sane_name(data, sane_name_mapping_tex)
 +def sane_takename(data):      return sane_name(data, sane_name_mapping_take)
 +def sane_groupname(data):     return sane_name(data, sane_name_mapping_group)
 +
 +# def derived_paths(fname_orig, basepath, FORCE_CWD=False):
 +#     '''
 +#     fname_orig - blender path, can be relative
 +#     basepath - fname_rel will be relative to this
 +#     FORCE_CWD - dont use the basepath, just add a ./ to the filename.
 +#             use when we know the file will be in the basepath.
 +#     '''
 +#     fname = bpy.sys.expandpath(fname_orig)
 +# #   fname = Blender.sys.expandpath(fname_orig)
 +#     fname_strip = os.path.basename(fname)
 +# #   fname_strip = strip_path(fname)
 +#     if FORCE_CWD:
 +#             fname_rel = '.' + os.sep + fname_strip
 +#     else:
 +#             fname_rel = bpy.sys.relpath(fname, basepath)
 +# #           fname_rel = Blender.sys.relpath(fname, basepath)
 +#     if fname_rel.startswith('//'): fname_rel = '.' + os.sep + fname_rel[2:]
 +#     return fname, fname_strip, fname_rel
 +
 +
 +def mat4x4str(mat):
 +      return '%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f' % tuple([ f for v in mat for f in v ])
 +
 +# XXX not used
 +# duplicated in OBJ exporter
 +def getVertsFromGroup(me, group_index):
 +      ret = []
 +
 +      for i, v in enumerate(me.verts):
 +              for g in v.groups:
 +                      if g.group == group_index:
 +                              ret.append((i, g.weight))
 +
 +              return ret
 +
 +# ob must be OB_MESH
 +def BPyMesh_meshWeight2List(ob):
 +      ''' Takes a mesh and return its group names and a list of lists, one list per vertex.
 +      aligning the each vert list with the group names, each list contains float value for the weight.
 +      These 2 lists can be modified and then used with list2MeshWeight to apply the changes.
 +      '''
 +
 +      me = ob.data
 +
 +      # Clear the vert group.
 +      groupNames= [g.name for g in ob.vertex_groups]
 +      len_groupNames= len(groupNames)
 +      
 +      if not len_groupNames:
 +              # no verts? return a vert aligned empty list
 +              return [[] for i in range(len(me.verts))], []
 +      else:
 +              vWeightList= [[0.0]*len_groupNames for i in range(len(me.verts))]
 +
 +      for i, v in enumerate(me.verts):
 +              for g in v.groups:
 +                      vWeightList[i][g.group] = g.weight
 +
 +      return groupNames, vWeightList
 +
 +def meshNormalizedWeights(me):
 +      try: # account for old bad BPyMesh
 +              groupNames, vWeightList = BPyMesh_meshWeight2List(me)
 +#             groupNames, vWeightList = BPyMesh.meshWeight2List(me)
 +      except:
 +              return [],[]
 +      
 +      if not groupNames:
 +              return [],[]
 +      
 +      for i, vWeights in enumerate(vWeightList):
 +              tot = 0.0
 +              for w in vWeights:
 +                      tot+=w
 +              
 +              if tot:
 +                      for j, w in enumerate(vWeights):
 +                              vWeights[j] = w/tot
 +      
 +      return groupNames, vWeightList
 +
 +header_comment = \
 +'''; FBX 6.1.0 project file
 +; Created by Blender FBX Exporter
 +; for support mail: ideasman42@gmail.com
 +; ----------------------------------------------------
 +
 +'''
 +
 +# This func can be called with just the filename
 +def write(filename, batch_objects = None, \
 +              context = None,
 +              EXP_OBS_SELECTED =                      True,
 +              EXP_MESH =                                      True,
 +              EXP_MESH_APPLY_MOD =            True,
 +#             EXP_MESH_HQ_NORMALS =           False,
 +              EXP_ARMATURE =                          True,
 +              EXP_LAMP =                                      True,
 +              EXP_CAMERA =                            True,
 +              EXP_EMPTY =                                     True,
 +              EXP_IMAGE_COPY =                        False,
 +              GLOBAL_MATRIX =                         Mathutils.Matrix(),
 +              ANIM_ENABLE =                           True,
 +              ANIM_OPTIMIZE =                         True,
 +              ANIM_OPTIMIZE_PRECISSION =      6,
 +              ANIM_ACTION_ALL =                       False,
 +              BATCH_ENABLE =                          False,
 +              BATCH_GROUP =                           True,
 +              BATCH_FILE_PREFIX =                     '',
 +              BATCH_OWN_DIR =                         False
 +      ):
 +      
 +      # ----------------- Batch support!
 +      if BATCH_ENABLE:
 +              if os == None:  BATCH_OWN_DIR = False
 +              
 +              fbxpath = filename
 +              
 +              # get the path component of filename
 +              tmp_exists = bpy.sys.exists(fbxpath)
 +#             tmp_exists = Blender.sys.exists(fbxpath)
 +              
 +              if tmp_exists != 2: # a file, we want a path
 +                      fbxpath = os.path.dirname(fbxpath)
 +#                     while fbxpath and fbxpath[-1] not in ('/', '\\'):
 +#                             fbxpath = fbxpath[:-1]
 +                      if not fbxpath:
 +#                     if not filename:
 +                              # XXX
 +                              print('Error%t|Directory does not exist!')
 +#                             Draw.PupMenu('Error%t|Directory does not exist!')
 +                              return
 +
 +                      tmp_exists = bpy.sys.exists(fbxpath)
 +#                     tmp_exists = Blender.sys.exists(fbxpath)
 +              
 +              if tmp_exists != 2:
 +                      # XXX
 +                      print('Error%t|Directory does not exist!')
 +#                     Draw.PupMenu('Error%t|Directory does not exist!')
 +                      return
 +              
 +              if not fbxpath.endswith(os.sep):
 +                      fbxpath += os.sep
 +              del tmp_exists
 +              
 +              
 +              if BATCH_GROUP:
 +                      data_seq = bpy.data.groups
 +              else:
 +                      data_seq = bpy.data.scenes
 +              
 +              # call this function within a loop with BATCH_ENABLE == False
 +              orig_sce = context.scene
 +#             orig_sce = bpy.data.scenes.active
 +              
 +              
 +              new_fbxpath = fbxpath # own dir option modifies, we need to keep an original
 +              for data in data_seq: # scene or group
 +                      newname = BATCH_FILE_PREFIX + cleanName(data.name)
 +#                     newname = BATCH_FILE_PREFIX + BPySys.cleanName(data.name)
 +                      
 +                      
 +                      if BATCH_OWN_DIR:
 +                              new_fbxpath = fbxpath + newname + os.sep
 +                              # path may alredy exist
 +                              # TODO - might exist but be a file. unlikely but should probably account for it.
 +
 +                              if bpy.sys.exists(new_fbxpath) == 0:
 +#                             if Blender.sys.exists(new_fbxpath) == 0:
 +                                      os.mkdir(new_fbxpath)
 +                              
 +                      
 +                      filename = new_fbxpath + newname + '.fbx'
 +                      
 +                      print('\nBatch exporting %s as...\n\t"%s"' % (data, filename))
 +
 +                      # XXX don't know what to do with this, probably do the same? (Arystan)
 +                      if BATCH_GROUP: #group
 +                              # group, so objects update properly, add a dummy scene.
 +                              sce = bpy.data.scenes.new()
 +                              sce.Layers = (1<<20) -1
 +                              bpy.data.scenes.active = sce
 +                              for ob_base in data.objects:
 +                                      sce.objects.link(ob_base)
 +                              
 +                              sce.update(1)
 +                              
 +                              # TODO - BUMMER! Armatures not in the group wont animate the mesh
 +                              
 +                      else:# scene
 +                              
 +                              
 +                              data_seq.active = data
 +                      
 +                      
 +                      # Call self with modified args
 +                      # Dont pass batch options since we alredy usedt them
 +                      write(filename, data.objects,
 +                              context,
 +                              False,
 +                              EXP_MESH,
 +                              EXP_MESH_APPLY_MOD,
 +#                             EXP_MESH_HQ_NORMALS,
 +                              EXP_ARMATURE,
 +                              EXP_LAMP,
 +                              EXP_CAMERA,
 +                              EXP_EMPTY,
 +                              EXP_IMAGE_COPY,
 +                              GLOBAL_MATRIX,
 +                              ANIM_ENABLE,
 +                              ANIM_OPTIMIZE,
 +                              ANIM_OPTIMIZE_PRECISSION,
 +                              ANIM_ACTION_ALL
 +                      )
 +                      
 +                      if BATCH_GROUP:
 +                              # remove temp group scene
 +                              bpy.data.remove_scene(sce)
 +#                             bpy.data.scenes.unlink(sce)
 +              
 +              bpy.data.scenes.active = orig_sce
 +              
 +              return # so the script wont run after we have batch exported.
 +      
 +      # end batch support
 +      
 +      # Use this for working out paths relative to the export location
 +      basepath = os.path.dirname(filename) or '.'
 +      basepath += os.sep
 +#     basepath = Blender.sys.dirname(filename)
 +      
 +      # ----------------------------------------------
 +      # storage classes
 +      class my_bone_class:
 +              __slots__ =(\
 +                'blenName',\
 +                'blenBone',\
 +                'blenMeshes',\
 +                'restMatrix',\
 +                'parent',\
 +                'blenName',\
 +                'fbxName',\
 +                'fbxArm',\
 +                '__pose_bone',\
 +                '__anim_poselist')
 +              
 +              def __init__(self, blenBone, fbxArm):
 +                      
 +                      # This is so 2 armatures dont have naming conflicts since FBX bones use object namespace
 +                      self.fbxName = sane_obname(blenBone)
 +                      
 +                      self.blenName =                 blenBone.name
 +                      self.blenBone =                 blenBone
 +                      self.blenMeshes =               {}                                      # fbxMeshObName : mesh
 +                      self.fbxArm =                   fbxArm
 +                      self.restMatrix =               blenBone.armature_matrix
 +#                     self.restMatrix =               blenBone.matrix['ARMATURESPACE']
 +                      
 +                      # not used yet
 +                      # self.restMatrixInv =  self.restMatrix.copy().invert()
 +                      # self.restMatrixLocal =        None # set later, need parent matrix
 +                      
 +                      self.parent =                   None
 +                      
 +                      # not public
 +                      pose = fbxArm.blenObject.pose
 +#                     pose = fbxArm.blenObject.getPose()
 +                      self.__pose_bone =              pose.pose_channels[self.blenName]
 +#                     self.__pose_bone =              pose.bones[self.blenName]
 +                      
 +                      # store a list if matricies here, (poseMatrix, head, tail)
 +                      # {frame:posematrix, frame:posematrix, ...}
 +                      self.__anim_poselist = {}
 +              
 +              '''
 +              def calcRestMatrixLocal(self):
 +                      if self.parent:
 +                              self.restMatrixLocal = self.restMatrix * self.parent.restMatrix.copy().invert()
 +                      else:
 +                              self.restMatrixLocal = self.restMatrix.copy()
 +              '''
 +              def setPoseFrame(self, f):
 +                      # cache pose info here, frame must be set beforehand
 +                      
 +                      # Didnt end up needing head or tail, if we do - here it is.
 +                      '''
 +                      self.__anim_poselist[f] = (\
 +                              self.__pose_bone.poseMatrix.copy(),\
 +                              self.__pose_bone.head.copy(),\
 +                              self.__pose_bone.tail.copy() )
 +                      '''
 +
 +                      self.__anim_poselist[f] = self.__pose_bone.pose_matrix.copy()
 +#                     self.__anim_poselist[f] = self.__pose_bone.poseMatrix.copy()
 +              
 +              # get pose from frame.
 +              def getPoseMatrix(self, f):# ----------------------------------------------
 +                      return self.__anim_poselist[f]
 +              '''
 +              def getPoseHead(self, f):
 +                      #return self.__pose_bone.head.copy()
 +                      return self.__anim_poselist[f][1].copy()
 +              def getPoseTail(self, f):
 +                      #return self.__pose_bone.tail.copy()
 +                      return self.__anim_poselist[f][2].copy()
 +              '''
 +              # end
 +              
 +              def getAnimParRelMatrix(self, frame):
 +                      #arm_mat = self.fbxArm.matrixWorld
 +                      #arm_mat = self.fbxArm.parRelMatrix()
 +                      if not self.parent:
 +                              #return mtx4_z90 * (self.getPoseMatrix(frame) * arm_mat) # dont apply arm matrix anymore
 +                              return mtx4_z90 * self.getPoseMatrix(frame)
 +                      else:
 +                              #return (mtx4_z90 * ((self.getPoseMatrix(frame) * arm_mat)))  *  (mtx4_z90 * (self.parent.getPoseMatrix(frame) * arm_mat)).invert()
 +                              return (mtx4_z90 * (self.getPoseMatrix(frame)))  *  (mtx4_z90 * self.parent.getPoseMatrix(frame)).invert()
 +              
 +              # we need thes because cameras and lights modified rotations
 +              def getAnimParRelMatrixRot(self, frame):
 +                      return self.getAnimParRelMatrix(frame)
 +              
 +              def flushAnimData(self):
 +                      self.__anim_poselist.clear()
 +
 +
 +      class my_object_generic:
 +              # Other settings can be applied for each type - mesh, armature etc.
 +              def __init__(self, ob, matrixWorld = None):
 +                      self.fbxName = sane_obname(ob)
 +                      self.blenObject = ob
 +                      self.fbxGroupNames = []
 +                      self.fbxParent = None # set later on IF the parent is in the selection.
 +                      if matrixWorld:         self.matrixWorld = matrixWorld * GLOBAL_MATRIX
 +                      else:                           self.matrixWorld = ob.matrix * GLOBAL_MATRIX
 +#                     else:                           self.matrixWorld = ob.matrixWorld * GLOBAL_MATRIX
 +                      self.__anim_poselist = {} # we should only access this
 +              
 +              def parRelMatrix(self):
 +                      if self.fbxParent:
 +                              return self.matrixWorld * self.fbxParent.matrixWorld.copy().invert()
 +                      else:
 +                              return self.matrixWorld
 +              
 +              def setPoseFrame(self, f):
 +                      self.__anim_poselist[f] =  self.blenObject.matrix.copy()
 +#                     self.__anim_poselist[f] =  self.blenObject.matrixWorld.copy()
 +              
 +              def getAnimParRelMatrix(self, frame):
 +                      if self.fbxParent:
 +                              #return (self.__anim_poselist[frame] * self.fbxParent.__anim_poselist[frame].copy().invert() ) * GLOBAL_MATRIX
 +                              return (self.__anim_poselist[frame] * GLOBAL_MATRIX) * (self.fbxParent.__anim_poselist[frame] * GLOBAL_MATRIX).invert()
 +                      else:
 +                              return self.__anim_poselist[frame] * GLOBAL_MATRIX
 +              
 +              def getAnimParRelMatrixRot(self, frame):
 +                      type = self.blenObject.type
 +                      if self.fbxParent:
 +                              matrix_rot = (((self.__anim_poselist[frame] * GLOBAL_MATRIX) * (self.fbxParent.__anim_poselist[frame] * GLOBAL_MATRIX).invert())).rotationPart()
 +                      else:
 +                              matrix_rot = (self.__anim_poselist[frame] * GLOBAL_MATRIX).rotationPart()
 +                      
 +                      # Lamps need to be rotated
 +                      if type =='LAMP':
 +                              matrix_rot = mtx_x90 * matrix_rot
 +                      elif type =='CAMERA':
 +#                     elif ob and type =='Camera':
 +                              y = Mathutils.Vector(0,1,0) * matrix_rot
 +                              matrix_rot = matrix_rot * Mathutils.RotationMatrix(math.pi/2, 3, 'r', y)
 +                      
 +                      return matrix_rot
 +                      
 +      # ----------------------------------------------
 +      
 +      
 +      
 +      
 +      
 +      print('\nFBX export starting...', filename)
-       print('export finished in %.4f sec.' % (bpy.sys.time() - start_time))
++      start_time = time.clock()
 +#     start_time = Blender.sys.time()
 +      try:
 +              file = open(filename, 'w')
 +      except:
 +              return False
 +
 +      sce = context.scene
 +#     sce = bpy.data.scenes.active
 +      world = sce.world
 +      
 +      
 +      # ---------------------------- Write the header first
 +      file.write(header_comment)
 +      if time:
 +              curtime = time.localtime()[0:6]
 +      else:
 +              curtime = (0,0,0,0,0,0)
 +      # 
 +      file.write(\
 +'''FBXHeaderExtension:  {
 +      FBXHeaderVersion: 1003
 +      FBXVersion: 6100
 +      CreationTimeStamp:  {
 +              Version: 1000
 +              Year: %.4i
 +              Month: %.2i
 +              Day: %.2i
 +              Hour: %.2i
 +              Minute: %.2i
 +              Second: %.2i
 +              Millisecond: 0
 +      }
 +      Creator: "FBX SDK/FBX Plugins build 20070228"
 +      OtherFlags:  {
 +              FlagPLE: 0
 +      }
 +}''' % (curtime))
 +      
 +      file.write('\nCreationTime: "%.4i-%.2i-%.2i %.2i:%.2i:%.2i:000"' % curtime)
 +      file.write('\nCreator: "Blender3D version 2.5"')
 +#     file.write('\nCreator: "Blender3D version %.2f"' % Blender.Get('version'))
 +      
 +      pose_items = [] # list of (fbxName, matrix) to write pose data for, easier to collect allong the way
 +      
 +      # --------------- funcs for exporting
 +      def object_tx(ob, loc, matrix, matrix_mod = None):
 +              '''
 +              Matrix mod is so armature objects can modify their bone matricies
 +              '''
 +              if isinstance(ob, bpy.types.Bone):
 +#             if isinstance(ob, Blender.Types.BoneType):
 +                      
 +                      # we know we have a matrix
 +                      # matrix = mtx4_z90 * (ob.matrix['ARMATURESPACE'] * matrix_mod)
 +                      matrix = mtx4_z90 * ob.armature_matrix # dont apply armature matrix anymore
 +#                     matrix = mtx4_z90 * ob.matrix['ARMATURESPACE'] # dont apply armature matrix anymore
 +                      
 +                      parent = ob.parent
 +                      if parent:
 +                              #par_matrix = mtx4_z90 * (parent.matrix['ARMATURESPACE'] * matrix_mod)
 +                              par_matrix = mtx4_z90 * parent.armature_matrix # dont apply armature matrix anymore
 +#                             par_matrix = mtx4_z90 * parent.matrix['ARMATURESPACE'] # dont apply armature matrix anymore
 +                              matrix = matrix * par_matrix.copy().invert()
 +                              
 +                      matrix_rot =    matrix.rotationPart()
 +                      
 +                      loc =                   tuple(matrix.translationPart())
 +                      scale =                 tuple(matrix.scalePart())
 +                      rot =                   tuple(matrix_rot.toEuler())
 +                      
 +              else:
 +                      # This is bad because we need the parent relative matrix from the fbx parent (if we have one), dont use anymore
 +                      #if ob and not matrix: matrix = ob.matrixWorld * GLOBAL_MATRIX
 +                      if ob and not matrix: raise Exception("error: this should never happen!")
 +                      
 +                      matrix_rot = matrix
 +                      #if matrix:
 +                      #       matrix = matrix_scale * matrix
 +                      
 +                      if matrix:
 +                              loc = tuple(matrix.translationPart())
 +                              scale = tuple(matrix.scalePart())
 +                              
 +                              matrix_rot = matrix.rotationPart()
 +                              # Lamps need to be rotated
 +                              if ob and ob.type =='Lamp':
 +                                      matrix_rot = mtx_x90 * matrix_rot
 +                                      rot = tuple(matrix_rot.toEuler())
 +                              elif ob and ob.type =='Camera':
 +                                      y = Mathutils.Vector(0,1,0) * matrix_rot
 +                                      matrix_rot = matrix_rot * Mathutils.RotationMatrix(math.pi/2, 3, 'r', y)
 +                                      rot = tuple(matrix_rot.toEuler())
 +                              else:
 +                                      rot = tuple(matrix_rot.toEuler())
 +                      else:
 +                              if not loc:
 +                                      loc = 0,0,0
 +                              scale = 1,1,1
 +                              rot = 0,0,0
 +              
 +              return loc, rot, scale, matrix, matrix_rot
 +      
 +      def write_object_tx(ob, loc, matrix, matrix_mod= None):
 +              '''
 +              We have loc to set the location if non blender objects that have a location
 +              
 +              matrix_mod is only used for bones at the moment
 +              '''
 +              loc, rot, scale, matrix, matrix_rot = object_tx(ob, loc, matrix, matrix_mod)
 +              
 +              file.write('\n\t\t\tProperty: "Lcl Translation", "Lcl Translation", "A+",%.15f,%.15f,%.15f' % loc)
 +              file.write('\n\t\t\tProperty: "Lcl Rotation", "Lcl Rotation", "A+",%.15f,%.15f,%.15f' % tuple(eulerRadToDeg(rot)))
 +#             file.write('\n\t\t\tProperty: "Lcl Rotation", "Lcl Rotation", "A+",%.15f,%.15f,%.15f' % rot)
 +              file.write('\n\t\t\tProperty: "Lcl Scaling", "Lcl Scaling", "A+",%.15f,%.15f,%.15f' % scale)
 +              return loc, rot, scale, matrix, matrix_rot
 +      
 +      def write_object_props(ob=None, loc=None, matrix=None, matrix_mod=None):
 +              # if the type is 0 its an empty otherwise its a mesh
 +              # only difference at the moment is one has a color
 +              file.write('''
 +              Properties60:  {
 +                      Property: "QuaternionInterpolate", "bool", "",0
 +                      Property: "Visibility", "Visibility", "A+",1''')
 +              
 +              loc, rot, scale, matrix, matrix_rot = write_object_tx(ob, loc, matrix, matrix_mod)
 +              
 +              # Rotation order, note, for FBX files Iv loaded normal order is 1
 +              # setting to zero.
 +              # eEULER_XYZ = 0
 +              # eEULER_XZY
 +              # eEULER_YZX
 +              # eEULER_YXZ
 +              # eEULER_ZXY
 +              # eEULER_ZYX
 +              
 +              file.write('''
 +                      Property: "RotationOffset", "Vector3D", "",0,0,0
 +                      Property: "RotationPivot", "Vector3D", "",0,0,0
 +                      Property: "ScalingOffset", "Vector3D", "",0,0,0
 +                      Property: "ScalingPivot", "Vector3D", "",0,0,0
 +                      Property: "TranslationActive", "bool", "",0
 +                      Property: "TranslationMin", "Vector3D", "",0,0,0
 +                      Property: "TranslationMax", "Vector3D", "",0,0,0
 +                      Property: "TranslationMinX", "bool", "",0
 +                      Property: "TranslationMinY", "bool", "",0
 +                      Property: "TranslationMinZ", "bool", "",0
 +                      Property: "TranslationMaxX", "bool", "",0
 +                      Property: "TranslationMaxY", "bool", "",0
 +                      Property: "TranslationMaxZ", "bool", "",0
 +                      Property: "RotationOrder", "enum", "",0
 +                      Property: "RotationSpaceForLimitOnly", "bool", "",0
 +                      Property: "AxisLen", "double", "",10
 +                      Property: "PreRotation", "Vector3D", "",0,0,0
 +                      Property: "PostRotation", "Vector3D", "",0,0,0
 +                      Property: "RotationActive", "bool", "",0
 +                      Property: "RotationMin", "Vector3D", "",0,0,0
 +                      Property: "RotationMax", "Vector3D", "",0,0,0
 +                      Property: "RotationMinX", "bool", "",0
 +                      Property: "RotationMinY", "bool", "",0
 +                      Property: "RotationMinZ", "bool", "",0
 +                      Property: "RotationMaxX", "bool", "",0
 +                      Property: "RotationMaxY", "bool", "",0
 +                      Property: "RotationMaxZ", "bool", "",0
 +                      Property: "RotationStiffnessX", "double", "",0
 +                      Property: "RotationStiffnessY", "double", "",0
 +                      Property: "RotationStiffnessZ", "double", "",0
 +                      Property: "MinDampRangeX", "double", "",0
 +                      Property: "MinDampRangeY", "double", "",0
 +                      Property: "MinDampRangeZ", "double", "",0
 +                      Property: "MaxDampRangeX", "double", "",0
 +                      Property: "MaxDampRangeY", "double", "",0
 +                      Property: "MaxDampRangeZ", "double", "",0
 +                      Property: "MinDampStrengthX", "double", "",0
 +                      Property: "MinDampStrengthY", "double", "",0
 +                      Property: "MinDampStrengthZ", "double", "",0
 +                      Property: "MaxDampStrengthX", "double", "",0
 +                      Property: "MaxDampStrengthY", "double", "",0
 +                      Property: "MaxDampStrengthZ", "double", "",0
 +                      Property: "PreferedAngleX", "double", "",0
 +                      Property: "PreferedAngleY", "double", "",0
 +                      Property: "PreferedAngleZ", "double", "",0
 +                      Property: "InheritType", "enum", "",0
 +                      Property: "ScalingActive", "bool", "",0
 +                      Property: "ScalingMin", "Vector3D", "",1,1,1
 +                      Property: "ScalingMax", "Vector3D", "",1,1,1
 +                      Property: "ScalingMinX", "bool", "",0
 +                      Property: "ScalingMinY", "bool", "",0
 +                      Property: "ScalingMinZ", "bool", "",0
 +                      Property: "ScalingMaxX", "bool", "",0
 +                      Property: "ScalingMaxY", "bool", "",0
 +                      Property: "ScalingMaxZ", "bool", "",0
 +                      Property: "GeometricTranslation", "Vector3D", "",0,0,0
 +                      Property: "GeometricRotation", "Vector3D", "",0,0,0
 +                      Property: "GeometricScaling", "Vector3D", "",1,1,1
 +                      Property: "LookAtProperty", "object", ""
 +                      Property: "UpVectorProperty", "object", ""
 +                      Property: "Show", "bool", "",1
 +                      Property: "NegativePercentShapeSupport", "bool", "",1
 +                      Property: "DefaultAttributeIndex", "int", "",0''')
 +              if ob and not isinstance(ob, bpy.types.Bone):
 +#             if ob and type(ob) != Blender.Types.BoneType:
 +                      # Only mesh objects have color 
 +                      file.write('\n\t\t\tProperty: "Color", "Color", "A",0.8,0.8,0.8')
 +                      file.write('\n\t\t\tProperty: "Size", "double", "",100')
 +                      file.write('\n\t\t\tProperty: "Look", "enum", "",1')
 +              
 +              return loc, rot, scale, matrix, matrix_rot
 +      
 +      
 +      # -------------------------------------------- Armatures
 +      #def write_bone(bone, name, matrix_mod):
 +      def write_bone(my_bone):
 +              file.write('\n\tModel: "Model::%s", "Limb" {' % my_bone.fbxName)
 +              file.write('\n\t\tVersion: 232')
 +              
 +              #poseMatrix = write_object_props(my_bone.blenBone, None, None, my_bone.fbxArm.parRelMatrix())[3]
 +              poseMatrix = write_object_props(my_bone.blenBone)[3] # dont apply bone matricies anymore
 +              pose_items.append( (my_bone.fbxName, poseMatrix) )
 +              
 +              
 +              # file.write('\n\t\t\tProperty: "Size", "double", "",%.6f' % ((my_bone.blenData.head['ARMATURESPACE'] - my_bone.blenData.tail['ARMATURESPACE']) * my_bone.fbxArm.parRelMatrix()).length)
 +              file.write('\n\t\t\tProperty: "Size", "double", "",1')
 +              
 +              #((my_bone.blenData.head['ARMATURESPACE'] * my_bone.fbxArm.matrixWorld) - (my_bone.blenData.tail['ARMATURESPACE'] * my_bone.fbxArm.parRelMatrix())).length)
 +              
 +              """
 +              file.write('\n\t\t\tProperty: "LimbLength", "double", "",%.6f' %\
 +                      ((my_bone.blenBone.head['ARMATURESPACE'] - my_bone.blenBone.tail['ARMATURESPACE']) * my_bone.fbxArm.parRelMatrix()).length)
 +              """
 +              
 +              file.write('\n\t\t\tProperty: "LimbLength", "double", "",%.6f' %
 +                                 (my_bone.blenBone.armature_head - my_bone.blenBone.armature_tail).length)
 +#                     (my_bone.blenBone.head['ARMATURESPACE'] - my_bone.blenBone.tail['ARMATURESPACE']).length)
 +              
 +              #file.write('\n\t\t\tProperty: "LimbLength", "double", "",1')
 +              file.write('\n\t\t\tProperty: "Color", "ColorRGB", "",0.8,0.8,0.8')
 +              file.write('\n\t\t\tProperty: "Color", "Color", "A",0.8,0.8,0.8')
 +              file.write('\n\t\t}')
 +              file.write('\n\t\tMultiLayer: 0')
 +              file.write('\n\t\tMultiTake: 1')
 +              file.write('\n\t\tShading: Y')
 +              file.write('\n\t\tCulling: "CullingOff"')
 +              file.write('\n\t\tTypeFlags: "Skeleton"')
 +              file.write('\n\t}')
 +      
 +      def write_camera_switch():
 +              file.write('''
 +      Model: "Model::Camera Switcher", "CameraSwitcher" {
 +              Version: 232''')
 +              
 +              write_object_props()
 +              file.write('''
 +                      Property: "Color", "Color", "A",0.8,0.8,0.8
 +                      Property: "Camera Index", "Integer", "A+",100
 +              }
 +              MultiLayer: 0
 +              MultiTake: 1
 +              Hidden: "True"
 +              Shading: W
 +              Culling: "CullingOff"
 +              Version: 101
 +              Name: "Model::Camera Switcher"
 +              CameraId: 0
 +              CameraName: 100
 +              CameraIndexName: 
 +      }''')
 +      
 +      def write_camera_dummy(name, loc, near, far, proj_type, up):
 +              file.write('\n\tModel: "Model::%s", "Camera" {' % name )
 +              file.write('\n\t\tVersion: 232')
 +              write_object_props(None, loc)
 +              
 +              file.write('\n\t\t\tProperty: "Color", "Color", "A",0.8,0.8,0.8')
 +              file.write('\n\t\t\tProperty: "Roll", "Roll", "A+",0')
 +              file.write('\n\t\t\tProperty: "FieldOfView", "FieldOfView", "A+",40')
 +              file.write('\n\t\t\tProperty: "FieldOfViewX", "FieldOfView", "A+",1')
 +              file.write('\n\t\t\tProperty: "FieldOfViewY", "FieldOfView", "A+",1')
 +              file.write('\n\t\t\tProperty: "OpticalCenterX", "Real", "A+",0')
 +              file.write('\n\t\t\tProperty: "OpticalCenterY", "Real", "A+",0')
 +              file.write('\n\t\t\tProperty: "BackgroundColor", "Color", "A+",0.63,0.63,0.63')
 +              file.write('\n\t\t\tProperty: "TurnTable", "Real", "A+",0')
 +              file.write('\n\t\t\tProperty: "DisplayTurnTableIcon", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "Motion Blur Intensity", "Real", "A+",1')
 +              file.write('\n\t\t\tProperty: "UseMotionBlur", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "UseRealTimeMotionBlur", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "ResolutionMode", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "ApertureMode", "enum", "",2')
 +              file.write('\n\t\t\tProperty: "GateFit", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "FocalLength", "Real", "A+",21.3544940948486')
 +              file.write('\n\t\t\tProperty: "CameraFormat", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "AspectW", "double", "",320')
 +              file.write('\n\t\t\tProperty: "AspectH", "double", "",200')
 +              file.write('\n\t\t\tProperty: "PixelAspectRatio", "double", "",1')
 +              file.write('\n\t\t\tProperty: "UseFrameColor", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "FrameColor", "ColorRGB", "",0.3,0.3,0.3')
 +              file.write('\n\t\t\tProperty: "ShowName", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "ShowGrid", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "ShowOpticalCenter", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "ShowAzimut", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "ShowTimeCode", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "NearPlane", "double", "",%.6f' % near)
 +              file.write('\n\t\t\tProperty: "FarPlane", "double", "",%.6f' % far)
 +              file.write('\n\t\t\tProperty: "FilmWidth", "double", "",0.816')
 +              file.write('\n\t\t\tProperty: "FilmHeight", "double", "",0.612')
 +              file.write('\n\t\t\tProperty: "FilmAspectRatio", "double", "",1.33333333333333')
 +              file.write('\n\t\t\tProperty: "FilmSqueezeRatio", "double", "",1')
 +              file.write('\n\t\t\tProperty: "FilmFormatIndex", "enum", "",4')
 +              file.write('\n\t\t\tProperty: "ViewFrustum", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "ViewFrustumNearFarPlane", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "ViewFrustumBackPlaneMode", "enum", "",2')
 +              file.write('\n\t\t\tProperty: "BackPlaneDistance", "double", "",100')
 +              file.write('\n\t\t\tProperty: "BackPlaneDistanceMode", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "ViewCameraToLookAt", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "LockMode", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "LockInterestNavigation", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "FitImage", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "Crop", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "Center", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "KeepRatio", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "BackgroundMode", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "BackgroundAlphaTreshold", "double", "",0.5')
 +              file.write('\n\t\t\tProperty: "ForegroundTransparent", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "DisplaySafeArea", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "SafeAreaDisplayStyle", "enum", "",1')
 +              file.write('\n\t\t\tProperty: "SafeAreaAspectRatio", "double", "",1.33333333333333')
 +              file.write('\n\t\t\tProperty: "Use2DMagnifierZoom", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "2D Magnifier Zoom", "Real", "A+",100')
 +              file.write('\n\t\t\tProperty: "2D Magnifier X", "Real", "A+",50')
 +              file.write('\n\t\t\tProperty: "2D Magnifier Y", "Real", "A+",50')
 +              file.write('\n\t\t\tProperty: "CameraProjectionType", "enum", "",%i' % proj_type)
 +              file.write('\n\t\t\tProperty: "UseRealTimeDOFAndAA", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "UseDepthOfField", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "FocusSource", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "FocusAngle", "double", "",3.5')
 +              file.write('\n\t\t\tProperty: "FocusDistance", "double", "",200')
 +              file.write('\n\t\t\tProperty: "UseAntialiasing", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "AntialiasingIntensity", "double", "",0.77777')
 +              file.write('\n\t\t\tProperty: "UseAccumulationBuffer", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "FrameSamplingCount", "int", "",7')
 +              file.write('\n\t\t}')
 +              file.write('\n\t\tMultiLayer: 0')
 +              file.write('\n\t\tMultiTake: 0')
 +              file.write('\n\t\tHidden: "True"')
 +              file.write('\n\t\tShading: Y')
 +              file.write('\n\t\tCulling: "CullingOff"')
 +              file.write('\n\t\tTypeFlags: "Camera"')
 +              file.write('\n\t\tGeometryVersion: 124')
 +              file.write('\n\t\tPosition: %.6f,%.6f,%.6f' % loc)
 +              file.write('\n\t\tUp: %i,%i,%i' % up)
 +              file.write('\n\t\tLookAt: 0,0,0')
 +              file.write('\n\t\tShowInfoOnMoving: 1')
 +              file.write('\n\t\tShowAudio: 0')
 +              file.write('\n\t\tAudioColor: 0,1,0')
 +              file.write('\n\t\tCameraOrthoZoom: 1')
 +              file.write('\n\t}')
 +      
 +      def write_camera_default():
 +              # This sucks but to match FBX converter its easier to
 +              # write the cameras though they are not needed.
 +              write_camera_dummy('Producer Perspective',      (0,71.3,287.5), 10, 4000, 0, (0,1,0))
 +              write_camera_dummy('Producer Top',                      (0,4000,0), 1, 30000, 1, (0,0,-1))
 +              write_camera_dummy('Producer Bottom',                   (0,-4000,0), 1, 30000, 1, (0,0,-1))
 +              write_camera_dummy('Producer Front',                    (0,0,4000), 1, 30000, 1, (0,1,0))
 +              write_camera_dummy('Producer Back',                     (0,0,-4000), 1, 30000, 1, (0,1,0))
 +              write_camera_dummy('Producer Right',                    (4000,0,0), 1, 30000, 1, (0,1,0))
 +              write_camera_dummy('Producer Left',                     (-4000,0,0), 1, 30000, 1, (0,1,0))
 +      
 +      def write_camera(my_cam):
 +              '''
 +              Write a blender camera
 +              '''
 +              render = sce.render_data
 +              width   = render.resolution_x
 +              height  = render.resolution_y
 +#             render = sce.render
 +#             width   = render.sizeX
 +#             height  = render.sizeY
 +              aspect  = float(width)/height
 +              
 +              data = my_cam.blenObject.data
 +              
 +              file.write('\n\tModel: "Model::%s", "Camera" {' % my_cam.fbxName )
 +              file.write('\n\t\tVersion: 232')
 +              loc, rot, scale, matrix, matrix_rot = write_object_props(my_cam.blenObject, None, my_cam.parRelMatrix())
 +              
 +              file.write('\n\t\t\tProperty: "Roll", "Roll", "A+",0')
 +              file.write('\n\t\t\tProperty: "FieldOfView", "FieldOfView", "A+",%.6f' % data.angle)
 +              file.write('\n\t\t\tProperty: "FieldOfViewX", "FieldOfView", "A+",1')
 +              file.write('\n\t\t\tProperty: "FieldOfViewY", "FieldOfView", "A+",1')
 +              file.write('\n\t\t\tProperty: "FocalLength", "Real", "A+",14.0323972702026')
 +              file.write('\n\t\t\tProperty: "OpticalCenterX", "Real", "A+",%.6f' % data.shift_x) # not sure if this is in the correct units?
 +#             file.write('\n\t\t\tProperty: "OpticalCenterX", "Real", "A+",%.6f' % data.shiftX) # not sure if this is in the correct units?
 +              file.write('\n\t\t\tProperty: "OpticalCenterY", "Real", "A+",%.6f' % data.shift_y) # ditto 
 +#             file.write('\n\t\t\tProperty: "OpticalCenterY", "Real", "A+",%.6f' % data.shiftY) # ditto 
 +              file.write('\n\t\t\tProperty: "BackgroundColor", "Color", "A+",0,0,0')
 +              file.write('\n\t\t\tProperty: "TurnTable", "Real", "A+",0')
 +              file.write('\n\t\t\tProperty: "DisplayTurnTableIcon", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "Motion Blur Intensity", "Real", "A+",1')
 +              file.write('\n\t\t\tProperty: "UseMotionBlur", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "UseRealTimeMotionBlur", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "ResolutionMode", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "ApertureMode", "enum", "",2')
 +              file.write('\n\t\t\tProperty: "GateFit", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "CameraFormat", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "AspectW", "double", "",%i' % width)
 +              file.write('\n\t\t\tProperty: "AspectH", "double", "",%i' % height)
 +              
 +              '''Camera aspect ratio modes.
 +                      0 If the ratio mode is eWINDOW_SIZE, both width and height values aren't relevant.
 +                      1 If the ratio mode is eFIXED_RATIO, the height value is set to 1.0 and the width value is relative to the height value.
 +                      2 If the ratio mode is eFIXED_RESOLUTION, both width and height values are in pixels.
 +                      3 If the ratio mode is eFIXED_WIDTH, the width value is in pixels and the height value is relative to the width value.
 +                      4 If the ratio mode is eFIXED_HEIGHT, the height value is in pixels and the width value is relative to the height value. 
 +              
 +              Definition at line 234 of file kfbxcamera.h. '''
 +              
 +              file.write('\n\t\t\tProperty: "PixelAspectRatio", "double", "",2')
 +              
 +              file.write('\n\t\t\tProperty: "UseFrameColor", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "FrameColor", "ColorRGB", "",0.3,0.3,0.3')
 +              file.write('\n\t\t\tProperty: "ShowName", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "ShowGrid", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "ShowOpticalCenter", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "ShowAzimut", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "ShowTimeCode", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "NearPlane", "double", "",%.6f' % data.clip_start)
 +#             file.write('\n\t\t\tProperty: "NearPlane", "double", "",%.6f' % data.clipStart)
 +              file.write('\n\t\t\tProperty: "FarPlane", "double", "",%.6f' % data.clip_end)
 +#             file.write('\n\t\t\tProperty: "FarPlane", "double", "",%.6f' % data.clipStart)
 +              file.write('\n\t\t\tProperty: "FilmWidth", "double", "",1.0')
 +              file.write('\n\t\t\tProperty: "FilmHeight", "double", "",1.0')
 +              file.write('\n\t\t\tProperty: "FilmAspectRatio", "double", "",%.6f' % aspect)
 +              file.write('\n\t\t\tProperty: "FilmSqueezeRatio", "double", "",1')
 +              file.write('\n\t\t\tProperty: "FilmFormatIndex", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "ViewFrustum", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "ViewFrustumNearFarPlane", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "ViewFrustumBackPlaneMode", "enum", "",2')
 +              file.write('\n\t\t\tProperty: "BackPlaneDistance", "double", "",100')
 +              file.write('\n\t\t\tProperty: "BackPlaneDistanceMode", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "ViewCameraToLookAt", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "LockMode", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "LockInterestNavigation", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "FitImage", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "Crop", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "Center", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "KeepRatio", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "BackgroundMode", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "BackgroundAlphaTreshold", "double", "",0.5')
 +              file.write('\n\t\t\tProperty: "ForegroundTransparent", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "DisplaySafeArea", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "SafeAreaDisplayStyle", "enum", "",1')
 +              file.write('\n\t\t\tProperty: "SafeAreaAspectRatio", "double", "",%.6f' % aspect)
 +              file.write('\n\t\t\tProperty: "Use2DMagnifierZoom", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "2D Magnifier Zoom", "Real", "A+",100')
 +              file.write('\n\t\t\tProperty: "2D Magnifier X", "Real", "A+",50')
 +              file.write('\n\t\t\tProperty: "2D Magnifier Y", "Real", "A+",50')
 +              file.write('\n\t\t\tProperty: "CameraProjectionType", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "UseRealTimeDOFAndAA", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "UseDepthOfField", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "FocusSource", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "FocusAngle", "double", "",3.5')
 +              file.write('\n\t\t\tProperty: "FocusDistance", "double", "",200')
 +              file.write('\n\t\t\tProperty: "UseAntialiasing", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "AntialiasingIntensity", "double", "",0.77777')
 +              file.write('\n\t\t\tProperty: "UseAccumulationBuffer", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "FrameSamplingCount", "int", "",7')
 +              
 +              file.write('\n\t\t}')
 +              file.write('\n\t\tMultiLayer: 0')
 +              file.write('\n\t\tMultiTake: 0')
 +              file.write('\n\t\tShading: Y')
 +              file.write('\n\t\tCulling: "CullingOff"')
 +              file.write('\n\t\tTypeFlags: "Camera"')
 +              file.write('\n\t\tGeometryVersion: 124')
 +              file.write('\n\t\tPosition: %.6f,%.6f,%.6f' % loc)
 +              file.write('\n\t\tUp: %.6f,%.6f,%.6f' % tuple(Mathutils.Vector(0,1,0) * matrix_rot) )
 +              file.write('\n\t\tLookAt: %.6f,%.6f,%.6f' % tuple(Mathutils.Vector(0,0,-1)*matrix_rot) )
 +              
 +              #file.write('\n\t\tUp: 0,0,0' )
 +              #file.write('\n\t\tLookAt: 0,0,0' )
 +              
 +              file.write('\n\t\tShowInfoOnMoving: 1')
 +              file.write('\n\t\tShowAudio: 0')
 +              file.write('\n\t\tAudioColor: 0,1,0')
 +              file.write('\n\t\tCameraOrthoZoom: 1')
 +              file.write('\n\t}')
 +      
 +      def write_light(my_light):
 +              light = my_light.blenObject.data
 +              file.write('\n\tModel: "Model::%s", "Light" {' % my_light.fbxName)
 +              file.write('\n\t\tVersion: 232')
 +              
 +              write_object_props(my_light.blenObject, None, my_light.parRelMatrix())
 +              
 +              # Why are these values here twice?????? - oh well, follow the holy sdk's output
 +              
 +              # Blender light types match FBX's, funny coincidence, we just need to
 +              # be sure that all unsupported types are made into a point light
 +              #ePOINT, 
 +              #eDIRECTIONAL
 +              #eSPOT
 +              light_type_items = {'POINT': 0, 'SUN': 1, 'SPOT': 2, 'HEMI': 3, 'AREA': 4}
 +              light_type = light_type_items[light.type]
 +#             light_type = light.type
 +              if light_type > 2: light_type = 1 # hemi and area lights become directional
 +
 +#             mode = light.mode
 +              if light.shadow_method == 'RAY_SHADOW' or light.shadow_method == 'BUFFER_SHADOW':
 +#             if mode & Blender.Lamp.Modes.RayShadow or mode & Blender.Lamp.Modes.Shadows:
 +                      do_shadow = 1
 +              else:
 +                      do_shadow = 0
 +
 +              if light.only_shadow or (not light.diffuse and not light.specular):
 +#             if mode & Blender.Lamp.Modes.OnlyShadow or (mode & Blender.Lamp.Modes.NoDiffuse and mode & Blender.Lamp.Modes.NoSpecular):
 +                      do_light = 0
 +              else:
 +                      do_light = 1
 +              
 +              scale = abs(GLOBAL_MATRIX.scalePart()[0]) # scale is always uniform in this case
 +              
 +              file.write('\n\t\t\tProperty: "LightType", "enum", "",%i' % light_type)
 +              file.write('\n\t\t\tProperty: "CastLightOnObject", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "DrawVolumetricLight", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "DrawGroundProjection", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "DrawFrontFacingVolumetricLight", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "GoboProperty", "object", ""')
 +              file.write('\n\t\t\tProperty: "Color", "Color", "A+",1,1,1')
 +              file.write('\n\t\t\tProperty: "Intensity", "Intensity", "A+",%.2f' % (min(light.energy*100, 200))) # clamp below 200
 +              if light.type == 'SPOT':
 +                      file.write('\n\t\t\tProperty: "Cone angle", "Cone angle", "A+",%.2f' % (light.spot_size * scale))
 +#             file.write('\n\t\t\tProperty: "Cone angle", "Cone angle", "A+",%.2f' % (light.spotSize * scale))
 +              file.write('\n\t\t\tProperty: "Fog", "Fog", "A+",50')
 +              file.write('\n\t\t\tProperty: "Color", "Color", "A",%.2f,%.2f,%.2f' % tuple(light.color))
 +#             file.write('\n\t\t\tProperty: "Color", "Color", "A",%.2f,%.2f,%.2f' % tuple(light.col))
 +              file.write('\n\t\t\tProperty: "Intensity", "Intensity", "A+",%.2f' % (min(light.energy*100, 200))) # clamp below 200
 +# 
 +              # duplication? see ^ (Arystan)
 +#             file.write('\n\t\t\tProperty: "Cone angle", "Cone angle", "A+",%.2f' % (light.spotSize * scale))
 +              file.write('\n\t\t\tProperty: "Fog", "Fog", "A+",50')
 +              file.write('\n\t\t\tProperty: "LightType", "enum", "",%i' % light_type)
 +              file.write('\n\t\t\tProperty: "CastLightOnObject", "bool", "",%i' % do_light)
 +              file.write('\n\t\t\tProperty: "DrawGroundProjection", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "DrawFrontFacingVolumetricLight", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "DrawVolumetricLight", "bool", "",1')
 +              file.write('\n\t\t\tProperty: "GoboProperty", "object", ""')
 +              file.write('\n\t\t\tProperty: "DecayType", "enum", "",0')
 +              file.write('\n\t\t\tProperty: "DecayStart", "double", "",%.2f' % light.distance)
 +#             file.write('\n\t\t\tProperty: "DecayStart", "double", "",%.2f' % light.dist)
 +              file.write('\n\t\t\tProperty: "EnableNearAttenuation", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "NearAttenuationStart", "double", "",0')
 +              file.write('\n\t\t\tProperty: "NearAttenuationEnd", "double", "",0')
 +              file.write('\n\t\t\tProperty: "EnableFarAttenuation", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "FarAttenuationStart", "double", "",0')
 +              file.write('\n\t\t\tProperty: "FarAttenuationEnd", "double", "",0')
 +              file.write('\n\t\t\tProperty: "CastShadows", "bool", "",%i' % do_shadow)
 +              file.write('\n\t\t\tProperty: "ShadowColor", "ColorRGBA", "",0,0,0,1')
 +              file.write('\n\t\t}')
 +              file.write('\n\t\tMultiLayer: 0')
 +              file.write('\n\t\tMultiTake: 0')
 +              file.write('\n\t\tShading: Y')
 +              file.write('\n\t\tCulling: "CullingOff"')
 +              file.write('\n\t\tTypeFlags: "Light"')
 +              file.write('\n\t\tGeometryVersion: 124')
 +              file.write('\n\t}')
 +      
 +      # matrixOnly is not used at the moment
 +      def write_null(my_null = None, fbxName = None, matrixOnly = None):
 +              # ob can be null
 +              if not fbxName: fbxName = my_null.fbxName
 +              
 +              file.write('\n\tModel: "Model::%s", "Null" {' % fbxName)
 +              file.write('\n\t\tVersion: 232')
 +              
 +              # only use this for the root matrix at the moment
 +              if matrixOnly:
 +                      poseMatrix = write_object_props(None, None, matrixOnly)[3]
 +              
 +              else: # all other Null's
 +                      if my_null:             poseMatrix = write_object_props(my_null.blenObject, None, my_null.parRelMatrix())[3]
 +                      else:                   poseMatrix = write_object_props()[3]
 +              
 +              pose_items.append((fbxName, poseMatrix))
 +              
 +              file.write('''
 +              }
 +              MultiLayer: 0
 +              MultiTake: 1
 +              Shading: Y
 +              Culling: "CullingOff"
 +              TypeFlags: "Null"
 +      }''')
 +      
 +      # Material Settings
 +      if world:       world_amb = tuple(world.ambient_color)
 +#     if world:       world_amb = world.getAmb()
 +      else:           world_amb = (0,0,0) # Default value
 +      
 +      def write_material(matname, mat):
 +              file.write('\n\tMaterial: "Material::%s", "" {' % matname)
 +              
 +              # Todo, add more material Properties.
 +              if mat:
 +                      mat_cold = tuple(mat.diffuse_color)
 +#                     mat_cold = tuple(mat.rgbCol)
 +                      mat_cols = tuple(mat.specular_color)
 +#                     mat_cols = tuple(mat.specCol)
 +                      #mat_colm = tuple(mat.mirCol) # we wont use the mirror color
 +                      mat_colamb = world_amb
 +#                     mat_colamb = tuple([c for c in world_amb])
 +
 +                      mat_dif = mat.diffuse_reflection
 +#                     mat_dif = mat.ref
 +                      mat_amb = mat.ambient
 +#                     mat_amb = mat.amb
 +                      mat_hard = (float(mat.specular_hardness)-1)/5.10
 +#                     mat_hard = (float(mat.hard)-1)/5.10
 +                      mat_spec = mat.specular_reflection/2.0
 +#                     mat_spec = mat.spec/2.0
 +                      mat_alpha = mat.alpha
 +                      mat_emit = mat.emit
 +                      mat_shadeless = mat.shadeless
 +#                     mat_shadeless = mat.mode & Blender.Material.Modes.SHADELESS
 +                      if mat_shadeless:
 +                              mat_shader = 'Lambert'
 +                      else:
 +                              if mat.diffuse_shader == 'LAMBERT':
 +#                             if mat.diffuseShader == Blender.Material.Shaders.DIFFUSE_LAMBERT:
 +                                      mat_shader = 'Lambert'
 +                              else:
 +                                      mat_shader = 'Phong'
 +              else:
 +                      mat_cols = mat_cold = 0.8, 0.8, 0.8
 +                      mat_colamb = 0.0,0.0,0.0
 +                      # mat_colm 
 +                      mat_dif = 1.0
 +                      mat_amb = 0.5
 +                      mat_hard = 20.0
 +                      mat_spec = 0.2
 +                      mat_alpha = 1.0
 +                      mat_emit = 0.0
 +                      mat_shadeless = False
 +                      mat_shader = 'Phong'
 +              
 +              file.write('\n\t\tVersion: 102')
 +              file.write('\n\t\tShadingModel: "%s"' % mat_shader.lower())
 +              file.write('\n\t\tMultiLayer: 0')
 +              
 +              file.write('\n\t\tProperties60:  {')
 +              file.write('\n\t\t\tProperty: "ShadingModel", "KString", "", "%s"' % mat_shader)
 +              file.write('\n\t\t\tProperty: "MultiLayer", "bool", "",0')
 +              file.write('\n\t\t\tProperty: "EmissiveColor", "ColorRGB", "",%.4f,%.4f,%.4f' % mat_cold) # emit and diffuse color are he same in blender
 +              file.write('\n\t\t\tProperty: "EmissiveFactor", "double", "",%.4f' % mat_emit)
 +              
 +              file.write('\n\t\t\tProperty: "AmbientColor", "ColorRGB", "",%.4f,%.4f,%.4f' % mat_colamb)
 +              file.write('\n\t\t\tProperty: "AmbientFactor", "double", "",%.4f' % mat_amb)
 +              file.write('\n\t\t\tProperty: "DiffuseColor", "ColorRGB", "",%.4f,%.4f,%.4f' % mat_cold)
 +              file.write('\n\t\t\tProperty: "DiffuseFactor", "double", "",%.4f' % mat_dif)
 +              file.write('\n\t\t\tProperty: "Bump", "Vector3D", "",0,0,0')
 +              file.write('\n\t\t\tProperty: "TransparentColor", "ColorRGB", "",1,1,1')
 +              file.write('\n\t\t\tProperty: "TransparencyFactor", "double", "",%.4f' % (1.0 - mat_alpha))
 +              if not mat_shadeless:
 +                      file.write('\n\t\t\tProperty: "SpecularColor", "ColorRGB", "",%.4f,%.4f,%.4f' % mat_cols)
 +                      file.write('\n\t\t\tProperty: "SpecularFactor", "double", "",%.4f' % mat_spec)
 +                      file.write('\n\t\t\tProperty: "ShininessExponent", "double", "",80.0')
 +                      file.write('\n\t\t\tProperty: "ReflectionColor", "ColorRGB", "",0,0,0')
 +                      file.write('\n\t\t\tProperty: "ReflectionFactor", "double", "",1')
 +              file.write('\n\t\t\tProperty: "Emissive", "ColorRGB", "",0,0,0')
 +              file.write('\n\t\t\tProperty: "Ambient", "ColorRGB", "",%.1f,%.1f,%.1f' % mat_colamb)
 +              file.write('\n\t\t\tProperty: "Diffuse", "ColorRGB", "",%.1f,%.1f,%.1f' % mat_cold)
 +              if not mat_shadeless:
 +                      file.write('\n\t\t\tProperty: "Specular", "ColorRGB", "",%.1f,%.1f,%.1f' % mat_cols)
 +                      file.write('\n\t\t\tProperty: "Shininess", "double", "",%.1f' % mat_hard)
 +              file.write('\n\t\t\tProperty: "Opacity", "double", "",%.1f' % mat_alpha)
 +              if not mat_shadeless:
 +                      file.write('\n\t\t\tProperty: "Reflectivity", "double", "",0')
 +
 +              file.write('\n\t\t}')
 +              file.write('\n\t}')
 +
 +      def copy_image(image):
 +
 +              rel = image.get_export_path(basepath, True)
 +              base = os.path.basename(rel)
 +
 +              if EXP_IMAGE_COPY:
 +                      src = bpy.sys.expandpath(image.filename)
 +                      absp = image.get_export_path(basepath, False)
 +                      if not os.path.exists(absp):
 +                              shutil.copy(src, absp)
 +
 +              return (rel, base)
 +
 +      # tex is an Image (Arystan)
 +      def write_video(texname, tex):
 +              # Same as texture really!
 +              file.write('\n\tVideo: "Video::%s", "Clip" {' % texname)
 +              
 +              file.write('''
 +              Type: "Clip"
 +              Properties60:  {
 +                      Property: "FrameRate", "double", "",0
 +                      Property: "LastFrame", "int", "",0
 +                      Property: "Width", "int", "",0
 +                      Property: "Height", "int", "",0''')
 +              if tex:
 +                      fname_rel, fname_strip = copy_image(tex)
 +#                     fname, fname_strip, fname_rel = derived_paths(tex.filename, basepath, EXP_IMAGE_COPY)
 +              else:
 +                      fname = fname_strip = fname_rel = ''
 +              
 +              file.write('\n\t\t\tProperty: "Path", "charptr", "", "%s"' % fname_strip)
 +              
 +              
 +              file.write('''
 +                      Property: "StartFrame", "int", "",0
 +                      Property: "StopFrame", "int", "",0
 +                      Property: "PlaySpeed", "double", "",1
 +                      Property: "Offset", "KTime", "",0
 +                      Property: "InterlaceMode", "enum", "",0
 +                      Property: "FreeRunning", "bool", "",0
 +                      Property: "Loop", "bool", "",0
 +                      Property: "AccessMode", "enum", "",0
 +              }
 +              UseMipMap: 0''')
 +              
 +              file.write('\n\t\tFilename: "%s"' % fname_strip)
 +              if fname_strip: fname_strip = '/' + fname_strip
 +              file.write('\n\t\tRelativeFilename: "%s"' % fname_rel) # make relative
 +              file.write('\n\t}')
 +
 +      
 +      def write_texture(texname, tex, num):
 +              # if tex == None then this is a dummy tex
 +              file.write('\n\tTexture: "Texture::%s", "TextureVideoClip" {' % texname)
 +              file.write('\n\t\tType: "TextureVideoClip"')
 +              file.write('\n\t\tVersion: 202')
 +              # TODO, rare case _empty_ exists as a name.
 +              file.write('\n\t\tTextureName: "Texture::%s"' % texname)
 +              
 +              file.write('''
 +              Properties60:  {
 +                      Property: "Translation", "Vector", "A+",0,0,0
 +                      Property: "Rotation", "Vector", "A+",0,0,0
 +                      Property: "Scaling", "Vector", "A+",1,1,1''')
 +              file.write('\n\t\t\tProperty: "Texture alpha", "Number", "A+",%i' % num)
 +              
 +              
 +              # WrapModeU/V 0==rep, 1==clamp, TODO add support
 +              file.write('''
 +                      Property: "TextureTypeUse", "enum", "",0
 +                      Property: "CurrentTextureBlendMode", "enum", "",1
 +                      Property: "UseMaterial", "bool", "",0
 +                      Property: "UseMipMap", "bool", "",0
 +                      Property: "CurrentMappingType", "enum", "",0
 +                      Property: "UVSwap", "bool", "",0''')
 +
 +              file.write('\n\t\t\tProperty: "WrapModeU", "enum", "",%i' % tex.clamp_x)
 +#             file.write('\n\t\t\tProperty: "WrapModeU", "enum", "",%i' % tex.clampX)
 +              file.write('\n\t\t\tProperty: "WrapModeV", "enum", "",%i' % tex.clamp_y)
 +#             file.write('\n\t\t\tProperty: "WrapModeV", "enum", "",%i' % tex.clampY)
 +              
 +              file.write('''
 +                      Property: "TextureRotationPivot", "Vector3D", "",0,0,0
 +                      Property: "TextureScalingPivot", "Vector3D", "",0,0,0
 +                      Property: "VideoProperty", "object", ""
 +              }''')
 +              
 +              file.write('\n\t\tMedia: "Video::%s"' % texname)
 +              
 +              if tex:
 +                      fname_rel, fname_strip = copy_image(tex)
 +#                     fname, fname_strip, fname_rel = derived_paths(tex.filename, basepath, EXP_IMAGE_COPY)
 +              else:
 +                      fname = fname_strip = fname_rel = ''
 +              
 +              file.write('\n\t\tFileName: "%s"' % fname_strip)
 +              file.write('\n\t\tRelativeFilename: "%s"' % fname_rel) # need some make relative command
 +              
 +              file.write('''
 +              ModelUVTranslation: 0,0
 +              ModelUVScaling: 1,1
 +              Texture_Alpha_Source: "None"
 +              Cropping: 0,0,0,0
 +      }''')
 +
 +      def write_deformer_skin(obname):
 +              '''
 +              Each mesh has its own deformer
 +              '''
 +              file.write('\n\tDeformer: "Deformer::Skin %s", "Skin" {' % obname)
 +              file.write('''
 +              Version: 100
 +              MultiLayer: 0
 +              Type: "Skin"
 +              Properties60:  {
 +              }
 +              Link_DeformAcuracy: 50
 +      }''')
 +      
 +      # in the example was 'Bip01 L Thigh_2'
 +      def write_sub_deformer_skin(my_mesh, my_bone, weights):
 +      
 +              '''
 +              Each subdeformer is spesific to a mesh, but the bone it links to can be used by many sub-deformers
 +              So the SubDeformer needs the mesh-object name as a prefix to make it unique
 +              
 +              Its possible that there is no matching vgroup in this mesh, in that case no verts are in the subdeformer,
 +              a but silly but dosnt really matter
 +              '''
 +              file.write('\n\tDeformer: "SubDeformer::Cluster %s %s", "Cluster" {' % (my_mesh.fbxName, my_bone.fbxName))
 +              
 +              file.write('''
 +              Version: 100
 +              MultiLayer: 0
 +              Type: "Cluster"
 +              Properties60:  {
 +                      Property: "SrcModel", "object", ""
 +                      Property: "SrcModelReference", "object", ""
 +              }
 +              UserData: "", ""''')
 +              
 +              # Support for bone parents
 +              if my_mesh.fbxBoneParent:
 +                      if my_mesh.fbxBoneParent == my_bone:
 +                              # TODO - this is a bit lazy, we could have a simple write loop
 +                              # for this case because all weights are 1.0 but for now this is ok
 +                              # Parent Bones arent used all that much anyway.
 +                              vgroup_data = [(j, 1.0) for j in range(len(my_mesh.blenData.verts))]
 +                      else:
 +                              # This bone is not a parent of this mesh object, no weights
 +                              vgroup_data = []
 +                      
 +              else:
 +                      # Normal weight painted mesh
 +                      if my_bone.blenName in weights[0]:
 +                              # Before we used normalized wright list
 +                              #vgroup_data = me.getVertsFromGroup(bone.name, 1)
 +                              group_index = weights[0].index(my_bone.blenName)
 +                              vgroup_data = [(j, weight[group_index]) for j, weight in enumerate(weights[1]) if weight[group_index]] 
 +                      else:
 +                              vgroup_data = []
 +              
 +              file.write('\n\t\tIndexes: ')
 +              
 +              i = -1
 +              for vg in vgroup_data:
 +                      if i == -1:
 +                              file.write('%i'  % vg[0])
 +                              i=0
 +                      else:
 +                              if i==23:
 +                                      file.write('\n\t\t')
 +                                      i=0
 +                              file.write(',%i' % vg[0])
 +                      i+=1
 +              
 +              file.write('\n\t\tWeights: ')
 +              i = -1
 +              for vg in vgroup_data:
 +                      if i == -1:
 +                              file.write('%.8f'  % vg[1])
 +                              i=0
 +                      else:
 +                              if i==38:
 +                                      file.write('\n\t\t')
 +                                      i=0
 +                              file.write(',%.8f' % vg[1])
 +                      i+=1
 +              
 +              if my_mesh.fbxParent:
 +                      # TODO FIXME, this case is broken in some cases. skinned meshes just shouldnt have parents where possible!
 +                      m = mtx4_z90 * (my_bone.restMatrix * my_bone.fbxArm.matrixWorld.copy() * my_mesh.matrixWorld.copy().invert() )
 +              else:
 +                      # Yes! this is it...  - but dosnt work when the mesh is a.
 +                      m = mtx4_z90 * (my_bone.restMatrix * my_bone.fbxArm.matrixWorld.copy() * my_mesh.matrixWorld.copy().invert() )
 +              
 +              #m = mtx4_z90 * my_bone.restMatrix
 +              matstr = mat4x4str(m)
 +              matstr_i = mat4x4str(m.invert())
 +              
 +              file.write('\n\t\tTransform: %s' % matstr_i) # THIS IS __NOT__ THE GLOBAL MATRIX AS DOCUMENTED :/
 +              file.write('\n\t\tTransformLink: %s' % matstr)
 +              file.write('\n\t}')
 +      
 +      def write_mesh(my_mesh):
 +              
 +              me = my_mesh.blenData
 +              
 +              # if there are non NULL materials on this mesh
 +              if my_mesh.blenMaterials:       do_materials = True
 +              else:                                           do_materials = False
 +              
 +              if my_mesh.blenTextures:        do_textures = True
 +              else:                                           do_textures = False     
 +              
 +              do_uvs = len(me.uv_textures) > 0
 +#             do_uvs = me.faceUV
 +              
 +              
 +              file.write('\n\tModel: "Model::%s", "Mesh" {' % my_mesh.fbxName)
 +              file.write('\n\t\tVersion: 232') # newline is added in write_object_props
 +              
 +              poseMatrix = write_object_props(my_mesh.blenObject, None, my_mesh.parRelMatrix())[3]
 +              pose_items.append((my_mesh.fbxName, poseMatrix))
 +              
 +              file.write('\n\t\t}')
 +              file.write('\n\t\tMultiLayer: 0')
 +              file.write('\n\t\tMultiTake: 1')
 +              file.write('\n\t\tShading: Y')
 +              file.write('\n\t\tCulling: "CullingOff"')
 +              
 +              
 +              # Write the Real Mesh data here
 +              file.write('\n\t\tVertices: ')
 +              i=-1
 +              
 +              for v in me.verts:
 +                      if i==-1:
 +                              file.write('%.6f,%.6f,%.6f' % tuple(v.co));     i=0
 +                      else:
 +                              if i==7:
 +                                      file.write('\n\t\t');   i=0
 +                              file.write(',%.6f,%.6f,%.6f'% tuple(v.co))
 +                      i+=1
 +                              
 +              file.write('\n\t\tPolygonVertexIndex: ')
 +              i=-1
 +              for f in me.faces:
 +                      fi = [v_index for j, v_index in enumerate(f.verts) if v_index != 0 or j != 3]
 +#                     fi = [v.index for v in f]
 +
 +                      # flip the last index, odd but it looks like
 +                      # this is how fbx tells one face from another
 +                      fi[-1] = -(fi[-1]+1)
 +                      fi = tuple(fi)
 +                      if i==-1:
 +                              if len(fi) == 3:        file.write('%i,%i,%i' % fi )
 +#                             if len(f) == 3:         file.write('%i,%i,%i' % fi )
 +                              else:                           file.write('%i,%i,%i,%i' % fi )
 +                              i=0
 +                      else:
 +                              if i==13:
 +                                      file.write('\n\t\t')
 +                                      i=0
 +                              if len(fi) == 3:        file.write(',%i,%i,%i' % fi )
 +#                             if len(f) == 3:         file.write(',%i,%i,%i' % fi )
 +                              else:                           file.write(',%i,%i,%i,%i' % fi )
 +                      i+=1
 +              
 +              file.write('\n\t\tEdges: ')
 +              i=-1
 +              for ed in me.edges:
 +                              if i==-1:
 +                                      file.write('%i,%i' % (ed.verts[0], ed.verts[1]))
 +#                                     file.write('%i,%i' % (ed.v1.index, ed.v2.index))
 +                                      i=0
 +                              else:
 +                                      if i==13:
 +                                              file.write('\n\t\t')
 +                                              i=0
 +                                      file.write(',%i,%i' % (ed.verts[0], ed.verts[1]))
 +#                                     file.write(',%i,%i' % (ed.v1.index, ed.v2.index))
 +                              i+=1
 +              
 +              file.write('\n\t\tGeometryVersion: 124')
 +              
 +              file.write('''
 +              LayerElementNormal: 0 {
 +                      Version: 101
 +                      Name: ""
 +                      MappingInformationType: "ByVertice"
 +                      ReferenceInformationType: "Direct"
 +                      Normals: ''')
 +              
 +              i=-1
 +              for v in me.verts:
 +                      if i==-1:
 +                              file.write('%.15f,%.15f,%.15f' % tuple(v.normal));      i=0
 +#                             file.write('%.15f,%.15f,%.15f' % tuple(v.no));  i=0
 +                      else:
 +                              if i==2:
 +                                      file.write('\n                   ');    i=0
 +                              file.write(',%.15f,%.15f,%.15f' % tuple(v.normal))
 +#                             file.write(',%.15f,%.15f,%.15f' % tuple(v.no))
 +                      i+=1
 +              file.write('\n\t\t}')
 +              
 +              # Write Face Smoothing
 +              file.write('''
 +              LayerElementSmoothing: 0 {
 +                      Version: 102
 +                      Name: ""
 +                      MappingInformationType: "ByPolygon"
 +                      ReferenceInformationType: "Direct"
 +                      Smoothing: ''')
 +              
 +              i=-1
 +              for f in me.faces:
 +                      if i==-1:
 +                              file.write('%i' % f.smooth);    i=0
 +                      else:
 +                              if i==54:
 +                                      file.write('\n                   ');    i=0
 +                              file.write(',%i' % f.smooth)
 +                      i+=1
 +              
 +              file.write('\n\t\t}')
 +              
 +              # Write Edge Smoothing
 +              file.write('''
 +              LayerElementSmoothing: 0 {
 +                      Version: 101
 +                      Name: ""
 +                      MappingInformationType: "ByEdge"
 +                      ReferenceInformationType: "Direct"
 +                      Smoothing: ''')
 +              
 +#             SHARP = Blender.Mesh.EdgeFlags.SHARP
 +              i=-1
 +              for ed in me.edges:
 +                      if i==-1:
 +                              file.write('%i' % (ed.sharp));  i=0
 +#                             file.write('%i' % ((ed.flag&SHARP)!=0));        i=0
 +                      else:
 +                              if i==54:
 +                                      file.write('\n                   ');    i=0
 +                              file.write(',%i' % (ed.sharp))
 +#                             file.write(',%i' % ((ed.flag&SHARP)!=0))
 +                      i+=1
 +              
 +              file.write('\n\t\t}')
 +#             del SHARP
 +
 +              # small utility function
 +              # returns a slice of data depending on number of face verts
 +              # data is either a MeshTextureFace or MeshColor
 +              def face_data(data, face):
 +                      if f.verts[3] == 0:
 +                              totvert = 3
 +                      else:
 +                              totvert = 4
 +                                              
 +                      return data[:totvert]
 +
 +              
 +              # Write VertexColor Layers
 +              # note, no programs seem to use this info :/
 +              collayers = []
 +              if len(me.vertex_colors):
 +#             if me.vertexColors:
 +                      collayers = me.vertex_colors
 +#                     collayers = me.getColorLayerNames()
 +                      collayer_orig = me.active_vertex_color
 +#                     collayer_orig = me.activeColorLayer
 +                      for colindex, collayer in enumerate(collayers):
 +#                             me.activeColorLayer = collayer
 +                              file.write('\n\t\tLayerElementColor: %i {' % colindex)
 +                              file.write('\n\t\t\tVersion: 101')
 +                              file.write('\n\t\t\tName: "%s"' % collayer.name)
 +#                             file.write('\n\t\t\tName: "%s"' % collayer)
 +                              
 +                              file.write('''
 +                      MappingInformationType: "ByPolygonVertex"
 +                      ReferenceInformationType: "IndexToDirect"
 +                      Colors: ''')
 +                      
 +                              i = -1
 +                              ii = 0 # Count how many Colors we write
 +
 +                              for f, cf in zip(me.faces, collayer.data):
 +                                      colors = [cf.color1, cf.color2, cf.color3, cf.color4]
 +
 +                                      # determine number of verts
 +                                      colors = face_data(colors, f)
 +
 +                                      for col in colors:
 +                                              if i==-1:
 +                                                      file.write('%.4f,%.4f,%.4f,1' % tuple(col))
 +                                                      i=0
 +                                              else:
 +                                                      if i==7:
 +                                                              file.write('\n\t\t\t\t')
 +                                                              i=0
 +                                                      file.write(',%.4f,%.4f,%.4f,1' % tuple(col))
 +                                              i+=1
 +                                              ii+=1 # One more Color
 +
 +#                             for f in me.faces:
 +#                                     for col in f.col:
 +#                                             if i==-1:
 +#                                                     file.write('%.4f,%.4f,%.4f,1' % (col[0]/255.0, col[1]/255.0, col[2]/255.0))
 +#                                                     i=0
 +#                                             else:
 +#                                                     if i==7:
 +#                                                             file.write('\n\t\t\t\t')
 +#                                                             i=0
 +#                                                     file.write(',%.4f,%.4f,%.4f,1' % (col[0]/255.0, col[1]/255.0, col[2]/255.0))
 +#                                             i+=1
 +#                                             ii+=1 # One more Color
 +                              
 +                              file.write('\n\t\t\tColorIndex: ')
 +                              i = -1
 +                              for j in range(ii):
 +                                      if i == -1:
 +                                              file.write('%i' % j)
 +                                              i=0
 +                                      else:
 +                                              if i==55:
 +                                                      file.write('\n\t\t\t\t')
 +                                                      i=0
 +                                              file.write(',%i' % j)
 +                                      i+=1
 +                              
 +                              file.write('\n\t\t}')
 +              
 +              
 +              
 +              # Write UV and texture layers.
 +              uvlayers = []
 +              if do_uvs:
 +                      uvlayers = me.uv_textures
 +#                     uvlayers = me.getUVLayerNames()
 +                      uvlayer_orig = me.active_uv_texture
 +#                     uvlayer_orig = me.activeUVLayer
 +                      for uvindex, uvlayer in enumerate(me.uv_textures):
 +#                     for uvindex, uvlayer in enumerate(uvlayers):
 +#                             me.activeUVLayer = uvlayer
 +                              file.write('\n\t\tLayerElementUV: %i {' % uvindex)
 +                              file.write('\n\t\t\tVersion: 101')
 +                              file.write('\n\t\t\tName: "%s"' % uvlayer.name)
 +#                             file.write('\n\t\t\tName: "%s"' % uvlayer)
 +                              
 +                              file.write('''
 +                      MappingInformationType: "ByPolygonVertex"
 +                      ReferenceInformationType: "IndexToDirect"
 +                      UV: ''')
 +                      
 +                              i = -1
 +                              ii = 0 # Count how many UVs we write
 +                              
 +                              for f, uf in zip(me.faces, uvlayer.data):
 +#                             for f in me.faces:
 +                                      uvs = [uf.uv1, uf.uv2, uf.uv3, uf.uv4]
 +                                      uvs = face_data(uvs, f)
 +                                      
 +                                      for uv in uvs:
 +#                                     for uv in f.uv:
 +                                              if i==-1:
 +                                                      file.write('%.6f,%.6f' % tuple(uv))
 +                                                      i=0
 +                                              else:
 +                                                      if i==7:
 +                                                              file.write('\n                   ')
 +                                                              i=0
 +                                                      file.write(',%.6f,%.6f' % tuple(uv))
 +                                              i+=1
 +                                              ii+=1 # One more UV
 +                              
 +                              file.write('\n\t\t\tUVIndex: ')
 +                              i = -1
 +                              for j in range(ii):
 +                                      if i == -1:
 +                                              file.write('%i'  % j)
 +                                              i=0
 +                                      else:
 +                                              if i==55:
 +                                                      file.write('\n\t\t\t\t')
 +                                                      i=0
 +                                              file.write(',%i' % j)
 +                                      i+=1
 +                              
 +                              file.write('\n\t\t}')
 +                              
 +                              if do_textures:
 +                                      file.write('\n\t\tLayerElementTexture: %i {' % uvindex)
 +                                      file.write('\n\t\t\tVersion: 101')
 +                                      file.write('\n\t\t\tName: "%s"' % uvlayer.name)
 +#                                     file.write('\n\t\t\tName: "%s"' % uvlayer)
 +                                      
 +                                      if len(my_mesh.blenTextures) == 1:
 +                                              file.write('\n\t\t\tMappingInformationType: "AllSame"')
 +                                      else:
 +                                              file.write('\n\t\t\tMappingInformationType: "ByPolygon"')
 +                                      
 +                                      file.write('\n\t\t\tReferenceInformationType: "IndexToDirect"')
 +                                      file.write('\n\t\t\tBlendMode: "Translucent"')
 +                                      file.write('\n\t\t\tTextureAlpha: 1')
 +                                      file.write('\n\t\t\tTextureId: ')
 +                                      
 +                                      if len(my_mesh.blenTextures) == 1:
 +                                              file.write('0')
 +                                      else:
 +                                              texture_mapping_local = {None:-1}
 +                                              
 +                                              i = 0 # 1 for dummy
 +                                              for tex in my_mesh.blenTextures:
 +                                                      if tex: # None is set above
 +                                                              texture_mapping_local[tex] = i
 +                                                              i+=1
 +                                              
 +                                              i=-1
 +                                              for f in uvlayer.data:
 +#                                             for f in me.faces:
 +                                                      img_key = f.image
 +                                                      
 +                                                      if i==-1:
 +                                                              i=0
 +                                                              file.write( '%s' % texture_mapping_local[img_key])
 +                                                      else:
 +                                                              if i==55:
 +                                                                      file.write('\n                   ')
 +                                                                      i=0
 +                                                              
 +                                                              file.write(',%s' % texture_mapping_local[img_key])
 +                                                      i+=1
 +                              
 +                              else:
 +                                      file.write('''
 +              LayerElementTexture: 0 {
 +                      Version: 101
 +                      Name: ""
 +                      MappingInformationType: "NoMappingInformation"
 +                      ReferenceInformationType: "IndexToDirect"
 +                      BlendMode: "Translucent"
 +                      TextureAlpha: 1
 +                      TextureId: ''')
 +                              file.write('\n\t\t}')
 +                      
 +#                     me.activeUVLayer = uvlayer_orig
 +                      
 +              # Done with UV/textures.
 +              
 +              if do_materials:
 +                      file.write('\n\t\tLayerElementMaterial: 0 {')
 +                      file.write('\n\t\t\tVersion: 101')
 +                      file.write('\n\t\t\tName: ""')
 +                      
 +                      if len(my_mesh.blenMaterials) == 1:
 +                              file.write('\n\t\t\tMappingInformationType: "AllSame"')
 +                      else:
 +                              file.write('\n\t\t\tMappingInformationType: "ByPolygon"')
 +                      
 +                      file.write('\n\t\t\tReferenceInformationType: "IndexToDirect"')
 +                      file.write('\n\t\t\tMaterials: ')
 +                      
 +                      if len(my_mesh.blenMaterials) == 1:
 +                              file.write('0')
 +                      else:
 +                              # Build a material mapping for this 
 +                              material_mapping_local = {} # local-mat & tex : global index.
 +                              
 +                              for j, mat_tex_pair in enumerate(my_mesh.blenMaterials):
 +                                      material_mapping_local[mat_tex_pair] = j
 +                              
 +                              len_material_mapping_local = len(material_mapping_local)
 +                              
 +                              mats = my_mesh.blenMaterialList
 +
 +                              if me.active_uv_texture:
 +                                      uv_faces = me.active_uv_texture.data
 +                              else:
 +                                      uv_faces = [None] * len(me.faces)
 +                              
 +                              i=-1
 +                              for f, uf in zip(me.faces, uv_faces):
 +#                             for f in me.faces:
 +                                      try:    mat = mats[f.material_index]
 +#                                     try:    mat = mats[f.mat]
 +                                      except:mat = None
 +                                      
 +                                      if do_uvs: tex = uf.image # WARNING - MULTI UV LAYER IMAGES NOT SUPPORTED :/
 +#                                     if do_uvs: tex = f.image # WARNING - MULTI UV LAYER IMAGES NOT SUPPORTED :/
 +                                      else: tex = None
 +                                      
 +                                      if i==-1:
 +                                              i=0
 +                                              file.write( '%s' % (material_mapping_local[mat, tex])) # None for mat or tex is ok
 +                                      else:
 +                                              if i==55:
 +                                                      file.write('\n\t\t\t\t')
 +                                                      i=0
 +                                              
 +                                              file.write(',%s' % (material_mapping_local[mat, tex]))
 +                                      i+=1
 +                      
 +                      file.write('\n\t\t}')
 +              
 +              file.write('''
 +              Layer: 0 {
 +                      Version: 100
 +                      LayerElement:  {
 +                              Type: "LayerElementNormal"
 +                              TypedIndex: 0
 +                      }''')
 +              
 +              if do_materials:
 +                      file.write('''
 +                      LayerElement:  {
 +                              Type: "LayerElementMaterial"
 +                              TypedIndex: 0
 +                      }''')
 +                      
 +              # Always write this
 +              if do_textures:
 +                      file.write('''
 +                      LayerElement:  {
 +                              Type: "LayerElementTexture"
 +                              TypedIndex: 0
 +                      }''')
 +              
 +              if me.vertex_colors:
 +#             if me.vertexColors:
 +                      file.write('''
 +                      LayerElement:  {
 +                              Type: "LayerElementColor"
 +                              TypedIndex: 0
 +                      }''')
 +              
 +              if do_uvs: # same as me.faceUV
 +                      file.write('''
 +                      LayerElement:  {
 +                              Type: "LayerElementUV"
 +                              TypedIndex: 0
 +                      }''')
 +              
 +              
 +              file.write('\n\t\t}')
 +              
 +              if len(uvlayers) > 1:
 +                      for i in range(1, len(uvlayers)):
 +                              
 +                              file.write('\n\t\tLayer: %i {' % i)
 +                              file.write('\n\t\t\tVersion: 100')
 +                              
 +                              file.write('''
 +                      LayerElement:  {
 +                              Type: "LayerElementUV"''')
 +                              
 +                              file.write('\n\t\t\t\tTypedIndex: %i' % i)
 +                              file.write('\n\t\t\t}')
 +                              
 +                              if do_textures:
 +                                      
 +                                      file.write('''
 +                      LayerElement:  {
 +                              Type: "LayerElementTexture"''')
 +                                      
 +                                      file.write('\n\t\t\t\tTypedIndex: %i' % i)
 +                                      file.write('\n\t\t\t}')
 +                              
 +                              file.write('\n\t\t}')
 +              
 +              if len(collayers) > 1:
 +                      # Take into account any UV layers
 +                      layer_offset = 0
 +                      if uvlayers: layer_offset = len(uvlayers)-1
 +                      
 +                      for i in range(layer_offset, len(collayers)+layer_offset):
 +                              file.write('\n\t\tLayer: %i {' % i)
 +                              file.write('\n\t\t\tVersion: 100')
 +                              
 +                              file.write('''
 +                      LayerElement:  {
 +                              Type: "LayerElementColor"''')
 +                              
 +                              file.write('\n\t\t\t\tTypedIndex: %i' % i)
 +                              file.write('\n\t\t\t}')
 +                              file.write('\n\t\t}')
 +              file.write('\n\t}')
 +      
 +      def write_group(name):
 +              file.write('\n\tGroupSelection: "GroupSelection::%s", "Default" {' % name)
 +              
 +              file.write('''
 +              Properties60:  {
 +                      Property: "MultiLayer", "bool", "",0
 +                      Property: "Pickable", "bool", "",1
 +                      Property: "Transformable", "bool", "",1
 +                      Property: "Show", "bool", "",1
 +              }
 +              MultiLayer: 0
 +      }''')
 +      
 +      
 +      # add meshes here to clear because they are not used anywhere.
 +      meshes_to_clear = []
 +      
 +      ob_meshes = []  
 +      ob_lights = []
 +      ob_cameras = []
 +      # in fbx we export bones as children of the mesh
 +      # armatures not a part of a mesh, will be added to ob_arms
 +      ob_bones = [] 
 +      ob_arms = []
 +      ob_null = [] # emptys
 +      
 +      # List of types that have blender objects (not bones)
 +      ob_all_typegroups = [ob_meshes, ob_lights, ob_cameras, ob_arms, ob_null]
 +      
 +      groups = [] # blender groups, only add ones that have objects in the selections
 +      materials = {} # (mat, image) keys, should be a set()
 +      textures = {} # should be a set()
 +      
 +      tmp_ob_type = ob_type = None # incase no objects are exported, so as not to raise an error
 +      
 +      # if EXP_OBS_SELECTED is false, use sceens objects
 +      if not batch_objects:
 +              if EXP_OBS_SELECTED:    tmp_objects = context.selected_objects
 +#             if EXP_OBS_SELECTED:    tmp_objects = sce.objects.context
 +              else:                                   tmp_objects = sce.objects
 +      else:
 +              tmp_objects = batch_objects
 +      
 +      if EXP_ARMATURE:
 +              # This is needed so applying modifiers dosnt apply the armature deformation, its also needed
 +              # ...so mesh objects return their rest worldspace matrix when bone-parents are exported as weighted meshes.
 +              # set every armature to its rest, backup the original values so we done mess up the scene
 +              ob_arms_orig_rest = [arm.rest_position for arm in bpy.data.armatures]
 +#             ob_arms_orig_rest = [arm.restPosition for arm in bpy.data.armatures]
 +              
 +              for arm in bpy.data.armatures:
 +                      arm.rest_position = True
 +#                     arm.restPosition = True
 +              
 +              if ob_arms_orig_rest:
 +                      for ob_base in bpy.data.objects:
 +                              #if ob_base.type == 'Armature':
 +                              ob_base.make_display_list()
 +#                             ob_base.makeDisplayList()
 +                                      
 +                      # This causes the makeDisplayList command to effect the mesh
 +                      sce.set_frame(sce.current_frame)
 +#                     Blender.Set('curframe', Blender.Get('curframe'))
 +                      
 +      
 +      for ob_base in tmp_objects:
 +
 +              # ignore dupli children
 +              if ob_base.parent and ob_base.parent.dupli_type != 'NONE':
 +                      continue
 +
 +              obs = [(ob_base, ob_base.matrix)]
 +              if ob_base.dupli_type != 'NONE':
 +                      ob_base.create_dupli_list()
 +                      obs = [(dob.object, dob.matrix) for dob in ob_base.dupli_list]
 +
 +              for ob, mtx in obs:
 +#             for ob, mtx in BPyObject.getDerivedObjects(ob_base):
 +                      tmp_ob_type = ob.type
 +                      if tmp_ob_type == 'CAMERA':
 +#                     if tmp_ob_type == 'Camera':
 +                              if EXP_CAMERA:
 +                                      ob_cameras.append(my_object_generic(ob, mtx))
 +                      elif tmp_ob_type == 'LAMP':
 +#                     elif tmp_ob_type == 'Lamp':
 +                              if EXP_LAMP:
 +                                      ob_lights.append(my_object_generic(ob, mtx))
 +                      elif tmp_ob_type == 'ARMATURE':
 +#                     elif tmp_ob_type == 'Armature':
 +                              if EXP_ARMATURE:
 +                                      # TODO - armatures dont work in dupligroups!
 +                                      if ob not in ob_arms: ob_arms.append(ob)
 +                                      # ob_arms.append(ob) # replace later. was "ob_arms.append(sane_obname(ob), ob)"
 +                      elif tmp_ob_type == 'EMPTY':
 +#                     elif tmp_ob_type == 'Empty':
 +                              if EXP_EMPTY:
 +                                      ob_null.append(my_object_generic(ob, mtx))
 +                      elif EXP_MESH:
 +                              origData = True
 +                              if tmp_ob_type != 'MESH':
 +#                             if tmp_ob_type != 'Mesh':
 +#                                     me = bpy.data.meshes.new()
 +                                      try:    me = ob.create_mesh(True, 'PREVIEW')
 +#                                     try:    me.getFromObject(ob)
 +                                      except: me = None
 +                                      if me:
 +                                              meshes_to_clear.append( me )
 +                                              mats = me.materials
 +                                              origData = False
 +                              else:
 +                                      # Mesh Type!
 +                                      if EXP_MESH_APPLY_MOD:
 +#                                             me = bpy.data.meshes.new()
 +                                              me = ob.create_mesh(True, 'PREVIEW')
 +#                                             me.getFromObject(ob)
 +                                              
 +                                              # so we keep the vert groups
 +#                                             if EXP_ARMATURE:
 +#                                                     orig_mesh = ob.getData(mesh=1)
 +#                                                     if orig_mesh.getVertGroupNames():
 +#                                                             ob.copy().link(me)
 +#                                                             # If new mesh has no vgroups we can try add if verts are teh same
 +#                                                             if not me.getVertGroupNames(): # vgroups were not kept by the modifier
 +#                                                                     if len(me.verts) == len(orig_mesh.verts):
 +#                                                                             groupNames, vWeightDict = BPyMesh.meshWeight2Dict(orig_mesh)
 +#                                                                             BPyMesh.dict2MeshWeight(me, groupNames, vWeightDict)
 +                                              
 +                                              # print ob, me, me.getVertGroupNames()
 +                                              meshes_to_clear.append( me )
 +                                              origData = False
 +                                              mats = me.materials
 +                                      else:
 +                                              me = ob.data
 +#                                             me = ob.getData(mesh=1)
 +                                              mats = me.materials
 +                                              
 +#                                             # Support object colors
 +#                                             tmp_colbits = ob.colbits
 +#                                             if tmp_colbits:
 +#                                                     tmp_ob_mats = ob.getMaterials(1) # 1 so we get None's too.
 +#                                                     for i in xrange(16):
 +#                                                             if tmp_colbits & (1<<i):
 +#                                                                     mats[i] = tmp_ob_mats[i]
 +#                                                     del tmp_ob_mats
 +#                                             del tmp_colbits
 +                                                      
 +                                      
 +                              if me:
 +#                                     # This WILL modify meshes in blender if EXP_MESH_APPLY_MOD is disabled.
 +#                                     # so strictly this is bad. but only in rare cases would it have negative results
 +#                                     # say with dupliverts the objects would rotate a bit differently
 +#                                     if EXP_MESH_HQ_NORMALS:
 +#                                             BPyMesh.meshCalcNormals(me) # high quality normals nice for realtime engines.
 +                                      
 +                                      texture_mapping_local = {}
 +                                      material_mapping_local = {}
 +                                      if len(me.uv_textures) > 0:
 +#                                     if me.faceUV:
 +                                              uvlayer_orig = me.active_uv_texture
 +#                                             uvlayer_orig = me.activeUVLayer
 +                                              for uvlayer in me.uv_textures:
 +#                                             for uvlayer in me.getUVLayerNames():
 +#                                                     me.activeUVLayer = uvlayer
 +                                                      for f, uf in zip(me.faces, uvlayer.data):
 +#                                                     for f in me.faces:
 +                                                              tex = uf.image
 +#                                                             tex = f.image
 +                                                              textures[tex] = texture_mapping_local[tex] = None
 +                                                              
 +                                                              try: mat = mats[f.material_index]
 +#                                                             try: mat = mats[f.mat]
 +                                                              except: mat = None
 +                                                              
 +                                                              materials[mat, tex] = material_mapping_local[mat, tex] = None # should use sets, wait for blender 2.5
 +                                                                      
 +                                                      
 +#                                                     me.activeUVLayer = uvlayer_orig
 +                                      else:
 +                                              for mat in mats:
 +                                                      # 2.44 use mat.lib too for uniqueness
 +                                                      materials[mat, None] = material_mapping_local[mat, None] = None
 +                                              else:
 +                                                      materials[None, None] = None
 +                                      
 +                                      if EXP_ARMATURE:
 +                                              armob = ob.find_armature()
 +                                              blenParentBoneName = None
 +                                              
 +                                              # parent bone - special case
 +                                              if (not armob) and ob.parent and ob.parent.type == 'ARMATURE' and \
 +                                                              ob.parent_type == 'BONE':
 +#                                             if (not armob) and ob.parent and ob.parent.type == 'Armature' and ob.parentType == Blender.Object.ParentTypes.BONE:
 +                                                      armob = ob.parent
 +                                                      blenParentBoneName = ob.parent_bone
 +#                                                     blenParentBoneName = ob.parentbonename
 +                                              
 +                                                      
 +                                              if armob and armob not in ob_arms:
 +                                                      ob_arms.append(armob)
 +                                      
 +                                      else:
 +                                              blenParentBoneName = armob = None
 +                                      
 +                                      my_mesh = my_object_generic(ob, mtx)
 +                                      my_mesh.blenData =              me
 +                                      my_mesh.origData =              origData
 +                                      my_mesh.blenMaterials = list(material_mapping_local.keys())
 +                                      my_mesh.blenMaterialList = mats
 +                                      my_mesh.blenTextures =  list(texture_mapping_local.keys())
 +                                      
 +                                      # if only 1 null texture then empty the list
 +                                      if len(my_mesh.blenTextures) == 1 and my_mesh.blenTextures[0] == None:
 +                                              my_mesh.blenTextures = []
 +                                      
 +                                      my_mesh.fbxArm =        armob                                   # replace with my_object_generic armature instance later
 +                                      my_mesh.fbxBoneParent = blenParentBoneName      # replace with my_bone instance later
 +                                      
 +                                      ob_meshes.append( my_mesh )
 +
 +              # not forgetting to free dupli_list
 +              if ob_base.dupli_list: ob_base.free_dupli_list()
 +
 +
 +      if EXP_ARMATURE:
 +              # now we have the meshes, restore the rest arm position
 +              for i, arm in enumerate(bpy.data.armatures):
 +                      arm.rest_position = ob_arms_orig_rest[i]
 +#                     arm.restPosition = ob_arms_orig_rest[i]
 +                      
 +              if ob_arms_orig_rest:
 +                      for ob_base in bpy.data.objects:
 +                              if ob_base.type == 'ARMATURE':
 +#                             if ob_base.type == 'Armature':
 +                                      ob_base.make_display_list()
 +#                                     ob_base.makeDisplayList()
 +                      # This causes the makeDisplayList command to effect the mesh
 +                      sce.set_frame(sce.current_frame)
 +#                     Blender.Set('curframe', Blender.Get('curframe'))
 +      
 +      del tmp_ob_type, tmp_objects
 +      
 +      # now we have collected all armatures, add bones
 +      for i, ob in enumerate(ob_arms):
 +              
 +              ob_arms[i] = my_arm = my_object_generic(ob)
 +              
 +              my_arm.fbxBones =               []
 +              my_arm.blenData =               ob.data
 +              if ob.animation_data:
 +                      my_arm.blenAction =     ob.animation_data.action
 +              else:
 +                      my_arm.blenAction = None
 +#             my_arm.blenAction =             ob.action
 +              my_arm.blenActionList = []
 +              
 +              # fbxName, blenderObject, my_bones, blenderActions
 +              #ob_arms[i] = fbxArmObName, ob, arm_my_bones, (ob.action, [])
 +              
 +              for bone in my_arm.blenData.bones:
 +#             for bone in my_arm.blenData.bones.values():
 +                      my_bone = my_bone_class(bone, my_arm)
 +                      my_arm.fbxBones.append( my_bone )
 +                      ob_bones.append( my_bone )
 +      
 +      # add the meshes to the bones and replace the meshes armature with own armature class
 +      #for obname, ob, mtx, me, mats, arm, armname in ob_meshes:
 +      for my_mesh in ob_meshes:
 +              # Replace 
 +              # ...this could be sped up with dictionary mapping but its unlikely for
 +              # it ever to be a bottleneck - (would need 100+ meshes using armatures)
 +              if my_mesh.fbxArm:
 +                      for my_arm in ob_arms:
 +                              if my_arm.blenObject == my_mesh.fbxArm:
 +                                      my_mesh.fbxArm = my_arm
 +                                      break
 +              
 +              for my_bone in ob_bones:
 +                      
 +                      # The mesh uses this bones armature!
 +                      if my_bone.fbxArm == my_mesh.fbxArm:
 +                              my_bone.blenMeshes[my_mesh.fbxName] = me
 +                              
 +                              
 +                              # parent bone: replace bone names with our class instances
 +                              # my_mesh.fbxBoneParent is None or a blender bone name initialy, replacing if the names match.
 +                              if my_mesh.fbxBoneParent == my_bone.blenName:
 +                                      my_mesh.fbxBoneParent = my_bone
 +      
 +      bone_deformer_count = 0 # count how many bones deform a mesh
 +      my_bone_blenParent = None
 +      for my_bone in ob_bones:
 +              my_bone_blenParent = my_bone.blenBone.parent
 +              if my_bone_blenParent:
 +                      for my_bone_parent in ob_bones:
 +                              # Note 2.45rc2 you can compare bones normally
 +                              if my_bone_blenParent.name == my_bone_parent.blenName and my_bone.fbxArm == my_bone_parent.fbxArm:
 +                                      my_bone.parent = my_bone_parent
 +                                      break
 +              
 +              # Not used at the moment
 +              # my_bone.calcRestMatrixLocal()
 +              bone_deformer_count += len(my_bone.blenMeshes)
 +      
 +      del my_bone_blenParent 
 +      
 +      
 +      # Build blenObject -> fbxObject mapping
 +      # this is needed for groups as well as fbxParenting
 +#     for ob in bpy.data.objects:     ob.tag = False
 +#     bpy.data.objects.tag = False
 +
 +      # using a list of object names for tagging (Arystan)
 +      tagged_objects = []
 +
 +      tmp_obmapping = {}
 +      for ob_generic in ob_all_typegroups:
 +              for ob_base in ob_generic:
 +                      tagged_objects.append(ob_base.blenObject.name)
 +#                     ob_base.blenObject.tag = True
 +                      tmp_obmapping[ob_base.blenObject] = ob_base
 +      
 +      # Build Groups from objects we export
 +      for blenGroup in bpy.data.groups:
 +              fbxGroupName = None
 +              for ob in blenGroup.objects:
 +                      if ob.name in tagged_objects:
 +#                     if ob.tag:
 +                              if fbxGroupName == None:
 +                                      fbxGroupName = sane_groupname(blenGroup)
 +                                      groups.append((fbxGroupName, blenGroup))
 +                              
 +                              tmp_obmapping[ob].fbxGroupNames.append(fbxGroupName) # also adds to the objects fbxGroupNames
 +      
 +      groups.sort() # not really needed
 +      
 +      # Assign parents using this mapping
 +      for ob_generic in ob_all_typegroups:
 +              for my_ob in ob_generic:
 +                      parent = my_ob.blenObject.parent
 +                      if parent and parent.name in tagged_objects: # does it exist and is it in the mapping
 +#                     if parent and parent.tag: # does it exist and is it in the mapping
 +                              my_ob.fbxParent = tmp_obmapping[parent]
 +      
 +      
 +      del tmp_obmapping
 +      # Finished finding groups we use
 +      
 +      
 +      materials =     [(sane_matname(mat_tex_pair), mat_tex_pair) for mat_tex_pair in materials.keys()]
 +      textures =      [(sane_texname(tex), tex) for tex in textures.keys()  if tex]
 +      materials.sort() # sort by name
 +      textures.sort()
 +      
 +      camera_count = 8
 +      file.write('''
 +
 +; Object definitions
 +;------------------------------------------------------------------
 +
 +Definitions:  {
 +      Version: 100
 +      Count: %i''' % (\
 +              1+1+camera_count+\
 +              len(ob_meshes)+\
 +              len(ob_lights)+\
 +              len(ob_cameras)+\
 +              len(ob_arms)+\
 +              len(ob_null)+\
 +              len(ob_bones)+\
 +              bone_deformer_count+\
 +              len(materials)+\
 +              (len(textures)*2))) # add 1 for the root model 1 for global settings
 +      
 +      del bone_deformer_count
 +      
 +      file.write('''
 +      ObjectType: "Model" {
 +              Count: %i
 +      }''' % (\
 +              1+camera_count+\
 +              len(ob_meshes)+\
 +              len(ob_lights)+\
 +              len(ob_cameras)+\
 +              len(ob_arms)+\
 +              len(ob_null)+\
 +              len(ob_bones))) # add 1 for the root model
 +      
 +      file.write('''
 +      ObjectType: "Geometry" {
 +              Count: %i
 +      }''' % len(ob_meshes))
 +      
 +      if materials:
 +              file.write('''
 +      ObjectType: "Material" {
 +              Count: %i
 +      }''' % len(materials))
 +      
 +      if textures:
 +              file.write('''
 +      ObjectType: "Texture" {
 +              Count: %i
 +      }''' % len(textures)) # add 1 for an empty tex
 +              file.write('''
 +      ObjectType: "Video" {
 +              Count: %i
 +      }''' % len(textures)) # add 1 for an empty tex
 +      
 +      tmp = 0
 +      # Add deformer nodes
 +      for my_mesh in ob_meshes:
 +              if my_mesh.fbxArm:
 +                      tmp+=1
 +      
 +      # Add subdeformers
 +      for my_bone in ob_bones:
 +              tmp += len(my_bone.blenMeshes)
 +      
 +      if tmp:
 +              file.write('''
 +      ObjectType: "Deformer" {
 +              Count: %i
 +      }''' % tmp)
 +      del tmp
 +      
 +      # we could avoid writing this possibly but for now just write it
 +      
 +      file.write('''
 +      ObjectType: "Pose" {
 +              Count: 1
 +      }''')
 +      
 +      if groups:
 +              file.write('''
 +      ObjectType: "GroupSelection" {
 +              Count: %i
 +      }''' % len(groups))
 +      
 +      file.write('''
 +      ObjectType: "GlobalSettings" {
 +              Count: 1
 +      }
 +}''')
 +
 +      file.write('''
 +
 +; Object properties
 +;------------------------------------------------------------------
 +
 +Objects:  {''')
 +      
 +      # To comply with other FBX FILES
 +      write_camera_switch()
 +      
 +      # Write the null object
 +      write_null(None, 'blend_root')# , GLOBAL_MATRIX) 
 +      
 +      for my_null in ob_null:
 +              write_null(my_null)
 +      
 +      for my_arm in ob_arms:
 +              write_null(my_arm)
 +      
 +      for my_cam in ob_cameras:
 +              write_camera(my_cam)
 +
 +      for my_light in ob_lights:
 +              write_light(my_light)
 +      
 +      for my_mesh in ob_meshes:
 +              write_mesh(my_mesh)
 +
 +      #for bonename, bone, obname, me, armob in ob_bones:
 +      for my_bone in ob_bones:
 +              write_bone(my_bone)
 +      
 +      write_camera_default()
 +      
 +      for matname, (mat, tex) in materials:
 +              write_material(matname, mat) # We only need to have a material per image pair, but no need to write any image info into the material (dumb fbx standard)
 +      
 +      # each texture uses a video, odd
 +      for texname, tex in textures:
 +              write_video(texname, tex)
 +      i = 0
 +      for texname, tex in textures:
 +              write_texture(texname, tex, i)
 +              i+=1
 +      
 +      for groupname, group in groups:
 +              write_group(groupname)
 +      
 +      # NOTE - c4d and motionbuilder dont need normalized weights, but deep-exploration 5 does and (max?) do.
 +      
 +      # Write armature modifiers
 +      # TODO - add another MODEL? - because of this skin definition.
 +      for my_mesh in ob_meshes:
 +              if my_mesh.fbxArm:
 +                      write_deformer_skin(my_mesh.fbxName)
 +                      
 +                      # Get normalized weights for temorary use
 +                      if my_mesh.fbxBoneParent:
 +                              weights = None
 +                      else:
 +                              weights = meshNormalizedWeights(my_mesh.blenObject)
 +#                             weights = meshNormalizedWeights(my_mesh.blenData)
 +                      
 +                      #for bonename, bone, obname, bone_mesh, armob in ob_bones:
 +                      for my_bone in ob_bones:
 +                              if me in iter(my_bone.blenMeshes.values()):
 +                                      write_sub_deformer_skin(my_mesh, my_bone, weights)
 +      
 +      # Write pose's really weired, only needed when an armature and mesh are used together
 +      # each by themselves dont need pose data. for now only pose meshes and bones
 +      
 +      file.write('''
 +      Pose: "Pose::BIND_POSES", "BindPose" {
 +              Type: "BindPose"
 +              Version: 100
 +              Properties60:  {
 +              }
 +              NbPoseNodes: ''')
 +      file.write(str(len(pose_items)))
 +      
 +
 +      for fbxName, matrix in pose_items:
 +              file.write('\n\t\tPoseNode:  {')
 +              file.write('\n\t\t\tNode: "Model::%s"' % fbxName )
 +              if matrix:              file.write('\n\t\t\tMatrix: %s' % mat4x4str(matrix))
 +              else:                   file.write('\n\t\t\tMatrix: %s' % mat4x4str(mtx4_identity))
 +              file.write('\n\t\t}')
 +      
 +      file.write('\n\t}')
 +      
 +      
 +      # Finish Writing Objects
 +      # Write global settings
 +      file.write('''
 +      GlobalSettings:  {
 +              Version: 1000
 +              Properties60:  {
 +                      Property: "UpAxis", "int", "",1
 +                      Property: "UpAxisSign", "int", "",1
 +                      Property: "FrontAxis", "int", "",2
 +                      Property: "FrontAxisSign", "int", "",1
 +                      Property: "CoordAxis", "int", "",0
 +                      Property: "CoordAxisSign", "int", "",1
 +                      Property: "UnitScaleFactor", "double", "",100
 +              }
 +      }
 +''')  
 +      file.write('}')
 +      
 +      file.write('''
 +
 +; Object relations
 +;------------------------------------------------------------------
 +
 +Relations:  {''')
 +
 +      file.write('\n\tModel: "Model::blend_root", "Null" {\n\t}')
 +
 +      for my_null in ob_null:
 +              file.write('\n\tModel: "Model::%s", "Null" {\n\t}' % my_null.fbxName)
 +
 +      for my_arm in ob_arms:
 +              file.write('\n\tModel: "Model::%s", "Null" {\n\t}' % my_arm.fbxName)
 +
 +      for my_mesh in ob_meshes:
 +              file.write('\n\tModel: "Model::%s", "Mesh" {\n\t}' % my_mesh.fbxName)
 +
 +      # TODO - limbs can have the same name for multiple armatures, should prefix.
 +      #for bonename, bone, obname, me, armob in ob_bones:
 +      for my_bone in ob_bones:
 +              file.write('\n\tModel: "Model::%s", "Limb" {\n\t}' % my_bone.fbxName)
 +      
 +      for my_cam in ob_cameras:
 +              file.write('\n\tModel: "Model::%s", "Camera" {\n\t}' % my_cam.fbxName)
 +      
 +      for my_light in ob_lights:
 +              file.write('\n\tModel: "Model::%s", "Light" {\n\t}' % my_light.fbxName)
 +      
 +      file.write('''
 +      Model: "Model::Producer Perspective", "Camera" {
 +      }
 +      Model: "Model::Producer Top", "Camera" {
 +      }
 +      Model: "Model::Producer Bottom", "Camera" {
 +      }
 +      Model: "Model::Producer Front", "Camera" {
 +      }
 +      Model: "Model::Producer Back", "Camera" {
 +      }
 +      Model: "Model::Producer Right", "Camera" {
 +      }
 +      Model: "Model::Producer Left", "Camera" {
 +      }
 +      Model: "Model::Camera Switcher", "CameraSwitcher" {
 +      }''')
 +      
 +      for matname, (mat, tex) in materials:
 +              file.write('\n\tMaterial: "Material::%s", "" {\n\t}' % matname)
 +
 +      if textures:
 +              for texname, tex in textures:
 +                      file.write('\n\tTexture: "Texture::%s", "TextureVideoClip" {\n\t}' % texname)
 +              for texname, tex in textures:
 +                      file.write('\n\tVideo: "Video::%s", "Clip" {\n\t}' % texname)
 +
 +      # deformers - modifiers
 +      for my_mesh in ob_meshes:
 +              if my_mesh.fbxArm:
 +                      file.write('\n\tDeformer: "Deformer::Skin %s", "Skin" {\n\t}' % my_mesh.fbxName)
 +      
 +      #for bonename, bone, obname, me, armob in ob_bones:
 +      for my_bone in ob_bones:
 +              for fbxMeshObName in my_bone.blenMeshes: # .keys() - fbxMeshObName
 +                      # is this bone effecting a mesh?
 +                      file.write('\n\tDeformer: "SubDeformer::Cluster %s %s", "Cluster" {\n\t}' % (fbxMeshObName, my_bone.fbxName))
 +      
 +      # This should be at the end
 +      # file.write('\n\tPose: "Pose::BIND_POSES", "BindPose" {\n\t}')
 +      
 +      for groupname, group in groups:
 +              file.write('\n\tGroupSelection: "GroupSelection::%s", "Default" {\n\t}' % groupname)
 +      
 +      file.write('\n}')
 +      file.write('''
 +
 +; Object connections
 +;------------------------------------------------------------------
 +
 +Connections:  {''')
 +      
 +      # NOTE - The FBX SDK dosnt care about the order but some importers DO!
 +      # for instance, defining the material->mesh connection
 +      # before the mesh->blend_root crashes cinema4d
 +      
 +
 +      # write the fake root node
 +      file.write('\n\tConnect: "OO", "Model::blend_root", "Model::Scene"')
 +      
 +      for ob_generic in ob_all_typegroups: # all blender 'Object's we support
 +              for my_ob in ob_generic:
 +                      if my_ob.fbxParent:
 +                              file.write('\n\tConnect: "OO", "Model::%s", "Model::%s"' % (my_ob.fbxName, my_ob.fbxParent.fbxName))
 +                      else:
 +                              file.write('\n\tConnect: "OO", "Model::%s", "Model::blend_root"' % my_ob.fbxName)
 +      
 +      if materials:
 +              for my_mesh in ob_meshes:
 +                      # Connect all materials to all objects, not good form but ok for now.
 +                      for mat, tex in my_mesh.blenMaterials:
 +                              if mat: mat_name = mat.name
 +                              else:   mat_name = None
 +                              
 +                              if tex: tex_name = tex.name
 +                              else:   tex_name = None
 +                              
 +                              file.write('\n\tConnect: "OO", "Material::%s", "Model::%s"' % (sane_name_mapping_mat[mat_name, tex_name], my_mesh.fbxName))
 +      
 +      if textures:
 +              for my_mesh in ob_meshes:
 +                      if my_mesh.blenTextures:
 +                              # file.write('\n\tConnect: "OO", "Texture::_empty_", "Model::%s"' % my_mesh.fbxName)
 +                              for tex in my_mesh.blenTextures:
 +                                      if tex:
 +                                              file.write('\n\tConnect: "OO", "Texture::%s", "Model::%s"' % (sane_name_mapping_tex[tex.name], my_mesh.fbxName))
 +              
 +              for texname, tex in textures:
 +                      file.write('\n\tConnect: "OO", "Video::%s", "Texture::%s"' % (texname, texname))
 +      
 +      for my_mesh in ob_meshes:
 +              if my_mesh.fbxArm:
 +                      file.write('\n\tConnect: "OO", "Deformer::Skin %s", "Model::%s"' % (my_mesh.fbxName, my_mesh.fbxName))
 +      
 +      #for bonename, bone, obname, me, armob in ob_bones:
 +      for my_bone in ob_bones:
 +              for fbxMeshObName in my_bone.blenMeshes: # .keys()
 +                      file.write('\n\tConnect: "OO", "SubDeformer::Cluster %s %s", "Deformer::Skin %s"' % (fbxMeshObName, my_bone.fbxName, fbxMeshObName))
 +      
 +      # limbs -> deformers
 +      # for bonename, bone, obname, me, armob in ob_bones:
 +      for my_bone in ob_bones:
 +              for fbxMeshObName in my_bone.blenMeshes: # .keys()
 +                      file.write('\n\tConnect: "OO", "Model::%s", "SubDeformer::Cluster %s %s"' % (my_bone.fbxName, fbxMeshObName, my_bone.fbxName))
 +      
 +      
 +      #for bonename, bone, obname, me, armob in ob_bones:
 +      for my_bone in ob_bones:
 +              # Always parent to armature now
 +              if my_bone.parent:
 +                      file.write('\n\tConnect: "OO", "Model::%s", "Model::%s"' % (my_bone.fbxName, my_bone.parent.fbxName) )
 +              else:
 +                      # the armature object is written as an empty and all root level bones connect to it
 +                      file.write('\n\tConnect: "OO", "Model::%s", "Model::%s"' % (my_bone.fbxName, my_bone.fbxArm.fbxName) )
 +      
 +      # groups
 +      if groups:
 +              for ob_generic in ob_all_typegroups:
 +                      for ob_base in ob_generic:
 +                              for fbxGroupName in ob_base.fbxGroupNames:
 +                                      file.write('\n\tConnect: "OO", "Model::%s", "GroupSelection::%s"' % (ob_base.fbxName, fbxGroupName))
 +      
 +      for my_arm in ob_arms:
 +              file.write('\n\tConnect: "OO", "Model::%s", "Model::blend_root"' % my_arm.fbxName)
 +      
 +      file.write('\n}')
 +      
 +      
 +      # Needed for scene footer as well as animation
 +      render = sce.render_data
 +#     render = sce.render
 +      
 +      # from the FBX sdk
 +      #define KTIME_ONE_SECOND        KTime (K_LONGLONG(46186158000))
 +      def fbx_time(t):
 +              # 0.5 + val is the same as rounding.
 +              return int(0.5 + ((t/fps) * 46186158000))
 +      
 +      fps = float(render.fps) 
 +      start = sce.start_frame
 +#     start = render.sFrame
 +      end =   sce.end_frame
 +#     end =   render.eFrame
 +      if end < start: start, end = end, start
 +      if start==end: ANIM_ENABLE = False
 +      
 +      # animations for these object types
 +      ob_anim_lists = ob_bones, ob_meshes, ob_null, ob_cameras, ob_lights, ob_arms
 +      
 +      if ANIM_ENABLE and [tmp for tmp in ob_anim_lists if tmp]:
 +              
 +              frame_orig = sce.current_frame
 +#             frame_orig = Blender.Get('curframe')
 +              
 +              if ANIM_OPTIMIZE:
 +                      ANIM_OPTIMIZE_PRECISSION_FLOAT = 0.1 ** ANIM_OPTIMIZE_PRECISSION
 +              
 +              # default action, when no actions are avaioable
 +              tmp_actions = [None] # None is the default action
 +              blenActionDefault = None
 +              action_lastcompat = None
 +
 +              # instead of tagging
 +              tagged_actions = []
 +              
 +              if ANIM_ACTION_ALL:
 +#                     bpy.data.actions.tag = False
 +                      tmp_actions = list(bpy.data.actions)
 +                      
 +                      
 +                      # find which actions are compatible with the armatures
 +                      # blenActions is not yet initialized so do it now.
 +                      tmp_act_count = 0
 +                      for my_arm in ob_arms:
 +                              
 +                              # get the default name
 +                              if not blenActionDefault:
 +                                      blenActionDefault = my_arm.blenAction
 +                              
 +                              arm_bone_names = set([my_bone.blenName for my_bone in my_arm.fbxBones])
 +                              
 +                              for action in tmp_actions:
 +
 +                                      action_chan_names = arm_bone_names.intersection( set([g.name for g in action.groups]) )
 +#                                     action_chan_names = arm_bone_names.intersection( set(action.getChannelNames()) )
 +                                      
 +                                      if action_chan_names: # at least one channel matches.
 +                                              my_arm.blenActionList.append(action)
 +                                              tagged_actions.append(action.name)
 +#                                             action.tag = True
 +                                              tmp_act_count += 1
 +                                              
 +                                              # incase there is no actions applied to armatures
 +                                              action_lastcompat = action
 +                      
 +                      if tmp_act_count:
 +                              # unlikely to ever happen but if no actions applied to armatures, just use the last compatible armature.
 +                              if not blenActionDefault:
 +                                      blenActionDefault = action_lastcompat
 +              
 +              del action_lastcompat
 +              
 +              file.write('''
 +;Takes and animation section
 +;----------------------------------------------------
 +
 +Takes:  {''')
 +              
 +              if blenActionDefault:
 +                      file.write('\n\tCurrent: "%s"' % sane_takename(blenActionDefault))
 +              else:
 +                      file.write('\n\tCurrent: "Default Take"')
 +              
 +              for blenAction in tmp_actions:
 +                      # we have tagged all actious that are used be selected armatures
 +                      if blenAction:
 +                              if blenAction.name in tagged_actions:
 +#                             if blenAction.tag:
 +                                      print('\taction: "%s" exporting...' % blenAction.name)
 +                              else:
 +                                      print('\taction: "%s" has no armature using it, skipping' % blenAction.name)
 +                                      continue
 +                      
 +                      if blenAction == None:
 +                              # Warning, this only accounts for tmp_actions being [None]
 +                              file.write('\n\tTake: "Default Take" {')
 +                              act_start =     start
 +                              act_end =       end
 +                      else:
 +                              # use existing name
 +                              if blenAction == blenActionDefault: # have we alredy got the name
 +                                      file.write('\n\tTake: "%s" {' % sane_name_mapping_take[blenAction.name])
 +                              else:
 +                                      file.write('\n\tTake: "%s" {' % sane_takename(blenAction))
 +
 +                              act_start, act_end = blenAction.get_frame_range()
 +#                             tmp = blenAction.getFrameNumbers()
 +#                             if tmp:
 +#                                     act_start =     min(tmp)
 +#                                     act_end =       max(tmp)
 +#                                     del tmp
 +#                             else:
 +#                                     # Fallback on this, theres not much else we can do? :/
 +#                                     # when an action has no length
 +#                                     act_start =     start
 +#                                     act_end =       end
 +                              
 +                              # Set the action active
 +                              for my_bone in ob_arms:
 +                                      if blenAction in my_bone.blenActionList:
 +                                              ob.action = blenAction
 +                                              # print '\t\tSetting Action!', blenAction
 +                              # sce.update(1)
 +                      
 +                      file.write('\n\t\tFileName: "Default_Take.tak"') # ??? - not sure why this is needed
 +                      file.write('\n\t\tLocalTime: %i,%i' % (fbx_time(act_start-1), fbx_time(act_end-1))) # ??? - not sure why this is needed
 +                      file.write('\n\t\tReferenceTime: %i,%i' % (fbx_time(act_start-1), fbx_time(act_end-1))) # ??? - not sure why this is needed
 +                      
 +                      file.write('''
 +
 +              ;Models animation
 +              ;----------------------------------------------------''')
 +                      
 +                      
 +                      # set pose data for all bones
 +                      # do this here incase the action changes
 +                      '''
 +                      for my_bone in ob_bones:
 +                              my_bone.flushAnimData()
 +                      '''
 +                      i = act_start
 +                      while i <= act_end:
 +                              sce.set_frame(i)
 +#                             Blender.Set('curframe', i)
 +                              for ob_generic in ob_anim_lists:
 +                                      for my_ob in ob_generic:
 +                                              #Blender.Window.RedrawAll()
 +                                              if ob_generic == ob_meshes and my_ob.fbxArm:
 +                                                      # We cant animate armature meshes!
 +                                                      pass
 +                                              else:
 +                                                      my_ob.setPoseFrame(i)
 +                                              
 +                              i+=1
 +                      
 +                      
 +                      #for bonename, bone, obname, me, armob in ob_bones:
 +                      for ob_generic in (ob_bones, ob_meshes, ob_null, ob_cameras, ob_lights, ob_arms):
 +                                      
 +                              for my_ob in ob_generic:
 +                                      
 +                                      if ob_generic == ob_meshes and my_ob.fbxArm:
 +                                              # do nothing,
 +                                              pass
 +                                      else:
 +                                                      
 +                                              file.write('\n\t\tModel: "Model::%s" {' % my_ob.fbxName) # ??? - not sure why this is needed
 +                                              file.write('\n\t\t\tVersion: 1.1')
 +                                              file.write('\n\t\t\tChannel: "Transform" {')
 +                                              
 +                                              context_bone_anim_mats = [ (my_ob.getAnimParRelMatrix(frame), my_ob.getAnimParRelMatrixRot(frame)) for frame in range(act_start, act_end+1) ]
 +                                              
 +                                              # ----------------
 +                                              # ----------------
 +                                              for TX_LAYER, TX_CHAN in enumerate('TRS'): # transform, rotate, scale
 +                                                      
 +                                                      if              TX_CHAN=='T':   context_bone_anim_vecs = [mtx[0].translationPart()      for mtx in context_bone_anim_mats]
 +                                                      elif    TX_CHAN=='S':   context_bone_anim_vecs = [mtx[0].scalePart()            for mtx in context_bone_anim_mats]
 +                                                      elif    TX_CHAN=='R':
 +                                                              # Was....
 +                                                              # elif  TX_CHAN=='R':   context_bone_anim_vecs = [mtx[1].toEuler()                      for mtx in context_bone_anim_mats]
 +                                                              # 
 +                                                              # ...but we need to use the previous euler for compatible conversion.
 +                                                              context_bone_anim_vecs = []
 +                                                              prev_eul = None
 +                                                              for mtx in context_bone_anim_mats:
 +                                                                      if prev_eul:    prev_eul = mtx[1].toEuler(prev_eul)
 +                                                                      else:                   prev_eul = mtx[1].toEuler()
 +                                                                      context_bone_anim_vecs.append(eulerRadToDeg(prev_eul))
 +#                                                                     context_bone_anim_vecs.append(prev_eul)
 +                                                      
 +                                                      file.write('\n\t\t\t\tChannel: "%s" {' % TX_CHAN) # translation
 +                                                      
 +                                                      for i in range(3):
 +                                                              # Loop on each axis of the bone
 +                                                              file.write('\n\t\t\t\t\tChannel: "%s" {'% ('XYZ'[i])) # translation
 +                                                              file.write('\n\t\t\t\t\t\tDefault: %.15f' % context_bone_anim_vecs[0][i] )
 +                                                              file.write('\n\t\t\t\t\t\tKeyVer: 4005')
 +                                                              
 +                                                              if not ANIM_OPTIMIZE:
 +                                                                      # Just write all frames, simple but in-eficient
 +                                                                      file.write('\n\t\t\t\t\t\tKeyCount: %i' % (1 + act_end - act_start))
 +                                                                      file.write('\n\t\t\t\t\t\tKey: ')
 +                                                                      frame = act_start
 +                                                                      while frame <= act_end:
 +                                                                              if frame!=act_start:
 +                                                                                      file.write(',')
 +                                                                              
 +                                                                              # Curve types are 'C,n' for constant, 'L' for linear
 +                                                                              # C,n is for bezier? - linear is best for now so we can do simple keyframe removal
 +                                                                              file.write('\n\t\t\t\t\t\t\t%i,%.15f,L'  % (fbx_time(frame-1), context_bone_anim_vecs[frame-act_start][i] ))
 +                                                                              frame+=1
 +                                                              else:
 +                                                                      # remove unneeded keys, j is the frame, needed when some frames are removed.
 +                                                                      context_bone_anim_keys = [ (vec[i], j) for j, vec in enumerate(context_bone_anim_vecs) ]
 +                                                                      
 +                                                                      # last frame to fisrt frame, missing 1 frame on either side.
 +                                                                      # removeing in a backwards loop is faster
 +                                                                      #for j in xrange( (act_end-act_start)-1, 0, -1 ):
 +                                                                      # j = (act_end-act_start)-1
 +                                                                      j = len(context_bone_anim_keys)-2
 +                                                                      while j > 0 and len(context_bone_anim_keys) > 2:
 +                                                                              # print j, len(context_bone_anim_keys)
 +                                                                              # Is this key the same as the ones next to it?
 +                                                                              
 +                                                                              # co-linear horizontal...
 +                                                                              if              abs(context_bone_anim_keys[j][0] - context_bone_anim_keys[j-1][0]) < ANIM_OPTIMIZE_PRECISSION_FLOAT and\
 +                                                                                              abs(context_bone_anim_keys[j][0] - context_bone_anim_keys[j+1][0]) < ANIM_OPTIMIZE_PRECISSION_FLOAT:
 +                                                                                              
 +                                                                                      del context_bone_anim_keys[j]
 +                                                                                      
 +                                                                              else:
 +                                                                                      frame_range = float(context_bone_anim_keys[j+1][1] - context_bone_anim_keys[j-1][1])
 +                                                                                      frame_range_fac1 = (context_bone_anim_keys[j+1][1] - context_bone_anim_keys[j][1]) / frame_range
 +                                                                                      frame_range_fac2 = 1.0 - frame_range_fac1
 +                                                                                      
 +                                                                                      if abs(((context_bone_anim_keys[j-1][0]*frame_range_fac1 + context_bone_anim_keys[j+1][0]*frame_range_fac2)) - context_bone_anim_keys[j][0]) < ANIM_OPTIMIZE_PRECISSION_FLOAT:
 +                                                                                              del context_bone_anim_keys[j]
 +                                                                                      else:
 +                                                                                              j-=1
 +                                                                                      
 +                                                                              # keep the index below the list length
 +                                                                              if j > len(context_bone_anim_keys)-2:
 +                                                                                      j = len(context_bone_anim_keys)-2
 +                                                                      
 +                                                                      if len(context_bone_anim_keys) == 2 and context_bone_anim_keys[0][0] == context_bone_anim_keys[1][0]:
 +                                                                              # This axis has no moton, its okay to skip KeyCount and Keys in this case
 +                                                                              pass
 +                                                                      else:
 +                                                                              # We only need to write these if there is at least one 
 +                                                                              file.write('\n\t\t\t\t\t\tKeyCount: %i' % len(context_bone_anim_keys))
 +                                                                              file.write('\n\t\t\t\t\t\tKey: ')
 +                                                                              for val, frame in context_bone_anim_keys:
 +                                                                                      if frame != context_bone_anim_keys[0][1]: # not the first
 +                                                                                              file.write(',')
 +                                                                                      # frame is alredy one less then blenders frame
 +                                                                                      file.write('\n\t\t\t\t\t\t\t%i,%.15f,L'  % (fbx_time(frame), val ))
 +                                                              
 +                                                              if              i==0:   file.write('\n\t\t\t\t\t\tColor: 1,0,0')
 +                                                              elif    i==1:   file.write('\n\t\t\t\t\t\tColor: 0,1,0')
 +                                                              elif    i==2:   file.write('\n\t\t\t\t\t\tColor: 0,0,1')
 +                                                              
 +                                                              file.write('\n\t\t\t\t\t}')
 +                                                      file.write('\n\t\t\t\t\tLayerType: %i' % (TX_LAYER+1) )
 +                                                      file.write('\n\t\t\t\t}')
 +                                              
 +                                              # --------------- 
 +                                              
 +                                              file.write('\n\t\t\t}')
 +                                              file.write('\n\t\t}')
 +                      
 +                      # end the take
 +                      file.write('\n\t}')
 +                      
 +                      # end action loop. set original actions 
 +                      # do this after every loop incase actions effect eachother.
 +                      for my_bone in ob_arms:
 +                              my_bone.blenObject.action = my_bone.blenAction
 +              
 +              file.write('\n}')
 +
 +              sce.set_frame(frame_orig)
 +#             Blender.Set('curframe', frame_orig)
 +              
 +      else:
 +              # no animation
 +              file.write('\n;Takes and animation section')
 +              file.write('\n;----------------------------------------------------')
 +              file.write('\n')
 +              file.write('\nTakes:  {')
 +              file.write('\n\tCurrent: ""')
 +              file.write('\n}')
 +      
 +      
 +      # write meshes animation
 +      #for obname, ob, mtx, me, mats, arm, armname in ob_meshes:
 +              
 +      
 +      # Clear mesh data Only when writing with modifiers applied
 +      for me in meshes_to_clear:
 +              bpy.data.remove_mesh(me)
 +#             me.verts = None
 +      
 +      # --------------------------- Footer
 +      if world:
 +              m = world.mist
 +              has_mist = m.enabled
 +#             has_mist = world.mode & 1
 +              mist_intense = m.intensity
 +              mist_start = m.start
 +              mist_end = m.depth
 +              mist_height = m.height
 +#             mist_intense, mist_start, mist_end, mist_height = world.mist
 +              world_hor = world.horizon_color
 +#             world_hor = world.hor
 +      else:
 +              has_mist = mist_intense = mist_start = mist_end = mist_height = 0
 +              world_hor = 0,0,0
 +      
 +      file.write('\n;Version 5 settings')
 +      file.write('\n;------------------------------------------------------------------')
 +      file.write('\n')
 +      file.write('\nVersion5:  {')
 +      file.write('\n\tAmbientRenderSettings:  {')
 +      file.write('\n\t\tVersion: 101')
 +      file.write('\n\t\tAmbientLightColor: %.1f,%.1f,%.1f,0' % tuple(world_amb))
 +      file.write('\n\t}')
 +      file.write('\n\tFogOptions:  {')
 +      file.write('\n\t\tFlogEnable: %i' % has_mist)
 +      file.write('\n\t\tFogMode: 0')
 +      file.write('\n\t\tFogDensity: %.3f' % mist_intense)
 +      file.write('\n\t\tFogStart: %.3f' % mist_start)
 +      file.write('\n\t\tFogEnd: %.3f' % mist_end)
 +      file.write('\n\t\tFogColor: %.1f,%.1f,%.1f,1' % tuple(world_hor))
 +      file.write('\n\t}')
 +      file.write('\n\tSettings:  {')
 +      file.write('\n\t\tFrameRate: "%i"' % int(fps))
 +      file.write('\n\t\tTimeFormat: 1')
 +      file.write('\n\t\tSnapOnFrames: 0')
 +      file.write('\n\t\tReferenceTimeIndex: -1')
 +      file.write('\n\t\tTimeLineStartTime: %i' % fbx_time(start-1))
 +      file.write('\n\t\tTimeLineStopTime: %i' % fbx_time(end-1))
 +      file.write('\n\t}')
 +      file.write('\n\tRendererSetting:  {')
 +      file.write('\n\t\tDefaultCamera: "Producer Perspective"')
 +      file.write('\n\t\tDefaultViewingMode: 0')
 +      file.write('\n\t}')
 +      file.write('\n}')
 +      file.write('\n')
 +      
 +      # Incase sombody imports this, clean up by clearing global dicts
 +      sane_name_mapping_ob.clear()
 +      sane_name_mapping_mat.clear()
 +      sane_name_mapping_tex.clear()
 +      
 +      ob_arms[:] =    []
 +      ob_bones[:] =   []
 +      ob_cameras[:] = []
 +      ob_lights[:] =  []
 +      ob_meshes[:] =  []
 +      ob_null[:] =    []
 +      
 +      
 +      # copy images if enabled
 +#     if EXP_IMAGE_COPY:
 +# #           copy_images( basepath,  [ tex[1] for tex in textures if tex[1] != None ])
 +#             bpy.util.copy_images( [ tex[1] for tex in textures if tex[1] != None ], basepath)       
 +      
++      print('export finished in %.4f sec.' % (time.clock() - start_time))
 +#     print 'export finished in %.4f sec.' % (Blender.sys.time() - start_time)
 +      return True
 +      
 +
 +# --------------------------------------------
 +# UI Function - not a part of the exporter.
 +# this is to seperate the user interface from the rest of the exporter.
 +# from Blender import Draw, Window
 +EVENT_NONE = 0
 +EVENT_EXIT = 1
 +EVENT_REDRAW = 2
 +EVENT_FILESEL = 3
 +
 +GLOBALS = {}
 +
 +# export opts
 +
 +def do_redraw(e,v):           GLOBALS['EVENT'] = e
 +
 +# toggle between these 2, only allow one on at once
 +def do_obs_sel(e,v):
 +      GLOBALS['EVENT'] = e
 +      GLOBALS['EXP_OBS_SCENE'].val = 0
 +      GLOBALS['EXP_OBS_SELECTED'].val = 1
 +
 +def do_obs_sce(e,v):
 +      GLOBALS['EVENT'] = e
 +      GLOBALS['EXP_OBS_SCENE'].val = 1
 +      GLOBALS['EXP_OBS_SELECTED'].val = 0
 +
 +def do_batch_type_grp(e,v):
 +      GLOBALS['EVENT'] = e
 +      GLOBALS['BATCH_GROUP'].val = 1
 +      GLOBALS['BATCH_SCENE'].val = 0
 +
 +def do_batch_type_sce(e,v):
 +      GLOBALS['EVENT'] = e
 +      GLOBALS['BATCH_GROUP'].val = 0
 +      GLOBALS['BATCH_SCENE'].val = 1
 +
 +def do_anim_act_all(e,v):
 +      GLOBALS['EVENT'] = e
 +      GLOBALS['ANIM_ACTION_ALL'][0].val = 1
 +      GLOBALS['ANIM_ACTION_ALL'][1].val = 0
 +
 +def do_anim_act_cur(e,v):
 +      if GLOBALS['BATCH_ENABLE'].val and GLOBALS['BATCH_GROUP'].val:
 +              Draw.PupMenu('Warning%t|Cant use this with batch export group option')
 +      else:
 +              GLOBALS['EVENT'] = e
 +              GLOBALS['ANIM_ACTION_ALL'][0].val = 0
 +              GLOBALS['ANIM_ACTION_ALL'][1].val = 1
 +
 +def fbx_ui_exit(e,v):
 +      GLOBALS['EVENT'] = e
 +
 +def do_help(e,v):
 +    url = 'http://wiki.blender.org/index.php/Scripts/Manual/Export/autodesk_fbx'
 +    print('Trying to open web browser with documentation at this address...')
 +    print('\t' + url)
 +    
 +    try:
 +        import webbrowser
 +        webbrowser.open(url)
 +    except:
 +        Blender.Draw.PupMenu("Error%t|Opening a webbrowser requires a full python installation")
 +        print('...could not open a browser window.')
 +
 +      
 +
 +# run when export is pressed
 +#def fbx_ui_write(e,v):
 +def fbx_ui_write(filename, context):
 +      
 +      # Dont allow overwriting files when saving normally
 +      if not GLOBALS['BATCH_ENABLE'].val:
 +              if not BPyMessages.Warning_SaveOver(filename):
 +                      return
 +      
 +      GLOBALS['EVENT'] = EVENT_EXIT
 +      
 +      # Keep the order the same as above for simplicity
 +      # the [] is a dummy arg used for objects
 +      
 +      Blender.Window.WaitCursor(1)
 +      
 +      # Make the matrix
 +      GLOBAL_MATRIX = mtx4_identity
 +      GLOBAL_MATRIX[0][0] = GLOBAL_MATRIX[1][1] = GLOBAL_MATRIX[2][2] = GLOBALS['_SCALE'].val
 +      if GLOBALS['_XROT90'].val:      GLOBAL_MATRIX = GLOBAL_MATRIX * mtx4_x90n
 +      if GLOBALS['_YROT90'].val:      GLOBAL_MATRIX = GLOBAL_MATRIX * mtx4_y90n
 +      if GLOBALS['_ZROT90'].val:      GLOBAL_MATRIX = GLOBAL_MATRIX * mtx4_z90n
 +      
 +      ret = write(\
 +              filename, None,\
 +              context,
 +              GLOBALS['EXP_OBS_SELECTED'].val,\
 +              GLOBALS['EXP_MESH'].val,\
 +              GLOBALS['EXP_MESH_APPLY_MOD'].val,\
 +              GLOBALS['EXP_MESH_HQ_NORMALS'].val,\
 +              GLOBALS['EXP_ARMATURE'].val,\
 +              GLOBALS['EXP_LAMP'].val,\
 +              GLOBALS['EXP_CAMERA'].val,\
 +              GLOBALS['EXP_EMPTY'].val,\
 +              GLOBALS['EXP_IMAGE_COPY'].val,\
 +              GLOBAL_MATRIX,\
 +              GLOBALS['ANIM_ENABLE'].val,\
 +              GLOBALS['ANIM_OPTIMIZE'].val,\
 +              GLOBALS['ANIM_OPTIMIZE_PRECISSION'].val,\
 +              GLOBALS['ANIM_ACTION_ALL'][0].val,\
 +              GLOBALS['BATCH_ENABLE'].val,\
 +              GLOBALS['BATCH_GROUP'].val,\
 +              GLOBALS['BATCH_SCENE'].val,\
 +              GLOBALS['BATCH_FILE_PREFIX'].val,\
 +              GLOBALS['BATCH_OWN_DIR'].val,\
 +      )
 +      
 +      Blender.Window.WaitCursor(0)
 +      GLOBALS.clear()
 +      
 +      if ret == False:
 +              Draw.PupMenu('Error%t|Path cannot be written to!')
 +
 +
 +def fbx_ui():
 +      # Only to center the UI
 +      x,y = GLOBALS['MOUSE']
 +      x-=180; y-=0 # offset... just to get it centered
 +      
 +      Draw.Label('Export Objects...', x+20,y+165, 200, 20)
 +      
 +      if not GLOBALS['BATCH_ENABLE'].val:
 +              Draw.BeginAlign()
 +              GLOBALS['EXP_OBS_SELECTED'] =   Draw.Toggle('Selected Objects', EVENT_REDRAW, x+20,  y+145, 160, 20, GLOBALS['EXP_OBS_SELECTED'].val,   'Export selected objects on visible layers', do_obs_sel)
 +              GLOBALS['EXP_OBS_SCENE'] =              Draw.Toggle('Scene Objects',    EVENT_REDRAW, x+180,  y+145, 160, 20, GLOBALS['EXP_OBS_SCENE'].val,             'Export all objects in this scene', do_obs_sce)
 +              Draw.EndAlign()
 +      
 +      Draw.BeginAlign()
 +      GLOBALS['_SCALE'] =             Draw.Number('Scale:',   EVENT_NONE, x+20, y+120, 140, 20, GLOBALS['_SCALE'].val,        0.01, 1000.0, 'Scale all data, (Note! some imports dont support scaled armatures)')
 +      GLOBALS['_XROT90'] =    Draw.Toggle('Rot X90',  EVENT_NONE, x+160, y+120, 60, 20, GLOBALS['_XROT90'].val,               'Rotate all objects 90 degrese about the X axis')
 +      GLOBALS['_YROT90'] =    Draw.Toggle('Rot Y90',  EVENT_NONE, x+220, y+120, 60, 20, GLOBALS['_YROT90'].val,               'Rotate all objects 90 degrese about the Y axis')
 +      GLOBALS['_ZROT90'] =    Draw.Toggle('Rot Z90',  EVENT_NONE, x+280, y+120, 60, 20, GLOBALS['_ZROT90'].val,               'Rotate all objects 90 degrese about the Z axis')
 +      Draw.EndAlign()
 +      
 +      y -= 35
 +      
 +      Draw.BeginAlign()
 +      GLOBALS['EXP_EMPTY'] =          Draw.Toggle('Empty',    EVENT_NONE, x+20, y+120, 60, 20, GLOBALS['EXP_EMPTY'].val,              'Export empty objects')
 +      GLOBALS['EXP_CAMERA'] =         Draw.Toggle('Camera',   EVENT_NONE, x+80, y+120, 60, 20, GLOBALS['EXP_CAMERA'].val,             'Export camera objects')
 +      GLOBALS['EXP_LAMP'] =           Draw.Toggle('Lamp',             EVENT_NONE, x+140, y+120, 60, 20, GLOBALS['EXP_LAMP'].val,              'Export lamp objects')
 +      GLOBALS['EXP_ARMATURE'] =       Draw.Toggle('Armature', EVENT_NONE, x+200,  y+120, 60, 20, GLOBALS['EXP_ARMATURE'].val, 'Export armature objects')
 +      GLOBALS['EXP_MESH'] =           Draw.Toggle('Mesh',             EVENT_REDRAW, x+260,  y+120, 80, 20, GLOBALS['EXP_MESH'].val,   'Export mesh objects', do_redraw) #, do_axis_z)
 +      Draw.EndAlign()
 +      
 +      if GLOBALS['EXP_MESH'].val:
 +              # below mesh but
 +              Draw.BeginAlign()
 +              GLOBALS['EXP_MESH_APPLY_MOD'] =         Draw.Toggle('Modifiers',        EVENT_NONE, x+260,  y+100, 80, 20, GLOBALS['EXP_MESH_APPLY_MOD'].val,           'Apply modifiers to mesh objects') #, do_axis_z)
 +              GLOBALS['EXP_MESH_HQ_NORMALS'] =        Draw.Toggle('HQ Normals',               EVENT_NONE, x+260,  y+80, 80, 20, GLOBALS['EXP_MESH_HQ_NORMALS'].val,           'Generate high quality normals') #, do_axis_z)
 +              Draw.EndAlign()
 +      
 +      GLOBALS['EXP_IMAGE_COPY'] =             Draw.Toggle('Copy Image Files', EVENT_NONE, x+20, y+80, 160, 20, GLOBALS['EXP_IMAGE_COPY'].val,         'Copy image files to the destination path') #, do_axis_z)
 +      
 +      
 +      Draw.Label('Export Armature Animation...', x+20,y+45, 300, 20)
 +      
 +      GLOBALS['ANIM_ENABLE'] =        Draw.Toggle('Enable Animation',         EVENT_REDRAW, x+20,  y+25, 160, 20, GLOBALS['ANIM_ENABLE'].val,         'Export keyframe animation', do_redraw)
 +      if GLOBALS['ANIM_ENABLE'].val:
 +              Draw.BeginAlign()
 +              GLOBALS['ANIM_OPTIMIZE'] =                              Draw.Toggle('Optimize Keyframes',       EVENT_REDRAW, x+20,  y+0, 160, 20, GLOBALS['ANIM_OPTIMIZE'].val,        'Remove double keyframes', do_redraw)
 +              if GLOBALS['ANIM_OPTIMIZE'].val:
 +                      GLOBALS['ANIM_OPTIMIZE_PRECISSION'] =   Draw.Number('Precission: ',                     EVENT_NONE, x+180,  y+0, 160, 20, GLOBALS['ANIM_OPTIMIZE_PRECISSION'].val,      1, 16, 'Tolerence for comparing double keyframes (higher for greater accuracy)')
 +              Draw.EndAlign()
 +              
 +              Draw.BeginAlign()
 +              GLOBALS['ANIM_ACTION_ALL'][1] = Draw.Toggle('Current Action',   EVENT_REDRAW, x+20, y-25, 160, 20, GLOBALS['ANIM_ACTION_ALL'][1].val,           'Use actions currently applied to the armatures (use scene start/end frame)', do_anim_act_cur)
 +              GLOBALS['ANIM_ACTION_ALL'][0] =         Draw.Toggle('All Actions',      EVENT_REDRAW, x+180,y-25, 160, 20, GLOBALS['ANIM_ACTION_ALL'][0].val,           'Use all actions for armatures', do_anim_act_all)
 +              Draw.EndAlign()
 +      
 +      
 +      Draw.Label('Export Batch...', x+20,y-60, 300, 20)
 +      GLOBALS['BATCH_ENABLE'] =       Draw.Toggle('Enable Batch',             EVENT_REDRAW, x+20,  y-80, 160, 20, GLOBALS['BATCH_ENABLE'].val,                'Automate exporting multiple scenes or groups to files', do_redraw)
 +      
 +      if GLOBALS['BATCH_ENABLE'].val:
 +              Draw.BeginAlign()
 +              GLOBALS['BATCH_GROUP'] =        Draw.Toggle('Group > File',     EVENT_REDRAW, x+20,  y-105, 160, 20, GLOBALS['BATCH_GROUP'].val,                'Export each group as an FBX file', do_batch_type_grp)
 +              GLOBALS['BATCH_SCENE'] =        Draw.Toggle('Scene > File',     EVENT_REDRAW, x+180,  y-105, 160, 20, GLOBALS['BATCH_SCENE'].val,       'Export each scene as an FBX file', do_batch_type_sce)
 +              
 +              # Own dir requires OS module
 +              if os:
 +                      GLOBALS['BATCH_OWN_DIR'] =              Draw.Toggle('Own Dir',  EVENT_NONE, x+20,  y-125, 80, 20, GLOBALS['BATCH_OWN_DIR'].val,         'Create a dir for each exported file')
 +                      GLOBALS['BATCH_FILE_PREFIX'] =  Draw.String('Prefix: ', EVENT_NONE, x+100,  y-125, 240, 20, GLOBALS['BATCH_FILE_PREFIX'].val, 64,       'Prefix each file with this name ')
 +              else:
 +                      GLOBALS['BATCH_FILE_PREFIX'] =  Draw.String('Prefix: ', EVENT_NONE, x+20,  y-125, 320, 20, GLOBALS['BATCH_FILE_PREFIX'].val, 64,        'Prefix each file with this name ')
 +              
 +              
 +              Draw.EndAlign()
 +
 +      #y+=80
 +              
 +      '''
 +      Draw.BeginAlign()
 +      GLOBALS['FILENAME'] =   Draw.String('path: ',   EVENT_NONE, x+20,  y-170, 300, 20, GLOBALS['FILENAME'].val, 64, 'Prefix each file with this name ')
 +      Draw.PushButton('..',   EVENT_FILESEL, x+320,  y-170, 20, 20,           'Select the path', do_redraw)
 +      '''
 +      # Until batch is added
 +      #
 +      
 +      
 +      #Draw.BeginAlign()
 +      Draw.PushButton('Online Help',  EVENT_REDRAW, x+20, y-160, 100, 20,     'Open online help in a browser window', do_help)
 +      Draw.PushButton('Cancel',               EVENT_EXIT, x+130, y-160, 100, 20,      'Exit the exporter', fbx_ui_exit)
 +      Draw.PushButton('Export',               EVENT_FILESEL, x+240, y-160, 100, 20,   'Export the fbx file', do_redraw)
 +      
 +      #Draw.PushButton('Export',      EVENT_EXIT, x+180, y-160, 160, 20,      'Export the fbx file', fbx_ui_write)
 +      #Draw.EndAlign()
 +      
 +      # exit when mouse out of the view?
 +      # GLOBALS['EVENT'] = EVENT_EXIT
 +
 +#def write_ui(filename):
 +def write_ui():
 +      
 +      # globals
 +      GLOBALS['EVENT'] = EVENT_REDRAW
 +      #GLOBALS['MOUSE'] = Window.GetMouseCoords()
 +      GLOBALS['MOUSE'] = [i/2 for i in Window.GetScreenSize()]
 +      GLOBALS['FILENAME'] = ''
 +      '''
 +      # IF called from the fileselector
 +      if filename == None:
 +              GLOBALS['FILENAME'] = filename # Draw.Create(Blender.sys.makename(ext='.fbx'))
 +      else:
 +              GLOBALS['FILENAME'].val = filename
 +      '''
 +      GLOBALS['EXP_OBS_SELECTED'] =                   Draw.Create(1) # dont need 2 variables but just do this for clarity
 +      GLOBALS['EXP_OBS_SCENE'] =                              Draw.Create(0)
 +
 +      GLOBALS['EXP_MESH'] =                                   Draw.Create(1)
 +      GLOBALS['EXP_MESH_APPLY_MOD'] =                 Draw.Create(1)
 +      GLOBALS['EXP_MESH_HQ_NORMALS'] =                Draw.Create(0)
 +      GLOBALS['EXP_ARMATURE'] =                               Draw.Create(1)
 +      GLOBALS['EXP_LAMP'] =                                   Draw.Create(1)
 +      GLOBALS['EXP_CAMERA'] =                                 Draw.Create(1)
 +      GLOBALS['EXP_EMPTY'] =                                  Draw.Create(1)
 +      GLOBALS['EXP_IMAGE_COPY'] =                             Draw.Create(0)
 +      # animation opts
 +      GLOBALS['ANIM_ENABLE'] =                                Draw.Create(1)
 +      GLOBALS['ANIM_OPTIMIZE'] =                              Draw.Create(1)
 +      GLOBALS['ANIM_OPTIMIZE_PRECISSION'] =   Draw.Create(4) # decimal places
 +      GLOBALS['ANIM_ACTION_ALL'] =                    [Draw.Create(0), Draw.Create(1)] # not just the current action
 +      
 +      # batch export options
 +      GLOBALS['BATCH_ENABLE'] =                               Draw.Create(0)
 +      GLOBALS['BATCH_GROUP'] =                                Draw.Create(1) # cant have both of these enabled at once.
 +      GLOBALS['BATCH_SCENE'] =                                Draw.Create(0) # see above
 +      GLOBALS['BATCH_FILE_PREFIX'] =                  Draw.Create(Blender.sys.makename(ext='_').split('\\')[-1].split('/')[-1])
 +      GLOBALS['BATCH_OWN_DIR'] =                              Draw.Create(0)
 +      # done setting globals
 +      
 +      # Used by the user interface
 +      GLOBALS['_SCALE'] =                                             Draw.Create(1.0)
 +      GLOBALS['_XROT90'] =                                    Draw.Create(True)
 +      GLOBALS['_YROT90'] =                                    Draw.Create(False)
 +      GLOBALS['_ZROT90'] =                                    Draw.Create(False)
 +      
 +      # best not do move the cursor
 +      # Window.SetMouseCoords(*[i/2 for i in Window.GetScreenSize()])
 +      
 +      # hack so the toggle buttons redraw. this is not nice at all
 +      while GLOBALS['EVENT'] != EVENT_EXIT:
 +              
 +              if GLOBALS['BATCH_ENABLE'].val and GLOBALS['BATCH_GROUP'].val and GLOBALS['ANIM_ACTION_ALL'][1].val:
 +                      #Draw.PupMenu("Warning%t|Cant batch export groups with 'Current Action' ")
 +                      GLOBALS['ANIM_ACTION_ALL'][0].val = 1
 +                      GLOBALS['ANIM_ACTION_ALL'][1].val = 0
 +              
 +              if GLOBALS['EVENT'] == EVENT_FILESEL:
 +                      if GLOBALS['BATCH_ENABLE'].val:
 +                              txt = 'Batch FBX Dir'
 +                              name = Blender.sys.expandpath('//')
 +                      else:
 +                              txt = 'Export FBX'
 +                              name = Blender.sys.makename(ext='.fbx')
 +                      
 +                      Blender.Window.FileSelector(fbx_ui_write, txt, name)
 +                      #fbx_ui_write('/test.fbx')
 +                      break
 +              
 +              Draw.UIBlock(fbx_ui, 0)
 +      
 +      
 +      # GLOBALS.clear()
 +
 +class EXPORT_OT_fbx(bpy.types.Operator):
 +      '''
 +      Operator documentation text, will be used for the operator tooltip and python docs.
 +      '''
 +      __idname__ = "export.fbx"
 +      __label__ = "Export FBX"
 +      
 +      # List of operator properties, the attributes will be assigned
 +      # to the class instance from the operator settings before calling.
 +      
 +      __props__ = [
 +              bpy.props.StringProperty(attr="filename", name="File Name", description="File name used for exporting the PLY file", maxlen= 1024, default=""),
 +              bpy.props.BoolProperty(attr="EXP_OBS_SELECTED", name="Selected Objects", description="Export selected objects on visible layers", default=True),
 +#             bpy.props.BoolProperty(attr="EXP_OBS_SCENE", name="Scene Objects", description="Export all objects in this scene", default=True),
 +              bpy.props.FloatProperty(attr="_SCALE", name="Scale", description="Scale all data, (Note! some imports dont support scaled armatures)", min=0.01, max=1000.0, soft_min=0.01, soft_max=1000.0, default=1.0),
 +              bpy.props.BoolProperty(attr="_XROT90", name="Rot X90", description="Rotate all objects 90 degrese about the X axis", default=True),
 +              bpy.props.BoolProperty(attr="_YROT90", name="Rot Y90", description="Rotate all objects 90 degrese about the Y axis", default=False),
 +              bpy.props.BoolProperty(attr="_ZROT90", name="Rot Z90", description="Rotate all objects 90 degrese about the Z axis", default=False),
 +              bpy.props.BoolProperty(attr="EXP_EMPTY", name="Empties", description="Export empty objects", default=True),
 +              bpy.props.BoolProperty(attr="EXP_CAMERA", name="Cameras", description="Export camera objects", default=True),
 +              bpy.props.BoolProperty(attr="EXP_LAMP", name="Lamps", description="Export lamp objects", default=True),
 +              bpy.props.BoolProperty(attr="EXP_ARMATURE", name="Armatures", description="Export armature objects", default=True),
 +              bpy.props.BoolProperty(attr="EXP_MESH", name="Meshes", description="Export mesh objects", default=True),
 +              bpy.props.BoolProperty(attr="EXP_MESH_APPLY_MOD", name="Modifiers", description="Apply modifiers to mesh objects", default=True),
 +              bpy.props.BoolProperty(attr="EXP_MESH_HQ_NORMALS", name="HQ Normals", description="Generate high quality normals", default=True),
 +              bpy.props.BoolProperty(attr="EXP_IMAGE_COPY", name="Copy Image Files", description="Copy image files to the destination path", default=False),
 +              # armature animation
 +              bpy.props.BoolProperty(attr="ANIM_ENABLE", name="Enable Animation", description="Export keyframe animation", default=True),
 +              bpy.props.BoolProperty(attr="ANIM_OPTIMIZE", name="Optimize Keyframes", description="Remove double keyframes", default=True),
 +              bpy.props.FloatProperty(attr="ANIM_OPTIMIZE_PRECISSION", name="Precision", description="Tolerence for comparing double keyframes (higher for greater accuracy)", min=1, max=16, soft_min=1, soft_max=16, default=6.0),
 +#             bpy.props.BoolProperty(attr="ANIM_ACTION_ALL", name="Current Action", description="Use actions currently applied to the armatures (use scene start/end frame)", default=True),
 +              bpy.props.BoolProperty(attr="ANIM_ACTION_ALL", name="All Actions", description="Use all actions for armatures, if false, use current action", default=False),
 +              # batch
 +              bpy.props.BoolProperty(attr="BATCH_ENABLE", name="Enable Batch", description="Automate exporting multiple scenes or groups to files", default=False),
 +              bpy.props.BoolProperty(attr="BATCH_GROUP", name="Group > File", description="Export each group as an FBX file, if false, export each scene as an FBX file", default=False),
 +              bpy.props.BoolProperty(attr="BATCH_OWN_DIR", name="Own Dir", description="Create a dir for each exported file", default=True),
 +              bpy.props.StringProperty(attr="BATCH_FILE_PREFIX", name="Prefix", description="Prefix each file with this name", maxlen= 1024, default=""),
 +      ]
 +      
 +      def poll(self, context):
 +              print("Poll")
 +              return context.active_object != None
 +      
 +      def execute(self, context):
 +              if not self.filename:
 +                      raise Exception("filename not set")
 +
 +              GLOBAL_MATRIX = mtx4_identity
 +              GLOBAL_MATRIX[0][0] = GLOBAL_MATRIX[1][1] = GLOBAL_MATRIX[2][2] = self._SCALE
 +              if self._XROT90: GLOBAL_MATRIX = GLOBAL_MATRIX * mtx4_x90n
 +              if self._YROT90: GLOBAL_MATRIX = GLOBAL_MATRIX * mtx4_y90n
 +              if self._ZROT90: GLOBAL_MATRIX = GLOBAL_MATRIX * mtx4_z90n
 +                      
 +              write(self.filename,
 +                        None, # XXX
 +                        context,
 +                        self.EXP_OBS_SELECTED,
 +                        self.EXP_MESH,
 +                        self.EXP_MESH_APPLY_MOD,
 +#                       self.EXP_MESH_HQ_NORMALS,
 +                        self.EXP_ARMATURE,
 +                        self.EXP_LAMP,
 +                        self.EXP_CAMERA,
 +                        self.EXP_EMPTY,
 +                        self.EXP_IMAGE_COPY,
 +                        GLOBAL_MATRIX,
 +                        self.ANIM_ENABLE,
 +                        self.ANIM_OPTIMIZE,
 +                        self.ANIM_OPTIMIZE_PRECISSION,
 +                        self.ANIM_ACTION_ALL,
 +                        self.BATCH_ENABLE,
 +                        self.BATCH_GROUP,
 +                        self.BATCH_FILE_PREFIX,
 +                        self.BATCH_OWN_DIR)           
 +
 +              return ('FINISHED',)
 +      
 +      def invoke(self, context, event):       
 +              wm = context.manager
 +              wm.add_fileselect(self.__operator__)
 +              return ('RUNNING_MODAL',)
 +
 +
 +bpy.ops.add(EXPORT_OT_fbx)
 +
 +# if __name__ == "__main__":
 +#     bpy.ops.EXPORT_OT_ply(filename="/tmp/test.ply")
 +
 +
 +# NOTES (all line numbers correspond to original export_fbx.py (under release/scripts)
 +# - Draw.PupMenu alternative in 2.5?, temporarily replaced PupMenu with print
 +# - get rid of cleanName somehow
 +# + fixed: isinstance(inst, bpy.types.*) doesn't work on RNA objects: line 565
 +# + get rid of BPyObject_getObjectArmature, move it in RNA?
 +# - BATCH_ENABLE and BATCH_GROUP options: line 327
 +# - implement all BPyMesh_* used here with RNA
 +# - getDerivedObjects is not fully replicated with .dupli* funcs
 +# - talk to Campbell, this code won't work? lines 1867-1875
 +# - don't know what those colbits are, do we need them? they're said to be deprecated in DNA_object_types.h: 1886-1893
 +# - no hq normals: 1900-1901
 +
 +# TODO
 +
 +# - bpy.data.remove_scene: line 366
 +# - bpy.sys.time move to bpy.sys.util?
 +# - new scene creation, activation: lines 327-342, 368
 +# - uses bpy.sys.expandpath, *.relpath - replace at least relpath
 +
 +# SMALL or COSMETICAL
 +# - find a way to get blender version, and put it in bpy.util?, old was Blender.Get('version')
Simple merge
@@@ -74,24 -76,18 +76,24 @@@ class INFO_MT_file_import(bpy.types.Men
  
        def draw(self, context):
                layout = self.layout
 +              layout.itemO("import.3ds", text="3DS")
 +              layout.itemO("import.obj", text="OBJ")
  
  class INFO_MT_file_export(bpy.types.Menu):
-       __space_type__ = "USER_PREFERENCES"
+       __space_type__ = "INFO"
        __label__ = "Export"
  
        def draw(self, context):
                layout = self.layout
  
 +              layout.itemO("export.3ds", text="3DS")
 +              layout.itemO("export.fbx", text="FBX")
 +              layout.itemO("export.obj", text="OBJ")
                layout.itemO("export.ply", text="PLY")
 +              layout.itemO("export.x3d", text="X3D")
  
  class INFO_MT_file_external_data(bpy.types.Menu):
-       __space_type__ = "USER_PREFERENCES"
+       __space_type__ = "INFO"
        __label__ = "External Data"
  
        def draw(self, context):
Simple merge
@@@ -227,10 -233,10 +233,11 @@@ typedef struct Object 
        int lastDataMask;                       /* the custom data layer mask that was last used to calculate derivedDeform and derivedFinal */
        unsigned int state;                     /* bit masks of game controllers that are active */
        unsigned int init_state;        /* bit masks of initial state as recorded by the users */
-       int pad2;
+       int restore_mode;               /* Keep track of what mode to return to after edit mode exits */
  
        ListBase gpulamp;               /* runtime, for lamps only */
 +      ListBase *duplilist;    /* only for internal use by RNA API functions. To get dupli list, use object_duplilist instead */
  } Object;
  
  /* Warning, this is not used anymore because hooks are now modifiers */
Simple merge
@@@ -469,37 -469,6 +469,37 @@@ static void rna_def_bone(BlenderRNA *br
        RNA_def_property_boolean_sdna(prop, NULL, "flag", BONE_SELECTED);
        RNA_def_property_ui_text(prop, "Selected", "");
        RNA_def_property_update(prop, 0, "rna_Armature_redraw_data");
-       prop= RNA_def_property(srna, "tail", PROP_FLOAT, PROP_VECTOR);
 +
 +      /* XXX better matrix descriptions possible (Arystan) */
 +      prop= RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
 +      RNA_def_property_float_sdna(prop, NULL, "bone_mat");
 +      RNA_def_property_array(prop, 9);
 +      RNA_def_property_ui_text(prop, "Bone Matrix", "3x3 bone matrix.");
 +
 +      prop= RNA_def_property(srna, "armature_matrix", PROP_FLOAT, PROP_MATRIX);
 +      RNA_def_property_float_sdna(prop, NULL, "arm_mat");
 +      RNA_def_property_array(prop, 16);
 +      RNA_def_property_ui_text(prop, "Bone Armature-Relative Matrix", "4x4 bone matrix relative to armature.");
 +
-       prop= RNA_def_property(srna, "armature_tail", PROP_FLOAT, PROP_VECTOR);
++      prop= RNA_def_property(srna, "tail", PROP_FLOAT, PROP_TRANSLATION);
 +      RNA_def_property_float_sdna(prop, NULL, "tail");
 +      RNA_def_property_array(prop, 3);
 +      RNA_def_property_ui_text(prop, "Tail", "Location of tail end of the bone.");
 +
-       prop= RNA_def_property(srna, "head", PROP_FLOAT, PROP_VECTOR);
++      prop= RNA_def_property(srna, "armature_tail", PROP_FLOAT, PROP_TRANSLATION);
 +      RNA_def_property_float_sdna(prop, NULL, "arm_tail");
 +      RNA_def_property_array(prop, 3);
 +      RNA_def_property_ui_text(prop, "Armature-Relative Tail", "Location of tail end of the bone relative to armature.");
 +
-       prop= RNA_def_property(srna, "armature_head", PROP_FLOAT, PROP_VECTOR);
++      prop= RNA_def_property(srna, "head", PROP_FLOAT, PROP_TRANSLATION);
 +      RNA_def_property_float_sdna(prop, NULL, "head");
 +      RNA_def_property_array(prop, 3);
 +      RNA_def_property_ui_text(prop, "Head", "Location of head end of the bone.");
 +
++      prop= RNA_def_property(srna, "armature_head", PROP_FLOAT, PROP_TRANSLATION);
 +      RNA_def_property_float_sdna(prop, NULL, "arm_head");
 +      RNA_def_property_array(prop, 3);
 +      RNA_def_property_ui_text(prop, "Armature-Relative Head", "Location of head end of the bone relative to armature.");
  }
  
  static void rna_def_edit_bone(BlenderRNA *brna)
@@@ -1344,8 -1412,7 +1412,9 @@@ void RNA_def_material(BlenderRNA *brna
        rna_def_material_sss(brna);
        rna_def_material_mtex(brna);
        rna_def_material_strand(brna);
+       rna_def_material_physics(brna);
 +
 +      RNA_api_material(srna);
  }
  
  void rna_def_mtex_common(StructRNA *srna, const char *begin, const char *activeget, const char *activeset, const char *structname)
@@@ -917,8 -904,8 +917,8 @@@ static void rna_def_mface(BlenderRNA *b
        prop= RNA_def_property(srna, "smooth", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", ME_SMOOTH);
        RNA_def_property_ui_text(prop, "Smooth", "");
 -      
 +
-       prop= RNA_def_property(srna, "normal", PROP_FLOAT, PROP_VECTOR);
+       prop= RNA_def_property(srna, "normal", PROP_FLOAT, PROP_DIRECTION);
        RNA_def_property_array(prop, 3);
        RNA_def_property_range(prop, -1.0f, 1.0f);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
@@@ -1302,15 -1386,9 +1403,15 @@@ static void rna_def_object(BlenderRNA *
        RNA_def_property_ui_text(prop, "Dupli Frames Off", "Recurring frames to exclude from the Dupliframes.");
        RNA_def_property_update(prop, NC_OBJECT|ND_DRAW, "rna_Object_update");
  
 +      prop= RNA_def_property(srna, "dupli_list", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "duplilist", NULL);
 +      RNA_def_property_struct_type(prop, "DupliObject");
 +      RNA_def_property_ui_text(prop, "Dupli list", "Object duplis.");
 +
 +
        /* time offset */
  
-       prop= RNA_def_property(srna, "time_offset", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "time_offset", PROP_FLOAT, PROP_NONE|PROP_UNIT_TIME);
        RNA_def_property_float_sdna(prop, NULL, "sf");
        RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
        RNA_def_property_ui_text(prop, "Time Offset", "Animation offset in frames for IPO's and dupligroup instances.");
@@@ -430,10 -427,9 +430,10 @@@ static void rna_def_pose_channel(Blende
        prop= RNA_def_property(srna, "constraint_inverse_matrix", PROP_FLOAT, PROP_MATRIX);
        RNA_def_property_struct_type(prop, "constinv");
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 -      RNA_def_property_ui_text(prop, "Constraint Inverse Matrix", "4x4 matrix, defines transform from final position to unconstrained position."); */
 +      RNA_def_property_ui_text(prop, "Constraint Inverse Matrix", "4x4 matrix, defines transform from final position to unconstrained position.");
 +      */
        
-       prop= RNA_def_property(srna, "pose_head", PROP_FLOAT, PROP_VECTOR);
+       prop= RNA_def_property(srna, "pose_head", PROP_FLOAT, PROP_TRANSLATION);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        RNA_def_property_ui_text(prop, "Pose Head Position", "Location of head of the channel's bone.");
  
@@@ -69,7 -140,7 +141,10 @@@ static void bpy_init_modules( void 
        PyModule_AddObject( mod, "props", BPY_rna_props() );
        PyModule_AddObject( mod, "__ops__", BPY_operator_module() ); /* ops is now a python module that does the conversion from SOME_OT_foo -> some.foo */
        PyModule_AddObject( mod, "ui", BPY_ui_module() ); // XXX very experimental, consider this a test, especially PyCObject is not meant to be permanent
--      
++
++      /* Arystan: this module is used by i/o scripts for bpy.sys.expandpath() and others. It should be renamed/move? */
++      PyModule_AddObject( mod, "sys", BPY_sys_module() );
++
        /* add the module so we can import it */
        PyDict_SetItemString(PySys_GetObject("modules"), "bpy", mod);
        Py_DECREF(mod);
  
  void BPY_update_modules( void )
  {
+ #if 0 // slow, this runs all the time poll, draw etc 100's of time a sec.
        PyObject *mod= PyImport_ImportModuleLevel("bpy", NULL, NULL, NULL, 0);
        PyModule_AddObject( mod, "data", BPY_rna_module() );
-       PyModule_AddObject( mod, "types", BPY_rna_types() );
-       /* PyModule_AddObject( mod, "util", BPY_util_module() ); */
+       PyModule_AddObject( mod, "types", BPY_rna_types() ); // atm this does not need updating
+ #endif
  
-       /* XXX this will move to bpy.util */
-       PyModule_AddObject( mod, "sys", BPY_sys_module() );
+       /* refreshes the main struct */
+       BPY_update_rna_module();
 -
  }
  
  /*****************************************************************************
@@@ -1832,10 -1827,6 +1857,10 @@@ PyObject *pyrna_param_to_py(PointerRNA 
                /* resolve the array from a new pytype */
                ret = PyTuple_New(len);
  
-               if (prop->flag & PROP_DYNAMIC_ARRAY)
 +              /* for return values, data is a pointer to an array, not first element pointer */
++              if (RNA_property_flag(prop) & PROP_DYNAMIC_ARRAY)
 +                      data = *(char**)(char*)data;
 +
                switch (type) {
                case PROP_BOOLEAN:
                        for(a=0; a<len; a++)
Simple merge
Simple merge
diff --cc tools/btools.py
Simple merge