phew... a whole bunch of old and nasty files translated, including the
authorTon Roosendaal <ton@blender.org>
Tue, 29 Apr 2003 15:30:59 +0000 (15:30 +0000)
committerTon Roosendaal <ton@blender.org>
Tue, 29 Apr 2003 15:30:59 +0000 (15:30 +0000)
central mesh editing one.

source/blender/src/editface.c
source/blender/src/editika.c
source/blender/src/editimasel.c
source/blender/src/editipo.c
source/blender/src/editkey.c
source/blender/src/editlattice.c
source/blender/src/editmball.c
source/blender/src/editmesh.c
source/blender/src/editobject.c
source/blender/src/editoops.c
source/blender/src/editscreen.c

index 2749f96036ce2e3343384cf89ba6c535cdf68857..191cf0319942637d5c276d6611a43a43f3d54ae7 100644 (file)
@@ -269,7 +269,7 @@ void select_linked_tfaces()
        while(doit) {
                doit= 0;
                
-               /* select connected: array vullen */
+               /* select connected: fill array */
                tface= me->tface;
                mface= me->mface;
                a= me->totface;
@@ -286,7 +286,7 @@ void select_linked_tfaces()
                        tface++; mface++;
                }
                
-               /* omgekeerd: vanuit array vlakken selecteren */
+               /* reverse: using array select the faces */
 
                tface= me->tface;
                mface= me->mface;
