Code and style cleanup in own modules in BKE and also mball module
authorSergey Sharybin <sergey.vfx@gmail.com>
Sat, 28 Apr 2012 16:49:00 +0000 (16:49 +0000)
committerSergey Sharybin <sergey.vfx@gmail.com>
Sat, 28 Apr 2012 16:49:00 +0000 (16:49 +0000)
- Make sure functions are named in way BKE_<object>_<action> (same way as RNA callbacks)
- Make functions which are used by mball.c only static and remove their prototypes
  from public header file.

Further cleanup is coming.

52 files changed:
source/blender/blenkernel/BKE_curve.h
source/blender/blenkernel/BKE_mball.h
source/blender/blenkernel/BKE_movieclip.h
source/blender/blenkernel/intern/anim.c
source/blender/blenkernel/intern/armature.c
source/blender/blenkernel/intern/colortools.c
source/blender/blenkernel/intern/curve.c
source/blender/blenkernel/intern/depsgraph.c
source/blender/blenkernel/intern/displist.c
source/blender/blenkernel/intern/fcurve.c
source/blender/blenkernel/intern/font.c
source/blender/blenkernel/intern/key.c
source/blender/blenkernel/intern/library.c
source/blender/blenkernel/intern/material.c
source/blender/blenkernel/intern/mball.c
source/blender/blenkernel/intern/mesh.c
source/blender/blenkernel/intern/movieclip.c
source/blender/blenkernel/intern/object.c
source/blender/blenkernel/intern/softbody.c
source/blender/editors/animation/anim_channels_defines.c
source/blender/editors/curve/editcurve.c
source/blender/editors/curve/editfont.c
source/blender/editors/gpencil/gpencil_edit.c
source/blender/editors/include/ED_curve.h
source/blender/editors/interface/interface_widgets.c
source/blender/editors/metaball/mball_edit.c
source/blender/editors/object/object_add.c
source/blender/editors/object/object_edit.c
source/blender/editors/object/object_modifier.c
source/blender/editors/object/object_relations.c
source/blender/editors/object/object_shapekey.c
source/blender/editors/object/object_transform.c
source/blender/editors/render/render_shading.c
source/blender/editors/space_clip/clip_ops.c
source/blender/editors/space_graph/graph_draw.c
source/blender/editors/space_info/info_stats.c
source/blender/editors/space_node/drawnode.c
source/blender/editors/space_view3d/drawobject.c
source/blender/editors/space_view3d/view3d_buttons.c
source/blender/editors/space_view3d/view3d_snap.c
source/blender/editors/transform/transform_conversions.c
source/blender/editors/transform/transform_generics.c
source/blender/editors/transform/transform_manipulator.c
source/blender/editors/transform/transform_orientations.c
source/blender/makesrna/intern/rna_curve.c
source/blender/makesrna/intern/rna_main_api.c
source/blender/makesrna/intern/rna_meta.c
source/blender/makesrna/intern/rna_object.c
source/blender/makesrna/intern/rna_object_api.c
source/blender/python/mathutils/mathutils_geometry.c
source/blender/render/intern/source/convertblender.c
source/blender/windowmanager/intern/wm_init_exit.c

index fa3a1a6..3b9328a 100644 (file)
@@ -53,72 +53,83 @@ struct Scene;
 #define CU_DO_TILT(cu, nu) (((nu->flag & CU_2D) && (cu->flag & CU_3D)==0) ? 0 : 1)
 #define CU_DO_RADIUS(cu, nu) ((CU_DO_TILT(cu, nu) || ((cu)->flag & CU_PATH_RADIUS) || (cu)->bevobj || (cu)->ext1!=0.0f || (cu)->ext2!=0.0f) ? 1:0)
 
+/* ** Curve ** */
+void BKE_curve_unlink(struct Curve *cu);
+void BKE_curve_free(struct Curve *cu);
+void BKE_curve_editfont_free(struct Curve *cu);
+struct Curve *BKE_curve_add(const char *name, int type);
+struct Curve *BKE_curve_copy(struct Curve *cu);
+void BKE_curve_make_local(struct Curve *cu);
+short BKE_curve_type_get(struct Curve *cu);
+void BKE_curve_type_test(struct Object *ob);
+void BKE_curve_curve_dimension_update(struct Curve *cu);
+void BKE_curve_tex_space_calc(struct Curve *cu);
 
-void unlink_curve(struct Curve *cu);
-void free_curve_editNurb_keyIndex(struct EditNurb *editnurb);
-void free_curve_editNurb(struct Curve *cu);
-void free_curve(struct Curve *cu);
-void BKE_free_editfont(struct Curve *cu);
-struct Curve *add_curve(const char *name, int type);
-struct Curve *copy_curve(struct Curve *cu);
-void make_local_curve(struct Curve *cu);
-struct ListBase *curve_editnurbs(struct Curve *cu);
-short curve_type(struct Curve *cu);
-void test_curve_type(struct Object *ob);
-void update_curve_dimension(struct Curve *cu );
-void tex_space_curve(struct Curve *cu);
-int count_curveverts(struct ListBase *nurb);
-int count_curveverts_without_handles(struct ListBase *nurb);
-void freeNurb(struct Nurb *nu);
-void freeNurblist(struct ListBase *lb);
-struct Nurb *duplicateNurb(struct Nurb *nu);
-void duplicateNurblist(struct ListBase *lb1,  struct ListBase *lb2);
-void test2DNurb(struct Nurb *nu);
-void minmaxNurb(struct Nurb *nu, float *min, float *max);
-
-void nurbs_knot_calc_u(struct Nurb *nu);
-void nurbs_knot_calc_v(struct Nurb *nu);
-
-void makeNurbfaces(struct Nurb *nu, float *coord_array, int rowstride, int resolu, int resolv);
-void makeNurbcurve(struct Nurb *nu, float *coord_array, float *tilt_array, float *radius_array, float *weight_array, int resolu, int stride);
-void forward_diff_bezier(float q0, float q1, float q2, float q3, float *p, int it, int stride);
-float *make_orco_curve(struct Scene *scene, struct Object *ob);
-float *make_orco_surf(struct Object *ob);
-void makebevelcurve(struct Scene *scene, struct Object *ob,  struct ListBase *disp, int forRender);
-
-void makeBevelList(struct Object *ob);
-
-void calchandleNurb(struct BezTriple *bezt, struct BezTriple *prev,  struct BezTriple *next, int mode);
-void calchandlesNurb(struct Nurb *nu);
-void testhandlesNurb(struct Nurb *nu);
-void autocalchandlesNurb(struct Nurb *nu, int flag);
-void autocalchandlesNurb_all(ListBase *editnurb, int flag);
-void sethandlesNurb(ListBase *editnurb, short code);
-
-void switchdirectionNurb(struct Nurb *nu);
-
-void addNurbPoints(struct Nurb *nu, int number);
-void addNurbPointsBezier(struct Nurb *nu, int number);
-
-float (*curve_getVertexCos(struct Curve *cu, struct ListBase *lb, int *numVerts_r))[3];
-void curve_applyVertexCos(struct Curve *cu, struct ListBase *lb, float (*vertexCos)[3]);
-
-float (*curve_getKeyVertexCos(struct Curve *cu, struct ListBase *lb, float *key))[3];
-void curve_applyKeyVertexTilts(struct Curve *cu, struct ListBase *lb, float *key);
+int BKE_curve_minmax(struct Curve *cu, float min[3], float max[3]);
+int BKE_curve_center_median(struct Curve *cu, float cent[3]);
+int BKE_curve_center_bounds(struct Curve *cu, float cent[3]);
+void BKE_curve_translate(struct Curve *cu, float offset[3], int do_keys);
+void BKE_curve_delete_material_index(struct Curve *cu, int index);
+
+ListBase *BKE_curve_nurbs_get(struct Curve *cu);
+
+float (*BKE_curve_vertexCos_get(struct Curve *cu, struct ListBase *lb, int *numVerts_r))[3];
+void BK_curve_vertexCos_apply(struct Curve *cu, struct ListBase *lb, float (*vertexCos)[3]);
+
+float (*BKE_curve_keyVertexCos_get(struct Curve *cu, struct ListBase *lb, float *key))[3];
+void BKE_curve_keyVertexTilts_apply(struct Curve *cu, struct ListBase *lb, float *key);
+
+void BKE_curve_editNurb_keyIndex_free(struct EditNurb *editnurb);
+void BKE_curve_editNurb_free(struct Curve *cu);
+struct ListBase *BKE_curve_editNurbs_get(struct Curve *cu);
+
+float *BKE_curve_make_orco(struct Scene *scene, struct Object *ob);
+float *BKE_curve_surf_make_orco(struct Object *ob);
+
+void BKE_curve_bevelList_make(struct Object *ob);
+void BKE_curve_bevel_make(struct Scene *scene, struct Object *ob,  struct ListBase *disp, int forRender);
+
+void BKE_curve_forward_diff_bezier(float q0, float q1, float q2, float q3, float *p, int it, int stride);
+
+/* ** Nurbs ** */
+
+int BKE_nurbList_verts_count(struct ListBase *nurb);
+int BKE_nurbList_verts_count_without_handles(struct ListBase *nurb);
+
+void BKE_nurbList_free(struct ListBase *lb);
+void BKE_nurbList_duplicate(struct ListBase *lb1,  struct ListBase *lb2);
+void BKE_nurbList_handles_set(struct ListBase *editnurb, short code);
+
+void BKE_nurbList_handles_autocalc(ListBase *editnurb, int flag);
+
+void BKE_nurb_free(struct Nurb *nu);
+struct Nurb *BKE_nurb_duplicate(struct Nurb *nu);
+
+void BKE_nurb_test2D(struct Nurb *nu);
+void BKE_nurb_minmax(struct Nurb *nu, float *min, float *max);
+
+void BKE_nurb_makeFaces(struct Nurb *nu, float *coord_array, int rowstride, int resolu, int resolv);
+void BKE_nurb_makeCurve(struct Nurb *nu, float *coord_array, float *tilt_array, float *radius_array, float *weight_array, int resolu, int stride);
+
+void BKE_nurb_knot_calc_u(struct Nurb *nu);
+void BKE_nurb_knot_calc_v(struct Nurb *nu);
 
 /* nurb checks if they can be drawn, also clamp order func */
-int check_valid_nurb_u(struct Nurb *nu);
-int check_valid_nurb_v(struct Nurb *nu);
+int BKE_nurb_check_valid_u(struct Nurb *nu);
+int BKE_nurb_check_valid_v(struct Nurb *nu);
 
-int clamp_nurb_order_u(struct Nurb *nu);
-int clamp_nurb_order_v(struct Nurb *nu);
+int BKE_nurb_order_clamp_u(struct Nurb *nu);
+int BKE_nurb_order_clamp_v(struct Nurb *nu);
 
-ListBase *BKE_curve_nurbs(struct Curve *cu);
+void BKE_nurb_direction_switch(struct Nurb *nu);
 
-int minmax_curve(struct Curve *cu, float min[3], float max[3]);
-int curve_center_median(struct Curve *cu, float cent[3]);
-int curve_center_bounds(struct Curve *cu, float cent[3]);
-void curve_translate(struct Curve *cu, float offset[3], int do_keys);
-void curve_delete_material_index(struct Curve *cu, int index);
-#endif
+void BKE_nurb_points_add(struct Nurb *nu, int number);
+void BKE_nurb_bezierPoints_add(struct Nurb *nu, int number);
+
+void BKE_nurb_handle_calc(struct BezTriple *bezt, struct BezTriple *prev,  struct BezTriple *next, int mode);
 
+void BKE_nurb_handles_calc(struct Nurb *nu);
+void BKE_nurb_handles_autocalc(struct Nurb *nu, int flag);
+void BKE_nurb_handles_test(struct Nurb *nu);
+
+#endif
index fafd2a3..018ee7f 100644 (file)
@@ -37,147 +37,30 @@ struct Object;
 struct Scene;
 struct MetaElem;
 
-typedef struct point {                 /* a three-dimensional point */
-       float x, y, z;                          /* its coordinates */
-} MB_POINT;
+void BKE_metaball_unlink(struct MetaBall *mb);
+void BKE_metaball_free(struct MetaBall *mb);
+struct MetaBall *BKE_metaball_add(const char *name);
+struct MetaBall *BKE_metaball_copy(struct MetaBall *mb);
 
-typedef struct vertex {                        /* surface vertex */
-       MB_POINT position, normal;              /* position and surface normal */
-} VERTEX;
+void BKE_metaball_make_local(struct MetaBall *mb);
 
-typedef struct vertices {              /* list of vertices in polygonization */
-       int count, max;                         /* # vertices, max # allowed */
-       VERTEX *ptr;                            /* dynamically allocated */
-} VERTICES;
+void BKE_metaball_cubeTable_free(void);
 
-typedef struct corner {                        /* corner of a cube */
-       int i, j, k;                            /* (i, j, k) is index within lattice */
-       float x, y, z, value;           /* location and function value */
-       struct corner *next;
-} CORNER;
+void BKE_metaball_polygonize(struct Scene *scene, struct Object *ob, struct ListBase *dispbase);
+int BKE_metaball_is_basis_for(struct Object *ob1, struct Object *ob2);
+int BKE_metaball_is_basis(struct Object *ob);
+struct Object *BKE_metaball_basis_find(struct Scene *scene, struct Object *ob);
 
-typedef struct cube {                  /* partitioning cell (cube) */
-       int i, j, k;                            /* lattice location of cube */
-       CORNER *corners[8];                     /* eight corners */
-} CUBE;
+void BKE_metaball_tex_space_calc(struct Object *ob);
+float *BKE_metaball_make_orco(struct Object *ob, struct ListBase *dispbase);
 
-typedef struct cubes {                 /* linked list of cubes acting as stack */
-       CUBE cube;                                      /* a single cube */
-       struct cubes *next;                     /* remaining elements */
-} CUBES;
-
-typedef struct centerlist {            /* list of cube locations */
-       int i, j, k;                            /* cube location */
-       struct centerlist *next;        /* remaining elements */
-} CENTERLIST;
-
-typedef struct edgelist {              /* list of edges */
-       int i1, j1, k1, i2, j2, k2;     /* edge corner ids */
-       int vid;                                        /* vertex id */
-       struct edgelist *next;          /* remaining elements */
-} EDGELIST;
-
-typedef struct intlist {               /* list of integers */
-       int i;                                          /* an integer */
-       struct intlist *next;           /* remaining elements */
-} INTLIST;
-
-typedef struct intlists {              /* list of list of integers */
-       INTLIST *list;                          /* a list of integers */
-       struct intlists *next;          /* remaining elements */
-} INTLISTS;
-
-typedef struct process {               /* parameters, function, storage */
-       /* what happens here? floats, I think. */
-       /*  float (*function)(void);     */     /* implicit surface function */
-       float (*function)(float, float, float);
-       float size, delta;                      /* cube size, normal delta */
-       int bounds;                                     /* cube range within lattice */
-       CUBES *cubes;                           /* active cubes */
-       VERTICES vertices;                      /* surface vertices */
-       CENTERLIST **centers;           /* cube center hash table */
-       CORNER **corners;                       /* corner value hash table */
-       EDGELIST **edges;                       /* edge and vertex id hash table */
-} PROCESS;
-
-/* dividing scene using octal tree makes polygonisation faster */
-typedef struct ml_pointer {
-       struct ml_pointer *next, *prev;
-       struct MetaElem *ml;
-} ml_pointer;
-
-typedef struct octal_node {
-       struct octal_node *nodes[8];    /* children of current node */
-       struct octal_node *parent;      /* parent of current node */
-       struct ListBase elems;          /* ListBase of MetaElem pointers (ml_pointer) */
-       float x_min, y_min, z_min;      /* 1st border point */
-       float x_max, y_max, z_max;      /* 7th border point */
-       float x,y,z;                    /* center of node */
-       int pos, neg;                   /* number of positive and negative MetaElements in the node */
-       int count;                      /* number of MetaElems, which belongs to the node */
-} octal_node;
-
-typedef struct octal_tree {
-       struct octal_node *first;       /* first node */
-       int pos, neg;                   /* number of positive and negative MetaElements in the scene */
-       short depth;                    /* number of scene subdivision */
-} octal_tree;
-
-struct pgn_elements {
-       struct pgn_elements *next, *prev;
-       char *data;
-};
-
-octal_node* find_metaball_octal_node(octal_node *node, float x, float y, float z, short depth);
-
-void freepolygonize(PROCESS *p);
-void docube(CUBE *cube, PROCESS *p, struct MetaBall *mb);
-void testface(int i, int j, int k, CUBE* old, int bit, int c1, int c2, int c3, int c4, PROCESS *p);
-CORNER *setcorner (PROCESS* p, int i, int j, int k);
-int vertid (CORNER *c1, CORNER *c2, PROCESS *p, struct MetaBall *mb);
-int setcenter(CENTERLIST *table[], int i, int j, int k);
-int otherface (int edge, int face);
-void makecubetable (void);
-void setedge (EDGELIST *table[], int i1, int j1, int k1, int i2, int j2, int k2, int vid);
-int getedge (EDGELIST *table[], int i1, int j1, int k1, int i2, int j2, int k2);
-void addtovertices (VERTICES *vertices, VERTEX v);
-void vnormal (MB_POINT *point, PROCESS *p, MB_POINT *v);
-void converge (MB_POINT *p1, MB_POINT *p2, float v1, float v2, float (*function)(float, float, float), MB_POINT *p, struct MetaBall *mb, int f);
-void add_cube(PROCESS *mbproc, int i, int j, int k, int count);
-void find_first_points(PROCESS *mbproc, struct MetaBall *mb, int a);
-
-void fill_metaball_octal_node(octal_node *node, struct MetaElem *ml, short i);
-void subdivide_metaball_octal_node(octal_node *node, float size_x, float size_y, float size_z, short depth);
-void free_metaball_octal_node(octal_node *node);
-void init_metaball_octal_tree(int depth);
-void polygonize(PROCESS *mbproc, struct MetaBall *mb);
-float init_meta(struct Scene *scene, struct Object *ob);
-
-void unlink_mball(struct MetaBall *mb);
-void free_mball(struct MetaBall *mb);
-struct MetaBall *add_mball(const char *name);
-struct MetaBall *copy_mball(struct MetaBall *mb);
-void make_local_mball(struct MetaBall *mb);
-struct MetaElem *add_metaball_element(struct MetaBall *mb, const int type);
-void tex_space_mball(struct Object *ob);
-float *make_orco_mball(struct Object *ob, struct ListBase *dispbase);
-void copy_mball_properties(struct Scene *scene, struct Object *active_object);
-struct Object *find_basis_mball(struct Scene *scene, struct Object *ob);
-int is_basis_mball(struct Object *ob);
-int is_mball_basis_for(struct Object *ob1, struct Object *ob2);
-void metaball_polygonize(struct Scene *scene, struct Object *ob, struct ListBase *dispbase);
-void calc_mballco(struct MetaElem *ml, float vec[3]);
-float densfunc(struct MetaElem *ball, float x, float y, float z);
-float metaball(float x, float y, float z);
-void accum_mballfaces(int i1, int i2, int i3, int i4);
-void *new_pgn_element(int size);
-int nextcwedge (int edge, int face);
-void BKE_freecubetable(void);
+void BKE_metaball_properties_copy(struct Scene *scene, struct Object *active_object);
 
 int BKE_metaball_minmax(struct MetaBall *mb, float min[3], float max[3]);
 int BKE_metaball_center_median(struct MetaBall *mb, float cent[3]);
 int BKE_metaball_center_bounds(struct MetaBall *mb, float cent[3]);
 void BKE_metaball_translate(struct MetaBall *mb, float offset[3]);
 
-#endif
+struct MetaElem *BKE_metaball_element_add(struct MetaBall *mb, const int type);
 
+#endif
index d7b2f27..2992454 100644 (file)
@@ -40,10 +40,10 @@ struct MovieClipUser;
 struct MovieTrackingTrack;
 struct MovieDistortion;
 
-void free_movieclip(struct MovieClip *clip);
-void unlink_movieclip(struct Main *bmain, struct MovieClip *clip);
+void BKE_movieclip_free(struct MovieClip *clip);
+void BKE_movieclip_unlink(struct Main *bmain, struct MovieClip *clip);
 
-struct MovieClip *BKE_add_movieclip_file(const char *name);
+struct MovieClip *BKE_movieclip_file_add(const char *name);
 void BKE_movieclip_reload(struct MovieClip *clip);
 
 struct ImBuf *BKE_movieclip_get_ibuf(struct MovieClip *clip, struct MovieClipUser *user);
index 05171a5..38c73ba 100644 (file)
@@ -482,7 +482,7 @@ void calc_curvepath(Object *ob)
        if (ob==NULL || ob->type != OB_CURVE) return;
        cu= ob->data;
 
