?login_element?

Subversion Repositories NedoOS

Rev

Blame | Last modification | View Log | Download

  1. const int sprhgt=16;
  2. const int sprwid=16;
  3.  
  4. int sprnr,curaddr,spraddr,sprpg;
  5. unsigned char sprite[16][16];
  6. unsigned char tspraddr[16384];
  7. unsigned char foutbuf[16385];
  8. int foutbufpos;
  9. unsigned char *mempos;
  10.  
  11.  
  12. inline void foutflush(void)
  13. {
  14.         int off;
  15.  
  16.         //ЄрсышЎр ъєёърьш яю 256 ёяЁрщЄют
  17.  
  18.         off=256+(sprnr&255)+(sprnr>>8)*768;
  19.  
  20.         tspraddr[off+0  ]=spraddr;
  21.         tspraddr[off+256]=spraddr>>8;
  22.         tspraddr[off+512]=sprpg^0xff; //pg
  23.  
  24.         memcpy(mempos,foutbuf,foutbufpos);
  25.         mempos+=foutbufpos;
  26.  
  27.         foutbufpos=0;
  28. }
  29.  
  30.  
  31.  
  32. inline void wrbyte(unsigned char b)
  33. {
  34.         //BlockWrite(fout,b,1);
  35.         foutbuf[foutbufpos++]=b;
  36.         ++curaddr;
  37. }
  38.  
  39.  
  40.  
  41. inline bool sprisempty(void)
  42. {
  43.         int i,j;
  44.  
  45.         for(i=0;i<16;++i)
  46.         {
  47.                 for(j=0;j<16;++j)
  48.                 {
  49.                         if(sprite[i][j]<16) return false;//transparent_color
  50.                 }
  51.         }
  52.  
  53.         return true;
  54. }
  55.  
  56.  
  57.  
  58. inline bool colisempty(unsigned char col1,unsigned char col2)
  59. {
  60.         return (col1>=16)&&(col2>=16); //transparent_color
  61. }
  62.  
  63.  
  64.  
  65. inline unsigned char coltopixel(unsigned char col1,unsigned char col2)
  66. {
  67.         //transparent_color and $0f = 0!!!
  68.         return ((col1&0x08)<<3) + (col1&0x07) + ((col2&0x08)<<4) + ((col2&0x07)<<3);
  69. }
  70.  
  71.  
  72.  
  73. inline unsigned char coltomask(unsigned char col1,unsigned char col2)
  74. {
  75.         unsigned char mask;
  76.  
  77.         mask=0;
  78.  
  79.         if(col1>=16) mask =0x47;
  80.         if(col2>=16) mask|=0xb8;
  81.  
  82.         return mask;
  83. }
  84.  
  85.  
  86.  
  87. void mksprite(void)
  88. {
  89.         int x,y;
  90.         unsigned char mask,pixel;
  91.         int curscraddr,oldscraddr,scraddrdelta,oldde;
  92.  
  93.         x=6;
  94.  
  95.         oldde=65536; //false value
  96.  
  97.         while(x>=0) //4 layers
  98.         {
  99.                 //start of the layer
  100.                 wrbyte(225); //pop hl
  101.                 oldscraddr=0;
  102.                 curscraddr=0;
  103.  
  104.                 while(x<sprwid) //layer columns
  105.                 {
  106.                         for(y=0;y<16;++y)
  107.                         {
  108.                                 scraddrdelta=curscraddr-oldscraddr;
  109.  
  110.                                 if(!colisempty(sprite[y][x],sprite[y][x+1]))
  111.                                 {
  112.                                         if(scraddrdelta)
  113.                                         {
  114.                                                 if(scraddrdelta!=40)
  115.                                                 {
  116.                                                         if(scraddrdelta!=oldde)
  117.                                                         {
  118.                                                                 if((oldde!=65536) && ((scraddrdelta&0xff00)==(oldde&0xff00)))
  119.                                                                 {//ld e,N
  120.                                                                         wrbyte(30); //ld e,N
  121.                                                                         wrbyte(scraddrdelta);
  122.                                                                 }
  123.                                                                 else
  124.                                                                 {//ld de,N
  125.                                                                         wrbyte(17); //ld de,N
  126.                                                                         wrbyte(scraddrdelta);
  127.                                                                         wrbyte(scraddrdelta>>8);
  128.                                                                 }
  129.  
  130.                                                                 oldde=scraddrdelta;
  131.                                                         }
  132.  
  133.                                                         wrbyte(25); //add hl,de
  134.                                                 }
  135.                                                 else
  136.                                                 {//scraddrdelta=40
  137.                                                         wrbyte(9); //add hl,bc
  138.                                                 }
  139.                                         }
  140.  
  141.                                         oldscraddr=curscraddr;
  142.                                         mask =coltomask (sprite[y][x],sprite[y][x+1]);
  143.                                         pixel=coltopixel(sprite[y][x],sprite[y][x+1]);
  144.  
  145.                                         if(!mask)
  146.                                         {
  147.                                                 if(!pixel)
  148.                                                 {
  149.                                                         wrbyte(112); //ld (hl),b
  150.                                                 }
  151.                                                 else
  152.                                                 {
  153.                                                         wrbyte(54); //ld (hl),N
  154.                                                         wrbyte(pixel);
  155.                                                 }
  156.                                         }
  157.                                         else
  158.                                         {//mask<>0
  159.                                                 wrbyte(126); //ld a,(hl)
  160.                                                 wrbyte(230); //and N
  161.                                                 wrbyte(mask);
  162.  
  163.                                                 if(pixel)
  164.                                                 {
  165.                                                         wrbyte(246); //or N
  166.                                                         wrbyte(pixel);
  167.                                                 }
  168.  
  169.                                                 wrbyte(119); //ld (hl),a
  170.                                         }
  171.  
  172.                                 } //nonempty
  173.  
  174.                                 curscraddr+=40;
  175.                         } //y
  176.  
  177.                         curscraddr=curscraddr-(40*sprhgt)+1;
  178.                         x+=8;
  179.                 } //x in layer
  180.  
  181.                 x=x-sprwid-2;
  182.         } //layers
  183.  
  184.         wrbyte(0xfd); //$fd
  185.         wrbyte(233); //jp (iy)
  186. }
  187.  
  188.  
  189.  
  190. void mkspr_init(int page)
  191. {
  192.         int i,off;
  193.  
  194.         sprnr=0;
  195.         curaddr=0; //todo +$0200?
  196.         sprpg=page; //todo $10?
  197.         foutbufpos=0;
  198.         mempos=mem;
  199.  
  200.         memset(tspraddr,0,sizeof(tspraddr));
  201.  
  202.         for(i=0;i<256*21;++i)
  203.         {
  204.                 off=256+(i&255)+(i>>8)*768;
  205.                 tspraddr[off+0  ]=0;
  206.                 tspraddr[off+256]=0;    //todo $02?
  207.                 tspraddr[off+512]=0xeb; //pg
  208.         }
  209. }
  210.  
  211.  
  212. int mkspr_add(const char *filename, int sprite_slot, FILE * fileOutAsm, int * pageNumCntr)
  213. {
  214.         FILE *fin;
  215.         int i,j,x,y,pp,size,bshift,wdt,hgt,bpp,rle;
  216.         unsigned char *data;
  217.  
  218.         fin=fopen(filename,"rb");//256c 256x256
  219.  
  220.         if(!fin)
  221.         {
  222.                 printf("ERR: Can't open sprite sheet BMP (%s)\n",filename);
  223.                 return -1;
  224.         }
  225.  
  226.         fseek(fin,0,SEEK_END);
  227.         size=ftell(fin);
  228.         fseek(fin,0,SEEK_SET);
  229.         data=(unsigned char*)malloc(size);
  230.         fread(data,size,1,fin);
  231.         fclose(fin);
  232.  
  233.         bshift=read_dword(&data[10]);
  234.         wdt=read_dword(&data[18]);
  235.         hgt=read_dword(&data[22]);
  236.         bpp=read_word (&data[28]);
  237.         rle=read_dword(&data[30]);
  238.        
  239.         if((wdt&15)||(hgt&15))
  240.         {
  241.                 printf("ERR: Width and height should be 16px aligned (%s)\n",filename);
  242.                 free(data);
  243.                 return -1;
  244.         }
  245.  
  246.         if(rle!=0||bpp!=8)
  247.         {
  248.                 printf("ERR: Sprite sheet should be 256 colors uncompressed BMP (%s)\n",filename);
  249.                 free(data);
  250.                 return -1;
  251.         }
  252.  
  253.         /* Code to generate:
  254.         dup 4
  255.         pop hl
  256.         dup ?
  257.         dup ?
  258.         [ld de,N:add hl,de]/[add hl,bc]
  259.         ld (hl),N / ld a,(hl):and N:or N:ld (hl),a
  260.         edup ;bytes
  261.         edup ;columns
  262.         edup ;layers
  263.         jp (iy)
  264.         */
  265.  
  266.         for(y=0;y<hgt;y+=16)
  267.         {
  268.                 for(x=0;x<wdt;x+=16)
  269.                 {
  270.                         if(sprnr>=5376) break;//юъЁєуы╕ээюх (16384/768) *256
  271.  
  272.                         //ъюяшЁютрэшх ёяЁрщЄр шч шчюсЁрцхэш  т сєЇхЁ
  273.  
  274.                         for(i=0;i<16;++i)
  275.                         {
  276.                                 pp=bshift+((hgt-1-(y+i))*wdt)+x;
  277.  
  278.                                 for(j=0;j<16;++j)
  279.                                 {
  280.                                         sprite[i][j]=data[pp++];
  281.                                 }
  282.                         }
  283.  
  284.                         //sprite 16 x 16 (sprwid x sprhgt)
  285.  
  286.                         spraddr=curaddr;
  287.  
  288.                         mksprite();
  289.  
  290.                         if(curaddr<16384)
  291.                         {
  292.                                 foutflush();
  293.                         }
  294.                         else
  295.                         {//page overflow
  296.                                 page_save(sprite_slot,sprpg,"spriteData",*pageNumCntr,fileOutAsm);
  297.                                 mempos=mem;
  298.                                 (*pageNumCntr)++;
  299.                                 ++sprpg;
  300.                                 curaddr=0;//-=spraddr; //todo +$0200?
  301.                                 spraddr=0;
  302.  
  303.                                 foutbufpos=0;
  304.  
  305.                                 mksprite();
  306.                                 foutflush();
  307.                         }
  308.  
  309.                         ++sprnr;
  310.                 }
  311.         }
  312.  
  313.         free(data);
  314.  
  315.         return sprpg;
  316. }
  317.