home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C++ / Applications / PICSee Dust 1.01 / Quaternary Source / AlphaChannel.cpp next >
Encoding:
C/C++ Source or Header  |  1995-11-23  |  3.7 KB  |  169 lines  |  [TEXT/CWIE]
  1. #include "AlphaChannel.h"
  2. #include "assert_mac.h"
  3.  
  4. // ---------------------------------------------------------------------------
  5.  
  6. #define kRowBytesMask    0x7FFF
  7.  
  8. // ---------------------------------------------------------------------------
  9.  
  10. static ThirtyTwoBitPixelPtr Get32BitPixel(
  11.     GWorldPtr srcBuffer,
  12.     short h,
  13.     short v);
  14.  
  15. static void Set32BitPixel(
  16.     GWorldPtr destBuffer,
  17.     ThirtyTwoBitPixelPtr pixel,
  18.     short h,
  19.     short v);
  20.  
  21. static void Set8BitPixel(
  22.     GWorldPtr destBuffer,
  23.     unsigned char pixel,
  24.     short h,
  25.     short v);
  26.     
  27. // ---------------------------------------------------------------------------
  28.  
  29. Boolean HasPossibleAlphaChannel(GWorldPtr buffer) {
  30.     PixMapHandle pixie;
  31.     
  32.     pixie = GetGWorldPixMap(buffer);
  33.     if (pixie == NULL)
  34.         return(false);
  35.         
  36.     if ((**pixie).pixelSize == 32 &&
  37.         (**pixie).cmpCount == 3 &&
  38.         (**pixie).cmpSize == 8)
  39.         return(true);
  40.     else
  41.         return(false);
  42. } // END HasPossibleAlphaChannel
  43.  
  44. // ---------------------------------------------------------------------------
  45.  
  46. void SplitAlphaChannel(
  47.     GWorldPtr srcBuffer,
  48.     GWorldPtr imageBuffer,
  49.     GWorldPtr alphaBuffer,
  50.     AlphaPixelFilterProc pixelProc) {
  51.  
  52.     Rect bufferArea;
  53.     ThirtyTwoBitPixelPtr pixel;
  54.     ThirtyTwoBitPixel aPixel;
  55.     short h, v;
  56.     
  57.     if (!HasPossibleAlphaChannel(srcBuffer)) {
  58.         SysBeep(10);
  59.         return;
  60.     }
  61.  
  62.     bufferArea = (**GetGWorldPixMap(srcBuffer)).bounds;
  63.     OffsetRect(&bufferArea, -bufferArea.left, -bufferArea.top);
  64.     
  65.     for (v = 0; v < bufferArea.bottom; v++) {
  66.         for (h = 0; h < bufferArea.right; h++) {
  67.             pixel = Get32BitPixel(srcBuffer, h, v);
  68.             aPixel = *pixel;
  69.             // alpha == 0 -> pixel is a mask, not part of image
  70.             // alpha >  0 -> pixel is part of image
  71.             if (aPixel.alpha == 0) {
  72.                 aPixel.red = 255;
  73.                 aPixel.green = 255;
  74.                 aPixel.blue = 255;
  75.             }
  76.             /*
  77.             aPixel.red |= aPixel.alpha;
  78.             aPixel.green |= aPixel.alpha;
  79.             aPixel.blue |= aPixel.alpha;
  80.             */
  81.  
  82.             if (pixelProc != NULL)
  83.                 pixelProc(&aPixel);
  84.  
  85.             if (imageBuffer != NULL)
  86.                 Set32BitPixel(imageBuffer, &aPixel, h, v);
  87.             if (alphaBuffer != NULL)
  88.                 Set8BitPixel(alphaBuffer, aPixel.alpha, h, v);
  89.         }
  90.     }
  91. } // END SplitAlphaChannel
  92.  
  93. // ---------------------------------------------------------------------------
  94.  
  95. /*
  96.     Assumes:
  97.         1) Cpu is in 32-bit addressing mode. If in 24-bit mode, may crash.
  98.         2) GWorld's pixmap is LOCKED. Use LockPixels(). If not, may crash.
  99. */
  100. ThirtyTwoBitPixelPtr Get32BitPixel(
  101.     GWorldPtr srcBuffer,
  102.     short h,
  103.     short v) {
  104.  
  105.     PixMapHandle            pixie;
  106.     ThirtyTwoBitPixelPtr    srcMem;
  107.     unsigned long            realRowBytes;
  108.  
  109.     pixie = GetGWorldPixMap(srcBuffer);
  110.     ASSERT(pixie != NULL);
  111.  
  112.     realRowBytes = kRowBytesMask & (**pixie).rowBytes;
  113.  
  114.         // Calculate address
  115.     srcMem = (ThirtyTwoBitPixelPtr)(GetPixBaseAddr(pixie) +
  116.             (realRowBytes * v) + (h*4));
  117.  
  118.     return(srcMem);
  119. } // END Get32BitPixel
  120.  
  121. void Set32BitPixel(
  122.     GWorldPtr destBuffer,
  123.     ThirtyTwoBitPixelPtr pixel,
  124.     short h,
  125.     short v) {
  126.  
  127.     PixMapHandle            pixie;
  128.     ThirtyTwoBitPixelPtr    destMem;
  129.     unsigned long            realRowBytes;
  130.  
  131.     pixie = GetGWorldPixMap(destBuffer);
  132.     ASSERT(pixie != NULL);
  133.     if (pixie == NULL)
  134.         return;
  135.  
  136.     realRowBytes = (**pixie).rowBytes & kRowBytesMask;
  137.  
  138.         // Calculate address
  139.     destMem = (ThirtyTwoBitPixelPtr)(GetPixBaseAddr(pixie) +
  140.             (realRowBytes * v) + (h*4));
  141.  
  142.     *destMem = *pixel;
  143. } // END Get32BitPixel
  144.  
  145. // ---------------------------------------------------------------------------
  146.  
  147. void Set8BitPixel(
  148.     GWorldPtr destBuffer,
  149.     unsigned char pixel,
  150.     short h,
  151.     short v) {
  152.  
  153.     PixMapHandle    pixie;
  154.     unsigned char    *destMem;
  155.     unsigned long    realRowBytes;
  156.  
  157.     pixie = GetGWorldPixMap(destBuffer);
  158.     ASSERT(pixie != NULL);
  159.     if (pixie == NULL)
  160.         return;
  161.  
  162.     realRowBytes = (**pixie).rowBytes & kRowBytesMask;
  163.  
  164.         // Calculate address
  165.     destMem = (unsigned char*)(GetPixBaseAddr(pixie) +
  166.             (realRowBytes * v) + (h));
  167.  
  168.     *destMem = pixel;
  169. } // END Get8BitPixel