G3D::ImageFormat Class Reference

#include <ImageFormat.h>

Classes
class	BayerAlgorithm

Public Types
enum	Code {   CODE_AUTO = -2, CODE_NONE = -1, CODE_L8, CODE_L16,   CODE_L16F, CODE_L32F, CODE_A8, CODE_A16,   CODE_A16F, CODE_A32F, CODE_LA4, CODE_LA8,   CODE_LA16, CODE_LA16F, CODE_LA32F, CODE_RGB5,   CODE_RGB5A1, CODE_RGB8, CODE_RGB10, CODE_RGB10A2,   CODE_RGB16, CODE_RGB16F, CODE_RGB32F, CODE_R11G11B10F,   CODE_RGB9E5F, CODE_RGB8I, CODE_RGB8UI, CODE_RGBA8I,   CODE_RGBA8UI, CODE_RGB8_SNORM, CODE_RGBA8_SNORM, CODE_RGB16_SNORM,   CODE_RGBA16_SNORM, CODE_ARGB8, CODE_BGR8, CODE_BGRA8,   CODE_R8, CODE_R8I, CODE_R8UI, CODE_R16,   CODE_R16I, CODE_R16UI, CODE_R32I, CODE_R32UI,   CODE_RG8, CODE_RG8I, CODE_RG8UI, CODE_RG16,   CODE_RG16I, CODE_RG16UI, CODE_R16F, CODE_RG16F,   CODE_RG32I, CODE_RG32UI, CODE_R32F, CODE_RG32F,   CODE_RGBA8, CODE_RGBA16, CODE_RGBA16F, CODE_RGBA32F,   CODE_RGBA16I, CODE_RGBA16UI, CODE_RGB32I, CODE_RGB32UI,   CODE_RGBA32I, CODE_RGBA32UI, CODE_BAYER_RGGB8, CODE_BAYER_GRBG8,   CODE_BAYER_GBRG8, CODE_BAYER_BGGR8, CODE_BAYER_RGGB32F, CODE_BAYER_GRBG32F,   CODE_BAYER_GBRG32F, CODE_BAYER_BGGR32F, CODE_HSV8, CODE_HSV32F,   CODE_YUV420_PLANAR, CODE_YUV422, CODE_YUV444, CODE_RGB_DXT1,   CODE_RGBA_DXT1, CODE_RGBA_DXT3, CODE_RGBA_DXT5, CODE_SRGB8,   CODE_SRGBA8, CODE_SL8, CODE_SLA8, CODE_SRGB_DXT1,   CODE_SRGBA_DXT1, CODE_SRGBA_DXT3, CODE_SRGBA_DXT5, CODE_DEPTH16,   CODE_DEPTH24, CODE_DEPTH32, CODE_DEPTH32F, CODE_STENCIL1,   CODE_STENCIL4, CODE_STENCIL8, CODE_STENCIL16, CODE_DEPTH24_STENCIL8,   CODE_NUM }
enum	ColorSpace {   COLOR_SPACE_NONE, COLOR_SPACE_RGB, COLOR_SPACE_HSV, COLOR_SPACE_YUV,   COLOR_SPACE_SRGB }
enum	BayerPattern {   BAYER_PATTERN_NONE, BAYER_PATTERN_RGGB, BAYER_PATTERN_GRBG, BAYER_PATTERN_GBRG,   BAYER_PATTERN_BGGR }
enum	NumberFormat { FLOATING_POINT_FORMAT, INTEGER_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, OTHER }

Public Member Functions
const std::string &	name () const
bool	canInterpretAs (const ImageFormat *otherFormat) const
bool	representableAsColor1unorm8 () const
bool	representableAsColor2unorm8 () const
bool	representableAsColor3unorm8 () const
bool	representableAsColor4unorm8 () const
Color4	channelMask () const
bool	isIntegerFormat () const
bool	sameComponents (const ImageFormat *other) const

