home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 262.lha / SpriteWizard_v1.0 / SW_Twist.c < prev    next >
C/C++ Source or Header  |  1989-06-30  |  13KB  |  481 lines
  1. /*  SpriteWiz modification routines  -  By David A. Visage  */
  2.  
  3. #include <stdio.h>
  4. #include <exec/types.h>
  5. #include <intuition/intuition.h>
  6.  
  7. #define BOX_WIDTH  15
  8. #define BOX_HEIGHT 10
  9.  
  10. #define GRID_WIDTH  (16 * BOX_WIDTH)
  11. #define GRID_HEIGHT (16 * BOX_HEIGHT)
  12.  
  13. #define SPRITE_SIZE  36              /*  In words  */
  14.  
  15. #define ALL_BITS  0xffff
  16.  
  17. /*  The world famous Sprite structure  */
  18. struct Sprite
  19.  {
  20.  UWORD SpriteData [SPRITE_SIZE];
  21.  UWORD SprColor1,SprColor2,SprColor3;
  22.  UWORD SpriteNumber;
  23.  };
  24.  
  25.  
  26. /*  Scroll up routine for grid and sprite data  */
  27. ScrollUp(Rp,VertRast,SpritePtr,BoxPtr)
  28. struct RastPort *Rp;
  29. struct RastPort *VertRast;
  30. struct Sprite *SpritePtr;
  31. struct Rectangle *BoxPtr;
  32. {
  33. struct Rectangle *RectPtr1,*RectPtr2;
  34. UWORD *SpriteDataPtr;
  35. LONG SrcX,SrcY,DestX,DestY;
  36. int i;
  37. LONG BoxIndex;
  38. LONG WordIndex1,WordIndex2;
  39. UWORD SaveHigh,SaveLow;
  40. UWORD HighWord,LowWord;
  41.  
  42. SpriteDataPtr = &SpritePtr->SpriteData[0];
  43.  
  44. /*  Save first row of grid data  */
  45. SrcX = BoxPtr->MinX;
  46. SrcY = BoxPtr->MinY;
  47. ClipBlit(Rp,SrcX,SrcY,VertRast,0,0,GRID_WIDTH,BOX_HEIGHT,0xc0);
  48.  
  49. /*  Save first row of sprite data  */
  50. WordIndex1 = 2;
  51. SaveHigh = *(SpriteDataPtr + WordIndex1);
  52. SaveLow = *(SpriteDataPtr + WordIndex1 + 1);
  53.  
  54. for ( i = 1; i <= 15; i++ )
  55.     {
  56.     /*  Scroll grid row to next higher row  */
  57.     RectPtr1 = BoxPtr + (i * 16);
  58.     RectPtr2 = RectPtr1 - 16;         /*  Rectangle row about current  */
  59.     SrcX = RectPtr1->MinX;
  60.     SrcY = RectPtr1->MinY;
  61.     DestX = RectPtr2->MinX;
  62.     DestY = RectPtr2->MinY;
  63.     ClipBlit(Rp,SrcX,SrcY,Rp,DestX,DestY,GRID_WIDTH,BOX_HEIGHT,0xc0);
  64.  
  65.     /*  Scroll sprite row to next higher row  */
  66.     WordIndex1 = 2 + (2 * i);
  67.     WordIndex2 = 2 * i;
  68.     HighWord = *(SpriteDataPtr + WordIndex1);
  69.     LowWord = *(SpriteDataPtr + WordIndex1 + 1);
  70.     *(SpriteDataPtr + WordIndex2) = HighWord;
  71.     *(SpriteDataPtr + WordIndex2 + 1) = LowWord;
  72.     };
  73.  
  74. /*  Restore last row of grid data  */
  75. BoxIndex = 16 * 15;
  76. RectPtr1 = BoxPtr + BoxIndex;        /*  Auto scaled by argument size  */
  77. DestX = RectPtr1->MinX;
  78. DestY = RectPtr1->MinY;
  79. ClipBlit(VertRast,0,0,Rp,DestX,DestY,GRID_WIDTH,BOX_HEIGHT,0xc0);
  80.  
  81. /*  Restore last row of sprite  */
  82. WordIndex1 = 2 + (15 * 2);
  83. *(SpriteDataPtr + WordIndex1) = SaveHigh;
  84. *(SpriteDataPtr + WordIndex1 + 1) = SaveLow;
  85. }
  86.  
  87.  
  88. /*  Scroll down routine for grid and sprite data  */
  89. ScrollDown(Rp,VertRast,SpritePtr,BoxPtr)
  90. struct RastPort *Rp;
  91. struct RastPort *VertRast;
  92. struct Sprite *SpritePtr;
  93. struct Rectangle *BoxPtr;
  94. {
  95. struct Rectangle *RectPtr1,*RectPtr2;
  96. UWORD *SpriteDataPtr;
  97. LONG SrcX,SrcY,DestX,DestY;
  98. int i;
  99. LONG BoxIndex;
  100. LONG WordIndex1,WordIndex2;
  101. UWORD SaveHigh,SaveLow;
  102. UWORD HighWord,LowWord;
  103.  
  104. SpriteDataPtr = &SpritePtr->SpriteData[0];
  105.  
  106. /*  Save last row of grid data  */
  107. BoxIndex = 16 * 15;
  108. RectPtr1 = BoxPtr + BoxIndex;
  109. SrcX = RectPtr1->MinX;
  110. SrcY = RectPtr1->MinY;
  111. ClipBlit(Rp,SrcX,SrcY,VertRast,0,0,GRID_WIDTH,BOX_HEIGHT,0xc0);
  112.  
  113. /*  Save last row of sprite data  */
  114. WordIndex1 = 2 + (15 * 2);
  115. SaveHigh = *(SpriteDataPtr + WordIndex1);
  116. SaveLow = *(SpriteDataPtr + WordIndex1 + 1);
  117.  
  118. for ( i = 15; i > 0 ; i-- )
  119.     {
  120.     /*  Scroll row of grid data to next lower row  */
  121.     BoxIndex = i * 16;
  122.     RectPtr1 = BoxPtr + BoxIndex;          /*  Row below current  */
  123.     RectPtr2 = RectPtr1 - 16;
  124.     SrcX = RectPtr2->MinX;
  125.     SrcY = RectPtr2->MinY;
  126.     DestX = RectPtr1->MinX;
  127.     DestY = RectPtr1->MinY;
  128.     ClipBlit(Rp,SrcX,SrcY,Rp,DestX,DestY,GRID_WIDTH,BOX_HEIGHT,0xc0);
  129.  
  130.     /*  Scroll sprite row to next lower row  */
  131.     WordIndex1 = 2 * i;
  132.     WordIndex2 = 2 + (2 * i);
  133.     HighWord = *(SpriteDataPtr + WordIndex1);
  134.     LowWord = *(SpriteDataPtr + WordIndex1 + 1);
  135.     *(SpriteDataPtr + WordIndex2) = HighWord;
  136.     *(SpriteDataPtr + WordIndex2 + 1) = LowWord;
  137.     };
  138.  
  139. /*  Restore first row of grid data  */
  140. DestX = BoxPtr->MinX;
  141. DestY = BoxPtr->MinY;
  142. ClipBlit(VertRast,0,0,Rp,DestX,DestY,GRID_WIDTH,BOX_HEIGHT,0xc0);
  143.  
  144. /*  Restore first row of sprite  */
  145. WordIndex1 = 2;
  146. *(SpriteDataPtr + WordIndex1) = SaveHigh;
  147. *(SpriteDataPtr + WordIndex1 + 1) = SaveLow;
  148. }
  149.  
  150.  
  151. /*  Scroll left routine for grid and sprite data  */
  152. ScrollLeft(Rp,HorizRast,SpritePtr,BoxPtr)
  153. struct RastPort *Rp;
  154. struct RastPort *HorizRast;
  155. struct Sprite *SpritePtr;
  156. struct Rectangle *BoxPtr;
  157. {
  158. struct Rectangle *RectPtr1,*RectPtr2;
  159. UWORD *SpriteDataPtr;
  160. LONG SrcX,SrcY,DestX,DestY;
  161. int i;
  162. LONG BoxIndex;
  163. LONG WordIndex;
  164. UWORD *HighWordPtr,*LowWordPtr;
  165.  
  166. SpriteDataPtr = &SpritePtr->SpriteData[0];
  167.  
  168. /*  Save first column of grid data  */
  169. SrcX = BoxPtr->MinX;
  170. SrcY = BoxPtr->MinY;
  171. ClipBlit(Rp,SrcX,SrcY,HorizRast,0,0,BOX_WIDTH,GRID_HEIGHT,0xc0);
  172.  
  173. /*  Shift first line of sprite data to the left  */
  174. WordIndex = 2;
  175. HighWordPtr = SpriteDataPtr + WordIndex;
  176. LowWordPtr = SpriteDataPtr + WordIndex + 1;
  177. ShiftLeft(HighWordPtr,LowWordPtr);
  178.  
  179. for ( i = 1; i <= 15 ; i++ )
  180.     {
  181.     /*  Move next grid column to the left  */
  182.     RectPtr1 = BoxPtr + i;
  183.     RectPtr2 = RectPtr1 - 1;       /*  Column to left of current  */
  184.     SrcX = RectPtr1->MinX;
  185.     SrcY = RectPtr1->MinY;
  186.     DestX = RectPtr2->MinX;
  187.     DestY = RectPtr2->MinY;
  188.     ClipBlit(Rp,SrcX,SrcY,Rp,DestX,DestY,BOX_WIDTH,GRID_HEIGHT,0xc0);
  189.  
  190.     /*  Shift next line of sprite data to the left  */
  191.     WordIndex = 2 + (2 * i);
  192.     HighWordPtr = SpriteDataPtr + WordIndex;
  193.     LowWordPtr = SpriteDataPtr + WordIndex + 1;
  194.     ShiftLeft(HighWordPtr,LowWordPtr);
  195.     };
  196.  
  197. /*  Restore last column of grid data  */
  198. BoxIndex = 15;
  199. RectPtr1 = BoxPtr + BoxIndex;        /*  Auto scaled by argument size  */
  200. DestX = RectPtr1->MinX;
  201. DestY = RectPtr1->MinY;
  202. ClipBlit(HorizRast,0,0,Rp,DestX,DestY,BOX_WIDTH,GRID_HEIGHT,0xc0);
  203. }
  204.  
  205.  
  206. /*  Scroll right routine for grid and sprite data  */
  207. ScrollRight(Rp,HorizRast,SpritePtr,BoxPtr)
  208. struct RastPort *Rp;
  209. struct RastPort *HorizRast;
  210. struct Sprite *SpritePtr;
  211. struct Rectangle *BoxPtr;
  212. {
  213. struct Rectangle *RectPtr1,*RectPtr2;
  214. UWORD *SpriteDataPtr;
  215. LONG SrcX,SrcY,DestX,DestY;
  216. int i;
  217. LONG BoxIndex,WordIndex;
  218. UWORD *HighWordPtr,*LowWordPtr;
  219.  
  220. SpriteDataPtr = &SpritePtr->SpriteData[0];
  221.  
  222. /*  Save last column of grid data  */
  223. BoxIndex = 15;
  224. RectPtr1 = BoxPtr + BoxIndex;
  225. SrcX = RectPtr1->MinX;
  226. SrcY = RectPtr1->MinY;
  227. ClipBlit(Rp,SrcX,SrcY,HorizRast,0,0,BOX_WIDTH,GRID_HEIGHT,0xc0);
  228.  
  229. /*  Shift first line of sprite data to the right  */
  230. WordIndex = 2;
  231. HighWordPtr = SpriteDataPtr + WordIndex;
  232. LowWordPtr = SpriteDataPtr + WordIndex + 1;
  233. ShiftRight(HighWordPtr,LowWordPtr);
  234.  
  235. for ( i = 15; i > 0; i-- )
  236.     {
  237.     /*  Move next column of grid data to the right  */
  238.     RectPtr1 = BoxPtr + i;      /*  Column right of current  */
  239.     RectPtr2 = RectPtr1 - 1;
  240.     SrcX = RectPtr2->MinX;
  241.     SrcY = RectPtr2->MinY;
  242.     DestX = RectPtr1->MinX;
  243.     DestY = RectPtr1->MinY;
  244.     ClipBlit(Rp,SrcX,SrcY,Rp,DestX,DestY,BOX_WIDTH,GRID_HEIGHT,0xc0);
  245.  
  246.     /*  Shift next line of sprite data to the right  */
  247.     WordIndex = 2 + (2 * i);
  248.     HighWordPtr = SpriteDataPtr + WordIndex;
  249.     LowWordPtr = SpriteDataPtr + WordIndex + 1;
  250.     ShiftRight(HighWordPtr,LowWordPtr);
  251.     };
  252.  
  253. /*  Restore first column of grid data  */
  254. DestX = BoxPtr->MinX;
  255. DestY = BoxPtr->MinY;
  256. ClipBlit(HorizRast,0,0,Rp,DestX,DestY,BOX_WIDTH,GRID_HEIGHT,0xc0);
  257. }
  258.  
  259.  
  260. /*  Rotate right for grid and sprite data  */
  261. RotateRight(Rp,GRast,SpritePtr,BoxPtr)
  262. struct RastPort *Rp;
  263. struct RastPort *GRast;                      /*  Pointer to GRast  */
  264. struct Sprite *SpritePtr;
  265. struct Rectangle *BoxPtr;
  266. {
  267. struct Rectangle *RectPtr;
  268. UWORD *SpriteDataPtr;
  269. UWORD TempSprite[SPRITE_SIZE];
  270. UWORD HighWord,LowWord;
  271. ULONG HighBit,LowBit;
  272. LONG WordIndex1,WordIndex2;
  273. LONG SrcX,SrcY;
  274. LONG DestX,DestY;
  275. LONG BoxIndex,BitMask;
  276. int i,j;
  277.  
  278. SpriteDataPtr = &SpritePtr->SpriteData[0];
  279.  
  280. ClearSprData(&TempSprite[0]);           /*  Clear temporary sprite     */
  281.  
  282. DestX = GRID_WIDTH - BOX_WIDTH;        /*  Last column in GridRast    */
  283. for ( i = 0; i <= 15; i++ )
  284.     {
  285.     /*  Get next row of sprite data  */
  286.     WordIndex1 = 2 + (2 * i);
  287.     HighWord = *(SpriteDataPtr + WordIndex1);
  288.     LowWord = *(SpriteDataPtr + WordIndex1 + 1);
  289.  
  290.     DestY = 0;                       /*  DestY starts at mimimum  */
  291.     for ( j = 0; j <= 15; j++ )
  292.         {
  293.         /*  Calculate new sprite image  */
  294.         BitMask = 1 << (15 - j);
  295.         HighBit = HighWord & BitMask;
  296.         LowBit = LowWord & BitMask;
  297.         WordIndex2 = 2 + (2 * j);             /*  Start at top  */
  298.         if ( HighBit != 0 )
  299.            TempSprite[WordIndex2] |= (1 << i);
  300.         if ( LowBit != 0 )
  301.            TempSprite[WordIndex2 + 1] |= (1 << i);
  302.  
  303.         /*  Save current box data in backup raster  */
  304.         BoxIndex = j + (16 * i);
  305.         RectPtr = BoxPtr + BoxIndex;  /*  Auto scaled by argument size  */
  306.         SrcX = RectPtr->MinX;
  307.         SrcY = RectPtr->MinY;
  308.         ClipBlit(Rp,SrcX,SrcY,GRast,DestX,DestY,BOX_WIDTH,BOX_HEIGHT,0xc0);
  309.         DestY += BOX_HEIGHT;   /*  Next Y position in grid raster    */
  310.         };
  311.  
  312.     DestX -= BOX_WIDTH;        /*  Next X position in grid raster  */
  313.     };
  314.  
  315. /*  Copy temporary sprite data to real sprite data  */
  316. CopySprData(&TempSprite[0],SpriteDataPtr);
  317.  
  318. /*  Copy GRast to drawing grid  */
  319. DestX = BoxPtr->MinX;
  320. DestY = BoxPtr->MinY;
  321. ClipBlit(GRast,0,0,Rp,DestX,DestY,GRID_WIDTH,GRID_HEIGHT,0xc0);
  322. }
  323.  
  324.  
  325. /*  Rotate left for grid and sprite data  */
  326. RotateLeft(Rp,GRast,SpritePtr,BoxPtr)
  327. struct RastPort *Rp;
  328. struct RastPort *GRast;                      /*  Pointer to GRast  */
  329. struct Sprite *SpritePtr;
  330. struct Rectangle *BoxPtr;
  331. {
  332. struct Rectangle *RectPtr;
  333. UWORD *SpriteDataPtr;
  334. UWORD TempSprite[SPRITE_SIZE];
  335. UWORD HighWord,LowWord;
  336. ULONG HighBit,LowBit;
  337. LONG WordIndex1,WordIndex2;
  338. LONG SrcX,SrcY;
  339. LONG DestX,DestY;
  340. LONG BoxIndex,BitMask;
  341. int i,j;
  342.  
  343. SpriteDataPtr = &SpritePtr->SpriteData[0]; 
  344.  
  345. ClearSprData(&TempSprite[0]);     /*  Clear temporary sprite  */
  346.  
  347. DestX = 0;                       /*  First column in GridRast  */
  348. for ( i = 0; i <= 15; i++ )
  349.     {
  350.     /*  Get next row of sprite data  */
  351.     WordIndex1 = 2 + (2 * i);
  352.     HighWord = *(SpriteDataPtr + WordIndex1);
  353.     LowWord = *(SpriteDataPtr + WordIndex1 + 1);
  354.  
  355.     DestY = GRID_HEIGHT - BOX_HEIGHT;     /*  Initial grid Y coordinate  */
  356.     for ( j = 0; j <= 15; j++ )
  357.         {
  358.         /*  Calculate new sprite image  */
  359.         BitMask = 1 << (15 - j);
  360.         HighBit = HighWord & BitMask;
  361.         LowBit = LowWord & BitMask;
  362.         WordIndex2 = 32 - (2 * j);             /*  Start at bottom  */
  363.         if ( HighBit != 0 )
  364.            TempSprite[WordIndex2] |= (1 << (15 - i));
  365.         if ( LowBit != 0 )
  366.            TempSprite[WordIndex2 + 1] |= (1 << (15 - i));
  367.  
  368.         /*  Save current box data in backup raster  */
  369.         BoxIndex = j + (16 * i);
  370.         RectPtr = BoxPtr + BoxIndex;  /*  Auto scaled by argument size  */
  371.         SrcX = RectPtr->MinX;
  372.         SrcY = RectPtr->MinY;
  373.         ClipBlit(Rp,SrcX,SrcY,GRast,DestX,DestY,BOX_WIDTH,BOX_HEIGHT,0xc0);
  374.         DestY -= BOX_HEIGHT;     /*  Next Y position in grid raster  */
  375.         };
  376.  
  377.     DestX += BOX_WIDTH;        /*  Next X position in grid raster  */
  378.     };
  379.  
  380. /*  Copy temporary sprite data to real sprite data  */
  381. CopySprData(&TempSprite[0],SpriteDataPtr);
  382.  
  383. /*  Copy GRast to drawing grid  */
  384. DestX = BoxPtr->MinX;
  385. DestY = BoxPtr->MinY;
  386. ClipBlit(GRast,0,0,Rp,DestX,DestY,GRID_WIDTH,GRID_HEIGHT,0xc0);
  387. }
  388.  
  389.  
  390. /*  Flip sprite on the Y Axis  */
  391. FlipY(SpritePtr)
  392. struct Sprite *SpritePtr;
  393. {
  394. UWORD *SpriteDataPtr;
  395. UWORD TempSprite[SPRITE_SIZE];
  396. UWORD HighWord,LowWord;
  397. UWORD BitMask;
  398. LONG WordIndex;
  399. int i,j;
  400.  
  401. SpriteDataPtr = &SpritePtr->SpriteData[0];
  402.  
  403. ClearSprData(&TempSprite[0]);            /*  Clear temporary sprite  */
  404. for ( i = 0; i <= 15; i++ )
  405.     {
  406.     WordIndex = 2 + ( 2 * i);
  407.     HighWord = *(SpriteDataPtr + WordIndex);
  408.     LowWord = *(SpriteDataPtr + WordIndex + 1);
  409.     for ( j = 0; j <= 15; j++ )
  410.         {
  411.         BitMask = 1 << (15 - j);
  412.         if ( (HighWord & BitMask) != 0 )
  413.            TempSprite[WordIndex] |= (1 << j);
  414.         if ( (LowWord & BitMask) != 0 )
  415.            TempSprite[WordIndex + 1] |= (1 << j);
  416.         };
  417.     };
  418.  
  419. /*  Copy TempSprite data to edit sprite image  */
  420. CopySprData(&TempSprite[0],SpriteDataPtr);
  421. }
  422.  
  423.  
  424. /*  Flip sprite on the X Axis  */
  425. FlipX(SpritePtr)
  426. struct Sprite *SpritePtr;
  427. {
  428. UWORD *SpriteDataPtr;
  429. UWORD TempSprite[SPRITE_SIZE];
  430. UWORD HighWord,LowWord;
  431. LONG WordIndex1,WordIndex2;
  432. int i;
  433.  
  434. SpriteDataPtr = &SpritePtr->SpriteData[0];
  435.  
  436. ClearSprData(&TempSprite[0]);            /*  Clear temporary sprite  */
  437. for ( i = 0; i <= 15; i++ )
  438.     {
  439.     /*  Get next line of sprite data from top  */
  440.     WordIndex1 = 2 + ( 2 * i);
  441.     HighWord = *(SpriteDataPtr + WordIndex1);
  442.     LowWord = *(SpriteDataPtr + WordIndex1 + 1);
  443.     /*  Move to next line of temporary sprite from bottom  */
  444.     WordIndex2 = 2 + (2 * (15 - i));
  445.     TempSprite[WordIndex2] = HighWord;
  446.     TempSprite[WordIndex2 + 1] = LowWord;
  447.     };
  448.  
  449. /*  Copy TempSprite data to edit sprite image  */
  450. CopySprData(&TempSprite[0],SpriteDataPtr);
  451. }
  452.  
  453.  
  454. /*  Negate image of sprite by using XOR  */
  455. Negate(SpritePtr)
  456. struct Sprite *SpritePtr;
  457. {
  458. UWORD *SpriteDataPtr;
  459. UWORD HighWord,LowWord;
  460. LONG WordIndex;
  461. int i;
  462.  
  463. SpriteDataPtr = &SpritePtr->SpriteData[0];
  464.  
  465. for ( i = 0; i <= 15; i++ )
  466.     {
  467.     /*  Get next line of sprite  */
  468.     WordIndex = 2 + (2 * i);
  469.     HighWord = *(SpriteDataPtr + WordIndex);
  470.     LowWord = *(SpriteDataPtr + WordIndex + 1);
  471.     /*  Negate sense of all bits  */
  472.     HighWord ^= ALL_BITS;
  473.     LowWord ^= ALL_BITS;
  474.     /*  Assign back to sprite  */
  475.     *(SpriteDataPtr + WordIndex) = HighWord;
  476.     *(SpriteDataPtr + WordIndex + 1) = LowWord;
  477.     };
  478. }
  479.  
  480.  
  481.