home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’97 / Invisible JEDI / source code / PixMapUtilities.cpp next >
Encoding:
Text File  |  1997-06-28  |  6.1 KB  |  241 lines  |  [TEXT/CWIE]
  1. /***********************************************************
  2.     PixMapUtilities.cpp
  3.     ©1997 Eric Cole
  4. ***********************************************************/
  5.  
  6.  
  7. void ShiftPixPat( PixPatHandle pixpat , long horz , long vert );
  8. void FlipPixPat( PixPatHandle pixpat , long horz , long vert );
  9. void InvertPixPat( PixPatHandle pixpat );
  10.  
  11.  
  12. void VShiftPixMap( PixMapHandle pixmap , long dist );
  13. void HShiftPixMap( PixMapHandle pixmap , long dist );
  14. void RotateBitsLeft( void *data , UInt32 bits , void *buff , UInt32 move );
  15. void RotateDataLeft( char *data , UInt32 size , char *buff , UInt32 move );
  16. void RotateBitsRight( void *data , UInt32 bits , void *buff , UInt32 move );
  17. void RotateDataRight( char *data , UInt32 size , char *buff , UInt32 move );
  18.  
  19.  
  20. void InvertBits( char *bytes , int bits );
  21. void InvertPixMap( PixMapPtr pix , char *base );
  22.  
  23.  
  24. #ifndef StripAddress
  25. #define StripAddress(x) x
  26. #endif
  27.  
  28.  
  29. void InvertBits( char *bytes , int bits ) {
  30.     register int                i = ( bits / 8 );
  31.     while ( --i >= 0 ) bytes[i] = ~bytes[i];
  32.     
  33.     //    endian dependant
  34.     if ( bits & 7 ) {
  35.         i = (-1L) << ( bits & 7 );
  36.         bits /= 8;
  37.         bytes[bits] = ( bytes[bits] & ~i ) | ( ~bytes[bits] & i );
  38.     }
  39. }
  40.  
  41.  
  42. void InvertPixMap( PixMapPtr pix , char *base ) {
  43.     Rect            *rect = &pix->bounds;
  44.     int                bits = (unsigned long)( rect->right - rect->left ) * pix->pixelSize;
  45.     int                tall = rect->bottom - rect->top;
  46.     int                wide = pix->rowBytes & 0x3FFF;
  47.     
  48.     while ( tall-- > 0 ) {
  49.         InvertBits( base , bits );
  50.         base += wide;
  51.     }
  52. }
  53.  
  54.  
  55. void InvertPixPat( PixPatHandle pixpat ) {
  56.     InvertPixMap( *(**pixpat).patMap , *(**pixpat).patData );
  57.     (**pixpat).patXValid = -1;
  58. }
  59.  
  60.  
  61. void ShiftPixPat( PixPatHandle pixpat , long horz , long vert ) {
  62.     Handle            data = (**pixpat).patData;
  63.     int                state = HGetState( data );
  64.     PixMapHandle    pixmap = (**pixpat).patMap;
  65.     
  66.     HLock( data );
  67.     (**pixmap).baseAddr = StripAddress( *data );
  68.     if ( horz ) HShiftPixMap( pixmap , horz );
  69.     if ( vert ) VShiftPixMap( pixmap , vert );
  70.     HSetState( data , state );
  71.     (**pixmap).baseAddr = nil;
  72.     
  73.     (**pixpat).patXValid = -1;
  74. }
  75.  
  76.  
  77. void VShiftPixMap( PixMapHandle pixmap , long dist ) {
  78.     Ptr                base , move , addr , dest = (**pixmap).baseAddr;
  79.     long            diff , full , size = (**pixmap).rowBytes;
  80.     Rect            rect = (**pixmap).bounds;
  81.     Ptr                buff = NewPtr( size &= 0x3FFF );
  82.     if ( buff == nil || dest == nil ) return;
  83.     
  84.     base = move = addr = dest;
  85.     full = ( rect.bottom - rect.top );
  86.     dist %= full;
  87.     full *= size;
  88.     full -= size;
  89.     
  90.     if ( dist > 0 ) {
  91.         addr += full;
  92.         move += size;
  93.         diff = -1;
  94.     } else {
  95.         dest += full;
  96.         base += size;
  97.         diff = 1;
  98.     }
  99.     
  100.     while ( dist ) {
  101.         BlockMoveData( addr , buff , size );
  102.         BlockMoveData( base , move , full );
  103.         BlockMoveData( buff , dest , size );
  104.         dist += diff;
  105.     }
  106.     
  107.     DisposePtr( buff );
  108. }
  109.  
  110.  
  111.  
  112. void RotateDataLeft( char *data , UInt32 size , char *buff , UInt32 move ) {
  113.     BlockMoveData( data , buff , move );
  114.     BlockMoveData( data + move , data , size - move );
  115.     BlockMoveData( buff , data + size - move , move );
  116. }
  117.  
  118.  
  119. void RotateDataRight( char *data , UInt32 size , char *buff , UInt32 move ) {
  120.     BlockMoveData( data + size - move , buff , move );
  121.     BlockMoveData( data , data + move , size - move );
  122.     BlockMoveData( buff , data , move );
  123. }
  124.  
  125.  
  126. //    changes -- start on an arbitrary bit --  be endian aware
  127. void RotateBitsLeft( void *data , UInt32 bits , void *buff , UInt32 move ) {
  128.     UInt8        *addr = (UInt8 *)data;
  129.     UInt8        mask , keep , temp;
  130.     
  131.     if ( move == 0 || bits == 0 || data == nil || buff == nil ) return;
  132.     
  133.     if ( move > 7 && bits > move ) {
  134.         if ( buff ) {
  135.             RotateDataLeft( (char *)addr , ( bits + 7 ) / 8 , (char *)buff , move / 8 );
  136.         } else return;
  137.         
  138.         if ( bits & 7 ) {
  139.             temp = bits / 8;
  140.             keep = addr[temp-1];
  141.             mask = ( 0xFF << ( 8 - ( bits & 7 ) ) );
  142.             
  143.             addr[temp-1] = ( keep & mask ) | ( addr[temp] >> ( bits & 7 ) );
  144.             addr[temp] = ( keep & ~mask ) | ( addr[temp] << ( 8 - ( bits & 7 ) ) );
  145.         }
  146.     }
  147.     
  148.     keep = *addr;
  149.     move &= 7;
  150.     
  151.     if ( move > bits ) move %= bits;
  152.     
  153.     for ( temp = 8 - move ; bits >= 16 ; bits -= 8 , ++addr ) {
  154.         addr[0] = ( addr[0] << move ) | ( addr[1] >> temp );
  155.     }
  156.     
  157.     if ( bits >= 8 ) {
  158.         temp = ( addr[1] & ( 0xFF << ( 16 - bits ) ) ) | ( keep >> ( bits - 8 ) );
  159.         addr[0] = ( addr[0] << move ) | ( temp >> ( 8 - move ) );
  160.         bits -= 8;
  161.         ++addr;
  162.     }
  163.     
  164.     if ( bits > 0 ) {
  165.         mask = ( 0xFF << ( 8 - bits ) );
  166.         temp = ( ( addr[0] & mask ) << move );
  167.         temp |= ( bits > move ) ? keep >> ( bits - move ) : keep << ( move - bits );
  168.         addr[0] = ( temp & mask ) | ( addr[0] & ~mask );
  169.     }
  170. }
  171.  
  172.  
  173. void RotateBitsRight( void *data , UInt32 bits , void *buff , UInt32 move ) {
  174.     return;
  175.     
  176.     UInt8        *addr = (UInt8 *)data;
  177.     UInt8        mask , keep , temp;
  178.     
  179.     if ( move == 0 || bits == 0 || data == nil || buff == nil ) return;
  180.     
  181.     if ( move > 7 && bits > move ) {
  182.         if ( buff ) {
  183.             RotateDataRight( (char *)addr , ( bits + 7 ) / 8 , (char *)buff , move / 8 );
  184.         } else return;
  185.         
  186.         if ( bits & 7 ) {
  187.             temp = bits / 8;
  188.             keep = addr[temp-1];
  189.             mask = ( 0xFF << ( 8 - ( bits & 7 ) ) );
  190.             
  191.             addr[temp-1] = ( keep & mask ) | ( addr[temp] >> ( bits & 7 ) );
  192.             addr[temp] = ( keep & ~mask ) | ( addr[temp] << ( 8 - ( bits & 7 ) ) );
  193.         }
  194.     }
  195.     
  196.     keep = *addr;
  197.     move &= 7;
  198.     
  199.     if ( move > bits ) move %= bits;
  200.     
  201.     for ( temp = 8 - move ; bits >= 16 ; bits -= 8 , ++addr ) {
  202.         addr[0] = ( addr[0] << move ) | ( addr[1] >> temp );
  203.     }
  204.     
  205.     if ( bits >= 8 ) {
  206.         temp = ( addr[1] & ( 0xFF << ( 16 - bits ) ) ) | ( keep >> ( bits - 8 ) );
  207.         addr[0] = ( addr[0] << move ) | ( temp >> ( 8 - move ) );
  208.         bits -= 8;
  209.         ++addr;
  210.     }
  211.     
  212.     if ( bits > 0 ) {
  213.         mask = ( 0xFF << ( 8 - bits ) );
  214.         temp = ( ( addr[0] & mask ) << move );
  215.         temp |= ( bits > move ) ? keep >> ( bits - move ) : keep << ( move - bits );
  216.         addr[0] = ( temp & mask ) | ( addr[0] & ~mask );
  217.     }
  218. }
  219.  
  220.  
  221. void HShiftPixMap( PixMapHandle pixmap , long dist ) {
  222.     long            deep = (**pixmap).pixelSize;
  223.     Ptr                dest = (**pixmap).baseAddr;
  224.     long            size = (**pixmap).rowBytes;
  225.     Rect            rect = (**pixmap).bounds;
  226.     long            wide = rect.right - rect.left;
  227.     Ptr                buff = NewPtr( size &= 0x3FFF );
  228.     if ( buff == nil || dest == nil ) return;
  229.     
  230.     dist %= wide;
  231.     while ( rect.top < rect.bottom ) {
  232.         RotateBitsLeft( dest , deep * wide , buff , ( ( ( dist < 0 ? 0 : wide ) - dist ) * deep ) );
  233.         
  234.         dest += size;
  235.         rect.top += 1;
  236.     }
  237.     
  238.     DisposePtr( buff );
  239. }
  240.  
  241.