return f.read()\r
\r
\r
-class BinaryLoader(object):\r
- """general BinaryLoader\r
+class BinaryReader(object):\r
+ """general BinaryReader\r
"""\r
def __init__(self, ios):\r
self.ios=ios\r
"""\r
\r
\r
-class Loader(object):\r
- """mqo loader\r
+class Reader(object):\r
+ """mqo reader\r
"""\r
__slots__=[\r
"has_mikoto",\r
return False\r
\r
\r
-def load_from_file(path):\r
+def read_from_file(path):\r
with open(path, 'rb') as ios:\r
- load(ios)\r
+ read(ios)\r
\r
\r
-def load(ios):\r
+def read(ios):\r
assert(isinstance(ios, io.IOBase))\r
- loader=Loader(ios)\r
+ reader=Reader(ios)\r
model=pymeshio.mqo.Model()\r
\r
- line=loader.getline()\r
+ line=reader.getline()\r
if line!="Metasequoia Document":\r
print("invalid signature")\r
return False\r
\r
- line=loader.getline()\r
+ line=reader.getline()\r
if line!="Format Text Ver 1.0":\r
print("unknown version: %s" % line)\r
\r
while True:\r
- line=loader.getline()\r
+ line=reader.getline()\r
if line==None:\r
# eof\r
break;\r
if key=="Eof":\r
return model\r
elif key=="Scene":\r
- if not loader.readChunk():\r
+ if not reader.readChunk():\r
return\r
elif key=="Material":\r
- materials=loader.readMaterial()\r
+ materials=reader.readMaterial()\r
if not materials:\r
return\r
model.materials=materials\r
elif key=="Object":\r
firstQuote=line.find('"')\r
secondQuote=line.find('"', firstQuote+1)\r
- obj=loader.readObject(line[firstQuote+1:secondQuote])\r
+ obj=reader.readObject(line[firstQuote+1:secondQuote])\r
if not obj:\r
return\r
model.objects.append(obj)\r
elif key=="BackImage":\r
- if not loader.readChunk():\r
+ if not reader.readChunk():\r
return\r
elif key=="IncludeXml":\r
firstQuote=line.find('"')\r
print("IncludeXml", line[firstQuote+1:secondQuote])\r
else:\r
print("unknown key: %s" % key)\r
- if not loader.readChunk():\r
+ if not reader.readChunk():\r
return\r
# error not reach here\r
raise ParseException("invalid eof")\r
def getUV(self, i): return self.vertices[i].uv
def __str__(self):
- return '<PMDLoader version: %g, model: "%s", vertex: %d, face: %d, material: %d, bone: %d ik: %d, skin: %d>' % (
+ return '<pmd-%g, "%s" vertex: %d, face: %d, material: %d, bone: %d ik: %d, skin: %d>' % (
self.version, self.name, len(self.vertices), len(self.indices),
len(self.materials), len(self.bones), len(self.ik_list), len(self.morph_list))
def read(self, path):
warnings.warn("'pymeshio.mqo.IO.read' will be replaced by 'pymeshio.mqo.loader.load'")
- model=pymeshio.pmd.loader.load_from_file(path)
+ model=pymeshio.pmd.reader.read_from_file(path)
if model:
return True
import pymeshio.pmd\r
\r
\r
-class Loader(pymeshio.common.BinaryLoader):\r
- """pmx loader\r
+class Reader(pymeshio.common.BinaryReader):\r
+ """pmx reader\r
"""\r
def __init__(self, ios, version):\r
- super(Loader, self).__init__(ios)\r
+ super(Reader, self).__init__(ios)\r
self.version=version\r
\r
def read_text(self, size):\r
\r
\r
\r
-def __load(loader, model):\r
+def __read(reader, model):\r
# model info\r
- model.name=loader.read_text(20)\r
- model.comment=loader.read_text(256) \r
+ model.name=reader.read_text(20)\r
+ model.comment=reader.read_text(256) \r
\r
# model data\r
- model.vertices=[loader.read_vertex()\r
- for _ in range(loader.read_uint(4))]\r
- model.indices=[loader.read_uint(2)\r
- for _ in range(loader.read_uint(4))]\r
- model.materials=[loader.read_material()\r
- for _ in range(loader.read_uint(4))]\r
- model.bones=[loader.read_bone()\r
- for _ in range(loader.read_uint(2))]\r
- model.ik_list=[loader.read_ik()\r
- for _ in range(loader.read_uint(2))]\r
- model.morphs=[loader.read_morph()\r
- for _ in range(loader.read_uint(2))]\r
- model.morph_indices=[loader.read_uint(2)\r
- for _ in range(loader.read_uint(1))]\r
- model.bone_group_list=[loader.read_text(50)\r
- for _ in range(loader.read_uint(1))]\r
- model.bone_display_list=[(loader.read_uint(2), loader.read_uint(1))\r
- for _i in range(loader.read_uint(4))]\r
-\r
- if loader.is_end():\r
+ model.vertices=[reader.read_vertex()\r
+ for _ in range(reader.read_uint(4))]\r
+ model.indices=[reader.read_uint(2)\r
+ for _ in range(reader.read_uint(4))]\r
+ model.materials=[reader.read_material()\r
+ for _ in range(reader.read_uint(4))]\r
+ model.bones=[reader.read_bone()\r
+ for _ in range(reader.read_uint(2))]\r
+ model.ik_list=[reader.read_ik()\r
+ for _ in range(reader.read_uint(2))]\r
+ model.morphs=[reader.read_morph()\r
+ for _ in range(reader.read_uint(2))]\r
+ model.morph_indices=[reader.read_uint(2)\r
+ for _ in range(reader.read_uint(1))]\r
+ model.bone_group_list=[reader.read_text(50)\r
+ for _ in range(reader.read_uint(1))]\r
+ model.bone_display_list=[(reader.read_uint(2), reader.read_uint(1))\r
+ for _i in range(reader.read_uint(4))]\r
+\r
+ if reader.is_end():\r
# EOF\r
return True\r
\r
############################################################\r
# extend1: english name\r
############################################################\r
- if loader.read_uint(1)==0:\r
+ if reader.read_uint(1)==0:\r
print("no extend flag")\r
return True\r
- model.english_name=loader.read_text(20)\r
- model.english_comment=loader.read_text(256)\r
+ model.english_name=reader.read_text(20)\r
+ model.english_comment=reader.read_text(256)\r
for bone in model.bones:\r
- bone.english_name=loader.read_text(20)\r
+ bone.english_name=reader.read_text(20)\r
for morph in model.morphs:\r
if morph.name==b'base':\r
continue\r
- morph.english_name=loader.read_text(20)\r
- model.bone_group_english_list=[loader.read_text(50)\r
+ morph.english_name=reader.read_text(20)\r
+ model.bone_group_english_list=[reader.read_text(50)\r
for _ in model.bone_group_list]\r
\r
############################################################\r
# extend2: toon_textures\r
############################################################\r
- if loader.is_end():\r
+ if reader.is_end():\r
# EOF\r
return True\r
- model.toon_textures=[loader.read_text(100)\r
+ model.toon_textures=[reader.read_text(100)\r
for _ in range(10)]\r
\r
############################################################\r
# extend2: rigidbodies and joints\r
############################################################\r
- if loader.is_end():\r
+ if reader.is_end():\r
# EOF\r
return True\r
- model.rigidbodies=[loader.read_rigidbody()\r
- for _ in range(loader.read_uint(4))]\r
- model.joints=[loader.read_joint()\r
- for _ in range(loader.read_uint(4))]\r
+ model.rigidbodies=[reader.read_rigidbody()\r
+ for _ in range(reader.read_uint(4))]\r
+ model.joints=[reader.read_joint()\r
+ for _ in range(reader.read_uint(4))]\r
\r
return True\r
\r
\r
-def load_from_file(path):\r
- return load(io.BytesIO(pymeshio.common.readall(path)))\r
+def read_from_file(path):\r
+ return read(io.BytesIO(pymeshio.common.readall(path)))\r
\r
\r
-def load(ios):\r
+def read(ios):\r
assert(isinstance(ios, io.IOBase))\r
- loader=pymeshio.common.BinaryLoader(ios)\r
+ reader=pymeshio.common.BinaryReader(ios)\r
\r
# header\r
- signature=loader.unpack("3s", 3)\r
+ signature=reader.unpack("3s", 3)\r
if signature!=b"Pmd":\r
raise pymeshio.common.ParseException(\r
"invalid signature: {0}".format(signature))\r
- version=loader.read_float()\r
+ version=reader.read_float()\r
\r
model=pymeshio.pmd.Model(version)\r
- loader=Loader(loader.ios, version)\r
- if(__load(loader, model)):\r
+ reader=Reader(reader.ios, version)\r
+ if(__read(reader, model)):\r
# check eof\r
- if not loader.is_end():\r
+ if not reader.is_end():\r
#print("can not reach eof.")\r
pass\r
\r
import pymeshio.pmx\r
\r
\r
-class Loader(pymeshio.common.BinaryLoader):\r
- """pmx loader\r
+class Reader(pymeshio.common.BinaryReader):\r
+ """pmx reader\r
"""\r
def __init__(self, ios,\r
text_encoding,\r
morph_index_size,\r
rigidbody_index_size\r
):\r
- super(Loader, self).__init__(ios)\r
+ super(Reader, self).__init__(ios)\r
self.read_text=self.get_read_text(text_encoding)\r
if extended_uv>0:\r
raise pymeshio.common.ParseException(\r
self.read_rigidbody_index=lambda : self.read_uint(rigidbody_index_size)\r
\r
def __str__(self):\r
- return '<pymeshio.pmx.Loader>'\r
+ return '<pymeshio.pmx.Reader>'\r
\r
def get_read_text(self, text_encoding):\r
if text_encoding==0:\r
spring_constant_rotation=self.read_vector3())\r
\r
\r
-def load_from_file(path):\r
- return load(io.BytesIO(pymeshio.common.readall(path)))\r
+def read_from_file(path):\r
+ return read(io.BytesIO(pymeshio.common.readall(path)))\r
\r
\r
-def load(ios):\r
+def read(ios):\r
assert(isinstance(ios, io.IOBase))\r
- loader=pymeshio.common.BinaryLoader(ios)\r
+ reader=pymeshio.common.BinaryReader(ios)\r
\r
# header\r
- signature=loader.unpack("4s", 4)\r
+ signature=reader.unpack("4s", 4)\r
if signature!=b"PMX ":\r
raise pymeshio.common.ParseException(\r
"invalid signature", signature)\r
\r
- version=loader.read_float()\r
+ version=reader.read_float()\r
if version!=2.0:\r
print("unknown version", version)\r
model=pymeshio.pmx.Model(version)\r
\r
# flags\r
- flag_bytes=loader.read_uint(1)\r
+ flag_bytes=reader.read_uint(1)\r
if flag_bytes!=8:\r
raise pymeshio.common.ParseException(\r
- "invalid flag length", loader.flag_bytes)\r
- text_encoding=loader.read_uint(1)\r
- extended_uv=loader.read_uint(1)\r
- vertex_index_size=loader.read_uint(1)\r
- texture_index_size=loader.read_uint(1)\r
- material_index_size=loader.read_uint(1)\r
- bone_index_size=loader.read_uint(1)\r
- morph_index_size=loader.read_uint(1)\r
- rigidbody_index_size=loader.read_uint(1)\r
+ "invalid flag length", reader.flag_bytes)\r
+ text_encoding=reader.read_uint(1)\r
+ extended_uv=reader.read_uint(1)\r
+ vertex_index_size=reader.read_uint(1)\r
+ texture_index_size=reader.read_uint(1)\r
+ material_index_size=reader.read_uint(1)\r
+ bone_index_size=reader.read_uint(1)\r
+ morph_index_size=reader.read_uint(1)\r
+ rigidbody_index_size=reader.read_uint(1)\r
\r
- # pmx custom loader\r
- loader=Loader(loader.io,\r
+ # pmx custom reader\r
+ reader=Reader(reader.io,\r
text_encoding,\r
extended_uv,\r
vertex_index_size,\r
)\r
\r
# model info\r
- model.name = loader.read_text()\r
- model.english_name = loader.read_text()\r
- model.comment = loader.read_text()\r
- model.english_comment = loader.read_text()\r
+ model.name = reader.read_text()\r
+ model.english_name = reader.read_text()\r
+ model.comment = reader.read_text()\r
+ model.english_comment = reader.read_text()\r
\r
# model data\r
- model.vertices=[loader.read_vertex() \r
- for _ in range(loader.read_uint(4))]\r
- model.indices=[loader.read_vertex_index() \r
- for _ in range(loader.read_uint(4))]\r
- model.textures=[loader.read_text() \r
- for _ in range(loader.read_uint(4))]\r
- model.materials=[loader.read_material() \r
- for _ in range(loader.read_uint(4))]\r
- model.bones=[loader.read_bone() \r
- for _ in range(loader.read_uint(4))]\r
- model.morphs=[loader.read_morgh() \r
- for _ in range(loader.read_uint(4))]\r
- model.display_slots=[loader.read_display_slot() \r
- for _ in range(loader.read_uint(4))]\r
- model.rigidbodies=[loader.read_rigidbody()\r
- for _ in range(loader.read_uint(4))]\r
- model.joints=[loader.read_joint()\r
- for _ in range(loader.read_uint(4))]\r
+ model.vertices=[reader.read_vertex() \r
+ for _ in range(reader.read_uint(4))]\r
+ model.indices=[reader.read_vertex_index() \r
+ for _ in range(reader.read_uint(4))]\r
+ model.textures=[reader.read_text() \r
+ for _ in range(reader.read_uint(4))]\r
+ model.materials=[reader.read_material() \r
+ for _ in range(reader.read_uint(4))]\r
+ model.bones=[reader.read_bone() \r
+ for _ in range(reader.read_uint(4))]\r
+ model.morphs=[reader.read_morgh() \r
+ for _ in range(reader.read_uint(4))]\r
+ model.display_slots=[reader.read_display_slot() \r
+ for _ in range(reader.read_uint(4))]\r
+ model.rigidbodies=[reader.read_rigidbody()\r
+ for _ in range(reader.read_uint(4))]\r
+ model.joints=[reader.read_joint()\r
+ for _ in range(reader.read_uint(4))]\r
\r
return model\r
\r
import pymeshio.mqo
+import pymeshio.mqo.reader
import sys
+
MQO_FILE="resources/cube.mqo"
def test_old_mqo_load():
io=pymeshio.mqo.IO()
assert io.read(MQO_FILE)
-def test_mqo_load():
- model=pymeshio.mqo.loader.load_from_file(MQO_FILE)
+def test_mqo_read():
+ model=pymeshio.mqo.reader.read_from_file(MQO_FILE)
print(model.materials)
assert pymeshio.mqo.Model==model.__class__
assert 6==len(model.materials)
import io
import unittest
import pymeshio.pmd
-import pymeshio.pmd.loader
+import pymeshio.pmd.reader
import pymeshio.pmd.writer
def setUp(self):
pass
- def test_load(self):
- model=pymeshio.pmd.loader.load_from_file(PMD_FILE)
+ def test_read(self):
+ model=pymeshio.pmd.reader.read_from_file(PMD_FILE)
self.assertEqual(pymeshio.pmd.Model, model.__class__)
self.assertEqual(u'初音ミク'.encode('cp932'), model.name)
self.assertEqual(u'Miku Hatsune'.encode('cp932'), model.english_name)
def test_write(self):
# read source file
buf=pymeshio.common.readall(PMD_FILE)
- # load and write to out
- model=pymeshio.pmd.loader.load(io.BytesIO(buf))
+ # read and write to out
+ model=pymeshio.pmd.reader.read(io.BytesIO(buf))
out=io.BytesIO()
pymeshio.pmd.writer.write(out, model)
# read out buffer again
- model2=pymeshio.pmd.loader.load(io.BytesIO(out.getvalue()))
+ model2=pymeshio.pmd.reader.read(io.BytesIO(out.getvalue()))
self.assertEqual(model, model2)
# coding: utf-8\r
-import pymeshio.pmx.loader\r
+import pymeshio.pmx.reader\r
import unittest\r
\r
\r
pass\r
\r
def test_read(self):\r
- model=pymeshio.pmx.loader.load_from_file(PMX_FILE)\r
+ model=pymeshio.pmx.reader.read_from_file(PMX_FILE)\r
self.assertEqual(pymeshio.pmx.Model, model.__class__)\r
self.assertEqual(u'初音ミク', model.name)\r
self.assertEqual(u'Miku Hatsune', model.english_name)\r