code cleanup: brush/camera naming

16 files changed, 127 insertions, 127 deletions

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;