Code cleanup: use r_ prefix for return args

17 files changed, 146 insertions, 147 deletions

diff --git a/source/blender/blenkernel/BKE_DerivedMesh.h b/source/blender/blenkernel/BKE_DerivedMesh.h
index 353b1c5d597..ff1c04fd00d 100644
--- a/source/blender/blenkernel/BKE_DerivedMesh.h
+++ b/source/blender/blenkernel/BKE_DerivedMesh.h
@@ -208,9 +208,9 @@ struct DerivedMesh {
 	 * of this function can be quite slow, iterating over all
 	 * elements (editmesh)
 	 */
-	void (*getVert)(DerivedMesh *dm, int index, struct MVert *vert_r);
-	void (*getEdge)(DerivedMesh *dm, int index, struct MEdge *edge_r);
-	void (*getTessFace)(DerivedMesh *dm, int index, struct MFace *face_r);
+	void (*getVert)(DerivedMesh *dm, int index, struct MVert *r_vert);
+	void (*getEdge)(DerivedMesh *dm, int index, struct MEdge *r_edge);
+	void (*getTessFace)(DerivedMesh *dm, int index, struct MFace *r_face);
 
 	/** Return a pointer to the entire array of verts/edges/face from the
 	 * derived mesh. if such an array does not exist yet, it will be created,
@@ -226,11 +226,11 @@ struct DerivedMesh {
 	/** Copy all verts/edges/faces from the derived mesh into
 	 * *{vert/edge/face}_r (must point to a buffer large enough)
 	 */
-	void (*copyVertArray)(DerivedMesh *dm, struct MVert *vert_r);
-	void (*copyEdgeArray)(DerivedMesh *dm, struct MEdge *edge_r);
-	void (*copyTessFaceArray)(DerivedMesh *dm, struct MFace *face_r);
-	void (*copyLoopArray)(DerivedMesh *dm, struct MLoop *loop_r);
-	void (*copyPolyArray)(DerivedMesh *dm, struct MPoly *poly_r);
+	void (*copyVertArray)(DerivedMesh *dm, struct MVert *r_vert);
+	void (*copyEdgeArray)(DerivedMesh *dm, struct MEdge *r_edge);
+	void (*copyTessFaceArray)(DerivedMesh *dm, struct MFace *r_face);
+	void (*copyLoopArray)(DerivedMesh *dm, struct MLoop *r_loop);
+	void (*copyPolyArray)(DerivedMesh *dm, struct MPoly *r_poly);
 
 	/** Return a copy of all verts/edges/faces from the derived mesh
 	 * it is the caller's responsibility to free the returned pointer
@@ -318,21 +318,21 @@ struct DerivedMesh {
 	 *
 	 * Also called in Editmode
 	 */
-	void (*getMinMax)(DerivedMesh *dm, float min_r[3], float max_r[3]);
+	void (*getMinMax)(DerivedMesh *dm, float r_min[3], float r_max[3]);
 
 	/** Direct Access Operations
 	 * - Can be undefined
 	 * - Must be defined for modifiers that only deform however */
 
 	/** Get vertex location, undefined if index is not valid */
-	void (*getVertCo)(DerivedMesh *dm, int index, float co_r[3]);
+	void (*getVertCo)(DerivedMesh *dm, int index, float r_co[3]);
 
 	/** Fill the array (of length .getNumVerts()) with all vertex locations */
-	void (*getVertCos)(DerivedMesh *dm, float (*cos_r)[3]);
+	void (*getVertCos)(DerivedMesh *dm, float (*r_cos)[3]);
 
 	/** Get smooth vertex normal, undefined if index is not valid */
-	void (*getVertNo)(DerivedMesh *dm, int index, float no_r[3]);
-	void (*getPolyNo)(DerivedMesh *dm, int index, float no_r[3]);
+	void (*getVertNo)(DerivedMesh *dm, int index, float r_no[3]);
+	void (*getPolyNo)(DerivedMesh *dm, int index, float r_no[3]);
 
 	/** Get a map of vertices to faces
 	 */
@@ -385,7 +385,7 @@ struct DerivedMesh {
 
 	/** Draw mapped faces (no color, or texture)
 	 * - Only if !setDrawOptions or
-	 *   setDrawOptions(userData, mapped-face-index, drawSmooth_r)
+	 *   setDrawOptions(userData, mapped-face-index, r_drawSmooth)
 	 *   returns true
 	 *
 	 * If drawSmooth is set to true then vertex normals should be set and
@@ -670,9 +670,9 @@ DerivedMesh *editbmesh_get_derived_base(struct Object *, struct BMEditMesh *em);
 DerivedMesh *editbmesh_get_derived_cage(struct Scene *scene, struct Object *, 
                                         struct BMEditMesh *em, CustomDataMask dataMask);
 DerivedMesh *editbmesh_get_derived_cage_and_final(struct Scene *scene, struct Object *, 
-                                                  struct BMEditMesh *em, DerivedMesh **final_r,
+                                                  struct BMEditMesh *em, DerivedMesh **r_final,
                                                   CustomDataMask dataMask);
-float (*editbmesh_get_vertex_cos(struct BMEditMesh *em, int *numVerts_r))[3];
+float (*editbmesh_get_vertex_cos(struct BMEditMesh *em, int *r_numVerts))[3];
 bool editbmesh_modifier_is_enabled(struct Scene *scene, struct ModifierData *md, DerivedMesh *dm);
 void makeDerivedMesh(struct Scene *scene, struct Object *ob, struct BMEditMesh *em, 
                      CustomDataMask dataMask, int build_shapekey_layers);
diff --git a/source/blender/blenkernel/BKE_curve.h b/source/blender/blenkernel/BKE_curve.h
index 4b8c557f0dd..1ea2cb06bc0 100644
--- a/source/blender/blenkernel/BKE_curve.h
+++ b/source/blender/blenkernel/BKE_curve.h
@@ -97,7 +97,7 @@ void         BKE_curve_nurb_vert_active_set(struct Curve *cu, struct Nurb *nu,
 bool         BKE_curve_nurb_vert_active_get(struct Curve *cu, struct Nurb **r_nu, void **r_vert);
 void         BKE_curve_nurb_vert_active_validate(struct Curve *cu);
 
-float (*BKE_curve_nurbs_vertexCos_get(struct ListBase *lb, int *numVerts_r))[3];
+float (*BKE_curve_nurbs_vertexCos_get(struct ListBase *lb, int *r_numVerts))[3];
 void BK_curve_nurbs_vertexCos_apply(struct ListBase *lb, float (*vertexCos)[3]);
 
 float (*BKE_curve_nurbs_keyVertexCos_get(struct ListBase *lb, float *key))[3];
diff --git a/source/blender/blenkernel/BKE_lattice.h b/source/blender/blenkernel/BKE_lattice.h
index fc84ef1f0bd..8d8d3702634 100644
--- a/source/blender/blenkernel/BKE_lattice.h
+++ b/source/blender/blenkernel/BKE_lattice.h
@@ -73,7 +73,7 @@ void armature_deform_verts(struct Object *armOb, struct Object *target,
                            float (*defMats)[3][3], int numVerts, int deformflag,
                            float (*prevCos)[3], const char *defgrp_name);
 
-float (*BKE_lattice_vertexcos_get(struct Object *ob, int *numVerts_r))[3];
+float (*BKE_lattice_vertexcos_get(struct Object *ob, int *r_numVerts))[3];
 void    BKE_lattice_vertexcos_apply(struct Object *ob, float (*vertexCos)[3]);
 void    BKE_lattice_modifiers_calc(struct Scene *scene, struct Object *ob);
 
diff --git a/source/blender/blenkernel/BKE_mesh.h b/source/blender/blenkernel/BKE_mesh.h
index 7b1f39ab643..25fd95176b2 100644
--- a/source/blender/blenkernel/BKE_mesh.h
+++ b/source/blender/blenkernel/BKE_mesh.h
@@ -79,7 +79,7 @@ int poly_find_loop_from_vert(const struct MPoly *poly,
                              const struct MLoop *loopstart,
                              unsigned vert);
 
-int poly_get_adj_loops_from_vert(unsigned adj_r[3], const struct MPoly *poly,
+int poly_get_adj_loops_from_vert(unsigned r_adj[3], const struct MPoly *poly,
                                  const struct MLoop *mloop, unsigned vert);
 
 int BKE_mesh_edge_other_vert(const struct MEdge *e, int v);
@@ -152,23 +152,23 @@ void BKE_mesh_mselect_active_set(struct Mesh *me, int index, int type);
 
 void BKE_mesh_calc_normals_mapping(
         struct MVert *mverts, int numVerts,
-        struct MLoop *mloop, struct MPoly *mpolys, int numLoops, int numPolys, float (*polyNors_r)[3],
-        struct MFace *mfaces, int numFaces, int *origIndexFace, float (*faceNors_r)[3]);
+        struct MLoop *mloop, struct MPoly *mpolys, int numLoops, int numPolys, float (*r_polyNors)[3],
+        struct MFace *mfaces, int numFaces, const int *origIndexFace, float (*r_faceNors)[3]);
 void BKE_mesh_calc_normals_mapping_ex(
         struct MVert *mverts, int numVerts,
-        struct MLoop *mloop, struct MPoly *mpolys, int numLoops, int numPolys, float (*polyNors_r)[3],
-        struct MFace *mfaces, int numFaces, int *origIndexFace, float (*faceNors_r)[3],
+        struct MLoop *mloop, struct MPoly *mpolys, int numLoops, int numPolys, float (*r_polyNors)[3],
+        struct MFace *mfaces, int numFaces, const int *origIndexFace, float (*r_faceNors)[3],
         const bool only_face_normals);
 void BKE_mesh_calc_normals_poly(
         struct MVert *mverts, int numVerts,
         struct MLoop *mloop, struct MPoly *mpolys,
-        int numLoops, int numPolys, float (*polyNors_r)[3],
+        int numLoops, int numPolys, float (*r_polyNors)[3],
         const bool only_face_normals);
 void BKE_mesh_calc_normals(struct Mesh *me);
 void BKE_mesh_calc_normals_tessface(
         struct MVert *mverts, int numVerts,
         struct MFace *mfaces, int numFaces,
-        float (*faceNors_r)[3]);
+        float (*r_faceNors)[3]);
 void BKE_mesh_normals_loop_split(
         struct MVert *mverts, const int numVerts, struct MEdge *medges, const int numEdges,
         struct MLoop *mloops, float (*r_loopnors)[3], const int numLoops,
@@ -233,8 +233,8 @@ void BKE_mesh_convert_mfaces_to_mpolys_ex(
         struct CustomData *fdata, struct CustomData *ldata, struct CustomData *pdata,
         int totedge_i, int totface_i, int totloop_i, int totpoly_i,
         struct MEdge *medge, struct MFace *mface,
-        int *totloop_r, int *totpoly_r,
-        struct MLoop **mloop_r, struct MPoly **mpoly_r);
+        int *r_totloop, int *r_totpoly,
+        struct MLoop **r_mloop, struct MPoly **r_mpoly);
 
 /* flush flags */
 void BKE_mesh_flush_hidden_from_verts_ex(
diff --git a/source/blender/blenkernel/BKE_modifier.h b/source/blender/blenkernel/BKE_modifier.h
index 25dee613d20..2d47cf307f7 100644
--- a/source/blender/blenkernel/BKE_modifier.h
+++ b/source/blender/blenkernel/BKE_modifier.h
@@ -345,7 +345,7 @@ struct ModifierData  *modifiers_findByType(struct Object *ob, ModifierType type)
 struct ModifierData  *modifiers_findByName(struct Object *ob, const char *name);
 void          modifiers_clearErrors(struct Object *ob);
 int           modifiers_getCageIndex(struct Scene *scene, struct Object *ob,
-                                     int *lastPossibleCageIndex_r, int virtual_);
+                                     int *r_lastPossibleCageIndex, bool is_virtual);
 
 bool          modifiers_isModifierEnabled(struct Object *ob, int modifierType);
 bool          modifiers_isSoftbodyEnabled(struct Object *ob);
diff --git a/source/blender/blenkernel/BKE_subsurf.h b/source/blender/blenkernel/BKE_subsurf.h
index ab8b8b29915..3dae4087866 100644
--- a/source/blender/blenkernel/BKE_subsurf.h
+++ b/source/blender/blenkernel/BKE_subsurf.h
@@ -69,7 +69,7 @@ struct DerivedMesh *subsurf_make_derived_from_derived(
         float (*vertCos)[3],
         SubsurfFlags flags);
 
-void subsurf_calculate_limit_positions(struct Mesh *me, float (*positions_r)[3]);
+void subsurf_calculate_limit_positions(struct Mesh *me, float (*r_positions)[3]);
 
 /* get gridsize from 'level', level must be greater than zero */
 int BKE_ccg_gridsize(int level);
diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index 4223e903113..b4a2dab8b1e 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -1919,14 +1919,14 @@ static void mesh_calc_modifiers(Scene *scene, Object *ob, float (*inputVertexCos
 	BLI_linklist_free((LinkNode *)datamasks, NULL);
 }
 
-float (*editbmesh_get_vertex_cos(BMEditMesh *em, int *numVerts_r))[3]
+float (*editbmesh_get_vertex_cos(BMEditMesh *em, int *r_numVerts))[3]
 {
 	BMIter iter;
 	BMVert *eve;
 	float (*cos)[3];
 	int i;
 
-	*numVerts_r = em->bm->totvert;
+	*r_numVerts = em->bm->totvert;
 
 	cos = MEM_mallocN(sizeof(float) * 3 * em->bm->totvert, "vertexcos");
 
@@ -2415,7 +2415,7 @@ DerivedMesh *mesh_create_derived_no_deform_render(Scene *scene, Object *ob,
 
 /***/
 
-DerivedMesh *editbmesh_get_derived_cage_and_final(Scene *scene, Object *obedit, BMEditMesh *em, DerivedMesh **final_r,
+DerivedMesh *editbmesh_get_derived_cage_and_final(Scene *scene, Object *obedit, BMEditMesh *em, DerivedMesh **r_final,
                                                   CustomDataMask dataMask)
 {
 	/* if there's no derived mesh or the last data mask used doesn't include
@@ -2429,7 +2429,7 @@ DerivedMesh *editbmesh_get_derived_cage_and_final(Scene *scene, Object *obedit,
 		editbmesh_build_data(scene, obedit, em, dataMask);
 	}
 
-	*final_r = em->derivedFinal;
+	*r_final = em->derivedFinal;
 	if (em->derivedFinal) { BLI_assert(!(em->derivedFinal->dirty & DM_DIRTY_NORMALS)); }
 	return em->derivedCage;
 }
diff --git a/source/blender/blenkernel/intern/cdderivedmesh.c b/source/blender/blenkernel/intern/cdderivedmesh.c
index b40e04d29d3..a7940eb8f9c 100644
--- a/source/blender/blenkernel/intern/cdderivedmesh.c
+++ b/source/blender/blenkernel/intern/cdderivedmesh.c
@@ -122,90 +122,90 @@ static int cdDM_getNumPolys(DerivedMesh *dm)
 	return dm->numPolyData;
 }
 
-static void cdDM_getVert(DerivedMesh *dm, int index, MVert *vert_r)
+static void cdDM_getVert(DerivedMesh *dm, int index, MVert *r_vert)
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-	*vert_r = cddm->mvert[index];
+	*r_vert = cddm->mvert[index];
 }
 
-static void cdDM_getEdge(DerivedMesh *dm, int index, MEdge *edge_r)
+static void cdDM_getEdge(DerivedMesh *dm, int index, MEdge *r_edge)
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-	*edge_r = cddm->medge[index];
+	*r_edge = cddm->medge[index];
 }
 
-static void cdDM_getTessFace(DerivedMesh *dm, int index, MFace *face_r)
+static void cdDM_getTessFace(DerivedMesh *dm, int index, MFace *r_face)
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-	*face_r = cddm->mface[index];
+	*r_face = cddm->mface[index];
 }
 
-static void cdDM_copyVertArray(DerivedMesh *dm, MVert *vert_r)
+static void cdDM_copyVertArray(DerivedMesh *dm, MVert *r_vert)
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-	memcpy(vert_r, cddm->mvert, sizeof(*vert_r) * dm->numVertData);
+	memcpy(r_vert, cddm->mvert, sizeof(*r_vert) * dm->numVertData);
 }
 
-static void cdDM_copyEdgeArray(DerivedMesh *dm, MEdge *edge_r)
+static void cdDM_copyEdgeArray(DerivedMesh *dm, MEdge *r_edge)
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-	memcpy(edge_r, cddm->medge, sizeof(*edge_r) * dm->numEdgeData);
+	memcpy(r_edge, cddm->medge, sizeof(*r_edge) * dm->numEdgeData);
 }
 
-static void cdDM_copyTessFaceArray(DerivedMesh *dm, MFace *face_r)
+static void cdDM_copyTessFaceArray(DerivedMesh *dm, MFace *r_face)
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-	memcpy(face_r, cddm->mface, sizeof(*face_r) * dm->numTessFaceData);
+	memcpy(r_face, cddm->mface, sizeof(*r_face) * dm->numTessFaceData);
 }
 
-static void cdDM_copyLoopArray(DerivedMesh *dm, MLoop *loop_r)
+static void cdDM_copyLoopArray(DerivedMesh *dm, MLoop *r_loop)
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-	memcpy(loop_r, cddm->mloop, sizeof(*loop_r) * dm->numLoopData);
+	memcpy(r_loop, cddm->mloop, sizeof(*r_loop) * dm->numLoopData);
 }
 
-static void cdDM_copyPolyArray(DerivedMesh *dm, MPoly *poly_r)
+static void cdDM_copyPolyArray(DerivedMesh *dm, MPoly *r_poly)
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh *)dm;
-	memcpy(poly_r, cddm->mpoly, sizeof(*poly_r) * dm->numPolyData);
+	memcpy(r_poly, cddm->mpoly, sizeof(*r_poly) * dm->numPolyData);
 }
 
-static void cdDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3])
+static void cdDM_getMinMax(DerivedMesh *dm, float r_min[3], float r_max[3])
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh *) dm;
 	int i;
 
 	if (dm->numVertData) {
 		for (i = 0; i < dm->numVertData; i++) {
-			minmax_v3v3_v3(min_r, max_r, cddm->mvert[i].co);
+			minmax_v3v3_v3(r_min, r_max, cddm->mvert[i].co);
 		}
 	}
 	else {
-		zero_v3(min_r);
-		zero_v3(max_r);
+		zero_v3(r_min);
+		zero_v3(r_max);
 	}
 }
 
-static void cdDM_getVertCo(DerivedMesh *dm, int index, float co_r[3])
+static void cdDM_getVertCo(DerivedMesh *dm, int index, float r_co[3])
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh *) dm;
 
-	copy_v3_v3(co_r, cddm->mvert[index].co);
+	copy_v3_v3(r_co, cddm->mvert[index].co);
 }
 
-static void cdDM_getVertCos(DerivedMesh *dm, float (*cos_r)[3])
+static void cdDM_getVertCos(DerivedMesh *dm, float (*r_cos)[3])
 {
 	MVert *mv = CDDM_get_verts(dm);
 	int i;
 
 	for (i = 0; i < dm->numVertData; i++, mv++)
-		copy_v3_v3(cos_r[i], mv->co);
+		copy_v3_v3(r_cos[i], mv->co);
 }
 
-static void cdDM_getVertNo(DerivedMesh *dm, int index, float no_r[3])
+static void cdDM_getVertNo(DerivedMesh *dm, int index, float r_no[3])
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh *) dm;
-	normal_short_to_float_v3(no_r, cddm->mvert[index].no);
+	normal_short_to_float_v3(r_no, cddm->mvert[index].no);
 }
 
 static const MeshElemMap *cdDM_getPolyMap(Object *ob, DerivedMesh *dm)
diff --git a/source/blender/blenkernel/intern/curve.c b/source/blender/blenkernel/intern/curve.c
index c3046804e59..4fc80f30e97 100644
--- a/source/blender/blenkernel/intern/curve.c
+++ b/source/blender/blenkernel/intern/curve.c
@@ -3637,9 +3637,9 @@ void BKE_nurb_direction_switch(Nurb *nu)
 }
 
 
-float (*BKE_curve_nurbs_vertexCos_get(ListBase *lb, int *numVerts_r))[3]
+float (*BKE_curve_nurbs_vertexCos_get(ListBase *lb, int *r_numVerts))[3]
 {
-	int i, numVerts = *numVerts_r = BKE_nurbList_verts_count(lb);
+	int i, numVerts = *r_numVerts = BKE_nurbList_verts_count(lb);
 	float *co, (*cos)[3] = MEM_mallocN(sizeof(*cos) * numVerts, "cu_vcos");
 	Nurb *nu;
 
diff --git a/source/blender/blenkernel/intern/displist.c b/source/blender/blenkernel/intern/displist.c
index 9582d87c540..f3fa5f75dbb 100644
--- a/source/blender/blenkernel/intern/displist.c
+++ b/source/blender/blenkernel/intern/displist.c
@@ -1282,9 +1282,9 @@ void BKE_displist_make_surf(Scene *scene, Object *ob, ListBase *dispbase,
 	BKE_nurbList_free(&nubase);
 }
 
-static void rotateBevelPiece(Curve *cu, BevPoint *bevp, BevPoint *nbevp, DispList *dlb, float bev_blend, float widfac, float fac, float **data_r)
+static void rotateBevelPiece(Curve *cu, BevPoint *bevp, BevPoint *nbevp, DispList *dlb, float bev_blend, float widfac, float fac, float **r_data)
 {
-	float *fp, *data = *data_r;
+	float *fp, *data = *r_data;
 	int b;
 
 	fp = dlb->verts;
@@ -1335,7 +1335,7 @@ static void rotateBevelPiece(Curve *cu, BevPoint *bevp, BevPoint *nbevp, DispLis
 		}
 	}
 
-	*data_r = data;
+	*r_data = data;
 }
 
 static void fillBevelCap(Nurb *nu, DispList *dlb, float *prev_fp, ListBase *dispbase)
diff --git a/source/blender/blenkernel/intern/image.c b/source/blender/blenkernel/intern/image.c
index b8b126c4c8e..aaeead431b9 100644
--- a/source/blender/blenkernel/intern/image.c
+++ b/source/blender/blenkernel/intern/image.c
@@ -2916,7 +2916,7 @@ static ImBuf *image_get_render_result(Image *ima, ImageUser *iuser, void **lock_
 	return ibuf;
 }
 
-static void image_get_frame_and_index(Image *ima, ImageUser *iuser, int *frame_r, int *index_r)
+static void image_get_frame_and_index(Image *ima, ImageUser *iuser, int *r_frame, int *r_index)
 {
 	int frame = 0, index = 0;
 
@@ -2934,8 +2934,8 @@ static void image_get_frame_and_index(Image *ima, ImageUser *iuser, int *frame_r
 		}
 	}
 
-	*frame_r = frame;
-	*index_r = index;
+	*r_frame = frame;
+	*r_index = index;
 }
 
 /* Get the ibuf from an image cache for a given image user.
@@ -2944,7 +2944,7 @@ static void image_get_frame_and_index(Image *ima, ImageUser *iuser, int *frame_r
  * call IMB_freeImBuf to de-reference the image buffer after
  * it's done handling it.
  */
-static ImBuf *image_get_cached_ibuf(Image *ima, ImageUser *iuser, int *frame_r, int *index_r)
+static ImBuf *image_get_cached_ibuf(Image *ima, ImageUser *iuser, int *r_frame, int *r_index)
 {
 	ImBuf *ibuf = NULL;
 	int frame = 0, index = 0;
@@ -2990,11 +2990,11 @@ static ImBuf *image_get_cached_ibuf(Image *ima, ImageUser *iuser, int *frame_r,
 		 * a big bottleneck */
 	}
 
-	if (frame_r)
-		*frame_r = frame;
+	if (r_frame)
+		*r_frame = frame;
 
-	if (index_r)
-		*index_r = index;
+	if (r_index)
+		*r_index = index;
 
 	return ibuf;
 }
diff --git a/source/blender/blenkernel/intern/lattice.c b/source/blender/blenkernel/intern/lattice.c
index 72462eed30c..f647926fc0f 100644
--- a/source/blender/blenkernel/intern/lattice.c
+++ b/source/blender/blenkernel/intern/lattice.c
@@ -620,7 +620,7 @@ static bool where_on_path_deform(Object *ob, float ctime, float vec[4], float di
 /* returns quaternion for rotation, using cd->no_rot_axis */
 /* axis is using another define!!! */
 static bool calc_curve_deform(Scene *scene, Object *par, float co[3],
-                              const short axis, CurveDeform *cd, float quat_r[4])
+                              const short axis, CurveDeform *cd, float r_quat[4])
 {
 	Curve *cu = par->data;
 	float fac, loc[4], dir[3], new_quat[4], radius;
@@ -706,8 +706,8 @@ static bool calc_curve_deform(Scene *scene, Object *par, float co[3],
 		/* translation */
 		add_v3_v3v3(co, cent, loc);
 
-		if (quat_r)
-			copy_qt_qt(quat_r, quat);
+		if (r_quat)
+			copy_qt_qt(r_quat, quat);
 
 		return 1;
 	}
@@ -1024,14 +1024,14 @@ void outside_lattice(Lattice *lt)
 	}
 }
 
-float (*BKE_lattice_vertexcos_get(struct Object *ob, int *numVerts_r))[3]
+float (*BKE_lattice_vertexcos_get(struct Object *ob, int *r_numVerts))[3]
 {
 	Lattice *lt = ob->data;
 	int i, numVerts;
 	float (*vertexCos)[3];
 
 	if (lt->editlatt) lt = lt->editlatt->latt;
-	numVerts = *numVerts_r = lt->pntsu * lt->pntsv * lt->pntsw;
+	numVerts = *r_numVerts = lt->pntsu * lt->pntsv * lt->pntsw;
 	
 	vertexCos = MEM_mallocN(sizeof(*vertexCos) * numVerts, "lt_vcos");
 	
diff --git a/source/blender/blenkernel/intern/mask_evaluate.c b/source/blender/blenkernel/intern/mask_evaluate.c
index c6cc4a412b8..4d9791a077c 100644
--- a/source/blender/blenkernel/intern/mask_evaluate.c
+++ b/source/blender/blenkernel/intern/mask_evaluate.c
@@ -252,8 +252,9 @@ static void feather_bucket_add_edge(FeatherEdgesBucket *bucket, int start, int e
 	bucket->tot_segment++;
 }
 
-static void feather_bucket_check_intersect(float (*feather_points)[2], int tot_feather_point, FeatherEdgesBucket *bucket,
-                                           int cur_a, int cur_b)
+static void feather_bucket_check_intersect(
+        float (*feather_points)[2], int tot_feather_point, FeatherEdgesBucket *bucket,
+        int cur_a, int cur_b)
 {
 	int i;
 
@@ -313,8 +314,9 @@ static void feather_bucket_check_intersect(float (*feather_points)[2], int tot_f
 	}
 }
 
-static int feather_bucket_index_from_coord(const float co[2], const float min[2], const float bucket_scale[2],
-                                           const int buckets_per_side)
+static int feather_bucket_index_from_coord(
+        const float co[2], const float min[2], const float bucket_scale[2],
+        const int buckets_per_side)
 {
 	int x = (int) ((co[0] - min[0]) * bucket_scale[0]);
 	int y = (int) ((co[1] - min[1]) * bucket_scale[1]);
@@ -328,9 +330,9 @@ static int feather_bucket_index_from_coord(const float co[2], const float min[2]
 	return y * buckets_per_side + x;
 }
 
-static void feather_bucket_get_diagonal(FeatherEdgesBucket *buckets, int start_bucket_index, int end_bucket_index,
-                                        int buckets_per_side, FeatherEdgesBucket **diagonal_bucket_a_r,
-                                        FeatherEdgesBucket **diagonal_bucket_b_r)
+static void feather_bucket_get_diagonal(
+        FeatherEdgesBucket *buckets, int start_bucket_index, int end_bucket_index, int buckets_per_side,
+        FeatherEdgesBucket **r_diagonal_bucket_a, FeatherEdgesBucket **r_diagonal_bucket_b)
 {
 	int start_bucket_x = start_bucket_index % buckets_per_side;
 	int start_bucket_y = start_bucket_index / buckets_per_side;
@@ -341,11 +343,12 @@ static void feather_bucket_get_diagonal(FeatherEdgesBucket *buckets, int start_b
 	int diagonal_bucket_a_index = start_bucket_y * buckets_per_side + end_bucket_x;
 	int diagonal_bucket_b_index = end_bucket_y * buckets_per_side + start_bucket_x;
 
-	*diagonal_bucket_a_r = &buckets[diagonal_bucket_a_index];
-	*diagonal_bucket_b_r = &buckets[diagonal_bucket_b_index];
+	*r_diagonal_bucket_a = &buckets[diagonal_bucket_a_index];
+	*r_diagonal_bucket_b = &buckets[diagonal_bucket_b_index];
 }
 
-void BKE_mask_spline_feather_collapse_inner_loops(MaskSpline *spline, float (*feather_points)[2], const unsigned int tot_feather_point)
+void BKE_mask_spline_feather_collapse_inner_loops(
+        MaskSpline *spline, float (*feather_points)[2], const unsigned int tot_feather_point)
 {
 #define BUCKET_INDEX(co) \
 	feather_bucket_index_from_coord(co, min, bucket_scale, buckets_per_side)
@@ -502,11 +505,9 @@ void BKE_mask_spline_feather_collapse_inner_loops(MaskSpline *spline, float (*fe
 }
 
 /** only called from #BKE_mask_spline_feather_differentiated_points_with_resolution() ! */
-static float (*mask_spline_feather_differentiated_points_with_resolution__even(MaskSpline *spline,
-                                                                               unsigned int *tot_feather_point,
-                                                                               const unsigned int resol,
-                                                                               const bool do_feather_isect
-                                                                               ))[2]
+static float (*mask_spline_feather_differentiated_points_with_resolution__even(
+        MaskSpline *spline, unsigned int *tot_feather_point,
+        const unsigned int resol, const bool do_feather_isect))[2]
 {
 	MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
 	MaskSplinePoint *point_curr, *point_prev;
@@ -575,11 +576,9 @@ static float (*mask_spline_feather_differentiated_points_with_resolution__even(M
 }
 
 /** only called from #BKE_mask_spline_feather_differentiated_points_with_resolution() ! */
-static float (*mask_spline_feather_differentiated_points_with_resolution__double(MaskSpline *spline,
-                                                                                 unsigned int *tot_feather_point,
-                                                                                 const unsigned int resol,
-                                                                                 const bool do_feather_isect
-                                                                                 ))[2]
+static float (*mask_spline_feather_differentiated_points_with_resolution__double(
+        MaskSpline *spline, unsigned int *tot_feather_point,
+        const unsigned int resol, const bool do_feather_isect))[2]
 {
 	MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);
 
@@ -712,11 +711,9 @@ static float (*mask_spline_feather_differentiated_points_with_resolution__double
  * values align with #BKE_mask_spline_differentiate_with_resolution
  * when \a resol arguments match.
  */
-float (*BKE_mask_spline_feather_differentiated_points_with_resolution(MaskSpline *spline,
-                                                                      unsigned int *tot_feather_point,
-                                                                      const unsigned int resol,
-                                                                      const bool do_feather_isect
-                                                                      ))[2]
+float (*BKE_mask_spline_feather_differentiated_points_with_resolution(
+        MaskSpline *spline, unsigned int *tot_feather_point,
+        const unsigned int resol, const bool do_feather_isect))[2]
 {
 	switch (spline->offset_mode) {
 		case MASK_SPLINE_OFFSET_EVEN:
diff --git a/source/blender/blenkernel/intern/mesh.c b/source/blender/blenkernel/intern/mesh.c
index 7a81aedb60b..838f93e5222 100644
--- a/source/blender/blenkernel/intern/mesh.c
+++ b/source/blender/blenkernel/intern/mesh.c
@@ -1750,7 +1750,7 @@ void BKE_mesh_smooth_flag_set(Object *meshOb, int enableSmooth)
 
 /**
  * Return a newly MEM_malloc'd array of all the mesh vertex locations
- * \note \a numVerts_r may be NULL
+ * \note \a r_numVerts may be NULL
  */
 float (*BKE_mesh_vertexCos_get(Mesh *me, int *r_numVerts))[3]
 {
@@ -1781,11 +1781,11 @@ int poly_find_loop_from_vert(const MPoly *poly, const MLoop *loopstart,
 }
 
 /**
- * Fill \a adj_r with the loop indices in \a poly adjacent to the
+ * Fill \a r_adj with the loop indices in \a poly adjacent to the
  * vertex. Returns the index of the loop matching vertex, or -1 if the
  * vertex is not in \a poly
  */
-int poly_get_adj_loops_from_vert(unsigned adj_r[3], const MPoly *poly,
+int poly_get_adj_loops_from_vert(unsigned r_adj[3], const MPoly *poly,
                                  const MLoop *mloop, unsigned vert)
 {
 	int corner = poly_find_loop_from_vert(poly,
@@ -1796,9 +1796,9 @@ int poly_get_adj_loops_from_vert(unsigned adj_r[3], const MPoly *poly,
 		const MLoop *ml = &mloop[poly->loopstart + corner];
 
 		/* vertex was found */
-		adj_r[0] = ME_POLY_LOOP_PREV(mloop, poly, corner)->v;
-		adj_r[1] = ml->v;
-		adj_r[2] = ME_POLY_LOOP_NEXT(mloop, poly, corner)->v;
+		r_adj[0] = ME_POLY_LOOP_PREV(mloop, poly, corner)->v;
+		r_adj[1] = ml->v;
+		r_adj[2] = ME_POLY_LOOP_NEXT(mloop, poly, corner)->v;
 	}
 
 	return corner;
diff --git a/source/blender/blenkernel/intern/mesh_evaluate.c b/source/blender/blenkernel/intern/mesh_evaluate.c
index be24fa8fc46..aa1f9e563db 100644
--- a/source/blender/blenkernel/intern/mesh_evaluate.c
+++ b/source/blender/blenkernel/intern/mesh_evaluate.c
@@ -83,26 +83,26 @@ static void mesh_calc_normals_vert_fallback(MVert *mverts, int numVerts)
 	}
 }
 
-/* Calculate vertex and face normals, face normals are returned in *faceNors_r if non-NULL
+/* Calculate vertex and face normals, face normals are returned in *r_faceNors if non-NULL
  * and vertex normals are stored in actual mverts.
  */
 void BKE_mesh_calc_normals_mapping(MVert *mverts, int numVerts,
-                                   MLoop *mloop, MPoly *mpolys, int numLoops, int numPolys, float (*polyNors_r)[3],
-                                   MFace *mfaces, int numFaces, int *origIndexFace, float (*faceNors_r)[3])
+                                   MLoop *mloop, MPoly *mpolys, int numLoops, int numPolys, float (*r_polyNors)[3],
+                                   MFace *mfaces, int numFaces, const int *origIndexFace, float (*r_faceNors)[3])
 {
 	BKE_mesh_calc_normals_mapping_ex(mverts, numVerts, mloop, mpolys,
-	                                 numLoops, numPolys, polyNors_r, mfaces, numFaces,
-	                                 origIndexFace, faceNors_r, FALSE);
+	                                 numLoops, numPolys, r_polyNors, mfaces, numFaces,
+	                                 origIndexFace, r_faceNors, FALSE);
 }
 /* extended version of 'BKE_mesh_calc_normals_poly' with option not to calc vertex normals */
 void BKE_mesh_calc_normals_mapping_ex(
         MVert *mverts, int numVerts,
         MLoop *mloop, MPoly *mpolys,
-        int numLoops, int numPolys, float (*polyNors_r)[3],
-        MFace *mfaces, int numFaces, int *origIndexFace, float (*faceNors_r)[3],
+        int numLoops, int numPolys, float (*r_polyNors)[3],
+        MFace *mfaces, int numFaces, const int *origIndexFace, float (*r_faceNors)[3],
         const bool only_face_normals)
 {
-	float (*pnors)[3] = polyNors_r, (*fnors)[3] = faceNors_r;
+	float (*pnors)[3] = r_polyNors, (*fnors)[3] = r_faceNors;
 	int i;
 	MFace *mf;
 	MPoly *mp;
@@ -115,7 +115,7 @@ void BKE_mesh_calc_normals_mapping_ex(
 	}
 
 	/* if we are not calculating verts and no verts were passes then we have nothing to do */
-	if ((only_face_normals == TRUE) && (polyNors_r == NULL) && (faceNors_r == NULL)) {
+	if ((only_face_normals == TRUE) && (r_polyNors == NULL) && (r_faceNors == NULL)) {
 		printf("%s: called with nothing to do\n", __func__);
 		return;
 	}
@@ -138,7 +138,7 @@ void BKE_mesh_calc_normals_mapping_ex(
 	}
 
 	if (origIndexFace &&
-	    /* fnors == faceNors_r */ /* NO NEED TO ALLOC YET */
+	    /* fnors == r_faceNors */ /* NO NEED TO ALLOC YET */
 	    fnors != NULL &&
 	    numFaces)
 	{
@@ -154,8 +154,8 @@ void BKE_mesh_calc_normals_mapping_ex(
 		}
 	}
 
-	if (pnors != polyNors_r) MEM_freeN(pnors);
-	/* if (fnors != faceNors_r) MEM_freeN(fnors); */ /* NO NEED TO ALLOC YET */
+	if (pnors != r_polyNors) MEM_freeN(pnors);
+	/* if (fnors != r_faceNors) MEM_freeN(fnors); */ /* NO NEED TO ALLOC YET */
 
 	fnors = pnors = NULL;
 	
@@ -277,10 +277,10 @@ void BKE_mesh_calc_normals(Mesh *mesh)
 #endif
 }
 
-void BKE_mesh_calc_normals_tessface(MVert *mverts, int numVerts, MFace *mfaces, int numFaces, float (*faceNors_r)[3])
+void BKE_mesh_calc_normals_tessface(MVert *mverts, int numVerts, MFace *mfaces, int numFaces, float (*r_faceNors)[3])
 {
 	float (*tnorms)[3] = MEM_callocN(sizeof(*tnorms) * (size_t)numVerts, "tnorms");
-	float (*fnors)[3] = (faceNors_r) ? faceNors_r : MEM_callocN(sizeof(*fnors) * (size_t)numFaces, "meshnormals");
+	float (*fnors)[3] = (r_faceNors) ? r_faceNors : MEM_callocN(sizeof(*fnors) * (size_t)numFaces, "meshnormals");
 	int i;
 
 	for (i = 0; i < numFaces; i++) {
@@ -312,7 +312,7 @@ void BKE_mesh_calc_normals_tessface(MVert *mverts, int numVerts, MFace *mfaces,
 	
 	MEM_freeN(tnorms);
 
-	if (fnors != faceNors_r)
+	if (fnors != r_faceNors)
 		MEM_freeN(fnors);
 }
 
@@ -1733,8 +1733,8 @@ void BKE_mesh_do_versions_convert_mfaces_to_mpolys(Mesh *mesh)
 void BKE_mesh_convert_mfaces_to_mpolys_ex(ID *id, CustomData *fdata, CustomData *ldata, CustomData *pdata,
                                           int totedge_i, int totface_i, int totloop_i, int totpoly_i,
                                           MEdge *medge, MFace *mface,
-                                          int *totloop_r, int *totpoly_r,
-                                          MLoop **mloop_r, MPoly **mpoly_r)
+                                          int *r_totloop, int *r_totpoly,
+                                          MLoop **r_mloop, MPoly **r_mpoly)
 {
 	MFace *mf;
 	MLoop *ml, *mloop;
@@ -1828,10 +1828,10 @@ void BKE_mesh_convert_mfaces_to_mpolys_ex(ID *id, CustomData *fdata, CustomData
 
 	BLI_edgehash_free(eh, NULL);
 
-	*totpoly_r = totpoly;
-	*totloop_r = totloop;
-	*mpoly_r = mpoly;
-	*mloop_r = mloop;
+	*r_totpoly = totpoly;
+	*r_totloop = totloop;
+	*r_mpoly = mpoly;
+	*r_mloop = mloop;
 }
 /** \} */
 
diff --git a/source/blender/blenkernel/intern/modifier.c b/source/blender/blenkernel/intern/modifier.c
index 2d6888244d0..054d09e8b70 100644
--- a/source/blender/blenkernel/intern/modifier.c
+++ b/source/blender/blenkernel/intern/modifier.c
@@ -337,15 +337,15 @@ void modifier_setError(ModifierData *md, const char *_format, ...)
  * then is NULL) 
  * also used for some mesh tools to give warnings
  */
-int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *lastPossibleCageIndex_r, int virtual_)
+int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *r_lastPossibleCageIndex, bool is_virtual)
 {
 	VirtualModifierData virtualModifierData;
-	ModifierData *md = (virtual_) ? modifiers_getVirtualModifierList(ob, &virtualModifierData) : ob->modifiers.first;
+	ModifierData *md = (is_virtual) ? modifiers_getVirtualModifierList(ob, &virtualModifierData) : ob->modifiers.first;
 	int i, cageIndex = -1;
 
-	if (lastPossibleCageIndex_r) {
+	if (r_lastPossibleCageIndex) {
 		/* ensure the value is initialized */
-		*lastPossibleCageIndex_r = -1;
+		*r_lastPossibleCageIndex = -1;
 	}
 
 	/* Find the last modifier acting on the cage. */
@@ -361,7 +361,9 @@ int modifiers_getCageIndex(struct Scene *scene, Object *ob, int *lastPossibleCag
 		if (!modifier_supportsMapping(md))
 			break;
 
-		if (lastPossibleCageIndex_r) *lastPossibleCageIndex_r = i;
+		if (r_lastPossibleCageIndex) {
+			*r_lastPossibleCageIndex = i;
+		}
 
 		if (!(md->mode & eModifierMode_Realtime)) continue;
 		if (!(md->mode & eModifierMode_Editmode)) continue;
diff --git a/source/blender/blenkernel/intern/subsurf_ccg.c b/source/blender/blenkernel/intern/subsurf_ccg.c
index 2d23c32720b..4fc241b8ea5 100644
--- a/source/blender/blenkernel/intern/subsurf_ccg.c
+++ b/source/blender/blenkernel/intern/subsurf_ccg.c
@@ -694,7 +694,7 @@ static void minmax_v3_v3v3(const float vec[3], float min[3], float max[3])
 	if (max[2] < vec[2]) max[2] = vec[2];
 }
 
-static void ccgDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3])
+static void ccgDM_getMinMax(DerivedMesh *dm, float r_min[3], float r_max[3])
 {
 	CCGDerivedMesh *ccgdm = (CCGDerivedMesh *) dm;
 	CCGSubSurf *ss = ccgdm->ss;
@@ -708,13 +708,13 @@ static void ccgDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3])
 	CCG_key_top_level(&key, ss);
 
 	if (!ccgSubSurf_getNumVerts(ss))
-		min_r[0] = min_r[1] = min_r[2] = max_r[0] = max_r[1] = max_r[2] = 0.0;
+		r_min[0] = r_min[1] = r_min[2] = r_max[0] = r_max[1] = r_max[2] = 0.0;
 
 	for (vi = ccgSubSurf_getVertIterator(ss); !ccgVertIterator_isStopped(vi); ccgVertIterator_next(vi)) {
 		CCGVert *v = ccgVertIterator_getCurrent(vi);
 		float *co = ccgSubSurf_getVertData(ss, v);
 
-		minmax_v3_v3v3(co, min_r, max_r);
+		minmax_v3_v3v3(co, r_min, r_max);
 	}
 	ccgVertIterator_free(vi);
 
@@ -723,7 +723,7 @@ static void ccgDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3])
 		CCGElem *edgeData = ccgSubSurf_getEdgeDataArray(ss, e);
 
 		for (i = 0; i < edgeSize; i++)
-			minmax_v3_v3v3(CCG_elem_offset_co(&key, edgeData, i), min_r, max_r);
+			minmax_v3_v3v3(CCG_elem_offset_co(&key, edgeData, i), r_min, r_max);
 	}
 	ccgEdgeIterator_free(ei);
 
@@ -736,7 +736,7 @@ static void ccgDM_getMinMax(DerivedMesh *dm, float min_r[3], float max_r[3])
 
 			for (y = 0; y < gridSize; y++)
 				for (x = 0; x < gridSize; x++)
-					minmax_v3_v3v3(CCG_grid_elem_co(&key, faceGridData, x, y), min_r, max_r);
+					minmax_v3_v3v3(CCG_grid_elem_co(&key, faceGridData, x, y), r_min, r_max);
 		}
 	}
 	ccgFaceIterator_free(fi);
@@ -863,20 +863,20 @@ static void ccgDM_getFinalVert(DerivedMesh *dm, int vertNum, MVert *mv)
 	}
 }
 
-static void ccgDM_getFinalVertCo(DerivedMesh *dm, int vertNum, float co_r[3])
+static void ccgDM_getFinalVertCo(DerivedMesh *dm, int vertNum, float r_co[3])
 {
 	MVert mvert;
 
 	ccgDM_getFinalVert(dm, vertNum, &mvert);
-	copy_v3_v3(co_r, mvert.co);
+	copy_v3_v3(r_co, mvert.co);
 }
 
-static void ccgDM_getFinalVertNo(DerivedMesh *dm, int vertNum, float no_r[3])
+static void ccgDM_getFinalVertNo(DerivedMesh *dm, int vertNum, float r_no[3])
 {
 	MVert mvert;
 
 	ccgDM_getFinalVert(dm, vertNum, &mvert);
-	normal_short_to_float_v3(no_r, mvert.no);
+	normal_short_to_float_v3(r_no, mvert.no);
 }
 
 static void ccgDM_getFinalEdge(DerivedMesh *dm, int edgeNum, MEdge *med)
@@ -3682,7 +3682,7 @@ struct DerivedMesh *subsurf_make_derived_from_derived(
 	return (DerivedMesh *)result;
 }
 
-void subsurf_calculate_limit_positions(Mesh *me, float (*positions_r)[3]) 
+void subsurf_calculate_limit_positions(Mesh *me, float (*r_positions)[3])
 {
 	/* Finds the subsurf limit positions for the verts in a mesh 
 	 * and puts them in an array of floats. Please note that the 
@@ -3722,9 +3722,9 @@ void subsurf_calculate_limit_positions(Mesh *me, float (*positions_r)[3])
 			mul_v3_fl(face_sum, (float)N / (float)numFaces);
 
 		co = ccgSubSurf_getVertData(ss, v);
-		positions_r[idx][0] = (co[0] * N * N + edge_sum[0] * 4 + face_sum[0]) / (N * (N + 5));
-		positions_r[idx][1] = (co[1] * N * N + edge_sum[1] * 4 + face_sum[1]) / (N * (N + 5));
-		positions_r[idx][2] = (co[2] * N * N + edge_sum[2] * 4 + face_sum[2]) / (N * (N + 5));
+		r_positions[idx][0] = (co[0] * N * N + edge_sum[0] * 4 + face_sum[0]) / (N * (N + 5));
+		r_positions[idx][1] = (co[1] * N * N + edge_sum[1] * 4 + face_sum[1]) / (N * (N + 5));
+		r_positions[idx][2] = (co[2] * N * N + edge_sum[2] * 4 + face_sum[2]) / (N * (N + 5));
 	}
 	ccgVertIterator_free(vi);