Static Public Member Functions
static const ImageFormat *	getFormatWithAlpha (const ImageFormat *otherFormat)
static const ImageFormat *	getSRGBFormat (const ImageFormat *otherFormat)
static const ImageFormat *	fromString (const std::string &s)
static const ImageFormat *	L8 ()
static const ImageFormat *	L16 ()
static const ImageFormat *	L16F ()
static const ImageFormat *	L32F ()
static const ImageFormat *	A8 ()
static const ImageFormat *	A16 ()
static const ImageFormat *	A16F ()
static const ImageFormat *	A32F ()
static const ImageFormat *	LA4 ()
static const ImageFormat *	LA8 ()
static const ImageFormat *	LA16 ()
static const ImageFormat *	LA16F ()
static const ImageFormat *	LA32F ()
static const ImageFormat *	BGR8 ()
static const ImageFormat *	BGRA8 ()
static const ImageFormat *	R8 ()
static const ImageFormat *	R8I ()
static const ImageFormat *	R8UI ()
static const ImageFormat *	R16 ()
static const ImageFormat *	R16I ()
static const ImageFormat *	R16UI ()
static const ImageFormat *	R32I ()
static const ImageFormat *	R32UI ()
static const ImageFormat *	RG8 ()
static const ImageFormat *	RG8I ()
static const ImageFormat *	RG8UI ()
static const ImageFormat *	RG16 ()
static const ImageFormat *	RG16I ()
static const ImageFormat *	RG16UI ()
static const ImageFormat *	R16F ()
static const ImageFormat *	RG16F ()
static const ImageFormat *	RG32I ()
static const ImageFormat *	RG32UI ()
static const ImageFormat *	R32F ()
static const ImageFormat *	RG32F ()
static const ImageFormat *	RGB5 ()
static const ImageFormat *	RGB5A1 ()
static const ImageFormat *	RGB8 ()
static const ImageFormat *	RGB10 ()
static const ImageFormat *	RGB10A2 ()
static const ImageFormat *	RGB16 ()
static const ImageFormat *	RGB16F ()
static const ImageFormat *	RGB32F ()
static const ImageFormat *	RGBA8 ()
static const ImageFormat *	RGBA16 ()
static const ImageFormat *	RGBA16F ()
static const ImageFormat *	RGBA32F ()
static const ImageFormat *	RGBA16I ()
static const ImageFormat *	RGBA16UI ()
static const ImageFormat *	RGB32UI ()
static const ImageFormat *	RGB32I ()
static const ImageFormat *	RGBA32I ()
static const ImageFormat *	RGBA32UI ()
static const ImageFormat *	R11G11B10F ()
static const ImageFormat *	RGB9E5F ()
static const ImageFormat *	RGB8I ()
static const ImageFormat *	RGB8UI ()
static const ImageFormat *	RGBA8I ()
static const ImageFormat *	RGBA8UI ()
static const ImageFormat *	RGB8_SNORM ()
static const ImageFormat *	RGBA8_SNORM ()
static const ImageFormat *	RGB16_SNORM ()
static const ImageFormat *	RGBA16_SNORM ()
static const ImageFormat *	RGB_DXT1 ()
static const ImageFormat *	RGBA_DXT1 ()
static const ImageFormat *	RGBA_DXT3 ()
static const ImageFormat *	RGBA_DXT5 ()
static const ImageFormat *	SRGB8 ()
static const ImageFormat *	SRGBA8 ()
static const ImageFormat *	SL8 ()
static const ImageFormat *	SLA8 ()
static const ImageFormat *	SRGB_DXT1 ()
static const ImageFormat *	SRGBA_DXT1 ()
static const ImageFormat *	SRGBA_DXT3 ()
static const ImageFormat *	SRGBA_DXT5 ()
static const ImageFormat *	DEPTH16 ()
static const ImageFormat *	DEPTH24 ()
static const ImageFormat *	DEPTH32 ()
static const ImageFormat *	DEPTH32F ()
static const ImageFormat *	STENCIL1 ()
static const ImageFormat *	STENCIL4 ()
static const ImageFormat *	STENCIL8 ()
static const ImageFormat *	STENCIL16 ()
static const ImageFormat *	DEPTH24_STENCIL8 ()
static const ImageFormat *	YUV420_PLANAR ()
static const ImageFormat *	YUV422 ()
static const ImageFormat *	YUV444 ()
static const ImageFormat *	AUTO ()
static const ImageFormat *	depth (int depthBits=24)
static const ImageFormat *	stencil (int bits=8)
static const ImageFormat *	fromCode (ImageFormat::Code code)
static bool	convert (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat *srcFormat, int srcRowPadBits, const Array< void * > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY=false, BayerAlgorithm bayerAlg=BayerAlgorithm::MHC)
static bool	conversionAvailable (const ImageFormat *srcFormat, int srcRowPadBits, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY=false)

Public Attributes
int	numComponents
bool	compressed
Code	code
ColorSpace	colorSpace
BayerPattern	bayerPattern
int	openGLFormat
int	openGLBaseFormat
int	luminanceBits
int	alphaBits
int	redBits
int	greenBits
int	blueBits
int	stencilBits
int	depthBits
int	cpuBitsPerPixel
int	openGLBitsPerPixel
int	openGLDataFormat
bool	opaque
bool	floatingPoint
NumberFormat	numberFormat

Private Member Functions
	ImageFormat (int numComponents, bool compressed, int glFormat, int glBaseFormat, int luminanceBits, int alphaBits, int redBits, int greenBits, int blueBits, int depthBits, int stencilBits, int openGLBitsPerPixel, int cpuBitsPerPixel, int glDataFormat, bool opaque, NumberFormat numberFormat, Code code, ColorSpace colorSpace, BayerPattern bayerPattern=BAYER_PATTERN_NONE)

Detailed Description

Information about common image formats. Don't construct these; use the methods provided to access the const instances.

For most formats, the number indicates the number of bits per channel and a suffix of "F" indicates floating point (following OpenGL conventions). This does not hold for the YUV and DXT formats.

See also

G3D::Image, G3D::Texture, G3D::ImageConvert

Member Enumeration Documentation

enum G3D::ImageFormat::BayerPattern

Enumerator
BAYER_PATTERN_NONE
BAYER_PATTERN_RGGB
BAYER_PATTERN_GRBG
BAYER_PATTERN_GBRG
BAYER_PATTERN_BGGR

 {
 BAYER_PATTERN_NONE,
 BAYER_PATTERN_RGGB,
 BAYER_PATTERN_GRBG,
 BAYER_PATTERN_GBRG,
 BAYER_PATTERN_BGGR
 };

enum G3D::ImageFormat::Code

