← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to release/scripts/wings_import.py

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2005-11-06 12:40:03 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051106124003-3pgs7tcg5rox96xg
Tags: 2.37a-1.1
http://bugs.debian.org/333958
* Non-maintainer upload.
* Split out parts of 01_SConstruct_debian.dpatch again: root_build_dir
  really needs to get adjusted before the clean target runs - closes: #333958,
  see #288882 for reference

Show diffs side-by-side

added added

removed removed

Lines of Context:
release/scripts/wings_import.py
 
1
#!BPY
 
2
 
 
3
"""
 
4
Name: 'Wings3D (.wings)...'
 
5
Blender: 232
 
6
Group: 'Import'
 
7
Tooltip: 'Import Wings3D File Format (.wings)'
 
8
"""
 
9
 
 
10
__author__ = "Anthony D'Agostino (Scorpius)"
 
11
__url__ = ("blender", "elysiun",
 
12
"Author's homepage, http://www.redrival.com/scorpius",
 
13
"Wings 3D, http://www.wings3d.com")
 
14
__version__ = "Part of IOSuite 0.5"
 
15
 
 
16
__bpydoc__ = """\
 
17
This script imports Wings3D files to Blender.
 
18
 
 
19
Wings3D is an open source polygon modeler written in Erlang, a
 
20
language similar to Lisp. The .wings file format is a binary
 
21
representation of erlang terms (lists, tuples, atoms, etc.) and is
 
22
compressed with zlib.
 
23
 
 
24
Usage:<br>
 
25
  Execute this script from the "File->Import" menu and choose a Wings file
 
26
to open.
 
27
 
 
28
Supported:<br>
 
29
        Meshes only. Not guaranteed to work in all situations.
 
30
 
 
31
Missing:<br>
 
32
  Materials, UV Coordinates, and Vertex Color info will be ignored.
 
33
 
 
34
Known issues:<br>
 
35
        Triangulation of convex polygons works fine, and uses a very simple
 
36
fanning algorithm. Convex polygons (i.e., shaped like the letter "U")
 
37
require a different algorithm, and will be triagulated incorrectly.
 
38
 
 
39
Notes:<br>
 
40
        Last tested with Wings 3D 0.98.25 & Blender 2.35a.
 
41
"""
 
42
 
 
43
# $Id: wings_import.py,v 1.6 2005/03/21 05:26:52 ianwill Exp $
 
44
#
 
45
# +---------------------------------------------------------+
 
46
# | Copyright (c) 2002 Anthony D'Agostino                   |
 
47
# | http://www.redrival.com/scorpius                        |
 
48
# | scorpius@netzero.com                                    |
 
49
# | Feb 19, 2002                                            |
 
50
# | Released under the Blender Artistic Licence (BAL)       |
 
51
# | Import Export Suite v0.5                                |
 
52
# +---------------------------------------------------------+
 
53
# | Read and write Wings3D File Format (*.wings)            |
 
54
# +---------------------------------------------------------+
 
55
 
 
56
import Blender, meshtools
 
57
import struct, time, sys, os, zlib, cStringIO
 
58
 
 
59
# ==============================================
 
60
# === Read The 'Header' Common To All Chunks ===
 
61
# ==============================================
 
62
def read_chunkheader(data):
 
63
        data.read(2) #version, tag = struct.unpack(">BB", data.read(2))
 
64
        misc, namelen = struct.unpack(">BH", data.read(3))
 
65
        name = data.read(namelen)
 
66
        return name
 
67
 
 
68
# ==============================
 
69
# === Read The Material Mode ===
 
70
# ==============================
 
71
def read_mode(data):
 
72
        data.read(5)                    # BL
 
73
        read_chunkheader(data)  # "mode"
 
74
        misc, namelen = struct.unpack(">BH", data.read(3))
 
75
        data.read(namelen)
 
76
        data.read(1)                    # 6A
 
77
 
 
78
# =======================
 
