API tools faq
paste
Advertisement
Siapran

m7sprites.c

Siapran
Oct 2nd, 2011
361
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 12.10 KB | None | 0 0
raw download clone embed print report
  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
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!