- added Mesh.transform
authorArystanbek Dyussenov <arystan.d@gmail.com>
Tue, 23 Jun 2009 17:52:58 +0000 (17:52 +0000)
committerArystanbek Dyussenov <arystan.d@gmail.com>
Tue, 23 Jun 2009 17:52:58 +0000 (17:52 +0000)
- fixed Object.create_dupli_list
- continuing OBJ exporter conversion

release/scripts/export_obj-2.5.py
source/blender/makesrna/intern/rna_mesh_api.c
source/blender/makesrna/intern/rna_object.c
source/blender/makesrna/intern/rna_object_api.c

index a9abba22944222c990eabec368fa11dced752409..4fa02ce2efea284548afa8a6880b017f74fa46fe 100644 (file)
@@ -186,7 +186,7 @@ def copy_images(dest_dir):
 
 
 def test_nurbs_compat(ob):
-       if ob.type != 'Curve':
+       if ob.type != 'CURVE':
                return False
        
        for nu in ob.data:
@@ -353,8 +353,328 @@ EXPORT_POLYGROUPS=False, EXPORT_CURVE_AS_NURBS=True):
                if ob_main.dupli_type != 'NONE':
                        ob_main.create_dupli_list()
 
-               if ob_main.parent:
-                       pass
+               # ignore dupli children
+               if ob_main.parent.dupli_type != 'NONE':
+                       continue
+
+               obs = []
+               if ob_main.dupli_type != 'NONE':
+                       obs = [(dob.matrix, dob.object) for dob in ob_main.dupli_list]
+               else:
+                       obs = [ob.matrix, ob]
+
+               for ob, ob_mat in obs:
+                       # XXX postponed
+#                      # Nurbs curve support
+#                      if EXPORT_CURVE_AS_NURBS and test_nurbs_compat(ob):
+#                              if EXPORT_ROTX90:
+#                                      ob_mat = ob_mat * mat_xrot90
+                               
+#                              totverts += write_nurb(file, ob, ob_mat)
+                               
+#                              continue
+#                      end nurbs
+                       
+#                      # Will work for non meshes now! :)
+#                      me= BPyMesh.getMeshFromObject(ob, containerMesh, EXPORT_APPLY_MODIFIERS, EXPORT_POLYGROUPS, scn)
+#                      if not me:
+#                              continue
+
+                       if ob.type != 'MESH':
+                               continue
+
+                       me = ob.data
+
+                       # XXX
+#                      if EXPORT_UV:
+#                              faceuv= me.faceUV
+#                      else:
+#                              faceuv = False
+
+                       convert_to_tri = False
+
+                       # We have a valid mesh
+                       if EXPORT_TRI and me.faces:
+                               # Add a dummy object to it.
+                               has_quads = False
+                               for f in me.faces:
+#                                      if len(f) == 4:
+                                       if len(f.verts) == 4:
+                                               has_quads = True
+                                               break
+                               
+                               convert_to_tri = has_quads
+#                                      oldmode = Mesh.Mode()
+#                                      Mesh.Mode(Mesh.SelectModes['FACE'])
+                                       
+#                                      me.sel = True
+#                                      tempob = scn.objects.new(me)
+#                                      me.quadToTriangle(0) # more=0 shortest length
+#                                      oldmode = Mesh.Mode(oldmode)
+#                                      scn.objects.unlink(tempob)
+                                       
+#                                      Mesh.Mode(oldmode)
+
+                       if EXPORT_ROTX90:
+                               ob_mat *= mat_xrot90
+
+                       me = ob.create_render_mesh(True, ob_mat, convert_to_tri)
+
+                       # Make our own list so it can be sorted to reduce context switching
+                       faces = [ f for f in me.faces ]
+                       
+                       if EXPORT_EDGES:
+                               edges = me.edges
+                       else:
+                               edges = []
+                       
+                       if not (len(faces)+len(edges)+len(me.verts)): # Make sure there is somthing to write
+                               continue # dont bother with this mesh.
+
+                       # done above ^
+#                      if EXPORT_ROTX90:
+#                              me.transform(ob_mat*mat_xrot90)
+#                      else:
+#                              me.transform(ob_mat)
+                       
+                       # High Quality Normals
+                       if EXPORT_NORMALS and faces:
+                               if EXPORT_NORMALS_HQ:
+                                       BPyMesh.meshCalcNormals(me)
+                               else:
+                                       # transforming normals is incorrect
+                                       # when the matrix is scaled,
+                                       # better to recalculate them
+                                       me.calcNormals()
+                       
+                       # # Crash Blender
+                       #materials = me.getMaterials(1) # 1 == will return None in the list.
+                       materials = me.materials
+                       
+                       materialNames = []
+                       materialItems = materials[:]
+                       if materials:
+                               for mat in materials:
+                                       if mat: # !=None
+                                               materialNames.append(mat.name)
+                                       else:
+                                               materialNames.append(None)
+                               # Cant use LC because some materials are None.
+                               # materialNames = map(lambda mat: mat.name, materials) # Bug Blender, dosent account for null materials, still broken.  
+                       
+                       # Possible there null materials, will mess up indicies
+                       # but at least it will export, wait until Blender gets fixed.
+                       materialNames.extend((16-len(materialNames)) * [None])
+                       materialItems.extend((16-len(materialItems)) * [None])
+                       
+                       # Sort by Material, then images
+                       # so we dont over context switch in the obj file.
+                       if EXPORT_KEEP_VERT_ORDER:
+                               pass
+                       elif faceuv:
+                               try:    faces.sort(key = lambda a: (a.mat, a.image, a.smooth))
+                               except: faces.sort(lambda a,b: cmp((a.mat, a.image, a.smooth), (b.mat, b.image, b.smooth)))
+                       elif len(materials) > 1:
+                               try:    faces.sort(key = lambda a: (a.mat, a.smooth))
+                               except: faces.sort(lambda a,b: cmp((a.mat, a.smooth), (b.mat, b.smooth)))
+                       else:
+                               # no materials
+                               try:    faces.sort(key = lambda a: a.smooth)
+                               except: faces.sort(lambda a,b: cmp(a.smooth, b.smooth))
+                       
+                       # Set the default mat to no material and no image.
+                       contextMat = (0, 0) # Can never be this, so we will label a new material teh first chance we get.
+                       contextSmooth = None # Will either be true or false,  set bad to force initialization switch.
+                       
+                       if EXPORT_BLEN_OBS or EXPORT_GROUP_BY_OB:
+                               name1 = ob.name
+                               name2 = ob.getData(1)
+                               if name1 == name2:
+                                       obnamestring = fixName(name1)
+                               else:
+                                       obnamestring = '%s_%s' % (fixName(name1), fixName(name2))
+                               
+                               if EXPORT_BLEN_OBS:
+                                       file.write('o %s\n' % obnamestring) # Write Object name
+                               else: # if EXPORT_GROUP_BY_OB:
+                                       file.write('g %s\n' % obnamestring)
+                       
+                       
+                       # Vert
+                       for v in me.verts:
+                               file.write('v %.6f %.6f %.6f\n' % tuple(v.co))
+                       
+                       # UV
+                       if faceuv:
+                               uv_face_mapping = [[0,0,0,0] for f in faces] # a bit of a waste for tri's :/
+                               
+                               uv_dict = {} # could use a set() here
+                               for f_index, f in enumerate(faces):
+                                       
+                                       for uv_index, uv in enumerate(f.uv):
+                                               uvkey = veckey2d(uv)
+                                               try:
+                                                       uv_face_mapping[f_index][uv_index] = uv_dict[uvkey]
+                                               except:
+                                                       uv_face_mapping[f_index][uv_index] = uv_dict[uvkey] = len(uv_dict)
+                                                       file.write('vt %.6f %.6f\n' % tuple(uv))
+                               
+                               uv_unique_count = len(uv_dict)
+                               del uv, uvkey, uv_dict, f_index, uv_index
+                               # Only need uv_unique_count and uv_face_mapping
+                       
+                       # NORMAL, Smooth/Non smoothed.
+                       if EXPORT_NORMALS:
+                               for f in faces:
+                                       if f.smooth:
+                                               for v in f:
+                                                       noKey = veckey3d(v.no)
+                                                       if not globalNormals.has_key( noKey ):
+                                                               globalNormals[noKey] = totno
+                                                               totno +=1
+                                                               file.write('vn %.6f %.6f %.6f\n' % noKey)
+                                       else:
+                                               # Hard, 1 normal from the face.
+                                               noKey = veckey3d(f.no)
+                                               if not globalNormals.has_key( noKey ):
+                                                       globalNormals[noKey] = totno
+                                                       totno +=1
+                                                       file.write('vn %.6f %.6f %.6f\n' % noKey)
+                       
+                       if not faceuv:
+                               f_image = None
+                       
+                       if EXPORT_POLYGROUPS:
+                               # Retrieve the list of vertex groups
+                               vertGroupNames = me.getVertGroupNames()
+
+                               currentVGroup = ''
+                               # Create a dictionary keyed by face id and listing, for each vertex, the vertex groups it belongs to
+                               vgroupsMap = [[] for _i in xrange(len(me.verts))]
+                               for vertexGroupName in vertGroupNames:
+                                       for vIdx, vWeight in me.getVertsFromGroup(vertexGroupName, 1):
+                                               vgroupsMap[vIdx].append((vertexGroupName, vWeight))
+
+                       for f_index, f in enumerate(faces):
+                               f_v= f.v
+                               f_smooth= f.smooth
+                               f_mat = min(f.mat, len(materialNames)-1)
+                               if faceuv:
+                                       f_image = f.image
+                                       f_uv= f.uv
+                               
+                               # MAKE KEY
+                               if faceuv and f_image: # Object is always true.
+                                       key = materialNames[f_mat],      f_image.name
+                               else:
+                                       key = materialNames[f_mat],      None # No image, use None instead.
+                               
+                               # Write the vertex group
+                               if EXPORT_POLYGROUPS:
+                                       if vertGroupNames:
+                                               # find what vertext group the face belongs to
+                                               theVGroup = findVertexGroupName(f,vgroupsMap)
+                                               if      theVGroup != currentVGroup:
+                                                       currentVGroup = theVGroup
+                                                       file.write('g %s\n' % theVGroup)
+
+                               # CHECK FOR CONTEXT SWITCH
+                               if key == contextMat:
+                                       pass # Context alredy switched, dont do anything
+                               else:
+                                       if key[0] == None and key[1] == None:
+                                               # Write a null material, since we know the context has changed.
+                                               if EXPORT_GROUP_BY_MAT:
+                                                       file.write('g %s_%s\n' % (fixName(ob.name), fixName(ob.getData(1))) ) # can be mat_image or (null)
+                                               file.write('usemtl (null)\n') # mat, image
+                                               
+                                       else:
+                                               mat_data= MTL_DICT.get(key)
+                                               if not mat_data:
+                                                       # First add to global dict so we can export to mtl
+                                                       # Then write mtl
+                                                       
+                                                       # Make a new names from the mat and image name,
+                                                       # converting any spaces to underscores with fixName.
+                                                       
+                                                       # If none image dont bother adding it to the name
+                                                       if key[1] == None:
+                                                               mat_data = MTL_DICT[key] = ('%s'%fixName(key[0])), materialItems[f_mat], f_image
+                                                       else:
+                                                               mat_data = MTL_DICT[key] = ('%s_%s' % (fixName(key[0]), fixName(key[1]))), materialItems[f_mat], f_image
+                                               
+                                               if EXPORT_GROUP_BY_MAT:
+                                                       file.write('g %s_%s_%s\n' % (fixName(ob.name), fixName(ob.getData(1)), mat_data[0]) ) # can be mat_image or (null)
+
+                                               file.write('usemtl %s\n' % mat_data[0]) # can be mat_image or (null)
+                                       
+                               contextMat = key
+                               if f_smooth != contextSmooth:
+                                       if f_smooth: # on now off
+                                               file.write('s 1\n')
+                                               contextSmooth = f_smooth
+                                       else: # was off now on
+                                               file.write('s off\n')
+                                               contextSmooth = f_smooth
+                               
+                               file.write('f')
+                               if faceuv:
+                                       if EXPORT_NORMALS:
+                                               if f_smooth: # Smoothed, use vertex normals
+                                                       for vi, v in enumerate(f_v):
+                                                               file.write( ' %d/%d/%d' % (\
+                                                                 v.index+totverts,\
+                                                                 totuvco + uv_face_mapping[f_index][vi],\
+                                                                 globalNormals[ veckey3d(v.no) ])) # vert, uv, normal
+                                                       
+                                               else: # No smoothing, face normals
+                                                       no = globalNormals[ veckey3d(f.no) ]
+                                                       for vi, v in enumerate(f_v):
+                                                               file.write( ' %d/%d/%d' % (\
+                                                                 v.index+totverts,\
+                                                                 totuvco + uv_face_mapping[f_index][vi],\
+                                                                 no)) # vert, uv, normal
+                                       
+                                       else: # No Normals
+                                               for vi, v in enumerate(f_v):
+                                                       file.write( ' %d/%d' % (\
+                                                         v.index+totverts,\
+                                                         totuvco + uv_face_mapping[f_index][vi])) # vert, uv
+                                       
+                                       face_vert_index += len(f_v)
+                               
+                               else: # No UV's
+                                       if EXPORT_NORMALS:
+                                               if f_smooth: # Smoothed, use vertex normals
+                                                       for v in f_v:
+                                                               file.write( ' %d//%d' % (\
+                                                                 v.index+totverts,\
+                                                                 globalNormals[ veckey3d(v.no) ]))
+                                               else: # No smoothing, face normals
+                                                       no = globalNormals[ veckey3d(f.no) ]
+                                                       for v in f_v:
+                                                               file.write( ' %d//%d' % (\
+                                                                 v.index+totverts,\
+                                                                 no))
+                                       else: # No Normals
+                                               for v in f_v:
+                                                       file.write( ' %d' % (\
+                                                         v.index+totverts))
+                                               
+                               file.write('\n')
+                       
+                       # Write edges.
+                       if EXPORT_EDGES:
+                               LOOSE= Mesh.EdgeFlags.LOOSE
+                               for ed in edges:
+                                       if ed.flag & LOOSE:
+                                               file.write('f %d %d\n' % (ed.v1.index+totverts, ed.v2.index+totverts))
+                               
+                       # Make the indicies global rather then per mesh
+                       totverts += len(me.verts)
+                       if faceuv:
+                               totuvco += uv_unique_count
+                       me.verts= None                  
 
                if ob_main.dupli_type != 'NONE':
                        ob_main.free_dupli_list()