79
# === Read Hard Edges ===
 
80
# =======================
 
81
def read_hardedges(data):
 
82
        tag = data.read(1)
 
83
        if tag == '\x6A':
 
84
                return # There are no hard edges
 
85
        elif tag == '\x6B':
 
86
                numhardedges, = struct.unpack(">H", data.read(2))
 
87
                print "numhardedges:", numhardedges
 
88
                for i in range(numhardedges):
 
89
                        data.read(1)
 
90
        elif tag == '\x6C':
 
91
                numhardedges, = struct.unpack(">L", data.read(4))
 
92
                print "numhardedges:", numhardedges
 
93
                for i in range(numhardedges):
 
94
                        misc = data.read(1)
 
95
                        if misc == '\x61':    # next value is stored as a byte
 
96
                                data.read(1)
 
97
                        elif misc == '\x62':  # next value is stored as a long
 
98
                                data.read(4)
 
99
                data.read(1) # 6A
 
100
        else:
 
101
                print tag
 
102
 
 
103
# ==================
 
104
# === Read Edges ===
 
105
# ==================
 
106
def read_edges(data):
 
107
        misc, numedges = struct.unpack(">BL", data.read(5))
 
108
        edge_table = {}  # the winged-edge table
 
109
        for i in range(numedges):
 
110
                if not i%100 and meshtools.show_progress: Blender.Window.DrawProgressBar(float(i)/numedges, "Reading Edges")
 
111
                misc, etype = struct.unpack(">BL", data.read(5))
 
112
                if etype == 2:                          # Vertex Colors
 
113
                        data.read(10)                   # or read_chunkheader(data)  # "color"
 
114
                        data.read(5)                    # BL
 
115
                        r1,g1,b1,r2,g2,b2 = struct.unpack(">dddddd", data.read(48))
 
116
                        #print "%3d %3d %3d | %3d %3d %3d" % (r1*255,g1*255,b1*255,r2*255,g2*255,b2*255),
 
117
                        #print "%f %f %f | %f %f %f" % (r1, g1, b1, r2, g2, b2)
 
118
                data.read(9) # or read_chunkheader(data)  # "edge"
 
119
                edge = []                       # the eight entries for this edge
 
120
                for e in range(8):      # Sv Ev | Lf Rf | Lp Ls | Rp Rs
 
121
                        misc = data.read(1)
 
122
                        if misc == '\x61':    # next value is stored as a byte
 
123
                                entry, = struct.unpack(">B", data.read(1))
 
124
                                edge.append(entry)
 
125
                        elif misc == '\x62':  # next value is stored as a long
 
126
                                entry, = struct.unpack(">L", data.read(4))
 
127
                                edge.append(entry)
 
128
                edge_table[i] = edge
 
129
                data.read(1) # 6A
 
130
        data.read(1) # 6A
 
131
        return edge_table
 
132
 
 
133
# ==================
 
134
# === Read Faces ===
 
135
# ==================
 
136
def read_faces(data):
 
137
        misc, numfaces = struct.unpack(">BL", data.read(5))
 
138
        for i in range(numfaces):
 
139
                if not i%100 and meshtools.show_progress: Blender.Window.DrawProgressBar(float(i)/numfaces, "Reading Faces")
 
140
                if data.read(1) == '\x6C':  # a material follows
 
141
                        data.read(4)
 
142
                        read_chunkheader(data)
 
143
                        misc, namelen = struct.unpack(">BH", data.read(3))
 
144
                        materialname = data.read(namelen)
 
145
                        data.read(1)
 
146
        data.read(1) # 6A
 
147
        return numfaces
 
148
 
 
149
# ==================
 
150
# === Read Verts ===
 
151
# ==================
 
152
def read_verts(data):
 
153
        misc, numverts = struct.unpack(">BL", data.read(5))
 
154
        verts = []      # a list of verts
 
155
        for i in range(numverts):
 
