OGRE  1.9
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  //-----------------------------------------------------------------------
40  struct PixelFormatDescription {
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  */
48  uint32 flags;
51  PixelComponentType componentType;
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 */
60  uint64 rmask, gmask, bmask, amask;
61  unsigned char rshift, gshift, bshift, ashift;
62  };
63  //-----------------------------------------------------------------------
65  PixelFormatDescription _pixelFormats[PF_COUNT] = {
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 */
84  PFF_LUMINANCE | PFF_NATIVEENDIAN,
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 */
97  PFF_LUMINANCE | PFF_NATIVEENDIAN,
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 */
110  PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
123  PFF_HASALPHA | PFF_LUMINANCE | PFF_NATIVEENDIAN,
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 */
136  PFF_HASALPHA | PFF_LUMINANCE,
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 */
149  PFF_NATIVEENDIAN,
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 */
163  PFF_NATIVEENDIAN,
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 */
177  PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
191  PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
205  PFF_NATIVEENDIAN,
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 */
219  PFF_NATIVEENDIAN,
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 */
233  PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
247  PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
261  PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
275  PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
289  PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
303  PFF_COMPRESSED | PFF_HASALPHA,
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 */
316  PFF_COMPRESSED | PFF_HASALPHA,
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 */
329  PFF_COMPRESSED | PFF_HASALPHA,
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 */
342  PFF_COMPRESSED | PFF_HASALPHA,
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 */
355  PFF_COMPRESSED | PFF_HASALPHA,
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 */
381  PFF_FLOAT | PFF_HASALPHA,
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 */
407  PFF_FLOAT | PFF_HASALPHA,
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 */
420  PFF_NATIVEENDIAN,
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 */
434  PFF_NATIVEENDIAN,
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 */
448  PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
488  PFF_NATIVEENDIAN,
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 */
528  PFF_NATIVEENDIAN,
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 */
581  PFF_COMPRESSED,
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 */
594  PFF_COMPRESSED | PFF_HASALPHA,
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 */
607  PFF_COMPRESSED,
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 */
620  PFF_COMPRESSED | PFF_HASALPHA,
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 */
633  PFF_COMPRESSED | PFF_HASALPHA,
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 */
646  PFF_COMPRESSED | PFF_HASALPHA,
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 */
659  PFF_FLOAT | PFF_NATIVEENDIAN,
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 */
673  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
687  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
701  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
715  PFF_INTEGER | PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
729  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
743  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
757  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
771  PFF_INTEGER | PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
785  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
799  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
813  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
827  PFF_INTEGER | PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
841  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
855  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
869  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
883  PFF_INTEGER | PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
897  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
911  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
925  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
939  PFF_INTEGER | PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
953  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
967  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
981  PFF_INTEGER | PFF_NATIVEENDIAN,
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 */
995  PFF_INTEGER | PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
1009  PFF_NATIVEENDIAN,
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 */
1023  PFF_COMPRESSED,
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 */
1036  PFF_COMPRESSED,
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 */
1049  PFF_COMPRESSED,
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 */
1062  PFF_COMPRESSED,
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 */
1075  PFF_COMPRESSED,
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 */
1088  PFF_COMPRESSED,
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 */
1101  PFF_COMPRESSED | PFF_HASALPHA,
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 */
1114  PFF_COMPRESSED | PFF_HASALPHA,
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 */
1127  PFF_NATIVEENDIAN,
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 */
1141  PFF_NATIVEENDIAN,
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 */
1155  PFF_NATIVEENDIAN,
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 */
1169  PFF_NATIVEENDIAN,
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 */
1183  PFF_NATIVEENDIAN,
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 */
1197  PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
1211  PFF_NATIVEENDIAN,
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 */
1225  PFF_NATIVEENDIAN,
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 */
1239  PFF_NATIVEENDIAN,
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 */
1253  PFF_HASALPHA | PFF_NATIVEENDIAN,
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 */
1268  PFF_COMPRESSED,
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 */
1281  PFF_COMPRESSED,
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 */
1294  PFF_COMPRESSED | PFF_HASALPHA,
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 */
1307  PFF_COMPRESSED | PFF_HASALPHA,
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 */
1320  PFF_COMPRESSED,
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 */
1333  PFF_COMPRESSED | PFF_HASALPHA,
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 */
1346  PFF_COMPRESSED | PFF_HASALPHA,
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
Ogre::PixelFormatDescription::componentType
PixelComponentType componentType
Component type.
Definition: OgrePixelFormatDescriptions.h:51
Ogre::PCT_FLOAT16
Short per component (16 bit fixed 0.0..1.0))
Definition: OgrePixelFormat.h:292
Ogre::uint32
unsigned int uint32
Definition: OgrePlatform.h:344
Ogre::PFF_DEPTH
This is a depth format (for depth textures)
Definition: OgrePixelFormat.h:276
Ogre::PCT_SINT
32 bit float per component
Definition: OgrePixelFormat.h:294
OgreHeaderSuffix.h
Ogre::PF_COUNT
Definition: OgrePixelFormat.h:260
Ogre::PFF_NATIVEENDIAN
Format is in native endian.
Definition: OgrePixelFormat.h:279
Ogre::PFF_FLOAT
This is a floating point format.
Definition: OgrePixelFormat.h:274
Ogre::PCT_SHORT
Byte per component (8 bit fixed 0.0..1.0)
Definition: OgrePixelFormat.h:291
Ogre::PFF_HASALPHA
This format has an alpha channel.
Definition: OgrePixelFormat.h:269
Ogre::PixelFormatDescription
A record that describes a pixel format in detail.
Definition: OgrePixelFormatDescriptions.h:40
OgrePrerequisites.h
OgreCommon.h
Ogre::PixelComponentType
PixelComponentType
Pixel component format.
Definition: OgrePixelFormat.h:288
Ogre::PCT_FLOAT32
16 bit float per component
Definition: OgrePixelFormat.h:293
OgreHeaderPrefix.h
Ogre::uint64
unsigned long long uint64
Definition: OgrePlatform.h:355
Ogre::PFF_LUMINANCE
This is an intensity format instead of a RGB one.
Definition: OgrePixelFormat.h:282
Ogre::PixelFormatDescription::componentCount
unsigned char componentCount
Component count.
Definition: OgrePixelFormatDescriptions.h:54
Ogre::PCT_BYTE
Definition: OgrePixelFormat.h:290
Ogre::PFF_COMPRESSED
This format is compressed.
Definition: OgrePixelFormat.h:272
Ogre::PCT_UINT
Signed integer per component.
Definition: OgrePixelFormat.h:295
Ogre::PFF_INTEGER
This is an integer format.
Definition: OgrePixelFormat.h:284
Ogre::_pixelFormats
PixelFormatDescription _pixelFormats[PF_COUNT]
Pixel format database.
Definition: OgrePixelFormatDescriptions.h:65