-       nurbs= BKE_curve_nurbs(cu);
+       nurbs= BKE_curve_nurbs_get(cu);
        nu= nurbs->first;
 
        if (cu->path) free_path(cu->path);
index 931aa2d..d1d6833 100644 (file)
@@ -566,13 +566,13 @@ Mat4 *b_bone_spline_setup(bPoseChannel *pchan, int rest)
        if (bone->segments > MAX_BBONE_SUBDIV)
                bone->segments = MAX_BBONE_SUBDIV;
 
-       forward_diff_bezier(0.0,   h1[0],                           h2[0],                           0.0,    data[0],
+       BKE_curve_forward_diff_bezier(0.0,   h1[0],                           h2[0],                           0.0,    data[0],
                            MAX_BBONE_SUBDIV, 4*sizeof(float));
-       forward_diff_bezier(0.0,   h1[1],                           length + h2[1],                  length, data[0]+1,
+       BKE_curve_forward_diff_bezier(0.0,   h1[1],                           length + h2[1],                  length, data[0]+1,
                            MAX_BBONE_SUBDIV, 4*sizeof(float));
-       forward_diff_bezier(0.0,   h1[2],                           h2[2],                           0.0,    data[0]+2,
+       BKE_curve_forward_diff_bezier(0.0,   h1[2],                           h2[2],                           0.0,    data[0]+2,
                            MAX_BBONE_SUBDIV, 4*sizeof(float));
-       forward_diff_bezier(roll1, roll1 + 0.390464f*(roll2-roll1), roll2 - 0.390464f*(roll2-roll1), roll2,  data[0]+3,
+       BKE_curve_forward_diff_bezier(roll1, roll1 + 0.390464f*(roll2-roll1), roll2 - 0.390464f*(roll2-roll1), roll2,  data[0]+3,
                            MAX_BBONE_SUBDIV, 4*sizeof(float));
 
        equalize_bezier(data[0], bone->segments); /* note: does stride 4! */
index 2d56315..6dc1b2a 100644 (file)
@@ -499,8 +499,8 @@ static void curvemap_make_table(CurveMap *cuma, rctf *clipr)
        
        for (a=0; a<cuma->totpoint-1; a++, fp += 2*CM_RESOL) {
                correct_bezpart(bezt[a].vec[1], bezt[a].vec[2], bezt[a+1].vec[0], bezt[a+1].vec[1]);
-               forward_diff_bezier(bezt[a].vec[1][0], bezt[a].vec[2][0], bezt[a+1].vec[0][0], bezt[a+1].vec[1][0], fp, CM_RESOL-1, 2*sizeof(float));   
-               forward_diff_bezier(bezt[a].vec[1][1], bezt[a].vec[2][1], bezt[a+1].vec[0][1], bezt[a+1].vec[1][1], fp+1, CM_RESOL-1, 2*sizeof(float));
+               BKE_curve_forward_diff_bezier(bezt[a].vec[1][0], bezt[a].vec[2][0], bezt[a+1].vec[0][0], bezt[a+1].vec[1][0], fp, CM_RESOL-1, 2*sizeof(float)); 
+               BKE_curve_forward_diff_bezier(bezt[a].vec[1][1], bezt[a].vec[2][1], bezt[a+1].vec[0][1], bezt[a+1].vec[1][1], fp+1, CM_RESOL-1, 2*sizeof(float));
        }
        
        /* store first and last handle for extrapolation, unit length */
index e5b2e5f..e0cadac 100644 (file)
@@ -70,7 +70,7 @@ static int cu_isectLL(const float v1[3], const float v2[3], const float v3[3], c
                       short cox, short coy,
                       float *labda, float *mu, float vec[3]);
 
-void unlink_curve(Curve *cu)
+void BKE_curve_unlink(Curve *cu)
 {
        int a;
        
@@ -95,7 +95,7 @@ void unlink_curve(Curve *cu)
 }
 
 /* frees editcurve entirely */
-void BKE_free_editfont(Curve *cu)
+void BKE_curve_editfont_free(Curve *cu)
 {
        if (cu->editfont) {
                EditFont *ef= cu->editfont;
@@ -112,7 +112,7 @@ void BKE_free_editfont(Curve *cu)
        }
 }
 
-void free_curve_editNurb_keyIndex(EditNurb *editnurb)
+void BKE_curve_editNurb_keyIndex_free(EditNurb *editnurb)
 {
        if (!editnurb->keyindex) {
                return;
@@ -121,26 +121,26 @@ void free_curve_editNurb_keyIndex(EditNurb *editnurb)
        editnurb->keyindex= NULL;
 }
 
-void free_curve_editNurb (Curve *cu)
+void BKE_curve_editNurb_free (Curve *cu)
 {
        if (cu->editnurb) {
-               freeNurblist(&cu->editnurb->nurbs);
-               free_curve_editNurb_keyIndex(cu->editnurb);
+               BKE_nurbList_free(&cu->editnurb->nurbs);
+               BKE_curve_editNurb_keyIndex_free(cu->editnurb);
                MEM_freeN(cu->editnurb);
                cu->editnurb= NULL;
        }
 }
 
 /* don't free curve itself */
-void free_curve(Curve *cu)
+void BKE_curve_free(Curve *cu)
 {
-       freeNurblist(&cu->nurb);
+       BKE_nurbList_free(&cu->nurb);
        BLI_freelistN(&cu->bev);
        freedisplist(&cu->disp);
-       BKE_free_editfont(cu);
+       BKE_curve_editfont_free(cu);
 
-       free_curve_editNurb(cu);
-       unlink_curve(cu);
+       BKE_curve_editNurb_free(cu);
+       BKE_curve_unlink(cu);
        BKE_free_animdata((ID *)cu);
        
        if (cu->mat) MEM_freeN(cu->mat);
@@ -151,7 +151,7 @@ void free_curve(Curve *cu)
        if (cu->tb) MEM_freeN(cu->tb);
 }
 
-Curve *add_curve(const char *name, int type)
+Curve *BKE_curve_add(const char *name, int type)
 {
        Curve *cu;
 
@@ -187,14 +187,14 @@ Curve *add_curve(const char *name, int type)
        return cu;
 }
 
-Curve *copy_curve(Curve *cu)
+Curve *BKE_curve_copy(Curve *cu)
 {
        Curve *cun;
        int a;
        
        cun= copy_libblock(&cu->id);
        cun->nurb.first= cun->nurb.last= NULL;
-       duplicateNurblist( &(cun->nurb), &(cu->nurb));
+       BKE_nurbList_duplicate( &(cun->nurb), &(cu->nurb));
 
        cun->mat= MEM_dupallocN(cu->mat);
        for (a=0; a<cun->totcol; a++) {
@@ -242,7 +242,7 @@ static void extern_local_curve(Curve *cu)
        }
 }
 
-void make_local_curve(Curve *cu)
+void BKE_curve_make_local(Curve *cu)
 {
        Main *bmain= G.main;
        Object *ob;
@@ -273,7 +273,7 @@ void make_local_curve(Curve *cu)
                extern_local_curve(cu);
        }
        else if (is_local && is_lib) {
-               Curve *cu_new= copy_curve(cu);
+               Curve *cu_new= BKE_curve_copy(cu);
                cu_new->id.us= 0;
 
                BKE_id_lib_local_paths(bmain, cu->id.lib, &cu_new->id);
@@ -291,7 +291,7 @@ void make_local_curve(Curve *cu)
 }
 
 /* Get list of nurbs from editnurbs structure */
-ListBase *curve_editnurbs(Curve *cu)
+ListBase *BKE_curve_editNurbs_get(Curve *cu)
 {
        if (cu->editnurb) {
                return &cu->editnurb->nurbs;
@@ -300,7 +300,7 @@ ListBase *curve_editnurbs(Curve *cu)
        return NULL;
 }
 
-short curve_type(Curve *cu)
+short BKE_curve_type_get(Curve *cu)
 {
        Nurb *nu;
        int type= cu->type;
@@ -322,9 +322,9 @@ short curve_type(Curve *cu)
        return type;
 }
 
-void update_curve_dimension(Curve *cu)
+void BKE_curve_curve_dimension_update(Curve *cu)
 {
-       ListBase *nurbs= BKE_curve_nurbs(cu);
+       ListBase *nurbs= BKE_curve_nurbs_get(cu);
        Nurb *nu= nurbs->first;
 
        if (cu->flag&CU_3D) {
@@ -335,24 +335,24 @@ void update_curve_dimension(Curve *cu)
        else {
                for ( ; nu; nu= nu->next) {
                        nu->flag |= CU_2D;
-                       test2DNurb(nu);
+                       BKE_nurb_test2D(nu);
 
                        /* since the handles are moved they need to be auto-located again */
                        if (nu->type == CU_BEZIER)
-                               calchandlesNurb(nu);
+                               BKE_nurb_handles_calc(nu);
                }
        }
 }
 
-void test_curve_type(Object *ob)
+void BKE_curve_type_test(Object *ob)
 {
-       ob->type= curve_type(ob->data);
+       ob->type= BKE_curve_type_get(ob->data);
 
        if (ob->type==OB_CURVE)
-               update_curve_dimension((Curve *)ob->data);
+               BKE_curve_curve_dimension_update((Curve *)ob->data);
 }
 
-void tex_space_curve(Curve *cu)
+void BKE_curve_tex_space_calc(Curve *cu)
 {
        DispList *dl;
        BoundBox *bb;
@@ -408,7 +408,7 @@ void tex_space_curve(Curve *cu)
        }
 }
 
-int count_curveverts(ListBase *nurb)
+int BKE_nurbList_verts_count(ListBase *nurb)
 {
        Nurb *nu;
        int tot=0;
@@ -423,7 +423,7 @@ int count_curveverts(ListBase *nurb)
        return tot;
 }
 
-int count_curveverts_without_handles(ListBase *nurb)
+int BKE_nurbList_verts_count_without_handles(ListBase *nurb)
 {
        Nurb *nu;
        int tot=0;
@@ -440,7 +440,7 @@ int count_curveverts_without_handles(ListBase *nurb)
 
 /* **************** NURBS ROUTINES ******************** */
 
-void freeNurb(Nurb *nu)
+void BKE_nurb_free(Nurb *nu)
 {
 
        if (nu==NULL) return;
@@ -460,7 +460,7 @@ void freeNurb(Nurb *nu)
 }
 
 
-void freeNurblist(ListBase *lb)
+void BKE_nurbList_free(ListBase *lb)
 {
        Nurb *nu, *next;
 
@@ -469,13 +469,13 @@ void freeNurblist(ListBase *lb)
        nu= lb->first;
        while (nu) {
                next= nu->next;
-               freeNurb(nu);
+               BKE_nurb_free(nu);
                nu= next;
        }
        lb->first= lb->last= NULL;
 }
 
-Nurb *duplicateNurb(Nurb *nu)
+Nurb *BKE_nurb_duplicate(Nurb *nu)
 {
        Nurb *newnu;
        int len;
@@ -515,22 +515,22 @@ Nurb *duplicateNurb(Nurb *nu)
        return newnu;
 }
 
-void duplicateNurblist(ListBase *lb1, ListBase *lb2)
+void BKE_nurbList_duplicate(ListBase *lb1, ListBase *lb2)
 {
        Nurb *nu, *nun;
        
-       freeNurblist(lb1);
+       BKE_nurbList_free(lb1);
        
        nu= lb2->first;
        while (nu) {
-               nun= duplicateNurb(nu);
+               nun= BKE_nurb_duplicate(nu);
                BLI_addtail(lb1, nun);
                
                nu= nu->next;
        }
 }
 
-void test2DNurb(Nurb *nu)
+void BKE_nurb_test2D(Nurb *nu)
 {
        BezTriple *bezt;
        BPoint *bp;
@@ -559,7 +559,7 @@ void test2DNurb(Nurb *nu)
        }
 }
 
-void minmaxNurb(Nurb *nu, float *min, float *max)
+void BKE_nurb_minmax(Nurb *nu, float *min, float *max)
 {
        BezTriple *bezt;
        BPoint *bp;
@@ -586,7 +586,7 @@ void minmaxNurb(Nurb *nu, float *min, float *max)
 }
 
 /* be sure to call makeknots after this */
-void addNurbPoints(Nurb *nu, int number)
+void BKE_nurb_points_add(Nurb *nu, int number)
 {
        BPoint *tmp= nu->bp;
        int i;
@@ -606,7 +606,7 @@ void addNurbPoints(Nurb *nu, int number)
        nu->pntsu += number;
 }
 
-void addNurbPointsBezier(Nurb *nu, int number)
+void BKE_nurb_bezierPoints_add(Nurb *nu, int number)
 {
        BezTriple *tmp= nu->bezt;
        int i;
@@ -706,7 +706,7 @@ static void makeknots(Nurb *nu, short uv)
        if (nu->type == CU_NURBS) {
                if (uv == 1) {
                        if (nu->knotsu) MEM_freeN(nu->knotsu);
-                       if (check_valid_nurb_u(nu)) {
+                       if (BKE_nurb_check_valid_u(nu)) {
                                nu->knotsu= MEM_callocN(4+sizeof(float)*KNOTSU(nu), "makeknots");
                                if (nu->flagu & CU_NURB_CYCLIC) {
                                        calcknots(nu->knotsu, nu->pntsu, nu->orderu, 0);  /* cyclic should be uniform */
@@ -721,7 +721,7 @@ static void makeknots(Nurb *nu, short uv)
                }
                else if (uv == 2) {
                        if (nu->knotsv) MEM_freeN(nu->knotsv);
-                       if (check_valid_nurb_v(nu)) {
+                       if (BKE_nurb_check_valid_v(nu)) {
                                nu->knotsv= MEM_callocN(4+sizeof(float)*KNOTSV(nu), "makeknots");
                                if (nu->flagv & CU_NURB_CYCLIC) {
                                        calcknots(nu->knotsv, nu->pntsv, nu->orderv, 0);  /* cyclic should be uniform */
@@ -736,12 +736,12 @@ static void makeknots(Nurb *nu, short uv)
        }
 }
 
-void nurbs_knot_calc_u(Nurb *nu)
+void BKE_nurb_knot_calc_u(Nurb *nu)
 {
        makeknots(nu, 1);
 }
 
-void nurbs_knot_calc_v(Nurb *nu)
+void BKE_nurb_knot_calc_v(Nurb *nu)
 {
        makeknots(nu, 2);
 }
@@ -809,7 +809,7 @@ static void basisNurb(float t, short order, short pnts, float *knots, float *bas
 }
 
 
-void makeNurbfaces(Nurb *nu, float *coord_array, int rowstride, int resolu, int resolv)
+void BKE_nurb_makeFaces(Nurb *nu, float *coord_array, int rowstride, int resolu, int resolv)
 /* coord_array  has to be 3*4*resolu*resolv in size, and zero-ed */
 {
        BPoint *bp;
@@ -972,7 +972,7 @@ void makeNurbfaces(Nurb *nu, float *coord_array, int rowstride, int resolu, int
        MEM_freeN(jend);
 }
 
-void makeNurbcurve(Nurb *nu, float *coord_array, float *tilt_array, float *radius_array, float *weight_array, int resolu, int stride)
+void BKE_nurb_makeCurve(Nurb *nu, float *coord_array, float *tilt_array, float *radius_array, float *weight_array, int resolu, int stride)
 /* coord_array has to be 3*4*pntsu*resolu in size and zero-ed
  * tilt_array and radius_array will be written to if valid */
 {
@@ -1074,7 +1074,7 @@ void makeNurbcurve(Nurb *nu, float *coord_array, float *tilt_array, float *radiu
 }
 
 /* forward differencing method for bezier curve */
-void forward_diff_bezier(float q0, float q1, float q2, float q3, float *p, int it, int stride)
+void BKE_curve_forward_diff_bezier(float q0, float q1, float q2, float q3, float *p, int it, int stride)
 {
        float rt0,rt1,rt2,rt3,f;
        int a;
@@ -1122,7 +1122,7 @@ static void forward_diff_bezier_cotangent(float *p0, float *p1, float *p2, float
 
 /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
 
-float *make_orco_surf(Object *ob)
+float *BKE_curve_surf_make_orco(Object *ob)
 {
        /* Note: this function is used in convertblender only atm, so
         * suppose nonzero curve's render resolution should always be used */
@@ -1190,7 +1190,7 @@ float *make_orco_surf(Object *ob)
                                float *_tdata= MEM_callocN((nu->pntsu*resolu) * (nu->pntsv*resolv) *3*sizeof(float), "temp data");
                                float *tdata= _tdata;
                                
-                               makeNurbfaces(nu, tdata, 0, resolu, resolv);
+                               BKE_nurb_makeFaces(nu, tdata, 0, resolu, resolv);
                                
                                for (b=0; b<sizeu; b++) {
                                        int use_b= b;
@@ -1224,7 +1224,7 @@ float *make_orco_surf(Object *ob)
        /* NOTE: This routine is tied to the order of vertex
         * built by displist and as passed to the renderer.
         */
-float *make_orco_curve(Scene *scene, Object *ob)
+float *BKE_curve_make_orco(Scene *scene, Object *ob)
 {
        Curve *cu = ob->data;
        DispList *dl;
@@ -1312,7 +1312,7 @@ float *make_orco_curve(Scene *scene, Object *ob)
 
 /* ***************** BEVEL ****************** */
 
-void makebevelcurve(Scene *scene, Object *ob, ListBase *disp, int forRender)
+void BKE_curve_bevel_make(Scene *scene, Object *ob, ListBase *disp, int forRender)
 {
        DispList *dl, *dlnew;
        Curve *bevcu, *cu;
@@ -2083,7 +2083,7 @@ static void make_bevel_list_segment_3D(BevList *bl)
 
 
 
-void makeBevelList(Object *ob)
+void BKE_curve_bevelList_make(Object *ob)
 {
        /*
         * - convert all curves to polys, with indication of resol and flags for double-vertices
@@ -2112,7 +2112,7 @@ void makeBevelList(Object *ob)
 
        BLI_freelistN(&(cu->bev));
        if (cu->editnurb && ob->type!=OB_FONT) {
-               ListBase *nurbs= curve_editnurbs(cu);
+               ListBase *nurbs= BKE_curve_editNurbs_get(cu);
                nu = nurbs->first;
        }
        else {
@@ -2128,7 +2128,7 @@ void makeBevelList(Object *ob)
                
                /* check we are a single point? also check we are not a surface and that the orderu is sane,
                 * enforced in the UI but can go wrong possibly */
-               if (!check_valid_nurb_u(nu)) {
+               if (!BKE_nurb_check_valid_u(nu)) {
                        bl= MEM_callocN(sizeof(BevList)+1*sizeof(BevPoint), "makeBevelList1");
                        BLI_addtail(&(cu->bev), bl);
                        bl->nr= 0;
@@ -2201,7 +2201,7 @@ void makeBevelList(Object *ob)
                                                
                                                /* BevPoint must stay aligned to 4 so sizeof(BevPoint)/sizeof(float) works */
                                                for (j=0; j<3; j++) {
-                                                       forward_diff_bezier(    prevbezt->vec[1][j],    prevbezt->vec[2][j],
+                                                       BKE_curve_forward_diff_bezier(  prevbezt->vec[1][j],    prevbezt->vec[2][j],
                                                                                                        bezt->vec[0][j],                bezt->vec[1][j],
                                                                                                        &(bevp->vec[j]), resolu, sizeof(BevPoint));
                                                }
@@ -2256,7 +2256,7 @@ void makeBevelList(Object *ob)
                                        else bl->poly= -1;
                                        bevp= (BevPoint *)(bl+1);
                                        
-                                       makeNurbcurve(  nu, &bevp->vec[0],
+                                       BKE_nurb_makeCurve(     nu, &bevp->vec[0],
                                                                        do_tilt         ? &bevp->alfa : NULL,
                                                                        do_radius       ? &bevp->radius : NULL,
                                                                        do_weight       ? &bevp->weight : NULL,
@@ -2719,18 +2719,18 @@ static void calchandlesNurb_intern(Nurb *nu, int skip_align)
        }
 }
 
-void calchandleNurb(BezTriple *bezt, BezTriple *prev, BezTriple *next, int mode)
+void BKE_nurb_handle_calc(BezTriple *bezt, BezTriple *prev, BezTriple *next, int mode)
 {
        calchandleNurb_intern(bezt, prev, next, mode, FALSE);
 }
 
-void calchandlesNurb(Nurb *nu) /* first, if needed, set handle flags */
+void BKE_nurb_handles_calc(Nurb *nu) /* first, if needed, set handle flags */
 {
        calchandlesNurb_intern(nu, FALSE);
 }
 
 
-void testhandlesNurb(Nurb *nu)
+void BKE_nurb_handles_test(Nurb *nu)
 {
        /* use when something has changed with handles.
         * it treats all BezTriples with the following rules:
@@ -2770,10 +2770,10 @@ void testhandlesNurb(Nurb *nu)
                bezt++;
        }
        
-       calchandlesNurb(nu);
+       BKE_nurb_handles_calc(nu);
 }
 
-void autocalchandlesNurb(Nurb *nu, int flag)
+void BKE_nurb_handles_autocalc(Nurb *nu, int flag)
 {
        /* checks handle coordinates and calculates type */
        
@@ -2841,21 +2841,21 @@ void autocalchandlesNurb(Nurb *nu, int flag)
                bezt2++;
        }
 
-       calchandlesNurb(nu);
+       BKE_nurb_handles_calc(nu);
 }
 
-void autocalchandlesNurb_all(ListBase *editnurb, int flag)
+void BKE_nurbList_handles_autocalc(ListBase *editnurb, int flag)
 {
        Nurb *nu;
        
        nu= editnurb->first;
        while (nu) {
-               autocalchandlesNurb(nu, flag);
+               BKE_nurb_handles_autocalc(nu, flag);
                nu= nu->next;
        }
 }
 
-void sethandlesNurb(ListBase *editnurb, short code)
+void BKE_nurbList_handles_set(ListBase *editnurb, short code)
 {
        /* code==1: set autohandle */
        /* code==2: set vectorhandle */
@@ -2884,7 +2884,7 @@ void sethandlesNurb(ListBase *editnurb, short code)
                                        }
                                        bezt++;
                                }
-                               calchandlesNurb(nu);
+                               BKE_nurb_handles_calc(nu);
                        }
                        nu= nu->next;
                }
@@ -2928,7 +2928,7 @@ void sethandlesNurb(ListBase *editnurb, short code)
        
                                        bezt++;
                                }
-                               calchandlesNurb(nu);
+                               BKE_nurb_handles_calc(nu);
                        }
                        nu= nu->next;
                }
@@ -2958,7 +2958,7 @@ static void swapdata(void *adr1, void *adr2, int len)
        }
 }
 
-void switchdirectionNurb(Nurb *nu)
+void BKE_nurb_direction_switch(Nurb *nu)
 {
        BezTriple *bezt1, *bezt2;
        BPoint *bp1, *bp2;
@@ -3064,9 +3064,9 @@ void switchdirectionNurb(Nurb *nu)
 }
 
 
-float (*curve_getVertexCos(Curve *UNUSED(cu), ListBase *lb, int *numVerts_r))[3]
+float (*BKE_curve_vertexCos_get(Curve *UNUSED(cu), ListBase *lb, int *numVerts_r))[3]
 {
-       int i, numVerts = *numVerts_r = count_curveverts(lb);
+       int i, numVerts = *numVerts_r = BKE_nurbList_verts_count(lb);
        float *co, (*cos)[3] = MEM_mallocN(sizeof(*cos)*numVerts, "cu_vcos");
        Nurb *nu;
 
@@ -3093,7 +3093,7 @@ float (*curve_getVertexCos(Curve *UNUSED(cu), ListBase *lb, int *numVerts_r))[3]
        return cos;
 }
 
-void curve_applyVertexCos(Curve *UNUSED(cu), ListBase *lb, float (*vertexCos)[3])
+void BK_curve_vertexCos_apply(Curve *UNUSED(cu), ListBase *lb, float (*vertexCos)[3])
 {
        float *co = vertexCos[0];
        Nurb *nu;
@@ -3121,9 +3121,9 @@ void curve_applyVertexCos(Curve *UNUSED(cu), ListBase *lb, float (*vertexCos)[3]
        }
 }
 
-float (*curve_getKeyVertexCos(Curve *UNUSED(cu), ListBase *lb, float *key))[3]
+float (*BKE_curve_keyVertexCos_get(Curve *UNUSED(cu), ListBase *lb, float *key))[3]
 {
-       int i, numVerts = count_curveverts(lb);
+       int i, numVerts = BKE_nurbList_verts_count(lb);
        float *co, (*cos)[3] = MEM_mallocN(sizeof(*cos)*numVerts, "cu_vcos");
        Nurb *nu;
 
@@ -3152,7 +3152,7 @@ float (*curve_getKeyVertexCos(Curve *UNUSED(cu), ListBase *lb, float *key))[3]
        return cos;
 }
 
-void curve_applyKeyVertexTilts(Curve *UNUSED(cu), ListBase *lb, float *key)
+void BKE_curve_keyVertexTilts_apply(Curve *UNUSED(cu), ListBase *lb, float *key)
 {
        Nurb *nu;
        int i;
@@ -3179,7 +3179,7 @@ void curve_applyKeyVertexTilts(Curve *UNUSED(cu), ListBase *lb, float *key)
        }
 }
 
-int check_valid_nurb_u( struct Nurb *nu )
+int BKE_nurb_check_valid_u( struct Nurb *nu )
 {
        if (nu==NULL)                                           return 0;
        if (nu->pntsu <= 1)                                     return 0;
@@ -3194,7 +3194,7 @@ int check_valid_nurb_u( struct Nurb *nu )
        }
        return 1;
 }
-int check_valid_nurb_v( struct Nurb *nu)
+int BKE_nurb_check_valid_v( struct Nurb *nu)
 {
        if (nu==NULL)                                           return 0;
        if (nu->pntsv <= 1)                                     return 0;
@@ -3210,7 +3210,7 @@ int check_valid_nurb_v( struct Nurb *nu)
        return 1;
 }
 
-int clamp_nurb_order_u( struct Nurb *nu )
+int BKE_nurb_order_clamp_u( struct Nurb *nu )
 {
        int change = 0;
        if (nu->pntsu<nu->orderu) {
@@ -3224,7 +3224,7 @@ int clamp_nurb_order_u( struct Nurb *nu )
        return change;
 }
 
-int clamp_nurb_order_v( struct Nurb *nu)
+int BKE_nurb_order_clamp_v( struct Nurb *nu)
 {
        int change = 0;
        if (nu->pntsv<nu->orderv) {
@@ -3239,10 +3239,10 @@ int clamp_nurb_order_v( struct Nurb *nu)
 }
 
 /* Get edit nurbs or normal nurbs list */
-ListBase *BKE_curve_nurbs(Curve *cu)
+ListBase *BKE_curve_nurbs_get(Curve *cu)
 {
        if (cu->editnurb) {
-               return curve_editnurbs(cu);
+               return BKE_curve_editNurbs_get(cu);
        }
 
        return &cu->nurb;
@@ -3250,20 +3250,20 @@ ListBase *BKE_curve_nurbs(Curve *cu)
 
 
 /* basic vertex data functions */
-int minmax_curve(Curve *cu, float min[3], float max[3])
+int BKE_curve_minmax(Curve *cu, float min[3], float max[3])
 {
-       ListBase *nurb_lb= BKE_curve_nurbs(cu);
+       ListBase *nurb_lb= BKE_curve_nurbs_get(cu);
        Nurb *nu;
 
        for (nu= nurb_lb->first; nu; nu= nu->next)
-               minmaxNurb(nu, min, max);
+               BKE_nurb_minmax(nu, min, max);
 
        return (nurb_lb->first != NULL);
 }
 
-int curve_center_median(Curve *cu, float cent[3])
+int BKE_curve_center_median(Curve *cu, float cent[3])
 {
-       ListBase *nurb_lb= BKE_curve_nurbs(cu);
+       ListBase *nurb_lb= BKE_curve_nurbs_get(cu);
        Nurb *nu;
        int total= 0;
 
@@ -3297,11 +3297,11 @@ int curve_center_median(Curve *cu, float cent[3])
        return (total != 0);
 }
 
-int curve_center_bounds(Curve *cu, float cent[3])
+int BKE_curve_center_bounds(Curve *cu, float cent[3])
 {
        float min[3], max[3];
        INIT_MINMAX(min, max);
-       if (minmax_curve(cu, min, max)) {
+       if (BKE_curve_minmax(cu, min, max)) {
                mid_v3_v3v3(cent, min, max);
                return 1;
        }
@@ -3309,9 +3309,9 @@ int curve_center_bounds(Curve *cu, float cent[3])
        return 0;
 }
 
-void curve_translate(Curve *cu, float offset[3], int do_keys)
+void BKE_curve_translate(Curve *cu, float offset[3], int do_keys)
 {
-       ListBase *nurb_lb= BKE_curve_nurbs(cu);
+       ListBase *nurb_lb= BKE_curve_nurbs_get(cu);
        Nurb *nu;
        int i;
 
@@ -3346,9 +3346,9 @@ void curve_translate(Curve *cu, float offset[3], int do_keys)
        }
 }
 
-void curve_delete_material_index(Curve *cu, int index)
+void BKE_curve_delete_material_index(Curve *cu, int index)
 {
-       const int curvetype= curve_type(cu);
+       const int curvetype= BKE_curve_type_get(cu);
 
        if (curvetype == OB_FONT) {
                struct CharInfo *info= cu->strinfo;
index 246c973..045d852 100644 (file)
@@ -539,7 +539,7 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O
                        break;
                case OB_MBALL: 
                {
-                       Object *mom= find_basis_mball(scene, ob);
+                       Object *mom= BKE_metaball_basis_find(scene, ob);
                        
                        if (mom!=ob) {
                                node2 = dag_get_node(dag, mom);
index fcd8069..3d79386 100644 (file)
@@ -1,4 +1,5 @@
 /*
+
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
@@ -296,7 +297,7 @@ static void curve_to_displist(Curve *cu, ListBase *nubase, ListBase *dispbase, i
                        else
                                resolu= nu->resolu;
                        
-                       if (!check_valid_nurb_u(nu));
+                       if (!BKE_nurb_check_valid_u(nu));
                        else if (nu->type == CU_BEZIER) {
                                
                                /* count */
@@ -351,7 +352,7 @@ static void curve_to_displist(Curve *cu, ListBase *nubase, ListBase *dispbase, i
                                        else {
                                                int j;
                                                for (j=0; j<3; j++) {
-                                                       forward_diff_bezier(    prevbezt->vec[1][j],
+                                                       BKE_curve_forward_diff_bezier(  prevbezt->vec[1][j],
                                                                                                        prevbezt->vec[2][j],
                                                                                                        bezt->vec[0][j],
                                                                                                        bezt->vec[1][j],
@@ -384,7 +385,7 @@ static void curve_to_displist(Curve *cu, ListBase *nubase, ListBase *dispbase, i
                                data= dl->verts;
                                if (nu->flagu & CU_NURB_CYCLIC) dl->type= DL_POLY;
                                else dl->type= DL_SEGM;
-                               makeNurbcurve(nu, data, NULL, NULL, NULL, resolu, 3*sizeof(float));
+                               BKE_nurb_makeCurve(nu, data, NULL, NULL, NULL, resolu, 3*sizeof(float));
                        }
                        else if (nu->type == CU_POLY) {
                                len= nu->pntsu;
@@ -672,9 +673,9 @@ void makeDispListMBall(Scene *scene, Object *ob)
        freedisplist(&(ob->disp));
 
        if (ob->type==OB_MBALL) {
-               if (ob==find_basis_mball(scene, ob)) {
-                       metaball_polygonize(scene, ob, &ob->disp);
-                       tex_space_mball(ob);
+               if (ob==BKE_metaball_basis_find(scene, ob)) {
+                       BKE_metaball_polygonize(scene, ob, &ob->disp);
+                       BKE_metaball_tex_space_calc(ob);
 
                        object_deform_mball(ob, &ob->disp);
                }
@@ -685,8 +686,8 @@ void makeDispListMBall(Scene *scene, Object *ob)
 
 void makeDispListMBall_forRender(Scene *scene, Object *ob, ListBase *dispbase)
 {
-       metaball_polygonize(scene, ob, dispbase);
-       tex_space_mball(ob);
+       BKE_metaball_polygonize(scene, ob, dispbase);
+       BKE_metaball_tex_space_calc(ob);
        
        object_deform_mball(ob, dispbase);
 }
@@ -730,7 +731,7 @@ static void curve_calc_modifiers_pre(Scene *scene, Object *ob, int forRender, fl
        ModifierData *md = modifiers_getVirtualModifierList(ob);
        ModifierData *pretessellatePoint;
        Curve *cu= ob->data;
-       ListBase *nurb= BKE_curve_nurbs(cu);
+       ListBase *nurb= BKE_curve_nurbs_get(cu);
        int numVerts = 0;
        int editmode = (!forRender && cu->editnurb);
        float (*originalVerts)[3] = NULL;
@@ -753,9 +754,9 @@ static void curve_calc_modifiers_pre(Scene *scene, Object *ob, int forRender, fl
                         * tilts, which is passed through in the modifier stack.
                         * this is also the reason curves do not use a virtual
                         * shape key modifier yet. */
-                       deformedVerts= curve_getKeyVertexCos(cu, nurb, keyVerts);
+                       deformedVerts= BKE_curve_keyVertexCos_get(cu, nurb, keyVerts);
                        originalVerts= MEM_dupallocN(deformedVerts);
-                       numVerts = count_curveverts_without_handles(nurb);
+                       numVerts = BKE_nurbList_verts_count_without_handles(nurb);
                }
        }
        
@@ -770,7 +771,7 @@ static void curve_calc_modifiers_pre(Scene *scene, Object *ob, int forRender, fl
                        if (mti->type!=eModifierTypeType_OnlyDeform) continue;
 
                        if (!deformedVerts) {
-                               deformedVerts = curve_getVertexCos(cu, nurb, &numVerts);
+                               deformedVerts = BKE_curve_vertexCos_get(cu, nurb, &numVerts);
                                originalVerts = MEM_dupallocN(deformedVerts);
                        }
 
@@ -782,9 +783,9 @@ static void curve_calc_modifiers_pre(Scene *scene, Object *ob, int forRender, fl
        }
 
        if (deformedVerts)
-               curve_applyVertexCos(cu, nurb, deformedVerts);
+               BK_curve_vertexCos_apply(cu, nurb, deformedVerts);
        if (keyVerts) /* these are not passed through modifier stack */
-               curve_applyKeyVertexTilts(cu, nurb, keyVerts);
+               BKE_curve_keyVertexTilts_apply(cu, nurb, keyVerts);
 
        if (keyVerts)
                MEM_freeN(keyVerts);
@@ -834,7 +835,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *dispba
        ModifierData *md = modifiers_getVirtualModifierList(ob);
        ModifierData *pretessellatePoint;
        Curve *cu= ob->data;
-       ListBase *nurb= BKE_curve_nurbs(cu);
+       ListBase *nurb= BKE_curve_nurbs_get(cu);
        int required_mode = 0, totvert = 0;
        int editmode = (!forRender && cu->editnurb);
        DerivedMesh *dm= NULL, *ndm;
@@ -956,7 +957,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *dispba
        }
 
        if (deformedVerts) {
-               curve_applyVertexCos(ob->data, nurb, originalVerts);
+               BK_curve_vertexCos_apply(ob->data, nurb, originalVerts);
                MEM_freeN(originalVerts);
                MEM_freeN(deformedVerts);
        }
@@ -1023,7 +1024,7 @@ static void add_orco_dm(Scene *scene, Object *ob, DerivedMesh *dm, DerivedMesh *
                        dm->getVertCos(dm, orco);
        }
        else {
-               orco= (float(*)[3])make_orco_curve(scene, ob);
+               orco= (float(*)[3])BKE_curve_make_orco(scene, ob);
        }
 
        for (a=0; a<totvert; a++) {
@@ -1108,7 +1109,7 @@ void makeDispListSurf(Scene *scene, Object *ob, ListBase *dispbase,
        float (*deformedVerts)[3];
 
        if (!forRender && cu->editnurb)
-               nubase= curve_editnurbs(cu);
+               nubase= BKE_curve_editNurbs_get(cu);
        else
                nubase= &cu->nurb;
 
@@ -1144,7 +1145,7 @@ void makeDispListSurf(Scene *scene, Object *ob, ListBase *dispbase,
                                if (nu->flagu & CU_NURB_CYCLIC) dl->type= DL_POLY;
                                else dl->type= DL_SEGM;
 
-                               makeNurbcurve(nu, data, NULL, NULL, NULL, resolu, 3*sizeof(float));
+                               BKE_nurb_makeCurve(nu, data, NULL, NULL, NULL, resolu, 3*sizeof(float));
                        }
                        else {
                                len= (nu->pntsu*resolu) * (nu->pntsv*resolv);
@@ -1168,7 +1169,7 @@ void makeDispListSurf(Scene *scene, Object *ob, ListBase *dispbase,
                                if (nu->flagv & CU_NURB_CYCLIC) dl->flag|= DL_CYCL_U;   /* reverse too! */
                                if (nu->flagu & CU_NURB_CYCLIC) dl->flag|= DL_CYCL_V;
 
-                               makeNurbfaces(nu, data, 0, resolu, resolv);
+                               BKE_nurb_makeFaces(nu, data, 0, resolu, resolv);
                                
                                /* gl array drawing: using indices */
                                displist_surf_indices(dl);
@@ -1182,7 +1183,7 @@ void makeDispListSurf(Scene *scene, Object *ob, ListBase *dispbase,
        copy_displist(&cu->disp, dispbase);
 
        if (!forRender) {
-               tex_space_curve(cu);
+               BKE_curve_tex_space_calc(cu);
        }
 
        if (!forOrco)
@@ -1262,7 +1263,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
                float (*deformedVerts)[3];
                int numVerts;
 
-               nubase= BKE_curve_nurbs(cu);
+               nubase= BKE_curve_nurbs_get(cu);
 
                BLI_freelistN(&(cu->bev));
 
@@ -1273,10 +1274,10 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
 
                if (!forOrco) curve_calc_modifiers_pre(scene, ob, forRender, &originalVerts, &deformedVerts, &numVerts);
 
-               makeBevelList(ob);
+               BKE_curve_bevelList_make(ob);
 
                /* If curve has no bevel will return nothing */
-               makebevelcurve(scene, ob, &dlbev, forRender);
+               BKE_curve_bevel_make(scene, ob, &dlbev, forRender);
 
                /* no bevel or extrude, and no width correction? */
                if (!dlbev.first && cu->width==1.0f) {
@@ -1410,7 +1411,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
                copy_displist(&cu->disp, dispbase);
 
                if (!forRender) {
-                       tex_space_curve(cu);
+                       BKE_curve_tex_space_calc(cu);
                }
 
                if (!forOrco) curve_calc_modifiers_post(scene, ob, dispbase, derivedFinal, forRender, originalVerts, deformedVerts);
index 806d795..e854325 100644 (file)
@@ -800,7 +800,7 @@ void calchandles_fcurve (FCurve *fcu)
                if (bezt->vec[2][0] < bezt->vec[1][0]) bezt->vec[2][0]= bezt->vec[1][0];
                
                /* calculate auto-handles */
-               calchandleNurb(bezt, prev, next, 1);    /* 1==special autohandle */
+               BKE_nurb_handle_calc(bezt, prev, next, 1);      /* 1==special autohandle */
                
                /* for automatic ease in and out */
                if (ELEM(bezt->h1,HD_AUTO,HD_AUTO_ANIM) && ELEM(bezt->h2,HD_AUTO,HD_AUTO_ANIM)) {
index cdc9236..5d7960a 100644 (file)
@@ -1011,7 +1011,7 @@ struct chartrans *BKE_text_to_curve(Main *bmain, Scene *scene, Object *ob, int m
 
        if (mode == FO_EDIT) {
                /* make nurbdata */
-               freeNurblist(&cu->nurb);
+               BKE_nurbList_free(&cu->nurb);
                
                ct= chartransdata;
                if (cu->sepchar==0) {
index 0a1c046..54a2613 100644 (file)
@@ -1594,7 +1594,7 @@ void curve_to_key(Curve *cu, KeyBlock *kb, ListBase *nurb)
        int a, tot;
 
        /* count */
-       tot = count_curveverts(nurb);
+       tot = BKE_nurbList_verts_count(nurb);
        if (tot == 0) return;
 
        if (kb->data) MEM_freeN(kb->data);
@@ -1647,7 +1647,7 @@ void key_to_curve(KeyBlock *kb, Curve *UNUSED(cu), ListBase *nurb)
        nu = nurb->first;
        fp = kb->data;
 
-       tot = count_curveverts(nurb);
+       tot = BKE_nurbList_verts_count(nurb);
 
        tot = MIN2(kb->totelem, tot);
 
@@ -1742,7 +1742,7 @@ float (*key_to_vertcos(Object * ob, KeyBlock * kb))[3]
        }
        else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
                Curve *cu = (Curve *)ob->data;
-               tot = count_curveverts(&cu->nurb);
+               tot = BKE_nurbList_verts_count(&cu->nurb);
        }
 
        if (tot == 0) return NULL;
@@ -1822,7 +1822,7 @@ void vertcos_to_key(Object *ob, KeyBlock *kb, float (*vertCos)[3])
        else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
                Curve *cu = (Curve *)ob->data;
                elemsize = cu->key->elemsize;
-               tot = count_curveverts(&cu->nurb);
+               tot = BKE_nurbList_verts_count(&cu->nurb);
        }
 
        if (tot == 0) {
index 07839b1..7126627 100644 (file)
@@ -198,12 +198,12 @@ int id_make_local(ID *id, int test)
                        return 1;
                case ID_CU:
                        if (!test) {
-                               make_local_curve((Curve*)id);
+                               BKE_curve_make_local((Curve*)id);
                                make_local_key(((Curve*)id)->key);
                        }
                        return 1;
                case ID_MB:
-                       if (!test) make_local_mball((MetaBall*)id);
+                       if (!test) BKE_metaball_make_local((MetaBall*)id);
                        return 1;
                case ID_MA:
                        if (!test) make_local_material((Material*)id);
@@ -291,10 +291,10 @@ int id_copy(ID *id, ID **newid, int test)
                        if (!test) *newid= (ID*)copy_mesh((Mesh*)id);
                        return 1;
                case ID_CU:
-                       if (!test) *newid= (ID*)copy_curve((Curve*)id);
+                       if (!test) *newid= (ID*)BKE_curve_copy((Curve*)id);
                        return 1;
                case ID_MB:
-                       if (!test) *newid= (ID*)copy_mball((MetaBall*)id);
+                       if (!test) *newid= (ID*)BKE_metaball_copy((MetaBall*)id);
                        return 1;
                case ID_MA:
                        if (!test) *newid= (ID*)copy_material((Material*)id);
@@ -810,10 +810,10 @@ void free_libblock(ListBase *lb, void *idv)
                        free_mesh((Mesh *)id, 1);
                        break;
                case ID_CU:
-                       free_curve((Curve *)id);
+                       BKE_curve_free((Curve *)id);
                        break;
                case ID_MB:
-                       free_mball((MetaBall *)id);
+                       BKE_metaball_free((MetaBall *)id);
                        break;
                case ID_MA:
                        free_material((Material *)id);
@@ -886,7 +886,7 @@ void free_libblock(ListBase *lb, void *idv)
                        free_gpencil_data((bGPdata *)id);
                        break;
                case ID_MC:
-                       free_movieclip((MovieClip *)id);
+                       BKE_movieclip_free((MovieClip *)id);
                        break;
        }
 
index 21a91b3..2dfd41f 100644 (file)
@@ -530,7 +530,7 @@ static void data_delete_material_index_id(ID *id, short index)
                mesh_delete_material_index((Mesh *)id, index);
                break;
        case ID_CU:
-               curve_delete_material_index((Curve *)id, index);
+               BKE_curve_delete_material_index((Curve *)id, index);
                break;
        case ID_MB:
                /* meta-elems don't have materials atm */
index 60ccfa2..73e3576 100644 (file)
 #include "BKE_object.h"
 #include "BKE_material.h"
 
+/* Data types */
+
+typedef struct point {                 /* a three-dimensional point */
+       float x, y, z;                          /* its coordinates */
+} MB_POINT;
+
+typedef struct vertex {                        /* surface vertex */
+       MB_POINT position, normal;              /* position and surface normal */
+} VERTEX;
+
+typedef struct vertices {              /* list of vertices in polygonization */
+       int count, max;                         /* # vertices, max # allowed */
+       VERTEX *ptr;                            /* dynamically allocated */
+} VERTICES;
+
+typedef struct corner {                        /* corner of a cube */
+       int i, j, k;                            /* (i, j, k) is index within lattice */
+       float x, y, z, value;           /* location and function value */
+       struct corner *next;
+} CORNER;
+
+typedef struct cube {                  /* partitioning cell (cube) */
+       int i, j, k;                            /* lattice location of cube */
+       CORNER *corners[8];                     /* eight corners */
+} CUBE;
+
+typedef struct cubes {                 /* linked list of cubes acting as stack */
+       CUBE cube;                                      /* a single cube */
+       struct cubes *next;                     /* remaining elements */
+} CUBES;
+
+typedef struct centerlist {            /* list of cube locations */
+       int i, j, k;                            /* cube location */
+       struct centerlist *next;        /* remaining elements */
+} CENTERLIST;
+
+typedef struct edgelist {              /* list of edges */
+       int i1, j1, k1, i2, j2, k2;     /* edge corner ids */
+       int vid;                                        /* vertex id */
+       struct edgelist *next;          /* remaining elements */
+} EDGELIST;
+
+typedef struct intlist {               /* list of integers */
+       int i;                                          /* an integer */
+       struct intlist *next;           /* remaining elements */
+} INTLIST;
+
+typedef struct intlists {              /* list of list of integers */
+       INTLIST *list;                          /* a list of integers */
+       struct intlists *next;          /* remaining elements */
+} INTLISTS;
+
+typedef struct process {               /* parameters, function, storage */
+       /* what happens here? floats, I think. */
+       /*  float (*function)(void);     */     /* implicit surface function */
+       float (*function)(float, float, float);
+       float size, delta;                      /* cube size, normal delta */
+       int bounds;                                     /* cube range within lattice */
+       CUBES *cubes;                           /* active cubes */
+       VERTICES vertices;                      /* surface vertices */
+       CENTERLIST **centers;           /* cube center hash table */
+       CORNER **corners;                       /* corner value hash table */
+       EDGELIST **edges;                       /* edge and vertex id hash table */
+} PROCESS;
+
+/* dividing scene using octal tree makes polygonisation faster */
+typedef struct ml_pointer {
+       struct ml_pointer *next, *prev;
+       struct MetaElem *ml;
+} ml_pointer;
+
+typedef struct octal_node {
+       struct octal_node *nodes[8];    /* children of current node */
+       struct octal_node *parent;      /* parent of current node */
+       struct ListBase elems;          /* ListBase of MetaElem pointers (ml_pointer) */
+       float x_min, y_min, z_min;      /* 1st border point */
+       float x_max, y_max, z_max;      /* 7th border point */
+       float x,y,z;                    /* center of node */
+       int pos, neg;                   /* number of positive and negative MetaElements in the node */
+       int count;                      /* number of MetaElems, which belongs to the node */
+} octal_node;
+
+typedef struct octal_tree {
+       struct octal_node *first;       /* first node */
+       int pos, neg;                   /* number of positive and negative MetaElements in the scene */
+       short depth;                    /* number of scene subdivision */
+} octal_tree;
+
+struct pgn_elements {
+       struct pgn_elements *next, *prev;
+       char *data;
+};
+
+/* Forward declarations */
+static int vertid(CORNER *c1, CORNER *c2, PROCESS *p, MetaBall *mb);
+static int setcenter(CENTERLIST *table[], int i, int j, int k);
+static CORNER *setcorner(PROCESS* p, int i, int j, int k);
+static void converge (MB_POINT *p1, MB_POINT *p2, float v1, float v2,
+                          float (*function)(float, float, float), MB_POINT *p, MetaBall *mb, int f);
+
 /* Global variables */
 
 static float thresh= 0.6f;
@@ -73,7 +173,7 @@ static MetaElem **mainb;
 static octal_tree *metaball_tree = NULL;
 /* Functions */
 
-void unlink_mball(MetaBall *mb)
+void BKE_metaball_unlink(MetaBall *mb)
 {
        int a;
        
@@ -85,9 +185,9 @@ void unlink_mball(MetaBall *mb)
 
 
 /* do not free mball itself */
-void free_mball(MetaBall *mb)
+void BKE_metaball_free(MetaBall *mb)
 {
-       unlink_mball(mb);       
+       BKE_metaball_unlink(mb);        
        
        if (mb->adt) {
                BKE_free_animdata((ID *)mb);
@@ -99,7 +199,7 @@ void free_mball(MetaBall *mb)
        if (mb->disp.first) freedisplist(&mb->disp);
 }
 
-MetaBall *add_mball(const char *name)
+MetaBall *BKE_metaball_add(const char *name)
 {
        MetaBall *mb;
        
@@ -115,7 +215,7 @@ MetaBall *add_mball(const char *name)
        return mb;
 }
 
-MetaBall *copy_mball(MetaBall *mb)
+MetaBall *BKE_metaball_copy(MetaBall *mb)
 {
        MetaBall *mbn;
        int a;
@@ -143,7 +243,7 @@ static void extern_local_mball(MetaBall *mb)
        }
 }
 
-void make_local_mball(MetaBall *mb)
+void BKE_metaball_make_local(MetaBall *mb)
 {
        Main *bmain= G.main;
        Object *ob;
@@ -174,7 +274,7 @@ void make_local_mball(MetaBall *mb)
                extern_local_mball(mb);
        }
        else if (is_local && is_lib) {
-               MetaBall *mb_new= copy_mball(mb);
+               MetaBall *mb_new= BKE_metaball_copy(mb);
                mb_new->id.us= 0;
 
                /* Remap paths of new ID using old library as base. */
@@ -194,7 +294,7 @@ void make_local_mball(MetaBall *mb)
 
 /* most simple meta-element adding function
  * don't do context manipulation here (rna uses) */
-MetaElem *add_metaball_element(MetaBall *mb, const int type)
+MetaElem *BKE_metaball_element_add(MetaBall *mb, const int type)
 {
        MetaElem *ml= MEM_callocN(sizeof(MetaElem), "metaelem");
 
@@ -246,7 +346,7 @@ MetaElem *add_metaball_element(MetaBall *mb, const int type)
  * basic MetaBall (usually with name Meta). All other MetaBalls (with
  * names Meta.001, Meta.002, etc) are included in this Bounding Box.
  */
-void tex_space_mball(Object *ob)
+void BKE_metaball_tex_space_calc(Object *ob)
 {
        DispList *dl;
        BoundBox *bb;
@@ -290,7 +390,7 @@ void tex_space_mball(Object *ob)
        boundbox_set_from_min_max(bb, min, max);
 }
 
-float *make_orco_mball(Object *ob, ListBase *dispbase)
+float *BKE_metaball_make_orco(Object *ob, ListBase *dispbase)
 {
        BoundBox *bb;
        DispList *dl;
@@ -342,7 +442,7 @@ float *make_orco_mball(Object *ob, ListBase *dispbase)
  * It test last character of Object ID name. If last character
  * is digit it return 0, else it return 1.
  */
-int is_basis_mball(Object *ob)
+int BKE_metaball_is_basis(Object *ob)
 {
        int len;
        
@@ -353,7 +453,7 @@ int is_basis_mball(Object *ob)
 }
 
 /* return nonzero if ob1 is a basis mball for ob */
-int is_mball_basis_for (Object *ob1, Object *ob2)
+int BKE_metaball_is_basis_for (Object *ob1, Object *ob2)
 {
        int basis1nr, basis2nr;
        char basis1name[MAX_ID_NAME], basis2name[MAX_ID_NAME];
@@ -361,7 +461,7 @@ int is_mball_basis_for (Object *ob1, Object *ob2)
        BLI_split_name_num(basis1name, &basis1nr, ob1->id.name+2, '.');
        BLI_split_name_num(basis2name, &basis2nr, ob2->id.name+2, '.');
 
-       if (!strcmp(basis1name, basis2name)) return is_basis_mball(ob1);
+       if (!strcmp(basis1name, basis2name)) return BKE_metaball_is_basis(ob1);
        else return 0;
 }
 
@@ -371,7 +471,7 @@ int is_mball_basis_for (Object *ob1, Object *ob2)
  * are copied to all metaballs in same "group" (metaballs with same base name: MBall,
  * MBall.001, MBall.002, etc). The most important is to copy properties to the base metaball,
  * because this metaball influence polygonisation of metaballs. */
-void copy_mball_properties(Scene *scene, Object *active_object)
+void BKE_metaball_properties_copy(Scene *scene, Object *active_object)
 {
        Scene *sce_iter= scene;
        Base *base;
@@ -416,7 +516,7 @@ void copy_mball_properties(Scene *scene, Object *active_object)
  *
  * warning!, is_basis_mball() can fail on returned object, see long note above.
  */
-Object *find_basis_mball(Scene *scene, Object *basis)
+Object *BKE_metaball_basis_find(Scene *scene, Object *basis)
 {
        Scene *sce_iter= scene;
        Base *base;
@@ -522,14 +622,14 @@ Object *find_basis_mball(Scene *scene, Object *basis)
 
 /* **************** POLYGONIZATION ************************ */
 
-void calc_mballco(MetaElem *ml, float vec[3])
+static void calc_mballco(MetaElem *ml, float vec[3])
 {
        if (ml->mat) {
                mul_m4_v3((float (*)[4])ml->mat, vec);
        }
 }
 
-float densfunc(MetaElem *ball, float x, float y, float z)
+static float densfunc(MetaElem *ball, float x, float y, float z)
 {
        float dist2 = 0.0, dx, dy, dz;
        float vec[3];
@@ -605,7 +705,7 @@ float densfunc(MetaElem *ball, float x, float y, float z)
        }
 }
 
-octal_node* find_metaball_octal_node(octal_node *node, float x, float y, float z, short depth)
+static octal_node* find_metaball_octal_node(octal_node *node, float x, float y, float z, short depth)
 {
        if (!depth) return node;
        
@@ -673,7 +773,7 @@ octal_node* find_metaball_octal_node(octal_node *node, float x, float y, float z
        return node;
 }
 
-float metaball(float x, float y, float z)
+static float metaball(float x, float y, float z)
 /*  float x, y, z; */
 {
        struct octal_node *node;
@@ -713,7 +813,7 @@ static int *indices=NULL;
 static int totindex, curindex;
 
 
-void accum_mballfaces(int i1, int i2, int i3, int i4)
+static void accum_mballfaces(int i1, int i2, int i3, int i4)
 {
        int *newi, *cur;
        /* static int i=0; I would like to delete altogether, but I don't dare to, yet */
@@ -746,7 +846,7 @@ void accum_mballfaces(int i1, int i2, int i3, int i4)
 }
 
 /* ******************* MEMORY MANAGEMENT *********************** */
-void *new_pgn_element(int size)
+static void *new_pgn_element(int size)
 {
        /* during polygonize 1000s of elements are allocated
         * and never freed in between. Freeing only done at the end.
@@ -789,7 +889,7 @@ void *new_pgn_element(int size)
        return cur->data;
 }
 
-void freepolygonize(PROCESS *p)
+static void freepolygonize(PROCESS *p)
 {
        MEM_freeN(p->corners);
        MEM_freeN(p->edges);
@@ -832,7 +932,7 @@ static int rightface[12]   = {
 
 /* docube: triangulate the cube directly, without decomposition */
 
-void docube(CUBE *cube, PROCESS *p, MetaBall *mb)
+static void docube(CUBE *cube, PROCESS *p, MetaBall *mb)
 {
        INTLISTS *polys;
        CORNER *c1, *c2;
@@ -900,7 +1000,7 @@ void docube(CUBE *cube, PROCESS *p, MetaBall *mb)
  * if surface crosses face, compute other four corners of adjacent cube
  * and add new cube to cube stack */
 
-void testface(int i, int j, int k, CUBE* old, int bit, int c1, int c2, int c3, int c4, PROCESS *p)
+static void testface(int i, int j, int k, CUBE* old, int bit, int c1, int c2, int c3, int c4, PROCESS *p)
 {
        CUBE newc;
        CUBES *oldcubes = p->cubes;
@@ -951,7 +1051,7 @@ void testface(int i, int j, int k, CUBE* old, int bit, int c1, int c2, int c3, i
 /* setcorner: return corner with the given lattice location
  * set (and cache) its function value */
 
-CORNER *setcorner (PROCESS* p, int i, int j, int k)
+static CORNER *setcorner (PROCESS* p, int i, int j, int k)
 {
        /* for speed, do corner value caching here */
        CORNER *c;
@@ -986,7 +1086,7 @@ CORNER *setcorner (PROCESS* p, int i, int j, int k)
 
 /* nextcwedge: return next clockwise edge from given edge around given face */
 
-int nextcwedge (int edge, int face)
+static int nextcwedge (int edge, int face)
 {
        switch (edge) {
        case LB: 
@@ -1020,7 +1120,7 @@ int nextcwedge (int edge, int face)
 
 /* otherface: return face adjoining edge that is not the given face */
 
-int otherface (int edge, int face)
+static int otherface (int edge, int face)
 {
        int other = leftface[edge];
        return face == other? rightface[edge] : other;
@@ -1029,7 +1129,7 @@ int otherface (int edge, int face)
 
 /* makecubetable: create the 256 entry table for cubical polygonization */
 
-void makecubetable (void)
+static void makecubetable (void)
 {
        static int isdone= 0;
        int i, e, c, done[12], pos[8];
@@ -1070,7 +1170,7 @@ void makecubetable (void)
        }
 }
 
-void BKE_freecubetable(void)
+void BKE_metaball_cubeTable_free(void)
 {
        int i;
        INTLISTS *lists, *nlists;
@@ -1100,7 +1200,7 @@ void BKE_freecubetable(void)
 /* setcenter: set (i,j,k) entry of table[]
  * return 1 if already set; otherwise, set and return 0 */
 
-int setcenter(CENTERLIST *table[], int i, int j, int k)
+static int setcenter(CENTERLIST *table[], int i, int j, int k)
 {
        int index;
        CENTERLIST *newc, *l, *q;
@@ -1125,7 +1225,7 @@ int setcenter(CENTERLIST *table[], int i, int j, int k)
 
 /* setedge: set vertex id for edge */
 
-void setedge (EDGELIST *table[],
+static void setedge (EDGELIST *table[],
                          int i1, int j1,
                          int k1, int i2,
                          int j2, int k2,
@@ -1161,7 +1261,7 @@ void setedge (EDGELIST *table[],
 
 /* getedge: return vertex id for edge; return -1 if not set */
 
-int getedge (EDGELIST *table[],
+static int getedge (EDGELIST *table[],
                         int i1, int j1, int k1,
                         int i2, int j2, int k2)
 {
@@ -1202,7 +1302,7 @@ int getedge (EDGELIST *table[],
 
 /* addtovertices: add v to sequence of vertices */
 
-void addtovertices (VERTICES *vertices, VERTEX v)
+static void addtovertices (VERTICES *vertices, VERTEX v)
 {
        if (vertices->count == vertices->max) {
                int i;
@@ -1220,7 +1320,7 @@ void addtovertices (VERTICES *vertices, VERTEX v)
 
 /* vnormal: compute unit length surface normal at point */
 
-void vnormal (MB_POINT *point, PROCESS *p, MB_POINT *v)
+static void vnormal (MB_POINT *point, PROCESS *p, MB_POINT *v)
 {
        float delta= 0.2f*p->delta;
        float f = p->function(point->x, point->y, point->z);
@@ -1270,7 +1370,7 @@ void vnormal (MB_POINT *point, PROCESS *p, MB_POINT *v)
 }
 
 
-int vertid (CORNER *c1, CORNER *c2, PROCESS *p, MetaBall *mb)
+static int vertid (CORNER *c1, CORNER *c2, PROCESS *p, MetaBall *mb)
 {
        VERTEX v;
        MB_POINT a, b;
@@ -1299,7 +1399,7 @@ int vertid (CORNER *c1, CORNER *c2, PROCESS *p, MetaBall *mb)
 
 /* converge: from two points of differing sign, converge to zero crossing */
 /* watch it: p1 and p2 are used to calculate */
-void converge (MB_POINT *p1, MB_POINT *p2, float v1, float v2,
+static void converge (MB_POINT *p1, MB_POINT *p2, float v1, float v2,
                           float (*function)(float, float, float), MB_POINT *p, MetaBall *mb, int f)
 {
        int i = 0;
@@ -1399,7 +1499,7 @@ void converge (MB_POINT *p1, MB_POINT *p2, float v1, float v2,
 }
 
 /* ************************************** */
-void add_cube(PROCESS *mbproc, int i, int j, int k, int count)
+static void add_cube(PROCESS *mbproc, int i, int j, int k, int count)
 {
        CUBES *ncube;
        int n;
@@ -1429,7 +1529,7 @@ void add_cube(PROCESS *mbproc, int i, int j, int k, int count)
 }
 
 
-void find_first_points(PROCESS *mbproc, MetaBall *mb, int a)
+static void find_first_points(PROCESS *mbproc, MetaBall *mb, int a)
 {
        MB_POINT IN, in, OUT, out; /*point;*/
        MetaElem *ml;
@@ -1549,7 +1649,7 @@ void find_first_points(PROCESS *mbproc, MetaBall *mb, int a)
        }
 }
 
-void polygonize(PROCESS *mbproc, MetaBall *mb)
+static void polygonize(PROCESS *mbproc, MetaBall *mb)
 {
        CUBE c;
        int a;
@@ -1589,7 +1689,7 @@ void polygonize(PROCESS *mbproc, MetaBall *mb)
        }
 }
 
-float init_meta(Scene *scene, Object *ob)      /* return totsize */
+static float init_meta(Scene *scene, Object *ob)       /* return totsize */
 {
        Scene *sce_iter= scene;
        Base *base;
@@ -1815,7 +1915,7 @@ float init_meta(Scene *scene, Object *ob) /* return totsize */
 /* if MetaElem lies in node, then node includes MetaElem pointer (ml_p)
  * pointing at MetaElem (ml)
  */
-void fill_metaball_octal_node(octal_node *node, MetaElem *ml, short i)
+static void fill_metaball_octal_node(octal_node *node, MetaElem *ml, short i)
 {
        ml_pointer *ml_p;
 
@@ -1847,7 +1947,7 @@ void fill_metaball_octal_node(octal_node *node, MetaElem *ml, short i)
  *  +------+------+
  *  
  */
-void subdivide_metaball_octal_node(octal_node *node, float size_x, float size_y, float size_z, short depth)
+static void subdivide_metaball_octal_node(octal_node *node, float size_x, float size_y, float size_z, short depth)
 {
        MetaElem *ml;
        ml_pointer *ml_p;
@@ -2104,7 +2204,7 @@ void subdivide_metaball_octal_node(octal_node *node, float size_x, float size_y,
 }
 
 /* free all octal nodes recursively */
-void free_metaball_octal_node(octal_node *node)
+static void free_metaball_octal_node(octal_node *node)
 {
        int a;
        for (a=0;a<8;a++) {
@@ -2115,7 +2215,7 @@ void free_metaball_octal_node(octal_node *node)
 }
 
 /* If scene include more then one MetaElem, then octree is used */
-void init_metaball_octal_tree(int depth)
+static void init_metaball_octal_tree(int depth)
 {
        struct octal_node *node;
        ml_pointer *ml_p;
@@ -2173,7 +2273,7 @@ void init_metaball_octal_tree(int depth)
        subdivide_metaball_octal_node(node, size[0], size[1], size[2], metaball_tree->depth);
 }
 
-void metaball_polygonize(Scene *scene, Object *ob, ListBase *dispbase)
+void BKE_metaball_polygonize(Scene *scene, Object *ob, ListBase *dispbase)
 {
        PROCESS mbproc;
        MetaBall *mb;
index 14ccd40..c7f6bf9 100644 (file)
@@ -1616,7 +1616,7 @@ void mesh_to_curve(Scene *scene, Object *ob)
        BLI_edgehash_free(eh, NULL);
 
        if (edges.first) {
-               Curve *cu = add_curve(ob->id.name+2, OB_CURVE);
+               Curve *cu = BKE_curve_add(ob->id.name+2, OB_CURVE);
                cu->flag |= CU_3D;
 
                while (edges.first) {
index a3baa88..d548d75 100644 (file)
@@ -450,7 +450,7 @@ static MovieClip *movieclip_alloc(const char *name)
  * otherwise creates new.
  * does not load ibuf itself
  * pass on optional frame for #name images */
-MovieClip *BKE_add_movieclip_file(const char *name)
+MovieClip *BKE_movieclip_file_add(const char *name)
 {
        MovieClip *clip;
        MovieClipUser user;
@@ -1149,14 +1149,14 @@ void BKE_movieclip_build_proxy_frame(MovieClip *clip, int clip_flag, struct Movi
        }
 }
 
-void free_movieclip(MovieClip *clip)
+void BKE_movieclip_free(MovieClip *clip)
 {
        free_buffers(clip);
 
        BKE_tracking_free(&clip->tracking);
 }
 
-void unlink_movieclip(Main *bmain, MovieClip *clip)
+void BKE_movieclip_unlink(Main *bmain, MovieClip *clip)
 {
        bScreen *scr;
        ScrArea *area;
index 6b44ba9..3ffd811 100644 (file)
@@ -319,8 +319,8 @@ void free_object(Object *ob)
                id->us--;
                if (id->us==0) {
                        if (ob->type==OB_MESH) unlink_mesh(ob->data);
-                       else if (ob->type==OB_CURVE) unlink_curve(ob->data);
-                       else if (ob->type==OB_MBALL) unlink_mball(ob->data);
+                       else if (ob->type==OB_CURVE) BKE_curve_unlink(ob->data);
+                       else if (ob->type==OB_MBALL) BKE_metaball_unlink(ob->data);
                }
                ob->data= NULL;
        }
@@ -459,7 +459,7 @@ void unlink_object(Object *ob)
                        }
                } 
                else if (ELEM(OB_MBALL, ob->type, obt->type)) {
-                       if (is_mball_basis_for (obt, ob))
+                       if (BKE_metaball_is_basis_for (obt, ob))
                                obt->recalc|= OB_RECALC_DATA;
                }
                
@@ -749,10 +749,10 @@ static void *add_obdata_from_type(int type)
 {
        switch (type) {
        case OB_MESH: return add_mesh("Mesh");
-       case OB_CURVE: return add_curve("Curve", OB_CURVE);
-       case OB_SURF: return add_curve("Surf", OB_SURF);
-       case OB_FONT: return add_curve("Text", OB_FONT);
-       case OB_MBALL: return add_mball("Meta");
+       case OB_CURVE: return BKE_curve_add("Curve", OB_CURVE);
+       case OB_SURF: return BKE_curve_add("Surf", OB_SURF);
+       case OB_FONT: return BKE_curve_add("Text", OB_FONT);
+       case OB_MBALL: return BKE_metaball_add("Meta");
        case OB_CAMERA: return add_camera("Camera");
        case OB_LAMP: return add_lamp("Lamp");
        case OB_LATTICE: return add_lattice("Lattice");
@@ -1822,7 +1822,7 @@ static void give_parvert(Object *par, int nr, float vec[3])
                ListBase *nurbs;
 
                cu= par->data;
-               nurbs= BKE_curve_nurbs(cu);
+               nurbs= BKE_curve_nurbs_get(cu);
                nu= nurbs->first;
 
                count= 0;
@@ -2268,7 +2268,7 @@ void minmax_object(Object *ob, float min[3], float max[3])
                {
                        Curve *cu= ob->data;
 
-                       if (cu->bb==NULL) tex_space_curve(cu);
+                       if (cu->bb==NULL) BKE_curve_tex_space_calc(cu);
                        bb= *(cu->bb);
 
                        for (a=0; a<8; a++) {
@@ -2930,7 +2930,7 @@ static KeyBlock *insert_curvekey(Scene *scene, Object *ob, const char *name, int
        Curve *cu= ob->data;
        Key *key= cu->key;
        KeyBlock *kb;
-       ListBase *lb= BKE_curve_nurbs(cu);
+       ListBase *lb= BKE_curve_nurbs_get(cu);
        int newkey= 0;
 
        if (key==NULL) {
@@ -2957,7 +2957,7 @@ static KeyBlock *insert_curvekey(Scene *scene, Object *ob, const char *name, int
 
                /* create new block with prepared data */
                kb = add_keyblock_ctime(key, name, FALSE);
-               kb->totelem= count_curveverts(lb);
+               kb->totelem= BKE_nurbList_verts_count(lb);
                kb->data= data;
        }
 
index d0eca73..5d8a495 100644 (file)
@@ -3559,7 +3559,7 @@ static void curve_surf_to_softbody(Scene *scene, Object *ob)
        int a, curindex=0;
        int totvert, totspring = 0, setgoal=0;
 
-       totvert= count_curveverts(&cu->nurb);
+       totvert= BKE_nurbList_verts_count(&cu->nurb);
 
        if (ob->softflag & OB_SB_EDGES) {
                if (ob->type==OB_CURVE) {
index fbed5cc..8aafdc6 100644 (file)
@@ -1427,7 +1427,7 @@ static bAnimChannelType ACF_DSCAM=
 static int acf_dscur_icon(bAnimListElem *ale)
 {
        Curve *cu= (Curve *)ale->data;
-       short obtype= curve_type(cu);
+       short obtype= BKE_curve_type_get(cu);
        
        switch (obtype) {
                case OB_FONT:
index d339af3..e65b428 100644 (file)
@@ -132,7 +132,7 @@ static void set_actNurb(Object *obedit, Nurb *nu)
        if (nu==NULL)
                cu->actnu = -1;
        else {
-               ListBase *nurbs= curve_editnurbs(cu);
+               ListBase *nurbs= BKE_curve_editNurbs_get(cu);
                cu->actnu = BLI_findindex(nurbs, nu);
        }
 }
@@ -140,7 +140,7 @@ static void set_actNurb(Object *obedit, Nurb *nu)
 static Nurb *get_actNurb(Object *obedit)
 {
        Curve *cu= obedit->data;
-       ListBase *nurbs= curve_editnurbs(cu);
+       ListBase *nurbs= BKE_curve_editNurbs_get(cu);
 
        return BLI_findlink(nurbs, cu->actnu);
 }
@@ -736,7 +736,7 @@ static void calc_keyHandles(ListBase *nurb, float *key)
                                if (nextp) key_to_bezt(nextfp, nextp, &next);
                                if (prevp) key_to_bezt(prevfp, prevp, &prev);
 
-                               calchandleNurb(&cur, prevp ? &prev : NULL, nextp ? &next : NULL, 0);
+                               BKE_nurb_handle_calc(&cur, prevp ? &prev : NULL, nextp ? &next : NULL, 0);
                                bezt_to_key(&cur, fp);
 
                                prevp= bezt;
@@ -782,7 +782,7 @@ static void calc_shapeKeys(Object *obedit)
                BezTriple *bezt, *oldbezt;
                BPoint *bp, *oldbp;
                Nurb *nu;
-               int totvert= count_curveverts(&editnurb->nurbs);
+               int totvert= BKE_nurbList_verts_count(&editnurb->nurbs);
 
                float (*ofs)[3] = NULL;
                float *oldkey, *newkey, *ofp;
@@ -1207,11 +1207,11 @@ void load_editNurb(Object *obedit)
                ListBase newnurb= {NULL, NULL}, oldnurb= cu->nurb;
 
                for (nu= editnurb->first; nu; nu= nu->next) {
-                       newnu= duplicateNurb(nu);
+                       newnu= BKE_nurb_duplicate(nu);
                        BLI_addtail(&newnurb, newnu);
 
                        if (nu->type == CU_NURBS) {
-                               clamp_nurb_order_u(nu);
+                               BKE_nurb_order_clamp_u(nu);
                        }
                }
 
@@ -1220,7 +1220,7 @@ void load_editNurb(Object *obedit)
                calc_shapeKeys(obedit);
                ED_curve_updateAnimPaths(obedit->data);
 
-               freeNurblist(&oldnurb);
+               BKE_nurbList_free(&oldnurb);
        }
 
        set_actNurb(obedit, NULL);
@@ -1247,8 +1247,8 @@ void make_editNurb(Object *obedit)
                }
 
                if (editnurb) {
-                       freeNurblist(&editnurb->nurbs);
-                       free_curve_editNurb_keyIndex(editnurb);
+                       BKE_nurbList_free(&editnurb->nurbs);
+                       BKE_curve_editNurb_keyIndex_free(editnurb);
                        editnurb->keyindex= NULL;
                }
                else {
@@ -1260,8 +1260,8 @@ void make_editNurb(Object *obedit)
                cu->lastsel= NULL;   /* for select row */
 
                while (nu) {
-                       newnu= duplicateNurb(nu);
-                       test2DNurb(newnu);      // after join, or any other creation of curve
+                       newnu= BKE_nurb_duplicate(nu);
+                       BKE_nurb_test2D(newnu); // after join, or any other creation of curve
                        BLI_addtail(&editnurb->nurbs, newnu);
 
                        if (nu_act == NULL && isNurbsel(nu)) {
@@ -1285,7 +1285,7 @@ void free_editNurb(Object *obedit)
 {
        Curve *cu= obedit->data;
 
-       free_curve_editNurb(cu);
+       BKE_curve_editNurb_free(cu);
 }
 
 void CU_deselect_all(Object *obedit)
@@ -1377,15 +1377,15 @@ static int separate_exec(bContext *C, wmOperator *op)
        ED_base_object_select(newbase, BA_DESELECT);
        newob= newbase->object;
 
-       newcu= newob->data= copy_curve(oldcu);
+       newcu= newob->data= BKE_curve_copy(oldcu);
        newcu->editnurb= NULL;
        oldcu->id.us--; /* because new curve is a copy: reduce user count */
 
        /* 2. put new object in editmode and clear it */
        make_editNurb(newob);
        newedit= newcu->editnurb;
-       freeNurblist(&newedit->nurbs);
-       free_curve_editNurb_keyIndex(newedit);
+       BKE_nurbList_free(&newedit->nurbs);
+       BKE_curve_editNurb_keyIndex_free(newedit);
 
        /* 3. move over parts from old object */
        for (nu= oldedit->nurbs.first; nu; nu=nu1) {
@@ -1547,7 +1547,7 @@ static void translateflagNurb(ListBase *editnurb, short flag, const float vec[3]
                        }
                }
 
-               test2DNurb(nu);
+               BKE_nurb_test2D(nu);
        }
 }
 
@@ -1602,7 +1602,7 @@ static int deleteflagNurb(bContext *C, wmOperator *UNUSED(op), int flag)
                if (a==0) {
                        BLI_remlink(editnurb, nu);
                        keyIndex_delNurb(cu->editnurb, nu);
-                       freeNurb(nu); nu=NULL;
+                       BKE_nurb_free(nu); nu=NULL;
                }
                else {
                        /* is nurb in U direction selected */
@@ -1640,9 +1640,9 @@ static int deleteflagNurb(bContext *C, wmOperator *UNUSED(op), int flag)
                                nu->pntsv= newv;
                                MEM_freeN(nu->bp);
                                nu->bp= newbp;
-                               clamp_nurb_order_v(nu);
+                               BKE_nurb_order_clamp_v(nu);
 
-                               nurbs_knot_calc_v(nu);
+                               BKE_nurb_knot_calc_v(nu);
                        }
                        else {
                                /* is the nurb in V direction selected */
@@ -1684,15 +1684,15 @@ static int deleteflagNurb(bContext *C, wmOperator *UNUSED(op), int flag)
                                                nu->pntsu= nu->pntsv;
                                                nu->pntsv= 1;
                                                SWAP(short, nu->orderu, nu->orderv);
-                                               clamp_nurb_order_u(nu);
+                                               BKE_nurb_order_clamp_u(nu);
                                                if (nu->knotsv) MEM_freeN(nu->knotsv);
                                                nu->knotsv= NULL;
                                        }
                                        else {
                                                nu->pntsu= newu;
-                                               clamp_nurb_order_u(nu);
+                                               BKE_nurb_order_clamp_u(nu);
                                        }
-                                       nurbs_knot_calc_u(nu);
+                                       BKE_nurb_knot_calc_u(nu);
                                }
                        }
                }
@@ -1743,7 +1743,7 @@ static short extrudeflagNurb(EditNurb *editnurb, int flag)
 
                                nu->pntsv= 2;
                                nu->orderv= 2;
-                               nurbs_knot_calc_v(nu);
+                               BKE_nurb_knot_calc_v(nu);
                        }
                }
                else {
@@ -1786,7 +1786,7 @@ static short extrudeflagNurb(EditNurb *editnurb, int flag)
                                        MEM_freeN(nu->bp);
                                        nu->bp= newbp;
                                        nu->pntsv++;
-                                       nurbs_knot_calc_v(nu);
+                                       BKE_nurb_knot_calc_v(nu);
                                }
                                else if (v==0 || v== nu->pntsu-1) {         /* column in v-direction selected */
                                        ok= 1;
@@ -1813,7 +1813,7 @@ static short extrudeflagNurb(EditNurb *editnurb, int flag)
                                        MEM_freeN(nu->bp);
                                        nu->bp= newbp;
                                        nu->pntsu++;
-                                       nurbs_knot_calc_u(nu);
+                                       BKE_nurb_knot_calc_u(nu);
                                }
                        }
                }
@@ -1911,7 +1911,7 @@ static void adduplicateflagNurb(Object *obedit, short flag)
 
                                        /* knots */
                                        newnu->knotsu= NULL;
-                                       nurbs_knot_calc_u(newnu);
+                                       BKE_nurb_knot_calc_u(newnu);
                                }
                                bp++;
                        }
@@ -1956,8 +1956,8 @@ static void adduplicateflagNurb(Object *obedit, short flag)
                                        newnu->pntsv= newv;
                                        newnu->bp =
                                                (BPoint*)MEM_mallocN(newu * newv * sizeof(BPoint), "adduplicateN6");
-                                       clamp_nurb_order_u(newnu);
-                                       clamp_nurb_order_v(newnu);
+                                       BKE_nurb_order_clamp_u(newnu);
+                                       BKE_nurb_order_clamp_v(newnu);
                                        
                                        newnu->knotsu= newnu->knotsv= NULL;
                                        
@@ -1972,20 +1972,20 @@ static void adduplicateflagNurb(Object *obedit, short flag)
                                                        }
                                                }
                                        }
-                                       if (check_valid_nurb_u(newnu)) {
+                                       if (BKE_nurb_check_valid_u(newnu)) {
                                                if (nu->pntsu==newnu->pntsu && nu->knotsu) {
                                                        newnu->knotsu= MEM_dupallocN( nu->knotsu );
                                                }
                                                else {
-                                                       nurbs_knot_calc_u(newnu);
+                                                       BKE_nurb_knot_calc_u(newnu);
                                                }
                                        }
-                                       if (check_valid_nurb_v(newnu)) {
+                                       if (BKE_nurb_check_valid_v(newnu)) {
                                                if (nu->pntsv==newnu->pntsv && nu->knotsv) {
                                                        newnu->knotsv= MEM_dupallocN( nu->knotsv );
                                                }
                                                else {
-                                                       nurbs_knot_calc_v(newnu);
+                                                       BKE_nurb_knot_calc_v(newnu);
                                                }
                                        }
                                }
@@ -2010,7 +2010,7 @@ static int switch_direction_exec(bContext *C, wmOperator *UNUSED(op))
 
        for (nu= editnurb->nurbs.first; nu; nu= nu->next)
                if (isNurbsel(nu)) {
-                       switchdirectionNurb(nu);
+                       BKE_nurb_direction_switch(nu);
                        keyData_switchDirectionNurb(cu, nu);
                }
 
@@ -2174,7 +2174,7 @@ static int smooth_exec(bContext *C, wmOperator *UNUSED(op))
                        }
                        MEM_freeN(beztOrig);
                        if (change)
-                               calchandlesNurb(nu);
+                               BKE_nurb_handles_calc(nu);
                }
                else if (nu->bp) {
                        bpOrig = MEM_dupallocN( nu->bp );
@@ -2893,7 +2893,7 @@ static void subdividenurb(Object *obedit, int number_cuts)
                                nu->bezt= beztnew;
                                nu->pntsu+= amount;
 
-                               calchandlesNurb(nu);
+                               BKE_nurb_handles_calc(nu);
                        }
                } /* End of 'if (nu->type == CU_BEZIER)' */
                else if (nu->pntsv==1) {
@@ -2965,7 +2965,7 @@ static void subdividenurb(Object *obedit, int number_cuts)
                                nu->pntsu+= amount;
 
                                if (nu->type & CU_NURBS) {
-                                       nurbs_knot_calc_u(nu);
+                                       BKE_nurb_knot_calc_u(nu);
                                }
                        }
                } /* End of 'else if (nu->pntsv==1)' */
@@ -3086,8 +3086,8 @@ static void subdividenurb(Object *obedit, int number_cuts)
                                nu->bp= bpnew;
                                nu->pntsu= (number_cuts+1)*nu->pntsu-number_cuts;
                                nu->pntsv= (number_cuts+1)*nu->pntsv-number_cuts;
-                               nurbs_knot_calc_u(nu);
-                               nurbs_knot_calc_v(nu);
+                               BKE_nurb_knot_calc_u(nu);
+                               BKE_nurb_knot_calc_v(nu);
                        } /* End of 'if (sel== nu->pntsu*nu->pntsv)' (subdivide entire NURB) */
                        else {
                                /* subdivide in v direction? */
@@ -3132,7 +3132,7 @@ static void subdividenurb(Object *obedit, int number_cuts)
                                        MEM_freeN(nu->bp);
                                        nu->bp= bpnew;
                                        nu->pntsv+= sel;
-                                       nurbs_knot_calc_v(nu);
+                                       BKE_nurb_knot_calc_v(nu);
                                }
                                else {
                                        /* or in u direction? */
@@ -3173,7 +3173,7 @@ static void subdividenurb(Object *obedit, int number_cuts)
                                                MEM_freeN(nu->bp);
                                                nu->bp= bpnew;
                                                nu->pntsu+= sel;
-                                               nurbs_knot_calc_u(nu); /* shift knots forward */
+                                               BKE_nurb_knot_calc_u(nu); /* shift knots forward */
                                        }
                                }
                        }
@@ -3373,13 +3373,13 @@ static int convertspline(short type, Nurb *nu)
                        nu->bp= NULL;
                        nu->pntsu= nr;
                        nu->type = CU_BEZIER;
-                       calchandlesNurb(nu);
+                       BKE_nurb_handles_calc(nu);
                }
                else if (type==CU_NURBS) {
                        nu->type = CU_NURBS;
                        nu->orderu= 4;
                        nu->flagu &= CU_NURB_CYCLIC; /* disable all flags except for cyclic */
-                       nurbs_knot_calc_u(nu);
+                       BKE_nurb_knot_calc_u(nu);
                        a= nu->pntsu*nu->pntsv;
                        bp= nu->bp;
                        while (a--) {
@@ -3436,7 +3436,7 @@ static int convertspline(short type, Nurb *nu)
                        if (type== CU_NURBS) {
                                nu->flagu &= CU_NURB_CYCLIC; /* disable all flags except for cyclic */
                                nu->flagu |= CU_NURB_BEZIER;
-                               nurbs_knot_calc_u(nu);
+                               BKE_nurb_knot_calc_u(nu);
                        }
                }
        }
@@ -3559,7 +3559,7 @@ static int set_handle_type_exec(bContext *C, wmOperator *op)
        Object *obedit= CTX_data_edit_object(C);
        ListBase *editnurb= object_editcurve_get(obedit);
 
-       sethandlesNurb(editnurb, RNA_enum_get(op->ptr, "type"));
+       BKE_nurbList_handles_set(editnurb, RNA_enum_get(op->ptr, "type"));
 
        WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
        DAG_id_tag_update(obedit->data, 0);
@@ -3865,15 +3865,15 @@ static void merge_2_nurb(wmOperator *op, ListBase *editnurb, Nurb *nu1, Nurb *nu
 
        if (nu1->type == CU_NURBS) {
                /* merge knots */
-               nurbs_knot_calc_u(nu1);
+               BKE_nurb_knot_calc_u(nu1);
        
                /* make knots, for merged curved for example */
-               nurbs_knot_calc_v(nu1);
+               BKE_nurb_knot_calc_v(nu1);
        }
        
        MEM_freeN(temp);
        BLI_remlink(editnurb, nu2);
-       freeNurb(nu2);
+       BKE_nurb_free(nu2);
 }
 
 static int merge_nurb(bContext *C, wmOperator *op)
@@ -3976,7 +3976,7 @@ static int make_segment_exec(bContext *C, wmOperator *op)
                                        else {
                                                if ( BEZSELECTED_HIDDENHANDLES(cu, &(nu->bezt[nu->pntsu-1])) ) {
                                                        nu1= nu;
-                                                       switchdirectionNurb(nu);
+                                                       BKE_nurb_direction_switch(nu);
                                                        keyData_switchDirectionNurb(cu, nu);
                                                }
                                        }
@@ -3984,7 +3984,7 @@ static int make_segment_exec(bContext *C, wmOperator *op)
                                else if (nu2==NULL) {
                                        if ( BEZSELECTED_HIDDENHANDLES(cu, nu->bezt) ) {
                                                nu2= nu;
-                                               switchdirectionNurb(nu);
+                                               BKE_nurb_direction_switch(nu);
                                                keyData_switchDirectionNurb(cu, nu);
                                        }
                                        else {
@@ -4003,7 +4003,7 @@ static int make_segment_exec(bContext *C, wmOperator *op)
                                                bp= bp+(nu->pntsu-1);
                                                if ( bp->f1 & SELECT ) {
                                                        nu1= nu;
-                                                       switchdirectionNurb(nu);
+                                                       BKE_nurb_direction_switch(nu);
                                                        keyData_switchDirectionNurb(cu, nu);
                                                }
                                        }
@@ -4011,7 +4011,7 @@ static int make_segment_exec(bContext *C, wmOperator *op)
                                else if (nu2==NULL) {
                                        if ( bp->f1 & SELECT ) {
                                                nu2= nu;
-                                               switchdirectionNurb(nu);
+                                               BKE_nurb_direction_switch(nu);
                                                keyData_switchDirectionNurb(cu, nu);
                                        }
                                        else {
@@ -4038,8 +4038,8 @@ static int make_segment_exec(bContext *C, wmOperator *op)
                                nu1->bezt= bezt;
                                nu1->pntsu+= nu2->pntsu;
                                BLI_remlink(nubase, nu2);
-                               freeNurb(nu2); nu2= NULL;
-                               calchandlesNurb(nu1);
+                               BKE_nurb_free(nu2); nu2= NULL;
+                               BKE_nurb_handles_calc(nu1);
                        }
                        else {
                                bp =
@@ -4057,7 +4057,7 @@ static int make_segment_exec(bContext *C, wmOperator *op)
                                /* now join the knots */
                                if (nu1->type == CU_NURBS) {
                                        if (nu1->knotsu==NULL) {
-                                               nurbs_knot_calc_u(nu1);
+                                               BKE_nurb_knot_calc_u(nu1);
                                        }
                                        else {
                                                fp= MEM_mallocN(sizeof(float)*KNOTSU(nu1), "addsegment3");
@@ -4076,7 +4076,7 @@ static int make_segment_exec(bContext *C, wmOperator *op)
                                                }
                                        }
                                }
-                               freeNurb(nu2); nu2= NULL;
+                               BKE_nurb_free(nu2); nu2= NULL;
                        }
 
                        set_actNurb(obedit, nu1);       /* for selected */
@@ -4088,12 +4088,12 @@ static int make_segment_exec(bContext *C, wmOperator *op)
                        if (nu1->type == CU_BEZIER && BEZSELECTED_HIDDENHANDLES(cu, nu1->bezt) &&
                                BEZSELECTED_HIDDENHANDLES(cu, nu1->bezt+(nu1->pntsu-1))) {
                                nu1->flagu|= CU_NURB_CYCLIC;
-                               calchandlesNurb(nu1);
+                               BKE_nurb_handles_calc(nu1);
                                ok= 1;
                        }
                        else if (nu1->type == CU_NURBS && nu1->bp->f1&SELECT && (nu1->bp+(nu1->pntsu-1))->f1&SELECT) {
                                nu1->flagu|= CU_NURB_CYCLIC;
-                               nurbs_knot_calc_u(nu1);
+                               BKE_nurb_knot_calc_u(nu1);
                                ok= 1;
                        }
                }
@@ -4293,7 +4293,7 @@ static int spin_nurb(float viewmat[][4], Object *obedit, float *axis, float *cen
                        if (isNurbsel(nu)) {
                                nu->orderv= 4;
                                nu->flagv |= CU_NURB_CYCLIC;
-                               nurbs_knot_calc_v(nu);
+                               BKE_nurb_knot_calc_v(nu);
                        }
                }
        }
@@ -4446,7 +4446,7 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
                                newbp->vec[3]= 1.0;
 
                                newnu->knotsu= newnu->knotsv= NULL;
-                               nurbs_knot_calc_u(newnu);
+                               BKE_nurb_knot_calc_u(newnu);
 
                                ok= 1;
                                nu= newnu;
@@ -4538,7 +4538,7 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
                                if (bezt_recalc[1]) {
                                        const char h1 = bezt_recalc[1]->h1, h2 = bezt_recalc[1]->h2;
                                        bezt_recalc[1]->h1 = bezt_recalc[1]->h2 = HD_AUTO;
-                                       calchandleNurb(bezt_recalc[1], bezt_recalc[0], bezt_recalc[2], 0);
+                                       BKE_nurb_handle_calc(bezt_recalc[1], bezt_recalc[0], bezt_recalc[2], 0);
                                        bezt_recalc[1]->h1 = h1;
                                        bezt_recalc[1]->h2 = h2;
                                }
@@ -4548,8 +4548,8 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
                                }
                                
 
-                               if (newnu) calchandlesNurb(newnu);
-                               else calchandlesNurb(nu);
+                               if (newnu) BKE_nurb_handles_calc(newnu);
+                               else BKE_nurb_handles_calc(nu);
                        }
                }
        }
@@ -4617,14 +4617,14 @@ static int addvert_Nurb(bContext *C, short mode, float location[3])
 
                        if (!newnu) {
                                nu->pntsu++;
-                               nurbs_knot_calc_u(nu);
+                               BKE_nurb_knot_calc_u(nu);
                        }
-                       else nurbs_knot_calc_u(newnu);
+                       else BKE_nurb_knot_calc_u(newnu);
                }
        }
 
        if (ok) {
-               test2DNurb(nu);
+               BKE_nurb_test2D(nu);
 
                if (ED_curve_updateAnimPaths(obedit->data))
                        WM_event_add_notifier(C, NC_OBJECT|ND_KEYS, obedit);
@@ -4783,7 +4783,7 @@ static int toggle_cyclic_exec(bContext *C, wmOperator *op)
                                        }
                                        bezt++;
                                }
-                               calchandlesNurb(nu);
+                               BKE_nurb_handles_calc(nu);
                        }
                        else if (nu->pntsv==1 && nu->type == CU_NURBS) {
                                if (nu->knotsu) { /* if check_valid_nurb_u fails the knotsu can be NULL */
@@ -4792,7 +4792,7 @@ static int toggle_cyclic_exec(bContext *C, wmOperator *op)
                                        while (a--) {
                                                if ( bp->f1 & SELECT ) {
                                                        nu->flagu ^= CU_NURB_CYCLIC;
-                                                       nurbs_knot_calc_u(nu);  /* 1==u  type is ignored for cyclic curves */
+                                                       BKE_nurb_knot_calc_u(nu);       /* 1==u  type is ignored for cyclic curves */
                                                        break;
                                                }
                                                bp++;
@@ -4807,11 +4807,11 @@ static int toggle_cyclic_exec(bContext *C, wmOperator *op)
                                        if ( bp->f1 & SELECT) {
                                                if (direction==0 && nu->pntsu>1) {
                                                        nu->flagu ^= CU_NURB_CYCLIC;
-                                                       nurbs_knot_calc_u(nu);   /* 1==u  type is ignored for cyclic curves */
+                                                       BKE_nurb_knot_calc_u(nu);   /* 1==u  type is ignored for cyclic curves */
                                                }
                                                if (direction==1 && nu->pntsv>1) {
                                                        nu->flagv ^= CU_NURB_CYCLIC;
-                                                       nurbs_knot_calc_v(nu);   /* 2==v  type is ignored for cyclic curves */
+                                                       BKE_nurb_knot_calc_v(nu);   /* 2==v  type is ignored for cyclic curves */
                                                }
                                                break;
                                        }
@@ -5472,7 +5472,7 @@ static int point_on_nurb(Nurb *nu, void *point)
 
 static Nurb *get_lastsel_nurb(Curve *cu)
 {
-       ListBase *nubase= curve_editnurbs(cu);
+       ListBase *nubase= BKE_curve_editNurbs_get(cu);
        Nurb *nu= nubase->first;
 
        if (!cu->lastsel)
@@ -5638,7 +5638,7 @@ static int delete_exec(bContext *C, wmOperator *op)
                }
                else {
                        keyIndex_delNurbList(editnurb, nubase);
-                       freeNurblist(nubase);
+                       BKE_nurbList_free(nubase);
 
                        if (ED_curve_updateAnimPaths(obedit->data))
                                WM_event_add_notifier(C, NC_OBJECT|ND_KEYS, obedit);
@@ -5672,7 +5672,7 @@ static int delete_exec(bContext *C, wmOperator *op)
 
                                                BLI_remlink(nubase, nu);
                                                keyIndex_delNurb(editnurb, nu);
-                                               freeNurb(nu); nu= NULL;
+                                               BKE_nurb_free(nu); nu= NULL;
                                        }
                                }
                        }
@@ -5692,7 +5692,7 @@ static int delete_exec(bContext *C, wmOperator *op)
 
                                                BLI_remlink(nubase, nu);
                                                keyIndex_delNurb(editnurb, nu);
-                                               freeNurb(nu); nu= NULL;
+                                               BKE_nurb_free(nu); nu= NULL;
                                        }
                                }
                        }
@@ -5734,7 +5734,7 @@ static int delete_exec(bContext *C, wmOperator *op)
                                        keyIndex_updateBezt(editnurb, nu->bezt, bezt1, nu->pntsu);
                                        MEM_freeN(nu->bezt);
                                        nu->bezt= bezt1;
-                                       calchandlesNurb(nu);
+                                       BKE_nurb_handles_calc(nu);
                                }
                        }
                        else if (nu->pntsv==1) {
@@ -5770,8 +5770,8 @@ static int delete_exec(bContext *C, wmOperator *op)
                                        }
 #endif
                                }
-                               clamp_nurb_order_u(nu);
-                               nurbs_knot_calc_u(nu);
+                               BKE_nurb_order_clamp_u(nu);
+                               BKE_nurb_knot_calc_u(nu);
                        }
                        nu= next;
                }
@@ -5797,7 +5797,7 @@ static int delete_exec(bContext *C, wmOperator *op)
                                                                bezt2= bezt+(nu->pntsu-1);
                                                                if ( (bezt2->f1 & SELECT) || (bezt2->f2 & SELECT) || (bezt2->f3 & SELECT) ) {
                                                                        nu->flagu &= ~CU_NURB_CYCLIC;
-                                                                       calchandlesNurb(nu);
+                                                                       BKE_nurb_handles_calc(nu);
                                                                        WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
                                                                        DAG_id_tag_update(obedit->data, 0);
                                                                }
@@ -5850,7 +5850,7 @@ static int delete_exec(bContext *C, wmOperator *op)
                                                cu->actnu= -1;
 
                                        BLI_remlink(nubase, nu);
-                                       freeNurb(nu); nu = NULL;
+                                       BKE_nurb_free(nu); nu = NULL;
                                }
                                else if (nu1->flagu & CU_NURB_CYCLIC) { /* cyclic */
                                        bezt =
@@ -5862,7 +5862,7 @@ static int delete_exec(bContext *C, wmOperator *op)
 
                                        nu1->flagu &= ~CU_NURB_CYCLIC;
                                        MEM_freeN(bezt);
-                                       calchandlesNurb(nu);
+                                       BKE_nurb_handles_calc(nu);
                                }
                                else {                  /* add new curve */
 
@@ -5886,8 +5886,8 @@ static int delete_exec(bContext *C, wmOperator *op)
                                        nu->pntsu= cut+1;
                                        
                                        
-                                       calchandlesNurb(nu);
-                                       calchandlesNurb(nu1);
+                                       BKE_nurb_handles_calc(nu);
+                                       BKE_nurb_handles_calc(nu1);
                                }
                        }
                        else if (bp1) {
@@ -5896,7 +5896,7 @@ static int delete_exec(bContext *C, wmOperator *op)
                                                cu->actnu= -1;
 
                                        BLI_remlink(nubase, nu);
-                                       freeNurb(nu); nu= NULL;
+                                       BKE_nurb_free(nu); nu= NULL;
                                }
                                else if (nu1->flagu & CU_NURB_CYCLIC) { /* cyclic */
                                        bp =
@@ -5926,11 +5926,11 @@ static int delete_exec(bContext *C, wmOperator *op)
                                        nu1->knotsu= NULL;
                                        nu->pntsu= cut+1;
 
-                                       clamp_nurb_order_u(nu);
-                                       nurbs_knot_calc_u(nu);
+                                       BKE_nurb_order_clamp_u(nu);
+                                       BKE_nurb_knot_calc_u(nu);
 
-                                       clamp_nurb_order_u(nu1);
-                                       nurbs_knot_calc_u(nu1);
+                                       BKE_nurb_order_clamp_u(nu1);
+                                       BKE_nurb_knot_calc_u(nu1);
                                }
                        }
                }
@@ -5938,7 +5938,7 @@ static int delete_exec(bContext *C, wmOperator *op)
        else if (type==2) {
                cu->actnu= -1;
                keyIndex_delNurbList(editnurb, nubase);
-               freeNurblist(nubase);
+               BKE_nurbList_free(nubase);
        }
 
        if (ED_curve_updateAnimPaths(obedit->data))
@@ -6083,7 +6083,7 @@ int join_curve_exec(bContext *C, wmOperator *UNUSED(op))
                                        
                                        nu= cu->nurb.first;
                                        while (nu) {
-                                               newnu= duplicateNurb(nu);
+                                               newnu= BKE_nurb_duplicate(nu);
                                                if (ob->totcol) { /* TODO, merge material lists */
                                                        CLAMP(newnu->mat_nr, 0, ob->totcol-1);
                                                }
@@ -6098,7 +6098,7 @@ int join_curve_exec(bContext *C, wmOperator *UNUSED(op))
                                                                mul_m4_v3(cmat, bezt->vec[2]);
                                                                bezt++;
                                                        }
-                                                       calchandlesNurb(newnu);
+                                                       BKE_nurb_handles_calc(newnu);
                                                }
                                                if ( (bp= newnu->bp) ) {
                                                        a= newnu->pntsu*nu->pntsv;
@@ -6240,7 +6240,7 @@ Nurb *add_nurbs_primitive(bContext *C, float mat[4][4], int type, int newob)
                        bezt->vec[2][1] = 0;
                        for (a=0;a<3;a++) mul_m4_v3(mat, bezt->vec[a]);
 
-                       calchandlesNurb(nu);
+                       BKE_nurb_handles_calc(nu);
                }
                else {
                        
@@ -6272,7 +6272,7 @@ Nurb *add_nurbs_primitive(bContext *C, float mat[4][4], int type, int newob)
 
                        if (cutype==CU_NURBS) {
                                nu->knotsu= NULL;       /* nurbs_knot_calc_u allocates */
-                               nurbs_knot_calc_u(nu);
+                               BKE_nurb_knot_calc_u(nu);
                        }
 
                }
@@ -6306,7 +6306,7 @@ Nurb *add_nurbs_primitive(bContext *C, float mat[4][4], int type, int newob)
 
                if (cutype==CU_NURBS) {
                        nu->knotsu= NULL;       /* nurbs_knot_calc_u allocates */
-                       nurbs_knot_calc_u(nu);
+                       BKE_nurb_knot_calc_u(nu);
                }
 
                break;
@@ -6347,7 +6347,7 @@ Nurb *add_nurbs_primitive(bContext *C, float mat[4][4], int type, int newob)
                        for (a=0;a<3;a++) mul_m4_v3(mat,bezt->vec[a]);
                        bezt->radius = bezt->weight = 1.0;
 
-                       calchandlesNurb(nu);
+                       BKE_nurb_handles_calc(nu);
                }
                else if ( cutype==CU_NURBS ) {  /* nurb */
                        nu->pntsu= 8;
@@ -6375,7 +6375,7 @@ Nurb *add_nurbs_primitive(bContext *C, float mat[4][4], int type, int newob)
                                bp++;
                        }
 
-                       nurbs_knot_calc_u(nu);
+                       BKE_nurb_knot_calc_u(nu);
                }
                break;
        case CU_PRIM_PATCH:     /* 4x4 patch */
@@ -6407,8 +6407,8 @@ Nurb *add_nurbs_primitive(bContext *C, float mat[4][4], int type, int newob)
                                }
                        }
 
-                       nurbs_knot_calc_u(nu);
-                       nurbs_knot_calc_v(nu);
+                       BKE_nurb_knot_calc_u(nu);
+                       BKE_nurb_knot_calc_v(nu);
                }
                break;
        case CU_PRIM_TUBE:      /* Cylinder */
@@ -6469,7 +6469,7 @@ Nurb *add_nurbs_primitive(bContext *C, float mat[4][4], int type, int newob)
                                bp++;
                        }
                        nu->flagu= CU_NURB_BEZIER;
-                       nurbs_knot_calc_u(nu);
+                       BKE_nurb_knot_calc_u(nu);
 
                        BLI_addtail(editnurb, nu); /* temporal for spin */
 
@@ -6477,7 +6477,7 @@ Nurb *add_nurbs_primitive(bContext *C, float mat[4][4], int type, int newob)
                        else if ((U.flag & USER_ADD_VIEWALIGNED))                       spin_nurb(viewmat, obedit, zvec, mat[3]);
                        else                                                                                            spin_nurb(umat, obedit, tmp_vec, mat[3]);
 
-                       nurbs_knot_calc_v(nu);
+                       BKE_nurb_knot_calc_v(nu);
 
                        a= nu->pntsu*nu->pntsv;
                        bp= nu->bp;
@@ -6529,7 +6529,7 @@ Nurb *add_nurbs_primitive(bContext *C, float mat[4][4], int type, int newob)
        if (nu) { /* should always be set */
                nu->flag |= CU_SMOOTH;
 
-               test2DNurb(nu);
+               BKE_nurb_test2D(nu);
        }
 
        return nu;
@@ -6947,13 +6947,13 @@ static void undoCurve_to_editCurve(void *ucu, void *UNUSED(edata), void *cu_v)
        Curve *cu= cu_v;
        UndoCurve *undoCurve= ucu;
        ListBase *undobase= &undoCurve->nubase;
-       ListBase *editbase= curve_editnurbs(cu);
+       ListBase *editbase= BKE_curve_editNurbs_get(cu);
        Nurb *nu, *newnu;
        EditNurb *editnurb= cu->editnurb;
        void *lastsel= NULL;
        AnimData *ad= BKE_animdata_from_id(&cu->id);
 
-       freeNurblist(editbase);
+       BKE_nurbList_free(editbase);
 
        if (undoCurve->undoIndex) {
                BLI_ghash_free(editnurb->keyindex, NULL, (GHashValFreeFP)MEM_freeN);
@@ -6972,7 +6972,7 @@ static void undoCurve_to_editCurve(void *ucu, void *UNUSED(edata), void *cu_v)
 
        /* copy  */
        for (nu= undobase->first; nu; nu= nu->next) {
-               newnu= duplicateNurb(nu);
+               newnu= BKE_nurb_duplicate(nu);
 
                if (lastsel == NULL) {
                        lastsel= undo_check_lastsel(undoCurve->lastsel, nu, newnu);
@@ -6993,7 +6993,7 @@ static void undoCurve_to_editCurve(void *ucu, void *UNUSED(edata), void *cu_v)
 static void *editCurve_to_undoCurve(void *UNUSED(edata), void *cu_v)
 {
        Curve *cu= cu_v;
-       ListBase *nubase= curve_editnurbs(cu);
+       ListBase *nubase= BKE_curve_editNurbs_get(cu);
        UndoCurve *undoCurve;
        EditNurb *editnurb= cu->editnurb, tmpEditnurb;
        Nurb *nu, *newnu;
@@ -7016,7 +7016,7 @@ static void *editCurve_to_undoCurve(void *UNUSED(edata), void *cu_v)
 
        /* copy  */
        for (nu= nubase->first; nu; nu= nu->next) {
-               newnu= duplicateNurb(nu);
+               newnu= BKE_nurb_duplicate(nu);
 
                if (lastsel == NULL) {
                        lastsel= undo_check_lastsel(cu->lastsel, nu, newnu);
@@ -7039,7 +7039,7 @@ static void free_undoCurve(void *ucv)
 {
        UndoCurve *undoCurve= ucv;
 
-       freeNurblist(&undoCurve->nubase);
+       BKE_nurbList_free(&undoCurve->nubase);
 
        if (undoCurve->undoIndex)
                BLI_ghash_free(undoCurve->undoIndex, NULL, (GHashValFreeFP)MEM_freeN);
index 29bebfa..cca5dd7 100644 (file)
@@ -1500,7 +1500,7 @@ void load_editText(Object *obedit)
 
 void free_editText(Object *obedit)
 {
-       BKE_free_editfont((Curve *)obedit->data);
+       BKE_curve_editfont_free((Curve *)obedit->data);
 }
 
 /********************** set case operator *********************/
index d48cfaa..5f31a27 100644 (file)
@@ -534,7 +534,7 @@ static void gp_stroke_to_bezier (bContext *C, bGPDlayer *gpl, bGPDstroke *gps, C
        }
 
        /* must calculate handles or else we crash */
-       calchandlesNurb(nu);
+       BKE_nurb_handles_calc(nu);
 
        /* add nurb to curve */
        BLI_addtail(&cu->nurb, nu);
index 50e43c4..73ff8e9 100644 (file)
@@ -63,7 +63,7 @@ void  load_editNurb   (struct Object *obedit);
 void   make_editNurb   (struct Object *obedit);
 void   free_editNurb   (struct Object *obedit);
 
-void   free_curve_editNurb     (struct Curve *cu);
+void   BKE_curve_editNurb_free (struct Curve *cu);
 
 int    mouse_nurb              (struct bContext *C, const int mval[2], int extend);
 
index 4666232..fe7a4e8 100644 (file)
@@ -2231,8 +2231,8 @@ int ui_link_bezier_points(rcti *rect, float coord_array[][2], int resol)
        vec[2][0] = vec[3][0] - dist;
        vec[2][1] = vec[3][1];
        
-       forward_diff_bezier(vec[0][0], vec[1][0], vec[2][0], vec[3][0], coord_array[0], resol, sizeof(float) * 2);
-       forward_diff_bezier(vec[0][1], vec[1][1], vec[2][1], vec[3][1], coord_array[0] + 1, resol, sizeof(float) * 2);
+       BKE_curve_forward_diff_bezier(vec[0][0], vec[1][0], vec[2][0], vec[3][0], coord_array[0], resol, sizeof(float) * 2);
+       BKE_curve_forward_diff_bezier(vec[0][1], vec[1][1], vec[2][1], vec[3][1], coord_array[0] + 1, resol, sizeof(float) * 2);
        
        return 1;
 }
index 713009d..1407d38 100644 (file)
@@ -111,7 +111,7 @@ MetaElem *add_metaball_primitive(bContext *C, float mat[4][4], int type, int UNU
                ml= ml->next;
        }
        
-       ml= add_metaball_element(mball, type);
+       ml= BKE_metaball_element_add(mball, type);
        copy_v3_v3(&ml->x, mat[3]);
 
        ml->flag |= SELECT;
index 21c9f77..fcce65c 100644 (file)
@@ -1391,7 +1391,7 @@ static int convert_exec(bContext *C, wmOperator *op)
                                ((Curve *)newob->data)->id.us--;
 
                                /* make a new copy of the curve */
-                               newob->data = copy_curve(ob->data);
+                               newob->data = BKE_curve_copy(ob->data);
                        }
                        else {
                                newob = ob;
@@ -1456,7 +1456,7 @@ static int convert_exec(bContext *C, wmOperator *op)
                                        ((Curve *)newob->data)->id.us--;
 
                                        /* make a new copy of the curve */
-                                       newob->data = copy_curve(ob->data);
+                                       newob->data = BKE_curve_copy(ob->data);
                                }
                                else {
                                        newob = ob;
@@ -1474,7 +1474,7 @@ static int convert_exec(bContext *C, wmOperator *op)
                        base->flag &= ~SELECT;
                        ob->flag &= ~SELECT;
 
-                       baseob = find_basis_mball(scene, ob);
+                       baseob = BKE_metaball_basis_find(scene, ob);
 
                        if (ob != baseob) {
                                /* if motherball is converting it would be marked as done later */
@@ -1701,7 +1701,7 @@ static Base *object_add_duplicate_internal(Main *bmain, Scene *scene, Base *base
                                if (dupflag & USER_DUP_CURVE) {
                                        ID_NEW_US2(obn->data)
                                        else {
-                                               obn->data = copy_curve(obn->data);
+                                               obn->data = BKE_curve_copy(obn->data);
                                                didit = 1;
                                        }
                                        id->us--;
@@ -1711,7 +1711,7 @@ static Base *object_add_duplicate_internal(Main *bmain, Scene *scene, Base *base
                                if (dupflag & USER_DUP_SURF) {
                                        ID_NEW_US2(obn->data)
                                        else {
-                                               obn->data = copy_curve(obn->data);
+                                               obn->data = BKE_curve_copy(obn->data);
                                                didit = 1;
                                        }
                                        id->us--;
@@ -1721,7 +1721,7 @@ static Base *object_add_duplicate_internal(Main *bmain, Scene *scene, Base *base
                                if (dupflag & USER_DUP_FONT) {
                                        ID_NEW_US2(obn->data)
                                        else {
-                                               obn->data = copy_curve(obn->data);
+                                               obn->data = BKE_curve_copy(obn->data);
                                                didit = 1;
                                        }
                                        id->us--;
@@ -1731,7 +1731,7 @@ static Base *object_add_duplicate_internal(Main *bmain, Scene *scene, Base *base
                                if (dupflag & USER_DUP_MBALL) {
                                        ID_NEW_US2(obn->data)
                                        else {
-                                               obn->data = copy_mball(obn->data);
+                                               obn->data = BKE_metaball_copy(obn->data);
                                                didit = 1;
                                        }
                                        id->us--;
index 874b04f..d5385d0 100644 (file)
@@ -746,10 +746,10 @@ static void copy_texture_space(Object *to, Object *ob)
                /* pass */
        }
        else if (to->type == OB_MBALL) {
-               tex_space_mball(to);
+               BKE_metaball_tex_space_calc(to);
        }
        else {
-               tex_space_curve(to->data);
+               BKE_curve_tex_space_calc(to->data);
        }
        
 }
index bd69b3a..f2d682c 100644 (file)
@@ -544,9 +544,9 @@ static int modifier_apply_obdata(ReportList *reports, Scene *scene, Object *ob,
                cu = ob->data;
                BKE_report(reports, RPT_INFO, "Applied modifier only changed CV points, not tessellated/bevel vertices");
 
-               vertexCos = curve_getVertexCos(cu, &cu->nurb, &numVerts);
+               vertexCos = BKE_curve_vertexCos_get(cu, &cu->nurb, &numVerts);
                mti->deformVerts(md, ob, NULL, vertexCos, numVerts, 0, 0);
-               curve_applyVertexCos(cu, &cu->nurb, vertexCos);
+               BK_curve_vertexCos_apply(cu, &cu->nurb, vertexCos);
 
                MEM_freeN(vertexCos);
 
index 3a00c69..077ae28 100644 (file)
@@ -1480,12 +1480,12 @@ static void single_obdata_users(Main *bmain, Scene *scene, int flag)
                                                //      ipo_idnew(me->key->ipo);        /* drivers */
                                                break;
                                        case OB_MBALL:
-                                               ob->data = copy_mball(ob->data);
+                                               ob->data = BKE_metaball_copy(ob->data);
                                                break;
                                        case OB_CURVE:
                                        case OB_SURF:
                                        case OB_FONT:
-                                               ob->data = cu = copy_curve(ob->data);
+                                               ob->data = cu = BKE_curve_copy(ob->data);
                                                ID_NEW(cu->bevobj);
                                                ID_NEW(cu->taperobj);
                                                break;
index bd88bbd..5d31bff 100644 (file)
@@ -119,7 +119,7 @@ static int ED_object_shape_key_remove(bContext *C, Object *ob)
                                                break;
                                        case OB_CURVE:
                                        case OB_SURF:
-                                               key_to_curve(key->refkey, ob->data, BKE_curve_nurbs(ob->data));
+                                               key_to_curve(key->refkey, ob->data, BKE_curve_nurbs_get(ob->data));
                                                break;
                                        case OB_LATTICE:
                                                key_to_latt(key->refkey, ob->data);
index 1c0899a..e416bd5 100644 (file)
@@ -520,7 +520,7 @@ static int apply_objects_internal(bContext *C, ReportList *reports, int apply_lo
                                                mul_m4_v3(mat, bezt->vec[2]);
                                                bezt->radius *= scale;
                                        }
-                                       calchandlesNurb(nu);
+                                       BKE_nurb_handles_calc(nu);
                                }
                                else {
                                        a = nu->pntsu * nu->pntsv;
@@ -779,15 +779,15 @@ static int object_origin_set_exec(bContext *C, wmOperator *op)
                                Curve *cu = ob->data;
 
                                if (centermode == ORIGIN_TO_CURSOR) { /* done */ }
-                               else if (around == V3D_CENTROID) { curve_center_median(cu, cent); }
-                               else { curve_center_bounds(cu, cent);   }
+                               else if (around == V3D_CENTROID) { BKE_curve_center_median(cu, cent); }
+                               else { BKE_curve_center_bounds(cu, cent);   }
 
                                /* don't allow Z change if curve is 2D */
                                if ((ob->type == OB_CURVE) && !(cu->flag & CU_3D))
                                        cent[2] = 0.0;
 
                                negate_v3_v3(cent_neg, cent);
-                               curve_translate(cu, cent_neg, 1);
+                               BKE_curve_translate(cu, cent_neg, 1);
 
                                tot_change++;
                                cu->id.flag |= LIB_DOIT;
index bced6f0..b648dac 100644 (file)
@@ -178,7 +178,7 @@ static int material_slot_assign_exec(bContext *C, wmOperator *UNUSED(op))
                }
                else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
                        Nurb *nu;
-                       ListBase *nurbs = curve_editnurbs((Curve *)ob->data);
+                       ListBase *nurbs = BKE_curve_editNurbs_get((Curve *)ob->data);
 
                        if (nurbs) {
                                for (nu = nurbs->first; nu; nu = nu->next)
@@ -233,7 +233,7 @@ static int material_slot_de_select(bContext *C, int select)
                }
        }
        else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
-               ListBase *nurbs = curve_editnurbs((Curve *)ob->data);
+               ListBase *nurbs = BKE_curve_editNurbs_get((Curve *)ob->data);
                Nurb *nu;
                BPoint *bp;
                BezTriple *bezt;
index 64ce529..c7033b0 100644 (file)
@@ -157,7 +157,7 @@ static int open_exec(bContext *C, wmOperator *op)
 
        errno = 0;
 
-       clip = BKE_add_movieclip_file(str);
+       clip = BKE_movieclip_file_add(str);
 
        if (!clip) {
                if (op->customdata)
index fc84cfc..d435b78 100644 (file)
@@ -720,8 +720,8 @@ static void draw_fcurve_curve_bezts (bAnimContext *ac, ID *id, FCurve *fcu, View
                                
                                correct_bezpart(v1, v2, v3, v4);
                                
-                               forward_diff_bezier(v1[0], v2[0], v3[0], v4[0], data, resol, sizeof(float)*3);
-                               forward_diff_bezier(v1[1], v2[1], v3[1], v4[1], data+1, resol, sizeof(float)*3);
+                               BKE_curve_forward_diff_bezier(v1[0], v2[0], v3[0], v4[0], data, resol, sizeof(float)*3);
+                               BKE_curve_forward_diff_bezier(v1[1], v2[1], v3[1], v4[1], data+1, resol, sizeof(float)*3);
                                
                                for (fp= data; resol; resol--, fp+= 3)
                                        glVertex2fv(fp);
index 1c2f43f..2ef8f6c 100644 (file)
@@ -183,7 +183,7 @@ static void stats_object_edit(Object *obedit, SceneStats *stats)
                BezTriple *bezt;
                BPoint *bp;
                int a;
-               ListBase *nurbs = curve_editnurbs(cu);
+               ListBase *nurbs = BKE_curve_editNurbs_get(cu);
 
                for (nu = nurbs->first; nu; nu = nu->next) {
                        if (nu->type == CU_BEZIER) {
index e00abff..91ece36 100644 (file)
@@ -2499,8 +2499,8 @@ int node_link_bezier_points(View2D *v2d, SpaceNode *snode, bNodeLink *link, floa
        else {
                
                /* always do all three, to prevent data hanging around */
-               forward_diff_bezier(vec[0][0], vec[1][0], vec[2][0], vec[3][0], coord_array[0], resol, sizeof(float)*2);
-               forward_diff_bezier(vec[0][1], vec[1][1], vec[2][1], vec[3][1], coord_array[0]+1, resol, sizeof(float)*2);
+               BKE_curve_forward_diff_bezier(vec[0][0], vec[1][0], vec[2][0], vec[3][0], coord_array[0], resol, sizeof(float)*2);
+               BKE_curve_forward_diff_bezier(vec[0][1], vec[1][1], vec[2][1], vec[3][1], coord_array[0]+1, resol, sizeof(float)*2);
                
                return 1;
        }
index 4508dae..3f43158 100644 (file)
@@ -2213,7 +2213,7 @@ void nurbs_foreachScreenVert(
        short s[2] = {IS_CLIPPED, 0};
        Nurb *nu;
        int i;
-       ListBase *nurbs = curve_editnurbs(cu);
+       ListBase *nurbs = BKE_curve_editNurbs_get(cu);
 
        ED_view3d_clipping_local(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
 
@@ -3963,7 +3963,7 @@ static int drawDispList(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *bas
                        break;
                case OB_MBALL:
 
-                       if (is_basis_mball(ob)) {
+                       if (BKE_metaball_is_basis(ob)) {
                                lb = &ob->disp;
                                if (lb->first == NULL) makeDispListMBall(scene, ob);
                                if (lb->first == NULL) return 1;
@@ -6140,7 +6140,7 @@ static void draw_bounding_volume(Scene *scene, Object *ob, char type)
                bb = ob->bb ? ob->bb : ( (Curve *)ob->data)->bb;
        }
        else if (ob->type == OB_MBALL) {
-               if (is_basis_mball(ob)) {
+               if (BKE_metaball_is_basis(ob)) {
                        bb = ob->bb;
                        if (bb == NULL) {
                                makeDispListMBall(scene, ob);
@@ -6231,7 +6231,7 @@ static void drawObjectSelect(Scene *scene, View3D *v3d, ARegion *ar, Base *base)
                }
        }
        else if (ob->type == OB_MBALL) {
-               if (is_basis_mball(ob)) {
+               if (BKE_metaball_is_basis(ob)) {
                        if ((base->flag & OB_FROMDUPLI) == 0)
                                drawDispListwire(&ob->disp);
                }
@@ -6291,7 +6291,7 @@ static void drawWireExtra(Scene *scene, RegionView3D *rv3d, Object *ob)
                }
        }
        else if (ob->type == OB_MBALL) {
-               if (is_basis_mball(ob)) {
+               if (BKE_metaball_is_basis(ob)) {
                        drawDispListwire(&ob->disp);
                }
        }
@@ -6670,7 +6670,7 @@ void draw_object(Scene *scene, ARegion *ar, View3D *v3d, Base *base, int flag)
                        cu = ob->data;
 
                        if (cu->editnurb) {
-                               ListBase *nurbs = curve_editnurbs(cu);
+                               ListBase *nurbs = BKE_curve_editNurbs_get(cu);
                                drawnurb(scene, v3d, rv3d, base, nurbs->first, dt);
                        }
                        else if (dt == OB_BOUNDBOX) {
index c3ff00e..6d810d9 100644 (file)
@@ -211,7 +211,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float
                BPoint *bp;
                BezTriple *bezt;
                int a;
-               ListBase *nurbs = curve_editnurbs(cu);
+               ListBase *nurbs = BKE_curve_editNurbs_get(cu);
                StructRNA *seltype = NULL;
                void *selp = NULL;
 
@@ -509,7 +509,7 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float
                        BPoint *bp;
                        BezTriple *bezt;
                        int a;
-                       ListBase *nurbs = curve_editnurbs(cu);
+                       ListBase *nurbs = BKE_curve_editNurbs_get(cu);
                        const float scale_w = compute_scale_factor(ve_median[4], median[4]);
 
                        nu = nurbs->first;
@@ -571,8 +571,8 @@ static void v3d_editvertex_buts(uiLayout *layout, View3D *v3d, Object *ob, float
                                                bp++;
                                        }
                                }
-                               test2DNurb(nu);
-                               testhandlesNurb(nu); /* test for bezier too */
+                               BKE_nurb_test2D(nu);
+                               BKE_nurb_handles_test(nu); /* test for bezier too */
 
                                nu = nu->next;
                        }
index 2c301dc..988d0a0 100644 (file)
@@ -106,7 +106,7 @@ static void special_transvert_update(Object *obedit)
                }
                else if (ELEM(obedit->type, OB_CURVE, OB_SURF)) {
                        Curve *cu = obedit->data;
-                       ListBase *nurbs = curve_editnurbs(cu);
+                       ListBase *nurbs = BKE_curve_editNurbs_get(cu);
                        Nurb *nu = nurbs->first;
 
                        while (nu) {
@@ -141,8 +141,8 @@ static void special_transvert_update(Object *obedit)
                                        }
                                }
 
-                               test2DNurb(nu);
-                               testhandlesNurb(nu); /* test for bezier too */
+                               BKE_nurb_test2D(nu);
+                               BKE_nurb_handles_test(nu); /* test for bezier too */
                                nu = nu->next;
                        }
                }
@@ -375,7 +375,7 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode)
        else if (ELEM(obedit->type, OB_CURVE, OB_SURF)) {
                Curve *cu = obedit->data;
                int totmalloc = 0;
-               ListBase *nurbs = curve_editnurbs(cu);
+               ListBase *nurbs = BKE_curve_editNurbs_get(cu);
 
                for (nu = nurbs->first; nu; nu = nu->next) {
                        if (nu->type == CU_BEZIER)
index bdae2c0..00c8e0a 100644 (file)
@@ -1438,7 +1438,7 @@ static void createTransCurveVerts(bContext *C, TransInfo *t)
        if (cu->editnurb==NULL) return;
 
        /* count total of vertices, check identical as in 2nd loop for making transdata! */
-       nurbs= curve_editnurbs(cu);
+       nurbs= BKE_curve_editNurbs_get(cu);
        for (nu= nurbs->first; nu; nu= nu->next) {
                if (nu->type == CU_BEZIER) {
                        for (a=0, bezt= nu->bezt; a<nu->pntsu; a++, bezt++) {
@@ -1588,7 +1588,7 @@ static void createTransCurveVerts(bContext *C, TransInfo *t)
                         * but for now just don't change handle types */
                        if (ELEM(t->mode, TFM_CURVE_SHRINKFATTEN, TFM_TILT) == 0) {
                                /* sets the handles based on their selection, do this after the data is copied to the TransData */
-                               testhandlesNurb(nu);
+                               BKE_nurb_handles_test(nu);
                        }
                }
                else {
index 2c5d074..217e0d3 100644 (file)
@@ -673,7 +673,7 @@ static void recalcData_view3d(TransInfo *t)
        if (t->obedit) {
                if (ELEM(t->obedit->type, OB_CURVE, OB_SURF)) {
                        Curve *cu= t->obedit->data;
-                       ListBase *nurbs= curve_editnurbs(cu);
+                       ListBase *nurbs= BKE_curve_editNurbs_get(cu);
                        Nurb *nu= nurbs->first;
                        
                        if (t->state != TRANS_CANCEL) {
@@ -685,15 +685,15 @@ static void recalcData_view3d(TransInfo *t)
                                
                        if (t->state == TRANS_CANCEL) {
                                while (nu) {
-                                       calchandlesNurb(nu); /* Cant do testhandlesNurb here, it messes up the h1 and h2 flags */
+                                       BKE_nurb_handles_calc(nu); /* Cant do testhandlesNurb here, it messes up the h1 and h2 flags */
                                        nu= nu->next;
                                }
                        } 
                        else {
                                /* Normal updating */
                                while (nu) {
-                                       test2DNurb(nu);
-                                       calchandlesNurb(nu);
+                                       BKE_nurb_test2D(nu);
+                                       BKE_nurb_handles_calc(nu);
                                        nu= nu->next;
                                }
                        }
index c043be0..f8a982c 100644 (file)
@@ -389,7 +389,7 @@ int calc_manipulator_stats(const bContext *C)
                                Nurb *nu;
                                BezTriple *bezt;
                                BPoint *bp;
-                               ListBase *nurbs= curve_editnurbs(cu);
+                               ListBase *nurbs= BKE_curve_editNurbs_get(cu);
 
                                nu= nurbs->first;
                                while (nu) {
index 0f9f908..db97462 100644 (file)
@@ -715,7 +715,7 @@ int getTransformOrientation(const bContext *C, float normal[3], float plane[3],
                        Nurb *nu;
                        BezTriple *bezt;
                        int a;
-                       ListBase *nurbs= curve_editnurbs(cu);
+                       ListBase *nurbs= BKE_curve_editNurbs_get(cu);
 
                        for (nu = nurbs->first; nu; nu = nu->next) {
                                /* only bezier has a normal */
index 97cf73a..86a2d6c 100644 (file)
@@ -100,12 +100,12 @@ static const EnumPropertyItem curve2d_fill_mode_items[] = {
 
 #include "MEM_guardedalloc.h"
 
-#include "ED_curve.h" /* for BKE_curve_nurbs */
+#include "ED_curve.h" /* for BKE_curve_nurbs_get */
 
 /* highly irritating but from RNA we cant know this */
 static Nurb *curve_nurb_from_point(Curve *cu, const void *point, int *nu_index, int *pt_index)
 {
-       ListBase *nurbs = BKE_curve_nurbs(cu);
+       ListBase *nurbs = BKE_curve_nurbs_get(cu);
        Nurb *nu;
        int i = 0;
 
@@ -139,7 +139,7 @@ static Nurb *curve_nurb_from_point(Curve *cu, const void *point, int *nu_index,
 static StructRNA *rna_Curve_refine(PointerRNA *ptr)
 {
        Curve *cu = (Curve*)ptr->data;
-       short obtype = curve_type(cu);
+       short obtype = BKE_curve_type_get(cu);
        
        if (obtype == OB_FONT) return &RNA_TextCurve;
        else if (obtype == OB_SURF) return &RNA_SurfaceCurve;
@@ -205,7 +205,7 @@ static void rna_Curve_texspace_set(Main *UNUSED(bmain), Scene *UNUSED(scene), Po
        Curve *cu = (Curve*)ptr->data;
        
        if (cu->texflag & CU_AUTOSPACE)
-               tex_space_curve(cu);
+               BKE_curve_tex_space_calc(cu);
 }
 
 static int rna_Curve_texspace_editable(PointerRNA *ptr)
@@ -219,7 +219,7 @@ static void rna_Curve_texspace_loc_get(PointerRNA *ptr, float *values)
        Curve *cu = (Curve *)ptr->data;
        
        if (!cu->bb)
-               tex_space_curve(cu);
+               BKE_curve_tex_space_calc(cu);
        
        copy_v3_v3(values, cu->loc);
 }
@@ -236,7 +236,7 @@ static void rna_Curve_texspace_size_get(PointerRNA *ptr, float *values)
        Curve *cu = (Curve *)ptr->data;
        
        if (!cu->bb)
-               tex_space_curve(cu);
+               BKE_curve_tex_space_calc(cu);
        
        copy_v3_v3(values, cu->size);
 }
@@ -271,7 +271,7 @@ static void rna_Curve_dimension_set(PointerRNA *ptr, int value)
        if (value == CU_3D) cu->flag |=  CU_3D;
        else cu->flag &= ~CU_3D;
 
-       update_curve_dimension(cu);
+       BKE_curve_curve_dimension_update(cu);
 }
 
 static EnumPropertyItem *rna_Curve_fill_mode_itemf(bContext *UNUSED(C), PointerRNA *ptr,
@@ -326,7 +326,7 @@ static void rna_Curve_update_points(Main *bmain, Scene *scene, PointerRNA *ptr)
        Nurb *nu = curve_nurb_from_point(cu, ptr->data, NULL, NULL);
 
        if (nu)
-               calchandlesNurb(nu);
+               BKE_nurb_handles_calc(nu);
 
        rna_Curve_update_data(bmain, scene, ptr);
 }
@@ -404,7 +404,7 @@ static void rna_Curve_taperObject_set(PointerRNA *ptr, PointerRNA value)
 static void rna_Curve_resolution_u_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
 {
        Curve *cu = (Curve*)ptr->id.data;
-       ListBase *nurbs = BKE_curve_nurbs(cu);
+       ListBase *nurbs = BKE_curve_nurbs_get(cu);
        Nurb *nu = nurbs->first;
 
        while (nu) {
@@ -418,7 +418,7 @@ static void rna_Curve_resolution_u_update_data(Main *bmain, Scene *scene, Pointe
 static void rna_Curve_resolution_v_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
 {
        Curve *cu = (Curve*)ptr->id.data;
-       ListBase *nurbs = BKE_curve_nurbs(cu);
+       ListBase *nurbs = BKE_curve_nurbs_get(cu);
        Nurb *nu = nurbs->first;
 
 
@@ -481,10 +481,10 @@ static void rna_Nurb_update_cyclic_u(Main *bmain, Scene *scene, PointerRNA *ptr)
        Nurb *nu = (Nurb*)ptr->data;
 
        if (nu->type == CU_BEZIER) {
-               calchandlesNurb(nu);
+               BKE_nurb_handles_calc(nu);
        }
        else {
-               nurbs_knot_calc_u(nu);
+               BKE_nurb_knot_calc_u(nu);
        }
 
        rna_Curve_update_data(bmain, scene, ptr);
@@ -494,7 +494,7 @@ static void rna_Nurb_update_cyclic_v(Main *bmain, Scene *scene, PointerRNA *ptr)
 {
        Nurb *nu = (Nurb*)ptr->data;
 
-       nurbs_knot_calc_v(nu);
+       BKE_nurb_knot_calc_v(nu);
 
        rna_Curve_update_data(bmain, scene, ptr);
 }
@@ -503,8 +503,8 @@ static void rna_Nurb_update_knot_u(Main *bmain, Scene *scene, PointerRNA *ptr)
 {
        Nurb *nu = (Nurb*)ptr->data;
 
-       clamp_nurb_order_u(nu);
-       nurbs_knot_calc_u(nu);
+       BKE_nurb_order_clamp_u(nu);
+       BKE_nurb_knot_calc_u(nu);
 
        rna_Curve_update_data(bmain, scene, ptr);
 }
@@ -513,8 +513,8 @@ static void rna_Nurb_update_knot_v(Main *bmain, Scene *scene, PointerRNA *ptr)
 {
        Nurb *nu = (Nurb*)ptr->data;
 
-       clamp_nurb_order_v(nu);
-       nurbs_knot_calc_v(nu);
+       BKE_nurb_order_clamp_v(nu);
+       BKE_nurb_knot_calc_v(nu);
 
        rna_Curve_update_data(bmain, scene, ptr);
 }
@@ -529,10 +529,10 @@ static void rna_Curve_spline_points_add(ID *id, Nurb *nu, ReportList *reports, i
        }
        else {
 
-               addNurbPoints(nu, number);
+               BKE_nurb_points_add(nu, number);
 
                /* update */
-               nurbs_knot_calc_u(nu);
+               BKE_nurb_knot_calc_u(nu);
 
                rna_Curve_update_data_id(NULL, NULL, id);
        }
@@ -547,10 +547,10 @@ static void rna_Curve_spline_bezpoints_add(ID *id, Nurb *nu, ReportList *reports
                /* do nothing */
        }
        else {
-               addNurbPointsBezier(nu, number);
+               BKE_nurb_bezierPoints_add(nu, number);
 
                /* update */
-               nurbs_knot_calc_u(nu);
+               BKE_nurb_knot_calc_u(nu);
 
                rna_Curve_update_data_id(NULL, NULL, id);
        }
@@ -579,7 +579,7 @@ static Nurb *rna_Curve_spline_new(Curve *cu, int type)
        nu->resolu = nu->resolv = 12;
        nu->flag = CU_SMOOTH;
 
-       BLI_addtail(BKE_curve_nurbs(cu), nu);
+       BLI_addtail(BKE_curve_nurbs_get(cu), nu);
 
        return nu;
 }
@@ -587,7 +587,7 @@ static Nurb *rna_Curve_spline_new(Curve *cu, int type)
 static void rna_Curve_spline_remove(Curve *cu, ReportList *reports, Nurb *nu)
 {
        int found = 0;
-       ListBase *nurbs = BKE_curve_nurbs(cu);
+       ListBase *nurbs = BKE_curve_nurbs_get(cu);
 
        found = BLI_remlink_safe(nurbs, nu);
 
@@ -596,7 +596,7 @@ static void rna_Curve_spline_remove(Curve *cu, ReportList *reports, Nurb *nu)
                return;
        }
 
-       freeNurb(nu);
+       BKE_nurb_free(nu);
        /* invalidate pointer!, no can do */
 
        DAG_id_tag_update(&cu->id, OB_RECALC_DATA);
@@ -605,9 +605,9 @@ static void rna_Curve_spline_remove(Curve *cu, ReportList *reports, Nurb *nu)
 
 static void rna_Curve_spline_clear(Curve *cu)
 {
-       ListBase *nurbs = BKE_curve_nurbs(cu);
+       ListBase *nurbs = BKE_curve_nurbs_get(cu);
 
-       freeNurblist(nurbs);
+       BKE_nurbList_free(nurbs);
 
        DAG_id_tag_update(&cu->id, OB_RECALC_DATA);
        WM_main_add_notifier(NC_GEOM|ND_DATA, NULL);
@@ -617,7 +617,7 @@ static PointerRNA rna_Curve_active_spline_get(PointerRNA *ptr)
 {
        Curve *cu = (Curve*)ptr->data;
        Nurb *nu;
-       ListBase *nurbs = BKE_curve_nurbs(cu);
+       ListBase *nurbs = BKE_curve_nurbs_get(cu);
 
        /* for curve outside editmode will set to -1,  should be changed to be allowed outside of editmode. */
        nu = BLI_findlink(nurbs, cu->actnu);
@@ -632,7 +632,7 @@ static void rna_Curve_active_spline_set(PointerRNA *ptr, PointerRNA value)
 {
        Curve *cu = (Curve*)ptr->data;
        Nurb *nu = value.data;
-       ListBase *nubase = BKE_curve_nurbs(cu);
+       ListBase *nubase = BKE_curve_nurbs_get(cu);
 
        /* -1 is ok for an unset index */
        if (nu == NULL)
@@ -644,7 +644,7 @@ static void rna_Curve_active_spline_set(PointerRNA *ptr, PointerRNA value)
 static char *rna_Curve_spline_path(PointerRNA *ptr)
 {
        Curve *cu = (Curve*)ptr->id.data;
-       ListBase *nubase = BKE_curve_nurbs(cu);
+       ListBase *nubase = BKE_curve_nurbs_get(cu);
        Nurb *nu = ptr->data;
        int index = BLI_findindex(nubase, nu);
 
@@ -693,7 +693,7 @@ static char *rna_TextBox_path(PointerRNA *ptr)
 static void rna_Curve_splines_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
        Curve *cu = (Curve*)ptr->id.data;
-       rna_iterator_listbase_begin(iter, BKE_curve_nurbs(cu), NULL);
+       rna_iterator_listbase_begin(iter, BKE_curve_nurbs_get(cu), NULL);
 }
 
 #else
index 10a45fb..63006af 100644 (file)
@@ -141,7 +141,7 @@ Object *rna_Main_objects_new(Main *UNUSED(bmain), ReportList *reports, const cha
                                type = OB_MESH;
                                break;
                        case ID_CU:
-                               type = curve_type((struct Curve *)data);
+                               type = BKE_curve_type_get((struct Curve *)data);
                                break;
                        case ID_MB:
                                type = OB_MBALL;
@@ -314,7 +314,7 @@ void rna_Main_lattices_remove(Main *bmain, ReportList *reports, struct Lattice *
 
 Curve *rna_Main_curves_new(Main *UNUSED(bmain), const char *name, int type)
 {
-       Curve *cu = add_curve(name, type);
+       Curve *cu = BKE_curve_add(name, type);
        id_us_min(&cu->id);
        return cu;
 }
@@ -329,7 +329,7 @@ void rna_Main_curves_remove(Main *bmain, ReportList *reports, struct Curve *cu)
 
 MetaBall *rna_Main_metaballs_new(Main *UNUSED(bmain), const char *name)
 {
-       MetaBall *mb = add_mball(name);
+       MetaBall *mb = BKE_metaball_add(name);
        id_us_min(&mb->id);
        return mb;
 }
@@ -523,7 +523,7 @@ MovieClip *rna_Main_movieclip_load(Main *UNUSED(bmain), ReportList *reports, con
        MovieClip *clip;
 
        errno = 0;
-       clip = BKE_add_movieclip_file(filepath);
+       clip = BKE_movieclip_file_add(filepath);
 
        if (!clip)
                BKE_reportf(reports, RPT_ERROR, "Can't read: \"%s\", %s.", filepath,
@@ -534,7 +534,7 @@ MovieClip *rna_Main_movieclip_load(Main *UNUSED(bmain), ReportList *reports, con
 
 void rna_Main_movieclips_remove(Main *bmain, MovieClip *clip)
 {
-       unlink_movieclip(bmain, clip);
+       BKE_movieclip_unlink(bmain, clip);
        free_libblock(&bmain->movieclip, clip);
        /* XXX python now has invalid pointer? */
 }
index e8ea19a..f7ef0c5 100644 (file)
@@ -99,7 +99,7 @@ static void rna_MetaBall_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
        if (mb->id.us > 0) {
                for (ob = bmain->object.first; ob; ob = ob->id.next)
                        if (ob->data == mb)
-                               copy_mball_properties(scene, ob);
+                               BKE_metaball_properties_copy(scene, ob);
        
                DAG_id_tag_update(&mb->id, 0);
                WM_main_add_notifier(NC_GEOM|ND_DATA, mb);
@@ -115,7 +115,7 @@ static void rna_MetaBall_update_rotation(Main *bmain, Scene *scene, PointerRNA *
 
 static MetaElem *rna_MetaBall_elements_new(MetaBall *mb, int type)
 {
-       MetaElem *ml = add_metaball_element(mb, type);
+       MetaElem *ml = BKE_metaball_element_add(mb, type);
 
        /* cheating way for importers to avoid slow updates */
        if (mb->id.us > 0) {
index bd024ba..140e874 100644 (file)
@@ -353,7 +353,7 @@ static void rna_Object_data_set(PointerRNA *ptr, PointerRNA value)
                test_object_materials(id);
 
                if (GS(id->name) == ID_CU)
-                       test_curve_type(ob);
+                       BKE_curve_type_test(ob);
                else if (ob->type == OB_ARMATURE)
                        armature_rebuild_pose(ob, ob->data);
        }
index fb383b1..0ac6dcb 100644 (file)
@@ -96,7 +96,7 @@ Mesh *rna_Object_to_mesh(Object *ob, ReportList *reports, Scene *sce, int apply_
                        object_free_modifiers(tmpobj);
 
                /* copies the data */
-               copycu = tmpobj->data = copy_curve( (Curve *) ob->data );
+               copycu = tmpobj->data = BKE_curve_copy( (Curve *) ob->data );
 
                /* temporarily set edit so we get updates from edit mode, but
                 * also because for text datablocks copying it while in edit
@@ -124,7 +124,7 @@ Mesh *rna_Object_to_mesh(Object *ob, ReportList *reports, Scene *sce, int apply_
 
        case OB_MBALL: {
                /* metaballs don't have modifiers, so just convert to mesh */
-               Object *basis_ob = find_basis_mball(sce, ob);
+               Object *basis_ob = BKE_metaball_basis_find(sce, ob);
                /* todo, re-generatre for render-res */
                /* metaball_polygonize(scene, ob) */
 
index b94c2e2..543574e 100644 (file)
@@ -1011,7 +1011,7 @@ static PyObject *M_Geometry_interpolate_bezier(PyObject *UNUSED(self), PyObject
 
        coord_array = MEM_callocN(dims * (resolu) * sizeof(float), "interpolate_bezier");
        for (i = 0; i < dims; i++) {
-               forward_diff_bezier(k1[i], h1[i], h2[i], k2[i], coord_array + i, resolu - 1, sizeof(float) * dims);
+               BKE_curve_forward_diff_bezier(k1[i], h1[i], h2[i], k2[i], coord_array + i, resolu - 1, sizeof(float) * dims);
        }
 
        list = PyList_New(resolu);
index 404901f..7fe1fab 100644 (file)
@@ -908,10 +908,10 @@ static float *get_object_orco(Render *re, Object *ob)
 
        if (!orco) {
                if (ELEM(ob->type, OB_CURVE, OB_FONT)) {
-                       orco = make_orco_curve(re->scene, ob);
+                       orco = BKE_curve_make_orco(re->scene, ob);
                }
                else if (ob->type==OB_SURF) {
-                       orco = make_orco_surf(ob);
+                       orco = BKE_curve_surf_make_orco(ob);
                }
 
                if (orco)
@@ -2437,7 +2437,7 @@ static void init_render_mball(Render *re, ObjectRen *obr)
        int a, need_orco, vlakindex, *index, negative_scale;
        ListBase dispbase= {NULL, NULL};
 
-       if (ob!=find_basis_mball(re->scene, ob))
+       if (ob!=BKE_metaball_basis_find(re->scene, ob))
                return;
 
        mult_m4_m4m4(mat, re->viewmat, ob->obmat);
@@ -2463,7 +2463,7 @@ static void init_render_mball(Render *re, ObjectRen *obr)
 
                if (!orco) {
                        /* orco hasn't been found in cache - create new one and add to cache */
-                       orco= make_orco_mball(ob, &dispbase);
+                       orco= BKE_metaball_make_orco(ob, &dispbase);
                        set_object_orco(re, ob, orco);
                }
        }
@@ -4725,7 +4725,7 @@ static int allow_render_object(Render *re, Object *ob, int nolamps, int onlysele
                return 0;
        
        /* don't add non-basic meta objects, ends up having renderobjects with no geometry */
-       if (ob->type == OB_MBALL && ob!=find_basis_mball(re->scene, ob))
+       if (ob->type == OB_MBALL && ob!=BKE_metaball_basis_find(re->scene, ob))
                return 0;
        
        if (nolamps && (ob->type==OB_LAMP))
index 0c95cce..58c2c64 100644 (file)
@@ -364,7 +364,7 @@ void WM_exit_ext(bContext *C, const short do_python)
 
        free_openrecent();
        
-       BKE_freecubetable();
+       BKE_metaball_cubeTable_free();
        
        ED_preview_free_dbase();  /* frees a Main dbase, before free_blender! */