Enumerator
CODE_AUTO
CODE_NONE
CODE_L8
CODE_L16
CODE_L16F
CODE_L32F
CODE_A8
CODE_A16
CODE_A16F
CODE_A32F
CODE_LA4
CODE_LA8
CODE_LA16
CODE_LA16F
CODE_LA32F
CODE_RGB5
CODE_RGB5A1
CODE_RGB8
CODE_RGB10
CODE_RGB10A2
CODE_RGB16
CODE_RGB16F
CODE_RGB32F
CODE_R11G11B10F
CODE_RGB9E5F
CODE_RGB8I
CODE_RGB8UI
CODE_RGBA8I
CODE_RGBA8UI
CODE_RGB8_SNORM
CODE_RGBA8_SNORM
CODE_RGB16_SNORM
CODE_RGBA16_SNORM
CODE_ARGB8
CODE_BGR8
CODE_BGRA8
CODE_R8
CODE_R8I
CODE_R8UI
CODE_R16
CODE_R16I
CODE_R16UI
CODE_R32I
CODE_R32UI
CODE_RG8
CODE_RG8I
CODE_RG8UI
CODE_RG16
CODE_RG16I
CODE_RG16UI
CODE_R16F
CODE_RG16F
CODE_RG32I
CODE_RG32UI
CODE_R32F
CODE_RG32F
CODE_RGBA8
CODE_RGBA16
CODE_RGBA16F
CODE_RGBA32F
CODE_RGBA16I
CODE_RGBA16UI
CODE_RGB32I
CODE_RGB32UI
CODE_RGBA32I
CODE_RGBA32UI
CODE_BAYER_RGGB8
CODE_BAYER_GRBG8
CODE_BAYER_GBRG8
CODE_BAYER_BGGR8
CODE_BAYER_RGGB32F
CODE_BAYER_GRBG32F
CODE_BAYER_GBRG32F
CODE_BAYER_BGGR32F
CODE_HSV8
CODE_HSV32F
CODE_YUV420_PLANAR
CODE_YUV422
CODE_YUV444
CODE_RGB_DXT1
CODE_RGBA_DXT1
CODE_RGBA_DXT3
CODE_RGBA_DXT5
CODE_SRGB8
CODE_SRGBA8
CODE_SL8
CODE_SLA8
CODE_SRGB_DXT1
CODE_SRGBA_DXT1
CODE_SRGBA_DXT3
CODE_SRGBA_DXT5
CODE_DEPTH16
CODE_DEPTH24
CODE_DEPTH32
CODE_DEPTH32F
CODE_STENCIL1
CODE_STENCIL4
CODE_STENCIL8
CODE_STENCIL16
CODE_DEPTH24_STENCIL8
CODE_NUM

 {
 CODE_AUTO = -2,
 CODE_NONE = -1,
 CODE_L8,
 CODE_L16,
 CODE_L16F,
 CODE_L32F,

 CODE_A8,
 CODE_A16,
 CODE_A16F,
 CODE_A32F,

 CODE_LA4,
 CODE_LA8,
 CODE_LA16,
 CODE_LA16F,
 CODE_LA32F,

 CODE_RGB5,
 CODE_RGB5A1,
 CODE_RGB8,
 CODE_RGB10,
 CODE_RGB10A2,
 CODE_RGB16,
 CODE_RGB16F,
 CODE_RGB32F,
 CODE_R11G11B10F,
 CODE_RGB9E5F,

 CODE_RGB8I,
 CODE_RGB8UI,

 CODE_RGBA8I,
 CODE_RGBA8UI,

 CODE_RGB8_SNORM,
 CODE_RGBA8_SNORM,
 CODE_RGB16_SNORM,
 CODE_RGBA16_SNORM,

 CODE_ARGB8,
 CODE_BGR8,
 CODE_BGRA8,

 CODE_R8,
 CODE_R8I,
 CODE_R8UI,

 CODE_R16,
 CODE_R16I,
 CODE_R16UI,

 CODE_R32I,
 CODE_R32UI,

 CODE_RG8,
 CODE_RG8I,
 CODE_RG8UI,

 CODE_RG16,
 CODE_RG16I,
 CODE_RG16UI,

 CODE_R16F,
 CODE_RG16F,

 CODE_RG32I,
 CODE_RG32UI,

 CODE_R32F,
 CODE_RG32F,

 CODE_RGBA8,
 CODE_RGBA16,
 CODE_RGBA16F,
 CODE_RGBA32F,

 CODE_RGBA16I,
 CODE_RGBA16UI,

 CODE_RGB32I,
 CODE_RGB32UI,
 CODE_RGBA32I,
 CODE_RGBA32UI,

 CODE_BAYER_RGGB8,
 CODE_BAYER_GRBG8,
 CODE_BAYER_GBRG8,
 CODE_BAYER_BGGR8,
 CODE_BAYER_RGGB32F,
 CODE_BAYER_GRBG32F,
 CODE_BAYER_GBRG32F,
 CODE_BAYER_BGGR32F,

 CODE_HSV8,
 CODE_HSV32F,

 CODE_YUV420_PLANAR,
 CODE_YUV422,
 CODE_YUV444,

 CODE_RGB_DXT1,
 CODE_RGBA_DXT1,
 CODE_RGBA_DXT3,
 CODE_RGBA_DXT5,

 CODE_SRGB8,
 CODE_SRGBA8,

 CODE_SL8,
 CODE_SLA8,

 CODE_SRGB_DXT1,
 CODE_SRGBA_DXT1,
 CODE_SRGBA_DXT3,
 CODE_SRGBA_DXT5,

 CODE_DEPTH16,
 CODE_DEPTH24,
 CODE_DEPTH32,
 CODE_DEPTH32F,
 
 CODE_STENCIL1,
 CODE_STENCIL4,
 CODE_STENCIL8,
 CODE_STENCIL16,

 CODE_DEPTH24_STENCIL8,

 CODE_NUM
 };

enum G3D::ImageFormat::ColorSpace

