add MT method parameter ,smooth normal generation for MT and correct bug in getChildrenOf

exporter/osg/__init__.py

@@ -192,6 +192,10 @@ class OSGGUI(bpy.types.Operator, ExportHelper):
                                 default=False)
     BAKE_ALL = BoolProperty(name="Bake all animations", description="Force baking for all animations",
                             default=True)
+    morph_target_export_modes_list = [("NORMALIZED", "NORMALIZED", "NORMALIZED"),
+         ("RELATIVE", "RELATIVE", "RELATIVE")]
+    MORPHTARGETEXPORTMODE = EnumProperty(name="MorphTargets Mode", items=morph_target_export_modes_list, description="MorphTargets export mode.", default='NORMALIZED')
+
     USE_QUATERNIONS = BoolProperty(name="Use quaternions", description="Bake rotations using quaternions",
                                    default=True)
     BAKE_CONSTRAINTS = BoolProperty(name="Bake Constraints", description="Bake constraints into actions", default=True)
@@ -222,6 +226,7 @@ def draw(self, context):
         layout.row(align=True).prop(self, "EXPORT_ALL_SCENES")
         layout.row(align=True).prop(self, "APPLYMODIFIERS")
         layout.row(align=True).prop(self, "BAKE_ALL")
+        layout.row(align=True).prop(self, "MORPHTARGETEXPORTMODE")
         layout.row(align=True).prop(self, "USE_QUATERNIONS")
         layout.row(align=True).prop(self, "BAKE_CONSTRAINTS")
         layout.row(align=True).prop(self, "ARMATURE_REST")
@@ -268,6 +273,7 @@ def invoke(self, context, event):
         self.ZERO_TRANSLATIONS = self.config.zero_translations
         self.LOG = self.config.log
         self.BAKE_ALL = self.config.bake_animations
+        self.MORPHTARGETEXPORTMODE = "RELATIVE" if self.config.morph_target_mode_relative else "NORMALIZED"
         self.USE_QUATERNIONS = self.config.use_quaternions
         self.BAKE_CONSTRAINTS = self.config.bake_constraints
         self.BAKE_FRAME_STEP = self.config.bake_frame_step
@@ -310,6 +316,7 @@ def execute(self, context):
         self.config.log = self.LOG
         self.config.zero_translations = self.ZERO_TRANSLATIONS
         self.config.bake_animations = self.BAKE_ALL
+        self.config.morph_target_mode_relative = self.MORPHTARGETEXPORTMODE=="RELATIVE"
         self.config.use_quaternions = self.USE_QUATERNIONS
         self.config.bake_constraints = self.BAKE_CONSTRAINTS
         self.config.bake_frame_step = self.BAKE_FRAME_STEP

exporter/osg/osgconf.py

@@ -60,6 +60,7 @@ def activate(self):
         self.defaultattr("zero_translations", False)
         self.defaultattr("apply_modifiers", False)
         self.defaultattr("bake_animations", False)
+        self.defaultattr("morph_target_mode_relative", False)
         self.defaultattr("use_quaternions", False)
         self.defaultattr("bake_constraints", True)
         self.defaultattr("bake_frame_step", 1)

exporter/osg/osgdata.py

@@ -1404,8 +1404,19 @@ def parseMorphTargets(self, obj, geometry, morph_vertex_map, material_index):
                                                 key.data[morph_vertex_map[i]].co[2]])
 
             target.vertexes = osg_vertexes
-            # FIXME we don't currently generate normals, so osganimationviewer will crash
             target.primitives = geometry.primitives
+
+            # FIXME we regenerate normals assuming it is smooth..perhaps using to_mesh would be better
+            target.generateSmoothNormals()
+            if self.config.morph_target_mode_relative:
+                geometry.method = "RELATIVE"
+                for i in range(len(target.vertexes.getArray())):
+                    for j in range(3):
+                        target.vertexes.getArray()[i][j] = target.vertexes.getArray()[i][j] - geometry.vertexes.getArray()[i][j]
+                for i in range(len(target.normals.getArray())):
+                    for j in range(3):
+                        target.normals.getArray()[i][j] = target.normals.getArray()[i][j] - geometry.normals.getArray()[i][j]
+
             geometry.morphTargets.append(target)
             target.factor = key.value
 

exporter/osg/osgobject.py

@@ -1071,6 +1071,36 @@ def copyFrom(self, geometry):
         self.uvs = geometry.uvs
         self.stateset = geometry.stateset
 
+    def generateSmoothNormals(self):
+        if not self.normals or len(self.vertexes.getArray()) != len(self.normals.getArray()):
+            self.normals= NormalArray()
+            for i in range(len(self.vertexes.getArray())):
+                self.normals.getArray().append([0,0,0])
+
+        for prim in self.primitives:
+            priminc=1
+            if prim.type == "GL_TRIANGLES":
+                priminc = 3
+            elif prim.type == "GL_QUADS":
+                priminc = 4
+            else: continue;
+            primit=0
+            while primit<len(prim.indexes):
+                    v0=Vector((self.vertexes.getArray()[ prim.indexes[primit]][0],self.vertexes.getArray()[ prim.indexes[primit]][1],self.vertexes.getArray()[ prim.indexes[primit]][2]))
+                    v1=Vector((self.vertexes.getArray()[ prim.indexes[primit+1]][0],self.vertexes.getArray()[ prim.indexes[primit+1]][1],self.vertexes.getArray()[ prim.indexes[primit+1]][2]))
+                    v2=Vector((self.vertexes.getArray()[ prim.indexes[primit+2]][0],self.vertexes.getArray()[ prim.indexes[primit+2]][1],self.vertexes.getArray()[ prim.indexes[primit+2]][2]))
+                    norm=(v1-v0).cross(v2-v0)
+                    norm.normalize();
+                    for i in range(3):
+                        for j in range(priminc):
+                            self.normals.getArray()[prim.indexes[primit+j]][i]=self.normals.getArray()[prim.indexes[primit+j]][i]+norm[i]
+                    primit=primit+priminc
+        #normalize array at the end
+        for i in range(len(self.normals.getArray())):
+            norm=Vector((self.normals.getArray()[i][0],self.normals.getArray()[i][1],self.normals.getArray()[i][2]))
+            norm.normalize()
+            for j in range(3):self.normals.getArray()[i][j]=norm[j];
+
     def serialize(self, output):
         output.write(self.encode("$%s {\n" % self.getNameSpaceClass()))
         Object.serializeContent(self, output)
@@ -1237,6 +1267,7 @@ def __init__(self, *args, **kwargs):
         self.dataVariance = "DYNAMIC"
         self.morphTargets = []
         self.update_callbacks = []
+        self.method = "NORMALIZED"
 
     def className(self):
         return "MorphGeometry"
@@ -1252,6 +1283,7 @@ def serialize(self, output):
         output.write(self.encode("$}\n"))
 
     def serializeContent(self, output):
+        output.write(self.encode("$#Method %s \n" % self.method))
         if self.morphTargets:
             output.write(self.encode("$#MorphTargets %s {\n" % len(self.morphTargets)))
             for target in self.morphTargets:

exporter/osg/osgutils.py

@@ -244,11 +244,11 @@ def getDeltaMatrixFromMatrix(parent, child):
     return bi * child
 
 
-def getChildrenOf(scene, object):
+def getChildrenOf(scene, obj):
     children = []
-    for obj in scene.objects:
-        if obj.parent == object:
-            children.append(obj)
+    for o in scene.objects:
+        if o.parent is obj:
+            children.append(o)
     return children