archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
642fea299b7ce108783d1075c6c1a3d94eab3f7d
blender-archive/release/scripts/ac3d_export.py

829 lines
24 KiB
Python
Raw Blame History

#!BPY
""" Registration info for Blender menus:
Name: 'AC3D (.ac)...'
Blender: 243
Group: 'Export'
Tip: 'Export selected meshes to AC3D (.ac) format'
"""
__author__ = "Willian P. Germano"
__url__ = ("blender", "blenderartists.org", "AC3D's homepage, http://www.ac3d.org",
"PLib 3d gaming lib, http://plib.sf.net")
__version__ = "2.44 2007-05-05"
__bpydoc__ = """\
This script exports selected Blender meshes to AC3D's .ac file format.
AC3D is a simple commercial 3d modeller also built with OpenGL.
The .ac file format is an easy to parse text format well supported,
for example, by the PLib 3d gaming library (AC3D 3.x).
Supported:<br>
UV-textured meshes with hierarchy (grouping) information.
Missing:<br>
The 'url' tag, specific to AC3D. It is easy to add by hand to the exported
file, if needed.
Known issues:<br>
The ambient and emit data we can retrieve from Blender are single values,
that this script copies to R, G, B, giving shades of gray.<br>
Loose edges (lines) receive the first material found in the mesh, if any, or a default white material.<br>
In AC3D 4 "compatibility mode":<br>
- shininess of materials is taken from the shader specularity value in Blender, mapped from [0.0, 2.0] to [0, 128];<br>
- crease angle is exported, but in Blender it is limited to [1, 80], since there are other more powerful ways to control surface smoothing. In AC3D 4.0 crease's range is [0.0, 180.0];
Config Options:<br>
toggle:<br>
- AC3D 4 mode: unset it to export without the 'crease' tag that was
introduced with AC3D 4.0 and with the old material handling;<br>
- global coords: transform all vertices of all meshes to global coordinates;<br>
- skip data: set it if you don't want mesh names (ME:, not OB: field)
to be exported as strings for AC's "data" tags (19 chars max);<br>
- rgb mirror color can be exported as ambient and/or emissive if needed,
since Blender handles these differently;<br>
- default mat: a default (white) material is added if some mesh was
left without mats -- it's better to always add your own materials;<br>
- no split: don't split meshes (see above);<br>
- set texture dir: override the actual textures path with a given default
path (or simply export the texture names, without dir info, if the path is
empty);<br>
- per face 1 or 2 sided: override the "Double Sided" button that defines this behavior per whole mesh in favor of the UV Face Select mode "twosided" per face atribute;<br>
- only selected: only consider selected objects when looking for meshes
to export (read notes below about tokens, too);<br>
strings:<br>
- export dir: default dir to export to;<br>
- texture dir: override textures path with this path if 'set texture dir'
toggle is "on".
Notes:<br>
This version updates:<br>
- modified meshes are correctly exported, no need to apply the modifiers in Blender;<br>
- correctly export each used material, be it assigned to the object or to its mesh data;<br>
- exporting lines (edges) is again supported; color comes from first material found in the mesh, if any, or a default white one.<br>
- there's a new option to choose between exporting meshes with transformed (global) coordinates or local ones;<br>
Multiple textures per mesh are supported (mesh gets split);<br>
Parents are exported as a group containing both the parent and its children;<br>
Start mesh object names (OB: field) with "!" or "#" if you don't want them to be exported;<br>
Start mesh object names (OB: field) with "=" or "$" to prevent them from being split (meshes with multiple textures or both textured and non textured faces are split unless this trick is used or the "no split" option is set.
"""
# $Id$
#
# --------------------------------------------------------------------------
# AC3DExport version 2.44
# Program versions: Blender 2.42+ and AC3Db files (means version 0xb)
# new: updated for new Blender version and Mesh module; supports lines (edges) again;
# option to export vertices transformed to global coordinates or not; now the modified
# (by existing mesh modifiers) mesh is exported; materials are properly exported, no
# matter if each of them is linked to the mesh or to the object. New (2.43.1): loose
# edges use color of first material found in the mesh, if any.
# --------------------------------------------------------------------------
# Thanks: Steve Baker for discussions and inspiration; for testing, bug
# reports, suggestions, patches: David Megginson, Filippo di Natale,
# Franz Melchior, Campbell Barton, Josh Babcock, Ralf Gerlich, Stewart Andreason.
# --------------------------------------------------------------------------
# ***** BEGIN GPL LICENSE BLOCK *****
#
# Copyright (C) 2004-2007: Willian P. Germano, wgermano _at_ ig.com.br
#
# 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,
# --------------------------------------------------------------------------
import Blender
from Blender import Object, Mesh, Material, Image, Mathutils, Registry
from Blender import sys as bsys
# Globals
REPORT_DATA = {
'main': [],
'errors': [],
'warns': [],
'nosplit': [],
'noexport': []
}
TOKENS_DONT_EXPORT = ['!', '#']
TOKENS_DONT_SPLIT = ['=', '$']
MATIDX_ERROR = 0
# flags:
LOOSE = Mesh.EdgeFlags['LOOSE']
FACE_TWOSIDED = Mesh.FaceModes['TWOSIDE']
MESH_TWOSIDED = Mesh.Modes['TWOSIDED']
REG_KEY = 'ac3d_export'
# config options:
GLOBAL_COORDS = True
SKIP_DATA = False
MIRCOL_AS_AMB = False
MIRCOL_AS_EMIS = False
ADD_DEFAULT_MAT = True
SET_TEX_DIR = True
TEX_DIR = ''
AC3D_4 = True # export crease value, compatible with AC3D 4 loaders
NO_SPLIT = False
ONLY_SELECTED = True
EXPORT_DIR = ''
PER_FACE_1_OR_2_SIDED = True
tooltips = {
'GLOBAL_COORDS': "transform all vertices of all meshes to global coordinates",
'SKIP_DATA': "don't export mesh names as data fields",
'MIRCOL_AS_AMB': "export mirror color as ambient color",
'MIRCOL_AS_EMIS': "export mirror color as emissive color",
'ADD_DEFAULT_MAT': "always add a default white material",
'SET_TEX_DIR': "don't export default texture paths (edit also \"tex dir\")",
'EXPORT_DIR': "default / last folder used to export .ac files to",
'TEX_DIR': "(see \"set tex dir\") dir to prepend to all exported texture names (leave empty for no dir)",
'AC3D_4': "compatibility mode, adds 'crease' tag and slightly better material support",
'NO_SPLIT': "don't split meshes with multiple textures (or both textured and non textured polygons)",
'ONLY_SELECTED': "export only selected objects",
'PER_FACE_1_OR_2_SIDED': "override \"Double Sided\" button in favor of per face \"twosided\" attribute (UV Face Select mode)"
}
def update_RegistryInfo():
d = {}
d['SKIP_DATA'] = SKIP_DATA
d['MIRCOL_AS_AMB'] = MIRCOL_AS_AMB
d['MIRCOL_AS_EMIS'] = MIRCOL_AS_EMIS
d['ADD_DEFAULT_MAT'] = ADD_DEFAULT_MAT
d['SET_TEX_DIR'] = SET_TEX_DIR
d['TEX_DIR'] = TEX_DIR
d['AC3D_4'] = AC3D_4
d['NO_SPLIT'] = NO_SPLIT
d['EXPORT_DIR'] = EXPORT_DIR
d['ONLY_SELECTED'] = ONLY_SELECTED
d['PER_FACE_1_OR_2_SIDED'] = PER_FACE_1_OR_2_SIDED
d['tooltips'] = tooltips
d['GLOBAL_COORDS'] = GLOBAL_COORDS
Registry.SetKey(REG_KEY, d, True)
# Looking for a saved key in Blender.Registry dict:
rd = Registry.GetKey(REG_KEY, True)
if rd:
try:
AC3D_4 = rd['AC3D_4']
SKIP_DATA = rd['SKIP_DATA']
MIRCOL_AS_AMB = rd['MIRCOL_AS_AMB']
MIRCOL_AS_EMIS = rd['MIRCOL_AS_EMIS']
ADD_DEFAULT_MAT = rd['ADD_DEFAULT_MAT']
SET_TEX_DIR = rd['SET_TEX_DIR']
TEX_DIR = rd['TEX_DIR']
EXPORT_DIR = rd['EXPORT_DIR']
ONLY_SELECTED = rd['ONLY_SELECTED']
NO_SPLIT = rd['NO_SPLIT']
PER_FACE_1_OR_2_SIDED = rd['PER_FACE_1_OR_2_SIDED']
GLOBAL_COORDS = rd['GLOBAL_COORDS']
except KeyError: update_RegistryInfo()
else:
update_RegistryInfo()
VERBOSE = True
CONFIRM_OVERWRITE = True
# check General scripts config key for default behaviors
rd = Registry.GetKey('General', True)
if rd:
try:
VERBOSE = rd['verbose']
CONFIRM_OVERWRITE = rd['confirm_overwrite']
except: pass
# The default material to be used when necessary (see ADD_DEFAULT_MAT)
DEFAULT_MAT = \
'MATERIAL "DefaultWhite" rgb 1 1 1 amb 1 1 1 emis 0 0 0 \
spec 0.5 0.5 0.5 shi 64 trans 0'
# This transformation aligns Blender and AC3D coordinate systems:
BLEND_TO_AC3D_MATRIX = Mathutils.Matrix([1,0,0,0], [0,0,-1,0], [0,1,0,0], [0,0,0,1])
def Round_s(f):
"Round to default precision and turn value to a string"
r = round(f,6) # precision set to 10e-06
if r == int(r):
return str(int(r))
else:
return str(r)
def transform_verts(verts, m):
vecs = []
for v in verts:
x, y, z = v.co
vec = Mathutils.Vector([x, y, z, 1])
vecs.append(vec*m)
return vecs
def get_loose_edges(mesh):
loose = LOOSE
return [e for e in mesh.edges if e.flag & loose]
# ---
# meshes with more than one texture assigned
# are split and saved as these foomeshes
class FooMesh:
class FooVert:
def __init__(self, v):
self.v = v
self.index = 0
class FooFace:
def __init__(self, foomesh, f):
self.f = f
foov = foomesh.FooVert
self.v = [foov(f.v[0]), foov(f.v[1])]
len_fv = len(f.v)
if len_fv > 2 and f.v[2]:
self.v.append(foov(f.v[2]))
if len_fv > 3 and f.v[3]: self.v.append(foov(f.v[3]))
def __getattr__(self, attr):
if attr == 'v': return self.v
return getattr(self.f, attr)
def __len__(self):
return len(self.f)
def __init__(self, tex, faces, mesh):
self.name = mesh.name
self.mesh = mesh
self.looseEdges = []
self.faceUV = mesh.faceUV
self.degr = mesh.degr
vidxs = [0]*len(mesh.verts)
foofaces = []
for f in faces:
foofaces.append(self.FooFace(self, f))
for v in f.v:
if v: vidxs[v.index] = 1
i = 0
fooverts = []
for v in mesh.verts:
if vidxs[v.index]:
fooverts.append(v)
vidxs[v.index] = i
i += 1
for f in foofaces:
for v in f.v:
if v: v.index = vidxs[v.v.index]
self.faces = foofaces
self.verts = fooverts
class AC3DExport: # the ac3d exporter part
def __init__(self, scene_objects, file):
global ARG, SKIP_DATA, ADD_DEFAULT_MAT, DEFAULT_MAT
header = 'AC3Db'
self.file = file
self.buf = ''
self.mbuf = []
self.mlist = []
world_kids = 0
parents_list = self.parents_list = []
kids_dict = self.kids_dict = {}
objs = []
exp_objs = self.exp_objs = []
tree = {}
file.write(header+'\n')
objs = \
[o for o in scene_objects if o.type in ['Mesh', 'Empty']]
# create a tree from parents to children objects
for obj in objs[:]:
parent = obj.parent
lineage = [obj]
while parent:
parents_list.append(parent.name)
obj = parent
parent = parent.getParent()
lineage.insert(0, obj)
d = tree
for i in xrange(len(lineage)):
lname = lineage[i].getType()[:2] + lineage[i].name
if lname not in d.keys():
d[lname] = {}
d = d[lname]
# traverse the tree to get an ordered list of names of objects to export
self.traverse_dict(tree)
world_kids = len(tree.keys())
# get list of objects to export, start writing the .ac file
objlist = [Object.Get(name) for name in exp_objs]
meshlist = [o for o in objlist if o.type == 'Mesh']
# create a temporary mesh to hold actual (modified) mesh data
TMP_mesh = Mesh.New('tmp_for_ac_export')
# write materials
self.MATERIALS(meshlist, TMP_mesh)
mbuf = self.mbuf
if not mbuf or ADD_DEFAULT_MAT:
mbuf.insert(0, "%s\n" % DEFAULT_MAT)
mbuf = "".join(mbuf)
file.write(mbuf)
file.write('OBJECT world\nkids %s\n' % world_kids)
# write the objects
for obj in objlist:
self.obj = obj
objtype = obj.type
objname = obj.name
kidsnum = kids_dict[objname]
# A parent plus its children are exported as a group.
# If the parent is a mesh, its rot and loc are exported as the
# group rot and loc and the mesh (w/o rot and loc) is added to the group.
if kidsnum:
self.OBJECT('group')
self.name(objname)
if objtype == 'Mesh':
kidsnum += 1
if not GLOBAL_COORDS:
localmatrix = obj.getMatrix('localspace')
if not obj.getParent():
localmatrix *= BLEND_TO_AC3D_MATRIX
self.rot(localmatrix.rotationPart())
self.loc(localmatrix.translationPart())
self.kids(kidsnum)
if objtype == 'Mesh':
mesh = TMP_mesh # temporary mesh to hold actual (modified) mesh data
mesh.getFromObject(objname)
self.mesh = mesh
if mesh.faceUV:
meshes = self.split_mesh(mesh)
else:
meshes = [mesh]
if len(meshes) > 1:
if NO_SPLIT or self.dont_split(objname):
self.export_mesh(mesh, ob)
REPORT_DATA['nosplit'].append(objname)
else:
self.OBJECT('group')
self.name(objname)
self.kids(len(meshes))
counter = 0
for me in meshes:
self.export_mesh(me, obj,
name = '%s_%s' % (obj.name, counter), foomesh = True)
self.kids()
counter += 1
else:
self.export_mesh(mesh, obj)
self.kids()
def traverse_dict(self, d):
kids_dict = self.kids_dict
exp_objs = self.exp_objs
keys = d.keys()
keys.sort() # sort for predictable output
keys.reverse()
for k in keys:
objname = k[2:]
klen = len(d[k])
kids_dict[objname] = klen
if self.dont_export(objname):
d.pop(k)
parent = Object.Get(objname).getParent()
if parent: kids_dict[parent.name] -= 1
REPORT_DATA['noexport'].append(objname)
continue
if klen:
self.traverse_dict(d[k])
exp_objs.insert(0, objname)
else:
if k.find('Em', 0) == 0: # Empty w/o children
d.pop(k)
parent = Object.Get(objname).getParent()
if parent: kids_dict[parent.name] -= 1
else:
exp_objs.insert(0, objname)
def dont_export(self, name): # if name starts with '!' or '#'
length = len(name)
if length >= 1:
if name[0] in TOKENS_DONT_EXPORT: # '!' or '#' doubled (escaped): export
if length > 1 and name[1] == name[0]:
return 0
return 1
def dont_split(self, name): # if name starts with '=' or '$'
length = len(name)
if length >= 1:
if name[0] in TOKENS_DONT_SPLIT: # '=' or '$' doubled (escaped): split
if length > 1 and name[1] == name[0]:
return 0
return 1
def split_mesh(self, mesh):
tex_dict = {0:[]}
for f in mesh.faces:
if f.image:
if not f.image.name in tex_dict: tex_dict[f.image.name] = []
tex_dict[f.image.name].append(f)
else: tex_dict[0].append(f)
keys = tex_dict.keys()
len_keys = len(keys)
if not tex_dict[0]:
len_keys -= 1
tex_dict.pop(0)
keys.remove(0)
elif len_keys > 1:
lines = []
anyimgkey = [k for k in keys if k != 0][0]
for f in tex_dict[0]:
if len(f.v) < 3:
lines.append(f)
if len(tex_dict[0]) == len(lines):
for l in lines:
tex_dict[anyimgkey].append(l)
len_keys -= 1
tex_dict.pop(0)
if len_keys > 1:
foo_meshes = []
for k in keys:
faces = tex_dict[k]
foo_meshes.append(FooMesh(k, faces, mesh))
foo_meshes[0].edges = get_loose_edges(mesh)
return foo_meshes
return [mesh]
def export_mesh(self, mesh, obj, name = None, foomesh = False):
file = self.file
self.OBJECT('poly')
if not name: name = obj.name
self.name(name)
if not SKIP_DATA:
meshname = obj.getData(name_only = True)
self.data(len(meshname), meshname)
if mesh.faceUV:
texline = self.texture(mesh.faces)
if texline: file.write(texline)
if AC3D_4:
self.crease(mesh.degr)
# If exporting using local coordinates, children object coordinates should not be
# transformed to ac3d's coordinate system, since that will be accounted for in
# their topmost parents (the parents w/o parents) transformations.
if not GLOBAL_COORDS:
# We hold parents in a list, so they also don't get transformed,
# because for each parent we create an ac3d group to hold both the
# parent and its children.
if obj.name not in self.parents_list:
localmatrix = obj.getMatrix('localspace')
if not obj.getParent():
localmatrix *= BLEND_TO_AC3D_MATRIX
self.rot(localmatrix.rotationPart())
self.loc(localmatrix.translationPart())
matrix = None
else:
matrix = obj.getMatrix() * BLEND_TO_AC3D_MATRIX
self.numvert(mesh.verts, matrix)
self.numsurf(mesh, foomesh)
def MATERIALS(self, meshlist, me):
for meobj in meshlist:
me.getFromObject(meobj)
mats = me.materials
mbuf = []
mlist = self.mlist
for m in mats:
if not m: continue
name = m.name
if name not in mlist:
mlist.append(name)
M = Material.Get(name)
material = 'MATERIAL "%s"' % name
mirCol = "%s %s %s" % (Round_s(M.mirCol[0]), Round_s(M.mirCol[1]),
Round_s(M.mirCol[2]))
rgb = "rgb %s %s %s" % (Round_s(M.R), Round_s(M.G), Round_s(M.B))
ambval = Round_s(M.amb)
amb = "amb %s %s %s" % (ambval, ambval, ambval)
spec = "spec %s %s %s" % (Round_s(M.specCol[0]),
Round_s(M.specCol[1]), Round_s(M.specCol[2]))
if AC3D_4:
emit = Round_s(M.emit)
emis = "emis %s %s %s" % (emit, emit, emit)
shival = int(M.spec * 64)
else:
emis = "emis 0 0 0"
shival = 72
shi = "shi %s" % shival
trans = "trans %s" % (Round_s(1 - M.alpha))
if MIRCOL_AS_AMB:
amb = "amb %s" % mirCol
if MIRCOL_AS_EMIS:
emis = "emis %s" % mirCol
mbuf.append("%s %s %s %s %s %s %s\n" \
% (material, rgb, amb, emis, spec, shi, trans))
self.mlist = mlist
self.mbuf.append("".join(mbuf))
def OBJECT(self, type):
self.file.write('OBJECT %s\n' % type)
def name(self, name):
if name[0] in TOKENS_DONT_EXPORT or name[0] in TOKENS_DONT_SPLIT:
if len(name) > 1: name = name[1:]
self.file.write('name "%s"\n' % name)
def kids(self, num = 0):
self.file.write('kids %s\n' % num)
def data(self, num, str):
self.file.write('data %s\n%s\n' % (num, str))
def texture(self, faces):
tex = ""
for f in faces:
if f.image:
tex = f.image.name
break
if tex:
image = Image.Get(tex)
texfname = image.filename
if SET_TEX_DIR:
texfname = bsys.basename(texfname)
if TEX_DIR:
texfname = bsys.join(TEX_DIR, texfname)
buf = 'texture "%s"\n' % texfname
xrep = image.xrep
yrep = image.yrep
buf += 'texrep %s %s\n' % (xrep, yrep)
self.file.write(buf)
def rot(self, matrix):
rot = ''
not_I = 0 # not identity
matstr = []
for i in [0, 1, 2]:
r = map(Round_s, matrix[i])
not_I += (r[0] != '0')+(r[1] != '0')+(r[2] != '0')
not_I -= (r[i] == '1')
for j in [0, 1, 2]:
matstr.append(' %s' % r[j])
if not_I: # no need to write identity
self.file.write('rot%s\n' % "".join(matstr))
def loc(self, loc):
loc = map(Round_s, loc)
if loc != ['0', '0', '0']: # no need to write default
self.file.write('loc %s %s %s\n' % (loc[0], loc[1], loc[2]))
def crease(self, crease):
self.file.write('crease %f\n' % crease)
def numvert(self, verts, matrix):
file = self.file
nvstr = []
nvstr.append("numvert %s\n" % len(verts))
if matrix:
verts = transform_verts(verts, matrix)
for v in verts:
v = map (Round_s, v)
nvstr.append("%s %s %s\n" % (v[0], v[1], v[2]))
else:
for v in verts:
v = map(Round_s, v.co)
nvstr.append("%s %s %s\n" % (v[0], v[1], v[2]))
file.write("".join(nvstr))
def numsurf(self, mesh, foomesh = False):
global MATIDX_ERROR
# local vars are faster and so better in tight loops
lc_ADD_DEFAULT_MAT = ADD_DEFAULT_MAT
lc_MATIDX_ERROR = MATIDX_ERROR
lc_PER_FACE_1_OR_2_SIDED = PER_FACE_1_OR_2_SIDED
lc_FACE_TWOSIDED = FACE_TWOSIDED
lc_MESH_TWOSIDED = MESH_TWOSIDED
faces = mesh.faces
hasFaceUV = mesh.faceUV
if foomesh:
looseEdges = mesh.looseEdges
else:
looseEdges = get_loose_edges(mesh)
file = self.file
file.write("numsurf %s\n" % (len(faces) + len(looseEdges)))
if not foomesh: verts = list(self.mesh.verts)
materials = self.mesh.materials
mlist = self.mlist
matidx_error_reported = False
objmats = []
for omat in materials:
if omat: objmats.append(omat.name)
else: objmats.append(None)
for f in faces:
if not objmats:
m_idx = 0
elif objmats[f.mat] in mlist:
m_idx = mlist.index(objmats[f.mat])
else:
if not lc_MATIDX_ERROR:
rdat = REPORT_DATA['warns']
rdat.append("Object %s" % self.obj.name)
rdat.append("has at least one material *index* assigned but not")
rdat.append("defined (not linked to an existing material).")
rdat.append("Result: some faces may be exported with a wrong color.")
rdat.append("You can assign materials in the Edit Buttons window (F9).")
elif not matidx_error_reported:
midxmsg = "- Same for object %s." % self.obj.name
REPORT_DATA['warns'].append(midxmsg)
lc_MATIDX_ERROR += 1
matidx_error_reported = True
m_idx = 0
if lc_ADD_DEFAULT_MAT: m_idx -= 1
refs = len(f)
flaglow = 0 # polygon
if lc_PER_FACE_1_OR_2_SIDED and hasFaceUV: # per face attribute
two_side = f.mode & lc_FACE_TWOSIDED
else: # global, for the whole mesh
two_side = self.mesh.mode & lc_MESH_TWOSIDED
two_side = (two_side > 0) << 1
flaghigh = f.smooth | two_side
surfstr = "SURF 0x%d%d\n" % (flaghigh, flaglow)
if lc_ADD_DEFAULT_MAT and objmats: m_idx += 1
matstr = "mat %s\n" % m_idx
refstr = "refs %s\n" % refs
u, v, vi = 0, 0, 0
fvstr = []
if foomesh:
for vert in f.v:
fvstr.append(str(vert.index))
if hasFaceUV:
u = f.uv[vi][0]
v = f.uv[vi][1]
vi += 1
fvstr.append(" %s %s\n" % (u, v))
else:
for vert in f.v:
fvstr.append(str(verts.index(vert)))
if hasFaceUV:
u = f.uv[vi][0]
v = f.uv[vi][1]
vi += 1
fvstr.append(" %s %s\n" % (u, v))
fvstr = "".join(fvstr)
file.write("%s%s%s%s" % (surfstr, matstr, refstr, fvstr))
# material for loose edges
edges_mat = 0 # default to first material
for omat in objmats: # but look for a material from this mesh
if omat in mlist:
edges_mat = mlist.index(omat)
if lc_ADD_DEFAULT_MAT: edges_mat += 1
break
for e in looseEdges:
fvstr = []
#flaglow = 2 # 1 = closed line, 2 = line
#flaghigh = 0
#surfstr = "SURF 0x%d%d\n" % (flaghigh, flaglow)
surfstr = "SURF 0x02\n"
fvstr.append("%d 0 0\n" % verts.index(e.v1))
fvstr.append("%d 0 0\n" % verts.index(e.v2))
fvstr = "".join(fvstr)
matstr = "mat %d\n" % edges_mat # for now, use first material
refstr = "refs 2\n" # 2 verts
file.write("%s%s%s%s" % (surfstr, matstr, refstr, fvstr))
MATIDX_ERROR = lc_MATIDX_ERROR
# End of Class AC3DExport
from Blender.Window import FileSelector
def report_data():
global VERBOSE
if not VERBOSE: return
d = REPORT_DATA
msgs = {
'0main': '%s\nExporting meshes to AC3D format' % str(19*'-'),
'1warns': 'Warnings',
'2errors': 'Errors',
'3nosplit': 'Not split (because name starts with "=" or "$")',
'4noexport': 'Not exported (because name starts with "!" or "#")'
}
if NO_SPLIT:
l = msgs['3nosplit']
l = "%s (because OPTION NO_SPLIT is set)" % l.split('(')[0]
msgs['3nosplit'] = l
keys = msgs.keys()
keys.sort()
for k in keys:
msgk = msgs[k]
msg = '\n'.join(d[k[1:]])
if msg:
print '\n-%s:' % msgk
print msg
# File Selector callback:
def fs_callback(filename):
global EXPORT_DIR, OBJS, CONFIRM_OVERWRITE, VERBOSE
if not filename.endswith('.ac'): filename = '%s.ac' % filename
if bsys.exists(filename) and CONFIRM_OVERWRITE:
if Blender.Draw.PupMenu('OVERWRITE?%t|File exists') != 1:
return
Blender.Window.WaitCursor(1)
starttime = bsys.time()
export_dir = bsys.dirname(filename)
if export_dir != EXPORT_DIR:
EXPORT_DIR = export_dir
update_RegistryInfo()
try:
file = open(filename, 'w')
except IOError, (errno, strerror):
error = "IOError #%s: %s" % (errno, strerror)
REPORT_DATA['errors'].append("Saving failed - %s." % error)
error_msg = "Couldn't save file!%%t|%s" % error
Blender.Draw.PupMenu(error_msg)
return
try:
test = AC3DExport(OBJS, file)
except:
file.close()
raise
else:
file.close()
endtime = bsys.time() - starttime
REPORT_DATA['main'].append("Done. Saved to: %s" % filename)
REPORT_DATA['main'].append("Data exported in %.3f seconds." % endtime)
if VERBOSE: report_data()
Blender.Window.WaitCursor(0)
# -- End of definitions
scn = Blender.Scene.GetCurrent()
if ONLY_SELECTED:
OBJS = list(scn.objects.context)
else:
OBJS = list(scn.objects)
if not OBJS:
Blender.Draw.PupMenu('ERROR: no objects selected')
else:
fname = bsys.makename(ext=".ac")
if EXPORT_DIR:
fname = bsys.join(EXPORT_DIR, bsys.basename(fname))
FileSelector(fs_callback, "Export AC3D", fname)
View Git Blame Copy Permalink