Enumerator
COLOR_SPACE_NONE
COLOR_SPACE_RGB
COLOR_SPACE_HSV
COLOR_SPACE_YUV
COLOR_SPACE_SRGB

 {
 COLOR_SPACE_NONE,
 COLOR_SPACE_RGB,
 COLOR_SPACE_HSV,
 COLOR_SPACE_YUV,
 COLOR_SPACE_SRGB
 };

enum G3D::ImageFormat::NumberFormat

Enumerator
FLOATING_POINT_FORMAT
INTEGER_FORMAT
NORMALIZED_FIXED_POINT_FORMAT
OTHER

 { 
 FLOATING_POINT_FORMAT,
 INTEGER_FORMAT,
 NORMALIZED_FIXED_POINT_FORMAT,
 OTHER // e.g. DXT
 };

Constructor & Destructor Documentation

G3D::ImageFormat::ImageFormat ( int  numComponents, bool  compressed, int  glFormat, int  glBaseFormat, int  luminanceBits, int  alphaBits, int  redBits, int  greenBits, int  blueBits, int  depthBits, int  stencilBits, int  openGLBitsPerPixel, int  cpuBitsPerPixel, int  glDataFormat, bool  opaque, NumberFormat  numberFormat, Code  code, ColorSpace  colorSpace, BayerPattern  bayerPattern = BAYER_PATTERN_NONE  )

private

 : 

 numComponents(_numComponents),
 compressed(_compressed),
 code(_code),
 colorSpace(_colorSpace),
 bayerPattern(_bayerPattern),
 openGLFormat(_glFormat),
 openGLBaseFormat(_glBaseFormat),
 luminanceBits(_luminanceBits),
 alphaBits(_alphaBits),
 redBits(_redBits),
 greenBits(_greenBits),
 blueBits(_blueBits),
 stencilBits(_stencilBits),
 depthBits(_depthBits),
 cpuBitsPerPixel(_cpuBitsPerPixel),
 openGLBitsPerPixel(_openGLBitsPerPixel),
 openGLDataFormat(glDataFormat),
 opaque(_opaque),
 numberFormat(_numberFormat){

 floatingPoint = (numberFormat == FLOATING_POINT_FORMAT);
 debugAssert(cpuBitsPerPixel <= openGLBitsPerPixel);
}

Member Function Documentation

static const ImageFormat* G3D::ImageFormat::A16 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::A16F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::A32F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::A8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::AUTO ( )

inlinestatic

NULL pointer; indicates that the G3D::Texture class should choose either RGBA8 or RGB8 depending on the presence of an alpha channel in the input.

{ return NULL; }

static const ImageFormat* G3D::ImageFormat::BGR8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::BGRA8 ( )

static

Here is the caller graph for this function:

bool G3D::ImageFormat::canInterpretAs

(

const ImageFormat *

otherFormat

)

const

True if data in otherFormat is binary compatible

 {
 if (this == otherFormat) {
 return true;
 }

 if (compressed || otherFormat->compressed) {
 return false;
 }

 if (colorSpace != otherFormat->colorSpace) {
 return false;
 }

 if (floatingPoint != otherFormat->floatingPoint) {
 return false;
 }

 if (numComponents != otherFormat->numComponents) {
 return false;
 }

 if (cpuBitsPerPixel != otherFormat->cpuBitsPerPixel) {
 return false;
 }

 if (openGLDataFormat != otherFormat->openGLDataFormat) {
 return false;
 }

 return true;
}

Color4 G3D::ImageFormat::channelMask

(

)

const

Returns a Color4 that masks off unused components in the format, given in RGBA For example, the mask for R32F is (1,0,0,0), for A32F is (0,0,0,1), for RGB32F is (1,1,1,0). (Note that luminance is interpreted as using only the R channel, even though RGB would make more sense to me...)

 {
 Color4 mask;
 mask.r = (redBits > 0 || luminanceBits > 0) ? 1.0f : 0.0f;
 mask.b = (blueBits > 0) ? 1.0f : 0.0f;
 mask.g = (greenBits > 0) ? 1.0f : 0.0f;
 mask.a = (alphaBits > 0) ? 1.0f : 0.0f;
 return mask;

}

static bool G3D::ImageFormat::conversionAvailable ( const ImageFormat *  srcFormat, int  srcRowPadBits, const ImageFormat *  dstFormat, int  dstRowPadBits, bool  invertY = false  )

static

Checks if a conversion between two formats is available.

Deprecated:

See also

G3D::ImageConvert

Here is the caller graph for this function:

bool G3D::ImageFormat::convert ( const Array< const void * > &  srcBytes, int  srcWidth, int  srcHeight, const ImageFormat *  srcFormat, int  srcRowPadBits, const Array< void * > &  dstBytes, const ImageFormat *  dstFormat, int  dstRowPadBits, bool  invertY = false, BayerAlgorithm  bayerAlg = BayerAlgorithm::MHC  )

static

Converts between arbitrary formats on the CPU. Not all format conversions are supported or directly supported. Formats without direct conversions will attempt to convert through RGBA first.

A conversion routine might only support source or destination padding or y inversion or none. If support is needed and not available in any of the direct conversion routines, then no conversion is done.

YUV422 expects data in YUY2 format (Y, U, Y2, v). Most YUV formats require width and heights that are multiples of 2.

Returns true if a conversion was available, false if none occurred.

Deprecated:

See also

