forked from bartvdbraak/blender
Removed wings support, both apps are free and have good obj support. wings import was not maintainded and would not load some files.
This commit is contained in:
parent
ce202f7540
commit
8466ba9a3a
@ -1,375 +0,0 @@
|
||||
#!BPY
|
||||
|
||||
"""
|
||||
Name: 'Wings3D (.wings)...'
|
||||
Blender: 232
|
||||
Group: 'Export'
|
||||
Tooltip: 'Export selected mesh to 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__ = "Part of IOSuite 0.5"
|
||||
|
||||
__bpydoc__ = """\
|
||||
This script exports meshes to Wings3D file format.
|
||||
|
||||
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>
|
||||
Select meshes to be exported and run this script from "File->Export" menu.
|
||||
|
||||
Supported:<br>
|
||||
1. Exports meshes only. Hint: use ALT-C to convert non-mesh objects,
|
||||
and CTRL-ALT-A if you have "dupliverts" objects.<br>
|
||||
2. Exports Vertex Colors & Radiosity Solutions.
|
||||
|
||||
Missing:<br>
|
||||
Materials and UV Coordinates info will be ignored.
|
||||
|
||||
Known issues:<br>
|
||||
Exports only well-behaved and topologically correct meshes (i.e,
|
||||
closed meshes, manifolds, meshes imported from wings, etc). The mesh
|
||||
cannot have duplicate vertices, missing faces (holes), open edges, etc.<br>
|
||||
PowerUser Hint: In editmode, if CTRL-ALT-SHIFT-M results in a selection,
|
||||
then your mesh is not a manifold and most likely will not export.
|
||||
|
||||
Notes:<br>
|
||||
Last tested with Wings 3D 0.98.25 & Blender 2.35a.
|
||||
"""
|
||||
|
||||
# $Id$
|
||||
#
|
||||
# +---------------------------------------------------------+
|
||||
# | Copyright (c) 2002 Anthony D'Agostino |
|
||||
# | http://www.redrival.com/scorpius |
|
||||
# | scorpius@netzero.com |
|
||||
# | Feb 19, 2002 |
|
||||
# | Read and write Wings3D File Format (*.wings) |
|
||||
# +---------------------------------------------------------+
|
||||
|
||||
# ***** 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
|
||||
|
||||
# ===============================================
|
||||
# === Write The 'Header' Common To All Chunks ===
|
||||
# ===============================================
|
||||
def write_chunkheader(data, version, tag, name):
|
||||
data.write(struct.pack(">BB", version, tag))
|
||||
data.write(struct.pack(">BH", 0x64, len(name)))
|
||||
data.write(name)
|
||||
|
||||
# ===================
|
||||
# === Write Faces ===
|
||||
# ===================
|
||||
def write_faces(data, mesh):
|
||||
numfaces = len(mesh.faces)
|
||||
data.write(struct.pack(">BL", 0x6C, numfaces))
|
||||
#for i in range(numfaces):
|
||||
# if not i%100 and meshtools.show_progress: Blender.Window.DrawProgressBar(float(i)/numfaces, "Writing Faces")
|
||||
# data.write("\x6A")
|
||||
data.write("\x6A" * numfaces) # same, but faster than the above loop
|
||||
data.write("\x6A")
|
||||
|
||||
# ===================
|
||||
# === Write Verts ===
|
||||
# ===================
|
||||
def write_verts(data, mesh):
|
||||
numverts = len(mesh.verts)
|
||||
data.write(struct.pack(">BL", 0x6C, numverts))
|
||||
for i in range(numverts):
|
||||
if not i%100 and meshtools.show_progress: Blender.Window.DrawProgressBar(float(i)/numverts, "Writing Verts")
|
||||
data.write(struct.pack(">BLBL", 0x6C, 1, 0x6D, 24))
|
||||
#data.write("\x6c\x00\x00\x00\x01\x6D\x00\x00\x00\x30")
|
||||
x, y, z = mesh.verts[i].co
|
||||
data.write(struct.pack(">ddd", x, z, -y))
|
||||
data.write("\x6A")
|
||||
data.write("\x6A")
|
||||
|
||||
# ===================
|
||||
# === Write Edges ===
|
||||
# ===================
|
||||
def write_edges(data, mesh, edge_table):
|
||||
numedges = len(edge_table)
|
||||
data.write(struct.pack(">BL", 0x6C, numedges))
|
||||
keys = edge_table.keys()
|
||||
keys.sort()
|
||||
for key in keys:
|
||||
i = edge_table[key][6]
|
||||
if not i%100 and meshtools.show_progress: Blender.Window.DrawProgressBar(float(i)/numedges, "Writing Edges")
|
||||
|
||||
if meshtools.has_vertex_colors(mesh):
|
||||
r1, g1, b1 = edge_table[key][7]
|
||||
r2, g2, b2 = edge_table[key][8]
|
||||
data.write("\x6C\x00\x00\x00\x02")
|
||||
data.write("\x68\x02\x64\x00\x05color")
|
||||
data.write("\x6D\x00\x00\x00\x30")
|
||||
data.write(struct.pack(">dddddd", r1, g1, b1, r2, g2, b2))
|
||||
#print "%f %f %f - %f %f %f" % (r1, g1, b1, r2, g2, b2)
|
||||
else:
|
||||
data.write("\x6C\x00\x00\x00\x01") # BL
|
||||
|
||||
#$write_chunkheader(data, 0x68, 0x09, "edge")
|
||||
data.write("\x68\x09\x64\x00\x04edge") # faster
|
||||
|
||||
# Sv Ev (Reversed)
|
||||
data.write(struct.pack(">BLBL", 0x62, key[1], 0x62, key[0]))
|
||||
|
||||
# Lf Rf LP LS RP RS
|
||||
for i in range(6):
|
||||
if edge_table[key][i] < 256:
|
||||
data.write(struct.pack(">BB", 0x61, edge_table[key][i]))
|
||||
else:
|
||||
data.write(struct.pack(">BL", 0x62, edge_table[key][i]))
|
||||
|
||||
data.write("\x6A")
|
||||
|
||||
data.write("\x6A")
|
||||
|
||||
# ===============================
|
||||
# === Write The Material Mode ===
|
||||
# ===============================
|
||||
def write_mode(data, mesh):
|
||||
data.write("\x6A")
|
||||
data.write(struct.pack(">BL", 0x6C, 1))
|
||||
write_chunkheader(data, 0x68, 0x02, "mode")
|
||||
if meshtools.has_vertex_colors(mesh):
|
||||
data.write(struct.pack(">BH6s", 0x64, 6, "vertex"))
|
||||
else:
|
||||
data.write(struct.pack(">BH8s", 0x64, 8, "material"))
|
||||
data.write("\x6A")
|
||||
|
||||
# ======================
|
||||
# === Write Material ===
|
||||
# ======================
|
||||
def write_material(data, mesh):
|
||||
data.write("\x6A")
|
||||
data.write(struct.pack(">BL", 0x6C, 1))
|
||||
write_chunkheader(data, 0x68, 0x02, "my default")
|
||||
|
||||
data.write(struct.pack(">BL", 0x6C, 2))
|
||||
write_chunkheader(data, 0x68, 0x02, "maps")
|
||||
data.write("\x6A")
|
||||
write_chunkheader(data, 0x68, 0x02, "opengl")
|
||||
|
||||
# === The Material Components ===
|
||||
data.write(struct.pack(">BL", 0x6C, 5))
|
||||
|
||||
write_chunkheader(data, 0x68, 0x02, "diffuse")
|
||||
data.write("\x68\x04")
|
||||
data.write("\x63"+"1.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
data.write("\x63"+"1.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
data.write("\x63"+"1.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
data.write("\x63"+"1.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
|
||||
write_chunkheader(data, 0x68, 0x02, "ambient")
|
||||
data.write("\x68\x04")
|
||||
data.write("\x63"+"1.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
data.write("\x63"+"1.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
data.write("\x63"+"1.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
data.write("\x63"+"1.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
|
||||
write_chunkheader(data, 0x68, 0x02, "specular")
|
||||
data.write("\x68\x04")
|
||||
data.write("\x63"+"1.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
data.write("\x63"+"1.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
data.write("\x63"+"1.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
data.write("\x63"+"1.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
|
||||
write_chunkheader(data, 0x68, 0x02, "emission")
|
||||
data.write("\x68\x04")
|
||||
data.write("\x63"+"0.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
data.write("\x63"+"0.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
data.write("\x63"+"0.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
data.write("\x63"+"0.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
|
||||
write_chunkheader(data, 0x68, 0x02, "shininess")
|
||||
data.write("\x63"+"0.00000000000000000000"+"e+000"+"\x00"*4)
|
||||
|
||||
#write_chunkheader(data, 0x68, 0x02, "twosided")
|
||||
#data.write(struct.pack(">BH4s", 0x64, 4, "true"))
|
||||
|
||||
data.write("\x6A"*3) # use *4 if no ambient light
|
||||
|
||||
# =====================
|
||||
# === Generate Data ===
|
||||
# =====================
|
||||
def generate_data(objname, edge_table, mesh):
|
||||
data = cStringIO.StringIO()
|
||||
|
||||
# === wings chunk ===
|
||||
write_chunkheader(data, 0x68, 0x03, "wings")
|
||||
|
||||
numobjs = 1 # len(Blender.Object.GetSelected())
|
||||
data.write("\x61\x02\x68\x03") # misc bytes
|
||||
data.write(struct.pack(">BL", 0x6C, numobjs))
|
||||
|
||||
# === object chunk ===
|
||||
write_chunkheader(data, 0x68, 0x04, "object")
|
||||
data.write(struct.pack(">BH", 0x6B, len(objname)))
|
||||
data.write(objname)
|
||||
|
||||
# === winged chunk ===
|
||||
write_chunkheader(data, 0x68, 0x05, "winged")
|
||||
write_edges(data, mesh, edge_table)
|
||||
write_faces(data, mesh)
|
||||
write_verts(data, mesh)
|
||||
write_mode(data, mesh)
|
||||
write_material(data, mesh)
|
||||
write_ambient_light(data)
|
||||
return data.getvalue()
|
||||
|
||||
# ===========================
|
||||
# === Write Ambient Light ===
|
||||
# ===========================
|
||||
def write_ambient_light(data):
|
||||
light = [ # A quick cheat ;)
|
||||
0x6C, 0x00, 0x00, 0x00, 0x01, 0x68, 0x02, 0x64, 0x00, 0x06, 0x6C, 0x69,
|
||||
0x67, 0x68, 0x74, 0x73, 0x6C, 0x00, 0x00, 0x00, 0x01, 0x68, 0x02, 0x6B,
|
||||
0x00, 0x07, 0x41, 0x6D, 0x62, 0x69, 0x65, 0x6E, 0x74, 0x6C, 0x00, 0x00,
|
||||
0x00, 0x08, 0x68, 0x02, 0x64, 0x00, 0x07, 0x76, 0x69, 0x73, 0x69, 0x62,
|
||||
0x6C, 0x65, 0x64, 0x00, 0x04, 0x74, 0x72, 0x75, 0x65, 0x68, 0x02, 0x64,
|
||||
0x00, 0x06, 0x6C, 0x6F, 0x63, 0x6B, 0x65, 0x64, 0x64, 0x00, 0x05, 0x66,
|
||||
0x61, 0x6C, 0x73, 0x65, 0x68, 0x02, 0x64, 0x00, 0x06, 0x6F, 0x70, 0x65,
|
||||
0x6E, 0x67, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x03, 0x68, 0x02, 0x64, 0x00,
|
||||
0x04, 0x74, 0x79, 0x70, 0x65, 0x64, 0x00, 0x07, 0x61, 0x6D, 0x62, 0x69,
|
||||
0x65, 0x6E, 0x74, 0x68, 0x02, 0x64, 0x00, 0x07, 0x61, 0x6D, 0x62, 0x69,
|
||||
0x65, 0x6E, 0x74, 0x68, 0x04, 0x63, 0x31, 0x2E, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x65, 0x2B, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00,
|
||||
0x00, 0x63, 0x31, 0x2E, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x65, 0x2B, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x63, 0x31, 0x2E,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x2B, 0x30, 0x30,
|
||||
0x30, 0x00, 0x00, 0x00, 0x00, 0x63, 0x31, 0x2E, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x65, 0x2B, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00,
|
||||
0x00, 0x68, 0x02, 0x64, 0x00, 0x08, 0x70, 0x6F, 0x73, 0x69, 0x74, 0x69,
|
||||
0x6F, 0x6E, 0x68, 0x03, 0x63, 0x30, 0x2E, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x65, 0x2B, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00,
|
||||
0x63, 0x33, 0x2E, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65,
|
||||
0x2B, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x63, 0x30, 0x2E, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x2B, 0x30, 0x30, 0x30,
|
||||
0x00, 0x00, 0x00, 0x00, 0x6A, 0x68, 0x02, 0x64, 0x00, 0x07, 0x76, 0x69,
|
||||
0x73, 0x69, 0x62, 0x6C, 0x65, 0x64, 0x00, 0x04, 0x74, 0x72, 0x75, 0x65,
|
||||
0x68, 0x02, 0x64, 0x00, 0x06, 0x6C, 0x6F, 0x63, 0x6B, 0x65, 0x64, 0x64,
|
||||
0x00, 0x05, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x68, 0x02, 0x64, 0x00, 0x06,
|
||||
0x79, 0x61, 0x66, 0x72, 0x61, 0x79, 0x6C, 0x00, 0x00, 0x00, 0x0B, 0x68,
|
||||
0x02, 0x64, 0x00, 0x09, 0x6D, 0x69, 0x6E, 0x69, 0x6D, 0x69, 0x7A, 0x65,
|
||||
0x64, 0x64, 0x00, 0x04, 0x74, 0x72, 0x75, 0x65, 0x68, 0x02, 0x64, 0x00,
|
||||
0x05, 0x70, 0x6F, 0x77, 0x65, 0x72, 0x63, 0x31, 0x2E, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x2B, 0x30, 0x30, 0x30, 0x00, 0x00,
|
||||
0x00, 0x00, 0x68, 0x02, 0x64, 0x00, 0x04, 0x74, 0x79, 0x70, 0x65, 0x64,
|
||||
0x00, 0x09, 0x68, 0x65, 0x6D, 0x69, 0x6C, 0x69, 0x67, 0x68, 0x74, 0x68,
|
||||
0x02, 0x64, 0x00, 0x07, 0x73, 0x61, 0x6D, 0x70, 0x6C, 0x65, 0x73, 0x62,
|
||||
0x00, 0x00, 0x01, 0x00, 0x68, 0x02, 0x64, 0x00, 0x05, 0x64, 0x65, 0x70,
|
||||
0x74, 0x68, 0x61, 0x03, 0x68, 0x02, 0x64, 0x00, 0x0A, 0x62, 0x61, 0x63,
|
||||
0x6B, 0x67, 0x72, 0x6F, 0x75, 0x6E, 0x64, 0x64, 0x00, 0x09, 0x75, 0x6E,
|
||||
0x64, 0x65, 0x66, 0x69, 0x6E, 0x65, 0x64, 0x68, 0x02, 0x64, 0x00, 0x18,
|
||||
0x62, 0x61, 0x63, 0x6B, 0x67, 0x72, 0x6F, 0x75, 0x6E, 0x64, 0x5F, 0x66,
|
||||
0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D, 0x65, 0x5F, 0x48, 0x44, 0x52, 0x49,
|
||||
0x6A, 0x68, 0x02, 0x64, 0x00, 0x19, 0x62, 0x61, 0x63, 0x6B, 0x67, 0x72,
|
||||
0x6F, 0x75, 0x6E, 0x64, 0x5F, 0x66, 0x69, 0x6C, 0x65, 0x6E, 0x61, 0x6D,
|
||||
0x65, 0x5F, 0x69, 0x6D, 0x61, 0x67, 0x65, 0x6A, 0x68, 0x02, 0x64, 0x00,
|
||||
0x1A, 0x62, 0x61, 0x63, 0x6B, 0x67, 0x72, 0x6F, 0x75, 0x6E, 0x64, 0x5F,
|
||||
0x65, 0x78, 0x70, 0x6F, 0x73, 0x75, 0x72, 0x65, 0x5F, 0x61, 0x64, 0x6A,
|
||||
0x75, 0x73, 0x74, 0x61, 0x00, 0x68, 0x02, 0x64, 0x00, 0x12, 0x62, 0x61,
|
||||
0x63, 0x6B, 0x67, 0x72, 0x6F, 0x75, 0x6E, 0x64, 0x5F, 0x6D, 0x61, 0x70,
|
||||
0x70, 0x69, 0x6E, 0x67, 0x64, 0x00, 0x05, 0x70, 0x72, 0x6F, 0x62, 0x65,
|
||||
0x68, 0x02, 0x64, 0x00, 0x10, 0x62, 0x61, 0x63, 0x6B, 0x67, 0x72, 0x6F,
|
||||
0x75, 0x6E, 0x64, 0x5F, 0x70, 0x6F, 0x77, 0x65, 0x72, 0x63, 0x31, 0x2E,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
|
||||
0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x65, 0x2B, 0x30, 0x30,
|
||||
0x30, 0x00, 0x00, 0x00, 0x00, 0x6A, 0x68, 0x02, 0x64, 0x00, 0x07, 0x76,
|
||||
0x69, 0x73, 0x69, 0x62, 0x6C, 0x65, 0x64, 0x00, 0x04, 0x74, 0x72, 0x75,
|
||||
0x65, 0x68, 0x02, 0x64, 0x00, 0x06, 0x6C, 0x6F, 0x63, 0x6B, 0x65, 0x64,
|
||||
0x64, 0x00, 0x05, 0x66, 0x61, 0x6C, 0x73, 0x65, 0x6A, 0x6A, 0x6A]
|
||||
data.write("".join(map(chr, light)))
|
||||
|
||||
# ==========================
|
||||
# === Write Wings Format ===
|
||||
# ==========================
|
||||
def write(filename):
|
||||
start = time.clock()
|
||||
|
||||
objects = Blender.Object.GetSelected()
|
||||
|
||||
objname = objects[0].name
|
||||
meshname = objects[0].data.name
|
||||
mesh = Blender.NMesh.GetRaw(meshname)
|
||||
obj = Blender.Object.Get(objname)
|
||||
|
||||
try:
|
||||
edge_table = meshtools.generate_edgetable(mesh)
|
||||
except:
|
||||
edge_table = {}
|
||||
message = "Unable to generate\nEdge Table for mesh.\n"
|
||||
message += "Object name is: " + meshname
|
||||
meshtools.print_boxed(message)
|
||||
Blender.Draw.PupMenu("Wings Export error|Unable to generate Edge Table for mesh")
|
||||
return
|
||||
|
||||
data = generate_data(objname, edge_table, mesh)
|
||||
dsize = len(data)
|
||||
Blender.Window.DrawProgressBar(0.98, "Compressing Data")
|
||||
data = zlib.compress(data, 6)
|
||||
fsize = len(data)+6
|
||||
header = "#!WINGS-1.0\r\n\032\04"
|
||||
misc = 0x8350
|
||||
|
||||
file = open(filename, "wb")
|
||||
file.write(header)
|
||||
file.write(struct.pack(">L", fsize))
|
||||
file.write(struct.pack(">H", misc))
|
||||
file.write(struct.pack(">L", dsize))
|
||||
file.write(data)
|
||||
|
||||
# Blender.Window.RedrawAll()
|
||||
Blender.Window.DrawProgressBar(1.0, '') # clear progressbar
|
||||
file.close()
|
||||
end = time.clock()
|
||||
seconds = " in %.2f %s" % (end-start, "seconds")
|
||||
message = "Successfully exported " + os.path.basename(filename) + seconds + '\n\n'
|
||||
message += "objname : " + objname + '\n'
|
||||
message += "faces : " + `len(mesh.faces)` + '\n'
|
||||
message += "edges : " + `len(edge_table)` + '\n'
|
||||
message += "verts : " + `len(mesh.verts)` + '\n'
|
||||
meshtools.print_boxed(message)
|
||||
|
||||
def fs_callback(filename):
|
||||
if filename.find('.wings', -6) <= 0: filename += '.wings'
|
||||
write(filename)
|
||||
|
||||
|
||||
if Blender.Object.GetSelected()[0].getType() != "Mesh":
|
||||
Blender.Draw.PupMenu("Wings Export error|Selected object is not a mesh!")
|
||||
else:
|
||||
Blender.Window.FileSelector(fs_callback, "Export Wings3D")
|
@ -1,452 +0,0 @@
|
||||
#!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 "Ä"*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" % ("ÄÄÄÄÄÄ".ljust(15), "ÄÄÄÄÄ", "ÄÄÄÄÄ", "ÄÄÄÄÄ")
|
||||
|
||||
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")
|
Loading…
Reference in New Issue
Block a user