home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1999 Spring / macformat-077.iso / Shareware Plus / Development / SpriteWorld 2.2 / SpriteWorld files / Sources / SpriteCompiler.c < prev    next >
Encoding:
Text File  |  1998-04-25  |  19.4 KB  |  925 lines  |  [TEXT/CWIE]
  1.  
  2. ///--------------------------------------------------------------------------------------
  3. //    SpriteCompiler.c
  4. //
  5. //    Portions are copyright: © 1991-94 Tony Myles, All rights reserved worldwide.
  6. //
  7. //    Description:    implementation of the sprite compiler
  8. ///--------------------------------------------------------------------------------------
  9.  
  10. #ifndef __SWCOMMON__
  11. #include "SWCommonHeaders.h"
  12. #endif
  13.  
  14. #ifndef __TYPES__
  15. #include <Types.h>
  16. #endif
  17.  
  18. #ifndef __MEMORY__
  19. #include <Memory.h>
  20. #endif
  21.  
  22. #ifndef __RESOURCES__
  23. #include <Resources.h>
  24. #endif
  25.  
  26. #ifndef __QUICKDRAW__
  27. #include <QuickDraw.h>
  28. #endif
  29.  
  30. #ifndef __SPRITEFRAME__
  31. #include "SpriteFrame.h"
  32. #endif
  33.  
  34. #ifndef __SPRITE__
  35. #include "Sprite.h"
  36. #endif
  37.  
  38. #ifndef __SPRITEWORLDUTILS__
  39. #include "SpriteWorldUtils.h"
  40. #endif
  41.  
  42. #ifndef __SPRITECOMPILER__
  43. #include "SpriteCompiler.h"
  44. #endif
  45.  
  46.  
  47. ///--------------------------------------------------------------------------------------
  48. //        SWCompileSprite
  49. ///--------------------------------------------------------------------------------------
  50.  
  51. SW_FUNC OSErr SWCompileSprite(
  52.     SpritePtr srcSpriteP)
  53. {
  54.     OSErr             err = noErr;
  55.     short            frame;
  56.  
  57. #if SW_PPC
  58.     #pragma unused(frame, srcSpriteP)
  59. #else
  60.     for (frame = 0; (err == noErr) && (frame < srcSpriteP->maxFrames); frame++)
  61.     {
  62.         err = SWCompileFrame( srcSpriteP->frameArray[frame] );
  63.     }
  64.     
  65.     SWSetStickyIfError( err );
  66. #endif
  67.     return err;
  68. }
  69.  
  70.  
  71. ///--------------------------------------------------------------------------------------
  72. //        SWCompileFrame
  73. ///--------------------------------------------------------------------------------------
  74.  
  75. SW_FUNC OSErr SWCompileFrame(
  76.     FramePtr srcFrameP)
  77. {
  78.     OSErr             err = noErr;
  79.     GWorldPtr         saveGWorld;
  80.     GDHandle         saveGDH;
  81.     PixelCodeHdl     newPixCodeH = NULL;
  82.     Boolean            lockedState;
  83.     Rect            frameRect;
  84.     unsigned long     maskBaseOffset;
  85.  
  86. #if SW_PPC    
  87.     #pragma unused(srcFrameP, saveGWorld, saveGDH, lockedState, frameRect, maskBaseOffset)
  88. #else
  89.     GetGWorld(&saveGWorld, &saveGDH);
  90.     
  91.         // can't do this stuff if the Frame is unlocked
  92.     lockedState = srcFrameP->isFrameLocked;
  93.     if ( lockedState == false )
  94.         SWLockFrame(srcFrameP);
  95.     
  96.     if ( (**srcFrameP->framePixHndl).pixelSize != 8 ||
  97.          (**srcFrameP->maskPixHndl).pixelSize != 8 )
  98.         err = kWrongDepthErr;
  99.     
  100.     if ( srcFrameP->maskPort == NULL )
  101.         err = kWrongMaskErr;
  102.         
  103.     if ( err == noErr )
  104.     {
  105.         frameRect = srcFrameP->frameRect;
  106.         maskBaseOffset = srcFrameP->
  107.             scanLinePtrArray[frameRect.top-srcFrameP->frameRect.top] + frameRect.left;
  108.                 
  109.         SetGWorld( srcFrameP->maskPort, nil );
  110.         InvertRect( &frameRect );
  111.         
  112.         err = SWParsePixels(
  113.                 // offset to the first byte of the mask
  114.             srcFrameP->maskBaseAddr + maskBaseOffset,
  115.                 // mask's rect
  116.             &frameRect,
  117.                 // bytes per scanline of mask's GWorld
  118.             srcFrameP->frameRowBytes,
  119.                 // receives handle to compiled mask
  120.             &newPixCodeH);
  121.             
  122.         InvertRect( &frameRect );
  123.         SetGWorld( saveGWorld, saveGDH );
  124.     }
  125.     if (err == noErr)
  126.     {
  127.             // get rid of old compiled mask, if any
  128.         if ( srcFrameP->pixCodeH != NULL )
  129.             DisposeHandle( (Handle)srcFrameP->pixCodeH );
  130.             // attach the new one
  131.         srcFrameP->pixCodeH = newPixCodeH;
  132.     }
  133.     
  134.     if ( lockedState == false )
  135.         SWUnlockFrame(srcFrameP);
  136.     if ( lockedState == true && err == noErr )
  137.     {
  138.         HLock((Handle)srcFrameP->pixCodeH);
  139.         srcFrameP->frameBlitterP = (BlitFuncPtr)*srcFrameP->pixCodeH;
  140.     }
  141.             
  142.     SWSetStickyIfError( err );
  143. #endif
  144.     return err;
  145. }
  146.  
  147.  
  148. ///--------------------------------------------------------------------------------------
  149. //        SWParsePixels
  150. ///--------------------------------------------------------------------------------------
  151.  
  152. SW_FUNC OSErr SWParsePixels(
  153.     Ptr maskStartAddrP,
  154.     Rect* frameRect,
  155.     unsigned long numBytesPerRow,
  156.     PixelCodeHdl* newPixCodeH)
  157. {
  158.     OSErr             err = noErr;
  159.     PixelCodeHdl     tempPixCodeH;
  160.         
  161.  
  162.     *newPixCodeH = NULL;
  163.  
  164.     tempPixCodeH = (PixelCodeHdl)NewHandle(0);
  165.  
  166.     if (tempPixCodeH != NULL)
  167.     {
  168.         long     scanLine;
  169.         long     numberOfScanLines = frameRect->bottom - frameRect->top;
  170.         
  171.         
  172.         err = SWGeneratePreamble(tempPixCodeH);
  173.  
  174.         for (scanLine = 0; (err == noErr) && (scanLine < numberOfScanLines); scanLine++)
  175.         {
  176.             err = SWCompileMaskScanLine(
  177.                 tempPixCodeH, 
  178.                 maskStartAddrP, 
  179.                 frameRect->right - frameRect->left, 
  180.                 scanLine == (numberOfScanLines-1));
  181.  
  182.             if (err == noErr)
  183.             {
  184.                 maskStartAddrP += numBytesPerRow;
  185.             }
  186.         }
  187.  
  188.         if (err == noErr)
  189.         {
  190.             err = SWGeneratePostamble(tempPixCodeH);
  191.         }
  192.  
  193.         if (err == noErr)
  194.         {
  195.             *newPixCodeH = tempPixCodeH;
  196.         }
  197.     }
  198.     else
  199.     {
  200.         err = MemError();
  201.     }
  202.  
  203.     return err;
  204. }
  205.  
  206.  
  207. ///--------------------------------------------------------------------------------------
  208. //        SWGeneratePreamble
  209. ///--------------------------------------------------------------------------------------
  210.  
  211. SW_FUNC OSErr SWGeneratePreamble(PixelCodeHdl srcPixCodeH)
  212. {
  213.     OSErr err = noErr;
  214.     Size curHandleSize;
  215.     unsigned char* scanCodeP;
  216.  
  217.     curHandleSize = GetHandleSize((Handle)srcPixCodeH);
  218.     err = MemError();
  219.  
  220.     if (err == noErr)
  221.     {
  222.         SetHandleSize((Handle)srcPixCodeH, curHandleSize + 10);
  223.         err = MemError();
  224.     }
  225.  
  226.     if (err == noErr)
  227.     {
  228.         scanCodeP = ((unsigned char*)*srcPixCodeH) + curHandleSize;
  229.         
  230.             //48E7 1F3E          MOVEM.L   D3-D7/A2-A6,-(A7)
  231.         *(unsigned long*)scanCodeP = 0x48E71F3E;
  232.         scanCodeP += 4;
  233.  
  234.             //4CEF 0303 002C     MOVEM.L   $002C(A7),D0/D1/A0/A1
  235.         *(unsigned long*)scanCodeP = 0x4CEF0303;
  236.         scanCodeP += 4;
  237.  
  238.         *(unsigned short*)scanCodeP = 0x002C;
  239.         scanCodeP += 2;
  240.     }
  241.  
  242.     return err;
  243. }
  244.  
  245. /*
  246. 00000000: 48E7 1F3E          MOVEM.L   D3-D7/A2-A6,-(A7)
  247. 00000004: 4CEF 0303 002C     MOVEM.L   $002C(A7),D0/D1/A0/A1
  248. 0000000A: 4E92               JSR       (A2)
  249. 0000000C: 4CDF 7CF8          MOVEM.L   (A7)+,D3-D7/A2-A6
  250. 00000010: 4E75               RTS
  251. */
  252.  
  253.  
  254. ///--------------------------------------------------------------------------------------
  255. //        SWGeneratePostamble
  256. ///--------------------------------------------------------------------------------------
  257.  
  258. SW_FUNC OSErr SWGeneratePostamble(PixelCodeHdl srcPixCodeH)
  259. {
  260.     OSErr err = noErr;
  261.     Size curHandleSize;
  262.     unsigned char* scanCodeP;
  263.  
  264.     curHandleSize = GetHandleSize((Handle)srcPixCodeH);
  265.     err = MemError();
  266.  
  267.     if (err == noErr)
  268.     {
  269.         SetHandleSize((Handle)srcPixCodeH, curHandleSize + 6);
  270.         err = MemError();
  271.     }
  272.  
  273.     if (err == noErr)
  274.     {
  275.         scanCodeP = ((unsigned char*)*srcPixCodeH) + curHandleSize;
  276.         
  277.             //4CDF 7CF8          MOVEM.L   (A7)+,D3-D7/A2-A6
  278.         *(unsigned long*)scanCodeP = 0x4CDF7CF8;
  279.         scanCodeP += 4;
  280.  
  281.             //4E75               RTS
  282.         *(unsigned short*)scanCodeP = 0x4E75;
  283.         scanCodeP += 2;
  284.     }
  285.  
  286.     return err;
  287. }
  288.  
  289.  
  290.  
  291. ///--------------------------------------------------------------------------------------
  292. //        SWCompileMaskScanLine
  293. ///--------------------------------------------------------------------------------------
  294.  
  295. SW_FUNC OSErr SWCompileMaskScanLine(
  296.     PixelCodeHdl newPixCodeH,
  297.     Ptr maskPixelP,
  298.     long numberOfPixels,
  299.     Boolean isLastScanLine)
  300. {
  301.     OSErr             err = noErr;
  302.     Size             curHandleSize;
  303.     unsigned char*     scanCodeP;
  304.     unsigned char*     maskScanPixelP = (unsigned char*)maskPixelP;
  305.     Size             codeSize;
  306.     long             pixelsToScan;
  307.     unsigned short     numPixelsToBlit;
  308.     unsigned short     pixelOffset;
  309.  
  310.  
  311.     curHandleSize = GetHandleSize((Handle)newPixCodeH);
  312.     err = MemError();
  313.  
  314.     if (err == noErr)
  315.     {
  316.         SetHandleSize((Handle)newPixCodeH, curHandleSize + (numberOfPixels * kMaxInstructionSize) + 4);
  317.         err = MemError();
  318.     }
  319.  
  320.     if (err == noErr)
  321.     {
  322.         scanCodeP = ((unsigned char*)*newPixCodeH) + curHandleSize;
  323.         codeSize = curHandleSize;
  324.         pixelOffset = 0;
  325.         pixelsToScan = numberOfPixels;
  326.  
  327.         while (pixelsToScan)
  328.         {
  329.             numPixelsToBlit = 0;
  330.  
  331.                 // scan for pixels to blit
  332.             while (pixelsToScan && *maskScanPixelP)
  333.             {
  334.                 maskScanPixelP++;
  335.                 numPixelsToBlit++;
  336.                 pixelsToScan--;
  337.             }
  338.  
  339.                 // generate code for the pixel run
  340.             while (numPixelsToBlit)
  341.             {
  342.                 if (numPixelsToBlit >= 44)
  343.                 {
  344.                     if (pixelOffset)
  345.                     {
  346.                             //4CE8 7CFC 0042     MOVEM.L   $0042(A0),D2-D7/A2-A6
  347.                             //48E9 7CFC 0042     MOVEM.L   D2-D7/A2-A6,$0042(A1)
  348.  
  349.                         *(unsigned long*)scanCodeP = 0x4CE87CFC;
  350.                         scanCodeP += 4;
  351.     
  352.                         *(unsigned short*)scanCodeP = pixelOffset;
  353.                         scanCodeP += 2;
  354.     
  355.                         *(unsigned long*)scanCodeP = 0x48E97CFC;
  356.                         scanCodeP += 4;
  357.     
  358.                         *(unsigned short*)scanCodeP = pixelOffset;
  359.                         scanCodeP += 2;
  360.  
  361.                         codeSize += 12;
  362.                     }
  363.                     else
  364.                     {
  365.                             //4CD0 7CFC          MOVEM.L   (A0),D2-D7/A2-A6
  366.                             //48D1 7CFC          MOVEM.L   D2-D7/A2-A6,(A1)
  367.  
  368.                         *(unsigned long*)scanCodeP = 0x4CD07CFC;
  369.                         scanCodeP += 4;
  370.     
  371.                         *(unsigned long*)scanCodeP = 0x48D17CFC;
  372.                         scanCodeP += 4;
  373.  
  374.                         codeSize += 8;
  375.                     }
  376.  
  377.                     pixelOffset += 44;
  378.                     numPixelsToBlit -= 44;
  379.                 }
  380.                 else if (numPixelsToBlit >= 40)
  381.                 {
  382.                     if (pixelOffset)
  383.                     {
  384.                             //4CD0 3CFC 0042     MOVEM.L   $0042(A0),D2-D7/A2-A5
  385.                             //48D1 3CFC 0042     MOVEM.L   D2-D7/A2-A5,$0042(A1)
  386.                         *(unsigned long*)scanCodeP = 0x4CE83CFC;
  387.                         scanCodeP += 4;
  388.     
  389.                         *(unsigned short*)scanCodeP = pixelOffset;
  390.                         scanCodeP += 2;
  391.     
  392.                         *(unsigned long*)scanCodeP = 0x48E93CFC;
  393.                         scanCodeP += 4;
  394.     
  395.                         *(unsigned short*)scanCodeP = pixelOffset;
  396.                         scanCodeP += 2;
  397.  
  398.                         codeSize += 12;
  399.                     }
  400.                     else
  401.                     {
  402.                             //4CD0 3CFC     MOVEM.L   (A0),D2-D7/A2-A5
  403.                             //48D1 3CFC     MOVEM.L   D2-D7/A2-A5,(A1)
  404.     
  405.                         *(unsigned long*)scanCodeP = 0x4CD03CFC;
  406.                         scanCodeP += 4;
  407.     
  408.                         *(unsigned long*)scanCodeP = 0x48D13CFC;
  409.                         scanCodeP += 4;
  410.     
  411.                         codeSize += 8;
  412.                     }
  413.  
  414.                     pixelOffset += 40;
  415.                     numPixelsToBlit -= 40;
  416.                 }
  417.                 else if (numPixelsToBlit >= 36)
  418.                 {
  419.                     if (pixelOffset)
  420.                     {
  421.                             //4CE8 1CFC 0042     MOVEM.L   $0042(A0),D2-D7/A2-A4
  422.                             //48E9 1CFC 0042     MOVEM.L   D2-D7/A2-A4,$0042(A1)
  423.     
  424.                         *(unsigned long*)scanCodeP = 0x4CE81CFC;
  425.                         scanCodeP += 4;
  426.     
  427.                         *(unsigned short*)scanCodeP = pixelOffset;
  428.                         scanCodeP += 2;
  429.     
  430.                         *(unsigned long*)scanCodeP = 0x48E91CFC;
  431.                         scanCodeP += 4;
  432.     
  433.                         *(unsigned short*)scanCodeP = pixelOffset;
  434.                         scanCodeP += 2;
  435.  
  436.                         codeSize += 12;
  437.                     }
  438.                     else
  439.                     {
  440.                             //4CD0 1CFC     MOVEM.L   (A0),D2-D7/A2-A4
  441.                             //48D1 1CFC     MOVEM.L   D2-D7/A2-A4,(A1)
  442.     
  443.                         *(unsigned long*)scanCodeP = 0x4CD01CFC;
  444.                         scanCodeP += 4;
  445.     
  446.                         *(unsigned long*)scanCodeP = 0x48D11CFC;
  447.                         scanCodeP += 4;
  448.     
  449.                         codeSize += 8;
  450.                     }
  451.  
  452.                     pixelOffset += 36;
  453.                     numPixelsToBlit -= 36;
  454.                 }
  455.                 else if (numPixelsToBlit >= 32)
  456.                 {
  457.                     if (pixelOffset)
  458.                     {
  459.                             //4CD0 0CFC 0042     MOVEM.L   $0042(A0),D2-D7/A2/A3
  460.                             //48D1 0CFC 0042     MOVEM.L   D2-D7/A2/A3,$0042(A1)
  461.  
  462.                         *(unsigned long*)scanCodeP = 0x4CE80CFC;
  463.                         scanCodeP += 4;
  464.     
  465.                         *(unsigned short*)scanCodeP = pixelOffset;
  466.                         scanCodeP += 2;
  467.     
  468.                         *(unsigned long*)scanCodeP = 0x48E90CFC;
  469.                         scanCodeP += 4;
  470.     
  471.                         *(unsigned short*)scanCodeP = pixelOffset;
  472.                         scanCodeP += 2;
  473.  
  474.                         codeSize += 12;
  475.                     }
  476.                     else
  477.                     {
  478.                             //4CD0 0CFC     MOVEM.L   (A0),D2-D7/A2/A3
  479.                             //48D1 0CFC     MOVEM.L   D2-D7/A2/A3,(A1)
  480.     
  481.                         *(unsigned long*)scanCodeP = 0x4CD00CFC;
  482.                         scanCodeP += 4;
  483.     
  484.                         *(unsigned long*)scanCodeP = 0x48D10CFC;
  485.                         scanCodeP += 4;
  486.     
  487.                         codeSize += 8;
  488.                     }
  489.  
  490.                     pixelOffset += 32;
  491.                     numPixelsToBlit -= 32;
  492.                 }
  493.                 else if (numPixelsToBlit >= 28)
  494.                 {
  495.                     if (pixelOffset)
  496.                     {
  497.                             //4CE8 04FC 0042     MOVEM.L   $0042(A0),D2-D7/A2
  498.                             //48E9 04FC 0042     MOVEM.L   D2-D7/A2,$0042(A1)
  499.     
  500.                         *(unsigned long*)scanCodeP = 0x4CE804FC;
  501.                         scanCodeP += 4;
  502.     
  503.                         *(unsigned short*)scanCodeP = pixelOffset;
  504.                         scanCodeP += 2;
  505.     
  506.                         *(unsigned long*)scanCodeP = 0x48E904FC;
  507.                         scanCodeP += 4;
  508.     
  509.                         *(unsigned short*)scanCodeP = pixelOffset;
  510.                         scanCodeP += 2;
  511.  
  512.                         codeSize += 12;
  513.                     }
  514.                     else
  515.                     {
  516.                             //4CD0 04FC     MOVEM.L   (A0),D2-D7/A2
  517.                             //48D1 04FC     MOVEM.L   D2-D7/A2,(A1)
  518.     
  519.                         *(unsigned long*)scanCodeP = 0x4CD004FC;
  520.                         scanCodeP += 4;
  521.     
  522.                         *(unsigned long*)scanCodeP = 0x48D104FC;
  523.                         scanCodeP += 4;
  524.     
  525.                         codeSize += 8;
  526.                     }
  527.  
  528.                     pixelOffset += 28;
  529.                     numPixelsToBlit -= 28;
  530.                 }
  531.                 else if (numPixelsToBlit >= 24)
  532.                 {
  533.                     if (pixelOffset)
  534.                     {
  535.                             //4CE8 00FC 0042     MOVEM.L   $0042(A0),D2-D7
  536.                             //48E9 00FC 0042     MOVEM.L   D2-D7,$0042(A1)
  537.                         *(unsigned long*)scanCodeP = 0x4CE800FC;
  538.                         scanCodeP += 4;
  539.     
  540.                         *(unsigned short*)scanCodeP = pixelOffset;
  541.                         scanCodeP += 2;
  542.     
  543.                         *(unsigned long*)scanCodeP = 0x48E900FC;
  544.                         scanCodeP += 4;
  545.     
  546.                         *(unsigned short*)scanCodeP = pixelOffset;
  547.                         scanCodeP += 2;
  548.  
  549.                         codeSize += 12;
  550.                     }
  551.                     else
  552.                     {
  553.                             //4CD0 00FC          MOVEM.L   (A0),D2-D7
  554.                             //48D1 00FC          MOVEM.L   D2-D7,(A1)
  555.                         *(unsigned long*)scanCodeP = 0x4CD000FC;
  556.                         scanCodeP += 4;
  557.     
  558.                         *(unsigned long*)scanCodeP = 0x48D100FC;
  559.                         scanCodeP += 4;
  560.     
  561.                         codeSize += 8;
  562.                     }
  563.  
  564.                     pixelOffset += 24;
  565.                     numPixelsToBlit -= 24;
  566.                 }
  567.                 else if (numPixelsToBlit >= 20)
  568.                 {
  569.                     if (pixelOffset)
  570.                     {
  571.                             //4CE8 007C 0042     MOVEM.L   $0042(A0),D2-D6
  572.                             //48E9 007C 0042     MOVEM.L   D2-D6,$0042(A1)
  573.                         *(unsigned long*)scanCodeP = 0x4CE8007C;
  574.                         scanCodeP += 4;
  575.     
  576.                         *(unsigned short*)scanCodeP = pixelOffset;
  577.                         scanCodeP += 2;
  578.     
  579.                         *(unsigned long*)scanCodeP = 0x48E9007C;
  580.                         scanCodeP += 4;
  581.     
  582.                         *(unsigned short*)scanCodeP = pixelOffset;
  583.                         scanCodeP += 2;
  584.  
  585.                         codeSize += 12;
  586.                     }
  587.                     else
  588.                     {
  589.                             //4CD0 007C          MOVEM.L   (A0),D2-D6
  590.                             //48D1 007C          MOVEM.L   D2-D6,(A1)
  591.                         *(unsigned long*)scanCodeP = 0x4CD0007C;
  592.                         scanCodeP += 4;
  593.     
  594.                         *(unsigned long*)scanCodeP = 0x48D1007C;
  595.                         scanCodeP += 4;
  596.     
  597.                         codeSize += 8;
  598.                     }
  599.  
  600.                     pixelOffset += 20;
  601.                     numPixelsToBlit -= 20;
  602.                 }
  603.                 else if (numPixelsToBlit >= 16)
  604.                 {
  605.                     if (pixelOffset)
  606.                     {
  607.                             //4CE8 003C 0042     MOVEM.L   $0042(A0),D2-D5
  608.                             //48E9 003C 0042     MOVEM.L   D2-D5,$0042(A1)
  609.                         *(unsigned long*)scanCodeP = 0x4CE8003C;
  610.                         scanCodeP += 4;
  611.     
  612.                         *(unsigned short*)scanCodeP = pixelOffset;
  613.                         scanCodeP += 2;
  614.     
  615.                         *(unsigned long*)scanCodeP = 0x48E9003C;
  616.                         scanCodeP += 4;
  617.     
  618.                         *(unsigned short*)scanCodeP = pixelOffset;
  619.                         scanCodeP += 2;
  620.  
  621.                         codeSize += 12;
  622.                     }
  623.                     else
  624.                     {
  625.                             //4CD0 003C     MOVEM.L   (A0),D2-D5
  626.                             //48D1 003C     MOVEM.L   D2-D5,(A1)
  627.                         *(unsigned long*)scanCodeP = 0x4CD0003C;
  628.                         scanCodeP += 4;
  629.     
  630.                         *(unsigned long*)scanCodeP = 0x48D1003C;
  631.                         scanCodeP += 4;
  632.     
  633.                         codeSize += 8;
  634.                     }
  635.  
  636.                     pixelOffset += 16;
  637.                     numPixelsToBlit -= 16;
  638.                 }
  639.                 else if (numPixelsToBlit >= 12)
  640.                 {
  641.                     if (pixelOffset)
  642.                     {
  643.                             //4CE8 001C 0042     MOVEM.L   $0042(A0),D2-D4
  644.                             //48E9 001C 0042     MOVEM.L   D2-D4,$0042(A1)
  645.                         *(unsigned long*)scanCodeP = 0x4CE8001C;
  646.                         scanCodeP += 4;
  647.     
  648.                         *(unsigned short*)scanCodeP = pixelOffset;
  649.                         scanCodeP += 2;
  650.     
  651.                         *(unsigned long*)scanCodeP = 0x48E9001C;
  652.                         scanCodeP += 4;
  653.     
  654.                         *(unsigned short*)scanCodeP = pixelOffset;
  655.                         scanCodeP += 2;
  656.  
  657.                         codeSize += 12;
  658.                     }
  659.                     else
  660.                     {
  661.                             //4CD0 001C     MOVEM.L   (A0),D2-D4
  662.                             //48D1 001C     MOVEM.L   D2-D4,(A1)
  663.                         *(unsigned long*)scanCodeP = 0x4CD0001C;
  664.                         scanCodeP += 4;
  665.     
  666.                         *(unsigned long*)scanCodeP = 0x48D1001C;
  667.                         scanCodeP += 4;
  668.     
  669.                         codeSize += 8;
  670.                     }
  671.  
  672.                     pixelOffset += 12;
  673.                     numPixelsToBlit -= 12;
  674.                 }
  675.                 else if (numPixelsToBlit >= 4)
  676.                 {
  677.                     if (pixelOffset)
  678.                     {
  679.                             //2368 0066 0066     MOVE.L    $0066(A0),$0066(A1)
  680.     
  681.                         *(unsigned short*)scanCodeP = 0x2368;
  682.                         scanCodeP += 2;
  683.     
  684.                         *(unsigned short*)scanCodeP = pixelOffset;
  685.                         scanCodeP += 2;
  686.     
  687.                         *(unsigned short*)scanCodeP = pixelOffset;
  688.                         scanCodeP += 2;
  689.  
  690.                         codeSize += 6;
  691.                     }
  692.                     else
  693.                     {
  694.                             //2290               MOVE.L    (A0),(A1)
  695.  
  696.                         *(unsigned short*)scanCodeP = 0x2290;
  697.                         scanCodeP += 2;
  698.  
  699.                         codeSize += 2;
  700.                     }
  701.  
  702.                     pixelOffset += 4;
  703.                     numPixelsToBlit -= 4;
  704.                 }
  705.                 else if (numPixelsToBlit >= 2)
  706.                 {
  707.                     if (pixelOffset)
  708.                     {
  709.                             //3368 0066 0066     MOVE.W    $0066(A0),$0066(A1)
  710.     
  711.                         *(unsigned short*)scanCodeP = 0x3368;
  712.                         scanCodeP += 2;
  713.     
  714.                         *(unsigned short*)scanCodeP = pixelOffset;
  715.                         scanCodeP += 2;
  716.     
  717.                         *(unsigned short*)scanCodeP = pixelOffset;
  718.                         scanCodeP += 2;
  719.  
  720.                         codeSize += 6;
  721.                     }
  722.                     else
  723.                     {
  724.                             //3290               MOVE.W    (A0),(A1)
  725.  
  726.                         *(unsigned short*)scanCodeP = 0x3290;
  727.                         scanCodeP += 2;
  728.  
  729.                         codeSize += 2;
  730.                     }
  731.  
  732.                     pixelOffset += 2;
  733.                     numPixelsToBlit -= 2;
  734.                 }
  735.                 else if (numPixelsToBlit == 1)
  736.                 {
  737.                     if (pixelOffset)
  738.                     {
  739.                             //1368 0066 0066     MOVE.B    $0066(A0),$0066(A1)
  740.     
  741.                         *(unsigned short*)scanCodeP = 0x1368;
  742.                         scanCodeP += 2;
  743.     
  744.                         *(unsigned short*)scanCodeP = pixelOffset;
  745.                         scanCodeP += 2;
  746.     
  747.                         *(unsigned short*)scanCodeP = pixelOffset;
  748.                         scanCodeP += 2;
  749.  
  750.                         codeSize += 6;
  751.                     }
  752.                     else
  753.                     {
  754.                             //1290               MOVE.B    (A0),(A1)
  755.  
  756.                         *(unsigned short*)scanCodeP = 0x1290;
  757.                         scanCodeP += 2;
  758.  
  759.                         codeSize += 2;
  760.                     }
  761.  
  762.                     pixelOffset++;
  763.                     numPixelsToBlit--;
  764.                 }
  765.             }
  766.  
  767.                 // scan for pixels to skip
  768.             while (pixelsToScan && !*maskScanPixelP)
  769.             {
  770.                 pixelOffset++;
  771.                 maskScanPixelP++;
  772.                 pixelsToScan--;
  773.             }
  774.         }
  775.  
  776.         if (!isLastScanLine)
  777.         {
  778.                 //D1C0               ADDA.L    D0,A0
  779.             *(unsigned short*)scanCodeP = 0xD1C0;
  780.             scanCodeP += 2;
  781.  
  782.                 //D3C1               ADDA.L    D1,A1
  783.             *(unsigned short*)scanCodeP = 0xD3C1;
  784.             scanCodeP += 2;
  785.  
  786.             codeSize += 4;
  787.         }
  788.  
  789.         SetHandleSize((Handle)newPixCodeH, codeSize);
  790.         err = MemError();
  791.     }
  792.  
  793.     return err;
  794. }
  795.  
  796.  
  797.  
  798.  
  799. #if 0
  800.  
  801. void x(void);
  802.  
  803. SW_ASM_FUNC void x(void)                // See "Sex Lies and Video Games" by Bill Hensler
  804. {                                        // for info on a compiled sprite algorithm like
  805.         SW_ASM_BEGIN                    // this one.
  806.  
  807.         movem.l    d3-d7/a2-a6,-(sp)        // save off regs
  808.         movem.l 44(sp),d0/d1/a0-a1        // blast the parameters into registers (cool!)
  809.         jsr        (a2)                    // jump into the blitter
  810.         movem.l    (sp)+,d3-d7/a2-a6        // restore regs
  811.         rts
  812.  
  813.             // move 44 bytes
  814.         movem.l    66(a0), d2-d7/a2-a6
  815.         movem.l d2-d7/a2-a6, 66(a1)        // 66 (0x0042) is a dummy number, replaced by
  816.                                         // pixelOffset in the actual compiled code
  817.             // move 40 bytes
  818.         movem.l    66(a0), d2-d7/a2-a5
  819.         movem.l d2-d7/a2-a5, 66(a1)
  820.  
  821.             // move 36 bytes
  822.         movem.l    66(a0), d2-d7/a2-a4
  823.         movem.l d2-d7/a2-a4, 66(a1)
  824.  
  825.             // move 32 bytes
  826.         movem.l    66(a0), d2-d7/a2/a3
  827.         movem.l d2-d7/a2/a3, 66(a1)
  828.  
  829.             // move 28 bytes
  830.         movem.l    66(a0), d2-d7/a2
  831.         movem.l d2-d7/a2, 66(a1)
  832.  
  833.             // move 24 bytes
  834.         movem.l    66(a0), d2-d7
  835.         movem.l d2-d7, 66(a1)
  836.  
  837.             // move 20 bytes
  838.         movem.l    66(a0), d2-d6
  839.         movem.l d2-d6, 66(a1)
  840.  
  841.             // move 16 bytes
  842.         movem.l    66(a0), d2-d5
  843.         movem.l d2-d5, 66(a1)
  844.  
  845.             // move 12 bytes
  846.         movem.l    66(a0), d2-d4
  847.         movem.l d2-d4, 66(a1)
  848.  
  849.  
  850.  
  851.             // move 44 bytes (no offset)
  852.         movem.l (a0), d2-d7/a2-a6
  853.         movem.l d2-d7/a2-a6, (a1)
  854.  
  855.             // move 40 bytes
  856.         movem.l    (a0), d2-d7/a2-a5
  857.         movem.l d2-d7/a2-a5, (a1)
  858.  
  859.             // move 36 bytes
  860.         movem.l    (a0), d2-d7/a2-a4
  861.         movem.l d2-d7/a2-a4, (a1)
  862.  
  863.             // move 32 bytes
  864.         movem.l    (a0), d2-d7/a2/a3
  865.         movem.l d2-d7/a2/a3, (a1)
  866.  
  867.             // move 28 bytes
  868.         movem.l    (a0), d2-d7/a2
  869.         movem.l d2-d7/a2, (a1)
  870.  
  871.             // move 24 bytes
  872.         movem.l    (a0), d2-d7
  873.         movem.l d2-d7, (a1)
  874.  
  875.             // move 20 bytes
  876.         movem.l    (a0), d2-d6
  877.         movem.l d2-d6, (a1)
  878.  
  879.             // move 16 bytes
  880.         movem.l    (a0), d2-d5
  881.         movem.l d2-d5, (a1)
  882.  
  883.             // move 12 bytes
  884.         movem.l    (a0), d2-d4
  885.         movem.l d2-d4, (a1)
  886.  
  887.  
  888.  
  889.         move.l    0x66(a0),0x66(a1)
  890.         move.w    0x66(a0),0x66(a1)
  891.         move.b    0x66(a0),0x66(a1)
  892.  
  893.         move.l    (a0),(a1)
  894.         move.w    (a0),(a1)
  895.         move.b    (a0),(a1)
  896.  
  897.         move.l    (a0)+,0x66(a1)
  898.         move.w    (a0)+,0x66(a1)
  899.         move.b    (a0)+,0x66(a1)
  900.  
  901.         move.l    (a0)+,(a1)+
  902.         move.w    (a0)+,(a1)+
  903.         move.b    (a0)+,(a1)+
  904.  
  905.         adda.l    d0, a0
  906.         adda.l    d1, a1
  907.  
  908.         adda.l    a2, a0
  909.         adda.l    a3, a1
  910.  
  911.  
  912.         add.l    #9,a1
  913.         addq.l    #8,a1
  914.         lea        6666(a0),a0
  915.         lea        6666(a1),a1
  916.         lea        6(a1),a1
  917.  
  918.         SW_ASM_END
  919. }
  920.  
  921. #endif
  922.  
  923.  
  924.  
  925.