Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

OgrePixelFormatDescriptions.h @ 153

Last change on this file since 153 was 148, checked in by patricwi, 6 years ago
Added new dependencies for ogre1.9 and cegui0.8
File size: 45.5 KB

Line
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-2013 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	//-----------------------------------------------------------------------
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.

Context Navigation

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

Download in other formats: