code cleanup: brush/camera naming

40 files changed, 347 insertions, 347 deletions

diff --git a/source/blender/blenkernel/BKE_brush.h b/source/blender/blenkernel/BKE_brush.h
index 52666ca1538..b5edc8f3e50 100644
--- a/source/blender/blenkernel/BKE_brush.h
+++ b/source/blender/blenkernel/BKE_brush.h
@@ -41,34 +41,34 @@ struct wmOperator;
 // enum CurveMappingPreset;
 
 /* datablock functions */
-struct Brush *add_brush(const char *name);
-struct Brush *copy_brush(struct Brush *brush);
-void make_local_brush(struct Brush *brush);
-void free_brush(struct Brush *brush);
+struct Brush *BKE_brush_add(const char *name);
+struct Brush *BKE_brush_copy(struct Brush *brush);
+void BKE_brush_make_local(struct Brush *brush);
+void BKE_brush_free(struct Brush *brush);
 
-void brush_reset_sculpt(struct Brush *brush);
+void BKE_brush_sculpt_reset(struct Brush *brush);
 
 /* image icon function */
 struct ImBuf *get_brush_icon(struct Brush *brush);
 
 /* brush library operations used by different paint panels */
-int brush_texture_set_nr(struct Brush *brush, int nr);
-int brush_texture_delete(struct Brush *brush);
-int brush_clone_image_set_nr(struct Brush *brush, int nr);
-int brush_clone_image_delete(struct Brush *brush);
+int BKE_brush_texture_set_nr(struct Brush *brush, int nr);
+int BKE_brush_texture_delete(struct Brush *brush);
+int BKE_brush_clone_image_set_nr(struct Brush *brush, int nr);
+int BKE_brush_clone_image_delete(struct Brush *brush);
 
 /* jitter */
-void brush_jitter_pos(const struct Scene *scene, struct Brush *brush,
+void BKE_brush_jitter_pos(const struct Scene *scene, struct Brush *brush,
                       const float pos[2], float jitterpos[2]);
 
 /* brush curve */
-void brush_curve_preset(struct Brush *b, /*enum CurveMappingPreset*/int preset);
-float brush_curve_strength_clamp(struct Brush *br, float p, const float len);
-float brush_curve_strength(struct Brush *br, float p, const float len); /* used for sculpt */
+void BKE_brush_curve_preset(struct Brush *b, /*enum CurveMappingPreset*/int preset);
+float BKE_brush_curve_strength_clamp(struct Brush *br, float p, const float len);
+float BKE_brush_curve_strength(struct Brush *br, float p, const float len); /* used for sculpt */
 
 /* sampling */
-void brush_sample_tex(const struct Scene *scene, struct Brush *brush, const float xy[2], float rgba[4], const int thread);
-void brush_imbuf_new(const struct Scene *scene, struct Brush *brush, short flt, short texfalloff, int size,
+void BKE_brush_sample_tex(const struct Scene *scene, struct Brush *brush, const float xy[2], float rgba[4], const int thread);
+void BKE_brush_imbuf_new(const struct Scene *scene, struct Brush *brush, short flt, short texfalloff, int size,
 	struct ImBuf **imbuf, int use_color_correction);
 
 /* painting */
@@ -76,48 +76,48 @@ struct BrushPainter;
 typedef struct BrushPainter BrushPainter;
 typedef int (*BrushFunc)(void *user, struct ImBuf *ibuf, const float lastpos[2], const float pos[2]);
 
-BrushPainter *brush_painter_new(struct Scene *scene, struct Brush *brush);
-void brush_painter_require_imbuf(BrushPainter *painter, short flt,
+BrushPainter *BKE_brush_painter_new(struct Scene *scene, struct Brush *brush);
+void BKE_brush_painter_require_imbuf(BrushPainter *painter, short flt,
                                  short texonly, int size);
-int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2],
+int BKE_brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2],
                         double time, float pressure, void *user, int use_color_correction);
-void brush_painter_break_stroke(BrushPainter *painter);
-void brush_painter_free(BrushPainter *painter);
+void BKE_brush_painter_break_stroke(BrushPainter *painter);
+void BKE_brush_painter_free(BrushPainter *painter);
 
 /* texture */
-unsigned int *brush_gen_texture_cache(struct Brush *br, int half_side);
+unsigned int *BKE_brush_gen_texture_cache(struct Brush *br, int half_side);
 
 /* radial control */
-struct ImBuf *brush_gen_radial_control_imbuf(struct Brush *br);
+struct ImBuf *BKE_brush_gen_radial_control_imbuf(struct Brush *br);
 
 /* unified strength and size */
 
-int  brush_size(const struct Scene *scene, struct Brush *brush);
-void brush_set_size(struct Scene *scene, struct Brush *brush, int value);
+int  BKE_brush_size_get(const struct Scene *scene, struct Brush *brush);
+void BKE_brush_size_set(struct Scene *scene, struct Brush *brush, int value);
 
-float brush_unprojected_radius(const struct Scene *scene, struct Brush *brush);
-void  brush_set_unprojected_radius(struct Scene *scene, struct Brush *brush, float value);
+float BKE_brush_unprojected_radius_get(const struct Scene *scene, struct Brush *brush);
+void  BKE_brush_unprojected_radius_set(struct Scene *scene, struct Brush *brush, float value);
 
-float brush_alpha(const struct Scene *scene, struct Brush *brush);
-float brush_weight(const Scene *scene, struct Brush *brush);
-void brush_set_weight(const Scene *scene, struct Brush *brush, float value);
+float BKE_brush_alpha_get(const struct Scene *scene, struct Brush *brush);
+float BKE_brush_weight_get(const Scene *scene, struct Brush *brush);
+void BKE_brush_weight_set(const Scene *scene, struct Brush *brush, float value);
 
-int  brush_use_locked_size(const struct Scene *scene, struct Brush *brush);
-int  brush_use_alpha_pressure(const struct Scene *scene, struct Brush *brush);
-int  brush_use_size_pressure(const struct Scene *scene, struct Brush *brush);
+int  BKE_brush_use_locked_size(const struct Scene *scene, struct Brush *brush);
+int  BKE_brush_use_alpha_pressure(const struct Scene *scene, struct Brush *brush);
+int  BKE_brush_use_size_pressure(const struct Scene *scene, struct Brush *brush);
 
 /* scale unprojected radius to reflect a change in the brush's 2D size */
-void brush_scale_unprojected_radius(float *unprojected_radius,
+void BKE_brush_scale_unprojected_radius(float *unprojected_radius,
 									int new_brush_size,
 									int old_brush_size);
 
 /* scale brush size to reflect a change in the brush's unprojected radius */
-void brush_scale_size(int *brush_size,
+void BKE_brush_scale_size(int *BKE_brush_size_get,
 					  float new_unprojected_radius,
 					  float old_unprojected_radius);
 
 /* debugging only */
-void brush_debug_print_state(struct Brush *br);
+void BKE_brush_debug_print_state(struct Brush *br);
 
 #endif
 
diff --git a/source/blender/blenkernel/BKE_camera.h b/source/blender/blenkernel/BKE_camera.h
index 6d10219e74c..8f68d7abcac 100644
--- a/source/blender/blenkernel/BKE_camera.h
+++ b/source/blender/blenkernel/BKE_camera.h
@@ -48,18 +48,18 @@ struct View3D;
 
 /* Camera Datablock */
 
-void *add_camera(const char *name);
-struct Camera *copy_camera(struct Camera *cam);
-void make_local_camera(struct Camera *cam);
-void free_camera(struct Camera *ca);
+void *BKE_camera_add(const char *name);
+struct Camera *BKE_camera_copy(struct Camera *cam);
+void BKE_camera_make_local(struct Camera *cam);
+void BKE_camera_free(struct Camera *ca);
 
 /* Camera Usage */
 
-float object_camera_dof_distance(struct Object *ob);
-void object_camera_mode(struct RenderData *rd, struct Object *ob);
+float BKE_camera_object_dof_distance(struct Object *ob);
+void BKE_camera_object_mode(struct RenderData *rd, struct Object *ob);
 
-int camera_sensor_fit(int sensor_fit, float sizex, float sizey);
-float camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y);
+int BKE_camera_sensor_fit(int sensor_fit, float sizex, float sizey);
+float BKE_camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y);
 
 /* Camera Parameters:
  *
@@ -102,21 +102,21 @@ typedef struct CameraParams {
 	float winmat[4][4];
 } CameraParams;
 
-void camera_params_init(CameraParams *params);
-void camera_params_from_object(CameraParams *params, struct Object *camera);
-void camera_params_from_view3d(CameraParams *params, struct View3D *v3d, struct RegionView3D *rv3d);
+void BKE_camera_params_init(CameraParams *params);
+void BKE_camera_params_from_object(CameraParams *params, struct Object *camera);
+void BKE_camera_params_from_view3d(CameraParams *params, struct View3D *v3d, struct RegionView3D *rv3d);
 
-void camera_params_compute_viewplane(CameraParams *params, int winx, int winy, float aspx, float aspy);
-void camera_params_compute_matrix(CameraParams *params);
+void BKE_camera_params_compute_viewplane(CameraParams *params, int winx, int winy, float aspx, float aspy);
+void BKE_camera_params_compute_matrix(CameraParams *params);
 
 /* Camera View Frame */
 
