More translations of c comments, now also include files!

7 files changed, 141 insertions, 150 deletions

diff --git a/source/blender/radiosity/extern/include/radio_types.h b/source/blender/radiosity/extern/include/radio_types.h
index b485495e845..4d5e56d7a15 100644
--- a/source/blender/radiosity/extern/include/radio_types.h
+++ b/source/blender/radiosity/extern/include/radio_types.h
@@ -72,7 +72,7 @@ typedef struct RadView {
 #define RAD_BACKFACE	8
 
 
-typedef struct RNode {					/* lengte: 76 */
+typedef struct RNode {					/* length: 76 */
 	struct RNode *down1, *down2, *up;
 	struct RNode *ed1, *ed2, *ed3, *ed4;
 	struct RPatch *par;
@@ -87,7 +87,7 @@ typedef struct RNode {					/* lengte: 76 */
 } RNode;
 
 
-typedef struct Elem {					/* lengte: 44 */
+typedef struct Elem {					/* length: 44 */
 	struct RPatch *par;
 
 	short type;							/* type: 4==QUAD, 3==TRIA */
@@ -99,7 +99,7 @@ typedef struct Elem {					/* lengte: 44 */
 } Elem;
 
 
-typedef struct Face {					/* lengte: 24 */
+typedef struct Face {					/* length: 24 */
 	float *v1, *v2, *v3, *v4;
 	unsigned int col, matindex;
 } Face;
@@ -114,7 +114,7 @@ typedef struct RPatch {
 	struct Object *from;
 	
 	int type;				/* 3: TRIA, 4: QUAD */
-	short f, f1;			/* flags f: als node, alleen subdiv */
+	short f, f1;			/* flags f: if node, only for subdiv */
 
 	float ref[3], emit[3], unshot[3];
 	float cent[3], norm[3];
@@ -124,7 +124,7 @@ typedef struct RPatch {
 } RPatch;
 
 
-typedef struct VeNoCo {				/* nodig voor splitconnected */
+typedef struct VeNoCo {				/* needed for splitconnected */
 	struct VeNoCo *next;
 	float *v;
 	float *n;
@@ -133,7 +133,7 @@ typedef struct VeNoCo {				/* nodig voor splitconnected */
 } VeNoCo;
 
 
-typedef	struct EdSort {					/* sorteren edges */
+typedef	struct EdSort {					/* sort edges */
 	float *v1, *v2;
 	RNode *node;
 	int nr;
@@ -144,18 +144,18 @@ typedef struct {
 	unsigned int *hemibuf;
 	struct ListBase patchbase;
 	int totpatch, totelem, totvert, totlamp;
-	RNode **elem;						/* globaal array van alle pointers */
-	VeNoCo *verts;						/* tijdelijk vertices van patches */
-	float *formfactors;				    /* een factor per element */
-	float *topfactors, *sidefactors;    /* LUT voor delta's */
-	int *index;						/* LUT voor bovenstaande LUT */
+	RNode **elem;						/* global array with all pointers */
+	VeNoCo *verts;						/* temporal vertices from patches */
+	float *formfactors;				    /* 1 factor per element */
+	float *topfactors, *sidefactors;    /* LUT for delta's */
+	int *index;						/* LUT for above LUT */
 	Face **facebase;
 	int totface;
 	float min[3], max[3], size[3], cent[3];	/* world */
 	float maxsize, totenergy;
 	float patchmin, patchmax;
 	float elemmin, elemmax;
-	float radfactor, lostenergy, igamma;		/* radfac zit in button, radfactor wordt berekend */
+	float radfactor, lostenergy, igamma;		/* radfac is in button, radfactor is calculated */
 	int phase;
 	/* to preserve materials as used before, max 16 */
 	Material *matar[MAXMAT];
@@ -163,11 +163,11 @@ typedef struct {
 	
 		/* this part is a copy of struct Radio */
 	short hemires, maxiter;
-	short drawtype, flag;			/* bit 0 en 1: limits laten zien */
+	short drawtype, flag;			/* bit 0 en 1: show limits */
 	short subshootp, subshoote, nodelim, maxsublamp;
 	int maxnode;
 	float convergence;
-	float radfac, gamma;		/* voor afbeelden */
+	float radfac, gamma;		/* for display */
 
 } RadGlobal;
 
diff --git a/source/blender/radiosity/intern/source/raddisplay.c b/source/blender/radiosity/intern/source/raddisplay.c
index de8ffbacd81..8046f07874d 100644
--- a/source/blender/radiosity/intern/source/raddisplay.c
+++ b/source/blender/radiosity/intern/source/raddisplay.c
@@ -66,9 +66,7 @@
 
 #include "radio.h"
 
-/* Mij afspraak is cpack een getal dat als 0xFFaa66 of zo kan worden
- * uitgedrukt. Is dus gevoelig voor endian. Met deze define wordt het
- * altijd goed afgebeeld */
+/* cpack has to be endian-insensitive! (old irisgl function) */
 #define cpack(x)   glColor3ub( ((x)&0xFF), (((x)>>8)&0xFF), (((x)>>16)&0xFF) )
 
 char calculatecolor(float col)
@@ -217,7 +215,7 @@ void drawpatch_ext(RPatch *patch, unsigned int col)
 	sa= G.curscreen->areabase.first;
 	while(sa) {
 		if (sa->spacetype==SPACE_VIEW3D) {
-		 	/* hier mywinget() gebruiken: anders wordt in header getekend */
+		 	/* use mywinget() here: otherwise it draws in header */
 		 	if(sa->win != mywinget()) areawinset(sa->win);
 			drawnodeWire(patch->first);
 		}
@@ -358,7 +356,7 @@ void drawsquare(float *cent, float size, short cox, short coy)
 
 void drawlimits()
 {
-	/* centreer rond cent */
+	/* centre around cent */
 	short cox=0, coy=1;
 	
 	if((RG.flag & 3)==2) coy= 2;
@@ -404,7 +402,7 @@ void pseudoAmb()
 	float fac;
 	char col[4];
 	
-	/* zet pseudo ambient kleuren in de nodes */
+	/* sets pseudo ambient color in the nodes */
 
 	rp= RG.patchbase.first;
 	while(rp) {
@@ -429,7 +427,7 @@ void pseudoAmb()
 
 void RAD_drawall(int depth_is_on)
 {
-	/* maakt afbeelding van elements of van faces */
+	/* displays elements or faces */
 	Face *face = NULL;
 	RNode **el;
 	RPatch *rp;
@@ -518,7 +516,7 @@ void rad_forcedraw()
 	sa= G.curscreen->areabase.first;
 	while(sa) {
 		if (sa->spacetype==SPACE_VIEW3D) {
-		 	/* hier mywinget() gebruiken: anders wordt in header getekend */
+		 	/* use mywinget() here: othwerwise it draws in header */
 		 	if(sa->win != mywinget()) areawinset(sa->win);
 		 	scrarea_do_windraw(sa);
 		}
diff --git a/source/blender/radiosity/intern/source/radfactors.c b/source/blender/radiosity/intern/source/radfactors.c
index 1111593de5b..d0b6a7752a9 100644
--- a/source/blender/radiosity/intern/source/radfactors.c
+++ b/source/blender/radiosity/intern/source/radfactors.c
@@ -69,18 +69,18 @@ RadView hemitop, hemiside;
 float calcStokefactor(RPatch *shoot, RPatch *rp, RNode *rn, float *area)
 {
 	float tvec[3], fac;
-	float vec[4][3];	/* vectoren van shootcent naar vertices rp */
-	float cross[4][3];	/* uitprodukten hiervan */
-	float rad[4];	/* hoeken tussen vecs */
+	float vec[4][3];	/* vectors of shoot->cent to vertices rp */
+	float cross[4][3];	/* cross products of this */
+	float rad[4];	/* anlgles between vecs */
 
-	/* test op richting */
+	/* test for direction */
 	VecSubf(tvec, shoot->cent, rp->cent);
 	if( tvec[0]*shoot->norm[0]+ tvec[1]*shoot->norm[1]+ tvec[2]*shoot->norm[2]>0.0)
 		return 0.0;
 	
 	if(rp->type==4) {
 
-		/* hoekvectors */
+		/* corner vectors */
 		VecSubf(vec[0], shoot->cent, rn->v1);
 		VecSubf(vec[1], shoot->cent, rn->v2);
 		VecSubf(vec[2], shoot->cent, rn->v3);
@@ -91,7 +91,7 @@ float calcStokefactor(RPatch *shoot, RPatch *rp, RNode *rn, float *area)
 		Normalise(vec[2]);
 		Normalise(vec[3]);
 
-		/* uitprod */
+		/* cross product */
 		Crossf(cross[0], vec[0], vec[1]);
 		Crossf(cross[1], vec[1], vec[2]);
 		Crossf(cross[2], vec[2], vec[3]);
@@ -101,7 +101,7 @@ float calcStokefactor(RPatch *shoot, RPatch *rp, RNode *rn, float *area)
 		Normalise(cross[2]);
 		Normalise(cross[3]);
 
-		/* hoeken */
+		/* angles */
 		rad[0]= vec[0][0]*vec[1][0]+ vec[0][1]*vec[1][1]+ vec[0][2]*vec[1][2];
 		rad[1]= vec[1][0]*vec[2][0]+ vec[1][1]*vec[2][1]+ vec[1][2]*vec[2][2];
 		rad[2]= vec[2][0]*vec[3][0]+ vec[2][1]*vec[3][1]+ vec[2][2]*vec[3][2];
@@ -112,7 +112,7 @@ float calcStokefactor(RPatch *shoot, RPatch *rp, RNode *rn, float *area)
 		rad[2]= acos(rad[2]);
 		rad[3]= acos(rad[3]);
 
-		/* Stoke formule */
+		/* Stoke formula */
 		VecMulf(cross[0], rad[0]);
 		VecMulf(cross[1], rad[1]);
 		VecMulf(cross[2], rad[2]);
@@ -125,7 +125,7 @@ float calcStokefactor(RPatch *shoot, RPatch *rp, RNode *rn, float *area)
 		fac+= tvec[0]*cross[3][0]+ tvec[1]*cross[3][1]+ tvec[2]*cross[3][2];
 	}
 	else {
-		/* hoekvectors */
+		/* corner vectors */
 		VecSubf(vec[0], shoot->cent, rn->v1);
 		VecSubf(vec[1], shoot->cent, rn->v2);
 		VecSubf(vec[2], shoot->cent, rn->v3);
@@ -134,7 +134,7 @@ float calcStokefactor(RPatch *shoot, RPatch *rp, RNode *rn, float *area)
 		Normalise(vec[1]);
 		Normalise(vec[2]);
 
-		/* uitprod */
+		/* cross product */
 		Crossf(cross[0], vec[0], vec[1]);
 		Crossf(cross[1], vec[1], vec[2]);
 		Crossf(cross[2], vec[2], vec[0]);
@@ -142,7 +142,7 @@ float calcStokefactor(RPatch *shoot, RPatch *rp, RNode *rn, float *area)
 		Normalise(cross[1]);
 		Normalise(cross[2]);
 
-		/* hoeken */
+		/* angles */
 		rad[0]= vec[0][0]*vec[1][0]+ vec[0][1]*vec[1][1]+ vec[0][2]*vec[1][2];
 		rad[1]= vec[1][0]*vec[2][0]+ vec[1][1]*vec[2][1]+ vec[1][2]*vec[2][2];
 		rad[2]= vec[2][0]*vec[0][0]+ vec[2][1]*vec[0][1]+ vec[2][2]*vec[0][2];
@@ -151,7 +151,7 @@ float calcStokefactor(RPatch *shoot, RPatch *rp, RNode *rn, float *area)
 		rad[1]= acos(rad[1]);
 		rad[2]= acos(rad[2]);
 
-		/* Stoke formule */
+		/* Stoke formula */
 		VecMulf(cross[0], rad[0]);
 		VecMulf(cross[1], rad[1]);
 		VecMulf(cross[2], rad[2]);
@@ -228,8 +228,8 @@ void calcSidefactors()
 
 void initradiosity()
 {
-	/* alloceert en maakt LUTs voor top/side factors */
-	/* alloceert en maakt index array */
+	/* allocates and makes LUTs for top/side factors */
+	/* allocates and makes index array */
 	int a, hres2;
 
 	if(RG.topfactors) MEM_freeN(RG.topfactors);
@@ -261,7 +261,7 @@ void rad_make_hocos(RadView *vw)
 	/* } */
 }
 
-void rad_setmatrices(RadView *vw)	    /* voor hemi's */
+void rad_setmatrices(RadView *vw)	    /* for hemi's */
 {
 	float up1[3], len, twist;
 
@@ -292,7 +292,7 @@ void hemizbuf(RadView *vw)
 	rad_setmatrices(vw);
 	RE_zbufferall_radio(vw, RG.elem, RG.totelem);
 
-	/* factors tellen */
+	/* count factors */
 	if(vw->recty==vw->rectx) factors= RG.topfactors;
 	else factors= RG.sidefactors;
 	hres= RG.hemires/2;
@@ -730,13 +730,13 @@ void subdivideshootElements(int it)
 			if(blender_test_break()) break;
 		}
 		
-		/* test op extreem weinig kleurverloop binnen patch met subdivflag */
+		/* test for extreme small color change within a patch with subdivflag */
 		
 		rp= RG.patchbase.first;
 		
 		while(rp) {
-			if(rp->f & RAD_SUBDIV) {		/* rp heeft elems die moet gesubd */
-				/* minstens 4 levels diep */
+			if(rp->f & RAD_SUBDIV) {		/* rp has elems that need subdiv */
+				/* at least 4 levels deep */
 				rn= rp->first->down1;
 				if(rn) {
 					rn= rn->down1;
@@ -748,13 +748,13 @@ void subdivideshootElements(int it)
 				if(rn) {
 					min[0]= min[1]= min[2]= 1.0e10;
 					max[0]= max[1]= max[2]= -1.0e10;
-					/* errmin en max zijn de gefilterde kleuren */
+					/* errmin and max are the filtered colors */
 					errmin[0]= errmin[1]= errmin[2]= 1.0e10;
 					errmax[0]= errmax[1]= errmax[2]= -1.0e10;
 					minmaxradelemfilt(rp->first, min, max, errmin, errmax);
 					
-					/* verschil tussen kleuren klein: toch maar niet subd */
-					/* test ook voor de gefilterde: maar kritischer */
+					/* if small difference between colors: no subdiv */
+					/* also test for the filtered ones: but with higher critical level */
 					
 					contin= 0;
 					a= abs( calculatecolor(min[0])-calculatecolor(max[0]));
@@ -837,7 +837,7 @@ void subdivideshootPatches(int it)
 					
 						stoke= calcStokefactor(shoot, rp, rp->first, &area);
 						if(stoke!= 0.0) {
-							if(area>.1) {	/* ontvangt patch meer dan (ong)10% van energie? */
+							if(area>.1) {	/* does patch receive more than (about)10% of energy? */
 								rp->f= RAD_SUBDIV;
 							}
 							else {
@@ -853,16 +853,6 @@ void subdivideshootPatches(int it)
 														
 											rp->f= RAD_SUBDIV;
 											
-											/* if(get_qual()&LR_SHIFTKEY);
-											else {
-												drawpatch_ext(rp, 0xFF77FF);
-					
-												printf("Pa hemi %f stoke %f err %f area %f\n", *fp, stoke, err, area);
-					
-												while(get_mbut()&L_MOUSE==0);
-												while(get_mbut()&L_MOUSE);
-											}
-											*/
 										}
 									}
 								}
@@ -919,7 +909,7 @@ void inithemiwindows()
 {
 	RadView *vw;
 
-	/* de hemiwindows */
+	/* the hemiwindows */
 	vw= &(hemitop);
 	memset(vw, 0, sizeof(RadView));
 	vw->rectx= RG.hemires;
diff --git a/source/blender/radiosity/intern/source/radio.c b/source/blender/radiosity/intern/source/radio.c
index b601605157a..08968483a18 100644
--- a/source/blender/radiosity/intern/source/radio.c
+++ b/source/blender/radiosity/intern/source/radio.c
@@ -279,7 +279,6 @@ int rad_go(void)	/* return 0 when user escapes */
 {
 	double stime= PIL_check_seconds_timer();
 	int retval;
-	/* firsttime moet vervangen worden door radphase? */
 	
 	if(RG.totface) return 0;
 
@@ -311,7 +310,7 @@ int rad_go(void)	/* return 0 when user escapes */
 
 	removeEqualNodes(RG.nodelim);
 
-	make_face_tab();	/* nu geankerd */
+	make_face_tab();	/* now anchored */
 
 	closehemiwindows();
 	RG.phase= 0;
diff --git a/source/blender/radiosity/intern/source/radnode.c b/source/blender/radiosity/intern/source/radnode.c
index 522f08d4e00..844973e4d1f 100644
--- a/source/blender/radiosity/intern/source/radnode.c
+++ b/source/blender/radiosity/intern/source/radnode.c
@@ -237,7 +237,7 @@ void setnodelimit(float limit)
 
 }
 
-/* ************  GEHEUGENBEHEER ***********  */
+/* ************  memory management ***********  */
 
 int Ntotvert=0, Ntotnode=0, Ntotpatch=0;
 
@@ -313,7 +313,7 @@ void freePatch(RPatch *patch)
 
 void replaceAllNode(RNode *neighb, RNode *newn)
 {
-	/* verandert van alle buren de edgepointers die naar newn->up wijzen in new */
+	/* changes from all neighbours the edgepointers that point to newn->up in new */
 	int ok= 0;
 	
 	
@@ -345,7 +345,7 @@ void replaceAllNode(RNode *neighb, RNode *newn)
 
 void replaceAllNodeInv(RNode *neighb, RNode *old)
 {
-	/* verandert van alle buren de edgepointers die naar old wijzen in old->up */
+	/* changes from all neighbours the edgepointers that point to old in old->up */
 	if(neighb==0) return;
 	if(old->up==0) return;
 	
@@ -370,7 +370,7 @@ void replaceAllNodeInv(RNode *neighb, RNode *old)
 
 void replaceAllNodeUp(RNode *neighb, RNode *old)
 {
-	/* verandert van alle buren de edgepointers die naar old wijzen in old->up */
+	/* changes from all neighbours the edgepointers that point to old in old->up */
 	if(neighb==0) return;
 	if(old->up==0) return;
 	neighb= neighb->up;
@@ -397,15 +397,15 @@ void replaceAllNodeUp(RNode *neighb, RNode *old)
 
 void replaceTestNode(RNode *neighb, RNode **edpp, RNode *newn, int level, float *vert)
 {
-	/*	IF neighb->ed wijst naar newn->up
-	 *		IF edgelevels gelijk
-				IF testvert zit in neighb->ed
-					pointers beide kanten op veranderen
+	/*	IF neighb->ed points to newn->up
+	 *		IF edgelevels equal
+				IF testvert is in neighb->ed
+					change pointers both ways
 				ELSE
 					RETURN
 			ELSE
-				IF neighb edgelevel is dieper
-					verander neighb pointer
+				IF neighb edgelevel is deeper
+					change neighb pointer
 		
 	 */
 	int ok= 0;
@@ -484,7 +484,7 @@ void replaceTestNode(RNode *neighb, RNode **edpp, RNode *newn, int level, float
 
 int setvertexpointersNode(RNode *neighb, RNode *node, int level, float **v1, float **v2)
 {
-	/* vergelijkt edgelevels , als gelijk zet het de vertexpointers */
+	/* compares edgelevels , if equal it sets the vertexpointers */
 	
 	if(neighb==0) return 0;
 	
@@ -542,7 +542,7 @@ void subdivideTriNode(RNode *node, RNode *edge)
 		return;
 	}
 	
-	/* bepaal subdivide richting */
+	/* defines subdivide direction */
 
 	if(edge==0) {
 		/* areathreshold */
@@ -563,7 +563,7 @@ void subdivideTriNode(RNode *node, RNode *edge)
 		else uvl= 3;
 	}
 	
-	/*  moeten naastliggende nodes dieper? Recursief! */
+	/*  should neighbour nodes be deeper? Recursive! */
 	n1= 0; 
 	if(uvl==1) {
 		if(node->ed1 && node->ed1->down1==0) n1= node->ed1;
@@ -576,7 +576,7 @@ void subdivideTriNode(RNode *node, RNode *edge)
 	}
 	if(n1) {
 		up= node->up;
-		while(up) {							/* ook testen op ed4 !!! */
+		while(up) {							/* also test for ed4 !!! */
 			if(n1->ed1==up || n1->ed2==up || n1->ed3==up || n1->ed4==up) {
 				subdivideNode(n1, up);
 				break;
@@ -585,7 +585,7 @@ void subdivideTriNode(RNode *node, RNode *edge)
 		}
 	}
 	
-	/* Het subdividen */
+	/* the subsidiving */
 	n1= mallocNode();
 	memcpy(n1, node, sizeof(RNode));
 	n2= mallocNode();
@@ -600,22 +600,22 @@ void subdivideTriNode(RNode *node, RNode *edge)
 	/* subdivide edge 1 */
 	if(uvl==1) {
 	
-		/* EERSTE NODE  krijgt edge 2 */
+		/* FIRST NODE  gets edge 2 */
 		n1->ed3= n2;
 		n1->lev3= 0;
 		replaceAllNode(n1->ed2, n1);
 		n1->lev1++;
 		replaceTestNode(n1->ed1, &(n1->ed1), n1, n1->lev1, n1->v2);
 
-		/* TWEEDE NODE  krijgt edge 3 */
+		/* SECOND NODE  gets edge 3 */
 		n2->ed2= n1;
 		n2->lev2= 0;
 		replaceAllNode(n2->ed3, n2);
 		n2->lev1++;
 		replaceTestNode(n2->ed1, &(n2->ed1), n2, n2->lev1, n2->v1);
 		
-		/* NIEUWE VERTEX uit edge 1 */
-		if( setvertexpointersNode(n1->ed1, n1, n1->lev1, &v1, &v2) ) {	/* nodes hebben gelijke levels */
+		/* NEW VERTEX from edge 1 */
+		if( setvertexpointersNode(n1->ed1, n1, n1->lev1, &v1, &v2) ) {	/* nodes have equal levels */
 			if(v1== n1->v2) {
 				n1->v1= v2;
 				n2->v2= v2;
@@ -635,22 +635,22 @@ void subdivideTriNode(RNode *node, RNode *edge)
 	}
 	else if(uvl==2) {
 	
-		/* EERSTE NODE  krijgt edge 1 */
+		/* FIRST NODE gets edge 1 */
 		n1->ed3= n2;
 		n1->lev3= 0;
 		replaceAllNode(n1->ed1, n1);
 		n1->lev2++;
 		replaceTestNode(n1->ed2, &(n1->ed2), n1, n1->lev2, n1->v2);
 
-		/* TWEEDE NODE  krijgt edge 3 */
+		/* SECOND NODE gets edge 3 */
 		n2->ed1= n1;
 		n2->lev1= 0;
 		replaceAllNode(n2->ed3, n2);
 		n2->lev2++;
 		replaceTestNode(n2->ed2, &(n2->ed2), n2, n2->lev2, n2->v3);
 		
-		/* NIEUWE VERTEX uit edge 2 */
-		if( setvertexpointersNode(n1->ed2, n1, n1->lev2, &v1, &v2) ) {	/* nodes hebben gelijke levels */
+		/* NEW VERTEX from edge 2 */
+		if( setvertexpointersNode(n1->ed2, n1, n1->lev2, &v1, &v2) ) {	/* nodes have equal levels */
 			if(v1== n1->v2) {
 				n1->v3= v2;
 				n2->v2= v2;
@@ -670,22 +670,22 @@ void subdivideTriNode(RNode *node, RNode *edge)
 	}
 	else if(uvl==3) {
 	
-		/* EERSTE NODE  krijgt edge 1 */
+		/* FIRST NODE gets edge 1 */
 		n1->ed2= n2;
 		n1->lev2= 0;
 		replaceAllNode(n1->ed1, n1);
 		n1->lev3++;
 		replaceTestNode(n1->ed3, &(n1->ed3), n1, n1->lev3, n1->v1);
 
-		/* TWEEDE NODE  krijgt edge 2 */
+		/* SECOND NODE gets edge 2 */
 		n2->ed1= n1;
 		n2->lev1= 0;
 		replaceAllNode(n2->ed2, n2);
 		n2->lev3++;
 		replaceTestNode(n2->ed3, &(n2->ed3), n2, n2->lev3, n2->v3);
 		
-		/* NIEUWE VERTEX uit edge 3 */
-		if( setvertexpointersNode(n1->ed3, n1, n1->lev3, &v1, &v2) ) {	/* nodes hebben gelijke levels */
+		/* NEW VERTEX from edge 3 */
+		if( setvertexpointersNode(n1->ed3, n1, n1->lev3, &v1, &v2) ) {	/* nodes have equal levels */
 			if(v1== n1->v1) {
 				n1->v3= v2;
 				n2->v1= v2;
@@ -727,7 +727,7 @@ void subdivideNode(RNode *node, RNode *edge)
 		return;
 	}
 	
-	/* bepaal subdivide richting */
+	/* defines subdivide direction */
 
 	if(edge==0) {
 		/* areathreshold */
@@ -744,7 +744,7 @@ void subdivideNode(RNode *node, RNode *edge)
 		else uvl= 2;
 	}
 	
-	/*  moeten naastliggende nodes dieper? Recursief! */
+	/*  do neighbour nodes have to be deeper? Recursive! */
 	n1= n2= 0; 
 	if(uvl==1) {
 		if(node->ed1 && node->ed1->down1==0) n1= node->ed1;
@@ -777,7 +777,7 @@ void subdivideNode(RNode *node, RNode *edge)
 		}
 	}
 
-	/* Het subdividen */
+	/* the subdividing */
 	n1= mallocNode();
 	memcpy(n1, node, sizeof(RNode));
 	n2= mallocNode();
@@ -789,10 +789,10 @@ void subdivideNode(RNode *node, RNode *edge)
 	node->down1= n1;
 	node->down2= n2;
 
-	/* subdivide edge 1 en 3 */
+	/* subdivide edge 1 and 3 */
 	if(uvl==1) {
 		
-		/* EERSTE NODE  krijgt edge 2 */
+		/* FIRST NODE  gets edge 2 */
 		n1->ed4= n2;
 		n1->lev4= 0;
 		replaceAllNode(n1->ed2, n1);
@@ -801,7 +801,7 @@ void subdivideNode(RNode *node, RNode *edge)
 		replaceTestNode(n1->ed1, &(n1->ed1), n1, n1->lev1, n1->v2);
 		replaceTestNode(n1->ed3, &(n1->ed3), n1, n1->lev3, n1->v3);
 
-		/* TWEEDE NODE  krijgt edge 4 */
+		/* SECOND NODE gets edge 4 */
 		n2->ed2= n1;
 		n2->lev2= 0;
 		replaceAllNode(n2->ed4, n2);
@@ -810,8 +810,8 @@ void subdivideNode(RNode *node, RNode *edge)
 		replaceTestNode(n2->ed1, &(n2->ed1), n2, n2->lev1, n2->v1);
 		replaceTestNode(n2->ed3, &(n2->ed3), n2, n2->lev3, n2->v4);
 		
-		/* NIEUWE VERTEX uit edge 1 */
-		if( setvertexpointersNode(n1->ed1, n1, n1->lev1, &v1, &v2) ) {	/* nodes hebben gelijke levels */
+		/* NEW VERTEX from edge 1 */
+		if( setvertexpointersNode(n1->ed1, n1, n1->lev1, &v1, &v2) ) {	/* nodes have equal levels */
 			if(v1== n1->v2) {
 				n1->v1= v2;
 				n2->v2= v2;
@@ -829,8 +829,8 @@ void subdivideNode(RNode *node, RNode *edge)
 			n1->v1[3]= node->v1[3];	/* color */
 		}
 		
-		/* NIEUWE VERTEX uit edge 3 */
-		if( setvertexpointersNode(n1->ed3, n1, n1->lev3, &v1, &v2) ) {	/* nodes hebben gelijke levels */
+		/* NEW VERTEX from edge 3 */
+		if( setvertexpointersNode(n1->ed3, n1, n1->lev3, &v1, &v2) ) {	/* nodes have equal levels */
 			if(v1== n1->v3) {
 				n1->v4= v2;
 				n2->v3= v2;
@@ -848,10 +848,10 @@ void subdivideNode(RNode *node, RNode *edge)
 			n1->v4[3]= node->v4[3];	/* color */
 		}
 	}
-	/* subdivide edge 2 en 4 */
+	/* subdivide edge 2 and 4 */
 	else if(uvl==2) {
 		
-		/* EERSTE NODE  krijgt edge 1 */
+		/* FIRST NODE gets edge 1 */
 		n1->ed3= n2;
 		n1->lev3= 0;
 		replaceAllNode(n1->ed1, n1);
@@ -860,7 +860,7 @@ void subdivideNode(RNode *node, RNode *edge)
 		replaceTestNode(n1->ed2, &(n1->ed2), n1, n1->lev2, n1->v2);
 		replaceTestNode(n1->ed4, &(n1->ed4), n1, n1->lev4, n1->v1);
 
-		/* TWEEDE NODE  krijgt edge 3 */
+		/* SECOND NODE gets edge 3 */
 		n2->ed1= n1;
 		n2->lev1= 0;
 		replaceAllNode(n2->ed3, n2);
@@ -869,8 +869,8 @@ void subdivideNode(RNode *node, RNode *edge)
 		replaceTestNode(n2->ed2, &(n2->ed2), n2, n2->lev2, n2->v3);
 		replaceTestNode(n2->ed4, &(n2->ed4), n2, n2->lev4, n2->v4);
 
-		/* NIEUWE VERTEX uit edge 2 */
-		if( setvertexpointersNode(n1->ed2, n1, n1->lev2, &v1, &v2) ) {	/* nodes hebben gelijke levels */
+		/* NEW VERTEX from edge 2 */
+		if( setvertexpointersNode(n1->ed2, n1, n1->lev2, &v1, &v2) ) {	/* nodes have equal levels */
 			if(v1== n1->v2) {
 				n1->v3= v2;
 				n2->v2= v2;
@@ -888,8 +888,8 @@ void subdivideNode(RNode *node, RNode *edge)
 			n1->v3[3]= node->v3[3];	/* color */
 		}
 
-		/* NIEUWE VERTEX uit edge 4 */
-		if( setvertexpointersNode(n1->ed4, n1, n1->lev4, &v1, &v2) ) {	/* nodes hebben gelijke levels */
+		/* NEW VERTEX from edge 4 */
+		if( setvertexpointersNode(n1->ed4, n1, n1->lev4, &v1, &v2) ) {	/* nodes have equal levels */
 			if(v1== n1->v1) {
 				n1->v4= v2;
 				n2->v1= v2;
@@ -916,15 +916,18 @@ void subdivideNode(RNode *node, RNode *edge)
 
 int comparelevel(RNode *node, RNode *nb, int level)
 {
-	/* recursief afdalen: bij diepste node testen */
-	/* return 1 is gelijk of hoger */
+	/* recursive descent: test with deepest node */
+	/* return 1 means equal or higher */
 	
 	if(nb==0) return 1;
 	
 	if(nb->down1) {
 		return 0;
 		
-		/*		HIER ZIT EEN FOUT, MAAR WELKE?  (zonder dit werkt 't ook, maar langzamer)
+		/*		THERE IS AN ERROR HERE, BUT WHAT?  (without this function the system
+		        works too, but is slower) (ton) */
+
+		/*
 		n1= nb->down1;
 		if(n1->ed1==node) return comparelevel(node, n1, level);
 		if(n1->ed2==node) return comparelevel(node, n1, level);
@@ -947,17 +950,17 @@ int comparelevel(RNode *node, RNode *nb, int level)
 		/* if(nb->ed3==node) return (nb->lev3<=level); */
 		/* if(nb->ed4==node) return (nb->lev4<=level); */
 		
-		return 1;	/* is hogere node */
+		return 1;	/* is higher node */
 	}
 	return 1;
 }
 
-void deleteTriNodes(RNode *node) 	/* beide kinderen van node */
+void deleteTriNodes(RNode *node) 	/* both children of node */
 {
 	RNode *n1, *n2;
 	
-	/* als naastliggende nodes dieper zijn: geen delete */
-	/* enkel twee nodes testen, van andere verandert level niet */
+	/* if neighbour nodes are deeper: no delete */
+	/* just test 2 nodes, from the others the level doesn't change */
 	
 	n1= node->down1;
 	n2= node->down2;
@@ -966,7 +969,7 @@ void deleteTriNodes(RNode *node) 	/* beide kinderen van node */
 	
 	if(n1->down1 || n2->down1) return;
 	
-	/* aan edges mag geen gesubdivide node zitten */
+	/* at the edges no subdivided node is allowed */
 
 	if(n1->ed1 && n1->ed1->down1) return;
 	if(n1->ed2 && n1->ed2->down1) return;
@@ -992,7 +995,7 @@ void deleteTriNodes(RNode *node) 	/* beide kinderen van node */
 	replaceAllNodeUp(n2->ed2, n2);
 	replaceAllNodeUp(n2->ed3, n2);
 
-	n1->down1= (RNode *)12;	/* voor debug */
+	n1->down1= (RNode *)12;	/* for debug */
 	n2->down1= (RNode *)12;
 	
 	freeNode(n1);
@@ -1001,13 +1004,13 @@ void deleteTriNodes(RNode *node) 	/* beide kinderen van node */
 	
 }
 
-	/* beide kinderen van node */
+	/* both children of node */
 void deleteNodes(RNode *node)
 {
 	RNode *n1, *n2;
-	
-	/* als naastliggende nodes dieper zijn: geen delete */
-	/* enkel twee nodes testen, van andere verandert level niet */
+
+	/* if neighbour nodes are deeper: no delete */
+	/* just test 2 nodes, from the others the level doesn't change */
 
 	if(node->type==3) {
 		deleteTriNodes(node);
@@ -1023,7 +1026,7 @@ void deleteNodes(RNode *node)
 	
 	if(n1->ed3==n2) {
 
-		/* aan edges mag geen gesubdivide node zitten */
+		/* at the edges no subdivided node is allowed */
 
 		if(n1->ed1 && n1->ed1->down1) return;
 		if(n1->ed2 && n1->ed2->down1) return;
@@ -1049,7 +1052,7 @@ void deleteNodes(RNode *node)
 		replaceAllNodeUp(n2->ed3, n2);
 		replaceAllNodeUp(n2->ed4, n2);
 
-		n1->down1= (RNode *)12;	/* voor debug */
+		n1->down1= (RNode *)12;	/* for debug */
 		n2->down1= (RNode *)12;
 		
 		freeNode(n1);
@@ -1084,7 +1087,7 @@ void deleteNodes(RNode *node)
 		replaceAllNodeUp(n2->ed3, n2);
 		replaceAllNodeUp(n2->ed4, n2);
 
-		n1->down1= (RNode *)12;	/* voor debug */
+		n1->down1= (RNode *)12;	/* for debug */
 		n2->down1= (RNode *)12;
 		
 		freeNode(n1);
diff --git a/source/blender/radiosity/intern/source/radpostprocess.c b/source/blender/radiosity/intern/source/radpostprocess.c
index 010189ccb81..7b362b0e508 100644
--- a/source/blender/radiosity/intern/source/radpostprocess.c
+++ b/source/blender/radiosity/intern/source/radpostprocess.c
@@ -365,7 +365,7 @@ float *findmiddlevertex(RNode *node, RNode *nb, float *v1, float *v2)
 	return 0;
 }
 
-void make_face_tab()	/* zorgt voor ankers */
+void make_face_tab()	/* takes care of anchoring */
 {
 	RNode *rn, **el;
 	Face *face = NULL;
@@ -380,7 +380,7 @@ void make_face_tab()	/* zorgt voor ankers */
 	RG.igamma= 1.0/RG.gamma;
 	RG.radfactor= RG.radfac*pow(64*64, RG.igamma);
 
-	/* vlakkleuren omzetten */
+	/* convert face colors */
 	el= RG.elem;
 	for(a=RG.totelem; a>0; a--, el++) {
 		rn= *el;
@@ -391,7 +391,7 @@ void make_face_tab()	/* zorgt voor ankers */
 		charcol[1]= calculatecolor(rn->totrad[2]);
 	}
 	
-	/* nodes aflopen en Face's maken */
+	/* check nodes and make faces */
 	el= RG.elem;
 	for(a=RG.totelem; a>0; a--, el++) {
 
@@ -402,7 +402,7 @@ void make_face_tab()	/* zorgt voor ankers */
 		rn->v3[3]= 0.0;
 		if(rn->v4) rn->v4[3]= 0.0;
 		
-		/* test edges op subdivide */
+		/* test edges for subdivide */
 		flag= 0;
 		v1= v2= v3= v4= 0;
 		if(rn->ed1) {
@@ -425,7 +425,7 @@ void make_face_tab()	/* zorgt voor ankers */
 			if(v4) flag |= 8;
 		}
 		
-		/* met flag en vertexpointers kunnen nu Face's gemaakt*/
+		/* using flag and vertexpointers now Faces can be made */
 		
 		if(flag==0) {
 			makeface(rn->v1, rn->v2, rn->v3, rn->v4, rn);
@@ -434,7 +434,7 @@ void make_face_tab()	/* zorgt voor ankers */
 		else anchorTriface(rn, v1, v2, v3, flag);
 	}
 	
-	/* optellen */
+	/* add */
 	for(a=0; a<RG.totface; a++) {
 		
 		RAD_NEXTFACE(a);
@@ -457,20 +457,20 @@ void make_face_tab()	/* zorgt voor ankers */
 
 void filterFaces()
 {
-	/* alle kleuren van vertices in faces en weer terug */
+	/* put vertex colors in faces, and put them back */
 	
 	Face *face = NULL;
 	int a, w1, w2, w3;
 
 	if(RG.totface==0) return;
 
-	/* wissen */
+	/* clear */
 	for(a=0; a<RG.totface; a++) {
 		RAD_NEXTFACE(a);
 		face->col= 0;
 	}
 	
-	/* optellen: punten bij vlakken */
+	/* add: vertices with faces */
 	for(a=0; a<RG.totface; a++) {
 		RAD_NEXTFACE(a);
 		
@@ -488,7 +488,7 @@ void filterFaces()
 		}
 	}
 	
-	/* wissen */
+	/* clear */
 	for(a=0; a<RG.totface; a++) {
 		RAD_NEXTFACE(a);
 		face->v1[3]= 0.0;
@@ -498,7 +498,7 @@ void filterFaces()
 	}
 
 
-	/* optellen: vlakken bij punten */
+	/* add: faces with vertices */
 	for(a=0; a<RG.totface; a++) {
 		
 		RAD_NEXTFACE(a);
@@ -559,14 +559,14 @@ void calcfiltrad(RNode *rn, float *cd)
 
 void filterNodes()
 {
-	/* alle kleuren van nodes in tempblok en weer terug */
+	/* colors from nodes in tempblock and back */
 	
 	RNode *rn, **el;
 	float *coldata, *cd;
 	int a;
 
 	if(RG.totelem==0) return;
-	/* de upnodes moeten kleur hebben */
+	/* the up-nodes need a color */
 	el= RG.elem;
 	for(a=0; a<RG.totelem; a++, el++) {
 		rn= *el;
@@ -596,7 +596,7 @@ void filterNodes()
 		}
 	}
 	
-	/* met area optellen */
+	/* add using area */
 	cd= coldata= MEM_mallocN(3*4*RG.totelem, "filterNodes");
 	el= RG.elem;
 	for(a=0; a<RG.totelem; a++, el++) {
@@ -616,7 +616,7 @@ void filterNodes()
 
 void removeEqualNodes(short limit)
 {
-	/* nodes met kleur gelijk aan elkaar: verwijderen */
+	/* nodes with equal colors: remove */
 	RNode **el, *rn, *rn1;
 	float thresh, f1, f2;
 	int a, foundone=1, ok;
@@ -811,7 +811,7 @@ void rad_addmesh(void)
 			md[3]= coldata[mface->v4];
 		}
 		
-		/* boundbox en centrenew */
+		/* boundbox and centrenew */
 		
 		INIT_MINMAX(min, max);
 
diff --git a/source/blender/radiosity/intern/source/radpreprocess.c b/source/blender/radiosity/intern/source/radpreprocess.c
index 9946809926d..a1fb90abecc 100644
--- a/source/blender/radiosity/intern/source/radpreprocess.c
+++ b/source/blender/radiosity/intern/source/radpreprocess.c
@@ -72,15 +72,16 @@ void setparelem(RNode *rn, RPatch *par);
 
 void splitconnected()
 {
-	/* voor zover de videoscapefile nog gedeelde vertices leverde, worden de vlakken getest
-	 * op normaal en kleur. Doe dit door voor elke vertex een normaal en een kleur te onthouden.
+	/* Since input meshes can have faces with sharing vertices, the geometry is being tested here.
+	 * Using normals and colors, faces are split separately. we do this by storing for each
+	 * vertex a normal and a color
 	 */
 	RPatch *rp;
 	RNode *rn;
 	VeNoCo *vnc, *next, *vnc1;
 	int a;
 	
-	/* test of gesplit moet worden */
+	/* test if we need a split */
 	
 	rp= RG.patchbase.first;
 	while(rp) {
@@ -98,7 +99,7 @@ void splitconnected()
 					vnc->col= (float *)rp->ref;
 					vnc->flag= 1;
 				}
-				else {	/* mag vlak deze vertex gebruiken voor gouraud? */
+				else {	/* is face from this vertex allowed for gouraud? */
 					vnc1= vnc;
 					while(vnc1) {
 						if(VecCompare(vnc1->n, rp->norm, 0.01)) {
@@ -127,7 +128,7 @@ void splitconnected()
 		}
 		rp= rp->next;
 	}
-		/* de vertexpointers van nodes aanpassen */
+		/* adapt vertexpointers from nodes */
 	
 	rp= RG.patchbase.first;
 	while(rp) {
@@ -141,7 +142,7 @@ void splitconnected()
 	}
 	
 	
-	/* het hele zaakje vrijgeven */
+	/* free all */
 	vnc= RG.verts;
 	for(a=0; a<RG.totvert; a++) {
 		vnc1= vnc->next;
@@ -218,8 +219,8 @@ static void setedge(RNode *node, RNode *nb, int nr, int nrb)
 
 void setedgepointers()
 {
-	/* edge-array maken en sorteren */
-	/* paren edges staan bij elkaar: pointers invullen in nodes */
+	/* make edge-array and sort it */
+	/* pairs of edges are put together: fill in pointers in nodes */
 	EdSort *es, *esblock;
 	RPatch *rp;
 	RNode *rn;
@@ -430,7 +431,7 @@ void rad_collect_meshes()
 							v4= (RG.verts+mface->v4+offs)->v;
 						}			
 						rn->par= rp;
-						rn->f= RAD_PATCH;	/* deze node is Patch */
+						rn->f= RAD_PATCH;	/* this node is a Patch */
 						rn->type= rp->type;
 
 						CalcNormFloat(v1, v2, v3, rp->norm);
@@ -439,7 +440,7 @@ void rad_collect_meshes()
 
 						rn->area= rp->area;
 
-						/* kleur en emit */
+						/* color and emit */
 						if(mface->mat_nr != index) {
 							index= mface->mat_nr;
 							ma= give_current_material(ob, index+1);
@@ -516,7 +517,7 @@ void countelem(RNode *rn)
 
 void countglobaldata()
 {
-	/* telt aantal elements en patches*/
+	/* counts elements and patches*/
 	RPatch *rp;
 
 	RG.totelem= RG.totpatch= 0;
@@ -559,7 +560,7 @@ void makeGlobalElemArray()
 		return;
 	}
 
-	/* recursief elements toevoegen */
+	/* recursive adding elements */
 	rp= RG.patchbase.first;
 	while(rp) {
 		addelem(&el, rp->first, rp);
@@ -574,7 +575,7 @@ void makeGlobalElemArray()
 		RG.formfactors= 0;
 }
 
-void splitpatch(RPatch *old)		/* bij overflow gedurende shoot */
+void splitpatch(RPatch *old)		/* in case of overflow during shoot */
 {
 	RNode *rn;
 	float **fpp;
@@ -670,7 +671,7 @@ void addpatch(RPatch *old, RNode *rn)
 
 void converttopatches()
 {
-	/* loopt patcheslijst af, als node gesubdivided: nieuwe patch */
+	/* chacks patches list, if node subdivided: new patch */
 	RPatch *rp, *next;
 	
 	rp= RG.patchbase.first;
@@ -693,7 +694,7 @@ void subdiv_elements()
 
 	rad_init_energy();
 	
-	/* eerst maxsize elements */
+	/* first maxsize elements */
 	
 	while(toobig) {
 		toobig= 0;
@@ -773,7 +774,7 @@ void maxsizePatches()
 		if(toobig) converttopatches();
 	}
 	
-	/* aantal lampen tellen */
+	/* count lamps */
 	rp= RG.patchbase.first;
 	RG.totlamp= 0;
 	while(rp) {