156
                if not i%100 and meshtools.show_progress: Blender.Window.DrawProgressBar(float(i)/numverts, "Reading Verts")
 
157
                data.read(10)
 
158
                x, y, z = struct.unpack(">ddd", data.read(24))  # double precision
 
159
                verts.append((x, -z, y))
 
160
                data.read(1) # 6A
 
161
        data.read(1) # 6A
 
162
        return verts
 
163
 
 
164
# =======================
 
165
# === Make Face Table ===
 
166
# =======================
 
167
def make_face_table(edge_table): # For Wings
 
168
        face_table = {}
 
169
        for i in range(len(edge_table)):
 
170
                Lf = edge_table[i][2]
 
171
                Rf = edge_table[i][3]
 
172
                face_table[Lf] = i
 
173
                face_table[Rf] = i
 
174
        return face_table
 
175
 
 
176
# =======================
 
177
# === Make Vert Table ===
 
178
# =======================
 
179
def make_vert_table(edge_table): # For Wings
 
180
        vert_table = {}
 
181
        for i in range(len(edge_table)):
 
182
                Sv = edge_table[i][0]
 
183
                Ev = edge_table[i][1]
 
184
                vert_table[Sv] = i
 
185
                vert_table[Ev] = i
 
186
        return vert_table
 
187
 
 
188
# ==================
 
189
# === Make Faces ===
 
190
# ==================
 
191
def make_faces(edge_table): # For Wings
 
192
        face_table = make_face_table(edge_table)
 
193
        faces=[]
 
194
        for i in range(len(face_table)):
 
195
                face_verts = []
 
196
                current_edge = face_table[i]
 
197
                while(1):
 
198
                        if i == edge_table[current_edge][3]:
 
199
                                next_edge = edge_table[current_edge][7] # Right successor edge
 
200
                                next_vert = edge_table[current_edge][0]
 
201
                        else:
 
202
                                next_edge = edge_table[current_edge][5] # Left successor edge
 
203
                                next_vert = edge_table[current_edge][1]
 
204
                        face_verts.append(next_vert)
 
205
                        current_edge = next_edge
 
206
                        if current_edge == face_table[i]: break
 
207
                face_verts.reverse()
 
208
                faces.append(face_verts)
 
209
        return faces
 
210
 
 
211
# =======================
 
212
# === Dump Wings File ===
 
213
# =======================
 
214
def dump_wings(filename):
 
215
        import pprint
 
216
        start = time.clock()
 
217
        file = open(filename, "rb")
 
218
        header = file.read(15)
 
219
        fsize, = struct.unpack(">L",  file.read(4))   # file_size - 19
 
220
        misc,  = struct.unpack(">H",  file.read(2))
 
221
        dsize, = struct.unpack(">L",  file.read(4))   # uncompressed data size
 
222
        data   = file.read(fsize-6)
 
223
        file.close()
 
224
        data = zlib.decompress(data)
 
225
        if dsize != len(data): print "ERROR: uncompressed size does not match."
 
226
        data = cStringIO.StringIO(data)
 
227
        print "header:", header
 
228
        print read_chunkheader(data)  # === wings chunk ===
 
229
        data.read(4) # misc bytes
 
230
        misc, numobjs, = struct.unpack(">BL", data.read(5))
 
231
        print "filename:", filename
 
232
        print "numobjs :", numobjs
 
233
        for obj in range(numobjs):
 
234
                print read_chunkheader(data) # === object chunk ===
 
235
                misc, namelen = struct.unpack(">BH", data.read(3))
 
236
                objname = data.read(namelen)
 
237
                print read_chunkheader(data) # === winged chunk ===
 
238
                edge_table = read_edges(data)
 
239
                numfaces = read_faces(data)
 
240
                verts = read_verts(data)
 
241
                read_hardedges(data)
 
242
 
 
243
                face_table = {}  # contains an incident edge
 
244
                vert_table = {}  # contains an incident edge
 
245
                for i in range(len(edge_table)):
 
