86f5d0e0c0f726f7485afd5e32640b094c2527ee
[blender.git] / intern / img / extern / IMG_Pixmap.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  * Abstract base class for pixmaps of different types.
37  * @author      Maarten Gribnau
38  * @date        March 6, 2001
39  */
40
41 #ifndef _H_IMG_Pixmap
42 #define _H_IMG_Pixmap
43
44 #include "GEN_Types.h"
45 #include "GEN_Rect.h"
46
47
48 class IMG_Pixmap
49 {
50 public:
51         /** The type of pixels that are stored in this pixmap. */
52         typedef enum {
53            kPixelTypeUnknown       = 0,    /**< R:8, G:8, B:8, Ignore:8  */
54 /*         kPixelTypeRGB32         = 1, */ /*< R:8, G:8, B:8, Ignore:8   */
55            kPixelTypeRGBA32        = 2,    /**< R:8, G:8, B:8, Alpha:8   */
56 /*         kPixelTypeRGB16         = 3, */ /**< Ignore:1, R:5, G:5, B:5  */
57 /*         kPixelTypeRGBA16        = 4, */ /**< Alpha:1,  R:5, G:5, B:5  */
58 /*         kPixelTypeRGB16_565     = 5, */ /**<           R:5, G:6, B:5  */
59 /*         kPixelTypeRGB24         = 6  */ /**< R:8, G:8, B:8            */
60         } TPixelType;
61
62         /**
63          * Default constructor.
64          */
65         IMG_Pixmap();
66
67         /**
68          * Constructs a pixmap with the requested width and height.
69          * @param width The width of the pixmap created.
70          * @param height The height of the pixmap created.
71          */
72         IMG_Pixmap(GEN_TUns32 width, GEN_TUns32 height);
73
74         /**
75          * Destructor.
76          */
77         virtual ~IMG_Pixmap();
78
79         /**
80          * Access to image data
81          * @return      pointer to the image data
82          */
83         virtual void* getDataPtr() const = 0;
84
85         /**
86          * Access to image width.
87          * @return      width of the image
88          */
89         inline GEN_TUns32 getWidth() const;
90
91         /**
92          * Access to image height.
93          * @return      height of the image
94          */
95         inline GEN_TUns32 getHeight() const;
96
97         /**
98          * Returns the bounds of the pixmap in a rectangle.
99          * @param       bounds of the image
100          */
101         inline void getBounds(GEN_Rect& r) const;
102
103         /**
104          * Access to pixel type.
105          * @return      the pixel type
106          */
107         inline TPixelType getPixelType() const;
108
109         /**
110          * Clamps coordinates inside (0, 0) and (width, height).
111          * @param       x       requested x-coordinate
112          * @param       y       requested y-coordinate
113          */
114         inline void clamp(GEN_TInt32& x, GEN_TInt32& y) const;
115
116         /**
117          * Clamps u, v coordinates between 0 and 1.
118          * @param       u       requested u-coordinate
119          * @param       v       requested v-coordinate
120          */
121         inline void clamp(float& u, float& v) const;
122
123         /**
124          * Converts (u,v) coordinates to pixel addresses.
125          * Assumes that (u,v) coordinates are in the [0,1] range.
126          * @param       u       requested u-coordinate in the image
127          * @param       v       requested v-coordinate in the image
128          * @param       x       calculated x-coordinate in the image
129          * @param       y       calculated y-coordinate in the image 
130          */
131         inline void     getPixelAddress(float u, float v, GEN_TInt32& x, GEN_TInt32& y) const;
132
133         /**
134          * Fills the rectangle given with the color given.
135          * Performs a bounds check.
136          * @param       r       requested bounds rectangle in the image
137          * @param       c       color to use
138          */
139         /*virtual void fillRect(const GEN_Rect& r, const IMG_ColorRGBA& c) = 0; */
140
141 protected:
142         /** Width of the image in pixels */
143         GEN_TUns32 m_width;
144         /** Height of the image in pixels */
145         GEN_TUns32 m_height;
146         /** Number of bytes for one row in the image. */
147         GEN_TUns32 m_rowBytes;
148         /** Size in bits for one pixel */
149         GEN_TUns32 m_pixelSize;
150         /** Type of pixels in this image. */
151         TPixelType m_pixelType;
152 /*      TEndian m_bitOrder;
153         TEndian m_byteOrder;
154 */
155 };
156
157 inline GEN_TUns32 IMG_Pixmap::getWidth() const
158 {
159         return m_width;
160 }
161
162 inline GEN_TUns32 IMG_Pixmap::getHeight() const
163 {
164         return m_height;
165 }
166
167 inline void IMG_Pixmap::getBounds(GEN_Rect& r) const
168 {
169         r.set(0, 0, m_width, m_height);
170 }
171
172 inline IMG_Pixmap::TPixelType IMG_Pixmap::getPixelType() const
173 {
174         return m_pixelType;
175 }
176
177 inline void IMG_Pixmap::clamp(GEN_TInt32& x, GEN_TInt32& y) const
178 {
179         if (x < 0) x = 0;
180         if (x > (GEN_TInt32)m_width) x = (GEN_TInt32)m_width;
181         if (y < 0) y = 0;
182         if (y > (GEN_TInt32)m_height) y = (GEN_TInt32)m_height;
183 }
184
185 inline void IMG_Pixmap::clamp(float& u, float& v) const
186 {
187         if (u < 0.f) u = 0.f;
188         if (u > 1.f) u = 1.f;
189         if (v < 0.f) v = 0.f;
190         if (v > 1.f) v = 1.f;
191 }
192
193 inline void     IMG_Pixmap::getPixelAddress(float u, float v, GEN_TInt32& x, GEN_TInt32& y) const
194 {
195         x = (GEN_TInt32)(((float)m_width) * u);
196         y = (GEN_TInt32)(((float)m_height) * v);
197 }
198
199 #endif /* _H_IMG_Pixmap */