Return to frame.c CVS log

Up to [Research Unix] / researchv10no / cmd / view2d / term

Annotation of researchv10no/cmd/view2d/term/frame.c, revision 1.1.1.1

1.1       root        1: #include       <CC/jerq.h>
                      2: #include       "frame.pri"
                      3: #include       "camera.pub"
                      4: 
                      5: Hcoord direct(short, short, short);
                      6: 
                      7: #define        Z(x,y)  data[(x)+m->nx*(y)]
                      8: #define        SEG(x1,y1,x2,y2)        {if((Z(x1,y1)>m->floor)&&(Z(x2,y2)>m->floor))seg(x1,y1,x2,y2);}
                      9: 
                     10: void
                     11: Frame.view(short vlat, short vlon, short vdist, short valat, short valon, short vpersp)
                     12: {
                     13:        register i;
                     14: 
                     15:        if((vlat != lat) || (vlon != lon) || (vdist != dist) || (valat != alat)
                     16:                || (valon != alon) || (vpersp != persp))
                     17:        {
                     18:                lat = vlat;
                     19:                lon = vlon;
                     20:                dist = vdist;
                     21:                alat = valat;
                     22:                alon = valon;
                     23:                persp = vpersp;
                     24:                draw();
                     25:        }
                     26:        show();
                     27: }
                     28: 
                     29: void
                     30: Frame.draw()
                     31: {
                     32:        register x, y;
                     33: 
                     34:        transdata();
                     35:        rectf(b, b->rect, F_CLR);
                     36:        for(y = 0; y < m->ny; y++)
                     37:        {
                     38:                for(x = 0; x < m->nx; x++)
                     39:                {
                     40:                        if(y) SEG(x, y-1, x, y);
                     41:                        if(x) SEG(x-1, y, x, y);
                     42:                }
                     43:                wait(CPU);
                     44:        }
                     45: }
                     46: 
                     47: void
                     48: Frame.show()
                     49: {
                     50:        bitblt(b, b->rect, &display, m->ctr, F_STORE);
                     51: }
                     52: 
                     53: void
                     54: Frame.rd(int n)
                     55: {
                     56:        register short *s;
                     57:        extern int getn();
                     58: 
                     59:        alon = -1;
                     60:        gets(time);
                     61:        s = data = (short *)alloc(n*2);
                     62:        while(n--)
                     63:                *s++ = getn();
                     64:        b = balloc(m->bound);
                     65: }
                     66: /*
                     67:        the data will always fall in the cube 1000*1000*1000
                     68:        centered at the origin
                     69: */
                     70: 
                     71: #define                SCALE           1000
                     72: 
                     73: void
                     74: Frame.transdata()
                     75: {
                     76:        register x, y;
                     77:        register Hcoord *h;
                     78:        short *d;
                     79:        int scaly;
                     80:        int scale = max(m->nx, m->ny)-1;
                     81:        Hcoord e = direct(lat, lon, dist*SCALE/100);
                     82:        Hcoord l = direct(alat, alon, ONE*2);
                     83:        extern long vscale;
                     84: 
                     85:        init3(b, 1, 1);
                     86:        look3(e, l, Hcoord((l.x == 0) && (l.y == 0), 0, 1, 1));
                     87:        clip3scale = (1-persp)*SCALE;
                     88:        scaly = muldiv(SCALE/2, vscale, 32768);
                     89:        h = (Hcoord *)m->tdata;
                     90:        for(y = 0, d = data; y < m->ny; y++)
                     91:                for(x = 0; x < m->nx; x++, h++)
                     92:                {
                     93:                        *h = Hcoord(muldiv(x, SCALE, scale)-SCALE/2,
                     94:                                muldiv(y, SCALE, scale)-SCALE/2,
                     95:                                muldiv(*d++, scaly, 32768), 1);
                     96:                }
                     97: }
                     98: 
                     99: void
                    100: Frame.seg(short x1, short y1, short x2, short y2)
                    101: {
                    102:        register Hcoord *h = (Hcoord *)m->tdata;
                    103: 
                    104:        move3(h[x1+y1*m->nx]);
                    105:        line3(h[x2+y2*m->nx]);
                    106: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.