Initial revision
[blender.git] / intern / img / extern / IMG_PixmapRGBA32.h
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 /**
33
34  * $Id$
35  * Copyright (C) 2001 NaN Technologies B.V.
36  * Pixmap of kPixelTypeRGBA32 type.
37  * A pixmap with 24 bits per pixel in ABGR format.
38  * Provides methods to fill rectangular areas in this image with a color.
39  * Provides methods to paste or blend other pixmaps into this pixmap.
40  * @author      Maarten Gribnau
41  * @date        March 6, 2001
42  */
43
44
45 #ifndef _H_IMG_PixmapRGBA32
46 #define _H_IMG_PixmapRGBA32
47
48 #include "IMG_Pixmap.h"
49 #include "IMG_MemPtr.h"
50 #include "IMG_Color.h"
51
52
53 class IMG_PixmapRGBA32 : public IMG_Pixmap {
54 public:
55         /** The pixel type in this pixmap. */
56         typedef GEN_TUns32 TPixelRGBA32;
57
58         /** The pixel pointer type of this pixmap. */
59         typedef TPixelRGBA32* TPixelPtr;
60
61         /** Indices of color component byes within a pixel. */
62         typedef enum {
63                 bi_r = 0,
64                 bi_g = 1,
65                 bi_b = 2,
66                 bi_a = 3
67         } TPixelIndex;
68
69         /**
70          * Constructor.
71          * Creates a new pixmap of the kPixelTypeRGBA32 type with the requested dimensions.
72          * @throw <IMG_MemPtr::Size>    when an invalid width and/or height is passed.
73          * @throw <IMG_MemPtr::Memory>  when a there is not enough memory to allocate the image.
74          * @param       width   the width in pixels of the image.
75          * @param       height  the height in pixels of the image.
76          */
77         IMG_PixmapRGBA32(GEN_TUns32 width, GEN_TUns32 height);
78
79         /**
80          * Constructor.
81          * Creates a new pixmap of the kPixelTypeRGBA32 from a pointer to image data.
82          * The image data will not be freed upon destruction of this object.
83          * The owner of this object is reponsible for that.
84          * @throw <Size>        when an invalid width and/or height is passed.
85          * @param       image   pointer to the image data.
86          * @param       width   the width in pixels of the image.
87          * @param       height  the height in pixels of the image.
88          */
89         IMG_PixmapRGBA32(void* image, GEN_TUns32 width, GEN_TUns32 height, GEN_TUns32 rowBytes);
90
91 #if 0
92         /**
93          * Destructor.
94          */
95         virtual ~IMG_PixmapRGBA32();
96 #endif
97
98         /**
99          * Fills the rectangle given with the color given.
100          * Retains the alpha values.
101          * Performs a bounds check.
102          * @param       r       requested bounds rectangle in the image
103          * @param       c       color to use
104          */
105         virtual void fillRect(const GEN_Rect& r, const IMG_ColorRGB& c);
106
107         /**
108          * Fills the rectangle given with the color given.
109          * Sets the alpha values from the color.
110          * Performs a bounds check.
111          * @param       r       requested bounds rectangle in the image
112          * @param       c       color to use
113          */
114         virtual void fillRect(const GEN_Rect& r, const IMG_ColorRGBA& c);
115
116         /**
117          * Pastes an area of a pixmap into this pixmap.
118          * Pastes an area of the given pixmap centered at the given coordinates into this pixmap.
119          * Ignores the alpha information, this is pasted as well.
120          * Performs a bounds check.
121          * @param       src                     the pixmap to paste.
122          * @param       srcBnds         the bounds of the area of the pixmap to paste.
123          * @param       destBnds        the destination area for the paste.
124          */
125         virtual void setPixmap(const IMG_PixmapRGBA32& src, const GEN_Rect& srcBnds, const GEN_Rect& destBnds);
126
127         /**
128          * Blends an area of a pixmap into this pixmap.
129          * Blends an area of the given pixmap centered at the given coordinates into this pixmap.
130          * The alpha information in the given image is used to blend.
131          * Performs a bounds check.
132          * @param       src                     the pixmap to paste.
133          * @param       srcBnds         the bounds of the area of the pixmap to paste.
134          * @param       destBnds        the destination area for the paste.
135          */
136         virtual void blendPixmap(const IMG_PixmapRGBA32& src, const GEN_Rect& srcBnds, const GEN_Rect& destBnds);
137
138 protected:
139         /**
140          * Returns pointer to the pixel.
141          * Returns a pointer of TPixelPtr type to the pixel at the requested coordinates.
142          * Does not perform a bounds check!
143          * @param       x       column address of the pixel.
144          * @param       y       row address of the pixel.
145          * @return      the pointer calculated.
146          */
147         inline TPixelPtr getPixelPtr(GEN_TUns32 x, GEN_TUns32 y) const;
148
149         /**
150          * Returns the pixel value of a color.
151          * @param       c       the color to convert
152          * @return      the pixel value calculated
153          */
154         inline TPixelRGBA32     getPixelValue(const IMG_ColorRGBA& c) const;
155
156         /**
157          * Returns the color of from a pixel value.
158          * @param       p       the pixel value
159          * @param       c       the color calculated
160          */
161         inline void     getColor(TPixelRGBA32 p, IMG_ColorRGBA& c) const;
162
163 protected:
164         /** "Save" memory pointer. */
165         IMG_MemPtr<TPixelRGBA32> m_pixels;
166
167         /** Pointer to the first pixel. */
168         TPixelPtr m_pixelsBase;
169 };
170
171
172 inline IMG_PixmapRGBA32::TPixelPtr IMG_PixmapRGBA32::getPixelPtr(GEN_TUns32 x, GEN_TUns32 y) const
173 {
174         return (TPixelPtr) (((GEN_TUns8*)m_pixelsBase) + (y*m_rowBytes) + (x<<2));
175 }
176
177
178 inline IMG_PixmapRGBA32::TPixelRGBA32 IMG_PixmapRGBA32::getPixelValue(const IMG_ColorRGBA& c) const
179 {
180 #if 0
181         // Obtain pixel value through shifting
182         TPixelRGBA32 p = ((TPixelRGBA32) (((float) 0xFF) * c.m_a)) << 24;
183         p |= ((TPixelRGBA32) (((float) 0xFF) * c.m_b)) << 16;
184         p |= ((TPixelRGBA32) (((float) 0xFF) * c.m_g)) << 8;
185         p |= ((TPixelRGBA32) (((float) 0xFF) * c.m_r));
186         return p;
187 #else
188         // Obtain pixel value through byte indexing
189         TPixelRGBA32 pixel;
190         GEN_TUns8* bytes = (GEN_TUns8*)&pixel;
191         bytes[bi_r] = (GEN_TUns8)(((float) 0xFF) * c.m_r);
192         bytes[bi_g] = (GEN_TUns8)(((float) 0xFF) * c.m_g);
193         bytes[bi_b] = (GEN_TUns8)(((float) 0xFF) * c.m_b);
194         bytes[bi_a] = (GEN_TUns8)(((float) 0xFF) * c.m_a);
195         return pixel;
196 #endif
197 }
198
199 inline void     IMG_PixmapRGBA32::getColor(TPixelRGBA32 p, IMG_ColorRGBA& c) const
200 {
201 #if 0
202         // Obtain color value through shifting
203         c.m_a = ((float) ((p >> 24) & 0x00FF)) / ((float) 0xFF);
204         c.m_b = ((float) ((p >> 16) & 0x00FF)) / ((float) 0xFF);
205         c.m_g = ((float) ((p >>  8) & 0x00FF)) / ((float) 0xFF);
206         c.m_r = ((float) ( p        & 0x00FF)) / ((float) 0xFF);
207 #else
208         // Obtain color value through byte indexing
209         GEN_TUns8* bytes = (GEN_TUns8*)&p;
210         c.m_r = ((float)bytes[bi_r]) / ((float) 0xFF);
211         c.m_g = ((float)bytes[bi_g]) / ((float) 0xFF);
212         c.m_b = ((float)bytes[bi_b]) / ((float) 0xFF);
213         c.m_a = ((float)bytes[bi_a]) / ((float) 0xFF);
214 #endif
215 }
216
217 #endif // _H_IMG_PixmapRGBA32