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

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.