Demo/InfPlane/infplane.c

   1
   2 #include <dos/dos.h>
   3 #include <intuition/intuition.h>
   4 #include <graphics/gfx.h>
   5 #include <cybergraphx/cybergraphics.h>
   6 #include <proto/exec.h>
   7 #include <proto/dos.h>
   8 #include <proto/graphics.h>
   9 #include <proto/cybergraphics.h>
  10 #include <proto/intuition.h>
  11 #include <aros/macros.h>
  12
  13 #include <math.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <memory.h>
  18
  19
  20 /***********************************************************************************/
  21
  22 struct IntuitionBase    *IntuitionBase;
  23 struct GfxBase          *GfxBase;
  24 struct Library          *CyberGfxBase;
  25 struct Screen           *scr;
  26 struct Window           *win;
  27 struct RastPort         *rp;
  28 ULONG                   cgfx_coltab[256];
  29 UBYTE                   remaptable[256];
  30 UBYTE                   Keys[128];
  31 char                    s[256];
  32 WORD                    winx = -1, winy = -1;
  33 BOOL                    forcescreen, forcewindow;
  34 BOOL                    mustremap, truecolor, remapped, wbscreen = TRUE;
  35
  36 static void cleanup(char *msg);
  37
  38 /***********************************************************************************/
  39
  40 #define C_FUNCTION
  41 /* comment/undefine this define to use the asm routine */
  42
  43 #define W               320
  44 #define H               240
  45
  46 #ifndef M_PI
  47 #define M_PI            3.14159265358979323846  /* pi */
  48 #endif
  49
  50
  51 #define RADIUS 64
  52 #define DIST 256
  53
  54 void do_precalc(float Hp2,                     /* altitude du 2eme plan (1er = 0) (positif...) */
  55                 float Xd, float Yd, float Zd,
  56                 float cx, float cy,  float cz,    /* vecteur de visee central */
  57                 float vx1, float vy1, float vz1, /* vecteur selon X ecran */
  58                 float vx2, float vy2, float vz2 /* vecteur selon Y ecran  */
  59                 );
  60 void refresh1 ();
  61 extern void refresh_prout();   /* eh eh */
  62
  63 float alpha [H/8+1][W/8+1]  ;
  64 float zede [H/8+1][W/8+1] ;
  65
  66 unsigned char *texture1, *buffer, *buffer_remapped;
  67
  68 int ikse [H/8+1][W/8+1]  ;
  69 int igrek [H/8+1][W/8+1] ;
  70
  71 /***********************************************************************************/
  72
  73 void rotate3d(float *xr, float *yr, float *zr,  /* le point a faire tourner */
  74               float ax, float ay, float az)     /* les 3 angles (ordre ?..) */
  75 {
  76   float xr2,yr2,zr2;
  77
  78
  79   xr2= (*xr*cos(az) + *yr*sin(az));
  80   yr2= (*xr*sin(az) - *yr*cos(az));
  81   *xr=xr2;
  82   *yr=yr2;
  83
  84   xr2= (*xr*cos(ay) + *zr*sin(ay));
  85   zr2= (*xr*sin(ay) - *zr*cos(ay));
  86   *xr=xr2;
  87   *zr=zr2;
  88
  89   zr2= (*zr*cos(ax) + *yr*sin(ax));
  90   yr2= (*zr*sin(ax) - *yr*cos(ax));
  91   *zr=zr2;
  92   *yr=yr2;
  93 }
  94
  95 void initinfplane(void)
  96 {
  97   FILE * fichier;
  98   char * c;
  99
 100   /* Chargement de la texture */
 101
 102   c = (char *) malloc ( 256*257 );
 103   buffer = (char *)malloc (W*(H+1));
 104   if (!c || !buffer)
 105     cleanup("Out of memory!");
 106
 107   if (mustremap)
 108   {
 109     buffer_remapped = malloc(W*H);
 110     if (!buffer_remapped)
 111       cleanup("Out of memory!");
 112   }
 113
 114   fichier = fopen ( "pattern.data" , "rb" );
 115   if (!fichier)
 116     cleanup("Can't open pattern.data file!");
 117
 118   if (fread ( c , 1, 256*256 , fichier ) != 256*256)
 119     cleanup("Error reading pattern.data file!");
 120   fclose ( fichier );
 121
 122   /* Open palette */
 123
 124   fichier = fopen ( "pattern.pal" , "rb" );
 125   if (!fichier)
 126   {
 127     fclose(fichier);
 128     cleanup("Can't open pattern.pal file!");
 129   }
 130
 131   if (fread ( cgfx_coltab , 1, 256 * 4 , fichier ) != 256 * 4)
 132   {
 133     fclose(fichier);
 134     cleanup("Error reading pattern.pal file!");
 135   }
 136
 137   fclose ( fichier );
 138
 139   /* Fix palette endianess */
 140
 141 #if !AROS_BIG_ENDIAN
 142   {
 143       int i;
 144
 145       for(i = 0; i < 256; i ++)
 146       {
 147           cgfx_coltab[i] = AROS_LONG2BE(cgfx_coltab[i]);
 148       }
 149   }
 150 #endif
 151
 152   if (!truecolor)
 153   {
 154     WORD i;
 155
 156     for(i = 0; i < 256; i++)
 157     {
 158         ULONG r   = (cgfx_coltab[i] >> 16) & 0xFF;
 159         ULONG g = (cgfx_coltab[i] >> 8) & 0xFF;
 160         ULONG b  = cgfx_coltab[i] & 0xFF;
 161
 162      if (mustremap)
 163      {
 164        ULONG red   = r * 0x01010101;
 165        ULONG green = g * 0x01010101;
 166        ULONG blue  = b * 0x01010101;
 167
 168        remaptable[i] = ObtainBestPen(scr->ViewPort.ColorMap,
 169                                      red,
 170                                      green,
 171                                      blue,
 172                                      OBP_Precision, PRECISION_IMAGE,
 173                                      OBP_FailIfBad, FALSE,
 174                                      TAG_DONE);
 175        remapped = TRUE;
 176      }
 177      else
 178      {
 179
 180        ULONG red   = r * 0x01010101;
 181        ULONG green = g * 0x01010101;
 182        ULONG blue  = b * 0x01010101;
 183
 184        SetRGB32(&scr->ViewPort, i, red, green, blue);
 185      }
 186     }
 187   }
 188
 189   texture1 = (unsigned char *) c;
 190
 191 }
 192
 193 void do_precalc(float Hp2,
 194                 float Xd, float Yd, float Zd,
 195                 float cx, float cy,  float cz,    /* vecteur de visee central */
 196                 float vx1, float vy1, float vz1, /* vecteur selon X ecran */
 197                 float vx2, float vy2, float vz2 /* vecteur selon Y ecran  */
 198                 )
 199 {
 200   int i,j;
 201   float t;
 202   float x,y,z;
 203
 204
 205   /* euh hem, tjours le meme probleme qd X ou Y arrivent a 65536... */
 206
 207
 208   vx1/=W/8.0;
 209   vy1/=W/8.0;
 210   vz1/=W/8.0;
 211
 212   vx2/=H/8.0;
 213   vy2/=H/8.0;
 214   vz2/=H/8.0;
 215
 216
 217   for (j=0; j<=H/8; j++)
 218     {
 219       x = cx   - vx1*W/16 +   (j - H/16)*vx2;
 220       y = cy   - vy1*W/16 +   (j - H/16)*vy2;
 221       z = cz   - vz1*W/16 +   (j - H/16)*vz2;
 222
 223       for (i=0; i<=W/8; i++)
 224       {
 225
 226         x+=vx1;
 227         y+=vy1;
 228         z+=vz1;
 229
 230
 231         if (z <=0.001)        /* look downward ? */
 232           {
 233
 234             t= -Zd/z;
 235
 236             ikse [j][i]= (int)256*(Xd+x*t);
 237             igrek[j][i]= (int)256*(Yd+y*t);
 238
 239           }
 240         else if (z >=0.001)  /* look at the sky => 2nd plane */
 241           {
 242             t= (Hp2-Zd)/z;
 243
 244             ikse [j][i]= (int)256*(Xd+x*t);
 245             igrek[j][i]= (int)256*(Yd+y*t);
 246
 247           }
 248         else             /* look infinite */
 249           {
 250             ikse [j][i]= -1;                    /* C'est une valeur completement idiote */
 251             igrek[j][i]= -1;
 252           }
 253
 254       }
 255     }
 256
 257 }
 258
 259
 260 void refresh1 () {
 261   int i,j;    /* macro-bloc */
 262   int ii,jj;  /* dans bloc (interpolation) */
 263   int a,ai, z,zi;      /* 8-8 (fixed-point = lsb) (/pixel)*/
 264
 265   int a0,a0i, z0,z0i;
 266   int a1,a1i, z1,z1i;
 267   int a2,a3,z2,z3;
 268
 269   unsigned char *tmp,*tmp1;
 270
 271
 272   for (j=0; j<H/8; j++)
 273     for (i=0; i<W/8; i++)
 274       {
 275         a0=ikse[j][i];
 276         a1=ikse[j][i+1];
 277         a2=ikse[j+1][i];
 278         a3=ikse[j+1][i+1];
 279
 280         z0=igrek[j][i]     ;
 281         z1=igrek[j][i+1]   ;
 282         z2=igrek[j+1][i]   ;
 283         z3=igrek[j+1][i+1] ;
 284
 285         a0i=( a2   - a0) /8;
 286         z0i=( z2   - z0)  /8;
 287
 288
 289         a1i=(  a3  - a1) /8;
 290         z1i=(  z3  - z1)  /8;
 291
 292
 293
 294
 295         tmp1= (unsigned char *)buffer + i*8 + (j*8)*W-W;
 296         for (jj=8; jj; jj--)
 297           {
 298             tmp=tmp1+=W;
 299
 300             a=a0;
 301             z=z0;
 302             ai = (a1-a0) >>3;
 303             zi = (z1-z0) >>3;
 304
 305             for (ii=8; ii; ii--)
 306               {
 307                 * ( tmp++ ) = * ( texture1  +
 308                                   ( ((a>>8)&255)   |
 309                                     ((z) & (255<<8))
 310                                   )
 311                                 ) ;
 312                 a+=ai;
 313                 z+=zi;
 314               }
 315           /* unrolling loop... just to see if it improves things
 316           (it does a bit) */
 317
 318 /*
 319             * ( tmp++ ) = * ( texture1  +
 320                                   ((((a+=ai)>>8)&255)
 321                                   | (((z+=zi)) & (255<<8))  )) ;
 322             * ( tmp++ ) = * ( texture1  +
 323                                   ((((a+=ai)>>8)&255)
 324                                   | (((z+=zi)) & (255<<8))  )) ;
 325             * ( tmp++ ) = * ( texture1  +
 326                                   ((((a+=ai)>>8)&255)
 327                                   | (((z+=zi)) & (255<<8))  )) ;
 328             * ( tmp++ ) = * ( texture1  +
 329                                   ((((a+=ai)>>8)&255)
 330                                   | (((z+=zi)) & (255<<8))  )) ;
 331             * ( tmp++ ) = * ( texture1  +
 332                                   ((((a+=ai)>>8)&255)
 333                                   | (((z+=zi)) & (255<<8))  )) ;
 334             * ( tmp++ ) = * ( texture1  +
 335                                   ((((a+=ai)>>8)&255)
 336                                   | (((z+=zi)) & (255<<8))  )) ;
 337             * ( tmp++ ) = * ( texture1  +
 338                                   ((((a+=ai)>>8)&255)
 339                                   | (((z+=zi)) & (255<<8))  )) ;
 340             * ( tmp++ ) = * ( texture1  +
 341                                   ((((a+=ai)>>8)&255)
 342                                   | (((z+=zi)) & (255<<8))  )) ;
 343         */
 344
 345             a0+=a0i;
 346             z0+=z0i;
 347
 348             a1+=a1i;
 349             z1+=z1i;
 350
 351           }
 352       }
 353
 354 }
 355
 356 /***********************************************************************************/
 357
 358 static void cleanup(char *msg)
 359 {
 360
 361     if (msg)
 362     {
 363         printf("InfPlane: %s\n",msg);
 364     }
 365
 366     if (win) CloseWindow(win);
 367
 368     if (remapped)
 369     {
 370         WORD i;
 371
 372         for(i = 0; i < 256; i++)
 373         {
 374             ReleasePen(scr->ViewPort.ColorMap, remaptable[i]);
 375         }
 376     }
 377
 378     if (scr)
 379     {
 380         if (wbscreen)
 381             UnlockPubScreen(0, scr);
 382         else
 383             CloseScreen(scr);
 384     }
 385
 386     if (CyberGfxBase) CloseLibrary(CyberGfxBase);
 387     if (GfxBase) CloseLibrary((struct Library *)GfxBase);
 388     if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
 389
 390     exit(0);
 391 }
 392
 393 /***********************************************************************************/
 394
 395 #define ARG_TEMPLATE "WINPOSX=X/N/K,WINPOSY=Y/N/K,FORCESCREEN=SCR/S,FORCEWINDOW=WIN/S"
 396 #define ARG_X 0
 397 #define ARG_Y 1
 398 #define ARG_SCR 2
 399 #define ARG_WIN 3
 400 #define NUM_ARGS 4
 401
 402 static IPTR args[NUM_ARGS];
 403
 404 static void getarguments(void)
 405 {
 406     struct RDArgs *myargs;
 407
 408     if ((myargs = ReadArgs(ARG_TEMPLATE, args, NULL)))
 409     {
 410         if (args[ARG_SCR])
 411             forcescreen = TRUE;
 412         else if (args[ARG_WIN])
 413             forcewindow = TRUE;
 414
 415         if (args[ARG_X]) winx = *(IPTR *)args[ARG_X];
 416         if (args[ARG_Y]) winy = *(IPTR *)args[ARG_Y];
 417
 418         FreeArgs(myargs);
 419     }
 420 }
 421
 422 /***********************************************************************************/
 423
 424 static void openlibs(void)
 425 {
 426     if (!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library", 39)))
 427     {
 428         cleanup("Can't open intuition.library V39!");
 429     }
 430
 431     if (!(GfxBase = (struct GfxBase *)OpenLibrary("graphics.library", 39)))
 432     {
 433         cleanup("Can't open graphics.library V39!");
 434     }
 435
 436     if (!(CyberGfxBase = OpenLibrary("cybergraphics.library",0)))
 437     {
 438         cleanup("Can't open cybergraphics.library!");
 439     }
 440 }
 441
 442
 443 /***********************************************************************************/
 444
 445 static void getvisual(void)
 446 {
 447     if (!(scr = LockPubScreen(NULL)))
 448     {
 449         cleanup("Can't lock pub screen!");
 450     }
 451
 452     if (GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH) <= 8)
 453     {
 454         if (!forcewindow)
 455         {
 456             wbscreen = FALSE;
 457         }
 458         else
 459         {
 460             mustremap = TRUE;
 461         }
 462     }
 463
 464     if (forcescreen) wbscreen = FALSE;
 465
 466     if (!wbscreen)
 467     {
 468         UnlockPubScreen(NULL, scr);
 469         wbscreen = FALSE;
 470
 471         scr = OpenScreenTags(NULL, SA_Width     , W     ,
 472                                    SA_Height    , H     ,
 473                                    SA_Depth     , 8     ,
 474                                    TAG_DONE);
 475         if (!scr) cleanup("Can't open screen!");
 476     }
 477
 478     truecolor = (GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH) >= 15) ? TRUE : FALSE;
 479 }
 480
 481 /***********************************************************************************/
 482
 483 static void makewin(void)
 484 {
 485     struct TagItem winonwbtags[] =
 486     {
 487         {WA_DragBar     , TRUE              },
 488         {WA_DepthGadget , TRUE              },
 489         {WA_CloseGadget , TRUE              },
 490         {WA_Title       , (IPTR)"InfPlane"  },
 491         {TAG_DONE                           }
 492     };
 493
 494     struct TagItem winonscrtags[] =
 495     {
 496         {WA_Borderless, TRUE },
 497         {TAG_DONE            }
 498     };
 499
 500     if (winx == -1) winx = (scr->Width - W - scr->WBorLeft - scr->WBorRight) / 2;
 501     if (winy == -1) winy = (scr->Height - H - scr->WBorTop - scr->WBorTop - scr->Font->ta_YSize - 1) / 2;
 502
 503     win = OpenWindowTags(NULL, WA_CustomScreen  , (IPTR)scr,
 504                                WA_Left          , winx,
 505                                WA_Top           , winy,
 506                                WA_InnerWidth    , W,
 507                                WA_InnerHeight   , H,
 508                                WA_AutoAdjust    , TRUE,
 509                                WA_Activate      , TRUE,
 510                                WA_IDCMP         , IDCMP_CLOSEWINDOW |
 511                                                   IDCMP_RAWKEY,
 512                                TAG_MORE         , wbscreen ? winonwbtags : winonscrtags);
 513
 514
 515    if (!win) cleanup("Can't open window");
 516
 517    rp = win->RPort;
 518 }
 519
 520 /***********************************************************************************/
 521
 522 #define KC_LEFT         0x4F
 523 #define KC_RIGHT        0x4E
 524 #define KC_UP           0x4C
 525 #define KC_DOWN         0x4D
 526 #define KC_ESC          0x45
 527
 528 /***********************************************************************************/
 529
 530 static void getevents(void)
 531 {
 532     struct IntuiMessage *msg;
 533
 534     while ((msg = (struct IntuiMessage *)GetMsg(win->UserPort)))
 535     {
 536         switch(msg->Class)
 537         {
 538             case IDCMP_CLOSEWINDOW:
 539                 Keys[KC_ESC] = 1;
 540                 break;
 541
 542             case IDCMP_RAWKEY:
 543                 {
 544                     WORD code = msg->Code & ~IECODE_UP_PREFIX;
 545
 546                     Keys[code] = (code == msg->Code) ? 1 : 0;
 547
 548                 }
 549                 break;
 550
 551         }
 552         ReplyMsg((struct Message *)msg);
 553     }
 554
 555 }
 556
 557 /***********************************************************************************/
 558
 559 static void action(void)
 560 {
 561   float Xd,Yd,Zd;
 562   float dzz=0;
 563   float aa=0,thet=0;
 564
 565
 566
 567   float ax,ay,az;
 568
 569   float cx,cy,cz;      /* vecteur  visee */
 570   float exx,exy,exz;   /* vecteur ex normal */
 571   float eyx,eyy,eyz;   /* ey */
 572
 573   initinfplane();
 574
 575   /* Boucle */
 576
 577   Xd=Yd=0;
 578   ax=ay=az=0;
 579
 580   /* Init FPS */
 581
 582   //init_fps ();
 583
 584   /* Boucle */
 585
 586   while (!Keys[KC_ESC])
 587   {
 588       getevents();
 589
 590      aa+=0.006;
 591     thet+=0.008203;
 592
 593
 594     if (aa>1){             /* this is the "keyframing" code :)) */
 595       if (aa<2.45)
 596         ax+=0.0261;
 597       else
 598         {
 599           ax+=0.0061;
 600           ay+=0.0033;
 601           az+=0.0018;
 602         }
 603     }
 604
 605     /* rotate view */
 606     cx=0.3; cy=0; cz=0;
 607     exx=0; exy=1; exz=0;
 608     eyx=0; eyy=0; eyz=1;
 609
 610     rotate3d(&cx, &cy, &cz,
 611              ax,ay,az);
 612     rotate3d(&exx, &exy, &exz,
 613              ax,ay,az);
 614     rotate3d(&eyx, &eyy, &eyz,
 615              ax,ay,az);
 616
 617
 618
 619     Zd=10*sin(dzz/70)*0.9+30;
 620     Yd=dzz+sin(aa*0.1-thet*0.2)*700;
 621     dzz+=1.5;
 622     Xd=dzz*2;
 623
 624
 625     /*Xd=Yd=0;
 626     //Zd=10; */
 627     do_precalc(240,
 628                Xd,Yd,Zd,
 629                cx,cy,cz,
 630                exx,exy,exz,
 631                eyx,eyy,eyz
 632                );
 633
 634
 635 #ifdef C_FUNCTION
 636     refresh1 ();                  /* la routine en C */
 637 #else
 638     refresh_prout ();           /* ma routine asm */
 639 #endif
 640
 641     if (truecolor)
 642     {
 643         WriteLUTPixelArray(buffer,
 644                            0,
 645                            0,
 646                            W,
 647                            rp,
 648                            cgfx_coltab,
 649                            win->BorderLeft,
 650                            win->BorderTop,
 651                            W,
 652                            H,
 653                            CTABFMT_XRGB8);
 654     }
 655     else if (mustremap)
 656     {
 657         LONG i;
 658         UBYTE *src = buffer;
 659         UBYTE *dest = buffer_remapped;
 660
 661         for(i = 0; i < W * H; i++)
 662         {
 663             *dest++ = remaptable[*src++];
 664         }
 665         WriteChunkyPixels(rp,
 666                           win->BorderLeft,
 667                           win->BorderTop,
 668                           win->BorderLeft + W - 1,
 669                           win->BorderTop + H - 1,
 670                           buffer_remapped,
 671                           W);
 672
 673     }
 674     else
 675     {
 676         WriteChunkyPixels(rp,
 677                           win->BorderLeft,
 678                           win->BorderTop,
 679                           win->BorderLeft + W - 1,
 680                           win->BorderTop + H - 1,
 681                           buffer,
 682                           W);
 683     }
 684
 685     WaitTOF();
 686
 687     //update_x ();
 688     //next_fps();
 689
 690   }
 691
 692   /* Aff FPS */
 693
 694   //aff_fps (NAME);
 695
 696 }
 697
 698 /***********************************************************************************/
 699
 700 int main(void)
 701 {
 702     getarguments();
 703     openlibs();
 704     getvisual();
 705     makewin();
 706     action();
 707     cleanup(0);
 708
 709     return 0;
 710 }
 711
 712 /***********************************************************************************/
 713