index f167489dc5cf5246ddc93fca999a8b686ba50eb3..bf94f3db3c95baf3d17744b2bda8eb51f4e22910 100644 (file)
@@ -1,4 +1,10 @@
 /**
+ * ------------------------------------------------------------
+ * This is the old 'Ika' system of Blender (until 2.14)
+ * it should be removed entirely from the tree, so I'll also leave comments
+ * not translated... (ton)
+ * ------------------------------------------------------------
+ *
  * $Id$
  *
  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
index d2c43a9efbfe5e65a859da9b242d38aca42bde9d..76594c62ad8cb3eddca3fd778e1a2111482a0bb0 100644 (file)
@@ -262,7 +262,7 @@ void winqreadimaselspace(ScrArea *sa, void *spacedata, BWinEvent *evt)
        
        case MOUSEX:
        case MOUSEY:
-               getmouseco_areawin(mval);       /* lokaal screen */
+               getmouseco_areawin(mval);       /* local screen coordinates */
                calc_hilite(simasel);
                if (simasel->mouse_move_redraw ){
                        simasel->mouse_move_redraw = 0;
index 9e14858b875fe58544a8c97d1ea1911ac8f240c8..6d6b03828c8ce46a994a0fe7840441ba85866cf9 100644 (file)
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  */
 
+
+/* this code feels over-complex, mostly because I choose in the past to devise a system
+  that converts the Ipo blocks (linked to Object, Material, etc), into a copy of that
+  data which is being worked on;  the 'editipo'.
+  The editipo then can have 'ipokey' data, which is optimized for editing curves as if
+  it were key positions. This is still a great feature to work with, which makes ipo editing
+  in Blender still valuable. However, getting this beast under control was hard, even
+  for me... (ton) */
+
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
@@ -554,7 +563,7 @@ void editipo_changed(SpaceIpo *si, int doredraw)
                
                if(ei->icu) {
                        
-                               /* 2 keer i.v.m. ittereren nieuwe autohandle */
+                               /* twice because of ittererating new autohandle */
                        calchandles_ipocurve(ei->icu);
                        calchandles_ipocurve(ei->icu);
                        
@@ -572,9 +581,8 @@ void editipo_changed(SpaceIpo *si, int doredraw)
        }
 
        v2d= &(si->v2d);        
-//     v2d = &G.v2d;
 
-       /* keylijnen? */
+       /* keylines? */
        if(si->blocktype==ID_KE) {
                key= (Key *)si->from;
                if(key && key->block.first) {
@@ -586,7 +594,7 @@ void editipo_changed(SpaceIpo *si, int doredraw)
        }
        
        
-       /* is er geen curve? */
+       /* is there no curve? */
        if(first) {
                v2d->tot.xmin= 0.0;
                v2d->tot.xmax= EFRA;
@@ -604,13 +612,12 @@ void editipo_changed(SpaceIpo *si, int doredraw)
        si->tot= v2d->tot;      
        
        if(doredraw) {
-               /* als do_ipo altijd wordt aangeroepen: problemen met insertkey, bijvoorbeeld
-                * als alleen een 'loc' wordt ge-insert wordt de 'ob->rot' veranderd.
+               /* if you always call do_ipo: you get problems with insertkey, for example
+                * when inserting only a 'loc' the 'ob->rot' value then is changed.
                 */
 
-
                if(si->blocktype==ID_OB) {                      
-                               /* clear delta loc,rot,size (bij ipo vrijgeven/deleten) */
+                               /* clear delta loc,rot,size (when free/delete ipo) */
                        clear_delta_obipo(si->ipo);
                        
                }
@@ -658,7 +665,7 @@ void editipo_changed(SpaceIpo *si, int doredraw)
 
 void scale_editipo()
 {
-       /* komt uit buttons, scale met G.sipo->tot rect */
+       /* comes from buttons, scale with G.sipo->tot rect */
        
        EditIpo *ei;
        BezTriple *bezt;
@@ -801,7 +808,7 @@ unsigned int ipo_rainbow(int cur, int tot)
 
        dfac= (float)(1.0/( (float)tot+1.0));
 
-       /* deze berekening zorgt voor twee verschillende cycles regenboogkleuren */
+       /* this calculation makes 2 different cycles of rainbow colors */
        if(cur< tot/2) fac= (float)(cur*2.0*dfac);
        else fac= (float)((cur-tot/2)*2.0*dfac +dfac);
        
@@ -973,7 +980,6 @@ void make_mat_editipo(SpaceIpo *si)
                        ei->adrcode |= texchannel_to_adrcode(si->channel);
                }
                else {
-                       /* dit was weggecommentaard. Waarom? */
                        if(ei->adrcode==MA_MODE) ei->disptype= IPO_DISPBITS;
                }
                
@@ -1246,7 +1252,7 @@ void make_editipo()
 
        if(G.sipo->editipo==0) return;
        
-       /* rowbut voor VISIBLE select */
+       /* rowbut for VISIBLE select */
        G.sipo->rowbut= 0;
        ei= G.sipo->editipo;
        for(a=0; a<G.sipo->totipo; a++, ei++) {
@@ -1357,7 +1363,7 @@ void get_status_editipo()
                        if(ei->flag & IPO_SELECT) totipo_sel++;
                        if(G.sipo->showkey || (ei->flag & IPO_EDIT)) {
                                
-                               /* als showkey: wel de vertices tellen (voor grab) */
+                               /* if showkey: do count the vertices (for grab) */
                                if(G.sipo->showkey==0) totipo_edit++;
                                
                                if(ei->icu) {
@@ -1439,7 +1445,7 @@ void set_editflag_editipo()
        EditIpo *ei;
        int a; /*  , tot= 0, ok= 0; */
        
-       /* van showkey direkt door naar editen geselecteerde punten */
+       /* after showkey immediately go to editing of selected points */
        if(G.sipo->showkey) {
                G.sipo->showkey= 0;
                if(G.sipo->ipo) G.sipo->ipo->showkey= 0;
@@ -1646,8 +1652,8 @@ void deselectall_editipo()
 
 short findnearest_ipovert(IpoCurve **icu, BezTriple **bezt)
 {
-       /* selected krijgen een nadeel */
-       /* in icu en (bezt of bp) wordt nearest weggeschreven */
+       /* selected verts get a disadvantage */
+       /* in icu and (bezt or bp) the nearest is written */
        /* return 0 1 2: handlepunt */
        EditIpo *ei;
        BezTriple *bezt1;
@@ -1686,7 +1692,7 @@ short findnearest_ipovert(IpoCurve **icu, BezTriple **bezt)
                                        }
                                        
                                        if(ei->disptype!=IPO_DISPBITS && ei->icu->ipo==IPO_BEZ) {
-                                               /* middelste punten een klein voordeel */
+                                               /* middle points get an advantage */
                                                temp= -3+abs(mval[0]- bezt1->s[0][0])+ abs(mval[1]- bezt1->s[0][1]);
                                                if( bezt1->f1 & 1) temp+=5;
                                                if(temp<dist) { 
@@ -1788,13 +1794,13 @@ void do_ipo_selectbuttons()
        
        if(G.sipo->showkey) return;
        
-       /* geen editipo toestaan: editipo's naar selected omzetten */
+       /* do not allow editipo here: convert editipos to selected */
        get_status_editipo();
        if(totipo_edit) {
                set_editflag_editipo();
        }
        
-       /* welke */
+       /* which */
        getmouseco_areawin(mval);
 
        nr= -(mval[1]-curarea->winy+30-G.sipo->butofs-IPOBUTY)/IPOBUTY;
@@ -1970,8 +1976,8 @@ IpoCurve *get_ipocurve(ID *from, short type, int adrcode, Ipo *useipo)
        Ipo *ipo= 0;
        IpoCurve *icu=0;
        
-       /* return 0 als lib */
-       /* ook testen of ipo en ipocurve bestaan */
+       /* return 0 if lib */
+       /* also test if ipo and ipocurve exist */
 
        if (useipo==NULL) {
 
@@ -2036,7 +2042,7 @@ void insert_vert_ipo(IpoCurve *icu, float x, float y)
                icu->totvert= 1;
        }
        else {
-               /* alle vertices deselect */
+               /* all vertices deselect */
                for(a=0; a<icu->totvert; a++, bezt++) {
                        bezt->f1= bezt->f2= bezt->f3= 0;
                }
@@ -2044,7 +2050,7 @@ void insert_vert_ipo(IpoCurve *icu, float x, float y)
                bezt= icu->bezt;
                for(a=0; a<=icu->totvert; a++, bezt++) {
                        
-                       /* geen dubbele punten */
+                       /* no double points */
                        if(a<icu->totvert && (bezt->vec[1][0]>x-IPOTHRESH && bezt->vec[1][0]<x+IPOTHRESH)) {
                                *(bezt)= beztr;
                                break;
@@ -2071,7 +2077,7 @@ void insert_vert_ipo(IpoCurve *icu, float x, float y)
        
        calchandles_ipocurve(icu);
        
-       /* handletype goedzetten */
+       /* set handletype */
        if(icu->totvert>2) {
                h1= h2= HD_AUTO;
                if(a>0) h1= (bezt-1)->h2;
@@ -2120,7 +2126,7 @@ void add_vert_ipo()
        
        insert_vert_ipo(ei->icu, x, y);
 
-       /* voor zekerheid: als icu 0 was, of maar 1 curve visible */
+       /* to be sure: if icu was 0, or only 1 curve visible */
        ei->flag |= IPO_SELECT;
        ei->icu->flag= ei->flag;
 
@@ -2144,7 +2150,7 @@ void add_duplicate_editipo()
                        if(G.sipo->showkey || (ei->flag & IPO_EDIT)) {
                                icu= ei->icu;
                                
-                               /* hoeveel punten */
+                               /* how many points */
                                tot= 0;
                                b= icu->totvert;
                                bezt= icu->bezt;
@@ -2199,7 +2205,7 @@ void remove_doubles_ipo()
        for(a=0; a<G.sipo->totipo; a++, ei++) {
                if ISPOIN3(ei, flag & IPO_VISIBLE, icu, icu->bezt) {
                        
-                       /* OF de curve is selected OF in editmode OF in keymode */
+                       /* OR the curve is selected OR in editmode OR in keymode */
                        mode= 0;
                        if(G.sipo->showkey || (ei->flag & IPO_EDIT)) mode= 1;
                        else if(ei->flag & IPO_SELECT) mode= 2;
@@ -2212,16 +2218,16 @@ void remove_doubles_ipo()
                                bezt++;
                                while(b--) {
                                        
-                                       /* mag er verwijderd worden? */
+                                       /* can we remove? */
                                        if(mode==2 || (bezt->f2 & 1)) {
                                        
-                                               /* verschillen de punten? */
+                                               /* are the points different? */
                                                if( fabs( bezt->vec[1][0]-newb->vec[1][0] ) > 0.9 ) {
                                                        newb++;
                                                        *newb= *bezt;
                                                }
                                                else {
-                                                       /* gemiddelde */
+                                                       /* median */
                                                        VecMidf(newb->vec[0], newb->vec[0], bezt->vec[0]);
                                                        VecMidf(newb->vec[1], newb->vec[1], bezt->vec[1]);
                                                        VecMidf(newb->vec[2], newb->vec[2], bezt->vec[2]);
@@ -2247,9 +2253,9 @@ void remove_doubles_ipo()
                }
        }
        
-       editipo_changed(G.sipo, 1);     /* maakt ook ipokeys opnieuw! */
+       editipo_changed(G.sipo, 1);     /* makes ipokeys again! */
 
-       /* dubbele keys weg */
+       /* remove double keys */
        if(G.sipo->showkey) {
                ik= G.sipo->ipokey.first;
                ikn= ik->next;
@@ -2270,7 +2276,7 @@ void remove_doubles_ipo()
 
                }
                
-               editipo_changed(G.sipo, 1);     /* maakt ook ipokeys opnieuw! */
+               editipo_changed(G.sipo, 1);     /* makes ipokeys agian! */
 
        }
        deselectall_editipo();
@@ -2294,14 +2300,14 @@ void join_ipo()
        }
        else if(mode!=1) return;
        
-       /* eerst: meerdere geselecteerde verts in 1 curve */
+       /* first: multiple selected verts in 1 curve */
        ei= G.sipo->editipo;
        for(a=0; a<G.sipo->totipo; a++, ei++) {
                if ISPOIN3(ei, flag & IPO_VISIBLE, icu, icu->bezt) {
                        if(G.sipo->showkey || (ei->flag & IPO_EDIT)) {
                                icu= ei->icu;
                                
-                               /* hoeveel punten */
+                               /* how many points */
                                tot= 0;
                                b= icu->totvert;
                                bezt= icu->bezt;
@@ -2315,7 +2321,7 @@ void join_ipo()
                                        icu->totvert-= tot;
                                        
                                        newb= MEM_mallocN(icu->totvert*sizeof(BezTriple), "bezt");
-                                       /* het eerste punt wordt het nieuwe punt */
+                                       /* the first point is the new one */
                                        beztn= newb+1;
                                        tot= 0;
                                        
@@ -2353,9 +2359,9 @@ void join_ipo()
                }
        }
        
-       /* dan: in keymode: meerdere geselecteerde keys samenvoegen */
+       /* next: in keymode: join multiple selected keys */
        
-       editipo_changed(G.sipo, 1);     /* maakt ook ipokeys opnieuw! */
+       editipo_changed(G.sipo, 1);     /* makes ipokeys again! */
        
        if(G.sipo->showkey) {
                ik= G.sipo->ipokey.first;
@@ -2572,7 +2578,7 @@ void mouse_select_ipo()
                                getmouseco_areawin(mval);
                                
                                areamouseco_to_ipoco(G.v2d, mval, &x, &y);
-                               /* hoeveel is 20 pixels? */
+                               /* how much is 20 pixels? */
                                mindist= (float)(20.0*(G.v2d->cur.ymax-G.v2d->cur.ymin)/(float)curarea->winy);
                                
                                kb= key->block.first;
@@ -2591,25 +2597,12 @@ void mouse_select_ipo()
                                                ok= okee("Copy Key after leaving EditMode");
                                        }
                                        if(ok) {
-                                               /* doet ook alle keypos */
+                                               /* also does all keypos */
                                                deselectall_editipo();
                                                
-                                               /* oldflag= actkb->flag; */
-                                               
-                                               /* if(G.qual & LR_SHIFTKEY); */
-                                               /* else { */
-                                               /*      deselectall_key(); */
-                                               /* } */
-                                               
-                                               /* if(G.qual & LR_SHIFTKEY) { */
-                                               /*      if(oldflag & 1) actkb->flag &= ~1; */
-                                               /*      else actkb->flag |= 1; */
-                                               /* } */
-                                               /* else { */
-                                                       actkb->flag |= 1;
-                                               /* } */
+                                               actkb->flag |= 1;
                                                
-                                               /* bereken keypos */
+                                               /* calc keypos */
                                                showkeypos((Key *)G.sipo->from, actkb);
                                        }
                                }
@@ -2795,6 +2788,7 @@ int selected_bezier_loop(int (*looptest)(EditIpo *),
                                ipocurve_function(ei->icu);
                }
                /* nufte flourdje zim ploopydu <-- random dutch looking comment ;) */
+               /* looks more like russian to me! (ton) */
        }
 
        return 0;
@@ -3330,7 +3324,7 @@ void paste_editipo()
                error("Incompatible paste");
        }
        else {
-               /* problemen voorkomen: andere splines visible dan select */
+               /* prevent problems: splines visible that are not selected */
                if(totipo_vis==totipo_sel) totipo_vis= 0;
                
                icu= ipocopybuf.first;
@@ -3376,7 +3370,7 @@ void set_exprap_ipo(int mode)
        int a;
                
        if(G.sipo->ipo && G.sipo->ipo->id.lib) return;
-       /* in geval van keys: altijd ok */
+       /* in case of keys: always ok */
 
        ei= G.sipo->editipo;
        for(a=0; a<G.sipo->totipo; a++, ei++) {
@@ -3425,7 +3419,7 @@ void set_speed_editipo(float speed)
                
        if(G.sipo->ipo && G.sipo->ipo->id.lib) return;
 
-       /* uitgaande van 1 visible curve, selected punt, bijhorende punten: lencorr! */
+       /* starting with 1 visible curve, selected point, associated points: do lencorr! */
 
        ei= G.sipo->editipo;
        for(a=0; a<G.sipo->totipo; a++, ei++) {
@@ -3514,7 +3508,7 @@ void insertkey(ID *id, int adrcode)
                                if( GS(id->name)==ID_OB ) {
                                        ob= (Object *)id;
                                        if(ob->sf!=0.0 && (ob->ipoflag & OB_OFFS_OB) ) {
-                                               /* eigenlijk frametofloat overniew berekenen! daarvoor CFRA als float door kunnen geven */
+                                               /* actually frametofloat calc again! */
                                                cfra-= ob->sf*G.scene->r.framelen;
                                        }
                                }
@@ -3550,7 +3544,7 @@ void insertkey_editipo()
                        else if(ei->flag & IPO_SELECT) ok= 1;
 
                        if(ok) {
-                               /* aantal tellen */
+                               /* count amount */
                                if(event==1) tot= 1;
                                else {
                                        ik= G.sipo->ipokey.first;
@@ -3562,7 +3556,7 @@ void insertkey_editipo()
                                }
                                if(tot) {
                                
-                                       /* correctie voor ob timeoffs */
+                                       /* correction for ob timeoffs */
                                        cfra= frame_to_float(CFRA);
                                        id= G.sipo->from;       
                                        if(id && GS(id->name)==ID_OB ) {
@@ -3580,7 +3574,7 @@ void insertkey_editipo()
                                        }
                        
                                        insertvals= MEM_mallocN(sizeof(float)*2*tot, "insertkey_editipo");
-                                       /* zeker zijn dat icu->curval klopt */
+                                       /* make sure icu->curval is correct */
                                        calc_ipo(G.sipo->ipo, cfra);
                                        
                                        if(event==1) {
@@ -3939,7 +3933,7 @@ void common_insertkey()
                                if TESTBASELIB(base) {
                                        id= (ID *)(base->object);
                                        
-                                       /* alle curves in ipo deselect */
+                                       /* all curves in ipo deselect */
                                        if(base->object->ipo) {
                                                icu= base->object->ipo->curve.first;
                                                while(icu) {
@@ -3965,14 +3959,14 @@ void common_insertkey()
                                                insertkey(id, OB_SIZE_Z);
                                        }
                                        if(event==5) {
-                                               /* localview weghalen */
+                                               /* remove localview  */
                                                tlay= base->object->lay;
                                                base->object->lay &= 0xFFFFFF;
                                                insertkey(id, OB_LAY);
                                                base->object->lay= tlay;
                                        }
                                        if(event==8) {
-                                               /* deze patch moet omdat duplicators de positie van effg veranderen */
+                                               /* a patch, can be removed (old ika) */
                                                Ika *ika= ob->data;
                                                VecMat4MulVecfl(ika->effg, ob->obmat, ika->effn);
                                                
@@ -3998,10 +3992,10 @@ void common_insertkey()
 
 /* IPOKEY:
  * 
- *   er zijn drie manieren om hiermee om te gaan:
- *   1. hieronder: voor tekenen en editen in Ipo window
- *   2. voor tekenen keys in View3D (zie ipo.c en drawobject.c)
- *   3. voor editen keys in View3D (hieronder en editobject.c)
+ *   there are three ways to use this system:
+ *   1. below: for drawing and editing in Ipo window
+ *   2. for drawing key positions in View3D (see ipo.c and drawobject.c)
+ *   3. editing keys in View3D (below and in editobject.c)
  * 
  */
 
@@ -4027,7 +4021,7 @@ void add_to_ipokey(ListBase *lb, BezTriple *bezt, int nr, int len)
        while(ik) {
                
                if( ik->val==bezt->vec[1][0] ) {
-                       if(ik->data[nr]==0) {   /* dubbele punten! */
+                       if(ik->data[nr]==0) {   /* double points! */
                                ik->data[nr]= bezt;
                                if(bezt->f2 & 1) ik->flag= 1;
                                return;
@@ -4077,7 +4071,7 @@ void make_ipokey(void)
                }
        }
        
-       /* selectflags testen */
+       /* test selectflags */
        ik= lb->first;
        while(ik) {
                sel= desel= 0;
@@ -4121,7 +4115,7 @@ void make_ipokey_transform(Object *ob, ListBase *lb, int sel)
        if(ob->ipo==0) return;
        if(ob->ipo->showkey==0) return;
        
-       /* testen: zijn er delta curves? */
+       /* test: are there delta curves? */
        icu= ob->ipo->curve.first;
        while(icu) {
                if(icu->flag & IPO_VISIBLE) {
@@ -4202,7 +4196,7 @@ void make_ipokey_transform(Object *ob, ListBase *lb, int sel)
        }
 }
 
-void update_ipokey_val()       /* na verplaatsen vertices */
+void update_ipokey_val()       /* after moving vertices */
 {
        IpoKey *ik;
        int a;
@@ -4276,17 +4270,17 @@ void set_ipo_pointers_transob(IpoKey *ik, TransOb *tob)
                }
        }
        
-       /* oldvals voor o.a. undo */
+       /* oldvals for e.g. undo */
        if(tob->locx) set_tob_old(tob->oldloc, tob->locx);
        if(tob->locy) set_tob_old(tob->oldloc+1, tob->locy);
        if(tob->locz) set_tob_old(tob->oldloc+2, tob->locz);
                
-               /* bewaar de eerste oldrot, ivm mapping curves ('1'=10 graden) en correcte berekening */
+               /* store first oldrot, for mapping curves ('1'=10 degrees) and correct calculation */
        if(tob->rotx) set_tob_old(tob->oldrot+3, tob->rotx);
        if(tob->roty) set_tob_old(tob->oldrot+4, tob->roty);
        if(tob->rotz) set_tob_old(tob->oldrot+5, tob->rotz);
        
-               /* bewaar de eerste oldsize, dit mag niet de dsize zijn! */
+               /* store the first oldsize, this is not allowed to be dsize! */
        if(tob->sizex) set_tob_old(tob->oldsize+3, tob->sizex);
        if(tob->sizey) set_tob_old(tob->oldsize+4, tob->sizey);
        if(tob->sizez) set_tob_old(tob->oldsize+5, tob->sizez);
@@ -4326,7 +4320,7 @@ void nextkey(ListBase *elems, int dir)
                else if(ik==0) previk->flag= 0;
        }
        
-       /* als geen een key select: */
+       /* when no key select: */
        if(totsel==0) {
                if(dir==1) ik= elems->first;
                else ik= elems->last;
@@ -4344,7 +4338,7 @@ static int float_to_frame (float frame)
        return to;      
 }
 
-void movekey_ipo(int dir)              /* alleen extern aanroepen vanuit view3d queue */
+void movekey_ipo(int dir)              /* only call external from view3d queue */
 {
        IpoKey *ik;
        float toframe = 0.0;
@@ -4381,7 +4375,7 @@ void movekey_ipo(int dir)         /* alleen extern aanroepen vanuit view3d queue */
 
 }
 
-void movekey_obipo(int dir)            /* alleen extern aanroepen vanuit view3d queue */
+void movekey_obipo(int dir)            /* only call external from view3d queue */
 {
        Base *base;
        Object *ob;
@@ -4436,7 +4430,7 @@ void movekey_obipo(int dir)               /* alleen extern aanroepen vanuit view3d queue */
 
 }
 
-void nextkey_ipo(int dir)                      /* aanroepen vanuit ipo queue */
+void nextkey_ipo(int dir)                      /* call from ipo queue */
 {
        IpoKey *ik;
        int a;
@@ -4445,7 +4439,7 @@ void nextkey_ipo(int dir)                 /* aanroepen vanuit ipo queue */
        
        nextkey(&G.sipo->ipokey, dir);
        
-       /* kopieeren naar beziers */
+       /* copy to beziers */
        ik= G.sipo->ipokey.first;
        while(ik) {
                for(a=0; a<G.sipo->totipo; a++) {
@@ -4460,7 +4454,7 @@ void nextkey_ipo(int dir)                 /* aanroepen vanuit ipo queue */
        if(G.sipo->blocktype == ID_OB) allqueue(REDRAWVIEW3D, 0);
 }
 
-void nextkey_obipo(int dir)            /* alleen extern aanroepen vanuit view3d queue */
+void nextkey_obipo(int dir)            /* only call external from view3d queue */
 {
        Base *base;
        Object *ob;
@@ -4482,7 +4476,7 @@ void nextkey_obipo(int dir)               /* alleen extern aanroepen vanuit view3d queue */
                                        
                                        nextkey(&elems, dir);
                                        
-                                       /* kopieeren naar beziers */
+                                       /* copy to beziers */
                                        ik= elems.first;
                                        while(ik) {
                                                for(a=0; a<OB_TOTIPO; a++) {
@@ -4584,11 +4578,11 @@ void transform_ipo(int mode)
        
        if(G.sipo->ipo && G.sipo->ipo->id.lib) return;
        if(G.sipo->editipo==0) return;
-       if(mode=='r') return;   /* vanuit gesture */
+       if(mode=='r') return;   /* from gesture */
        
        INIT_MINMAX(min, max);
        
-       /* welke vertices doen mee */
+       /* which vertices are involved */
        get_status_editipo();
        if(totipo_vertsel) {
                tot= totipo_vertsel;
@@ -4611,7 +4605,7 @@ void transform_ipo(int mode)
                                                                        VECCOPY(tv->oldloc, tv->loc);
                                                                        if(ei->disptype==IPO_DISPBITS) tv->flag= 1;
                                                                        
-                                                                       /* let op: we nemen middelste vertex */
+                                                                       /* we take the middle vertex */
                                                                        DO_MINMAX2(bezt->vec[1], min, max);
 
                                                                        tv++;
@@ -4621,7 +4615,7 @@ void transform_ipo(int mode)
                                                                        VECCOPY(tv->oldloc, tv->loc);
                                                                        if(ei->disptype==IPO_DISPBITS) tv->flag= 1;
                                                                        
-                                                                       /* let op: we nemen middelste vertex */
+                                                                       /* we take the middle vertex */
                                                                        DO_MINMAX2(bezt->vec[1], min, max);
 
                                                                        tv++;
@@ -4732,7 +4726,7 @@ void transform_ipo(int mode)
                                
                                if(midtog) dvec[proj]= 0.0;
                                
-                               /* vec wordt verderop nog gebruikt: remake_ipo_transverts */
+                               /* vec is reused below: remake_ipo_transverts */
                                vec[0]= dvec[0];
                                vec[1]= dvec[1];
                                
@@ -4780,7 +4774,7 @@ void transform_ipo(int mode)
                        for(a=0; a<G.sipo->totipo; a++, ei++) {
                                if ISPOIN(ei, flag & IPO_VISIBLE, icu) {
                                        
-                                       /* let op: als de tijd verkeerd is: niet de handles corrigeren */
+                                       /* watch it: if the time is wrong: do not correct handles */
                                        if (test_time_ipocurve(ei->icu) ) dosort++;
                                        else testhandles_ipocurve(ei->icu);
                                }
@@ -4924,7 +4918,7 @@ void clever_numbuts_ipo()
        if(G.sipo->ipo && G.sipo->ipo->id.lib) return;
        if(G.sipo->editipo==0) return;
        
-       /* welke vertices doen mee */
+       /* which vertices are involved */
        get_status_editipo();
 
        if(G.qual & LR_SHIFTKEY) totbut= 1;
@@ -5074,7 +5068,7 @@ void sampledata_to_ipocurve(float *data, int sfra, int efra, IpoCurve *icu)
        if(icu->bezt) MEM_freeN(icu->bezt);
        icu->bezt= 0;
        
-       tot= 1; /* eerste punt */
+       tot= 1; /* first point */
        da= data+1;
        for(a=sfra+1; a<efra; a++, da++) {
                if( IS_EQ(da[0], da[1])==0 && IS_EQ(da[1], da[2])==0 ) tot++;
@@ -5097,12 +5091,12 @@ void sampledata_to_ipocurve(float *data, int sfra, int efra, IpoCurve *icu)
 
 void ipo_record()
 {
-       /* 1 of 2 aktieve curves
-        * kopie maken (ESC) 
+       /* only 1 or 2 active curves
+        * make a copy (ESC) 
         *
-        * nulpunt is de huidige stand (of 0)
-        * dx (dy identiek) is de hoogteverhouding
-        * CTRL start record
+        * reference point is the current situation (or 0)
+        * dx (dy) is the height correction factor
+        * CTRL: start record
         */
        extern double tottime;
        EditIpo *ei, *ei1=0, *ei2=0;
@@ -5147,7 +5141,7 @@ void ipo_record()
                return;
        }
        
-       /* curves gereedmaken, startwaardes */
+       /* make curves ready, start values */
        if(ei1->icu==0) ei1->icu= get_ipocurve(G.sipo->from, G.sipo->blocktype, ei1->adrcode, 0);
        if(ei1->icu==0) return;
        poin= get_ipo_poin(G.sipo->from, ei1->icu, &type);
@@ -5167,7 +5161,7 @@ void ipo_record()
        fac= G.v2d->cur.ymax - G.v2d->cur.ymin;
        fac/= (float)curarea->winy;
 
-       /* welke area */
+       /* which area */
        oldarea= curarea;
        sa= G.curscreen->areabase.first;
        while(sa) {
@@ -5183,7 +5177,7 @@ void ipo_record()
        }
        if(sa) areawinset(sa->win);
        
-       /* kandie? */
+       /* can we? */
        while(get_mbut()&L_MOUSE) BIF_wait_for_statechange();
        data1= MEM_callocN(sizeof(float)*(EFRA-SFRA+1), "data1");
        data2= MEM_callocN(sizeof(float)*(EFRA-SFRA+1), "data2");
@@ -5208,7 +5202,7 @@ void ipo_record()
 
                        set_timecursor(cfra);
                        
-                       /* ipo doen: eerst alles daarna de specifieke */
+                       /* do ipo: first all, then the specific ones */
                        if(anim==2) {
                                do_all_ipos();
                                do_all_keys();
@@ -5236,7 +5230,7 @@ void ipo_record()
 
                        if(sa) scrarea_do_windraw(sa);
 
-                       /* minimaal swaptime laten voorbijgaan */
+                       /* minimal wait swaptime */
                        tottime -= swaptime;
                        while (update_time()) PIL_sleep_ms(1);
 
@@ -5270,14 +5264,14 @@ void ipo_record()
                sampledata_to_ipocurve(data1+sfra-SFRA, sfra, efra, ei1->icu);
                if(ei2) sampledata_to_ipocurve(data2+sfra-SFRA, sfra, efra, ei2->icu);
 
-               /* vervelend als dat aanstaat */
+               /* not nice when this is on */
                if(G.sipo->showkey) {
                        G.sipo->showkey= 0;
                        free_ipokey(&G.sipo->ipokey);
                }
        }
        else {
-               /* undo: startwaardes */
+               /* undo: start values */
                poin= get_ipo_poin(G.sipo->from, ei1->icu, &type);
                if(poin) write_ipo_poin(poin, type, or1);
                if(ei1->icu->bezt==0) {
@@ -5307,7 +5301,7 @@ void ipo_record()
        scrarea_queue_redraw(oldarea);
        CFRA= cfrao;
        
-       /* vooropig? */
+       /* for the time being? */
        update_for_newframe();
        
        MEM_freeN(data1);
index b1a2ec1a2ba231842b6720a942ab11603be7a46b..0d8b04339c1fa578bf20d9ca176829d1bc172531 100644 (file)
@@ -192,7 +192,7 @@ void insert_meshkey(Mesh *me)
        
        sort_keys(me->key);
 
-       /* curent actief: */
+       /* curent active: */
        kkb= key->block.first;
        while(kkb) {
                kkb->flag &= ~SELECT;
@@ -272,7 +272,7 @@ void insert_lattkey(Lattice *lt)
        
        sort_keys(lt->key);
 
-       /* curent actief: */
+       /* curent active: */
        kkb= key->block.first;
        while(kkb) {
                kkb->flag &= ~SELECT;
@@ -292,7 +292,7 @@ void curve_to_key(Curve *cu, KeyBlock *kb, ListBase *nurb)
        float *fp;
        int a, tot;
        
-       /* tellen */
+       /* count */
        tot= count_curveverts(nurb);
        if(tot==0) return;
        
@@ -315,7 +315,7 @@ void curve_to_key(Curve *cu, KeyBlock *kb, ListBase *nurb)
                                fp+= 3;
                                VECCOPY(fp, bezt->vec[2]);
                                fp+= 3;
-                               fp+= 3; /* alfa's */
+                               fp+= 3; /* alphas */
                                bezt++;
                        }
                }
@@ -361,7 +361,7 @@ void key_to_curve(KeyBlock *kb, Curve  *cu, ListBase *nurb)
                                fp+= 3;
                                VECCOPY(bezt->vec[2], fp);
                                fp+= 3;
-                               fp+= 3; /* alfa's */
+                               fp+= 3; /* alphas */
                                
                                tot-= 3;
                                bezt++;
@@ -415,7 +415,7 @@ void insert_curvekey(Curve *cu)
        
        sort_keys(cu->key);
 
-       /* curent actief: */
+       /* curent active: */
        kkb= key->block.first;
        while(kkb) {
                kkb->flag &= ~SELECT;
@@ -457,7 +457,7 @@ void showkeypos(Key *key, KeyBlock *kb)
        Curve *cu;
        int tot;
        
-       /* vanuit ipo */
+       /* from ipo */
        ob= OBACT;
        if(ob==0) return;
        
@@ -483,7 +483,6 @@ void showkeypos(Key *key, KeyBlock *kb)
                        tot= count_curveverts(&cu->nurb);
                        cp_cu_key(cu, kb, 0, tot);
 
-/*                     make_displists_by_obdata(me);   */
                        make_displists_by_obdata(cu);
                }
                
@@ -541,7 +540,7 @@ void delete_key(void)
                else if(GS(key->from->name)==ID_LT) ((Lattice *)key->from)->key= 0;
 
                free_libblock_us(&(G.main->key), key);
-               scrarea_queue_headredraw(curarea);      /* ipo ook weg */
+               scrarea_queue_headredraw(curarea);      /* ipo remove too */
        }
        else do_spec_key(key);
        
@@ -568,7 +567,7 @@ void move_keys(void)
        key= (Key *)G.sipo->from;
        if(key==0) return;
        
-       /* welke keys doen mee */
+       /* which keys are involved */
        kb= key->block.first;
        while(kb) {
                if(kb->flag & SELECT) tot++;
@@ -650,7 +649,7 @@ void move_keys(void)
        sort_keys(key);
        do_spec_key(key);
        
-       /* voor boundbox */
+       /* for boundbox */
        editipo_changed(G.sipo, 0);
 
        MEM_freeN(transmain);   
index 599af1e49475d3084d3df25a3646eb9ee64c7c5b..2c958d9211037ddef98dd3287a207672155bcdcb 100644 (file)
@@ -178,7 +178,7 @@ void load_editLatt(void)
        
        lt= G.obedit->data;
        
-       /* zijn er keys? */
+       /* are there keys? */
        if(lt->key) {
                actkey= lt->key->block.first;
                while(actkey) {
@@ -188,7 +188,7 @@ void load_editLatt(void)
        }
 
        if(actkey) {
-               /* aktieve key: vertices */
+               /* active key: vertices */
                tot= editLatt->pntsu*editLatt->pntsv*editLatt->pntsw;
                
                if(actkey->data) MEM_freeN(actkey->data);
@@ -259,14 +259,14 @@ void deselectall_Latt(void)
 
 static BPoint *findnearestLattvert(int sel)
 {
-       /* sel==1: selected krijgen een nadeel */
-       /* in bp wordt nearest weggeschreven */
+       /* sel==1: selected get a disadvantage */
+       /* in bp nearest is written */
        BPoint *bp1, *bp;
        short dist= 100, temp, mval[2], a;
 
        bp= 0;
 
-       /* projektie doen */
+       /* do projection */
        calc_lattverts_ext();   /* drawobject.c */
        
        getmouseco_areawin(mval);
index c187a70aa08d608d5fd0eff708c128a47be8d1fe..3ab0dff5b6967d7dcf1a2f7bbfee161f3b5a4723 100644 (file)
@@ -131,7 +131,7 @@ void add_primitiveMball(int dummy_argument)
        
        check_editmode(OB_MBALL);
 
-       /* als geen obedit: nieuw object en in editmode gaan */
+       /* if no obedit: new object and enter editmode */
        if(G.obedit==0) {
                add_object(OB_MBALL);
                base_init_from_view3d(BASACT, G.vd);
@@ -143,14 +143,14 @@ void add_primitiveMball(int dummy_argument)
                setcursor_space(SPACE_VIEW3D, CURSOR_EDIT);
        }
        
-       /* deselecteren */
+       /* deselect */
        ml= editelems.first;
        while(ml) {
                ml->flag &= ~SELECT;
                ml= ml->next;
        }
        
-       /* imat en centrum en afmeting */
+       /* imat and centre and size */
        Mat3CpyMat4(mat, G.obedit->obmat);
 
        curs= give_cursor();
@@ -218,7 +218,7 @@ void mouse_mball()
        
        hits= selectprojektie(buffer, 0, 0, 0, 0);
 
-       /* bestaat startelem? */
+       /* does startelem exist? */
        ml= editelems.first;
        while(ml) {
                if(ml==startelem) break;
index 19c0a28de1305f66dcb0b4a4eaa21d59dfe7eec9..b169ebf3fa315f19f9c94c2f9ac3e3bc45c835d0 100644 (file)
@@ -30,6 +30,9 @@
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
  */
 
+/* main mesh editing routines. please note that 'vlak' is used here to denote a 'face'. */
+/* at that time for me a face was something at the frontside of a human head! (ton) */
+
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
@@ -106,7 +109,7 @@ static float convex(float *v1, float *v2, float *v3, float *v4);
 /* extern ListBase fillvertbase, filledgebase; */ /* scanfill.c, in
     the lib... already in BLI_blenlib.h */
 
-/*  voor debug:
+/*  for debug:
 #define free(a)                        freeN(a)
 #define malloc(a)              mallocN(a, "malloc")
 #define calloc(a, b)   callocN((a)*(b), "calloc")
@@ -162,7 +165,7 @@ static short icovlak[20][3] = {
 
 /* ***************** HASH ********************* */
 
-/* HASH struct voor snel opzoeken edges */
+/* HASH struct quickly finding of edges */
 struct HashEdge {
        struct EditEdge *eed;
        struct HashEdge *next;
@@ -268,12 +271,6 @@ EditEdge *findedgelist(EditVert *v1, EditVert *v2)
                v1= v3;
        }
        
-       /* eerst even op de flip-plek kijken */
-       
-/*     he= hashedgetab + EDHASH(v2->hash, v1->hash); */
-/*     if(he->eed && he->eed->v1==v1 && he->eed->v2==v2) return he->eed; */
-       
-       
        he= hashedgetab + EDHASH(v1->hash, v2->hash);
        
        while(he) {
@@ -287,18 +284,10 @@ EditEdge *findedgelist(EditVert *v1, EditVert *v2)
 
 static void insert_hashedge(EditEdge *eed)
 {
-       /* er van uitgaande dat eed nog niet in lijst zit, en eerst een find is gedaan */
+       /* assuming that eed is not in the list yet, and that a find has been done before */
        
        struct HashEdge *first, *he;
 
-       /* eerst even op de flip-plek kijken */
-/*     he= hashedgetab + EDHASH(eed->v2->hash, eed->v1->hash); */
-
-/*     if(he->eed==0) { */
-/*             he->eed= eed; */
-/*             return; */
-/*     } */
-
        first= hashedgetab + EDHASH(eed->v1->hash, eed->v2->hash);
 
        if( first->eed==0 ) {
@@ -314,34 +303,16 @@ static void insert_hashedge(EditEdge *eed)
 
 static void remove_hashedge(EditEdge *eed)
 {
-       /* er van uitgaande dat eed in lijst zit */
+       /* assuming eed is in the list */
        
        struct HashEdge *first, *he, *prev=NULL;
 
 
-       /* eerst even op de flip-plek kijken */
-/*     first= hashedgetab + EDHASH(eed->v2->hash, eed->v1->hash); */
-
-/*     if(first->eed==eed) { */
-               /* uit lijst verwijderen */
-               
-/*             if(first->next) { */
-/*                     he= first->next; */
-/*                     first->eed= he->eed; */
-/*                     first->next= he->next; */
-/*                     free(he); */
-/*             } */
-/*             else first->eed= 0; */
-
-/*             return; */
-/*     } */
-
-
        he=first= hashedgetab + EDHASH(eed->v1->hash, eed->v2->hash);
 
        while(he) {
                if(he->eed == eed) {
-                       /* uit lijst verwijderen */
+                       /* remove from list */
                        if(he==first) {
                                if(first->next) {
                                        he= first->next;
@@ -366,35 +337,20 @@ void free_hashedgetab(void)
 {
        struct HashEdge *he, *first, *hen;
        int a;
-/*     int test[30], nr, toted=0; */
-       
-       /* for(a=0; a<30; a++) test[a]=0; */
        
        if(hashedgetab) {
        
                first= hashedgetab;
                for(a=0; a<EDHASHSIZE; a++, first++) {
                        he= first->next;
-                       /* nr= 0; */
-                       /* if(first->eed) toted++; */
-                       /* if(first->eed) nr++; */
                        while(he) {
                                hen= he->next;
                                free(he);
                                he= hen;
-                               /* nr++; */
                        }
-                       /* if(nr>29) nr= 29; */
-                       /* test[nr]++; */
                }
                MEM_freeN(hashedgetab);
                hashedgetab= 0;
-
-               /* printf("toted %d\n", toted); */
-               /* toted= 0; */
-               /* for(a=0; a<30; a++) { */
-               /*      printf("tab %d %d\n", a, test[a]); */
-               /* } */
        }
 }
 
@@ -415,7 +371,7 @@ EditEdge *addedgelist(EditVert *v1, EditVert *v2)
        if(v1==v2) return 0;
        if(v1==0 || v2==0) return 0;
        
-       /* opzoeken in hashlijst */
+       /* find in hashlist */
        eed= findedgelist(v1, v2);
        
        if(eed==0) {
@@ -463,7 +419,7 @@ EditVlak *addvlaklist(EditVert *v1, EditVert *v2, EditVert *v3, EditVert *v4, Ed
        EditEdge *e1, *e2=0, *e3=0, *e4=0;
        
 
-       /* voeg vlak toe aan lijst en doe meteen de edges */
+       /* add face to list and do the edges */
        e1= addedgelist(v1, v2);
        if(v3) e2= addedgelist(v2, v3);
        if(v4) e3= addedgelist(v3, v4); else e3= addedgelist(v3, v1);
@@ -689,9 +645,13 @@ static void edge_drawflags(void)
        EditEdge *eed, *e1, *e2, *e3, *e4;
        EditVlak *evl;
        
-       /* - tel aantal keren in vlakken gebruikt: 0 en 1 is tekenen
-        * - edges meer dan 1 keer: in *vn zit pointer naar (eerste) vlak
-        * - loop alle vlakken af, is normaal te afwijkend: tekenen (flag wordt 1)
+       /* - count number of times edges are used in faces: 0 en 1 time means draw edge
+        * - edges more than 1 time used: in *vn is pointer to first face
+        * - check all faces, when normal differs to much: draw (flag becomes 1)
+        */
+
+       /* later on: added flags for 'cylinder' and 'sphere' intersection tests in old
+          game engine (2.04)
         */
        
        recalc_editnormals();
@@ -699,7 +659,7 @@ static void edge_drawflags(void)
        /* init */
        eve= G.edve.first;
        while(eve) {
-               eve->f1= 1;             /* wordt bij test op nul gezet */
+               eve->f1= 1;             /* during test it's set at zero */
                eve= eve->next;
        }
        eed= G.eded.first;
@@ -741,7 +701,7 @@ static void edge_drawflags(void)
        }       
        else {
                
-               /* single-edges afvangen voor cylinder flag */
+               /* handle single-edges for 'test cylinder flag' (old engine) */
                
                eed= G.eded.first;
                while(eed) {
@@ -749,7 +709,7 @@ static void edge_drawflags(void)
                        eed= eed->next;
                }
 
-               /* alle vlakken, alle edges met flag==2: vergelijk normaal */
+               /* all faces, all edges with flag==2: compare normal */
                evl= G.edvl.first;
                while(evl) {
                        if(evl->e1->f==2) edge_normal_compare(evl->e1, evl);
@@ -773,7 +733,7 @@ static void edge_drawflags(void)
        }
 }
 
-static int contrpuntnorm(float *n, float *puno)
+static int contrpuntnorm(float *n, float *puno)  /* dutch: check vertex normal */
 {
        float inp;
 
@@ -792,7 +752,7 @@ void vertexnormals(int testflip)
        EditVlak *evl;  
        float n1[3], n2[3], n3[3], n4[3], co[4], fac1, fac2, fac3, fac4, *temp;
        float *f1, *f2, *f3, *f4, xn, yn, zn;
-       float opp, len;
+       float len;
        
        if(G.obedit && G.obedit->type==OB_MESH) {
                me= G.obedit->data;
@@ -802,7 +762,7 @@ void vertexnormals(int testflip)
        if(G.totvert==0) return;
 
        if(G.totface==0) {
-               /* namaak puno's voor halopuno! */
+               /* fake vertex normals for 'halo puno'! */
                eve= G.edve.first;
                while(eve) {
                        VECCOPY(eve->no, eve->co);
@@ -819,7 +779,7 @@ void vertexnormals(int testflip)
                eve= eve->next;
        }
        
-       /* berekenen cos hoeken en oppervlakte en optellen bij puno */
+       /* calculate cosine angles and add to vertex normal */
        evl= G.edvl.first;
        while(evl) {
                VecSubf(n1, evl->v2->co, evl->v1->co);
@@ -831,14 +791,9 @@ void vertexnormals(int testflip)
                        VecSubf(n3, evl->v1->co, evl->v3->co);
                        Normalise(n3);
                        
-                       /* opp= AreaT3Dfl(evl->v1->co, evl->v2->co, evl->v3->co); */
-                       /* if(opp!=0.0) opp=1.0/opp;  */
-                       /* opp= sqrt(opp); */
-                       /* for smooth subdivide...*/
-                       opp= 1.0;
-                       co[0]= opp*saacos(-n3[0]*n1[0]-n3[1]*n1[1]-n3[2]*n1[2]);
-                       co[1]= opp*saacos(-n1[0]*n2[0]-n1[1]*n2[1]-n1[2]*n2[2]);
-                       co[2]= opp*saacos(-n2[0]*n3[0]-n2[1]*n3[1]-n2[2]*n3[2]);
+                       co[0]= saacos(-n3[0]*n1[0]-n3[1]*n1[1]-n3[2]*n1[2]);
+                       co[1]= saacos(-n1[0]*n2[0]-n1[1]*n2[1]-n1[2]*n2[2]);
+                       co[2]= saacos(-n2[0]*n3[0]-n2[1]*n3[1]-n2[2]*n3[2]);
                        
                }
                else {
@@ -847,15 +802,10 @@ void vertexnormals(int testflip)
                        Normalise(n3);
                        Normalise(n4);
                        
-                       /* opp= AreaQ3Dfl(evl->v1->co, evl->v2->co, evl->v3->co, evl->v4->co); */
-                       /* if(opp!=0.0) opp=1.0/opp;  */
-                       /* opp= sqrt(opp); */
-                       /* for smooth subdivide...*/
-                       opp= 1.0;
-                       co[0]= opp*saacos(-n4[0]*n1[0]-n4[1]*n1[1]-n4[2]*n1[2]);
-                       co[1]= opp*saacos(-n1[0]*n2[0]-n1[1]*n2[1]-n1[2]*n2[2]);
-                       co[2]= opp*saacos(-n2[0]*n3[0]-n2[1]*n3[1]-n2[2]*n3[2]);
-                       co[3]= opp*saacos(-n3[0]*n4[0]-n3[1]*n4[1]-n3[2]*n4[2]);
+                       co[0]= saacos(-n4[0]*n1[0]-n4[1]*n1[1]-n4[2]*n1[2]);
+                       co[1]= saacos(-n1[0]*n2[0]-n1[1]*n2[1]-n1[2]*n2[2]);
+                       co[2]= saacos(-n2[0]*n3[0]-n2[1]*n3[1]-n2[2]*n3[2]);
+                       co[3]= saacos(-n3[0]*n4[0]-n3[1]*n4[1]-n3[2]*n4[2]);
                }
                
                temp= evl->v1->no;
@@ -887,7 +837,7 @@ void vertexnormals(int testflip)
                evl= evl->next;
        }
 
-       /* normaliseren puntnormalen */
+       /* normalise vertex normals */
        eve= G.edve.first;
        while(eve) {
                len= Normalise(eve->no);
@@ -898,7 +848,7 @@ void vertexnormals(int testflip)
                eve= eve->next;
        }
        
-       /* puntnormaal omklap-vlaggen voor bij shade */
+       /* vertex normal flip-flags for shade (render) */
        evl= G.edvl.first;
        while(evl) {
                evl->f=0;                       
@@ -928,7 +878,7 @@ void vertexnormals(int testflip)
                                }
                        }
                }
-               /* proj voor cubemap! */
+               /* projection for cubemap! */
                xn= fabs(evl->n[0]);
                yn= fabs(evl->n[1]);
                zn= fabs(evl->n[2]);
@@ -996,7 +946,7 @@ void make_editMesh(void)
 
        if(G.obedit==0) return;
 
-       /* ivm reload */
+       /* because of reload */
        free_editMesh();
        
        me= get_mesh(G.obedit);
@@ -1023,7 +973,7 @@ void make_editMesh(void)
                tot= actkey->totelem;
        }
 
-       /* editverts aanmaken */
+       /* make editverts */
        mvert= me->mvert;
 
        evlist= (EditVert **)MEM_mallocN(tot*sizeof(void *),"evlist");
@@ -1060,7 +1010,7 @@ void make_editMesh(void)
        else {
                unsigned int *mcol;
                
-               /* edges en vlakken maken */
+               /* make edges and faces */
                mface= me->mface;
                tface= me->tface;
                mcol= (unsigned int *)me->mcol;
@@ -1126,12 +1076,6 @@ static void fix_faceindices(MFace *mface, EditVlak *evl, int nr)
        float tmpuv[2];
        unsigned int tmpcol;
 
-/*
-mface =  ((MFace *) me->mface) + index;
-       tface =  ((TFace *) me->tface) + index;
-
-*/
-
        /* first test if the face is legal */
 
        if(mface->v3 && mface->v3==mface->v4) {
@@ -1150,7 +1094,7 @@ mface =  ((MFace *) me->mface) + index;
                nr--;
        }
 
-       /* voorkom dat een nul op de verkeerde plek staat */
+       /* prevent a zero index value at the wrong location */
        if(nr==2) {
                if(mface->v2==0) SWAP(int, mface->v1, mface->v2);
        }
@@ -1248,7 +1192,7 @@ void load_editMesh(void)
        
        ototvert= me->totvert;
        
-       /* zijn er keys? */
+       /* are there keys? */
        if(me->key) {
                actkey= me->key->block.first;
                while(actkey) {
@@ -1259,7 +1203,7 @@ void load_editMesh(void)
 
        
        if(actkey && me->key->refkey!=actkey) {
-               /* aktieve key && niet de refkey: alleen vertices */
+               /* active key && not the refkey: only vertices */
                                
                if(G.totvert) {
                        if(actkey->data) MEM_freeN(actkey->data);
@@ -1276,8 +1220,8 @@ void load_editMesh(void)
                }
        }
        else if(me->key && actkey==0) {
-               /* er zijn keys, alleen veranderingen in mverts schrijven */
-               /* als aantal vertices verschillen, beetje onvoorspelbaar */
+               /* there are keys, only write changes in mverts */
+               /* a bit unpredictable when the amount of vertices differ */
                        
                eve= G.edve.first;
                mvert= me->mvert;
@@ -1288,15 +1232,15 @@ void load_editMesh(void)
                }
        }
        else {
-               /* als er keys zijn: de refkey, anders gewoon de me */
+               /* when there are keys: the refkey, otherise the mesh */
                
-               /* deze telt ook of edges niet in vlakken zitten: */
-               /* eed->f==0 niet in vlak, f==1 is tekenen */
-               /* eed->f1 : flag voor dynaface (cylindertest) */
-               /* eve->f1 : flag voor dynaface (sphere test) */
+               /* this one also tests of edges are not in faces: */
+               /* eed->f==0: not in face, f==1: draw it */
+               /* eed->f1 : flag for dynaface (cylindertest, old engine) */
+               /* eve->f1 : flag for dynaface (sphere test, old engine) */
                edge_drawflags();
        
-               /* LET OP: op evl->f de punoflag */
+               /* WATCH IT: in evl->f is punoflag (for vertex normal) */
                vertexnormals( (me->flag & ME_NOPUNOFLIP)==0 );
        
                eed= G.eded.first;
@@ -1305,10 +1249,10 @@ void load_editMesh(void)
                        eed= eed->next;
                }
        
-               /* nieuw Face blok */
+               /* new Face block */
                if(G.totface==0) mface= 0;
                else mface= MEM_callocN(G.totface*sizeof(MFace), "loadeditMesh1");
-               /* nieuw Vertex blok */
+               /* nieuw Vertex block */
                if(G.totvert==0) mvert= 0;
                else mvert= MEM_callocN(G.totvert*sizeof(MVert), "loadeditMesh2");
 
@@ -1327,29 +1271,19 @@ void load_editMesh(void)
                me->totvert= G.totvert;
                me->totface= G.totface;
                
-               /* de vertices, gebruik ->vn als teller */
+               /* the vertices, abuse ->vn as counter */
                eve= G.edve.first;
                a=0;
 
-
-
                while(eve) {
                        VECCOPY(mvert->co, eve->co);
-                       mvert->mat_nr= 255;  /* waarvoor ook al weer, haloos? */
+                       mvert->mat_nr= 255;  /* what was this for, halos? */
                        
-                       /* puno */
+                       /* vertex normal */
                        VECCOPY(nor, eve->no);
                        VecMulf(nor, 32767.0);
                        VECCOPY(mvert->no, nor);
 #ifdef __NLA
-/*                     OLD VERSION */
-/*                     mvert->totweight = eve->totweight;
-                       if (eve->dw){
-                               int     cv;
-                               mvert->dw = BLI_callocN (sizeof(MDeformWeight)*eve->totweight, "deformWeight");
-                               memcpy (mvert->dw, eve->dw, sizeof(MDeformWeight)*eve->totweight);
-                       }
-*/
                        /* NEW VERSION */
                        if (dvert){
                                dvert->totweight=eve->totweight;
@@ -1361,7 +1295,7 @@ void load_editMesh(void)
                        }
 #endif
 
-                       eve->vn= (EditVert *)(long)(a++);  /* teller */
+                       eve->vn= (EditVert *)(long)(a++);  /* counter */
                        
                        mvert->flag= 0;
                        if(eve->f1==1) mvert->flag |= ME_SPHERETEST;
@@ -1381,7 +1315,7 @@ void load_editMesh(void)
                }
 #endif
 
-               /* de vlakken */
+               /* the faces */
                evl= G.edvl.first;
                i = 0;
                while(evl) {
@@ -1410,12 +1344,7 @@ void load_editMesh(void)
                                }
                        }
                        
-                       /* dyna cilinder flag minder kritisch testen: 'dubbel' in vlakken laten zitten. 
-                        * gaat anders fout bij scherpe hoeken (inpspeed voor een wel, ander niet!)
-                        * Mogelijk oplossen door volgorde aan te passen: sphere-cyl-face. Kost te veel?
-                        */
-
-                       /* letop: evl->e1->f==0 is losse edge */ 
+                       /* watch: evl->e1->f==0 means loose edge */ 
                        
                        if(evl->e1->f==1) {
                                mface->edcode |= ME_V1V2; 
@@ -1439,7 +1368,7 @@ void load_editMesh(void)
                                evl->e4->f= 2;
                        }
                        
-                       /* geen index '0' op plek 3 of 4 */
+                       /* no index '0' at location 3 or 4 */
                        if(evl->v4) fix_faceindices(mface, evl, 4);
                        else fix_faceindices(mface, evl, 3);
                        
@@ -1447,7 +1376,7 @@ void load_editMesh(void)
                        evl= evl->next;
                }
                
-               /* losse edges als vlak toevoegen */
+               /* add loose edges as a face */
                eed= G.eded.first;
                while(eed) {
                        if( eed->f==0 ) {
@@ -1464,7 +1393,7 @@ void load_editMesh(void)
                tex_space_mesh(me);
                if(actkey) mesh_to_key(me, actkey);
                
-               /* texmesh: ahv ->tface alles opnieuw maken */
+               /* texmesh: using ->tface remake all */
                if(me->tface && me->totface) {
                        TFace *tfn, *tf;
                        
@@ -1498,7 +1427,7 @@ void load_editMesh(void)
                        /* me->tface= 0; */
                }
                
-               /* mcol: ahv indexnrs opnieuw maken */
+               /* mcol: using index numbers make again */
                if(me->mcol && me->totface) {
                        unsigned int *mcn, *mc;
                        
@@ -1523,14 +1452,14 @@ void load_editMesh(void)
        
        if(actkey) do_spec_key(me->key);
        
-       /* voor zekerheid: ->vn pointers wissen */
+       /* te be sure: clear ->vn pointers */
        eve= G.edve.first;
        while(eve) {
                eve->vn= 0;
                eve= eve->next;
        }
 
-       /* displisten van alle users, ook deze */
+       /* displists of all users, including this one */
        freedisplist(&me->disp);
        freedisplist(&G.obedit->disp);
        
@@ -1589,7 +1518,7 @@ void make_sticky(void)
                                if(me->msticky) MEM_freeN(me->msticky);
                                me->msticky= MEM_mallocN(me->totvert*sizeof(MSticky), "sticky");
                                
-                               /* stukje roteerscene */                
+                               /* like convert to render data */               
                                R.r= G.scene->r;
                                R.r.xsch= (R.r.size*R.r.xsch)/100;
                                R.r.ysch= (R.r.size*R.r.ysch)/100;
@@ -1640,7 +1569,7 @@ void fasterdraw(void)
 
        if(G.obedit) return;
 
-       /* vlaggen resetten */
+       /* reset flags */
        me= G.main->mesh.first;
        while(me) {
                me->flag &= ~ME_ISDONE;
@@ -1678,7 +1607,7 @@ void fasterdraw(void)
                base= base->next;
        }
 
-       /* belangrijk?: vlaggen weer resetten */
+       /* important?: reset flags again */
        me= G.main->mesh.first;
        while(me) {
                me->flag &= ~ME_ISDONE;
@@ -1781,25 +1710,25 @@ void deselectall_mesh(void)     /* toggle */
 }
 
 
-void righthandfaces(int select)        /* maakt vlakken rechtsdraaiend */
+void righthandfaces(int select)        /* makes faces righthand turning */
 {
        EditEdge *eed, *ed1, *ed2, *ed3, *ed4;
        EditVlak *evl, *startvl;
        float maxx, nor[3], cent[3];
        int totsel, found, foundone, direct, turn;
 
-   /* op basis selectconnected om losse objecten te onderscheiden */
-
-       /* tel per edge hoeveel vlakken het heeft */
+   /* based at a select-connected to witness loose objects */
 
-       /* vind het meest linkse, voorste, bovenste vlak */
+       /* count per edge the amount of faces */
 
-       /* zet normaal naar buiten en de eerste richtings vlaggen in de edges */
+       /* find the ultimate left, front, upper face */
 
-       /* loop object af en zet richtingen / richtingsvlaggen: alleen bij edges van 1 of 2 vlakken */
-       /* dit is in feit de select connected */
+       /* put normal to the outside, and set the first direction flags in edges */
 
-       /* indien nog (selected) vlakken niet gedaan: opnieuw vind de meest linkse ... */
+       /* then check the object, and set directions / direction-flags: but only for edges with 1 or 2 faces */
+       /* this is in fact the 'select connected' */
+       
+       /* in case (selected) faces were not done: start over with 'find the ultimate ...' */
 
        waitcursor(1);
 
@@ -1810,7 +1739,7 @@ void righthandfaces(int select)   /* maakt vlakken rechtsdraaiend */
                eed= eed->next;
        }
 
-       /* vlakken en edges tellen */
+       /* count faces and edges */
        totsel= 0;
        evl= G.edvl.first;
        while(evl) {
@@ -1828,7 +1757,7 @@ void righthandfaces(int select)   /* maakt vlakken rechtsdraaiend */
        }
 
        while(totsel>0) {
-               /* van buiten naar binnen */
+               /* from the outside to the inside */
 
                evl= G.edvl.first;
                startvl= 0;
@@ -1847,11 +1776,11 @@ void righthandfaces(int select) /* maakt vlakken rechtsdraaiend */
                        evl= evl->next;
                }
                
-               /* eerste vlak goedzetten: normaal berekenen */
+               /* set first face correct: calc normal */
                CalcNormFloat(startvl->v1->co, startvl->v2->co, startvl->v3->co, nor);
                CalcCent3f(cent, startvl->v1->co, startvl->v2->co, startvl->v3->co);
                
-               /* eerste normaal staat zus of zo */
+               /* first normal is oriented this way or the other */
                if(select) {
                        if(select==2) {
                                if(cent[0]*nor[0]+cent[1]*nor[1]+cent[2]*nor[2] > 0.0) flipvlak(startvl);
@@ -1884,7 +1813,7 @@ void righthandfaces(int select)   /* maakt vlakken rechtsdraaiend */
                startvl->f= 0;
                totsel--;
 
-               /* de normalen testen */
+               /* test normals */
                found= 1;
                direct= 1;
                while(found) {
@@ -1972,18 +1901,18 @@ void righthandfaces(int select) /* maakt vlakken rechtsdraaiend */
 
 static EditVert *findnearestvert(short sel)
 {
-       /* als sel==1 krijgen vertices met flag==1 een nadeel */
+       /* if sel==1 the vertices with flag==1 get a disadvantage */
        EditVert *eve,*act=0;
        static EditVert *acto=0;
        short dist=100,temp,mval[2];
 
        if(G.edve.first==0) return 0;
 
-       /* projektie doen */
+       /* do projection */
        calc_meshverts_ext();   /* drawobject.c */
        
-       /* er wordt geteld van acto->next tot last en van first tot acto */
-       /* bestaat acto ? */
+       /* we count from acto->next to last, and from first to acto */
+       /* does acto exist? */
        eve= G.edve.first;
        while(eve) {
                if(eve==acto) break;
@@ -1993,7 +1922,7 @@ static EditVert *findnearestvert(short sel)
 
        if(acto==0) return 0;
 
-       /* is er een aangegeven vertex? deel 1 */
+       /* is there an indicated vertex? part 1 */
        getmouseco_areawin(mval);
        eve= acto->next;
        while(eve) {
@@ -2008,7 +1937,7 @@ static EditVert *findnearestvert(short sel)
                }
                eve= eve->next;
        }
-       /* is er een aangegeven vertex? deel 2 */
+       /* is there an indicated vertex? part 2 */
        if(dist>3) {
                eve= G.edve.first;
                while(eve) {
@@ -2030,11 +1959,11 @@ static EditVert *findnearestvert(short sel)
        return act;
 }
 
-static void tekenvertices_special(int mode, EditVert *act)
+static void tekenvertices_special(int mode, EditVert *act) /* teken = draw */
 {
-       /* voor speciale gevallen:
-        * mode 0: deselect geselecteerde, teken ze,  behalve act
-        * mode 1: teken alleen act
+       /* for special cases:
+        * mode 0: deselect the selected ones, draw then, except act
+        * mode 1: only draw act
         */
        ScrArea *tempsa, *sa;
        View3D *vd;
@@ -2042,7 +1971,7 @@ static void tekenvertices_special(int mode, EditVert *act)
        float mat[4][4];
        int doit=0;
        
-       /* eerst testen of er wel special vertices zijn */
+       /* first test if there are special vertices */
        
        eve= (EditVert *)G.edve.first;
        while(eve) {
@@ -2073,7 +2002,7 @@ static void tekenvertices_special(int mode, EditVert *act)
        
        glDrawBuffer(GL_FRONT);
 
-       /* alle views aflopen */
+       /* check all views */
        tempsa= curarea;
        sa= G.curscreen->areabase.first;
        while(sa) {
@@ -2187,7 +2116,7 @@ void selectconnected_mesh(void)
                return;
        }
 
-       /* testflaggen wissen */
+       /* clear test flags */
        eve= G.edve.first;
        while(eve) {
                eve->f&= ~2;
@@ -2229,9 +2158,9 @@ void selectconnected_mesh(void)
 
 short extrudeflag(short flag,short type)
 {
-       /* als type=1 worden oude extrudevlakken verwijderd (ivm spin etc) */
-       /* alle verts met (flag & 'flag') extrude */
-       /* van oude wordt flag 'flag' gewist, van nieuwe gezet */
+       /* when type=1 old extrusion faces are removed (for spin etc) */
+       /* all verts with (flag & 'flag'): extrude */
+       /* from old verts, 'flag' is cleared, in new ones it is set */
 
        EditVert *eve, *v1, *v2, *v3, *v4, *nextve;
        EditEdge *eed, *e1, *e2, *e3, *e4, *nexted;
@@ -2240,14 +2169,14 @@ short extrudeflag(short flag,short type)
 
        if(G.obedit==0 || get_mesh(G.obedit)==0) return 0;
 
-       /* de vert flag f1 wissen, hiermee test op losse geselecteerde vert */
+       /* clear vert flag f1, we use this to detext a loose selected vertice */
        eve= G.edve.first;
        while(eve) {
                if(eve->f & flag) eve->f1= 1;
                else eve->f1= 0;
                eve= eve->next;
        }
-       /* de edges tellerflag wissen, als selected op 1 zetten */
+       /* clear edges counter flag, if selected we set it at 1 */
        eed= G.eded.first;
        while(eed) {
                if( (eed->v1->f & flag) && (eed->v2->f & flag) ) {
@@ -2257,13 +2186,12 @@ short extrudeflag(short flag,short type)
                }
                else eed->f= 0;
                
-               eed->f1= 1;             /* aangeven is 'oude' edge (er worden in deze routine nieuwe gemaakt */
+               eed->f1= 1;             /* this indicates it is an 'old' edge (in this routine we make new ones) */
                
                eed= eed->next;
        }
 
-
-       /* in alle vlak sel een dupl.flag zetten en bijhorende edgeflags ophogen */
+       /* we set a flag in all selected faces, and increase the associated edge counters */
 
        evl= G.edvl.first;
        while(evl) {
@@ -2321,27 +2249,26 @@ short extrudeflag(short flag,short type)
        }       
 
 
-       /* de stand van zaken nu:
-               eve->f1==1: losse selected vertex 
+       /* the current state now is:
+               eve->f1==1: loose selected vertex 
 
-               eed->f==0 : edge niet selected, geen extrude
-               eed->f==1 : edge selected, komt niet in vlak voor, extrude
-               eed->f==2 : edge selected, komt 1 keer in vlak voor, extrude
-               eed->f==3 : edge selected, komt in meer vlakken voor, geen extrude
+               eed->f==0 : edge is not selected, no extrude
+               eed->f==1 : edge selected, is not part of a face, extrude
+               eed->f==2 : edge selected, is part of 1 face, extrude
+               eed->f==3 : edge selected, is part of more faces, no extrude
                
-               eed->f1==0: nieuwe edge
-               eed->f1==1: edge selected,  komt in selected vlak voor,  als f==3: remove
-               eed->f1==2: edge selected, komt in NIET selected vlak voor
+               eed->f1==0: new edge
+               eed->f1==1: edge selected, is part of selected face, when eed->f==3: remove
+               eed->f1==2: edge selected, is not part of a selected face
                                        
-                                       
-               evl->f==1 : vlak dupliceren
+               evl->f==1 : duplicate this face
        */
 
-       /* alle geselecteerde vertices kopieeren, */
-       /* de pointer naar nieuwe vert in oude struct schrijven op eve->vn */
+       /* copy all selected vertices, */
+       /* write pointer to new vert in old struct at eve->vn */
        eve= G.edve.last;
        while(eve) {
-               eve->f&= ~128;  /* wissen voor test later op losse verts */
+               eve->f&= ~128;  /* clear, for later test for loose verts */
                if(eve->f & flag) {
                        sel= 1;
                        v1= addvertlist(0);
@@ -2357,13 +2284,13 @@ short extrudeflag(short flag,short type)
 
        if(sel==0) return 0;
 
-       /* alle edges met eed->f==1 of eed->f==2 worden vlakken */
-       /* als deloud==1 worden edges eed->f>2 verwijderd */
+       /* all edges with eed->f==1 or eed->f==2 become faces */
+       /* if deloud==1 then edges with eed->f>2 are removed */
        eed= G.eded.last;
        while(eed) {
                nexted= eed->prev;
                if( eed->f<3) {
-                       eed->v1->f|=128;  /* =geen losse vert! */
+                       eed->v1->f|=128;  /* = no loose vert! */
                        eed->v2->f|=128;
                }
                if( (eed->f==1 || eed->f==2) ) {
@@ -2388,7 +2315,7 @@ short extrudeflag(short flag,short type)
                        eed= nexted;
                }
        }
-       /* de vlakken dupliceren, eventueel oude verwijderen  */
+       /* duplicate faces, if necessart remove old ones  */
        evl= G.edvl.first;
        while(evl) {
                nextvl= evl->next;
@@ -2409,9 +2336,9 @@ short extrudeflag(short flag,short type)
                }
                evl= nextvl;
        }
-       /* alle verts met eve->vn!=0 
-               als eve->f1==1: edge maken
-               als flag!=128 :als deloud==1:  verwijderen
+       /* for all vertices with eve->vn!=0 
+               if eve->f1==1: make edge
+               if flag!=128 : if deloud==1: remove
        */
        eve= G.edve.last;
        while(eve) {
@@ -2432,26 +2359,12 @@ short extrudeflag(short flag,short type)
                eve= nextve;
        }
 
-       /* debug temp: testen op consistente:
-       evl= G.edvl.first;
-       while(evl) {
-               e1= findedgelist(evl->v1, evl->v2);
-               e2= findedgelist(evl->v2, evl->v3);
-               e3= findedgelist(evl->v3, evl->v1);
-               if(e1==0 || e2==0 || e3==0) {
-                       error("edge not in edgelist");
-                       break;
-               } 
-               evl= evl->next;
-       }
-       */
-
        return 1;
 }
 
 void rotateflag(short flag, float *cent, float rotmat[][3])
 {
-       /* alle verts met (flag & 'flag') rotate */
+       /* all verts with (flag & 'flag') rotate */
 
        EditVert *eve;
 
@@ -2472,7 +2385,7 @@ void rotateflag(short flag, float *cent, float rotmat[][3])
 
 void translateflag(short flag, float *vec)
 {
-       /* alle verts met (flag & 'flag') translate */
+       /* all verts with (flag & 'flag') translate */
 
        EditVert *eve;
 
@@ -2487,9 +2400,9 @@ void translateflag(short flag, float *vec)
        }
 }
 
-short removedoublesflag(short flag, float limit)               /* return aantal */
+short removedoublesflag(short flag, float limit)               /* return amount */
 {
-       /* alle verts met (flag & 'flag') worden getest */
+       /* all verts with (flag & 'flag') are being evaluated */
        EditVert *eve, *v1, *nextve;
        EditEdge *eed, *e1, *nexted;
        EditVlak *evl, *nextvl;
@@ -2498,7 +2411,7 @@ short removedoublesflag(short flag, float limit)          /* return aantal */
        float dist;
        int a, b, test, aantal;
 
-       /* flag 128 wordt gewist, aantal tellen */
+       /* flag 128 is cleared, count */
        eve= G.edve.first;
        aantal= 0;
        while(eve) {
@@ -2508,7 +2421,7 @@ short removedoublesflag(short flag, float limit)          /* return aantal */
        }
        if(aantal==0) return 0;
 
-       /* geheugen reserveren en qsorten */
+       /* allocate memory and qsort */
        sb= sortblock= (struct xvertsort *)MEM_mallocN(sizeof(struct xvertsort)*aantal,"sortremovedoub");
        eve= G.edve.first;
        while(eve) {
@@ -2521,18 +2434,18 @@ short removedoublesflag(short flag, float limit)                /* return aantal */
        }
        qsort(sortblock, aantal, sizeof(struct xvertsort), vergxco);
 
-       /* testen op doubles */
+       /* test for doubles */
        sb= sortblock;
        for(a=0; a<aantal; a++) {
                eve= sb->v1;
                if( (eve->f & 128)==0 ) {
                        sb1= sb+1;
                        for(b=a+1; b<aantal; b++) {
-                               /* eerste test: simpel dist */
+                               /* first test: simpel dist */
                                dist= sb1->x - sb->x;
                                if(dist > limit) break;
                                
-                               /* tweede test: is vertex toegestaan */
+                               /* second test: is vertex allowed */
                                v1= sb1->v1;
                                if( (v1->f & 128)==0 ) {
                                        
@@ -2555,7 +2468,7 @@ short removedoublesflag(short flag, float limit)          /* return aantal */
        }
        MEM_freeN(sortblock);
 
-       /* edges testen en opnieuw invoegen */
+       /* test edges and insert again */
        eed= G.eded.first;
        while(eed) {
                eed->f= 0;
@@ -2581,7 +2494,7 @@ short removedoublesflag(short flag, float limit)          /* return aantal */
                eed= nexted;
        }
 
-       /* eerst aantal testvlakken tellen */
+       /* first count amount of test faces */
        evl= (struct EditVlak *)G.edvl.first;
        aantal= 0;
        while(evl) {
@@ -2595,7 +2508,7 @@ short removedoublesflag(short flag, float limit)          /* return aantal */
                evl= evl->next;
        }
 
-       /* vlakken testen op dubbele punten en eventueel verwijderen */
+       /* test faces for double vertices, and if needed remove them */
        evl= (struct EditVlak *)G.edvl.first;
        while(evl) {
                nextvl= evl->next;
@@ -2640,7 +2553,7 @@ short removedoublesflag(short flag, float limit)          /* return aantal */
                        }
                        
                        if(test==0) {
-                               /* edgepointers goedzetten */
+                               /* set edge pointers */
                                evl->e1= findedgelist(evl->v1, evl->v2);
                                evl->e2= findedgelist(evl->v2, evl->v3);
                                if(evl->v4==0) {
@@ -2656,8 +2569,8 @@ short removedoublesflag(short flag, float limit)          /* return aantal */
                evl= nextvl;
        }
 
-       /* dubbele vlakken: sortblock */
-       /* opnieuw tellen, nu alle selected vlakken */
+       /* double faces: sort block */
+       /* count again, now all selected faces */
        aantal= 0;
        evl= G.edvl.first;
        while(evl) {
@@ -2670,7 +2583,7 @@ short removedoublesflag(short flag, float limit)          /* return aantal */
        }
 
        if(aantal) {
-               /* dubbele vlakken: sortblock */
+               /* double faces: sort block */
                vsb= vlsortblock= MEM_mallocN(sizeof(struct vlaksort)*aantal, "sortremovedoub");
                evl= G.edvl.first;
                while(evl) {
@@ -2694,10 +2607,10 @@ short removedoublesflag(short flag, float limit)                /* return aantal */
 
                                for(b=a+1; b<aantal; b++) {
                                
-                                       /* eerste test: zelfde poin? */
+                                       /* first test: same pointer? */
                                        if(vsb->x != vsb1->x) break;
                                        
-                                       /* tweede test: is test toegestaan */
+                                       /* second test: is test permitted? */
                                        evl= vsb1->evl;
                                        if( (evl->f & 128)==0 ) {
                                                if( comparevlak(evl, vsb->evl)) evl->f |= 128;
@@ -2711,7 +2624,7 @@ short removedoublesflag(short flag, float limit)          /* return aantal */
                
                MEM_freeN(vlsortblock);
                
-               /* dubbele vlakken eruit */
+               /* remove double faces */
                evl= (struct EditVlak *)G.edvl.first;
                while(evl) {
                        nextvl= evl->next;
@@ -2723,7 +2636,7 @@ short removedoublesflag(short flag, float limit)          /* return aantal */
                }
        }
        
-       /* dubbele vertices eruit */
+       /* remove double vertices */
        a= 0;
        eve= (struct EditVert *)G.edve.first;
        while(eve) {
@@ -2739,19 +2652,18 @@ short removedoublesflag(short flag, float limit)                /* return aantal */
                }
                eve= nextve;
        }
-       return a;       /* aantal */
+       return a;       /* amount */
 }
 
 void xsortvert_flag(int flag)
-//short flag;
 {
-       /* alle verts met (flag & 'flag') worden gesorteerd */
+       /* all verts with (flag & 'flag') are sorted */
        EditVert *eve;
        struct xvertsort *sortblock, *sb;
        ListBase tbase;
        int aantal;
        
-       /* aantal tellen */
+       /* count */
        eve= G.edve.first;
        aantal= 0;
        while(eve) {
@@ -2760,7 +2672,7 @@ void xsortvert_flag(int flag)
        }
        if(aantal==0) return;
 
-       /* geheugen reserveren en qsorten */
+       /* allocate memory and sort */
        sb= sortblock= (struct xvertsort *)MEM_mallocN(sizeof(struct xvertsort)*aantal,"sortremovedoub");
        eve= G.edve.first;
        while(eve) {
@@ -2773,7 +2685,7 @@ void xsortvert_flag(int flag)
        }
        qsort(sortblock, aantal, sizeof(struct xvertsort), vergxco);
        
-       /* tijdelijke listbase maken */
+       /* make temporal listbase */
        tbase.first= tbase.last= 0;
        sb= sortblock;
        while(aantal--) {
@@ -2791,12 +2703,13 @@ void xsortvert_flag(int flag)
 
 void hashvert_flag(int flag)
 {
+       /* switch vertex order using hash table */
        EditVert *eve;
        struct xvertsort *sortblock, *sb, onth, *newsort;
        ListBase tbase;
        int aantal, a, b;
        
-       /* aantal tellen */
+       /* count */
        eve= G.edve.first;
        aantal= 0;
        while(eve) {
@@ -2805,7 +2718,7 @@ void hashvert_flag(int flag)
        }
        if(aantal==0) return;
 
-       /* geheugen reserveren */
+       /* allocate memory */
        sb= sortblock= (struct xvertsort *)MEM_mallocN(sizeof(struct xvertsort)*aantal,"sortremovedoub");
        eve= G.edve.first;
        while(eve) {
@@ -2829,7 +2742,7 @@ void hashvert_flag(int flag)
                }
        }
 
-       /* tijdelijke listbase maken */
+       /* make temporal listbase */
        tbase.first= tbase.last= 0;
        sb= sortblock;
        while(aantal--) {
@@ -2877,7 +2790,7 @@ static void uv_quart(float *uv, float *uv1)
 
 static void set_wuv(int tot, EditVlak *evl, int v1, int v2, int v3, int v4)
 {
-       /* deze vreemde fie alleen bij de subdiv te gebruiken, de 'w' in de naam slaat nergens op! */
+       /* this weird function only to be used for subdivide, the 'w' in the name has no meaning! */
        float *uv, uvo[4][2];
        unsigned int *col, colo[4], col1, col2;
        int a, v;
@@ -3054,8 +2967,9 @@ static void smooth_subdiv_quad(EditVlak *evl, float *vec)
 
 void subdivideflag(int flag, float rad, int beauty)
 {
-       /* divide alle vlakken met (vertflag & flag) */
-       /* als rad>0.0 zet dan nieuw vert op afstand rad van 0,0,0 */
+       /* subdivide all with (vertflag & flag) */
+       /* if rad>0.0 it's a 'sphere' subdivide */
+       /* if rad<0.0 it's a fractal subdivide */
        extern float doublimit;
        EditVert *eve;
        EditEdge *eed, *e1, *e2, *e3, *e4, *nexted;
@@ -3081,14 +2995,14 @@ void subdivideflag(int flag, float rad, int beauty)
                eed= eed->next;
        }
        
-       /* als beauty: opp testen en edgeflags wissen van 'lelijke' edges */
+       /* if beauty: test for area and clear edge flags of 'ugly' edges */
        if(beauty & B_BEAUTY) {
                evl= G.edvl.first;
                while(evl) {
                        if( vlakselectedAND(evl, flag) ) {
                                if(evl->v4) {
                                
-                                       /* opp */
+                                       /* area */
                                        len1= AreaQ3Dfl(evl->v1->co, evl->v2->co, evl->v3->co, evl->v4->co);
                                        if(len1 <= doublimit) {
                                                evl->e1->f = 0;
@@ -3112,7 +3026,7 @@ void subdivideflag(int flag, float rad, int beauty)
                                }
                                else {
 
-                                       /* opp */
+                                       /* area */
                                        len1= AreaT3Dfl(evl->v1->co, evl->v2->co, evl->v3->co);
                                        if(len1 <= doublimit) {
                                                evl->e1->f = 0;
@@ -3147,7 +3061,7 @@ void subdivideflag(int flag, float rad, int beauty)
                        
        }
        
-       /* nieuw punt maken en in edge wegschrijven, flag wissen! is voor vlakkenmaak stuk nodig */
+       /* make new normal and put in edge, clear flag! needed for face creation part below */
        eed= G.eded.first;
        while(eed) {
                if(eed->f & flag) {
@@ -3156,13 +3070,13 @@ void subdivideflag(int flag, float rad, int beauty)
                        vec[1]= (eed->v1->co[1]+eed->v2->co[1])/2.0;
                        vec[2]= (eed->v1->co[2]+eed->v2->co[2])/2.0;
 
-                       if(rad > 0.0) {   /* perf sph */
+                       if(rad > 0.0) {   /* subdivide sphere */
                                Normalise(vec);
                                vec[0]*= rad;
                                vec[1]*= rad;
                                vec[2]*= rad;
                        }
-                       else if(rad< 0.0) {  /* fract */
+                       else if(rad< 0.0) {  /* fractal subdivide */
                                fac= rad* VecLenf(eed->v1->co, eed->v2->co);
                                vec1[0]= fac*BLI_drand();
                                vec1[1]= fac*BLI_drand();
@@ -3181,12 +3095,12 @@ void subdivideflag(int flag, float rad, int beauty)
                }
                else eed->vn= 0;
                
-               eed->f= 0; /* moet! */
+               eed->f= 0; /* needed! */
                
                eed= eed->next;
        }
 
-       /* alle vlakken testen op subdiv edges, 8 of 16 gevallen! */
+       /* test all faces for subdivide edges, there are 8 or 16 cases (ugh)! */
 
        evl= G.edvl.last;
        while(evl) {
@@ -3220,7 +3134,7 @@ void subdivideflag(int flag, float rad, int beauty)
                                        if((test & 6)==6) addvlak_subdiv(evl, 3, 3+4, 2+4, 0, 0);
                                        if((test & 5)==5) addvlak_subdiv(evl, 1, 1+4, 3+4, 0, 0);
 
-                                       if(test==7) {  /* vier nieuwe vlakken, oude vernieuwt */
+                                       if(test==7) {  /* four new faces, old face renews */
                                                evl->v1= e1->vn;
                                                evl->v2= e2->vn;
                                                evl->v3= e3->vn;
@@ -3263,7 +3177,7 @@ void subdivideflag(int flag, float rad, int beauty)
                                }
                                else {
                                        if(test==15) {
-                                               /* nog een nieuw punt toevoegen */
+                                               /* add a new point */
                                                CalcCent4f(vec, evl->v1->co, evl->v2->co, evl->v3->co, evl->v4->co);
                                                
                                                if(beauty & B_SMOOTH) {
@@ -3283,7 +3197,6 @@ void subdivideflag(int flag, float rad, int beauty)
                                                set_wuv(4, evl, 1, 1+4, 9, 4+4);
                                        }
                                        else {
-                                               /* kleine hoekpunten */
                                                if((test & 3)==3) addvlak_subdiv(evl, 1+4, 2, 2+4, 0, 0);
                                                if((test & 6)==6) addvlak_subdiv(evl, 2+4, 3, 3+4, 0, 0);
                                                if((test & 12)==12) addvlak_subdiv(evl, 3+4, 4, 4+4, 0, 0);
@@ -3405,12 +3318,12 @@ void subdivideflag(int flag, float rad, int beauty)
                evl= evl->prev;
        }
 
-       /* alle oude edges verwijderen, eventueel nog nieuwe maken */
+       /* remove all old edges, if needed make new ones */
        eed= G.eded.first;
        while(eed) {
                nexted= eed->next;
                if( eed->vn ) {
-                       if(eed->f==0) {  /* niet gebruikt in vlak */
+                       if(eed->f==0) {  /* not used in face */
                                addedgelist(eed->v1,eed->vn);
                                addedgelist(eed->vn,eed->v2);
                        }
@@ -3426,13 +3339,13 @@ void subdivideflag(int flag, float rad, int beauty)
 
 void adduplicateflag(int flag)
 {
-       /* oude verts hebben flag 128 gezet en flag 'flag' gewist
-          nieuwe verts hebben flag 'flag' gezet */
+       /* old verts have flag 128 set, and flag 'flag' cleared
+          new verts have flag 'flag' set */
        EditVert *eve, *v1, *v2, *v3, *v4;
        EditEdge *eed;
        EditVlak *evl;
 
-       /* eerst vertices */
+       /* vertices first */
        eve= G.edve.last;
        while(eve) {
                eve->f&= ~128;
@@ -3465,7 +3378,7 @@ void adduplicateflag(int flag)
                eed= eed->next;
        }
 
-       /* tenslotte de vlakken dupliceren */
+       /* then dupicate faces */
        evl= G.edvl.first;
        while(evl) {
                if( (evl->v1->f & 128) && (evl->v2->f & 128) && (evl->v3->f & 128) ) {
@@ -3491,8 +3404,8 @@ void adduplicateflag(int flag)
 
 static void delvlakflag(int flag)
 {
-       /* alle vlak 3/4 verts flag + edges + losse vertices deleten */
-       /* van alle verts wordt 'flag' gewist */
+       /* delete all faces with 'flag', including edges and loose vertices */
+       /* in vertices the 'flag' is cleared */
        EditVert *eve,*nextve;
        EditEdge *eed, *nexted;
        EditVlak *evl,*nextvl;
@@ -3520,7 +3433,7 @@ static void delvlakflag(int flag)
                }
                evl= nextvl;
        }
-       /* alle vlakken 1, 2 (3) verts select edges behouden */
+       /* all faces with 1, 2 (3) vertices selected: make sure we keep the edges */
        evl= G.edvl.first;
        while(evl) {
                evl->e1->f= 0;
@@ -3533,7 +3446,7 @@ static void delvlakflag(int flag)
                evl= evl->next;
        }
        
-       /* alle edges testen op vertices met flag en wissen */
+       /* test all edges for vertices with 'flag', and clear */
        eed= G.eded.first;
        while(eed) {
                nexted= eed->next;
@@ -3547,7 +3460,7 @@ static void delvlakflag(int flag)
                }
                eed= nexted;
        }
-       /* vertices met flag nog gezet zijn losse en worden verwijderd */
+       /* vertices with 'flag' now are the loose ones, and will be removed */
        eve= G.edve.first;
        while(eve) {
                nextve= eve->next;
@@ -3577,7 +3490,7 @@ void extrude_mesh(void)
                error("Can't extrude");
        }
        else {
-               countall();  /* voor G.totvert in calc_meshverts() */
+               countall();  /* for G.totvert in calc_meshverts() */
                calc_meshverts();
                transform('d');
        }
@@ -3593,7 +3506,7 @@ void adduplicate_mesh(void)
        adduplicateflag(1);
        waitcursor(0);
 
-       countall();  /* voor G.totvert in calc_meshverts() */
+       countall();  /* for G.totvert in calc_meshverts() */
        transform('d');
 }
 
@@ -3606,9 +3519,9 @@ void split_mesh(void)
 
        waitcursor(1);
 
-       /* eerst duplicate maken */
+       /* make duplicate first */
        adduplicateflag(1);
-       /* oude vlakken hebben 3x flag 128 gezet, deze deleten */
+       /* old faces have 3x flag 128 set, delete them */
        delvlakflag(128);
 
        waitcursor(0);
@@ -3642,15 +3555,15 @@ void separate_mesh(void)
                return;
        }
        
-       /* we gaan de zaak als volgt neppen:
-        * 1. duplicate object: dit wordt de nieuwe,  oude pointer onthouden
-        * 2: split doen als modig.
-        * 3. alle NIET geselecteerde verts, edges, vlakken apart zetten
-        * 4. loadobeditdata(): dit is de nieuwe ob
+       /* we are going to abuse the system as follows:
+        * 1. add a duplicate object: this will be the new one, we remember old pointer
+        * 2: then do a split if needed.
+        * 3. put apart: all NOT selected verts, edges, faces
+        * 4. call loadobeditdata(): this will be the new object
         * 5. freelist en oude verts, eds, vlakken weer terughalen
         */
        
-       /* alleen obedit geselecteerd */
+       /* make only obedit selected */
        base= FIRSTBASE;
        while(base) {
                if(base->lay & G.vd->lay) {
@@ -3660,7 +3573,7 @@ void separate_mesh(void)
                base= base->next;
        }
        
-       /* testen of split */
+       /* testen for split */
        ok= 0;
        eed= G.eded.first;
        while(eed) {
@@ -3672,13 +3585,13 @@ void separate_mesh(void)
                eed= eed->next;
        }
        if(ok) {
-               /* SPLIT: eerst duplicate maken */
+               /* SPLIT: first make duplicate */
                adduplicateflag(1);
-               /* SPLIT: oude vlakken hebben 3x flag 128 gezet, deze deleten */
+               /* SPLIT: old faces have 3x flag 128 set, delete these ones */
                delvlakflag(128);
        }
        
-       /* apart zetten: alles wat maar enigszins NIET select is */
+       /* set apart: everything that is not selected */
        edve.first= edve.last= eded.first= eded.last= edvl.first= edvl.last= 0;
        eve= G.edve.first;
        while(eve) {
@@ -3713,15 +3626,15 @@ void separate_mesh(void)
        
        trans[0]=trans[1]=trans[2]=trans[3]=trans[4]=trans[5]= 0.0;
        trans[6]=trans[7]=trans[8]= 1.0;
-       G.qual |= LR_ALTKEY;    /* patch om zeker te zijn van gelinkte dupli */
+       G.qual |= LR_ALTKEY;    /* patch to make sure we get a linked duplicate */
        adduplicate(trans);
        G.qual &= ~LR_ALTKEY;
        
-       G.obedit= BASACT->object;       /* basact wordt in adduplicate() gezet */
+       G.obedit= BASACT->object;       /* basact was set in adduplicate()  */
 
        men= copy_mesh(me);
        set_mesh(G.obedit, men);
-       /* omdat nieuwe mesh een kopie is: aantal users verlagen */
+       /* because new mesh is a copy: reduce user count */
        men->id.us--;
        
        load_editMesh();
@@ -3758,7 +3671,6 @@ void separate_mesh(void)
 void extrude_repeat_mesh(int steps, float offs)
 {
        float dvec[3], tmat[3][3], bmat[3][3];
-/*     float phi; */
        short a,ok;
 
        TEST_EDITMESH
@@ -3773,10 +3685,8 @@ void extrude_repeat_mesh(int steps, float offs)
        dvec[1]*= offs;
        dvec[2]*= offs;
 
-       /* base correctie */
+       /* base correction */
        Mat3CpyMat4(bmat, G.obedit->obmat);
-       /* phi= ((struct ObData *)G.obedit->d)->vv->ws; */
-       /* Mat3MulFloat(bmat, phi); */
        Mat3Inv(tmat, bmat);
        Mat3MulVecfl(tmat, dvec);
 
@@ -3807,7 +3717,7 @@ void spin_mesh(int steps,int degr,float *dvec, int mode)
        
        waitcursor(1);
 
-       /* imat en centrum en afmeting */
+       /* imat and centre and size */
        Mat3CpyMat4(bmat, G.obedit->obmat);
        Mat3Inv(imat,bmat);
 
@@ -3861,7 +3771,7 @@ void spin_mesh(int steps,int degr,float *dvec, int mode)
 
        waitcursor(0);
        if(ok==0) {
-               /* geen of alleen losse verts select, dups verwijderen */
+               /* no vertices or only loose ones selected, remove duplicates */
                eve= G.edve.first;
                while(eve) {
                        nextve= eve->next;
@@ -3887,31 +3797,31 @@ void screw_mesh(int steps,int turns)
 
        TEST_EDITMESH
 
-       /* eerste voorwaarde: frontview! */
+       /* first condition: we need frontview! */
        if(G.vd->view!=1) {
                error("Only in frontview!");
                return;
        }
 
-       /* flags wissen */
+       /* clear flags */
        eve= G.edve.first;
        while(eve) {
                eve->f1= 0;
                eve= eve->next;
        }
-       /* edges zetten flags in verts */
+       /* edges set flags in verts */
        eed= G.eded.first;
        while(eed) {
                if(eed->v1->f & 1) {
                        if(eed->v2->f & 1) {
-                               /* oppassen f1 is een byte */
+                               /* watch: f1 is a byte */
                                if(eed->v1->f1<2) eed->v1->f1++;
                                if(eed->v2->f1<2) eed->v2->f1++;
                        }
                }
                eed= eed->next;
        }
-       /* vind twee vertices met eve->f1==1, meer of minder is fout */
+       /* find two vertices with eve->f1==1, more or less is wrong */
        eve= G.edve.first;
        while(eve) {
                if(eve->f1==1) {
@@ -3929,7 +3839,7 @@ void screw_mesh(int steps,int turns)
                return;
        }
 
-       /* bereken dvec */
+       /* calculate dvec */
        dvec[0]= ( (v1->co[0]- v2->co[0]) )/(steps);
        dvec[1]= ( (v1->co[1]- v2->co[1]) )/(steps);
        dvec[2]= ( (v1->co[2]- v2->co[2]) )/(steps);
@@ -3980,7 +3890,7 @@ void addvert_mesh(void)
                if(v1->f & 1) break;
                v1= v1->next;
        }
-       eve= v1;        /* voorkomen dat er nog meer select zijn */
+       eve= v1;        /* prevent there are more selected */
        while(eve) {
                eve->f&= ~1;
                eve= eve->next;
@@ -4018,7 +3928,7 @@ void addedgevlak_mesh(void)
 
        if( (G.vd->lay & G.obedit->lay)==0 ) return;
 
-       /* hoeveel geselecteerd ? */
+       /* how many selected ? */
        eve= G.edve.first;
        while(eve) {
                if(eve->f & 1) {
@@ -4213,7 +4123,7 @@ void delete_mesh(void)
                        }
                        evl= nextvl;
                }
-               /* om losse vertices te wissen: */
+               /* to remove loose vertices: */
                eed= G.eded.first;
                while(eed) {
                        if( eed->v1->f & 1) eed->v1->f-=1;
@@ -4278,7 +4188,7 @@ void add_primitiveMesh(int type)
        G.f &= ~(G_VERTEXPAINT+G_FACESELECT+G_TEXTUREPAINT);
        setcursor_space(SPACE_VIEW3D, CURSOR_STD);
 
-       /* als geen obedit: nieuw object en in editmode gaan */
+       /* if no obedit: new object and enter editmode */
        if(G.obedit==0) {
                /* add_object actually returns an object ! :-)
                But it also stores the added object struct in
@@ -4303,9 +4213,9 @@ void add_primitiveMesh(int type)
                eve= eve->next;
        }
 
-       totoud= tot; /* onthouden en terugzetten als cube/plane */
+       totoud= tot; /* store, and restore when cube/plane */
        
-       /* imat en centrum en afmeting */
+       /* imat and centre and size */
        Mat3CpyMat4(mat, G.obedit->obmat);
 
        curs= give_cursor();
@@ -4323,7 +4233,7 @@ void add_primitiveMesh(int type)
                Mat3Inv(imat, mat);
        }
        
-       /* ext==extrudeflag, tot==aantal verts in basis */
+       /* ext==extrudeflag, tot==amount of vertices in basis */
 
        switch(type) {
        case 0:         /* plane */
@@ -4397,10 +4307,10 @@ void add_primitiveMesh(int type)
        phi= .25*M_PI;
 
 
-       if(type<10) {   /* alles behalve grid of sphere */
+       if(type<10) {   /* all types except grid, sphere... */
                if(ext==0 && type!=7) d= 0;
        
-               /* de vertices */
+               /* vertices */
                vtop= vdown= v1= v2= 0;
                for(b=0; b<=ext; b++) {
                        for(a=0; a<tot; a++) {
@@ -4420,7 +4330,7 @@ void add_primitiveMesh(int type)
                        }
                        d= -d;
                }
-               /* centrum vertices */
+               /* centre vertices */
                if(fill && type>1) {
                        VECCOPY(vec,cent);
                        vec[2]-= -d;
@@ -4439,7 +4349,7 @@ void add_primitiveMesh(int type)
                if(vtop) vtop->f= 1;
                if(vdown) vdown->f= 1;
        
-               /* boven en ondervlak */
+               /* top and bottom face */
                if(fill) {
                        if(tot==4 && (type==0 || type==1)) {
                                v3= v1->next->next;
@@ -4466,7 +4376,7 @@ void add_primitiveMesh(int type)
                                }
                        }
                }
-               else if(type==4) {  /* wel edges bij circle */
+               else if(type==4) {  /* we need edges for a circle */
                        v3= v1;
                        for(a=1;a<tot;a++) {
                                addedgelist(v3,v3->next);
@@ -4474,7 +4384,7 @@ void add_primitiveMesh(int type)
                        }
                        addedgelist(v3,v1);
                }
-               /* zijvlakken */
+               /* side faces */
                if(ext) {
                        v3= v1;
                        v4= v2;
@@ -4498,14 +4408,14 @@ void add_primitiveMesh(int type)
                
        }
        else if(type==10) {     /*  grid */
-               /* alle flags wissen */
+               /* clear flags */
                eve= G.edve.first;
                while(eve) {
                        eve->f= 0;
                        eve= eve->next;
                }
                dia= G.vd->grid;
-               /* eerst een segment: de X as */
+               /* one segment first: de X as */
                phi= -1.0; 
                phid= 2.0/((float)tot-1);
                for(a=0;a<tot;a++) {
@@ -4518,7 +4428,7 @@ void add_primitiveMesh(int type)
                        if (a) addedgelist(eve->prev,eve);
                        phi+=phid;
                }
-               /* extruden en transleren */
+               /* extrude and translate */
                vec[0]= vec[2]= 0.0;
                vec[1]= dia*phid;
                Mat3MulVecfl(imat, vec);
@@ -4530,14 +4440,14 @@ void add_primitiveMesh(int type)
        else if(type==11) {     /*  UVsphere */
                float tmat[3][3];
                
-               /* alle flags wissen */
+               /* clear all flags */
                eve= G.edve.first;
                while(eve) {
                        eve->f= 0;
                        eve= eve->next;
                }
                
-               /* eerst een segment */
+               /* one segment first */
                phi= 0; 
                phid/=2;
                for(a=0; a<=tot; a++) {
@@ -4552,7 +4462,7 @@ void add_primitiveMesh(int type)
                        phi+= phid;
                }
                
-               /* extruden en roteren */
+               /* extrude and rotate */
                phi= M_PI/seg;
                q[0]= cos(phi);
                q[3]= sin(phi);
@@ -4570,7 +4480,7 @@ void add_primitiveMesh(int type)
        else if(type==12) {     /* Icosphere */
                EditVert *eva[12];
 
-               /* alle flags wissen */
+               /* clear all flags */
                eve= G.edve.first;
                while(eve) {
                        eve->f= 0;
@@ -4593,7 +4503,7 @@ void add_primitiveMesh(int type)
 
                dia*=200;
                for(a=1; a<subdiv; a++) subdivideflag(2, dia, 0);
-               /* nu pas met imat */
+               /* and now do imat */
                eve= G.edve.first;
                while(eve) {
                        if(eve->f & 2) {
@@ -4628,7 +4538,7 @@ void add_primitiveMesh(int type)
        allqueue(REDRAWVIEW3D, 0);
        allqueue(REDRAWIPO, 0);
        allqueue(REDRAWHEADERS, 0);
-       allqueue(REDRAWINFO, 1);        /* 1, want header->win==0! */   
+       allqueue(REDRAWINFO, 1);        /* 1, because header->win==0! */        
        allqueue(REDRAWBUTSEDIT, 0);
        makeDispList(G.obedit);
 
@@ -4645,7 +4555,7 @@ void vertexsmooth(void)
 
        if(G.obedit==0) return;
 
-       /* aantal tellen */
+       /* count */
        eve= G.edve.first;
        while(eve) {
                if(eve->f & 1) teller++;
@@ -4940,45 +4850,8 @@ if(evl1->v1== *v2) {
 }
 
 
-/* ook weer twee zeer vreemde 'patch' functies om de uv van tfaces te bewaren */
-/*
-static float *set_correct_uv(EditVert *eve,  EditVlak **evla)
-{
-       
-       if(eve== evla[1]->v3) return evla[1]->uv[2];
-       if(eve== evla[0]->v3) return evla[0]->uv[2];
-       if(eve== evla[1]->v2) return evla[1]->uv[1];
-       if(eve== evla[0]->v2) return evla[0]->uv[1];
-       if(eve== evla[1]->v1) return evla[1]->uv[0];
-       if(eve== evla[0]->v1) return evla[0]->uv[0];
-       return 0;
-}
-
-crazy code commented out..
-static void restore_wuv(EditVlak *evl, void **evla)
-{
-       int *lp;
-       
-       lp= (int *)set_correct_uv(evl->v1, (EditVlak **)evla);
-       ((int *)(evl->uv[0]))[0]= lp[0];
-       ((int *)(evl->uv[0]))[4]= lp[4];
-       
-       lp= (int *)set_correct_uv(evl->v2, (EditVlak **)evla);
-       ((int *)(evl->uv[1]))[0]= lp[0];
-       ((int *)(evl->uv[1]))[4]= lp[4];
-
-       lp= (int *)set_correct_uv(evl->v3, (EditVlak **)evla);
-       ((int *)(evl->uv[2]))[0]= lp[0];
-       ((int *)(evl->uv[2]))[4]= lp[4];
-       
-}
-*/
-
 
 /* Helper functions for edge/quad edit features*/
-/*
-
-*/
 
 static void untag_edges(EditVlak *f)
 {
@@ -5206,11 +5079,11 @@ void edge_flip(void)
 
        int totedge, ok;
        
-       /* - alle geselecteerde edges met 2 vlakken
-        * - vind die vlakken: opslaan in edges (extra datablok)
+       /* - all selected edges with two faces
+        * - find the faces: store them in edges (using datablock)
         * - per edge: - test convex
         *                         - test edge: flip?
-                                               - zoja: remedge,  addedge, alle randedges nieuwe vlakpointers
+                                               - if true: remedge,  addedge, all edges at the edge get new face pointers
         */
 
        totedge = count_edges(G.eded.first);
@@ -5311,19 +5184,19 @@ void beauty_fill(void)
     float len1, len2, len3, len4, len5, len6, opp1, opp2, fac1, fac2;
     int totedge, ok, notbeauty=8, onedone;
 
-    /* - alle geselecteerde edges met 2 vlakken
-     * - vind die vlakken: opslaan in edges (extra datablok)
-     * - per edge: - test convex
-     *             - test edge: flip?
-                        - zoja: remedge,  addedge, alle randedges nieuwe vlakpointers
-     */
-
+       /* - all selected edges with two faces
+               * - find the faces: store them in edges (using datablock)
+               * - per edge: - test convex
+               *                          - test edge: flip?
+               *               - if true: remedge,  addedge, all edges at the edge get new face pointers
+               */
+       
     totedge = count_edges(G.eded.first);
     if(totedge==0) return;
 
     if(okee("Beauty Fill")==0) return;
 
-    /* tempblok met vlakpointers */
+    /* temp block with face pointers */
     evlar= (EVPTuple *) MEM_callocN(totedge * sizeof(EVPTuple), "beautyfill");
 
     while (notbeauty) {
@@ -5331,7 +5204,7 @@ void beauty_fill(void)
 
         ok = collect_quadedges(evlar, G.eded.first, G.edvl.first);
 
-        /* gaatie */
+        /* there we go */
         onedone= 0;
 
         eed= G.eded.first;
@@ -5342,7 +5215,7 @@ void beauty_fill(void)
 
                 evla = (EVPtr *) eed->vn;
 
-                /* geen van de vlakken mag al gedaan zijn */
+                /* none of the faces should be treated before */
                 ok= 1;
                 evl= evla[0];
                 if(evl->e1->f1 || evl->e2->f1 || evl->e3->f1) ok= 0;
@@ -5373,9 +5246,8 @@ void beauty_fill(void)
                             dia2.v2= v4;
                         }
 
-                        /* testregel:
-                         * de oppervlakte gedeeld door de totale edgelengte
-                         *
+                        /* testing rule:
+                         * the area divided by the total edge lengths
                          */
 
                         len1= VecLenf(v1->co, v2->co);
@@ -5508,7 +5380,7 @@ void join_mesh(void)
        ob= OBACT;
        if(!ob || ob->type!=OB_MESH) return;
        
-       /* tellen */
+       /* count */
        
        base= FIRSTBASE;
        while(base) {
@@ -5524,22 +5396,22 @@ void join_mesh(void)
                base= base->next;
        }
        
-       /* zodoende is het aktieve object altijd select */ 
+       /* that way the active object is always selected */ 
        if(ok==0) return;
        
        if(totvert==0 || totvert>65000) return;
        
        if(okee("Join selected Meshes")==0) return;
        
-       /* nieuwe materiaal indexen en hoofdarray */
+       /* new material indices and material array */
        matar= MEM_callocN(sizeof(void *)*MAXMAT, "join_mesh");
        totcol= ob->totcol;
        
-       /* obact materials in nieuw hoofdarray, is mooiere start! */
+       /* obact materials in new main array, is nicer start! */
        for(a=1; a<=ob->totcol; a++) {
                matar[a-1]= give_current_material(ob, a);
                id_us_plus((ID *)matar[a-1]);
-               /* id->us ophogen: wordt ook verlaagd */
+               /* increase id->us : will be lowered later */
        }
        
        base= FIRSTBASE;
@@ -5612,7 +5484,7 @@ void join_mesh(void)
 
        vertofs= 0;
        
-       /* alle geselecteerde meshes invers transformen in obact */
+       /* inverse transorm all selected meshes in this object */
        Mat4Invert(imat, ob->obmat);
        
        base= FIRSTBASE;
@@ -5630,24 +5502,6 @@ void join_mesh(void)
 #ifdef __NLA
                                        copy_dverts(dvert, me->dvert, me->totvert);
 
-                                               /* >>>>> FIXME: Ensure that deformation groups are updated correctly */
-                                       /* OLD VERSION */
-                                       /*
-                                       for (i=0; i<me->totvert; i++){
-                                               for (j=0; j<mvert[i].totweight; j++){
-                                                       //      Find the old vertex group
-                                                       odg = BLI_findlink (&base->object->defbase, mvert[i].dw[j].def_nr);
-
-                                                       //      Search for a match in the new object
-                                                       for (dg=ob->defbase.first, index=0; dg; dg=dg->next, index++){
-                                                               if (!strcmp(dg->name, odg->name)){
-                                                                       mvert[i].dw[j].def_nr = index;
-                                                                       break;
-                                                               }
-                                                       }
-                                               }
-                                       }
-                                       */
                                        /* NEW VERSION */
                                        if (dvertmain){
                                                for (i=0; i<me->totvert; i++){
@@ -5669,7 +5523,7 @@ void join_mesh(void)
 
 #endif
                                        if(base->object != ob) {
-                                               /* let op: matmul omkeren is ECHT fout */
+                                               /* watch this: switch matmul order really goes wrong */
                                                Mat4MulMat4(cmat, base->object->obmat, imat);
                                                
                                                a= me->totvert;
@@ -5687,7 +5541,7 @@ void join_mesh(void)
                                }
                                if(me->totface) {
                                
-                                       /* mapping maken voor materialen */
+                                       /* make mapping for materials */
                                        memset(map, 0, 4*MAXMAT);
                                        for(a=1; a<=base->object->totcol; a++) {
                                                ma= give_current_material(base->object, a);
@@ -5748,7 +5602,7 @@ void join_mesh(void)
        me->totvert= totvert;
        me->totface= totface;
        
-       /* oude material array */
+       /* old material array */
        for(a=1; a<=ob->totcol; a++) {
                ma= ob->mat[a-1];
                if(ma) ma->id.us--;
@@ -5770,7 +5624,7 @@ void join_mesh(void)
        ob->totcol= me->totcol= totcol;
        ob->colbits= 0;
        
-       /* andere mesh gebruikers */
+       /* other mesh users */
        test_object_materials((ID *)me);
        
        enter_editmode();
@@ -5800,8 +5654,6 @@ void clever_numbuts_mesh(void)
        do_clever_numbuts("Active Vertex", 3, REDRAW);
 }
 
-/* never used, see CVS */
-/*  static void insert_radiogour(char *str) */
 
 static void permutate(void *list, int num, int size, int *index)
 {
@@ -5901,7 +5753,7 @@ void vertices_to_sphere(void)
        Mat3CpyMat4(bmat, ob->obmat);
        Mat3Inv(imat, bmat);
 
-       /* centrum */
+       /* centre */
        curs= give_cursor();
        cent[0]= curs[0]-ob->obmat[3][0];
        cent[1]= curs[1]-ob->obmat[3][1];
@@ -5956,7 +5808,7 @@ void fill_mesh(void)
 
        waitcursor(1);
 
-       /* alle selected vertices kopieeren */
+       /* copy all selected vertices */
        eve= G.edve.first;
        while(eve) {
                if(eve->f & 1) {
@@ -5967,7 +5819,7 @@ void fill_mesh(void)
                }
                eve= eve->next;
        }
-       /* alle selected edges kopieeren */
+       /* copy all selected edges */
        eed= G.eded.first;
        while(eed) {
                if( (eed->v1->f & 1) && (eed->v2->f & 1) ) {
@@ -5977,9 +5829,9 @@ void fill_mesh(void)
                }
                eed= eed->next;
        }
-       /* van alle selected vlakken vertices en edges verwijderen om dubbels te voorkomen */
-       /* alle edges tellen punten op, vlakken trekken af,
-          edges met vertices ->h<2 verwijderen */
+       /* from all selected faces: remove vertices and edges verwijderen to prevent doubles */
+       /* all edges add values, faces subtract,
+          then remove edges with vertices ->h<2 */
        evl= G.edvl.first;
        ok= 0;
        while(evl) {
@@ -5994,7 +5846,7 @@ void fill_mesh(void)
                }
                evl= nextvl;
        }
-       if(ok) {        /* er zijn vlakken geselecteerd */
+       if(ok) {        /* there are faces selected */
                eed= filledgebase.first;
                while(eed) {
                        nexted= eed->next;
@@ -6005,8 +5857,6 @@ void fill_mesh(void)
                }
        }
 
-       /* tijd=clock(); */
-       
        /* to make edgefill work */
        BLI_setScanFillObjectRef(G.obedit);
        BLI_setScanFillColourRef(&G.obedit->actcol);
@@ -6057,10 +5907,10 @@ void vertexnormals_mesh(Mesh *me, float *extverts)
        if(me->totvert==0) return;
 
        testflip= (me->flag & ME_NOPUNOFLIP)==0;
-       if((me->flag & ME_TWOSIDED)==0) testflip= 0;    /* grote hoeken */
+       if((me->flag & ME_TWOSIDED)==0) testflip= 0;    /* large angles */
        
        if(me->totface==0) {
-               /* namaak puno's voor halopuno! */
+               /* fake vertex normals for 'halopuno' (render option) */
                mvert= me->mvert;
                for(a=0; a<me->totvert; a++, mvert++) {
                        VECCOPY(n1, mvert->co);
@@ -6074,7 +5924,7 @@ void vertexnormals_mesh(Mesh *me, float *extverts)
 
        normals= MEM_callocN(me->totvert*3*sizeof(float), "normals");
        
-       /* berekenen cos hoeken en oppervlakte en optellen bij puno */
+       /* calculate cosine angles, and add to vertex normal */
        mface= me->mface;
        mvert= me->mvert;
        for(a=0; a<me->totface; a++, mface++) {
@@ -6149,7 +5999,7 @@ void vertexnormals_mesh(Mesh *me, float *extverts)
                }
        }
 
-       /* normaliseren puntnormalen */
+       /* normalize vertex normals */
        mvert= me->mvert;
        for(a=0; a<me->totvert; a++, mvert++) {
                len= Normalise(normals+3*a);
@@ -6163,7 +6013,7 @@ void vertexnormals_mesh(Mesh *me, float *extverts)
                }
        }
        
-       /* puntnormaal omklap-vlaggen voor bij shade */
+       /* vertex normal flipping flags, for during render */
        mface= me->mface;
        mvert= me->mvert;
        for(a=0; a<me->totface; a++, mface++) {
@@ -6209,7 +6059,7 @@ void vertexnormals_mesh(Mesh *me, float *extverts)
                                }
                        }
                }
-               /* proj voor cubemap! */
+               /* proj for cubemap! */
                xn= fabs(vnor[0]);
                yn= fabs(vnor[1]);
                zn= fabs(vnor[2]);
index ec3386c511b38b8b8c1a70235e0b54442500f027..b4825869f3759b186b6c6cfd3343fb1128576efd 100644 (file)
@@ -182,7 +182,7 @@ float prop_cent[3];
 
 float centre[3], centroid[3];
 
-void add_object_draw(int type) /* voor toolbox */
+void add_object_draw(int type) /* for toolbox */
 {
        Object *ob;
        
@@ -215,7 +215,7 @@ void add_object_draw(int type)      /* voor toolbox */
        allqueue(REDRAWNLA, 0);
        deselect_all_area_oops();
        set_select_flag_oops();
-       allqueue(REDRAWINFO, 1);        /* 1, want header->win==0! */
+       allqueue(REDRAWINFO, 1);        /* 1, because header->win==0! */
 
 }
 
@@ -280,6 +280,8 @@ void make_track(void)
        /* Not yet */
        notice ("Make Track no longer supported.  Use constraints instead.");
        return;
+
+       /* hrms, i would suppose then just to add a constraint for the user. be nice! (ton) */
 #endif
 
        if(okee("Make Track")==0) return;
@@ -475,7 +477,7 @@ void clear_object(char mode)
 
 void reset_slowparents(void)
 {
-       /* terug op correcte plek */
+       /* back to original locations */
        Base *base;
        
        base= FIRSTBASE;
@@ -517,7 +519,7 @@ void make_vertex_parent(void)
        Object *par, *ob;
        int a, v1=0, v2=0, v3=0, nr=1;
        
-       /* er moet 1 of 3 vertices select zijn */
+       /* we need 1 ot 3 selected vertices */
        
        if(G.obedit->type==OB_MESH) {
                eve= G.edve.first;
@@ -597,7 +599,7 @@ void make_vertex_parent(void)
                                                ob->par2= v2-1;
                                                ob->par3= v3-1;
 
-                                               /* inverse parent matrix berekenen */
+                                               /* inverse parent matrix */
                                                what_does_parent(ob);
                                                Mat4Invert(ob->parentinv, workob.obmat);
                                                clear_workob();
@@ -606,7 +608,7 @@ void make_vertex_parent(void)
                                                ob->partype= PARVERT1;
                                                ob->par1= v1-1;
 
-                                               /* inverse parent matrix berekenen */
+                                               /* inverse parent matrix */
                                                what_does_parent(ob);
                                                Mat4Invert(ob->parentinv, workob.obmat);
                                                clear_workob();
@@ -771,7 +773,7 @@ void make_parent(void)
                                base= base->next;
                        }
                        
-                       /* nu gaan we alle objecten clearparentandkeeptransformen */
+                       /* now we'll clearparentandkeeptransform all objects */
                        base= FIRSTBASE;
                        while(base) {
                                if TESTBASELIB(base) {
@@ -843,9 +845,9 @@ void make_parent(void)
                                                
                                                base->object->parent= par;
                                                
-                                               /* inverse parent matrix berekenen? */
+                                               /* calculate inverse parent matrix? */
                                                if( (qual & LR_SHIFTKEY) ) {
-                                                       /* niet dus... */
+                                                       /* not... */
                                                        Mat4One(base->object->parentinv);
                                                        memset(base->object->loc, 0, 3*sizeof(float));
                                                }
@@ -936,7 +938,7 @@ void enter_editmode(void)
                make_editArmature();
                allqueue (REDRAWVIEW3D,0);
        }
-       else if(ob->type==OB_IKA) {     /* grabtype */
+       else if(ob->type==OB_IKA) {     /* grab type */
                base= FIRSTBASE;
                while(base) {
                        if TESTBASE(base) {
@@ -993,7 +995,7 @@ void make_displists_by_parent(Object *ob) {
                        makeDispList(base->object);
 }
 
-void exit_editmode(int freedata)       /* freedata==0 bij render */
+void exit_editmode(int freedata)       /* freedata==0 at render */
 {
        Base *base;
        Object *ob;
@@ -1003,7 +1005,7 @@ void exit_editmode(int freedata)  /* freedata==0 bij render */
 
        if(G.obedit->type==OB_MESH) {
 
-               /* tijdelijk */
+               /* temporal */
                countall();
                if(G.totvert>65000) {
                        error("too many vertices");
@@ -1038,17 +1040,17 @@ void exit_editmode(int freedata)        /* freedata==0 bij render */
 
        ob= G.obedit;
        
-       /* obedit moet 0 zijn voor curve-extrude, niet voor smeshes */
+       /* obedit has to be 0 for curve-extrude, not for smeshes */
        if(ob->type==OB_CURVE) G.obedit= 0;
        G.obedit= 0;
        makeDispList(ob);
        
        
 
-       /* heeft dit nog invloed op andere bases? */
+       /* has this influence at other objects? */
        if(ob->type==OB_CURVE) {
 
-               /* test of ob als bevelcurve of textoncurve wordt gebruikt */
+               /* test if ob is use as bevelcurve r textoncurve */
                base= FIRSTBASE;
                while(base) {
                        if ELEM(base->object->type, OB_CURVE, OB_FONT) {
@@ -1133,7 +1135,7 @@ void docentre(void)
                }
        }
        
-       /* vlaggen resetten */
+       /* reset flags */
        base= FIRSTBASE;
        while(base) {
                if TESTBASELIB(base) {
@@ -1194,7 +1196,7 @@ void docentre(void)
                                                base->object->loc[1]+= centn[1];
                                                base->object->loc[2]+= centn[2];
                                                
-                                               /* andere users? */
+                                               /* other users? */
                                                ob= G.main->object.first;
                                                while(ob) {
                                                        if((ob->flag & OB_DONE)==0) {
@@ -1225,10 +1227,10 @@ void docentre(void)
                                                }
                                        }
                                
-                                       /* displisten van alle users, ook deze base */
+                                       /* displist of all users, also this one */
                                        makeDispList(base->object);
                                        
-                                       /* DOEN: alle users aflopen... */
+                                       /* DO: check all users... */
                                        tex_space_mesh(me);
                
                                }
@@ -1301,15 +1303,15 @@ void docentre(void)
        
                                }
                                else if(base->object->type==OB_FONT) {
-                                       /* uit de bb halen */
+                                       /* get from bb */
                                        
                                        cu= base->object->data;
                                        if(cu->bb==0) return;
                                        
                                        cu->xof= -0.5*( cu->bb->vec[4][0] - cu->bb->vec[0][0]);
-                                       cu->yof= -0.5 -0.5*( cu->bb->vec[0][1] - cu->bb->vec[2][1]);    /* extra 0.5 is de hoogte van de bovenste regel */
+                                       cu->yof= -0.5 -0.5*( cu->bb->vec[0][1] - cu->bb->vec[2][1]);    /* extra 0.5 is the height of above line */
                                        
-                                       /* klopt niet helemaal, een keer goed doen! */
+                                       /* not really ok, do this better once! */
                                        cu->xof /= cu->fsize;
                                        cu->yof /= cu->fsize;
                                        
@@ -1545,18 +1547,8 @@ void special_editmenu(void)
                if(nr>0) waitcursor(0);
                
        }
-/*     else if (G.obedit->type==OB_ARMATURE){
-               nr= pupmenu("Specials%t|");
-               if (nr>0) waitcursor (1);
-               switch (nr){
-               case 1:
-               }
-               if (nr>0) waitcursor (0);
-       }
-*/
        else if ELEM(G.obedit->type, OB_CURVE, OB_SURF) {
 
-               /* nr= pupmenu("Specials%t|Subdivide%x1|Hide%x5|Reveal%x6|Select swap%x7"); */
                nr= pupmenu("Specials%t|Subdivide%x1|Switch Direction%x2");
                
                switch(nr) {
@@ -1617,9 +1609,9 @@ void convertmenu(void)
        }
        if(ok==0) return;
 
-       /* denk aan meerdere users! */
+       /* don't forget multiple users! */
 
-       /* vlaggen resetten */
+       /* reset flags */
        base= FIRSTBASE;
        while(base) {
                if TESTBASELIB(base) {
@@ -1645,7 +1637,7 @@ void convertmenu(void)
 
                                        basen= MEM_mallocN(sizeof(Base), "duplibase");
                                        *basen= *base;
-                                       BLI_addhead(&G.scene->base, basen);     /* addhead: anders oneindige lus */
+                                       BLI_addhead(&G.scene->base, basen);     /* addhead: otherwise eternal loop */
                                        basen->object= ob1;
                                        basen->flag &= ~SELECT;
                                                
@@ -1680,7 +1672,7 @@ void convertmenu(void)
                                                cu->vfont->id.us--;
                                                cu->vfont= 0;
                                        }
-                                       /* andere users */
+                                       /* other users */
                                        if(cu->id.us>1) {
                                                ob1= G.main->object.first;
                                                while(ob1) {
@@ -1699,9 +1691,9 @@ void convertmenu(void)
                                        dl= cu->disp.first;
                                        if(dl==0) makeDispList(ob);
 
-                                       nurbs_to_mesh(ob); /* doet ook users */
+                                       nurbs_to_mesh(ob); /* also does users */
 
-                                       /* texspace en normalen */
+                                       /* texspace and normals */
                                        BASACT= base;
                                        enter_editmode();
                                        exit_editmode(1);
@@ -1721,7 +1713,7 @@ void convertmenu(void)
 
                                                basen= MEM_mallocN(sizeof(Base), "duplibase");
                                                *basen= *base;
-                                               BLI_addhead(&G.scene->base, basen);     /* addhead: anders oneindige lus */
+                                               BLI_addhead(&G.scene->base, basen);     /* addhead: othwise eternal loop */
                                                basen->object= ob1;
                                                basen->flag &= ~SELECT;
                                                
@@ -2148,7 +2140,7 @@ void linkmenu()
                        }
                        if(sce==0 || sce->id.lib) return;
                        
-                       /* denk eraan: is verderop nog nodig */
+                       /* remember: is needed below */
                        event= 1;
                }
        }
@@ -2163,13 +2155,13 @@ void linkmenu()
                                
                                if(event==1) {          /* to scene */
                                        
-                                       /* testen of het soms al gelinkt is */
+                                       /* test if already linked */
                                        sbase= sce->base.first;
                                        while(sbase) {
                                                if(sbase->object==base->object) break;
                                                sbase= sbase->next;
                                        }
-                                       if(sbase) {     /* eruit */
+                                       if(sbase) {     /* remove */
                                                base= base->next;
                                                continue;
                                        }
@@ -2191,7 +2183,7 @@ void linkmenu()
                                                        id_us_plus(id);
                                                        obt->data= id;
                                                        
-                                                       /* als aantal mat indices veranderd zijn: */
+                                                       /* if amount of material indices changed: */
                                                        test_object_materials(obt->data);
                                                }
                                        }
@@ -2205,17 +2197,17 @@ void linkmenu()
                                }
                                else if(event==3) {  /* materials */
                                        
-                                       /* alleen als obt geen materiaal heeft: arrays maken */
-                                       /* van ob naar obt! */
+                                       /* only if obt has no material: make arrays */
+                                       /* from ob to obt! */
                                        
                                        obmatarar= give_matarar(ob);
                                        matarar= give_matarar(obt);
                                        totcolp= give_totcolp(obt);
 
-                                       /* als 1 van de 2 nul is: geen renderbaar object */                                             
+                                       /* if one of the two is zero: no render-able object */                                          
                                        if( matarar && obmatarar) {
                                                
-                                               /* voorzichtig met users! Dus eerst kopie orig: */
+                                               /* take care of users! so first a copy of original: */
 
                                                if(ob->totcol) {
                                                        matar1= MEM_dupallocN(ob->mat);
@@ -2225,23 +2217,23 @@ void linkmenu()
                                                        matar1= matar2= 0;
                                                }
                                                
-                                               /* alles van obt los linken */
+                                               /* remove links from obt */
                                                for(a=0; a<obt->totcol; a++) {
                                                        if(obt->mat[a]) obt->mat[a]->id.us--;
                                                        if( (*matarar)[a]) (*matarar)[a]->id.us--;
                                                }
                                                
-                                               /* vrijgeven */
+                                               /* free */
                                                if(obt->mat) MEM_freeN(obt->mat);
                                                if(*matarar) MEM_freeN(*matarar);
                                                
-                                               /* hangen kopie er aan */
+                                               /* connect a copy */
                                                obt->mat= matar1;
                                                *matarar= matar2;
                                                obt->totcol= ob->totcol;
                                                *totcolp= ob->totcol;
                                        
-                                               /* users ophogen */
+                                               /* increase users */
                                                for(a=0; a<obt->totcol; a++) {
                                                        if(obt->mat[a]) id_us_plus((ID *)obt->mat[a]);
                                                        if( (*matarar)[a]) id_us_plus((ID *)(*matarar)[a]);
@@ -2249,7 +2241,7 @@ void linkmenu()
 
                                                obt->colbits= ob->colbits;
                                                
-                                               /* als aantal mat indices veranderd zijn: */
+                                               /* if amount of material indices changed: */
                                                test_object_materials(obt->data);
                                        }
                                }
@@ -2281,15 +2273,15 @@ void make_duplilist_real()
                                ob= duplilist.first;
                                while(ob) {
                                        
-                                       /* font dupli's kunnen totcol hebben zonder mat, halen ze van parent af
-                                        * dit zou netter moeten
+                                       /* font duplis can have a totcol without material, we get them from parent
+                                        * should be implemented better...
                                         */
                                        if(ob->mat==0) ob->totcol= 0;
                                        
                                        basen= MEM_dupallocN(base);
                                        basen->flag &= ~OB_FROMDUPLI;
-                                       BLI_addhead(&G.scene->base, basen);     /* addhead: anders oneindige lus */
-                                       ob->ipo= 0;             /* zeker weten dat de apply werkt */
+                                       BLI_addhead(&G.scene->base, basen);     /* addhead: othwise eternal loop */
+                                       ob->ipo= 0;             /* make sure apply works */
                                        ob->parent= ob->track= 0;
                                        ob->disp.first= ob->disp.last= 0;
                                        ob->transflag &= ~OB_DUPLI;
@@ -2368,7 +2360,7 @@ void apply_object()
                                
                                where_is_object(ob);
                                
-                               /* texspace en normalen */
+                               /* texspace and normals */
                                BASACT= base;
                                enter_editmode();
                                exit_editmode(1);
@@ -2435,7 +2427,7 @@ void apply_object()
                                
                                where_is_object(ob);
                                
-                               /* texspace en normalen */
+                               /* texspace and normals */
                                BASACT= base;
                                enter_editmode();
                                exit_editmode(1);
@@ -2450,7 +2442,7 @@ void apply_object()
 
 
 
-/* ************ ALGEMENE  *************** */
+/* ************ GENERAL  *************** */
 
 static Object *is_a_parent_selected_int(Object *startob, Object *ob, GHash *done_hash) {
        if (ob!=startob && TESTBASE(ob))
@@ -2527,7 +2519,7 @@ static void setbaseflags_for_editing(int mode)    /* 0,'g','r','s' */
                        Object *ob= base->object;
                        Object *parsel= is_a_parent_selected(ob);
                        
-                       /* hier ook parentkey? */
+                       /* parentkey here? */
 
                        if(parsel) {
                                if(base->flag & SELECT) {
@@ -2543,7 +2535,6 @@ static void setbaseflags_for_editing(int mode)    /* 0,'g','r','s' */
                        }
                        
                        /* updates? */
-                               /* ivm automatische portals */
                        if(ob->type==OB_IKA) {
                                Ika *ika= ob->data;
                                if(ika->parent && parsel) base->flag |= BA_WHERE_UPDATE;
@@ -2643,13 +2634,13 @@ void ob_to_transob(Object *ob, TransOb *tob)
 
        VECCOPY(tob->olddsize, ob->dsize);
 
-       /* alleen object, geen parent */
+       /* only object, not parent */
        object_to_mat3(ob, tob->obmat);
        Mat3Inv(tob->obinv, tob->obmat);
        
        Mat3CpyMat4(totmat, ob->obmat);
 
-       /* dit is totmat zonder obmat: dus parmat */
+       /* this is totmat without obmat: so a parmat */
        Mat3MulMat3(tob->parmat, totmat, tob->obinv);
        Mat3Inv(tob->parinv, tob->parmat);
 
@@ -2681,11 +2672,9 @@ void ob_to_transob(Object *ob, TransOb *tob)
                        VECCOPY(tob->oldeff, tob->eff);
                        tob->flag |= TOB_IKA;
 
-                       /* zodat alleen eff update wordt */
                        tob->loc= 0;
                }
                
-               /* set_ika_undo_vals(); */
        }
 }
 
@@ -2742,7 +2731,7 @@ void make_trans_objects()
        INIT_MINMAX(min, max);
        centroid[0]=centroid[1]=centroid[2]= 0.0;
        
-       /* aantal tellen */     
+       /* count */     
        base= FIRSTBASE;
        while(base) {
                if TESTBASELIB(base) {
@@ -2754,7 +2743,7 @@ void make_trans_objects()
                        else {
                                if(ob->ipo && ob->ipo->showkey && (ob->ipoflag & OB_DRAWKEY)) {
                                        elems.first= elems.last= 0;
-                                       make_ipokey_transform(ob, &elems, 1); /* '1' alleen selected keys */
+                                       make_ipokey_transform(ob, &elems, 1); /* '1' only selected keys */
                                        
                                        pushdata(&elems, sizeof(ListBase));
                                        
@@ -2776,7 +2765,7 @@ void make_trans_objects()
        reset_slowparents();
 
 
-       /* dit hieronder wel doen als tottrans==0, i.v.m. vrijgeven pushpop en ipokeys */
+       /*also do this below when tottrans==0, because of freeing pushpop and ipokeys */
        
        base= FIRSTBASE;
        while(base) {
@@ -2795,7 +2784,7 @@ void make_trans_objects()
                        }
                        else {
 
-                               /* van belang! (o.a. bevobj) */
+                               /* is needed! (bevobj) */
                                if(base->flag & SELECT) ob->flag|= SELECT; else ob->flag &= ~SELECT;
        
                                if(ob->ipo && ob->ipo->showkey && (ob->ipoflag & OB_DRAWKEY)) {
@@ -2824,7 +2813,7 @@ void make_trans_objects()
                                                        ob_to_transob(ob, tob);
                                                        DO_MINMAX(tob->obvec, min, max);
                                                        
-                                                       /* doet ook tob->flag en oldvals, moet NA ob_to_transob()! */
+                                                       /* also does tob->flag and oldvals, needs to be after ob_to_transob()! */
                                                        set_ipo_pointers_transob(ik, tob);
                                                        
                                                        tob++;
@@ -2861,7 +2850,7 @@ void make_trans_objects()
                base= base->next;
        }
        
-       pushpop_test(); /* alleen voor debug & zekerheid */
+       pushpop_test(); /* only for debug & to be sure */
        
        if(tottrans==0) return;
        
@@ -3036,7 +3025,7 @@ void make_trans_verts(float *min, float *max, int mode)
                }
        }
        
-       /* cent enz berekenen */
+       /* cent etc */
        tv= transvmain;
        for(a=0; a<tottrans; a++, tv++) {
                if(tv->flag) {
@@ -3239,7 +3228,7 @@ void special_aftertrans_update(char mode, int flip, short canceled, int keyflags
        int doit,redrawipo=0;
 
        
-       /* displaylisten e.d. */
+       /* displaylists etc. */
        
        if(G.obedit) {
                if(G.obedit->type==OB_MBALL) {
@@ -3307,7 +3296,6 @@ void special_aftertrans_update(char mode, int flip, short canceled, int keyflags
 
                                if(ob->type==OB_IKA) {
                                        ika= ob->data;                                  
-                                       /* vooral voor ika NIET in GRABEFF mode, updaten van globale effector */
                                        VecMat4MulVecfl(ika->effg, ob->obmat, ika->eff);
                                        itterate_ika(ob);
                                }
@@ -3344,7 +3332,7 @@ void special_aftertrans_update(char mode, int flip, short canceled, int keyflags
                                        makeDispList(ob);
                        }
                        
-                       where_is_object(ob);    /* altijd ivm track eytc */
+                       where_is_object(ob);    /* always do, for track etc. */
 
                        /* Set autokey if necessary */
                        if ((U.uiflag & KEYINSERTOBJ) && (!canceled) && (base->flag & SELECT)){
@@ -3396,7 +3384,7 @@ void calc_trans_verts(void)
                Nurb *nu= editNurb.first;
                while(nu) {
                        test2DNurb(nu);
-                       testhandlesNurb(nu); /* test ook op bezier */
+                       testhandlesNurb(nu); /* test for bezier too */
                        nu= nu->next;
                }
                makeDispList(G.obedit);
@@ -3408,7 +3396,7 @@ static int test_midtog_proj(short xn, short yn, short *mval)
 {
        float x,y,z;
 
-       /* welke beweging is het grootst? die wordt het */
+       /* which movement is the largest? that'll be the one */
        xn= (xn-mval[0]);
        yn= (yn-mval[1]);
        x = fabs(G.vd->persinv[0][0]*xn + G.vd->persinv[1][0]*yn);
@@ -3422,7 +3410,7 @@ static int test_midtog_proj(short xn, short yn, short *mval)
 
 void apply_keyb_grid(float *val, float fac1, float fac2, float fac3, int invert)
 {
-       /* fac1 is voor 'niets', fac2 voor CTRL fac3 voor SHIFT */
+       /* fac1 is for 'nothing', fac2 for CTRL, fac3 for SHIFT */
        int ctrl;
 
        if(invert) {
@@ -3448,16 +3436,12 @@ void compatible_eul(float *eul, float *oldrot)
 {
        float dx, dy, dz;
        
-       /* verschillen van ong 360 graden eerst corrigeren */
+       /* correct differences of about 360 degrees first */
 
        dx= eul[0] - oldrot[0];
        dy= eul[1] - oldrot[1];
        dz= eul[2] - oldrot[2];
 
-/* printf("komt binnen: \n"); */
-/* PRINT3(f, f, f, eul[0], eul[1], eul[2]); */
-/* PRINT3(f, f, f, dx, dy, dz); */
-
        while( fabs(dx) > 5.1) {
                if(dx > 0.0) eul[0] -= 2.0*M_PI; else eul[0]+= 2.0*M_PI;
                dx= eul[0] - oldrot[0];
@@ -3471,10 +3455,7 @@ void compatible_eul(float *eul, float *oldrot)
                dz= eul[2] - oldrot[2];
        }
        
-/* PRINT3(f, f, f, oldrot[0], oldrot[1], oldrot[2]); */
-       
-
-       /* is 1 van de asrotaties groter dan 180 graden en de andere klein? GEEN ELSEIF!! */    
+       /* is 1 of the axis rotations larger than 180 degrees and the other small? NO ELSE IF!! */      
        if( fabs(dx) > 3.2 && fabs(dy)<1.6 && fabs(dz)<1.6 ) {
                if(dx > 0.0) eul[0] -= 2.0*M_PI; else eul[0]+= 2.0*M_PI;
        }
@@ -3484,14 +3465,15 @@ void compatible_eul(float *eul, float *oldrot)
        if( fabs(dz) > 3.2 && fabs(dx)<1.6 && fabs(dy)<1.6 ) {
                if(dz > 0.0) eul[2] -= 2.0*M_PI; else eul[2]+= 2.0*M_PI;
        }
+
+       return; /* <- intersting to find out who did that! */
        
-return;
-       /* opnieuw berekenen */
+       /* calc again */
        dx= eul[0] - oldrot[0];
        dy= eul[1] - oldrot[1];
        dz= eul[2] - oldrot[2];
 
-       /* dit is een bijzonder geval, voor x-z getest */
+       /* special case, tested for x-z  */
        
        if( (fabs(dx) > 3.1 && fabs(dz) > 1.5 ) || ( fabs(dx) > 1.5 && fabs(dz) > 3.1 ) ) {
                if(dx > 0.0) eul[0] -= M_PI; else eul[0]+= M_PI;
@@ -3510,8 +3492,6 @@ return;
                if(dz > 0.0) eul[2] -= M_PI; else eul[2]+= M_PI;
        }
 
-/* PRINT3(f, f, f, eul[0], eul[1], eul[2]); */
-/* printf("\n"); */
 }
 
 void headerprint(char *str)
@@ -3582,9 +3562,7 @@ int cylinder_intersect_test(void)
        
        VecSubf(rc, oldloc, base);
        
-       /* als we nou speed normaliseren (kan van te voren! */
-
-       /* en de axis ook alvast */
+       /* the axis */
        len2= Normalise(axis);
        
        Crossf(n, speed, axis);
@@ -3604,12 +3582,12 @@ int cylinder_intersect_test(void)
        labdacor= t-s;
        labda= t+s;
 
-       /* twee gevallen waarbij geen snijpunt is */
+       /* two cases with no intersection point */
        if(labdacor>=1.0 && labda>=1.0) return 0;
        if(labdacor<=0.0 && labda<=0.0) return 0;
        
-       /* normaalvector berekenen */
-       /* snijpunt: */
+       /* calc normal */
+       /* intersection: */
        
        rc[0]= oldloc[0] + labdacor*speed[0] - base[0];
        rc[1]= oldloc[1] + labdacor*speed[1] - base[1];
@@ -3655,14 +3633,14 @@ int sphere_intersect_test(void)
        
        if(disc>=0.0) {
                disc= sqrt(disc);
-               labdacor= (-bsq - disc)/len;    /* intrede */
+               labdacor= (-bsq - disc)/len;    /* entry point */
                labda= (-bsq + disc)/len;
                
                printf("var1: %f, var2: %f, var3: %f\n", labdacor, labda, editbutsize);
        }
        else return 0;
 
-       /* snijpunt en normaal */
+       /* intersection and normal */
        rc[0]= oldloc[0] + labdacor*speed[0] - base[0];
        rc[1]= oldloc[1] + labdacor*speed[1] - base[1];
        rc[2]= oldloc[2] + labdacor*speed[2] - base[2];
@@ -3777,7 +3755,7 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
        /* form duplicate routines */
        if(mode=='d') mode= 'g';
 
-       /* kan floating exception veroorzaken op alpha */
+       /* this can cause floating exception at dec alpha */
        d_dvec[0]= d_dvec[1]= d_dvec[2]= 0.0;
        dvec[0]= dvec[1]= dvec[2]= 0.0;
        
@@ -3788,11 +3766,11 @@ void transform(int mode)        /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
        }
        if(mode=='w' && G.obedit==0) return;
        
-       /* welke data wordt behandeld? */
+       /* what data will be involved? */
        if(G.obedit) {
                if(mode=='N') vertexnormals(0);
        
-               /* min en max zijn nodig voor de warp */
+               /* min en max needed for warp */
                if(mode=='G' || mode=='R' || mode=='C') make_trans_verts(min, max, 1);
                else make_trans_verts(min, max, 0);
        }
@@ -3849,13 +3827,13 @@ void transform(int mode)        /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                VECCOPY (centre, centroid);
        }
 
-       /* moving: onderscheid i.v.m. drawobj */
+       /* moving: is shown in drawobject() */
        if(G.obedit) G.moving= 2;
        else G.moving= 1;
        
        areawinset(curarea->win);
        
-       /* de persinv is vervuild met translatie, niet gebruiken!! */
+       /* the persinv is polluted with translation, do not use!! */
        Mat3CpyMat4(persmat, G.vd->persmat);
        Mat3Inv(persinv, persmat);
        
@@ -3877,9 +3855,9 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                project_short_noclip(vec, mval);
        }
        else {
-               /* voor pannen vanuit cameraview */
+               /* voor panning from cameraview */
                if( G.vd->camera==OBACT && G.vd->persp>1) {
-                       /* 6.0 = 6 grideenheden */
+                       /* 6.0 = 6 grid units */
                        centre[0]+= -6.0*rot2[0];
                        centre[1]+= -6.0*rot2[1];
                        centre[2]+= -6.0*rot2[2];
@@ -3939,7 +3917,7 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                centre[1]= (min[1]+max[1])/2.0;
                centre[2]= (min[2]+max[2])/2.0;
 
-                       /* middelpunt is cursor */
+                       /* cursor is centre */
                curs= give_cursor();
                VECCOPY(axis, curs);
                Mat4MulVecfl(G.vd->viewmat, axis);
@@ -3967,7 +3945,7 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                if(mval[0]!=xo || mval[1]!=yo || firsttime) {
                        if(firsttime) {
                                
-                               /* niet zo netjes, maar toch! */
+                               /* not really nice, but who cares! */
                                oldval[0]= oldval[1]= oldval[2]= MAXFLOAT;
                                
                                /* proportional precalc */
@@ -3985,7 +3963,6 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                        if(mode=='g' || mode=='G') {
                                
                                keyflags |= KEYFLAG_LOC;
-                               /* if(G.edve.first) sphere_intersect_test(); */
                                
                                if(midtog) {
                                        if(cameragrab) {
@@ -3993,7 +3970,7 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                                                dvec[0]-= dx1*G.vd->viewinv[2][0];
                                                dvec[1]-= dx1*G.vd->viewinv[2][1];
                                                dvec[2]-= dx1*G.vd->viewinv[2][2];
-                                               firsttime= 1;   /* blijftie lopen */
+                                               firsttime= 1;   /* so it keeps going */
                                        }
                                        else {
                                                window_to_3d(dvec, mval[0]-xn, mval[1]-yn);
@@ -4142,10 +4119,10 @@ void transform(int mode)        /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                                        
                                        for(a=0; a<tottrans; a++, tob++, tv++) {
                                                if(transmain) {
-                                                       /* rotatie in drie stappen:
-                                                        * 1. editrot corrigeren voor parent
-                                                        * 2. hier de euler uit destilleren. Deze stap moet omdat de MatToEul nogal zwak is
-                                                        * 3. deze vermenigvuldigen met eigen rot, euler berekenen.
+                                                       /* rotation in three steps:
+                                                        * 1. editrot correction for parent
+                                                        * 2. distill from this the euler. Always do this step because MatToEul is pretty weak
+                                                        * 3. multiply with its own rotation, calculate euler.
                                                         */
                                                
                                                        /* Roll around local axis */
@@ -4180,11 +4157,11 @@ void transform(int mode)        /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                                                                }
                                                        
                                                                /* 3 */
-                                                               /* we werken even met de rot+drot */
+                                                               /* we now work with rot+drot */
                                                                
                                                        if(tob->ob->transflag & OB_QUAT || !tob->rot)
                                                        {
-                                                               /* drot+rot NOG DOEN! */
+                                                               /* drot+rot TO DO! */
                                                                Mat3ToQuat(smat, quat); // Original
                                                                QuatMul(tob->quat, quat, tob->oldquat);
                                                                
@@ -4195,7 +4172,6 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                                                                        }
                                                                        else {
                                                                                /* VecSubf(rot, eul, tob->olddrot); */
-//                                                                             VecSubf(rot, eul, tob->olddrot);
                                                                        }
        
                                                                        /* VecMulf(rot, 9.0/M_PI_2); */
@@ -4208,7 +4184,6 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                                                                }
                                                                else {
                                                                        /* QuatSub(tob->quat, quat, tob->oldquat); */
-//                                                                     QuatSub(tob->quat, quat, tob->oldquat);
                                                                }
                                                        }
                                                        else {
@@ -4219,8 +4194,8 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
 
                                                                Mat3ToEul(totmat, eul);
 
-                                                               /* Eul mag niet te gek afwijken van oude eul.
-                                                                * Dit is alleen nog maar getest voor dx && dz
+                                                               /* Eul is not allowed to differ too much from old eul.
+                                                                * This has only been tested for dx && dz
                                                                 */
                                                                
                                                                compatible_eul(eul, tob->oldrot);
@@ -4255,11 +4230,11 @@ void transform(int mode)        /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                                                        }
                                                        
                                                        if(G.vd->around!=V3D_LOCAL && (!G.obpose))  {
-                                                                       /* translatie */
+                                                                       /* translation */
                                                                        VecSubf(vec, tob->obvec, centre);
                                                                        Mat3MulVecfl(mat, vec);
                                                                        VecAddf(vec, vec, centre);
-                                                                       /* vec is nu de plek waar het object moet komen */
+                                                                       /* vec now is the location where the object has to be */
                                                                        VecSubf(vec, vec, tob->obvec);
                                                                        Mat3MulVecfl(tob->parinv, vec);
                                                                        
@@ -4348,7 +4323,7 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                                        if(proj==2) size[1]=size[0]= 1.0;
                                }
 
-/* X en Y flip, twee methodes: bij  |**| commentaar weghalen maakt flips lokaal */
+/* X en Y flip, there are 2 methods: at  |**| removing comments makes flips local */
 
 /**/                   /* if(transvmain) { */
        
@@ -4384,14 +4359,12 @@ void transform(int mode)        /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                                        
                                        for(a=0; a<tottrans; a++, tob++, tv++) {
                                                if(transmain) {
-                                                       /* size moet lokaal t.o.v. ouder EN van eigen rotatie */
-                                                       /* lokaal tov. ouder: */
-
-                                                       
+                                                       /* size local with respect to parent AND own rotation */
+                                                       /* local wrt parent: */
                                                        
                                                        Mat3MulSerie(smat, tob->parmat, mat, tob->parinv, 0, 0,0 ,0, 0);
                                                        
-                                                       /* lokaal tov. eigen rot: */
+                                                       /* local wrt own rotation: */
                                                        Mat3MulSerie(totmat, tob->obmat, smat, tob->obinv, 0, 0, 0,0 ,0);
 
                                                        /* XXX this can yield garbage in case of inverted sizes (< 0.0)
@@ -4401,7 +4374,7 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                                                                sizelo[1]= size[1];
                                                                sizelo[2]= size[2];
                                                        } else {        
-                                                       /* dan klopt de vorige berekening van de juiste size niet meer precies */
+                                                       /* in this case the previous calculation of the size is wrong */
                                                                sizelo[0]= totmat[0][0];        
                                                                sizelo[1]= totmat[1][1];        
                                                                sizelo[2]= totmat[2][2];
@@ -4419,9 +4392,9 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
 
 
                                                        /* what you see is what you want; not what you get! */
-                                                       /* correctie voor delta size */
+                                                       /* correction for delta size */
                                                        if(tob->flag & TOB_IPO) {
-                                                               /* deltasize berekenen (gelijk voor size en dsize) */
+                                                               /* calculate delta size (equal for size and dsize) */
                                                                
                                                                vec[0]= (tob->oldsize[0]+tob->olddsize[0])*(sizelo[0] -1.0);
                                                                vec[1]= (tob->oldsize[1]+tob->olddsize[1])*(sizelo[1] -1.0);
@@ -4439,11 +4412,11 @@ void transform(int mode)        /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                                                        }
                                                        
                                                        if(G.vd->around!=V3D_LOCAL && !G.obpose) {
-                                                               /* translatie */
+                                                               /* translation */
                                                                VecSubf(vec, tob->obvec, centre);
                                                                Mat3MulVecfl(mat, vec);
                                                                VecAddf(vec, vec, centre);
-                                                               /* vec is nu de plek waar het object moet komen */
+                                                               /* vec is the location where the object has to be */
                                                                VecSubf(vec, vec, tob->obvec);
                                                                Mat3MulVecfl(tob->parinv, vec);
 
@@ -4535,7 +4508,7 @@ void transform(int mode)  /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                                
                                omtrekfac= startomtrekfac+ 0.05*( mval[1] - yn)*Normalise(dvec);
        
-                               /* berekenen hoek voor print */
+                               /* calc angle for print */
                                dist= max[0]-centre[0];
                                phi0= 360*omtrekfac*dist/(rad*M_PI);
                                
@@ -4548,14 +4521,14 @@ void transform(int mode)        /* 'g' 'G' 'r' 'R' 's' 'S' 't' or 'w' 'N' */
                                sprintf(str, "Warp %3.3f", phi0); 
                                headerprint(str);
        
-                               /* elke vertex moet apart geroteerd */
+                               /* each vertex transform individually */
                                tob= transmain;
                                tv= transvmain;
                                        
                                for(a=0; a<tottrans; a++, tob++, tv++) {
                                        if(transvmain) {
                                                
-                                               /* punt transleren naar centre, zodanig roteren dat omtrekafstand==afstand */
+                                               /* translate point to centre, rotate in such a way that outline==distance */
                                                
                                                VECCOPY(vec, tv->oldloc);
                                                Mat4MulVecfl(G.obedit->obmat, vec);
@@ -4812,14 +4785,14 @@ void rightmouse_transform(void)
 
 
 void single_object_users(int flag)     
-       /* hierna wel clear_id_newpoins() aanroepen */
+       /* after this call clear_id_newpoins() */
 {
        Base *base;
        Object *ob, *obn;
        
        clear_sca_new_poins();  /* sensor/contr/act */
 
-       /* dupliceren */
+       /* duplicate */
        base= FIRSTBASE;
        while(base) {
                ob= base->object;
@@ -4839,7 +4812,7 @@ void single_object_users(int flag)
        ID_NEW(G.scene->camera);
        if(G.vd) ID_NEW(G.vd->camera);
        
-       /* evt object pointers */
+       /* object pointers */
        base= FIRSTBASE;
        while(base) {
                ob= base->object;
@@ -5021,7 +4994,7 @@ void single_mat_users(int flag)
                        for(a=1; a<=ob->totcol; a++) {
                                ma= give_current_material(ob, a);
                                if(ma) {
-                                       /* hier niet LIB_NEW testen: deze fie geeft gegarandeerde single_users! */
+                                       /* do not test for LIB_NEW: this functions guaranteed delivers single_users! */
                                        
                                        if(ma->id.us>1) {
                                                man= copy_material(ma);
@@ -5075,7 +5048,7 @@ void do_single_tex_user(Tex **from)
 
 void single_tex_users_expand()
 {
-       /* alleen als 'ouder' blokken LIB_NEW zijn */
+       /* only when 'parent' blocks are LIB_NEW */
        Material *ma;
        Lamp *la;
        World *wo;
@@ -5119,7 +5092,7 @@ void single_tex_users_expand()
 
 void single_mat_users_expand(void)
 {
-       /* alleen als 'ouder' blokken LIB_NEW zijn */
+       /* only when 'parent' blocks are LIB_NEW */
 
        Object *ob;
        Mesh *me;
@@ -5192,7 +5165,7 @@ void single_user(void)
                else if(nr==3) {
                        single_object_users(1);
                        single_obdata_users(1);
-                       single_mat_users(1); /* ook tex */
+                       single_mat_users(1); /* also tex */
                        
                }
                else if(nr==4) {
@@ -5219,7 +5192,7 @@ void make_local(void)
        ID *id;
        int a, b, mode;
        
-       /* LETOP: de functie new_id(..) voegt het id blok opnieuw in!!! */
+       /* WATCH: the function new_id(..) re-inserts the id block!!! */
        
        if(G.scene->id.lib) return;
        
@@ -5245,7 +5218,7 @@ void make_local(void)
                base= base->next;
        }
        
-       /* evt object pointers */
+       /* maybe object pointers */
        base= FIRSTBASE;
        while(base) {
                ob= base->object;
@@ -5398,14 +5371,14 @@ void adduplicate(float *dtrans)
                        
                        basen= MEM_mallocN(sizeof(Base), "duplibase");
                        *basen= *base;
-                       BLI_addhead(&G.scene->base, basen);     /* addhead: anders oneindige lus */
+                       BLI_addhead(&G.scene->base, basen);     /* addhead: prevent eternal loop */
                        basen->object= obn;
                        base->flag &= ~SELECT;
                        basen->flag &= ~OB_FROMGROUP;
                        
                        if(BASACT==base) BASACT= basen;
 
-                       /* duplicates ahv userflags */
+                       /* duplicates using userflags */
                        
                        if(dupflag & DUPIPO) {
                                id= (ID *)obn->ipo;
@@ -5559,7 +5532,7 @@ void adduplicate(float *dtrans)
                base= base->next;
        }
        
-       /* evt object pointers */
+       /* check object pointers */
        base= FIRSTBASE;
        while(base) {
                if TESTBASELIB(base) {
@@ -5592,7 +5565,7 @@ void adduplicate(float *dtrans)
                base= base->next;
        }
 
-       /* materialen */
+       /* materials */
        if( dupflag & DUPMAT) {
                mao= G.main->mat.first;
                while(mao) {
@@ -5634,8 +5607,8 @@ void adduplicate(float *dtrans)
        set_active_base(BASACT);
        
        allqueue(REDRAWNLA, 0);
-       allqueue(REDRAWACTION, 0);      /* ook oops */
-       allqueue(REDRAWIPO, 0); /* ook oops */
+       allqueue(REDRAWACTION, 0);      /* also oops */
+       allqueue(REDRAWIPO, 0); /* also oops */
 }
 
 
@@ -5708,7 +5681,7 @@ void selectlinks(void)
 
 void image_aspect(void)
 {
-       /* alle geselecteerde objecten die imap hebben: scalen in ima verhouding */
+       /* all selected objects with an image map: scale in image aspect */
        Base *base;
        Object *ob;
        Material *ma;
@@ -5914,7 +5887,7 @@ void auto_timeoffs(void)
        if(BASACT==0) return;
        if(button(&offset, 0, 1000,"Total time")==0) return;
 
-       /* maak array van alle bases, xco yco (scherm) */
+       /* make array of all bases, xco yco (screen) */
        base= FIRSTBASE;
        while(base) {
                if(TESTBASELIB(base)) {
@@ -5957,8 +5930,8 @@ void texspace_edit(void)
        Base *base;
        int nr=0;
        
-       /* eerst testen of van de zichtbare en geselecteerde ob's
-        * wel de texspacedraw aanstaat:
+       /* first test if from visible and selected objects
+        * texspacedraw is set:
         */
        
        if(G.obedit) return;
@@ -5975,7 +5948,6 @@ void texspace_edit(void)
                return;
        }
        
-       /* nr= pupmenu("Texture space %t|Grabber%x1|Size%x2|Rotate%x3"); */
        nr= pupmenu("Texture space %t|Grabber%x1|Size%x2");
        if(nr<1) return;
        
@@ -5999,7 +5971,7 @@ void texspace_edit(void)
 
 void first_base(void)
 {
-       /* maakt de select bases los en insert ze aan begin */
+       /* inserts selected Bases in beginning of list, sometimes useful for operation order */
        Base *base, *next;
        
        if(okee("make first base")==0) return;
index 11ca482f7a754835edcfaf3be6a8cdac1fca817a..9612024cd1855c3ca950fcad2c64850d92571f24 100644 (file)
@@ -146,7 +146,7 @@ void swap_select_all_oops(void)
                oops= oops->next;
        }
        
-       oops_to_select_objects();       /* ook redr */
+       oops_to_select_objects();       /* also redraw */
        
        G.soops->lockpoin= 0;
 }
@@ -170,7 +170,7 @@ static void deselect_all_oops(void)
        G.soops->lockpoin= 0;
 }
 
-void set_select_flag_oops(void)        /* alle areas */
+void set_select_flag_oops(void)        /* all areas */
 {
        SpaceOops *so;
        ScrArea *sa;
@@ -186,7 +186,7 @@ void set_select_flag_oops(void)     /* alle areas */
        if(G.soops) G.soops->lockpoin= 0;
 }
 
-void deselect_all_area_oops(void)      /* alle areas */
+void deselect_all_area_oops(void)      /* all areas */
 {
        SpaceOops *so;
        Oops *oops;
@@ -223,7 +223,7 @@ void transform_oops(int mode)
        
        if(G.soops==0) return;  
                
-       /* welke oopsen doen mee */
+       /* which oopses... */
        oops= G.soops->oops.first;
        while(oops) {
                if(oops->hide==0) {     
@@ -433,7 +433,7 @@ void mouse_select_oops(void)
        
        if(G.soops==0) return;  
                
-       /* welke oopsen doen mee */
+       /* which oopses... */
        oops= G.soops->oops.first;
 
        oops= find_nearest_oops();
@@ -463,7 +463,7 @@ void mouse_select_oops(void)
                G.soops->lockpoin= oops;
        }
        
-       oops_to_select_objects();       /* ook redr */
+       oops_to_select_objects();       /* also redraw */
        scrarea_queue_headredraw(curarea);
        
        force_draw();
@@ -512,7 +512,7 @@ void borderselect_oops(void)
                        oops= oops->next;
                }
 
-               oops_to_select_objects();       /* ook redr */
+               oops_to_select_objects();       /* also redraw */
        }
 }
 
@@ -562,7 +562,7 @@ void select_linked_oops(void)
                oops= oops->next;
        }
        
-       oops_to_select_objects();       /* ook redr */
+       oops_to_select_objects();       /* also redraw */
        
 }
 
@@ -600,7 +600,7 @@ void select_backlinked_oops(void)
                oops= oops->next;
        }
        
-       oops_to_select_objects();       /* ook redr */
+       oops_to_select_objects();       /* also redraw */
        
 }
 
index 1bfc239b0eb1e3ff9bee5efabbf6ddaaebf4c781..58680e10f68ca8cc5d1da931ae3e3d3cbbcd8e7b 100644 (file)
 
 /* TIPS:
  * 
- * - LET OP DE EDGES,  VERTICES ERVAN MOETEN IN VOLGORDE
-        (laagste pointer eerst). Anders onvoorspelbare effecten!
- * - probleem: flags zijn nog niet echt netjes. Altijd na gebruik
-        op nul zetten.
+ * - WATCH THE EDGES,  VERTICES HAVE TO BE IN ORDER...
+        (lowest pointer first). Otherwise unpredictable effects!
+ * - problem: flags here are not nicely implemented. After usage
+        always reset to zero.
  */
 
 static void testareas(void);
@@ -184,12 +184,12 @@ void setcursor_space(int spacetype, short cur)
 
 /* *********  IN/OUT  ************* */
 
-void getmouseco_sc(short *mval)                /* screen coordinaten */
+void getmouseco_sc(short *mval)                /* screen coordinates */
 {
        getmouse(mval);
 }
 
-void getmouseco_areawin(short *mval)           /* interne area coordinaten */
+void getmouseco_areawin(short *mval)           /* internal area coordinates */
 {
        getmouseco_sc(mval);
        
@@ -199,7 +199,7 @@ void getmouseco_areawin(short *mval)                /* interne area coordinaten */
        }
 }
 
-void getmouseco_headwin(short *mval)           /* interne area coordinaten */
+void getmouseco_headwin(short *mval)           /* internal area coordinates */
 {
        getmouseco_sc(mval);
        
@@ -470,11 +470,11 @@ static void scrarea_dispatch_header_events(ScrArea *sa)
                }
        }
 
-       /* test: bestaat window nog */  
+       /* test: does window still exist? */    
        tempsa= areawinar[sa->headwin];
        if(tempsa==0) return;
        
-       /* dit onderscheid loopt niet lekker... */
+       /* this functional separation does not work as well as i expected... */
        if(do_change) scrarea_do_headchange(sa);
        if(do_redraw) scrarea_do_headdraw(sa);
 }
@@ -503,7 +503,7 @@ static void scrarea_dispatch_events(ScrArea *sa)
                if(winqueue_break) return;
        }
 
-       /* test: bestaat window nog */  
+       /* test: does window still exist */     
        tempsa= areawinar[sa->win];
        if(tempsa==0) return;
 
@@ -534,8 +534,8 @@ void markdirty_all()
 
 int is_allowed_to_change_screen(bScreen *new)
 {
-       /* niet als curscreen is full
-        * niet als obedit && old->scene!=new->scene
+       /* not when curscreen is full
+        * not when obedit && old->scene!=new->scene
         */
        
        if(new==0) return 0;
@@ -806,7 +806,7 @@ unsigned short screen_qread(short *val, char *ascii)
 
 unsigned short extern_qread_ext(short *val, char *ascii)
 {
-       /* bewaart de laatste INPUTCHANGE en de laatste REDRAW */
+       /* stores last INPUTCHANGE and last REDRAW */
        unsigned short event;
        
        event= screen_qread(val, ascii);
@@ -863,7 +863,7 @@ static void screen_dispatch_events(void) {
                                
                winqueue_break= 0;
                for (sa= G.curscreen->areabase.first; sa; sa= sa->next) {
-                               /* bewust eerst header afhandelen, dan rest. Header is soms init */
+                               /* first check header, then rest. Header sometimes has initialization code */
                        if (sa->headwin && bwin_qtest(sa->headwin)) {
                                scrarea_dispatch_header_events(sa);
                                events_remaining= 1;
@@ -1219,12 +1219,12 @@ static void removedouble_scrverts(void)
                verg= verg->next;
        }
        
-       /* vervang pointers in edges en vlakken */
+       /* replace pointers in edges and faces */
        se= G.curscreen->edgebase.first;
        while(se) {
                if(se->v1->newv) se->v1= se->v1->newv;
                if(se->v2->newv) se->v2= se->v2->newv;
-               /* edges zijn veranderd: dus.... */
+               /* edges changed: so.... */
                sortscrvert(&(se->v1), &(se->v2));
                se= se->next;
        }
@@ -1237,7 +1237,7 @@ static void removedouble_scrverts(void)
                sa= sa->next;
        }
        
-       /* verwijderen */
+       /* remove */
        verg= G.curscreen->vertbase.first;
        while(verg) {
                v1= verg->next;
@@ -1255,7 +1255,7 @@ static void removenotused_scrverts(void)
        ScrVert *sv, *svn;
        ScrEdge *se;
 
-       /* ga ervan uit dat de edges goed zijn */
+       /* we assume edges are ok */
        
        se= G.curscreen->edgebase.first;
        while(se) {
@@ -1280,7 +1280,7 @@ static void removedouble_scredges(void)
 {
        ScrEdge *verg, *se, *sn;
        
-       /* vergelijken */
+       /* compare */
        verg= G.curscreen->edgebase.first;
        while(verg) {
                se= verg->next;
@@ -1302,7 +1302,7 @@ static void removenotused_scredges(void)
        ScrArea *sa;
        int a=0;
        
-       /* zet flag als edge gebruikt wordt in area */
+       /* sets flags when edge is used in area */
        sa= G.curscreen->areabase.first;
        while(sa) {
                se= screen_findedge(G.curscreen, sa->v1, sa->v2);
@@ -1359,7 +1359,7 @@ void calc_arearcts(ScrArea *sa)
        }
        if(sa->winrct.ymin>sa->winrct.ymax) sa->winrct.ymin= sa->winrct.ymax;
        
-       /* als speedup voor berekeningen */
+       /* for speedup */
        sa->winx= sa->winrct.xmax-sa->winrct.xmin+1;
        sa->winy= sa->winrct.ymax-sa->winrct.ymin+1;
 }
@@ -1371,7 +1371,7 @@ static void openheadwin(ScrArea *sa)
 
        glMatrixMode(GL_MODELVIEW);
        
-       areawinar[sa->headwin]= sa;     /* anders doet addqueue het niet */
+       areawinar[sa->headwin]= sa;     /* oterwise addqueue does not work */
        addqueue(sa->headwin, CHANGED, 1);
 }
 
@@ -1380,7 +1380,7 @@ static void openareawin(ScrArea *sa)
        sa->win= myswinopen(G.curscreen->mainwin, 
                sa->winrct.xmin, sa->winrct.xmax, sa->winrct.ymin, sa->winrct.ymax);
 
-       areawinar[sa->win]= sa; /* anders doet addqueue het niet */
+       areawinar[sa->win]= sa; /* otherwise addqueue does not work */
        addqueue(sa->win, CHANGED, 1);
 }
 
@@ -1451,8 +1451,8 @@ static void testareas(void)
 {
        ScrArea *sa;
 
-       /* testen of header er moet zijn, of weg moet, of verplaatst */
-       /* testen of window er moet zijn, of weg moet, of verplaatst */
+       /* test for header, if removed, or moved */
+       /* testen for window, if removed, or moved */
 
        for (sa= G.curscreen->areabase.first; sa; sa= sa->next) {
                rcti oldhr= sa->headrct;
@@ -1490,14 +1490,14 @@ static void testareas(void)
                areawinar[sa->win]= sa;
        }
        
-               /* test of winakt in orde is */ 
+               /* test if winakt is OK */      
        if( areawinar[G.curscreen->winakt]==0) G.curscreen->winakt= 0;
 }
 
 static ScrArea *test_edge_area(ScrArea *sa, ScrEdge *se)
 {
-       /* test of edge in area ligt, zo niet, 
-          vind een area die 'm wel heeft */
+       /* test if edge is in area, if not, 
+          then find an area that has it */
   
        ScrEdge *se1=0, *se2=0, *se3=0, *se4=0;
        
@@ -1511,7 +1511,7 @@ static ScrArea *test_edge_area(ScrArea *sa, ScrEdge *se)
                
                sa= G.curscreen->areabase.first;
                while(sa) {
-                       /* een beetje optimaliseren? */
+                       /* a bit optimise? */
                        if(se->v1==sa->v1 || se->v1==sa->v2 || se->v1==sa->v3 || se->v1==sa->v4) {
                                se1= screen_findedge(G.curscreen, sa->v1, sa->v2);
                                se2= screen_findedge(G.curscreen, sa->v2, sa->v3);
@@ -1523,7 +1523,7 @@ static ScrArea *test_edge_area(ScrArea *sa, ScrEdge *se)
                }
        }
 
-       return sa;      /* is keurig 0 als niet gevonden */
+       return sa;      /* is null when not find */
 }
 
 ScrArea *closest_bigger_area(void)
@@ -1543,7 +1543,7 @@ ScrArea *closest_bigger_area(void)
                if(sa!=curarea) {
                        if(sa->winy>=curarea->winy) {
                        
-                               /* mimimum van vier hoekpunten */
+                               /* mimimum of the 4 corners */
                                vec[0]= sa->v1->vec.x; vec[1]= sa->v1->vec.y;
                                len= VecLenf(vec, cent);
                                vec[0]= sa->v2->vec.x; vec[1]= sa->v2->vec.y;
@@ -1555,13 +1555,13 @@ ScrArea *closest_bigger_area(void)
                                
                                len= MIN4(len, len1, len2, len3);
                                
-                               /* plus centrum */
+                               /* plus centre */
                                vec[0]= (sa->v2->vec.x+sa->v3->vec.x)/2;
                                vec[1]= (sa->v1->vec.y+sa->v2->vec.y)/2;
 
                                len+= 0.5*VecLenf(vec, cent);
                                
-                               /* min afmeting */
+                               /* min size */
                                len-= sa->winy+sa->winx;
                                
                                if(len<dist) {
@@ -1577,7 +1577,7 @@ ScrArea *closest_bigger_area(void)
        else return curarea;
 }
 
-/* ************ SCREENBEHEER ************** */
+/* ************ SCREEN MANAGEMENT ************** */
 
 static int statechanged= 0;
 void BIF_wait_for_statechange(void)
@@ -1644,10 +1644,10 @@ void add_to_mainqueue(Window *win, void *user_data, short evt, short val, char a
        mainqenter_ext(evt, val, ascii);
 }
 
-static bScreen *addscreen(char *name)          /* gebruik de setprefsize() als je anders dan fullscreen wilt */
+static bScreen *addscreen(char *name)          /* use setprefsize() if you want something else than a full windpw */
 {
-       /* deze functie zet de variabele G.curscreen
-        * omdat alle hulpfuncties moeten weten welk screen
+       /* this function sets variabele G.curscreen,
+        * that global is about used everywhere!
         */
        bScreen *sc;
        ScrVert *sv1, *sv2, *sv3, *sv4;
@@ -1726,7 +1726,7 @@ void setscreen(bScreen *sc)
        ScrArea *sa;
        short mval[2];
        
-       if(sc->full) {                          /* vind de bijhorende full */
+       if(sc->full) {                          /* find associated full */
                sc1= G.main->screen.first;
                while(sc1) {
                        sa= sc1->areabase.first;
@@ -1739,7 +1739,7 @@ void setscreen(bScreen *sc)
                if(sc1==0) printf("setscreen error\n");
        }
 
-       /* G.curscreen de-activeren */
+       /* de-activate G.curscreen */
        if (G.curscreen && G.curscreen != sc) {
                sa= G.curscreen->areabase.first;
                while(sa) {
@@ -1785,7 +1785,7 @@ void setscreen(bScreen *sc)
                        if (sl->spacetype==SPACE_OOPS) {
                                SpaceOops *soops= (SpaceOops*) sl;
 
-                               /* patch als deze in oude files zit */
+                               /* patch for old files */
                                if (soops->v2d.cur.xmin==soops->v2d.cur.xmax) {
                                        extern void init_v2d_oops(View2D*);
                                        init_v2d_oops(&soops->v2d);
@@ -1805,20 +1805,20 @@ void setscreen(bScreen *sc)
        mainqenter(DRAWEDGES, 1);
        dodrawscreen= 1;                /* patch! even gets lost,,,? */
 
-       winqueue_break= 1;              /* overal uit de queue's gaan */
+       winqueue_break= 1;              /* means leave queue everywhere */
 }
 
 static void splitarea(ScrArea *sa, char dir, float fac);
 
-void area_fullscreen(void)     /* met curarea */
+void area_fullscreen(void)     /* with curarea */
 {
-       /* deze funktie toggelt: als area full is wordt de parent weer zichtbaar */
+       /* this function toggles: if area is full then the parent will be restored */
        bScreen *sc, *oldscreen;
        ScrArea *newa, *old;
        short headertype, fulltype;
        
        if(curarea->full) {
-               sc= curarea->full;      /* de oude screen */
+               sc= curarea->full;      /* the old screen */
                fulltype = sc->full;
 
                // refuse to go out of SCREENAUTOPLAY as long as G_FLAGS_AUTOPLAY
@@ -1827,7 +1827,7 @@ void area_fullscreen(void)        /* met curarea */
                if (fulltype != SCREENAUTOPLAY || (G.flags & G_FLAGS_AUTOPLAY) == 0) {
                        sc->full= 0;
                
-                       /* vind oude area */
+                       /* find old area */
                        old= sc->areabase.first;
                        while(old) {
                                if(old->full) break;
@@ -1858,7 +1858,7 @@ void area_fullscreen(void)        /* met curarea */
                
        }
        else {
-               /* is er maar 1 area? */
+               /* is there only 1 area? */
                if(G.curscreen->areabase.first==G.curscreen->areabase.last) return;
                if(curarea->spacetype==SPACE_INFO) return;
                
@@ -1866,16 +1866,16 @@ void area_fullscreen(void)      /* met curarea */
                
                old= curarea;           
                oldscreen= G.curscreen;
-               sc= addscreen("temp");          /* deze zet G.curscreen */
+               sc= addscreen("temp");          /* this sets G.curscreen */
 
                splitarea( (ScrArea *)sc->areabase.first, 'h', 0.99);
                newa= sc->areabase.first;
                newspace(newa->next, SPACE_INFO);
                
                curarea= old;
-               G.curscreen= oldscreen; /* moet voor setscreen */
+               G.curscreen= oldscreen; /* needed because of setscreen */
                
-               /* area kopieeren */
+               /* vopy area */
                copy_areadata(newa, curarea);
                
                curarea->full= oldscreen;
@@ -1911,12 +1911,12 @@ static void area_autoplayscreen(void)
                        
                        old= curarea;           
                        oldscreen= G.curscreen;
-                       sc= addscreen("temp");          /* deze zet G.curscreen */
+                       sc= addscreen("temp");          /* this sets G.curscreen */
        
                        newa= sc->areabase.first;
                        
                        curarea= old;
-                       G.curscreen= oldscreen; /* moet voor setscreen */
+                       G.curscreen= oldscreen; /* because of setscreen */
                        
                        /* copy area settings */
                        copy_areadata(newa, curarea);
@@ -1937,10 +1937,10 @@ static void copy_screen(bScreen *to, bScreen *from)
        ScrEdge *se;
        ScrArea *sa;
        ListBase lbase;
-       
-       /* alles van to vrijgeven */
+
+       /* free 'to' */
        free_screen(to);
-       winqueue_break= 1;      /* overal uit queue's gaan */
+       winqueue_break= 1;      /* leave queues everywhere */
        
        duplicatelist(&to->vertbase, &from->vertbase);
        duplicatelist(&to->edgebase, &from->edgebase);
@@ -1978,7 +1978,7 @@ static void copy_screen(bScreen *to, bScreen *from)
                sa= sa->next;
        }
        
-       /* op nul zetten (nodig?) */
+       /* put at zero (needed?) */
        s1= from->vertbase.first;
        while(s1) {
                s1->newv= 0;
@@ -1992,10 +1992,10 @@ void duplicate_screen(void)
        
        if(G.curscreen->full != SCREENNORMAL) return;
        
-       /* nieuw screen maken: */
+       /* make new screen: */
 
        oldscreen= G.curscreen;
-       sc= addscreen(oldscreen->id.name+2);    /* deze zet G.curscreen */
+       sc= addscreen(oldscreen->id.name+2);    /* this sets G.curscreen */
        copy_screen(sc, oldscreen);
 
        G.curscreen= oldscreen;
@@ -2004,7 +2004,7 @@ void duplicate_screen(void)
 }
 
 
-/* ************ END SCREENBEHEER ************** */
+/* ************ END SCREEN MANAGEMENT ************** */
 /* ************  JOIN/SPLIT/MOVE ************** */
 
 static void joinarea(ScrArea *sa, ScrEdge *onedge)
@@ -2017,8 +2017,8 @@ static void joinarea(ScrArea *sa, ScrEdge *onedge)
        sa= test_edge_area(sa, onedge);
        if (sa==0) return;
 
-       /* welke edges kunnen ermee? */
-       /* vind richtingen met zelfde edge */
+       /* which edges? */
+       /* find directions with same edge */
        sa2= G.curscreen->areabase.first;
        while(sa2) {
                if(sa2 != sa) {
@@ -2052,7 +2052,7 @@ static void joinarea(ScrArea *sa, ScrEdge *onedge)
        
        
        if(sa2) {
-               /* nieuwe area is oude sa */
+               /* new area is old sa */
                if(sa2==left) {
                        sa->v1= sa2->v1;
                        sa->v2= sa2->v2;
@@ -2078,7 +2078,7 @@ static void joinarea(ScrArea *sa, ScrEdge *onedge)
                        screen_addedge(G.curscreen, sa->v3, sa->v4);
                }
        
-               /* edge en area weg */
+               /* remove edge and area */
                /* remlink(&G.curscreen->edgebase, setest); */
                /* freeN(setest); */
                del_area(sa2);
@@ -2087,7 +2087,7 @@ static void joinarea(ScrArea *sa, ScrEdge *onedge)
                
                removedouble_scredges();
                removenotused_scredges();
-               removenotused_scrverts();       /* moet als laatste */
+               removenotused_scrverts();       /* as last */
                
                testareas();
                mainqenter(DRAWEDGES, 1);
@@ -2097,16 +2097,16 @@ static void joinarea(ScrArea *sa, ScrEdge *onedge)
 }
 
 static short testsplitpoint(ScrArea *sa, char dir, float fac)
-/* return 0: geen split mogelijk */
-/* else return (integer) screencoordinaat splitpunt */
+/* return 0: no split possible */
+/* else return (integer) screencoordinate split point */
 {
        short x, y;
        
-       /* area groot genoeg? */
+       /* area big enough? */
        if(sa->v4->vec.x- sa->v1->vec.x <= 2*AREAMINX) return 0;
        if(sa->v2->vec.y- sa->v1->vec.y <= 2*AREAMINY) return 0;
 
-       /* voor zekerheid */
+       /* to be sure */
        if(fac<0.0) fac= 0.0;
        if(fac>1.0) fac= 1.0;
        
@@ -2152,54 +2152,54 @@ static void splitarea(ScrArea *sa, char dir, float fac)
        areawinset(sa->win);
        
        if(dir=='h') {
-               /* nieuwe vertices */
+               /* new vertices */
                sv1= screen_addvert(sc, sa->v1->vec.x, split);
                sv2= screen_addvert(sc, sa->v4->vec.x, split);
                
-               /* nieuwe edges */
+               /* new edges */
                screen_addedge(sc, sa->v1, sv1);
                screen_addedge(sc, sv1, sa->v2);
                screen_addedge(sc, sa->v3, sv2);
                screen_addedge(sc, sv2, sa->v4);
                screen_addedge(sc, sv1, sv2);
                
-               /* nieuwe areas: boven */
+               /* new areas: top */
                newa= screen_addarea(sc, sv1, sa->v2, sa->v3, sv2, sa->headertype, sa->spacetype);
                copy_areadata(newa, sa);
 
-               /* area onder */
+               /* area below */
                sa->v2= sv1;
                sa->v3= sv2;
                
        }
        else {
-               /* nieuwe vertices */
+               /* new vertices */
                sv1= screen_addvert(sc, split, sa->v1->vec.y);
                sv2= screen_addvert(sc, split, sa->v2->vec.y);
                
-               /* nieuwe edges */
+               /* new edges */
                screen_addedge(sc, sa->v1, sv1);
                screen_addedge(sc, sv1, sa->v4);
                screen_addedge(sc, sa->v2, sv2);
                screen_addedge(sc, sv2, sa->v3);
                screen_addedge(sc, sv1, sv2);
                
-               /* nieuwe areas: links */
+               /* new areas: left */
                newa= screen_addarea(sc, sa->v1, sa->v2, sv2, sv1, sa->headertype, sa->spacetype);
                copy_areadata(newa, sa);
 
-               /* area rechts */
+               /* area right */
                sa->v1= sv1;            
                sa->v2= sv2;
        }
        
-       /* dubbele vertices en edges verwijderen */
+       /* remove double vertices en edges */
        removedouble_scrverts();
        removedouble_scredges();
        removenotused_scredges();
        
        mainqenter(DRAWEDGES, 1);
-       dodrawscreen= 1;                /* patch! even gets lost,,,? */
+       dodrawscreen= 1;                /* patch! event gets lost,,,? */
        testareas();
 }
 
@@ -2232,9 +2232,9 @@ static void splitarea_interactive(ScrArea *area, ScrEdge *onedge)
        dir= scredge_is_horizontal(onedge)?'v':'h';
        
        mywinset(G.curscreen->mainwin);
-       /* hoort al goede matrix te hebben */
+       /* should already have a good matrix */
 
-       /* rekening houden met grid en minsize */
+       /* keep track of grid and minsize */
        while(ok==0) {
                getmouseco_sc(mval);
                
@@ -2287,7 +2287,7 @@ static void splitarea_interactive(ScrArea *area, ScrEdge *onedge)
        if(ok==1) {
                splitarea(sa, dir, fac);
                mainqenter(DRAWEDGES, 1);
-               dodrawscreen= 1;                /* patch! even gets lost,,,? */
+               dodrawscreen= 1;                /* patch! event gets lost,,,? */
        }
 }
 
@@ -2335,8 +2335,8 @@ static void select_connected_scredge(bScreen *sc, ScrEdge *edge)
        int oneselected;
        char dir;
        
-       /* select connected, alleen in de juiste richting */
-       /* 'dir' is de richting van de EDGE */
+       /* select connected, only in the right direction */
+       /* 'dir' is the direction of EDGE */
 
        if(edge->v1->vec.x==edge->v2->vec.x) dir= 'v';
        else dir= 'h';
@@ -2371,8 +2371,8 @@ static void select_connected_scredge(bScreen *sc, ScrEdge *edge)
 }
 
 void test_scale_screen(bScreen *sc)
-/* testen of screenvertices vergroot/verkleind moeten worden */
-/* testen of offset nog klopt */
+/* test if screen vertices should be scaled */
+/* also check offset */
 {
        ScrVert *sv=0;
        ScrEdge *se;
@@ -2523,12 +2523,12 @@ static void moveareas(ScrEdge *edge)
                }
        }
 
-       /* nu zijn alle vertices met 'flag==1' degene die verplaatst kunnen worden. */
-       /* we lopen de areas af en testen vrije ruimte met MINSIZE */
+       /* now all verices with 'flag==1' are the ones that can be moved. */
+       /* we check all areas and test for free space with MINSIZE */
        bigger= smaller= 10000;
        sa= G.curscreen->areabase.first;
        while(sa) {
-               if(dir=='h') {  /* als top of down edge select, test hoogte */
+               if(dir=='h') {  /* if top or down edge selected, test height */
                        if(sa->headertype) {
                                headery= HEADERY;
                                areaminy= AREAMINY;
@@ -2540,7 +2540,7 @@ static void moveareas(ScrEdge *edge)
 
                        if(sa->v1->flag && sa->v4->flag) {
                                int y1;
-                               if(sa->v2->vec.y==G.curscreen->sizey-1) /* bovenste edge */
+                               if(sa->v2->vec.y==G.curscreen->sizey-1) /* top edge */
                                        y1= sa->v2->vec.y - sa->v1->vec.y-headery-EDGEWIDTH;
                                else 
                                        y1= sa->v2->vec.y - sa->v1->vec.y-areaminy;
@@ -2548,14 +2548,14 @@ static void moveareas(ScrEdge *edge)
                        }
                        else if(sa->v2->flag && sa->v3->flag) {
                                int y1;
-                               if(sa->v1->vec.y==0)    /* onderste edge */
+                               if(sa->v1->vec.y==0)    /* bottom edge */
                                        y1= sa->v2->vec.y - sa->v1->vec.y-headery-EDGEWIDTH;
                                else
                                        y1= sa->v2->vec.y - sa->v1->vec.y-areaminy;
                                smaller= MIN2(smaller, y1);
                        }
                }
-               else {  /* als left of right edge select, test breedte */
+               else {  /* if left or right edge selected, test width */
                        if(sa->v1->flag && sa->v2->flag) {
                                int x1= sa->v4->vec.x - sa->v1->vec.x-AREAMINX;
                                bigger= MIN2(bigger, x1);
@@ -2602,7 +2602,7 @@ static void moveareas(ScrEdge *edge)
        if (doit==1) {
                for (v1= G.curscreen->vertbase.first; v1; v1= v1->next) {
                        if (v1->flag) {
-                                       /* zo is AREAGRID netjes */
+                                       /* that way a nice AREAGRID  */
                                if((dir=='v') && v1->vec.x>0 && v1->vec.x<G.curscreen->sizex-1) {
                                        v1->vec.x+= delta;
                                        if(delta != bigger && delta != -smaller) v1->vec.x-= (v1->vec.x % AREAGRID);
@@ -2628,7 +2628,7 @@ static void moveareas(ScrEdge *edge)
        
        glDrawBuffer(GL_BACK);
        mainqenter(DRAWEDGES, 1);
-       dodrawscreen= 1;                /* patch! even gets lost,,,? */
+       dodrawscreen= 1;                /* patch! event gets lost,,,? */
 }
 
 static void scrollheader(ScrArea *area)
@@ -2666,8 +2666,8 @@ static void scrollheader(ScrArea *area)
 
 int select_area(int spacetype)
 {
-       /* vanuit editroutines aanroepen, als er meer area's
-        * zijn van type 'spacetype' kan er een area aangegeven worden
+       /* call from edit routines, when there are more areas
+        * of type 'spacetype', you can indicate an area manually
         */
        ScrArea *sa, *sact = NULL;
        int tot=0;
@@ -2789,9 +2789,9 @@ static void drawscredge(ScrEdge *se)
        v1= &(se->v1->vec);
        v2= &(se->v2->vec);
        
-       /* borders screen niet tekenen */
-       /* vanwege resolutie verschillen (PC/SGI files) de linit een
-        * beetje afronden?
+       /* do not draw borders screen© */
+       /* bcause of different framebuffer resoltions (PC/SGI etc files) 
+        * a bit rounding here? should be looked at further...
         */
        se->border= 1;
        if(v1->x<=1 && v2->x<=1) return;