Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/ogre_src_v1-9-0/OgreMain/include/OgrePixelFormatDescriptions.h

Last change on this file was 148, checked in by patricwi, 6 years ago

Added new dependencies for ogre1.9 and cegui0.8
File size: 45.5 KB
RevLine 
[148]1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4    (Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2013 Torus Knot Software Ltd
8
9Permission is hereby granted, free of charge, to any person obtaining a copy
10of this software and associated documentation files (the "Software"), to deal
11in the Software without restriction, including without limitation the rights
12to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13copies of the Software, and to permit persons to whom the Software is
14furnished to do so, subject to the following conditions:
15
16The above copyright notice and this permission notice shall be included in
17all copies or substantial portions of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25THE 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
35namespace Ogre {
36    //-----------------------------------------------------------------------
37    /**
38     * A record that describes a pixel format in detail.
39     */
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;
49        /** Component type
50         */
51        PixelComponentType componentType;
52        /** Component count
53         */
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    //-----------------------------------------------------------------------
64    /** Pixel format database */
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    };
1355        /** @} */
1356        /** @} */
1357
1358}
1359
1360#include "OgreHeaderSuffix.h"
1361
1362#endif
Note: See TracBrowser for help on using the repository browser.