884 lines
27 KiB
Python
884 lines
27 KiB
Python
#!BPY
|
|
|
|
"""
|
|
Name: 'Wavefront (.obj)...'
|
|
Blender: 242
|
|
Group: 'Import'
|
|
Tooltip: 'Load a Wavefront OBJ File, Shift: batch import all dir.'
|
|
"""
|
|
|
|
__author__= "Campbell Barton", "Jiri Hnidek"
|
|
__url__= ["blender.org", "blenderartists.org"]
|
|
__version__= "2.0"
|
|
|
|
__bpydoc__= """\
|
|
This script imports a Wavefront OBJ files to Blender.
|
|
|
|
Usage:
|
|
Run this script from "File->Import" menu and then load the desired OBJ file.
|
|
Note, This loads mesh objects and materials only, nurbs and curves are not supported.
|
|
"""
|
|
|
|
# ***** BEGIN GPL LICENSE BLOCK *****
|
|
#
|
|
# Script copyright (C) Campbell J Barton 2007
|
|
#
|
|
# 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 *****
|
|
# --------------------------------------------------------------------------
|
|
|
|
from Blender import *
|
|
import bpy
|
|
import BPyMesh
|
|
import BPyImage
|
|
import BPyMessages
|
|
|
|
try: import os
|
|
except: os= False
|
|
|
|
|
|
# Generic path functions
|
|
def stripFile(path):
|
|
'''Return directory, where the file is'''
|
|
lastSlash= max(path.rfind('\\'), path.rfind('/'))
|
|
if lastSlash != -1:
|
|
path= path[:lastSlash]
|
|
return '%s%s' % (path, sys.sep)
|
|
|
|
def stripPath(path):
|
|
'''Strips the slashes from the back of a string'''
|
|
return path.split('/')[-1].split('\\')[-1]
|
|
|
|
def stripExt(name): # name is a string
|
|
'''Strips the prefix off the name before writing'''
|
|
index= name.rfind('.')
|
|
if index != -1:
|
|
return name[ : index ]
|
|
else:
|
|
return name
|
|
# end path funcs
|
|
|
|
|
|
|
|
def line_value(line_split):
|
|
'''
|
|
Returns 1 string represneting the value for this line
|
|
None will be returned if theres only 1 word
|
|
'''
|
|
length= len(line_split)
|
|
if length == 1:
|
|
return None
|
|
|
|
elif length == 2:
|
|
return line_split[1]
|
|
|
|
elif length > 2:
|
|
return ' '.join( line_split[1:] )
|
|
|
|
def obj_image_load(imagepath, DIR, IMAGE_SEARCH):
|
|
'''
|
|
Mainly uses comprehensiveImageLoad
|
|
but tries to replace '_' with ' ' for Max's exporter replaces spaces with underscores.
|
|
'''
|
|
|
|
if '_' in imagepath:
|
|
image= BPyImage.comprehensiveImageLoad(imagepath, DIR, PLACE_HOLDER= False, RECURSIVE= IMAGE_SEARCH)
|
|
if image: return image
|
|
# Did the exporter rename the image?
|
|
image= BPyImage.comprehensiveImageLoad(imagepath.replace('_', ' '), DIR, PLACE_HOLDER= False, RECURSIVE= IMAGE_SEARCH)
|
|
if image: return image
|
|
|
|
# Return an image, placeholder if it dosnt exist
|
|
image= BPyImage.comprehensiveImageLoad(imagepath, DIR, PLACE_HOLDER= True, RECURSIVE= IMAGE_SEARCH)
|
|
return image
|
|
|
|
|
|
def create_materials(filepath, material_libs, unique_materials, unique_material_images, IMAGE_SEARCH):
|
|
'''
|
|
Create all the used materials in this obj,
|
|
assign colors and images to the materials from all referenced material libs
|
|
'''
|
|
DIR= stripFile(filepath)
|
|
|
|
#==================================================================================#
|
|
# This function sets textures defined in .mtl file #
|
|
#==================================================================================#
|
|
def load_material_image(blender_material, context_material_name, imagepath, type):
|
|
|
|
texture= bpy.data.textures.new(type)
|
|
texture.setType('Image')
|
|
|
|
# Absolute path - c:\.. etc would work here
|
|
image= obj_image_load(imagepath, DIR, IMAGE_SEARCH)
|
|
has_data = image.has_data
|
|
texture.image = image
|
|
|
|
# Adds textures for materials (rendering)
|
|
if type == 'Kd':
|
|
if has_data and image.depth == 32:
|
|
# Image has alpha
|
|
blender_material.setTexture(0, texture, Texture.TexCo.UV, Texture.MapTo.COL | Texture.MapTo.ALPHA)
|
|
texture.setImageFlags('MipMap', 'InterPol', 'UseAlpha')
|
|
blender_material.mode |= Material.Modes.ZTRANSP
|
|
blender_material.alpha = 0.0
|
|
else:
|
|
blender_material.setTexture(0, texture, Texture.TexCo.UV, Texture.MapTo.COL)
|
|
|
|
# adds textures to faces (Textured/Alt-Z mode)
|
|
# Only apply the diffuse texture to the face if the image has not been set with the inline usemat func.
|
|
unique_material_images[context_material_name]= image, has_data # set the texface image
|
|
|
|
elif type == 'Ka':
|
|
blender_material.setTexture(1, texture, Texture.TexCo.UV, Texture.MapTo.CMIR) # TODO- Add AMB to BPY API
|
|
|
|
elif type == 'Ks':
|
|
blender_material.setTexture(2, texture, Texture.TexCo.UV, Texture.MapTo.SPEC)
|
|
|
|
elif type == 'Bump':
|
|
blender_material.setTexture(3, texture, Texture.TexCo.UV, Texture.MapTo.NOR)
|
|
elif type == 'D':
|
|
blender_material.setTexture(4, texture, Texture.TexCo.UV, Texture.MapTo.ALPHA)
|
|
blender_material.mode |= Material.Modes.ZTRANSP
|
|
blender_material.alpha = 0.0
|
|
# Todo, unset deffuse material alpha if it has an alpha channel
|
|
|
|
elif type == 'refl':
|
|
blender_material.setTexture(5, texture, Texture.TexCo.UV, Texture.MapTo.REF)
|
|
|
|
|
|
# Add an MTL with the same name as the obj if no MTLs are spesified.
|
|
temp_mtl= stripExt(stripPath(filepath))+ '.mtl'
|
|
|
|
if sys.exists(DIR + temp_mtl) and temp_mtl not in material_libs:
|
|
material_libs.append( temp_mtl )
|
|
del temp_mtl
|
|
|
|
#Create new materials
|
|
for name in unique_materials.iterkeys():
|
|
unique_materials[name]= bpy.data.materials.new(name)
|
|
|
|
unique_material_images[name]= None, False # assign None to all material images to start with, add to later.
|
|
|
|
unique_materials[None]= None
|
|
|
|
for libname in material_libs:
|
|
mtlpath= DIR + libname
|
|
if not sys.exists(mtlpath):
|
|
#print '\tError Missing MTL: "%s"' % mtlpath
|
|
pass
|
|
else:
|
|
#print '\t\tloading mtl: "%s"' % mtlpath
|
|
context_material= None
|
|
mtl= open(mtlpath)
|
|
for line in mtl: #.xreadlines():
|
|
if line.startswith('newmtl'):
|
|
context_material_name= line_value(line.split())
|
|
if unique_materials.has_key(context_material_name):
|
|
context_material = unique_materials[ context_material_name ]
|
|
else:
|
|
context_material = None
|
|
|
|
elif context_material:
|
|
# we need to make a material to assign properties to it.
|
|
line_split= line.split()
|
|
line_lower= line.lower()
|
|
if line_lower.startswith('ka'):
|
|
context_material.setMirCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
|
|
elif line_lower.startswith('kd'):
|
|
context_material.setRGBCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
|
|
elif line_lower.startswith('ks'):
|
|
context_material.setSpecCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
|
|
elif line_lower.startswith('ns'):
|
|
context_material.setHardness( int((float(line_split[1])*0.51)) )
|
|
elif line_lower.startswith('ni'): # Refraction index
|
|
context_material.setIOR( max(1, min(float(line_split[1]), 3))) # Between 1 and 3
|
|
elif line_lower.startswith('d') or line_lower.startswith('tr'):
|
|
context_material.setAlpha(float(line_split[1]))
|
|
elif line_lower.startswith('map_ka'):
|
|
img_filepath= line_value(line.split())
|
|
if img_filepath:
|
|
load_material_image(context_material, context_material_name, img_filepath, 'Ka')
|
|
elif line_lower.startswith('map_ks'):
|
|
img_filepath= line_value(line.split())
|
|
if img_filepath:
|
|
load_material_image(context_material, context_material_name, img_filepath, 'Ks')
|
|
elif line_lower.startswith('map_kd'):
|
|
img_filepath= line_value(line.split())
|
|
if img_filepath:
|
|
load_material_image(context_material, context_material_name, img_filepath, 'Kd')
|
|
elif line_lower.startswith('map_bump'):
|
|
img_filepath= line_value(line.split())
|
|
if img_filepath:
|
|
load_material_image(context_material, context_material_name, img_filepath, 'Bump')
|
|
elif line_lower.startswith('map_d') or line_lower.startswith('map_tr'): # Alpha map - Dissolve
|
|
img_filepath= line_value(line.split())
|
|
if img_filepath:
|
|
load_material_image(context_material, context_material_name, img_filepath, 'D')
|
|
|
|
elif line_lower.startswith('refl'): # Reflectionmap
|
|
img_filepath= line_value(line.split())
|
|
if img_filepath:
|
|
load_material_image(context_material, context_material_name, img_filepath, 'refl')
|
|
mtl.close()
|
|
|
|
|
|
|
|
|
|
def split_mesh(verts_loc, faces, unique_materials, filepath, SPLIT_OB_OR_GROUP, SPLIT_MATERIALS):
|
|
'''
|
|
Takes vert_loc and faces, and seperates into multiple sets of
|
|
(verts_loc, faces, unique_materials, dataname)
|
|
This is done so objects do not overload the 16 material limit.
|
|
'''
|
|
|
|
filename = stripExt(stripPath(filepath))
|
|
|
|
if not SPLIT_OB_OR_GROUP and not SPLIT_MATERIALS:
|
|
# use the filename for the object name since we arnt chopping up the mesh.
|
|
return [(verts_loc, faces, unique_materials, filename)]
|
|
|
|
|
|
def key_to_name(key):
|
|
# if the key is a tuple, join it to make a string
|
|
if type(key) == tuple:
|
|
return '%s_%s' % key
|
|
elif not key:
|
|
return filename # assume its a string. make sure this is true if the splitting code is changed
|
|
else:
|
|
return key
|
|
|
|
# Return a key that makes the faces unique.
|
|
if SPLIT_OB_OR_GROUP and not SPLIT_MATERIALS:
|
|
def face_key(face):
|
|
return face[4] # object
|
|
|
|
elif not SPLIT_OB_OR_GROUP and SPLIT_MATERIALS:
|
|
def face_key(face):
|
|
return face[2] # material
|
|
|
|
else: # Both
|
|
def face_key(face):
|
|
return face[4], face[2] # object,material
|
|
|
|
|
|
face_split_dict= {}
|
|
|
|
oldkey= -1 # initialize to a value that will never match the key
|
|
|
|
for face in faces:
|
|
|
|
key= face_key(face)
|
|
|
|
if oldkey != key:
|
|
# Check the key has changed.
|
|
try:
|
|
verts_split, faces_split, unique_materials_split, vert_remap= face_split_dict[key]
|
|
except KeyError:
|
|
faces_split= []
|
|
verts_split= []
|
|
unique_materials_split= {}
|
|
vert_remap= [-1]*len(verts_loc)
|
|
|
|
face_split_dict[key]= (verts_split, faces_split, unique_materials_split, vert_remap)
|
|
|
|
oldkey= key
|
|
|
|
face_vert_loc_indicies= face[0]
|
|
|
|
# Remap verts to new vert list and add where needed
|
|
for enum, i in enumerate(face_vert_loc_indicies):
|
|
if vert_remap[i] == -1:
|
|
new_index= len(verts_split)
|
|
vert_remap[i]= new_index # set the new remapped index so we only add once and can reference next time.
|
|
face_vert_loc_indicies[enum] = new_index # remap to the local index
|
|
verts_split.append( verts_loc[i] ) # add the vert to the local verts
|
|
|
|
else:
|
|
face_vert_loc_indicies[enum] = vert_remap[i] # remap to the local index
|
|
|
|
matname= face[2]
|
|
if matname and not unique_materials_split.has_key(matname):
|
|
unique_materials_split[matname] = unique_materials[matname]
|
|
|
|
faces_split.append(face)
|
|
|
|
|
|
# remove one of the itemas and reorder
|
|
return [(value[0], value[1], value[2], key_to_name(key)) for key, value in face_split_dict.iteritems()]
|
|
|
|
|
|
def create_mesh(scn, new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc, verts_tex, faces, unique_materials, unique_material_images, unique_smooth_groups, dataname):
|
|
'''
|
|
Takes all the data gathered and generates a mesh, adding the new object to new_objects
|
|
deals with fgons, sharp edges and assigning materials
|
|
'''
|
|
if not has_ngons:
|
|
CREATE_FGONS= False
|
|
|
|
if unique_smooth_groups:
|
|
sharp_edges= {}
|
|
smooth_group_users= dict([ (context_smooth_group, {}) for context_smooth_group in unique_smooth_groups.iterkeys() ])
|
|
context_smooth_group_old= -1
|
|
|
|
# Split fgons into tri's
|
|
fgon_edges= {} # Used for storing fgon keys
|
|
if CREATE_EDGES:
|
|
edges= []
|
|
|
|
context_object= None
|
|
|
|
# reverse loop through face indicies
|
|
for f_idx in xrange(len(faces)-1, -1, -1):
|
|
|
|
face_vert_loc_indicies,\
|
|
face_vert_tex_indicies,\
|
|
context_material,\
|
|
context_smooth_group,\
|
|
context_object= faces[f_idx]
|
|
|
|
len_face_vert_loc_indicies = len(face_vert_loc_indicies)
|
|
|
|
if len_face_vert_loc_indicies==1:
|
|
faces.pop(f_idx)# cant add single vert faces
|
|
|
|
elif not face_vert_tex_indicies or len_face_vert_loc_indicies == 2: # faces that have no texture coords are lines
|
|
if CREATE_EDGES:
|
|
# generators are better in python 2.4+ but can't be used in 2.3
|
|
# edges.extend( (face_vert_loc_indicies[i], face_vert_loc_indicies[i+1]) for i in xrange(len_face_vert_loc_indicies-1) )
|
|
edges.extend( [(face_vert_loc_indicies[i], face_vert_loc_indicies[i+1]) for i in xrange(len_face_vert_loc_indicies-1)] )
|
|
|
|
faces.pop(f_idx)
|
|
else:
|
|
|
|
# Smooth Group
|
|
if unique_smooth_groups and context_smooth_group:
|
|
# Is a part of of a smooth group and is a face
|
|
if context_smooth_group_old is not context_smooth_group:
|
|
edge_dict= smooth_group_users[context_smooth_group]
|
|
context_smooth_group_old= context_smooth_group
|
|
|
|
for i in xrange(len_face_vert_loc_indicies):
|
|
i1= face_vert_loc_indicies[i]
|
|
i2= face_vert_loc_indicies[i-1]
|
|
if i1>i2: i1,i2= i2,i1
|
|
|
|
try:
|
|
edge_dict[i1,i2]+= 1
|
|
except KeyError:
|
|
edge_dict[i1,i2]= 1
|
|
|
|
# FGons into triangles
|
|
if has_ngons and len_face_vert_loc_indicies > 4:
|
|
|
|
ngon_face_indices= BPyMesh.ngon(verts_loc, face_vert_loc_indicies)
|
|
faces.extend(\
|
|
[(\
|
|
[face_vert_loc_indicies[ngon[0]], face_vert_loc_indicies[ngon[1]], face_vert_loc_indicies[ngon[2]] ],\
|
|
[face_vert_tex_indicies[ngon[0]], face_vert_tex_indicies[ngon[1]], face_vert_tex_indicies[ngon[2]] ],\
|
|
context_material,\
|
|
context_smooth_group,\
|
|
context_object)\
|
|
for ngon in ngon_face_indices]\
|
|
)
|
|
|
|
# edges to make fgons
|
|
if CREATE_FGONS:
|
|
edge_users= {}
|
|
for ngon in ngon_face_indices:
|
|
for i in (0,1,2):
|
|
i1= face_vert_loc_indicies[ngon[i ]]
|
|
i2= face_vert_loc_indicies[ngon[i-1]]
|
|
if i1>i2: i1,i2= i2,i1
|
|
|
|
try:
|
|
edge_users[i1,i2]+=1
|
|
except KeyError:
|
|
edge_users[i1,i2]= 1
|
|
|
|
for key, users in edge_users.iteritems():
|
|
if users>1:
|
|
fgon_edges[key]= None
|
|
|
|
# remove all after 3, means we dont have to pop this one.
|
|
faces.pop(f_idx)
|
|
|
|
|
|
# Build sharp edges
|
|
if unique_smooth_groups:
|
|
for edge_dict in smooth_group_users.itervalues():
|
|
for key, users in edge_dict.iteritems():
|
|
if users==1: # This edge is on the boundry of a group
|
|
sharp_edges[key]= None
|
|
|
|
|
|
# mat the material names to an index
|
|
material_mapping= dict([(name, i) for i, name in enumerate(unique_materials.keys())])
|
|
|
|
materials= [None] * len(unique_materials)
|
|
|
|
for name, index in material_mapping.iteritems():
|
|
materials[index]= unique_materials[name]
|
|
|
|
me= bpy.data.meshes.new(dataname)
|
|
|
|
me.materials= materials[0:16] # make sure the list isnt too big.
|
|
#me.verts.extend([(0,0,0)]) # dummy vert
|
|
me.verts.extend(verts_loc)
|
|
|
|
face_mapping= me.faces.extend([f[0] for f in faces], indexList=True)
|
|
|
|
if verts_tex and me.faces:
|
|
me.faceUV= 1
|
|
# TEXMODE= Mesh.FaceModes['TEX']
|
|
|
|
context_material_old= -1 # avoid a dict lookup
|
|
mat= 0 # rare case it may be un-initialized.
|
|
me_faces= me.faces
|
|
ALPHA= Mesh.FaceTranspModes.ALPHA
|
|
|
|
for i, face in enumerate(faces):
|
|
if len(face[0]) < 2:
|
|
pass #raise "bad face"
|
|
elif len(face[0])==2:
|
|
if CREATE_EDGES:
|
|
edges.append(face[0])
|
|
else:
|
|
face_index_map= face_mapping[i]
|
|
if face_index_map!=None: # None means the face wasnt added
|
|
blender_face= me_faces[face_index_map]
|
|
|
|
face_vert_loc_indicies,\
|
|
face_vert_tex_indicies,\
|
|
context_material,\
|
|
context_smooth_group,\
|
|
context_object= face
|
|
|
|
|
|
|
|
if context_smooth_group:
|
|
blender_face.smooth= True
|
|
|
|
if context_material:
|
|
if context_material_old is not context_material:
|
|
mat= material_mapping[context_material]
|
|
if mat>15:
|
|
mat= 15
|
|
context_material_old= context_material
|
|
|
|
blender_face.mat= mat
|
|
|
|
|
|
if verts_tex:
|
|
if context_material:
|
|
image, has_data= unique_material_images[context_material]
|
|
if image: # Can be none if the material dosnt have an image.
|
|
blender_face.image= image
|
|
if has_data and image.depth == 32:
|
|
blender_face.transp |= ALPHA
|
|
|
|
# BUG - Evil eekadoodle problem where faces that have vert index 0 location at 3 or 4 are shuffled.
|
|
if len(face_vert_loc_indicies)==4:
|
|
if face_vert_loc_indicies[2]==0 or face_vert_loc_indicies[3]==0:
|
|
face_vert_tex_indicies= face_vert_tex_indicies[2], face_vert_tex_indicies[3], face_vert_tex_indicies[0], face_vert_tex_indicies[1]
|
|
else: # length of 3
|
|
if face_vert_loc_indicies[2]==0:
|
|
face_vert_tex_indicies= face_vert_tex_indicies[1], face_vert_tex_indicies[2], face_vert_tex_indicies[0]
|
|
# END EEEKADOODLE FIX
|
|
|
|
# assign material, uv's and image
|
|
for ii, uv in enumerate(blender_face.uv):
|
|
uv.x, uv.y= verts_tex[face_vert_tex_indicies[ii]]
|
|
del me_faces
|
|
del ALPHA
|
|
|
|
# Add edge faces.
|
|
me_edges= me.edges
|
|
if CREATE_FGONS and fgon_edges:
|
|
FGON= Mesh.EdgeFlags.FGON
|
|
for ed in me.findEdges( fgon_edges.keys() ):
|
|
if ed!=None:
|
|
me_edges[ed].flag |= FGON
|
|
del FGON
|
|
|
|
if unique_smooth_groups and sharp_edges:
|
|
SHARP= Mesh.EdgeFlags.SHARP
|
|
for ed in me.findEdges( sharp_edges.keys() ):
|
|
if ed!=None:
|
|
me_edges[ed].flag |= SHARP
|
|
del SHARP
|
|
|
|
if CREATE_EDGES:
|
|
me_edges.extend( edges )
|
|
|
|
del me_edges
|
|
|
|
me.calcNormals()
|
|
|
|
ob= scn.objects.new(me)
|
|
new_objects.append(ob)
|
|
|
|
def get_float_func(filepath):
|
|
'''
|
|
find the float function for this obj file
|
|
- weather to replace commas or not
|
|
'''
|
|
file= open(filepath, 'rU')
|
|
for line in file: #.xreadlines():
|
|
if line.startswith('v'): # vn vt v
|
|
if ',' in line:
|
|
return lambda f: float(f.replace(',', '.'))
|
|
elif '.' in line:
|
|
return float
|
|
|
|
# incase all vert values were ints
|
|
return float
|
|
|
|
def load_obj(filepath, CLAMP_SIZE= 0.0, CREATE_FGONS= True, CREATE_SMOOTH_GROUPS= True, CREATE_EDGES= True, SPLIT_OBJECTS= True, SPLIT_GROUPS= True, SPLIT_MATERIALS= True, IMAGE_SEARCH=True):
|
|
'''
|
|
Called by the user interface or another script.
|
|
load_obj(path) - should give acceptable results.
|
|
This function passes the file and sends the data off
|
|
to be split into objects and then converted into mesh objects
|
|
'''
|
|
print '\nimporting obj "%s"' % filepath
|
|
|
|
time_main= sys.time()
|
|
|
|
verts_loc= []
|
|
verts_tex= []
|
|
faces= [] # tuples of the faces
|
|
material_libs= [] # filanems to material libs this uses
|
|
|
|
|
|
# Get the string to float conversion func for this file- is 'float' for almost all files.
|
|
float_func= get_float_func(filepath)
|
|
|
|
# Context variables
|
|
context_material= None
|
|
context_smooth_group= None
|
|
context_object= None
|
|
|
|
has_ngons= False
|
|
# has_smoothgroups= False - is explicit with len(unique_smooth_groups) being > 0
|
|
|
|
# Until we can use sets
|
|
unique_materials= {}
|
|
unique_material_images= {}
|
|
unique_smooth_groups= {}
|
|
# unique_obects= {} - no use for this variable since the objects are stored in the face.
|
|
|
|
# when there are faces that end with \
|
|
# it means they are multiline-
|
|
# since we use xreadline we cant skip to the next line
|
|
# so we need to know weather
|
|
multi_line_face= False
|
|
|
|
print '\tpassing obj file "%s"...' % filepath,
|
|
time_sub= sys.time()
|
|
file= open(filepath, 'r')
|
|
for line in file: #.xreadlines():
|
|
|
|
if line.startswith('v '):
|
|
line_split= line.split()
|
|
# rotate X90: (x,-z,y)
|
|
verts_loc.append( (float_func(line_split[1]), -float_func(line_split[3]), float_func(line_split[2])) )
|
|
|
|
elif line.startswith('vn '):
|
|
pass
|
|
|
|
elif line.startswith('vt '):
|
|
line_split= line.split()
|
|
verts_tex.append( (float_func(line_split[1]), float_func(line_split[2])) )
|
|
|
|
# Handel faces lines (as faces) and the second+ lines of fa multiline face here
|
|
# use 'f' not 'f ' because some objs (very rare have 'fo ' for faces)
|
|
elif line.startswith('f') or (line.startswith('l ') and CREATE_EDGES) or multi_line_face:
|
|
|
|
if multi_line_face:
|
|
# use face_vert_loc_indicies and face_vert_tex_indicies previously defined and used the obj_face
|
|
line_split= line.split()
|
|
multi_line_face= False
|
|
|
|
else:
|
|
line_split= line[2:].split()
|
|
face_vert_loc_indicies= []
|
|
face_vert_tex_indicies= []
|
|
|
|
# Instance a face
|
|
faces.append((\
|
|
face_vert_loc_indicies,\
|
|
face_vert_tex_indicies,\
|
|
context_material,\
|
|
context_smooth_group,\
|
|
context_object\
|
|
))
|
|
|
|
if line_split[-1][-1]== '\\':
|
|
multi_line_face= True
|
|
if len(line_split[-1])==1:
|
|
line_split.pop() # remove the \ item
|
|
else:
|
|
line_split[-1]= line_split[-1][:-1] # remove the \ from the end last number
|
|
|
|
isline= line.startswith('l')
|
|
|
|
for v in line_split:
|
|
obj_vert= v.split('/')
|
|
|
|
vert_loc_index= int(obj_vert[0])-1
|
|
|
|
# Make relative negative vert indicies absolute
|
|
if vert_loc_index < 0:
|
|
vert_loc_index= len(verts_loc) + vert_loc_index + 1
|
|
|
|
face_vert_loc_indicies.append(vert_loc_index)
|
|
|
|
if not isline:
|
|
if len(obj_vert)>1 and obj_vert[1]:
|
|
# formatting for faces with normals and textures us
|
|
# loc_index/tex_index/nor_index
|
|
|
|
vert_tex_index= int(obj_vert[1])-1
|
|
# Make relative negative vert indicies absolute
|
|
if vert_tex_index < 0:
|
|
vert_tex_index= len(verts_tex) + vert_tex_index + 1
|
|
|
|
face_vert_tex_indicies.append(vert_tex_index)
|
|
else:
|
|
# dummy
|
|
face_vert_tex_indicies.append(0)
|
|
|
|
if len(face_vert_loc_indicies) > 4:
|
|
has_ngons= True
|
|
|
|
elif line.startswith('s'):
|
|
if CREATE_SMOOTH_GROUPS:
|
|
context_smooth_group= line_value(line.split())
|
|
if context_smooth_group=='off':
|
|
context_smooth_group= None
|
|
elif context_smooth_group: # is not None
|
|
unique_smooth_groups[context_smooth_group]= None
|
|
|
|
elif line.startswith('o'):
|
|
if SPLIT_OBJECTS:
|
|
context_object= line_value(line.split())
|
|
# unique_obects[context_object]= None
|
|
|
|
elif line.startswith('g'):
|
|
if SPLIT_GROUPS:
|
|
context_object= line_value(line.split())
|
|
# print 'context_object', context_object
|
|
# unique_obects[context_object]= None
|
|
|
|
elif line.startswith('usemtl'):
|
|
context_material= line_value(line.split())
|
|
unique_materials[context_material]= None
|
|
elif line.startswith('mtllib'): # usemap or usemat
|
|
material_libs.extend( line.split()[1:] ) # can have multiple mtllib filenames per line
|
|
|
|
''' # How to use usemap? depricated?
|
|
elif line.startswith('usema'): # usemap or usemat
|
|
context_image= line_value(line.split())
|
|
'''
|
|
|
|
file.close()
|
|
time_new= sys.time()
|
|
print '%.4f sec' % (time_new-time_sub)
|
|
time_sub= time_new
|
|
|
|
|
|
print '\tloading materials and images...',
|
|
create_materials(filepath, material_libs, unique_materials, unique_material_images, IMAGE_SEARCH)
|
|
|
|
time_new= sys.time()
|
|
print '%.4f sec' % (time_new-time_sub)
|
|
time_sub= time_new
|
|
|
|
|
|
# deselect all
|
|
scn = bpy.data.scenes.active
|
|
scn.objects.selected = []
|
|
new_objects= [] # put new objects here
|
|
|
|
print '\tbuilding geometry...\n\tverts:%i faces:%i materials: %i smoothgroups:%i ...' % ( len(verts_loc), len(faces), len(unique_materials), len(unique_smooth_groups) ),
|
|
# Split the mesh by objects/materials, may
|
|
if SPLIT_OBJECTS or SPLIT_GROUPS: SPLIT_OB_OR_GROUP = True
|
|
else: SPLIT_OB_OR_GROUP = False
|
|
|
|
for verts_loc_split, faces_split, unique_materials_split, dataname in split_mesh(verts_loc, faces, unique_materials, filepath, SPLIT_OB_OR_GROUP, SPLIT_MATERIALS):
|
|
# Create meshes from the data
|
|
create_mesh(scn, new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc_split, verts_tex, faces_split, unique_materials_split, unique_material_images, unique_smooth_groups, dataname)
|
|
|
|
axis_min= [ 1000000000]*3
|
|
axis_max= [-1000000000]*3
|
|
|
|
if CLAMP_SIZE:
|
|
# Get all object bounds
|
|
for ob in new_objects:
|
|
for v in ob.getBoundBox():
|
|
for axis, value in enumerate(v):
|
|
if axis_min[axis] > value: axis_min[axis]= value
|
|
if axis_max[axis] < value: axis_max[axis]= value
|
|
|
|
# Scale objects
|
|
max_axis= max(axis_max[0]-axis_min[0], axis_max[1]-axis_min[1], axis_max[2]-axis_min[2])
|
|
scale= 1.0
|
|
|
|
while CLAMP_SIZE < max_axis * scale:
|
|
scale= scale/10.0
|
|
|
|
for ob in new_objects:
|
|
ob.setSize(scale, scale, scale)
|
|
|
|
time_new= sys.time()
|
|
|
|
print '%.4f sec' % (time_new-time_sub)
|
|
print 'finished importing: "%s" in %.4f sec.' % (filepath, (time_new-time_main))
|
|
|
|
|
|
DEBUG= True
|
|
|
|
|
|
def load_obj_ui(filepath, BATCH_LOAD= False):
|
|
if BPyMessages.Error_NoFile(filepath):
|
|
return
|
|
|
|
|
|
CREATE_SMOOTH_GROUPS= Draw.Create(0)
|
|
CREATE_FGONS= Draw.Create(1)
|
|
CREATE_EDGES= Draw.Create(1)
|
|
SPLIT_OBJECTS= Draw.Create(1)
|
|
SPLIT_GROUPS= Draw.Create(1)
|
|
SPLIT_MATERIALS= Draw.Create(1)
|
|
MORPH_TARGET= Draw.Create(0)
|
|
CLAMP_SIZE= Draw.Create(10.0)
|
|
IMAGE_SEARCH= Draw.Create(1)
|
|
|
|
|
|
# Get USER Options
|
|
pup_block= [\
|
|
'Import...',\
|
|
('Smooth Groups', CREATE_SMOOTH_GROUPS, 'Surround smooth groups by sharp edges'),\
|
|
('Create FGons', CREATE_FGONS, 'Import faces with more then 4 verts as fgons.'),\
|
|
('Lines', CREATE_EDGES, 'Import lines and faces with 2 verts as edges'),\
|
|
'Separate objects from obj...',\
|
|
('Object', SPLIT_OBJECTS, 'Import OBJ Objects into Blender Objects'),\
|
|
('Group', SPLIT_GROUPS, 'Import OBJ Groups into Blender Objects'),\
|
|
('Material', SPLIT_MATERIALS, 'Import each material into a seperate mesh (Avoids > 16 per mesh error)'),\
|
|
'Options...',\
|
|
('Morph Target', MORPH_TARGET, 'Keep vert and face order, disables some other options.'),\
|
|
('Clamp Scale:', CLAMP_SIZE, 0.0, 1000.0, 'Clamp the size to this maximum (Zero to Disable)'),\
|
|
('Image Search', IMAGE_SEARCH, 'Search subdirs for any assosiated images (Warning, may be slow)'),\
|
|
]
|
|
|
|
if not Draw.PupBlock('Import OBJ...', pup_block):
|
|
return
|
|
|
|
if MORPH_TARGET.val:
|
|
SPLIT_OBJECTS.val = False
|
|
SPLIT_GROUPS.val = False
|
|
SPLIT_MATERIALS.val = False
|
|
|
|
Window.WaitCursor(1)
|
|
|
|
if BATCH_LOAD: # load the dir
|
|
try:
|
|
files= [ f for f in os.listdir(filepath) if f.lower().endswith('.obj') ]
|
|
except:
|
|
Window.WaitCursor(0)
|
|
Draw.PupMenu('Error%t|Could not open path ' + filepath)
|
|
return
|
|
|
|
if not files:
|
|
Window.WaitCursor(0)
|
|
Draw.PupMenu('Error%t|No files at path ' + filepath)
|
|
return
|
|
|
|
for f in files:
|
|
scn= bpy.data.scenes.new( stripExt(f) )
|
|
scn.makeCurrent()
|
|
|
|
load_obj(sys.join(filepath, f),\
|
|
CLAMP_SIZE.val,\
|
|
CREATE_FGONS.val,\
|
|
CREATE_SMOOTH_GROUPS.val,\
|
|
CREATE_EDGES.val,\
|
|
SPLIT_OBJECTS.val,\
|
|
SPLIT_GROUPS.val,\
|
|
SPLIT_MATERIALS.val,\
|
|
IMAGE_SEARCH.val,\
|
|
)
|
|
|
|
else: # Normal load
|
|
load_obj(filepath,\
|
|
CLAMP_SIZE.val,\
|
|
CREATE_FGONS.val,\
|
|
CREATE_SMOOTH_GROUPS.val,\
|
|
CREATE_EDGES.val,\
|
|
SPLIT_OBJECTS.val,\
|
|
SPLIT_GROUPS.val,\
|
|
SPLIT_MATERIALS.val,\
|
|
IMAGE_SEARCH.val,\
|
|
)
|
|
|
|
Window.WaitCursor(0)
|
|
|
|
|
|
def load_obj_ui_batch(file):
|
|
load_obj_ui(file, True)
|
|
|
|
DEBUG= False
|
|
|
|
if __name__=='__main__' and not DEBUG:
|
|
if os and Window.GetKeyQualifiers() & Window.Qual.SHIFT:
|
|
Window.FileSelector(load_obj_ui_batch, 'Import OBJ Dir', '')
|
|
else:
|
|
Window.FileSelector(load_obj_ui, 'Import a Wavefront OBJ', '*.obj')
|
|
|
|
|
|
'''
|
|
# For testing compatibility
|
|
else:
|
|
# DEBUG ONLY
|
|
TIME= sys.time()
|
|
import os
|
|
print 'Searching for files'
|
|
os.system('find /fe/obj -iname "*.obj" > /tmp/temp3ds_list')
|
|
|
|
print '...Done'
|
|
file= open('/tmp/temp3ds_list', 'r')
|
|
lines= file.readlines()
|
|
file.close()
|
|
|
|
def between(v,a,b):
|
|
if v <= max(a,b) and v >= min(a,b):
|
|
return True
|
|
return False
|
|
|
|
for i, _obj in enumerate(lines):
|
|
if between(i, 0,20):
|
|
_obj= _obj[:-1]
|
|
print 'Importing', _obj, '\nNUMBER', i, 'of', len(lines)
|
|
_obj_file= _obj.split('/')[-1].split('\\')[-1]
|
|
newScn= bpy.data.scenes.new(_obj_file)
|
|
newScn.makeCurrent()
|
|
load_obj(_obj, False)
|
|
|
|
print 'TOTAL TIME: %.6f' % (sys.time() - TIME)
|
|
'''
|
|
#load_obj('/test.obj')
|
|
#load_obj('/fe/obj/mba1.obj')
|