- added API functions:
authorArystanbek Dyussenov <arystan.d@gmail.com>
Thu, 2 Jul 2009 20:46:35 +0000 (20:46 +0000)
committerArystanbek Dyussenov <arystan.d@gmail.com>
Thu, 2 Jul 2009 20:46:35 +0000 (20:46 +0000)
 - Mesh.calc_normals
 - Object.add_vertex_to_group
 - Main.add_material
 - Main.add_texture
 - Material.add_texture
- OBJ importer conversion in progress

release/io/export_obj.py
release/io/import_obj.py
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_internal.h
source/blender/makesrna/intern/rna_main_api.c
source/blender/makesrna/intern/rna_material.c
source/blender/makesrna/intern/rna_material_api.c [new file with mode: 0644]
source/blender/makesrna/intern/rna_mesh_api.c
source/blender/makesrna/intern/rna_object_api.c

index d139e87..1ee685a 100644 (file)
@@ -464,7 +464,7 @@ def write(filename, objects, scene,
                        # XXX
                        # High Quality Normals
                        if EXPORT_NORMALS and face_index_pairs:
-                               pass
+                               me.calc_normals()
 #                              if EXPORT_NORMALS_HQ:
 #                                      BPyMesh.meshCalcNormals(me)
 #                              else:
index b81ada1..e16780c 100644 (file)
@@ -42,7 +42,7 @@ Note, This loads mesh objects and materials only, nurbs and curves are not suppo
 
 from Blender import Mesh, Draw, Window, Texture, Material, sys
 import bpy
-import BPyMesh
+import BPyMesh
 import BPyImage
 import BPyMessages
 
@@ -130,9 +130,11 @@ def create_materials(filepath, material_libs, unique_materials, unique_material_
        # This function sets textures defined in .mtl file                                 #
        #==================================================================================#
        def load_material_image(blender_material, context_material_name, imagepath, type):
-               
-               texture= bpy.data.textures.new(type)
-               texture.setType('Image')
+
+               texture= bpy.data.add_texture(type)
+               texture.type= 'IMAGE'
+#              texture= bpy.data.textures.new(type)
+#              texture.setType('Image')
                
                # Absolute path - c:\.. etc would work here
                image= obj_image_load(imagepath, DIR, IMAGE_SEARCH)
@@ -182,7 +184,8 @@ def create_materials(filepath, material_libs, unique_materials, unique_material_
        #Create new materials
        for name in unique_materials: # .keys()
                if name != None:
-                       unique_materials[name]= bpy.data.materials.new(name)
+                       unique_materials[name]= bpy.data.add_material(name)
+#                      unique_materials[name]= bpy.data.materials.new(name)
                        unique_material_images[name]= None, False # assign None to all material images to start with, add to later.
                
        unique_materials[None]= None
@@ -190,7 +193,8 @@ def create_materials(filepath, material_libs, unique_materials, unique_material_
        
        for libname in material_libs:
                mtlpath= DIR + libname
-               if not sys.exists(mtlpath):
+               if not bpy.sys.exists(mtlpath):
+#              if not sys.exists(mtlpath):
                        #print '\tError Missing MTL: "%s"' % mtlpath
                        pass
                else:
@@ -210,17 +214,23 @@ def create_materials(filepath, material_libs, unique_materials, unique_material_
                                        line_split= line.split()
                                        line_lower= line.lower().lstrip()
                                        if line_lower.startswith('ka'):
-                                               context_material.setMirCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
+                                               context_material.mirror_color = (float(line_split[1]), float(line_split[2]), float(line_split[3]))
+#                                              context_material.setMirCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
                                        elif line_lower.startswith('kd'):
-                                               context_material.setRGBCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
+                                               context_material.diffuse_color = (float(line_split[1]), float(line_split[2]), float(line_split[3]))
+#                                              context_material.setRGBCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
                                        elif line_lower.startswith('ks'):
-                                               context_material.setSpecCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
+                                               context_material.specular_color = (float(line_split[1]), float(line_split[2]), float(line_split[3]))
+#                                              context_material.setSpecCol((float(line_split[1]), float(line_split[2]), float(line_split[3])))
                                        elif line_lower.startswith('ns'):
-                                               context_material.setHardness( int((float(line_split[1])*0.51)) )
+                                               context_material.specular_hardness = int((float(line_split[1])*0.51))
+#                                              context_material.setHardness( int((float(line_split[1])*0.51)) )
                                        elif line_lower.startswith('ni'): # Refraction index
-                                               context_material.setIOR( max(1, min(float(line_split[1]), 3))) # Between 1 and 3
+                                               context_material.ior = max(1, min(float(line_split[1]), 3))
+#                                              context_material.setIOR( max(1, min(float(line_split[1]), 3))) # Between 1 and 3
                                        elif line_lower.startswith('d') or line_lower.startswith('tr'):
-                                               context_material.setAlpha(float(line_split[1]))
+                                               context_material.alpha = float(line_split[1])
+#                                              context_material.setAlpha(float(line_split[1]))
                                        elif line_lower.startswith('map_ka'):
                                                img_filepath= line_value(line.split())
                                                if img_filepath:
@@ -395,39 +405,39 @@ def create_mesh(scn, new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_l
                                                edge_dict[i1,i2]=  1
                        
                        # FGons into triangles
-                       if has_ngons and len_face_vert_loc_indicies > 4:
+#                      if has_ngons and len_face_vert_loc_indicies > 4:
                                
-                               ngon_face_indices= BPyMesh.ngon(verts_loc, face_vert_loc_indicies)
-                               faces.extend(\
-                               [(\
-                               [face_vert_loc_indicies[ngon[0]], face_vert_loc_indicies[ngon[1]], face_vert_loc_indicies[ngon[2]] ],\
-                               [face_vert_tex_indicies[ngon[0]], face_vert_tex_indicies[ngon[1]], face_vert_tex_indicies[ngon[2]] ],\
-                               context_material,\
-                               context_smooth_group,\
-                               context_object)\
-                               for ngon in ngon_face_indices]\
-                               )
+#                              ngon_face_indices= BPyMesh.ngon(verts_loc, face_vert_loc_indicies)
+#                              faces.extend(\
+#                              [(\
+#                              [face_vert_loc_indicies[ngon[0]], face_vert_loc_indicies[ngon[1]], face_vert_loc_indicies[ngon[2]] ],\
+#                              [face_vert_tex_indicies[ngon[0]], face_vert_tex_indicies[ngon[1]], face_vert_tex_indicies[ngon[2]] ],\
+#                              context_material,\
+#                              context_smooth_group,\
+#                              context_object)\
+#                              for ngon in ngon_face_indices]\
+#                              )
                                
-                               # edges to make fgons
-                               if CREATE_FGONS:
-                                       edge_users= {}
-                                       for ngon in ngon_face_indices:
-                                               for i in (0,1,2):
-                                                       i1= face_vert_loc_indicies[ngon[i  ]]
-                                                       i2= face_vert_loc_indicies[ngon[i-1]]
-                                                       if i1>i2: i1,i2= i2,i1
+#                              # edges to make fgons
+#                              if CREATE_FGONS:
+#                                      edge_users= {}
+#                                      for ngon in ngon_face_indices:
+#                                              for i in (0,1,2):
+#                                                      i1= face_vert_loc_indicies[ngon[i  ]]
+#                                                      i2= face_vert_loc_indicies[ngon[i-1]]
+#                                                      if i1>i2: i1,i2= i2,i1
                                                        
-                                                       try:
-                                                               edge_users[i1,i2]+=1
-                                                       except KeyError:
-                                                               edge_users[i1,i2]= 1
+#                                                      try:
+#                                                              edge_users[i1,i2]+=1
+#                                                      except KeyError:
+#                                                              edge_users[i1,i2]= 1
                                        
-                                       for key, users in edge_users.iteritems():
-                                               if users>1:
-                                                       fgon_edges[key]= None
+#                                      for key, users in edge_users.iteritems():
+#                                              if users>1:
+#                                                      fgon_edges[key]= None
                                
-                               # remove all after 3, means we dont have to pop this one.
-                               faces.pop(f_idx)
+#                              # remove all after 3, means we dont have to pop this one.
+#                              faces.pop(f_idx)
                
                
        # Build sharp edges
@@ -564,33 +574,36 @@ def create_mesh(scn, new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_l
 #                              me_edges[ed].flag |= SHARP
 #              del SHARP
        
-#      if CREATE_EDGES:
+       if CREATE_EDGES:
+
+               me.add_geometry(0, len(edges))
+
+               # edges is (should be) a list of (a, b) tuples
+               me.edges.foreach_set("verts", unpack_list(edges))
 #              me_edges.extend( edges )
        
 #      del me_edges
-       
+
+       me.calc_normals()
 #      me.calcNormals()
 
        ob= bpy.data.add_object("MESH", "Mesh")
        ob.data= me
+       scn.add_object(ob)
 #      ob= scn.objects.new(me)
        new_objects.append(ob)
 
-#      # Create the vertex groups. No need to have the flag passed here since we test for the 
-#      # content of the vertex_groups. If the user selects to NOT have vertex groups saved then
-#      # the following test will never run
-#      for group_name, group_indicies in vertex_groups.iteritems():
-#              i= ob.add_vertex_group(group_name)
-# #            me.addVertGroup(group_name)
-#              me.assign_verts_to_group(group_index, group_indicies, len(group_indicies), 1.0, 'REPLACE')
-# #            me.assignVertsToGroup(group_name, group_indicies, 1.00, Mesh.AssignModes.REPLACE)
+       # Create the vertex groups. No need to have the flag passed here since we test for the 
+       # content of the vertex_groups. If the user selects to NOT have vertex groups saved then
+       # the following test will never run
+       for group_name, group_indicies in vertex_groups.iteritems():
+               group= ob.add_vertex_group(group_name)
+#              me.addVertGroup(group_name)
+               for vertex_index in group_indicies:
+                       ob.add_vertex_to_group(vertex_index, group, 1.0, 'REPLACE')
+#              me.assignVertsToGroup(group_name, group_indicies, 1.00, Mesh.AssignModes.REPLACE)
 
 
-class Mesh(bpy.types.Mesh):
-
-       def assign_verts_to_group(self, group_index, vert_indices, weight):
-               
-
 def create_nurbs(scn, context_nurbs, vert_loc, new_objects):
        '''
        Add nurbs object to blender, only support one type at the moment
@@ -700,16 +713,16 @@ def get_float_func(filepath):
        return float
 
 def load_obj(filepath,
-                                                CLAMP_SIZE= 0.0, 
-                                                CREATE_FGONS= True, 
-                                                CREATE_SMOOTH_GROUPS= True, 
-                                                CREATE_EDGES= True, 
-                                                SPLIT_OBJECTS= True, 
-                                                SPLIT_GROUPS= True, 
-                                                SPLIT_MATERIALS= True, 
-                                                ROTATE_X90= True, 
-                                                IMAGE_SEARCH=True,
-                                                POLYGROUPS=False):
+                        CLAMP_SIZE= 0.0, 
+                        CREATE_FGONS= True, 
+                        CREATE_SMOOTH_GROUPS= True, 
+                        CREATE_EDGES= True, 
+                        SPLIT_OBJECTS= True, 
+                        SPLIT_GROUPS= True, 
+                        SPLIT_MATERIALS= True, 
+                        ROTATE_X90= True, 
+                        IMAGE_SEARCH=True,
+                        POLYGROUPS=False):
        '''
        Called by the user interface or another script.
        load_obj(path) - should give acceptable results.
@@ -997,30 +1010,30 @@ def load_obj(filepath,
                create_mesh(scn, new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc_split, verts_tex, faces_split, unique_materials_split, unique_material_images, unique_smooth_groups, vertex_groups, dataname)
        
        # nurbs support
-       for context_nurbs in nurbs:
-               create_nurbs(scn, context_nurbs, verts_loc, new_objects)
+#      for context_nurbs in nurbs:
+#              create_nurbs(scn, context_nurbs, verts_loc, new_objects)
        
        
        axis_min= [ 1000000000]*3
        axis_max= [-1000000000]*3
        
-       if CLAMP_SIZE:
-               # Get all object bounds
-               for ob in new_objects:
-                       for v in ob.getBoundBox():
-                               for axis, value in enumerate(v):
-                                       if axis_min[axis] > value:      axis_min[axis]= value
-                                       if axis_max[axis] < value:      axis_max[axis]= value
+#      if CLAMP_SIZE:
+#              # Get all object bounds
+#              for ob in new_objects:
+#                      for v in ob.getBoundBox():
+#                              for axis, value in enumerate(v):
+#                                      if axis_min[axis] > value:      axis_min[axis]= value
+#                                      if axis_max[axis] < value:      axis_max[axis]= value
                
-               # Scale objects
-               max_axis= max(axis_max[0]-axis_min[0], axis_max[1]-axis_min[1], axis_max[2]-axis_min[2])
-               scale= 1.0
+#              # Scale objects
+#              max_axis= max(axis_max[0]-axis_min[0], axis_max[1]-axis_min[1], axis_max[2]-axis_min[2])
+#              scale= 1.0
                
-               while CLAMP_SIZE < max_axis * scale:
-                       scale= scale/10.0
+#              while CLAMP_SIZE < max_axis * scale:
+#                      scale= scale/10.0
                
-               for ob in new_objects:
-                       ob.setSize(scale, scale, scale)
+#              for ob in new_objects:
+#                      ob.setSize(scale, scale, scale)
        
        # Better rotate the vert locations
        #if not ROTATE_X90:
@@ -1276,5 +1289,10 @@ else:
 
 # NOTES (all line numbers refer to 2.4x import_obj.py, not this file)
 # check later: line 489
-# edge flags, edges, normals: lines 508-528
-# vertex groups: line 533 - cannot assign vertex groups
+# can convert now: edge flags, edges: lines 508-528
+# ngon (uses python module BPyMesh): 384-414
+# nurbs: 947-
+# clamp size: cannot get bound box with RNA - neither I can write RNA struct function that returns it -
+# again, RNA limitation
+# warning: uses bpy.sys.exists
+# get back to l 140 (here)
index e779f90..8a9fdb8 100644 (file)
@@ -1911,7 +1911,7 @@ RNAProcessItem PROCESS_ITEMS[]= {
        {"rna_lamp.c", NULL, RNA_def_lamp},
        {"rna_lattice.c", NULL, RNA_def_lattice},
        {"rna_main.c", "rna_main_api.c", RNA_def_main},
-       {"rna_material.c", NULL, RNA_def_material},
+       {"rna_material.c", "rna_material_api.c", RNA_def_material},
        {"rna_mesh.c", "rna_mesh_api.c", RNA_def_mesh},
        {"rna_meta.c", NULL, RNA_def_meta},
        {"rna_modifier.c", NULL, RNA_def_modifier},
index f465e73..7bf3376 100644 (file)
@@ -193,6 +193,7 @@ void RNA_api_object(struct StructRNA *srna);
 void RNA_api_ui_layout(struct StructRNA *srna);
 void RNA_api_wm(struct StructRNA *srna);
 void RNA_api_scene(struct StructRNA *srna); 
+void RNA_api_material(StructRNA *srna);
 
 /* ID Properties */
 
index 08a3b7c..9dc32ac 100644 (file)
@@ -40,6 +40,7 @@
 #include "BKE_mesh.h"
 #include "BKE_library.h"
 #include "BKE_object.h"
+#include "BKE_material.h"
 
 #include "DNA_mesh_types.h"
 
@@ -68,7 +69,7 @@ static Object* rna_Main_add_object(Main *main, int type, char *name)
 }
 
 /*
-  WARNING: the following example shows when this function should not be called
+  NOTE: the following example shows when this function should _not_ be called
 
   ob = bpy.data.add_object()
   scene.add_object(ob)
@@ -87,6 +88,20 @@ static void rna_Main_remove_object(Main *main, ReportList *reports, Object *ob)
                BKE_report(reports, RPT_ERROR, "Object must have zero users to be removed.");
 }
 
+static Material *rna_Main_add_material(Main *main, char *name)
+{
+       return add_material(name);
+}
+
+/* TODO: remove material? */
+
+struct Tex *rna_Main_add_texture(Main *main, char *name)
+{
+       return add_texture(name);
+}
+
+/* TODO: remove texture? */
+
 #else
 
 void RNA_api_main(StructRNA *srna)
@@ -136,6 +151,19 @@ void RNA_api_main(StructRNA *srna)
        RNA_def_function_ui_description(func, "Remove a mesh if it has zero users.");
        parm= RNA_def_pointer(func, "mesh", "Mesh", "", "Mesh to remove.");
        RNA_def_property_flag(parm, PROP_REQUIRED);
+
+       func= RNA_def_function(srna, "add_material", "rna_Main_add_material");
+       RNA_def_function_ui_description(func, "Add a new material.");
+       parm= RNA_def_string(func, "name", "Material", 0, "", "New name for the datablock."); /* optional */
+       parm= RNA_def_pointer(func, "material", "Material", "", "New material.");
+       RNA_def_function_return(func, parm);
+
+       func= RNA_def_function(srna, "add_texture", "rna_Main_add_texture");
+       RNA_def_function_ui_description(func, "Add a new texture.");
+       parm= RNA_def_string(func, "name", "Tex", 0, "", "New name for the datablock."); /* optional */
+       parm= RNA_def_pointer(func, "texture", "Texture", "", "New texture.");
+       RNA_def_function_return(func, parm);
+
 }
 
 #endif
index 41f3159..6de13db 100644 (file)
@@ -1134,6 +1134,8 @@ void RNA_def_material(BlenderRNA *brna)
        rna_def_material_sss(brna);
        rna_def_material_mtex(brna);
        rna_def_material_strand(brna);
+
+       RNA_api_material(srna);
 }
 
 void rna_def_mtex_common(StructRNA *srna, const char *begin, const char *activeget, const char *structname)
diff --git a/source/blender/makesrna/intern/rna_material_api.c b/source/blender/makesrna/intern/rna_material_api.c
new file mode 100644 (file)
index 0000000..e2b4746
--- /dev/null
@@ -0,0 +1,126 @@
+/**
+ *
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. 
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2009 Blender Foundation.
+ * All rights reserved.
+ *
+ * 
+ * Contributor(s): Blender Foundation
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "RNA_define.h"
+#include "RNA_types.h"
+
+#include "DNA_material_types.h"
+
+#ifdef RNA_RUNTIME
+
+#include "BKE_material.h"
+#include "BKE_texture.h"
+
+/*
+  Adds material to the first free texture slot.
+  If all slots are busy, replaces the first.
+*/
+static void rna_Material_add_texture(Material *ma, Tex *tex, int mapto, int texco)
+{
+       int i;
+       MTex *mtex;
+       int slot= -1;
+
+       for (i= 0; i < MAX_MTEX; i++) {
+               if (!ma->mtex[i]) {
+                       slot= i;
+                       break;
+               }
+       }
+
+       if (slot == -1)
+               slot= 0;
+
+       if (ma->mtex[slot]) {
+               ma->mtex[slot]->tex->id.us--;
+       }
+       else {
+               ma->mtex[slot]= add_mtex();
+       }
+
+       mtex= ma->mtex[slot];
+
+       mtex->tex= tex;
+       id_us_plus(&tex->id);
+
+       mtex->texco= mapto;
+       mtex->mapto= texco;
+}
+
+#else
+
+void RNA_api_material(StructRNA *srna)
+{
+       FunctionRNA *func;
+       PropertyRNA *parm;
+
+       /* copied from rna_def_material_mtex (rna_material.c) */
+       static EnumPropertyItem prop_texture_coordinates_items[] = {
+               {TEXCO_GLOB, "GLOBAL", 0, "Global", "Uses global coordinates for the texture coordinates."},
+               {TEXCO_OBJECT, "OBJECT", 0, "Object", "Uses linked object's coordinates for texture coordinates."},
+               {TEXCO_UV, "UV", 0, "UV", "Uses UV coordinates for texture coordinates."},
+               {TEXCO_ORCO, "ORCO", 0, "Generated", "Uses the original undeformed coordinates of the object."},
+               {TEXCO_STRAND, "STRAND", 0, "Strand", "Uses normalized strand texture coordinate (1D)."},
+               {TEXCO_STICKY, "STICKY", 0, "Sticky", "Uses mesh's sticky coordinates for the texture coordinates."},
+               {TEXCO_WINDOW, "WINDOW", 0, "Window", "Uses screen coordinates as texture coordinates."},
+               {TEXCO_NORM, "NORMAL", 0, "Normal", "Uses normal vector as texture coordinates."},
+               {TEXCO_REFL, "REFLECTION", 0, "Reflection", "Uses reflection vector as texture coordinates."},
+               {TEXCO_STRESS, "STRESS", 0, "Stress", "Uses the difference of edge lengths compared to original coordinates of the mesh."},
+               {TEXCO_TANGENT, "TANGENT", 0, "Tangent", "Uses the optional tangent vector as texture coordinates."},
+
+               {0, NULL, 0, NULL, NULL}};
+
+       static EnumPropertyItem prop_texture_mapto_items[] = {
+               {MAP_COL, "COLOR", 0, "Color", "Causes the texture to affect basic color of the material"},
+               {MAP_NORM, "NORMAL", 0, "Normal", "Causes the texture to affect the rendered normal"},
+               {MAP_COLSPEC, "SPEC_COLOR", 0, "Specularity Color", "Causes the texture to affect the specularity color"},
+               {MAP_COLMIR, "MIRROR", 0, "Mirror", "Causes the texture to affect the mirror color"},
+               {MAP_REF, "REFLECTION", 0, "Reflection", "Causes the texture to affect the value of the materials reflectivity"},
+               {MAP_SPEC, "SPECULARITY", 0, "Specularity", "Causes the texture to affect the value of specularity"},
+               {MAP_EMIT, "EMIT", 0, "Emit", "Causes the texture to affect the emit value"},
+               {MAP_ALPHA, "ALPHA", 0, "Alpha", "Causes the texture to affect the alpha value"},
+               {MAP_HAR, "HARDNESS", 0, "Hardness", "Causes the texture to affect the hardness value"},
+               {MAP_RAYMIRR, "RAY_MIRROR", 0, "Ray-Mirror", "Causes the texture to affect the ray-mirror value"},
+               {MAP_TRANSLU, "TRANSLUCENCY", 0, "Translucency", "Causes the texture to affect the translucency value"},
+               {MAP_AMB, "AMBIENT", 0, "Ambient", "Causes the texture to affect the value of ambient"},
+               {MAP_DISPLACE, "DISPLACEMENT", 0, "Displacement", "Let the texture displace the surface"},
+               {MAP_WARP, "WARP", 0, "Warp", "Let the texture warp texture coordinates of next channels"},
+               {0, NULL, 0, NULL, NULL}};
+
+       func= RNA_def_function(srna, "add_texture", "rna_Material_add_texture");
+       RNA_def_function_ui_description(func, "Add a texture to material's free texture slot.");
+       parm= RNA_def_pointer(func, "texture", "Texture", "", "Texture to add.");
+       parm= RNA_def_enum(func, "texture_coordinates", prop_texture_coordinates_items, TEXCO_UV, "", "Source of texture coordinate information."); /* optional */
+       parm= RNA_def_enum(func, "map_to", prop_texture_mapto_items, MAP_COL, "", "Controls which material property the texture affects."); /* optional */
+}
+
+#endif
+
index ecc32b2..b215734 100644 (file)
@@ -253,6 +253,11 @@ static void rna_Mesh_add_uv_layer(Mesh *me)
        me->mtface= CustomData_add_layer(&me->fdata, CD_MTFACE, CD_DEFAULT, NULL, me->totface);
 }
 
+static void rna_Mesh_calc_normals(Mesh *me)
+{
+       mesh_calc_normals(me->mvert, me->totvert, me->mface, me->totface, NULL);
+}
+
 #else
 
 void RNA_api_mesh(StructRNA *srna)
@@ -281,6 +286,9 @@ void RNA_api_mesh(StructRNA *srna)
        func= RNA_def_function(srna, "add_uv_layer", "rna_Mesh_add_uv_layer");
        RNA_def_function_ui_description(func, "Add new UV layer to Mesh.");
 
+       func= RNA_def_function(srna, "calc_normals", "rna_Mesh_calc_normals");
+       RNA_def_function_ui_description(func, "Calculate vertex normals.");
+
        /*
        func= RNA_def_function(srna, "add_geom", "rna_Mesh_add_geom");
        RNA_def_function_ui_description(func, "Add geometry data to mesh.");
index 9d1a6a3..02db7e8 100644 (file)
@@ -155,10 +155,15 @@ static void rna_Object_convert_to_triface(Object *ob, bContext *C, ReportList *r
        DAG_object_flush_update(sce, ob, OB_RECALC_DATA);
 }
 
-static int rna_Object_add_vertex_group(Object *ob, char *group_name)
+static bDeformGroup *rna_Object_add_vertex_group(Object *ob, char *group_name)
 {
-       bDeformGroup *defgroup= add_defgroup_name(ob, group_name);
-       return BLI_findindex(&ob->defbase, defgroup);
+       return add_defgroup_name(ob, group_name);
+}
+
+static void rna_Object_add_vertex_to_group(Object *ob, int vertex_index, bDeformGroup *def, float weight, int assignmode)
+{
+       /* creates dverts if needed */
+       add_vert_to_defgroup(ob, def, vertex_index, weight, assignmode);
 }
 
 /*
@@ -210,6 +215,13 @@ void RNA_api_object(StructRNA *srna)
                {0, NULL, 0, NULL, NULL}
        };
 
+       static EnumPropertyItem assign_mode_items[] = {
+               {WEIGHT_REPLACE, "REPLACE", 0, "Replace", "Replace."}, /* TODO: more meaningful descriptions */
+               {WEIGHT_ADD, "ADD", 0, "Add", "Add."},
+               {WEIGHT_SUBTRACT, "SUBTRACT", 0, "Subtract", "Subtract."},
+               {0, NULL, 0, NULL, NULL}
+       };
+
        func= RNA_def_function(srna, "create_mesh", "rna_Object_create_mesh");
        RNA_def_function_ui_description(func, "Create a Mesh datablock with all modifiers applied.");
        RNA_def_function_flag(func, FUNC_USE_CONTEXT|FUNC_USE_REPORTS);
@@ -234,9 +246,20 @@ void RNA_api_object(StructRNA *srna)
 
        func= RNA_def_function(srna, "add_vertex_group", "rna_Object_add_vertex_group");
        RNA_def_function_ui_description(func, "Add vertex group to object.");
-       parm= RNA_def_string(func, "name", "Group", 0, "", "Vertex group name.");
-       parm= RNA_def_int(func, "group_index", 0, 0, 0, "", "Index of the created vertex group.", 0, 0);
+       parm= RNA_def_string(func, "name", "Group", 0, "", "Vertex group name."); /* optional */
+       parm= RNA_def_pointer(func, "group", "VertexGroup", "", "New vertex group.");
        RNA_def_function_return(func, parm);
+
+       func= RNA_def_function(srna, "add_vertex_to_group", "rna_Object_add_vertex_to_group");
+       RNA_def_function_ui_description(func, "Add vertex to a vertex group.");
+       parm= RNA_def_int(func, "vertex_index", 0, 0, 0, "", "Vertex index.", 0, 0);
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_pointer(func, "group", "VertexGroup", "", "Vertex group to add vertex to.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_float(func, "weight", 0, 0.0f, 1.0f, "", "Vertex weight.", 0.0f, 1.0f);
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_enum(func, "type", assign_mode_items, 0, "", "Vertex assign mode.");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
 }
 
 #endif