blender/intern/img/extern/IMG_PixmapRGBA32.h

219 lines
6.9 KiB
C
Raw Normal View History

2002-10-12 11:37:38 +00:00
/**
* $Id$
* ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version. The Blender
* Foundation also sells licenses for use in proprietary software under
* the Blender License. See http://www.blender.org/BL/ for information
* about this.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
/**
* $Id$
* Copyright (C) 2001 NaN Technologies B.V.
* Pixmap of kPixelTypeRGBA32 type.
* A pixmap with 24 bits per pixel in ABGR format.
* Provides methods to fill rectangular areas in this image with a color.
* Provides methods to paste or blend other pixmaps into this pixmap.
* @author Maarten Gribnau
* @date March 6, 2001
*/
#ifndef _H_IMG_PixmapRGBA32
#define _H_IMG_PixmapRGBA32
#include "IMG_Pixmap.h"
#include "IMG_MemPtr.h"
#include "IMG_Color.h"
class IMG_PixmapRGBA32 : public IMG_Pixmap {
public:
/** The pixel type in this pixmap. */
typedef GEN_TUns32 TPixelRGBA32;
/** The pixel pointer type of this pixmap. */
typedef TPixelRGBA32* TPixelPtr;
/** Indices of color component byes within a pixel. */
typedef enum {
bi_r = 0,
bi_g = 1,
bi_b = 2,
bi_a = 3
} TPixelIndex;
/**
* Constructor.
* Creates a new pixmap of the kPixelTypeRGBA32 type with the requested dimensions.
* @throw <IMG_MemPtr::Size> when an invalid width and/or height is passed.
* @throw <IMG_MemPtr::Memory> when a there is not enough memory to allocate the image.
* @param width the width in pixels of the image.
* @param height the height in pixels of the image.
*/
IMG_PixmapRGBA32(GEN_TUns32 width, GEN_TUns32 height);
/**
* Constructor.
* Creates a new pixmap of the kPixelTypeRGBA32 from a pointer to image data.
* The image data will not be freed upon destruction of this object.
* The owner of this object is reponsible for that.
* @throw <Size> when an invalid width and/or height is passed.
* @param image pointer to the image data.
* @param width the width in pixels of the image.
* @param height the height in pixels of the image.
*/
IMG_PixmapRGBA32(void* image, GEN_TUns32 width, GEN_TUns32 height, GEN_TUns32 rowBytes);
#if 0
/**
* Destructor.
*/
virtual ~IMG_PixmapRGBA32();
#endif
/**
* Fills the rectangle given with the color given.
* Retains the alpha values.
* Performs a bounds check.
* @param r requested bounds rectangle in the image
* @param c color to use
*/
virtual void fillRect(const GEN_Rect& r, const IMG_ColorRGB& c);
/**
* Fills the rectangle given with the color given.
* Sets the alpha values from the color.
* Performs a bounds check.
* @param r requested bounds rectangle in the image
* @param c color to use
*/
virtual void fillRect(const GEN_Rect& r, const IMG_ColorRGBA& c);
/**
* Pastes an area of a pixmap into this pixmap.
* Pastes an area of the given pixmap centered at the given coordinates into this pixmap.
* Ignores the alpha information, this is pasted as well.
* Performs a bounds check.
* @param src the pixmap to paste.
* @param srcBnds the bounds of the area of the pixmap to paste.
* @param destBnds the destination area for the paste.
*/
virtual void setPixmap(const IMG_PixmapRGBA32& src, const GEN_Rect& srcBnds, const GEN_Rect& destBnds);
/**
* Blends an area of a pixmap into this pixmap.
* Blends an area of the given pixmap centered at the given coordinates into this pixmap.
* The alpha information in the given image is used to blend.
* Performs a bounds check.
* @param src the pixmap to paste.
* @param srcBnds the bounds of the area of the pixmap to paste.
* @param destBnds the destination area for the paste.
*/
virtual void blendPixmap(const IMG_PixmapRGBA32& src, const GEN_Rect& srcBnds, const GEN_Rect& destBnds);
protected:
/**
* Returns pointer to the pixel.
* Returns a pointer of TPixelPtr type to the pixel at the requested coordinates.
* Does not perform a bounds check!
* @param x column address of the pixel.
* @param y row address of the pixel.
* @return the pointer calculated.
*/
inline TPixelPtr getPixelPtr(GEN_TUns32 x, GEN_TUns32 y) const;
/**
* Returns the pixel value of a color.
* @param c the color to convert
* @return the pixel value calculated
*/
inline TPixelRGBA32 getPixelValue(const IMG_ColorRGBA& c) const;
/**
* Returns the color of from a pixel value.
* @param p the pixel value
* @param c the color calculated
*/
inline void getColor(TPixelRGBA32 p, IMG_ColorRGBA& c) const;
protected:
/** "Save" memory pointer. */
IMG_MemPtr<TPixelRGBA32> m_pixels;
/** Pointer to the first pixel. */
TPixelPtr m_pixelsBase;
};
inline IMG_PixmapRGBA32::TPixelPtr IMG_PixmapRGBA32::getPixelPtr(GEN_TUns32 x, GEN_TUns32 y) const
{
return (TPixelPtr) (((GEN_TUns8*)m_pixelsBase) + (y*m_rowBytes) + (x<<2));
}
inline IMG_PixmapRGBA32::TPixelRGBA32 IMG_PixmapRGBA32::getPixelValue(const IMG_ColorRGBA& c) const
{
#if 0
/* Obtain pixel value through shifting */
2002-10-12 11:37:38 +00:00
TPixelRGBA32 p = ((TPixelRGBA32) (((float) 0xFF) * c.m_a)) << 24;
p |= ((TPixelRGBA32) (((float) 0xFF) * c.m_b)) << 16;
p |= ((TPixelRGBA32) (((float) 0xFF) * c.m_g)) << 8;
p |= ((TPixelRGBA32) (((float) 0xFF) * c.m_r));
return p;
#else
/* Obtain pixel value through byte indexing */
2002-10-12 11:37:38 +00:00
TPixelRGBA32 pixel;
GEN_TUns8* bytes = (GEN_TUns8*)&pixel;
bytes[bi_r] = (GEN_TUns8)(((float) 0xFF) * c.m_r);
bytes[bi_g] = (GEN_TUns8)(((float) 0xFF) * c.m_g);
bytes[bi_b] = (GEN_TUns8)(((float) 0xFF) * c.m_b);
bytes[bi_a] = (GEN_TUns8)(((float) 0xFF) * c.m_a);
return pixel;
#endif
}
inline void IMG_PixmapRGBA32::getColor(TPixelRGBA32 p, IMG_ColorRGBA& c) const
{
#if 0
/* Obtain color value through shifting */
2002-10-12 11:37:38 +00:00
c.m_a = ((float) ((p >> 24) & 0x00FF)) / ((float) 0xFF);
c.m_b = ((float) ((p >> 16) & 0x00FF)) / ((float) 0xFF);
c.m_g = ((float) ((p >> 8) & 0x00FF)) / ((float) 0xFF);
c.m_r = ((float) ( p & 0x00FF)) / ((float) 0xFF);
#else
/* Obtain color value through byte indexing */
2002-10-12 11:37:38 +00:00
GEN_TUns8* bytes = (GEN_TUns8*)&p;
c.m_r = ((float)bytes[bi_r]) / ((float) 0xFF);
c.m_g = ((float)bytes[bi_g]) / ((float) 0xFF);
c.m_b = ((float)bytes[bi_b]) / ((float) 0xFF);
c.m_a = ((float)bytes[bi_a]) / ((float) 0xFF);
#endif
}
#endif /* _H_IMG_PixmapRGBA32 */