G3D::ImageConvert

 {

 bool conversionAvailable = false;

 // Handle direct copy of image to same format
 if ( (srcFormat->code == dstFormat->code) && (srcRowPadBits == dstRowPadBits) && !invertY) {

 System::memcpy(dstBytes[0], srcBytes[0], iCeil(((srcWidth * srcFormat->cpuBitsPerPixel + srcRowPadBits) * srcHeight) / 8.0f));
 conversionAvailable = true;
 } else {
 // if no direct conversion routine exists,
 // then look for conversion to intermediate
 // and then from intermediate to dest.
 // intermediate format is RGBA32F
 ConvertFunc directConverter = findConverter(srcFormat->code, dstFormat->code, srcRowPadBits > 0, dstRowPadBits > 0, invertY);

 // if we have a direct converter, use it, otherwise find intermdiate path
 if (directConverter) {
 directConverter(srcBytes, srcWidth, srcHeight, srcFormat, srcRowPadBits, dstBytes, dstFormat, dstRowPadBits, invertY, bayerAlg);
 conversionAvailable = true;
 } else {
 ConvertFunc toInterConverter = findConverter(srcFormat->code, ImageFormat::CODE_RGBA32F, srcRowPadBits > 0, false, false);;
 ConvertFunc fromInterConverter = findConverter(ImageFormat::CODE_RGBA32F, dstFormat->code, false, dstRowPadBits > 0, invertY);;

 if (toInterConverter && fromInterConverter) {
 Array<void*> tmp;
 tmp.append(System::malloc(srcWidth * srcHeight * ImageFormat::RGBA32F()->cpuBitsPerPixel * 8));

 toInterConverter(srcBytes, srcWidth, srcHeight, srcFormat, srcRowPadBits, tmp, ImageFormat::RGBA32F(), 0, false, bayerAlg);
 fromInterConverter(reinterpret_cast<Array<const void*>&>(tmp), srcWidth, srcHeight, ImageFormat::RGBA32F(), 0, dstBytes, dstFormat, dstRowPadBits, invertY, bayerAlg);

 System::free(tmp[0]);

 conversionAvailable = true;
 }
 }
 }

 return conversionAvailable;
}

Here is the call graph for this function:

const ImageFormat * G3D::ImageFormat::depth ( int  depthBits = 24 )

static

Returns DEPTH16, DEPTH24, or DEPTH32 according to the bits specified. You can use "glGetInteger(GL_DEPTH_BITS)" to match the screen's format.

 {

 switch (depthBits) {
 case 16:
 return DEPTH16();

 case 24:
 return DEPTH24();

 case 32:
 return DEPTH32();

 default:
 debugAssertM(false, "Depth must be 16, 24, or 32.");
 return DEPTH32();
 }
}

Here is the call graph for this function:

static const ImageFormat* G3D::ImageFormat::DEPTH16 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::DEPTH24 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::DEPTH24_STENCIL8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::DEPTH32 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::DEPTH32F ( )

static

Here is the caller graph for this function:

const ImageFormat * G3D::ImageFormat::fromCode ( ImageFormat::Code  code )

static

