?login_element?

Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  1. //---------------------------------------------------------------------------
  2.  
  3. #include <vcl.h>
  4. #include <math.h>
  5. #pragma hdrstop
  6.  
  7. #include "nedodefs.h"
  8.  
  9. #include "Unit1.h"
  10. //---------------------------------------------------------------------------
  11. #pragma package(smart_init)
  12. #pragma resource "*.dfm"
  13.  
  14. #define FLOAT int
  15.  
  16. #define SQRTFIXK 256L
  17. #define FIXK (SQRTFIXK*SQRTFIXK)
  18.  
  19. #define spheres 2
  20. FLOAT cx[spheres] = {
  21.         (FLOAT)(-30*FIXK/100), (FLOAT)(90*FIXK/100)
  22. };
  23. FLOAT cy[spheres] = {
  24.         (FLOAT)(-80*FIXK/100), (FLOAT)(-110*FIXK/100)
  25. };
  26. FLOAT cz[spheres] = {
  27.         (FLOAT)(300*FIXK/100), (FLOAT)(200*FIXK/100)
  28. };
  29. FLOAT r[spheres] = {(FLOAT)(60*FIXK/100), (FLOAT)(20*FIXK/100)};
  30. FLOAT q[spheres];
  31.  
  32.     FLOAT projx[spheres];
  33.     FLOAT projy[spheres];
  34.     FLOAT projr[spheres];
  35.  
  36. TForm1 *Form1;
  37. //---------------------------------------------------------------------------
  38. __fastcall TForm1::TForm1(TComponent* Owner)
  39.         : TForm(Owner)
  40. {
  41. }
  42. //---------------------------------------------------------------------------
  43.  
  44. FLOAT umul(FLOAT a,FLOAT b)
  45. {
  46.   RETURN ((a>>8) * (b>>8));
  47. }
  48.  
  49. FLOAT mul(FLOAT a,FLOAT b)
  50. {
  51.   FLOAT res;
  52.   FLOAT ia;
  53.   FLOAT ib;
  54.   ia = a;
  55.   ib = b;
  56.   IF (ia < 0 /*>= 0x80000000L*/) {ia = -ia;};
  57.   IF (ib < 0 /*>= 0x80000000L*/) {ib = -ib;};
  58.   res = umul(ia, ib);
  59.   IF ((a^b) < 0 /*>= 0x80000000L*/) {res = -res;};
  60.   RETURN res;
  61. }
  62.  
  63. FLOAT udiv(FLOAT a,FLOAT b)
  64. {
  65.   FLOAT ib;
  66.   ib = b>>8;///SQRTFIXK;
  67.   if (ib == 0L) {
  68.     ib = 1L;
  69.   };
  70.   RETURN ((a / ib)<<8/**SQRTFIXK*/);
  71. }
  72.  
  73. FLOAT idiv(FLOAT a,FLOAT b)
  74. {
  75.   FLOAT res;
  76.   FLOAT ia;
  77.   FLOAT ib;
  78.   ia = a;
  79.   ib = b;
  80.   IF (ia < 0 /*>= 0x80000000L*/) {ia = -ia;};
  81.   IF (ib < 0 /*>= 0x80000000L*/) {ib = -ib;};
  82.   res = udiv(ia, ib);
  83.   IF ((a^b) < 0 /*>= 0x80000000L*/) {res = -res;};
  84.   RETURN res;
  85. }
  86.  
  87. FLOAT add(FLOAT a,FLOAT b)
  88. {
  89.   RETURN (a + b);
  90. }
  91.  
  92. FLOAT mul2(FLOAT a)
  93. {
  94.   RETURN add(a,a);
  95. }
  96.  
  97. FLOAT sub(FLOAT a,FLOAT b)
  98. {
  99.   RETURN (a - b);
  100. }
  101.  
  102. FLOAT neg(FLOAT a)
  103. {
  104.   RETURN (-a);
  105. }
  106.  
  107. UINT lsqrt(FLOAT arg)
  108. {
  109.   BYTE count=0x10;
  110.   UINT res=0;
  111.   UINT tmp=0;
  112.   IF (arg!=0L) {
  113. /*    IF (!(arg&0xFF000000L)) {
  114.       arg = arg<<8;
  115.       count-=4;
  116.     };*/
  117.     res = 1;
  118.     WHILE ((tmp<1)&&(count!=0x00)){
  119.       DEC count;
  120.       IF (arg&0x80000000L) {tmp|=2;};
  121.       IF (arg&0x40000000L) {tmp|=1;};
  122.       arg = arg << 2L;
  123.     };//яюшёъ яхЁтющ 1-√
  124.     DEC tmp;
  125.  
  126.     WHILE (count!=0x00) {
  127.       tmp = tmp << 2;
  128.       res = res + res; //res << 1;
  129.       DEC count;
  130.       IF (arg&0x80000000L) {tmp = tmp | 2;};
  131.       IF (arg&0x40000000L) {tmp = tmp | 1;};
  132.       arg = arg << 2L;
  133.       IF (tmp >= ((res<<1)|1)) {
  134.         tmp = tmp - ((res<<1)|1);
  135.         res = res | 1;
  136.       };
  137.     };
  138.   };
  139.   RETURN res;
  140. }
  141.  
  142. FLOAT root(FLOAT a)
  143. {
  144.   RETURN ((FLOAT)lsqrt(a)*SQRTFIXK);
  145. }
  146.  
  147. FLOAT fract(FLOAT a)
  148. {
  149.   RETURN ( a & (FIXK/2) /*!= 0L*/ );
  150. }
  151.  
  152. BOOL positive(FLOAT a)
  153. {
  154.   RETURN (a >= 0 /*< 0x80000000L*/);
  155. }
  156.  
  157. BOOL less(FLOAT a, FLOAT b)
  158. {
  159.   RETURN ((unsigned int)a < (unsigned int)b);
  160. }
  161.  
  162.  
  163. void TForm1::prhex(AnsiString name, int a)
  164. {
  165.   AnsiString s = "";
  166.   AnsiString sc = " ";
  167.   char c;
  168.   for (int i = 0; i < 8; i++) {
  169.     c = (a & 0x0f) + '0';
  170.     if (c>=('0'+10)) c = c+'a'-('0'+10);
  171.     sc[1] = c;
  172.     s = sc + s;
  173.     a = a >> 4;
  174.   };
  175.   Memo1->Lines->Add(name+s);
  176. }
  177.  
  178. PROC TForm1::tracepixel(int i,int j)
  179. {
  180.   BYTE n;
  181.   BYTE k;
  182.   FLOAT s;
  183.   FLOAT px;
  184.   FLOAT py;
  185.   FLOAT pz;
  186.   FLOAT sc;
  187.   FLOAT aa;
  188.   FLOAT bb;
  189.   FLOAT pp;
  190.   FLOAT nx;
  191.   FLOAT ny;
  192.   FLOAT nz;
  193.   FLOAT nn;
  194.   FLOAT u;
  195.   FLOAT v;
  196.   FLOAT l;
  197.  
  198.   FLOAT x;
  199.   FLOAT y;
  200.   FLOAT z;
  201.   FLOAT dx;
  202.   FLOAT dy;
  203.   FLOAT dz;
  204.   FLOAT dd;
  205.  
  206. #define GROUND 0xfe
  207. #define SKY 0xff
  208. #define EYEX (FLOAT)(30*FIXK/100)
  209. #define EYEY (FLOAT)(-50*FIXK/100)
  210. #define EYEZ (FLOAT)(0*FIXK/100)
  211.  
  212.   x = EYEX;
  213.   y = EYEY;
  214.   z = EYEZ;
  215. #define KVECTOR 64L
  216. //  dx = (FLOAT)((FLOAT)(j-128)*FIXK/KVECTOR);
  217. //  dy = (FLOAT)((FLOAT)(88-i)*FIXK/KVECTOR);
  218. //  dz = (FLOAT)((FLOAT)(300)*FIXK/KVECTOR);
  219.  
  220. #define MULVECTOR 0x0400L
  221.   dx = mul(((FLOAT)(j)-(FLOAT)(128))*FIXK, MULVECTOR);
  222.   dy = mul(((FLOAT)(88)-(FLOAT)(i))*FIXK, MULVECTOR);
  223.   dz = mul((FLOAT)(256)*FIXK, MULVECTOR);
  224.   //prhex("dx=",dx);
  225.   //prhex("dy=",dy);
  226.   //prhex("dz=",dz);
  227.  
  228.   dd = add(mul(dx,dx),add(mul(dy,dy),mul(dz,dz))); //dx*dx+dy*dy+dz*dz;
  229.   //prhex("dx*dx=",mul(dx,dx));
  230.   //prhex("dy*dy=",mul(dy,dy));
  231.   //prhex("dz*dz=",mul(dz,dz));
  232.   //prhex("dd=",dd);
  233.  
  234. L100:
  235.   IF (positive(y) || !positive(dy)) {
  236.     n = SKY;
  237.     s = 0x7fffffffL;
  238.   }ELSE {
  239.     n = GROUND;
  240.     s = neg(idiv(y, dy)); //-y/dy; //???
  241.   };
  242.   //prhex("s=",s);
  243.  
  244.   k = 0x00;
  245.   REPEAT { //ш∙хь ёЇхЁє, эр ъюЄюЁє■ ёьюЄЁшь (хёыш хёЄ№)
  246.     px = sub(cx[k], x); //c[k][0]-x;
  247.     //prhex("px=",px);
  248.     py = sub(cy[k], y); //c[k][1]-y;
  249.     //prhex("py=",py);
  250.     pz = sub(cz[k], z); //c[k][2]-z;
  251.     //prhex("pz=",pz);
  252.  
  253. #define FIXX 256
  254. #define SCRX (((FLOAT)(j)-(FLOAT)(128))*FIXX)
  255. #define SCRY (((FLOAT)(88)-(FLOAT)(i))*FIXX)
  256.     IF (!(
  257.         (SCRX >= sub(projx[k],projr[k]))
  258.       &&(SCRX < add(projx[k],projr[k]))
  259.       &&(SCRY >= sub(projy[k],projr[k]))
  260.       &&(SCRY < add(projy[k],projr[k]))
  261. //      &&((i^j)&1)
  262.        )) {
  263.       //Image1->Canvas->Pixels[j][175-i] = 0xff7fff;
  264.       goto L200; //эх Єр ёЇхЁр
  265.       //goto RETURNME;
  266.     };
  267.  
  268.     pp = add(mul(px,px),add(mul(py,py),mul(pz,pz))); //px*px+py*py+pz*pz;
  269.   //prhex("px*px=",mul(px,px));
  270.   //prhex("py*py=",mul(py,py));
  271.   //prhex("pz*pz=",mul(pz,pz));
  272.     //prhex("pp=",pp);
  273.     sc = add(mul(px,dx),add(mul(py,dy),mul(pz,dz))); //px*dx+py*dy+pz*dz;
  274.     //prhex("sc=",sc);
  275.     IF (!positive(sc)) {
  276.       goto L200; //эх Єр ёЇхЁр
  277.     };
  278.     bb = idiv(mul(sc,sc),dd); //sc*sc/dd;
  279.     //prhex("bb=",bb);
  280.     aa = q[k]-pp+bb; //add(sub(q[k],pp),bb); //q[k]-pp+bb;
  281.     //prhex("aa=",aa);
  282.     IF (!positive(aa)) {
  283.       goto L200; //эх Єр ёЇхЁр
  284.     };
  285.     sc = idiv(sub(root(bb),root(aa)),root(dd)); //(sqrt(bb)-sqrt(aa))/sqrt(dd);
  286.     //prhex("scp=",sub(root(bb),root(aa)));
  287.     //prhex("scq=",root(dd));
  288.     //prhex("sc=",sc);
  289. //    IF (less(sc,s) /*|| (n >= 0x80)*/) { //эр°ыш ёЇхЁє
  290.       n = k;
  291.       s = sc;
  292.       goto LFOUND;
  293. //    };
  294. L200:
  295.     INC k;
  296.   }UNTIL (k == spheres);
  297.   IF (n == SKY) {goto RETURNME;}; //эхсю
  298. LFOUND:
  299. //    Image1->Canvas->Pixels[j][175-i] = 0x007fff;
  300. //    goto RETURNME;
  301.   dx = mul(dx,s); //dx*s;
  302.   dy = mul(dy,s); //dy*s;
  303.   dz = mul(dz,s); //dz*s;
  304.   //prhex("dx=",dx);
  305.   //prhex("dy=",dy);
  306.   //prhex("dz=",dz);
  307.   dd = mul(dd,mul(s,s)); //dd*s*s;
  308.   //prhex("dd=",dd);
  309.   x = add(x,dx);  //x+dx;
  310.   y = add(y,dy); //y+dy;
  311.   z = add(z,dz); //z+dz;
  312.   IF (n == GROUND) {goto L300;}; //чхьы 
  313.   nx = sub(x,cx[n]); //x-c[n][0];
  314.   ny = sub(y,cy[n]); //y-c[n][1];
  315.   nz = sub(z,cz[n]); //z-c[n][2];
  316.   nn = add(mul(nx,nx),add(mul(ny,ny),mul(nz,nz))); //nx*nx+ny*ny+nz*nz;
  317.   //prhex("nn=",nn);
  318.   l = idiv(mul2(add(mul(dx,nx),add(mul(dy,ny),mul(dz,nz)))),nn); //2*(dx*nx+dy*ny+dz*nz)/nn;
  319.   //prhex("l=",l);
  320.   dx = sub(dx,mul(nx,l)); //dx-nx*l;
  321.   dy = sub(dy,mul(ny,l)); //dy-ny*l;
  322.   dz = sub(dz,mul(nz,l)); //dz-nz*l;
  323.   //prhex("dx=",dx);
  324.   //prhex("dy=",dy);
  325.   //prhex("dz=",dz);
  326.   goto L100; //юЄЁрцхэшх
  327.  
  328. L300: //чхьы 
  329.   k = 0x00;
  330.   REPEAT {
  331.     u = sub(cx[k],x); //c[k][0]-x;
  332.     v = sub(cz[k],z); //c[k][2]-z;
  333.     IF (add(mul(u,u),mul(v,v)) <= q[k]) {goto RETURNME;};  //(u*u+v*v)
  334.     INC k;
  335.   }UNTIL (k == spheres);
  336.   IF (fract(x) != fract(z)) {Image1->Canvas->Pixels[j][175-i] = 0xffffff;};   //((x+100)-(int)(x+100))  //(z-(int)(z))
  337. RETURNME:
  338. }
  339.  
  340. void __fastcall TForm1::FormCreate(TObject *Sender)
  341. {
  342.   BYTE i;
  343.   BYTE j;
  344.   BYTE k;
  345.  
  346.   k = 0x00;
  347.   REPEAT {
  348.     q[k] = mul(r[k],r[k]); //r[k]*r[k];
  349.     INC k;
  350.   }UNTIL (k == spheres);
  351.  
  352.   k = 0x00;
  353.   REPEAT {
  354.     projx[k] = idiv(sub(cx[k],EYEX), sub(cz[k],EYEZ));
  355.     projy[k] = idiv(sub(cy[k],EYEY), sub(cz[k],EYEZ));
  356.     projr[k] = idiv(r[k]*17/16, sub(cz[k],EYEZ)); //сюы№°х, яюЄюьє ўЄю "сюъ" ёЇхЁ√ ЄюЁўшЄ чр яЁюхъЎш■
  357.   prhex("projx=",projx[k]);
  358.   prhex("projy=",projy[k]);
  359.   prhex("projr=",projr[k]);
  360.     INC k;
  361.   }UNTIL (k == spheres);
  362.  
  363.   i = 0x00;
  364.   REPEAT {
  365.     j = 0x00;
  366.     REPEAT {
  367.       Image1->Canvas->Pixels[j][175-i] = 0x000000;
  368.       tracepixel(i,j);
  369.       INC j;
  370.     }UNTIL (j == (BYTE)255);
  371.     INC i;
  372.   }UNTIL (i == (BYTE)175);
  373.  
  374.   cx[0] = cx[0]+(FLOAT)(10*FIXK/100);
  375.   cz[1] = cz[1]+(FLOAT)(30*FIXK/100);
  376.  
  377.   Memo1->Lines->Add(IntToStr(0x100000000000000 >> 16));
  378.  
  379. }
  380. //---------------------------------------------------------------------------
  381.