style cleanup: comment blocks

10 files changed, 318 insertions, 323 deletions

diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index 5bd5c09be28..4c683b2b2c8 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -421,7 +421,7 @@ void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob)
 	}
 	
 	/* not all DerivedMeshes store their verts/edges/faces in CustomData, so
-	   we set them here in case they are missing */
+	 * we set them here in case they are missing */
 	if(!CustomData_has_layer(&tmp.vdata, CD_MVERT))
 		CustomData_add_layer(&tmp.vdata, CD_MVERT, CD_ASSIGN, dm->dupVertArray(dm), totvert);
 	if(!CustomData_has_layer(&tmp.edata, CD_MEDGE))
@@ -454,9 +454,9 @@ void DM_to_mesh(DerivedMesh *dm, Mesh *me, Object *ob)
 	CustomData_free(&me->ldata, me->totloop);
 	CustomData_free(&me->pdata, me->totpoly);
 
-	/*  ok, this should now use new CD shapekey data,
-	    which shouuld be fed through the modifier 
-		stack*/
+	/* ok, this should now use new CD shapekey data,
+	 * which shouuld be fed through the modifier
+	 * stack*/
 	if(tmp.totvert != me->totvert && !did_shapekeys && me->key) {
 		printf("YEEK! this should be recoded! Shape key loss!!!\n");
 		if(tmp.key) tmp.key->id.us--;
@@ -787,7 +787,7 @@ static void *get_orco_coords_dm(Object *ob, BMEditMesh *em, int layer, int *free
 	}
 	else if(layer == CD_CLOTH_ORCO) {
 		/* apply shape key for cloth, this should really be solved
-		   by a more flexible customdata system, but not simple */
+		 * by a more flexible customdata system, but not simple */
 		if(!em) {
 			ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
 			KeyBlock *kb= key_get_keyblock(ob_get_key(ob), clmd->sim_parms->shapekey_rest);
@@ -2636,8 +2636,9 @@ void DM_vertex_attributes_from_gpu(DerivedMesh *dm, GPUVertexAttribs *gattribs,
 				attribs->tface[a].glIndex = gattribs->layer[b].glindex;
 				attribs->tface[a].glTexco = gattribs->layer[b].gltexco;
 			}
-			/* BMESH ONLY, may need to get this working?, otherwise remove */
-			/* else {
+			/* BMESH_TODO - BMESH ONLY, may need to get this working?, otherwise remove */
+#if 0
+			else {
 				int player;
 				CustomData *pdata = dm->getPolyDataLayout(dm);
 				
@@ -2657,7 +2658,7 @@ void DM_vertex_attributes_from_gpu(DerivedMesh *dm, GPUVertexAttribs *gattribs,
 					
 				}
 			}
-			*/
+#endif
 		}
 		else if(gattribs->layer[b].type == CD_MCOL) {
 			/* vertex colors */
@@ -2756,13 +2757,14 @@ static void navmesh_drawColored(DerivedMesh *dm)
 	if (!polygonIdx)
 		return;
 
-	/*
+#if 0
 	//UI_ThemeColor(TH_WIRE);
 	glDisable(GL_LIGHTING);
 	glLineWidth(2.0);
 	dm->drawEdges(dm, 0, 1);
 	glLineWidth(1.0);
-	glEnable(GL_LIGHTING);*/
+	glEnable(GL_LIGHTING);
+#endif
 
 	glDisable(GL_LIGHTING);
 	/*  if(GPU_buffer_legacy(dm) ) */ { /* TODO - VBO draw code, not high priority - campbell */
diff --git a/source/blender/blenkernel/intern/cdderivedmesh.c b/source/blender/blenkernel/intern/cdderivedmesh.c
index 7ba9e6b9686..cf435e96332 100644
--- a/source/blender/blenkernel/intern/cdderivedmesh.c
+++ b/source/blender/blenkernel/intern/cdderivedmesh.c
@@ -79,7 +79,7 @@ typedef struct {
 	DerivedMesh dm;
 
 	/* these point to data in the DerivedMesh custom data layers,
-	   they are only here for efficiency and convenience **/
+	 * they are only here for efficiency and convenience **/
 	MVert *mvert;
 	MEdge *medge;
 	MFace *mface;
@@ -237,13 +237,13 @@ static int can_pbvh_draw(Object *ob, DerivedMesh *dm)
 	int deformed= 0;
 
 	/* active modifiers means extra deformation, which can't be handled correct
-	   on bith of PBVH and sculpt "layer" levels, so use PBVH only for internal brush
-	   stuff and show final DerivedMesh so user would see actual object shape */
+	 * on bith of PBVH and sculpt "layer" levels, so use PBVH only for internal brush
+	 * stuff and show final DerivedMesh so user would see actual object shape */
 	deformed|= ob->sculpt->modifiers_active;
 
 	/* as in case with modifiers, we can't synchronize deformation made against
-	   PBVH and non-locked keyblock, so also use PBVH only for brushes and
-	   final DM to give final result to user */
+	 * PBVH and non-locked keyblock, so also use PBVH only for brushes and
+	 * final DM to give final result to user */
 	deformed|= ob->sculpt->kb && (ob->shapeflag&OB_SHAPE_LOCK) == 0;
 
 	if(deformed)
@@ -269,8 +269,8 @@ static struct PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm)
 	}
 
 	/* always build pbvh from original mesh, and only use it for drawing if
-	   this derivedmesh is just original mesh. it's the multires subsurf dm
-	   that this is actually for, to support a pbvh on a modified mesh */
+	 * this derivedmesh is just original mesh. it's the multires subsurf dm
+	 * that this is actually for, to support a pbvh on a modified mesh */
 	if(!cddm->pbvh && ob->type == OB_MESH) {
 		SculptSession *ss= ob->sculpt;
 		Mesh *me= ob->data;
@@ -297,7 +297,7 @@ static struct PBVH *cdDM_getPBVH(Object *ob, DerivedMesh *dm)
 }
 
 /* update vertex normals so that drawing smooth faces works during sculpt
-   TODO: proper fix is to support the pbvh in all drawing modes */
+ * TODO: proper fix is to support the pbvh in all drawing modes */
 static void cdDM_update_normals_from_pbvh(DerivedMesh *dm)
 {
 	CDDerivedMesh *cddm = (CDDerivedMesh*) dm;
@@ -760,7 +760,7 @@ static void cdDM_drawFacesTex_common(DerivedMesh *dm,
 
 				if(!flush && compareDrawOptions) {
 					/* also compare draw options and flush buffer if they're different
-					   need for face selection highlight in edit mode */
+					 * need for face selection highlight in edit mode */
 					flush|= compareDrawOptions(userData, actualFace, next_actualFace) == 0;
 				}
 
@@ -840,7 +840,7 @@ static void cdDM_drawMappedFaces(DerivedMesh *dm,
 					cp = (unsigned char *)&mc[i * 4];
 
 				/* no need to set shading mode to flat because
-				*  normals are already used to change shading */
+				 *  normals are already used to change shading */
 				glShadeModel(GL_SMOOTH);
 				glBegin(mf->v4?GL_QUADS:GL_TRIANGLES);
 
@@ -931,8 +931,8 @@ static void cdDM_drawMappedFaces(DerivedMesh *dm,
 						draw_option= setDrawOptions(userData, orig);
 	
 					/* Goal is to draw as long of a contiguous triangle
-					   array as possible, so draw when we hit either an
-					   invisible triangle or at the end of the array */
+					 * array as possible, so draw when we hit either an
+					 * invisible triangle or at the end of the array */
 
 					/* flush buffer if current triangle isn't drawable or it's last triangle... */
 					flush= (draw_option == DM_DRAW_OPTION_SKIP) || (i == tottri - 1);
@@ -1517,7 +1517,7 @@ void CDDM_recalc_tessellation_ex(DerivedMesh *dm, const int do_face_nor_cpy)
 	cddm->mface = CustomData_get_layer(&dm->faceData, CD_MFACE);
 
 	/* Tessellation recreated faceData, and the active layer indices need to get re-propagated
-	   from loops and polys to faces */
+	 * from loops and polys to faces */
 	CustomData_bmesh_update_active_layers(&dm->faceData, &dm->polyData, &dm->loopData);
 }
 
@@ -1826,8 +1826,8 @@ DerivedMesh *CDDM_from_BMEditMesh(BMEditMesh *em, Mesh *UNUSED(me), int use_mdis
 
 	mask = use_mdisps ? CD_MASK_DERIVEDMESH|CD_MASK_MDISPS : CD_MASK_DERIVEDMESH;
 	
-	/*don't process shapekeys, we only feed them through the modifier stack as needed,
-	  e.g. for applying modifiers or the like*/
+	/* don't process shapekeys, we only feed them through the modifier stack as needed,
+	 * e.g. for applying modifiers or the like*/
 	mask &= ~CD_MASK_SHAPEKEY;
 	CustomData_merge(&bm->vdata, &dm->vertData, mask,
 	                 CD_CALLOC, dm->numVertData);
@@ -1992,7 +1992,7 @@ static DerivedMesh *cddm_copy_ex(DerivedMesh *source, int faces_from_tessfaces)
 	/* any callers that need tessface data can calculate it - campbell */
 #if 0
 	/* BMESH_TODO: Find out why this is necessary (or else find a way to remove
-	   it). If it is necessary, add a comment explaining why. */
+	 * it). If it is necessary, add a comment explaining why. */
 	CDDM_recalc_tessellation((DerivedMesh *)cddm);
 #endif
 
diff --git a/source/blender/blenkernel/intern/depsgraph.c b/source/blender/blenkernel/intern/depsgraph.c
index 72890908457..c178a4ef6ea 100644
--- a/source/blender/blenkernel/intern/depsgraph.c
+++ b/source/blender/blenkernel/intern/depsgraph.c
@@ -595,8 +595,8 @@ static void build_dag_object(DagForest *dag, DagNode *scenenode, Scene *scene, O
 			if(part->ren_as == PART_DRAW_OB && part->dup_ob) {
 				node2 = dag_get_node(dag, part->dup_ob);
 				/* note that this relation actually runs in the wrong direction, the problem
-				   is that dupli system all have this (due to parenting), and the render
-				   engine instancing assumes particular ordering of objects in list */
+				 * is that dupli system all have this (due to parenting), and the render
+				 * engine instancing assumes particular ordering of objects in list */
 				dag_add_relation(dag, node, node2, DAG_RL_OB_OB, "Particle Object Visualisation");
 				if(part->dup_ob->type == OB_MBALL)
 					dag_add_relation(dag, node2, node, DAG_RL_DATA_DATA, "Particle Object Visualisation");
@@ -756,8 +756,8 @@ struct DagForest *build_dag(Main *bmain, Scene *sce, short mask)
 	}
 	
 	/* Now all relations were built, but we need to solve 1 exceptional case;
-	   When objects have multiple "parents" (for example parent + constraint working on same object)
-	   the relation type has to be synced. One of the parents can change, and should give same event to child */
+	 * When objects have multiple "parents" (for example parent + constraint working on same object)
+	 * the relation type has to be synced. One of the parents can change, and should give same event to child */
 	
 	/* nodes were callocced, so we can use node->color for temporal storage */
 	for(node = sce->theDag->DagNode.first; node; node= node->next) {
@@ -1159,9 +1159,8 @@ void graph_bfs(void)
 			}
 			set_node_xy(node, node->BFS_dist*DEPSX*2, pos[node->BFS_dist]*DEPSY*2);
 			node->color = DAG_BLACK;
-			/*
-			fprintf(stderr,"BFS node : %20s %i %5.0f %5.0f\n",((ID *) node->ob)->name,node->BFS_dist, node->x, node->y);
-			*/
+
+			// fprintf(stderr,"BFS node : %20s %i %5.0f %5.0f\n",((ID *) node->ob)->name,node->BFS_dist, node->x, node->y);
 		}
 	}
 	queue_delete(nqueue);
@@ -1185,8 +1184,8 @@ int pre_and_post_source_BFS(DagForest *dag, short mask, DagNode *source, graph_a
 	/* fprintf(stderr,"starting BFS \n ------------\n"); */	
 	
 	/* Init
-		* dagnode.first is always the root (scene)
-		*/
+	 * dagnode.first is always the root (scene)
+	 */
 	node = dag->DagNode.first;
 	nqueue = queue_create(DAGQUEUEALLOC);
 	while(node) {
@@ -1220,9 +1219,8 @@ int pre_and_post_source_BFS(DagForest *dag, short mask, DagNode *source, graph_a
 			}
 			post_func(node->ob,data);
 			node->color = DAG_BLACK;
-			/*
-			fprintf(stderr,"BFS node : %20s %i %5.0f %5.0f\n",((ID *) node->ob)->name,node->BFS_dist, node->x, node->y);
-			*/
+
+			// fprintf(stderr,"BFS node : %20s %i %5.0f %5.0f\n",((ID *) node->ob)->name,node->BFS_dist, node->x, node->y);
 		}
 	}
 	queue_delete(nqueue);
@@ -1303,7 +1301,7 @@ DagNodeQueue * graph_dfs(void)
 						;
 						/* already processed node but we may want later to change distance either to shorter to longer.
 						 * DFS_dist is the first encounter  
-						*/
+						 */
 						/*if (node->DFS_dist >= itA->node->DFS_dist)
 							itA->node->DFS_dist = node->DFS_dist + 1;
 
@@ -1337,9 +1335,8 @@ DagNodeQueue * graph_dfs(void)
 				}
 				set_node_xy(node, node->DFS_dist*DEPSX*2, pos[node->DFS_dist]*DEPSY*2);
 				
-				/*
-				fprintf(stderr,"DFS node : %20s %i %i %i %i\n",((ID *) node->ob)->name,node->BFS_dist, node->DFS_dist, node->DFS_dvtm, node->DFS_fntm );
-				*/
+				// fprintf(stderr,"DFS node : %20s %i %i %i %i\n",((ID *) node->ob)->name,node->BFS_dist, node->DFS_dist, node->DFS_dvtm, node->DFS_fntm );
+
 				push_stack(retqueue,node);
 				
 			}
@@ -1376,8 +1373,8 @@ int pre_and_post_source_DFS(DagForest *dag, short mask, DagNode *source, graph_a
 	nqueue = queue_create(DAGQUEUEALLOC);
 	
 	/* Init
-		* dagnode.first is always the root (scene)
-		*/
+	 * dagnode.first is always the root (scene)
+	 */
 	node = dag->DagNode.first;
 	while(node) {
 		node->color = DAG_WHITE;
@@ -1652,7 +1649,7 @@ void graph_print_adj_list(void)
 /* ************************ API *********************** */
 
 /* mechanism to allow editors to be informed of depsgraph updates,
-   to do their own updates based on changes... */
+ * to do their own updates based on changes... */
 static void (*EditorsUpdateIDCb)(Main *bmain, ID *id)= NULL;
 static void (*EditorsUpdateSceneCb)(Main *bmain, Scene *scene, int updated)= NULL;
 
@@ -2363,7 +2360,7 @@ static void dag_current_scene_layers(Main *bmain, Scene **sce, unsigned int *lay
 	wmWindow *win;
 
 	/* only one scene supported currently, making more scenes work
-	   correctly requires changes beyond just the dependency graph */
+	 * correctly requires changes beyond just the dependency graph */
 
 	*sce= NULL;
 	*lay= 0;
@@ -2383,8 +2380,8 @@ static void dag_current_scene_layers(Main *bmain, Scene **sce, unsigned int *lay
 		if(*sce) *lay= (*sce)->lay;
 
 		/* XXX for background mode, we should get the scene
-		   from somewhere, for the -S option, but it's in
-		   the context, how to get it here? */
+		 * from somewhere, for the -S option, but it's in
+		 * the context, how to get it here? */
 	}
 }
 
@@ -2414,9 +2411,9 @@ void DAG_on_visible_update(Main *bmain, const short do_time)
 	if(scene && scene->theDag) {
 		Scene *sce_iter;
 		/* derivedmeshes and displists are not saved to file so need to be
-		   remade, tag them so they get remade in the scene update loop,
-		   note armature poses or object matrices are preserved and do not
-		   require updates, so we skip those */
+		 * remade, tag them so they get remade in the scene update loop,
+		 * note armature poses or object matrices are preserved and do not
+		 * require updates, so we skip those */
 		dag_scene_flush_layers(scene, lay);
 
 		for(SETLOOPER(scene, sce_iter, base)) {
@@ -2471,7 +2468,7 @@ static void dag_id_flush_update(Scene *sce, ID *id)
 	short idtype;
 
 	/* here we flush a few things before actual scene wide flush, mostly
-	   due to only objects and not other datablocks being in the depsgraph */
+	 * due to only objects and not other datablocks being in the depsgraph */
 
 	/* set flags & pointcache for object */
 	if(GS(id->name) == ID_OB) {
@@ -2591,8 +2588,8 @@ static void dag_id_flush_update(Scene *sce, ID *id)
 		}
 
 		/* camera's matrix is used to orient reconstructed stuff,
-		   so it should happen tracking-related constraints recalculation
-		   when camera is changing (sergey) */
+		 * so it should happen tracking-related constraints recalculation
+		 * when camera is changing (sergey) */
 		if(sce->camera && &sce->camera->id == id) {
 			MovieClip *clip = object_get_movieclip(sce, sce->camera, 1);
 
@@ -2625,7 +2622,7 @@ void DAG_ids_flush_tagged(Main *bmain)
 		ID *id = lb->first;
 
 		/* we tag based on first ID type character to avoid 
-		   looping over all ID's in case there are no tags */
+		 * looping over all ID's in case there are no tags */
 		if(id && bmain->id_tag_update[id->name[0]]) {
 			for(; id; id=id->next) {
 				if(id->flag & (LIB_ID_RECALC|LIB_ID_RECALC_DATA)) {
@@ -2654,7 +2651,7 @@ void DAG_ids_check_recalc(Main *bmain, Scene *scene, int time)
 		ID *id = lb->first;
 
 		/* we tag based on first ID type character to avoid 
-		   looping over all ID's in case there are no tags */
+		 * looping over all ID's in case there are no tags */
 		if(id && bmain->id_tag_update[id->name[0]]) {
 			updated= 1;
 			break;
@@ -2677,7 +2674,7 @@ void DAG_ids_clear_recalc(Main *bmain)
 		ID *id = lb->first;
 
 		/* we tag based on first ID type character to avoid 
-		   looping over all ID's in case there are no tags */
+		 * looping over all ID's in case there are no tags */
 		if(id && bmain->id_tag_update[id->name[0]]) {
 			for(; id; id=id->next)
 				if(id->flag & (LIB_ID_RECALC|LIB_ID_RECALC_DATA))
diff --git a/source/blender/blenkernel/intern/displist.c b/source/blender/blenkernel/intern/displist.c
index 6383f7b9040..d10c060cc7f 100644
--- a/source/blender/blenkernel/intern/displist.c
+++ b/source/blender/blenkernel/intern/displist.c
@@ -613,10 +613,10 @@ static void curve_to_filledpoly(Curve *cu, ListBase *UNUSED(nurb), ListBase *dis
 }
 
 /* taper rules:
-  - only 1 curve
-  - first point left, last point right
-  - based on subdivided points in original curve, not on points in taper curve (still)
-*/
+ * - only 1 curve
+ * - first point left, last point right
+ * - based on subdivided points in original curve, not on points in taper curve (still)
+ */
 float calc_taper(Scene *scene, Object *taperobj, int cur, int tot)
 {
 	DispList *dl;
@@ -710,8 +710,8 @@ static ModifierData *curve_get_tesselate_point(Scene *scene, Object *ob, int for
 			preTesselatePoint = md;
 
 			/* this modifiers are moving point of tessellation automatically
-			   (some of them even can't be applied on tesselated curve), set flag
-			   for incformation button in modifier's header */
+			 * (some of them even can't be applied on tesselated curve), set flag
+			 * for incformation button in modifier's header */
 			md->mode |= eModifierMode_ApplyOnSpline;
 		} else if(md->mode&eModifierMode_ApplyOnSpline) {
 			preTesselatePoint = md;
@@ -746,9 +746,9 @@ static void curve_calc_modifiers_pre(Scene *scene, Object *ob, int forRender, fl
 
 		if(keyVerts) {
 			/* split coords from key data, the latter also includes
-			   tilts, which is passed through in the modifier stack.
-			   this is also the reason curves do not use a virtual
-			   shape key modifier yet. */
+			 * tilts, which is passed through in the modifier stack.
+			 * this is also the reason curves do not use a virtual
+			 * shape key modifier yet. */
 			deformedVerts= curve_getKeyVertexCos(cu, nurb, keyVerts);
 			originalVerts= MEM_dupallocN(deformedVerts);
 		}
@@ -1168,8 +1168,8 @@ void makeDispListSurf(Scene *scene, Object *ob, ListBase *dispbase,
 	}
 
 	/* make copy of 'undeformed" displist for texture space calculation
-	   actually, it's not totally undeformed -- pre-tessellation modifiers are
-	   already applied, thats how it worked for years, so keep for compatibility (sergey) */
+	 * actually, it's not totally undeformed -- pre-tessellation modifiers are
+	 * already applied, thats how it worked for years, so keep for compatibility (sergey) */
 	copy_displist(&cu->disp, dispbase);
 
 	if (!forRender) {
@@ -1394,8 +1394,8 @@ static void do_makeDispListCurveTypes(Scene *scene, Object *ob, ListBase *dispba
 		if(cu->flag & CU_PATH) calc_curvepath(ob);
 
 		/* make copy of 'undeformed" displist for texture space calculation
-		   actually, it's not totally undeformed -- pre-tessellation modifiers are
-		   already applied, thats how it worked for years, so keep for compatibility (sergey) */
+		 * actually, it's not totally undeformed -- pre-tessellation modifiers are
+		 * already applied, thats how it worked for years, so keep for compatibility (sergey) */
 		copy_displist(&cu->disp, dispbase);
 
 		if (!forRender) {
@@ -1416,8 +1416,8 @@ void makeDispListCurveTypes(Scene *scene, Object *ob, int forOrco)
 	ListBase *dispbase;
 
 	/* The same check for duplis as in do_makeDispListCurveTypes.
-	   Happens when curve used for constraint/bevel was converted to mesh.
-	   check there is still needed for render displist and orco displists. */
+	 * Happens when curve used for constraint/bevel was converted to mesh.
+	 * check there is still needed for render displist and orco displists. */
 	if(!ELEM3(ob->type, OB_SURF, OB_CURVE, OB_FONT)) return;
 
 	freedisplist(&(ob->disp));
diff --git a/source/blender/blenkernel/intern/dynamicpaint.c b/source/blender/blenkernel/intern/dynamicpaint.c
index 5280215d15c..2c7814a6a43 100644
--- a/source/blender/blenkernel/intern/dynamicpaint.c
+++ b/source/blender/blenkernel/intern/dynamicpaint.c
@@ -156,7 +156,7 @@ typedef struct PaintBakeData {
 	int *s_pos;	/* index to start reading point sample realCoord */
 	int *s_num;	/* num of realCoord samples */
 	Vec3f *realCoord;  /* current pixel center world-space coordinates for each sample
-					   *  ordered as (s_pos+s_num)*/
+	                    *  ordered as (s_pos+s_num)*/
 	Bounds3D mesh_bounds;
 
 	/* adjacency info */
@@ -4145,9 +4145,9 @@ static int dynamicPaint_prepareEffectStep(DynamicPaintSurface *surface, Scene *s
 	return steps;
 }
 
-/*
-*	Processes active effect step.
-*/
+/**
+ *	Processes active effect step.
+ */
 static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force, PaintPoint *prevPoint, float timescale, float steps)
 {
 	PaintSurfaceData *sData = surface->data;
@@ -4159,8 +4159,8 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
 	if (!sData->adj_data) return;
 
 	/*
-	*	Spread Effect
-	*/
+	 *	Spread Effect
+	 */
 	if (surface->effect & MOD_DPAINT_EFFECT_DO_SPREAD) {
 		float eff_scale = distance_scale*EFF_MOVEMENT_PER_FRAME*surface->spread_speed*timescale;
 
@@ -4175,7 +4175,7 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
 			PaintPoint *pPoint = &((PaintPoint*)sData->type_data)[index];
 
 			/*  Only reads values from the surface copy (prevPoint[]),
-			*	so this one is thread safe */
+			 *	so this one is thread safe */
 
 			/*	Loop through neighboring points	*/
 			for (i=0; i<numOfNeighs; i++) {
@@ -4202,8 +4202,8 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
 	}
 
 	/*
-	*	Shrink Effect
-	*/
+	 *	Shrink Effect
+	 */
 	if (surface->effect & MOD_DPAINT_EFFECT_DO_SHRINK) {
 		float eff_scale = distance_scale*EFF_MOVEMENT_PER_FRAME*surface->shrink_speed*timescale;
 
@@ -4227,7 +4227,7 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
 				totalAlpha += ePoint->e_alpha;
 
 				/* Check if neighboring point has lower alpha,
-				*  if so, decrease this point's alpha as well*/
+				 *  if so, decrease this point's alpha as well*/
 				if (pPoint->alpha <= 0.0f && pPoint->e_alpha <= 0.0f && pPoint->wetness <= 0.0f) continue;
 
 				/* decrease factor for dry paint alpha */
@@ -4251,8 +4251,8 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
 	}
 
 	/*
-	*	Drip Effect
-	*/
+	 *	Drip Effect
+	 */
 	if (surface->effect & MOD_DPAINT_EFFECT_DO_DRIP && force) 
 	{
 		float eff_scale = distance_scale*EFF_MOVEMENT_PER_FRAME*timescale/2.0f;
@@ -4450,8 +4450,8 @@ static void dynamicPaint_surfacePreStep(DynamicPaintSurface *surface, float time
 						dry_ratio = pPoint->wetness/p_wetness;
 
 						/*
-						*	Slowly "shift" paint from wet layer to dry layer as it drys:
-						*/
+						 *	Slowly "shift" paint from wet layer to dry layer as it drys:
+						 */
 						/* make sure alpha values are within proper range */
 						CLAMP(pPoint->alpha, 0.0f, 1.0f);
 						CLAMP(pPoint->e_alpha, 0.0f, 1.0f);
@@ -4464,7 +4464,7 @@ static void dynamicPaint_surfacePreStep(DynamicPaintSurface *surface, float time
 						/* now calculate new alpha for dry layer that keeps final blended color unchanged */
 						pPoint->alpha = (f_color[3] - pPoint->e_alpha)/(1.0f-pPoint->e_alpha);
 						/* for each rgb component, calculate a new dry layer color that keeps the final blend color
-						*  with these new alpha values. (wet layer color doesnt change)*/
+						 *  with these new alpha values. (wet layer color doesnt change)*/
 						if (pPoint->alpha) {
 							for (i=0; i<3; i++) {
 								pPoint->color[i] = (f_color[i]*f_color[3] - pPoint->e_color[i]*pPoint->e_alpha)/(pPoint->alpha*(1.0f-pPoint->e_alpha));
@@ -4635,8 +4635,8 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, Scene *sc
 	}
 
 	/*
-	*	Make a transformed copy of canvas derived mesh vertices to avoid recalculation.
-	*/
+	 *	Make a transformed copy of canvas derived mesh vertices to avoid recalculation.
+	 */
 	bData->mesh_bounds.valid = 0;
 	for (index=0; index<canvasNumOfVerts; index++) {
 		copy_v3_v3(canvas_verts[index].v, mvert[index].co);
@@ -4645,8 +4645,8 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, Scene *sc
 	}
 
 	/*
-	*	Prepare each surface point for a new step
-	*/
+	 *	Prepare each surface point for a new step
+	 */
 	#pragma omp parallel for schedule(static)
 	for (index=0; index<sData->total_points; index++)
 	{
@@ -4655,8 +4655,8 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, Scene *sc
 			copy_v3_v3(prev_point, bData->realCoord[bData->s_pos[index]].v);
 		}
 		/*
-		*	Calculate current 3D-position and normal of each surface point
-		*/
+		 *	Calculate current 3D-position and normal of each surface point
+		 */
 		if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
 			float n1[3], n2[3], n3[3];
 			ImgSeqFormatData *f_data = (ImgSeqFormatData*)sData->format_data;
@@ -4716,7 +4716,7 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, Scene *sc
 		}
 
 		/* Prepare surface normal directional scale to easily convert
-		*  brush intersection amount between global and local space */
+		 *  brush intersection amount between global and local space */
 		if (surface->type == MOD_DPAINT_SURFACE_T_DISPLACE ||
 			surface->type == MOD_DPAINT_SURFACE_T_WAVE) {
 			float temp_nor[3];
diff --git a/source/blender/blenkernel/intern/multires.c b/source/blender/blenkernel/intern/multires.c
index 95f4b465beb..6581c442356 100644
--- a/source/blender/blenkernel/intern/multires.c
+++ b/source/blender/blenkernel/intern/multires.c
@@ -106,8 +106,8 @@ MultiresModifierData *find_multires_modifier_before(Scene *scene, ModifierData *
 }
 
 /* used for applying scale on mdisps layer and syncing subdivide levels when joining objects
-   use_first - return first multires modifier if all multires'es are disabled
-*/
+ * use_first - return first multires modifier if all multires'es are disabled
+ */
 MultiresModifierData *get_multires_modifier(Scene *scene, Object *ob, int use_first)
 {
 	ModifierData *md;
@@ -128,7 +128,7 @@ MultiresModifierData *get_multires_modifier(Scene *scene, Object *ob, int use_fi
 
 	if (!mmd && use_first) {
 		/* active multires have not been found
-		   try to use first one */
+		 * try to use first one */
 		return firstmmd;
 	}
 
@@ -491,7 +491,7 @@ static DerivedMesh *subsurf_dm_create_local(Object *ob, DerivedMesh *dm, int lvl
 
 
 /* assumes no is normalized; return value's sign is negative if v is on
-   the other side of the plane */
+ * the other side of the plane */
 static float v3_dist_from_plane(float v[3], float center[3], float no[3])
 {
 	float s[3];
@@ -572,7 +572,7 @@ void multiresModifier_base_apply(MultiresModifierData *mmd, Object *ob)
 			float no[3];
 
 			/* set up poly, loops, and coords in order to call
-			   mesh_calc_poly_normal_coords() */
+			 * mesh_calc_poly_normal_coords() */
 			fake_poly.totloop = p->totloop;
 			fake_poly.loopstart = 0;
 			fake_loops = MEM_mallocN(sizeof(MLoop) * p->totloop, "fake_loops");
@@ -813,20 +813,20 @@ static void multiresModifier_disp_run(DerivedMesh *dm, Mesh *me, DerivedMesh *dm
 					switch(op) {
 					case APPLY_DISPLACEMENTS:
 						/* Convert displacement to object space
-						   and add to grid points */
+						 * and add to grid points */
 						mul_v3_m3v3(disp, mat, data);
 						add_v3_v3v3(co, sco, disp);
 						break;
 					case CALC_DISPLACEMENTS:
 						/* Calculate displacement between new and old
-						   grid points and convert to tangent space */
+						 * grid points and convert to tangent space */
 						sub_v3_v3v3(disp, co, sco);
 						invert_m3(mat);
 						mul_v3_m3v3(data, mat, disp);
 						break;
 					case ADD_DISPLACEMENTS:
 						/* Convert subdivided displacements to tangent
-						   space and add to the original displacements */
+						 * space and add to the original displacements */
 						invert_m3(mat);
 						mul_v3_m3v3(d, mat, co);
 						add_v3_v3(data, d);
@@ -1138,7 +1138,7 @@ DerivedMesh *multires_dm_create_from_derived(MultiresModifierData *mmd, int loca
 }
 
 /**** Old Multires code ****
-***************************/
+ ***************************/
 
 /* Adapted from sculptmode.c */
 void old_mdisps_bilinear(float out[3], float (*disps)[3], const int st, float u, float v)
@@ -1669,7 +1669,7 @@ static void multires_load_old_vcols(Mesh *me)
 		return;
 
 	/* older multires format never supported multiple vcol layers,
-	   so we can assume the active vcol layer is the correct one */
+	 * so we can assume the active vcol layer is the correct one */
 	if (!(mcol = CustomData_get_layer(&me->fdata, CD_MCOL)))
 		return;
 	
@@ -1776,9 +1776,9 @@ static void multires_sync_levels(Scene *scene, Object *ob, Object *to_ob)
 
 	if (!mmd) {
 		/* object could have MDISP even when there is no multires modifier
-		   this could lead to troubles due to i've got no idea how mdisp could be
-		   upsampled correct without modifier data.
-		   just remove mdisps if no multires present (nazgul) */
+		 * this could lead to troubles due to i've got no idea how mdisp could be
+		 * upsampled correct without modifier data.
+		 * just remove mdisps if no multires present (nazgul) */
 
 		Mesh *me= (Mesh*)ob->data;
 
diff --git a/source/blender/blenkernel/intern/seqeffects.c b/source/blender/blenkernel/intern/seqeffects.c
index 6a72933332b..b24b885c001 100644
--- a/source/blender/blenkernel/intern/seqeffects.c
+++ b/source/blender/blenkernel/intern/seqeffects.c
@@ -119,8 +119,8 @@ static struct ImBuf * prepare_effect_imbufs(
 }
 
 /* **********************************************************************
-   PLUGINS
-   ********************************************************************** */
+ * PLUGINS
+ * ********************************************************************** */
 
 static void open_plugin_seq(PluginSeq *pis, const char *seqname)
 {
@@ -288,8 +288,8 @@ static struct ImBuf * do_plugin_effect(
 	char *cp;
 	int float_rendering;
 	int use_temp_bufs = 0; /* Are needed since blur.c (and maybe some other
-				  old plugins) do very bad stuff
-				  with imbuf-internals */
+	                        * old plugins) do very bad stuff
+	                        * with imbuf-internals */
 
 	struct ImBuf * out = prepare_effect_imbufs(context,ibuf1, ibuf2, ibuf3);
 	int x = context.rectx;
@@ -394,8 +394,8 @@ static void free_plugin(struct Sequence * seq)
 }
 
 /* **********************************************************************
-   ALPHA OVER
-   ********************************************************************** */
+ * ALPHA OVER
+ * ********************************************************************** */
 
 static void init_alpha_over_or_under(Sequence * seq)
 {
@@ -558,8 +558,8 @@ static struct ImBuf * do_alphaover_effect(
 
 
 /* **********************************************************************
-   ALPHA UNDER
-   ********************************************************************** */
+ * ALPHA UNDER
+ * ********************************************************************** */
 
 static void do_alphaunder_effect_byte(
 	float facf0, float facf1, int x, int y, char *rect1, 
@@ -730,8 +730,8 @@ static struct ImBuf* do_alphaunder_effect(
 
 
 /* **********************************************************************
-   CROSS
-   ********************************************************************** */
+ * CROSS
+ * ********************************************************************** */
 
 static void do_cross_effect_byte(float facf0, float facf1, int x, int y, 
 			  char *rect1, char *rect2, 
@@ -855,8 +855,8 @@ static struct ImBuf* do_cross_effect(
 
 
 /* **********************************************************************
-   GAMMA CROSS
-   ********************************************************************** */
+ * GAMMA CROSS
+ * ********************************************************************** */
 
 /* copied code from initrender.c */
 static unsigned short gamtab[65536];
@@ -1124,8 +1124,8 @@ static struct ImBuf * do_gammacross_effect(
 
 
 /* **********************************************************************
-   ADD
-   ********************************************************************** */
+ * ADD
+ * ********************************************************************** */
 
 static void do_add_effect_byte(float facf0, float facf1, int x, int y, 
 				   unsigned char *rect1, unsigned char *rect2, 
@@ -1240,8 +1240,8 @@ static struct ImBuf * do_add_effect(SeqRenderData context,
 
 
 /* **********************************************************************
-   SUB
-   ********************************************************************** */
+ * SUB
+ * ********************************************************************** */
 
 static void do_sub_effect_byte(float facf0, float facf1, 
 				   int x, int y, 
@@ -1355,8 +1355,8 @@ static struct ImBuf * do_sub_effect(
 }
 
 /* **********************************************************************
-   DROP
-   ********************************************************************** */
+ * DROP
+ * ********************************************************************** */
 
 /* Must be > 0 or add precopy, etc to the function */
 #define XOFF	8
@@ -1444,8 +1444,8 @@ static void do_drop_effect_float(float facf0, float facf1, int x, int y,
 }
 
 /* **********************************************************************
-   MUL
-   ********************************************************************** */
+ * MUL
+ * ********************************************************************** */
 
 static void do_mul_effect_byte(float facf0, float facf1, int x, int y, 
 				   unsigned char *rect1, unsigned char *rect2, 
@@ -1464,7 +1464,7 @@ static void do_mul_effect_byte(float facf0, float facf1, int x, int y,
 
 	/* formula:
 	 *		fac*(a*b) + (1-fac)*a  => fac*a*(b-1)+axaux= c*px + py*s ;//+centx
-			yaux= -s*px + c*py;//+centy
+	 *		yaux= -s*px + c*py;//+centy
 	 */
 
 	while(y--) {
@@ -1569,8 +1569,8 @@ static struct ImBuf * do_mul_effect(
 }
 
 /* **********************************************************************
-   WIPE
-   ********************************************************************** */
+ * WIPE
+ * ********************************************************************** */
 
 typedef struct WipeZone {
 	float angle;
@@ -1616,9 +1616,8 @@ static float check_zone(WipeZone *wipezone, int x, int y,
 	Sequence *seq, float facf0) 
 {
 	float posx, posy,hyp,hyp2,angle,hwidth,b1,b2,b3,pointdist;
-/*some future stuff
-float hyp3,hyp4,b4,b5	   
-*/
+	/* some future stuff */
+	// float hyp3,hyp4,b4,b5
 	float temp1,temp2,temp3,temp4; //some placeholder variables
 	int xo = wipezone->xo;
 	int yo = wipezone->yo;
@@ -1714,12 +1713,12 @@ float hyp3,hyp4,b4,b5
 			if(!wipe->forward)output = 1-output;
 		break;
 		case DO_CLOCK_WIPE:
-			  /*
-				  temp1: angle of effect center in rads
-				  temp2: angle of line through (halfx,halfy) and (x,y) in rads
-				  temp3: angle of low side of blur
-				  temp4: angle of high side of blur
-			  */
+			/*
+			 *  temp1: angle of effect center in rads
+			 *  temp2: angle of line through (halfx,halfy) and (x,y) in rads
+			 *  temp3: angle of low side of blur
+			 *  temp4: angle of high side of blur
+			 */
 			output = 1.0f - facf0;
 			widthf = wipe->edgeWidth*2.0f*(float)M_PI;
 			temp1 = 2.0f * (float)M_PI * facf0;
@@ -2002,8 +2001,8 @@ static struct ImBuf * do_wipe_effect(
 	return out;
 }
 /* **********************************************************************
-   TRANSFORM
-   ********************************************************************** */
+ * TRANSFORM
+ * ********************************************************************** */
 static void init_transform_effect(Sequence *seq)
 {
 	TransformVars *transform;
@@ -2140,8 +2139,8 @@ static struct ImBuf * do_transform_effect(
 
 
 /* **********************************************************************
-   GLOW
-   ********************************************************************** */
+ * GLOW
+ * ********************************************************************** */
 
 static void RVBlurBitmap2_byte ( unsigned char* map, int width,int height,
 				 float blur,
@@ -2667,8 +2666,8 @@ static struct ImBuf * do_glow_effect(
 }
 
 /* **********************************************************************
-   SOLID COLOR
-   ********************************************************************** */
+ * SOLID COLOR
+ * ********************************************************************** */
 
 static void init_solid_color(Sequence *seq)
 {
@@ -2786,8 +2785,8 @@ static struct ImBuf * do_solid_color(
 }
 
 /* **********************************************************************
-   MULTICAM
-   ********************************************************************** */
+ * MULTICAM
+ * ********************************************************************** */
 
 /* no effect inputs for multicam, we use give_ibuf_seq */
 static int num_inputs_multicam(void)
@@ -2840,8 +2839,8 @@ static struct ImBuf * do_multicam(
 }
 
 /* **********************************************************************
-   ADJUSTMENT
-   ********************************************************************** */
+ * ADJUSTMENT
+ * ********************************************************************** */
 
 /* no effect inputs for adjustment, we use give_ibuf_seq */
 static int num_inputs_adjustment(void)
@@ -2871,10 +2870,10 @@ static struct ImBuf * do_adjustment_impl(SeqRenderData context, Sequence * seq,
 	}
 
 	/* found nothing? so let's work the way up the metastrip stack, so
-	   that it is possible to group a bunch of adjustment strips into
-	   a metastrip and have that work on everything below the metastrip
-	*/
-	   
+	 *  that it is possible to group a bunch of adjustment strips into
+	 *  a metastrip and have that work on everything below the metastrip
+	 */
+
 	if (!i) {
 		Sequence * meta;
 
@@ -2917,8 +2916,8 @@ static struct ImBuf * do_adjustment(
 }
 
 /* **********************************************************************
-   SPEED
-   ********************************************************************** */
+ * SPEED
+ * ********************************************************************** */
 static void init_speed_effect(Sequence *seq)
 {
 	SpeedControlVars * v;
@@ -3010,8 +3009,7 @@ void sequence_effect_speed_rebuild_map(Scene *scene, Sequence * seq, int force)
 	}
 	if (	(seq->seq1 == NULL) ||
 	        (seq->len < 1)
-	) { /* make coverity happy and check for (CID 598)
-						 input strip ... */
+	) { /* make coverity happy and check for (CID 598) input strip ... */
 		return;
 	}
 
diff --git a/source/blender/blenkernel/intern/sequencer.c b/source/blender/blenkernel/intern/sequencer.c
index 4b2a2fef27f..8f8874d3a3c 100644
--- a/source/blender/blenkernel/intern/sequencer.c
+++ b/source/blender/blenkernel/intern/sequencer.c
@@ -124,8 +124,8 @@ int seq_recursive_apply(Sequence *seq, int (*apply_func)(Sequence *, void *), vo
 }
 
 /* **********************************************************************
-   alloc / free functions
-   ********************************************************************** */
+ * alloc / free functions
+ * ********************************************************************** */
 
 
 
@@ -281,8 +281,8 @@ void seq_free_editing(Scene *scene)
 }
 
 /* **********************************************************************
-   * sequencer pipeline functions
-   ********************************************************************** */
+ * sequencer pipeline functions
+ * ********************************************************************** */
 
 SeqRenderData seq_new_render_data(
 	struct Main * bmain, struct Scene * scene,
@@ -456,13 +456,13 @@ void seq_end(SeqIterator *iter)
 }
 
 /*
-  **********************************************************************
-  * build_seqar
-  **********************************************************************
-  * Build a complete array of _all_ sequencies (including those
-  * in metastrips!)
-  **********************************************************************
-*/
+ * **********************************************************************
+ * build_seqar
+ * *********************************************************************
+ * Build a complete array of _all_ sequencies (including those
+ * in metastrips!)
+ * *********************************************************************
+ */
 
 static void do_seq_count_cb(ListBase *seqbase, int *totseq,
 				int (*test_func)(Sequence * seq))
@@ -1048,11 +1048,11 @@ StripElem *give_stripelem(Sequence *seq, int cfra)
 {
 	StripElem *se= seq->strip->stripdata;
 
-	if(seq->type == SEQ_IMAGE) { /* only 
-					IMAGE strips use the whole array,
-					MOVIE strips use only 
-					the first element, all other strips
-					don't use this... */
+	if(seq->type == SEQ_IMAGE) { /* only
+		                          * IMAGE strips use the whole array,
+		                          * MOVIE strips use only
+		                          * the first element, all other strips
+		                          * don't use this... */
 		int nr = (int) give_stripelem_index(seq, cfra);
 
 		if (nr == -1 || se == NULL) return NULL;
@@ -1137,8 +1137,8 @@ static int get_shown_sequences(	ListBase * seqbasep, int cfra, int chanshown, Se
 
 
 /* **********************************************************************
-   proxy management
-   ********************************************************************** */
+ * proxy management
+ * ********************************************************************** */
 
 typedef struct SeqIndexBuildContext {
 	struct IndexBuildContext *index_context;
@@ -1214,12 +1214,12 @@ static int seq_proxy_get_fname(Sequence * seq, int cfra, int render_size, char *
 	}
 
 	/* MOVIE tracks (only exception: custom files) are now handled 
-	   internally by ImBuf module for various reasons: proper time code 
-	   support, quicker index build, using one file instead 
-	   of a full directory of jpeg files, etc. Trying to support old
-	   and new method at once could lead to funny effects, if people
-	   have both, a directory full of jpeg files and proxy avis, so
-	   sorry folks, please rebuild your proxies... */
+	 * internally by ImBuf module for various reasons: proper time code
+	 * support, quicker index build, using one file instead
+	 * of a full directory of jpeg files, etc. Trying to support old
+	 * and new method at once could lead to funny effects, if people
+	 * have both, a directory full of jpeg files and proxy avis, so
+	 * sorry folks, please rebuild your proxies... */
 
 	if (seq->flag & (SEQ_USE_PROXY_CUSTOM_DIR|SEQ_USE_PROXY_CUSTOM_FILE)) {
 		BLI_strncpy(dir, seq->strip->proxy->dir, sizeof(dir));
@@ -1339,7 +1339,7 @@ static void seq_proxy_build_frame(SeqRenderData context,
 	}
 
 	/* depth = 32 is intentionally left in, otherwise ALPHA channels
-	   won't work... */
+	 * won't work... */
 	quality = seq->strip->proxy->quality;
 	ibuf->ftype= JPG | quality;
 
@@ -1465,8 +1465,8 @@ void seq_proxy_rebuild_finish(SeqIndexBuildContext *context, short stop)
 }
 
 /* **********************************************************************
-   color balance 
-   ********************************************************************** */
+ * color balance
+ * ********************************************************************** */
 
 static StripColorBalance calc_cb(StripColorBalance * cb_)
 {
@@ -1628,23 +1628,22 @@ static void color_balance(Sequence * seq, ImBuf* ibuf, float mul)
 }
 
 /*
-  input preprocessing for SEQ_IMAGE, SEQ_MOVIE and SEQ_SCENE
-
-  Do all the things you can't really do afterwards using sequence effects
-  (read: before rescaling to render resolution has been done)
-
-  Order is important!
-
-  - Deinterlace
-  - Crop and transform in image source coordinate space
-  - Flip X + Flip Y (could be done afterwards, backward compatibility)
-  - Promote image to float data (affects pipeline operations afterwards)
-  - Color balance (is most efficient in the byte -> float 
-	(future: half -> float should also work fine!)
-	case, if done on load, since we can use lookup tables)
-  - Premultiply
-
-*/
+ *  input preprocessing for SEQ_IMAGE, SEQ_MOVIE and SEQ_SCENE
+ *
+ *  Do all the things you can't really do afterwards using sequence effects
+ *  (read: before rescaling to render resolution has been done)
+ *
+ *  Order is important!
+ *
+ *  - Deinterlace
+ *  - Crop and transform in image source coordinate space
+ *  - Flip X + Flip Y (could be done afterwards, backward compatibility)
+ *  - Promote image to float data (affects pipeline operations afterwards)
+ *  - Color balance (is most efficient in the byte -> float
+ *    (future: half -> float should also work fine!)
+ *    case, if done on load, since we can use lookup tables)
+ *  - Premultiply
+ */
 
 int input_have_to_preprocess(
 	SeqRenderData UNUSED(context), Sequence * seq, float UNUSED(cfra))
@@ -1824,8 +1823,8 @@ static void copy_to_ibuf_still(SeqRenderData context, Sequence * seq, float nr,
 {
 	if (nr == 0 || nr == seq->len - 1) {
 		/* we have to store a copy, since the passed ibuf
-		   could be preprocessed afterwards (thereby silently
-		   changing the cached image... */
+		 * could be preprocessed afterwards (thereby silently
+		 * changing the cached image... */
 		ibuf = IMB_dupImBuf(ibuf);
 
 		if (nr == 0) {
@@ -1845,8 +1844,8 @@ static void copy_to_ibuf_still(SeqRenderData context, Sequence * seq, float nr,
 }
 
 /* **********************************************************************
-   strip rendering functions
-   ********************************************************************** */
+ * strip rendering functions
+ * ********************************************************************** */
 
 static ImBuf* seq_render_strip_stack( 
 	SeqRenderData context, ListBase *seqbasep, float cfra, int chanshown);
@@ -1964,35 +1963,35 @@ static ImBuf * seq_render_scene_strip_impl(
 	ListBase oldmarkers;
 	
 	/* Old info:
-	   Hack! This function can be called from do_render_seq(), in that case
-	   the seq->scene can already have a Render initialized with same name,
-	   so we have to use a default name. (compositor uses scene name to
-	   find render).
-	   However, when called from within the UI (image preview in sequencer)
-	   we do want to use scene Render, that way the render result is defined
-	   for display in render/imagewindow
-	   
-	   Hmm, don't see, why we can't do that all the time,
-	   and since G.rendering is uhm, gone... (Peter)
-	*/
+	 * Hack! This function can be called from do_render_seq(), in that case
+	 * the seq->scene can already have a Render initialized with same name,
+	 * so we have to use a default name. (compositor uses scene name to
+	 * find render).
+	 * However, when called from within the UI (image preview in sequencer)
+	 * we do want to use scene Render, that way the render result is defined
+	 * for display in render/imagewindow
+	 *
+	 * Hmm, don't see, why we can't do that all the time,
+	 * and since G.rendering is uhm, gone... (Peter)
+	 */
 
 	/* New info:
-	   Using the same name for the renders works just fine as the do_render_seq()
-	   render is not used while the scene strips are rendered.
-	   
-	   However rendering from UI (through sequencer_preview_area_draw) can crash in
-	   very many cases since other renders (material preview, an actual render etc.)
-	   can be started while this sequence preview render is running. The only proper
-	   solution is to make the sequencer preview render a proper job, which can be
-	   stopped when needed. This would also give a nice progress bar for the preview
-	   space so that users know there's something happening.
-
-	   As a result the active scene now only uses OpenGL rendering for the sequencer
-	   preview. This is far from nice, but is the only way to prevent crashes at this
-	   time. 
-
-	   -jahka
-	*/
+	 * Using the same name for the renders works just fine as the do_render_seq()
+	 * render is not used while the scene strips are rendered.
+	 *
+	 * However rendering from UI (through sequencer_preview_area_draw) can crash in
+	 * very many cases since other renders (material preview, an actual render etc.)
+	 * can be started while this sequence preview render is running. The only proper
+	 * solution is to make the sequencer preview render a proper job, which can be
+	 * stopped when needed. This would also give a nice progress bar for the preview
+	 * space so that users know there's something happening.
+	 *
+	 * As a result the active scene now only uses OpenGL rendering for the sequencer
+	 * preview. This is far from nice, but is the only way to prevent crashes at this
+	 * time.
+	 *
+	 * -jahka
+	 */
 
 	int rendering = G.rendering;
 	int doseq;
@@ -2120,7 +2119,7 @@ static ImBuf * seq_render_strip(SeqRenderData context, Sequence * seq, float cfr
 	ibuf = seq_stripelem_cache_get(context, seq, cfra, SEQ_STRIPELEM_IBUF);
 
 	/* currently, we cache preprocessed images in SEQ_STRIPELEM_IBUF,
-	   but not(!) on SEQ_STRIPELEM_IBUF_ENDSTILL and ..._STARTSTILL */
+	 * but not(!) on SEQ_STRIPELEM_IBUF_ENDSTILL and ..._STARTSTILL */
 	if (ibuf)
 		use_preprocess = FALSE;
 
@@ -2263,15 +2262,15 @@ static ImBuf * seq_render_strip(SeqRenderData context, Sequence * seq, float cfr
 }
 
 /* **********************************************************************
-   strip stack rendering functions
-   ********************************************************************** */
+ * strip stack rendering functions
+ * ********************************************************************** */
 
 static int seq_must_swap_input_in_blend_mode(Sequence * seq)
 {
 	int swap_input = FALSE;
 
 	/* bad hack, to fix crazy input ordering of 
-	   those two effects */
+	 * those two effects */
 
 	if (ELEM3(seq->blend_mode, SEQ_ALPHAOVER, SEQ_ALPHAUNDER, SEQ_OVERDROP)) {
 		swap_input = TRUE;
@@ -2808,13 +2807,13 @@ void free_imbuf_seq(Scene *scene, ListBase * seqbase, int check_mem_usage,
 	if (check_mem_usage) {
 		/* Let the cache limitor take care of this (schlaile) */
 		/* While render let's keep all memory available for render 
-		   (ton)
-		   At least if free memory is tight...
-		   This can make a big difference in encoding speed
-		   (it is around 4 times(!) faster, if we do not waste time
-		   on freeing _all_ buffers every time on long timelines...)
-		   (schlaile)
-		*/
+		 * (ton)
+		 * At least if free memory is tight...
+		 * This can make a big difference in encoding speed
+		 * (it is around 4 times(!) faster, if we do not waste time
+		 * on freeing _all_ buffers every time on long timelines...)
+		 * (schlaile)
+		 */
 	
 		uintptr_t mem_in_use;
 		uintptr_t mmap_in_use;
@@ -2905,11 +2904,11 @@ void update_changed_seq_and_deps(Scene *scene, Sequence *changed_seq, int len_ch
 }
 
 /* seq funcs's for transforming internally
- notice the difference between start/end and left/right.
-
- left and right are the bounds at which the sequence is rendered,
-start and end are from the start and fixed length of the sequence.
-*/
+ * notice the difference between start/end and left/right.
+ *
+ * left and right are the bounds at which the sequence is rendered,
+ * start and end are from the start and fixed length of the sequence.
+ */
 int seq_tx_get_start(Sequence *seq)
 {
 	return seq->start;
@@ -2962,7 +2961,7 @@ void seq_tx_set_final_right(Sequence *seq, int val)
 }
 
 /* used so we can do a quick check for single image seq
-   since they work a bit differently to normal image seq's (during transform) */
+ * since they work a bit differently to normal image seq's (during transform) */
 int seq_single_check(Sequence *seq)
 {
 	return (seq->len==1 && (
diff --git a/source/blender/blenkernel/intern/softbody.c b/source/blender/blenkernel/intern/softbody.c
index 664c9389edb..b0075f5c121 100644
--- a/source/blender/blenkernel/intern/softbody.c
+++ b/source/blender/blenkernel/intern/softbody.c
@@ -3800,18 +3800,18 @@ static void softbody_update_positions(Object *ob, SoftBody *sb, float (*vertexCo
 
 /* void SB_estimate_transform */
 /* input   Object *ob out (says any object that can do SB like mesh,lattice,curve )
-   output  float lloc[3],float lrot[3][3],float lscale[3][3]
-   that is:
-   a precise position vector denoting the motion of the center of mass
-   give a rotation/scale matrix using averaging method, that's why estimate and not calculate
-   see: this is kind of reverse engeneering: having to states of a point cloud and recover what happend
-   our advantage here we know the identity of the vertex
-   there are others methods giving other results.
-   lloc,lrot,lscale are allowed to be NULL, just in case you don't need it.
-   should be pretty useful for pythoneers :)
-   not! velocity .. 2nd order stuff
-   vcloud_estimate_transform see
-   */
+ * output  float lloc[3],float lrot[3][3],float lscale[3][3]
+ * that is:
+ * a precise position vector denoting the motion of the center of mass
+ * give a rotation/scale matrix using averaging method, that's why estimate and not calculate
+ * see: this is kind of reverse engeneering: having to states of a point cloud and recover what happend
+ * our advantage here we know the identity of the vertex
+ * there are others methods giving other results.
+ * lloc,lrot,lscale are allowed to be NULL, just in case you don't need it.
+ * should be pretty useful for pythoneers :)
+ * not! velocity .. 2nd order stuff
+ * vcloud_estimate_transform see
+ */
 
 void SB_estimate_transform(Object *ob,float lloc[3],float lrot[3][3],float lscale[3][3])
 {
diff --git a/source/blender/blenkernel/intern/text.c b/source/blender/blenkernel/intern/text.c
index 6cd900c9ed2..3f382cc5543 100644
--- a/source/blender/blenkernel/intern/text.c
+++ b/source/blender/blenkernel/intern/text.c
@@ -65,68 +65,67 @@
 #include "BPY_extern.h"
 #endif
 
-/***************/ /*
-
-How Texts should work
---
-A text should relate to a file as follows -
-(Text *)->name should be the place where the 
-	file will or has been saved.
-	
-(Text *)->flags has the following bits
-	TXT_ISDIRTY - should always be set if the file in mem. differs from
-					the file on disk, or if there is no file on disk.
-	TXT_ISMEM - should always be set if the Text has not been mapped to
-					a file, in which case (Text *)->name may be NULL or garbage.			
-	TXT_ISEXT - should always be set if the Text is not to be written into
-					the .blend
-	TXT_ISSCRIPT - should be set if the user has designated the text
-					as a script. (NEW: this was unused, but now it is needed by
-					space handler script links (see header_view3d.c, for example)
-
-->>> see also: /makesdna/DNA_text_types.h
-
-Display
---
-The st->top determines at what line the top of the text is displayed.
-If the user moves the cursor the st containing that cursor should
-be popped ... other st's retain their own top location.
-
-Markers
---
-The mrk->flags define the behavior and relationships between markers. The
-upper two bytes are used to hold a group ID, the lower two are normal flags. If
-TMARK_EDITALL is set the group ID defines which other markers should be edited.
-
-The mrk->clr field is used to visually group markers where the flags may not
-match. A template system, for example, may allow editing of repeating tokens
-(in one group) but include other marked positions (in another group) all in the
-same template with the same color.
-
-Undo
---
-Undo/Redo works by storing
-events in a queue, and a pointer
-to the current position in the
-queue...
-
-Events are stored using an
-arbitrary op-code system
-to keep track of
-a) the two cursors (normal and selected)
-b) input (visible and control (ie backspace))
-
-input data is stored as its
-ASCII value, the opcodes are
-then selected to not conflict.
-
-opcodes with data in between are
-written at the beginning and end
-of the data to allow undo and redo
-to simply check the code at the current
-undo position
-
-*/ /***************/
+/*
+ * How Texts should work
+ * --
+ * A text should relate to a file as follows -
+ * (Text *)->name should be the place where the
+ *     file will or has been saved.
+ *
+ * (Text *)->flags has the following bits
+ *     TXT_ISDIRTY - should always be set if the file in mem. differs from
+ *                     the file on disk, or if there is no file on disk.
+ *     TXT_ISMEM - should always be set if the Text has not been mapped to
+ *                     a file, in which case (Text *)->name may be NULL or garbage.
+ *     TXT_ISEXT - should always be set if the Text is not to be written into
+ *                     the .blend
+ *     TXT_ISSCRIPT - should be set if the user has designated the text
+ *                     as a script. (NEW: this was unused, but now it is needed by
+ *                     space handler script links (see header_view3d.c, for example)
+ *
+ * ->>> see also: /makesdna/DNA_text_types.h
+ *
+ * Display
+ * --
+ * The st->top determines at what line the top of the text is displayed.
+ * If the user moves the cursor the st containing that cursor should
+ * be popped ... other st's retain their own top location.
+ *
+ * Markers
+ * --
+ * The mrk->flags define the behavior and relationships between markers. The
+ * upper two bytes are used to hold a group ID, the lower two are normal flags. If
+ * TMARK_EDITALL is set the group ID defines which other markers should be edited.
+ *
+ * The mrk->clr field is used to visually group markers where the flags may not
+ * match. A template system, for example, may allow editing of repeating tokens
+ * (in one group) but include other marked positions (in another group) all in the
+ * same template with the same color.
+ *
+ * Undo
+ * --
+ * Undo/Redo works by storing
+ * events in a queue, and a pointer
+ * to the current position in the
+ * queue...
+ *
+ * Events are stored using an
+ * arbitrary op-code system
+ * to keep track of
+ * a) the two cursors (normal and selected)
+ * b) input (visible and control (ie backspace))
+ *
+ * input data is stored as its
+ * ASCII value, the opcodes are
+ * then selected to not conflict.
+ *
+ * opcodes with data in between are
+ * written at the beginning and end
+ * of the data to allow undo and redo
+ * to simply check the code at the current
+ * undo position
+ *
+ */
 
 /***/