1 ///////////////////////////////////////////////////////////////////////////
2 //
3 // Copyright (c) 2004-2012, Industrial Light & Magic, a division of Lucas
4 // Digital Ltd. LLC
5 //
6 // All rights reserved.
7 //
8 // Redistribution and use in source and binary forms, with or without
9 // modification, are permitted provided that the following conditions are
10 // met:
11 // * Redistributions of source code must retain the above copyright
12 // notice, this list of conditions and the following disclaimer.
13 // * Redistributions in binary form must reproduce the above
14 // copyright notice, this list of conditions and the following disclaimer
15 // in the documentation and/or other materials provided with the
16 // distribution.
17 // * Neither the name of Industrial Light & Magic nor the names of
18 // its contributors may be used to endorse or promote products derived
19 // from this software without specific prior written permission.
20 //
21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 //
33 ///////////////////////////////////////////////////////////////////////////
34
35
36
37 #ifndef INCLUDED_IMATHCOLOR_H
38 #define INCLUDED_IMATHCOLOR_H
39
40 //----------------------------------------------------
41 //
42 // A three and four component color class template.
43 //
44 //----------------------------------------------------
45
46 #include "ImathVec.h"
47 #include <OpenEXR/ImathNamespace.h>
48 // #include "half.h"
49
50 #ifndef IMATH_HOSTDEVICE
51 #ifdef __CUDACC__
52 #define IMATH_HOSTDEVICE __host__ __device__
53 #else
54 #define IMATH_HOSTDEVICE
55 #endif
56 #endif
57
58 IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
59
60
61 template <class T>
62 class Color3: public Vec3 <T>
63 {
64 public:
65
66 //-------------
67 // Constructors
68 //-------------
69
70 IMATH_HOSTDEVICE Color3 (); // no initialization
71 IMATH_HOSTDEVICE explicit Color3 (T a); // (a a a)
72 IMATH_HOSTDEVICE Color3 (T a, T b, T c); // (a b c)
73 ~Color3 () = default;
74
75 //---------------------------------
76 // Copy constructors and assignment
77 //---------------------------------
78
79 IMATH_HOSTDEVICE Color3 (const Color3 &c);
80 template <class S> IMATH_HOSTDEVICE Color3 (const Vec3<S> &v);
81
82 IMATH_HOSTDEVICE const Color3 & operator = (const Color3 &c);
83
84
85 //------------------------
86 // Component-wise addition
87 //------------------------
88
89 IMATH_HOSTDEVICE const Color3 & operator += (const Color3 &c);
90 IMATH_HOSTDEVICE Color3 operator + (const Color3 &c) const;
91
92
93 //---------------------------
94 // Component-wise subtraction
95 //---------------------------
96
97 IMATH_HOSTDEVICE const Color3 & operator -= (const Color3 &c);
98 IMATH_HOSTDEVICE Color3 operator - (const Color3 &c) const;
99
100
101 //------------------------------------
102 // Component-wise multiplication by -1
103 //------------------------------------
104
105 IMATH_HOSTDEVICE Color3 operator - () const;
106 IMATH_HOSTDEVICE const Color3 & negate ();
107
108
109 //------------------------------
110 // Component-wise multiplication
111 //------------------------------
112
113 IMATH_HOSTDEVICE const Color3 & operator *= (const Color3 &c);
114 IMATH_HOSTDEVICE const Color3 & operator *= (T a);
115 IMATH_HOSTDEVICE Color3 operator * (const Color3 &c) const;
116 IMATH_HOSTDEVICE Color3 operator * (T a) const;
117
118
119 //------------------------
120 // Component-wise division
121 //------------------------
122
123 IMATH_HOSTDEVICE const Color3 & operator /= (const Color3 &c);
124 IMATH_HOSTDEVICE const Color3 & operator /= (T a);
125 IMATH_HOSTDEVICE Color3 operator / (const Color3 &c) const;
126 IMATH_HOSTDEVICE Color3 operator / (T a) const;
127 };
128
129 template <class T> class Color4
130 {
131 public:
132
133 //-------------------
134 // Access to elements
135 //-------------------
136
137 T r, g, b, a;
138
139 IMATH_HOSTDEVICE T & operator [] (int i);
140 IMATH_HOSTDEVICE const T & operator [] (int i) const;
141
142
143 //-------------
144 // Constructors
145 //-------------
146
147 IMATH_HOSTDEVICE Color4 (); // no initialization
148 IMATH_HOSTDEVICE explicit Color4 (T a); // (a a a a)
149 IMATH_HOSTDEVICE Color4 (T a, T b, T c, T d); // (a b c d)
150 ~Color4 () = default;
151
152 //---------------------------------
153 // Copy constructors and assignment
154 //---------------------------------
155
156 IMATH_HOSTDEVICE Color4 (const Color4 &v);
157 template <class S> IMATH_HOSTDEVICE Color4 (const Color4<S> &v);
158
159 IMATH_HOSTDEVICE const Color4 & operator = (const Color4 &v);
160
161
162 //----------------------
163 // Compatibility with Sb
164 //----------------------
165
166 template <class S> IMATH_HOSTDEVICE
167 void setValue (S a, S b, S c, S d);
168
169 template <class S> IMATH_HOSTDEVICE
170 void setValue (const Color4<S> &v);
171
172 template <class S> IMATH_HOSTDEVICE
173 void getValue (S &a, S &b, S &c, S &d) const;
174
175 template <class S> IMATH_HOSTDEVICE
176 void getValue (Color4<S> &v) const;
177
178 IMATH_HOSTDEVICE T * getValue();
179 IMATH_HOSTDEVICE const T * getValue() const;
180
181
182 //---------
183 // Equality
184 //---------
185
186 template <class S> IMATH_HOSTDEVICE
187 bool operator == (const Color4<S> &v) const;
188
189 template <class S> IMATH_HOSTDEVICE
190 bool operator != (const Color4<S> &v) const;
191
192
193 //------------------------
194 // Component-wise addition
195 //------------------------
196
197 IMATH_HOSTDEVICE const Color4 & operator += (const Color4 &v);
198 IMATH_HOSTDEVICE Color4 operator + (const Color4 &v) const;
199
200
201 //---------------------------
202 // Component-wise subtraction
203 //---------------------------
204
205 IMATH_HOSTDEVICE const Color4 & operator -= (const Color4 &v);
206 IMATH_HOSTDEVICE Color4 operator - (const Color4 &v) const;
207
208
209 //------------------------------------
210 // Component-wise multiplication by -1
211 //------------------------------------
212
213 IMATH_HOSTDEVICE Color4 operator - () const;
214 IMATH_HOSTDEVICE const Color4 & negate ();
215
216
217 //------------------------------
218 // Component-wise multiplication
219 //------------------------------
220
221 IMATH_HOSTDEVICE const Color4 & operator *= (const Color4 &v);
222 IMATH_HOSTDEVICE const Color4 & operator *= (T a);
223 IMATH_HOSTDEVICE Color4 operator * (const Color4 &v) const;
224 IMATH_HOSTDEVICE Color4 operator * (T a) const;
225
226
227 //------------------------
228 // Component-wise division
229 //------------------------
230
231 IMATH_HOSTDEVICE const Color4 & operator /= (const Color4 &v);
232 IMATH_HOSTDEVICE const Color4 & operator /= (T a);
233 IMATH_HOSTDEVICE Color4 operator / (const Color4 &v) const;
234 IMATH_HOSTDEVICE Color4 operator / (T a) const;
235
236
237 //----------------------------------------------------------
238 // Number of dimensions, i.e. number of elements in a Color4
239 //----------------------------------------------------------
240
dimensions()241 static unsigned int dimensions() {return 4;}
242
243
244 //-------------------------------------------------
245 // Limitations of type T (see also class limits<T>)
246 //-------------------------------------------------
247
baseTypeMin()248 IMATH_HOSTDEVICE static T baseTypeMin() {return limits<T>::min();}
baseTypeMax()249 IMATH_HOSTDEVICE static T baseTypeMax() {return limits<T>::max();}
baseTypeSmallest()250 IMATH_HOSTDEVICE static T baseTypeSmallest() {return limits<T>::smallest();}
baseTypeEpsilon()251 IMATH_HOSTDEVICE static T baseTypeEpsilon() {return limits<T>::epsilon();}
252
253
254 //--------------------------------------------------------------
255 // Base type -- in templates, which accept a parameter, V, which
256 // could be a Color4<T>, you can refer to T as
257 // V::BaseType
258 //--------------------------------------------------------------
259
260 typedef T BaseType;
261 };
262
263 //--------------
264 // Stream output
265 //--------------
266
267 template <class T>
268 std::ostream & operator << (std::ostream &s, const Color4<T> &v);
269
270 //----------------------------------------------------
271 // Reverse multiplication: S * Color4<T>
272 //----------------------------------------------------
273
274 template <class S, class T> Color4<T> IMATH_HOSTDEVICE operator * (S a, const Color4<T> &v);
275
276 //-------------------------
277 // Typedefs for convenience
278 //-------------------------
279
280 typedef Color3<float> Color3f;
281 //typedef Color3<half> Color3h;
282 typedef Color3<unsigned char> Color3c;
283 //typedef Color3<half> C3h;
284 typedef Color3<float> C3f;
285 typedef Color3<unsigned char> C3c;
286 typedef Color4<float> Color4f;
287 //typedef Color4<half> Color4h;
288 typedef Color4<unsigned char> Color4c;
289 typedef Color4<float> C4f;
290 //typedef Color4<half> C4h;
291 typedef Color4<unsigned char> C4c;
292 typedef unsigned int PackedColor;
293
294
295 //-------------------------
296 // Implementation of Color3
297 //-------------------------
298
299 template <class T> IMATH_HOSTDEVICE
300 inline
Color3()301 Color3<T>::Color3 (): Vec3 <T> ()
302 {
303 // empty
304 }
305
306 template <class T> IMATH_HOSTDEVICE
307 inline
Color3(T a)308 Color3<T>::Color3 (T a): Vec3 <T> (a)
309 {
310 // empty
311 }
312
313 template <class T> IMATH_HOSTDEVICE
314 inline
Color3(T a,T b,T c)315 Color3<T>::Color3 (T a, T b, T c): Vec3 <T> (a, b, c)
316 {
317 // empty
318 }
319
320 template <class T> IMATH_HOSTDEVICE
321 inline
Color3(const Color3 & c)322 Color3<T>::Color3 (const Color3 &c): Vec3 <T> (c)
323 {
324 // empty
325 }
326
327 template <class T>
328 template <class S> IMATH_HOSTDEVICE
329 inline
Color3(const Vec3<S> & v)330 Color3<T>::Color3 (const Vec3<S> &v): Vec3 <T> (v)
331 {
332 //empty
333 }
334
335 template <class T> IMATH_HOSTDEVICE
336 inline const Color3<T> &
337 Color3<T>::operator = (const Color3 &c)
338 {
339 *((Vec3<T> *) this) = c;
340 return *this;
341 }
342
343 template <class T> IMATH_HOSTDEVICE
344 inline const Color3<T> &
345 Color3<T>::operator += (const Color3 &c)
346 {
347 *((Vec3<T> *) this) += c;
348 return *this;
349 }
350
351 template <class T> IMATH_HOSTDEVICE
352 inline Color3<T>
353 Color3<T>::operator + (const Color3 &c) const
354 {
355 return Color3 (*(Vec3<T> *)this + (const Vec3<T> &)c);
356 }
357
358 template <class T> IMATH_HOSTDEVICE
359 inline const Color3<T> &
360 Color3<T>::operator -= (const Color3 &c)
361 {
362 *((Vec3<T> *) this) -= c;
363 return *this;
364 }
365
366 template <class T> IMATH_HOSTDEVICE
367 inline Color3<T>
368 Color3<T>::operator - (const Color3 &c) const
369 {
370 return Color3 (*(Vec3<T> *)this - (const Vec3<T> &)c);
371 }
372
373 template <class T> IMATH_HOSTDEVICE
374 inline Color3<T>
375 Color3<T>::operator - () const
376 {
377 return Color3 (-(*(Vec3<T> *)this));
378 }
379
380 template <class T> IMATH_HOSTDEVICE
381 inline const Color3<T> &
negate()382 Color3<T>::negate ()
383 {
384 ((Vec3<T> *) this)->negate();
385 return *this;
386 }
387
388 template <class T> IMATH_HOSTDEVICE
389 inline const Color3<T> &
390 Color3<T>::operator *= (const Color3 &c)
391 {
392 *((Vec3<T> *) this) *= c;
393 return *this;
394 }
395
396 template <class T> IMATH_HOSTDEVICE
397 inline const Color3<T> &
398 Color3<T>::operator *= (T a)
399 {
400 *((Vec3<T> *) this) *= a;
401 return *this;
402 }
403
404 template <class T> IMATH_HOSTDEVICE
405 inline Color3<T>
406 Color3<T>::operator * (const Color3 &c) const
407 {
408 return Color3 (*(Vec3<T> *)this * (const Vec3<T> &)c);
409 }
410
411 template <class T> IMATH_HOSTDEVICE
412 inline Color3<T>
413 Color3<T>::operator * (T a) const
414 {
415 return Color3 (*(Vec3<T> *)this * a);
416 }
417
418 template <class T> IMATH_HOSTDEVICE
419 inline const Color3<T> &
420 Color3<T>::operator /= (const Color3 &c)
421 {
422 *((Vec3<T> *) this) /= c;
423 return *this;
424 }
425
426 template <class T> IMATH_HOSTDEVICE
427 inline const Color3<T> &
428 Color3<T>::operator /= (T a)
429 {
430 *((Vec3<T> *) this) /= a;
431 return *this;
432 }
433
434 template <class T> IMATH_HOSTDEVICE
435 inline Color3<T>
436 Color3<T>::operator / (const Color3 &c) const
437 {
438 return Color3 (*(Vec3<T> *)this / (const Vec3<T> &)c);
439 }
440
441 template <class T> IMATH_HOSTDEVICE
442 inline Color3<T>
443 Color3<T>::operator / (T a) const
444 {
445 return Color3 (*(Vec3<T> *)this / a);
446 }
447
448 //-----------------------
449 // Implementation of Color4
450 //-----------------------
451
452 template <class T> IMATH_HOSTDEVICE
453 inline T &
454 Color4<T>::operator [] (int i)
455 {
456 return (&r)[i];
457 }
458
459 template <class T> IMATH_HOSTDEVICE
460 inline const T &
461 Color4<T>::operator [] (int i) const
462 {
463 return (&r)[i];
464 }
465
466 template <class T> IMATH_HOSTDEVICE
467 inline
Color4()468 Color4<T>::Color4 ()
469 {
470 // empty
471 }
472
473 template <class T> IMATH_HOSTDEVICE
474 inline
Color4(T x)475 Color4<T>::Color4 (T x)
476 {
477 r = g = b = a = x;
478 }
479
480 template <class T> IMATH_HOSTDEVICE
481 inline
Color4(T x,T y,T z,T w)482 Color4<T>::Color4 (T x, T y, T z, T w)
483 {
484 r = x;
485 g = y;
486 b = z;
487 a = w;
488 }
489
490 template <class T> IMATH_HOSTDEVICE
491 inline
Color4(const Color4 & v)492 Color4<T>::Color4 (const Color4 &v)
493 {
494 r = v.r;
495 g = v.g;
496 b = v.b;
497 a = v.a;
498 }
499
500 template <class T>
501 template <class S> IMATH_HOSTDEVICE
502 inline
Color4(const Color4<S> & v)503 Color4<T>::Color4 (const Color4<S> &v)
504 {
505 r = T (v.r);
506 g = T (v.g);
507 b = T (v.b);
508 a = T (v.a);
509 }
510
511 template <class T> IMATH_HOSTDEVICE
512 inline const Color4<T> &
513 Color4<T>::operator = (const Color4 &v)
514 {
515 r = v.r;
516 g = v.g;
517 b = v.b;
518 a = v.a;
519 return *this;
520 }
521
522 template <class T>
523 template <class S> IMATH_HOSTDEVICE
524 inline void
setValue(S x,S y,S z,S w)525 Color4<T>::setValue (S x, S y, S z, S w)
526 {
527 r = T (x);
528 g = T (y);
529 b = T (z);
530 a = T (w);
531 }
532
533 template <class T>
534 template <class S> IMATH_HOSTDEVICE
535 inline void
setValue(const Color4<S> & v)536 Color4<T>::setValue (const Color4<S> &v)
537 {
538 r = T (v.r);
539 g = T (v.g);
540 b = T (v.b);
541 a = T (v.a);
542 }
543
544 template <class T>
545 template <class S> IMATH_HOSTDEVICE
546 inline void
getValue(S & x,S & y,S & z,S & w)547 Color4<T>::getValue (S &x, S &y, S &z, S &w) const
548 {
549 x = S (r);
550 y = S (g);
551 z = S (b);
552 w = S (a);
553 }
554
555 template <class T>
556 template <class S> IMATH_HOSTDEVICE
557 inline void
getValue(Color4<S> & v)558 Color4<T>::getValue (Color4<S> &v) const
559 {
560 v.r = S (r);
561 v.g = S (g);
562 v.b = S (b);
563 v.a = S (a);
564 }
565
566 template <class T> IMATH_HOSTDEVICE
567 inline T *
getValue()568 Color4<T>::getValue()
569 {
570 return (T *) &r;
571 }
572
573 template <class T> IMATH_HOSTDEVICE
574 inline const T *
getValue()575 Color4<T>::getValue() const
576 {
577 return (const T *) &r;
578 }
579
580 template <class T>
581 template <class S> IMATH_HOSTDEVICE
582 inline bool
583 Color4<T>::operator == (const Color4<S> &v) const
584 {
585 return r == v.r && g == v.g && b == v.b && a == v.a;
586 }
587
588 template <class T>
589 template <class S> IMATH_HOSTDEVICE
590 inline bool
591 Color4<T>::operator != (const Color4<S> &v) const
592 {
593 return r != v.r || g != v.g || b != v.b || a != v.a;
594 }
595
596 template <class T> IMATH_HOSTDEVICE
597 inline const Color4<T> &
598 Color4<T>::operator += (const Color4 &v)
599 {
600 r += v.r;
601 g += v.g;
602 b += v.b;
603 a += v.a;
604 return *this;
605 }
606
607 template <class T> IMATH_HOSTDEVICE
608 inline Color4<T>
609 Color4<T>::operator + (const Color4 &v) const
610 {
611 return Color4 (r + v.r, g + v.g, b + v.b, a + v.a);
612 }
613
614 template <class T> IMATH_HOSTDEVICE
615 inline const Color4<T> &
616 Color4<T>::operator -= (const Color4 &v)
617 {
618 r -= v.r;
619 g -= v.g;
620 b -= v.b;
621 a -= v.a;
622 return *this;
623 }
624
625 template <class T> IMATH_HOSTDEVICE
626 inline Color4<T>
627 Color4<T>::operator - (const Color4 &v) const
628 {
629 return Color4 (r - v.r, g - v.g, b - v.b, a - v.a);
630 }
631
632 template <class T> IMATH_HOSTDEVICE
633 inline Color4<T>
634 Color4<T>::operator - () const
635 {
636 return Color4 (-r, -g, -b, -a);
637 }
638
639 template <class T> IMATH_HOSTDEVICE
640 inline const Color4<T> &
negate()641 Color4<T>::negate ()
642 {
643 r = -r;
644 g = -g;
645 b = -b;
646 a = -a;
647 return *this;
648 }
649
650 template <class T> IMATH_HOSTDEVICE
651 inline const Color4<T> &
652 Color4<T>::operator *= (const Color4 &v)
653 {
654 r *= v.r;
655 g *= v.g;
656 b *= v.b;
657 a *= v.a;
658 return *this;
659 }
660
661 template <class T> IMATH_HOSTDEVICE
662 inline const Color4<T> &
663 Color4<T>::operator *= (T x)
664 {
665 r *= x;
666 g *= x;
667 b *= x;
668 a *= x;
669 return *this;
670 }
671
672 template <class T> IMATH_HOSTDEVICE
673 inline Color4<T>
674 Color4<T>::operator * (const Color4 &v) const
675 {
676 return Color4 (r * v.r, g * v.g, b * v.b, a * v.a);
677 }
678
679 template <class T> IMATH_HOSTDEVICE
680 inline Color4<T>
681 Color4<T>::operator * (T x) const
682 {
683 return Color4 (r * x, g * x, b * x, a * x);
684 }
685
686 template <class T> IMATH_HOSTDEVICE
687 inline const Color4<T> &
688 Color4<T>::operator /= (const Color4 &v)
689 {
690 r /= v.r;
691 g /= v.g;
692 b /= v.b;
693 a /= v.a;
694 return *this;
695 }
696
697 template <class T> IMATH_HOSTDEVICE
698 inline const Color4<T> &
699 Color4<T>::operator /= (T x)
700 {
701 r /= x;
702 g /= x;
703 b /= x;
704 a /= x;
705 return *this;
706 }
707
708 template <class T> IMATH_HOSTDEVICE
709 inline Color4<T>
710 Color4<T>::operator / (const Color4 &v) const
711 {
712 return Color4 (r / v.r, g / v.g, b / v.b, a / v.a);
713 }
714
715 template <class T> IMATH_HOSTDEVICE
716 inline Color4<T>
717 Color4<T>::operator / (T x) const
718 {
719 return Color4 (r / x, g / x, b / x, a / x);
720 }
721
722
723 template <class T>
724 std::ostream &
725 operator << (std::ostream &s, const Color4<T> &v)
726 {
727 return s << '(' << v.r << ' ' << v.g << ' ' << v.b << ' ' << v.a << ')';
728 }
729
730 //-----------------------------------------
731 // Implementation of reverse multiplication
732 //-----------------------------------------
733
734 template <class S, class T> IMATH_HOSTDEVICE
735 inline Color4<T>
736 operator * (S x, const Color4<T> &v)
737 {
738 return Color4<T> (x * v.r, x * v.g, x * v.b, x * v.a);
739 }
740
741
742 IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
743
744 #endif // INCLUDED_IMATHCOLOR_H
745