Removed wings support, both apps are free and have good obj support. wings import was not maintainded and would not load some files.

2 files changed, 0 insertions, 827 deletions

diff --git a/release/scripts/wings_export.py b/release/scripts/wings_export.py
deleted file mode 100644
index 8477f9e076a..00000000000
--- a/release/scripts/wings_export.py
+++ /dev/null
@@ -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")
diff --git a/release/scripts/wings_import.py b/release/scripts/wings_import.py
deleted file mode 100644
index 8bba6f52de7..00000000000
--- a/release/scripts/wings_import.py
+++ /dev/null
@@ -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")