forked from bartvdbraak/blender
345866b61e
Maya uses OBJ's UV's to generate seams, some people complained that models imported from blender didnt work well in maya. It was faster to write every faces UV (without doing a remove doubles), but sharing UV coords makes smaller files and might also be more efficient in other applications.
678 lines
22 KiB
Python
678 lines
22 KiB
Python
#!BPY
|
|
|
|
"""
|
|
Name: 'Wavefront (.obj)...'
|
|
Blender: 243
|
|
Group: 'Export'
|
|
Tooltip: 'Save a Wavefront OBJ File'
|
|
"""
|
|
|
|
__author__ = "Campbell Barton, Jiri Hnidek"
|
|
__url__ = ['www.blender.org', 'blenderartists.org']
|
|
__version__ = "1.1"
|
|
|
|
__bpydoc__ = """\
|
|
This script is an exporter to OBJ file format.
|
|
|
|
Usage:
|
|
|
|
Select the objects you wish to export and run this script from "File->Export" menu.
|
|
Selecting the default options from the popup box will be good in most cases.
|
|
All objects that can be represented as a mesh (mesh, curve, metaball, surface, text3d)
|
|
will be exported as mesh data.
|
|
"""
|
|
|
|
|
|
# --------------------------------------------------------------------------
|
|
# OBJ Export v1.1 by Campbell Barton (AKA Ideasman)
|
|
# --------------------------------------------------------------------------
|
|
# ***** 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
|
|
from Blender import Mesh, Scene, Window, sys, Image, Draw
|
|
import BPyMesh
|
|
import BPyObject
|
|
import BPySys
|
|
import BPyMessages
|
|
|
|
# Returns a tuple - path,extension.
|
|
# 'hello.obj' > ('hello', '.obj')
|
|
def splitExt(path):
|
|
dotidx = path.rfind('.')
|
|
if dotidx == -1:
|
|
return path, ''
|
|
else:
|
|
return path[:dotidx], path[dotidx:]
|
|
|
|
def fixName(name):
|
|
if name == None:
|
|
return 'None'
|
|
else:
|
|
return name.replace(' ', '_')
|
|
|
|
# A Dict of Materials
|
|
# (material.name, image.name):matname_imagename # matname_imagename has gaps removed.
|
|
MTL_DICT = {}
|
|
|
|
def write_mtl(filename):
|
|
|
|
world = Blender.World.GetCurrent()
|
|
if world:
|
|
worldAmb = world.getAmb()
|
|
else:
|
|
worldAmb = (0,0,0) # Default value
|
|
|
|
file = open(filename, "w")
|
|
file.write('# Blender3D MTL File: %s\n' % Blender.Get('filename').split('\\')[-1].split('/')[-1])
|
|
file.write('# Material Count: %i\n' % len(MTL_DICT))
|
|
# Write material/image combinations we have used.
|
|
for key, (mtl_mat_name, mat, img) in MTL_DICT.iteritems():
|
|
|
|
# Get the Blender data for the material and the image.
|
|
# Having an image named None will make a bug, dont do it :)
|
|
|
|
file.write('newmtl %s\n' % mtl_mat_name) # Define a new material: matname_imgname
|
|
|
|
if mat:
|
|
file.write('Ns %.6f\n' % ((mat.getHardness()-1) * 1.9607843137254901) ) # Hardness, convert blenders 1-511 to MTL's
|
|
file.write('Ka %.6f %.6f %.6f\n' % tuple([c*mat.amb for c in worldAmb]) ) # Ambient, uses mirror colour,
|
|
file.write('Kd %.6f %.6f %.6f\n' % tuple([c*mat.ref for c in mat.rgbCol]) ) # Diffuse
|
|
file.write('Ks %.6f %.6f %.6f\n' % tuple([c*mat.spec for c in mat.specCol]) ) # Specular
|
|
file.write('Ni %.6f\n' % mat.IOR) # Refraction index
|
|
file.write('d %.6f\n' % mat.alpha) # Alpha (obj uses 'd' for dissolve)
|
|
|
|
# 0 to disable lighting, 1 for ambient & diffuse only (specular color set to black), 2 for full lighting.
|
|
if mat.getMode() & Blender.Material.Modes['SHADELESS']:
|
|
file.write('illum 0\n') # ignore lighting
|
|
elif mat.getSpec() == 0:
|
|
file.write('illum 1\n') # no specular.
|
|
else:
|
|
file.write('illum 2\n') # light normaly
|
|
|
|
else:
|
|
#write a dummy material here?
|
|
file.write('Ns 0\n')
|
|
file.write('Ka %.6f %.6f %.6f\n' % tuple([c for c in worldAmb]) ) # Ambient, uses mirror colour,
|
|
file.write('Kd 0.8 0.8 0.8\n')
|
|
file.write('Ks 0.8 0.8 0.8\n')
|
|
file.write('d 1\n') # No alpha
|
|
file.write('illum 2\n') # light normaly
|
|
|
|
# Write images!
|
|
if img: # We have an image on the face!
|
|
file.write('map_Kd %s\n' % img.filename.split('\\')[-1].split('/')[-1]) # Diffuse mapping image
|
|
|
|
elif not mat: # No face image. if we havea material search for MTex image.
|
|
for mtex in mat.getTextures():
|
|
if mtex and mtex.tex.type == Blender.Texture.Types.IMAGE:
|
|
try:
|
|
filename = mtex.tex.image.filename.split('\\')[-1].split('/')[-1]
|
|
file.write('map_Kd %s\n' % filename) # Diffuse mapping image
|
|
break
|
|
except:
|
|
# Texture has no image though its an image type, best ignore.
|
|
pass
|
|
|
|
file.write('\n\n')
|
|
|
|
file.close()
|
|
|
|
def copy_file(source, dest):
|
|
file = open(source, 'rb')
|
|
data = file.read()
|
|
file.close()
|
|
|
|
file = open(dest, 'wb')
|
|
file.write(data)
|
|
file.close()
|
|
|
|
|
|
def copy_images(dest_dir):
|
|
if dest_dir[-1] != sys.sep:
|
|
dest_dir += sys.sep
|
|
|
|
# Get unique image names
|
|
uniqueImages = {}
|
|
for matname, mat, image in MTL_DICT.itervalues(): # Only use image name
|
|
# Get Texface images
|
|
if image:
|
|
uniqueImages[image] = image # Should use sets here. wait until Python 2.4 is default.
|
|
|
|
# Get MTex images
|
|
if mat:
|
|
for mtex in mat.getTextures():
|
|
if mtex and mtex.tex.type == Blender.Texture.Types.IMAGE:
|
|
image_tex = mtex.tex.image
|
|
if image_tex:
|
|
try:
|
|
uniqueImages[image_tex] = image_tex
|
|
except:
|
|
pass
|
|
|
|
# Now copy images
|
|
copyCount = 0
|
|
|
|
for bImage in uniqueImages.itervalues():
|
|
image_path = sys.expandpath(bImage.filename)
|
|
if sys.exists(image_path):
|
|
# Make a name for the target path.
|
|
dest_image_path = dest_dir + image_path.split('\\')[-1].split('/')[-1]
|
|
if not sys.exists(dest_image_path): # Image isnt alredy there
|
|
print '\tCopying "%s" > "%s"' % (image_path, dest_image_path)
|
|
copy_file(image_path, dest_image_path)
|
|
copyCount+=1
|
|
print '\tCopied %d images' % copyCount
|
|
|
|
def write(filename, objects,\
|
|
EXPORT_TRI=False, EXPORT_EDGES=False, EXPORT_NORMALS=False, EXPORT_NORMALS_HQ=False,\
|
|
EXPORT_UV=True, EXPORT_MTL=True, EXPORT_COPY_IMAGES=False,\
|
|
EXPORT_APPLY_MODIFIERS=True, EXPORT_ROTX90=True, EXPORT_BLEN_OBS=True,\
|
|
EXPORT_GROUP_BY_OB=False, EXPORT_GROUP_BY_MAT=False, EXPORT_MORPH_TARGET=False):
|
|
'''
|
|
Basic write function. The context and options must be alredy set
|
|
This can be accessed externaly
|
|
eg.
|
|
write( 'c:\\test\\foobar.obj', Blender.Object.GetSelected() ) # Using default options.
|
|
'''
|
|
|
|
def veckey3d(v):
|
|
return round(v.x, 6), round(v.y, 6), round(v.z, 6)
|
|
|
|
def veckey2d(v):
|
|
return round(v.x, 6), round(v.y, 6)
|
|
|
|
print 'OBJ Export path: "%s"' % filename
|
|
temp_mesh_name = '~tmp-mesh'
|
|
|
|
time1 = sys.time()
|
|
scn = Scene.GetCurrent()
|
|
|
|
file = open(filename, "w")
|
|
|
|
# Write Header
|
|
file.write('# Blender3D v%s OBJ File: %s\n' % (Blender.Get('version'), Blender.Get('filename').split('/')[-1].split('\\')[-1] ))
|
|
file.write('# www.blender3d.org\n')
|
|
|
|
# Tell the obj file what material file to use.
|
|
if EXPORT_MTL:
|
|
mtlfilename = '%s.mtl' % '.'.join(filename.split('.')[:-1])
|
|
file.write('mtllib %s\n' % ( mtlfilename.split('\\')[-1].split('/')[-1] ))
|
|
|
|
# Get the container mesh. - used for applying modifiers and non mesh objects.
|
|
containerMesh = meshName = tempMesh = None
|
|
for meshName in Blender.NMesh.GetNames():
|
|
if meshName.startswith(temp_mesh_name):
|
|
tempMesh = Mesh.Get(meshName)
|
|
if not tempMesh.users:
|
|
containerMesh = tempMesh
|
|
if not containerMesh:
|
|
containerMesh = Mesh.New(temp_mesh_name)
|
|
|
|
if EXPORT_ROTX90:
|
|
mat_xrot90= Blender.Mathutils.RotationMatrix(-90, 4, 'x')
|
|
|
|
del meshName
|
|
del tempMesh
|
|
|
|
# Initialize totals, these are updated each object
|
|
totverts = totuvco = totno = 1
|
|
|
|
face_vert_index = 1
|
|
|
|
globalNormals = {}
|
|
|
|
# Get all meshs
|
|
for ob_main in objects:
|
|
for ob, ob_mat in BPyObject.getDerivedObjects(ob_main):
|
|
# Will work for non meshes now! :)
|
|
# getMeshFromObject(ob, container_mesh=None, apply_modifiers=True, vgroups=True, scn=None)
|
|
me= BPyMesh.getMeshFromObject(ob, containerMesh, EXPORT_APPLY_MODIFIERS, False, scn)
|
|
if not me:
|
|
continue
|
|
|
|
if EXPORT_UV:
|
|
faceuv= me.faceUV
|
|
else:
|
|
faceuv = False
|
|
|
|
# We have a valid mesh
|
|
if EXPORT_TRI and me.faces:
|
|
# Add a dummy object to it.
|
|
has_quads = False
|
|
for f in me.faces:
|
|
if len(f) == 4:
|
|
has_quads = True
|
|
break
|
|
|
|
if has_quads:
|
|
oldmode = Mesh.Mode()
|
|
Mesh.Mode(Mesh.SelectModes['FACE'])
|
|
|
|
me.sel = True
|
|
tempob = scn.objects.new(me)
|
|
me.quadToTriangle(0) # more=0 shortest length
|
|
oldmode = Mesh.Mode(oldmode)
|
|
scn.objects.unlink(tempob)
|
|
|
|
Mesh.Mode(oldmode)
|
|
|
|
# Make our own list so it can be sorted to reduce context switching
|
|
faces = [ f for f in me.faces ]
|
|
|
|
if EXPORT_EDGES:
|
|
edges = me.edges
|
|
else:
|
|
edges = []
|
|
|
|
if not (len(faces)+len(edges)+len(me.verts)): # Make sure there is somthing to write
|
|
continue # dont bother with this mesh.
|
|
|
|
if EXPORT_ROTX90:
|
|
me.transform(ob_mat*mat_xrot90)
|
|
else:
|
|
me.transform(ob_mat)
|
|
|
|
# High Quality Normals
|
|
if EXPORT_NORMALS and faces:
|
|
if EXPORT_NORMALS_HQ:
|
|
BPyMesh.meshCalcNormals(me)
|
|
else:
|
|
# transforming normals is incorrect
|
|
# when the matrix is scaled,
|
|
# better to recalculate them
|
|
me.calcNormals()
|
|
|
|
# # Crash Blender
|
|
#materials = me.getMaterials(1) # 1 == will return None in the list.
|
|
materials = me.materials
|
|
|
|
materialNames = []
|
|
materialItems = materials[:]
|
|
if materials:
|
|
for mat in materials:
|
|
if mat: # !=None
|
|
materialNames.append(mat.name)
|
|
else:
|
|
materialNames.append(None)
|
|
# Cant use LC because some materials are None.
|
|
# materialNames = map(lambda mat: mat.name, materials) # Bug Blender, dosent account for null materials, still broken.
|
|
|
|
# Possible there null materials, will mess up indicies
|
|
# but at least it will export, wait until Blender gets fixed.
|
|
materialNames.extend((16-len(materialNames)) * [None])
|
|
materialItems.extend((16-len(materialItems)) * [None])
|
|
|
|
# Sort by Material, then images
|
|
# so we dont over context switch in the obj file.
|
|
if EXPORT_MORPH_TARGET:
|
|
pass
|
|
elif faceuv:
|
|
try: faces.sort(key = lambda a: (a.mat, a.image, a.smooth))
|
|
except: faces.sort(lambda a,b: cmp((a.mat, a.image, a.smooth), (b.mat, b.image, b.smooth)))
|
|
elif len(materials) > 1:
|
|
try: faces.sort(key = lambda a: (a.mat, a.smooth))
|
|
except: faces.sort(lambda a,b: cmp((a.mat, a.smooth), (b.mat, b.smooth)))
|
|
else:
|
|
# no materials
|
|
try: faces.sort(key = lambda a: a.smooth)
|
|
except: faces.sort(lambda a,b: cmp(a.smooth, b.smooth))
|
|
|
|
# Set the default mat to no material and no image.
|
|
contextMat = (0, 0) # Can never be this, so we will label a new material teh first chance we get.
|
|
contextSmooth = None # Will either be true or false, set bad to force initialization switch.
|
|
|
|
if EXPORT_BLEN_OBS or EXPORT_GROUP_BY_OB:
|
|
name1 = ob.name
|
|
name2 = ob.getData(1)
|
|
if name1 == name2:
|
|
obnamestring = fixName(name1)
|
|
else:
|
|
obnamestring = '%s_%s' % (fixName(name1), fixName(name2))
|
|
|
|
if EXPORT_BLEN_OBS:
|
|
file.write('o %s\n' % obnamestring) # Write Object name
|
|
else: # if EXPORT_GROUP_BY_OB:
|
|
file.write('g %s\n' % obnamestring)
|
|
|
|
|
|
# Vert
|
|
for v in me.verts:
|
|
file.write('v %.6f %.6f %.6f\n' % tuple(v.co))
|
|
|
|
# UV
|
|
if faceuv:
|
|
uv_face_mapping = [[0,0,0,0] for f in faces] # a bit of a waste for tri's :/
|
|
|
|
uv_dict = {} # could use a set() here
|
|
for f_index, f in enumerate(faces):
|
|
|
|
for uv_index, uv in enumerate(f.uv):
|
|
uvkey = veckey2d(uv)
|
|
try:
|
|
uv_face_mapping[f_index][uv_index] = uv_dict[uvkey]
|
|
except:
|
|
uv_face_mapping[f_index][uv_index] = uv_dict[uvkey] = len(uv_dict)
|
|
file.write('vt %.6f %.6f\n' % tuple(uv))
|
|
|
|
uv_unique_count = len(uv_dict)
|
|
del uv, uvkey, uv_dict, f_index, uv_index
|
|
# Only need uv_unique_count and uv_face_mapping
|
|
|
|
# NORMAL, Smooth/Non smoothed.
|
|
if EXPORT_NORMALS:
|
|
for f in faces:
|
|
if f.smooth:
|
|
for v in f:
|
|
noKey = veckey3d(v.no)
|
|
if not globalNormals.has_key( noKey ):
|
|
globalNormals[noKey] = totno
|
|
totno +=1
|
|
file.write('vn %.6f %.6f %.6f\n' % noKey)
|
|
else:
|
|
# Hard, 1 normal from the face.
|
|
noKey = veckey3d(f.no)
|
|
if not globalNormals.has_key( noKey ):
|
|
globalNormals[noKey] = totno
|
|
totno +=1
|
|
file.write('vn %.6f %.6f %.6f\n' % noKey)
|
|
|
|
if not faceuv:
|
|
f_image = None
|
|
|
|
for f_index, f in enumerate(faces):
|
|
f_v= f.v
|
|
f_smooth= f.smooth
|
|
f_mat = min(f.mat, len(materialNames)-1)
|
|
if faceuv:
|
|
f_image = f.image
|
|
f_uv= f.uv
|
|
|
|
# MAKE KEY
|
|
if faceuv and f_image: # Object is always true.
|
|
key = materialNames[f_mat], f_image.name
|
|
else:
|
|
key = materialNames[f_mat], None # No image, use None instead.
|
|
|
|
# CHECK FOR CONTEXT SWITCH
|
|
if key == contextMat:
|
|
pass # Context alredy switched, dont do anythoing
|
|
else:
|
|
if key[0] == None and key[1] == None:
|
|
# Write a null material, since we know the context has changed.
|
|
if EXPORT_GROUP_BY_MAT:
|
|
file.write('g %s_%s\n' % (fixName(ob.name), fixName(ob.getData(1))) ) # can be mat_image or (null)
|
|
file.write('usemtl (null)\n') # mat, image
|
|
|
|
else:
|
|
mat_data= MTL_DICT.get(key)
|
|
if not mat_data:
|
|
# First add to global dict so we can export to mtl
|
|
# Then write mtl
|
|
|
|
# Make a new names from the mat and image name,
|
|
# converting any spaces to underscores with fixName.
|
|
|
|
# If none image dont bother adding it to the name
|
|
if key[1] == None:
|
|
mat_data = MTL_DICT[key] = ('%s'%fixName(key[0])), materialItems[f_mat], f_image
|
|
else:
|
|
mat_data = MTL_DICT[key] = ('%s_%s' % (fixName(key[0]), fixName(key[1]))), materialItems[f_mat], f_image
|
|
|
|
if EXPORT_GROUP_BY_MAT:
|
|
file.write('g %s_%s_%s\n' % (fixName(ob.name), fixName(ob.getData(1)), mat_data[0]) ) # can be mat_image or (null)
|
|
file.write('usemtl %s\n' % mat_data[0]) # can be mat_image or (null)
|
|
|
|
contextMat = key
|
|
if f_smooth != contextSmooth:
|
|
if f_smooth: # on now off
|
|
file.write('s 1\n')
|
|
contextSmooth = f_smooth
|
|
else: # was off now on
|
|
file.write('s off\n')
|
|
contextSmooth = f_smooth
|
|
|
|
file.write('f')
|
|
if faceuv:
|
|
if EXPORT_NORMALS:
|
|
if f_smooth: # Smoothed, use vertex normals
|
|
for vi, v in enumerate(f_v):
|
|
file.write( ' %d/%d/%d' % (\
|
|
v.index+totverts,\
|
|
totuvco + uv_face_mapping[f_index][vi],\
|
|
globalNormals[ veckey3d(v.no) ])) # vert, uv, normal
|
|
|
|
else: # No smoothing, face normals
|
|
no = globalNormals[ veckey3d(f.no) ]
|
|
for vi, v in enumerate(f_v):
|
|
file.write( ' %d/%d/%d' % (\
|
|
v.index+totverts,\
|
|
totuvco + uv_face_mapping[f_index][vi],\
|
|
no)) # vert, uv, normal
|
|
|
|
else: # No Normals
|
|
for vi, v in enumerate(f_v):
|
|
|
|
#print _uv_face_mapping == tuple([tuple([0] * len(f)) for f in faces])
|
|
if len(uv_face_mapping) != len(faces):
|
|
raise "ass"
|
|
print f_index
|
|
print uv_face_mapping[f_index]
|
|
print vi
|
|
print uv_face_mapping[f_index][vi]
|
|
file.write( ' %d/%d' % (\
|
|
v.index+totverts,\
|
|
totuvco + uv_face_mapping[f_index][vi])) # vert, uv
|
|
|
|
face_vert_index += len(f_v)
|
|
|
|
else: # No UV's
|
|
if EXPORT_NORMALS:
|
|
if f_smooth: # Smoothed, use vertex normals
|
|
for v in f_v:
|
|
file.write( ' %d//%d' % (\
|
|
v.index+totverts,\
|
|
globalNormals[ veckey3d(v.no) ]))
|
|
else: # No smoothing, face normals
|
|
no = globalNormals[ veckey3d(f.no) ]
|
|
for v in f_v:
|
|
file.write( ' %d//%d' % (\
|
|
v.index+totverts,\
|
|
no))
|
|
else: # No Normals
|
|
for v in f_v:
|
|
file.write( ' %d' % (\
|
|
v.index+totverts))
|
|
|
|
file.write('\n')
|
|
|
|
# Write edges.
|
|
if EXPORT_EDGES:
|
|
LOOSE= Mesh.EdgeFlags.LOOSE
|
|
for ed in edges:
|
|
if ed.flag & LOOSE:
|
|
file.write('f %d %d\n' % (ed.v1.index+totverts, ed.v2.index+totverts))
|
|
|
|
# Make the indicies global rather then per mesh
|
|
totverts += len(me.verts)
|
|
if faceuv:
|
|
totuvco += uv_unique_count
|
|
me.verts= None
|
|
file.close()
|
|
|
|
|
|
# Now we have all our materials, save them
|
|
if EXPORT_MTL:
|
|
write_mtl(mtlfilename)
|
|
if EXPORT_COPY_IMAGES:
|
|
dest_dir = filename
|
|
# Remove chars until we are just the path.
|
|
while dest_dir and dest_dir[-1] not in '\\/':
|
|
dest_dir = dest_dir[:-1]
|
|
if dest_dir:
|
|
copy_images(dest_dir)
|
|
else:
|
|
print '\tError: "%s" could not be used as a base for an image path.' % filename
|
|
|
|
print "OBJ Export time: %.2f" % (sys.time() - time1)
|
|
|
|
|
|
|
|
def write_ui(filename):
|
|
|
|
if not filename.lower().endswith('.obj'):
|
|
filename += '.obj'
|
|
|
|
if not BPyMessages.Warning_SaveOver(filename):
|
|
return
|
|
|
|
EXPORT_APPLY_MODIFIERS = Draw.Create(1)
|
|
EXPORT_ROTX90 = Draw.Create(1)
|
|
EXPORT_TRI = Draw.Create(0)
|
|
EXPORT_EDGES = Draw.Create(1)
|
|
EXPORT_NORMALS = Draw.Create(0)
|
|
EXPORT_NORMALS_HQ = Draw.Create(1)
|
|
EXPORT_UV = Draw.Create(1)
|
|
EXPORT_MTL = Draw.Create(1)
|
|
EXPORT_SEL_ONLY = Draw.Create(1)
|
|
EXPORT_ALL_SCENES = Draw.Create(0)
|
|
EXPORT_ANIMATION = Draw.Create(0)
|
|
EXPORT_COPY_IMAGES = Draw.Create(0)
|
|
EXPORT_BLEN_OBS = Draw.Create(1)
|
|
EXPORT_GROUP_BY_OB = Draw.Create(0)
|
|
EXPORT_GROUP_BY_MAT = Draw.Create(0)
|
|
EXPORT_MORPH_TARGET = Draw.Create(0)
|
|
|
|
# removed too many options are bad!
|
|
|
|
# Get USER Options
|
|
pup_block = [\
|
|
('Context...'),\
|
|
('Selection Only', EXPORT_SEL_ONLY, 'Only export objects in visible selection. Else export whole scene.'),\
|
|
('All Scenes', EXPORT_ALL_SCENES, 'Each scene as a separate OBJ file.'),\
|
|
('Animation', EXPORT_ANIMATION, 'Each frame as a numbered OBJ file.'),\
|
|
('Object Prefs...'),\
|
|
('Apply Modifiers', EXPORT_APPLY_MODIFIERS, 'Use transformed mesh data from each object. May break vert order for morph targets.'),\
|
|
('Rotate X90', EXPORT_ROTX90 , 'Rotate on export so Blenders UP is translated into OBJs UP'),\
|
|
('Morph Target', EXPORT_MORPH_TARGET, 'Keep vert and face order, disables some other options.'),\
|
|
('Extra Data...'),\
|
|
('Edges', EXPORT_EDGES, 'Edges not connected to faces.'),\
|
|
('Normals', EXPORT_NORMALS, 'Export vertex normal data (Ignored on import).'),\
|
|
('High Quality Normals', EXPORT_NORMALS_HQ, 'Calculate high quality normals for rendering.'),\
|
|
('UVs', EXPORT_UV, 'Export texface UV coords.'),\
|
|
('Materials', EXPORT_MTL, 'Write a separate MTL file with the OBJ.'),\
|
|
('Copy Images', EXPORT_COPY_IMAGES, 'Copy image files to the export directory, never overwrite.'),\
|
|
('Triangulate', EXPORT_TRI, 'Triangulate quads.'),\
|
|
('Grouping...'),\
|
|
('Objects', EXPORT_BLEN_OBS, 'Export blender objects as "OBJ objects".'),\
|
|
('Object Groups', EXPORT_GROUP_BY_OB, 'Export blender objects as "OBJ Groups".'),\
|
|
('Material Groups', EXPORT_GROUP_BY_MAT, 'Group by materials.'),\
|
|
]
|
|
|
|
if not Draw.PupBlock('Export...', pup_block):
|
|
return
|
|
|
|
if EXPORT_MORPH_TARGET.val:
|
|
EXPORT_BLEN_OBS.val = False
|
|
EXPORT_GROUP_BY_OB.val = False
|
|
EXPORT_GROUP_BY_MAT.val = False
|
|
EXPORT_GROUP_BY_MAT.val = False
|
|
EXPORT_APPLY_MODIFIERS.val = False
|
|
|
|
Window.EditMode(0)
|
|
Window.WaitCursor(1)
|
|
|
|
EXPORT_APPLY_MODIFIERS = EXPORT_APPLY_MODIFIERS.val
|
|
EXPORT_ROTX90 = EXPORT_ROTX90.val
|
|
EXPORT_TRI = EXPORT_TRI.val
|
|
EXPORT_EDGES = EXPORT_EDGES.val
|
|
EXPORT_NORMALS = EXPORT_NORMALS.val
|
|
EXPORT_NORMALS_HQ = EXPORT_NORMALS_HQ.val
|
|
EXPORT_UV = EXPORT_UV.val
|
|
EXPORT_MTL = EXPORT_MTL.val
|
|
EXPORT_SEL_ONLY = EXPORT_SEL_ONLY.val
|
|
EXPORT_ALL_SCENES = EXPORT_ALL_SCENES.val
|
|
EXPORT_ANIMATION = EXPORT_ANIMATION.val
|
|
EXPORT_COPY_IMAGES = EXPORT_COPY_IMAGES.val
|
|
EXPORT_BLEN_OBS = EXPORT_BLEN_OBS.val
|
|
EXPORT_GROUP_BY_OB = EXPORT_GROUP_BY_OB.val
|
|
EXPORT_GROUP_BY_MAT = EXPORT_GROUP_BY_MAT.val
|
|
EXPORT_MORPH_TARGET = EXPORT_MORPH_TARGET.val
|
|
|
|
|
|
|
|
base_name, ext = splitExt(filename)
|
|
context_name = [base_name, '', '', ext] # basename, scene_name, framenumber, extension
|
|
|
|
# Use the options to export the data using write()
|
|
# def write(filename, objects, EXPORT_EDGES=False, EXPORT_NORMALS=False, EXPORT_MTL=True, EXPORT_COPY_IMAGES=False, EXPORT_APPLY_MODIFIERS=True):
|
|
orig_scene = Scene.GetCurrent()
|
|
if EXPORT_ALL_SCENES:
|
|
export_scenes = Scene.Get()
|
|
else:
|
|
export_scenes = [orig_scene]
|
|
|
|
# Export all scenes.
|
|
for scn in export_scenes:
|
|
scn.makeCurrent() # If alredy current, this is not slow.
|
|
context = scn.getRenderingContext()
|
|
orig_frame = Blender.Get('curframe')
|
|
|
|
if EXPORT_ALL_SCENES: # Add scene name into the context_name
|
|
context_name[1] = '_%s' % BPySys.cleanName(scn.name) # WARNING, its possible that this could cause a collision. we could fix if were feeling parranoied.
|
|
|
|
# Export an animation?
|
|
if EXPORT_ANIMATION:
|
|
scene_frames = xrange(context.startFrame(), context.endFrame()+1) # up to and including the end frame.
|
|
else:
|
|
scene_frames = [orig_frame] # Dont export an animation.
|
|
|
|
# Loop through all frames in the scene and export.
|
|
for frame in scene_frames:
|
|
if EXPORT_ANIMATION: # Add frame to the filename.
|
|
context_name[2] = '_%.6d' % frame
|
|
|
|
Blender.Set('curframe', frame)
|
|
if EXPORT_SEL_ONLY:
|
|
export_objects = scn.objects.context
|
|
else:
|
|
export_objects = scn.objects
|
|
|
|
full_path= ''.join(context_name)
|
|
|
|
# erm... bit of a problem here, this can overwrite files when exporting frames. not too bad.
|
|
# EXPORT THE FILE.
|
|
write(full_path, export_objects,\
|
|
EXPORT_TRI, EXPORT_EDGES, EXPORT_NORMALS,\
|
|
EXPORT_NORMALS_HQ, EXPORT_UV, EXPORT_MTL,\
|
|
EXPORT_COPY_IMAGES, EXPORT_APPLY_MODIFIERS,\
|
|
EXPORT_ROTX90, EXPORT_BLEN_OBS,\
|
|
EXPORT_GROUP_BY_OB, EXPORT_GROUP_BY_MAT, EXPORT_MORPH_TARGET)
|
|
|
|
Blender.Set('curframe', orig_frame)
|
|
|
|
# Restore old active scene.
|
|
orig_scene.makeCurrent()
|
|
Window.WaitCursor(0)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
Window.FileSelector(write_ui, 'Export Wavefront OBJ', sys.makename(ext='.obj'))
|