From: ousttrue <ousttrue@gmail.com>
Date: Fri, 30 Sep 2011 14:52:00 +0000 (+0900)
Subject: implement DisplaySlot
X-Git-Url: http://git.osdn.net/view?p=meshio%2Fpymeshio.git;a=commitdiff_plain;h=6af4a957178e9a2855c338749167c8fd50e475a8

implement DisplaySlot
---

diff --git a/pymeshio/pmx/__init__.py b/pymeshio/pmx/__init__.py
index a5391d7..54ce4f1 100644
--- a/pymeshio/pmx/__init__.py
+++ b/pymeshio/pmx/__init__.py
@@ -259,6 +259,28 @@ class VerexMorphOffset(object):
         self.position_offset=position_offset
 
 
+class DisplaySlot(object):
+    """pmx display slot
+
+    Attributes:
+        name: 
+        english_name: 
+        special_flag:
+        refrences: list of (ref_type, ref_index)
+    """
+    __slots__=[
+            'name',
+            'english_name',
+            'special_flag',
+            'refrences',
+            ]
+    def __init__(self, name, english_name, special_flag):
+        self.name=name
+        self.english_name=english_name
+        self.special_flag=special_flag
+        self.refrences=[]
+
+
 class Model(object):
     """pmx data representation
 
diff --git a/pymeshio/pmx/loader.py b/pymeshio/pmx/loader.py
index 18e19c0..742f329 100644
--- a/pymeshio/pmx/loader.py
+++ b/pymeshio/pmx/loader.py
@@ -20,7 +20,8 @@ class Loader(pymeshio.common.BinaryLoader):
         super(Loader, self).__init__(io)
         self.read_text=self.get_read_text(text_encoding)
         if extended_uv>0:
-            raise pymeshio.common.ParseException("extended uv is not supported", extended_uv)
+            raise pymeshio.common.ParseException(
+                    "extended uv is not supported", extended_uv)
         self.read_vertex_index=lambda : self.read_uint(vertex_index_size)
         self.read_texture_index=lambda : self.read_uint(texture_index_size)
         self.read_material_index=lambda : self.read_uint(material_index_size)
@@ -66,9 +67,11 @@ class Loader(pymeshio.common.BinaryLoader):
                     )
         elif deform_type==2:
             # todo
-            raise pymeshio.common.ParseException("not implemented Bdef4")
+            raise pymeshio.common.ParseException(
+                    "not implemented Bdef4")
         else:
-            raise pymeshio.common.ParseException("unknown deform type: {0}".format(deform_type))
+            raise pymeshio.common.ParseException(
+                    "unknown deform type: {0}".format(deform_type))
 
     def read_material(self):
         material=pymeshio.pmx.Material(
@@ -92,7 +95,9 @@ class Loader(pymeshio.common.BinaryLoader):
         elif material.toon_sharing_flag==1:
             material.toon_texture_index=self.read_uint(1)
         else:
-            raise pymeshio.common.ParseException("unknown toon_sharing_flag {0}".format(material.toon_sharing_flag))
+            raise pymeshio.common.ParseException(
+                    "unknown toon_sharing_flag {0}".format(
+                        material.toon_sharing_flag))
         material.comment=self.read_text()
         material.index_count=self.read_uint(4)
         return material
@@ -111,7 +116,8 @@ class Loader(pymeshio.common.BinaryLoader):
         elif bone.getConnectionFlag()==1:
             bone.tail_index=self.read_bone_index()
         else:
-            raise pymeshio.common.ParseException("unknown bone conenction flag: {0}".format(
+            raise pymeshio.common.ParseException(
+                    "unknown bone conenction flag: {0}".format(
                 bone.getConnectionFlag()))
 
         if bone.getRotationFlag()==1 or bone.getTranslationFlag()==1:
@@ -139,7 +145,8 @@ class Loader(pymeshio.common.BinaryLoader):
                 loop=self.read_uint(4),
                 limit_radian=self.read_float())
         link_size=self.read_uint(4)
-        ik.link=[self.read_ik_link() for _ in range(link_size)]
+        ik.link=[self.read_ik_link() 
+                for _ in range(link_size)]
 
     def read_ik_link(self):
         link=pymeshio.pmx.IkLink(
@@ -151,7 +158,8 @@ class Loader(pymeshio.common.BinaryLoader):
             link.limit_min=self.read_vector3()
             link.limit_max=self.read_vector3()
         else:
-            raise pymeshio.common.ParseException("invalid ik link limit_angle: {0}".format(
+            raise pymeshio.common.ParseException(
+                    "invalid ik link limit_angle: {0}".format(
                 link.limit_angle))
         return link
 
@@ -163,40 +171,65 @@ class Loader(pymeshio.common.BinaryLoader):
         offset_size=self.read_uint(4)
         if morph_type==0:
             # todo
-            raise pymeshio.common.ParseException("not implemented GroupMorph")
+            raise pymeshio.common.ParseException(
+                    "not implemented GroupMorph")
         elif morph_type==1:
-            morph=pymeshio.pmx.Morph(name, english_name, panel, morph_type)
-            morph.offsets=[self.read_vertex_morph_offset() for _ in range(offset_size)]
+            morph=pymeshio.pmx.Morph(name, english_name, 
+                    panel, morph_type)
+            morph.offsets=[self.read_vertex_morph_offset() 
+                    for _ in range(offset_size)]
             return morph
         elif morph_type==2:
             # todo
-            raise pymeshio.common.ParseException("not implemented BoneMorph")
+            raise pymeshio.common.ParseException(
+                    "not implemented BoneMorph")
         elif morph_type==3:
             # todo
-            raise pymeshio.common.ParseException("not implemented UvMorph")
+            raise pymeshio.common.ParseException(
+                    "not implemented UvMorph")
         elif morph_type==4:
             # todo
-            raise pymeshio.common.ParseException("not implemented extended UvMorph1")
+            raise pymeshio.common.ParseException(
+                    "not implemented extended UvMorph1")
         elif morph_type==5:
             # todo
-            raise pymeshio.common.ParseException("not implemented extended UvMorph2")
+            raise pymeshio.common.ParseException(
+                    "not implemented extended UvMorph2")
         elif morph_type==6:
             # todo
-            raise pymeshio.common.ParseException("not implemented extended UvMorph3")
+            raise pymeshio.common.ParseException(
+                    "not implemented extended UvMorph3")
         elif morph_type==7:
             # todo
-            raise pymeshio.common.ParseException("not implemented extended UvMorph4")
+            raise pymeshio.common.ParseException(
+                    "not implemented extended UvMorph4")
         elif morph_type==8:
             # todo
-            raise pymeshio.common.ParseException("not implemented extended MaterialMorph")
+            raise pymeshio.common.ParseException(
+                    "not implemented extended MaterialMorph")
         else:
-            raise pymeshio.common.ParseException("unknown morph type: {0}".format(morph_type))
+            raise pymeshio.common.ParseException(
+                    "unknown morph type: {0}".format(morph_type))
 
     def read_vertex_morph_offset(self):
-        return pymeshio.pmx.VerexMorphOffset(self.read_vertex_index(), self.read_vector3())
+        return pymeshio.pmx.VerexMorphOffset(
+                self.read_vertex_index(), self.read_vector3())
 
     def read_display_slot(self):
-        pass
+        display_slot=pymeshio.pmx.DisplaySlot(self.read_text(), self.read_text(), 
+                self.read_uint(1))
+        display_count=self.read_uint(4)
+        for _ in range(display_count):
+            display_type=self.read_uint(1)
+            if display_type==0:
+                display_slot.refrences.append(
+                        (display_type, self.read_bone_index()))
+            elif display_type==1:
+                display_slot.refrences.append(
+                        (display_type, self.read_morph_index()))
+            else:
+                raise pymeshio.common.ParseException(
+                        "unknown display_type: {0}".format(display_type))
 
 
 def load(path: str) -> pymeshio.pmx.Model:
@@ -208,7 +241,8 @@ def load(path: str) -> pymeshio.pmx.Model:
     # header
     signature=loader.unpack("4s", 4)
     if signature!=b"PMX ":
-        raise pymeshio.common.ParseException("invalid signature", loader.signature)
+        raise pymeshio.common.ParseException(
+                "invalid signature", loader.signature)
 
     version=loader.read_float()
     if version!=2.0:
@@ -218,7 +252,8 @@ def load(path: str) -> pymeshio.pmx.Model:
     # flags
     flag_bytes=loader.read_uint(1)
     if flag_bytes!=8:
-        raise pymeshio.common.ParseException("invalid flag length", loader.flag_bytes)
+        raise pymeshio.common.ParseException(
+                "invalid flag length", loader.flag_bytes)
     text_encoding=loader.read_uint(1)
     extended_uv=loader.read_uint(1)
     vertex_index_size=loader.read_uint(1)
@@ -248,25 +283,32 @@ def load(path: str) -> pymeshio.pmx.Model:
 
     # model data
     vertex_count=loader.read_uint(4)
-    model.vertices=[loader.read_vertex() for _ in range(vertex_count)]
+    model.vertices=[loader.read_vertex() 
+            for _ in range(vertex_count)]
 
     index_count=loader.read_uint(4)
-    model.indices=[loader.read_vertex_index() for _ in range(index_count)]
+    model.indices=[loader.read_vertex_index() 
+            for _ in range(index_count)]
 
     texture_count=loader.read_uint(4)
-    model.textures=[loader.read_text() for _ in range(texture_count)]
+    model.textures=[loader.read_text() 
+            for _ in range(texture_count)]
 
     material_count=loader.read_uint(4)
-    model.materials=[loader.read_material() for _ in range(material_count)]
+    model.materials=[loader.read_material() 
+            for _ in range(material_count)]
 
     bone_count=loader.read_uint(4)
-    model.bones=[loader.read_bone() for _ in range(bone_count)]
+    model.bones=[loader.read_bone() 
+            for _ in range(bone_count)]
 
     morph_count=loader.read_uint(4)
-    model.morphs=[loader.read_morgh() for _ in range(morph_count)]
+    model.morphs=[loader.read_morgh() 
+            for _ in range(morph_count)]
 
     display_slot_count=loader.read_uint(4)
-    model.display_slots=[loader.read_display_slot() for _ in range(display_slot_count)]
+    model.display_slots=[loader.read_display_slot() 
+            for _ in range(display_slot_count)]
 
     return model