Репозиторий Sisyphus
Последнее обновление: 1 октября 2023 | Пакетов: 18631 | Посещений: 37517205
en ru br
Репозитории ALT

Группа :: Игры/Аркады
Пакет: fachoda

 Главная   Изменения   Спек   Патчи   Sources   Загрузить   Gear   Bugs and FR  Repocop 

Патч: fachoda-2.1-alt-e2k-nested-func.patch
Скачать


commit 4fa6b5643d4bd5377514f0b8f6b551fb6b79ed32
Author: Alexey Appolonov <alexey@altlinux.org>
Date:   Tue Oct 3 20:04:38 2017 +0300
    Nested function 'void trapeze(struct polymap_inner_data* d, dy)' converted to external function 'void trapeze(struct polymap_inner_data* d, dy)'
diff --git a/fachoda/src/mapping.c b/fachoda/src/mapping.c
index 28002ff..62ebdbf 100644
--- a/fachoda/src/mapping.c
+++ b/fachoda/src/mapping.c
@@ -35,60 +35,70 @@ void initmapping(void)
     mapping = malloc(256*256*sizeof(*mapping));
 }
 
-void polymap(struct vect2dm *p1, struct vect2dm *p2, struct vect2dm *p3) {
-    struct vect2dm *tmp, *pmax, *pmin;
+struct polymap_inner_data{
     int xi, yi, lx, i, ilim;
-    int q1, q2, q3=0, ql, qx, qxx, ql2;
+    int q1, q2, q3, ql, qx, qxx, ql2;
     int ix, iy;
-    int qmx1, qmx2, qmx3=0, qmy1, qmy2, qmy3=0, qmxx, qmyy, qmx, qmy;
+    int qmx1, qmx2, qmx3, qmy1, qmy2, qmy3, qmxx, qmyy, qmx, qmy;
     int *vid;
     int xm, ym;
-    void trapeze (int dy) {
-        int xxm, yym;
-        if (yi<0) {
-            if (yi<-dy) {
-                yi+=dy;
-                xi+=dy*qx;
-                lx+=dy*ql;
-                xm+=dy*qmx;
-                ym+=dy*qmy;
-                return;
-            } else {
-                xi-=yi*qx;
-                lx-=yi*ql;
-                xm-=yi*qmx;
-                ym-=yi*qmy;
-                dy+=yi;
-                yi=0;
-            }
+    };
+
+void trapeze (struct polymap_inner_data* d, int dy) {
+    int xxm, yym;
+    if (d->yi<0) {
+        if (d->yi<-dy) {
+            d->yi+=dy;
+            d->xi+=dy*d->qx;
+            d->lx+=dy*d->ql;
+            d->xm+=dy*d->qmx;
+            d->ym+=dy*d->qmy;
+            return;
         }
-        vid=(int*)videobuffer+yi*win_width;
-        while (dy>0 && yi<win_height) {
-            i=xi>>vf; ilim=i+(lx>>vf);
-            if (ilim>=win_width) ilim=win_width-1;
-            xxm=xm;
-            yym=ym;
-            if (i<0) {
-                xxm-=i*ix;
-                yym-=i*iy;
-                i=0;
-            }
-            if (i<ilim) {
-                do {
-                    vid[i]=*((int*)mapping+((xxm>>vf)&0xFF)+((yym>>(vf-8))&0xFF00));
-                    i++;
-                    xxm+=ix; yym+=iy;
-                } while (i<=ilim);
-            }
-            xi+=qx;
-            lx+=ql;
-            xm+=qmx;
-            ym+=qmy;
-            vid+=win_width;
-            dy--;
-            yi++;
+        else {
+            d->xi-=d->yi*d->qx;
+            d->lx-=d->yi*d->ql;
+            d->xm-=d->yi*d->qmx;
+            d->ym-=d->yi*d->qmy;
+            dy+=d->yi;
+            d->yi=0;
         }
-    };
+    }
+    d->vid=(int*)videobuffer+d->yi*win_width;
+    while (dy>0 && d->yi<win_height) {
+        d->i=(d->xi)>>vf; d->ilim=d->i+((d->lx)>>vf);
+        if (d->ilim>=win_width) d->ilim=win_width-1;
+        xxm=d->xm;
+        yym=d->ym;
+        if (d->i<0) {
+            xxm-=d->i*d->ix;
+            yym-=d->i*d->iy;
+            d->i=0;
+        }
+        if (d->i<d->ilim) {
+            do {
+                (d->vid)[d->i]=*((int*)mapping+((xxm>>vf)&0xFF)+((yym>>(vf-8))&0xFF00));
+                d->i++;
+                xxm+=d->ix; yym+=d->iy;
+            } while (d->i<=d->ilim);
+        }
+        d->xi+=d->qx;
+        d->lx+=d->ql;
+        d->xm+=d->qmx;
+        d->ym+=d->qmy;
+        d->vid+=win_width;
+        dy--;
+        d->yi++;
+    }
+}
+
+void polymap(struct vect2dm *p1, struct vect2dm *p2, struct vect2dm *p3) {
+    struct vect2dm *tmp, *pmax, *pmin;
+    struct polymap_inner_data d;
+    d.q3=d.qmx3=d.qmy3=0;
+
+    // Function "void trapeze (int dy)" was nested here
+
     if (p2->v.y<p1->v.y) { tmp=p1; p1=p2; p2=tmp; }
     if (p3->v.y<p1->v.y) { tmp=p1; p1=p3; p3=tmp; }
     if (p3->v.y<p2->v.y) { tmp=p2; p2=p3; p3=tmp; }
@@ -100,108 +110,108 @@ void polymap(struct vect2dm *p1, struct vect2dm *p2, struct vect2dm *p3) {
     if (p2->v.x<pmin->v.x) pmin=p2;
     if (p3->v.x<pmin->v.x) pmin=p3;
     if (pmin->v.x>win_width) return;
-    yi=p1->v.y;
+    d.yi=p1->v.y;
     if (p1->v.y!=p2->v.y) {
-        xi=p1->v.x<<vf;
-        xm=p1->mx<<vf;
-        ym=p1->my<<vf;
-        q1=((p2->v.x-p1->v.x)<<vf)/(p2->v.y-p1->v.y);
-        qmx1=(((int)(p2->mx-p1->mx))<<vf)/(p2->v.y-p1->v.y);
-        qmy1=(((int)(p2->my-p1->my))<<vf)/(p2->v.y-p1->v.y);
-        q2=((p3->v.x-p1->v.x)<<vf)/(p3->v.y-p1->v.y);
-        qmx2=(((int)(p3->mx-p1->mx))<<vf)/(p3->v.y-p1->v.y);
-        qmy2=(((int)(p3->my-p1->my))<<vf)/(p3->v.y-p1->v.y);
+        d.xi=p1->v.x<<vf;
+        d.xm=p1->mx<<vf;
+        d.ym=p1->my<<vf;
+        d.q1=((p2->v.x-p1->v.x)<<vf)/(p2->v.y-p1->v.y);
+        d.qmx1=(((int)(p2->mx-p1->mx))<<vf)/(p2->v.y-p1->v.y);
+        d.qmy1=(((int)(p2->my-p1->my))<<vf)/(p2->v.y-p1->v.y);
+        d.q2=((p3->v.x-p1->v.x)<<vf)/(p3->v.y-p1->v.y);
+        d.qmx2=(((int)(p3->mx-p1->mx))<<vf)/(p3->v.y-p1->v.y);
+        d.qmy2=(((int)(p3->my-p1->my))<<vf)/(p3->v.y-p1->v.y);
         if (p3->v.y-p2->v.y) {
-            q3=((p3->v.x-p2->v.x)<<vf)/(p3->v.y-p2->v.y);
-            qmx3=(((int)(p3->mx-p2->mx))<<vf)/(p3->v.y-p2->v.y);
-            qmy3=(((int)(p3->my-p2->my))<<vf)/(p3->v.y-p2->v.y);
+            d.q3=((p3->v.x-p2->v.x)<<vf)/(p3->v.y-p2->v.y);
+            d.qmx3=(((int)(p3->mx-p2->mx))<<vf)/(p3->v.y-p2->v.y);
+            d.qmy3=(((int)(p3->my-p2->my))<<vf)/(p3->v.y-p2->v.y);
         }
-        lx = vfm;
-        if (q1<=q2) {
-            if(!(ql=q2-q1)) ql=1;       // le taux d'accroissement de la taille du segment (en Иvitant 0);
-            if(!(ql2=q2-q3)) ql2=-1;
-            qx=q1; qxx=q3;
-            qmx=qmx1; qmy=qmy1; qmxx=qmx3; qmyy=qmy3;
+        d.lx = vfm;
+        if (d.q1<=d.q2) {
+            if(!(d.ql=d.q2-d.q1)) d.ql=1;       // le taux d'accroissement de la taille du segment (en ц╘vitant 0);
+            if(!(d.ql2=d.q2-d.q3)) d.ql2=-1;
+            d.qx=d.q1; d.qxx=d.q3;
+            d.qmx=d.qmx1; d.qmy=d.qmy1; d.qmxx=d.qmx3; d.qmyy=d.qmy3;
             if (p2->v.y-p1->v.y>p3->v.y-p2->v.y) {
 #define QLPREC (vfm/4)
-                if (ql>QLPREC) {
-                    ix=((qmx2-qmx1)<<vf)/ql;
-                    iy=((qmy2-qmy1)<<vf)/ql;
-                } else ix=iy=0;
+                if (d.ql>QLPREC) {
+                    d.ix=((d.qmx2-d.qmx1)<<vf)/d.ql;
+                    d.iy=((d.qmy2-d.qmy1)<<vf)/d.ql;
+                } else d.ix=d.iy=0;
             } else {
-                if (ql2<-QLPREC) {
-                    ix=((qmx2-qmx3)<<vf)/ql2;
-                    iy=((qmy2-qmy3)<<vf)/ql2;
-                } else ix=iy=0;
+                if (d.ql2<-QLPREC) {
+                    d.ix=((d.qmx2-d.qmx3)<<vf)/d.ql2;
+                    d.iy=((d.qmy2-d.qmy3)<<vf)/d.ql2;
+                } else d.ix=d.iy=0;
             }
         } else {
-            if (!(ql=q1-q2)) ql=1;
-            if (!(ql2=q3-q2)) ql2=-1;
-            qx=qxx=q2;
-            qmx=qmxx=qmx2; qmy=qmyy=qmy2;
+            if (!(d.ql=d.q1-d.q2)) d.ql=1;
+            if (!(d.ql2=d.q3-d.q2)) d.ql2=-1;
+            d.qx=d.qxx=d.q2;
+            d.qmx=d.qmxx=d.qmx2; d.qmy=d.qmyy=d.qmy2;
             if (p2->v.y-p1->v.y>p3->v.y-p2->v.y) {
-                if (ql>QLPREC) {
-                    ix=((qmx1-qmx2)<<vf)/ql;
-                    iy=((qmy1-qmy2)<<vf)/ql;
-                } else ix=iy=0;
+                if (d.ql>QLPREC) {
+                    d.ix=((d.qmx1-d.qmx2)<<vf)/d.ql;
+                    d.iy=((d.qmy1-d.qmy2)<<vf)/d.ql;
+                } else d.ix=d.iy=0;
             } else {
-                if (ql2<-QLPREC) {
-                    ix=((qmx3-qmx2)<<vf)/ql2;
-                    iy=((qmy3-qmy2)<<vf)/ql2;
-                } else ix=iy=0;
+                if (d.ql2<-QLPREC) {
+                    d.ix=((d.qmx3-d.qmx2)<<vf)/d.ql2;
+                    d.iy=((d.qmy3-d.qmy2)<<vf)/d.ql2;
+                } else d.ix=d.iy=0;
             }
         }
     //  MMXGouroPreca(ib,ig,ir);
-        trapeze(p2->v.y-p1->v.y);
-        qx=qxx; ql=ql2;
-        qmx=qmxx; qmy=qmyy;
-        trapeze(p3->v.y-p2->v.y+1);
+        trapeze(&d, p2->v.y-p1->v.y);
+        d.qx=d.qxx; d.ql=d.ql2;
+        d.qmx=d.qmxx; d.qmy=d.qmyy;
+        trapeze(&d, p3->v.y-p2->v.y+1);
     } else {
         if (p3->v.y>p2->v.y) {
-            q2=((p3->v.x-p1->v.x)<<vf)/(p3->v.y-p1->v.y);
-            qmx2=(((int)(p3->mx-p1->mx))<<vf)/(p3->v.y-p1->v.y);
-            qmy2=(((int)(p3->my-p1->my))<<vf)/(p3->v.y-p1->v.y);
-            q3=((p3->v.x-p2->v.x)<<vf)/(p3->v.y-p2->v.y);
-            qmx3=(((int)(p3->mx-p2->mx))<<vf)/(p3->v.y-p2->v.y);
-            qmy3=(((int)(p3->my-p2->my))<<vf)/(p3->v.y-p2->v.y);
+            d.q2=((p3->v.x-p1->v.x)<<vf)/(p3->v.y-p1->v.y);
+            d.qmx2=(((int)(p3->mx-p1->mx))<<vf)/(p3->v.y-p1->v.y);
+            d.qmy2=(((int)(p3->my-p1->my))<<vf)/(p3->v.y-p1->v.y);
+            d.q3=((p3->v.x-p2->v.x)<<vf)/(p3->v.y-p2->v.y);
+            d.qmx3=(((int)(p3->mx-p2->mx))<<vf)/(p3->v.y-p2->v.y);
+            d.qmy3=(((int)(p3->my-p2->my))<<vf)/(p3->v.y-p2->v.y);
             if (p2->v.x>=p1->v.x) {
-                xi=p1->v.x<<vf;
-                xm=p1->mx<<vf;
-                ym=p1->my<<vf;
-                lx = (p2->v.x-p1->v.x)<<vf;
-                if(!(ql=q3-q2)) ql=-1;
-                qx=q2;
-                qmx=qmx2; qmy=qmy2;
-                if (ql<-QLPREC) {
-                    ix=((qmx3-qmx2)<<vf)/ql;
-                    iy=((qmy3-qmy2)<<vf)/ql;
-                } else ix=iy=0;
+                d.xi=p1->v.x<<vf;
+                d.xm=p1->mx<<vf;
+                d.ym=p1->my<<vf;
+                d.lx = (p2->v.x-p1->v.x)<<vf;
+                if(!(d.ql=d.q3-d.q2)) d.ql=-1;
+                d.qx=d.q2;
+                d.qmx=d.qmx2; d.qmy=d.qmy2;
+                if (d.ql<-QLPREC) {
+                    d.ix=((d.qmx3-d.qmx2)<<vf)/d.ql;
+                    d.iy=((d.qmy3-d.qmy2)<<vf)/d.ql;
+                } else d.ix=d.iy=0;
             } else {
-                xi=p2->v.x<<vf;
-                xm=p2->mx<<vf;
-                ym=p2->my<<vf;
-                lx = (p1->v.x-p2->v.x)<<vf;
-                if(!(ql=q2-q3)) ql=-1;
-                qx=q3;
-                qmx=qmx3; qmy=qmy3;
-                if (ql<-QLPREC) {
-                    ix=((qmx2-qmx3)<<vf)/ql;
-                    iy=((qmy2-qmy3)<<vf)/ql;
-                } else ix=iy=0;
+                d.xi=p2->v.x<<vf;
+                d.xm=p2->mx<<vf;
+                d.ym=p2->my<<vf;
+                d.lx = (p1->v.x-p2->v.x)<<vf;
+                if(!(d.ql=d.q2-d.q3)) d.ql=-1;
+                d.qx=d.q3;
+                d.qmx=d.qmx3; d.qmy=d.qmy3;
+                if (d.ql<-QLPREC) {
+                    d.ix=((d.qmx2-d.qmx3)<<vf)/d.ql;
+                    d.iy=((d.qmy2-d.qmy3)<<vf)/d.ql;
+                } else d.ix=d.iy=0;
             }
         //  MMXGouroPreca(ib,ig,ir);
-            trapeze(p3->v.y-p1->v.y+1);
+            trapeze(&d, p3->v.y-p1->v.y+1);
         } else {
-            xi=pmin->v.x<<vf;
-            if(!(lx=(pmax->v.x-pmin->v.x)<<vf)) lx=vfm;
-            xm=pmin->mx<<vf;
-            ym=pmin->my<<vf;
-            if (lx>QLPREC) {
-                ix=(pmax->mx-pmin->mx)<<vf/lx;
-                iy=(pmax->my-pmin->my)<<vf/lx;
-            } else ix=iy=0;
+            d.xi=pmin->v.x<<vf;
+            if(!(lx=(pmax->v.x-pmin->v.x)<<vf)) d.lx=vfm;
+            d.xm=pmin->mx<<vf;
+            d.ym=pmin->my<<vf;
+            if (d.lx>QLPREC) {
+                d.ix=(pmax->mx-pmin->mx)<<vf/d.lx;
+                d.iy=(pmax->my-pmin->my)<<vf/d.lx;
+            } else d.ix=d.iy=0;
         //  MMXGouroPreca(ib,ig,ir);
-            trapeze(1);
+            trapeze(&d, 1);
         }
     }
 }
@@ -219,7 +229,7 @@ void polyphong(struct vect2dlum *p1, struct vect2dlum *p2, struct vect2dlum *p3,
     if (p1->v.y==p2->v.y && p1->v.x>p2->v.x) { tmp=p1; p1=p2; p2=tmp; }
     if (p3->v.y<0 || p1->v.y>win_height) return;
 
-//  if (p1->v.y==p2->v.y) p1->v.y--;    // de l'avantage d'une grosse rИzo...
+//  if (p1->v.y==p2->v.y) p1->v.y--;    // de l'avantage d'une grosse rц╘zo...
 //  if (p3->v.y==p2->v.y) p3->v.y++;
 
     yi=p1->v.y; y=p1->yl<<vf;
@@ -263,7 +273,7 @@ void polyphong(struct vect2dlum *p1, struct vect2dlum *p2, struct vect2dlum *p3,
 
     if (q1<=q2) {
         int p3x,p3y;
-        ql = (q2-q1)|1;     // le taux d'accroissement de la taille du segment (en Иvitant 0);
+        ql = (q2-q1)|1;     // le taux d'accroissement de la taille du segment (en ц╘vitant 0);
         ql2= (q3-q1)|1;
         qx=qx2=q1;
         if (q2==MAXINT && p3->v.y!=p2->v.y) {
 
дизайн и разработка: Vladimir Lettiev aka crux © 2004-2005, Andrew Avramenko aka liks © 2007-2008
текущий майнтейнер: Michael Shigorin