Returns the matching ImageFormat* identified by the Code. May return NULL if this format's code is reserved but not yet implemented by G3D.

 {
 switch (code) {
 case ImageFormat::CODE_L8:
 return ImageFormat::L8();

 case ImageFormat::CODE_L16:
 return ImageFormat::L16();

 case ImageFormat::CODE_L16F:
 return ImageFormat::L16F();

 case ImageFormat::CODE_L32F:
 return ImageFormat::L32F();

 case ImageFormat::CODE_A8:
 return ImageFormat::A8();

 case ImageFormat::CODE_A16:
 return ImageFormat::A16();

 case ImageFormat::CODE_A16F:
 return ImageFormat::A16F();

 case ImageFormat::CODE_A32F:
 return ImageFormat::A32F();

 case ImageFormat::CODE_LA4:
 return ImageFormat::LA4();

 case ImageFormat::CODE_LA8:
 return ImageFormat::LA8();

 case ImageFormat::CODE_LA16:
 return ImageFormat::LA16();

 case ImageFormat::CODE_LA16F:
 return ImageFormat::LA16F();
 
 case ImageFormat::CODE_LA32F:
 return ImageFormat::LA32F();

 case ImageFormat::CODE_RGB5:
 return ImageFormat::RGB5();

 case ImageFormat::CODE_RGB5A1:
 return ImageFormat::RGB5A1();

 case ImageFormat::CODE_RGB8:
 return ImageFormat::RGB8();

 case ImageFormat::CODE_RGB10:
 return ImageFormat::RGB10();

 case ImageFormat::CODE_RGB10A2:
 return ImageFormat::RGB10A2();

 case ImageFormat::CODE_RGB16:
 return ImageFormat::RGB16();

 case ImageFormat::CODE_RGB32F:
 return ImageFormat::RGB32F();

 case ImageFormat::CODE_R11G11B10F:
 return ImageFormat::R11G11B10F();

 case ImageFormat::CODE_RGB9E5F:
 return ImageFormat::RGB9E5F();

 case ImageFormat::CODE_RGB8I:
 return ImageFormat::RGB8I();

 case ImageFormat::CODE_RGB8UI:
 return ImageFormat::RGB8UI();

 case ImageFormat::CODE_RGBA8I:
 return ImageFormat::RGBA8I();

 case ImageFormat::CODE_RGBA8UI:
 return ImageFormat::RGBA8UI();

 case ImageFormat::CODE_RGB8_SNORM:
 return ImageFormat::RGB8_SNORM();
 case ImageFormat::CODE_RGBA8_SNORM:
 return ImageFormat::RGBA8_SNORM();
 case ImageFormat::CODE_RGB16_SNORM:
 return ImageFormat::RGB16_SNORM();
 case ImageFormat::CODE_RGBA16_SNORM:
 return ImageFormat::RGBA16_SNORM();

 case ImageFormat::CODE_ARGB8:
 return NULL;

 case ImageFormat::CODE_BGR8:
 return ImageFormat::BGR8();

 case ImageFormat::CODE_BGRA8:
 return ImageFormat::BGRA8();

 case ImageFormat::CODE_R8:
 return ImageFormat::R8();

 case ImageFormat::CODE_R8I:
 return ImageFormat::R8I();

 case ImageFormat::CODE_R8UI:
 return ImageFormat::R8UI();

 case ImageFormat::CODE_R16:
 return ImageFormat::R16();

 case ImageFormat::CODE_R16I:
 return ImageFormat::R16I();

 case ImageFormat::CODE_R16UI:
 return ImageFormat::R16UI();

 case ImageFormat::CODE_R32I:
 return ImageFormat::R32I();

 case ImageFormat::CODE_R32UI:
 return ImageFormat::R32UI();

 case ImageFormat::CODE_RG8:
 return ImageFormat::RG8();

 case ImageFormat::CODE_RG8I:
 return ImageFormat::RG8I();

 case ImageFormat::CODE_RG8UI:
 return ImageFormat::RG8UI();

 case ImageFormat::CODE_R16F:
 return ImageFormat::R16F();

 case ImageFormat::CODE_RG16F:
 return ImageFormat::RG16F();

 case ImageFormat::CODE_R32F:
 return ImageFormat::R32F();

 case ImageFormat::CODE_RG32F:
 return ImageFormat::RG32F();

 case ImageFormat::CODE_RGBA8:
 return ImageFormat::RGBA8();

 case ImageFormat::CODE_RGBA16:
 return ImageFormat::RGBA16();

 case ImageFormat::CODE_RGBA16F:
 return ImageFormat::RGBA16F();

 case ImageFormat::CODE_RGBA32F:
 return ImageFormat::RGBA32F();

 case ImageFormat::CODE_RGB32I:
 return ImageFormat::RGB32I();

 case ImageFormat::CODE_RGBA32I:
 return ImageFormat::RGBA32I();

 case ImageFormat::CODE_RGB32UI:
 return ImageFormat::RGB32UI();

 case ImageFormat::CODE_RGBA32UI:
 return ImageFormat::RGBA32UI();

 case ImageFormat::CODE_BAYER_RGGB8:
 // TODO
 case ImageFormat::CODE_BAYER_GRBG8:
 // TODO
 case ImageFormat::CODE_BAYER_GBRG8:
 // TODO
 case ImageFormat::CODE_BAYER_BGGR8:
 // TODO
 case ImageFormat::CODE_BAYER_RGGB32F:
 // TODO
 case ImageFormat::CODE_BAYER_GRBG32F:
 // TODO
 case ImageFormat::CODE_BAYER_GBRG32F:
 // TODO
 case ImageFormat::CODE_BAYER_BGGR32F:
 // TODO

 case ImageFormat::CODE_HSV8:
 // TODO
 case ImageFormat::CODE_HSV32F:
 // TODO
 return NULL;
 break;

 case ImageFormat::CODE_RGB_DXT1:
 return ImageFormat::RGB_DXT1();
 break;
 case ImageFormat::CODE_RGBA_DXT1:
 return ImageFormat::RGBA_DXT1();
 break;
 case ImageFormat::CODE_RGBA_DXT3:
 return ImageFormat::RGBA_DXT3();
 break;
 case ImageFormat::CODE_RGBA_DXT5:
 return ImageFormat::RGBA_DXT5();
 break;

 case ImageFormat::CODE_SRGB8:
 return ImageFormat::SRGB8();
 break;

 case ImageFormat::CODE_SRGBA8:
 return ImageFormat::SRGBA8();
 break;

 case ImageFormat::CODE_SL8:
 return ImageFormat::SL8();
 break;

 case ImageFormat::CODE_SLA8:
 return ImageFormat::SLA8();
 break;

 case ImageFormat::CODE_SRGB_DXT1:
 return ImageFormat::SRGB_DXT1();
 break;

 case ImageFormat::CODE_SRGBA_DXT1:
 return ImageFormat::SRGBA_DXT1();
 break;

 case ImageFormat::CODE_SRGBA_DXT3:
 return ImageFormat::SRGBA_DXT3();
 break;

 case ImageFormat::CODE_SRGBA_DXT5:
 return ImageFormat::SRGBA_DXT5();
 break;

 case ImageFormat::CODE_DEPTH16:
 return ImageFormat::DEPTH16();
 break;
 case ImageFormat::CODE_DEPTH24:
 return ImageFormat::DEPTH24();
 break;
 case ImageFormat::CODE_DEPTH32:
 return ImageFormat::DEPTH32();
 break;
 case ImageFormat::CODE_DEPTH32F:
 return ImageFormat::DEPTH32F();
 break;

 case ImageFormat::CODE_STENCIL1:
 return ImageFormat::STENCIL1();
 break;
 case ImageFormat::CODE_STENCIL4:
 return ImageFormat::STENCIL4();
 break;
 case ImageFormat::CODE_STENCIL8:
 return ImageFormat::STENCIL8();
 break;
 case ImageFormat::CODE_STENCIL16:
 return ImageFormat::STENCIL16();
 break;

 case ImageFormat::CODE_DEPTH24_STENCIL8:
 return ImageFormat::DEPTH24_STENCIL8();
 break;

 case ImageFormat::CODE_YUV420_PLANAR:
 return ImageFormat::YUV420_PLANAR();
 break;

 case ImageFormat::CODE_YUV422:
 return ImageFormat::YUV422();
 break;

 case ImageFormat::CODE_YUV444:
 return ImageFormat::YUV444();
 break;

 default:
 return NULL;
 }
}

