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