Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

OgrePixelConversions.h

Go to the documentation of this file.
00001  /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004     (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org/
00006 
00007 Copyright (c) 2000-2006 Torus Knot Software Ltd
00008 Also see acknowledgements in Readme.html
00009 
00010 This program is free software; you can redistribute it and/or modify it under
00011 the terms of the GNU Lesser General Public License as published by the Free Software
00012 Foundation; either version 2 of the License, or (at your option) any later
00013 version.
00014 
00015 This program is distributed in the hope that it will be useful, but WITHOUT
00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public License along with
00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
00022 http://www.gnu.org/copyleft/lesser.txt.
00023 
00024 You may alternatively use this source under the terms of a specific version of
00025 the OGRE Unrestricted License provided you have obtained such a license from
00026 Torus Knot Software Ltd.
00027 -----------------------------------------------------------------------------
00028 */
00030 using namespace Ogre;
00031 
00032 // NB VC6 can't handle these templates
00033 #if OGRE_COMPILER != OGRE_COMPILER_MSVC || OGRE_COMP_VER >= 1300
00034 
00035 #define FMTCONVERTERID(from,to) (((from)<<8)|(to))
00036 
00047 template <class U> struct PixelBoxConverter 
00048 {
00049     static const int ID = U::ID;
00050     static void conversion(const PixelBox &src, const PixelBox &dst)
00051     {
00052         typename U::SrcType *srcptr = static_cast<typename U::SrcType*>(src.data);
00053         typename U::DstType *dstptr = static_cast<typename U::DstType*>(dst.data);
00054         const size_t srcSliceSkip = src.getSliceSkip();
00055         const size_t dstSliceSkip = dst.getSliceSkip();
00056         const size_t k = src.right - src.left;
00057         for(size_t z=src.front; z<src.back; z++) 
00058         {
00059             for(size_t y=src.top; y<src.bottom; y++)
00060             {
00061                 for(size_t x=0; x<k; x++)
00062                 {
00063                     dstptr[x] = U::pixelConvert(srcptr[x]);
00064                 }
00065                 srcptr += src.rowPitch;
00066                 dstptr += dst.rowPitch;
00067             }
00068             srcptr += srcSliceSkip;
00069             dstptr += dstSliceSkip;
00070         }    
00071     }
00072 };
00073 
00074 template <typename T, typename U, int id> struct PixelConverter {
00075     static const int ID = id;
00076     typedef T SrcType;
00077     typedef U DstType;    
00078     
00079     //inline static DstType pixelConvert(const SrcType &inp);
00080 };
00081 
00082 
00084 struct Col3b {
00085     Col3b(unsigned int a, unsigned int b, unsigned int c): 
00086         x((uint8)a), y((uint8)b), z((uint8)c) { }
00087     uint8 x,y,z;
00088 };
00090 struct Col3f {
00091     Col3f(float r, float g, float b):
00092         r(r), g(g), b(b) { }
00093     float r,g,b;
00094 };
00096 struct Col4f {
00097     Col4f(float r, float g, float b, float a):
00098         r(r), g(g), b(b), a(a) { }
00099     float r,g,b,a;
00100 };
00101 
00102 struct A8R8G8B8toA8B8G8R8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_A8R8G8B8, PF_A8B8G8R8)>
00103 {
00104     inline static DstType pixelConvert(SrcType inp)
00105     {
00106         return ((inp&0x000000FF)<<16)|(inp&0xFF00FF00)|((inp&0x00FF0000)>>16);
00107     }
00108 };
00109 
00110 struct A8R8G8B8toB8G8R8A8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_A8R8G8B8, PF_B8G8R8A8)>
00111 {
00112     inline static DstType pixelConvert(SrcType inp)
00113     {
00114         return ((inp&0x000000FF)<<24)|((inp&0x0000FF00)<<8)|((inp&0x00FF0000)>>8)|((inp&0xFF000000)>>24);
00115     }
00116 };
00117 
00118 struct A8R8G8B8toR8G8B8A8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_A8R8G8B8, PF_R8G8B8A8)>
00119 {
00120     inline static DstType pixelConvert(SrcType inp)
00121     {
00122         return ((inp&0x00FFFFFF)<<8)|((inp&0xFF000000)>>24);
00123     }
00124 };
00125 
00126 struct A8B8G8R8toA8R8G8B8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_A8B8G8R8, PF_A8R8G8B8)>
00127 {
00128     inline static DstType pixelConvert(SrcType inp)
00129     {
00130         return ((inp&0x000000FF)<<16)|(inp&0xFF00FF00)|((inp&0x00FF0000)>>16);
00131     }
00132 };
00133 
00134 struct A8B8G8R8toB8G8R8A8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_A8B8G8R8, PF_B8G8R8A8)>
00135 {
00136     inline static DstType pixelConvert(SrcType inp)
00137     {
00138         return ((inp&0x00FFFFFF)<<8)|((inp&0xFF000000)>>24);
00139     }
00140 };
00141 
00142 struct A8B8G8R8toR8G8B8A8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_A8B8G8R8, PF_R8G8B8A8)>
00143 {
00144     inline static DstType pixelConvert(SrcType inp)
00145     {
00146         return ((inp&0x000000FF)<<24)|((inp&0x0000FF00)<<8)|((inp&0x00FF0000)>>8)|((inp&0xFF000000)>>24);
00147     }
00148 };
00149 
00150 struct B8G8R8A8toA8R8G8B8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_B8G8R8A8, PF_A8R8G8B8)>
00151 {
00152     inline static DstType pixelConvert(SrcType inp)
00153     {
00154         return ((inp&0x000000FF)<<24)|((inp&0x0000FF00)<<8)|((inp&0x00FF0000)>>8)|((inp&0xFF000000)>>24);
00155     }
00156 };
00157 
00158 struct B8G8R8A8toA8B8G8R8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_B8G8R8A8, PF_A8B8G8R8)>
00159 {
00160     inline static DstType pixelConvert(SrcType inp)
00161     {
00162         return ((inp&0x000000FF)<<24)|((inp&0xFFFFFF00)>>8);
00163     }
00164 };
00165 
00166 struct B8G8R8A8toR8G8B8A8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_B8G8R8A8, PF_R8G8B8A8)>
00167 {
00168     inline static DstType pixelConvert(SrcType inp)
00169     {
00170         return ((inp&0x0000FF00)<<16)|(inp&0x00FF00FF)|((inp&0xFF000000)>>16);
00171     }
00172 };
00173 
00174 struct R8G8B8A8toA8R8G8B8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_R8G8B8A8, PF_A8R8G8B8)>
00175 {
00176     inline static DstType pixelConvert(SrcType inp)
00177     {
00178         return ((inp&0x000000FF)<<24)|((inp&0xFFFFFF00)>>8);
00179     }
00180 };
00181 
00182 struct R8G8B8A8toA8B8G8R8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_R8G8B8A8, PF_A8B8G8R8)>
00183 {
00184     inline static DstType pixelConvert(SrcType inp)
00185     {
00186         return ((inp&0x000000FF)<<24)|((inp&0x0000FF00)<<8)|((inp&0x00FF0000)>>8)|((inp&0xFF000000)>>24);
00187     }
00188 };
00189 
00190 struct R8G8B8A8toB8G8R8A8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_R8G8B8A8, PF_B8G8R8A8)>
00191 {
00192     inline static DstType pixelConvert(SrcType inp)
00193     {
00194         return ((inp&0x0000FF00)<<16)|(inp&0x00FF00FF)|((inp&0xFF000000)>>16);
00195     }
00196 };
00197 
00198 struct A8B8G8R8toL8: public PixelConverter <uint32, uint8, FMTCONVERTERID(PF_A8B8G8R8, PF_L8)>
00199 {
00200     inline static DstType pixelConvert(SrcType inp)
00201     {
00202         return (uint8)(inp&0x000000FF);
00203     }
00204 };
00205 
00206 struct L8toA8B8G8R8: public PixelConverter <uint8, uint32, FMTCONVERTERID(PF_L8, PF_A8B8G8R8)>
00207 {
00208     inline static DstType pixelConvert(SrcType inp)
00209     {
00210         return 0xFF000000|(((unsigned int)inp)<<0)|(((unsigned int)inp)<<8)|(((unsigned int)inp)<<16);
00211     }
00212 };
00213 
00214 struct A8R8G8B8toL8: public PixelConverter <uint32, uint8, FMTCONVERTERID(PF_A8R8G8B8, PF_L8)>
00215 {
00216     inline static DstType pixelConvert(SrcType inp)
00217     {
00218         return (uint8)((inp&0x00FF0000)>>16);
00219     }
00220 };
00221 
00222 struct L8toA8R8G8B8: public PixelConverter <uint8, uint32, FMTCONVERTERID(PF_L8, PF_A8R8G8B8)>
00223 {
00224     inline static DstType pixelConvert(SrcType inp)
00225     {
00226         return 0xFF000000|(((unsigned int)inp)<<0)|(((unsigned int)inp)<<8)|(((unsigned int)inp)<<16);
00227     }
00228 };
00229 
00230 struct B8G8R8A8toL8: public PixelConverter <uint32, uint8, FMTCONVERTERID(PF_B8G8R8A8, PF_L8)>
00231 {
00232     inline static DstType pixelConvert(SrcType inp)
00233     {
00234         return (uint8)((inp&0x0000FF00)>>8);
00235     }
00236 };
00237 
00238 struct L8toB8G8R8A8: public PixelConverter <uint8, uint32, FMTCONVERTERID(PF_L8, PF_B8G8R8A8)>
00239 {
00240     inline static DstType pixelConvert(SrcType inp)
00241     {
00242         return 0x000000FF|(((unsigned int)inp)<<8)|(((unsigned int)inp)<<16)|(((unsigned int)inp)<<24);
00243     }
00244 };
00245 
00246 struct L8toL16: public PixelConverter <uint8, uint16, FMTCONVERTERID(PF_L8, PF_L16)>
00247 {
00248     inline static DstType pixelConvert(SrcType inp)
00249     {
00250         return (uint16)((((unsigned int)inp)<<8)|(((unsigned int)inp)));
00251     }
00252 };
00253 
00254 struct L16toL8: public PixelConverter <uint16, uint8, FMTCONVERTERID(PF_L16, PF_L8)>
00255 {
00256     inline static DstType pixelConvert(SrcType inp)
00257     {
00258         return (uint8)(inp>>8);
00259     }
00260 };
00261 
00262 struct R8G8B8toB8G8R8: public PixelConverter <Col3b, Col3b, FMTCONVERTERID(PF_R8G8B8, PF_B8G8R8)>
00263 {
00264     inline static DstType pixelConvert(const SrcType &inp)
00265     {
00266         return Col3b(inp.z, inp.y, inp.x);
00267     }  
00268 };
00269 
00270 struct B8G8R8toR8G8B8: public PixelConverter <Col3b, Col3b, FMTCONVERTERID(PF_B8G8R8, PF_R8G8B8)>
00271 {
00272     inline static DstType pixelConvert(const SrcType &inp)
00273     {
00274         return Col3b(inp.z, inp.y, inp.x);
00275     }  
00276 };
00277 
00278 // X8Y8Z8 ->  X8<<xshift Y8<<yshift Z8<<zshift A8<<ashift
00279 template <int id, unsigned int xshift, unsigned int yshift, unsigned int zshift, unsigned int ashift> struct Col3btoUint32swizzler:
00280     public PixelConverter <Col3b, uint32, id>
00281 {
00282     inline static uint32 pixelConvert(const Col3b &inp)
00283     {
00284 #if OGRE_ENDIAN == OGRE_ENDIAN_BIG
00285         return (0xFF<<ashift) | (((unsigned int)inp.x)<<xshift) | (((unsigned int)inp.y)<<yshift) | (((unsigned int)inp.z)<<zshift);
00286 #else
00287         return (0xFF<<ashift) | (((unsigned int)inp.x)<<zshift) | (((unsigned int)inp.y)<<yshift) | (((unsigned int)inp.z)<<xshift);
00288 #endif
00289     }
00290 };
00291 
00292 struct R8G8B8toA8R8G8B8: public Col3btoUint32swizzler<FMTCONVERTERID(PF_R8G8B8, PF_A8R8G8B8), 16, 8, 0, 24> { };
00293 struct B8G8R8toA8R8G8B8: public Col3btoUint32swizzler<FMTCONVERTERID(PF_B8G8R8, PF_A8R8G8B8), 0, 8, 16, 24> { };
00294 struct R8G8B8toA8B8G8R8: public Col3btoUint32swizzler<FMTCONVERTERID(PF_R8G8B8, PF_A8B8G8R8), 0, 8, 16, 24> { };
00295 struct B8G8R8toA8B8G8R8: public Col3btoUint32swizzler<FMTCONVERTERID(PF_B8G8R8, PF_A8B8G8R8), 16, 8, 0, 24> { };
00296 struct R8G8B8toB8G8R8A8: public Col3btoUint32swizzler<FMTCONVERTERID(PF_R8G8B8, PF_B8G8R8A8), 8, 16, 24, 0> { };
00297 struct B8G8R8toB8G8R8A8: public Col3btoUint32swizzler<FMTCONVERTERID(PF_B8G8R8, PF_B8G8R8A8), 24, 16, 8, 0> { };
00298 
00299 struct A8R8G8B8toR8G8B8: public PixelConverter <uint32, Col3b, FMTCONVERTERID(PF_A8R8G8B8, PF_BYTE_RGB)>
00300 {
00301     inline static DstType pixelConvert(uint32 inp)
00302     {
00303         return Col3b((uint8)((inp>>16)&0xFF), (uint8)((inp>>8)&0xFF), (uint8)((inp>>0)&0xFF));
00304     }
00305 };
00306 struct A8R8G8B8toB8G8R8: public PixelConverter <uint32, Col3b, FMTCONVERTERID(PF_A8R8G8B8, PF_BYTE_BGR)>
00307 {
00308     inline static DstType pixelConvert(uint32 inp)
00309     {
00310         return Col3b((uint8)((inp>>0)&0xFF), (uint8)((inp>>8)&0xFF), (uint8)((inp>>16)&0xFF));
00311     }
00312 };
00313 
00314 // Only conversions from X8R8G8B8 to formats with alpha need to be defined, the rest is implicitly the same
00315 // as A8R8G8B8
00316 struct X8R8G8B8toA8R8G8B8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_X8R8G8B8, PF_A8R8G8B8)>
00317 {
00318     inline static DstType pixelConvert(SrcType inp)
00319     {
00320         return inp | 0xFF000000;
00321     }
00322 };
00323 struct X8R8G8B8toA8B8G8R8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_X8R8G8B8, PF_A8B8G8R8)>
00324 {
00325     inline static DstType pixelConvert(SrcType inp)
00326     {
00327         return ((inp&0x0000FF)<<16)|((inp&0xFF0000)>>16)|(inp&0x00FF00)|0xFF000000;
00328     }
00329 };
00330 struct X8R8G8B8toB8G8R8A8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_X8R8G8B8, PF_B8G8R8A8)>
00331 {
00332     inline static DstType pixelConvert(SrcType inp)
00333     {
00334         return ((inp&0x0000FF)<<24)|((inp&0xFF0000)>>8)|((inp&0x00FF00)<<8)|0x000000FF;
00335     }
00336 };
00337 struct X8R8G8B8toR8G8B8A8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_X8R8G8B8, PF_R8G8B8A8)>
00338 {
00339     inline static DstType pixelConvert(SrcType inp)
00340     {
00341         return ((inp&0xFFFFFF)<<8)|0x000000FF;
00342     }
00343 };
00344 
00345 // X8B8G8R8
00346 struct X8B8G8R8toA8R8G8B8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_X8B8G8R8, PF_A8R8G8B8)>
00347 {
00348     inline static DstType pixelConvert(SrcType inp)
00349     {
00350         return ((inp&0x0000FF)<<16)|((inp&0xFF0000)>>16)|(inp&0x00FF00)|0xFF000000;
00351     }
00352 };
00353 struct X8B8G8R8toA8B8G8R8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_X8B8G8R8, PF_A8B8G8R8)>
00354 {
00355     inline static DstType pixelConvert(SrcType inp)
00356     {
00357         return inp | 0xFF000000;
00358     }
00359 };
00360 struct X8B8G8R8toB8G8R8A8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_X8B8G8R8, PF_B8G8R8A8)>
00361 {
00362     inline static DstType pixelConvert(SrcType inp)
00363     {
00364         return ((inp&0xFFFFFF)<<8)|0x000000FF;
00365     }
00366 };
00367 struct X8B8G8R8toR8G8B8A8: public PixelConverter <uint32, uint32, FMTCONVERTERID(PF_X8B8G8R8, PF_R8G8B8A8)>
00368 {
00369     inline static DstType pixelConvert(SrcType inp)
00370     {
00371         return ((inp&0x0000FF)<<24)|((inp&0xFF0000)>>8)|((inp&0x00FF00)<<8)|0x000000FF;
00372     }
00373 };
00374 
00375 
00376 #define CASECONVERTER(type) case type::ID : PixelBoxConverter<type>::conversion(src, dst); return 1;
00377 
00378 inline int doOptimizedConversion(const PixelBox &src, const PixelBox &dst)
00379 {;
00380     switch(FMTCONVERTERID(src.format, dst.format))
00381     {
00382         // Register converters here
00383         CASECONVERTER(A8R8G8B8toA8B8G8R8);
00384         CASECONVERTER(A8R8G8B8toB8G8R8A8);
00385         CASECONVERTER(A8R8G8B8toR8G8B8A8);
00386         CASECONVERTER(A8B8G8R8toA8R8G8B8);
00387         CASECONVERTER(A8B8G8R8toB8G8R8A8);
00388         CASECONVERTER(A8B8G8R8toR8G8B8A8);
00389         CASECONVERTER(B8G8R8A8toA8R8G8B8);
00390         CASECONVERTER(B8G8R8A8toA8B8G8R8);
00391         CASECONVERTER(B8G8R8A8toR8G8B8A8);
00392         CASECONVERTER(R8G8B8A8toA8R8G8B8);
00393         CASECONVERTER(R8G8B8A8toA8B8G8R8);
00394         CASECONVERTER(R8G8B8A8toB8G8R8A8);
00395         CASECONVERTER(A8B8G8R8toL8);
00396         CASECONVERTER(L8toA8B8G8R8);
00397         CASECONVERTER(A8R8G8B8toL8);
00398         CASECONVERTER(L8toA8R8G8B8);
00399         CASECONVERTER(B8G8R8A8toL8);
00400         CASECONVERTER(L8toB8G8R8A8);
00401         CASECONVERTER(L8toL16);
00402         CASECONVERTER(L16toL8);
00403         CASECONVERTER(B8G8R8toR8G8B8);
00404         CASECONVERTER(R8G8B8toB8G8R8);
00405         CASECONVERTER(R8G8B8toA8R8G8B8);
00406         CASECONVERTER(B8G8R8toA8R8G8B8);
00407         CASECONVERTER(R8G8B8toA8B8G8R8);
00408         CASECONVERTER(B8G8R8toA8B8G8R8);
00409         CASECONVERTER(R8G8B8toB8G8R8A8);
00410         CASECONVERTER(B8G8R8toB8G8R8A8);
00411         CASECONVERTER(A8R8G8B8toR8G8B8);
00412         CASECONVERTER(A8R8G8B8toB8G8R8);
00413         CASECONVERTER(X8R8G8B8toA8R8G8B8);
00414         CASECONVERTER(X8R8G8B8toA8B8G8R8);
00415         CASECONVERTER(X8R8G8B8toB8G8R8A8);
00416         CASECONVERTER(X8R8G8B8toR8G8B8A8);
00417         CASECONVERTER(X8B8G8R8toA8R8G8B8);
00418         CASECONVERTER(X8B8G8R8toA8B8G8R8);
00419         CASECONVERTER(X8B8G8R8toB8G8R8A8);
00420         CASECONVERTER(X8B8G8R8toR8G8B8A8);
00421 
00422         default:
00423             return 0;
00424     }
00425 }
00426 #undef CASECONVERTER
00427 
00428 #endif // VC6 protection

Copyright © 2000-2005 by The OGRE Team
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Sep 30 10:50:57 2007