index 26fb77777d7c92f830d66ccf69de27e15c76f7a9..0aa4faeddd809d1e080e27b68b28fa170447340c 100644 (file)
@@ -54,8 +54,15 @@ void rna_Mesh_copy_applied(Mesh *me, Scene *sce, Object *ob)
 }
 */
 
-void rna_Mesh_transform(Mesh *me, float **mat)
+void rna_Mesh_transform(Mesh *me, float *mat)
 {
+       /* TODO: old API transform had recalc_normals option */
+       int i;
+       MVert *mvert= me->mvert;
+
+       for(i= 0; i < mesh->totvert; i++, mvert++) {
+               Mat4MulVecfl(mat, mvert->co);
+       }
 }
 
 #if 0
@@ -85,14 +92,13 @@ static void rna_Mesh_verts_add(PointerRNA *ptr, PointerRNA *ptr_item)
 
 void RNA_api_mesh(StructRNA *srna)
 {
-       /*FunctionRNA *func;
-       PropertyRNA *prop;*/
+       FunctionRNA *func;
+       PropertyRNA *parm;
 
-       /*
-       func= RNA_def_function(srna, "copy", "rna_Mesh_copy");
-       RNA_def_function_ui_description(func, "Copy mesh data.");
-       prop= RNA_def_pointer(func, "src", "Mesh", "", "A mesh to copy data from.");
-       RNA_def_property_flag(prop, PROP_REQUIRED);*/
+       func= RNA_def_function(srna, "transform", "rna_Mesh_transform");
+       RNA_def_function_ui_description(func, "Transform mesh vertices by a matrix.");
+       parm= RNA_def_float_matrix(func, "matrix", 16, NULL, 0.0f, 0.0f, "", "Matrix.", 0.0f, 0.0f);
+       RNA_def_property_flag(parm, PROP_REQUIRED);
 
        /*
        func= RNA_def_function(srna, "add_geom", "rna_Mesh_add_geom");
index d566af1954c626fbd805fe78ea5b35cee93fb8c6..14ce5954cb7c946d19fa82407525193423fbbde1 100644 (file)
@@ -1028,6 +1028,12 @@ static void rna_def_object(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Dupli Frames Off", "Recurring frames to exclude from the Dupliframes.");
        RNA_def_property_update(prop, NC_OBJECT|ND_DRAW, "rna_Object_update");
 
+       prop= RNA_def_property(srna, "dupli_list", PROP_COLLECTION, PROP_NONE);
+       RNA_def_property_collection_sdna(prop, NULL, "duplilist", NULL);
+       RNA_def_property_struct_type(prop, "DupliObject");
+       RNA_def_property_ui_text(prop, "Dupli list", "Object duplis.");
+
+
        /* time offset */
 
        prop= RNA_def_property(srna, "time_offset", PROP_FLOAT, PROP_NONE);
index c3740921f0f3a171eb863c9a606e201d9977f4e5..69d3f48761cdafd266cb6202a43bea64214c4beb 100644 (file)
@@ -45,7 +45,7 @@
 #include "DNA_scene_types.h"
 #include "DNA_meshdata_types.h"
 
-#define OBJECT_API_PROP_DUPLILIST "dupli_list"
+#include "BLI_arithb.h"
 
 /* copied from init_render_mesh (render code) */
 static Mesh *rna_Object_create_render_mesh(Object *ob, bContext *C, ReportList *reports, int apply_matrix, float *matrix)
@@ -78,7 +78,7 @@ static Mesh *rna_Object_create_render_mesh(Object *ob, bContext *C, ReportList *
        dm->release(dm);
 
        if (apply_matrix) {
-               float *mat = ob->obmat;
+               float *mat = (float*)ob->obmat;
 
                if (matrix) {
                        /* apply custom matrix */
@@ -97,33 +97,20 @@ static Mesh *rna_Object_create_render_mesh(Object *ob, bContext *C, ReportList *
 /* When no longer needed, duplilist should be freed with Object.free_duplilist */
 static void rna_Object_create_duplilist(Object *ob, bContext *C, ReportList *reports)
 {
-       PointerRNA obptr;
-       PointerRNA dobptr;
-       Scene *sce;
-       DupliObject *dob;
-       PropertyRNA *prop;
-
        if (!(ob->transflag & OB_DUPLI)) {
                BKE_report(reports, RPT_ERROR, "Object does not have duplis.");
                return;
        }
 
-       RNA_id_pointer_create(&ob->id, &obptr);
+       /* free duplilist if a user forget to */
+       if (ob->duplilist) {
+               BKE_report(reports, RPT_WARNING, "%s.dupli_list has not been freed.", RNA_struct_identifier(&RNA_Object));
 
-       if (!(prop= RNA_struct_find_property(&obptr, OBJECT_API_PROP_DUPLILIST))) {
-               // hint: all Objects will now have this property defined
-               prop= RNA_def_collection_runtime(obptr.type, OBJECT_API_PROP_DUPLILIST, &RNA_DupliObject, "Dupli list", "");
+               free_object_duplilist(ob->duplilist);
+               ob->duplilist= NULL;
        }
 
-       RNA_property_collection_clear(&obptr, prop);
-       sce= CTX_data_scene(C);
-       ob->duplilist= object_duplilist(sce, ob);
-
-       for(dob= (DupliObject*)ob->duplilist->first; dob; dob= dob->next) {
-               RNA_pointer_create(NULL, &RNA_DupliObject, dob, &dobptr);
-               RNA_property_collection_add(&obptr, prop, &dobptr);
-               dob = dob->next;
-       }
+       ob->duplilist= object_duplilist(CTX_data_scene(C), ob);
 
        /* ob->duplilist should now be freed with Object.free_duplilist */
 }
@@ -133,15 +120,6 @@ static void rna_Object_free_duplilist(Object *ob, ReportList *reports)
        PointerRNA obptr;
        PropertyRNA *prop;
 
-       RNA_id_pointer_create(&ob->id, &obptr);
-
-       if (!(prop= RNA_struct_find_property(&obptr, OBJECT_API_PROP_DUPLILIST))) {
-               BKE_report(reports, RPT_ERROR, "Object has no duplilist property.");
-               return;
-       }
-
-       RNA_property_collection_clear(&obptr, prop);
-
        if (ob->duplilist) {
                free_object_duplilist(ob->duplilist);
                ob->duplilist= NULL;