home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 324.lha / BLITTER.c < prev    next >
C/C++ Source or Header  |  1989-11-30  |  15KB  |  691 lines
  1. /*
  2.  * BLITTER.c
  3.  *
  4.  * PROGRAMMER : Gregg A. Tavares 
  5.  *    VERSION : 00.002
  6.  *    CREATED : 08/22/89 
  7.  *   MODIFIED : 10/25/89
  8.  *
  9.  * DESCRIPTION
  10.  *   various BLITTER routines for manipulating graphic images.
  11.  *
  12.  * NOTES
  13.  *   Set ClipLeft, ClipTop, ClipWidth and ClipHeight to the
  14.  *   maximum area you want effected in your destination BitMap.
  15.  *
  16.  *   This code was written with Manx C68k 3.6a with the +l option
  17.  *   (32 bit ints) I don't know what if anything you'll have to
  18.  *   change to use it with out that option or with another compiler.
  19.  *
  20.  *   You must also add -L100 to compile with Manx.
  21.  *
  22.  * COPYWRONG
  23.  *   I hereby place this code IN THE PUBLIC DOMAIN.  Use it, Sell it,
  24.  *   burn it, frame it, worship it, whatever makes your pants smoke :-)
  25.  *
  26.  * DISCLAIMER
  27.  *   If this code causes you or any one you know any problems don't
  28.  *   come crying to me! ;-)
  29.  *
  30.  * HISTORY
  31.  *    9/6/89 Wednesday
  32.  *      Made CopyBitMap work non-distructively when copying on the same
  33.  *      BitMap.
  34.  *
  35. */
  36.  
  37. short    ClipLeft    = 0;
  38. short    ClipTop        = 0;    
  39. short    ClipHeight    = 320;
  40. short    ClipWidth    = 200;
  41.  
  42. #include <exec/types.h>
  43. #include <hardware/blit.h>
  44. #include <hardware/dmabits.h>
  45. #include <hardware/custom.h>
  46. #include <graphics/gfx.h>
  47.  
  48. /* remove the following macros if they are standard in your 'C' */
  49.  
  50. #ifndef OKAY
  51. #define OKAY        1
  52. #endif
  53.  
  54. #ifndef NULL
  55. #define NULL        0L
  56. #endif
  57.  
  58. #ifndef FALSE
  59. #define FALSE        0L
  60. #endif
  61.  
  62. #ifndef TRUE
  63. #define TRUE        (!FALSE)
  64. #endif
  65.  
  66. #ifndef abs
  67. #define    abs(value)    (((value) < 0) ? -(value) : (value))
  68. #endif
  69.  
  70. #ifndef min
  71. #define    min(a,b)    (((a) < (b)) ? (a) : (b))
  72. #endif
  73.  
  74. #ifndef max
  75. #define    max(a,b)    (((a) > (b)) ? (a) : (b))
  76. #endif
  77.  
  78. #ifndef sign
  79. #define sign(value)    (((value) > 0) - ((value) < 0))
  80. #endif
  81.  
  82. #define WAITFORBLITTER    while(custom.dmaconr & DMAF_BLTDONE);
  83.  
  84. /* 
  85. #define DEBUG 1
  86. */
  87.  
  88. #if DEBUG
  89. typedef struct {
  90.     UWORD bltddat;
  91.     UWORD bltcon0;
  92.     UWORD bltcon1;
  93.     UWORD bltafwm;
  94.     UWORD bltalwm;
  95.     APTR bltcpt;
  96.     APTR bltbpt;
  97.     APTR bltapt;
  98.     APTR bltdpt;
  99.     UWORD bltsize;
  100.     UWORD bltcmod;
  101.     UWORD bltbmod;
  102.     UWORD bltamod;
  103.     UWORD bltdmod;
  104.     UWORD bltcdat;
  105.     UWORD bltbdat;
  106.     UWORD bltadat;
  107. } BLITTER;
  108. #else
  109. typedef struct Custom BLITTER;
  110. #endif
  111.  
  112. #if DEBUG
  113. void dorealblit (hardware)
  114.     BLITTER *hardware;
  115. {
  116.     OwnBlitter ();
  117.  
  118.     WAITFORBLITTER
  119.  
  120.     custom.bltddat = hardware->bltddat;
  121.     custom.bltcon0 = hardware->bltcon0;
  122.     custom.bltcon1 = hardware->bltcon1;
  123.     custom.bltafwm = hardware->bltafwm;
  124.     custom.bltalwm = hardware->bltalwm;
  125.     custom.bltcpt  = hardware->bltcpt;
  126.     custom.bltbpt  = hardware->bltbpt;
  127.     custom.bltapt  = hardware->bltapt;
  128.     custom.bltdpt  = hardware->bltdpt;
  129.     custom.bltcmod = hardware->bltcmod;
  130.     custom.bltbmod = hardware->bltbmod;
  131.     custom.bltamod = hardware->bltamod;
  132.     custom.bltdmod = hardware->bltdmod;
  133.     custom.bltcdat = hardware->bltcdat;
  134.     custom.bltbdat = hardware->bltbdat;
  135.     custom.bltadat = hardware->bltadat;
  136.     custom.bltsize = hardware->bltsize;
  137.  
  138.     DisownBlitter ();
  139. }
  140. #endif
  141.  
  142. #if 0
  143.     if (!mask && !tsbit && !tebit && !fsbit && !febit) {
  144.         /*
  145.          * Use Special Quick Blit.
  146.          */
  147.     } else if (!mask) {
  148.     } else {
  149. #endif
  150. /**************************************************************************
  151.  *
  152.  * CopyMaskBitMap
  153.  *
  154.  * SYNOPSIS
  155.  *    void CopyMaskBitMap (
  156.  *                struct BitMap *frombm,
  157.  *                int            fromleft,  
  158.  *                int            fromtop,
  159.  *                struct BitMap *tobm,
  160.  *                int            toleft,
  161.  *                int            totop,
  162.  *                int            width,
  163.  *                int            height,
  164.  *                UBYTE         planemask,
  165.  *          UBYTE        *mask
  166.  *                );
  167.  *
  168.  * FUNCTION
  169.  *    Use the blitter to copy from one bitmap to another using a mask
  170.  *    for transparency.  As far as I can tell if you are blitting from
  171.  *    a one word source into a two word destination (example: pixels
  172.  *    10<->13 to 14<->17) you must use two blits (yech!) in the generic
  173.  *    case.  If are always blitting entire shape clipped to word boundries
  174.  *    then use ShapeBlit().
  175.  *
  176.  * INPUTS
  177.  *    frombm    = pointer to bitmap to copy from
  178.  *    fromleft  = x position to start copying from
  179.  *    fromtop   = y position to start copying from
  180.  *    tobm      = pointer to bitmap to copy to
  181.  *    toleft    = x position to start copying to
  182.  *    totop     = y position to start copying to
  183.  *    width     = width in pixels of area to copy
  184.  *    height    = height in pixels of area to copy
  185.  *    planemask = bitmask of planes to effect, bit0 = plane 0, bit1 = plane1...
  186.  *    mask      = optional pointer to a mask bitplane of same size as a
  187.  *                bitplane in frombm->Planes[0].
  188.  *
  189.  * BUGS
  190.  *   NOTE: If you copy from LEFT to RIGHT or TOP to BOTTOM from a bitmap
  191.  *         to the SAME bitmap and the areas overlap the area will be trashed
  192.  *         (or smeared)
  193.  *
  194.  * HISTORY
  195.  *
  196.  *
  197.  * SEE ALSO
  198.  *   ShapeBlit (), CopyBitMap ()
  199. */
  200.  
  201. void CopyMaskBitMap (
  202.     frombm,
  203.     fromleft,
  204.     fromtop,
  205.     tobm,
  206.     toleft,
  207.     totop,
  208.     inwidth,
  209.     inheight,
  210.     planemask,
  211.     mask
  212. )
  213.     struct BitMap    *frombm;
  214.     int         fromleft;
  215.     int         fromtop;
  216.     struct BitMap    *tobm;
  217.     int         toleft;
  218.     int         totop;
  219.     int         inwidth;
  220.     int         inheight;
  221.     UBYTE         planemask;
  222.     UBYTE        *mask;
  223. {
  224.     register ULONG         fromoffset;
  225.     register ULONG         tooffset;
  226.          BLITTER     h;
  227.     register BLITTER    *hardware = 
  228. #if DEBUG
  229.                         &h;
  230. #else
  231.                         (struct Custom *)0x0DFF000;
  232. #endif
  233.     UWORD        fsword;
  234.     UWORD        tsword;
  235.     UWORD        newwidth;
  236.     UWORD        fend;
  237.     UWORD        tend;
  238.     UWORD        fsbit;
  239.     UWORD        tsbit;
  240.     UWORD        febit;
  241.     UWORD        tebit;
  242.     UWORD        frommod;
  243.     UWORD        tomod;
  244.     UWORD        shift;
  245.     UWORD        bltshift;
  246.     UWORD        fbwidth;
  247.     UWORD        tbwidth;
  248.     UWORD        bltwidth;
  249.     ULONG        toptr;
  250.     UWORD        size;
  251.     UWORD        firstmask;
  252.     UWORD        lastmask;
  253.     UWORD        othermask;
  254.     UWORD        ndx;
  255.     UWORD        depth;
  256.     UWORD        more;
  257.     UBYTE        tempmask;
  258.  
  259. /* --------------------------------------------------------------------- */
  260.     int width  = inwidth; 
  261.     int height = inheight;
  262.  
  263.     if (toleft < ClipLeft) {
  264.         width      = inwidth - (ClipLeft - toleft);
  265.         toleft      = ClipLeft;
  266.         fromleft += inwidth - width;
  267.     } else if (toleft > ClipLeft + ClipWidth - inwidth) {
  268.         width      = (ClipLeft + ClipWidth) - toleft;
  269.     }
  270.  
  271.     if (totop < ClipTop) {
  272.         height     = inheight - (ClipTop - totop);
  273.         totop     = ClipTop;
  274.         fromtop += inheight - height;
  275.     } else  if (totop > ClipTop + ClipHeight - inheight) {
  276.         height     = (ClipTop + ClipHeight) - totop;
  277.     }
  278.  
  279.     if (width <= 0 || height <= 0) {
  280.         return;
  281.     }
  282. /* --------------------------------------------------------------------- */
  283.  
  284. #ifndef DEBUG
  285.     OwnBlitter ();
  286. #endif
  287.     more      = FALSE;
  288.     othermask = 0xFFFF;
  289.  
  290.     tempmask = planemask;
  291.  
  292.     depth = min (frombm->Depth, tobm->Depth);
  293.  
  294.     fsword = fromleft >> 4;
  295.     tsword = toleft   >> 4;
  296.  
  297.     newwidth = width - 1;
  298.     fend   = fromleft + newwidth;
  299.     tend   = toleft   + newwidth;
  300.  
  301.     fromoffset = fromtop * frombm->BytesPerRow + (fsword << 1);
  302.     tooffset   = totop   * tobm->BytesPerRow   + (tsword << 1);
  303.  
  304.     fsbit    = fromleft & 0x0F;
  305.     tsbit    = toleft   & 0x0F;
  306.  
  307.     febit    = fend & 0x0F;
  308.     tebit    = tend & 0x0F;
  309.  
  310.     fbwidth = (fend >> 4) - fsword + 1;
  311.     tbwidth = (tend >> 4) - tsword + 1;
  312.  
  313.     bltwidth  = fbwidth;
  314.     shift = (tsbit - fsbit);
  315.     if (shift > 15) {
  316.         bltwidth += 1;
  317.         shift    &= 0x0F;
  318.         tooffset -= 2;
  319.         othermask = 0x0000;
  320.     }
  321.  
  322.     firstmask = 0xFFFF >> fsbit;
  323.  
  324.     if (tbwidth > fbwidth) {
  325.         more = TRUE;
  326.         lastmask = 0xFFFF << shift;
  327.     } else {
  328.         lastmask  = 0xFFFF << (15 - febit);
  329.     }
  330.  
  331.     frommod = frombm->BytesPerRow - (bltwidth << 1);
  332.     tomod   = tobm->BytesPerRow   - (bltwidth << 1);
  333.  
  334.     bltshift = shift << 12;
  335.     size = (height << 6) | bltwidth;
  336.  
  337.     mask += fromoffset;
  338.  
  339. #ifndef DEBUG
  340.     WAITFORBLITTER
  341. #endif
  342.  
  343.     hardware->bltcon0 = bltshift | 0x0FCA;
  344.     hardware->bltcon1 = bltshift;
  345.     hardware->bltafwm = firstmask;
  346.     hardware->bltalwm = lastmask & othermask;
  347.     hardware->bltamod = frommod;
  348.     hardware->bltbmod = frommod;
  349.     hardware->bltcmod = tomod;
  350.     hardware->bltdmod = tomod;
  351.  
  352.     for (ndx = 0; ndx < depth; ndx++) {
  353.         if (planemask & 0x01) {
  354.             toptr = (ULONG)tobm->Planes[ndx] + (ULONG)tooffset;
  355. #ifndef DEBUG
  356.             WAITFORBLITTER
  357. #endif
  358.  
  359.             hardware->bltapt  = (APTR)mask;
  360.             hardware->bltbpt  = (APTR)((ULONG)frombm->Planes[ndx] + fromoffset);
  361.             hardware->bltcpt  = (APTR)toptr;
  362.             hardware->bltdpt  = (APTR)toptr;
  363.             hardware->bltsize = size;
  364.  
  365. #if DEBUG
  366.     dorealblit (hardware);
  367. #endif
  368.  
  369.         }
  370.         planemask >>= 1;
  371.     }
  372.  
  373.     if (more) {
  374.         bltwidth <<= 1;
  375.         newwidth = bltwidth - 2;
  376.         fromoffset += newwidth;
  377.         mask       += newwidth;
  378.         tooffset   += newwidth;
  379.  
  380.         frommod = frombm->BytesPerRow - (2 << 1);
  381.         tomod   = tobm->BytesPerRow   - (2 << 1);
  382.  
  383.         size    = (height << 6) | 2;
  384.  
  385.         firstmask = 0xFFFF << (15 - febit);
  386.         lastmask  = 0xFFFF >> (((15 - shift) + 1) & 0x0F);
  387. #ifndef DEBUG
  388.         WAITFORBLITTER
  389. #endif
  390.  
  391.         hardware->bltafwm = lastmask & firstmask;
  392.         hardware->bltalwm = 0x0000;
  393.         hardware->bltbmod = frommod;
  394.         hardware->bltamod = frommod;
  395.         hardware->bltcmod = tomod;
  396.         hardware->bltdmod = tomod;
  397.  
  398.         for (ndx = 0; ndx < depth; ndx++) {
  399.             if (tempmask & 0x01) {
  400.                 toptr = (ULONG)tobm->Planes[ndx] + (ULONG)tooffset;
  401. #ifndef DEBUG
  402.                 WAITFORBLITTER
  403. #endif
  404.  
  405.                 hardware->bltapt  = (APTR)mask;
  406.                 hardware->bltbpt  = (APTR)((ULONG)frombm->Planes[ndx] + fromoffset);
  407.                 hardware->bltcpt  = (APTR)toptr;
  408.                 hardware->bltdpt  = (APTR)toptr;
  409.                 hardware->bltsize = size;
  410.  
  411. #if DEBUG
  412.     dorealblit (hardware);
  413. #endif
  414.  
  415.             }
  416.             tempmask >>= 1;
  417.         }
  418.  
  419.     }
  420.  
  421.  
  422. #ifndef DEBUG
  423.     DisownBlitter ();
  424. #endif
  425.  
  426. }
  427.  
  428. /**************************************************************************
  429.  *
  430.  * CopyBitMap
  431.  *
  432.  * SYNOPSIS
  433.  *    void CopyBitMap (
  434.  *                struct BitMap *frombm,
  435.  *                int            fromleft,  
  436.  *                int            fromtop,
  437.  *                struct BitMap *tobm,
  438.  *                int            toleft,
  439.  *                int            totop,
  440.  *                int            width,
  441.  *                int            height,
  442.  *                UBYTE         planemask,
  443.  *                );
  444.  *
  445.  * FUNCTION
  446.  *    Use the blitter to copy from one bitmap to another.  If the blit
  447.  *    is word aligned (ie. First pixel is the first bit of the first
  448.  *    word and last pixel is last bit of the last word) and the same is
  449.  *    true for both the source and the destination then this routine will
  450.  *    use a special blit (D=A) which is twice as fast as the normal
  451.  *    'clipped' blit (D=AB+~AC).
  452.  *
  453.  * INPUTS
  454.  *    frombm    = pointer to bitmap to copy from
  455.  *    fromleft  = x position to start copying from
  456.  *    fromtop   = y position to start copying from
  457.  *    tobm      = pointer to bitmap to copy to
  458.  *    toleft    = x position to start copying to
  459.  *    totop     = y position to start copying to
  460.  *    width     = width in pixels of area to copy
  461.  *    height    = height in pixels of area to copy
  462.  *    planemask = bitmask of planes to effect, bit0 = plane 0, bit1 = plane1...
  463.  *
  464.  * HISTORY
  465.  *
  466.  *
  467.  * SEE ALSO
  468.  *   ShapeBlit (), CopyMaskBitMap ()
  469. */
  470. void CopyBitMap (
  471.     frombm,
  472.     fromleft,
  473.     fromtop,
  474.     tobm,
  475.     toleft,
  476.     totop,
  477.     inwidth,
  478.     inheight,
  479.     planemask,
  480. )
  481.     struct BitMap    *frombm;
  482.     int         fromleft;
  483.     int         fromtop;
  484.     struct BitMap    *tobm;
  485.     int         toleft;
  486.     int         totop;
  487.     int         inwidth;
  488.     int         inheight;
  489.     UBYTE         planemask;
  490. {
  491.     register ULONG         fromoffset;
  492.     register ULONG         tooffset;
  493.          BLITTER     h;
  494.     register BLITTER    *hardware = 
  495. #if DEBUG
  496.                         &h;
  497. #else
  498.                         (struct Custom *)0x0DFF000;
  499. #endif
  500.     register ULONG        newoffset;
  501.     UWORD        fsword;
  502.     UWORD        tsword;
  503.     UWORD        newwidth;
  504.     UWORD        fend;
  505.     UWORD        tend;
  506.     UWORD        fsbit;
  507.     UWORD        tsbit;
  508.     UWORD        febit;
  509.     UWORD        tebit;
  510.     UWORD        frommod;
  511.     UWORD        tomod;
  512.     UWORD        shift;
  513.     UWORD        bltshift;
  514.     UWORD        fbwidth;
  515.     UWORD        tbwidth;
  516.     UWORD        bltwidth;
  517.     ULONG        toptr;
  518.     UWORD        size;
  519.     UWORD        firstmask;
  520.     UWORD        lastmask;
  521.     UWORD        othermask;
  522.     UWORD        ndx;
  523.     UWORD        depth;
  524.     UWORD        control;
  525.  
  526. /* --------------------------------------------------------------------- */
  527.     int width  = inwidth; 
  528.     int height = inheight;
  529.  
  530.     if (toleft < ClipLeft) {
  531.         width      = inwidth - (ClipLeft - toleft);
  532.         toleft      = ClipLeft;
  533.         fromleft += inwidth - width;
  534.     } else if (toleft > ClipLeft + ClipWidth - inwidth) {
  535.         width      = (ClipLeft + ClipWidth) - toleft;
  536.     }
  537.  
  538.     if (totop < ClipTop) {
  539.         height     = inheight - (ClipTop - totop);
  540.         totop     = ClipTop;
  541.         fromtop += inheight - height;
  542.     } else  if (totop > ClipTop + ClipHeight - inheight) {
  543.         height     = (ClipTop + ClipHeight) - totop;
  544.     }
  545.  
  546.     if (width <= 0 || height <= 0) {
  547.         return;
  548.     }
  549. /* --------------------------------------------------------------------- */
  550.     depth = min (frombm->Depth, tobm->Depth);
  551.  
  552.     fsword = fromleft >> 4;
  553.     tsword = toleft   >> 4;
  554.  
  555.     newwidth = width - 1;
  556.     fend   = fromleft + newwidth;
  557.     tend   = toleft   + newwidth;
  558.  
  559.     fromoffset = fromtop * frombm->BytesPerRow + (fsword << 1);
  560.     tooffset   = totop   * tobm->BytesPerRow   + (tsword << 1);
  561.  
  562.     fsbit    = fromleft & 0x0F;
  563.     tsbit    = toleft   & 0x0F;
  564.  
  565.     febit    = fend & 0x0F;
  566.     tebit    = tend & 0x0F;
  567.  
  568.     fbwidth = (fend >> 4) - fsword + 1;
  569.     tbwidth = (tend >> 4) - tsword + 1;
  570.     bltwidth  = fbwidth;
  571.  
  572.     if (!fsbit && !tsbit && febit == 15 && tebit == 15) {
  573.         frommod = frombm->BytesPerRow - (bltwidth << 1);
  574.         tomod   = tobm->BytesPerRow   - (bltwidth << 1);
  575.  
  576.         size = (height << 6) | bltwidth;
  577.  
  578.         if (fromoffset < tooffset) {
  579.             control     = 0x0002;
  580.             newoffset   = (bltwidth - 1) << 1;
  581.             fromoffset += frombm->BytesPerRow * (height - 1) + newoffset;
  582.             tooffset   += tobm->BytesPerRow * (height - 1) + newoffset;
  583.         } else {
  584.             control = 0x0000;
  585.         }
  586.  
  587. #ifndef DEBUG
  588.         OwnBlitter ();
  589.         WAITFORBLITTER
  590. #endif
  591.  
  592.         hardware->bltcon0 = 0x09F0;
  593.         hardware->bltcon1 = control;
  594.         hardware->bltafwm = 0xFFFF;
  595.         hardware->bltalwm = 0xFFFF;
  596.         hardware->bltamod = frommod;
  597.         hardware->bltdmod = tomod;
  598.  
  599.         for (ndx = 0; ndx < depth; ndx++) {
  600.             if (planemask & 0x01) {
  601.                 toptr = (ULONG)tobm->Planes[ndx] + (ULONG)tooffset;
  602. #ifndef DEBUG
  603.                 WAITFORBLITTER
  604. #endif
  605.  
  606.                 hardware->bltapt  = (APTR)((ULONG)frombm->Planes[ndx] + fromoffset);
  607.                 hardware->bltdpt  = (APTR)toptr;
  608.                 hardware->bltsize = size;
  609.  
  610. #if DEBUG
  611.     dorealblit (hardware);
  612. #endif
  613.  
  614.             }
  615.             planemask >>= 1;
  616.         }
  617. #ifndef DEBUG
  618.         DisownBlitter ();
  619. #endif
  620.  
  621.     } else {
  622.  
  623.         BltBitMap (frombm, fromleft, fromtop,
  624.                tobm,   toleft,   totop,
  625.                width, height, 0xC0, 0xFF, NULL);
  626.  
  627. #if 0
  628.         shift = (tsbit - fsbit);
  629.  
  630.         if (shift > 15) {
  631.             bltwidth += 1;
  632.             shift    &= 0x0F;
  633.             tooffset -= 2;
  634.             othermask = 0x0000;
  635.         }
  636.  
  637.         firstmask = 0xFFFF >> fsbit;
  638.  
  639.         if (tbwidth > fbwidth) {
  640.             more = TRUE;
  641.             lastmask = 0xFFFF << shift;
  642.         } else {
  643.             lastmask  = 0xFFFF << (15 - febit);
  644.         }
  645.  
  646.         frommod = frombm->BytesPerRow - (bltwidth << 1);
  647.         tomod   = tobm->BytesPerRow   - (bltwidth << 1);
  648.  
  649.         bltshift = shift << 12;
  650.         size = (height << 6) | bltwidth;
  651.  
  652.         mask += fromoffset;
  653.  
  654. #ifndef DEBUG
  655.         WAITFORBLITTER
  656. #endif
  657.  
  658.         hardware->bltcon0 = bltshift | 0x0FCA;
  659.         hardware->bltcon1 = bltshift;
  660.         hardware->bltafwm = firstmask;
  661.         hardware->bltalwm = lastmask & othermask;
  662.         hardware->bltamod = frommod;
  663.         hardware->bltbmod = frommod;
  664.         hardware->bltcmod = tomod;
  665.         hardware->bltdmod = tomod;
  666.  
  667.         for (ndx = 0; ndx < depth; ndx++) {
  668.             if (planemask & 0x01) {
  669.                 toptr = (ULONG)tobm->Planes[ndx] + (ULONG)tooffset;
  670. #ifndef DEBUG
  671.                 WAITFORBLITTER
  672. #endif
  673.  
  674.                 hardware->bltapt  = (APTR)mask;
  675.                 hardware->bltbpt  = (APTR)((ULONG)frombm->Planes[ndx] + fromoffset);
  676.                 hardware->bltcpt  = (APTR)toptr;
  677.                 hardware->bltdpt  = (APTR)toptr;
  678.                 hardware->bltsize = size;
  679.  
  680. #if DEBUG
  681.     dorealblit (hardware);
  682. #endif
  683.  
  684.             }
  685.             planemask >>= 1;
  686.         }
  687. #endif
  688.     }
  689. }
  690.  
  691.