Egg classes moved

egg.py

@@ -0,0 +1,347 @@
+# -*- coding: utf-8 -*-
+
+from utils import *
+from euclid import Quaternion
+
+#supported poser texture modes
+class TextureMode:
+    MODULATE = 'MODULATE'
+    NORMAL = 'NORMAL'
+    GLOSS = 'GLOSS'
+    ALPHA = 'ALPHA'
+
+
+# Class for egg presentation of Poser material
+class EggMaterial:
+    def __init__(self, poser_material):
+        self.poser_material = poser_material
+        self.name = egg_safe_same(poser_material.Name())
+
+        textures = [self._check_texture(poser_material.TextureMapFileName(), '_texture', TextureMode.MODULATE),
+                   self._check_texture(poser_material.BumpMapFileName(), '_bump', TextureMode.NORMAL),
+                   self._check_texture(poser_material.TransparencyMapFileName(), '_transparency', TextureMode.ALPHA)]
+        self.textures = filter(None, textures)
+
+    def _check_texture(self, textureName, egg_texture_name, egg_texture_mode):
+        texture = EggTexture(textureName, self.name + egg_texture_name, egg_texture_mode)
+        return texture.check_texture()
+
+    def write(self):
+        lines = ["<Material> %s {\n" % self.name]
+        lines += "   <Scalar> diffr {%f} <Scalar> diffg {%f} <Scalar> diffb {%f}\n" % (self.poser_material.DiffuseColor())
+        sr, sg, sb = self.poser_material.SpecularColor()
+        lines += "   <Scalar> specr {%f} <Scalar> specg {%f} <Scalar> specb {%f}\n" % (sr * 0.2, sg * 0.2, sb * 0.2)
+        lines += "   <Scalar> shininess { 25 }"
+        lines += "\n}\n"
+        return lines
+
+    def __str__(self):
+        return self.name + ",".join(self.textures)
+
+
+# Class for egg presentation of Poser material textures
+class EggTexture:
+    EMPTY_TEXTURE = poser.ContentRootLocation().replace("\\", '/').replace(":", "")
+    ALL_TEXTURES = {}
+
+    def __init__(self, filename, texture_name, texture_mode):
+        self.texture_mode = texture_mode
+        self.filename = None
+        if filename is not None:
+            self.filename = filename.replace("\\", '/').replace(":", "")
+        self.name = egg_safe_same(texture_name)
+
+    def check_texture(self):
+        if self.filename != EggTexture.EMPTY_TEXTURE and self.filename is not None:
+            if self.filename not in EggTexture.ALL_TEXTURES:
+                EggTexture.ALL_TEXTURES[self.filename] = self
+            return EggTexture.ALL_TEXTURES[self.filename].name
+        return None
+
+    def write(self):
+        lines = ["<Texture> %s {\n \"%s\" \n" % (self.name, self.filename)]
+        # poser transparency textures are separate file and exported as pure alpha in egg
+        if self.texture_mode == TextureMode.ALPHA:
+            lines += "   <Scalar> format { alpha }\n"
+            lines += "   <Scalar> envtype { %s }" % TextureMode.MODULATE
+        else:
+            lines += "   <Scalar> envtype { %s }" % self.texture_mode
+        lines += "   <Scalar> wrap { %s }" % 'REPEAT'
+        lines += "\n}\n"
+        return lines
+
+
+class EggObject:
+    empty_texture = poser.ContentRootLocation()
+    SKIP_MORPHS = 'SKIP_MORPHS'
+    BAKE_MORPHS = 'BAKE_MORPHS'
+    EXPORT_MORPHS = 'EXPORT_MORPHS'
+
+    def __init__(self, figure):
+        self.options = {"morph": self.BAKE_MORPHS, "textures": True}
+        self.figure = figure
+        self.figure_name = fix_name(figure.Name())
+
+    def export(self):
+        # get geometry from poser
+        uniGeometry, self.uniActorList, self.uniActorVertexInfoList = self.figure.UnimeshInfo()
+        # collect materials/textures
+        self.materials, self.textures = self.collect_materials(self.figure)
+        # collect vertices
+        self.vertices, self.polygons, self.poser2egg = self.collect_vertices(self.uniActorList)
+        # collect joints
+        self.joints = self.collect_joints(self.figure.ParentActor(), 1)
+        # write egg content
+        return self.write()
+
+    def write(self):
+        lines = []
+        lines += "<CoordinateSystem> { Y-Up-Right }\n"
+        lines += write_comment('poser2egg - ' + self.figure_name, 0)
+        # write materials and textures
+        print 'Writing Materials ...'
+        lines + self.write_materials()
+        # write rig
+        print 'Writing Rig ...'
+        lines += "<Group> %s {\n  <Dart> { 1 }\n" % (self.figure_name, )
+        # write joints
+        lines += self.write_joints(self.joints)
+        poser.Scene().ProcessSomeEvents()
+        # write vertex pool
+        print 'Writing vertices ...'
+        lines += self.write_vertex_pool()
+        poser.Scene().ProcessSomeEvents()
+        # write polygons
+        print 'Writing Polygons ...'
+        lines += self.write_polygons()
+        poser.Scene().ProcessSomeEvents()
+        lines += '} // End Group: %s \n' % (self.figure_name, )
+        return lines
+
+    def collect_joints(self, actor, level):
+        if not actor.IsBodyPart() or actor.Name() == 'BodyMorphs':
+            return
+        actorName = fix_name(actor.Name())
+        print indent_string('processing %s' % actorName, level)
+        #origin = actor.Origin()
+        #parentOrigin = actor.Parent().Origin()
+        if actor.Name() == self.figure.ParentActor().Name():
+            #matrix = get_matrix(origin)
+            matrix = actor.WorldMatrix()  # get_matrix(origin)
+        else:
+            #matrix = get_matrix(vec_subtract(origin, parentOrigin))
+            matrix = actor.LocalMatrix()
+        vertex_refs = []
+        if actor.Geometry():
+            vertex_refs = self.poser2egg[self.get_actor_index(actor)]
+        child_joints = []
+        for child in actor.Children():
+            child_joint = self.collect_joints(child, level + 1)
+            if child_joint is not None:
+                child_joints += child_joint
+        return [(actorName, matrix, child_joints, vertex_refs, actor)]
+
+    def write_joints(self, joint, indent=1):
+        lines = []
+        for (joint_name, joint_matrix, child_joints, vertex_refs, actor) in joint:
+            #print joint_name
+            lines += indent_string('  <Joint> %s {\n' % joint_name, indent)
+            lines += write_transform(joint_matrix, indent + 1)
+
+            lines += indent_string('<VertexRef> {\n', indent + 1)
+            vx = [str(v) for v in vertex_refs]
+            lines.append(indent_string('%s\n' % (' '.join(vx)), indent + 2))
+            lines.append(indent_string('<Ref> { mesh }\n', indent + 2))
+            lines.append(indent_string('}\n', indent + 1))
+
+            lines += self.write_joints(child_joints, indent + 1)
+            lines += indent_string('  } // End joint %s \n' % joint_name, indent)
+
+        return lines
+
+    def get_actor_index(self, actor):
+        for i, a in enumerate(self.uniActorList):
+            if a.InternalName() == actor.InternalName():
+                return i
+        return None
+
+    def collect_materials(self, figure):
+        egg_materials = {}
+        for material in figure.Materials():
+            mat_name = material.Name()
+            if mat_name == 'Preview':
+                continue
+            egg_materials[mat_name] = EggMaterial(material)
+        return egg_materials, EggTexture.ALL_TEXTURES
+
+    def write_materials(self):
+        lines = []
+        for material in self.materials.values():
+            lines += material.write()
+        if self.options["textures"] == True:
+            for texture in self.textures.values():
+                lines += texture.write()
+        return lines
+
+    def collect_vertices(self, uniActorList):
+        bake_morph = self.options["morph"] == self.BAKE_MORPHS
+        print 'Collecting vertices ...'
+        egg_vertices = []
+        egg_polygons = []
+        poser2egg = {}
+        self.egg_uvs = {}
+        # egg vertex index is different from poser
+        vertex_index = 0
+        for actor in uniActorList:
+            print actor.Name()
+            actor_index = self.get_actor_index(actor)
+            poser2egg[actor_index] = {}
+            # get actor geom data
+            geom = actor.Geometry()
+            # check morph options
+            if bake_morph:
+                all_params = actor.Parameters()
+                # get morph targets
+                #morphs = [p for p in all_params if not p.Name().startswith('EMPTY') and not p.Name().startswith('V4') and p.Name() != '-' and p.IsMorphTarget() and (abs(p.Value()-0.0) > 0.001) and p.Hidden() != 1]
+                morphs = [p for p in all_params if p.IsMorphTarget() and not p.Name().startswith('EMPTY') and p.Name() != '-' and not p.Name().startswith('V4') and (abs(p.Value() - 0.0) > 0.1)]
+                #morphs = [p for p in all_params if p.IsMorphTarget() and p.IsValueParameter() and (abs(p.Value() - 0.0) > 0.1)]
+                # poser vertices/texture data
+            vertices, tex_vertices, normals = geom.Vertices(), geom.TexVertices(), geom.Normals()
+            # poser polygon/texture data (index to start in sets/tex_sets + number of vertices)
+            polygons, tex_polygons = geom.Polygons(), geom.TexPolygons()
+            # poser sets/texture sets containing vertices id for vertices/tex_vertices arrays
+            sets, tex_sets = geom.Sets(), geom.TexSets()
+            # collect all geom data for current actor and present as egg group
+            group_name = fix_name(actor.Name())
+            group_polygons = []
+            for polygon_index, polygon in enumerate(polygons):
+                poly_start = vertex_index
+                start = polygon.Start()
+                # get tex_polygon and tex_set for current polygon
+                tex_polygon = tex_polygons[polygon_index]
+                tex_set = tex_sets[tex_polygon.Start(): tex_polygon.Start() + tex_polygon.NumTexVertices()]
+                # get all polygon vertices
+                for k, v in enumerate(sets[start: start + polygon.NumVertices()]):
+                    vertex = vertices[v]
+                    self.egg_uvs[start + k] = tex_vertices[tex_set[k]]
+                    x, y, z = vertex.X(), vertex.Y(), vertex.Z()
+                    if bake_morph:
+                        for morph in morphs:
+                            dx, dy, dz = morph.MorphTargetDelta(v)
+                            x += dx * morph.Value()
+                            y += dy * morph.Value()
+                            z += dz * morph.Value()
+                    egg_vertices.append((vertex_index, (x, y, z), normals[v], tex_vertices[tex_set[k]]))
+                    poser2egg[actor_index][vertex_index] = vertex_index
+                    # increment egg vertex index
+                    vertex_index += 1
+                    # add egg polygon data to group polygons (poser polygon + start/length in egg_vertices list)
+                group_polygons.append((polygon, poly_start, vertex_index - poly_start))
+            egg_polygons.append((group_name, group_polygons))
+            poser.Scene().ProcessSomeEvents()
+        return egg_vertices, egg_polygons, poser2egg
+
+    def write_vertex_pool(self):
+        lines = []
+        lines += '  <VertexPool> mesh {\n'
+        for (i, v_tuple, n, t) in self.vertices:
+            lines.append('    <Vertex> %s { %f %f %f <Normal> { %f %f %f } <UV> { %f %f } }\n' %
+                         (str(i), v_tuple[0], v_tuple[1], v_tuple[2],
+                          n.X() != 'nan' or 0, n.Y() != 'nan' or 0, n.Z() != 'nan' or 0,
+                          t.U(), t.V()))
+
+        lines += '  } // End VertexPool: mesh\n'
+        print '* 100 %'
+        return lines
+
+    def write_polygons(self):
+        lines = []
+        for (group_name, group_polys) in self.polygons:
+            lines += "<Group> %s {\n" % (group_name, )
+            for (polygon, start_index, num_vertices) in group_polys:
+                refs = ' '.join([str(j) for j in range(start_index, start_index + num_vertices)])
+                if self.options["textures"] == True:
+                    polygon_trefs = ' '.join(
+                        "<TRef> {%s}" % texture_name for texture_name in self.materials[polygon.MaterialName()].textures)
+                else:
+                    polygon_trefs = ""
+                lines.append(
+                    "  <Polygon> {\n    %s\n    <MRef> { %s } \n    <VertexRef> { %s <Ref> { mesh } } \n}\n" % (
+                        polygon_trefs, polygon.MaterialName(), refs, ))
+            lines += "\n}\n"
+        print '* 100 %'
+        return lines
+
+    def collect_anims(self):
+        anims_data = {}
+        for frame in xrange(0, poser.Scene().NumFrames() - 1):
+        #for frame in xrange(0, 3):
+            poser.Scene().SetFrame(frame)
+            poser.Scene().DrawAll()
+            self.collect_anims2(self.joints, anims_data)
+        return anims_data
+
+    def collect_anims2(self, joint, anims):
+        for (joint_name, joint_matrix, child_joints, vertex_refs, actor) in joint:
+            #print "anims for %s" % joint_name
+            #get bone displacement
+            displacement = actor.LocalDisplacement()
+            origin = actor.Origin()
+            parentOrigin = actor.Parent().Origin()
+            if actor.Name() == self.figure.ParentActor().Name():
+                parentOrigin = origin
+            displacement = vec_add(vec_subtract(origin, parentOrigin), displacement)
+            displacement = vec_subtract(origin, parentOrigin)
+            # get rotation
+            quat_tuple = actor.LocalQuaternion()
+            quat = Quaternion(quat_tuple[0], quat_tuple[1], quat_tuple[2], quat_tuple[3])
+            hpr = radians_to_degrees(quat.get_euler())
+            #store displacement/rotation in anims data
+            if joint_name not in anims:
+                anims[joint_name] = []
+            anims[joint_name].append((displacement, hpr))
+            self.collect_anims2(child_joints, anims)
+        return anims
+
+    def write_animation(self):
+        print 'Writing animation ...'
+        anims_data = self.collect_anims()
+        #print anims_data
+        #return
+        lines = []
+        lines += '<Table> {\n'
+        lines += indent_string('<Bundle> %s {\n' % self.figure_name, 1)
+        lines += indent_string('<Table> "<skeleton>" {\n', 2)
+        lines += self.write_animation_table(self.joints, anims_data, 3)
+        lines += indent_string('}\n', 2)
+        lines += indent_string('}\n', 1)
+        lines += '}'
+
+        return lines
+
+    def write_animation_table(self, joint, anims_data, indent=1):
+        lines = []
+        for (joint_name, joint_matrix, child_joints, vertex_refs, actor) in joint:
+            #print joint_name
+            lines += indent_string('<Table> %s {\n' % joint_name, indent)
+            lines += indent_string('<Xfm$Anim> xform {\n', indent + 1)
+            lines += indent_string('<Scalar> order { sprht }\n', indent + 2)
+            lines += indent_string('<Scalar> contents { prhxyz }\n', indent + 2)
+            #lines += indent_string('<Scalar> contents { ijkprhxyz }\n', indent + 2)
+            lines += indent_string('<Scalar> fps { %u }\n' % 2, indent + 2)
+            lines += indent_string('<V> {\n', indent + 2)
+            for frame in xrange(0, poser.Scene().NumFrames() - 1):
+                displacement, hpr = anims_data[joint_name][frame]
+                #lines += indent_string("%s %s %s %s %s %s %s %s %s\n" %
+                lines += indent_string("%s %s %s %s %s %s\n" %
+                        (
+                            hpr[2], hpr[1], hpr[0],
+                            displacement[0], displacement[1], displacement[2]
+                        ),
+                    indent + 3)
+            lines += indent_string('}\n', indent + 2)
+            lines += indent_string('}\n', indent + 1)
+            lines += self.write_animation_table(child_joints, anims_data, indent + 2)
+            lines += indent_string('} // End table %s \n' % joint_name, indent)
+
+        return lines