Here is the caller graph for this function:

const ImageFormat * G3D::ImageFormat::fromString ( const std::string &  s )

static

Takes the same values that name() returns

                                                             {
    if (toLower(s) == "auto") {
        return NULL;
    }

    for (int i = 0; i < CODE_NUM; ++i) {
        if (s == nameArray[i]) {
            return fromCode(ImageFormat::Code(i));
        }
    }
    return NULL;
}

Here is the call graph for this function:

const ImageFormat * G3D::ImageFormat::getFormatWithAlpha ( const ImageFormat *  otherFormat )

static

Returns ImageFormat representing the same channels as otherFormat plus an alpha channel, all with at least the same precision as otherFormat, or returns NULL if an equivalent format is unavailable. Will return itself if already contains an alpha channel.

                                                                                 {
    if (! otherFormat->opaque) {
        return otherFormat;
    }

    switch (otherFormat->code) {
    case CODE_L8:
        return LA8();
        break;

    case CODE_L16F:
        return LA16F();
        break;

    case CODE_RGB8:
        return RGBA8();
        break;
        
    case CODE_RGB8I:
        return RGBA8I();
        break;

    case CODE_RGB32I:
        return RGBA32I();
        break;

    case CODE_RGB32UI:
        return RGBA32UI();
        break;

    case CODE_RGB8UI:
        return RGBA8UI();
        break;

    case CODE_RGB8_SNORM:
        return RGB8_SNORM();
        break;
    case CODE_RGBA8_SNORM:
        return RGBA8_SNORM();
        break;

    case CODE_RGB16_SNORM:
        return RGB16_SNORM();
        break;

    case CODE_RGBA16_SNORM:
        return RGBA16_SNORM();
        break;
        
    case CODE_BGR8:
        return BGRA8();
        break;
        
    case CODE_RGB16:
        return RGBA16();
        break;
        
    case CODE_RGB16F:
        return RGBA16F();
        break;
        
    case CODE_RGB32F:
        return RGBA32F();
        break;

    case CODE_R11G11B10F:
        return RGBA16F();
        break;
        
    default:
        break;
    }

    return NULL;
}

Here is the call graph for this function:

const ImageFormat * G3D::ImageFormat::getSRGBFormat ( const ImageFormat *  otherFormat )

static

                                                                            {
    switch (otherFormat->code) {
    case CODE_RGB8:
        return SRGB8();

    case CODE_RGBA8:
        return SRGBA8();

    case CODE_RGB_DXT1:
        return SRGB_DXT1();

    case CODE_RGBA_DXT1:
        return SRGBA_DXT1();

    case CODE_RGBA_DXT3:
        return SRGBA_DXT3();

    case CODE_RGBA_DXT5:
        return SRGBA_DXT5();

    default:
        return otherFormat;
    }
}

Here is the call graph for this function:

bool G3D::ImageFormat::isIntegerFormat ( ) const

inline

                                {
        return (numberFormat == INTEGER_FORMAT);
    }

static const ImageFormat* G3D::ImageFormat::L16 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::L16F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::L32F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::L8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::LA16 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::LA16F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::LA32F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::LA4 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::LA8 ( )

static

Here is the caller graph for this function:

const std::string & G3D::ImageFormat::name

(

)

const

Human readable name of this format.

                                         {
    debugAssert(code < CODE_NUM);
    return nameArray[code];
}

static const ImageFormat* G3D::ImageFormat::R11G11B10F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::R16 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::R16F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::R16I ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::R16UI ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::R32F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::R32I ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::R32UI ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::R8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::R8I ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::R8UI ( )

static

Here is the caller graph for this function:

bool G3D::ImageFormat::representableAsColor1unorm8

(

)

const

Does this contain exactly one unorm8 component?

                                                    {
    return (numComponents == 1) &&
        (cpuBitsPerPixel == 8) &&
        ((luminanceBits == 8) ||
         (redBits == 8) ||
         (alphaBits == 8));
}

bool G3D::ImageFormat::representableAsColor2unorm8

(

)

const

Does this contain exactly two unorm8 components?

                                                    {
    return (numComponents == 2) &&
        (cpuBitsPerPixel == 16) &&
        ((redBits == 8 && greenBits == 8) ||
         (luminanceBits == 8 && alphaBits == 8) ||
         (redBits == 8 && alphaBits == 8));
}

bool G3D::ImageFormat::representableAsColor3unorm8

(

)

const

Does this contain exactly three unorm8 components?

                                                    {
    return (numComponents == 3) &&
        (cpuBitsPerPixel == 24) &&
        (redBits == 8 && greenBits == 8 && blueBits == 8);
}

bool G3D::ImageFormat::representableAsColor4unorm8

(

)

const

Does this contain exactly four unorm8 components?

                                                    {
    return (numComponents == 4) &&
        (cpuBitsPerPixel == 32) &&
        (redBits == 8 && greenBits == 8 && blueBits == 8 && alphaBits == 8);
}

static const ImageFormat* G3D::ImageFormat::RG16 ( )

static

static const ImageFormat* G3D::ImageFormat::RG16F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RG16I ( )

static

static const ImageFormat* G3D::ImageFormat::RG16UI ( )

