forked from bartvdbraak/blender
971 lines
32 KiB
Python
971 lines
32 KiB
Python
#!BPY
|
|
|
|
"""
|
|
Name: 'Wavefront (.obj)...'
|
|
Blender: 237
|
|
Group: 'Import'
|
|
Tooltip: 'Load a Wavefront OBJ File, Shift: batch import all dir.'
|
|
"""
|
|
|
|
__author__= "Campbell Barton"
|
|
__url__= ["blender", "elysiun"]
|
|
__version__= "1.0"
|
|
|
|
__bpydoc__= """\
|
|
This script imports OBJ files to Blender.
|
|
|
|
Usage:
|
|
|
|
Run this script from "File->Import" menu and then load the desired OBJ file.
|
|
"""
|
|
|
|
# $Id$
|
|
#
|
|
# --------------------------------------------------------------------------
|
|
# OBJ Import v1.0 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 *****
|
|
# --------------------------------------------------------------------------
|
|
|
|
|
|
#==============================================#
|
|
# Return directory, where the file is #
|
|
#==============================================#
|
|
def stripFile(path):
|
|
lastSlash= max(path.rfind('\\'), path.rfind('/'))
|
|
if lastSlash != -1:
|
|
path= path[:lastSlash]
|
|
return '%s%s' % (path, sys.sep)
|
|
|
|
#==============================================#
|
|
# Strips the slashes from the back of a string #
|
|
#==============================================#
|
|
def stripPath(path):
|
|
return path.split('/')[-1].split('\\')[-1]
|
|
|
|
#====================================================#
|
|
# Strips the prefix off the name before writing #
|
|
#====================================================#
|
|
def stripExt(name): # name is a string
|
|
index= name.rfind('.')
|
|
if index != -1:
|
|
return name[ : index ]
|
|
else:
|
|
return name
|
|
|
|
|
|
from Blender import *
|
|
import BPyImage # use for comprehensiveImageLoad
|
|
import BPyMesh # use for ngon
|
|
|
|
try:
|
|
import os
|
|
except:
|
|
# So we know if os exists.
|
|
print 'Module "os" not found, install python to enable comprehensive image finding and batch loading.'
|
|
os= None
|
|
|
|
|
|
#==================================================================================#
|
|
# This function sets textures defined in .mtl file #
|
|
#==================================================================================#
|
|
def loadMaterialImage(mat, img_fileName, type, meshDict, dir):
|
|
TEX_ON_FLAG= NMesh.FaceModes['TEX']
|
|
|
|
texture= Texture.New(type)
|
|
texture.setType('Image')
|
|
|
|
# Absolute path - c:\.. etc would work here
|
|
image= BPyImage.comprehensiveImageLoad(img_fileName, dir)
|
|
|
|
if image:
|
|
texture.image= image
|
|
|
|
# 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.
|
|
if image and type == 'Kd':
|
|
for meshPair in meshDict.itervalues():
|
|
for f in meshPair[0].faces:
|
|
#print meshPair[0].materials[f.mat].name, mat.name
|
|
if meshPair[0].materials[f.mat].name == mat.name:
|
|
# the inline usemat command overides the material Image
|
|
if not f.image:
|
|
f.mode |= TEX_ON_FLAG
|
|
f.image= image
|
|
|
|
# adds textures for materials (rendering)
|
|
elif type == 'Ka':
|
|
mat.setTexture(0, texture, Texture.TexCo.UV, Texture.MapTo.CMIR) # TODO- Add AMB to BPY API
|
|
elif type == 'Kd':
|
|
mat.setTexture(1, texture, Texture.TexCo.UV, Texture.MapTo.COL)
|
|
elif type == 'Ks':
|
|
mat.setTexture(2, texture, Texture.TexCo.UV, Texture.MapTo.SPEC)
|
|
|
|
elif type == 'Bump': # New Additions
|
|
mat.setTexture(3, texture, Texture.TexCo.UV, Texture.MapTo.NOR)
|
|
elif type == 'D':
|
|
mat.setTexture(4, texture, Texture.TexCo.UV, Texture.MapTo.ALPHA)
|
|
elif type == 'refl':
|
|
mat.setTexture(5, texture, Texture.TexCo.UV, Texture.MapTo.REF)
|
|
|
|
|
|
#===============================================================================#
|
|
# This gets a mat or creates one of the requested name if none exist. #
|
|
#===============================================================================#
|
|
def getMat(matName, materialDict):
|
|
# Make a new mat
|
|
try: return materialDict[matName]
|
|
except: pass # Better do any exception
|
|
|
|
try: return materialDict[matName.lower()]
|
|
except: pass
|
|
|
|
# Do we realy need to keep the dict up to date?, not realy but keeps consuistant.
|
|
mat= materialDict[matName]= Material.New(matName)
|
|
return mat
|
|
|
|
|
|
#==================================================================================#
|
|
# This function loads materials from .mtl file (have to be defined in obj file) #
|
|
#==================================================================================#
|
|
def load_mtl(dir, IMPORT_USE_EXISTING_MTL, mtl_file, meshDict, materialDict):
|
|
|
|
mtl_file= stripPath(mtl_file)
|
|
mtl_fileName= dir + mtl_file
|
|
|
|
try:
|
|
fileLines= open(mtl_fileName, 'r').readlines()
|
|
except IOError:
|
|
print '\tunable to open referenced material file: "%s"' % mtl_fileName
|
|
return
|
|
|
|
try:
|
|
lIdx=0
|
|
while lIdx < len(fileLines):
|
|
l= fileLines[lIdx].split()
|
|
|
|
# Detect a line that will be ignored
|
|
if len(l) == 0 or l[0].startswith('#'):
|
|
pass
|
|
elif l[0] == 'newmtl':
|
|
currentMat= getMat('_'.join(l[1:]), materialDict) # Material should alredy exist.
|
|
elif l[0] == 'Ka':
|
|
currentMat.setMirCol((float(l[1]), float(l[2]), float(l[3])))
|
|
elif l[0] == 'Kd':
|
|
currentMat.setRGBCol((float(l[1]), float(l[2]), float(l[3])))
|
|
elif l[0] == 'Ks':
|
|
currentMat.setSpecCol((float(l[1]), float(l[2]), float(l[3])))
|
|
elif l[0] == 'Ns':
|
|
currentMat.setHardness( int((float(l[1])*0.51)) )
|
|
elif l[0] == 'Ni': # Refraction index
|
|
currentMat.setIOR( max(1, min(float(l[1]), 3))) # Between 1 and 3
|
|
elif l[0] == 'd':
|
|
currentMat.setAlpha(float(l[1]))
|
|
elif l[0] == 'Tr':
|
|
currentMat.setAlpha(float(l[1]))
|
|
elif l[0] == 'map_Ka':
|
|
img_fileName= ' '.join(l[1:])
|
|
loadMaterialImage(currentMat, img_fileName, 'Ka', meshDict, dir)
|
|
elif l[0] == 'map_Ks':
|
|
img_fileName= ' '.join(l[1:])
|
|
loadMaterialImage(currentMat, img_fileName, 'Ks', meshDict, dir)
|
|
elif l[0] == 'map_Kd':
|
|
img_fileName= ' '.join(l[1:])
|
|
loadMaterialImage(currentMat, img_fileName, 'Kd', meshDict, dir)
|
|
|
|
# new additions
|
|
elif l[0] == 'map_Bump': # Bumpmap
|
|
img_fileName= ' '.join(l[1:])
|
|
loadMaterialImage(currentMat, img_fileName, 'Bump', meshDict, dir)
|
|
elif l[0] == 'map_D': # Alpha map - Dissolve
|
|
img_fileName= ' '.join(l[1:])
|
|
loadMaterialImage(currentMat, img_fileName, 'D', meshDict, dir)
|
|
|
|
elif l[0] == 'refl': # Reflectionmap
|
|
img_fileName= ' '.join(l[1:])
|
|
loadMaterialImage(currentMat, img_fileName, 'refl', meshDict, dir)
|
|
|
|
lIdx+=1
|
|
except:
|
|
print '\tERROR: Unable to parse MTL file: "%s"' % mtl_file
|
|
return
|
|
print '\tUsing MTL: "%s"' % mtl_file
|
|
|
|
#==================================================================================#
|
|
# This loads data from .obj file #
|
|
#==================================================================================#
|
|
def load_obj(\
|
|
file,\
|
|
IMPORT_MTL=1,\
|
|
IMPORT_USE_EXISTING_MTL=0,\
|
|
IMPORT_CONSTRAIN_BOUNDS=0.0,\
|
|
IMPORT_ROTATE_X90=0,\
|
|
IMPORT_EDGES=1,\
|
|
IMPORT_SMOOTH_ALL=0,\
|
|
IMPORT_FGON=1,\
|
|
IMPORT_SMOOTH_GROUPS=0,\
|
|
IMPORT_MTL_SPLIT=0,\
|
|
IMPORT_AS_INSTANCE=0):
|
|
|
|
global currentMesh,\
|
|
currentUsedVertList,\
|
|
currentUsedVertListSmoothGroup,\
|
|
meshDict,\
|
|
contextMeshMatIdx,\
|
|
currentMaterialMeshMapping
|
|
|
|
print '\nImporting OBJ file: "%s"' % file
|
|
|
|
time1= sys.time()
|
|
|
|
# Deselect all objects in the scene.
|
|
# do this first so we dont have to bother, with objects we import
|
|
for ob in Scene.GetCurrent().getChildren():
|
|
ob.sel= 0
|
|
|
|
TEX_OFF_FLAG= ~NMesh.FaceModes['TEX']
|
|
|
|
# Used for bounds scaling
|
|
global BOUNDS
|
|
BOUNDS= 0.0
|
|
|
|
# Get the file name with no path or .obj
|
|
fileName= stripExt( stripPath(file) )
|
|
|
|
mtl_fileName= [] # Support multiple mtl files if needed.
|
|
|
|
DIR= stripFile(file)
|
|
|
|
tempFile= open(file, 'r')
|
|
fileLines= tempFile.readlines()
|
|
tempFile.close()
|
|
del tempFile
|
|
uvMapList= [] # store tuple uv pairs here
|
|
|
|
# This dummy vert makes life a whole lot easier-
|
|
# pythons index system then aligns with objs, remove later
|
|
vertList= [] # Could havea vert but since this is a placeholder theres no Point
|
|
|
|
|
|
# Store all imported images in a dict, names are key
|
|
imageDict= {}
|
|
|
|
# This stores the index that the current mesh has for the current material.
|
|
# if the mesh does not have the material then set -1
|
|
contextMeshMatIdx= -1
|
|
|
|
|
|
currentImg= None # Null image is a string, otherwise this should be set to an image object.\
|
|
if IMPORT_SMOOTH_ALL:
|
|
currentSmooth= True
|
|
else:
|
|
currentSmooth= False
|
|
|
|
# Store a list of unnamed names
|
|
currentUnnamedGroupIdx= 1
|
|
currentUnnamedObjectIdx= 1
|
|
|
|
quadList= (0, 1, 2, 3)
|
|
|
|
faceQuadVList= [None, None, None, None]
|
|
faceTriVList= [None, None, None]
|
|
|
|
#==================================================================================#
|
|
# Load all verts first (texture verts too) #
|
|
#==================================================================================#
|
|
print '\tfile length: %d' % len(fileLines)
|
|
# Ignore normals and comments.
|
|
fileLines= [lsplit for l in fileLines if not l.startswith('vn') if not l.startswith('#') for lsplit in (l.split(),) if lsplit]
|
|
|
|
|
|
if IMPORT_CONSTRAIN_BOUNDS == 0.0:
|
|
if IMPORT_ROTATE_X90:
|
|
def Vert(x,y,z):
|
|
return NMesh.Vert(x,-z,y) # rotate 90 about the x axis.
|
|
else:
|
|
Vert= NMesh.Vert
|
|
else:
|
|
# Adding a vert also sets the bounds.
|
|
if IMPORT_ROTATE_X90:
|
|
def Vert(x,y,z):
|
|
global BOUNDS
|
|
BOUNDS= max(BOUNDS, x,y,z)
|
|
return NMesh.Vert(x,-z,y) # Rotate X90 Deg.
|
|
else:
|
|
def Vert(x,y,z):
|
|
global BOUNDS
|
|
BOUNDS= max(BOUNDS, x,y,z)
|
|
return NMesh.Vert(x,y,z)
|
|
|
|
try:
|
|
vertList= [Vert(float(l[1]), float(l[2]), float(l[3]) ) for l in fileLines if l[0] == 'v']
|
|
except ValueError:
|
|
# What??? Maya 7 uses "6,45" instead of "6.45"
|
|
vertList= [Vert(float(l[1].replace(',', '.')), float(l[2].replace(',', '.')), float(l[3].replace(',', '.')) ) for l in fileLines if l[0] == 'v']
|
|
|
|
|
|
try:
|
|
uvMapList= [(float(l[1]), float(l[2])) for l in fileLines if l[0] == 'vt']
|
|
except ValueError:
|
|
# Same amazement as above. call that a float?
|
|
uvMapList= [(float(l[1].replace(',', '.')), float(l[2].replace(',', '.'))) for l in fileLines if l[0] == 'vt']
|
|
|
|
if IMPORT_SMOOTH_GROUPS:
|
|
smoothingGroups= dict([('_'.join(l[1:]), None) for l in fileLines if l[0] == 's' ])
|
|
else:
|
|
smoothingGroups= {}
|
|
|
|
print '\tvert:%i texverts:%i smoothgroups:%i' % (len(vertList), len(uvMapList), len(smoothingGroups))
|
|
|
|
# Replace filelines, Excluding v excludes "v ", "vn " and "vt "
|
|
# Remove any variables we may have created.
|
|
try: del _dummy
|
|
except: pass
|
|
try: del _x
|
|
except: pass
|
|
try: del _y
|
|
except: pass
|
|
try: del _z
|
|
except: pass
|
|
try: del lsplit
|
|
except: pass
|
|
del Vert
|
|
|
|
|
|
# With negative values this is used a lot. make faster access.
|
|
len_uvMapList= len(uvMapList)
|
|
len_vertList= len(vertList)
|
|
|
|
# Only want unique keys anyway
|
|
smoothingGroups['(null)']= None # Make sure we have at least 1.
|
|
smoothingGroups= smoothingGroups.keys()
|
|
|
|
|
|
# Add materials to Blender for later is in teh OBJ
|
|
|
|
# Keep this out of the dict for easy accsess.
|
|
if IMPORT_MTL:
|
|
materialDict= {}
|
|
|
|
if IMPORT_USE_EXISTING_MTL:
|
|
# Add existing materials to the dict./
|
|
for mat in Material.Get():
|
|
mat_name= mat.name.lower()
|
|
|
|
# Try add the name without the .001
|
|
if\
|
|
len(mat_name)>4 and\
|
|
mat_name[-4]=='.' and\
|
|
mat_name[-3:].isdigit():
|
|
materialDict[mat_name[-4:]]= mat
|
|
|
|
# Add the lower name
|
|
materialDict[mat_name]= mat
|
|
|
|
currentMat= nullMat= getMat('(null)', materialDict)
|
|
# Add all new materials allong the way...
|
|
|
|
|
|
# Make a list of all unused vert indices that we can copy from
|
|
VERT_USED_LIST= [-1]*len_vertList
|
|
|
|
# Here we store a boolean list of which verts are used or not
|
|
# no we know weather to add them to the current mesh
|
|
# This is an issue with global vertex indices being translated to per mesh indices
|
|
# like blenders, we start with a dummy just like the vert.
|
|
# -1 means unused, any other value refers to the local mesh index of the vert.
|
|
|
|
# currentObjectName has a char in front of it that determins weather its a group or object.
|
|
# We ignore it when naming the object.
|
|
currentObjectName= 'unnamed_obj_0' # If we cant get one, use this
|
|
|
|
if IMPORT_MTL_SPLIT:
|
|
currentObjectName_real= currentObjectName
|
|
|
|
#meshDict= {} # The 3 variables below are stored in a tuple within this dict for each mesh
|
|
currentMesh= NMesh.GetRaw() # The NMesh representation of the OBJ group/Object
|
|
#currentUsedVertList= {} # A Dict of smooth groups, each smooth group has a list of used verts and they are generated on demand so as to save memory.
|
|
currentMaterialMeshMapping= {} # Used to store material indices so we dont have to search the mesh for materials every time.
|
|
|
|
# Every mesh has a null smooth group, this is used if there are no smooth groups in the OBJ file.
|
|
# and when for faces where no smooth group is used.
|
|
currentSmoothGroup= '(null)' # The Name of the current smooth group
|
|
|
|
# For direct accsess to the Current Meshes, Current Smooth Groups- Used verts.
|
|
# This is of course context based and changes on the fly.
|
|
# Set the initial '(null)' Smooth group, every mesh has one.
|
|
currentUsedVertListSmoothGroup= VERT_USED_LIST[:]
|
|
currentUsedVertList= {currentSmoothGroup: currentUsedVertListSmoothGroup }
|
|
|
|
# 0:NMesh, 1:SmoothGroups[UsedVerts[0,0,0,0]], 2:materialMapping['matname':matIndexForThisNMesh]
|
|
meshDict= {currentObjectName: (currentMesh, currentUsedVertList, currentMaterialMeshMapping) }
|
|
|
|
# Only show the bad uv error once
|
|
badObjUvs= 0
|
|
badObjFaceVerts= 0
|
|
badObjFaceTexCo= 0
|
|
|
|
|
|
#currentMesh.verts.append(vertList[0]) # So we can sync with OBJ indices where 1 is the first item.
|
|
if len_uvMapList > 1:
|
|
currentMesh.hasFaceUV(1) # Turn UV's on if we have ANY texture coords in this obj file.
|
|
|
|
|
|
|
|
# Heres the code that gets a mesh, creating a new one if needed.
|
|
# may_exist is used to avoid a dict looup.
|
|
# if the mesh is unnamed then we generate a new name and dont bother looking
|
|
# to see if its alredy there.
|
|
def obj_getmesh(may_exist):
|
|
global currentMesh,\
|
|
currentUsedVertList,\
|
|
currentUsedVertListSmoothGroup,\
|
|
meshDict,\
|
|
contextMeshMatIdx,\
|
|
currentMaterialMeshMapping
|
|
|
|
#print 'getting mesh,', currentObjectName
|
|
|
|
# If we havnt written to this mesh before then do so.
|
|
# if we have then we'll just keep appending to it, this is required for soem files.
|
|
|
|
# If we are new, or we are not yet in the list of added meshes
|
|
# then make us new mesh.
|
|
if (not may_exist) or (not meshDict.has_key(currentObjectName)):
|
|
currentMesh= NMesh.GetRaw()
|
|
|
|
currentUsedVertList= {}
|
|
|
|
# SmoothGroup is a string
|
|
########currentSmoothGroup= '(null)' # From examplesm changing the g/o shouldent change the smooth group.
|
|
currentUsedVertList[currentSmoothGroup]= currentUsedVertListSmoothGroup= VERT_USED_LIST[:]
|
|
|
|
currentMaterialMeshMapping= {}
|
|
meshDict[currentObjectName]= (currentMesh, currentUsedVertList, currentMaterialMeshMapping)
|
|
currentMesh.hasFaceUV(1)
|
|
contextMeshMatIdx= -1
|
|
|
|
else:
|
|
# Since we have this in Blender then we will check if the current Mesh has the material.
|
|
# set the contextMeshMatIdx to the meshs index but only if we have it.
|
|
currentMesh, currentUsedVertList, currentMaterialMeshMapping= meshDict[currentObjectName]
|
|
#getMeshMaterialIndex(currentMesh, currentMat)
|
|
|
|
if IMPORT_MTL:
|
|
try:
|
|
contextMeshMatIdx= currentMaterialMeshMapping[currentMat.name] #getMeshMaterialIndex(currentMesh, currentMat)
|
|
except KeyError:
|
|
contextMeshMatIdx -1
|
|
|
|
# For new meshes switch smoothing groups to null
|
|
########currentSmoothGroup= '(null)' # From examplesm changing the g/o shouldent change the smooth group.
|
|
try:
|
|
currentUsedVertListSmoothGroup= currentUsedVertList[currentSmoothGroup]
|
|
except:
|
|
currentUsedVertList[currentSmoothGroup]= currentUsedVertListSmoothGroup= VERT_USED_LIST[:]
|
|
|
|
|
|
|
|
|
|
#==================================================================================#
|
|
# Load all faces into objects, main loop #
|
|
#==================================================================================#
|
|
lIdx= 0
|
|
EDGE_FGON_FLAG= NMesh.EdgeFlags['FGON']
|
|
EDGE_DRAW_FLAG= NMesh.EdgeFlags['EDGEDRAW']
|
|
|
|
REL_VERT_COUNT= REL_TVERT_COUNT=0
|
|
|
|
while lIdx < len(fileLines):
|
|
l= fileLines[lIdx]
|
|
#for l in fileLines:
|
|
if len(l) == 0:
|
|
continue
|
|
# FACE
|
|
elif l[0] == 'v':
|
|
REL_VERT_COUNT+=1
|
|
elif l[0] == 'vt':
|
|
REL_TVERT_COUNT+=1
|
|
|
|
elif l[0] == 'f' or l[0] == 'fo': # fo is not standard. saw it used once.
|
|
# Make a face with the correct material.
|
|
# Add material to mesh
|
|
if IMPORT_MTL:
|
|
if contextMeshMatIdx == -1:
|
|
tmpMatLs= currentMesh.materials
|
|
if len(tmpMatLs) == 16:
|
|
contextMeshMatIdx= 0 # Use first material
|
|
print 'material overflow, attempting to use > 16 materials. defaulting to first.'
|
|
else:
|
|
contextMeshMatIdx= len(tmpMatLs)
|
|
currentMaterialMeshMapping[currentMat.name]= contextMeshMatIdx
|
|
currentMesh.addMaterial(currentMat)
|
|
|
|
# Set up vIdxLs : Verts
|
|
# Set up vtIdxLs : UV
|
|
# Start with a dummy objects so python accepts OBJs 1 is the first index.
|
|
vIdxLs= []
|
|
vtIdxLs= []
|
|
|
|
fHasUV= len_uvMapList # Assume the face has a UV until it sho it dosent, if there are no UV coords then this will start as 0.
|
|
|
|
# Support stupid multiline faces
|
|
# not an obj spec but some objs exist that do this.
|
|
# f 1 2 3 \
|
|
# 4 5 6 \
|
|
# ..... instead of the more common and sane.
|
|
# f 1 2 3 4 5 6
|
|
#
|
|
# later lines are not modified, just skepped by advancing "lIdx"
|
|
while l[-1] == '\\':
|
|
l.pop()
|
|
lIdx+=1
|
|
l.extend(fileLines[lIdx])
|
|
# Done supporting crappy obj faces over multiple lines.
|
|
|
|
|
|
for v in l:
|
|
if not v.startswith('f'): # Only the first v will be f, any better ways to skip it?
|
|
# OBJ files can have // or / to seperate vert/texVert/normal
|
|
# this is a bit of a pain but we must deal with it.
|
|
objVert= v.split('/')
|
|
|
|
# Vert Index - OBJ supports negative index assignment (like python)
|
|
index= int(objVert[0])-1
|
|
|
|
# Account for negative indices.
|
|
if index < 0:
|
|
# Assume negative verts are relative.
|
|
index= REL_VERT_COUNT+index+1
|
|
|
|
vIdxLs.append(index)
|
|
if fHasUV:
|
|
# UV
|
|
index= 0 # Dummy var
|
|
if len(objVert) == 1:
|
|
index= vIdxLs[-1]
|
|
elif objVert[1]: # != '' # Its possible that theres no texture vert just he vert and normal eg 1//2
|
|
index= int(objVert[1])-1
|
|
if index < 0:
|
|
# Assume negative verts are relative
|
|
index= REL_TVERT_COUNT+index+1
|
|
|
|
if len_uvMapList > index:
|
|
vtIdxLs.append(index) # Seperate UV coords
|
|
else:
|
|
# BAD FILE, I have found this so I account for it.
|
|
# INVALID UV COORD
|
|
# Could ignore this- only happens with 1 in 1000 files.
|
|
badObjFaceTexCo +=1
|
|
vtIdxLs.append(1)
|
|
|
|
fHasUV= 0
|
|
|
|
# Dont add a UV to the face if its larger then the UV coord list
|
|
# The OBJ file would have to be corrupt or badly written for thi to happen
|
|
# but account for it anyway.
|
|
if len(vtIdxLs) > 0:
|
|
if vtIdxLs[-1] > len_uvMapList:
|
|
fHasUV= 0
|
|
|
|
badObjUvs +=1 # ERROR, Cont
|
|
|
|
# Quads only, we could import quads using the method below but it polite to import a quad as a quad.
|
|
#print lIdx, len(vIdxLs), len(currentUsedVertListSmoothGroup)
|
|
#print fileLines[lIdx]
|
|
|
|
# Add all the verts we need,
|
|
# dont edd edge verts if were not importing them.
|
|
face_vert_count= len(vIdxLs)
|
|
if (not IMPORT_EDGES) and face_vert_count == 2:
|
|
pass
|
|
else:
|
|
# Add the verts that arnt alredy added.
|
|
for i in vIdxLs:
|
|
if currentUsedVertListSmoothGroup[i] == -1:
|
|
v= vertList[i]
|
|
currentMesh.verts.append(v)
|
|
currentUsedVertListSmoothGroup[i]= len(currentMesh.verts)-1
|
|
|
|
if face_vert_count == 2:
|
|
if IMPORT_EDGES and vIdxLs[0]!=vIdxLs[1]:
|
|
# Edge
|
|
currentMesh.addEdge(\
|
|
currentMesh.verts[currentUsedVertListSmoothGroup[vIdxLs[0]]],\
|
|
currentMesh.verts[currentUsedVertListSmoothGroup[vIdxLs[0]]])
|
|
|
|
elif face_vert_count == 4:
|
|
|
|
# Have found some files where wach face references the same vert
|
|
# - This causes a bug and stopts the import so lets check here
|
|
if vIdxLs[0] == vIdxLs[1] or\
|
|
vIdxLs[0] == vIdxLs[2] or\
|
|
vIdxLs[0] == vIdxLs[3] or\
|
|
vIdxLs[1] == vIdxLs[2] or\
|
|
vIdxLs[1] == vIdxLs[3] or\
|
|
vIdxLs[2] == vIdxLs[3]:
|
|
badObjFaceVerts+=1
|
|
else:
|
|
for i in quadList: # quadList == [0,1,2,3]
|
|
faceQuadVList[i]= currentMesh.verts[currentUsedVertListSmoothGroup[vIdxLs[i]]]
|
|
|
|
f= NMesh.Face(faceQuadVList)
|
|
# UV MAPPING
|
|
if fHasUV:
|
|
f.uv= [uvMapList[ vtIdxLs[0] ],uvMapList[ vtIdxLs[1] ],uvMapList[ vtIdxLs[2] ],uvMapList[ vtIdxLs[3] ]]
|
|
if currentImg:
|
|
f.image= currentImg
|
|
else:
|
|
f.mode &= TEX_OFF_FLAG
|
|
if IMPORT_MTL:
|
|
f.mat= contextMeshMatIdx
|
|
f.smooth= currentSmooth
|
|
currentMesh.faces.append(f) # move the face onto the mesh
|
|
|
|
elif face_vert_count == 3: # This handles tri's and fans, dont use fans anymore.
|
|
for i in range(face_vert_count-2):
|
|
if vIdxLs[0] == vIdxLs[i+1] or\
|
|
vIdxLs[0] == vIdxLs[i+2] or\
|
|
vIdxLs[i+1] == vIdxLs[i+2]:
|
|
badObjFaceVerts+=1
|
|
else:
|
|
for k, j in [(0,0), (1,i+1), (2,i+2)]:
|
|
faceTriVList[k]= currentMesh.verts[currentUsedVertListSmoothGroup[vIdxLs[j]]]
|
|
|
|
f= NMesh.Face(faceTriVList)
|
|
|
|
# UV MAPPING
|
|
if fHasUV:
|
|
f.uv= [uvMapList[vtIdxLs[0]], uvMapList[vtIdxLs[i+1]], uvMapList[vtIdxLs[i+2]]]
|
|
if currentImg:
|
|
f.image= currentImg
|
|
else:
|
|
f.mode &= TEX_OFF_FLAG
|
|
if IMPORT_MTL:
|
|
f.mat= contextMeshMatIdx
|
|
f.smooth= currentSmooth
|
|
currentMesh.faces.append(f) # move the face onto the mesh
|
|
|
|
elif face_vert_count > 4: # NGons.
|
|
# we need to map indices to uv coords.
|
|
currentMeshRelativeIdxs= [currentUsedVertListSmoothGroup[i] for i in vIdxLs]
|
|
|
|
if fHasUV:
|
|
vert2UvMapping=dict( [ (currentMeshRelativeIdxs[i],vtIdxLs[i]) for i in xrange(face_vert_count)] )
|
|
|
|
ngon_face_indices= BPyMesh.ngon(currentMesh, currentMeshRelativeIdxs)
|
|
|
|
|
|
# At the moment scanfill always makes tri's but dont count on it
|
|
for fillFace in ngon_face_indices:
|
|
f= NMesh.Face([currentMesh.verts[currentMeshRelativeIdxs[i]] for i in fillFace])
|
|
|
|
if fHasUV:
|
|
f.uv= [uvMapList[vert2UvMapping[currentMeshRelativeIdxs[i]]] for i in fillFace]
|
|
if currentImg:
|
|
f.image= currentImg
|
|
else:
|
|
f.mode &= TEX_OFF_FLAG
|
|
if IMPORT_MTL:
|
|
f.mat= contextMeshMatIdx
|
|
f.smooth= currentSmooth
|
|
currentMesh.faces.append(f) # move the face onto the mesh
|
|
|
|
# Set fgon flag.
|
|
if IMPORT_FGON:
|
|
edgeUsers={}
|
|
for fillFace in ngon_face_indices:
|
|
for i in xrange(len(fillFace)): # Should always be 3
|
|
i1= currentMeshRelativeIdxs[fillFace[i]]
|
|
i2= currentMeshRelativeIdxs[fillFace[i-1]]
|
|
|
|
# Sort the pair so thet always match.
|
|
if i1>i2: i1,i2=i2,i1
|
|
|
|
try:
|
|
edgeUsers[i1,i2]+= 1
|
|
except:
|
|
edgeUsers[i1,i2]= 0
|
|
|
|
for edgeVerts, users in edgeUsers.iteritems():
|
|
if users:
|
|
ed= currentMesh.addEdge(\
|
|
currentMesh.verts[edgeVerts[0]],\
|
|
currentMesh.verts[edgeVerts[1]])
|
|
|
|
ed.flag|= EDGE_FGON_FLAG
|
|
|
|
# FACE SMOOTHING
|
|
elif l[0] == 's' and IMPORT_SMOOTH_GROUPS:
|
|
# No value? then turn on.
|
|
if len(l) == 1:
|
|
currentSmooth= True
|
|
currentSmoothGroup= '(null)'
|
|
else:
|
|
if l[1] == 'off': # We all have a null group so dont need to try, will try anyway to avoid code duplication.
|
|
if not IMPORT_SMOOTH_ALL:
|
|
currentSmooth= False
|
|
currentSmoothGroup= '(null)'
|
|
else:
|
|
currentSmooth= True
|
|
currentSmoothGroup= '_'.join(l[1:])
|
|
try:
|
|
currentUsedVertListSmoothGroup= currentUsedVertList[currentSmoothGroup]
|
|
except KeyError:
|
|
currentUsedVertList[currentSmoothGroup]= currentUsedVertListSmoothGroup= VERT_USED_LIST[:]
|
|
|
|
|
|
# OBJECT / GROUP
|
|
elif l[0] == 'o' or l[0] == 'g':
|
|
|
|
# Forget about the current image
|
|
currentImg= None
|
|
|
|
# This makes sure that if an object and a group have the same name then
|
|
# they are not put into the same object.
|
|
|
|
# Only make a new group.object name if the verts in the existing object have been used, this is obscure
|
|
# but some files face groups seperating verts and faces which results in silly things. (no groups have names.)
|
|
if len(l) == 1:
|
|
# Make a new empty name
|
|
if l[0] == 'g': # Make a blank group name
|
|
currentObjectName= 'unnamed_grp_%.4d' % currentUnnamedGroupIdx
|
|
currentUnnamedGroupIdx +=1
|
|
else: # is an object.
|
|
currentObjectName= 'unnamed_ob_%.4d' % currentUnnamedObjectIdx
|
|
currentUnnamedObjectIdx +=1
|
|
may_exist= False # we know the model is new.
|
|
else: # No name given
|
|
currentObjectName= '_'.join(l[1:])
|
|
may_exist= True
|
|
|
|
if IMPORT_MTL_SPLIT:
|
|
currentObjectName_real= currentObjectName
|
|
currentObjectName += '_'+currentMat.name
|
|
|
|
obj_getmesh(may_exist)
|
|
|
|
|
|
# MATERIAL
|
|
elif l[0] == 'usemtl' and IMPORT_MTL:
|
|
if len(l) == 1 or l[1] == '(null)':
|
|
currentMat= nullMat # We know we have a null mat.
|
|
else:
|
|
currentMat= getMat('_'.join(l[1:]), materialDict)
|
|
try:
|
|
contextMeshMatIdx= currentMaterialMeshMapping[currentMat.name]
|
|
except KeyError:
|
|
contextMeshMatIdx= -1 #getMeshMaterialIndex(currentMesh, currentMat)
|
|
|
|
# Check if we are splitting by material.
|
|
if IMPORT_MTL_SPLIT:
|
|
currentObjectName= '%s_%s' % (currentObjectName_real, currentMat.name)
|
|
obj_getmesh(True)
|
|
|
|
|
|
# IMAGE
|
|
elif l[0] == 'usemat' or l[0] == 'usemap':
|
|
if len(l) == 1 or l[1] == '(null)' or l[1] == 'off':
|
|
currentImg= None
|
|
else:
|
|
# Load an image.
|
|
newImgName= stripPath(' '.join(l[1:])) # Use space since its a file name.
|
|
|
|
try:
|
|
# Assume its alredy set in the dict (may or maynot be loaded)
|
|
currentImg= imageDict[newImgName]
|
|
|
|
except KeyError: # Not in dict, add for first time.
|
|
# Image has not been added, Try and load the image
|
|
currentImg= BPyImage.comprehensiveImageLoad(newImgName, DIR) # Use join in case of spaces
|
|
imageDict[newImgName]= currentImg
|
|
# These may be None, thats okay.
|
|
|
|
# MATERIAL FILE
|
|
elif l[0] == 'mtllib' and IMPORT_MTL and len(l)>1:
|
|
mtl_fileName.append(' '.join(l[1:]) ) # Support for multiple MTL's
|
|
lIdx+=1
|
|
|
|
# Applies material properties to materials alredy on the mesh as well as Textures.
|
|
if IMPORT_MTL:
|
|
for mtl in mtl_fileName:
|
|
load_mtl(DIR, IMPORT_USE_EXISTING_MTL, mtl, meshDict, materialDict)
|
|
|
|
# Get a new scale factor if set as an option
|
|
SCALE=1.0
|
|
if IMPORT_CONSTRAIN_BOUNDS != 0.0:
|
|
while (BOUNDS*SCALE) > IMPORT_CONSTRAIN_BOUNDS:
|
|
SCALE/=10
|
|
|
|
importedObjects= []
|
|
|
|
scn= Scene.GetCurrent()
|
|
|
|
# DeSelect all
|
|
for ob in scn.getChildren():
|
|
ob.sel=0
|
|
|
|
# Create objects for each mesh.
|
|
for mk, me in meshDict.iteritems():
|
|
nme= me[0]
|
|
|
|
# Ignore no vert meshes.
|
|
if not nme.verts: # == []
|
|
continue
|
|
|
|
ob= Object.New('Mesh', fileName)
|
|
nme.name= mk
|
|
ob.link(nme)
|
|
ob.setSize(SCALE, SCALE, SCALE)
|
|
importedObjects.append(ob)
|
|
|
|
Layers= scn.Layers
|
|
if IMPORT_AS_INSTANCE:
|
|
# Create a group for this import.
|
|
group_scn= Scene.New(fileName)
|
|
for ob in importedObjects:
|
|
group_scn.link(ob) # dont worry about the layers
|
|
|
|
grp= Group.New(fileName)
|
|
grp.objects= importedObjects
|
|
|
|
grp_ob= Object.New('Empty', fileName)
|
|
grp_ob.enableDupGroup= True
|
|
grp_ob.DupGroup= grp
|
|
scn.link(grp_ob)
|
|
grp_ob.Layers= Layers
|
|
grp_ob.sel= 1
|
|
|
|
else:
|
|
# Select all imported objects.
|
|
for ob in importedObjects:
|
|
scn.link(ob)
|
|
ob.Layers= Layers
|
|
ob.sel= 1
|
|
|
|
|
|
if badObjUvs > 0:
|
|
print '\tERROR: found %d faces with badly formatted UV coords. everything else went okay.' % badObjUvs
|
|
|
|
if badObjFaceVerts > 0:
|
|
print '\tERROR: found %d faces reusing the same vertex. everything else went okay.' % badObjFaceVerts
|
|
|
|
if badObjFaceTexCo > 0:
|
|
print '\tERROR: found %d faces with invalit texture coords. everything else went okay.' % badObjFaceTexCo
|
|
|
|
|
|
print "obj import time: ", sys.time() - time1
|
|
|
|
def load_obj_ui(file):
|
|
|
|
IMPORT_DIR= Draw.Create(0)
|
|
IMPORT_NEW_SCENE= Draw.Create(0)
|
|
IMPORT_MTL= Draw.Create(1)
|
|
IMPORT_USE_EXISTING_MTL= Draw.Create(1)
|
|
|
|
IMPORT_CONSTRAIN_BOUNDS= Draw.Create(10.0)
|
|
IMPORT_ROTATE_X90= Draw.Create(1)
|
|
IMPORT_EDGES= Draw.Create(1)
|
|
IMPORT_SMOOTH_ALL= Draw.Create(1)
|
|
IMPORT_FGON= Draw.Create(1)
|
|
IMPORT_SMOOTH_GROUPS= Draw.Create(0)
|
|
IMPORT_MTL_SPLIT= Draw.Create(0)
|
|
IMPORT_AS_INSTANCE= Draw.Create(0)
|
|
|
|
# Get USER Options
|
|
pup_block= [\
|
|
('All *.obj\'s in dir', IMPORT_DIR, 'Import all obj files in this dir (avoid overlapping data with "Create scene")'),\
|
|
('Create Scene', IMPORT_NEW_SCENE, 'Imports each obj into its own scene, named from the file'),\
|
|
('Group Instance', IMPORT_AS_INSTANCE, 'Import objects into a new scene and group, creating an instance in the current scene.'),\
|
|
'Materials...',\
|
|
('Import (*.mtl)', IMPORT_MTL, 'Imports material settings and images from the obj\'s .mtl file'),\
|
|
('Re-Use Existing', IMPORT_USE_EXISTING_MTL, 'Use materials from the current blend where names match.'),\
|
|
'Geometry...',\
|
|
('Size Constraint:', IMPORT_CONSTRAIN_BOUNDS, 0.0, 1000.0, 'Scale the model by factors of 10 until it reacehs the size constraint.'),\
|
|
('Rotate X90', IMPORT_ROTATE_X90, 'Rotate X-Up to Blenders Z-Up'),\
|
|
('Edges', IMPORT_EDGES, 'Import faces with 2 verts as in edge'),\
|
|
('Smooths all faces', IMPORT_SMOOTH_ALL, 'Smooth all faces even if they are not in a smoothing group'),\
|
|
('Create FGons', IMPORT_FGON, 'Import faces with more then 4 verts as fgons.'),\
|
|
('Smooth Groups', IMPORT_SMOOTH_GROUPS, 'Only Share verts within smooth groups. (Warning, Hogs Memory)'),\
|
|
('Split by Material', IMPORT_MTL_SPLIT, 'Import each material into a seperate mesh (Avoids >16 meterials per mesh problem)'),\
|
|
]
|
|
|
|
if not os:
|
|
pup_block.pop(0) # Make sure this is the IMPORT_DIR option that requires OS
|
|
|
|
if not Draw.PupBlock('Import OBJ...', pup_block):
|
|
return
|
|
|
|
Window.WaitCursor(1)
|
|
Window.DrawProgressBar(0, '')
|
|
time= sys.time()
|
|
|
|
IMPORT_DIR= IMPORT_DIR.val
|
|
IMPORT_NEW_SCENE= IMPORT_NEW_SCENE.val
|
|
IMPORT_MTL= IMPORT_MTL.val
|
|
IMPORT_USE_EXISTING_MTL= IMPORT_USE_EXISTING_MTL.val
|
|
|
|
IMPORT_CONSTRAIN_BOUNDS= IMPORT_CONSTRAIN_BOUNDS.val
|
|
IMPORT_ROTATE_X90= IMPORT_ROTATE_X90.val
|
|
IMPORT_EDGES= IMPORT_EDGES.val
|
|
IMPORT_SMOOTH_ALL= IMPORT_SMOOTH_ALL.val
|
|
IMPORT_FGON= IMPORT_FGON.val
|
|
IMPORT_SMOOTH_GROUPS= IMPORT_SMOOTH_GROUPS.val
|
|
IMPORT_MTL_SPLIT= IMPORT_MTL_SPLIT.val
|
|
IMPORT_AS_INSTANCE= IMPORT_AS_INSTANCE.val
|
|
orig_scene= Scene.GetCurrent()
|
|
|
|
# Dont do material split if we dont import material
|
|
if not IMPORT_MTL:
|
|
IMPORT_MTL_SPLIT=0
|
|
|
|
|
|
obj_dir= stripFile(file)
|
|
if IMPORT_DIR:
|
|
obj_files= [(obj_dir,f) for f in os.listdir(obj_dir) if f.lower().endswith('obj')]
|
|
else:
|
|
obj_files= [(obj_dir,stripPath(file))]
|
|
|
|
obj_len= len(obj_files)
|
|
count= 0
|
|
for d, f in obj_files:
|
|
count+= 1
|
|
if not sys.exists(d+f):
|
|
print 'Error: "%s%s" does not exist' % (d,f)
|
|
else:
|
|
if IMPORT_NEW_SCENE:
|
|
scn= Scene.New('.'.join(f.split('.')[0:-1]))
|
|
scn.makeCurrent()
|
|
|
|
Window.DrawProgressBar((float(count)/obj_len) - 0.01, '%s: %i of %i' % (f, count, obj_len))
|
|
load_obj(d+f, IMPORT_MTL, IMPORT_USE_EXISTING_MTL, IMPORT_CONSTRAIN_BOUNDS, IMPORT_ROTATE_X90, IMPORT_EDGES, IMPORT_SMOOTH_ALL, IMPORT_FGON, IMPORT_SMOOTH_GROUPS, IMPORT_MTL_SPLIT, IMPORT_AS_INSTANCE)
|
|
|
|
|
|
orig_scene.makeCurrent() # We can leave them in there new scene.
|
|
Window.DrawProgressBar(1, '')
|
|
Window.WaitCursor(0)
|
|
|
|
print 'Total obj import "%s" dir: %.2f' % (obj_dir, sys.time() - time)
|
|
|
|
|
|
def main():
|
|
Window.FileSelector(load_obj_ui, 'Import a Wavefront OBJ', '*.obj')
|
|
|
|
if __name__ == '__main__':
|
|
main() |