246
                        face_table[edge_table[i][2]] = i  # generate face_table
 
247
                        face_table[edge_table[i][3]] = i
 
248
                        vert_table[edge_table[i][0]] = i  # generate vert_table
 
249
                        vert_table[edge_table[i][1]] = i
 
250
 
 
251
                print "objname :", objname
 
252
                print "numedges:", len(edge_table)
 
253
                print "numfaces:", numfaces
 
254
                print "numverts:", len(verts)
 
255
                print
 
256
                print "�"*79
 
257
                print "edge_table:"
 
258
                pprint.pprint(edge_table)
 
259
                #for i in range(len(edge_table)): print "%2d" % (i), edge_table[i]
 
260
                print
 
261
                print "face_table:"
 
262
                pprint.pprint(face_table)
 
263
                #for i in range(len(face_table)): print "%2d %2d" % (i, face_table[i])
 
264
                print
 
265
                print "vert_table:"
 
266
                pprint.pprint(vert_table)
 
267
                #for i in range(len(vert_table)): print "%2d %2d" % (i, vert_table[i])
 
268
        file.close()
 
269
        end = time.clock()
 
270
        print '\a\r',
 
271
        sys.stderr.write("\nDone in %.2f %s" % (end-start, "seconds"))
 
272
 
 
273
# =========================
 
274
# === Read Wings Format ===
 
275
# =========================
 
276
def read(filename):
 
277
        start = time.clock()
 
278
        file = open(filename, "rb")
 
279
        header = file.read(15)
 
280
        fsize, = struct.unpack(">L",  file.read(4))   # file_size - 19
 
281
        misc,  = struct.unpack(">H",  file.read(2))
 
282
        dsize, = struct.unpack(">L",  file.read(4))   # uncompressed data size
 
283
        data   = file.read(fsize-6)
 
284
        #print file.tell(), "bytes"
 
285
        file.close()
 
286
        Blender.Window.DrawProgressBar(1.0, "Decompressing Data")
 
287
        data = zlib.decompress(data)
 
288
        data = cStringIO.StringIO(data)
 
289
        read_chunkheader(data) # wings chunk
 
290
        data.read(4)               # misc bytes
 
291
        misc, numobjs = struct.unpack(">BL", data.read(5))
 
292
        message = "Successfully imported " + os.path.basename(filename) + '\n\n'
 
293
        message += "%s %8s %8s %8s\n" % ("Object".ljust(15), "faces", "edges", "verts")
 
294
        message += "%s %8s %8s %8s\n" % ("������".ljust(15), "�����", "�����", "�����")
 
295
 
 
296
        for obj in range(numobjs):
 
297
                read_chunkheader(data) # object chunk
 
298
                misc, namelen = struct.unpack(">BH", data.read(3))
 
299
                objname = data.read(namelen)
 
300
                read_chunkheader(data) # winged chunk
 
301
                edge_table = read_edges(data)
 
302
                numfaces = read_faces(data)
 
303
                verts = read_verts(data)
 
304
                read_hardedges(data)
 
305
                read_mode(data)
 
306
                faces = make_faces(edge_table)
 
307
                message += "%s %8s %8s %8s\n" % (objname.ljust(15), len(faces), len(edge_table), len(verts))
 
308
                meshtools.create_mesh(verts, faces, objname)
 
309
 
 
310
        material = data.read()
 
311
        #for i in material[0:6]: print "%02X" % ord(i),
 
312
        #print
 
313
        Blender.Window.DrawProgressBar(1.0, "Done")    # clear progressbar
 
314
        data.close()
 
315
        end = time.clock()
 
316
        seconds = "\nDone in %.2f %s" % (end-start, "seconds")
 
317
        message += seconds
 
318
        meshtools.print_boxed(message)
 
319
 
 
320
def fs_callback(filename):
 
321
        read(filename)
 
322
 
 
323
Blender.Window.FileSelector(fs_callback, "Import Wings3D")