change python scripts so modules which register with blender have a register() functi...
[blender.git] / release / scripts / io / import_scene_obj.py
1 # ##### BEGIN GPL LICENSE BLOCK #####
2 #
3 #  This program is free software; you can redistribute it and/or
4 #  modify it under the terms of the GNU General Public License
5 #  as published by the Free Software Foundation; either version 2
6 #  of the License, or (at your option) any later version.
7 #
8 #  This program is distributed in the hope that it will be useful,
9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 #  GNU General Public License for more details.
12 #
13 #  You should have received a copy of the GNU General Public License
14 #  along with this program; if not, write to the Free Software Foundation,
15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 #
17 # ##### END GPL LICENSE BLOCK #####
18
19 # <pep8 compliant>
20
21 __author__= "Campbell Barton", "Jiri Hnidek", "Paolo Ciccone"
22 __url__= ['http://wiki.blender.org/index.php/Scripts/Manual/Import/wavefront_obj', 'blender.org', 'blenderartists.org']
23 __version__= "2.11"
24
25 __bpydoc__= """\
26 This script imports a Wavefront OBJ files to Blender.
27
28 Usage:
29 Run this script from "File->Import" menu and then load the desired OBJ file.
30 Note, This loads mesh objects and materials only, nurbs and curves are not supported.
31 """
32
33 # ***** BEGIN GPL LICENSE BLOCK *****
34 #
35 # Script copyright (C) Campbell J Barton 2007
36 #
37 # This program is free software; you can redistribute it and/or
38 # modify it under the terms of the GNU General Public License
39 # as published by the Free Software Foundation; either version 2
40 # of the License, or (at your option) any later version.
41 #
42 # This program is distributed in the hope that it will be useful,
43 # but WITHOUT ANY WARRANTY; without even the implied warranty of
44 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
45 # GNU General Public License for more details.
46 #
47 # You should have received a copy of the GNU General Public License
48 # along with this program; if not, write to the Free Software Foundation,
49 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
50 #
51 # ***** END GPL LICENCE BLOCK *****
52 # --------------------------------------------------------------------------
53
54 import os
55 import time
56 import bpy
57 import Mathutils
58 import Geometry
59
60 # from Blender import Mesh, Draw, Window, Texture, Material, sys
61 # # import BPyMesh
62 # import BPyImage
63 # import BPyMessages
64
65 # try:          import os
66 # except:               os= False
67
68 # Generic path functions
69 def stripFile(path):
70     '''Return directory, where the file is'''
71     lastSlash= max(path.rfind('\\'), path.rfind('/'))
72     if lastSlash != -1:
73         path= path[:lastSlash]
74     return '%s%s' % (path, os.sep)
75 #       return '%s%s' % (path, sys.sep)
76
77 def stripPath(path):
78     '''Strips the slashes from the back of a string'''
79     return path.split('/')[-1].split('\\')[-1]
80
81 def stripExt(name): # name is a string
82     '''Strips the prefix off the name before writing'''
83     index= name.rfind('.')
84     if index != -1:
85         return name[ : index ]
86     else:
87         return name
88 # end path funcs
89
90 def unpack_list(list_of_tuples):
91     l = []
92     for t in list_of_tuples:
93         l.extend(t)
94     return l
95
96 # same as above except that it adds 0 for triangle faces
97 def unpack_face_list(list_of_tuples):
98     l = []
99     for t in list_of_tuples:
100         face = [i for i in t]
101
102         if len(face) != 3 and len(face) != 4:
103             raise RuntimeError("{0} vertices in face.".format(len(face)))
104
105         # rotate indices if the 4th is 0
106         if len(face) == 4 and face[3] == 0:
107             face = [face[3], face[0], face[1], face[2]]
108
109         if len(face) == 3:
110             face.append(0)
111
112         l.extend(face)
113
114     return l
115
116 def BPyMesh_ngon(from_data, indices, PREF_FIX_LOOPS= True):
117     '''
118     Takes a polyline of indices (fgon)
119     and returns a list of face indicie lists.
120     Designed to be used for importers that need indices for an fgon to create from existing verts.
121
122     from_data: either a mesh, or a list/tuple of vectors.
123     indices: a list of indicies to use this list is the ordered closed polyline to fill, and can be a subset of the data given.
124     PREF_FIX_LOOPS: If this is enabled polylines that use loops to make multiple polylines are delt with correctly.
125     '''
126
127     if not set: # Need sets for this, otherwise do a normal fill.
128         PREF_FIX_LOOPS= False
129
130     Vector= Mathutils.Vector
131     if not indices:
132         return []
133
134     #   return []
135     def rvec(co): return round(co.x, 6), round(co.y, 6), round(co.z, 6)
136     def mlen(co): return abs(co[0])+abs(co[1])+abs(co[2]) # manhatten length of a vector, faster then length
137
138     def vert_treplet(v, i):
139         return v, rvec(v), i, mlen(v)
140
141     def ed_key_mlen(v1, v2):
142         if v1[3] > v2[3]:
143             return v2[1], v1[1]
144         else:
145             return v1[1], v2[1]
146
147
148     if not PREF_FIX_LOOPS:
149         '''
150         Normal single concave loop filling
151         '''
152         if type(from_data) in (tuple, list):
153             verts= [Vector(from_data[i]) for ii, i in enumerate(indices)]
154         else:
155             verts= [from_data.verts[i].co for ii, i in enumerate(indices)]
156
157         for i in range(len(verts)-1, 0, -1): # same as reversed(xrange(1, len(verts))):
158             if verts[i][1]==verts[i-1][0]:
159                 verts.pop(i-1)
160
161         fill= Geometry.PolyFill([verts])
162
163     else:
164         '''
165         Seperate this loop into multiple loops be finding edges that are used twice
166         This is used by lightwave LWO files a lot
167         '''
168
169         if type(from_data) in (tuple, list):
170             verts= [vert_treplet(Vector(from_data[i]), ii) for ii, i in enumerate(indices)]
171         else:
172             verts= [vert_treplet(from_data.verts[i].co, ii) for ii, i in enumerate(indices)]
173
174         edges= [(i, i-1) for i in range(len(verts))]
175         if edges:
176             edges[0]= (0,len(verts)-1)
177
178         if not verts:
179             return []
180
181
182         edges_used= set()
183         edges_doubles= set()
184         # We need to check if any edges are used twice location based.
185         for ed in edges:
186             edkey= ed_key_mlen(verts[ed[0]], verts[ed[1]])
187             if edkey in edges_used:
188                 edges_doubles.add(edkey)
189             else:
190                 edges_used.add(edkey)
191
192         # Store a list of unconnected loop segments split by double edges.
193         # will join later
194         loop_segments= []
195
196         v_prev= verts[0]
197         context_loop= [v_prev]
198         loop_segments= [context_loop]
199
200         for v in verts:
201             if v!=v_prev:
202                 # Are we crossing an edge we removed?
203                 if ed_key_mlen(v, v_prev) in edges_doubles:
204                     context_loop= [v]
205                     loop_segments.append(context_loop)
206                 else:
207                     if context_loop and context_loop[-1][1]==v[1]:
208                         #raise "as"
209                         pass
210                     else:
211                         context_loop.append(v)
212
213                 v_prev= v
214         # Now join loop segments
215
216         def join_seg(s1,s2):
217             if s2[-1][1]==s1[0][1]: #
218                 s1,s2= s2,s1
219             elif s1[-1][1]==s2[0][1]:
220                 pass
221             else:
222                 return False
223
224             # If were stuill here s1 and s2 are 2 segments in the same polyline
225             s1.pop() # remove the last vert from s1
226             s1.extend(s2) # add segment 2 to segment 1
227
228             if s1[0][1]==s1[-1][1]: # remove endpoints double
229                 s1.pop()
230
231             s2[:]= [] # Empty this segment s2 so we dont use it again.
232             return True
233
234         joining_segments= True
235         while joining_segments:
236             joining_segments= False
237             segcount= len(loop_segments)
238
239             for j in range(segcount-1, -1, -1): #reversed(range(segcount)):
240                 seg_j= loop_segments[j]
241                 if seg_j:
242                     for k in range(j-1, -1, -1): # reversed(range(j)):
243                         if not seg_j:
244                             break
245                         seg_k= loop_segments[k]
246
247                         if seg_k and join_seg(seg_j, seg_k):
248                             joining_segments= True
249
250         loop_list= loop_segments
251
252         for verts in loop_list:
253             while verts and verts[0][1]==verts[-1][1]:
254                 verts.pop()
255
256         loop_list= [verts for verts in loop_list if len(verts)>2]
257         # DONE DEALING WITH LOOP FIXING
258
259
260         # vert mapping
261         vert_map= [None]*len(indices)
262         ii=0
263         for verts in loop_list:
264             if len(verts)>2:
265                 for i, vert in enumerate(verts):
266                     vert_map[i+ii]= vert[2]
267                 ii+=len(verts)
268
269         fill= Geometry.PolyFill([ [v[0] for v in loop] for loop in loop_list ])
270         #draw_loops(loop_list)
271         #raise 'done loop'
272         # map to original indicies
273         fill= [[vert_map[i] for i in reversed(f)] for f in fill]
274
275
276     if not fill:
277         print('Warning Cannot scanfill, fallback on a triangle fan.')
278         fill= [ [0, i-1, i] for i in range(2, len(indices)) ]
279     else:
280         # Use real scanfill.
281         # See if its flipped the wrong way.
282         flip= None
283         for fi in fill:
284             if flip != None:
285                 break
286             for i, vi in enumerate(fi):
287                 if vi==0 and fi[i-1]==1:
288                     flip= False
289                     break
290                 elif vi==1 and fi[i-1]==0:
291                     flip= True
292                     break
293
294         if not flip:
295             for i, fi in enumerate(fill):
296                 fill[i]= tuple([ii for ii in reversed(fi)])
297
298     return fill
299
300 def line_value(line_split):
301     '''
302     Returns 1 string represneting the value for this line
303     None will be returned if theres only 1 word
304     '''
305     length= len(line_split)
306     if length == 1:
307         return None
308
309     elif length == 2:
310         return line_split[1]
311
312     elif length > 2:
313         return ' '.join( line_split[1:] )
314
315 # limited replacement for BPyImage.comprehensiveImageLoad
316 def load_image(imagepath, dirname):
317
318     if os.path.exists(imagepath):
319         return bpy.data.add_image(imagepath)
320
321     variants = [os.path.join(dirname, imagepath), os.path.join(dirname, os.path.basename(imagepath))]
322
323     for path in variants:
324         if os.path.exists(path):
325             return bpy.data.add_image(path)
326         else:
327             print(path, "doesn't exist")
328
329     # TODO comprehensiveImageLoad also searched in bpy.config.textureDir
330     return None
331
332 def obj_image_load(imagepath, DIR, IMAGE_SEARCH):
333
334     if '_' in imagepath:
335         image= load_image(imagepath.replace('_', ' '), DIR)
336         if image: return image
337
338     return load_image(imagepath, DIR)
339
340 # def obj_image_load(imagepath, DIR, IMAGE_SEARCH):
341 #       '''
342 #       Mainly uses comprehensiveImageLoad
343 #       but tries to replace '_' with ' ' for Max's exporter replaces spaces with underscores.
344 #       '''
345
346 #       if '_' in imagepath:
347 #               image= BPyImage.comprehensiveImageLoad(imagepath, DIR, PLACE_HOLDER= False, RECURSIVE= IMAGE_SEARCH)
348 #               if image: return image
349 #               # Did the exporter rename the image?
350 #               image= BPyImage.comprehensiveImageLoad(imagepath.replace('_', ' '), DIR, PLACE_HOLDER= False, RECURSIVE= IMAGE_SEARCH)
351 #               if image: return image
352
353 #       # Return an image, placeholder if it dosnt exist
354 #       image= BPyImage.comprehensiveImageLoad(imagepath, DIR, PLACE_HOLDER= True, RECURSIVE= IMAGE_SEARCH)
355 #       return image
356
357
358 def create_materials(filepath, material_libs, unique_materials, unique_material_images, IMAGE_SEARCH):
359     '''
360     Create all the used materials in this obj,
361     assign colors and images to the materials from all referenced material libs
362     '''
363     DIR= stripFile(filepath)
364
365     #==================================================================================#
366     # This function sets textures defined in .mtl file                                 #
367     #==================================================================================#
368     def load_material_image(blender_material, context_material_name, imagepath, type):
369
370         texture= bpy.data.textures.new(type)
371         texture.type= 'IMAGE'
372         texture = texture.recast_type() # Workaround for limitation in rna api.
373 #               texture= bpy.data.textures.new(type)
374 #               texture.setType('Image')
375
376         # Absolute path - c:\.. etc would work here
377         image= obj_image_load(imagepath, DIR, IMAGE_SEARCH)
378         has_data = image.has_data if image else False
379
380         if image:
381             texture.image = image
382
383         # Adds textures for materials (rendering)
384         if type == 'Kd':
385             if has_data and image.depth == 32:
386                 # Image has alpha
387
388                 # XXX bitmask won't work?
389                 blender_material.add_texture(texture, "UV", ("COLOR", "ALPHA"))
390                 texture.mipmap = True
391                 texture.interpolation = True
392                 texture.use_alpha = True
393                 blender_material.z_transparency = True
394                 blender_material.alpha = 0.0
395
396 #                               blender_material.setTexture(0, texture, Texture.TexCo.UV, Texture.MapTo.COL | Texture.MapTo.ALPHA)
397 #                               texture.setImageFlags('MipMap', 'InterPol', 'UseAlpha')
398 #                               blender_material.mode |= Material.Modes.ZTRANSP
399 #                               blender_material.alpha = 0.0
400             else:
401                 blender_material.add_texture(texture, "UV", "COLOR")
402 #                               blender_material.setTexture(0, texture, Texture.TexCo.UV, Texture.MapTo.COL)
403
404             # adds textures to faces (Textured/Alt-Z mode)
405             # Only apply the diffuse texture to the face if the image has not been set with the inline usemat func.
406             unique_material_images[context_material_name]= image, has_data # set the texface image
407
408         elif type == 'Ka':
409             blender_material.add_texture(texture, "UV", "AMBIENT")
410 #                       blender_material.setTexture(1, texture, Texture.TexCo.UV, Texture.MapTo.CMIR) # TODO- Add AMB to BPY API
411
412         elif type == 'Ks':
413             blender_material.add_texture(texture, "UV", "SPECULARITY")
414 #                       blender_material.setTexture(2, texture, Texture.TexCo.UV, Texture.MapTo.SPEC)
415
416         elif type == 'Bump':
417             blender_material.add_texture(texture, "UV", "NORMAL")
418 #                       blender_material.setTexture(3, texture, Texture.TexCo.UV, Texture.MapTo.NOR)
419         elif type == 'D':
420             blender_material.add_texture(texture, "UV", "ALPHA")
421             blender_material.z_transparency = True
422             blender_material.alpha = 0.0
423 #                       blender_material.setTexture(4, texture, Texture.TexCo.UV, Texture.MapTo.ALPHA)
424 #                       blender_material.mode |= Material.Modes.ZTRANSP
425 #                       blender_material.alpha = 0.0
426             # Todo, unset deffuse material alpha if it has an alpha channel
427
428         elif type == 'refl':
429             blender_material.add_texture(texture, "UV", "REFLECTION")
430 #                       blender_material.setTexture(5, texture, Texture.TexCo.UV, Texture.MapTo.REF)
431
432
433     # Add an MTL with the same name as the obj if no MTLs are spesified.
434     temp_mtl= stripExt(stripPath(filepath))+ '.mtl'
435
436     if os.path.exists(DIR + temp_mtl) and temp_mtl not in material_libs:
437 #       if sys.exists(DIR + temp_mtl) and temp_mtl not in material_libs:
438         material_libs.append( temp_mtl )
439     del temp_mtl
440
441     #Create new materials
442     for name in unique_materials: # .keys()
443         if name != None:
444             unique_materials[name]= bpy.data.materials.new(name)
445             unique_material_images[name]= None, False # assign None to all material images to start with, add to later.
446
447     unique_materials[None]= None
448     unique_material_images[None]= None, False
449
450     for libname in material_libs:
451         mtlpath= DIR + libname
452         if not os.path.exists(mtlpath):
453 #               if not sys.exists(mtlpath):
454             #print '\tError Missing MTL: "%s"' % mtlpath
455             pass
456         else:
457             #print '\t\tloading mtl: "%s"' % mtlpath
458             context_material= None
459             mtl= open(mtlpath, 'rU')
460             for line in mtl: #.xreadlines():
461                 if line.startswith('newmtl'):
462                     context_material_name= line_value(line.split())
463                     if context_material_name in unique_materials:
464                         context_material = unique_materials[ context_material_name ]
465                     else:
466                         context_material = None
467
468                 elif context_material:
469                     # we need to make a material to assign properties to it.
470                     line_split= line.split()
471                     line_lower= line.lower().lstrip()
472                     if line_lower.startswith('ka'):
473                         context_material.mirror_color = (float(line_split[1]), float(line_split[2]), float(line_split[3]))
474 #                                               context_material.setMirCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
475                     elif line_lower.startswith('kd'):
476                         context_material.diffuse_color = (float(line_split[1]), float(line_split[2]), float(line_split[3]))
477 #                                               context_material.setRGBCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
478                     elif line_lower.startswith('ks'):
479                         context_material.specular_color = (float(line_split[1]), float(line_split[2]), float(line_split[3]))
480 #                                               context_material.setSpecCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
481                     elif line_lower.startswith('ns'):
482                         context_material.specular_hardness = int((float(line_split[1])*0.51))
483 #                                               context_material.setHardness( int((float(line_split[1])*0.51)) )
484                     elif line_lower.startswith('ni'): # Refraction index
485                         context_material.raytrace_transparency.ior = max(1, min(float(line_split[1]), 3))
486 #                                               context_material.setIOR( max(1, min(float(line_split[1]), 3))) # Between 1 and 3
487                     elif line_lower.startswith('d') or line_lower.startswith('tr'):
488                         context_material.alpha = float(line_split[1])
489 #                                               context_material.setAlpha(float(line_split[1]))
490                     elif line_lower.startswith('map_ka'):
491                         img_filepath= line_value(line.split())
492                         if img_filepath:
493                             load_material_image(context_material, context_material_name, img_filepath, 'Ka')
494                     elif line_lower.startswith('map_ks'):
495                         img_filepath= line_value(line.split())
496                         if img_filepath:
497                             load_material_image(context_material, context_material_name, img_filepath, 'Ks')
498                     elif line_lower.startswith('map_kd'):
499                         img_filepath= line_value(line.split())
500                         if img_filepath:
501                             load_material_image(context_material, context_material_name, img_filepath, 'Kd')
502                     elif line_lower.startswith('map_bump'):
503                         img_filepath= line_value(line.split())
504                         if img_filepath:
505                             load_material_image(context_material, context_material_name, img_filepath, 'Bump')
506                     elif line_lower.startswith('map_d') or line_lower.startswith('map_tr'): # Alpha map - Dissolve
507                         img_filepath= line_value(line.split())
508                         if img_filepath:
509                             load_material_image(context_material, context_material_name, img_filepath, 'D')
510
511                     elif line_lower.startswith('refl'): # Reflectionmap
512                         img_filepath= line_value(line.split())
513                         if img_filepath:
514                             load_material_image(context_material, context_material_name, img_filepath, 'refl')
515             mtl.close()
516
517
518
519
520 def split_mesh(verts_loc, faces, unique_materials, filepath, SPLIT_OB_OR_GROUP, SPLIT_MATERIALS):
521     '''
522     Takes vert_loc and faces, and seperates into multiple sets of
523     (verts_loc, faces, unique_materials, dataname)
524     This is done so objects do not overload the 16 material limit.
525     '''
526
527     filename = stripExt(stripPath(filepath))
528
529     if not SPLIT_OB_OR_GROUP and not SPLIT_MATERIALS:
530         # use the filename for the object name since we arnt chopping up the mesh.
531         return [(verts_loc, faces, unique_materials, filename)]
532
533
534     def key_to_name(key):
535         # if the key is a tuple, join it to make a string
536         if type(key) == tuple:
537             return '%s_%s' % key
538         elif not key:
539             return filename # assume its a string. make sure this is true if the splitting code is changed
540         else:
541             return key
542
543     # Return a key that makes the faces unique.
544     if SPLIT_OB_OR_GROUP and not SPLIT_MATERIALS:
545         def face_key(face):
546             return face[4] # object
547
548     elif not SPLIT_OB_OR_GROUP and SPLIT_MATERIALS:
549         def face_key(face):
550             return face[2] # material
551
552     else: # Both
553         def face_key(face):
554             return face[4], face[2] # object,material
555
556
557     face_split_dict= {}
558
559     oldkey= -1 # initialize to a value that will never match the key
560
561     for face in faces:
562
563         key= face_key(face)
564
565         if oldkey != key:
566             # Check the key has changed.
567             try:
568                 verts_split, faces_split, unique_materials_split, vert_remap= face_split_dict[key]
569             except KeyError:
570                 faces_split= []
571                 verts_split= []
572                 unique_materials_split= {}
573                 vert_remap= [-1]*len(verts_loc)
574
575                 face_split_dict[key]= (verts_split, faces_split, unique_materials_split, vert_remap)
576
577             oldkey= key
578
579         face_vert_loc_indicies= face[0]
580
581         # Remap verts to new vert list and add where needed
582         for enum, i in enumerate(face_vert_loc_indicies):
583             if vert_remap[i] == -1:
584                 new_index= len(verts_split)
585                 vert_remap[i]= new_index # set the new remapped index so we only add once and can reference next time.
586                 face_vert_loc_indicies[enum] = new_index # remap to the local index
587                 verts_split.append( verts_loc[i] ) # add the vert to the local verts
588
589             else:
590                 face_vert_loc_indicies[enum] = vert_remap[i] # remap to the local index
591
592             matname= face[2]
593             if matname and matname not in unique_materials_split:
594                 unique_materials_split[matname] = unique_materials[matname]
595
596         faces_split.append(face)
597
598
599     # remove one of the itemas and reorder
600     return [(value[0], value[1], value[2], key_to_name(key)) for key, value in list(face_split_dict.items())]
601
602
603 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, vertex_groups, dataname):
604     '''
605     Takes all the data gathered and generates a mesh, adding the new object to new_objects
606     deals with fgons, sharp edges and assigning materials
607     '''
608     if not has_ngons:
609         CREATE_FGONS= False
610
611     if unique_smooth_groups:
612         sharp_edges= {}
613         smooth_group_users= dict([ (context_smooth_group, {}) for context_smooth_group in list(unique_smooth_groups.keys()) ])
614         context_smooth_group_old= -1
615
616     # Split fgons into tri's
617     fgon_edges= {} # Used for storing fgon keys
618     if CREATE_EDGES:
619         edges= []
620
621     context_object= None
622
623     # reverse loop through face indicies
624     for f_idx in range(len(faces)-1, -1, -1):
625
626         face_vert_loc_indicies,\
627         face_vert_tex_indicies,\
628         context_material,\
629         context_smooth_group,\
630         context_object= faces[f_idx]
631
632         len_face_vert_loc_indicies = len(face_vert_loc_indicies)
633
634         if len_face_vert_loc_indicies==1:
635             faces.pop(f_idx)# cant add single vert faces
636
637         elif not face_vert_tex_indicies or len_face_vert_loc_indicies == 2: # faces that have no texture coords are lines
638             if CREATE_EDGES:
639                 # generators are better in python 2.4+ but can't be used in 2.3
640                 # edges.extend( (face_vert_loc_indicies[i], face_vert_loc_indicies[i+1]) for i in xrange(len_face_vert_loc_indicies-1) )
641                 edges.extend( [(face_vert_loc_indicies[i], face_vert_loc_indicies[i+1]) for i in range(len_face_vert_loc_indicies-1)] )
642
643             faces.pop(f_idx)
644         else:
645
646             # Smooth Group
647             if unique_smooth_groups and context_smooth_group:
648                 # Is a part of of a smooth group and is a face
649                 if context_smooth_group_old is not context_smooth_group:
650                     edge_dict= smooth_group_users[context_smooth_group]
651                     context_smooth_group_old= context_smooth_group
652
653                 for i in range(len_face_vert_loc_indicies):
654                     i1= face_vert_loc_indicies[i]
655                     i2= face_vert_loc_indicies[i-1]
656                     if i1>i2: i1,i2= i2,i1
657
658                     try:
659                         edge_dict[i1,i2]+= 1
660                     except KeyError:
661                         edge_dict[i1,i2]=  1
662
663             # FGons into triangles
664             if has_ngons and len_face_vert_loc_indicies > 4:
665
666                 ngon_face_indices= BPyMesh_ngon(verts_loc, face_vert_loc_indicies)
667                 faces.extend(\
668                 [(\
669                 [face_vert_loc_indicies[ngon[0]], face_vert_loc_indicies[ngon[1]], face_vert_loc_indicies[ngon[2]] ],\
670                 [face_vert_tex_indicies[ngon[0]], face_vert_tex_indicies[ngon[1]], face_vert_tex_indicies[ngon[2]] ],\
671                 context_material,\
672                 context_smooth_group,\
673                 context_object)\
674                 for ngon in ngon_face_indices]\
675                 )
676
677                 # edges to make fgons
678                 if CREATE_FGONS:
679                     edge_users= {}
680                     for ngon in ngon_face_indices:
681                         for i in (0,1,2):
682                             i1= face_vert_loc_indicies[ngon[i  ]]
683                             i2= face_vert_loc_indicies[ngon[i-1]]
684                             if i1>i2: i1,i2= i2,i1
685
686                             try:
687                                 edge_users[i1,i2]+=1
688                             except KeyError:
689                                 edge_users[i1,i2]= 1
690
691                     for key, users in edge_users.items():
692                         if users>1:
693                             fgon_edges[key]= None
694
695                 # remove all after 3, means we dont have to pop this one.
696                 faces.pop(f_idx)
697
698
699     # Build sharp edges
700     if unique_smooth_groups:
701         for edge_dict in list(smooth_group_users.values()):
702             for key, users in list(edge_dict.items()):
703                 if users==1: # This edge is on the boundry of a group
704                     sharp_edges[key]= None
705
706
707     # map the material names to an index
708     material_mapping= dict([(name, i) for i, name in enumerate(unique_materials)]) # enumerate over unique_materials keys()
709
710     materials= [None] * len(unique_materials)
711
712     for name, index in list(material_mapping.items()):
713         materials[index]= unique_materials[name]
714
715     me= bpy.data.meshes.new(dataname)
716
717     # make sure the list isnt too big
718     for material in materials[0:16]:
719         me.add_material(material)
720 #       me.materials= materials[0:16] # make sure the list isnt too big.
721     #me.verts.extend([(0,0,0)]) # dummy vert
722
723     me.add_geometry(len(verts_loc), 0, len(faces))
724
725     # verts_loc is a list of (x, y, z) tuples
726     me.verts.foreach_set("co", unpack_list(verts_loc))
727 #       me.verts.extend(verts_loc)
728
729     # faces is a list of (vert_indices, texco_indices, ...) tuples
730     # XXX faces should contain either 3 or 4 verts
731     # XXX no check for valid face indices
732     me.faces.foreach_set("verts_raw", unpack_face_list([f[0] for f in faces]))
733 #       face_mapping= me.faces.extend([f[0] for f in faces], indexList=True)
734
735     if verts_tex and me.faces:
736         me.add_uv_texture()
737 #               me.faceUV= 1
738         # TEXMODE= Mesh.FaceModes['TEX']
739
740     context_material_old= -1 # avoid a dict lookup
741     mat= 0 # rare case it may be un-initialized.
742     me_faces= me.faces
743 #       ALPHA= Mesh.FaceTranspModes.ALPHA
744
745     for i, face in enumerate(faces):
746         if len(face[0]) < 2:
747             pass #raise "bad face"
748         elif len(face[0])==2:
749             if CREATE_EDGES:
750                 edges.append(face[0])
751         else:
752 #                       face_index_map= face_mapping[i]
753
754             # since we use foreach_set to add faces, all of them are added
755             if 1:
756 #                       if face_index_map!=None: # None means the face wasnt added
757
758                 blender_face = me.faces[i]
759 #                               blender_face= me_faces[face_index_map]
760
761                 face_vert_loc_indicies,\
762                 face_vert_tex_indicies,\
763                 context_material,\
764                 context_smooth_group,\
765                 context_object= face
766
767
768
769                 if context_smooth_group:
770                     blender_face.smooth= True
771
772                 if context_material:
773                     if context_material_old is not context_material:
774                         mat= material_mapping[context_material]
775                         if mat>15:
776                             mat= 15
777                         context_material_old= context_material
778
779                     blender_face.material_index= mat
780 #                                       blender_face.mat= mat
781
782
783                 if verts_tex:
784
785                     blender_tface= me.uv_textures[0].data[i]
786
787                     if context_material:
788                         image, has_data= unique_material_images[context_material]
789                         if image: # Can be none if the material dosnt have an image.
790                             blender_tface.image= image
791 #                                                       blender_face.image= image
792                             if has_data:
793 #                                                       if has_data and image.depth == 32:
794                                 blender_tface.transp = 'ALPHA'
795 #                                                               blender_face.transp |= ALPHA
796
797                     # BUG - Evil eekadoodle problem where faces that have vert index 0 location at 3 or 4 are shuffled.
798                     if len(face_vert_loc_indicies)==4:
799                         if face_vert_loc_indicies[2]==0 or face_vert_loc_indicies[3]==0:
800                             face_vert_tex_indicies= face_vert_tex_indicies[2], face_vert_tex_indicies[3], face_vert_tex_indicies[0], face_vert_tex_indicies[1]
801                     else: # length of 3
802                         if face_vert_loc_indicies[2]==0:
803                             face_vert_tex_indicies= face_vert_tex_indicies[1], face_vert_tex_indicies[2], face_vert_tex_indicies[0]
804                     # END EEEKADOODLE FIX
805
806                     # assign material, uv's and image
807                     blender_tface.uv1= verts_tex[face_vert_tex_indicies[0]]
808                     blender_tface.uv2= verts_tex[face_vert_tex_indicies[1]]
809                     blender_tface.uv3= verts_tex[face_vert_tex_indicies[2]]
810
811                     if len(face_vert_loc_indicies)==4:
812                         blender_tface.uv4= verts_tex[face_vert_tex_indicies[3]]
813
814 #                                       for ii, uv in enumerate(blender_face.uv):
815 #                                               uv.x, uv.y=  verts_tex[face_vert_tex_indicies[ii]]
816     del me_faces
817 #       del ALPHA
818
819     if CREATE_EDGES:
820
821         me.add_geometry(0, len(edges), 0)
822
823         # edges should be a list of (a, b) tuples
824         me.edges.foreach_set("verts", unpack_list(edges))
825 #               me_edges.extend( edges )
826
827 #       del me_edges
828
829     # Add edge faces.
830 #       me_edges= me.edges
831
832     def edges_match(e1, e2):
833         return (e1[0] == e2[0] and e1[1] == e2[1]) or (e1[0] == e2[1] and e1[1] == e2[0])
834
835     # XXX slow
836 #       if CREATE_FGONS and fgon_edges:
837 #               for fgon_edge in fgon_edges.keys():
838 #                       for ed in me.edges:
839 #                               if edges_match(fgon_edge, ed.verts):
840 #                                       ed.fgon = True
841
842 #       if CREATE_FGONS and fgon_edges:
843 #               FGON= Mesh.EdgeFlags.FGON
844 #               for ed in me.findEdges( fgon_edges.keys() ):
845 #                       if ed!=None:
846 #                               me_edges[ed].flag |= FGON
847 #               del FGON
848
849     # XXX slow
850 #       if unique_smooth_groups and sharp_edges:
851 #               for sharp_edge in sharp_edges.keys():
852 #                       for ed in me.edges:
853 #                               if edges_match(sharp_edge, ed.verts):
854 #                                       ed.sharp = True
855
856 #       if unique_smooth_groups and sharp_edges:
857 #               SHARP= Mesh.EdgeFlags.SHARP
858 #               for ed in me.findEdges( sharp_edges.keys() ):
859 #                       if ed!=None:
860 #                               me_edges[ed].flag |= SHARP
861 #               del SHARP
862
863     me.update()
864 #       me.calcNormals()
865
866     ob= bpy.data.objects.new("Mesh", 'MESH')
867     ob.data= me
868     scn.objects.link(ob)
869 #       ob= scn.objects.new(me)
870     new_objects.append(ob)
871
872     # Create the vertex groups. No need to have the flag passed here since we test for the
873     # content of the vertex_groups. If the user selects to NOT have vertex groups saved then
874     # the following test will never run
875     for group_name, group_indicies in vertex_groups.items():
876         group= ob.add_vertex_group(group_name)
877 #               me.addVertGroup(group_name)
878         for vertex_index in group_indicies:
879             ob.add_vertex_to_group(vertex_index, group, 1.0, 'REPLACE')
880 #               me.assignVertsToGroup(group_name, group_indicies, 1.00, Mesh.AssignModes.REPLACE)
881
882
883 def create_nurbs(scn, context_nurbs, vert_loc, new_objects):
884     '''
885     Add nurbs object to blender, only support one type at the moment
886     '''
887     deg = context_nurbs.get('deg', (3,))
888     curv_range = context_nurbs.get('curv_range')
889     curv_idx = context_nurbs.get('curv_idx', [])
890     parm_u = context_nurbs.get('parm_u', [])
891     parm_v = context_nurbs.get('parm_v', [])
892     name = context_nurbs.get('name', 'ObjNurb')
893     cstype = context_nurbs.get('cstype')
894
895     if cstype == None:
896         print('\tWarning, cstype not found')
897         return
898     if cstype != 'bspline':
899         print('\tWarning, cstype is not supported (only bspline)')
900         return
901     if not curv_idx:
902         print('\tWarning, curv argument empty or not set')
903         return
904     if len(deg) > 1 or parm_v:
905         print('\tWarning, surfaces not supported')
906         return
907
908     cu = bpy.data.curves.new(name, 'Curve')
909     cu.flag |= 1 # 3D curve
910
911     nu = None
912     for pt in curv_idx:
913
914         pt = vert_loc[pt]
915         pt = (pt[0], pt[1], pt[2], 1.0)
916
917         if nu == None:
918             nu = cu.appendNurb(pt)
919         else:
920             nu.append(pt)
921
922     nu.orderU = deg[0]+1
923
924     # get for endpoint flag from the weighting
925     if curv_range and len(parm_u) > deg[0]+1:
926         do_endpoints = True
927         for i in range(deg[0]+1):
928
929             if abs(parm_u[i]-curv_range[0]) > 0.0001:
930                 do_endpoints = False
931                 break
932
933             if abs(parm_u[-(i+1)]-curv_range[1]) > 0.0001:
934                 do_endpoints = False
935                 break
936
937     else:
938         do_endpoints = False
939
940     if do_endpoints:
941         nu.flagU |= 2
942
943
944     # close
945     '''
946     do_closed = False
947     if len(parm_u) > deg[0]+1:
948         for i in xrange(deg[0]+1):
949             #print curv_idx[i], curv_idx[-(i+1)]
950
951             if curv_idx[i]==curv_idx[-(i+1)]:
952                 do_closed = True
953                 break
954
955     if do_closed:
956         nu.flagU |= 1
957     '''
958
959     ob = scn.objects.new(cu)
960     new_objects.append(ob)
961
962
963 def strip_slash(line_split):
964     if line_split[-1][-1]== '\\':
965         if len(line_split[-1])==1:
966             line_split.pop() # remove the \ item
967         else:
968             line_split[-1]= line_split[-1][:-1] # remove the \ from the end last number
969         return True
970     return False
971
972
973
974 def get_float_func(filepath):
975     '''
976     find the float function for this obj file
977     - weather to replace commas or not
978     '''
979     file= open(filepath, 'rU')
980     for line in file: #.xreadlines():
981         line = line.lstrip()
982         if line.startswith('v'): # vn vt v
983             if ',' in line:
984                 return lambda f: float(f.replace(',', '.'))
985             elif '.' in line:
986                 return float
987
988     # incase all vert values were ints
989     return float
990
991 def load_obj(filepath,
992              context,
993              CLAMP_SIZE= 0.0,
994              CREATE_FGONS= True,
995              CREATE_SMOOTH_GROUPS= True,
996              CREATE_EDGES= True,
997              SPLIT_OBJECTS= True,
998              SPLIT_GROUPS= True,
999              SPLIT_MATERIALS= True,
1000              ROTATE_X90= True,
1001              IMAGE_SEARCH=True,
1002              POLYGROUPS=False):
1003     '''
1004     Called by the user interface or another script.
1005     load_obj(path) - should give acceptable results.
1006     This function passes the file and sends the data off
1007         to be split into objects and then converted into mesh objects
1008     '''
1009     print('\nimporting obj "%s"' % filepath)
1010
1011     if SPLIT_OBJECTS or SPLIT_GROUPS or SPLIT_MATERIALS:
1012         POLYGROUPS = False
1013
1014     time_main= time.time()
1015 #       time_main= sys.time()
1016
1017     verts_loc= []
1018     verts_tex= []
1019     faces= [] # tuples of the faces
1020     material_libs= [] # filanems to material libs this uses
1021     vertex_groups = {} # when POLYGROUPS is true
1022
1023     # Get the string to float conversion func for this file- is 'float' for almost all files.
1024     float_func= get_float_func(filepath)
1025
1026     # Context variables
1027     context_material= None
1028     context_smooth_group= None
1029     context_object= None
1030     context_vgroup = None
1031
1032     # Nurbs
1033     context_nurbs = {}
1034     nurbs = []
1035     context_parm = '' # used by nurbs too but could be used elsewhere
1036
1037     has_ngons= False
1038     # has_smoothgroups= False - is explicit with len(unique_smooth_groups) being > 0
1039
1040     # Until we can use sets
1041     unique_materials= {}
1042     unique_material_images= {}
1043     unique_smooth_groups= {}
1044     # unique_obects= {} - no use for this variable since the objects are stored in the face.
1045
1046     # when there are faces that end with \
1047     # it means they are multiline-
1048     # since we use xreadline we cant skip to the next line
1049     # so we need to know weather
1050     context_multi_line= ''
1051
1052     print('\tparsing obj file "%s"...' % filepath)
1053     time_sub= time.time()
1054 #       time_sub= sys.time()
1055
1056     file= open(filepath, 'rU')
1057     for line in file: #.xreadlines():
1058         line = line.lstrip() # rare cases there is white space at the start of the line
1059
1060         if line.startswith('v '):
1061             line_split= line.split()
1062             # rotate X90: (x,-z,y)
1063             verts_loc.append( (float_func(line_split[1]), -float_func(line_split[3]), float_func(line_split[2])) )
1064
1065         elif line.startswith('vn '):
1066             pass
1067
1068         elif line.startswith('vt '):
1069             line_split= line.split()
1070             verts_tex.append( (float_func(line_split[1]), float_func(line_split[2])) )
1071
1072         # Handel faces lines (as faces) and the second+ lines of fa multiline face here
1073         # use 'f' not 'f ' because some objs (very rare have 'fo ' for faces)
1074         elif line.startswith('f') or context_multi_line == 'f':
1075
1076             if context_multi_line:
1077                 # use face_vert_loc_indicies and face_vert_tex_indicies previously defined and used the obj_face
1078                 line_split= line.split()
1079
1080             else:
1081                 line_split= line[2:].split()
1082                 face_vert_loc_indicies= []
1083                 face_vert_tex_indicies= []
1084
1085                 # Instance a face
1086                 faces.append((\
1087                 face_vert_loc_indicies,\
1088                 face_vert_tex_indicies,\
1089                 context_material,\
1090                 context_smooth_group,\
1091                 context_object\
1092                 ))
1093
1094             if strip_slash(line_split):
1095                 context_multi_line = 'f'
1096             else:
1097                 context_multi_line = ''
1098
1099             for v in line_split:
1100                 obj_vert= v.split('/')
1101
1102                 vert_loc_index= int(obj_vert[0])-1
1103                 # Add the vertex to the current group
1104                 # *warning*, this wont work for files that have groups defined around verts
1105                 if      POLYGROUPS and context_vgroup:
1106                     vertex_groups[context_vgroup].append(vert_loc_index)
1107
1108                 # Make relative negative vert indicies absolute
1109                 if vert_loc_index < 0:
1110                     vert_loc_index= len(verts_loc) + vert_loc_index + 1
1111
1112                 face_vert_loc_indicies.append(vert_loc_index)
1113
1114                 if len(obj_vert)>1 and obj_vert[1]:
1115                     # formatting for faces with normals and textures us
1116                     # loc_index/tex_index/nor_index
1117
1118                     vert_tex_index= int(obj_vert[1])-1
1119                     # Make relative negative vert indicies absolute
1120                     if vert_tex_index < 0:
1121                         vert_tex_index= len(verts_tex) + vert_tex_index + 1
1122
1123                     face_vert_tex_indicies.append(vert_tex_index)
1124                 else:
1125                     # dummy
1126                     face_vert_tex_indicies.append(0)
1127
1128             if len(face_vert_loc_indicies) > 4:
1129                 has_ngons= True
1130
1131         elif CREATE_EDGES and (line.startswith('l ') or context_multi_line == 'l'):
1132             # very similar to the face load function above with some parts removed
1133
1134             if context_multi_line:
1135                 # use face_vert_loc_indicies and face_vert_tex_indicies previously defined and used the obj_face
1136                 line_split= line.split()
1137
1138             else:
1139                 line_split= line[2:].split()
1140                 face_vert_loc_indicies= []
1141                 face_vert_tex_indicies= []
1142
1143                 # Instance a face
1144                 faces.append((\
1145                 face_vert_loc_indicies,\
1146                 face_vert_tex_indicies,\
1147                 context_material,\
1148                 context_smooth_group,\
1149                 context_object\
1150                 ))
1151
1152             if strip_slash(line_split):
1153                 context_multi_line = 'l'
1154             else:
1155                 context_multi_line = ''
1156
1157             isline= line.startswith('l')
1158
1159             for v in line_split:
1160                 vert_loc_index= int(v)-1
1161
1162                 # Make relative negative vert indicies absolute
1163                 if vert_loc_index < 0:
1164                     vert_loc_index= len(verts_loc) + vert_loc_index + 1
1165
1166                 face_vert_loc_indicies.append(vert_loc_index)
1167
1168         elif line.startswith('s'):
1169             if CREATE_SMOOTH_GROUPS:
1170                 context_smooth_group= line_value(line.split())
1171                 if context_smooth_group=='off':
1172                     context_smooth_group= None
1173                 elif context_smooth_group: # is not None
1174                     unique_smooth_groups[context_smooth_group]= None
1175
1176         elif line.startswith('o'):
1177             if SPLIT_OBJECTS:
1178                 context_object= line_value(line.split())
1179                 # unique_obects[context_object]= None
1180
1181         elif line.startswith('g'):
1182             if SPLIT_GROUPS:
1183                 context_object= line_value(line.split())
1184                 # print 'context_object', context_object
1185                 # unique_obects[context_object]= None
1186             elif POLYGROUPS:
1187                 context_vgroup = line_value(line.split())
1188                 if context_vgroup and context_vgroup != '(null)':
1189                     vertex_groups.setdefault(context_vgroup, [])
1190                 else:
1191                     context_vgroup = None # dont assign a vgroup
1192
1193         elif line.startswith('usemtl'):
1194             context_material= line_value(line.split())
1195             unique_materials[context_material]= None
1196         elif line.startswith('mtllib'): # usemap or usemat
1197             material_libs.extend( line.split()[1:] ) # can have multiple mtllib filenames per line
1198
1199
1200             # Nurbs support
1201         elif line.startswith('cstype '):
1202             context_nurbs['cstype']= line_value(line.split()) # 'rat bspline' / 'bspline'
1203         elif line.startswith('curv ') or context_multi_line == 'curv':
1204             line_split= line.split()
1205
1206             curv_idx = context_nurbs['curv_idx'] = context_nurbs.get('curv_idx', []) # incase were multiline
1207
1208             if not context_multi_line:
1209                 context_nurbs['curv_range'] = float_func(line_split[1]), float_func(line_split[2])
1210                 line_split[0:3] = [] # remove first 3 items
1211
1212             if strip_slash(line_split):
1213                 context_multi_line = 'curv'
1214             else:
1215                 context_multi_line = ''
1216
1217
1218             for i in line_split:
1219                 vert_loc_index = int(i)-1
1220
1221                 if vert_loc_index < 0:
1222                     vert_loc_index= len(verts_loc) + vert_loc_index + 1
1223
1224                 curv_idx.append(vert_loc_index)
1225
1226         elif line.startswith('parm') or context_multi_line == 'parm':
1227             line_split= line.split()
1228
1229             if context_multi_line:
1230                 context_multi_line = ''
1231             else:
1232                 context_parm = line_split[1]
1233                 line_split[0:2] = [] # remove first 2
1234
1235             if strip_slash(line_split):
1236                 context_multi_line = 'parm'
1237             else:
1238                 context_multi_line = ''
1239
1240             if context_parm.lower() == 'u':
1241                 context_nurbs.setdefault('parm_u', []).extend( [float_func(f) for f in line_split] )
1242             elif context_parm.lower() == 'v': # surfaces not suported yet
1243                 context_nurbs.setdefault('parm_v', []).extend( [float_func(f) for f in line_split] )
1244             # else: # may want to support other parm's ?
1245
1246         elif line.startswith('deg '):
1247             context_nurbs['deg']= [int(i) for i in line.split()[1:]]
1248         elif line.startswith('end'):
1249             # Add the nurbs curve
1250             if context_object:
1251                 context_nurbs['name'] = context_object
1252             nurbs.append(context_nurbs)
1253             context_nurbs = {}
1254             context_parm = ''
1255
1256         ''' # How to use usemap? depricated?
1257         elif line.startswith('usema'): # usemap or usemat
1258             context_image= line_value(line.split())
1259         '''
1260
1261     file.close()
1262     time_new= time.time()
1263 #       time_new= sys.time()
1264     print('%.4f sec' % (time_new-time_sub))
1265     time_sub= time_new
1266
1267
1268     print('\tloading materials and images...')
1269     create_materials(filepath, material_libs, unique_materials, unique_material_images, IMAGE_SEARCH)
1270
1271     time_new= time.time()
1272 #       time_new= sys.time()
1273     print('%.4f sec' % (time_new-time_sub))
1274     time_sub= time_new
1275
1276     if not ROTATE_X90:
1277         verts_loc[:] = [(v[0], v[2], -v[1]) for v in verts_loc]
1278
1279     # deselect all
1280 #       if context.selected_objects:
1281 #               bpy.ops.OBJECT_OT_select_all()
1282
1283     scene = context.scene
1284 #       scn = bpy.data.scenes.active
1285 #       scn.objects.selected = []
1286     new_objects= [] # put new objects here
1287
1288     print('\tbuilding geometry...\n\tverts:%i faces:%i materials: %i smoothgroups:%i ...' % ( len(verts_loc), len(faces), len(unique_materials), len(unique_smooth_groups) ))
1289     # Split the mesh by objects/materials, may
1290     if SPLIT_OBJECTS or SPLIT_GROUPS:   SPLIT_OB_OR_GROUP = True
1291     else:                                                               SPLIT_OB_OR_GROUP = False
1292
1293     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):
1294         # Create meshes from the data, warning 'vertex_groups' wont support splitting
1295         create_mesh(scene, new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc_split, verts_tex, faces_split, unique_materials_split, unique_material_images, unique_smooth_groups, vertex_groups, dataname)
1296
1297     # nurbs support
1298 #       for context_nurbs in nurbs:
1299 #               create_nurbs(scn, context_nurbs, verts_loc, new_objects)
1300
1301
1302     axis_min= [ 1000000000]*3
1303     axis_max= [-1000000000]*3
1304
1305 #       if CLAMP_SIZE:
1306 #               # Get all object bounds
1307 #               for ob in new_objects:
1308 #                       for v in ob.getBoundBox():
1309 #                               for axis, value in enumerate(v):
1310 #                                       if axis_min[axis] > value:      axis_min[axis]= value
1311 #                                       if axis_max[axis] < value:      axis_max[axis]= value
1312
1313 #               # Scale objects
1314 #               max_axis= max(axis_max[0]-axis_min[0], axis_max[1]-axis_min[1], axis_max[2]-axis_min[2])
1315 #               scale= 1.0
1316
1317 #               while CLAMP_SIZE < max_axis * scale:
1318 #                       scale= scale/10.0
1319
1320 #               for ob in new_objects:
1321 #                       ob.setSize(scale, scale, scale)
1322
1323     # Better rotate the vert locations
1324     #if not ROTATE_X90:
1325     #   for ob in new_objects:
1326     #           ob.RotX = -1.570796326794896558
1327
1328     time_new= time.time()
1329 #       time_new= sys.time()
1330
1331     print('%.4f sec' % (time_new-time_sub))
1332     print('finished importing: "%s" in %.4f sec.' % (filepath, (time_new-time_main)))
1333
1334
1335 DEBUG= True
1336
1337
1338 def load_obj_ui(filepath, BATCH_LOAD= False):
1339     if BPyMessages.Error_NoFile(filepath):
1340         return
1341
1342     global CREATE_SMOOTH_GROUPS, CREATE_FGONS, CREATE_EDGES, SPLIT_OBJECTS, SPLIT_GROUPS, SPLIT_MATERIALS, CLAMP_SIZE, IMAGE_SEARCH, POLYGROUPS, KEEP_VERT_ORDER, ROTATE_X90
1343
1344     CREATE_SMOOTH_GROUPS= Draw.Create(0)
1345     CREATE_FGONS= Draw.Create(1)
1346     CREATE_EDGES= Draw.Create(1)
1347     SPLIT_OBJECTS= Draw.Create(0)
1348     SPLIT_GROUPS= Draw.Create(0)
1349     SPLIT_MATERIALS= Draw.Create(0)
1350     CLAMP_SIZE= Draw.Create(10.0)
1351     IMAGE_SEARCH= Draw.Create(1)
1352     POLYGROUPS= Draw.Create(0)
1353     KEEP_VERT_ORDER= Draw.Create(1)
1354     ROTATE_X90= Draw.Create(1)
1355
1356
1357     # Get USER Options
1358     # Note, Works but not pretty, instead use a more complicated GUI
1359     '''
1360     pup_block= [\
1361     'Import...',\
1362     ('Smooth Groups', CREATE_SMOOTH_GROUPS, 'Surround smooth groups by sharp edges'),\
1363     ('Create FGons', CREATE_FGONS, 'Import faces with more then 4 verts as fgons.'),\
1364     ('Lines', CREATE_EDGES, 'Import lines and faces with 2 verts as edges'),\
1365     'Separate objects from obj...',\
1366     ('Object', SPLIT_OBJECTS, 'Import OBJ Objects into Blender Objects'),\
1367     ('Group', SPLIT_GROUPS, 'Import OBJ Groups into Blender Objects'),\
1368     ('Material', SPLIT_MATERIALS, 'Import each material into a seperate mesh (Avoids > 16 per mesh error)'),\
1369     'Options...',\
1370     ('Keep Vert Order', KEEP_VERT_ORDER, 'Keep vert and face order, disables some other options.'),\
1371     ('Clamp Scale:', CLAMP_SIZE, 0.0, 1000.0, 'Clamp the size to this maximum (Zero to Disable)'),\
1372     ('Image Search', IMAGE_SEARCH, 'Search subdirs for any assosiated images (Warning, may be slow)'),\
1373     ]
1374
1375     if not Draw.PupBlock('Import OBJ...', pup_block):
1376         return
1377
1378     if KEEP_VERT_ORDER.val:
1379         SPLIT_OBJECTS.val = False
1380         SPLIT_GROUPS.val = False
1381         SPLIT_MATERIALS.val = False
1382     '''
1383
1384
1385
1386     # BEGIN ALTERNATIVE UI *******************
1387     if True:
1388
1389         EVENT_NONE = 0
1390         EVENT_EXIT = 1
1391         EVENT_REDRAW = 2
1392         EVENT_IMPORT = 3
1393
1394         GLOBALS = {}
1395         GLOBALS['EVENT'] = EVENT_REDRAW
1396         #GLOBALS['MOUSE'] = Window.GetMouseCoords()
1397         GLOBALS['MOUSE'] = [i/2 for i in Window.GetScreenSize()]
1398
1399         def obj_ui_set_event(e,v):
1400             GLOBALS['EVENT'] = e
1401
1402         def do_split(e,v):
1403             global SPLIT_OBJECTS, SPLIT_GROUPS, SPLIT_MATERIALS, KEEP_VERT_ORDER, POLYGROUPS
1404             if SPLIT_OBJECTS.val or SPLIT_GROUPS.val or SPLIT_MATERIALS.val:
1405                 KEEP_VERT_ORDER.val = 0
1406                 POLYGROUPS.val = 0
1407             else:
1408                 KEEP_VERT_ORDER.val = 1
1409
1410         def do_vertorder(e,v):
1411             global SPLIT_OBJECTS, SPLIT_GROUPS, SPLIT_MATERIALS, KEEP_VERT_ORDER
1412             if KEEP_VERT_ORDER.val:
1413                 SPLIT_OBJECTS.val = SPLIT_GROUPS.val = SPLIT_MATERIALS.val = 0
1414             else:
1415                 if not (SPLIT_OBJECTS.val or SPLIT_GROUPS.val or SPLIT_MATERIALS.val):
1416                     KEEP_VERT_ORDER.val = 1
1417
1418         def do_polygroups(e,v):
1419             global SPLIT_OBJECTS, SPLIT_GROUPS, SPLIT_MATERIALS, KEEP_VERT_ORDER, POLYGROUPS
1420             if POLYGROUPS.val:
1421                 SPLIT_OBJECTS.val = SPLIT_GROUPS.val = SPLIT_MATERIALS.val = 0
1422
1423         def do_help(e,v):
1424             url = __url__[0]
1425             print('Trying to open web browser with documentation at this address...')
1426             print('\t' + url)
1427
1428             try:
1429                 import webbrowser
1430                 webbrowser.open(url)
1431             except:
1432                 print('...could not open a browser window.')
1433
1434         def obj_ui():
1435             ui_x, ui_y = GLOBALS['MOUSE']
1436
1437             # Center based on overall pup size
1438             ui_x -= 165
1439             ui_y -= 90
1440
1441             global CREATE_SMOOTH_GROUPS, CREATE_FGONS, CREATE_EDGES, SPLIT_OBJECTS, SPLIT_GROUPS, SPLIT_MATERIALS, CLAMP_SIZE, IMAGE_SEARCH, POLYGROUPS, KEEP_VERT_ORDER, ROTATE_X90
1442
1443             Draw.Label('Import...', ui_x+9, ui_y+159, 220, 21)
1444             Draw.BeginAlign()
1445             CREATE_SMOOTH_GROUPS = Draw.Toggle('Smooth Groups', EVENT_NONE, ui_x+9, ui_y+139, 110, 20, CREATE_SMOOTH_GROUPS.val, 'Surround smooth groups by sharp edges')
1446             CREATE_FGONS = Draw.Toggle('NGons as FGons', EVENT_NONE, ui_x+119, ui_y+139, 110, 20, CREATE_FGONS.val, 'Import faces with more then 4 verts as fgons')
1447             CREATE_EDGES = Draw.Toggle('Lines as Edges', EVENT_NONE, ui_x+229, ui_y+139, 110, 20, CREATE_EDGES.val, 'Import lines and faces with 2 verts as edges')
1448             Draw.EndAlign()
1449
1450             Draw.Label('Separate objects by OBJ...', ui_x+9, ui_y+110, 220, 20)
1451             Draw.BeginAlign()
1452             SPLIT_OBJECTS = Draw.Toggle('Object', EVENT_REDRAW, ui_x+9, ui_y+89, 55, 21, SPLIT_OBJECTS.val, 'Import OBJ Objects into Blender Objects', do_split)
1453             SPLIT_GROUPS = Draw.Toggle('Group', EVENT_REDRAW, ui_x+64, ui_y+89, 55, 21, SPLIT_GROUPS.val, 'Import OBJ Groups into Blender Objects', do_split)
1454             SPLIT_MATERIALS = Draw.Toggle('Material', EVENT_REDRAW, ui_x+119, ui_y+89, 60, 21, SPLIT_MATERIALS.val, 'Import each material into a seperate mesh (Avoids > 16 per mesh error)', do_split)
1455             Draw.EndAlign()
1456
1457             # Only used for user feedback
1458             KEEP_VERT_ORDER = Draw.Toggle('Keep Vert Order', EVENT_REDRAW, ui_x+184, ui_y+89, 113, 21, KEEP_VERT_ORDER.val, 'Keep vert and face order, disables split options, enable for morph targets', do_vertorder)
1459
1460             ROTATE_X90 = Draw.Toggle('-X90', EVENT_REDRAW, ui_x+302, ui_y+89, 38, 21, ROTATE_X90.val, 'Rotate X 90.')
1461
1462             Draw.Label('Options...', ui_x+9, ui_y+60, 211, 20)
1463             CLAMP_SIZE = Draw.Number('Clamp Scale: ', EVENT_NONE, ui_x+9, ui_y+39, 130, 21, CLAMP_SIZE.val, 0.0, 1000.0, 'Clamp the size to this maximum (Zero to Disable)')
1464             POLYGROUPS = Draw.Toggle('Poly Groups', EVENT_REDRAW, ui_x+144, ui_y+39, 90, 21, POLYGROUPS.val, 'Import OBJ groups as vertex groups.', do_polygroups)
1465             IMAGE_SEARCH = Draw.Toggle('Image Search', EVENT_NONE, ui_x+239, ui_y+39, 100, 21, IMAGE_SEARCH.val, 'Search subdirs for any assosiated images (Warning, may be slow)')
1466             Draw.BeginAlign()
1467             Draw.PushButton('Online Help', EVENT_REDRAW, ui_x+9, ui_y+9, 110, 21, 'Load the wiki page for this script', do_help)
1468             Draw.PushButton('Cancel', EVENT_EXIT, ui_x+119, ui_y+9, 110, 21, '', obj_ui_set_event)
1469             Draw.PushButton('Import', EVENT_IMPORT, ui_x+229, ui_y+9, 110, 21, 'Import with these settings', obj_ui_set_event)
1470             Draw.EndAlign()
1471
1472
1473         # hack so the toggle buttons redraw. this is not nice at all
1474         while GLOBALS['EVENT'] not in (EVENT_EXIT, EVENT_IMPORT):
1475             Draw.UIBlock(obj_ui, 0)
1476
1477         if GLOBALS['EVENT'] != EVENT_IMPORT:
1478             return
1479
1480     # END ALTERNATIVE UI *********************
1481
1482
1483
1484
1485
1486
1487
1488     Window.WaitCursor(1)
1489
1490     if BATCH_LOAD: # load the dir
1491         try:
1492             files= [ f for f in os.listdir(filepath) if f.lower().endswith('.obj') ]
1493         except:
1494             Window.WaitCursor(0)
1495             Draw.PupMenu('Error%t|Could not open path ' + filepath)
1496             return
1497
1498         if not files:
1499             Window.WaitCursor(0)
1500             Draw.PupMenu('Error%t|No files at path ' + filepath)
1501             return
1502
1503         for f in files:
1504             scn= bpy.data.scenes.new( stripExt(f) )
1505             scn.makeCurrent()
1506
1507             load_obj(sys.join(filepath, f),\
1508               CLAMP_SIZE.val,\
1509               CREATE_FGONS.val,\
1510               CREATE_SMOOTH_GROUPS.val,\
1511               CREATE_EDGES.val,\
1512               SPLIT_OBJECTS.val,\
1513               SPLIT_GROUPS.val,\
1514               SPLIT_MATERIALS.val,\
1515               ROTATE_X90.val,\
1516               IMAGE_SEARCH.val,\
1517               POLYGROUPS.val
1518             )
1519
1520     else: # Normal load
1521         load_obj(filepath,\
1522           CLAMP_SIZE.val,\
1523           CREATE_FGONS.val,\
1524           CREATE_SMOOTH_GROUPS.val,\
1525           CREATE_EDGES.val,\
1526           SPLIT_OBJECTS.val,\
1527           SPLIT_GROUPS.val,\
1528           SPLIT_MATERIALS.val,\
1529           ROTATE_X90.val,\
1530           IMAGE_SEARCH.val,\
1531           POLYGROUPS.val
1532         )
1533
1534     Window.WaitCursor(0)
1535
1536
1537 def load_obj_ui_batch(file):
1538     load_obj_ui(file, True)
1539
1540 DEBUG= False
1541
1542 # if __name__=='__main__' and not DEBUG:
1543 #       if os and Window.GetKeyQualifiers() & Window.Qual.SHIFT:
1544 #               Window.FileSelector(load_obj_ui_batch, 'Import OBJ Dir', '')
1545 #       else:
1546 #               Window.FileSelector(load_obj_ui, 'Import a Wavefront OBJ', '*.obj')
1547
1548     # For testing compatibility
1549 '''
1550 else:
1551     # DEBUG ONLY
1552     TIME= sys.time()
1553     DIR = '/fe/obj'
1554     import os
1555     print 'Searching for files'
1556     def fileList(path):
1557         for dirpath, dirnames, filenames in os.walk(path):
1558             for filename in filenames:
1559                 yield os.path.join(dirpath, filename)
1560
1561     files = [f for f in fileList(DIR) if f.lower().endswith('.obj')]
1562     files.sort()
1563
1564     for i, obj_file in enumerate(files):
1565         if 0 < i < 20:
1566             print 'Importing', obj_file, '\nNUMBER', i, 'of', len(files)
1567             newScn= bpy.data.scenes.new(os.path.basename(obj_file))
1568             newScn.makeCurrent()
1569             load_obj(obj_file, False, IMAGE_SEARCH=0)
1570
1571     print 'TOTAL TIME: %.6f' % (sys.time() - TIME)
1572 '''
1573
1574 from bpy.props import *
1575
1576 class IMPORT_OT_obj(bpy.types.Operator):
1577     '''Load a Wavefront OBJ File.'''
1578     bl_idname = "import_scene.obj"
1579     bl_label = "Import OBJ"
1580
1581     # List of operator properties, the attributes will be assigned
1582     # to the class instance from the operator settings before calling.
1583
1584
1585     path = StringProperty(name="File Path", description="File path used for importing the OBJ file", maxlen= 1024, default= "")
1586
1587     CREATE_SMOOTH_GROUPS = BoolProperty(name="Smooth Groups", description="Surround smooth groups by sharp edges", default= True)
1588     CREATE_FGONS = BoolProperty(name="NGons as FGons", description="Import faces with more then 4 verts as fgons", default= True)
1589     CREATE_EDGES = BoolProperty(name="Lines as Edges", description="Import lines and faces with 2 verts as edge", default= True)
1590     SPLIT_OBJECTS = BoolProperty(name="Object", description="Import OBJ Objects into Blender Objects", default= True)
1591     SPLIT_GROUPS = BoolProperty(name="Group", description="Import OBJ Groups into Blender Objects", default= True)
1592     SPLIT_MATERIALS = BoolProperty(name="Material", description="Import each material into a seperate mesh (Avoids > 16 per mesh error)", default= True)
1593     # old comment: only used for user feedback
1594     # disabled this option because in old code a handler for it disabled SPLIT* params, it's not passed to load_obj
1595     # KEEP_VERT_ORDER = BoolProperty(name="Keep Vert Order", description="Keep vert and face order, disables split options, enable for morph targets", default= True)
1596     ROTATE_X90 = BoolProperty(name="-X90", description="Rotate X 90.", default= True)
1597     CLAMP_SIZE = FloatProperty(name="Clamp Scale", description="Clamp the size to this maximum (Zero to Disable)", min=0.0, max=1000.0, soft_min=0.0, soft_max=1000.0, default=0.0)
1598     POLYGROUPS = BoolProperty(name="Poly Groups", description="Import OBJ groups as vertex groups.", default= True)
1599     IMAGE_SEARCH = BoolProperty(name="Image Search", description="Search subdirs for any assosiated images (Warning, may be slow)", default= True)
1600
1601
1602     def execute(self, context):
1603         # print("Selected: " + context.active_object.name)
1604
1605         load_obj(self.properties.path,
1606                  context,
1607                  self.properties.CLAMP_SIZE,
1608                  self.properties.CREATE_FGONS,
1609                  self.properties.CREATE_SMOOTH_GROUPS,
1610                  self.properties.CREATE_EDGES,
1611                  self.properties.SPLIT_OBJECTS,
1612                  self.properties.SPLIT_GROUPS,
1613                  self.properties.SPLIT_MATERIALS,
1614                  self.properties.ROTATE_X90,
1615                  self.properties.IMAGE_SEARCH,
1616                  self.properties.POLYGROUPS)
1617
1618         return {'FINISHED'}
1619
1620     def invoke(self, context, event):
1621         wm = context.manager
1622         wm.add_fileselect(self)
1623         return {'RUNNING_MODAL'}
1624
1625
1626 menu_func = lambda self, context: self.layout.operator(IMPORT_OT_obj.bl_idname, text="Wavefront (.obj)...")
1627
1628
1629 def register():
1630     bpy.types.register(IMPORT_OT_obj)
1631     bpy.types.INFO_MT_file_export.append(menu_func)
1632     
1633 def unregister():
1634     bpy.types.unregister(IMPORT_OT_obj)
1635     bpy.types.INFO_MT_file_export.remove(menu_func)
1636
1637
1638 # NOTES (all line numbers refer to 2.4x import_obj.py, not this file)
1639 # check later: line 489
1640 # can convert now: edge flags, edges: lines 508-528
1641 # ngon (uses python module BPyMesh): 384-414
1642 # nurbs: 947-
1643 # NEXT clamp size: get bound box with RNA
1644 # get back to l 140 (here)
1645 # search image in bpy.config.textureDir - load_image
1646 # replaced BPyImage.comprehensiveImageLoad with a simplified version that only checks additional directory specified, but doesn't search dirs recursively (obj_image_load)
1647 # bitmask won't work? - 132
1648 # uses operator bpy.ops.OBJECT_OT_select_all() to deselect all (not necessary?)
1649 # uses bpy.sys.time()