home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 2000 November: Tool Chest / Dev.CD Nov 00 TC Disk 1.toast / Sample Code / Contributed / SpriteWorld / SpriteWorld Files / BlitPixie / Sources / BlitPixieCodeCompiler.c < prev    next >
Encoding:
Text File  |  2000-10-06  |  17.4 KB  |  831 lines  |  [TEXT/CWIE]

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