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