static

static const ImageFormat* G3D::ImageFormat::RG32F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RG32I ( )

static

static const ImageFormat* G3D::ImageFormat::RG32UI ( )

static

static const ImageFormat* G3D::ImageFormat::RG8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RG8I ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RG8UI ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB10 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB10A2 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB16 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB16_SNORM ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB16F ( )

static

static const ImageFormat* G3D::ImageFormat::RGB32F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB32I ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB32UI ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB5 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB5A1 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB8_SNORM ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB8I ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB8UI ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB9E5F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGB_DXT1 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA16 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA16_SNORM ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA16F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA16I ( )

static

static const ImageFormat* G3D::ImageFormat::RGBA16UI ( )

static

static const ImageFormat* G3D::ImageFormat::RGBA32F ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA32I ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA32UI ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA8_SNORM ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA8I ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA8UI ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA_DXT1 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA_DXT3 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::RGBA_DXT5 ( )

static

Here is the caller graph for this function:

bool G3D::ImageFormat::sameComponents

(

const ImageFormat *

other

)

const

Returns true if these formats have the same components (possibly in different NumberFormats or sizes)

                                                               {
    return
        (numComponents == other->numComponents) &&
        ((alphaBits != 0) == (other->alphaBits != 0)) &&
        ((redBits != 0) == (other->redBits != 0)) &&
        ((greenBits != 0) == (other->greenBits != 0)) &&
        ((blueBits != 0) == (other->blueBits != 0)) &&
        ((luminanceBits != 0) == (other->luminanceBits != 0)) &&
        ((stencilBits != 0) == (other->stencilBits != 0)) &&
        ((depthBits != 0) == (other->depthBits != 0));
}

static const ImageFormat* G3D::ImageFormat::SL8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::SLA8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::SRGB8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::SRGB_DXT1 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::SRGBA8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::SRGBA_DXT1 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::SRGBA_DXT3 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::SRGBA_DXT5 ( )

static

Here is the caller graph for this function:

const ImageFormat * G3D::ImageFormat::stencil ( int  bits = 8 )

static

Returns STENCIL1, STENCIL4, STENCIL8 or STENCIL16 according to the bits specified. You can use "glGetInteger(GL_STENCIL_BITS)" to match the screen's format.

                                                {
    switch (bits) {
    case 1:
        return STENCIL1();

    case 4:
        return STENCIL4();

    case 8:
        return STENCIL8();

    case 16:
        return STENCIL16();

    default:
        debugAssertM(false, "Stencil must be 1, 4, 8 or 16.");
        return STENCIL16();
    }
}

Here is the call graph for this function:

static const ImageFormat* G3D::ImageFormat::STENCIL1 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::STENCIL16 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::STENCIL4 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::STENCIL8 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::YUV420_PLANAR ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::YUV422 ( )

static

Here is the caller graph for this function:

static const ImageFormat* G3D::ImageFormat::YUV444 ( )

static

Here is the caller graph for this function:

Member Data Documentation

int G3D::ImageFormat::alphaBits

Number of bits per pixel storage for alpha values; Zero for compressed textures and non-RGB.

BayerPattern G3D::ImageFormat::bayerPattern

If this is a Bayer format, what is the pattern.

int G3D::ImageFormat::blueBits

Number of bits per pixel storage for blue values; Zero for compressed textures and non-RGB.

Code G3D::ImageFormat::code

Useful for serializing.

ColorSpace G3D::ImageFormat::colorSpace

bool G3D::ImageFormat::compressed

int G3D::ImageFormat::cpuBitsPerPixel

Amount of CPU memory per pixel when packed into an array, discounting any end-of-row padding.

int G3D::ImageFormat::depthBits

Number of depth bits (for depth textures; e.g. shadow maps)

bool G3D::ImageFormat::floatingPoint

True if the bit depths specified are for float formats. TODO: Remove, replace with function keying off numberFormat

int G3D::ImageFormat::greenBits

Number of bits per pixel storage for green values; Zero for compressed textures and non-RGB.

int G3D::ImageFormat::luminanceBits

NumberFormat G3D::ImageFormat::numberFormat

Indicates whether this format treats numbers as integers, floating point, or normalized fixed point

int G3D::ImageFormat::numComponents

Number of channels (1 for a depth texture).

bool G3D::ImageFormat::opaque

True if there is no alpha channel for this texture.

int G3D::ImageFormat::openGLBaseFormat

The OpenGL base format equivalent to this one (e.g., GL_RGB, GL_ALPHA). Zero if there is no equivalent.

int G3D::ImageFormat::openGLBitsPerPixel

Amount of GPU memory per pixel on most graphics cards, for formats supported by OpenGL. This is only an estimate–the actual amount of memory may be different on your actual card.

This may be greater than the sum of the per-channel bits because graphics cards need to pad to the nearest 1, 2, or 4 bytes.

int G3D::ImageFormat::openGLDataFormat

The OpenGL bytes (type) format of the data buffer used with this texture format, e.g., GL_UNSIGNED_BYTE

int G3D::ImageFormat::openGLFormat

The OpenGL format equivalent to this one, e.g, GL_RGB8 Zero if there is no equivalent. This is actually a GLenum

int G3D::ImageFormat::redBits

Number of bits per pixel storage for red values; Zero for compressed textures and non-RGB.

int G3D::ImageFormat::stencilBits

Number of bits per pixel

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/ImageFormat.h
• dep/g3dlite/source/ImageFormat.cpp
• dep/g3dlite/source/ImageFormat_convert.cpp