Advertisement
Siapran

m7sprites.c

Oct 2nd, 2011
399
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 12.10 KB | None | 0 0
  1. #include "m7sprites.h"
  2.  
  3. #if ENABLE_SKY == 1
  4. extern unsigned char SkyChange;
  5. #endif
  6.  
  7. unsigned char LoadedSpritesSlots[NBSPRT];
  8. LoadedSprite tabLoadedSprite[NBSPRT];
  9.  
  10. unsigned char AddedSprites[MAXSPRT];
  11. Sprite * AllSpriteList[MAXSPRT];
  12. unsigned char nbDisplayedSprites;
  13. DisplayedSprite * DisplayedSpriteList[MAXSPRT];
  14. DisplayedSprite * Displayed1stSpriteList[MAXSPRT];
  15.  
  16. void m7sprites_Init()
  17. {
  18.     register short i;
  19.     for(i=0;i<NBSPRT;i++)
  20.         LoadedSpritesSlots[i] = 0;
  21.     for(i=0;i<MAXSPRT;i++)
  22.     {
  23.         AddedSprites[i] = 0;
  24.         AllSpriteList[i] = NULL;
  25.         DisplayedSpriteList[i] = NULL;
  26.         Displayed1stSpriteList[i] = NULL;
  27.     }
  28.     nbDisplayedSprites = 0;
  29. }
  30.  
  31. short m7sprites_LoadSprite(ARCH * arch, const char * fileName)
  32. {
  33.     register unsigned short i;
  34.     short slot;
  35.     short cumul=0;
  36.     ARCH * spriteFile;
  37.  
  38.     for (i=0;(i<NBSPRT) && (LoadedSpritesSlots[i]);i++);
  39.     if (i == NBSPRT) return -1;
  40.     slot = i;  
  41.     spriteFile = aopen(arch, fileName);
  42.     if (spriteFile == NULL) return -1;
  43.    
  44.     aseek (spriteFile, 2, SEEK_SET);
  45.     aread (&(tabLoadedSprite[slot].NbScales), sizeof(short), 1, spriteFile);
  46.     aread (&(tabLoadedSprite[slot].NbImg), sizeof(short), 1, spriteFile);
  47.     aread (&(tabLoadedSprite[slot].NbAnim), sizeof(short), 1, spriteFile);
  48.     aread (&(tabLoadedSprite[slot].NbDir), sizeof(short), 1, spriteFile);
  49.  
  50.     tabLoadedSprite[slot].NbImgAnim = (unsigned short *)malloc(sizeof(short) * tabLoadedSprite[slot].NbAnim);
  51.     tabLoadedSprite[slot].ScaledSizes = (unsigned short *)malloc(sizeof(short) * 2 * tabLoadedSprite[slot].NbScales);
  52.  
  53.     aread ((tabLoadedSprite[slot].NbImgAnim), sizeof(short), tabLoadedSprite[slot].NbAnim, spriteFile);
  54.     aread ((tabLoadedSprite[slot].ScaledSizes), sizeof(short), 2 * tabLoadedSprite[slot].NbScales, spriteFile);
  55.  
  56.     for (i=0; i<tabLoadedSprite[slot].NbAnim; i++)
  57.         cumul += tabLoadedSprite[slot].NbImgAnim[i];
  58.  
  59.     cumul *= 2 * tabLoadedSprite[slot].NbDir;
  60.    
  61.  
  62.     tabLoadedSprite[slot].Data = (unsigned char *)malloc(sizeof(unsigned char) * cumul);
  63.  
  64.     aread ((tabLoadedSprite[slot].Data), sizeof(unsigned char), cumul, spriteFile);
  65.    
  66.     cumul = 0;
  67.    
  68.     for(i=0; i<tabLoadedSprite[slot].NbScales; i++)
  69.     {
  70.         cumul += tabLoadedSprite[slot].ScaledSizes[i*2] * tabLoadedSprite[slot].ScaledSizes[i*2 + 1];
  71.     }
  72.  
  73.     cumul *= tabLoadedSprite[slot].NbImg;
  74.  
  75.     tabLoadedSprite[slot].ImgData = (unsigned char *)malloc(sizeof(unsigned char) * cumul);
  76.     aread ((tabLoadedSprite[slot].ImgData), sizeof(unsigned char), cumul, spriteFile);
  77.     LoadedSpritesSlots[slot] = 1;
  78.    
  79.     aclose (spriteFile);
  80.     return slot;
  81.    
  82. }
  83.  
  84. void m7sprites_FreeSprite(unsigned short slot)
  85. {
  86.     free (tabLoadedSprite[slot].NbImgAnim);
  87.     free (tabLoadedSprite[slot].ScaledSizes);
  88.     free (tabLoadedSprite[slot].Data);
  89.     free (tabLoadedSprite[slot].ImgData);
  90.     LoadedSpritesSlots[slot] = 0;
  91. }
  92.  
  93.  
  94. void m7sprites_FreeAllSprite()
  95. {
  96.     register unsigned short i;
  97.     for (i=0; i<NBSPRT; i++)
  98.         if (LoadedSpritesSlots[i])
  99.             m7sprites_FreeSprite(i);
  100. }
  101.  
  102. short m7sprite_SearchFirstID()
  103. {
  104.     register unsigned short i;
  105.    
  106.     for (i=0; i<MAXSPRT; i++)
  107.     {
  108.         if (AddedSprites[i] == 0)
  109.             return i;
  110.     }
  111.     return -1;
  112. }
  113.  
  114. short m7sprites_AddSprite(unsigned short slot)
  115. {
  116.     Sprite * sprite;
  117.     short id = m7sprite_SearchFirstID();
  118.    
  119.     if (id == -1)
  120.         return -1;
  121.  
  122.     sprite = (Sprite *)malloc(sizeof(Sprite));
  123.     sprite->id = id;
  124.     sprite->x = 0;
  125.     sprite->y = 0;
  126.     sprite->z = 0;
  127.     sprite->dir = 0;
  128.     sprite->anim = 0;
  129.     sprite->imganim = 0;
  130.     sprite->slot = slot;
  131.     sprite->nbScales = tabLoadedSprite[slot].NbScales;
  132.    
  133.     AllSpriteList[id] = sprite;
  134.     AddedSprites[id] = 1;
  135.    
  136.     return id;
  137. }
  138.  
  139. short m7sprites_Add1stSprite(unsigned short slot)
  140. {
  141.     short id = m7sprites_AddSprite(slot);
  142.     if (id == -1)
  143.         return -1;
  144.     AddedSprites[id] = 2;
  145.  
  146.     return id;
  147. }
  148.  
  149.  
  150. void m7sprites_RemoveSprite(unsigned short id)
  151. {
  152.     free (AllSpriteList[id]);
  153.     AddedSprites[id] = 0;
  154. }
  155.  
  156. void m7sprites_RemoveAllSprites()
  157. {
  158.     register unsigned short i;
  159.    
  160.     for (i=0; i<MAXSPRT; i++)
  161.         if (AddedSprites[i])
  162.             m7sprites_RemoveSprite(i);
  163. }
  164.  
  165. void m7sprites_Animate(unsigned short id)
  166. {
  167.     Sprite * sprite = AllSpriteList[id];
  168.     sprite->imganim++;
  169.     sprite->imganim%=tabLoadedSprite[sprite->slot].NbImgAnim[sprite->anim];
  170. }
  171.  
  172. void m7sprites_SetDisplayed(unsigned short id,
  173.                                                         unsigned short Xscreen,
  174.                                                         unsigned short Yscreen,
  175.                                                         unsigned short Zscreen,
  176.                                                         unsigned short cameraDir,
  177.                                                         unsigned short dir,
  178.                                                         unsigned short scale)
  179. {
  180.     register unsigned short i;
  181.     unsigned short cumul=0;
  182.     unsigned short imgNum;
  183.     unsigned short maskNum;
  184.     LoadedSprite * ls;
  185.    
  186.     Sprite * sprite = AllSpriteList[id];
  187.    
  188.     ls = &(tabLoadedSprite[sprite->slot]);
  189.    
  190.     sprite->dsprite.Xscreen = Xscreen;
  191.     sprite->dsprite.Yscreen = Yscreen;
  192.     sprite->dsprite.Zscreen = Zscreen;
  193.    
  194.     sprite->dsprite.width = ls->ScaledSizes[scale * 2];
  195.     sprite->dsprite.height = ls->ScaledSizes[scale * 2 + 1];
  196.    
  197.     for (i = 0; i<sprite->anim ;i++)
  198.         cumul += 2 * ls->NbImgAnim[i] * ls->NbDir;
  199.     cumul += 2 * (sprite->imganim + (ls->NbImgAnim[sprite->anim] * (((((cameraDir + NBDIR) - dir + (NBDIR/(2*ls->NbDir)))%NBDIR) * ls->NbDir)/NBDIR)));
  200.     imgNum = ls->Data[cumul];
  201.     maskNum = ls->Data[cumul + 1];
  202.  
  203.     cumul=0;
  204.     for (i=0; i<scale; i++)
  205.         cumul += ls->ScaledSizes[i * 2] * ls->ScaledSizes[i * 2 + 1] * ls->NbImg;
  206.  
  207.     sprite->dsprite.img = ls->ImgData + cumul + sprite->dsprite.width * sprite->dsprite.height * imgNum;
  208.     sprite->dsprite.mask = ls->ImgData + cumul + sprite->dsprite.width * sprite->dsprite.height * maskNum;
  209.     DisplayedSpriteList[nbDisplayedSprites] = &(sprite->dsprite);
  210.    
  211.     nbDisplayedSprites++;
  212. }
  213.  
  214. void m7sprites_Set1stDisplayed(unsigned short id, unsigned short dir)
  215. {
  216.     Sprite * sprite = AllSpriteList[id];
  217.     m7sprites_SetDisplayed(id, sprite->dsprite.Xscreen, sprite->dsprite.Yscreen, sprite->dsprite.Zscreen, 0, dir, sprite->nbScales - 1);
  218.     nbDisplayedSprites--;
  219. }
  220.  
  221. CALLBACK short DisplayedSpriteComp(const void *a, const void *b)
  222. {
  223.     return (short)(((*((DisplayedSprite**)a)))->Yscreen) -
  224.     (short)(((*((DisplayedSprite**)b)))->Yscreen);
  225. }
  226.  
  227. void m7sprites_SortDisplayedSpriteList()
  228. {
  229.     qsort (DisplayedSpriteList, nbDisplayedSprites, sizeof (DisplayedSprite *), DisplayedSpriteComp);
  230. }
  231.  
  232.  
  233. #if ENABLE_GRAYSCALE == 1
  234. void m7sprite_Display(unsigned short num, unsigned char *Plane0, unsigned char *Plane1)
  235. #else
  236. void m7sprite_Display(unsigned short num, unsigned char *Plane0)
  237. #endif
  238. {
  239.     register short i, j;
  240.     DisplayedSprite * dsprite = DisplayedSpriteList[num];
  241.     short width = dsprite->width, width2, width3;
  242.     short height = dsprite->height;
  243.     short Xscreen = (dsprite->Xscreen) - (width*4);
  244.     short Yscreen = (dsprite->Yscreen) - height - (dsprite->Zscreen);
  245.     short offset = (Yscreen * 30);
  246.     short clippedup, clippeddown;
  247.     unsigned short shift = Xscreen % 8, hmshift;
  248.     unsigned char * img0 = dsprite->img;
  249. #if ENABLE_GRAYSCALE == 1
  250.     unsigned char * img1 = dsprite->img + width * height;
  251. #endif
  252.     unsigned char * mask = dsprite->mask;
  253.     BYTE byteMask;
  254.     BYTE byteImg0;
  255. #if ENABLE_GRAYSCALE == 1
  256.     BYTE byteImg1;
  257. #endif
  258.    
  259.     if (Yscreen < OFFSET_SCR_VERT)
  260.     {
  261. #if ENABLE_SKY == 1
  262. #if ENABLE_GRAYSCALE == 1
  263.         SkyChange = 2;
  264. #else
  265.         SkyChange = 1;
  266. #endif
  267. #endif
  268.     }
  269.    
  270.     if (Xscreen < 0)
  271.     {
  272.         shift = (8 + shift) % 8;
  273.         offset += (Xscreen-7) / 8;
  274.         clippeddown = (CLIP_DOWN - 1) * 30;
  275.         clippedup = (CLIP_UP - 1) * 30;
  276.     }
  277.     else
  278.     {
  279.         offset += (Xscreen / 8);
  280.         clippeddown = CLIP_DOWN*30;
  281.         clippedup = CLIP_UP*30;
  282.     }
  283.      
  284.     if (shift)
  285.         width2 = width + 1;
  286.     else
  287.         width2 = width;
  288.  
  289.     hmshift = 8 - shift;
  290.     width3 = width2 - 1;
  291.  
  292.     for (i=0; (i<height) && (offset < clippeddown); i++)
  293.     {
  294.         if (offset >= clippedup)
  295.         {
  296.             j=0;
  297.             if ((offset + j - ((Yscreen+i) * 30)) < CLIP_RIGHT)
  298.             {
  299.                 if ((offset + j - ((Yscreen+i) * 30)) >= CLIP_LEFT)
  300.                 {              
  301.                     if (shift)
  302.                     {
  303.                         byteMask = (*mask >> shift) | (0xFF << (hmshift));
  304.                         byteImg0 = (*img0 >> shift);
  305. #if ENABLE_GRAYSCALE == 1
  306.                         byteImg1 = (*img1 >> shift);
  307. #endif
  308.                     }
  309.                     else
  310.                     {
  311.                         byteMask = *mask;
  312.                         byteImg0 = *img0;
  313. #if ENABLE_GRAYSCALE == 1
  314.                         byteImg1 = *img1;
  315. #endif
  316.                         mask++;
  317.                         img0++;
  318. #if ENABLE_GRAYSCALE == 1
  319.                         img1++;
  320. #endif
  321.                     }
  322.  
  323.                     Plane0[offset + j] &= byteMask;
  324.                     Plane0[offset + j] |= byteImg0;
  325. #if ENABLE_GRAYSCALE == 1
  326.                     Plane1[offset + j] &= byteMask;
  327.                     Plane1[offset + j] |= byteImg1;
  328. #endif
  329.                 }
  330.                 else
  331.                 {                  
  332.                     if (!shift)
  333.                     {
  334.                         mask++;                                        
  335.                         img0++;
  336. #if ENABLE_GRAYSCALE == 1
  337.                         img1++;
  338. #endif
  339.                     }
  340.                 }
  341.             }
  342.             else
  343.             {
  344.                 mask++;                                        
  345.                 img0++;
  346. #if ENABLE_GRAYSCALE == 1
  347.                 img1++;
  348. #endif
  349.             }
  350.             for (j=1; j<width3; j++)
  351.             {
  352.                 if ((offset + j - ((Yscreen+i) * 30)) < CLIP_RIGHT)
  353.                 {
  354.                     if ((offset + j - ((Yscreen+i) * 30)) >= CLIP_LEFT)
  355.                     {
  356.                         if (shift)
  357.                         {
  358.                             byteMask = (*mask << (hmshift)) | (*(mask+1) >> shift);
  359.                             byteImg0 = (*img0 << (hmshift)) | (*(img0+1) >> shift);
  360. #if ENABLE_GRAYSCALE == 1
  361.                             byteImg1 = (*img1 << (hmshift)) | (*(img1+1) >> shift);
  362. #endif                     
  363.                         }
  364.                         else
  365.                         {
  366.                             byteMask = *mask;
  367.                             byteImg0 = *img0;
  368. #if ENABLE_GRAYSCALE == 1
  369.                             byteImg1 = *img1;
  370. #endif                     
  371.                         }
  372.                         mask++;
  373.                         img0++;
  374. #if ENABLE_GRAYSCALE == 1
  375.                         img1++;
  376. #endif                     
  377.                         Plane0[offset + j] &= byteMask;
  378.                         Plane0[offset + j] |= byteImg0;
  379. #if ENABLE_GRAYSCALE == 1
  380.                         Plane1[offset + j] &= byteMask;
  381.                         Plane1[offset + j] |= byteImg1;
  382. #endif
  383.                     }
  384.                     else
  385.                     {
  386.                         mask++;                                        
  387.                         img0++;
  388. #if ENABLE_GRAYSCALE == 1
  389.                         img1++;
  390. #endif
  391.                     }
  392.                 }
  393.                 else
  394.                 {
  395.                     mask++;                                        
  396.                     img0++;
  397. #if ENABLE_GRAYSCALE == 1
  398.                     img1++;
  399. #endif
  400.                 }
  401.             }
  402.             if (j == width3)
  403.             {
  404.                 if ((offset + j - ((Yscreen+i) * 30)) < CLIP_RIGHT)
  405.                 {
  406.                     if ((offset + j - ((Yscreen+i) * 30)) >= CLIP_LEFT)
  407.                     {
  408.                         if (shift)
  409.                         {
  410.                             byteMask = (*mask << (hmshift)) | (0xFF >> shift);
  411.                             byteImg0 = (*img0 << (hmshift));
  412. #if ENABLE_GRAYSCALE == 1
  413.                             byteImg1 = (*img1 << (hmshift));
  414. #endif         
  415.                         }
  416.                         else
  417.                         {
  418.                             byteMask = *mask;
  419.                             byteImg0 = *img0;
  420. #if ENABLE_GRAYSCALE == 1
  421.                             byteImg1 = *img1;
  422. #endif                                 
  423.                         }
  424.                         mask++;
  425.                         img0++;
  426. #if ENABLE_GRAYSCALE == 1
  427.                         img1++;
  428. #endif         
  429.                         Plane0[offset + j] &= byteMask;
  430.                         Plane0[offset + j] |= byteImg0;
  431. #if ENABLE_GRAYSCALE == 1
  432.                         Plane1[offset + j] &= byteMask;
  433.                         Plane1[offset + j] |= byteImg1;
  434. #endif
  435.                     }
  436.                     else
  437.                     {
  438.                         mask++;                                        
  439.                         img0++;
  440. #if ENABLE_GRAYSCALE == 1
  441.                         img1++;
  442. #endif
  443.                     }
  444.                 }
  445.                 else
  446.                 {
  447.                     mask++;                                        
  448.                     img0++;
  449. #if ENABLE_GRAYSCALE == 1
  450.                     img1++;
  451. #endif
  452.                 }              
  453.             }
  454.         }
  455.         else
  456.         {
  457.             mask+=width;
  458.             img0+=width;
  459. #if ENABLE_GRAYSCALE == 1
  460.             img1+=width;
  461. #endif         
  462.         }
  463.  
  464.         offset+=30;
  465.     }
  466.    
  467. }
  468.  
  469. #if ENABLE_GRAYSCALE == 1
  470. void m7sprite_Display1stPlane(unsigned short id, unsigned char *Plane0, unsigned char *Plane1)
  471. #else
  472. void m7sprite_Display1stPlane(unsigned short id, unsigned char *Plane0)
  473. #endif
  474. {
  475.     register short i, j;
  476.     DisplayedSprite * dsprite = &(AllSpriteList[id]->dsprite);
  477.     short width = dsprite->width;
  478.     short height = dsprite->height;
  479.     short Xscreen = ((dsprite->Xscreen) - (width*4)) >> 3;
  480.     short Yscreen = (dsprite->Yscreen) - height - (dsprite->Zscreen);
  481.     unsigned char * offset0 = Plane0 + (Yscreen * 30) + Xscreen;
  482.     unsigned char * img0 = dsprite->img;
  483. #if ENABLE_GRAYSCALE == 1
  484.     unsigned char * offset1 = Plane1 + (Yscreen * 30) + Xscreen;
  485.     unsigned char * img1 = dsprite->img + width * height;
  486. #endif
  487.     unsigned char * mask = dsprite->mask;
  488.  
  489.     if (Yscreen < OFFSET_SCR_VERT)
  490.     {
  491. #if ENABLE_SKY == 1
  492. #if ENABLE_GRAYSCALE == 1
  493.         SkyChange = 2;
  494. #else
  495.         SkyChange = 1;
  496. #endif
  497. #endif
  498.     }
  499.  
  500.     for(i=height; i--;)
  501.     {
  502.         for(j=width; j--;)
  503.         {
  504.             *offset0 &= *mask;
  505. #if ENABLE_GRAYSCALE == 1
  506.             *offset1 &= *mask;
  507. #endif
  508.             mask++;
  509.             *offset0 |= *img0;
  510.             img0++;
  511.             offset0++;
  512. #if ENABLE_GRAYSCALE == 1
  513.             *offset1 |= *img1;
  514.             img1++;
  515.             offset1++;
  516. #endif
  517.         }
  518.         offset0 += 30 - width;
  519. #if ENABLE_GRAYSCALE == 1
  520.         offset1 += 30 - width;
  521. #endif
  522.     }
  523. }
  524.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement