Crazy Eddie's GUI System 0.8.7
Colour.h
1/***********************************************************************
2 created: 20/8/2004
3 author: Paul D Turner (with code from Jeff Leigh)
4
5 purpose: Defines interface to the colour class used to represent
6 colour values within the system
7*************************************************************************/
8/***************************************************************************
9 * Copyright (C) 2004 - 2006 Paul D Turner & The CEGUI Development Team
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining
12 * a copy of this software and associated documentation files (the
13 * "Software"), to deal in the Software without restriction, including
14 * without limitation the rights to use, copy, modify, merge, publish,
15 * distribute, sublicense, and/or sell copies of the Software, and to
16 * permit persons to whom the Software is furnished to do so, subject to
17 * the following conditions:
18 *
19 * The above copyright notice and this permission notice shall be
20 * included in all copies or substantial portions of the Software.
21 *
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
25 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
26 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
27 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
28 * OTHER DEALINGS IN THE SOFTWARE.
29 ***************************************************************************/
30#ifndef _CEGUIColour_h_
31#define _CEGUIColour_h_
32
33#include "CEGUI/Base.h"
34
35// Start of CEGUI namespace section
36namespace CEGUI
37{
38typedef uint32 argb_t;
39
44class CEGUIEXPORT Colour :
45 public AllocatedObject<Colour>
46{
47public:
48 /*************************************************************************
49 Construction & Destruction
50 *************************************************************************/
51 Colour(void);
52 Colour(const Colour& val);
53 Colour(float red, float green, float blue, float alpha = 1.0f);
54 Colour(argb_t argb);
55
56 /*************************************************************************
57 Accessors
58 *************************************************************************/
59 argb_t getARGB(void) const
60 {
61 if (!d_argbValid)
62 {
63 d_argb = calculateARGB();
64 d_argbValid = true;
65 }
66
67 return d_argb;
68 }
69
70 float getAlpha(void) const {return d_alpha;}
71 float getRed(void) const {return d_red;}
72 float getGreen(void) const {return d_green;}
73 float getBlue(void) const {return d_blue;}
74
82 float getHue(void) const;
83
91 float getSaturation(void) const;
92
100 float getLumination(void) const;
101
102
103 /*************************************************************************
104 Manipulators
105 *************************************************************************/
106 void setARGB(argb_t argb);
107 inline void setAlpha(float alpha)
108 {
109 d_argbValid = false;
110 d_alpha = alpha;
111 }
112
113 inline void setRed(float red)
114 {
115 d_argbValid = false;
116 d_red = red;
117 }
118
119 inline void setGreen(float green)
120 {
121 d_argbValid = false;
122 d_green = green;
123 }
124
125 inline void setBlue(float blue)
126 {
127 d_argbValid = false;
128 d_blue = blue;
129 }
130
131 inline void set(float red, float green, float blue, float alpha = 1.0f)
132 {
133 d_argbValid = false;
134 d_alpha = alpha;
135 d_red = red;
136 d_green = green;
137 d_blue = blue;
138 }
139
140 inline void setRGB(float red, float green, float blue)
141 {
142 d_argbValid = false;
143 d_red = red;
144 d_green = green;
145 d_blue = blue;
146 }
147
148 inline void setRGB(const Colour& val)
149 {
150 d_red = val.d_red;
151 d_green = val.d_green;
152 d_blue = val.d_blue;
153 if (d_argbValid)
154 {
155 d_argbValid = val.d_argbValid;
156 if (d_argbValid)
157 d_argb = (d_argb & 0xFF000000) | (val.d_argb & 0x00FFFFFF);
158 }
159 }
160
161 void setHSL(float hue, float saturation, float luminance, float alpha = 1.0f);
162
163 void invertColour(void);
164 void invertColourWithAlpha(void);
165
166 /*************************************************************************
167 Operators
168 *************************************************************************/
169 inline Colour& operator=(argb_t val)
170 {
171 setARGB(val);
172 return *this;
173 }
174
175 inline Colour& operator=(const Colour& val)
176 {
177 d_alpha = val.d_alpha;
178 d_red = val.d_red;
179 d_green = val.d_green;
180 d_blue = val.d_blue;
181 d_argb = val.d_argb;
182 d_argbValid = val.d_argbValid;
183
184 return *this;
185 }
186
187 inline Colour& operator&=(argb_t val)
188 {
189 setARGB(getARGB() & val);
190 return *this;
191 }
192
193 inline Colour& operator&=(const Colour& val)
194 {
195 setARGB(getARGB() & val.getARGB());
196 return *this;
197 }
198
199 inline Colour& operator|=(argb_t val)
200 {
201 setARGB(getARGB() | val);
202 return *this;
203 }
204
205 inline Colour& operator|=(const Colour& val)
206 {
207 setARGB(getARGB() | val.getARGB());
208 return *this;
209 }
210
211 inline Colour& operator<<=(int val)
212 {
213 setARGB(getARGB() << val);
214 return *this;
215 }
216
217 inline Colour& operator>>=(int val)
218 {
219 setARGB(getARGB() >> val);
220 return *this;
221 }
222
223 inline Colour operator+(const Colour& val) const
224 {
225 return Colour(
226 d_red + val.d_red,
227 d_green + val.d_green,
228 d_blue + val.d_blue,
229 d_alpha + val.d_alpha
230 );
231 }
232
233 inline Colour operator-(const Colour& val) const
234 {
235 return Colour(
236 d_red - val.d_red,
237 d_green - val.d_green,
238 d_blue - val.d_blue,
239 d_alpha - val.d_alpha
240 );
241 }
242
243 inline Colour operator*(const float val) const
244 {
245 return Colour(
246 d_red * val,
247 d_green * val,
248 d_blue * val,
249 d_alpha * val
250 );
251 }
252
253 inline Colour& operator*=(const Colour& val)
254 {
255 d_red *= val.d_red;
256 d_blue *= val.d_blue;
257 d_green *= val.d_green;
258 d_alpha *= val.d_alpha;
259
260 d_argbValid = false;
261
262 return *this;
263 }
264
265 /*************************************************************************
266 Compare operators
267 *************************************************************************/
268 inline bool operator==(const Colour& rhs) const
269 {
270 return d_red == rhs.d_red &&
271 d_green == rhs.d_green &&
272 d_blue == rhs.d_blue &&
273 d_alpha == rhs.d_alpha;
274 }
275
276 inline bool operator!=(const Colour& rhs) const
277 {
278 return !(*this == rhs);
279 }
280
281 //
282 // Conversion operators
283 //
284 operator argb_t() const {return getARGB();}
285
286private:
287 /*************************************************************************
288 Implementation Methods
289 *************************************************************************/
294 argb_t calculateARGB(void) const;
295
296 /*************************************************************************
297 Implementation Data
298 *************************************************************************/
299 float d_alpha, d_red, d_green, d_blue;
300 mutable argb_t d_argb;
301 mutable bool d_argbValid;
302};
303
304} // End of CEGUI namespace section
305
306
307#endif // end of guard _CEGUIColour_h_
Definition: MemoryAllocatedObject.h:110
Class representing colour values within the system.
Definition: Colour.h:46
float getLumination(void) const
Calculates and returns the lumination value based on the Colour.
float getSaturation(void) const
Calculates and returns the saturation value based on the Colour.
float getHue(void) const
Calculates and returns the hue value based on the Colour.
Main namespace for Crazy Eddie's GUI Library.
Definition: arch_overview.dox:1
String CEGUIEXPORT operator+(const String &str1, const String &str2)
Return String object that is the concatenation of the given inputs.
uint32 argb_t
32 bit ARGB representation of a colour.
Definition: Colour.h:38
bool CEGUIEXPORT operator!=(const String &str1, const String &str2)
Return true if String str1 is not equal to String str2.
bool CEGUIEXPORT operator==(const String &str1, const String &str2)
Return true if String str1 is equal to String str2.