nevrax.org : docs

00001 
00007 /* Copyright, 2000 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 #ifndef NL_RGBA_H
00027 #define NL_RGBA_H
00028 
00029 #include "nel/misc/types_nl.h"
00030 #include "nel/misc/common.h"
00031 
00032 
00033 namespace NLMISC 
00034 {
00035 
00036 class   IStream;
00037 
00044 class CRGBA
00045 {
00046 public:
00047 
00049         CRGBA() {};
00050 
00058         CRGBA(uint8 r, uint8 g, uint8 b, uint8 a=255) :
00059                 R(r), G(g), B(b), A(a) {}
00060 
00064         uint    getPacked() const {return ((uint)R<<24) + ((uint)G<<16) + ((uint)B<<8) + A;}
00065 
00069         bool    operator<(CRGBA c) const {return getPacked()<c.getPacked();}
00073         bool    operator!=(CRGBA c) const {return !(*this==c);}
00074 
00078         bool    operator==(CRGBA c) const  
00079                 {return R==c.R && G==c.G && B==c.B && A==c.A;}
00080 
00085         void    serial (class NLMISC::IStream &f);
00086 
00093         void blendFromui(CRGBA c0, CRGBA c1, uint coef) // coef must be in [0,256]
00094         {
00095                 uint    a1 = coef;
00096                 uint    a2 = 256-a1;
00097                 R = (c0.R*a2 + c1.R*a1) >>8;
00098                 G = (c0.G*a2 + c1.G*a1) >>8;
00099                 B = (c0.B*a2 + c1.B*a1) >>8;
00100                 A = (c0.A*a2 + c1.A*a1) >>8;
00101         }
00102 
00108         void    modulateFromui (CRGBA c0, uint a)
00109         {
00110                 R = (c0.R*a) >>8;
00111                 G = (c0.G*a) >>8;
00112                 B = (c0.B*a) >>8;
00113                 A = (c0.A*a) >>8;
00114         }
00115 
00116 
00122         void    modulateFromColor (CRGBA c0, CRGBA c1)
00123         {
00124                 R = (c0.R*c1.R) >>8;
00125                 G = (c0.G*c1.G) >>8;
00126                 B = (c0.B*c1.B) >>8;
00127                 A = (c0.A*c1.A) >>8;
00128         }
00129 
00130 
00138         void    set (uint8 r, uint8 g, uint8 b, uint8 a=255);
00139 
00143         uint16 get565 () const
00144         {
00145                 return ((uint16)(R&0xf8)<<8) | ((uint16)(G&0xfc)<<3) | (uint16)(B>>3);
00146         }
00147 
00151         void    set565(uint16 col)
00152         {
00153                 // unpack.
00154                 R= col>>11;
00155                 G= (col>>5)&0x3F;
00156                 B= (col)&0x1F;
00157                 // to 8 bits.
00158                 R= (R<<3) + (R>>2);
00159                 G= (G<<2) + (G>>4);
00160                 B= (B<<3) + (B>>2);
00161         }
00162 
00163 
00167         void    avg2(CRGBA a, CRGBA b)
00168         {
00169                 R= ((uint)a.R+(uint)b.R)>>1;
00170                 G= ((uint)a.G+(uint)b.G)>>1;
00171                 B= ((uint)a.B+(uint)b.B)>>1;
00172                 A= ((uint)a.A+(uint)b.A)>>1;
00173         }
00174 
00179         void    avg4(CRGBA a, CRGBA b, CRGBA c, CRGBA d)
00180         {
00181                 R= ((uint)a.R+(uint)b.R+(uint)c.R+(uint)d.R+ 1)>>2;
00182                 G= ((uint)a.G+(uint)b.G+(uint)c.G+(uint)d.G+ 1)>>2;
00183                 B= ((uint)a.B+(uint)b.B+(uint)c.B+(uint)d.B+ 1)>>2;
00184                 A= ((uint)a.A+(uint)b.A+(uint)c.A+(uint)d.A+ 1)>>2;
00185         }
00186 
00190         void    add(CRGBA c0, CRGBA c1)
00191         {
00192                 uint    r,g,b,a;
00193                 r= c0.R + c1.R; r= std::min(r, 255U);   R= (uint8)r;
00194                 g= c0.G + c1.G; g= std::min(g, 255U);   G= (uint8)g;
00195                 b= c0.B + c1.B; b= std::min(b, 255U);   B= (uint8)b;
00196                 a= c0.A + c1.A; a= std::min(a, 255U);   A= (uint8)a;
00197         }
00198 
00202         void    sub(CRGBA c0, CRGBA c1)
00203         {
00204                 sint    r,g,b,a;
00205                 r= c0.R - c1.R; r= std::max(r, 0);      R= (uint8)r;
00206                 g= c0.G - c1.G; g= std::max(g, 0);      G= (uint8)g;
00207                 b= c0.B - c1.B; b= std::max(b, 0);      B= (uint8)b;
00208                 a= c0.A - c1.A; a= std::max(a, 0);      A= (uint8)a;
00209         }
00210 
00211 
00213         // @{
00214 
00216         void    blendFromuiRGBOnly(CRGBA c0, CRGBA c1, uint coef) // coef must be in [0,256]
00217         {
00218                 uint    a1 = coef;
00219                 uint    a2 = 256-a1;
00220                 R = (c0.R*a2 + c1.R*a1) >>8;
00221                 G = (c0.G*a2 + c1.G*a1) >>8;
00222                 B = (c0.B*a2 + c1.B*a1) >>8;
00223         }
00225         void    modulateFromuiRGBOnly(CRGBA c0, uint a)
00226         {
00227                 R = (c0.R*a) >>8;
00228                 G = (c0.G*a) >>8;
00229                 B = (c0.B*a) >>8;
00230         }
00232         void    modulateFromColorRGBOnly(CRGBA c0, CRGBA c1)
00233         {
00234                 R = (c0.R*c1.R) >>8;
00235                 G = (c0.G*c1.G) >>8;
00236                 B = (c0.B*c1.B) >>8;
00237         }
00239         void    avg2RGBOnly(CRGBA a, CRGBA b)
00240         {
00241                 R= ((uint)a.R+(uint)b.R)>>1;
00242                 G= ((uint)a.G+(uint)b.G)>>1;
00243                 B= ((uint)a.B+(uint)b.B)>>1;
00244         }
00246         void    avg4RGBOnly(CRGBA a, CRGBA b, CRGBA c, CRGBA d)
00247         {
00248                 R= ((uint)a.R+(uint)b.R+(uint)c.R+(uint)d.R+ 1)>>2;
00249                 G= ((uint)a.G+(uint)b.G+(uint)c.G+(uint)d.G+ 1)>>2;
00250                 B= ((uint)a.B+(uint)b.B+(uint)c.B+(uint)d.B+ 1)>>2;
00251         }
00253         void    addRGBOnly(CRGBA c0, CRGBA c1)
00254         {
00255                 uint    r,g,b;
00256                 r= c0.R + c1.R; r= std::min(r, 255U);   R= (uint8)r;
00257                 g= c0.G + c1.G; g= std::min(g, 255U);   G= (uint8)g;
00258                 b= c0.B + c1.B; b= std::min(b, 255U);   B= (uint8)b;
00259         }
00261         void    subRGBOnly(CRGBA c0, CRGBA c1)
00262         {
00263                 sint    r,g,b;
00264                 r= c0.R - c1.R; r= std::max(r, 0);      R= (uint8)r;
00265                 g= c0.G - c1.G; g= std::max(g, 0);      G= (uint8)g;
00266                 b= c0.B - c1.B; b= std::max(b, 0);      B= (uint8)b;
00267         }
00268 
00269 
00270 
00271         // @}
00272 
00274 
00275 
00284                 static void addColors(CRGBA *dest, const CRGBA *src1, const CRGBA *src2, uint numColors, uint srcStride = sizeof(CRGBA), uint destStride = sizeof(CRGBA), uint dup = 1);
00285 
00293                 static void modulateColors(CRGBA *dest, const CRGBA *src1, const CRGBA *src2, uint numColors, uint srcStride = sizeof(CRGBA), uint destStride = sizeof(CRGBA), uint dup = 1);
00294 
00302                 static void subtractColors(CRGBA *dest, const CRGBA *src1, const CRGBA *src2, uint numColors, uint srcStride = sizeof(CRGBA), uint destStride = sizeof(CRGBA), uint dup = 1);
00304 
00306 
00307 
00312                         bool convertToHLS(float &h, float &l, float &S) const;
00313 
00317                         void buildFromHLS(float h, float l, float s);
00319 
00320 
00321 
00323         uint8   R;
00325         uint8   G;
00327         uint8   B;
00329         uint8   A;
00330 
00331 
00333         static const CRGBA Black ;
00334         static const CRGBA Red ;
00335         static const CRGBA Green ;
00336         static const CRGBA Yellow ;
00337         static const CRGBA Blue ;
00338         static const CRGBA Magenta ;
00339         static const CRGBA Cyan ;
00340         static const CRGBA White ;
00341 };
00342 
00343 
00350 class CBGRA
00351 {
00352 public:
00353 
00355         CBGRA() {};
00356 
00361         CBGRA(CRGBA c) 
00362         {
00363                 R=c.R;
00364                 G=c.G;
00365                 B=c.B;
00366                 A=c.A;
00367         };
00368 
00376         CBGRA(uint8 r, uint8 g, uint8 b, uint8 a=255) :
00377                 R(r), G(g), B(b), A(a) {}
00378 
00382         operator CRGBA()
00383         {
00384                 return CRGBA (R, G, B, A);
00385         }
00386 
00390         uint    getPacked() const 
00391         {
00392                 return ((uint)R<<24) + ((uint)G<<16) + ((uint)B<<8) + A;
00393         }
00394 
00398         bool    operator<(const CBGRA &c) const 
00399         {
00400                 return getPacked()<c.getPacked();
00401         }
00402 
00406         bool    operator==(const CBGRA &c) const  
00407         {
00408                 return R==c.R && G==c.G && B==c.B && A==c.A;
00409         }
00410 
00415         void    serial(class NLMISC::IStream &f);
00416 
00423         void blendFromui(CBGRA &c0, CBGRA &c1, uint factor); 
00424 
00432         void set(uint8 r, uint8 g, uint8 b, uint8 a);
00433 
00435         uint8   R;
00437         uint8   G;
00439         uint8   B;
00441         uint8   A;
00442 };
00443 
00444 
00451 class CRGBAF
00452 {
00453 public:
00455         CRGBAF ()
00456         {}
00457 
00465         CRGBAF (float _r, float _g, float _b, float _a=1.f)
00466         {
00467                 R=_r;
00468                 G=_g;
00469                 B=_b;
00470                 A=_a;
00471         }
00472 
00477         CRGBAF (CRGBA c)
00478         {
00479                 R=(float)c.R/255.f;
00480                 G=(float)c.G/255.f;
00481                 B=(float)c.B/255.f;
00482                 A=(float)c.A/255.f;
00483         }
00484 
00488         operator CRGBA() const
00489         {
00490                 uint8 _r=(uint8)(R*255.f);
00491                 uint8 _g=(uint8)(G*255.f);
00492                 uint8 _b=(uint8)(B*255.f);
00493                 uint8 _a=(uint8)(A*255.f);
00494                 return CRGBA (_r, _g, _b, _a);
00495         }
00496 
00500         void normalize ()
00501         {
00502                 R= (R>1.f) ? 1.f : (R<0.f) ? 0.f : R;
00503                 G= (G>1.f) ? 1.f : (G<0.f) ? 0.f : G;
00504                 B= (B>1.f) ? 1.f : (B<0.f) ? 0.f : B;
00505                 A= (A>1.f) ? 1.f : (A<0.f) ? 0.f : A;
00506         }
00507 
00513         CRGBAF operator+ (const CRGBAF& c) const
00514         {
00515                 return CRGBAF (R+c.R, G+c.G, B+c.B, A+c.A);
00516         }
00517 
00523         CRGBAF operator- (const CRGBAF& c) const
00524         {
00525                 return CRGBAF (R-c.R, G-c.G, B-c.B, A-c.A);
00526         }
00527 
00533         CRGBAF operator* (const CRGBAF& c) const
00534         {
00535                 return CRGBAF (R*c.R, G*c.G, B*c.B, A*c.A);
00536         }
00537 
00543         CRGBAF operator* (float f) const
00544         {
00545                 return CRGBAF (R*f, G*f, B*f, A*f);
00546         }
00547 
00553         CRGBAF operator/ (float f) const
00554         {
00555                 return CRGBAF (R/f, G/f, B/f, A/f);
00556         }
00557 
00563         CRGBAF& operator+= (const CRGBAF& c)
00564         {
00565                 R+=c.R;
00566                 G+=c.G;
00567                 B+=c.B;
00568                 A+=c.A;
00569                 return *this;
00570         }
00571 
00577         CRGBAF& operator-= (const CRGBAF& c)
00578         {
00579                 R-=c.R;
00580                 G-=c.G;
00581                 B-=c.B;
00582                 A-=c.A;
00583                 return *this;
00584         }
00585 
00591         CRGBAF& operator*= (const CRGBAF& c)
00592         {
00593                 R*=c.R;
00594                 G*=c.G;
00595                 B*=c.B;
00596                 A*=c.A;
00597                 return *this;
00598         }
00599 
00605         CRGBAF& operator*= (float f)
00606         {
00607                 R*=f;
00608                 G*=f;
00609                 B*=f;
00610                 A*=f;
00611                 return *this;
00612         }
00613 
00619         CRGBAF& operator/= (float f)
00620         {
00621                 R/=f;
00622                 G/=f;
00623                 B/=f;
00624                 A/=f;
00625                 return *this;
00626         }
00627 
00632         void    serial(class NLMISC::IStream &f);
00633 
00641         void set(float r, float g, float b, float a);
00642         
00644         float   R;
00646         float   G;
00648         float   B;
00650         float   A;
00651 };
00652 
00658 inline CRGBAF operator* (float f, const CRGBAF& c)
00659 {
00660         return CRGBAF (c.R*f, c.G*f, c.B*f, c.A*f);
00661 }
00662 
00663 } // NLMISC
00664 
00665 
00666 #endif // NL_RGBA_H
00667 
00668 /* End of rgba.h */