[855] | 1 | /////////////////////////////////////////////////////////////////////////// |
---|
| 2 | // |
---|
| 3 | // Copyright (c) 2004, 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 <half.h> |
---|
| 48 | |
---|
| 49 | namespace Imath { |
---|
| 50 | |
---|
| 51 | |
---|
| 52 | template <class T> |
---|
| 53 | class Color3: public Vec3 <T> |
---|
| 54 | { |
---|
| 55 | public: |
---|
| 56 | |
---|
| 57 | //------------- |
---|
| 58 | // Constructors |
---|
| 59 | //------------- |
---|
| 60 | |
---|
| 61 | Color3 (); // no initialization |
---|
| 62 | explicit Color3 (T a); // (a a a) |
---|
| 63 | Color3 (T a, T b, T c); // (a b c) |
---|
| 64 | |
---|
| 65 | |
---|
| 66 | //--------------------------------- |
---|
| 67 | // Copy constructors and assignment |
---|
| 68 | //--------------------------------- |
---|
| 69 | |
---|
| 70 | Color3 (const Color3 &c); |
---|
| 71 | template <class S> Color3 (const Vec3<S> &v); |
---|
| 72 | |
---|
| 73 | const Color3 & operator = (const Color3 &c); |
---|
| 74 | |
---|
| 75 | |
---|
| 76 | //------------------------ |
---|
| 77 | // Component-wise addition |
---|
| 78 | //------------------------ |
---|
| 79 | |
---|
| 80 | const Color3 & operator += (const Color3 &c); |
---|
| 81 | Color3 operator + (const Color3 &c) const; |
---|
| 82 | |
---|
| 83 | |
---|
| 84 | //--------------------------- |
---|
| 85 | // Component-wise subtraction |
---|
| 86 | //--------------------------- |
---|
| 87 | |
---|
| 88 | const Color3 & operator -= (const Color3 &c); |
---|
| 89 | Color3 operator - (const Color3 &c) const; |
---|
| 90 | |
---|
| 91 | |
---|
| 92 | //------------------------------------ |
---|
| 93 | // Component-wise multiplication by -1 |
---|
| 94 | //------------------------------------ |
---|
| 95 | |
---|
| 96 | Color3 operator - () const; |
---|
| 97 | const Color3 & negate (); |
---|
| 98 | |
---|
| 99 | |
---|
| 100 | //------------------------------ |
---|
| 101 | // Component-wise multiplication |
---|
| 102 | //------------------------------ |
---|
| 103 | |
---|
| 104 | const Color3 & operator *= (const Color3 &c); |
---|
| 105 | const Color3 & operator *= (T a); |
---|
| 106 | Color3 operator * (const Color3 &c) const; |
---|
| 107 | Color3 operator * (T a) const; |
---|
| 108 | |
---|
| 109 | |
---|
| 110 | //------------------------ |
---|
| 111 | // Component-wise division |
---|
| 112 | //------------------------ |
---|
| 113 | |
---|
| 114 | const Color3 & operator /= (const Color3 &c); |
---|
| 115 | const Color3 & operator /= (T a); |
---|
| 116 | Color3 operator / (const Color3 &c) const; |
---|
| 117 | Color3 operator / (T a) const; |
---|
| 118 | }; |
---|
| 119 | |
---|
| 120 | template <class T> class Color4 |
---|
| 121 | { |
---|
| 122 | public: |
---|
| 123 | |
---|
| 124 | //------------------- |
---|
| 125 | // Access to elements |
---|
| 126 | //------------------- |
---|
| 127 | |
---|
| 128 | T r, g, b, a; |
---|
| 129 | |
---|
| 130 | T & operator [] (int i); |
---|
| 131 | const T & operator [] (int i) const; |
---|
| 132 | |
---|
| 133 | |
---|
| 134 | //------------- |
---|
| 135 | // Constructors |
---|
| 136 | //------------- |
---|
| 137 | |
---|
| 138 | Color4 (); // no initialization |
---|
| 139 | explicit Color4 (T a); // (a a a a) |
---|
| 140 | Color4 (T a, T b, T c, T d); // (a b c d) |
---|
| 141 | |
---|
| 142 | |
---|
| 143 | //--------------------------------- |
---|
| 144 | // Copy constructors and assignment |
---|
| 145 | //--------------------------------- |
---|
| 146 | |
---|
| 147 | Color4 (const Color4 &v); |
---|
| 148 | template <class S> Color4 (const Color4<S> &v); |
---|
| 149 | |
---|
| 150 | const Color4 & operator = (const Color4 &v); |
---|
| 151 | |
---|
| 152 | |
---|
| 153 | //---------------------- |
---|
| 154 | // Compatibility with Sb |
---|
| 155 | //---------------------- |
---|
| 156 | |
---|
| 157 | template <class S> |
---|
| 158 | void setValue (S a, S b, S c, S d); |
---|
| 159 | |
---|
| 160 | template <class S> |
---|
| 161 | void setValue (const Color4<S> &v); |
---|
| 162 | |
---|
| 163 | template <class S> |
---|
| 164 | void getValue (S &a, S &b, S &c, S &d) const; |
---|
| 165 | |
---|
| 166 | template <class S> |
---|
| 167 | void getValue (Color4<S> &v) const; |
---|
| 168 | |
---|
| 169 | T * getValue(); |
---|
| 170 | const T * getValue() const; |
---|
| 171 | |
---|
| 172 | |
---|
| 173 | //--------- |
---|
| 174 | // Equality |
---|
| 175 | //--------- |
---|
| 176 | |
---|
| 177 | template <class S> |
---|
| 178 | bool operator == (const Color4<S> &v) const; |
---|
| 179 | |
---|
| 180 | template <class S> |
---|
| 181 | bool operator != (const Color4<S> &v) const; |
---|
| 182 | |
---|
| 183 | |
---|
| 184 | //------------------------ |
---|
| 185 | // Component-wise addition |
---|
| 186 | //------------------------ |
---|
| 187 | |
---|
| 188 | const Color4 & operator += (const Color4 &v); |
---|
| 189 | Color4 operator + (const Color4 &v) const; |
---|
| 190 | |
---|
| 191 | |
---|
| 192 | //--------------------------- |
---|
| 193 | // Component-wise subtraction |
---|
| 194 | //--------------------------- |
---|
| 195 | |
---|
| 196 | const Color4 & operator -= (const Color4 &v); |
---|
| 197 | Color4 operator - (const Color4 &v) const; |
---|
| 198 | |
---|
| 199 | |
---|
| 200 | //------------------------------------ |
---|
| 201 | // Component-wise multiplication by -1 |
---|
| 202 | //------------------------------------ |
---|
| 203 | |
---|
| 204 | Color4 operator - () const; |
---|
| 205 | const Color4 & negate (); |
---|
| 206 | |
---|
| 207 | |
---|
| 208 | //------------------------------ |
---|
| 209 | // Component-wise multiplication |
---|
| 210 | //------------------------------ |
---|
| 211 | |
---|
| 212 | const Color4 & operator *= (const Color4 &v); |
---|
| 213 | const Color4 & operator *= (T a); |
---|
| 214 | Color4 operator * (const Color4 &v) const; |
---|
| 215 | Color4 operator * (T a) const; |
---|
| 216 | |
---|
| 217 | |
---|
| 218 | //------------------------ |
---|
| 219 | // Component-wise division |
---|
| 220 | //------------------------ |
---|
| 221 | |
---|
| 222 | const Color4 & operator /= (const Color4 &v); |
---|
| 223 | const Color4 & operator /= (T a); |
---|
| 224 | Color4 operator / (const Color4 &v) const; |
---|
| 225 | Color4 operator / (T a) const; |
---|
| 226 | |
---|
| 227 | |
---|
| 228 | //---------------------------------------------------------- |
---|
| 229 | // Number of dimensions, i.e. number of elements in a Color4 |
---|
| 230 | //---------------------------------------------------------- |
---|
| 231 | |
---|
| 232 | static unsigned int dimensions() {return 4;} |
---|
| 233 | |
---|
| 234 | |
---|
| 235 | //------------------------------------------------- |
---|
| 236 | // Limitations of type T (see also class limits<T>) |
---|
| 237 | //------------------------------------------------- |
---|
| 238 | |
---|
| 239 | static T baseTypeMin() {return limits<T>::min();} |
---|
| 240 | static T baseTypeMax() {return limits<T>::max();} |
---|
| 241 | static T baseTypeSmallest() {return limits<T>::smallest();} |
---|
| 242 | static T baseTypeEpsilon() {return limits<T>::epsilon();} |
---|
| 243 | |
---|
| 244 | |
---|
| 245 | //-------------------------------------------------------------- |
---|
| 246 | // Base type -- in templates, which accept a parameter, V, which |
---|
| 247 | // could be a Color4<T>, you can refer to T as |
---|
| 248 | // V::BaseType |
---|
| 249 | //-------------------------------------------------------------- |
---|
| 250 | |
---|
| 251 | typedef T BaseType; |
---|
| 252 | }; |
---|
| 253 | |
---|
| 254 | //-------------- |
---|
| 255 | // Stream output |
---|
| 256 | //-------------- |
---|
| 257 | |
---|
| 258 | template <class T> |
---|
| 259 | std::ostream & operator << (std::ostream &s, const Color4<T> &v); |
---|
| 260 | |
---|
| 261 | //---------------------------------------------------- |
---|
| 262 | // Reverse multiplication: S * Color4<T> |
---|
| 263 | //---------------------------------------------------- |
---|
| 264 | |
---|
| 265 | template <class S, class T> Color4<T> operator * (S a, const Color4<T> &v); |
---|
| 266 | |
---|
| 267 | //------------------------- |
---|
| 268 | // Typedefs for convenience |
---|
| 269 | //------------------------- |
---|
| 270 | |
---|
| 271 | typedef Color3<float> Color3f; |
---|
| 272 | typedef Color3<half> Color3h; |
---|
| 273 | typedef Color3<unsigned char> Color3c; |
---|
| 274 | typedef Color3<half> C3h; |
---|
| 275 | typedef Color3<float> C3f; |
---|
| 276 | typedef Color3<unsigned char> C3c; |
---|
| 277 | typedef Color4<float> Color4f; |
---|
| 278 | typedef Color4<half> Color4h; |
---|
| 279 | typedef Color4<unsigned char> Color4c; |
---|
| 280 | typedef Color4<float> C4f; |
---|
| 281 | typedef Color4<half> C4h; |
---|
| 282 | typedef Color4<unsigned char> C4c; |
---|
| 283 | typedef unsigned int PackedColor; |
---|
| 284 | |
---|
| 285 | |
---|
| 286 | //------------------------- |
---|
| 287 | // Implementation of Color3 |
---|
| 288 | //------------------------- |
---|
| 289 | |
---|
| 290 | template <class T> |
---|
| 291 | inline |
---|
| 292 | Color3<T>::Color3 (): Vec3 <T> () |
---|
| 293 | { |
---|
| 294 | // empty |
---|
| 295 | } |
---|
| 296 | |
---|
| 297 | template <class T> |
---|
| 298 | inline |
---|
| 299 | Color3<T>::Color3 (T a): Vec3 <T> (a) |
---|
| 300 | { |
---|
| 301 | // empty |
---|
| 302 | } |
---|
| 303 | |
---|
| 304 | template <class T> |
---|
| 305 | inline |
---|
| 306 | Color3<T>::Color3 (T a, T b, T c): Vec3 <T> (a, b, c) |
---|
| 307 | { |
---|
| 308 | // empty |
---|
| 309 | } |
---|
| 310 | |
---|
| 311 | template <class T> |
---|
| 312 | inline |
---|
| 313 | Color3<T>::Color3 (const Color3 &c): Vec3 <T> (c) |
---|
| 314 | { |
---|
| 315 | // empty |
---|
| 316 | } |
---|
| 317 | |
---|
| 318 | template <class T> |
---|
| 319 | template <class S> |
---|
| 320 | inline |
---|
| 321 | Color3<T>::Color3 (const Vec3<S> &v): Vec3 <T> (v) |
---|
| 322 | { |
---|
| 323 | //empty |
---|
| 324 | } |
---|
| 325 | |
---|
| 326 | template <class T> |
---|
| 327 | inline const Color3<T> & |
---|
| 328 | Color3<T>::operator = (const Color3 &c) |
---|
| 329 | { |
---|
| 330 | *((Vec3<T> *) this) = c; |
---|
| 331 | return *this; |
---|
| 332 | } |
---|
| 333 | |
---|
| 334 | template <class T> |
---|
| 335 | inline const Color3<T> & |
---|
| 336 | Color3<T>::operator += (const Color3 &c) |
---|
| 337 | { |
---|
| 338 | *((Vec3<T> *) this) += c; |
---|
| 339 | return *this; |
---|
| 340 | } |
---|
| 341 | |
---|
| 342 | template <class T> |
---|
| 343 | inline Color3<T> |
---|
| 344 | Color3<T>::operator + (const Color3 &c) const |
---|
| 345 | { |
---|
| 346 | return Color3 (*(Vec3<T> *)this + (const Vec3<T> &)c); |
---|
| 347 | } |
---|
| 348 | |
---|
| 349 | template <class T> |
---|
| 350 | inline const Color3<T> & |
---|
| 351 | Color3<T>::operator -= (const Color3 &c) |
---|
| 352 | { |
---|
| 353 | *((Vec3<T> *) this) -= c; |
---|
| 354 | return *this; |
---|
| 355 | } |
---|
| 356 | |
---|
| 357 | template <class T> |
---|
| 358 | inline Color3<T> |
---|
| 359 | Color3<T>::operator - (const Color3 &c) const |
---|
| 360 | { |
---|
| 361 | return Color3 (*(Vec3<T> *)this - (const Vec3<T> &)c); |
---|
| 362 | } |
---|
| 363 | |
---|
| 364 | template <class T> |
---|
| 365 | inline Color3<T> |
---|
| 366 | Color3<T>::operator - () const |
---|
| 367 | { |
---|
| 368 | return Color3 (-(*(Vec3<T> *)this)); |
---|
| 369 | } |
---|
| 370 | |
---|
| 371 | template <class T> |
---|
| 372 | inline const Color3<T> & |
---|
| 373 | Color3<T>::negate () |
---|
| 374 | { |
---|
| 375 | ((Vec3<T> *) this)->negate(); |
---|
| 376 | return *this; |
---|
| 377 | } |
---|
| 378 | |
---|
| 379 | template <class T> |
---|
| 380 | inline const Color3<T> & |
---|
| 381 | Color3<T>::operator *= (const Color3 &c) |
---|
| 382 | { |
---|
| 383 | *((Vec3<T> *) this) *= c; |
---|
| 384 | return *this; |
---|
| 385 | } |
---|
| 386 | |
---|
| 387 | template <class T> |
---|
| 388 | inline const Color3<T> & |
---|
| 389 | Color3<T>::operator *= (T a) |
---|
| 390 | { |
---|
| 391 | *((Vec3<T> *) this) *= a; |
---|
| 392 | return *this; |
---|
| 393 | } |
---|
| 394 | |
---|
| 395 | template <class T> |
---|
| 396 | inline Color3<T> |
---|
| 397 | Color3<T>::operator * (const Color3 &c) const |
---|
| 398 | { |
---|
| 399 | return Color3 (*(Vec3<T> *)this * (const Vec3<T> &)c); |
---|
| 400 | } |
---|
| 401 | |
---|
| 402 | template <class T> |
---|
| 403 | inline Color3<T> |
---|
| 404 | Color3<T>::operator * (T a) const |
---|
| 405 | { |
---|
| 406 | return Color3 (*(Vec3<T> *)this * a); |
---|
| 407 | } |
---|
| 408 | |
---|
| 409 | template <class T> |
---|
| 410 | inline const Color3<T> & |
---|
| 411 | Color3<T>::operator /= (const Color3 &c) |
---|
| 412 | { |
---|
| 413 | *((Vec3<T> *) this) /= c; |
---|
| 414 | return *this; |
---|
| 415 | } |
---|
| 416 | |
---|
| 417 | template <class T> |
---|
| 418 | inline const Color3<T> & |
---|
| 419 | Color3<T>::operator /= (T a) |
---|
| 420 | { |
---|
| 421 | *((Vec3<T> *) this) /= a; |
---|
| 422 | return *this; |
---|
| 423 | } |
---|
| 424 | |
---|
| 425 | template <class T> |
---|
| 426 | inline Color3<T> |
---|
| 427 | Color3<T>::operator / (const Color3 &c) const |
---|
| 428 | { |
---|
| 429 | return Color3 (*(Vec3<T> *)this / (const Vec3<T> &)c); |
---|
| 430 | } |
---|
| 431 | |
---|
| 432 | template <class T> |
---|
| 433 | inline Color3<T> |
---|
| 434 | Color3<T>::operator / (T a) const |
---|
| 435 | { |
---|
| 436 | return Color3 (*(Vec3<T> *)this / a); |
---|
| 437 | } |
---|
| 438 | |
---|
| 439 | //----------------------- |
---|
| 440 | // Implementation of Color4 |
---|
| 441 | //----------------------- |
---|
| 442 | |
---|
| 443 | template <class T> |
---|
| 444 | inline T & |
---|
| 445 | Color4<T>::operator [] (int i) |
---|
| 446 | { |
---|
| 447 | return (&r)[i]; |
---|
| 448 | } |
---|
| 449 | |
---|
| 450 | template <class T> |
---|
| 451 | inline const T & |
---|
| 452 | Color4<T>::operator [] (int i) const |
---|
| 453 | { |
---|
| 454 | return (&r)[i]; |
---|
| 455 | } |
---|
| 456 | |
---|
| 457 | template <class T> |
---|
| 458 | inline |
---|
| 459 | Color4<T>::Color4 () |
---|
| 460 | { |
---|
| 461 | // empty |
---|
| 462 | } |
---|
| 463 | |
---|
| 464 | template <class T> |
---|
| 465 | inline |
---|
| 466 | Color4<T>::Color4 (T x) |
---|
| 467 | { |
---|
| 468 | r = g = b = a = x; |
---|
| 469 | } |
---|
| 470 | |
---|
| 471 | template <class T> |
---|
| 472 | inline |
---|
| 473 | Color4<T>::Color4 (T x, T y, T z, T w) |
---|
| 474 | { |
---|
| 475 | r = x; |
---|
| 476 | g = y; |
---|
| 477 | b = z; |
---|
| 478 | a = w; |
---|
| 479 | } |
---|
| 480 | |
---|
| 481 | template <class T> |
---|
| 482 | inline |
---|
| 483 | Color4<T>::Color4 (const Color4 &v) |
---|
| 484 | { |
---|
| 485 | r = v.r; |
---|
| 486 | g = v.g; |
---|
| 487 | b = v.b; |
---|
| 488 | a = v.a; |
---|
| 489 | } |
---|
| 490 | |
---|
| 491 | template <class T> |
---|
| 492 | template <class S> |
---|
| 493 | inline |
---|
| 494 | Color4<T>::Color4 (const Color4<S> &v) |
---|
| 495 | { |
---|
| 496 | r = T (v.r); |
---|
| 497 | g = T (v.g); |
---|
| 498 | b = T (v.b); |
---|
| 499 | a = T (v.a); |
---|
| 500 | } |
---|
| 501 | |
---|
| 502 | template <class T> |
---|
| 503 | inline const Color4<T> & |
---|
| 504 | Color4<T>::operator = (const Color4 &v) |
---|
| 505 | { |
---|
| 506 | r = v.r; |
---|
| 507 | g = v.g; |
---|
| 508 | b = v.b; |
---|
| 509 | a = v.a; |
---|
| 510 | return *this; |
---|
| 511 | } |
---|
| 512 | |
---|
| 513 | template <class T> |
---|
| 514 | template <class S> |
---|
| 515 | inline void |
---|
| 516 | Color4<T>::setValue (S x, S y, S z, S w) |
---|
| 517 | { |
---|
| 518 | r = T (x); |
---|
| 519 | g = T (y); |
---|
| 520 | b = T (z); |
---|
| 521 | a = T (w); |
---|
| 522 | } |
---|
| 523 | |
---|
| 524 | template <class T> |
---|
| 525 | template <class S> |
---|
| 526 | inline void |
---|
| 527 | Color4<T>::setValue (const Color4<S> &v) |
---|
| 528 | { |
---|
| 529 | r = T (v.r); |
---|
| 530 | g = T (v.g); |
---|
| 531 | b = T (v.b); |
---|
| 532 | a = T (v.a); |
---|
| 533 | } |
---|
| 534 | |
---|
| 535 | template <class T> |
---|
| 536 | template <class S> |
---|
| 537 | inline void |
---|
| 538 | Color4<T>::getValue (S &x, S &y, S &z, S &w) const |
---|
| 539 | { |
---|
| 540 | x = S (r); |
---|
| 541 | y = S (g); |
---|
| 542 | z = S (b); |
---|
| 543 | w = S (a); |
---|
| 544 | } |
---|
| 545 | |
---|
| 546 | template <class T> |
---|
| 547 | template <class S> |
---|
| 548 | inline void |
---|
| 549 | Color4<T>::getValue (Color4<S> &v) const |
---|
| 550 | { |
---|
| 551 | v.r = S (r); |
---|
| 552 | v.g = S (g); |
---|
| 553 | v.b = S (b); |
---|
| 554 | v.a = S (a); |
---|
| 555 | } |
---|
| 556 | |
---|
| 557 | template <class T> |
---|
| 558 | inline T * |
---|
| 559 | Color4<T>::getValue() |
---|
| 560 | { |
---|
| 561 | return (T *) &r; |
---|
| 562 | } |
---|
| 563 | |
---|
| 564 | template <class T> |
---|
| 565 | inline const T * |
---|
| 566 | Color4<T>::getValue() const |
---|
| 567 | { |
---|
| 568 | return (const T *) &r; |
---|
| 569 | } |
---|
| 570 | |
---|
| 571 | template <class T> |
---|
| 572 | template <class S> |
---|
| 573 | inline bool |
---|
| 574 | Color4<T>::operator == (const Color4<S> &v) const |
---|
| 575 | { |
---|
| 576 | return r == v.r && g == v.g && b == v.b && a == v.a; |
---|
| 577 | } |
---|
| 578 | |
---|
| 579 | template <class T> |
---|
| 580 | template <class S> |
---|
| 581 | inline bool |
---|
| 582 | Color4<T>::operator != (const Color4<S> &v) const |
---|
| 583 | { |
---|
| 584 | return r != v.r || g != v.g || b != v.b || a != v.a; |
---|
| 585 | } |
---|
| 586 | |
---|
| 587 | template <class T> |
---|
| 588 | inline const Color4<T> & |
---|
| 589 | Color4<T>::operator += (const Color4 &v) |
---|
| 590 | { |
---|
| 591 | r += v.r; |
---|
| 592 | g += v.g; |
---|
| 593 | b += v.b; |
---|
| 594 | a += v.a; |
---|
| 595 | return *this; |
---|
| 596 | } |
---|
| 597 | |
---|
| 598 | template <class T> |
---|
| 599 | inline Color4<T> |
---|
| 600 | Color4<T>::operator + (const Color4 &v) const |
---|
| 601 | { |
---|
| 602 | return Color4 (r + v.r, g + v.g, b + v.b, a + v.a); |
---|
| 603 | } |
---|
| 604 | |
---|
| 605 | template <class T> |
---|
| 606 | inline const Color4<T> & |
---|
| 607 | Color4<T>::operator -= (const Color4 &v) |
---|
| 608 | { |
---|
| 609 | r -= v.r; |
---|
| 610 | g -= v.g; |
---|
| 611 | b -= v.b; |
---|
| 612 | a -= v.a; |
---|
| 613 | return *this; |
---|
| 614 | } |
---|
| 615 | |
---|
| 616 | template <class T> |
---|
| 617 | inline Color4<T> |
---|
| 618 | Color4<T>::operator - (const Color4 &v) const |
---|
| 619 | { |
---|
| 620 | return Color4 (r - v.r, g - v.g, b - v.b, a - v.a); |
---|
| 621 | } |
---|
| 622 | |
---|
| 623 | template <class T> |
---|
| 624 | inline Color4<T> |
---|
| 625 | Color4<T>::operator - () const |
---|
| 626 | { |
---|
| 627 | return Color4 (-r, -g, -b, -a); |
---|
| 628 | } |
---|
| 629 | |
---|
| 630 | template <class T> |
---|
| 631 | inline const Color4<T> & |
---|
| 632 | Color4<T>::negate () |
---|
| 633 | { |
---|
| 634 | r = -r; |
---|
| 635 | g = -g; |
---|
| 636 | b = -b; |
---|
| 637 | a = -a; |
---|
| 638 | return *this; |
---|
| 639 | } |
---|
| 640 | |
---|
| 641 | template <class T> |
---|
| 642 | inline const Color4<T> & |
---|
| 643 | Color4<T>::operator *= (const Color4 &v) |
---|
| 644 | { |
---|
| 645 | r *= v.r; |
---|
| 646 | g *= v.g; |
---|
| 647 | b *= v.b; |
---|
| 648 | a *= v.a; |
---|
| 649 | return *this; |
---|
| 650 | } |
---|
| 651 | |
---|
| 652 | template <class T> |
---|
| 653 | inline const Color4<T> & |
---|
| 654 | Color4<T>::operator *= (T x) |
---|
| 655 | { |
---|
| 656 | r *= x; |
---|
| 657 | g *= x; |
---|
| 658 | b *= x; |
---|
| 659 | a *= x; |
---|
| 660 | return *this; |
---|
| 661 | } |
---|
| 662 | |
---|
| 663 | template <class T> |
---|
| 664 | inline Color4<T> |
---|
| 665 | Color4<T>::operator * (const Color4 &v) const |
---|
| 666 | { |
---|
| 667 | return Color4 (r * v.r, g * v.g, b * v.b, a * v.a); |
---|
| 668 | } |
---|
| 669 | |
---|
| 670 | template <class T> |
---|
| 671 | inline Color4<T> |
---|
| 672 | Color4<T>::operator * (T x) const |
---|
| 673 | { |
---|
| 674 | return Color4 (r * x, g * x, b * x, a * x); |
---|
| 675 | } |
---|
| 676 | |
---|
| 677 | template <class T> |
---|
| 678 | inline const Color4<T> & |
---|
| 679 | Color4<T>::operator /= (const Color4 &v) |
---|
| 680 | { |
---|
| 681 | r /= v.r; |
---|
| 682 | g /= v.g; |
---|
| 683 | b /= v.b; |
---|
| 684 | a /= v.a; |
---|
| 685 | return *this; |
---|
| 686 | } |
---|
| 687 | |
---|
| 688 | template <class T> |
---|
| 689 | inline const Color4<T> & |
---|
| 690 | Color4<T>::operator /= (T x) |
---|
| 691 | { |
---|
| 692 | r /= x; |
---|
| 693 | g /= x; |
---|
| 694 | b /= x; |
---|
| 695 | a /= x; |
---|
| 696 | return *this; |
---|
| 697 | } |
---|
| 698 | |
---|
| 699 | template <class T> |
---|
| 700 | inline Color4<T> |
---|
| 701 | Color4<T>::operator / (const Color4 &v) const |
---|
| 702 | { |
---|
| 703 | return Color4 (r / v.r, g / v.g, b / v.b, a / v.a); |
---|
| 704 | } |
---|
| 705 | |
---|
| 706 | template <class T> |
---|
| 707 | inline Color4<T> |
---|
| 708 | Color4<T>::operator / (T x) const |
---|
| 709 | { |
---|
| 710 | return Color4 (r / x, g / x, b / x, a / x); |
---|
| 711 | } |
---|
| 712 | |
---|
| 713 | |
---|
| 714 | template <class T> |
---|
| 715 | std::ostream & |
---|
| 716 | operator << (std::ostream &s, const Color4<T> &v) |
---|
| 717 | { |
---|
| 718 | return s << '(' << v.r << ' ' << v.g << ' ' << v.b << ' ' << v.a << ')'; |
---|
| 719 | } |
---|
| 720 | |
---|
| 721 | //----------------------------------------- |
---|
| 722 | // Implementation of reverse multiplication |
---|
| 723 | //----------------------------------------- |
---|
| 724 | |
---|
| 725 | template <class S, class T> |
---|
| 726 | inline Color4<T> |
---|
| 727 | operator * (S x, const Color4<T> &v) |
---|
| 728 | { |
---|
| 729 | return Color4<T> (x * v.r, x * v.g, x * v.b, x * v.a); |
---|
| 730 | } |
---|
| 731 | |
---|
| 732 | } // namespace Imath |
---|
| 733 | |
---|
| 734 | #endif |
---|