home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 262.lha / SpriteWizard_v1.0 / SW_Support.c < prev    next >
C/C++ Source or Header  |  1989-06-30  |  13KB  |  585 lines
  1. /*  SpriteWiz support routines  */
  2.  
  3. #include <stdio.h>
  4. #include <ctype.h>
  5. #include <exec/types.h>
  6. #include <graphics/sprite.h>
  7. #include <intuition/intuition.h>
  8.  
  9. #include "SW_Menu.def"
  10.  
  11. /*  Color registers  */
  12. #define COLOR00  0
  13. #define COLOR01  1
  14. #define COLOR02  2
  15. #define COLOR03  3
  16. #define COLOR04  4
  17.  
  18. /*  Packed UWORDS for default sprite colors  */
  19. #define RED    0xf00
  20. #define GREEN  0x0f0
  21. #define BLUE   0x00f
  22.  
  23. /*  maximum and minimum bit definitions  */
  24. #define HIGH_BIT     (1 << 15)
  25. #define LOW_BIT      (1 << 0)
  26.  
  27. /*  Sprite number defines  */
  28. #define LOW_SPRITE    0
  29. #define HIGH_SPRITE   25
  30. #define MAX_SPRITES   26
  31.  
  32. /*  Various other defines  */
  33. #define MAX_INT      32767           /*  Used for random numbers  */
  34. #define MAX_DEPTH    3
  35. #define SPRITE_SIZE  36      /*  In words  */
  36.  
  37. /*  External declares  */
  38. extern UBYTE *AllocRaster();
  39. extern UWORD GetRGB4();
  40. extern UWORD PackRGB();
  41. extern BOOL CheckSequence();
  42. extern unsigned int rand();
  43. extern unsigned int GetRand();
  44.  
  45. /*  The world renowned Sprite structure  */
  46. struct Sprite
  47.  {
  48.  UWORD SpriteData [SPRITE_SIZE];
  49.  UWORD SprColor1,SprColor2,SprColor3;
  50.  UWORD SpriteNumber;
  51.  };
  52.  
  53. #define SPR_STRUCT_SIZE   sizeof(struct Sprite)
  54.  
  55. /*  Again, the world famous points structure  */
  56. struct Points
  57.  {
  58.  UWORD X1,Y1;
  59.  UWORD X2,Y2;
  60.  UWORD X3,Y3;
  61.  UWORD X4,Y4;
  62.  UWORD X5,Y5;
  63.  };
  64.  
  65.  
  66. /*  Initialize all sprites  */
  67. InitSprites(SpritePtr)
  68. struct Sprite *SpritePtr;                /*  Pointer to first sprite  */
  69. {
  70. struct Sprite *FirstSprPtr;
  71. ULONG Mode;
  72. int i;
  73.  
  74. FirstSprPtr = SpritePtr;      /*  Save pointer to first sprite  */
  75.  
  76. /*  Assign sprite numbers  */
  77. for ( i = 0; i < MAX_SPRITES; i++ )
  78.     {
  79.     SpritePtr->SpriteNumber = i;
  80.     SpritePtr++;
  81.     }
  82.  
  83. Mode = ALL;
  84. ClearSprite(FirstSprPtr,Mode);          /*  Clear sprite imagry   */
  85. ClearColor(FirstSprPtr,Mode);           /*  Reset sprite colors   */
  86. }
  87.  
  88.  
  89. /*  Initialzation code for buffer sprite  */
  90. InitTempSprite(SpritePtr)
  91. struct Sprite *SpritePtr;
  92. {
  93. ULONG Mode;
  94.  
  95. /*  Clear imagry and set colors of buffer sprite to default colors  */
  96. SpritePtr->SpriteNumber = 0;          /*  For KLUDGE purposes  */
  97. Mode = CURRENT;
  98. ClearSprite(SpritePtr,Mode);          /*  Clear sprite imagry   */
  99. ClearColor(SpritePtr,Mode);           /*  Reset sprite colors   */
  100. }
  101.  
  102.  
  103. /*  Dynamically allocate rastport for grid scroll and rotate routines  */
  104. InitTempRast(RastPtr,BitMapPtr,Width,Height)
  105. struct RastPort *RastPtr;
  106. struct BitMap *BitMapPtr;
  107. LONG Width,Height;
  108. {
  109. int i;
  110.  
  111. InitBitMap(BitMapPtr,MAX_DEPTH,Width,Height);
  112. for ( i = 0; i < MAX_DEPTH; i++ )
  113.     {
  114.     BitMapPtr->Planes[i] = AllocRaster(Width,Height);
  115.     if ( BitMapPtr->Planes[i] == NULL )
  116.        {
  117.        printf("Could not allocate space for Temporary BitMap! \n");
  118.        exit(1);
  119.        };
  120.      };
  121.  
  122. InitRastPort(RastPtr);
  123. RastPtr->BitMap = BitMapPtr;
  124. }
  125.  
  126.  
  127. /*  Free dynamically created BitMap  */
  128. FreeTempRast(RastPtr,BitMapPtr,Width,Height)
  129. struct RastPort *RastPtr;
  130. struct BitMap *BitMapPtr;
  131. {
  132. int i;
  133.  
  134. for ( i = 0; i < MAX_DEPTH; i++ )
  135.     FreeRaster(BitMapPtr->Planes[i],Width,Height);
  136. }
  137.  
  138.  
  139. /*  Draw sprite image onto grid  */
  140. CalcSprite(Rp,SpritePtr,BoxPtr)
  141. struct RastPort *Rp;
  142. struct Sprite *SpritePtr;
  143. struct Rectangle *BoxPtr;
  144. {
  145. struct Rectangle *RectPtr;
  146. UWORD *SpriteDataPtr;
  147. UWORD HighWord,LowWord;
  148. UWORD HighBit,LowBit;
  149. LONG Row,BoxIndex,WordIndex;
  150. LONG MinX,MinY,MaxX,MaxY;
  151. int i;
  152.  
  153. SpriteDataPtr = &SpritePtr->SpriteData[0];
  154.  
  155. for ( Row = 0; Row <= 15; Row++ )
  156.     {
  157.     /*  Get HighWord and LowWord of each sprite line  */
  158.     WordIndex = 2 + (2 * Row);
  159.     HighWord = *(SpriteDataPtr + WordIndex);
  160.     LowWord = *(SpriteDataPtr + WordIndex + 1);
  161.  
  162.     for ( i = 0; i <= 15; i++ )
  163.         {
  164.         /*  Check each bit position in HighWord amd LowWord  */
  165.         HighBit = HighWord & (1 << (15 - i));
  166.         LowBit =  LowWord & (1 << (15 - i));
  167.  
  168.         /*  Set Rp color depending on bit combination  */
  169.         if ( HighBit == 0 && LowBit == 0 )
  170.            SetAPen(Rp,COLOR00);
  171.         else if ( HighBit != 0 && LowBit == 0 )
  172.            SetAPen(Rp,COLOR01);
  173.         else if ( HighBit == 0 && LowBit != 0 )
  174.            SetAPen(Rp,COLOR02);
  175.         else if ( HighBit != 0 && LowBit != 0 )
  176.            SetAPen(Rp,COLOR03);
  177.  
  178.         /*  Get MinX, MinY, MaxX, MaxY for current box  */
  179.         BoxIndex = (Row * 16) + i;
  180.         RectPtr = BoxPtr + BoxIndex;
  181.         MinX = RectPtr->MinX;
  182.         MinY = RectPtr->MinY;
  183.         MaxX = RectPtr->MaxX;
  184.         MaxY = RectPtr->MaxY;
  185.  
  186.         /*  Do RectFill() to current box  */
  187.         RectFill(Rp,MinX + 1,MinY + 1,MaxX - 1,MaxY - 1);
  188.         };
  189.     };                               /*  Next row  */
  190. }
  191.  
  192.  
  193. ClearSprite(SpritePtr,Mode)
  194. struct Sprite *SpritePtr;         /*  Points to current sprite  */
  195. ULONG Mode;
  196. {
  197. UWORD *SpriteDataPtr;
  198. UWORD SprNum;
  199. int i,LowRange,HighRange;
  200. struct Sprite *FirstSprPtr,*NextSprPtr;
  201.  
  202. SprNum = SpritePtr->SpriteNumber;
  203. FirstSprPtr = SpritePtr - SprNum;    /*  Get pointer to first sprite  */
  204.  
  205. switch(Mode)
  206.   {
  207.   case CURRENT :
  208.        LowRange = SprNum;
  209.        HighRange = SprNum;
  210.        NextSprPtr = SpritePtr;
  211.   break;
  212.   case ALL :
  213.        LowRange = LOW_SPRITE;
  214.        HighRange = HIGH_SPRITE;
  215.        NextSprPtr = FirstSprPtr;
  216.   break;
  217.   case FROM :
  218.        LowRange = SprNum;
  219.        HighRange = HIGH_SPRITE;
  220.        NextSprPtr = SpritePtr;
  221.   break;
  222.   case UP_TO :
  223.        LowRange = LOW_SPRITE;
  224.        HighRange = SprNum;
  225.        NextSprPtr = FirstSprPtr;
  226.   break;
  227.   case EXCEPT :
  228.        LowRange = LOW_SPRITE;
  229.        HighRange = HIGH_SPRITE;
  230.        NextSprPtr = FirstSprPtr;
  231.   break;
  232.   };
  233.  
  234. /*  Clear specified range of sprites  */
  235. for ( i = LowRange; i <= HighRange; i++ )
  236.     {
  237.     if ( Mode == EXCEPT && i == SprNum )
  238.        {
  239.        NextSprPtr++;
  240.        continue;
  241.        };
  242.  
  243.        /*  Clear next sprite image  */
  244.        SpriteDataPtr = &NextSprPtr->SpriteData[0];
  245.        ClearSprData(SpriteDataPtr);
  246.        NextSprPtr++;
  247.     };
  248. }
  249.  
  250.  
  251. ClearColor(SpritePtr,Mode)
  252. struct Sprite *SpritePtr;         /*  Points to current sprite  */
  253. ULONG Mode;
  254. {
  255. UWORD SprNum;
  256. int i,LowRange,HighRange;
  257. struct Sprite *FirstSprPtr,*NextSprPtr;
  258.  
  259. SprNum = SpritePtr->SpriteNumber;
  260. FirstSprPtr = SpritePtr - SprNum;    /*  Get pointer to first sprite  */
  261.  
  262. switch(Mode)
  263.   {
  264.   case CURRENT :
  265.       LowRange = SprNum;
  266.       HighRange = SprNum;
  267.       NextSprPtr = SpritePtr;
  268.   break;
  269.   case ALL :
  270.        LowRange = LOW_SPRITE;
  271.        HighRange = HIGH_SPRITE;
  272.        NextSprPtr = FirstSprPtr;
  273.   break;
  274.   case FROM :
  275.        LowRange = SprNum;
  276.        HighRange = HIGH_SPRITE;
  277.        NextSprPtr = SpritePtr;
  278.   break;
  279.   case UP_TO :
  280.        LowRange = LOW_SPRITE;
  281.        HighRange = SprNum;
  282.        NextSprPtr = FirstSprPtr;
  283.   break;
  284.   case EXCEPT :
  285.        LowRange = LOW_SPRITE;
  286.        HighRange = HIGH_SPRITE;
  287.        NextSprPtr = FirstSprPtr;
  288.   break;
  289.   };
  290.  
  291. /*  Reset colors of specified range to default colors  */
  292. for ( i = LowRange; i <= HighRange; i++ )
  293.     {
  294.     if ( Mode == EXCEPT && i == SprNum )
  295.        {
  296.        NextSprPtr++;
  297.        continue;
  298.        };
  299.  
  300.        /*  Reset colors of next sprite to default colors  */
  301.        NextSprPtr->SprColor1 = RED;
  302.        NextSprPtr->SprColor2 = GREEN;
  303.        NextSprPtr->SprColor3 = BLUE;
  304.        NextSprPtr++;
  305.     };
  306. }
  307.  
  308.  
  309. /*  Clear sprite data to zero  */
  310. ClearSprData(SpriteDataPtr)
  311. UWORD *SpriteDataPtr;
  312. {
  313. UBYTE *SrcPtr;
  314.  
  315. SrcPtr = (UBYTE *) SpriteDataPtr;
  316. BltClear(SrcPtr,SPRITE_SIZE * sizeof(UWORD),1);
  317. }
  318.  
  319.  
  320. /*  Copy source sprite data to destination sprite data  */
  321. CopySprData(SrcData,DestData)
  322. UWORD *SrcData,*DestData;
  323. {
  324. UBYTE *SrcPtr,*DestPtr;
  325.  
  326. SrcPtr = (UBYTE *) SrcData;
  327. DestPtr = (UBYTE *) DestData;
  328. CopyMem(SrcPtr,DestPtr,SPRITE_SIZE * sizeof(UWORD));
  329. }
  330.  
  331.  
  332. /*  Copy source sprite sprite to destination sprite  */
  333. CopySprite(SrcSprite,DestSprite)
  334. struct Sprite *SrcSprite,*DestSprite;
  335. {
  336. UBYTE *SrcPtr,*DestPtr;
  337.  
  338. SrcPtr = (UBYTE *) SrcSprite;
  339. DestPtr = (UBYTE *) DestSprite;
  340. CopyMem(SrcPtr,DestPtr,SPR_STRUCT_SIZE);
  341. }
  342.  
  343.  
  344. /*  Clear posctldata and attached bits  */
  345. ClearPosCtl(SpriteDataPtr)
  346. UWORD *SpriteDataPtr;
  347. {
  348.  
  349. *SpriteDataPtr = 0;
  350. *(SpriteDataPtr + 1) = 0;
  351. *(SpriteDataPtr + 34) = 0;
  352. *(SpriteDataPtr + 35) = 0;
  353. }
  354.  
  355.  
  356. /*  Shift left for sprite data  */
  357. ShiftLeft(HighWordPtr,LowWordPtr)
  358. UWORD *HighWordPtr,*LowWordPtr;
  359. {
  360. UWORD HighWord,LowWord;
  361. LONG BitVal;
  362.  
  363. /*  Shift high word to the left by one bit  */
  364. HighWord = *HighWordPtr;
  365. if ( (HighWord & HIGH_BIT) != 0 )
  366.    BitVal = LOW_BIT;
  367. else
  368.    BitVal = 0;
  369. HighWord = (HighWord << 1) | BitVal;
  370. *HighWordPtr = HighWord;
  371.  
  372. /*  Shift low word to the left by one bit  */
  373. LowWord = *LowWordPtr;
  374. if ( (LowWord & HIGH_BIT) != 0 )
  375.    BitVal = LOW_BIT;
  376. else
  377.    BitVal = 0;
  378. LowWord = (LowWord << 1) | BitVal;
  379. *LowWordPtr = LowWord;
  380. }
  381.  
  382.  
  383. /*  Shift right for sprite data  */
  384. ShiftRight(HighWordPtr,LowWordPtr)
  385. UWORD *HighWordPtr,*LowWordPtr;
  386. {
  387. UWORD HighWord,LowWord;
  388. LONG BitVal;
  389.  
  390. /*  Shift high word to the right by one bit  */
  391. HighWord = *HighWordPtr;
  392. if ( (HighWord & LOW_BIT) != 0 )
  393.    BitVal = HIGH_BIT;
  394. else
  395.    BitVal = 0;
  396. HighWord = (HighWord >> 1) | BitVal;
  397. *HighWordPtr = HighWord;
  398.  
  399. /*  Shift low word to the right by one bit  */
  400. LowWord = *LowWordPtr;
  401. if ( (LowWord & LOW_BIT) != 0 )
  402.    BitVal = HIGH_BIT;
  403. else
  404.    BitVal = 0;
  405. LowWord = (LowWord >> 1) | BitVal;
  406. *LowWordPtr = LowWord;
  407. }
  408.  
  409.  
  410. /*  Allocate edit sprite  */
  411. AllocSprite(SpritePtr,SprNum)
  412. struct SimpleSprite *SpritePtr;
  413. LONG SprNum;
  414. {
  415.  
  416. if ( GetSprite(SpritePtr,SprNum) != SprNum )
  417.    {
  418.    printf("Could not allocate edit Sprite! \n");
  419.    exit(1);
  420.    };
  421.  
  422. SpritePtr->height = 16;
  423. SpritePtr->x = 500;
  424. SpritePtr->y = 120;
  425. SpritePtr->num = SprNum;
  426. }
  427.  
  428.  
  429. /*  Set a ViewPort color register from a Packed UWORD  */
  430. SetPackedRGB(VPortPtr,ColorVal,ColorReg)
  431. struct ViewPort *VPortPtr;
  432. UWORD ColorVal;
  433. ULONG ColorReg;
  434. {
  435. ULONG RedBits,GreenBits,BlueBits;
  436.  
  437. UnPackRGB(ColorVal,&RedBits,&GreenBits,&BlueBits);
  438. SetRGB4(VPortPtr,ColorReg,RedBits,GreenBits,BlueBits);
  439. }
  440.  
  441.  
  442. /*  Determine RGB values based on packed UWORD  */
  443. UnPackRGB(ColorVal,RedPtr,GreenPtr,BluePtr)
  444. UWORD ColorVal;
  445. ULONG *RedPtr,*GreenPtr,*BluePtr;
  446. {
  447. *RedPtr = (ColorVal >> 8) & 0xf;
  448. *GreenPtr = (ColorVal >> 4) & 0xf;
  449. *BluePtr = ColorVal & 0xf;
  450. }
  451.  
  452.  
  453. /*  Pack RGB Values into a single UWORD  */
  454. UWORD PackRGB(RedBits,GreenBits,BlueBits)
  455. ULONG RedBits,GreenBits,BlueBits;
  456. {
  457. UWORD ColorVal;
  458.  
  459. RedBits = (RedBits << 8) & 0xf00;
  460. GreenBits = (GreenBits << 4) & 0x0f0;
  461. BlueBits = BlueBits & 0x00f;
  462.  
  463. ColorVal = RedBits | GreenBits | BlueBits;
  464. return(ColorVal);
  465. }
  466.  
  467.  
  468. /*  Initialize borders for gadgets and requesters  */
  469. InitBorder(PointsPtr,BorderPtr,Width,Height)
  470. struct Points *PointsPtr;
  471. struct Border *BorderPtr;
  472. SHORT Width,Height;
  473. {
  474. /*  Define points structure for gadget border  */
  475. PointsPtr->X1 = PointsPtr->X5 = 0;
  476. PointsPtr->Y1 = PointsPtr->Y5 = 0;
  477. PointsPtr->X2 = Width;
  478. PointsPtr->Y2 = 0;
  479. PointsPtr->X3 = Width;
  480. PointsPtr->Y3 = Height;
  481. PointsPtr->X4 = 0;
  482. PointsPtr->Y4 = Height;
  483.  
  484. /*  Initialize border  */
  485. BorderPtr->LeftEdge = 0;
  486. BorderPtr->TopEdge = 0;
  487. BorderPtr->FrontPen = COLOR04;
  488. BorderPtr->BackPen = COLOR00;
  489. BorderPtr->DrawMode = JAM1;
  490. BorderPtr->Count = 5;
  491. BorderPtr->XY = (SHORT *) PointsPtr;
  492. BorderPtr->NextBorder = NULL;
  493. }
  494.  
  495. /*  Check if animation sequence is valid  -  Convert to upper case  */
  496. BOOL CheckSequence(StrPtr)
  497. char *StrPtr;
  498. {
  499. char NextChar;
  500.  
  501. while ( *StrPtr != NULL )
  502.   {
  503.   NextChar = *StrPtr;
  504.   NextChar = ( isupper(NextChar) ? NextChar : toupper(NextChar) );
  505.   if ( NextChar < 'A' || NextChar > 'Z' )
  506.      return(FALSE);
  507.   else
  508.      *StrPtr++ = NextChar;
  509.   };
  510.  
  511. return(TRUE);
  512. }
  513.  
  514.  
  515. /*  Get a random number between 0 and MaxRange  */
  516. unsigned int GetRand(MaxRange)
  517. int MaxRange;
  518. {
  519. int Divisor,Value;
  520.  
  521. Divisor = MAX_INT/MaxRange;
  522. Value = rand()/Divisor;
  523. return(Value);
  524. }
  525.  
  526.  
  527. /*  Seed random number generator based on the current time  */
  528. SetSeed()
  529. {
  530. ULONG Seconds,MicroSeconds;
  531. unsigned int IntSeconds;
  532.  
  533. CurrentTime(&Seconds,&MicroSeconds);
  534. IntSeconds = (unsigned int) Seconds;
  535. srand(IntSeconds);
  536. }
  537.  
  538. /*  Refresh sprite number display  */
  539. RefreshSprNum(Rp,SprNum)
  540. struct RastPort *Rp;
  541. UWORD SprNum;
  542. {
  543. char SprNumStr[25];
  544. LONG Len;
  545.  
  546. sprintf(SprNumStr,"Sprite = %c",SprNum + 65);
  547. Len = (LONG) strlen(SprNumStr);
  548. SetAPen(Rp,COLOR04);
  549. Move(Rp,511,25);
  550. Text(Rp,SprNumStr,Len);
  551. }
  552.  
  553.  
  554. /*  Refresh grid (X,Y) coordinates  */
  555. RefreshGridXY(Rp,Row,Column)
  556. struct RastPort *Rp;
  557. LONG Row,Column;
  558. {
  559. char CoordStr[50];
  560. LONG Len;
  561.  
  562. sprintf(CoordStr,"Row = %02d    Column = %02d",Row,Column);
  563. Len = (LONG) strlen(CoordStr);
  564. SetAPen(Rp,COLOR04);
  565. Move(Rp,300,25);
  566. Text(Rp,CoordStr,Len);
  567. }
  568.  
  569.  
  570. /*  Refresh current edit mode  */
  571. RefreshMode(Rp,ModeStr)
  572. struct RastPort *Rp;
  573. char *ModeStr;
  574. {
  575. LONG Len;
  576. char OutStr[80];
  577.  
  578. sprintf(OutStr,"Mode : %s",ModeStr);
  579. Len = (LONG) strlen(OutStr);
  580. SetAPen(Rp,COLOR04);
  581. Move(Rp,25,193);
  582. Text(Rp,OutStr,Len);
  583. }
  584.  
  585.