OGRE  2.0
Object-Oriented Graphics Rendering Engine
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
OgrePixelFormatDescriptions.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4  (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2014 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __PixelFormatDescriptions_H__
29 #define __PixelFormatDescriptions_H__
30 
31 #include "OgrePrerequisites.h"
32 #include "OgreCommon.h"
33 #include "OgreHeaderPrefix.h"
34 
35 namespace Ogre {
36  //-----------------------------------------------------------------------
41  /* Name of the format, as in the enum */
42  const char *name;
43  /* Number of bytes one element (colour value) takes. */
44  unsigned char elemBytes;
45  /* Pixel format flags, see enum PixelFormatFlags for the bit field
46  * definitions
47  */
54  unsigned char componentCount;
55  /* Number of bits for red(or luminance), green, blue, alpha
56  */
57  unsigned char rbits, gbits, bbits, abits; /*, ibits, dbits, ... */
58 
59  /* Masks and shifts as used by packers/unpackers */
61  unsigned char rshift, gshift, bshift, ashift;
62  };
63  //-----------------------------------------------------------------------
66  //-----------------------------------------------------------------------
67  {"PF_UNKNOWN",
68  /* Bytes per element */
69  0,
70  /* Flags */
71  0,
72  /* Component type and count */
73  PCT_BYTE, 0,
74  /* rbits, gbits, bbits, abits */
75  0, 0, 0, 0,
76  /* Masks and shifts */
77  0, 0, 0, 0, 0, 0, 0, 0
78  },
79  //-----------------------------------------------------------------------
80  {"PF_L8",
81  /* Bytes per element */
82  1,
83  /* Flags */
85  /* Component type and count */
86  PCT_BYTE, 1,
87  /* rbits, gbits, bbits, abits */
88  8, 0, 0, 0,
89  /* Masks and shifts */
90  0xFF, 0, 0, 0, 0, 0, 0, 0
91  },
92  //-----------------------------------------------------------------------
93  {"PF_L16",
94  /* Bytes per element */
95  2,
96  /* Flags */
98  /* Component type and count */
99  PCT_SHORT, 1,
100  /* rbits, gbits, bbits, abits */
101  16, 0, 0, 0,
102  /* Masks and shifts */
103  0xFFFF, 0, 0, 0, 0, 0, 0, 0
104  },
105  //-----------------------------------------------------------------------
106  {"PF_A8",
107  /* Bytes per element */
108  1,
109  /* Flags */
111  /* Component type and count */
112  PCT_BYTE, 1,
113  /* rbits, gbits, bbits, abits */
114  0, 0, 0, 8,
115  /* Masks and shifts */
116  0, 0, 0, 0xFF, 0, 0, 0, 0
117  },
118  //-----------------------------------------------------------------------
119  {"PF_A4L4",
120  /* Bytes per element */
121  1,
122  /* Flags */
124  /* Component type and count */
125  PCT_BYTE, 2,
126  /* rbits, gbits, bbits, abits */
127  4, 0, 0, 4,
128  /* Masks and shifts */
129  0x0F, 0, 0, 0xF0, 0, 0, 0, 4
130  },
131  //-----------------------------------------------------------------------
132  {"PF_BYTE_LA",
133  /* Bytes per element */
134  2,
135  /* Flags */
137  /* Component type and count */
138  PCT_BYTE, 2,
139  /* rbits, gbits, bbits, abits */
140  8, 0, 0, 8,
141  /* Masks and shifts */
142  0,0,0,0,0,0,0,0
143  },
144  //-----------------------------------------------------------------------
145  {"PF_R5G6B5",
146  /* Bytes per element */
147  2,
148  /* Flags */
150  /* Component type and count */
151  PCT_BYTE, 3,
152  /* rbits, gbits, bbits, abits */
153  5, 6, 5, 0,
154  /* Masks and shifts */
155  0xF800, 0x07E0, 0x001F, 0,
156  11, 5, 0, 0
157  },
158  //-----------------------------------------------------------------------
159  {"PF_B5G6R5",
160  /* Bytes per element */
161  2,
162  /* Flags */
164  /* Component type and count */
165  PCT_BYTE, 3,
166  /* rbits, gbits, bbits, abits */
167  5, 6, 5, 0,
168  /* Masks and shifts */
169  0x001F, 0x07E0, 0xF800, 0,
170  0, 5, 11, 0
171  },
172  //-----------------------------------------------------------------------
173  {"PF_A4R4G4B4",
174  /* Bytes per element */
175  2,
176  /* Flags */
178  /* Component type and count */
179  PCT_BYTE, 4,
180  /* rbits, gbits, bbits, abits */
181  4, 4, 4, 4,
182  /* Masks and shifts */
183  0x0F00, 0x00F0, 0x000F, 0xF000,
184  8, 4, 0, 12
185  },
186  //-----------------------------------------------------------------------
187  {"PF_A1R5G5B5",
188  /* Bytes per element */
189  2,
190  /* Flags */
192  /* Component type and count */
193  PCT_BYTE, 4,
194  /* rbits, gbits, bbits, abits */
195  5, 5, 5, 1,
196  /* Masks and shifts */
197  0x7C00, 0x03E0, 0x001F, 0x8000,
198  10, 5, 0, 15,
199  },
200  //-----------------------------------------------------------------------
201  {"PF_R8G8B8",
202  /* Bytes per element */
203  3, // 24 bit integer -- special
204  /* Flags */
206  /* Component type and count */
207  PCT_BYTE, 3,
208  /* rbits, gbits, bbits, abits */
209  8, 8, 8, 0,
210  /* Masks and shifts */
211  0xFF0000, 0x00FF00, 0x0000FF, 0,
212  16, 8, 0, 0
213  },
214  //-----------------------------------------------------------------------
215  {"PF_B8G8R8",
216  /* Bytes per element */
217  3, // 24 bit integer -- special
218  /* Flags */
220  /* Component type and count */
221  PCT_BYTE, 3,
222  /* rbits, gbits, bbits, abits */
223  8, 8, 8, 0,
224  /* Masks and shifts */
225  0x0000FF, 0x00FF00, 0xFF0000, 0,
226  0, 8, 16, 0
227  },
228  //-----------------------------------------------------------------------
229  {"PF_A8R8G8B8",
230  /* Bytes per element */
231  4,
232  /* Flags */
234  /* Component type and count */
235  PCT_BYTE, 4,
236  /* rbits, gbits, bbits, abits */
237  8, 8, 8, 8,
238  /* Masks and shifts */
239  0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
240  16, 8, 0, 24
241  },
242  //-----------------------------------------------------------------------
243  {"PF_A8B8G8R8",
244  /* Bytes per element */
245  4,
246  /* Flags */
248  /* Component type and count */
249  PCT_BYTE, 4,
250  /* rbits, gbits, bbits, abits */
251  8, 8, 8, 8,
252  /* Masks and shifts */
253  0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000,
254  0, 8, 16, 24,
255  },
256  //-----------------------------------------------------------------------
257  {"PF_B8G8R8A8",
258  /* Bytes per element */
259  4,
260  /* Flags */
262  /* Component type and count */
263  PCT_BYTE, 4,
264  /* rbits, gbits, bbits, abits */
265  8, 8, 8, 8,
266  /* Masks and shifts */
267  0x0000FF00, 0x00FF0000, 0xFF000000, 0x000000FF,
268  8, 16, 24, 0
269  },
270  //-----------------------------------------------------------------------
271  {"PF_A2R10G10B10",
272  /* Bytes per element */
273  4,
274  /* Flags */
276  /* Component type and count */
277  PCT_BYTE, 4,
278  /* rbits, gbits, bbits, abits */
279  10, 10, 10, 2,
280  /* Masks and shifts */
281  0x3FF00000, 0x000FFC00, 0x000003FF, 0xC0000000,
282  20, 10, 0, 30
283  },
284  //-----------------------------------------------------------------------
285  {"PF_A2B10G10R10",
286  /* Bytes per element */
287  4,
288  /* Flags */
290  /* Component type and count */
291  PCT_BYTE, 4,
292  /* rbits, gbits, bbits, abits */
293  10, 10, 10, 2,
294  /* Masks and shifts */
295  0x000003FF, 0x000FFC00, 0x3FF00000, 0xC0000000,
296  0, 10, 20, 30
297  },
298  //-----------------------------------------------------------------------
299  {"PF_DXT1",
300  /* Bytes per element */
301  0,
302  /* Flags */
304  /* Component type and count */
305  PCT_BYTE, 3, // No alpha
306  /* rbits, gbits, bbits, abits */
307  0, 0, 0, 0,
308  /* Masks and shifts */
309  0, 0, 0, 0, 0, 0, 0, 0
310  },
311  //-----------------------------------------------------------------------
312  {"PF_DXT2",
313  /* Bytes per element */
314  0,
315  /* Flags */
317  /* Component type and count */
318  PCT_BYTE, 4,
319  /* rbits, gbits, bbits, abits */
320  0, 0, 0, 0,
321  /* Masks and shifts */
322  0, 0, 0, 0, 0, 0, 0, 0
323  },
324  //-----------------------------------------------------------------------
325  {"PF_DXT3",
326  /* Bytes per element */
327  0,
328  /* Flags */
330  /* Component type and count */
331  PCT_BYTE, 4,
332  /* rbits, gbits, bbits, abits */
333  0, 0, 0, 0,
334  /* Masks and shifts */
335  0, 0, 0, 0, 0, 0, 0, 0
336  },
337  //-----------------------------------------------------------------------
338  {"PF_DXT4",
339  /* Bytes per element */
340  0,
341  /* Flags */
343  /* Component type and count */
344  PCT_BYTE, 4,
345  /* rbits, gbits, bbits, abits */
346  0, 0, 0, 0,
347  /* Masks and shifts */
348  0, 0, 0, 0, 0, 0, 0, 0
349  },
350  //-----------------------------------------------------------------------
351  {"PF_DXT5",
352  /* Bytes per element */
353  0,
354  /* Flags */
356  /* Component type and count */
357  PCT_BYTE, 4,
358  /* rbits, gbits, bbits, abits */
359  0, 0, 0, 0,
360  /* Masks and shifts */
361  0, 0, 0, 0, 0, 0, 0, 0
362  },
363  //-----------------------------------------------------------------------
364  {"PF_FLOAT16_RGB",
365  /* Bytes per element */
366  6,
367  /* Flags */
368  PFF_FLOAT,
369  /* Component type and count */
370  PCT_FLOAT16, 3,
371  /* rbits, gbits, bbits, abits */
372  16, 16, 16, 0,
373  /* Masks and shifts */
374  0, 0, 0, 0, 0, 0, 0, 0
375  },
376  //-----------------------------------------------------------------------
377  {"PF_FLOAT16_RGBA",
378  /* Bytes per element */
379  8,
380  /* Flags */
382  /* Component type and count */
383  PCT_FLOAT16, 4,
384  /* rbits, gbits, bbits, abits */
385  16, 16, 16, 16,
386  /* Masks and shifts */
387  0, 0, 0, 0, 0, 0, 0, 0
388  },
389  //-----------------------------------------------------------------------
390  {"PF_FLOAT32_RGB",
391  /* Bytes per element */
392  12,
393  /* Flags */
394  PFF_FLOAT,
395  /* Component type and count */
396  PCT_FLOAT32, 3,
397  /* rbits, gbits, bbits, abits */
398  32, 32, 32, 0,
399  /* Masks and shifts */
400  0, 0, 0, 0, 0, 0, 0, 0
401  },
402  //-----------------------------------------------------------------------
403  {"PF_FLOAT32_RGBA",
404  /* Bytes per element */
405  16,
406  /* Flags */
408  /* Component type and count */
409  PCT_FLOAT32, 4,
410  /* rbits, gbits, bbits, abits */
411  32, 32, 32, 32,
412  /* Masks and shifts */
413  0, 0, 0, 0, 0, 0, 0, 0
414  },
415  //-----------------------------------------------------------------------
416  {"PF_X8R8G8B8",
417  /* Bytes per element */
418  4,
419  /* Flags */
421  /* Component type and count */
422  PCT_BYTE, 3,
423  /* rbits, gbits, bbits, abits */
424  8, 8, 8, 0,
425  /* Masks and shifts */
426  0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
427  16, 8, 0, 24
428  },
429  //-----------------------------------------------------------------------
430  {"PF_X8B8G8R8",
431  /* Bytes per element */
432  4,
433  /* Flags */
435  /* Component type and count */
436  PCT_BYTE, 3,
437  /* rbits, gbits, bbits, abits */
438  8, 8, 8, 0,
439  /* Masks and shifts */
440  0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000,
441  0, 8, 16, 24
442  },
443  //-----------------------------------------------------------------------
444  {"PF_R8G8B8A8",
445  /* Bytes per element */
446  4,
447  /* Flags */
449  /* Component type and count */
450  PCT_BYTE, 4,
451  /* rbits, gbits, bbits, abits */
452  8, 8, 8, 8,
453  /* Masks and shifts */
454  0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF,
455  24, 16, 8, 0
456  },
457  //-----------------------------------------------------------------------
458  {"PF_DEPTH",
459  /* Bytes per element */
460  4,
461  /* Flags */
462  PFF_DEPTH,
463  /* Component type and count */
464  PCT_FLOAT16, 1, // ?
465  /* rbits, gbits, bbits, abits */
466  16, 0, 0, 0,
467  /* Masks and shifts */
468  0, 0, 0, 0, 0, 0, 0, 0
469  },
470  //-----------------------------------------------------------------------
471  {"PF_SHORT_RGBA",
472  /* Bytes per element */
473  8,
474  /* Flags */
475  PFF_HASALPHA,
476  /* Component type and count */
477  PCT_SHORT, 4,
478  /* rbits, gbits, bbits, abits */
479  16, 16, 16, 16,
480  /* Masks and shifts */
481  0, 0, 0, 0, 0, 0, 0, 0
482  },
483  //-----------------------------------------------------------------------
484  {"PF_R3G3B2",
485  /* Bytes per element */
486  1,
487  /* Flags */
489  /* Component type and count */
490  PCT_BYTE, 3,
491  /* rbits, gbits, bbits, abits */
492  3, 3, 2, 0,
493  /* Masks and shifts */
494  0xE0, 0x1C, 0x03, 0,
495  5, 2, 0, 0
496  },
497  //-----------------------------------------------------------------------
498  {"PF_FLOAT16_R",
499  /* Bytes per element */
500  2,
501  /* Flags */
502  PFF_FLOAT,
503  /* Component type and count */
504  PCT_FLOAT16, 1,
505  /* rbits, gbits, bbits, abits */
506  16, 0, 0, 0,
507  /* Masks and shifts */
508  0, 0, 0, 0, 0, 0, 0, 0
509  },
510  //-----------------------------------------------------------------------
511  {"PF_FLOAT32_R",
512  /* Bytes per element */
513  4,
514  /* Flags */
515  PFF_FLOAT,
516  /* Component type and count */
517  PCT_FLOAT32, 1,
518  /* rbits, gbits, bbits, abits */
519  32, 0, 0, 0,
520  /* Masks and shifts */
521  0, 0, 0, 0, 0, 0, 0, 0
522  },
523  //-----------------------------------------------------------------------
524  {"PF_SHORT_GR",
525  /* Bytes per element */
526  4,
527  /* Flags */
529  /* Component type and count */
530  PCT_SHORT, 2,
531  /* rbits, gbits, bbits, abits */
532  16, 16, 0, 0,
533  /* Masks and shifts */
534  0x0000FFFF, 0xFFFF0000, 0, 0,
535  0, 16, 0, 0
536  },
537  //-----------------------------------------------------------------------
538  {"PF_FLOAT16_GR",
539  /* Bytes per element */
540  4,
541  /* Flags */
542  PFF_FLOAT,
543  /* Component type and count */
544  PCT_FLOAT16, 2,
545  /* rbits, gbits, bbits, abits */
546  16, 16, 0, 0,
547  /* Masks and shifts */
548  0, 0, 0, 0, 0, 0, 0, 0
549  },
550  //-----------------------------------------------------------------------
551  {"PF_FLOAT32_GR",
552  /* Bytes per element */
553  8,
554  /* Flags */
555  PFF_FLOAT,
556  /* Component type and count */
557  PCT_FLOAT32, 2,
558  /* rbits, gbits, bbits, abits */
559  32, 32, 0, 0,
560  /* Masks and shifts */
561  0, 0, 0, 0, 0, 0, 0, 0
562  },
563  //-----------------------------------------------------------------------
564  {"PF_SHORT_RGB",
565  /* Bytes per element */
566  6,
567  /* Flags */
568  0,
569  /* Component type and count */
570  PCT_SHORT, 3,
571  /* rbits, gbits, bbits, abits */
572  16, 16, 16, 0,
573  /* Masks and shifts */
574  0, 0, 0, 0, 0, 0, 0, 0
575  },
576  //-----------------------------------------------------------------------
577  {"PF_PVRTC_RGB2",
578  /* Bytes per element */
579  0,
580  /* Flags */
582  /* Component type and count */
583  PCT_BYTE, 3,
584  /* rbits, gbits, bbits, abits */
585  0, 0, 0, 0,
586  /* Masks and shifts */
587  0, 0, 0, 0, 0, 0, 0, 0
588  },
589  //-----------------------------------------------------------------------
590  {"PF_PVRTC_RGBA2",
591  /* Bytes per element */
592  0,
593  /* Flags */
595  /* Component type and count */
596  PCT_BYTE, 4,
597  /* rbits, gbits, bbits, abits */
598  0, 0, 0, 0,
599  /* Masks and shifts */
600  0, 0, 0, 0, 0, 0, 0, 0
601  },
602  //-----------------------------------------------------------------------
603  {"PF_PVRTC_RGB4",
604  /* Bytes per element */
605  0,
606  /* Flags */
608  /* Component type and count */
609  PCT_BYTE, 3,
610  /* rbits, gbits, bbits, abits */
611  0, 0, 0, 0,
612  /* Masks and shifts */
613  0, 0, 0, 0, 0, 0, 0, 0
614  },
615  //-----------------------------------------------------------------------
616  {"PF_PVRTC_RGBA4",
617  /* Bytes per element */
618  0,
619  /* Flags */
621  /* Component type and count */
622  PCT_BYTE, 4,
623  /* rbits, gbits, bbits, abits */
624  0, 0, 0, 0,
625  /* Masks and shifts */
626  0, 0, 0, 0, 0, 0, 0, 0
627  },
628  //-----------------------------------------------------------------------
629  {"PF_PVRTC2_2BPP",
630  /* Bytes per element */
631  0,
632  /* Flags */
634  /* Component type and count */
635  PCT_BYTE, 4,
636  /* rbits, gbits, bbits, abits */
637  0, 0, 0, 0,
638  /* Masks and shifts */
639  0, 0, 0, 0, 0, 0, 0, 0
640  },
641  //-----------------------------------------------------------------------
642  {"PF_PVRTC2_4BPP",
643  /* Bytes per element */
644  0,
645  /* Flags */
647  /* Component type and count */
648  PCT_BYTE, 4,
649  /* rbits, gbits, bbits, abits */
650  0, 0, 0, 0,
651  /* Masks and shifts */
652  0, 0, 0, 0, 0, 0, 0, 0
653  },
654  //-----------------------------------------------------------------------
655  {"PF_R11G11B10_FLOAT",
656  /* Bytes per element */
657  4,
658  /* Flags */
660  /* Component type and count */
661  PCT_FLOAT32, 1,
662  /* rbits, gbits, bbits, abits */
663  11, 11, 10, 0,
664  /* Masks and shifts */
665  0xFFC00000, 0x03FF800, 0x000007FF, 0,
666  24, 16, 8, 0
667  },
668  //-----------------------------------------------------------------------
669  {"PF_R8_UINT",
670  /* Bytes per element */
671  1,
672  /* Flags */
674  /* Component type and count */
675  PCT_UINT, 1,
676  /* rbits, gbits, bbits, abits */
677  8, 0, 0, 0,
678  /* Masks and shifts */
679  0xFF, 0, 0, 0,
680  0, 0, 0, 0
681  },
682  //-----------------------------------------------------------------------
683  {"PF_R8G8_UINT",
684  /* Bytes per element */
685  2,
686  /* Flags */
688  /* Component type and count */
689  PCT_UINT, 2,
690  /* rbits, gbits, bbits, abits */
691  8, 8, 0, 0,
692  /* Masks and shifts */
693  0xFF00, 0x00FF, 0, 0,
694  8, 0, 0, 0
695  },
696  //-----------------------------------------------------------------------
697  {"PF_R8G8B8_UINT",
698  /* Bytes per element */
699  3,
700  /* Flags */
702  /* Component type and count */
703  PCT_UINT, 3,
704  /* rbits, gbits, bbits, abits */
705  8, 8, 8, 0,
706  /* Masks and shifts */
707  0xFF0000, 0x00FF00, 0x0000FF, 0,
708  16, 8, 0, 0
709  },
710  //-----------------------------------------------------------------------
711  {"PF_R8G8B8A8_UINT",
712  /* Bytes per element */
713  4,
714  /* Flags */
716  /* Component type and count */
717  PCT_UINT, 4,
718  /* rbits, gbits, bbits, abits */
719  8, 8, 8, 8,
720  /* Masks and shifts */
721  0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF,
722  24, 16, 8, 0
723  },
724  //-----------------------------------------------------------------------
725  {"PF_R16_UINT",
726  /* Bytes per element */
727  2,
728  /* Flags */
730  /* Component type and count */
731  PCT_UINT, 1,
732  /* rbits, gbits, bbits, abits */
733  16, 0, 0, 0,
734  /* Masks and shifts */
735  0xFFFF, 0, 0, 0,
736  0, 0, 0, 0
737  },
738  //-----------------------------------------------------------------------
739  {"PF_R16G16_UINT",
740  /* Bytes per element */
741  4,
742  /* Flags */
744  /* Component type and count */
745  PCT_UINT, 2,
746  /* rbits, gbits, bbits, abits */
747  16, 16, 0, 0,
748  /* Masks and shifts */
749  0xFFFF0000, 0x0000FFFF, 0, 0,
750  16, 0, 0, 0
751  },
752  //-----------------------------------------------------------------------
753  {"PF_R16G16B16_UINT",
754  /* Bytes per element */
755  6,
756  /* Flags */
758  /* Component type and count */
759  PCT_UINT, 3,
760  /* rbits, gbits, bbits, abits */
761  16, 16, 16, 0,
762  /* Masks and shifts */
763  0xFFFF00000000, 0x0000FFFF0000, 0x00000000FFFF, 0,
764  32, 16, 0, 0
765  },
766  //-----------------------------------------------------------------------
767  {"PF_R16G16B16A16_UINT",
768  /* Bytes per element */
769  8,
770  /* Flags */
772  /* Component type and count */
773  PCT_UINT, 4,
774  /* rbits, gbits, bbits, abits */
775  16, 16, 16, 16,
776  /* Masks and shifts */
777  0xFFFF000000000000, 0x0000FFFF00000000, 0x00000000FFFF0000, 0x000000000000FFFF,
778  48, 32, 16, 0
779  },
780  //-----------------------------------------------------------------------
781  {"PF_R32_UINT",
782  /* Bytes per element */
783  4,
784  /* Flags */
786  /* Component type and count */
787  PCT_UINT, 1,
788  /* rbits, gbits, bbits, abits */
789  32, 0, 0, 0,
790  /* Masks and shifts */
791  0xFFFFFFFF, 0, 0, 0,
792  0, 0, 0, 0
793  },
794  //-----------------------------------------------------------------------
795  {"PF_R32G32_UINT",
796  /* Bytes per element */
797  8,
798  /* Flags */
800  /* Component type and count */
801  PCT_UINT, 2,
802  /* rbits, gbits, bbits, abits */
803  32, 32, 0, 0,
804  /* Masks and shifts */
805  0xFFFFFFFF00000000, 0xFFFFFFFF, 0, 0,
806  32, 0, 0, 0
807  },
808  //-----------------------------------------------------------------------
809  {"PF_R32G32B32_UINT",
810  /* Bytes per element */
811  12,
812  /* Flags */
814  /* Component type and count */
815  PCT_UINT, 3,
816  /* rbits, gbits, bbits, abits */
817  32, 32, 32, 0,
818  /* Masks and shifts */
819  0, 0, 0, 0,
820  64, 32, 0, 0
821  },
822  //-----------------------------------------------------------------------
823  {"PF_R32G32B32A32_UINT",
824  /* Bytes per element */
825  16,
826  /* Flags */
828  /* Component type and count */
829  PCT_UINT, 4,
830  /* rbits, gbits, bbits, abits */
831  32, 32, 32, 32,
832  /* Masks and shifts */
833  0, 0, 0, 0,
834  96, 64, 32, 0
835  },
836  //-----------------------------------------------------------------------
837  {"PF_R8_SINT",
838  /* Bytes per element */
839  1,
840  /* Flags */
842  /* Component type and count */
843  PCT_SINT, 1,
844  /* rbits, gbits, bbits, abits */
845  8, 0, 0, 0,
846  /* Masks and shifts */
847  0xFF, 0, 0, 0,
848  0, 0, 0, 0
849  },
850  //-----------------------------------------------------------------------
851  {"PF_R8G8_SINT",
852  /* Bytes per element */
853  2,
854  /* Flags */
856  /* Component type and count */
857  PCT_SINT, 2,
858  /* rbits, gbits, bbits, abits */
859  8, 8, 0, 0,
860  /* Masks and shifts */
861  0xFF00, 0x00FF, 0, 0,
862  8, 0, 0, 0
863  },
864  //-----------------------------------------------------------------------
865  {"PF_R8G8B8_SINT",
866  /* Bytes per element */
867  3,
868  /* Flags */
870  /* Component type and count */
871  PCT_SINT, 3,
872  /* rbits, gbits, bbits, abits */
873  8, 8, 8, 0,
874  /* Masks and shifts */
875  0xFF0000, 0x00FF00, 0x0000FF, 0,
876  16, 8, 0, 0
877  },
878  //-----------------------------------------------------------------------
879  {"PF_R8G8B8A8_SINT",
880  /* Bytes per element */
881  4,
882  /* Flags */
884  /* Component type and count */
885  PCT_SINT, 4,
886  /* rbits, gbits, bbits, abits */
887  8, 8, 8, 8,
888  /* Masks and shifts */
889  0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF,
890  24, 16, 8, 0
891  },
892  //-----------------------------------------------------------------------
893  {"PF_R16_SINT",
894  /* Bytes per element */
895  2,
896  /* Flags */
898  /* Component type and count */
899  PCT_SINT, 1,
900  /* rbits, gbits, bbits, abits */
901  16, 0, 0, 0,
902  /* Masks and shifts */
903  0xFFFF, 0, 0, 0,
904  0, 0, 0, 0
905  },
906  //-----------------------------------------------------------------------
907  {"PF_R16G16_SINT",
908  /* Bytes per element */
909  4,
910  /* Flags */
912  /* Component type and count */
913  PCT_SINT, 2,
914  /* rbits, gbits, bbits, abits */
915  16, 16, 0, 0,
916  /* Masks and shifts */
917  0xFFFF0000, 0x0000FFFF, 0, 0,
918  16, 0, 0, 0
919  },
920  //-----------------------------------------------------------------------
921  {"PF_R16G16B16_SINT",
922  /* Bytes per element */
923  6,
924  /* Flags */
926  /* Component type and count */
927  PCT_SINT, 3,
928  /* rbits, gbits, bbits, abits */
929  16, 16, 16, 0,
930  /* Masks and shifts */
931  0xFFFF00000000, 0x0000FFFF0000, 0x00000000FFFF, 0,
932  32, 16, 0, 0
933  },
934  //-----------------------------------------------------------------------
935  {"PF_R16G16B16A16_SINT",
936  /* Bytes per element */
937  8,
938  /* Flags */
940  /* Component type and count */
941  PCT_SINT, 4,
942  /* rbits, gbits, bbits, abits */
943  16, 16, 16, 16,
944  /* Masks and shifts */
945  0xFFFF000000000000, 0x0000FFFF00000000, 0x00000000FFFF0000, 0x000000000000FFFF,
946  48, 32, 16, 0
947  },
948  //-----------------------------------------------------------------------
949  {"PF_R32_SINT",
950  /* Bytes per element */
951  4,
952  /* Flags */
954  /* Component type and count */
955  PCT_SINT, 1,
956  /* rbits, gbits, bbits, abits */
957  32, 0, 0, 0,
958  /* Masks and shifts */
959  0xFFFFFFFF, 0, 0, 0,
960  0, 0, 0, 0
961  },
962  //-----------------------------------------------------------------------
963  {"PF_R32G32_SINT",
964  /* Bytes per element */
965  8,
966  /* Flags */
968  /* Component type and count */
969  PCT_SINT, 2,
970  /* rbits, gbits, bbits, abits */
971  32, 32, 0, 0,
972  /* Masks and shifts */
973  0xFFFFFFFF00000000, 0xFFFFFFFF, 0, 0,
974  32, 0, 0, 0
975  },
976  //-----------------------------------------------------------------------
977  {"PF_R32G32B32_SINT",
978  /* Bytes per element */
979  12,
980  /* Flags */
982  /* Component type and count */
983  PCT_SINT, 3,
984  /* rbits, gbits, bbits, abits */
985  32, 32, 32, 0,
986  /* Masks and shifts */
987  0, 0, 0, 0,
988  64, 32, 0, 0
989  },
990  //-----------------------------------------------------------------------
991  {"PF_R32G32B32A32_SINT",
992  /* Bytes per element */
993  16,
994  /* Flags */
996  /* Component type and count */
997  PCT_SINT, 4,
998  /* rbits, gbits, bbits, abits */
999  32, 32, 32, 32,
1000  /* Masks and shifts */
1001  0, 0, 0, 0,
1002  96, 64, 32, 0
1003  },
1004  //-----------------------------------------------------------------------
1005  {"PF_R9G9B9E5_SHAREDEXP",
1006  /* Bytes per element */
1007  4,
1008  /* Flags */
1010  /* Component type and count */
1011  PCT_BYTE, 4,
1012  /* rbits, gbits, bbits, abits */
1013  9, 9, 9, 0,
1014  /* Masks and shifts */
1015  0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF,
1016  24, 16, 8, 0
1017  },
1018  //-----------------------------------------------------------------------
1019  {"PF_BC4_UNORM",
1020  /* Bytes per element */
1021  0,
1022  /* Flags */
1024  /* Component type and count */
1025  PCT_BYTE, 1, // Red only
1026  /* rbits, gbits, bbits, abits */
1027  0, 0, 0, 0,
1028  /* Masks and shifts */
1029  0, 0, 0, 0, 0, 0, 0, 0
1030  },
1031  //-----------------------------------------------------------------------
1032  {"PF_BC4_SNORM",
1033  /* Bytes per element */
1034  0,
1035  /* Flags */
1037  /* Component type and count */
1038  PCT_BYTE, 1, // Red only
1039  /* rbits, gbits, bbits, abits */
1040  0, 0, 0, 0,
1041  /* Masks and shifts */
1042  0, 0, 0, 0, 0, 0, 0, 0
1043  },
1044  //-----------------------------------------------------------------------
1045  {"PF_BC5_UNORM",
1046  /* Bytes per element */
1047  0,
1048  /* Flags */
1050  /* Component type and count */
1051  PCT_BYTE, 2, // Red-Green only
1052  /* rbits, gbits, bbits, abits */
1053  0, 0, 0, 0,
1054  /* Masks and shifts */
1055  0, 0, 0, 0, 0, 0, 0, 0
1056  },
1057  //-----------------------------------------------------------------------
1058  {"PF_BC5_SNORM",
1059  /* Bytes per element */
1060  0,
1061  /* Flags */
1063  /* Component type and count */
1064  PCT_BYTE, 2, // Red-Green only
1065  /* rbits, gbits, bbits, abits */
1066  0, 0, 0, 0,
1067  /* Masks and shifts */
1068  0, 0, 0, 0, 0, 0, 0, 0
1069  },
1070  //-----------------------------------------------------------------------
1071  {"PF_BC6H_UF16",
1072  /* Bytes per element */
1073  0,
1074  /* Flags */
1076  /* Component type and count */
1077  PCT_BYTE, 3,
1078  /* rbits, gbits, bbits, abits */
1079  0, 0, 0, 0,
1080  /* Masks and shifts */
1081  0, 0, 0, 0, 0, 0, 0, 0
1082  },
1083  //-----------------------------------------------------------------------
1084  {"PF_BC6H_SF16",
1085  /* Bytes per element */
1086  0,
1087  /* Flags */
1089  /* Component type and count */
1090  PCT_BYTE, 3,
1091  /* rbits, gbits, bbits, abits */
1092  0, 0, 0, 0,
1093  /* Masks and shifts */
1094  0, 0, 0, 0, 0, 0, 0, 0
1095  },
1096  //-----------------------------------------------------------------------
1097  {"PF_BC7_UNORM",
1098  /* Bytes per element */
1099  0,
1100  /* Flags */
1102  /* Component type and count */
1103  PCT_BYTE, 4,
1104  /* rbits, gbits, bbits, abits */
1105  0, 0, 0, 0,
1106  /* Masks and shifts */
1107  0, 0, 0, 0, 0, 0, 0, 0
1108  },
1109  //-----------------------------------------------------------------------
1110  {"PF_BC7_UNORM_SRGB",
1111  /* Bytes per element */
1112  0,
1113  /* Flags */
1115  /* Component type and count */
1116  PCT_BYTE, 4,
1117  /* rbits, gbits, bbits, abits */
1118  0, 0, 0, 0,
1119  /* Masks and shifts */
1120  0, 0, 0, 0, 0, 0, 0, 0
1121  },
1122  //-----------------------------------------------------------------------
1123  {"PF_R8",
1124  /* Bytes per element */
1125  1,
1126  /* Flags */
1128  /* Component type and count */
1129  PCT_BYTE, 1,
1130  /* rbits, gbits, bbits, abits */
1131  8, 0, 0, 0,
1132  /* Masks and shifts */
1133  0xFF, 0, 0, 0,
1134  0, 0, 0, 0
1135  },
1136  //-----------------------------------------------------------------------
1137  {"PF_RG8",
1138  /* Bytes per element */
1139  2,
1140  /* Flags */
1142  /* Component type and count */
1143  PCT_BYTE, 2,
1144  /* rbits, gbits, bbits, abits */
1145  8, 8, 0, 0,
1146  /* Masks and shifts */
1147  0xFF0000, 0x00FF00, 0, 0,
1148  8, 0, 0, 0
1149  },
1150  //-----------------------------------------------------------------------
1151  {"PF_R8_SNORM",
1152  /* Bytes per element */
1153  1,
1154  /* Flags */
1156  /* Component type and count */
1157  PCT_BYTE, 1,
1158  /* rbits, gbits, bbits, abits */
1159  8, 0, 0, 0,
1160  /* Masks and shifts */
1161  0xFF, 0, 0, 0,
1162  0, 0, 0, 0
1163  },
1164  //-----------------------------------------------------------------------
1165  {"PF_R8G8_SNORM",
1166  /* Bytes per element */
1167  2,
1168  /* Flags */
1170  /* Component type and count */
1171  PCT_BYTE, 2,
1172  /* rbits, gbits, bbits, abits */
1173  8, 8, 0, 0,
1174  /* Masks and shifts */
1175  0xFF00, 0x00FF, 0, 0,
1176  8, 0, 0, 0
1177  },
1178  //-----------------------------------------------------------------------
1179  {"PF_R8G8B8_SNORM",
1180  /* Bytes per element */
1181  3,
1182  /* Flags */
1184  /* Component type and count */
1185  PCT_BYTE, 3,
1186  /* rbits, gbits, bbits, abits */
1187  8, 8, 8, 0,
1188  /* Masks and shifts */
1189  0xFF0000, 0x00FF00, 0x0000FF, 0,
1190  16, 8, 0, 0
1191  },
1192  //-----------------------------------------------------------------------
1193  {"PF_R8G8B8A8_SNORM",
1194  /* Bytes per element */
1195  4,
1196  /* Flags */
1198  /* Component type and count */
1199  PCT_BYTE, 4,
1200  /* rbits, gbits, bbits, abits */
1201  8, 8, 8, 8,
1202  /* Masks and shifts */
1203  0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF,
1204  24, 16, 8, 0
1205  },
1206  //-----------------------------------------------------------------------
1207  {"PF_R16_SNORM",
1208  /* Bytes per element */
1209  2,
1210  /* Flags */
1212  /* Component type and count */
1213  PCT_BYTE, 1,
1214  /* rbits, gbits, bbits, abits */
1215  16, 0, 0, 0,
1216  /* Masks and shifts */
1217  0xFFFF, 0, 0, 0,
1218  0, 0, 0, 0
1219  },
1220  //-----------------------------------------------------------------------
1221  {"PF_R16G16_SNORM",
1222  /* Bytes per element */
1223  4,
1224  /* Flags */
1226  /* Component type and count */
1227  PCT_BYTE, 2,
1228  /* rbits, gbits, bbits, abits */
1229  16, 16, 0, 0,
1230  /* Masks and shifts */
1231  0xFFFF0000, 0x0000FFFF, 0, 0,
1232  16, 0, 0, 0
1233  },
1234  //-----------------------------------------------------------------------
1235  {"PF_R16G16B16_SNORM",
1236  /* Bytes per element */
1237  6,
1238  /* Flags */
1240  /* Component type and count */
1241  PCT_BYTE, 3,
1242  /* rbits, gbits, bbits, abits */
1243  16, 16, 16, 0,
1244  /* Masks and shifts */
1245  0xFFFF00000000, 0x0000FFFF0000, 0x00000000FFFF, 0,
1246  32, 16, 0, 0
1247  },
1248  //-----------------------------------------------------------------------
1249  {"PF_R16G16B16A16_SNORM",
1250  /* Bytes per element */
1251  8,
1252  /* Flags */
1254  /* Component type and count */
1255  PCT_BYTE, 4,
1256  /* rbits, gbits, bbits, abits */
1257  16, 16, 16, 16,
1258  /* Masks and shifts */
1259  0xFFFF000000000000, 0x0000FFFF00000000, 0x00000000FFFF0000, 0x000000000000FFFF,
1260  48, 32, 16, 0
1261  },
1262 
1263  //-----------------------------------------------------------------------
1264  {"PF_ETC1_RGB8",
1265  /* Bytes per element */
1266  0,
1267  /* Flags */
1269  /* Component type and count */
1270  PCT_BYTE, 3,
1271  /* rbits, gbits, bbits, abits */
1272  0, 0, 0, 0,
1273  /* Masks and shifts */
1274  0, 0, 0, 0, 0, 0, 0, 0
1275  },
1276  //-----------------------------------------------------------------------
1277  {"PF_ETC2_RGB8",
1278  /* Bytes per element */
1279  0,
1280  /* Flags */
1282  /* Component type and count */
1283  PCT_BYTE, 3,
1284  /* rbits, gbits, bbits, abits */
1285  0, 0, 0, 0,
1286  /* Masks and shifts */
1287  0, 0, 0, 0, 0, 0, 0, 0
1288  },
1289  //-----------------------------------------------------------------------
1290  {"PF_ETC2_RGBA8",
1291  /* Bytes per element */
1292  0,
1293  /* Flags */
1295  /* Component type and count */
1296  PCT_BYTE, 4,
1297  /* rbits, gbits, bbits, abits */
1298  0, 0, 0, 0,
1299  /* Masks and shifts */
1300  0, 0, 0, 0, 0, 0, 0, 0
1301  },
1302  //-----------------------------------------------------------------------
1303  {"PF_ETC2_RGB8A1",
1304  /* Bytes per element */
1305  0,
1306  /* Flags */
1308  /* Component type and count */
1309  PCT_BYTE, 4,
1310  /* rbits, gbits, bbits, abits */
1311  0, 0, 0, 0,
1312  /* Masks and shifts */
1313  0, 0, 0, 0, 0, 0, 0, 0
1314  },
1315  //-----------------------------------------------------------------------
1316  {"PF_ATC_RGB",
1317  /* Bytes per element */
1318  0,
1319  /* Flags */
1321  /* Component type and count */
1322  PCT_BYTE, 3,
1323  /* rbits, gbits, bbits, abits */
1324  0, 0, 0, 0,
1325  /* Masks and shifts */
1326  0, 0, 0, 0, 0, 0, 0, 0
1327  },
1328  //-----------------------------------------------------------------------
1329  {"PF_ATC_RGBA_EXPLICIT_ALPHA",
1330  /* Bytes per element */
1331  0,
1332  /* Flags */
1334  /* Component type and count */
1335  PCT_BYTE, 4,
1336  /* rbits, gbits, bbits, abits */
1337  0, 0, 0, 0,
1338  /* Masks and shifts */
1339  0, 0, 0, 0, 0, 0, 0, 0
1340  },
1341  //-----------------------------------------------------------------------
1342  {"PF_ATC_RGBA_INTERPOLATED_ALPHA",
1343  /* Bytes per element */
1344  0,
1345  /* Flags */
1347  /* Component type and count */
1348  PCT_BYTE, 4,
1349  /* rbits, gbits, bbits, abits */
1350  0, 0, 0, 0,
1351  /* Masks and shifts */
1352  0, 0, 0, 0, 0, 0, 0, 0
1353  }
1354  };
1358 }
1359 
1360 #include "OgreHeaderSuffix.h"
1361 
1362 #endif
PixelComponentType componentType
Component type.
Short per component (16 bit fixed 0.0..1.0))
unsigned int uint32
Definition: OgrePlatform.h:420
This is a depth format (for depth textures)
32 bit float per component
Format is in native endian.
This is a floating point format.
Byte per component (8 bit fixed 0.0..1.0)
This format has an alpha channel.
A record that describes a pixel format in detail.
PixelComponentType
Pixel component format.
16 bit float per component
unsigned long long uint64
Definition: OgrePlatform.h:431
This is an intensity format instead of a RGB one.
unsigned char componentCount
Component count.
This format is compressed.
Signed integer per component.
This is an integer format.
PixelFormatDescription _pixelFormats[PF_COUNT]
Pixel format database.