ad579abf00
Final (?) updates for 2.40 :) : - Bob Holcomb sent a better version of his 3ds importer - Added doc info to bvh2arm: links to doc and mocap tute from author Jean-Baptiste Perin - Alessandro Pirovano improved the Lightwave importer. - Mikael Lagre updated the collada scripts (fixed a bug with camera lens value) - Adam Saltsman improved the wings importer (ongoing work with his pal Toastie). - Anthony D'Agostino GPL'd his scripts (used Blender's BAL license previously) Thanks to all script authors for their work, interest and kindness. Again, Tom (LetterRip) has played an important part in this, thanks and welcome :).
453 lines
14 KiB
Python
453 lines
14 KiB
Python
#!BPY
|
||
|
||
"""
|
||
Name: 'Wings3D (.wings)...'
|
||
Blender: 232
|
||
Group: 'Import'
|
||
Tooltip: 'Import Wings3D File Format (.wings)'
|
||
"""
|
||
|
||
__author__ = "Anthony D'Agostino (Scorpius)"
|
||
__url__ = ("blender", "elysiun",
|
||
"Author's homepage, http://www.redrival.com/scorpius",
|
||
"Wings 3D, http://www.wings3d.com")
|
||
__version__ = "Update on version from IOSuite 0.5"
|
||
|
||
__bpydoc__ = """\
|
||
This script imports Wings3D files to Blender.
|
||
|
||
Wings3D is an open source polygon modeler written in Erlang, a
|
||
language similar to Lisp. The .wings file format is a binary
|
||
representation of erlang terms (lists, tuples, atoms, etc.) and is
|
||
compressed with zlib.
|
||
|
||
Usage:<br>
|
||
Execute this script from the "File->Import" menu and choose a Wings file
|
||
to open.
|
||
|
||
Supported:<br>
|
||
Meshes only. Not guaranteed to work in all situations.
|
||
|
||
Missing:<br>
|
||
Materials, UV Coordinates, and Vertex Color info will be ignored.
|
||
|
||
Known issues:<br>
|
||
Triangulation of convex polygons works fine, and uses a very simple
|
||
fanning algorithm. Convex polygons (i.e., shaped like the letter "U")
|
||
require a different algorithm, and will be triagulated incorrectly.
|
||
|
||
Notes:<br>
|
||
Last tested with Wings 3D 0.98.25 & Blender 2.35a.<br>
|
||
This version has improvements made by Adam Saltsman (AdamAtomic) and Toastie.
|
||
"""
|
||
|
||
# $Id$
|
||
#
|
||
# +---------------------------------------------------------+
|
||
# | Copyright (c) 2002 Anthony D'Agostino |
|
||
# | http://www.redrival.com/scorpius |
|
||
# | scorpius@netzero.com |
|
||
# | Feb 19, 2002 |
|
||
|
||
# ***** 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 Blender, meshtools
|
||
import struct, time, sys, os, zlib, cStringIO
|
||
|
||
# ==============================================
|
||
# === Read The 'Header' Common To All Chunks ===
|
||
# ==============================================
|
||
def read_chunkheader(data):
|
||
data.read(2) #version, tag = struct.unpack(">BB", data.read(2))
|
||
misc, namelen = struct.unpack(">BH", data.read(3))
|
||
name = data.read(namelen)
|
||
return name
|
||
|
||
# ==============================
|
||
# === Read The Material Mode ===
|
||
# ==============================
|
||
def read_mode(data):
|
||
data.read(5) # BL
|
||
read_chunkheader(data) # "mode"
|
||
misc, namelen = struct.unpack(">BH", data.read(3))
|
||
data.read(namelen)
|
||
data.read(1) # 6A
|
||
|
||
# =======================
|
||
# === Read Hard Edges ===
|
||
# =======================
|
||
def read_hardedges(data):
|
||
hardedge_table = {} # hard edges table
|
||
tag = data.read(1)
|
||
if tag == '\x6A':
|
||
return hardedge_table # There are no hard edges
|
||
elif tag == '\x6B':
|
||
numhardedges, = struct.unpack(">H", data.read(2))
|
||
#print "numhardedges:", numhardedges
|
||
for i in range(numhardedges):
|
||
hardedge_table[i] = struct.unpack(">B", data.read(1))[0]
|
||
elif tag == '\x6C':
|
||
numhardedges, = struct.unpack(">L", data.read(4))
|
||
#print "numhardedges:", numhardedges
|
||
for i in range(numhardedges):
|
||
misc = data.read(1)
|
||
if misc == '\x61': # next value is stored as a byte
|
||
hardedge_table[i] = struct.unpack(">B", data.read(1))[0]
|
||
elif misc == '\x62': # next value is stored as a long
|
||
hardedge_table[i] = struct.unpack(">L", data.read(4))[0]
|
||
data.read(1) # 6A
|
||
else:
|
||
print tag
|
||
return hardedge_table
|
||
|
||
# ==================
|
||
# === Read Edges ===
|
||
# ==================
|
||
def read_edges(data):
|
||
misc, numedges = struct.unpack(">BL", data.read(5))
|
||
edge_table = {} # the winged-edge table
|
||
for i in range(numedges):
|
||
if not i%100 and meshtools.show_progress: Blender.Window.DrawProgressBar(float(i)/numedges, "Reading Edges")
|
||
misc, etype = struct.unpack(">BL", data.read(5))
|
||
if etype == 2: # Vertex Colors
|
||
data.read(10) # or read_chunkheader(data) # "color"
|
||
data.read(5) # BL
|
||
r1,g1,b1,r2,g2,b2 = struct.unpack(">dddddd", data.read(48))
|
||
#print "%3d %3d %3d | %3d %3d %3d" % (r1*255,g1*255,b1*255,r2*255,g2*255,b2*255),
|
||
#print "%f %f %f | %f %f %f" % (r1, g1, b1, r2, g2, b2)
|
||
data.read(9) # or read_chunkheader(data) # "edge"
|
||
edge = [] # the eight entries for this edge
|
||
for e in range(8): # Sv Ev | Lf Rf | Lp Ls | Rp Rs
|
||
misc = data.read(1)
|
||
if misc == '\x61': # next value is stored as a byte
|
||
entry, = struct.unpack(">B", data.read(1))
|
||
edge.append(entry)
|
||
elif misc == '\x62': # next value is stored as a long
|
||
entry, = struct.unpack(">L", data.read(4))
|
||
edge.append(entry)
|
||
edge_table[i] = edge
|
||
data.read(1) # 6A
|
||
data.read(1) # 6A
|
||
return edge_table
|
||
|
||
# ==================
|
||
# === Read Faces ===
|
||
# ==================
|
||
def read_faces(data):
|
||
mat_table = {} #list of faces and material names
|
||
misc, numfaces = struct.unpack(">BL", data.read(5))
|
||
for i in range(numfaces):
|
||
if not i%100 and meshtools.show_progress: Blender.Window.DrawProgressBar(float(i)/numfaces, "Reading Faces")
|
||
if data.read(1) == '\x6C': # a material follows
|
||
data.read(4)
|
||
read_chunkheader(data)
|
||
misc, namelen = struct.unpack(">BH", data.read(3))
|
||
mat_table[i] = data.read(namelen)
|
||
data.read(1) # 6A?
|
||
data.read(1) # 6A
|
||
return mat_table
|
||
|
||
# ==================
|
||
# === Read Verts ===
|
||
# ==================
|
||
def read_verts(data):
|
||
misc, numverts = struct.unpack(">BL", data.read(5))
|
||
verts = [] # a list of verts
|
||
for i in range(numverts):
|
||
if not i%100 and meshtools.show_progress: Blender.Window.DrawProgressBar(float(i)/numverts, "Reading Verts")
|
||
data.read(10)
|
||
x, y, z = struct.unpack(">ddd", data.read(24)) # double precision
|
||
verts.append((x, -z, y))
|
||
data.read(1) # 6A
|
||
data.read(1) # 6A
|
||
return verts
|
||
|
||
# =======================
|
||
# === Make Face Table ===
|
||
# =======================
|
||
def make_face_table(edge_table): # For Wings
|
||
face_table = {}
|
||
for i in range(len(edge_table)):
|
||
Lf = edge_table[i][2]
|
||
Rf = edge_table[i][3]
|
||
if Lf >= 0:
|
||
face_table[Lf] = i
|
||
if Rf >= 0:
|
||
face_table[Rf] = i
|
||
return face_table
|
||
|
||
# =======================
|
||
# === Make Vert Table ===
|
||
# =======================
|
||
def make_vert_table(edge_table): # For Wings
|
||
vert_table = {}
|
||
for i in range(len(edge_table)):
|
||
Sv = edge_table[i][0]
|
||
Ev = edge_table[i][1]
|
||
vert_table[Sv] = i
|
||
vert_table[Ev] = i
|
||
return vert_table
|
||
|
||
# ==================
|
||
# === Make Faces ===
|
||
# ==================
|
||
def make_faces(edge_table): # For Wings
|
||
face_table = make_face_table(edge_table)
|
||
faces=[]
|
||
for i in range(len(face_table)):
|
||
face_verts = []
|
||
current_edge = face_table[i]
|
||
while(1):
|
||
if i == edge_table[current_edge][3]:
|
||
next_edge = edge_table[current_edge][7] # Right successor edge
|
||
next_vert = edge_table[current_edge][0]
|
||
elif i == edge_table[current_edge][2]:
|
||
next_edge = edge_table[current_edge][5] # Left successor edge
|
||
next_vert = edge_table[current_edge][1]
|
||
else:
|
||
break
|
||
face_verts.append(next_vert)
|
||
current_edge = next_edge
|
||
if current_edge == face_table[i]: break
|
||
if len(face_verts) > 0:
|
||
face_verts.reverse()
|
||
faces.append(face_verts)
|
||
return faces
|
||
|
||
# =======================
|
||
# === Dump Wings File ===
|
||
# =======================
|
||
def dump_wings(filename):
|
||
import pprint
|
||
start = time.clock()
|
||
file = open(filename, "rb")
|
||
header = file.read(15)
|
||
fsize, = struct.unpack(">L", file.read(4)) # file_size - 19
|
||
misc, = struct.unpack(">H", file.read(2))
|
||
dsize, = struct.unpack(">L", file.read(4)) # uncompressed data size
|
||
data = file.read(fsize-6)
|
||
file.close()
|
||
data = zlib.decompress(data)
|
||
if dsize != len(data): print "ERROR: uncompressed size does not match."
|
||
data = cStringIO.StringIO(data)
|
||
print "header:", header
|
||
print read_chunkheader(data) # === wings chunk ===
|
||
data.read(4) # misc bytes
|
||
misc, numobjs, = struct.unpack(">BL", data.read(5))
|
||
print "filename:", filename
|
||
print "numobjs :", numobjs
|
||
for obj in range(numobjs):
|
||
print read_chunkheader(data) # === object chunk ===
|
||
misc, namelen = struct.unpack(">BH", data.read(3))
|
||
objname = data.read(namelen)
|
||
print read_chunkheader(data) # === winged chunk ===
|
||
edge_table = read_edges(data)
|
||
mat_table = read_faces(data)
|
||
numfaces = len(mat_table)
|
||
verts = read_verts(data)
|
||
hardedge_table = read_hardedges(data)
|
||
|
||
face_table = {} # contains an incident edge
|
||
vert_table = {} # contains an incident edge
|
||
for i in range(len(edge_table)):
|
||
face_table[edge_table[i][2]] = i # generate face_table
|
||
face_table[edge_table[i][3]] = i
|
||
vert_table[edge_table[i][0]] = i # generate vert_table
|
||
vert_table[edge_table[i][1]] = i
|
||
|
||
print "objname :", objname
|
||
print "numedges:", len(edge_table)
|
||
print "numfaces:", numfaces
|
||
print "numverts:", len(verts)
|
||
print
|
||
print "<EFBFBD>"*79
|
||
print "edge_table:"
|
||
#pprint.pprint(edge_table)
|
||
#for i in range(len(edge_table)): print "%2d" % (i), edge_table[i]
|
||
print
|
||
print "face_table:"
|
||
#pprint.pprint(face_table)
|
||
#for i in range(len(face_table)): print "%2d %2d" % (i, face_table[i])
|
||
print
|
||
print "vert_table:"
|
||
#pprint.pprint(vert_table)
|
||
#for i in range(len(vert_table)): print "%2d %2d" % (i, vert_table[i])
|
||
file.close()
|
||
end = time.clock()
|
||
print '\a\r',
|
||
sys.stderr.write("\nDone in %.2f %s\a\r" % (end-start, "seconds"))
|
||
|
||
# =========================
|
||
# === Read Wings Format ===
|
||
# =========================
|
||
def read(filename):
|
||
|
||
start = time.clock()
|
||
file = open(filename, "rb")
|
||
header = file.read(15)
|
||
fsize, = struct.unpack(">L", file.read(4)) # file_size - 19
|
||
misc, = struct.unpack(">H", file.read(2))
|
||
dsize, = struct.unpack(">L", file.read(4)) # uncompressed data size
|
||
data = file.read(fsize-6)
|
||
#print file.tell(), "bytes"
|
||
file.close()
|
||
Blender.Window.DrawProgressBar(1.0, "Decompressing Data")
|
||
data = zlib.decompress(data)
|
||
data = cStringIO.StringIO(data)
|
||
read_chunkheader(data) # wings chunk
|
||
data.read(4) # misc bytes
|
||
misc, numobjs = struct.unpack(">BL", data.read(5))
|
||
message = "Successfully imported " + os.path.basename(filename) + '\n\n'
|
||
message += "%s %8s %8s %8s\n" % ("Object".ljust(15), "faces", "edges", "verts")
|
||
message += "%s %8s %8s %8s\n" % ("<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>".ljust(15), "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>", "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>")
|
||
|
||
for obj in range(numobjs):
|
||
read_chunkheader(data) # object chunk
|
||
misc, namelen = struct.unpack(">BH", data.read(3))
|
||
objname = data.read(namelen)
|
||
read_chunkheader(data) # winged chunk
|
||
edge_table = read_edges(data)
|
||
mat_table = read_faces(data)
|
||
numfaces = len(mat_table)
|
||
verts = read_verts(data)
|
||
hardedge_table = read_hardedges(data)
|
||
|
||
# Manually split hard edges
|
||
# TODO: Handle the case where there are 2+ edges on a face
|
||
duped = {}
|
||
processed = []
|
||
cleanup = []
|
||
oldedgecount = len(edge_table)
|
||
for i in range(len(verts)):
|
||
duped[i] = -1
|
||
for j in range(len(hardedge_table)):
|
||
hardedge = hardedge_table[j]
|
||
oldedge = edge_table[hardedge]
|
||
newedge = [] # Copy old edge into a new list
|
||
for k in range(len(oldedge)):
|
||
newedge.append(oldedge[k])
|
||
|
||
# Duplicate start vert if not duped already
|
||
sv = newedge[0]
|
||
if duped[sv] == -1:
|
||
verts.append(verts[sv])
|
||
duped[sv] = len(verts)-1
|
||
newedge[0] = duped[sv]
|
||
|
||
# Duplicate end vert if not duped already
|
||
ev = newedge[1]
|
||
if duped[ev] == -1:
|
||
verts.append(verts[ev])
|
||
duped[ev] = len(verts)-1
|
||
newedge[1] = duped[ev]
|
||
|
||
# Decide which way to cut the edge
|
||
flip = 0
|
||
for v in range(len(processed)):
|
||
if processed[v][0] == oldedge[0]:
|
||
flip = 1
|
||
elif processed[v][1] == oldedge[1]:
|
||
flip = 1
|
||
if flip == 0:
|
||
of = 3
|
||
oe1 = 6
|
||
oe2 = 7
|
||
nf = 2
|
||
ne1 = 4
|
||
ne2 = 5
|
||
else:
|
||
of = 2
|
||
oe1 = 4
|
||
oe2 = 5
|
||
nf = 3
|
||
ne1 = 6
|
||
ne2 = 7
|
||
|
||
# Fix up side-specific edge fields
|
||
oldedge[of] = -1
|
||
oldedge[oe1] = -1
|
||
oldedge[oe2] = -1
|
||
newedge[nf] = -1
|
||
newedge[ne1] = -1
|
||
newedge[ne2] = -1
|
||
|
||
# Store new edge's neighbors for cleanup later
|
||
cleanup.append(edge_table[newedge[oe1]])
|
||
cleanup.append(edge_table[newedge[oe2]])
|
||
|
||
#DEBUG
|
||
# Sv Ev | Lf Rf | Lp Ls | Rp Rs
|
||
#print "Old Edge:",hardedge,oldedge
|
||
#print "New Edge:",len(edge_table),newedge
|
||
|
||
# Add this new edge to the edge table
|
||
edge_table[len(edge_table)] = newedge
|
||
if flip == 0:
|
||
processed.append(oldedge) # mark it off as processed
|
||
|
||
# Cycle through cleanup list and fix it up
|
||
for c in range(len(cleanup)):
|
||
cleanupedge = cleanup[c]
|
||
|
||
# Fix up their verts in case they were duped
|
||
sv = cleanupedge[0]
|
||
if sv < len(duped):
|
||
if duped[sv] >= 0:
|
||
cleanupedge[0] = duped[sv]
|
||
ev = cleanupedge[1]
|
||
if ev < len(duped):
|
||
if duped[ev] >= 0:
|
||
cleanupedge[1] = duped[ev]
|
||
|
||
# Fix up edge info (in case a hard edge was replaced with a new one)
|
||
edgecount = c/2
|
||
hardedge = hardedge_table[edgecount] # look up what edge we were replacing
|
||
newedgenum = oldedgecount+edgecount # calculate new edge's index
|
||
if cleanupedge[4] == hardedge:
|
||
cleanupedge[4] = newedgenum
|
||
if cleanupedge[5] == hardedge:
|
||
cleanupedge[5] = newedgenum
|
||
if cleanupedge[6] == hardedge:
|
||
cleanupedge[6] = newedgenum
|
||
if cleanupedge[7] == hardedge:
|
||
cleanupedge[7] = newedgenum
|
||
|
||
#for i in range(len(edge_table)): print "%2d" % (i), edge_table[i]
|
||
|
||
read_mode(data)
|
||
faces = make_faces(edge_table)
|
||
message += "%s %8s %8s %8s\n" % (objname.ljust(15), len(faces), len(edge_table), len(verts))
|
||
meshtools.create_mesh(verts, faces, objname)
|
||
|
||
material = data.read()
|
||
#for i in material[0:6]: print "%02X" % ord(i),
|
||
#print
|
||
Blender.Window.DrawProgressBar(1.0, "Done") # clear progressbar
|
||
data.close()
|
||
end = time.clock()
|
||
seconds = "\nDone in %.2f %s" % (end-start, "seconds")
|
||
message += seconds
|
||
meshtools.print_boxed(message)
|
||
|
||
def fs_callback(filename):
|
||
read(filename)
|
||
|
||
Blender.Window.FileSelector(fs_callback, "Import Wings3D")
|