-void camera_view_frame_ex(struct Scene *scene, struct Camera *camera, float drawsize, const short do_clip, const float scale[3],
+void BKE_camera_view_frame_ex(struct Scene *scene, struct Camera *camera, float drawsize, const short do_clip, const float scale[3],
                           float r_asp[2], float r_shift[2], float *r_drawsize, float r_vec[4][3]);
 
-void camera_view_frame(struct Scene *scene, struct Camera *camera, float r_vec[4][3]);
+void BKE_camera_view_frame(struct Scene *scene, struct Camera *camera, float r_vec[4][3]);
 
-int camera_view_frame_fit_to_scene(
+int BKE_camera_view_frame_fit_to_scene(
         struct Scene *scene, struct View3D *v3d, struct Object *camera_ob,
         float r_co[3]);
 
diff --git a/source/blender/blenkernel/intern/brush.c b/source/blender/blenkernel/intern/brush.c
index b3d128bf2b4..51258b13f68 100644
--- a/source/blender/blenkernel/intern/brush.c
+++ b/source/blender/blenkernel/intern/brush.c
@@ -67,7 +67,7 @@
 #include "RE_render_ext.h" /* externtex */
 #include "RE_shader_ext.h"
 
-static void brush_set_defaults(Brush *brush)
+static void brush_defaults(Brush *brush)
 {
 	brush->blend = 0;
 	brush->flag = 0;
@@ -122,7 +122,7 @@ static void brush_set_defaults(Brush *brush)
 
 /* Datablock add/copy/free/make_local */
 
-Brush *add_brush(const char *name)
+Brush *BKE_brush_add(const char *name)
 {
 	Brush *brush;
 
@@ -131,17 +131,17 @@ Brush *add_brush(const char *name)
 	/* enable fake user by default */
 	brush->id.flag |= LIB_FAKEUSER;
 
-	brush_set_defaults(brush);
+	brush_defaults(brush);
 
 	brush->sculpt_tool = SCULPT_TOOL_DRAW; /* sculpting defaults to the draw tool for new brushes */
 
 	 /* the default alpha falloff curve */
-	brush_curve_preset(brush, CURVE_PRESET_SMOOTH);
+	BKE_brush_curve_preset(brush, CURVE_PRESET_SMOOTH);
 
 	return brush;
 }
 
-Brush *copy_brush(Brush *brush)
+Brush *BKE_brush_copy(Brush *brush)
 {
 	Brush *brushn;
 	
@@ -167,7 +167,7 @@ Brush *copy_brush(Brush *brush)
 }
 
 /* not brush itself */
-void free_brush(Brush *brush)
+void BKE_brush_free(Brush *brush)
 {
 	if (brush->mtex.tex)
 		brush->mtex.tex->id.us--;
@@ -186,7 +186,7 @@ static void extern_local_brush(Brush *brush)
 	id_lib_extern((ID *)brush->clone.image);
 }
 
-void make_local_brush(Brush *brush)
+void BKE_brush_make_local(Brush *brush)
 {
 
 	/* - only lib users: do nothing
@@ -225,7 +225,7 @@ void make_local_brush(Brush *brush)
 		}
 	}
 	else if (is_local && is_lib) {
-		Brush *brush_new= copy_brush(brush);
+		Brush *brush_new= BKE_brush_copy(brush);
 		brush_new->id.us= 1; /* only keep fake user */
 		brush_new->id.flag |= LIB_FAKEUSER;
 
@@ -242,11 +242,11 @@ void make_local_brush(Brush *brush)
 	}
 }
 
-void brush_debug_print_state(Brush *br)
+void BKE_brush_debug_print_state(Brush *br)
 {
 	/* create a fake brush and set it to the defaults */
 	Brush def= {{NULL}};
-	brush_set_defaults(&def);
+	brush_defaults(&def);
 	
 #define BR_TEST(field, t)					\
 	if (br->field != def.field)				\
@@ -329,14 +329,14 @@ void brush_debug_print_state(Brush *br)
 #undef BR_TEST_FLAG
 }
 
-void brush_reset_sculpt(Brush *br)
+void BKE_brush_sculpt_reset(Brush *br)
 {
 	/* enable this to see any non-default
 	 * settings used by a brush: */
-	// brush_debug_print_state(br);
+	// BKE_brush_debug_print_state(br);
 
-	brush_set_defaults(br);
-	brush_curve_preset(br, CURVE_PRESET_SMOOTH);
+	brush_defaults(br);
+	BKE_brush_curve_preset(br, CURVE_PRESET_SMOOTH);
 
 	switch (br->sculpt_tool) {
 	case SCULPT_TOOL_CLAY:
@@ -409,7 +409,7 @@ void brush_reset_sculpt(Brush *br)
 }
 
 /* Library Operations */
-void brush_curve_preset(Brush *b, /*CurveMappingPreset*/int preset)
+void BKE_brush_curve_preset(Brush *b, /*CurveMappingPreset*/int preset)
 {
 	CurveMap *cm = NULL;
 
@@ -424,7 +424,7 @@ void brush_curve_preset(Brush *b, /*CurveMappingPreset*/int preset)
 	curvemapping_changed(b->curve, 0);
 }
 
-int brush_texture_set_nr(Brush *brush, int nr)
+int BKE_brush_texture_set_nr(Brush *brush, int nr)
 {
 	ID *idtest, *id=NULL;
 
@@ -437,7 +437,7 @@ int brush_texture_set_nr(Brush *brush, int nr)
 		idtest->us--;
 	}
 	if (idtest!=id) {
-		brush_texture_delete(brush);
+		BKE_brush_texture_delete(brush);
 
 		brush->mtex.tex= (Tex*)idtest;
 		id_us_plus(idtest);
@@ -448,7 +448,7 @@ int brush_texture_set_nr(Brush *brush, int nr)
 	return 0;
 }
 
-int brush_texture_delete(Brush *brush)
+int BKE_brush_texture_delete(Brush *brush)
 {
 	if (brush->mtex.tex)
 		brush->mtex.tex->id.us--;
@@ -456,13 +456,13 @@ int brush_texture_delete(Brush *brush)
 	return 1;
 }
 
-int brush_clone_image_set_nr(Brush *brush, int nr)
+int BKE_brush_clone_image_set_nr(Brush *brush, int nr)
 {
 	if (brush && nr > 0) {
 		Image *ima= (Image*)BLI_findlink(&G.main->image, nr-1);
 
 		if (ima) {
-			brush_clone_image_delete(brush);
+			BKE_brush_clone_image_delete(brush);
 			brush->clone.image= ima;
 			id_us_plus(&ima->id);
 			brush->clone.offset[0]= brush->clone.offset[1]= 0.0f;
@@ -474,7 +474,7 @@ int brush_clone_image_set_nr(Brush *brush, int nr)
 	return 0;
 }
 
-int brush_clone_image_delete(Brush *brush)
+int BKE_brush_clone_image_delete(Brush *brush)
 {
 	if (brush && brush->clone.image) {
 		brush->clone.image->id.us--;
@@ -486,14 +486,14 @@ int brush_clone_image_delete(Brush *brush)
 }
 
 /* Brush Sampling */
-void brush_sample_tex(const Scene *scene, Brush *brush, const float xy[2], float rgba[4], const int thread)
+void BKE_brush_sample_tex(const Scene *scene, Brush *brush, const float xy[2], float rgba[4], const int thread)
 {
 	MTex *mtex= &brush->mtex;
 
 	if (mtex && mtex->tex) {
 		float co[3], tin, tr, tg, tb, ta;
 		int hasrgb;
-		const int radius= brush_size(scene, brush);
+		const int radius= BKE_brush_size_get(scene, brush);
 
 		co[0]= xy[0]/radius;
 		co[1]= xy[1]/radius;
@@ -520,14 +520,14 @@ void brush_sample_tex(const Scene *scene, Brush *brush, const float xy[2], float
 }
 
 /* TODO, use define for 'texfall' arg */
-void brush_imbuf_new(const Scene *scene, Brush *brush, short flt, short texfall, int bufsize, ImBuf **outbuf, int use_color_correction)
+void BKE_brush_imbuf_new(const Scene *scene, Brush *brush, short flt, short texfall, int bufsize, ImBuf **outbuf, int use_color_correction)
 {
 	ImBuf *ibuf;
 	float xy[2], rgba[4], *dstf;
 	int x, y, rowbytes, xoff, yoff, imbflag;
-	const int radius= brush_size(scene, brush);
+	const int radius= BKE_brush_size_get(scene, brush);
 	unsigned char *dst, crgb[3];
-	const float alpha= brush_alpha(scene, brush);
+	const float alpha= BKE_brush_alpha_get(scene, brush);
 	float brush_rgb[3];
     
 	imbflag= (flt)? IB_rectfloat: IB_rect;
@@ -555,15 +555,15 @@ void brush_imbuf_new(const Scene *scene, Brush *brush, short flt, short texfall,
 
 				if (texfall == 0) {
 					copy_v3_v3(dstf, brush_rgb);
-					dstf[3]= alpha*brush_curve_strength_clamp(brush, len_v2(xy), radius);
+					dstf[3]= alpha*BKE_brush_curve_strength_clamp(brush, len_v2(xy), radius);
 				}
 				else if (texfall == 1) {
-					brush_sample_tex(scene, brush, xy, dstf, 0);
+					BKE_brush_sample_tex(scene, brush, xy, dstf, 0);
 				}
 				else {
-					brush_sample_tex(scene, brush, xy, rgba, 0);
+					BKE_brush_sample_tex(scene, brush, xy, rgba, 0);
 					mul_v3_v3v3(dstf, rgba, brush_rgb);
-					dstf[3] = rgba[3]*alpha*brush_curve_strength_clamp(brush, len_v2(xy), radius);
+					dstf[3] = rgba[3]*alpha*BKE_brush_curve_strength_clamp(brush, len_v2(xy), radius);
 				}
 			}
 		}
@@ -580,7 +580,7 @@ void brush_imbuf_new(const Scene *scene, Brush *brush, short flt, short texfall,
 				xy[1] = y + yoff;
 
 				if (texfall == 0) {
-					alpha_f = alpha * brush_curve_strength(brush, len_v2(xy), radius);
+					alpha_f = alpha * BKE_brush_curve_strength(brush, len_v2(xy), radius);
 
 					dst[0] = crgb[0];
 					dst[1] = crgb[1];
@@ -588,21 +588,21 @@ void brush_imbuf_new(const Scene *scene, Brush *brush, short flt, short texfall,
 					dst[3] = FTOCHAR(alpha_f);
 				}
 				else if (texfall == 1) {
-					brush_sample_tex(scene, brush, xy, rgba, 0);
+					BKE_brush_sample_tex(scene, brush, xy, rgba, 0);
 					rgba_float_to_uchar(dst, rgba);
 				}
 				else if (texfall == 2) {
-					brush_sample_tex(scene, brush, xy, rgba, 0);
+					BKE_brush_sample_tex(scene, brush, xy, rgba, 0);
 					mul_v3_v3(rgba, brush->rgb);
-					alpha_f = rgba[3] * alpha * brush_curve_strength_clamp(brush, len_v2(xy), radius);
+					alpha_f = rgba[3] * alpha * BKE_brush_curve_strength_clamp(brush, len_v2(xy), radius);
 
 					rgb_float_to_uchar(dst, rgba);
 
 					dst[3] = FTOCHAR(alpha_f);
 				}
 				else {
-					brush_sample_tex(scene, brush, xy, rgba, 0);
-					alpha_f = rgba[3] * alpha * brush_curve_strength_clamp(brush, len_v2(xy), radius);
+					BKE_brush_sample_tex(scene, brush, xy, rgba, 0);
+					alpha_f = rgba[3] * alpha * BKE_brush_curve_strength_clamp(brush, len_v2(xy), radius);
 
 					dst[0] = crgb[0];
 					dst[1] = crgb[1];
@@ -631,7 +631,7 @@ void brush_imbuf_new(const Scene *scene, Brush *brush, short flt, short texfall,
 // In anycase, a better solution is needed to prevent
 // inconsistency.
 
-void brush_set_size(Scene *scene, Brush *brush, int size)
+void BKE_brush_size_set(Scene *scene, Brush *brush, int size)
 {
 	UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
 
@@ -641,14 +641,14 @@ void brush_set_size(Scene *scene, Brush *brush, int size)
 		brush->size= size;
 }
 
-int brush_size(const Scene *scene, Brush *brush)
+int BKE_brush_size_get(const Scene *scene, Brush *brush)
 {
 	UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
 
 	return (ups->flag & UNIFIED_PAINT_SIZE) ? ups->size : brush->size;
 }
 
-int brush_use_locked_size(const Scene *scene, Brush *brush)
+int BKE_brush_use_locked_size(const Scene *scene, Brush *brush)
 {
 	const short us_flag = scene->toolsettings->unified_paint_settings.flag;
 
@@ -657,7 +657,7 @@ int brush_use_locked_size(const Scene *scene, Brush *brush)
 	        (brush->flag & BRUSH_LOCK_SIZE);
 }
 
-int brush_use_size_pressure(const Scene *scene, Brush *brush)
+int BKE_brush_use_size_pressure(const Scene *scene, Brush *brush)
 {
 	const short us_flag = scene->toolsettings->unified_paint_settings.flag;
 
@@ -666,7 +666,7 @@ int brush_use_size_pressure(const Scene *scene, Brush *brush)
 	        (brush->flag & BRUSH_SIZE_PRESSURE);
 }
 
-int brush_use_alpha_pressure(const Scene *scene, Brush *brush)
+int BKE_brush_use_alpha_pressure(const Scene *scene, Brush *brush)
 {
 	const short us_flag = scene->toolsettings->unified_paint_settings.flag;
 
@@ -675,7 +675,7 @@ int brush_use_alpha_pressure(const Scene *scene, Brush *brush)
 	        (brush->flag & BRUSH_ALPHA_PRESSURE);
 }
 
-void brush_set_unprojected_radius(Scene *scene, Brush *brush, float unprojected_radius)
+void BKE_brush_unprojected_radius_set(Scene *scene, Brush *brush, float unprojected_radius)
 {
 	UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
 
@@ -685,7 +685,7 @@ void brush_set_unprojected_radius(Scene *scene, Brush *brush, float unprojected_
 		brush->unprojected_radius= unprojected_radius;
 }
 
-float brush_unprojected_radius(const Scene *scene, Brush *brush)
+float BKE_brush_unprojected_radius_get(const Scene *scene, Brush *brush)
 {
 	UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
 
@@ -694,7 +694,7 @@ float brush_unprojected_radius(const Scene *scene, Brush *brush)
 	        brush->unprojected_radius;
 }
 
-static void brush_set_alpha(Scene *scene, Brush *brush, float alpha)
+static void brush_alpha_set(Scene *scene, Brush *brush, float alpha)
 {
 	UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
 
@@ -704,21 +704,21 @@ static void brush_set_alpha(Scene *scene, Brush *brush, float alpha)
 		brush->alpha= alpha;
 }
 
-float brush_alpha(const Scene *scene, Brush *brush)
+float BKE_brush_alpha_get(const Scene *scene, Brush *brush)
 {
 	UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
 
 	return (ups->flag & UNIFIED_PAINT_ALPHA) ? ups->alpha : brush->alpha;
 }
 
-float brush_weight(const Scene *scene, Brush *brush)
+float BKE_brush_weight_get(const Scene *scene, Brush *brush)
 {
 	UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
 
 	return (ups->flag & UNIFIED_PAINT_WEIGHT) ? ups->weight : brush->weight;
 }
 
-void brush_set_weight(const Scene *scene, Brush *brush, float value)
+void BKE_brush_weight_set(const Scene *scene, Brush *brush, float value)
 {
 	UnifiedPaintSettings *ups = &scene->toolsettings->unified_paint_settings;
 
@@ -729,9 +729,9 @@ void brush_set_weight(const Scene *scene, Brush *brush, float value)
 }
 
 /* scale unprojected radius to reflect a change in the brush's 2D size */
-void brush_scale_unprojected_radius(float *unprojected_radius,
-									int new_brush_size,
-									int old_brush_size)
+void BKE_brush_scale_unprojected_radius(float *unprojected_radius,
+                                        int new_brush_size,
+                                        int old_brush_size)
 {
 	float scale = new_brush_size;
 	/* avoid division by zero */
@@ -741,15 +741,15 @@ void brush_scale_unprojected_radius(float *unprojected_radius,
 }
 
 /* scale brush size to reflect a change in the brush's unprojected radius */
-void brush_scale_size(int *brush_size,
-					  float new_unprojected_radius,
-					  float old_unprojected_radius)
+void BKE_brush_scale_size(int *BKE_brush_size_get,
+                          float new_unprojected_radius,
+                          float old_unprojected_radius)
 {
 	float scale = new_unprojected_radius;
 	/* avoid division by zero */
 	if (old_unprojected_radius != 0)
 		scale /= new_unprojected_radius;
-	(*brush_size)= (int)((float)(*brush_size) * scale);
+	(*BKE_brush_size_get)= (int)((float)(*BKE_brush_size_get) * scale);
 }
 
 /* Brush Painting */
@@ -757,7 +757,7 @@ void brush_scale_size(int *brush_size,
 typedef struct BrushPainterCache {
 	short enabled;
 
-	int size;			/* size override, if 0 uses 2*brush_size(brush) */
+	int size;			/* size override, if 0 uses 2*BKE_brush_size_get(brush) */
 	short flt;			/* need float imbuf? */
 	short texonly;		/* no alpha, color or fallof, only texture in imbuf */
 
@@ -795,7 +795,7 @@ struct BrushPainter {
 	BrushPainterCache cache;
 };
 
-BrushPainter *brush_painter_new(Scene *scene, Brush *brush)
+BrushPainter *BKE_brush_painter_new(Scene *scene, Brush *brush)
 {
 	BrushPainter *painter= MEM_callocN(sizeof(BrushPainter), "BrushPainter");
 
@@ -804,15 +804,15 @@ BrushPainter *brush_painter_new(Scene *scene, Brush *brush)
 	painter->firsttouch= 1;
 	painter->cache.lastsize= -1; /* force ibuf create in refresh */
 
-	painter->startsize = brush_size(scene, brush);
-	painter->startalpha = brush_alpha(scene, brush);
+	painter->startsize = BKE_brush_size_get(scene, brush);
+	painter->startalpha = BKE_brush_alpha_get(scene, brush);
 	painter->startjitter = brush->jitter;
 	painter->startspacing = brush->spacing;
 
 	return painter;
 }
 
-void brush_painter_require_imbuf(BrushPainter *painter, short flt, short texonly, int size)
+void BKE_brush_painter_require_imbuf(BrushPainter *painter, short flt, short texonly, int size)
 {
 	if ((painter->cache.flt != flt) || (painter->cache.size != size) ||
 		((painter->cache.texonly != texonly) && texonly)) {
@@ -834,12 +834,12 @@ void brush_painter_require_imbuf(BrushPainter *painter, short flt, short texonly
 	painter->cache.enabled= 1;
 }
 
-void brush_painter_free(BrushPainter *painter)
+void BKE_brush_painter_free(BrushPainter *painter)
 {
 	Brush *brush = painter->brush;
 
-	brush_set_size(painter->scene, brush, painter->startsize);
-	brush_set_alpha(painter->scene, brush, painter->startalpha);
+	BKE_brush_size_set(painter->scene, brush, painter->startsize);
+	brush_alpha_set(painter->scene, brush, painter->startalpha);
 	brush->jitter = painter->startjitter;
 	brush->spacing = painter->startspacing;
 
@@ -859,7 +859,7 @@ static void brush_painter_do_partial(BrushPainter *painter, ImBuf *oldtexibuf,
 	float *bf, *mf, *tf, *otf=NULL, xoff, yoff, xy[2], rgba[4];
 	unsigned char *b, *m, *t, *ot= NULL;
 	int dotexold, origx= x, origy= y;
-	const int radius= brush_size(painter->scene, brush);
+	const int radius= BKE_brush_size_get(painter->scene, brush);
 
 	xoff = -radius + 0.5f;
 	yoff = -radius + 0.5f;
@@ -897,7 +897,7 @@ static void brush_painter_do_partial(BrushPainter *painter, ImBuf *oldtexibuf,
 					xy[0] = x + xoff;
 					xy[1] = y + yoff;
 
-					brush_sample_tex(scene, brush, xy, tf, 0);
+					BKE_brush_sample_tex(scene, brush, xy, tf, 0);
 				}
 
 				bf[0] = tf[0]*mf[0];
@@ -928,7 +928,7 @@ static void brush_painter_do_partial(BrushPainter *painter, ImBuf *oldtexibuf,
 					xy[0] = x + xoff;
 					xy[1] = y + yoff;
 
-					brush_sample_tex(scene, brush, xy, rgba, 0);
+					BKE_brush_sample_tex(scene, brush, xy, rgba, 0);
 					rgba_float_to_uchar(t, rgba);
 				}
 
@@ -948,7 +948,7 @@ static void brush_painter_fixed_tex_partial_update(BrushPainter *painter, const
 	BrushPainterCache *cache= &painter->cache;
 	ImBuf *oldtexibuf, *ibuf;
 	int imbflag, destx, desty, srcx, srcy, w, h, x1, y1, x2, y2;
-	const int diameter= 2*brush_size(scene, brush);
+	const int diameter= 2*BKE_brush_size_get(scene, brush);
 
 	imbflag= (cache->flt)? IB_rectfloat: IB_rect;
 	if (!cache->ibuf)
@@ -1004,8 +1004,8 @@ static void brush_painter_refresh_cache(BrushPainter *painter, const float pos[2
 	MTex *mtex= &brush->mtex;
 	int size;
 	short flt;
-	const int diameter= 2*brush_size(scene, brush);
-	const float alpha= brush_alpha(scene, brush);
+	const int diameter= 2*BKE_brush_size_get(scene, brush);
+	const float alpha= BKE_brush_alpha_get(scene, brush);
 
 	if (diameter != cache->lastsize ||
 		alpha != cache->lastalpha ||
@@ -1024,11 +1024,11 @@ static void brush_painter_refresh_cache(BrushPainter *painter, const float pos[2
 		size= (cache->size)? cache->size: diameter;
 
 		if (brush->flag & BRUSH_FIXED_TEX) {
-			brush_imbuf_new(scene, brush, flt, 3, size, &cache->maskibuf, use_color_correction);
+			BKE_brush_imbuf_new(scene, brush, flt, 3, size, &cache->maskibuf, use_color_correction);
 			brush_painter_fixed_tex_partial_update(painter, pos);
 		}
 		else
-			brush_imbuf_new(scene, brush, flt, 2, size, &cache->ibuf, use_color_correction);
+			BKE_brush_imbuf_new(scene, brush, flt, 2, size, &cache->ibuf, use_color_correction);
 
 		cache->lastsize= diameter;
 		cache->lastalpha= alpha;
@@ -1043,24 +1043,24 @@ static void brush_painter_refresh_cache(BrushPainter *painter, const float pos[2
 	}
 }
 
-void brush_painter_break_stroke(BrushPainter *painter)
+void BKE_brush_painter_break_stroke(BrushPainter *painter)
 {
 	painter->firsttouch= 1;
 }
 
-static void brush_apply_pressure(BrushPainter *painter, Brush *brush, float pressure)
+static void brush_pressure_apply(BrushPainter *painter, Brush *brush, float pressure)
 {
-	if (brush_use_alpha_pressure(painter->scene, brush)) 
-		brush_set_alpha(painter->scene, brush, MAX2(0.0f, painter->startalpha*pressure));
-	if (brush_use_size_pressure(painter->scene, brush))
-		brush_set_size(painter->scene, brush, MAX2(1.0f, painter->startsize*pressure));
+	if (BKE_brush_use_alpha_pressure(painter->scene, brush))
+		brush_alpha_set(painter->scene, brush, MAX2(0.0f, painter->startalpha*pressure));
+	if (BKE_brush_use_size_pressure(painter->scene, brush))
+		BKE_brush_size_set(painter->scene, brush, MAX2(1.0f, painter->startsize*pressure));
 	if (brush->flag & BRUSH_JITTER_PRESSURE)
 		brush->jitter = MAX2(0.0f, painter->startjitter*pressure);
 	if (brush->flag & BRUSH_SPACING_PRESSURE)
 		brush->spacing = MAX2(1.0f, painter->startspacing*(1.5f-pressure));
 }
 
-void brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2], float jitterpos[2])
+void BKE_brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2], float jitterpos[2])
 {
 	int use_jitter= brush->jitter != 0;
 
@@ -1070,7 +1070,7 @@ void brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2], floa
 
 	if (use_jitter) {
 		float rand_pos[2];
-		const int radius= brush_size(scene, brush);
+		const int radius= BKE_brush_size_get(scene, brush);
 		const int diameter= 2*radius;
 
 		// find random position within a circle of diameter 1
@@ -1087,8 +1087,8 @@ void brush_jitter_pos(const Scene *scene, Brush *brush, const float pos[2], floa
 	}
 }
 
-int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2], double time, float pressure,
-                        void *user, int use_color_correction)
+int BKE_brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2], double time, float pressure,
+                            void *user, int use_color_correction)
 {
 	Scene *scene= painter->scene;
 	Brush *brush= painter->brush;
@@ -1105,7 +1105,7 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
 		painter->startpaintpos[0]= pos[0];
 		painter->startpaintpos[1]= pos[1];
 
-		brush_apply_pressure(painter, brush, pressure);
+		brush_pressure_apply(painter, brush, pressure);
 		if (painter->cache.enabled)
 			brush_painter_refresh_cache(painter, pos, use_color_correction);
 		totpaintops += func(user, painter->cache.ibuf, pos, pos);
@@ -1152,11 +1152,11 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
 	else {
 		float startdistance, spacing, step, paintpos[2], dmousepos[2], finalpos[2];
 		float t, len, press;
-		const int radius= brush_size(scene, brush);
+		const int radius= BKE_brush_size_get(scene, brush);
 
 		/* compute brush spacing adapted to brush radius, spacing may depend
 		 * on pressure, so update it */
-		brush_apply_pressure(painter, brush, painter->lastpressure);
+		brush_pressure_apply(painter, brush, painter->lastpressure);
 		spacing= MAX2(1.0f, radius)*brush->spacing*0.01f;
 
 		/* setup starting distance, direction vector and accumulated distance */
@@ -1174,10 +1174,10 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
 
 				t = step/len;
 				press= (1.0f-t)*painter->lastpressure + t*pressure;
-				brush_apply_pressure(painter, brush, press);
+				brush_pressure_apply(painter, brush, press);
 				spacing= MAX2(1.0f, radius)*brush->spacing*0.01f;
 
-				brush_jitter_pos(scene, brush, paintpos, finalpos);
+				BKE_brush_jitter_pos(scene, brush, paintpos, finalpos);
 
 				if (painter->cache.enabled)
 					brush_painter_refresh_cache(painter, finalpos, use_color_correction);
@@ -1192,7 +1192,7 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
 			}
 		}
 		else {
-			brush_jitter_pos(scene, brush, pos, finalpos);
+			BKE_brush_jitter_pos(scene, brush, pos, finalpos);
 
 			if (painter->cache.enabled)
 				brush_painter_refresh_cache(painter, finalpos, use_color_correction);
@@ -1218,9 +1218,9 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
 				painter->accumtime -= painttime;
 
 			while (painter->accumtime >= (double)brush->rate) {
-				brush_apply_pressure(painter, brush, pressure);
+				brush_pressure_apply(painter, brush, pressure);
 
-				brush_jitter_pos(scene, brush, pos, finalpos);
+				BKE_brush_jitter_pos(scene, brush, pos, finalpos);
 
 				if (painter->cache.enabled)
 					brush_painter_refresh_cache(painter, finalpos, use_color_correction);
@@ -1238,8 +1238,8 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
 	painter->lastmousepos[1]= pos[1];
 	painter->lastpressure= pressure;
 
-	brush_set_alpha(scene, brush, painter->startalpha);
-	brush_set_size(scene, brush, painter->startsize);
+	brush_alpha_set(scene, brush, painter->startalpha);
+	BKE_brush_size_set(scene, brush, painter->startsize);
 	brush->jitter = painter->startjitter;
 	brush->spacing = painter->startspacing;
 
@@ -1247,7 +1247,7 @@ int brush_painter_paint(BrushPainter *painter, BrushFunc func, const float pos[2
 }
 
 /* Uses the brush curve control to find a strength value between 0 and 1 */
-float brush_curve_strength_clamp(Brush *br, float p, const float len)
+float BKE_brush_curve_strength_clamp(Brush *br, float p, const float len)
 {
 	if (p >= len)	return 0;
 	else			p= p/len;
@@ -1259,7 +1259,7 @@ float brush_curve_strength_clamp(Brush *br, float p, const float len)
 }
 /* same as above but can return negative values if the curve enables
  * used for sculpt only */
-float brush_curve_strength(Brush *br, float p, const float len)
+float BKE_brush_curve_strength(Brush *br, float p, const float len)
 {
 	if (p >= len)
 		p= 1.0f;
@@ -1270,7 +1270,7 @@ float brush_curve_strength(Brush *br, float p, const float len)
 }
 
 /* TODO: should probably be unified with BrushPainter stuff? */
-unsigned int *brush_gen_texture_cache(Brush *br, int half_side)
+unsigned int *BKE_brush_gen_texture_cache(Brush *br, int half_side)
 {
 	unsigned int *texcache = NULL;
 	MTex *mtex = &br->mtex;
@@ -1316,7 +1316,7 @@ unsigned int *brush_gen_texture_cache(Brush *br, int half_side)
 }
 
 /**** Radial Control ****/
-struct ImBuf *brush_gen_radial_control_imbuf(Brush *br)
+struct ImBuf *BKE_brush_gen_radial_control_imbuf(Brush *br)
 {
 	ImBuf *im = MEM_callocN(sizeof(ImBuf), "radial control texture");
 	unsigned int *texcache;
@@ -1324,14 +1324,14 @@ struct ImBuf *brush_gen_radial_control_imbuf(Brush *br)
 	int half = side / 2;
 	int i, j;
 
-	texcache = brush_gen_texture_cache(br, half);
+	texcache = BKE_brush_gen_texture_cache(br, half);
 	im->rect_float = MEM_callocN(sizeof(float) * side * side, "radial control rect");
 	im->x = im->y = side;
 
 	for (i=0; i<side; ++i) {
 		for (j=0; j<side; ++j) {
 			float magn= sqrt(pow(i - half, 2) + pow(j - half, 2));
-			im->rect_float[i*side + j]= brush_curve_strength_clamp(br, magn, half);
+			im->rect_float[i*side + j]= BKE_brush_curve_strength_clamp(br, magn, half);
 		}
 	}
 
diff --git a/source/blender/blenkernel/intern/camera.c b/source/blender/blenkernel/intern/camera.c
index 6b1c6a26493..11c628e7848 100644
--- a/source/blender/blenkernel/intern/camera.c
+++ b/source/blender/blenkernel/intern/camera.c
@@ -50,7 +50,7 @@
 
 /****************************** Camera Datablock *****************************/
 
-void *add_camera(const char *name)
+void *BKE_camera_add(const char *name)
 {
 	Camera *cam;
 	
@@ -69,7 +69,7 @@ void *add_camera(const char *name)
 	return cam;
 }
 
-Camera *copy_camera(Camera *cam)
+Camera *BKE_camera_copy(Camera *cam)
 {
 	Camera *camn;
 	
@@ -80,7 +80,7 @@ Camera *copy_camera(Camera *cam)
 	return camn;
 }
 
-void make_local_camera(Camera *cam)
+void BKE_camera_make_local(Camera *cam)
 {
 	Main *bmain= G.main;
 	Object *ob;
@@ -108,7 +108,7 @@ void make_local_camera(Camera *cam)
 		id_clear_lib_data(bmain, &cam->id);
 	}
 	else if (is_local && is_lib) {
-		Camera *cam_new= copy_camera(cam);
+		Camera *cam_new= BKE_camera_copy(cam);
 
 		cam_new->id.us= 0;
 
@@ -127,14 +127,14 @@ void make_local_camera(Camera *cam)
 	}
 }
 
-void free_camera(Camera *ca)
+void BKE_camera_free(Camera *ca)
 {
 	BKE_free_animdata((ID *)ca);
 }
 
 /******************************** Camera Usage *******************************/
 
-void object_camera_mode(RenderData *rd, Object *cam_ob)
+void BKE_camera_object_mode(RenderData *rd, Object *cam_ob)
 {
 	rd->mode &= ~(R_ORTHO|R_PANORAMA);
 
@@ -146,7 +146,7 @@ void object_camera_mode(RenderData *rd, Object *cam_ob)
 }
 
 /* get the camera's dof value, takes the dof object into account */
-float object_camera_dof_distance(Object *ob)
+float BKE_camera_object_dof_distance(Object *ob)
 {
 	Camera *cam = (Camera *)ob->data; 
 	if (ob->type != OB_CAMERA)
@@ -165,7 +165,7 @@ float object_camera_dof_distance(Object *ob)
 	return cam->YF_dofdist;
 }
 
-float camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y)
+float BKE_camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y)
 {
 	/* sensor size used to fit to. for auto, sensor_x is both x and y. */
 	if (sensor_fit == CAMERA_SENSOR_FIT_VERT)
@@ -174,7 +174,7 @@ float camera_sensor_size(int sensor_fit, float sensor_x, float sensor_y)
 	return sensor_x;
 }
 
-int camera_sensor_fit(int sensor_fit, float sizex, float sizey)
+int BKE_camera_sensor_fit(int sensor_fit, float sizex, float sizey)
 {
 	if (sensor_fit == CAMERA_SENSOR_FIT_AUTO) {
 		if (sizex >= sizey)
@@ -188,7 +188,7 @@ int camera_sensor_fit(int sensor_fit, float sizex, float sizey)
 
 /******************************** Camera Params *******************************/
 
-void camera_params_init(CameraParams *params)
+void BKE_camera_params_init(CameraParams *params)
 {
 	memset(params, 0, sizeof(CameraParams));
 
@@ -200,7 +200,7 @@ void camera_params_init(CameraParams *params)
 	params->zoom= 1.0f;
 }
 
-void camera_params_from_object(CameraParams *params, Object *ob)
+void BKE_camera_params_from_object(CameraParams *params, Object *ob)
 {
 	if (!ob)
 		return;
@@ -239,7 +239,7 @@ void camera_params_from_object(CameraParams *params, Object *ob)
 	}
 }
 
-void camera_params_from_view3d(CameraParams *params, View3D *v3d, RegionView3D *rv3d)
+void BKE_camera_params_from_view3d(CameraParams *params, View3D *v3d, RegionView3D *rv3d)
 {
 	/* common */
 	params->lens= v3d->lens;
@@ -248,7 +248,7 @@ void camera_params_from_view3d(CameraParams *params, View3D *v3d, RegionView3D *
 
 	if (rv3d->persp==RV3D_CAMOB) {
 		/* camera view */
-		camera_params_from_object(params, v3d->camera);
+		BKE_camera_params_from_object(params, v3d->camera);
 
 		params->zoom= BKE_screen_view3d_zoom_to_fac((float)rv3d->camzoom);
 
@@ -275,7 +275,7 @@ void camera_params_from_view3d(CameraParams *params, View3D *v3d, RegionView3D *
 	}
 }
 
-void camera_params_compute_viewplane(CameraParams *params, int winx, int winy, float xasp, float yasp)
+void BKE_camera_params_compute_viewplane(CameraParams *params, int winx, int winy, float xasp, float yasp)
 {
 	rctf viewplane;
 	float pixsize, viewfac, sensor_size, dx, dy;
@@ -293,12 +293,12 @@ void camera_params_compute_viewplane(CameraParams *params, int winx, int winy, f
 	}
 	else {
 		/* perspective camera */
-		sensor_size= camera_sensor_size(params->sensor_fit, params->sensor_x, params->sensor_y);
+		sensor_size= BKE_camera_sensor_size(params->sensor_fit, params->sensor_x, params->sensor_y);
 		pixsize= (sensor_size * params->clipsta)/params->lens;
 	}
 
 	/* determine sensor fit */
-	sensor_fit = camera_sensor_fit(params->sensor_fit, xasp*winx, yasp*winy);
+	sensor_fit = BKE_camera_sensor_fit(params->sensor_fit, xasp*winx, yasp*winy);
 
 	if (sensor_fit==CAMERA_SENSOR_FIT_HOR)
 		viewfac= winx;
@@ -351,23 +351,23 @@ void camera_params_compute_viewplane(CameraParams *params, int winx, int winy, f
 }
 
 /* viewplane is assumed to be already computed */
-void camera_params_compute_matrix(CameraParams *params)
+void BKE_camera_params_compute_matrix(CameraParams *params)
 {
-	rctf viewplane= params->viewplane;
+	rctf viewplane = params->viewplane;
 
 	/* compute projection matrix */
 	if (params->is_ortho)
 		orthographic_m4(params->winmat, viewplane.xmin, viewplane.xmax,
-			viewplane.ymin, viewplane.ymax, params->clipsta, params->clipend);
+		                viewplane.ymin, viewplane.ymax, params->clipsta, params->clipend);
 	else
 		perspective_m4(params->winmat, viewplane.xmin, viewplane.xmax,
-			viewplane.ymin, viewplane.ymax, params->clipsta, params->clipend);
+		               viewplane.ymin, viewplane.ymax, params->clipsta, params->clipend);
 }
 
 /***************************** Camera View Frame *****************************/
 
-void camera_view_frame_ex(Scene *scene, Camera *camera, float drawsize, const short do_clip, const float scale[3],
-                          float r_asp[2], float r_shift[2], float *r_drawsize, float r_vec[4][3])
+void BKE_camera_view_frame_ex(Scene *scene, Camera *camera, float drawsize, const short do_clip, const float scale[3],
+                              float r_asp[2], float r_shift[2], float *r_drawsize, float r_vec[4][3])
 {
 	float facx, facy;
 	float depth;
@@ -376,7 +376,7 @@ void camera_view_frame_ex(Scene *scene, Camera *camera, float drawsize, const sh
 	if (scene) {
 		float aspx= (float) scene->r.xsch*scene->r.xasp;
 		float aspy= (float) scene->r.ysch*scene->r.yasp;
-		int sensor_fit= camera_sensor_fit(camera->sensor_fit, aspx, aspy);
+		int sensor_fit= BKE_camera_sensor_fit(camera->sensor_fit, aspx, aspy);
 
 		if (sensor_fit==CAMERA_SENSOR_FIT_HOR) {
 			r_asp[0]= 1.0;
@@ -431,14 +431,14 @@ void camera_view_frame_ex(Scene *scene, Camera *camera, float drawsize, const sh
 	r_vec[3][0]= r_shift[0] - facx; r_vec[3][1]= r_shift[1] + facy; r_vec[3][2]= depth;
 }
 
-void camera_view_frame(Scene *scene, Camera *camera, float r_vec[4][3])
+void BKE_camera_view_frame(Scene *scene, Camera *camera, float r_vec[4][3])
 {
 	float dummy_asp[2];
 	float dummy_shift[2];
 	float dummy_drawsize;
 	const float dummy_scale[3]= {1.0f, 1.0f, 1.0f};
 
-	camera_view_frame_ex(scene, camera, FALSE, 1.0, dummy_scale,
+	BKE_camera_view_frame_ex(scene, camera, FALSE, 1.0, dummy_scale,
 	                     dummy_asp, dummy_shift, &dummy_drawsize, r_vec);
 }
 
@@ -450,7 +450,7 @@ typedef struct CameraViewFrameData {
 	unsigned int tot;
 } CameraViewFrameData;
 
-static void camera_to_frame_view_cb(const float co[3], void *user_data)
+static void BKE_camera_to_frame_view_cb(const float co[3], void *user_data)
 {
 	CameraViewFrameData *data= (CameraViewFrameData *)user_data;
 	unsigned int i;
@@ -467,7 +467,7 @@ static void camera_to_frame_view_cb(const float co[3], void *user_data)
 
 /* don't move the camera, just yield the fit location */
 /* only valid for perspective cameras */
-int camera_view_frame_fit_to_scene(Scene *scene, struct View3D *v3d, Object *camera_ob, float r_co[3])
+int BKE_camera_view_frame_fit_to_scene(Scene *scene, struct View3D *v3d, Object *camera_ob, float r_co[3])
 {
 	float shift[2];
 	float plane_tx[4][3];
@@ -477,7 +477,7 @@ int camera_view_frame_fit_to_scene(Scene *scene, struct View3D *v3d, Object *cam
 
 	unsigned int i;
 
-	camera_view_frame(scene, camera_ob->data, data_cb.frame_tx);
+	BKE_camera_view_frame(scene, camera_ob->data, data_cb.frame_tx);
 
 	copy_m3_m4(rot_obmat, camera_ob->obmat);
 	normalize_m3(rot_obmat);
@@ -514,7 +514,7 @@ int camera_view_frame_fit_to_scene(Scene *scene, struct View3D *v3d, Object *cam
 	data_cb.tot= 0;
 	/* run callback on all visible points */
 	BKE_scene_foreach_display_point(scene, v3d, BA_SELECT,
-	                                camera_to_frame_view_cb, &data_cb);
+	                                BKE_camera_to_frame_view_cb, &data_cb);
 
 	if (data_cb.tot <= 1) {
 		return FALSE;
diff --git a/source/blender/blenkernel/intern/constraint.c b/source/blender/blenkernel/intern/constraint.c
index 47b497188ec..424ded0397e 100644
--- a/source/blender/blenkernel/intern/constraint.c
+++ b/source/blender/blenkernel/intern/constraint.c
@@ -4012,8 +4012,8 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
 
 			add_v2_v2v2(pos, marker->pos, track->offset);
 
-			camera_params_init(&params);
-			camera_params_from_object(&params, camob);
+			BKE_camera_params_init(&params);
+			BKE_camera_params_from_object(&params, camob);
 
 			if (params.is_ortho) {
 				vec[0] = params.ortho_scale * (pos[0] - 0.5f + params.shiftx);
diff --git a/source/blender/blenkernel/intern/library.c b/source/blender/blenkernel/intern/library.c
index 14ab8166f0a..14e2d75bee5 100644
--- a/source/blender/blenkernel/intern/library.c
+++ b/source/blender/blenkernel/intern/library.c
@@ -224,7 +224,7 @@ int id_make_local(ID *id, int test)
 			if (!test) make_local_lamp((Lamp*)id);
 			return 1;
 		case ID_CA:
-			if (!test) make_local_camera((Camera*)id);
+			if (!test) BKE_camera_make_local((Camera*)id);
 			return 1;
 		case ID_SPK:
 			if (!test) make_local_speaker((Speaker*)id);
@@ -258,7 +258,7 @@ int id_make_local(ID *id, int test)
 		case ID_NT:
 			return 0; /* not implemented */
 		case ID_BR:
-			if (!test) make_local_brush((Brush*)id);
+			if (!test) BKE_brush_make_local((Brush*)id);
 			return 1;
 		case ID_PA:
 			if (!test) make_local_particlesettings((ParticleSettings*)id);
@@ -315,7 +315,7 @@ int id_copy(ID *id, ID **newid, int test)
 			if (!test) *newid= (ID*)copy_speaker((Speaker*)id);
 			return 1;
 		case ID_CA:
-			if (!test) *newid= (ID*)copy_camera((Camera*)id);
+			if (!test) *newid= (ID*)BKE_camera_copy((Camera*)id);
 			return 1;
 		case ID_IP:
 			return 0; /* deprecated */
@@ -349,7 +349,7 @@ int id_copy(ID *id, ID **newid, int test)
 			if (!test) *newid= (ID*)ntreeCopyTree((bNodeTree*)id);
 			return 1;
 		case ID_BR:
-			if (!test) *newid= (ID*)copy_brush((Brush*)id);
+			if (!test) *newid= (ID*)BKE_brush_copy((Brush*)id);
 			return 1;
 		case ID_PA:
 			if (!test) *newid= (ID*)psys_copy_settings((ParticleSettings*)id);
@@ -831,7 +831,7 @@ void free_libblock(ListBase *lb, void *idv)
 			free_lamp((Lamp *)id);
 			break;
 		case ID_CA:
-			free_camera((Camera*) id);
+			BKE_camera_free((Camera*) id);
 			break;
 		case ID_IP:
 			free_ipo((Ipo *)id);
@@ -873,7 +873,7 @@ void free_libblock(ListBase *lb, void *idv)
 			ntreeFreeTree((bNodeTree *)id);
 			break;
 		case ID_BR:
-			free_brush((Brush *)id);
+			BKE_brush_free((Brush *)id);
 			break;
 		case ID_PA:
 			psys_free_settings((ParticleSettings *)id);
diff --git a/source/blender/blenkernel/intern/object.c b/source/blender/blenkernel/intern/object.c
index 280a8fdc2b2..fde8f8e3f3d 100644
--- a/source/blender/blenkernel/intern/object.c
+++ b/source/blender/blenkernel/intern/object.c
@@ -755,7 +755,7 @@ void *add_obdata_from_type(int type)
 	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_CAMERA: return BKE_camera_add("Camera");
 	case OB_LAMP: return add_lamp("Lamp");
 	case OB_LATTICE: return add_lattice("Lattice");
 	case OB_ARMATURE: return add_armature("Armature");
diff --git a/source/blender/blenkernel/intern/paint.c b/source/blender/blenkernel/intern/paint.c
index f417f9b79fb..08d8479fd93 100644
--- a/source/blender/blenkernel/intern/paint.c
+++ b/source/blender/blenkernel/intern/paint.c
@@ -126,7 +126,7 @@ void paint_init(Paint *p, const char col[3])
 	/* If there's no brush, create one */
 	brush = paint_brush(p);
 	if (brush == NULL)
-		brush= add_brush("Brush");
+		brush= BKE_brush_add("Brush");
 	paint_brush_set(p, brush);
 
 	memcpy(p->paint_cursor_col, col, 3);
diff --git a/source/blender/blenlib/BLI_voxel.h b/source/blender/blenlib/BLI_voxel.h
index 4e9e6f111db..7b92ac05d29 100644
--- a/source/blender/blenlib/BLI_voxel.h
+++ b/source/blender/blenlib/BLI_voxel.h
@@ -33,7 +33,7 @@
  */
 
 /** find the index number of a voxel, given x/y/z integer coords and resolution vector */
-#define BLI_VEXEL_INDEX(x, y, z, res) ((z) * (res)[1] * (res)[0] + (y) * (res)[0] + (x))
+#define BLI_VOXEL_INDEX(x, y, z, res) ((z) * (res)[1] * (res)[0] + (y) * (res)[0] + (x))
 
 /* all input coordinates must be in bounding box 0.0 - 1.0 */
 float BLI_voxel_sample_nearest(float *data, const int res[3], const float co[3]);
diff --git a/source/blender/blenlib/intern/voxel.c b/source/blender/blenlib/intern/voxel.c
index 1fe42384eb6..3ad9edd14a3 100644
--- a/source/blender/blenlib/intern/voxel.c
+++ b/source/blender/blenlib/intern/voxel.c
@@ -40,7 +40,7 @@ BLI_INLINE float D(float *data, const int res[3], int x, int y, int z)
 	CLAMP(x, 0, res[0] - 1);
 	CLAMP(y, 0, res[1] - 1);
 	CLAMP(z, 0, res[2] - 1);
-	return data[ BLI_VEXEL_INDEX(x, y, z, res) ];
+	return data[ BLI_VOXEL_INDEX(x, y, z, res) ];
 }
 
 /* *** nearest neighbor *** */
diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c
index c07b1d4f66a..c0ae6415fe1 100644
--- a/source/blender/blenloader/intern/readfile.c
+++ b/source/blender/blenloader/intern/readfile.c
@@ -1685,7 +1685,7 @@ static void direct_link_brush(FileData *fd, Brush *brush)
 	if (brush->curve)
 		direct_link_curvemapping(fd, brush->curve);
 	else
-		brush_curve_preset(brush, CURVE_PRESET_SHARP);
+		BKE_brush_curve_preset(brush, CURVE_PRESET_SHARP);
 
 	brush->preview= NULL;
 	brush->icon_imbuf= NULL;
diff --git a/source/blender/collada/DocumentImporter.cpp b/source/blender/collada/DocumentImporter.cpp
index c793453227a..1d315b6ea06 100644
--- a/source/blender/collada/DocumentImporter.cpp
+++ b/source/blender/collada/DocumentImporter.cpp
@@ -802,8 +802,8 @@ bool DocumentImporter::writeCamera( const COLLADAFW::Camera* camera )
 	
 	cam_id = camera->getOriginalId();
 	cam_name = camera->getName();
-	if (cam_name.size()) cam = (Camera*)add_camera((char*)cam_name.c_str());
-	else cam = (Camera*)add_camera((char*)cam_id.c_str());
+	if (cam_name.size()) cam = (Camera *)BKE_camera_add((char*)cam_name.c_str());
+	else cam = (Camera *)BKE_camera_add((char*)cam_id.c_str());
 	
 	if (!cam) {
 		fprintf(stderr, "Cannot create camera.\n");
diff --git a/source/blender/editors/object/object_add.c b/source/blender/editors/object/object_add.c
index 85735c1ac1c..d030e61952e 100644
--- a/source/blender/editors/object/object_add.c
+++ b/source/blender/editors/object/object_add.c
@@ -1783,7 +1783,7 @@ static Base *object_add_duplicate_internal(Main *bmain, Scene *scene, Base *base
 				if (dupflag != 0) {
 					ID_NEW_US2(obn->data)
 					else {
-						obn->data = copy_camera(obn->data);
+						obn->data = BKE_camera_copy(obn->data);
 						didit = 1;
 					}
 					id->us--;
diff --git a/source/blender/editors/object/object_relations.c b/source/blender/editors/object/object_relations.c
index 35b3b0a0407..4678416e1c9 100644
--- a/source/blender/editors/object/object_relations.c
+++ b/source/blender/editors/object/object_relations.c
@@ -1486,7 +1486,7 @@ static void single_obdata_users(Main *bmain, Scene *scene, int flag)
 						}
 						break;
 					case OB_CAMERA:
-						ob->data = copy_camera(ob->data);
+						ob->data = BKE_camera_copy(ob->data);
 						break;
 					case OB_MESH:
 						ob->data = copy_mesh(ob->data);
diff --git a/source/blender/editors/physics/particle_edit.c b/source/blender/editors/physics/particle_edit.c
index ba80fd83de7..7fb5352979d 100644
--- a/source/blender/editors/physics/particle_edit.c
+++ b/source/blender/editors/physics/particle_edit.c
@@ -2990,7 +2990,7 @@ static void brush_puff(PEData *data, int point_index)
 }
 
 
-static void brush_weight(PEData *data, float UNUSED(mat[][4]), float UNUSED(imat[][4]), int point_index, int key_index, PTCacheEditKey *UNUSED(key))
+static void BKE_brush_weight_get(PEData *data, float UNUSED(mat[][4]), float UNUSED(imat[][4]), int point_index, int key_index, PTCacheEditKey *UNUSED(key))
 {
 	/* roots have full weight allways */
 	if (key_index) {
@@ -3622,7 +3622,7 @@ static void brush_edit_apply(bContext *C, wmOperator *op, PointerRNA *itemptr)
 
 						data.weightfac = brush->strength; /* note that this will never be zero */
 
-						foreach_mouse_hit_key(&data, brush_weight, selected);
+						foreach_mouse_hit_key(&data, BKE_brush_weight_get, selected);
 					}
 
 					break;
diff --git a/source/blender/editors/sculpt_paint/paint_cursor.c b/source/blender/editors/sculpt_paint/paint_cursor.c
index 553a9a335d7..c681f8ddb75 100644
--- a/source/blender/editors/sculpt_paint/paint_cursor.c
+++ b/source/blender/editors/sculpt_paint/paint_cursor.c
@@ -69,7 +69,7 @@ typedef struct Snapshot {
 	float size[3];
 	float ofs[3];
 	float rot;
-	int brush_size;
+	int BKE_brush_size_get;
 	int winx;
 	int winy;
 	int brush_map_mode;
@@ -87,8 +87,8 @@ static int same_snap(Snapshot *snap, Brush *brush, ViewContext *vc)
 
 	        /* make brush smaller shouldn't cause a resample */
 	        ((mtex->brush_map_mode == MTEX_MAP_MODE_FIXED &&
-	          (brush_size(vc->scene, brush) <= snap->brush_size)) ||
-	         (brush_size(vc->scene, brush) == snap->brush_size)) &&
+	          (BKE_brush_size_get(vc->scene, brush) <= snap->BKE_brush_size_get)) ||
+	         (BKE_brush_size_get(vc->scene, brush) == snap->BKE_brush_size_get)) &&
 
 	        (mtex->brush_map_mode == snap->brush_map_mode) &&
 	        (vc->ar->winx == snap->winx) &&
@@ -110,7 +110,7 @@ static void make_snap(Snapshot *snap, Brush *brush, ViewContext *vc)
 		snap->rot = -1;
 	}
 
-	snap->brush_size = brush_size(vc->scene, brush);
+	snap->BKE_brush_size_get = BKE_brush_size_get(vc->scene, brush);
 	snap->winx = vc->ar->winx;
 	snap->winy = vc->ar->winy;
 }
@@ -155,7 +155,7 @@ static int load_tex(Sculpt *sd, Brush *br, ViewContext *vc)
 		make_snap(&snap, br, vc);
 
 		if (br->mtex.brush_map_mode == MTEX_MAP_MODE_FIXED) {
-			int s = brush_size(vc->scene, br);
+			int s = BKE_brush_size_get(vc->scene, br);
 			int r = 1;
 
 			for (s >>= 1; s > 0; s >>= 1)
@@ -196,7 +196,7 @@ static int load_tex(Sculpt *sd, Brush *br, ViewContext *vc)
 				// largely duplicated from tex_strength
 
 				const float rotation = -br->mtex.rot;
-				float radius = brush_size(vc->scene, br);
+				float radius = BKE_brush_size_get(vc->scene, br);
 				int index = j * size + i;
 				float x;
 				float avg;
@@ -240,7 +240,7 @@ static int load_tex(Sculpt *sd, Brush *br, ViewContext *vc)
 					avg += br->texture_sample_bias;
 
 					if (br->mtex.brush_map_mode == MTEX_MAP_MODE_FIXED)
-						avg *= brush_curve_strength(br, len, 1);  /* Falloff curve */
+						avg *= BKE_brush_curve_strength(br, len, 1);  /* Falloff curve */
 
 					buffer[index] = 255 - (GLubyte)(255 * avg);
 				}
@@ -345,11 +345,11 @@ static int sculpt_get_brush_geometry(bContext *C, ViewContext *vc,
 	    sculpt_stroke_get_location(C, location, window)) {
 		*pixel_radius =
 		    project_brush_radius(vc,
-		                         brush_unprojected_radius(scene, brush),
+		                         BKE_brush_unprojected_radius_get(scene, brush),
 		                         location);
 
 		if (*pixel_radius == 0)
-			*pixel_radius = brush_size(scene, brush);
+			*pixel_radius = BKE_brush_size_get(scene, brush);
 
 		mul_m4_v3(vc->obact->obmat, location);
 
@@ -359,7 +359,7 @@ static int sculpt_get_brush_geometry(bContext *C, ViewContext *vc,
 		Sculpt *sd    = CTX_data_tool_settings(C)->sculpt;
 		Brush *brush = paint_brush(&sd->paint);
 
-		*pixel_radius = brush_size(scene, brush);
+		*pixel_radius = BKE_brush_size_get(scene, brush);
 		hit = 0;
 	}
 
@@ -414,7 +414,7 @@ static void paint_draw_alpha_overlay(Sculpt *sd, Brush *brush,
 			glTranslatef(-0.5f, -0.5f, 0);
 
 			/* scale based on tablet pressure */
-			if (sd->draw_pressure && brush_use_size_pressure(vc->scene, brush)) {
+			if (sd->draw_pressure && BKE_brush_use_size_pressure(vc->scene, brush)) {
 				glTranslatef(0.5f, 0.5f, 0);
 				glScalef(1.0f / sd->pressure_value, 1.0f / sd->pressure_value, 1);
 				glTranslatef(-0.5f, -0.5f, 0);
@@ -429,7 +429,7 @@ static void paint_draw_alpha_overlay(Sculpt *sd, Brush *brush,
 				quad.ymax = aim[1] + sd->anchored_size - win->ymin;
 			}
 			else {
-				const int radius = brush_size(vc->scene, brush);
+				const int radius = BKE_brush_size_get(vc->scene, brush);
 				quad.xmin = x - radius;
 				quad.ymin = y - radius;
 				quad.xmax = x + radius;
@@ -475,7 +475,7 @@ static void paint_cursor_on_hit(Sculpt *sd, Brush *brush, ViewContext *vc,
 	float unprojected_radius, projected_radius;
 
 	/* update the brush's cached 3D radius */
-	if (!brush_use_locked_size(vc->scene, brush)) {
+	if (!BKE_brush_use_locked_size(vc->scene, brush)) {
 		/* get 2D brush radius */
 		if (sd->draw_anchored)
 			projected_radius = sd->anchored_size;
@@ -483,7 +483,7 @@ static void paint_cursor_on_hit(Sculpt *sd, Brush *brush, ViewContext *vc,
 			if (brush->flag & BRUSH_ANCHORED)
 				projected_radius = 8;
 			else
-				projected_radius = brush_size(vc->scene, brush);
+				projected_radius = BKE_brush_size_get(vc->scene, brush);
 		}
 	
 		/* convert brush radius from 2D to 3D */
@@ -491,11 +491,11 @@ static void paint_cursor_on_hit(Sculpt *sd, Brush *brush, ViewContext *vc,
 		                                                    projected_radius);
 
 		/* scale 3D brush radius by pressure */
-		if (sd->draw_pressure && brush_use_size_pressure(vc->scene, brush))
+		if (sd->draw_pressure && BKE_brush_use_size_pressure(vc->scene, brush))
 			unprojected_radius *= sd->pressure_value;
 
 		/* set cached value in either Brush or UnifiedPaintSettings */
-		brush_set_unprojected_radius(vc->scene, brush, unprojected_radius);
+		BKE_brush_unprojected_radius_set(vc->scene, brush, unprojected_radius);
 	}
 }
 
@@ -514,7 +514,7 @@ static void paint_draw_cursor(bContext *C, int x, int y, void *UNUSED(unused))
 	translation[1] = y;
 	outline_alpha = 0.5;
 	outline_col = brush->add_col;
-	final_radius = brush_size(scene, brush);
+	final_radius = BKE_brush_size_get(scene, brush);
 
 	/* check that brush drawing is enabled */
 	if (!(paint->flags & PAINT_SHOW_BRUSH))
@@ -557,8 +557,8 @@ static void paint_draw_cursor(bContext *C, int x, int y, void *UNUSED(unused))
 		/* draw overlay */
 		paint_draw_alpha_overlay(sd, brush, &vc, x, y);
 
-		if (brush_use_locked_size(scene, brush))
-			brush_set_size(scene, brush, pixel_radius);
+		if (BKE_brush_use_locked_size(scene, brush))
+			BKE_brush_size_set(scene, brush, pixel_radius);
 
 		/* check if brush is subtracting, use different color then */
 		/* TODO: no way currently to know state of pen flip or
diff --git a/source/blender/editors/sculpt_paint/paint_image.c b/source/blender/editors/sculpt_paint/paint_image.c
index dcf4efeff13..a025a84bea9 100644
--- a/source/blender/editors/sculpt_paint/paint_image.c
+++ b/source/blender/editors/sculpt_paint/paint_image.c
@@ -1457,7 +1457,7 @@ static float project_paint_uvpixel_mask(
 	
 	// This only works when the opacity dosnt change while painting, stylus pressure messes with this
 	// so don't use it.
-	// if (ps->is_airbrush==0) mask *= brush_alpha(ps->brush);
+	// if (ps->is_airbrush==0) mask *= BKE_brush_alpha_get(ps->brush);
 	
 	return mask;
 }
@@ -2953,7 +2953,7 @@ static void project_paint_begin(ProjPaintState *ps)
 	
 	MemArena *arena; /* at the moment this is just ps->arena_mt[0], but use this to show were not multithreading */
 
-	const int diameter = 2 * brush_size(ps->scene, ps->brush);
+	const int diameter = 2 * BKE_brush_size_get(ps->scene, ps->brush);
 	
 	/* ---- end defines ---- */
 	
@@ -3091,10 +3091,10 @@ static void project_paint_begin(ProjPaintState *ps)
 				invert_m4_m4(viewmat, viewinv);
 
 				/* window matrix, clipping and ortho */
-				camera_params_init(&params);
-				camera_params_from_object(&params, cam_ob);
-				camera_params_compute_viewplane(&params, ps->winx, ps->winy, 1.0f, 1.0f);
-				camera_params_compute_matrix(&params);
+				BKE_camera_params_init(&params);
+				BKE_camera_params_from_object(&params, cam_ob);
+				BKE_camera_params_compute_viewplane(&params, ps->winx, ps->winy, 1.0f, 1.0f);
+				BKE_camera_params_compute_matrix(&params);
 
 				copy_m4_m4(winmat, params.winmat);
 				ps->clipsta = params.clipsta;
@@ -3597,7 +3597,7 @@ static int project_bucket_iter_init(ProjPaintState *ps, const float mval_f[2])
 {
 	if (ps->source == PROJ_SRC_VIEW) {
 		float min_brush[2], max_brush[2];
-		const float radius = (float)brush_size(ps->scene, ps->brush);
+		const float radius = (float)BKE_brush_size_get(ps->scene, ps->brush);
 
 		/* so we don't have a bucket bounds that is way too small to paint into */
 		// if (radius < 1.0f) radius = 1.0f; // this doesn't work yet :/
@@ -3635,7 +3635,7 @@ static int project_bucket_iter_init(ProjPaintState *ps, const float mval_f[2])
 
 static int project_bucket_iter_next(ProjPaintState *ps, int *bucket_index, rctf *bucket_bounds, const float mval[2])
 {
-	const int diameter = 2 * brush_size(ps->scene, ps->brush);
+	const int diameter = 2 * BKE_brush_size_get(ps->scene, ps->brush);
 
 	if (ps->thread_tot > 1)
 		BLI_lock_thread(LOCK_CUSTOM1);
@@ -3859,7 +3859,7 @@ static void *do_projectpaint_thread(void *ph_v)
 	float co[2];
 	float mask = 1.0f; /* airbrush wont use mask */
 	unsigned short mask_short;
-	const float radius = (float)brush_size(ps->scene, ps->brush);
+	const float radius = (float)BKE_brush_size_get(ps->scene, ps->brush);
 	const float radius_squared = radius * radius; /* avoid a square root with every dist comparison */
 	
 	short lock_alpha = ELEM(ps->brush->blend, IMB_BLEND_ERASE_ALPHA, IMB_BLEND_ADD_ALPHA) ? 0 : ps->brush->flag & BRUSH_LOCK_ALPHA;
@@ -3913,12 +3913,12 @@ static void *do_projectpaint_thread(void *ph_v)
 				if (dist_nosqrt <= radius_squared) {
 					dist = sqrtf(dist_nosqrt);
 
-					falloff = brush_curve_strength_clamp(ps->brush, dist, radius);
+					falloff = BKE_brush_curve_strength_clamp(ps->brush, dist, radius);
 
 					if (falloff > 0.0f) {
 						if (ps->is_texbrush) {
 							/* note, for clone and smear, we only use the alpha, could be a special function */
-							brush_sample_tex(ps->scene, ps->brush, projPixel->projCoSS, rgba, thread_index);
+							BKE_brush_sample_tex(ps->scene, ps->brush, projPixel->projCoSS, rgba, thread_index);
 							alpha = rgba[3];
 						}
 						else {
@@ -3927,7 +3927,7 @@ static void *do_projectpaint_thread(void *ph_v)
 						
 						if (ps->is_airbrush) {
 							/* for an aurbrush there is no real mask, so just multiply the alpha by it */
-							alpha *= falloff * brush_alpha(ps->scene, ps->brush);
+							alpha *= falloff * BKE_brush_alpha_get(ps->scene, ps->brush);
 							mask = ((float)projPixel->mask) / 65535.0f;
 						}
 						else {
@@ -3935,7 +3935,7 @@ static void *do_projectpaint_thread(void *ph_v)
 							falloff = 1.0f - falloff;
 							falloff = 1.0f - (falloff * falloff);
 							
-							mask_short = (unsigned short)(projPixel->mask * (brush_alpha(ps->scene, ps->brush) * falloff));
+							mask_short = (unsigned short)(projPixel->mask * (BKE_brush_alpha_get(ps->scene, ps->brush) * falloff));
 							if (mask_short > projPixel->mask_max) {
 								mask = ((float)mask_short) / 65535.0f;
 								projPixel->mask_max = mask_short;
@@ -4101,9 +4101,9 @@ static int project_paint_sub_stroke(ProjPaintState *ps, BrushPainter *painter, c
 	pos[1] = (float)(mval_i[1]);
 	
 	// we may want to use this later 
-	// brush_painter_require_imbuf(painter, ((ibuf->rect_float)? 1: 0), 0, 0);
+	// BKE_brush_painter_require_imbuf(painter, ((ibuf->rect_float)? 1: 0), 0, 0);
 	
-	if (brush_painter_paint(painter, project_paint_op, pos, time, pressure, ps, 0)) {
+	if (BKE_brush_painter_paint(painter, project_paint_op, pos, time, pressure, ps, 0)) {
 		return 1;
 	}
 	else return 0;
@@ -4525,9 +4525,9 @@ static int imapaint_paint_sub_stroke(ImagePaintState *s, BrushPainter *painter,
 	pos[0] = uv[0] * ibuf->x;
 	pos[1] = uv[1] * ibuf->y;
 
-	brush_painter_require_imbuf(painter, ((ibuf->rect_float) ? 1 : 0), 0, 0);
+	BKE_brush_painter_require_imbuf(painter, ((ibuf->rect_float) ? 1 : 0), 0, 0);
 
-	if (brush_painter_paint(painter, imapaint_paint_op, pos, time, pressure, s, ibuf->profile == IB_PROFILE_LINEAR_RGB)) {
+	if (BKE_brush_painter_paint(painter, imapaint_paint_op, pos, time, pressure, s, ibuf->profile == IB_PROFILE_LINEAR_RGB)) {
 		if (update)
 			imapaint_image_update(s->sima, image, ibuf, texpaint);
 		return 1;
@@ -4580,7 +4580,7 @@ static int imapaint_paint_stroke(ViewContext *vc, ImagePaintState *s, BrushPaint
 			redraw |= imapaint_paint_sub_stroke(s, painter, s->image, texpaint,
 			                                    fwuv, time, 1, pressure);
 			imapaint_clear_partial_redraw();
-			brush_painter_break_stroke(painter);
+			BKE_brush_painter_break_stroke(painter);
 		}
 
 		/* set new canvas */
@@ -4854,7 +4854,7 @@ static int texture_paint_init(bContext *C, wmOperator *op)
 	if (pop->mode == PAINT_MODE_3D && (pop->s.tool == PAINT_TOOL_CLONE))
 		pop->s.tool = PAINT_TOOL_DRAW;
 	pop->s.blend = brush->blend;
-	pop->orig_brush_size = brush_size(scene, brush);
+	pop->orig_brush_size = BKE_brush_size_get(scene, brush);
 
 	if (pop->mode != PAINT_MODE_2D) {
 		Object *ob = OBACT;
@@ -4920,8 +4920,8 @@ static int texture_paint_init(bContext *C, wmOperator *op)
 			return 0;
 
 		/* Don't allow brush size below 2 */
-		if (brush_size(scene, brush) < 2)
-			brush_set_size(scene, brush, 2);
+		if (BKE_brush_size_get(scene, brush) < 2)
+			BKE_brush_size_set(scene, brush, 2);
 
 		/* allocate and initialize spacial data structures */
 		project_paint_begin(&pop->ps);
@@ -4935,7 +4935,7 @@ static int texture_paint_init(bContext *C, wmOperator *op)
 	                      image_undo_restore, image_undo_free);
 
 	/* create painter */
-	pop->painter = brush_painter_new(scene, pop->s.brush);
+	pop->painter = BKE_brush_painter_new(scene, pop->s.brush);
 
 	return 1;
 }
@@ -5002,10 +5002,10 @@ static void paint_exit(bContext *C, wmOperator *op)
 	
 	settings->imapaint.flag &= ~IMAGEPAINT_DRAWING;
 	imapaint_canvas_free(&pop->s);
-	brush_painter_free(pop->painter);
+	BKE_brush_painter_free(pop->painter);
 
 	if (pop->mode == PAINT_MODE_3D_PROJECT) {
-		brush_set_size(scene, pop->ps.brush, pop->orig_brush_size);
+		BKE_brush_size_set(scene, pop->ps.brush, pop->orig_brush_size);
 		paint_brush_exit_tex(pop->ps.brush);
 		
 		project_paint_end(&pop->ps);
@@ -5079,13 +5079,13 @@ static void paint_apply_event(bContext *C, wmOperator *op, wmEvent *event)
 
 		/* special exception here for too high pressure values on first touch in
 		 * windows for some tablets, then we just skip first touch ..  */
-		if (tablet && (pressure >= 0.99f) && ((pop->s.brush->flag & BRUSH_SPACING_PRESSURE) || brush_use_alpha_pressure(scene, pop->s.brush) || brush_use_size_pressure(scene, pop->s.brush)))
+		if (tablet && (pressure >= 0.99f) && ((pop->s.brush->flag & BRUSH_SPACING_PRESSURE) || BKE_brush_use_alpha_pressure(scene, pop->s.brush) || BKE_brush_use_size_pressure(scene, pop->s.brush)))
 			return;
 
 		/* This can be removed once fixed properly in
-		 * brush_painter_paint(BrushPainter *painter, BrushFunc func, float *pos, double time, float pressure, void *user) 
+		 * BKE_brush_painter_paint(BrushPainter *painter, BrushFunc func, float *pos, double time, float pressure, void *user) 
 		 * at zero pressure we should do nothing 1/2^12 is .0002 which is the sensitivity of the most sensitive pen tablet available */
-		if (tablet && (pressure < .0002f) && ((pop->s.brush->flag & BRUSH_SPACING_PRESSURE) || brush_use_alpha_pressure(scene, pop->s.brush) || brush_use_size_pressure(scene, pop->s.brush)))
+		if (tablet && (pressure < .0002f) && ((pop->s.brush->flag & BRUSH_SPACING_PRESSURE) || BKE_brush_use_alpha_pressure(scene, pop->s.brush) || BKE_brush_use_size_pressure(scene, pop->s.brush)))
 			return;
 	
 	}
@@ -5208,7 +5208,7 @@ static void brush_drawcursor(bContext *C, int x, int y, void *UNUSED(customdata)
 	if (paint && brush && paint->flags & PAINT_SHOW_BRUSH) {
 		ToolSettings *ts;
 		float zoomx, zoomy;
-		const float size = (float)brush_size(scene, brush);
+		const float size = (float)BKE_brush_size_get(scene, brush);
 		short use_zoom;
 		float pixel_size;
 		float alpha = 0.5f;
@@ -5702,8 +5702,8 @@ static int texture_paint_camera_project_exec(bContext *C, wmOperator *op)
 	/* override */
 	ps.is_texbrush = 0;
 	ps.is_airbrush = 1;
-	orig_brush_size = brush_size(scene, ps.brush);
-	brush_set_size(scene, ps.brush, 32); /* cover the whole image */
+	orig_brush_size = BKE_brush_size_get(scene, ps.brush);
+	BKE_brush_size_set(scene, ps.brush, 32); /* cover the whole image */
 
 	ps.tool = PAINT_TOOL_DRAW; /* so pixels are initialized with minimal info */
 
@@ -5716,7 +5716,7 @@ static int texture_paint_camera_project_exec(bContext *C, wmOperator *op)
 	project_paint_begin(&ps);
 
 	if (ps.dm == NULL) {
-		brush_set_size(scene, ps.brush, orig_brush_size);
+		BKE_brush_size_set(scene, ps.brush, orig_brush_size);
 		return OPERATOR_CANCELLED;
 	}
 	else {
@@ -5740,7 +5740,7 @@ static int texture_paint_camera_project_exec(bContext *C, wmOperator *op)
 	project_paint_end(&ps);
 
 	scene->toolsettings->imapaint.flag &= ~IMAGEPAINT_DRAWING;
-	brush_set_size(scene, ps.brush, orig_brush_size);
+	BKE_brush_size_set(scene, ps.brush, orig_brush_size);
 
 	return OPERATOR_FINISHED;
 }
diff --git a/source/blender/editors/sculpt_paint/paint_ops.c b/source/blender/editors/sculpt_paint/paint_ops.c
index e218cfe8fd2..2699e9f56f8 100644
--- a/source/blender/editors/sculpt_paint/paint_ops.c
+++ b/source/blender/editors/sculpt_paint/paint_ops.c
@@ -63,9 +63,9 @@ static int brush_add_exec(bContext *C, wmOperator *UNUSED(op))
 	struct Brush *br = paint_brush(paint);
 
 	if (br)
-		br = copy_brush(br);
+		br = BKE_brush_copy(br);
 	else
-		br = add_brush("Brush");
+		br = BKE_brush_add("Brush");
 
 	paint_brush_set(paint_get_active(CTX_data_scene(C)), br);
 
@@ -98,7 +98,7 @@ static int brush_scale_size_exec(bContext *C, wmOperator *op)
 	if (brush) {
 		// pixel radius
 		{
-			const int old_size = brush_size(scene, brush);
+			const int old_size = BKE_brush_size_get(scene, brush);
 			int size = (int)(scalar * old_size);
 
 			if (old_size == size) {
@@ -111,17 +111,17 @@ static int brush_scale_size_exec(bContext *C, wmOperator *op)
 			}
 			CLAMP(size, 1, 2000); // XXX magic number
 
-			brush_set_size(scene, brush, size);
+			BKE_brush_size_set(scene, brush, size);
 		}
 
 		// unprojected radius
 		{
-			float unprojected_radius = scalar * brush_unprojected_radius(scene, brush);
+			float unprojected_radius = scalar * BKE_brush_unprojected_radius_get(scene, brush);
 
 			if (unprojected_radius < 0.001f) // XXX magic number
 				unprojected_radius = 0.001f;
 
-			brush_set_unprojected_radius(scene, brush, unprojected_radius);
+			BKE_brush_unprojected_radius_set(scene, brush, unprojected_radius);
 		}
 	}
 
@@ -178,7 +178,7 @@ static int brush_reset_exec(bContext *C, wmOperator *UNUSED(op))
 	if (!ob) return OPERATOR_CANCELLED;
 
 	if (ob->mode & OB_MODE_SCULPT)
-		brush_reset_sculpt(brush);
+		BKE_brush_sculpt_reset(brush);
 	/* TODO: other modes */
 
 	return OPERATOR_FINISHED;
diff --git a/source/blender/editors/sculpt_paint/paint_stroke.c b/source/blender/editors/sculpt_paint/paint_stroke.c
index 010278e8621..fe228839c47 100644
--- a/source/blender/editors/sculpt_paint/paint_stroke.c
+++ b/source/blender/editors/sculpt_paint/paint_stroke.c
@@ -146,10 +146,10 @@ static void paint_brush_stroke_add_step(bContext *C, wmOperator *op, wmEvent *ev
 	if (stroke->vc.obact->sculpt) {
 		float delta[2];
 
-		brush_jitter_pos(scene, brush, mouse_in, mouse);
+		BKE_brush_jitter_pos(scene, brush, mouse_in, mouse);
 
 		/* XXX: meh, this is round about because
-		 * brush_jitter_pos isn't written in the best way to
+		 * BKE_brush_jitter_pos isn't written in the best way to
 		 * be reused here */
 		if (brush->flag & BRUSH_JITTER_PRESSURE) {
 			sub_v2_v2v2(delta, mouse, mouse_in);
@@ -231,11 +231,11 @@ static int paint_space_stroke(bContext *C, wmOperator *op, wmEvent *event, const
 			float pressure = 1.0f;
 
 			/* XXX mysterious :) what has 'use size' do with this here... if you don't check for it, pressure fails */
-			if (brush_use_size_pressure(scene, stroke->brush))
+			if (BKE_brush_use_size_pressure(scene, stroke->brush))
 				pressure = event_tablet_data(event, NULL);
 			
 			if (pressure > FLT_EPSILON) {
-				scale = (brush_size(scene, stroke->brush) * pressure * stroke->brush->spacing / 50.0f) / length;
+				scale = (BKE_brush_size_get(scene, stroke->brush) * pressure * stroke->brush->spacing / 50.0f) / length;
 				if (scale > FLT_EPSILON) {
 					mul_v2_fl(vec, scale);
 
diff --git a/source/blender/editors/sculpt_paint/paint_utils.c b/source/blender/editors/sculpt_paint/paint_utils.c
index 89a46272a8f..fb5ddda7a3e 100644
--- a/source/blender/editors/sculpt_paint/paint_utils.c
+++ b/source/blender/editors/sculpt_paint/paint_utils.c
@@ -358,7 +358,7 @@ void paint_sample_color(Scene *scene, ARegion *ar, int x, int y)    /* frontbuf
 static int brush_curve_preset_exec(bContext *C, wmOperator *op)
 {
 	Brush *br = paint_brush(paint_get_active(CTX_data_scene(C)));
-	brush_curve_preset(br, RNA_enum_get(op->ptr, "shape"));
+	BKE_brush_curve_preset(br, RNA_enum_get(op->ptr, "shape"));
 
 	return OPERATOR_FINISHED;
 }
diff --git a/source/blender/editors/sculpt_paint/paint_vertex.c b/source/blender/editors/sculpt_paint/paint_vertex.c
index 9c89eb7c573..37d5af553ab 100644
--- a/source/blender/editors/sculpt_paint/paint_vertex.c
+++ b/source/blender/editors/sculpt_paint/paint_vertex.c
@@ -859,7 +859,7 @@ static float calc_vp_strength_dl(VPaint *vp, ViewContext *vc, const float *vert_
 	}
 	else {
 		const float dist = sqrtf(dist_squared);
-		return brush_curve_strength_clamp(brush, dist, brush_size_pressure);
+		return BKE_brush_curve_strength_clamp(brush, dist, brush_size_pressure);
 	}
 }
 
@@ -1051,7 +1051,7 @@ static int weight_sample_invoke(bContext *C, wmOperator *op, wmEvent *event)
 
 				if (v_idx_best != -1) { /* should always be valid */
 					float vgroup_weight = defvert_find_weight(&me->dvert[v_idx_best], vgroup_active);
-					brush_set_weight(scene, brush, vgroup_weight);
+					BKE_brush_weight_set(scene, brush, vgroup_weight);
 					change = TRUE;
 				}
 			}
@@ -1641,7 +1641,7 @@ typedef struct WeightPaintInfo {
 	char do_multipaint;
 	char do_auto_normalize;
 
-	float brush_alpha_value;  /* result of brush_alpha() */
+	float brush_alpha_value;  /* result of BKE_brush_alpha_get() */
 } WeightPaintInfo;
 
 /* fresh start to make multi-paint and locking modular */
@@ -2244,9 +2244,9 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
 	char *defbase_sel;
 
 	const float pressure = RNA_float_get(itemptr, "pressure");
-	const float brush_size_pressure = brush_size(scene, brush) * (brush_use_size_pressure(scene, brush) ? pressure : 1.0f);
-	const float brush_alpha_value = brush_alpha(scene, brush);
-	const float brush_alpha_pressure = brush_alpha_value * (brush_use_alpha_pressure(scene, brush) ? pressure : 1.0f);
+	const float brush_size_pressure = BKE_brush_size_get(scene, brush) * (BKE_brush_use_size_pressure(scene, brush) ? pressure : 1.0f);
+	const float brush_alpha_value = BKE_brush_alpha_get(scene, brush);
+	const float brush_alpha_pressure = brush_alpha_value * (BKE_brush_use_alpha_pressure(scene, brush) ? pressure : 1.0f);
 
 	/* intentionally don't initialize as NULL, make sure we initialize all members below */
 	WeightPaintInfo wpi;
@@ -2342,7 +2342,7 @@ static void wpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
 	if (brush->vertexpaint_tool == PAINT_BLEND_BLUR)
 		paintweight = 0.0f;
 	else
-		paintweight = brush_weight(scene, brush);
+		paintweight = BKE_brush_weight_get(scene, brush);
 			
 	for (index = 0; index < totindex; index++) {
 		if (indexar[index] && indexar[index] <= me->totpoly) {
@@ -2510,7 +2510,7 @@ static int weight_paint_set_exec(bContext *C, wmOperator *UNUSED(op))
 	Object *obact = CTX_data_active_object(C);
 	ToolSettings *ts = CTX_data_tool_settings(C);
 	Brush *brush = paint_brush(&ts->wpaint->paint);
-	float vgroup_weight = brush_weight(scene, brush);
+	float vgroup_weight = BKE_brush_weight_get(scene, brush);
 
 	wpaint_fill(scene->toolsettings->wpaint, obact, vgroup_weight);
 	ED_region_tag_redraw(CTX_wm_region(C)); /* XXX - should redraw all 3D views */
@@ -2870,8 +2870,8 @@ static void vpaint_stroke_update_step(bContext *C, struct PaintStroke *stroke, P
 	float mval[2];
 
 	const float pressure = RNA_float_get(itemptr, "pressure");
-	const float brush_size_pressure = brush_size(scene, brush) * (brush_use_size_pressure(scene, brush) ? pressure : 1.0f);
-	const float brush_alpha_pressure = brush_alpha(scene, brush) * (brush_use_alpha_pressure(scene, brush) ? pressure : 1.0f);
+	const float brush_size_pressure = BKE_brush_size_get(scene, brush) * (BKE_brush_use_size_pressure(scene, brush) ? pressure : 1.0f);
+	const float brush_alpha_pressure = BKE_brush_alpha_get(scene, brush) * (BKE_brush_use_alpha_pressure(scene, brush) ? pressure : 1.0f);
 
 	RNA_float_get_array(itemptr, "mouse", mval);
 
diff --git a/source/blender/editors/sculpt_paint/sculpt.c b/source/blender/editors/sculpt_paint/sculpt.c
index 32ed55854b6..fa560dc138c 100644
--- a/source/blender/editors/sculpt_paint/sculpt.c
+++ b/source/blender/editors/sculpt_paint/sculpt.c
@@ -505,7 +505,7 @@ static float overlapped_curve(Brush *br, float x)
 		xx = fabs(x0 + i * h);
 
 		if (xx < 1.0f)
-			sum += brush_curve_strength(br, xx, 1);
+			sum += BKE_brush_curve_strength(br, xx, 1);
 	}
 
 	return sum;
@@ -618,10 +618,10 @@ static float brush_strength(Sculpt *sd, StrokeCache *cache, float feather)
 	Brush *brush = paint_brush(&sd->paint);
 
 	/* Primary strength input; square it to make lower values more sensitive */
-	const float root_alpha = brush_alpha(scene, brush);
+	const float root_alpha = BKE_brush_alpha_get(scene, brush);
 	float alpha        = root_alpha * root_alpha;
 	float dir          = brush->flag & BRUSH_DIR_IN ? -1 : 1;
-	float pressure     = brush_use_alpha_pressure(scene, brush) ? cache->pressure : 1;
+	float pressure     = BKE_brush_use_alpha_pressure(scene, brush) ? cache->pressure : 1;
 	float pen_flip     = cache->pen_flip ? -1 : 1;
 	float invert       = cache->invert ? -1 : 1;
 	float accum        = integrate_overlap(brush);
@@ -752,7 +752,7 @@ static float tex_strength(SculptSession *ss, Brush *br, float point[3],
 			   /* leave the coordinates relative to the screen */
 
 			/* use unadjusted size for tiled mode */
-			radius = brush_size(ss->cache->vc->scene, br);
+			radius = BKE_brush_size_get(ss->cache->vc->scene, br);
 		
 			x = point_2d[0];
 			y = point_2d[1];
@@ -792,7 +792,7 @@ static float tex_strength(SculptSession *ss, Brush *br, float point[3],
 	avg += br->texture_sample_bias;
 
 	/* Falloff curve */
-	avg *= brush_curve_strength(br, len, ss->cache->radius);
+	avg *= BKE_brush_curve_strength(br, len, ss->cache->radius);
 
 	avg *= frontface(br, sculpt_normal, vno, fno);
 
@@ -1250,8 +1250,8 @@ static void do_crease_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnod
 	
 	/* we divide out the squared alpha and multiply by the squared crease to give us the pinch strength */
 	
-	if (brush_alpha(scene, brush) > 0.0f)
-		crease_correction = brush->crease_pinch_factor * brush->crease_pinch_factor / (brush_alpha(scene, brush) * brush_alpha(scene, brush));
+	if (BKE_brush_alpha_get(scene, brush) > 0.0f)
+		crease_correction = brush->crease_pinch_factor * brush->crease_pinch_factor / (BKE_brush_alpha_get(scene, brush) * BKE_brush_alpha_get(scene, brush));
 	else
 		crease_correction = brush->crease_pinch_factor * brush->crease_pinch_factor;
 
@@ -2720,7 +2720,7 @@ static void do_symmetrical_brush_actions(Sculpt *sd, Object *ob)
 static void sculpt_update_tex(const Scene *scene, Sculpt *sd, SculptSession *ss)
 {
 	Brush *brush = paint_brush(&sd->paint);
-	const int radius = brush_size(scene, brush);
+	const int radius = BKE_brush_size_get(scene, brush);
 
 	if (ss->texcache) {
 		MEM_freeN(ss->texcache);
@@ -2730,7 +2730,7 @@ static void sculpt_update_tex(const Scene *scene, Sculpt *sd, SculptSession *ss)
 	/* Need to allocate a bigger buffer for bigger brush size */
 	ss->texcache_side = 2 * radius;
 	if (!ss->texcache || ss->texcache_side > ss->texcache_actual) {
-		ss->texcache = brush_gen_texture_cache(brush, radius);
+		ss->texcache = BKE_brush_gen_texture_cache(brush, radius);
 		ss->texcache_actual = ss->texcache_side;
 	}
 }
@@ -3130,19 +3130,19 @@ static void sculpt_update_cache_variants(bContext *C, Sculpt *sd, Object *ob,
 	sd->pressure_value = cache->pressure;
 
 	cache->previous_pixel_radius = cache->pixel_radius;
-	cache->pixel_radius = brush_size(scene, brush);
+	cache->pixel_radius = BKE_brush_size_get(scene, brush);
 
 	if (cache->first_time) {
-		if (!brush_use_locked_size(scene, brush)) {
-			cache->initial_radius = paint_calc_object_space_radius(cache->vc, cache->true_location, brush_size(scene, brush));
-			brush_set_unprojected_radius(scene, brush, cache->initial_radius);
+		if (!BKE_brush_use_locked_size(scene, brush)) {
+			cache->initial_radius = paint_calc_object_space_radius(cache->vc, cache->true_location, BKE_brush_size_get(scene, brush));
+			BKE_brush_unprojected_radius_set(scene, brush, cache->initial_radius);
 		}
 		else {
-			cache->initial_radius = brush_unprojected_radius(scene, brush);
+			cache->initial_radius = BKE_brush_unprojected_radius_get(scene, brush);
 		}
 	}
 
-	if (brush_use_size_pressure(scene, brush)) {
+	if (BKE_brush_use_size_pressure(scene, brush)) {
 		cache->pixel_radius *= cache->pressure;
 		cache->radius = cache->initial_radius * cache->pressure;
 	}
@@ -3374,7 +3374,7 @@ static void sculpt_restore_mesh(Sculpt *sd, SculptSession *ss)
 	/* Restore the mesh before continuing with anchored stroke */
 	if ((brush->flag & BRUSH_ANCHORED) ||
 	    (brush->sculpt_tool == SCULPT_TOOL_GRAB &&
-	     brush_use_size_pressure(ss->cache->vc->scene, brush)) ||
+	     BKE_brush_use_size_pressure(ss->cache->vc->scene, brush)) ||
 	    (brush->flag & BRUSH_RESTORE_MESH))
 	{
 		paint_mesh_restore_co(sd, ss);
diff --git a/source/blender/editors/sculpt_paint/sculpt_uv.c b/source/blender/editors/sculpt_paint/sculpt_uv.c
index 707d5b2aa7c..95441600d77 100644
--- a/source/blender/editors/sculpt_paint/sculpt_uv.c
+++ b/source/blender/editors/sculpt_paint/sculpt_uv.c
@@ -205,7 +205,7 @@ void HC_relaxation_iteration_uv(BMEditMesh *em, UvSculptData *sculptdata, float
 		if ((dist = dot_v2v2(diff, diff)) <= radius) {
 			UvElement *element;
 			float strength;
-			strength = alpha * brush_curve_strength(brush, sqrt(dist), radius_root);
+			strength = alpha * BKE_brush_curve_strength(brush, sqrt(dist), radius_root);
 
 			sculptdata->uv[i].uv[0] = (1.0f - strength) * sculptdata->uv[i].uv[0] + strength * (tmp_uvdata[i].p[0] - 0.5f * (tmp_uvdata[i].b[0] + tmp_uvdata[i].sum_b[0] / tmp_uvdata[i].ncounter));
 			sculptdata->uv[i].uv[1] = (1.0f - strength) * sculptdata->uv[i].uv[1] + strength * (tmp_uvdata[i].p[1] - 0.5f * (tmp_uvdata[i].b[1] + tmp_uvdata[i].sum_b[1] / tmp_uvdata[i].ncounter));
@@ -269,7 +269,7 @@ static void laplacian_relaxation_iteration_uv(BMEditMesh *em, UvSculptData *scul
 		if ((dist = dot_v2v2(diff, diff)) <= radius) {
 			UvElement *element;
 			float strength;
-			strength = alpha * brush_curve_strength(brush, sqrt(dist), radius_root);
+			strength = alpha * BKE_brush_curve_strength(brush, sqrt(dist), radius_root);
 
 			sculptdata->uv[i].uv[0] = (1.0f - strength) * sculptdata->uv[i].uv[0] + strength * tmp_uvdata[i].p[0];
 			sculptdata->uv[i].uv[1] = (1.0f - strength) * sculptdata->uv[i].uv[1] + strength * tmp_uvdata[i].p[1];
@@ -311,14 +311,14 @@ static void uv_sculpt_stroke_apply(bContext *C, wmOperator *op, wmEvent *event,
 	ToolSettings *toolsettings = CTX_data_tool_settings(C);
 	tool = sculptdata->tool;
 	invert = sculptdata->invert ? -1 : 1;
-	alpha = brush_alpha(scene, brush);
+	alpha = BKE_brush_alpha_get(scene, brush);
 	UI_view2d_region_to_view(&ar->v2d, event->mval[0], event->mval[1], &co[0], &co[1]);
 
 	sima = CTX_wm_space_image(C);
 	ED_space_image_size(sima, &width, &height);
 	ED_space_image_zoom(sima, ar, &zoomx, &zoomy);
 
-	radius = brush_size(scene, brush) / (width * zoomx);
+	radius = BKE_brush_size_get(scene, brush) / (width * zoomx);
 	aspectRatio = width / (float)height;
 
 	/* We will compare squares to save some computation */
@@ -344,7 +344,7 @@ static void uv_sculpt_stroke_apply(bContext *C, wmOperator *op, wmEvent *event,
 			if ((dist = dot_v2v2(diff, diff)) <= radius) {
 				UvElement *element;
 				float strength;
-				strength = alpha * brush_curve_strength(brush, sqrt(dist), radius_root);
+				strength = alpha * BKE_brush_curve_strength(brush, sqrt(dist), radius_root);
 				normalize_v2(diff);
 
 				sculptdata->uv[i].uv[0] -= strength * diff[0] * 0.001f;
@@ -679,9 +679,9 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, wmEvent
 			float alpha, zoomx, zoomy;
 			Brush *brush = paint_brush(sculptdata->uvsculpt);
 
-			alpha = brush_alpha(scene, brush);
+			alpha = BKE_brush_alpha_get(scene, brush);
 
-			radius = brush_size(scene, brush);
+			radius = BKE_brush_size_get(scene, brush);
 			sima = CTX_wm_space_image(C);
 			ED_space_image_size(sima, &width, &height);
 			ED_space_image_zoom(sima, ar, &zoomx, &zoomy);
@@ -715,7 +715,7 @@ static UvSculptData *uv_sculpt_stroke_init(bContext *C, wmOperator *op, wmEvent
 				diff[1] /= aspectRatio;
 				if ((dist = dot_v2v2(diff, diff)) <= radius) {
 					float strength;
-					strength = alpha * brush_curve_strength(brush, sqrt(dist), radius_root);
+					strength = alpha * BKE_brush_curve_strength(brush, sqrt(dist), radius_root);
 
 					data->initial_stroke->initialSelection[counter].uv = i;
 					data->initial_stroke->initialSelection[counter].strength = strength;
diff --git a/source/blender/editors/space_image/image_draw.c b/source/blender/editors/space_image/image_draw.c
index 793e5712c8c..aab628180c8 100644
--- a/source/blender/editors/space_image/image_draw.c
+++ b/source/blender/editors/space_image/image_draw.c
@@ -606,7 +606,7 @@ static void draw_image_view_tool(Scene *scene)
 		if (draw) {
 			getmouseco_areawin(mval);
 
-			radius = brush_size(brush) * G.sima->zoom;
+			radius = BKE_brush_size_get(brush) * G.sima->zoom;
 			fdrawXORcirc(mval[0], mval[1], radius);
 
 			if (brush->innerradius != 1.0) {
diff --git a/source/blender/editors/space_view3d/drawobject.c b/source/blender/editors/space_view3d/drawobject.c
index c8754681e41..068a31a888f 100644
--- a/source/blender/editors/space_view3d/drawobject.c
+++ b/source/blender/editors/space_view3d/drawobject.c
@@ -1762,7 +1762,7 @@ static void drawcamera(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base
 	scale[1] = 1.0f / len_v3(ob->obmat[1]);
 	scale[2] = 1.0f / len_v3(ob->obmat[2]);
 
-	camera_view_frame_ex(scene, cam, cam->drawsize, is_view, scale,
+	BKE_camera_view_frame_ex(scene, cam, cam->drawsize, is_view, scale,
 	                     asp, shift, &drawsize, vec);
 
 	glDisable(GL_LIGHTING);
@@ -1834,7 +1834,7 @@ static void drawcamera(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base
 			if (cam->flag & CAM_SHOWLIMITS) {
 				draw_limit_line(cam->clipsta, cam->clipend, 0x77FFFF);
 				/* qdn: was yafray only, now also enabled for Blender to be used with defocus composite node */
-				draw_focus_cross(object_camera_dof_distance(ob), cam->drawsize);
+				draw_focus_cross(BKE_camera_object_dof_distance(ob), cam->drawsize);
 			}
 
 			wrld = scene->world;
diff --git a/source/blender/editors/space_view3d/view3d_draw.c b/source/blender/editors/space_view3d/view3d_draw.c
index e1828bbef32..f48b45f9793 100644
--- a/source/blender/editors/space_view3d/view3d_draw.c
+++ b/source/blender/editors/space_view3d/view3d_draw.c
@@ -939,21 +939,21 @@ static void view3d_camera_border(Scene *scene, ARegion *ar, View3D *v3d, RegionV
 	rctf rect_view, rect_camera;
 
 	/* get viewport viewplane */
-	camera_params_init(&params);
-	camera_params_from_view3d(&params, v3d, rv3d);
+	BKE_camera_params_init(&params);
+	BKE_camera_params_from_view3d(&params, v3d, rv3d);
 	if (no_zoom)
 		params.zoom = 1.0f;
-	camera_params_compute_viewplane(&params, ar->winx, ar->winy, 1.0f, 1.0f);
+	BKE_camera_params_compute_viewplane(&params, ar->winx, ar->winy, 1.0f, 1.0f);
 	rect_view = params.viewplane;
 
 	/* get camera viewplane */
-	camera_params_init(&params);
-	camera_params_from_object(&params, v3d->camera);
+	BKE_camera_params_init(&params);
+	BKE_camera_params_from_object(&params, v3d->camera);
 	if (no_shift) {
 		params.shiftx = 0.0f;
 		params.shifty = 0.0f;
 	}
-	camera_params_compute_viewplane(&params, scene->r.xsch, scene->r.ysch, scene->r.xasp, scene->r.yasp);
+	BKE_camera_params_compute_viewplane(&params, scene->r.xsch, scene->r.ysch, scene->r.xasp, scene->r.yasp);
 	rect_camera = params.viewplane;
 
 	/* get camera border within viewport */
@@ -1226,7 +1226,7 @@ static void drawviewborder(Scene *scene, ARegion *ar, View3D *v3d)
 			 * assume and square sensor and only use sensor_x */
 			float sizex = scene->r.xsch * scene->r.xasp;
 			float sizey = scene->r.ysch * scene->r.yasp;
-			int sensor_fit = camera_sensor_fit(ca->sensor_fit, sizex, sizey);
+			int sensor_fit = BKE_camera_sensor_fit(ca->sensor_fit, sizex, sizey);
 			float sensor_x = ca->sensor_x;
 			float sensor_y = (ca->sensor_fit == CAMERA_SENSOR_FIT_AUTO) ? ca->sensor_x : ca->sensor_y;
 
@@ -2612,10 +2612,10 @@ ImBuf *ED_view3d_draw_offscreen_imbuf(Scene *scene, View3D *v3d, ARegion *ar,
 	if (rv3d->persp == RV3D_CAMOB && v3d->camera) {
 		CameraParams params;
 
-		camera_params_init(&params);
-		camera_params_from_object(&params, v3d->camera);
-		camera_params_compute_viewplane(&params, sizex, sizey, scene->r.xasp, scene->r.yasp);
-		camera_params_compute_matrix(&params);
+		BKE_camera_params_init(&params);
+		BKE_camera_params_from_object(&params, v3d->camera);
+		BKE_camera_params_compute_viewplane(&params, sizex, sizey, scene->r.xasp, scene->r.yasp);
+		BKE_camera_params_compute_matrix(&params);
 
 		ED_view3d_draw_offscreen(scene, v3d, ar, sizex, sizey, NULL, params.winmat, draw_background);
 	}
@@ -2673,10 +2673,10 @@ ImBuf *ED_view3d_draw_offscreen_imbuf_simple(Scene *scene, Object *camera, int w
 	{
 		CameraParams params;
 
-		camera_params_init(&params);
-		camera_params_from_object(&params, v3d.camera);
-		camera_params_compute_viewplane(&params, width, height, scene->r.xasp, scene->r.yasp);
-		camera_params_compute_matrix(&params);
+		BKE_camera_params_init(&params);
+		BKE_camera_params_from_object(&params, v3d.camera);
+		BKE_camera_params_compute_viewplane(&params, width, height, scene->r.xasp, scene->r.yasp);
+		BKE_camera_params_compute_matrix(&params);
 
 		copy_m4_m4(rv3d.winmat, params.winmat);
 		v3d.near = params.clipsta;
diff --git a/source/blender/editors/space_view3d/view3d_edit.c b/source/blender/editors/space_view3d/view3d_edit.c
index 39cda3efd93..ea4d28ce32f 100644
--- a/source/blender/editors/space_view3d/view3d_edit.c
+++ b/source/blender/editors/space_view3d/view3d_edit.c
@@ -3660,8 +3660,8 @@ void ED_view3d_from_object(Object *ob, float ofs[3], float quat[4], float *dist,
 	if (lens) {
 		CameraParams params;
 
-		camera_params_init(&params);
-		camera_params_from_object(&params, ob);
+		BKE_camera_params_init(&params);
+		BKE_camera_params_from_object(&params, ob);
 		*lens = params.lens;
 	}
 }
diff --git a/source/blender/editors/space_view3d/view3d_view.c b/source/blender/editors/space_view3d/view3d_view.c
index 8a0cb4b597b..733c5c55bfc 100644
--- a/source/blender/editors/space_view3d/view3d_view.c
+++ b/source/blender/editors/space_view3d/view3d_view.c
@@ -412,7 +412,7 @@ static int view3d_camera_to_view_selected_exec(bContext *C, wmOperator *UNUSED(o
 	float r_co[3]; /* the new location to apply */
 
 	/* this function does all the important stuff */
-	if (camera_view_frame_fit_to_scene(scene, v3d, camera_ob, r_co)) {
+	if (BKE_camera_view_frame_fit_to_scene(scene, v3d, camera_ob, r_co)) {
 
 		ObjectTfmProtectedChannels obtfm;
 		float obmat_new[4][4];
@@ -1000,8 +1000,8 @@ int ED_view3d_clip_range_get(View3D *v3d, RegionView3D *rv3d, float *clipsta, fl
 {
 	CameraParams params;
 
-	camera_params_init(&params);
-	camera_params_from_view3d(&params, v3d, rv3d);
+	BKE_camera_params_init(&params);
+	BKE_camera_params_from_view3d(&params, v3d, rv3d);
 
 	if (clipsta) *clipsta = params.clipsta;
 	if (clipend) *clipend = params.clipend;
@@ -1015,9 +1015,9 @@ int ED_view3d_viewplane_get(View3D *v3d, RegionView3D *rv3d, int winx, int winy,
 {
 	CameraParams params;
 
-	camera_params_init(&params);
-	camera_params_from_view3d(&params, v3d, rv3d);
-	camera_params_compute_viewplane(&params, winx, winy, 1.0f, 1.0f);
+	BKE_camera_params_init(&params);
+	BKE_camera_params_from_view3d(&params, v3d, rv3d);
+	BKE_camera_params_compute_viewplane(&params, winx, winy, 1.0f, 1.0f);
 
 	if (viewplane) *viewplane = params.viewplane;
 	if (clipsta) *clipsta = params.clipsta;
diff --git a/source/blender/makesrna/intern/rna_brush.c b/source/blender/makesrna/intern/rna_brush.c
index bdff545df5c..ee4b34508d1 100644
--- a/source/blender/makesrna/intern/rna_brush.c
+++ b/source/blender/makesrna/intern/rna_brush.c
@@ -288,7 +288,7 @@ static void rna_Brush_set_size(PointerRNA *ptr, int value)
 	Brush* brush = ptr->data;
 
 	/* scale unprojected radius so it stays consistent with brush size */
-	brush_scale_unprojected_radius(&brush->unprojected_radius,
+	BKE_brush_scale_unprojected_radius(&brush->unprojected_radius,
 								   value, brush->size);
 	brush->size = value;
 }
@@ -298,7 +298,7 @@ static void rna_Brush_set_unprojected_radius(PointerRNA *ptr, float value)
 	Brush* brush = ptr->data;
 
 	/* scale brush size so it stays consistent with unprojected_radius */
-	brush_scale_size(&brush->size, value, brush->unprojected_radius);
+	BKE_brush_scale_size(&brush->size, value, brush->unprojected_radius);
 	brush->unprojected_radius = value;
 }
 
diff --git a/source/blender/makesrna/intern/rna_camera.c b/source/blender/makesrna/intern/rna_camera.c
index 5331cfe8775..70a33734c3f 100644
--- a/source/blender/makesrna/intern/rna_camera.c
+++ b/source/blender/makesrna/intern/rna_camera.c
@@ -46,14 +46,14 @@
 static float rna_Camera_angle_get(PointerRNA *ptr)
 {
 	Camera *cam = ptr->id.data;
-	float sensor = camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
+	float sensor = BKE_camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
 	return focallength_to_fov(cam->lens, sensor);
 }
 
 static void rna_Camera_angle_set(PointerRNA *ptr, float value)
 {
 	Camera *cam = ptr->id.data;
-	float sensor = camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
+	float sensor = BKE_camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
 	cam->lens = fov_to_focallength(value, sensor);
 }
 
diff --git a/source/blender/makesrna/intern/rna_camera_api.c b/source/blender/makesrna/intern/rna_camera_api.c
index 14391e74239..2d19047ef89 100644
--- a/source/blender/makesrna/intern/rna_camera_api.c
+++ b/source/blender/makesrna/intern/rna_camera_api.c
@@ -46,7 +46,7 @@ void rna_camera_view_frame(struct Camera *camera, struct Scene *scene,
 {
 	float vec[4][3];
 
-	camera_view_frame(scene, camera, vec);
+	BKE_camera_view_frame(scene, camera, vec);
 
 	copy_v3_v3(vec1_r, vec[0]);
 	copy_v3_v3(vec2_r, vec[1]);
diff --git a/source/blender/makesrna/intern/rna_main_api.c b/source/blender/makesrna/intern/rna_main_api.c
index 63006af7c72..f00126986a5 100644
--- a/source/blender/makesrna/intern/rna_main_api.c
+++ b/source/blender/makesrna/intern/rna_main_api.c
@@ -92,7 +92,7 @@
 
 Camera *rna_Main_cameras_new(Main *UNUSED(bmain), const char *name)
 {
-	ID *id = add_camera(name);
+	ID *id = BKE_camera_add(name);
 	id_us_min(id);
 	return (Camera *)id;
 }
@@ -385,7 +385,7 @@ void rna_Main_textures_remove(Main *bmain, ReportList *reports, struct Tex *tex)
 
 Brush *rna_Main_brushes_new(Main *UNUSED(bmain), const char *name)
 {
-	Brush *brush = add_brush(name);
+	Brush *brush = BKE_brush_add(name);
 	id_us_min(&brush->id);
 	return brush;
 }
diff --git a/source/blender/makesrna/intern/rna_scene.c b/source/blender/makesrna/intern/rna_scene.c
index eb3c1c75cf4..d9f5ca1f9ed 100644
--- a/source/blender/makesrna/intern/rna_scene.c
+++ b/source/blender/makesrna/intern/rna_scene.c
@@ -1370,7 +1370,7 @@ static void rna_UnifiedPaintSettings_size_set(PointerRNA *ptr, int value)
 	UnifiedPaintSettings* ups = ptr->data;
 
 	/* scale unprojected radius so it stays consistent with brush size */
-	brush_scale_unprojected_radius(&ups->unprojected_radius,
+	BKE_brush_scale_unprojected_radius(&ups->unprojected_radius,
 								   value, ups->size);
 	ups->size = value;
 }
@@ -1380,7 +1380,7 @@ static void rna_UnifiedPaintSettings_unprojected_radius_set(PointerRNA *ptr, flo
 	UnifiedPaintSettings* ups = ptr->data;
 
 	/* scale brush size so it stays consistent with unprojected_radius */
-	brush_scale_size(&ups->size, value, ups->unprojected_radius);
+	BKE_brush_scale_size(&ups->size, value, ups->unprojected_radius);
 	ups->unprojected_radius = value;
 }
 
diff --git a/source/blender/modifiers/intern/MOD_uvproject.c b/source/blender/modifiers/intern/MOD_uvproject.c
index 4f8fd83491f..ef8cf24987c 100644
--- a/source/blender/modifiers/intern/MOD_uvproject.c
+++ b/source/blender/modifiers/intern/MOD_uvproject.c
@@ -199,8 +199,8 @@ static DerivedMesh *uvprojectModifier_do(UVProjectModifierData *umd,
 				free_uci= 1;
 			}
 			else {
-				float sensor= camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
-				int sensor_fit= camera_sensor_fit(cam->sensor_fit, aspx, aspy);
+				float sensor= BKE_camera_sensor_size(cam->sensor_fit, cam->sensor_x, cam->sensor_y);
+				int sensor_fit= BKE_camera_sensor_fit(cam->sensor_fit, aspx, aspy);
 				float scale= (cam->type == CAM_PERSP) ? cam->clipsta * sensor / cam->lens : cam->ortho_scale;
 				float xmax, xmin, ymax, ymin;
 
diff --git a/source/blender/nodes/composite/nodes/node_composite_defocus.c b/source/blender/nodes/composite/nodes/node_composite_defocus.c
index fc6e6847f34..72dec01066e 100644
--- a/source/blender/nodes/composite/nodes/node_composite_defocus.c
+++ b/source/blender/nodes/composite/nodes/node_composite_defocus.c
@@ -261,7 +261,7 @@ static void defocus_blur(bNode *node, CompBuf *new, CompBuf *img, CompBuf *zbuf,
 	if (camob && camob->type==OB_CAMERA) {
 		Camera* cam = (Camera*)camob->data;
 		cam_lens = cam->lens;
-		cam_fdist = object_camera_dof_distance(camob);
+		cam_fdist = BKE_camera_object_dof_distance(camob);
 		if (cam_fdist==0.0f) cam_fdist = 1e10f; /* if the dof is 0.0 then set it be be far away */
 		cam_invfdist = 1.f/cam_fdist;
 	}
diff --git a/source/blender/render/intern/source/initrender.c b/source/blender/render/intern/source/initrender.c
index 56aadfd63d0..e712950f4f8 100644
--- a/source/blender/render/intern/source/initrender.c
+++ b/source/blender/render/intern/source/initrender.c
@@ -463,7 +463,7 @@ static void re_camera_params_get(Render *re, CameraParams *params, Object *cam_o
 	re->viewdy= params->viewdy;
 	re->viewplane= params->viewplane;
 
-	object_camera_mode(&re->r, cam_ob);
+	BKE_camera_object_mode(&re->r, cam_ob);
 }
 
 void RE_SetEnvmapCamera(Render *re, Object *cam_ob, float viewscale, float clipsta, float clipend)
@@ -471,8 +471,8 @@ void RE_SetEnvmapCamera(Render *re, Object *cam_ob, float viewscale, float clips
 	CameraParams params;
 
 	/* setup parameters */
-	camera_params_init(&params);
-	camera_params_from_object(&params, cam_ob);
+	BKE_camera_params_init(&params);
+	BKE_camera_params_from_object(&params, cam_ob);
 
 	params.lens= 16.0f*viewscale;
 	params.sensor_x= 32.0f;
@@ -482,8 +482,8 @@ void RE_SetEnvmapCamera(Render *re, Object *cam_ob, float viewscale, float clips
 	params.clipend= clipend;
 	
 	/* compute matrix, viewplane, .. */
-	camera_params_compute_viewplane(&params, re->winx, re->winy, 1.0f, 1.0f);
-	camera_params_compute_matrix(&params);
+	BKE_camera_params_compute_viewplane(&params, re->winx, re->winy, 1.0f, 1.0f);
+	BKE_camera_params_compute_matrix(&params);
 
 	/* extract results */
 	re_camera_params_get(re, &params, cam_ob);
@@ -496,16 +496,16 @@ void RE_SetCamera(Render *re, Object *cam_ob)
 	CameraParams params;
 
 	/* setup parameters */
-	camera_params_init(&params);
-	camera_params_from_object(&params, cam_ob);
+	BKE_camera_params_init(&params);
+	BKE_camera_params_from_object(&params, cam_ob);
 
 	params.use_fields= (re->r.mode & R_FIELDS);
 	params.field_second= (re->flag & R_SEC_FIELD);
 	params.field_odd= (re->r.mode & R_ODDFIELD);
 
 	/* compute matrix, viewplane, .. */
-	camera_params_compute_viewplane(&params, re->winx, re->winy, re->r.xasp, re->r.yasp);
-	camera_params_compute_matrix(&params);
+	BKE_camera_params_compute_viewplane(&params, re->winx, re->winy, re->r.xasp, re->r.yasp);
+	BKE_camera_params_compute_matrix(&params);
 
 	/* extract results */
 	re_camera_params_get(re, &params, cam_ob);
diff --git a/source/blender/render/intern/source/pipeline.c b/source/blender/render/intern/source/pipeline.c
index 9ca2337e27f..f0fea072530 100644
--- a/source/blender/render/intern/source/pipeline.c
+++ b/source/blender/render/intern/source/pipeline.c
@@ -1872,7 +1872,7 @@ int RE_is_rendering_allowed(Scene *scene, Object *camera_override, ReportList *r
 	}
 	
 	/* get panorama & ortho, only after camera is set */
-	object_camera_mode(&scene->r, camera_override ? camera_override : scene->camera);
+	BKE_camera_object_mode(&scene->r, camera_override ? camera_override : scene->camera);
 
 	/* forbidden combinations */
 	if (scene->r.mode & R_PANORAMA) {
diff --git a/source/blender/render/intern/source/volume_precache.c b/source/blender/render/intern/source/volume_precache.c
index e7c97574629..ff715eeca07 100644
--- a/source/blender/render/intern/source/volume_precache.c
+++ b/source/blender/render/intern/source/volume_precache.c
@@ -177,7 +177,7 @@ static float get_avg_surrounds(float *cache, int *res, int xx, int yy, int zz)
 					for (x=-1; x <= 1; x++) {
 						x_ = xx+x;
 						if (x_ >= 0 && x_ <= res[0]-1) {
-							const int i= BLI_VEXEL_INDEX(x_, y_, z_, res);
+							const int i = BLI_VOXEL_INDEX(x_, y_, z_, res);
 							
 							if (cache[i] > 0.0f) {
 								tot += cache[i];
@@ -208,7 +208,7 @@ static void lightcache_filter(VolumePrecache *vp)
 		for (y=0; y < vp->res[1]; y++) {
 			for (x=0; x < vp->res[0]; x++) {
 				/* trigger for outside mesh */
-				const int i= BLI_VEXEL_INDEX(x, y, z, vp->res);
+				const int i = BLI_VOXEL_INDEX(x, y, z, vp->res);
 				
 				if (vp->data_r[i] < -0.f)
 					vp->data_r[i] = get_avg_surrounds(vp->data_r, vp->res, x, y, z);
@@ -240,7 +240,7 @@ static void lightcache_filter2(VolumePrecache *vp)
 		for (y=0; y < vp->res[1]; y++) {
 			for (x=0; x < vp->res[0]; x++) {
 				/* trigger for outside mesh */
-				const int i= BLI_VEXEL_INDEX(x, y, z, vp->res);
+				const int i = BLI_VOXEL_INDEX(x, y, z, vp->res);
 				if (vp->data_r[i] < -0.f)
 					new_r[i] = get_avg_surrounds(vp->data_r, vp->res, x, y, z);
 				if (vp->data_g[i] < -0.f)
@@ -291,7 +291,7 @@ static float total_ss_energy(Render *re, int do_test_break, VolumePrecache *vp)
 	for (z=0; z < res[2]; z++) {
 		for (y=0; y < res[1]; y++) {
 			for (x=0; x < res[0]; x++) {
-				const int i=BLI_VEXEL_INDEX(x, y, z, res);
+				const int i = BLI_VOXEL_INDEX(x, y, z, res);
 			
 				if (vp->data_r[i] > 0.f) energy += vp->data_r[i];
 				if (vp->data_g[i] > 0.f) energy += vp->data_g[i];
@@ -527,7 +527,7 @@ static void *vol_precache_part(void *data)
 					/* convert from world->camera space for shading */
 					mul_v3_m4v3(cco, pa->viewmat, co);
 					
-					i= BLI_VEXEL_INDEX(x, y, z, res);
+					i = BLI_VOXEL_INDEX(x, y, z, res);
 					
 					// don't bother if the point is not inside the volume mesh
 					if (!point_inside_obi(tree, obi, cco)) {
diff --git a/source/blender/render/intern/source/voxeldata.c b/source/blender/render/intern/source/voxeldata.c
index 5135061bc5c..90e6594d888 100644
--- a/source/blender/render/intern/source/voxeldata.c
+++ b/source/blender/render/intern/source/voxeldata.c
@@ -184,7 +184,7 @@ static void load_frame_image_sequence(VoxelData *vd, Tex *tex)
 		for (y=0; y < ibuf->y; y++) {
 			for (x=0; x < ibuf->x; x++) {
 				/* currently averaged to monchrome */
-				vd->dataset[ BLI_VEXEL_INDEX(x, y, z, vd->resol) ] = (rf[0] + rf[1] + rf[2]) * 0.333f;
+				vd->dataset[ BLI_VOXEL_INDEX(x, y, z, vd->resol) ] = (rf[0] + rf[1] + rf[2]) * 0.333f;
 				rf +=4;
 			}
 		}
diff --git a/source/blender/windowmanager/intern/wm_operators.c b/source/blender/windowmanager/intern/wm_operators.c
index cc4cf030988..db0429d33ab 100644
--- a/source/blender/windowmanager/intern/wm_operators.c
+++ b/source/blender/windowmanager/intern/wm_operators.c
@@ -2987,7 +2987,7 @@ static void radial_control_set_tex(RadialControl *rc)
 
 	switch (RNA_type_to_ID_code(rc->image_id_ptr.type)) {
 		case ID_BR:
-			if ((ibuf = brush_gen_radial_control_imbuf(rc->image_id_ptr.data))) {
+			if ((ibuf = BKE_brush_gen_radial_control_imbuf(rc->image_id_ptr.data))) {
 				glGenTextures(1, &rc->gltex);
 				glBindTexture(GL_TEXTURE_2D, rc->gltex);
 				glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, ibuf->x, ibuf->y, 0,