Code cleanup: use bools

9 files changed, 116 insertions, 102 deletions

diff --git a/source/blender/blenkernel/BKE_curve.h b/source/blender/blenkernel/BKE_curve.h
index 1ea2cb06bc0..407dc060574 100644
--- a/source/blender/blenkernel/BKE_curve.h
+++ b/source/blender/blenkernel/BKE_curve.h
@@ -111,7 +111,8 @@ float *BKE_curve_make_orco(struct Scene *scene, struct Object *ob, int *r_numVer
 float *BKE_curve_surf_make_orco(struct Object *ob);
 
 void BKE_curve_bevelList_make(struct Object *ob, struct ListBase *nurbs, bool for_render);
-void BKE_curve_bevel_make(struct Scene *scene, struct Object *ob,  struct ListBase *disp, int forRender, int renderResolution);
+void BKE_curve_bevel_make(struct Scene *scene, struct Object *ob,  struct ListBase *disp,
+                          const bool for_render, const bool use_render_resolution);
 
 void BKE_curve_forward_diff_bezier(float q0, float q1, float q2, float q3, float *p, int it, int stride);
 
diff --git a/source/blender/blenkernel/BKE_displist.h b/source/blender/blenkernel/BKE_displist.h
index dab552069f1..face19adc1e 100644
--- a/source/blender/blenkernel/BKE_displist.h
+++ b/source/blender/blenkernel/BKE_displist.h
@@ -88,9 +88,11 @@ void BKE_displist_count(struct ListBase *lb, int *totvert, int *totface, int *to
 void BKE_displist_free(struct ListBase *lb);
 bool BKE_displist_has_faces(struct ListBase *lb);
 
-void BKE_displist_make_surf(struct Scene *scene, struct Object *ob, struct ListBase *dispbase, struct DerivedMesh **derivedFinal, int forRender, int forOrco, int renderResolution);
-void BKE_displist_make_curveTypes(struct Scene *scene, struct Object *ob, int forOrco);
-void BKE_displist_make_curveTypes_forRender(struct Scene *scene, struct Object *ob, struct ListBase *dispbase, struct DerivedMesh **derivedFinal, int forOrco, int renderResolution);
+void BKE_displist_make_surf(struct Scene *scene, struct Object *ob, struct ListBase *dispbase, struct DerivedMesh **r_dm_final,
+                            const bool for_render, const bool for_orco, const bool use_render_resolution);
+void BKE_displist_make_curveTypes(struct Scene *scene, struct Object *ob, const bool for_orco);
+void BKE_displist_make_curveTypes_forRender(struct Scene *scene, struct Object *ob, struct ListBase *dispbase, struct DerivedMesh **r_dm_final,
+                                            const bool for_orco, const bool use_render_resolution);
 void BKE_displist_make_curveTypes_forOrco(struct Scene *scene, struct Object *ob, struct ListBase *dispbase);
 void BKE_displist_make_mball(struct EvaluationContext *eval_ctx, struct Scene *scene, struct Object *ob);
 void BKE_displist_make_mball_forRender(struct EvaluationContext *eval_ctx, struct Scene *scene, struct Object *ob, struct ListBase *dispbase);
@@ -101,7 +103,8 @@ void BKE_displist_fill(struct ListBase *dispbase, struct ListBase *to, const flo
 float BKE_displist_calc_taper(struct Scene *scene, struct Object *taperobj, int cur, int tot);
 
 /* add Orco layer to the displist object which has got derived mesh and return orco */
-float *BKE_displist_make_orco(struct Scene *scene, struct Object *ob, struct DerivedMesh *derivedFinal, int forRender, int renderResolution);
+float *BKE_displist_make_orco(struct Scene *scene, struct Object *ob, struct DerivedMesh *dm_final,
+                              const bool for_render, const bool use_render_resolution);
 
 void BKE_displist_minmax(struct ListBase *dispbase, float min[3], float max[3]);
 
diff --git a/source/blender/blenkernel/BKE_shrinkwrap.h b/source/blender/blenkernel/BKE_shrinkwrap.h
index 6e85d9ee0a0..59de43af907 100644
--- a/source/blender/blenkernel/BKE_shrinkwrap.h
+++ b/source/blender/blenkernel/BKE_shrinkwrap.h
@@ -122,7 +122,7 @@ typedef struct ShrinkwrapCalcData {
 } ShrinkwrapCalcData;
 
 void shrinkwrapModifier_deform(struct ShrinkwrapModifierData *smd, struct Object *ob, struct DerivedMesh *dm,
-                               float (*vertexCos)[3], int numVerts, bool forRender);
+                               float (*vertexCos)[3], int numVerts, bool for_render);
 
 /*
  * This function casts a ray in the given BVHTree.. but it takes into consideration the space_transform, that is:
@@ -134,9 +134,10 @@ void shrinkwrapModifier_deform(struct ShrinkwrapModifierData *smd, struct Object
  * Thus it provides an easy way to cast the same ray across several trees
  * (where each tree was built on its own coords space)
  */
-int BKE_shrinkwrap_project_normal(char options, const float vert[3], const float dir[3],
-                                  const SpaceTransform *transf, BVHTree *tree, BVHTreeRayHit *hit,
-                                  BVHTree_RayCastCallback callback, void *userdata);
+bool BKE_shrinkwrap_project_normal(
+        char options, const float vert[3], const float dir[3],
+        const SpaceTransform *transf, BVHTree *tree, BVHTreeRayHit *hit,
+        BVHTree_RayCastCallback callback, void *userdata);
 
 /*
  * NULL initializers to local data
diff --git a/source/blender/blenkernel/intern/curve.c b/source/blender/blenkernel/intern/curve.c
index 4fc80f30e97..bc65e5bf749 100644
--- a/source/blender/blenkernel/intern/curve.c
+++ b/source/blender/blenkernel/intern/curve.c
@@ -1620,7 +1620,8 @@ float *BKE_curve_make_orco(Scene *scene, Object *ob, int *r_numVerts)
 
 /* ***************** BEVEL ****************** */
 
-void BKE_curve_bevel_make(Scene *scene, Object *ob, ListBase *disp, int forRender, int renderResolution)
+void BKE_curve_bevel_make(Scene *scene, Object *ob, ListBase *disp,
+                          const bool for_render, const bool use_render_resolution)
 {
 	DispList *dl, *dlnew;
 	Curve *bevcu, *cu;
@@ -1643,8 +1644,8 @@ void BKE_curve_bevel_make(Scene *scene, Object *ob, ListBase *disp, int forRende
 			facx = cu->bevobj->size[0];
 			facy = cu->bevobj->size[1];
 
-			if (forRender) {
-				BKE_displist_make_curveTypes_forRender(scene, cu->bevobj, &bevdisp, NULL, 0, renderResolution);
+			if (for_render) {
+				BKE_displist_make_curveTypes_forRender(scene, cu->bevobj, &bevdisp, NULL, false, use_render_resolution);
 				dl = bevdisp.first;
 			}
 			else if (cu->bevobj->curve_cache) {
diff --git a/source/blender/blenkernel/intern/displist.c b/source/blender/blenkernel/intern/displist.c
index b5f631648ea..33cb2c0fb23 100644
--- a/source/blender/blenkernel/intern/displist.c
+++ b/source/blender/blenkernel/intern/displist.c
@@ -302,7 +302,8 @@ bool BKE_displist_surfindex_get(DispList *dl, int a, int *b, int *p1, int *p2, i
 
 /* ****************** make displists ********************* */
 
-static void curve_to_displist(Curve *cu, ListBase *nubase, ListBase *dispbase, int forRender, int renderResolution)
+static void curve_to_displist(Curve *cu, ListBase *nubase, ListBase *dispbase,
+                              const bool for_render, const bool use_render_resolution)
 {
 	Nurb *nu;
 	DispList *dl;
@@ -310,12 +311,12 @@ static void curve_to_displist(Curve *cu, ListBase *nubase, ListBase *dispbase, i
 	BPoint *bp;
 	float *data;
 	int a, len, resolu;
-	const int editmode = (!forRender && (cu->editnurb || cu->editfont));
+	const bool editmode = (!for_render && (cu->editnurb || cu->editfont));
 
 	nu = nubase->first;
 	while (nu) {
-		if (nu->hide == 0 || editmode == 0) {
-			if (renderResolution && cu->resolu_ren != 0)
+		if (nu->hide == 0 || editmode == false) {
+			if (use_render_resolution && cu->resolu_ren != 0)
 				resolu = cu->resolu_ren;
 			else
 				resolu = nu->resolu;
@@ -748,14 +749,15 @@ void BKE_displist_make_mball_forRender(EvaluationContext *eval_ctx, Scene *scene
 	object_deform_mball(ob, dispbase);
 }
 
-static ModifierData *curve_get_tessellate_point(Scene *scene, Object *ob, int renderResolution, int editmode)
+static ModifierData *curve_get_tessellate_point(Scene *scene, Object *ob,
+                                                const bool use_render_resolution, const bool editmode)
 {
 	VirtualModifierData virtualModifierData;
 	ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 	ModifierData *pretessellatePoint;
 	int required_mode;
 
-	if (renderResolution)
+	if (use_render_resolution)
 		required_mode = eModifierMode_Render;
 	else
 		required_mode = eModifierMode_Realtime;
@@ -790,14 +792,14 @@ static ModifierData *curve_get_tessellate_point(Scene *scene, Object *ob, int re
 }
 
 static void curve_calc_modifiers_pre(Scene *scene, Object *ob, ListBase *nurb,
-                                     int forRender, int renderResolution)
+                                     const bool for_render, const bool use_render_resolution)
 {
 	VirtualModifierData virtualModifierData;
 	ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 	ModifierData *pretessellatePoint;
 	Curve *cu = ob->data;
 	int numVerts = 0;
-	const int editmode = (!forRender && (cu->editnurb || cu->editfont));
+	const bool editmode = (!for_render && (cu->editnurb || cu->editfont));
 	ModifierApplyFlag app_flag = 0;
 	float (*deformedVerts)[3] = NULL;
 	float *keyVerts = NULL;
@@ -807,14 +809,14 @@ static void curve_calc_modifiers_pre(Scene *scene, Object *ob, ListBase *nurb,
 
 	if (editmode)
 		app_flag |= MOD_APPLY_USECACHE;
-	if (renderResolution) {
+	if (use_render_resolution) {
 		app_flag |= MOD_APPLY_RENDER;
 		required_mode = eModifierMode_Render;
 	}
 	else
 		required_mode = eModifierMode_Realtime;
 
-	pretessellatePoint = curve_get_tessellate_point(scene, ob, renderResolution, editmode);
+	pretessellatePoint = curve_get_tessellate_point(scene, ob, use_render_resolution, editmode);
 
 	if (editmode)
 		required_mode |= eModifierMode_Editmode;
@@ -900,28 +902,28 @@ static void displist_apply_allverts(ListBase *dispbase, float (*allverts)[3])
 }
 
 static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *nurb,
-                                      ListBase *dispbase, DerivedMesh **derivedFinal,
-                                      int forRender, int renderResolution)
+                                      ListBase *dispbase, DerivedMesh **r_dm_final,
+                                      const bool for_render, const bool use_render_resolution)
 {
 	VirtualModifierData virtualModifierData;
 	ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 	ModifierData *pretessellatePoint;
 	Curve *cu = ob->data;
 	int required_mode = 0, totvert = 0;
-	int editmode = (!forRender && (cu->editnurb || cu->editfont));
+	const bool editmode = (!for_render && (cu->editnurb || cu->editfont));
 	DerivedMesh *dm = NULL, *ndm;
 	float (*vertCos)[3] = NULL;
-	int useCache = !forRender;
+	int useCache = !for_render;
 	ModifierApplyFlag app_flag = 0;
 
-	if (renderResolution) {
+	if (use_render_resolution) {
 		app_flag |= MOD_APPLY_RENDER;
 		required_mode = eModifierMode_Render;
 	}
 	else
 		required_mode = eModifierMode_Realtime;
 
-	pretessellatePoint = curve_get_tessellate_point(scene, ob, renderResolution, editmode);
+	pretessellatePoint = curve_get_tessellate_point(scene, ob, use_render_resolution, editmode);
 
 	if (editmode)
 		required_mode |= eModifierMode_Editmode;
@@ -930,8 +932,8 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *nurb,
 		md = pretessellatePoint->next;
 	}
 
-	if (derivedFinal && *derivedFinal) {
-		(*derivedFinal)->release(*derivedFinal);
+	if (r_dm_final && *r_dm_final) {
+		(*r_dm_final)->release(*r_dm_final);
 	}
 
 	for (; md; md = md->next) {
@@ -966,7 +968,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *nurb,
 			}
 		}
 		else {
-			if (!derivedFinal) {
+			if (!r_dm_final) {
 				/* makeDisplistCurveTypes could be used for beveling, where derived mesh
 				 * is totally unnecessary, so we could stop modifiers applying
 				 * when we found constructive modifier but derived mesh is unwanted result
@@ -1033,7 +1035,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *nurb,
 		}
 	}
 
-	if (derivedFinal) {
+	if (r_dm_final) {
 		if (dm) {
 			/* see: mesh_calc_modifiers */
 			if (dm->getNumTessFaces(dm) == 0) {
@@ -1049,7 +1051,7 @@ static void curve_calc_modifiers_post(Scene *scene, Object *ob, ListBase *nurb,
 				CDDM_calc_normals_mapping_ex(dm, (dm->dirty & DM_DIRTY_NORMALS) ? false : true);
 			}
 		}
-		(*derivedFinal) = dm;
+		(*r_dm_final) = dm;
 	}
 }
 
@@ -1125,7 +1127,8 @@ static void add_orco_dm(Object *ob, DerivedMesh *dm, DerivedMesh *orcodm)
 		DM_add_vert_layer(dm, CD_ORCO, CD_ASSIGN, orco);
 }
 
-static void curve_calc_orcodm(Scene *scene, Object *ob, DerivedMesh *derivedFinal, int forRender, int renderResolution)
+static void curve_calc_orcodm(Scene *scene, Object *ob, DerivedMesh *dm_final,
+                              const bool for_render, const bool use_render_resolution)
 {
 	/* this function represents logic of mesh's orcodm calculation
 	 * for displist-based objects
@@ -1135,18 +1138,18 @@ static void curve_calc_orcodm(Scene *scene, Object *ob, DerivedMesh *derivedFina
 	ModifierData *pretessellatePoint;
 	Curve *cu = ob->data;
 	int required_mode;
-	int editmode = (!forRender && (cu->editnurb || cu->editfont));
+	const bool editmode = (!for_render && (cu->editnurb || cu->editfont));
 	DerivedMesh *ndm, *orcodm = NULL;
 	ModifierApplyFlag app_flag = MOD_APPLY_ORCO;
 
-	if (renderResolution) {
+	if (use_render_resolution) {
 		app_flag |= MOD_APPLY_RENDER;
 		required_mode = eModifierMode_Render;
 	}
 	else
 		required_mode = eModifierMode_Realtime;
 
-	pretessellatePoint = curve_get_tessellate_point(scene, ob, renderResolution, editmode);
+	pretessellatePoint = curve_get_tessellate_point(scene, ob, use_render_resolution, editmode);
 
 	if (editmode)
 		required_mode |= eModifierMode_Editmode;
@@ -1186,13 +1189,14 @@ static void curve_calc_orcodm(Scene *scene, Object *ob, DerivedMesh *derivedFina
 	}
 
 	/* add an orco layer if needed */
-	add_orco_dm(ob, derivedFinal, orcodm);
+	add_orco_dm(ob, dm_final, orcodm);
 
 	orcodm->release(orcodm);
 }
 
 void BKE_displist_make_surf(Scene *scene, Object *ob, ListBase *dispbase,
-                            DerivedMesh **derivedFinal, int forRender, int forOrco, int renderResolution)
+                            DerivedMesh **r_dm_final,
+                            const bool for_render, const bool for_orco, const bool use_render_resolution)
 {
 	ListBase nubase = {NULL, NULL};
 	Nurb *nu;
@@ -1201,21 +1205,21 @@ void BKE_displist_make_surf(Scene *scene, Object *ob, ListBase *dispbase,
 	float *data;
 	int len;
 
-	if (!forRender && cu->editnurb) {
+	if (!for_render && cu->editnurb) {
 		BKE_nurbList_duplicate(&nubase, BKE_curve_editNurbs_get(cu));
 	}
 	else {
 		BKE_nurbList_duplicate(&nubase, &cu->nurb);
 	}
 
-	if (!forOrco)
-		curve_calc_modifiers_pre(scene, ob, &nubase, forRender, renderResolution);
+	if (!for_orco)
+		curve_calc_modifiers_pre(scene, ob, &nubase, for_render, use_render_resolution);
 
 	for (nu = nubase.first; nu; nu = nu->next) {
-		if (forRender || nu->hide == 0) {
+		if (for_render || nu->hide == 0) {
 			int resolu = nu->resolu, resolv = nu->resolv;
 
-			if (renderResolution) {
+			if (use_render_resolution) {
 				if (cu->resolu_ren)
 					resolu = cu->resolu_ren;
 				if (cu->resolv_ren)
@@ -1274,9 +1278,9 @@ void BKE_displist_make_surf(Scene *scene, Object *ob, ListBase *dispbase,
 		}
 	}
 
-	if (!forOrco) {
-		curve_calc_modifiers_post(scene, ob, &nubase, dispbase, derivedFinal,
-		                          forRender, renderResolution);
+	if (!for_orco) {
+		curve_calc_modifiers_post(scene, ob, &nubase, dispbase, r_dm_final,
+		                          for_render, use_render_resolution);
 	}
 
 	BKE_nurbList_free(&nubase);
@@ -1361,7 +1365,8 @@ static void fillBevelCap(Nurb *nu, DispList *dlb, float *prev_fp, ListBase *disp
 }
 
 static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispbase,
-                                      DerivedMesh **derivedFinal, int forRender, int forOrco, int renderResolution)
+                                      DerivedMesh **r_dm_final,
+                                      const bool for_render, const bool for_orco, const bool use_render_resolution)
 {
 	Curve *cu = ob->data;
 
@@ -1369,7 +1374,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
 	if (!ELEM3(ob->type, OB_SURF, OB_CURVE, OB_FONT)) return;
 
 	if (ob->type == OB_SURF) {
-		BKE_displist_make_surf(scene, ob, dispbase, derivedFinal, forRender, forOrco, renderResolution);
+		BKE_displist_make_surf(scene, ob, dispbase, r_dm_final, for_render, for_orco, use_render_resolution);
 	}
 	else if (ELEM(ob->type, OB_CURVE, OB_FONT)) {
 		ListBase dlbev;
@@ -1381,7 +1386,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
 		 * If the calculation happens for orco, we should never free data which
 		 * was needed before and only not needed for orco calculation.
 		 */
-		if (!forOrco) {
+		if (!for_orco) {
 			if (ob->curve_cache->path) free_path(ob->curve_cache->path);
 			ob->curve_cache->path = NULL;
 		}
@@ -1393,17 +1398,17 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
 			BKE_nurbList_duplicate(&nubase, BKE_curve_nurbs_get(cu));
 		}
 
-		if (!forOrco)
-			curve_calc_modifiers_pre(scene, ob, &nubase, forRender, renderResolution);
+		if (!for_orco)
+			curve_calc_modifiers_pre(scene, ob, &nubase, for_render, use_render_resolution);
 
-		BKE_curve_bevelList_make(ob, &nubase, forRender != FALSE);
+		BKE_curve_bevelList_make(ob, &nubase, for_render != FALSE);
 
 		/* If curve has no bevel will return nothing */
-		BKE_curve_bevel_make(scene, ob, &dlbev, forRender, renderResolution);
+		BKE_curve_bevel_make(scene, ob, &dlbev, for_render, use_render_resolution);
 
 		/* no bevel or extrude, and no width correction? */
 		if (!dlbev.first && cu->width == 1.0f) {
-			curve_to_displist(cu, &nubase, dispbase, forRender, renderResolution);
+			curve_to_displist(cu, &nubase, dispbase, for_render, use_render_resolution);
 		}
 		else {
 			float widfac = cu->width - 1.0f;
@@ -1578,7 +1583,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
 			curve_to_filledpoly(cu, &nubase, dispbase);
 		}
 
-		if (!forOrco) {
+		if (!for_orco) {
 			if ((cu->flag & CU_PATH) ||
 			    DAG_get_eval_flags_for_object(scene, ob) & DAG_EVAL_NEED_CURVE_PATH)
 			{
@@ -1586,8 +1591,8 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
 			}
 		}
 
-		if (!forOrco)
-			curve_calc_modifiers_post(scene, ob, &nubase, dispbase, derivedFinal, forRender, renderResolution);
+		if (!for_orco)
+			curve_calc_modifiers_post(scene, ob, &nubase, dispbase, r_dm_final, for_render, use_render_resolution);
 
 		if (cu->flag & CU_DEFORM_FILL && !ob->derivedFinal) {
 			curve_to_filledpoly(cu, &nubase, dispbase);
@@ -1597,7 +1602,7 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
 	}
 }
 
-void BKE_displist_make_curveTypes(Scene *scene, Object *ob, int forOrco)
+void BKE_displist_make_curveTypes(Scene *scene, Object *ob, bool for_orco)
 {
 	ListBase *dispbase;
 
@@ -1615,19 +1620,19 @@ void BKE_displist_make_curveTypes(Scene *scene, Object *ob, int forOrco)
 
 	dispbase = &(ob->curve_cache->disp);
 
-	do_makeDispListCurveTypes(scene, ob, dispbase, &ob->derivedFinal, 0, forOrco, 0);
+	do_makeDispListCurveTypes(scene, ob, dispbase, &ob->derivedFinal, 0, for_orco, 0);
 
 	boundbox_displist_object(ob);
 }
 
 void BKE_displist_make_curveTypes_forRender(Scene *scene, Object *ob, ListBase *dispbase,
-                                      DerivedMesh **derivedFinal, int forOrco, int renderResolution)
+                                      DerivedMesh **r_dm_final, const bool for_orco, const bool use_render_resolution)
 {
 	if (ob->curve_cache == NULL) {
 		ob->curve_cache = MEM_callocN(sizeof(CurveCache), "CurveCache for MBall");
 	}
 
-	do_makeDispListCurveTypes(scene, ob, dispbase, derivedFinal, 1, forOrco, renderResolution);
+	do_makeDispListCurveTypes(scene, ob, dispbase, r_dm_final, true, for_orco, use_render_resolution);
 }
 
 void BKE_displist_make_curveTypes_forOrco(struct Scene *scene, struct Object *ob, struct ListBase *dispbase)
@@ -1640,18 +1645,20 @@ void BKE_displist_make_curveTypes_forOrco(struct Scene *scene, struct Object *ob
 }
 
 /* add Orco layer to the displist object which has got derived mesh and return orco */
-float *BKE_displist_make_orco(Scene *scene, Object *ob, DerivedMesh *derivedFinal, int forRender, int renderResolution)
+float *BKE_displist_make_orco(Scene *scene, Object *ob, DerivedMesh *dm_final,
+                              const bool for_render,
+                              const bool use_render_resolution)
 {
 	float *orco;
 
-	if (derivedFinal == NULL)
-		derivedFinal = ob->derivedFinal;
+	if (dm_final == NULL)
+		dm_final = ob->derivedFinal;
 
-	if (!derivedFinal->getVertDataArray(derivedFinal, CD_ORCO)) {
-		curve_calc_orcodm(scene, ob, derivedFinal, forRender, renderResolution);
+	if (!dm_final->getVertDataArray(dm_final, CD_ORCO)) {
+		curve_calc_orcodm(scene, ob, dm_final, for_render, use_render_resolution);
 	}
 
-	orco = derivedFinal->getVertDataArray(derivedFinal, CD_ORCO);
+	orco = dm_final->getVertDataArray(dm_final, CD_ORCO);
 
 	if (orco) {
 		orco = MEM_dupallocN(orco);
diff --git a/source/blender/blenkernel/intern/mask_rasterize.c b/source/blender/blenkernel/intern/mask_rasterize.c
index 90bda88819f..6aec474e2d0 100644
--- a/source/blender/blenkernel/intern/mask_rasterize.c
+++ b/source/blender/blenkernel/intern/mask_rasterize.c
@@ -294,7 +294,7 @@ static void maskrasterize_spline_differentiate_point_outset(float (*diff_feather
 		/* normalize_v2(d_prev); */ /* precalc */
 		normalize_v2(d_next);
 
-		if ((do_test == FALSE) ||
+		if ((do_test == false) ||
 		    (len_squared_v2v2(diff_feather_points[k], diff_points[k]) < ofs_squared))
 		{
 
@@ -347,18 +347,18 @@ static bool layer_bucket_isect_test(
 		const float *v3 = cos[face[2]];
 
 		if (isect_point_tri_v2(cent, v1, v2, v3)) {
-			return TRUE;
+			return true;
 		}
 		else {
 			if ((dist_squared_to_line_segment_v2(cent, v1, v2) < bucket_max_rad_squared) ||
 			    (dist_squared_to_line_segment_v2(cent, v2, v3) < bucket_max_rad_squared) ||
 			    (dist_squared_to_line_segment_v2(cent, v3, v1) < bucket_max_rad_squared))
 			{
-				return TRUE;
+				return true;
 			}
 			else {
 				// printf("skip tri\n");
-				return FALSE;
+				return false;
 			}
 		}
 
@@ -370,10 +370,10 @@ static bool layer_bucket_isect_test(
 		const float *v4 = cos[face[3]];
 
 		if (isect_point_tri_v2(cent, v1, v2, v3)) {
-			return TRUE;
+			return true;
 		}
 		else if (isect_point_tri_v2(cent, v1, v3, v4)) {
-			return TRUE;
+			return true;
 		}
 		else {
 			if ((dist_squared_to_line_segment_v2(cent, v1, v2) < bucket_max_rad_squared) ||
@@ -381,11 +381,11 @@ static bool layer_bucket_isect_test(
 			    (dist_squared_to_line_segment_v2(cent, v3, v4) < bucket_max_rad_squared) ||
 			    (dist_squared_to_line_segment_v2(cent, v4, v1) < bucket_max_rad_squared))
 			{
-				return TRUE;
+				return true;
 			}
 			else {
 				// printf("skip quad\n");
-				return FALSE;
+				return false;
 			}
 		}
 	}
@@ -632,7 +632,7 @@ void BKE_maskrasterize_handle_init(MaskRasterHandle *mr_handle, struct Mask *mas
 
 			if (do_feather) {
 				diff_feather_points = BKE_mask_spline_feather_differentiated_points_with_resolution(
-				                          spline, &tot_diff_feather_points, resol, FALSE);
+				                          spline, &tot_diff_feather_points, resol, false);
 				BLI_assert(diff_feather_points);
 			}
 			else {
@@ -680,20 +680,20 @@ void BKE_maskrasterize_handle_init(MaskRasterHandle *mr_handle, struct Mask *mas
 				}
 
 				/* fake aa, using small feather */
-				if (do_mask_aa == TRUE) {
-					if (do_feather == FALSE) {
+				if (do_mask_aa == true) {
+					if (do_feather == false) {
 						tot_diff_feather_points = tot_diff_point;
 						diff_feather_points = MEM_mallocN(sizeof(*diff_feather_points) *
 						                                  (size_t)tot_diff_feather_points,
 						                                  __func__);
 						/* add single pixel feather */
 						maskrasterize_spline_differentiate_point_outset(diff_feather_points, diff_points,
-						                                               tot_diff_point, pixel_size, FALSE);
+						                                               tot_diff_point, pixel_size, false);
 					}
 					else {
 						/* ensure single pixel feather, on any zero feather areas */
 						maskrasterize_spline_differentiate_point_outset(diff_feather_points, diff_points,
-						                                               tot_diff_point, pixel_size, TRUE);
+						                                               tot_diff_point, pixel_size, true);
 					}
 				}
 
diff --git a/source/blender/blenkernel/intern/mesh_evaluate.c b/source/blender/blenkernel/intern/mesh_evaluate.c
index aa1f9e563db..b0a43a218ee 100644
--- a/source/blender/blenkernel/intern/mesh_evaluate.c
+++ b/source/blender/blenkernel/intern/mesh_evaluate.c
@@ -92,7 +92,7 @@ void BKE_mesh_calc_normals_mapping(MVert *mverts, int numVerts,
 {
 	BKE_mesh_calc_normals_mapping_ex(mverts, numVerts, mloop, mpolys,
 	                                 numLoops, numPolys, r_polyNors, mfaces, numFaces,
-	                                 origIndexFace, r_faceNors, FALSE);
+	                                 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(
@@ -108,14 +108,14 @@ void BKE_mesh_calc_normals_mapping_ex(
 	MPoly *mp;
 
 	if (numPolys == 0) {
-		if (only_face_normals == FALSE) {
+		if (only_face_normals == false) {
 			mesh_calc_normals_vert_fallback(mverts, numVerts);
 		}
 		return;
 	}
 
 	/* if we are not calculating verts and no verts were passes then we have nothing to do */
-	if ((only_face_normals == TRUE) && (r_polyNors == NULL) && (r_faceNors == NULL)) {
+	if ((only_face_normals == true) && (r_polyNors == NULL) && (r_faceNors == NULL)) {
 		printf("%s: called with nothing to do\n", __func__);
 		return;
 	}
@@ -124,7 +124,7 @@ void BKE_mesh_calc_normals_mapping_ex(
 	/* if (!fnors) fnors = MEM_callocN(sizeof(float[3]) * numFaces, "face nors mesh.c"); */ /* NO NEED TO ALLOC YET */
 
 
-	if (only_face_normals == FALSE) {
+	if (only_face_normals == false) {
 		/* vertex normals are optional, they require some extra calculations,
 		 * so make them optional */
 		BKE_mesh_calc_normals_poly(mverts, numVerts, mloop, mpolys, numLoops, numPolys, pnors, false);
@@ -1990,13 +1990,13 @@ void BKE_mesh_flush_select_from_verts_ex(const MVert *mvert, const int UNUSED(to
 	i = totpoly;
 	for (mp = mpoly; i--; mp++) {
 		if ((mp->flag & ME_HIDE) == 0) {
-			int ok = TRUE;
+			bool ok = true;
 			const MLoop *ml;
 			int j;
 			j = mp->totloop;
 			for (ml = &mloop[mp->loopstart]; j--; ml++) {
 				if ((mvert[ml->v].flag & SELECT) == 0) {
-					ok = FALSE;
+					ok = false;
 					break;
 				}
 			}
diff --git a/source/blender/blenkernel/intern/modifier.c b/source/blender/blenkernel/intern/modifier.c
index 054d09e8b70..a3801fa29fe 100644
--- a/source/blender/blenkernel/intern/modifier.c
+++ b/source/blender/blenkernel/intern/modifier.c
@@ -173,12 +173,12 @@ bool modifier_isPreview(ModifierData *md)
 	ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 
 	if (!(mti->flags & eModifierTypeFlag_UsesPreview))
-		return FALSE;
+		return false;
 
 	if (md->mode & eModifierMode_Realtime)
-		return TRUE;
+		return true;
 
-	return FALSE;
+	return false;
 }
 
 ModifierData *modifiers_findByType(Object *ob, ModifierType type)
diff --git a/source/blender/blenkernel/intern/shrinkwrap.c b/source/blender/blenkernel/intern/shrinkwrap.c
index dce82f9cbc4..0035de0d825 100644
--- a/source/blender/blenkernel/intern/shrinkwrap.c
+++ b/source/blender/blenkernel/intern/shrinkwrap.c
@@ -203,10 +203,11 @@ static void shrinkwrap_calc_nearest_vertex(ShrinkwrapCalcData *calc)
  *	MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE (front faces hits are ignored)
  *	MOD_SHRINKWRAP_CULL_TARGET_BACKFACE (back faces hits are ignored)
  */
-int BKE_shrinkwrap_project_normal(char options, const float vert[3],
-                                  const float dir[3], const SpaceTransform *transf,
-                                  BVHTree *tree, BVHTreeRayHit *hit,
-                                  BVHTree_RayCastCallback callback, void *userdata)
+bool BKE_shrinkwrap_project_normal(
+        char options, const float vert[3],
+        const float dir[3], const SpaceTransform *transf,
+        BVHTree *tree, BVHTreeRayHit *hit,
+        BVHTree_RayCastCallback callback, void *userdata)
 {
 	/* don't use this because this dist value could be incompatible
 	 * this value used by the callback for comparing prev/new dist values.
@@ -255,7 +256,7 @@ int BKE_shrinkwrap_project_normal(char options, const float vert[3],
 			if (((options & MOD_SHRINKWRAP_CULL_TARGET_FRONTFACE) && dot <= 0.0f) ||
 			    ((options & MOD_SHRINKWRAP_CULL_TARGET_BACKFACE)  && dot >= 0.0f))
 			{
-				return FALSE; /* Ignore hit */
+				return false;  /* Ignore hit */
 			}
 		}
 
@@ -270,13 +271,13 @@ int BKE_shrinkwrap_project_normal(char options, const float vert[3],
 		BLI_assert(hit_tmp.dist <= hit->dist);
 
 		memcpy(hit, &hit_tmp, sizeof(hit_tmp));
-		return TRUE;
+		return true;
 	}
-	return FALSE;
+	return false;
 }
 
 
-static void shrinkwrap_calc_normal_projection(ShrinkwrapCalcData *calc, bool forRender)
+static void shrinkwrap_calc_normal_projection(ShrinkwrapCalcData *calc, bool for_render)
 {
 	int i;
 
@@ -323,7 +324,7 @@ static void shrinkwrap_calc_normal_projection(ShrinkwrapCalcData *calc, bool for
 	}
 
 	if (calc->smd->auxTarget) {
-		auxMesh = object_get_derived_final(calc->smd->auxTarget, forRender);
+		auxMesh = object_get_derived_final(calc->smd->auxTarget, for_render);
 		if (!auxMesh)
 			return;
 		SPACE_TRANSFORM_SETUP(&local2aux, calc->ob, calc->smd->auxTarget);
@@ -504,7 +505,7 @@ static void shrinkwrap_calc_nearest_surface_point(ShrinkwrapCalcData *calc)
 
 /* Main shrinkwrap function */
 void shrinkwrapModifier_deform(ShrinkwrapModifierData *smd, Object *ob, DerivedMesh *dm,
-                               float (*vertexCos)[3], int numVerts, bool forRender)
+                               float (*vertexCos)[3], int numVerts, bool for_render)
 {
 
 	DerivedMesh *ss_mesh    = NULL;
@@ -532,7 +533,7 @@ void shrinkwrapModifier_deform(ShrinkwrapModifierData *smd, Object *ob, DerivedM
 
 
 	if (smd->target) {
-		calc.target = object_get_derived_final(smd->target, forRender);
+		calc.target = object_get_derived_final(smd->target, for_render);
 
 		/* TODO there might be several "bugs" on non-uniform scales matrixs
 		 * because it will no longer be nearest surface, not sphere projection
@@ -583,7 +584,7 @@ void shrinkwrapModifier_deform(ShrinkwrapModifierData *smd, Object *ob, DerivedM
 				break;
 
 			case MOD_SHRINKWRAP_PROJECT:
-				TIMEIT_BENCH(shrinkwrap_calc_normal_projection(&calc, forRender), deform_project);
+				TIMEIT_BENCH(shrinkwrap_calc_normal_projection(&calc, for_render), deform_project);
 				break;
 
 			case MOD_SHRINKWRAP_NEAREST_VERTEX: