Forums - Texture rendering problem for ATITC Textures

7 posts / 0 new
Last post
Texture rendering problem for ATITC Textures
frontier
Join Date: 30 Dec 10
Posts: 12
Posted: Thu, 2010-12-30 09:24

Hi,

As I am not able to run your samples, tried ATITC code using core EGL in x86 debug. But couldn't see any textures rendered? Any help please?

Also can I know how can we get ".atc" image format?

Thanks in advance.

 

  • Up0
  • Down0
mxadd
Join Date: 20 Aug 10
Location: Poland
Posts: 10
Posted: Thu, 2010-12-30 12:53

I use ATI Compressonator to compress textures to ATC (and package them inside *.dds container). Then I just use glCompressedTexImage2D to load them to the device (ofcourse you need to 'extract' individual mip levels from dds container).

All works just fine on nexus one (GLES 2.0 based engine).

  • Up0
  • Down0
frontier
Join Date: 30 Dec 10
Posts: 12
Posted: Mon, 2011-01-03 00:09

Hi,

Yes using compressonator we are getting ".dds" format.

Trying to use your compression example of yours(in "tutorial" section), it looks like textureId is generated, but couldn't see any rendered texture on the screen.

Would be great if I could get any example code. Thanks a lot in advance. 

  • Up0
  • Down0
mxadd
Join Date: 20 Aug 10
Location: Poland
Posts: 10
Posted: Mon, 2011-01-03 11:53

Hi

// Trying to use your compression example of yours(in "tutorial" section), it looks like textureId is// generated, but couldn't see any rendered texture on the screen.

yy ??? tutorial section ... sorry what tutorial and what section ??? :>

but the example is as follows:

static int32_t getImageSize(uint32_t w, uint32_t h, uint32_t format){switch (format){case GL_ATC_RGB_AMD:return (((w+3) & 0xFFFFFFFC) * ((h+3) & 0xFFFFFFFC)) / 2;

case GL_ATC_RGBA_EXPLICIT_ALPHA_AMD:case GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD:return (((w+3) & 0xFFFFFFFC) * ((h+3) & 0xFFFFFFFC));}

return 0;}

static GLuint Load(DDSFile &dds){glGenTextures(1, &TextureID);glBindTexture(GL_TEXTURE_2D, TextureID);glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

uint32_t Width = dds.mWidth;uint32_t Height = dds.mHeight;uint32_t Level = 0;

for (; Level < dds.mMips; Level++){uint32_t Size = Width*Height, dds.mInternalFormat);

glCompressedTexImage2D(GL_TEXTURE_2D, Level, dds.mInternalFormat, Width, Height, 0, Size, dds.mImage[0].pixels[Level]);

Width = max(Width >>1, 1u);Height = max(Height>>1, 1u);}

return TextureID;}

dds.mImage[0].pixels[Level] -- just RAW bytes of compressed mip levelall works fine

  • Up0
  • Down0
frontier
Join Date: 30 Dec 10
Posts: 12
Posted: Sun, 2011-01-09 06:33

Hi,

I tried using your code, which is in "Adreno SDK installation folder/Tutorials/OPENGLES/CompressedTexture/Win32".

Rendering code is ok, but how to load ATI texture data, what could be the structure of ATI texture compression if we use Compressionator tool. Can you please give snippet of that code.

  • Up0
  • Down0
mxadd
Join Date: 20 Aug 10
Location: Poland
Posts: 10
Posted: Sun, 2011-01-09 08:38

Sorry I'm not in ANY way related to qualcomm :) so the tutorial is not my.

But ... the thing you want is the dds file format, if you are unfamiliar with dds'es then grab some dds loader, code of my loader is below (if you want it in more civilized way just drop me mail to [mxadd (at) mxadd (dot) org]

(basicale the XGSwap* just do endian swapping so you may ommit if for common arm mode)

/////////////////////////////////////////////////////////////////////////////////// DDS struct & defines//#ifndef GL_COMPRESSED_RGB_S3TC_DXT1_EXT#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0#endif

#ifndef GL_COMPRESSED_RGBA_S3TC_DXT1_EXT#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1#endif

#ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2#endif

#ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3#endif

#ifndef GL_BGRA#define GL_BGRA 0x80E1#endif

#ifndef GL_BGR#define GL_BGR 0x6664#endif

#ifndef MAKEFOURCC#define MAKEFOURCC(ch0, ch1, ch2, ch3) ((uint32_t)(uint8_t)(ch0) | ((uint32_t)(uint8_t)(ch1) << 8) | ((uint32_t)(uint8_t)(ch2) << 16) | ((uint32_t)(uint8_t)(ch3) << 24))#endif

const uint32_t gMaxMipmaps = 16;const uint32_t gMaxTextures = 16;

typedef struct PixelFormatFlag{static const uint32_t ALPHA_PIXELS = 0x00000001;static const uint32_t ALPHA = 0x00000002;static const uint32_t FOUR_CC = 0x00000004;static const uint32_t RGB = 0x00000040;static const uint32_t RGBA = 0x00000041;static const uint32_t LUMINANCE = 0x00020000;static const uint32_t LUMINANCE_ALPHA = 0x00020001;} PixelFormatFlag;

typedef struct Caps1Flag{static const uint32_t COMPLEX = 0x00000008;static const uint32_t TEXTURE = 0x00001000;static const uint32_t MIPMAP = 0x00400000;} Caps1Flag;

typedef struct Caps2Flag{static const uint32_t CUBEMAP = 0x00000200l;static const uint32_t CUBEMAP_POSITIVE_X = 0x00000400l;static const uint32_t CUBEMAP_NEGATIVE_X = 0x00000800l;static const uint32_t CUBEMAP_POSITIVE_Y = 0x00001000l;static const uint32_t CUBEMAP_NEGATIVE_Y = 0x00002000l;static const uint32_t CUBEMAP_POSITIVE_Z = 0x00004000l;static const uint32_t CUBEMAP_NEGATIVE_Z = 0x00008000l;static const uint32_t CUBEMAP_ALLFACES = 0x0000FC00l;static const uint32_t VOLUME = 0x00200000l;} Caps2Flag;

typedef struct FourCC{static const uint32_t A16B16G16R16 = 36;

static const uint32_t A16B16G16R16F = 113;static const uint32_t A32B32G32R32F = 116;

static const uint32_t DXT1 = 0x31545844;static const uint32_t DXT3 = 0x33545844;static const uint32_t DXT5 = 0x35545844;

static const uint32_t ATC_RGB = MAKEFOURCC('A', 'T', 'C', ' ');static const uint32_t ATC_RGBA_EA = MAKEFOURCC('A', 'T', 'C', 'A');static const uint32_t ATC_RGBA_IA = MAKEFOURCC('A', 'T', 'C', 'I');

static const uint32_t ETC_RGB = MAKEFOURCC('E', 'T', 'C', ' ');} FourCC;

typedef struct DdsPixelFormat{uint32_t dwSize;uint32_t dwFlags;uint32_t dwFourCC;uint32_t dwRGBBitCount;uint32_t dwRBitMask;uint32_t dwGBitMask;uint32_t dwBBitMask;uint32_t dwABitMask;} DdsPixelFormat;

typedef struct DdsHeader{uint32_t dwSize;uint32_t dwFlags;uint32_t dwHeight;uint32_t dwWidth;uint32_t dwPitchOrLinearSize;uint32_t dwDepth;uint32_t dwMipMapCount;uint32_t dwReserved1[11];DdsPixelFormat ddpfPixelFormat;uint32_t dwCaps1;uint32_t dwCaps2;uint32_t dwReserved2[3];} DdsHeader;

enum ComponentType{COMPONENT_TYPE_BYTE = GL_BYTE,COMPONENT_TYPE_UNSIGNED_BYTE = GL_UNSIGNED_BYTE,COMPONENT_TYPE_SHORT = GL_SHORT,COMPONENT_TYPE_UNSIGNED_SHORT = GL_UNSIGNED_SHORT,COMPONENT_TYPE_INT = GL_INT,COMPONENT_TYPE_UNSIGNED_INT = GL_UNSIGNED_INT,COMPONENT_TYPE_HALF_FLOAT = GL_HALF_FLOAT_OES,COMPONENT_TYPE_FLOAT = GL_FLOAT};

enum TextureType{TEXTURE_TYPE_NONE,TEXTURE_TYPE_FLAT,TEXTURE_TYPE_3D,TEXTURE_TYPE_CUBEMAP};

//// Helpers/////////////////////////////////////////////////////////////////////////////////static int32_t getPixelComponentSize(ComponentType component){int32_t size;switch ( component ){case COMPONENT_TYPE_BYTE:case COMPONENT_TYPE_UNSIGNED_BYTE:size = 1;break;case COMPONENT_TYPE_SHORT:case COMPONENT_TYPE_UNSIGNED_SHORT:size = 2;break;case COMPONENT_TYPE_INT:case COMPONENT_TYPE_UNSIGNED_INT:size = 4;break;case COMPONENT_TYPE_HALF_FLOAT:size = 2;break;case COMPONENT_TYPE_FLOAT:size = 4;break;default:Log("Unknown component size !");size = 0;}return size;}///////////////////////////////////////////////////////////////////////////////static int32_t getImageSize(uint32_t w, uint32_t h, uint32_t format, ComponentType component){int32_t componentSize = getPixelComponentSize(component);

switch (format){case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:return ((w+3)/4)*((h+3)/4)* 8;

case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:return ((w+3)/4)*((h+3)/4)* 16;

case GL_ATC_RGB_AMD:return (((w+3) & 0xFFFFFFFC) * ((h+3) & 0xFFFFFFFC)) / 2;

case GL_ATC_RGBA_EXPLICIT_ALPHA_AMD:case GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD:return (((w+3) & 0xFFFFFFFC) * ((h+3) & 0xFFFFFFFC));

case GL_ETC1_RGB8_OES:return (((w+3) & 0xFFFFFFFC) * ((h+3) & 0xFFFFFFFC)) / 2;

case GL_ALPHA:return w*h*componentSize;

case GL_RGBA:case GL_BGRA:return w*h*componentSize*4;

case GL_RGB:case GL_BGR:return w*h*componentSize*3;

case GL_LUMINANCE:return w*h*componentSize;

case GL_LUMINANCE_ALPHA:return w*h*componentSize*2;

default:Log("Unable to determine image size !");}

return 0;}///////////////////////////////////////////////////////////////////////////////static bool ImageSpec(uint32_t &format, ComponentType &type, const DdsHeader &ddsh){if (ddsh.ddpfPixelFormat.dwFlags & PixelFormatFlag::FOUR_CC){switch (ddsh.ddpfPixelFormat.dwFourCC){case FourCC::DXT1:format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;type = COMPONENT_TYPE_UNSIGNED_BYTE;break;

case FourCC::DXT3:format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;type = COMPONENT_TYPE_UNSIGNED_BYTE;break;

case FourCC::DXT5:format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;type = COMPONENT_TYPE_UNSIGNED_BYTE;break;

case FourCC::A16B16G16R16:format = GL_RGBA;type = COMPONENT_TYPE_UNSIGNED_SHORT;break;

case FourCC::A16B16G16R16F:format = GL_RGBA;type = COMPONENT_TYPE_HALF_FLOAT;break;

case FourCC::A32B32G32R32F:format = GL_RGBA;type = COMPONENT_TYPE_FLOAT;break;

case FourCC::ATC_RGB:format = GL_ATC_RGB_AMD;type = COMPONENT_TYPE_FLOAT;break;

case FourCC::ATC_RGBA_EA:format = GL_ATC_RGBA_EXPLICIT_ALPHA_AMD;type = COMPONENT_TYPE_FLOAT;break;

case FourCC::ATC_RGBA_IA:format = GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD;type = COMPONENT_TYPE_FLOAT;break;

case FourCC::ETC_RGB:format = GL_ETC1_RGB8_OES;type = COMPONENT_TYPE_FLOAT;break;

default:Log("Uses a compressed texture of unsupported type [0x%08X] !", ddsh.ddpfPixelFormat.dwFourCC);return false;}}elseif (ddsh.ddpfPixelFormat.dwFlags == PixelFormatFlag::RGBA){if (ddsh.ddpfPixelFormat.dwRGBBitCount == 32){if (ddsh.ddpfPixelFormat.dwRBitMask == 0x000000ff)format = GL_RGBA;elseformat = GL_BGRA;type = COMPONENT_TYPE_UNSIGNED_BYTE;}else{Log("Unsupported pixel format type !");return false;}}elseif (ddsh.ddpfPixelFormat.dwFlags == PixelFormatFlag::RGB){if (ddsh.ddpfPixelFormat.dwRGBBitCount == 32){if (ddsh.ddpfPixelFormat.dwRBitMask == 0x000000ff)format = GL_RGBA;elseformat = GL_BGRA;

type = COMPONENT_TYPE_UNSIGNED_BYTE;}elseif (ddsh.ddpfPixelFormat.dwRGBBitCount == 24){if (ddsh.ddpfPixelFormat.dwRBitMask == 0x000000ff)format = GL_RGB;elseformat = GL_BGR;

type = COMPONENT_TYPE_UNSIGNED_BYTE;}else{Log("Unsupported pixel format type !");return false;}}elseif (ddsh.ddpfPixelFormat.dwFlags == PixelFormatFlag::ALPHA){if (ddsh.ddpfPixelFormat.dwRGBBitCount == 8 && ddsh.ddpfPixelFormat.dwABitMask == 0x000000ff){format = GL_ALPHA;type = COMPONENT_TYPE_UNSIGNED_BYTE;}else{Log("Unsupported pixel format type !");return false;}}elseif (ddsh.ddpfPixelFormat.dwFlags == PixelFormatFlag::LUMINANCE_ALPHA){if (ddsh.ddpfPixelFormat.dwRGBBitCount == 16){format = GL_LUMINANCE_ALPHA;type = COMPONENT_TYPE_UNSIGNED_BYTE;}else{Log("Unsupported pixel format type !");return false;}}elseif (ddsh.ddpfPixelFormat.dwFlags == PixelFormatFlag::LUMINANCE){format = GL_LUMINANCE;

if (ddsh.ddpfPixelFormat.dwRGBBitCount == 16){type = COMPONENT_TYPE_UNSIGNED_SHORT;}elseif (ddsh.ddpfPixelFormat.dwRGBBitCount == 8){type = COMPONENT_TYPE_UNSIGNED_BYTE;}else{Log("Unsupported pixel format type !");return false;}}else{Log("Uses a texture of unsupported type !");return false;}

return true;}///////////////////////////////////////////////////////////////////////////////typedef struct DdsImage{uint8_t *pixels[gMaxMipmaps]; // the mip map images}DdsImage;

class DdsTexture{public:bool mIsCompressed;ComponentType mComponentType;uint32_t mFormat;uint32_t mWidth;uint32_t mHeight;uint32_t mMips;uint32_t mSurfaces;

DdsImage mImage[6]; // Images (1 for 2D, 6 for CUBE)

DdsTexture();~DdsTexture();

void dispose();

bool load(const void *data);

bool isCubeMap() const{return (mSurfaces == 6);}};

///////////////////////////////////////////////////////////////////////////////DdsTexture::DdsTexture(){__native_memset(this, 0, sizeof(DdsTexture));return;}///////////////////////////////////////////////////////////////////////////////DdsTexture::~DdsTexture(){dispose();return;}///////////////////////////////////////////////////////////////////////////////void DdsTexture::dispose(){__native_memset(this, 0, sizeof(DdsTexture));return;}///////////////////////////////////////////////////////////////////////////////bool DdsTexture::load(const void *data){uint8_t *buff = (uint8_t*)data;

//// Check if we are DDS//if (strncmp((char*)buff, "DDS ", 4) != 0){Log("This is not a valid DDS file !");return false;}

buff += 4; // Eat the MAGIC ID

DdsHeader *ddsh = (DdsHeader*)buff;buff += sizeof(DdsHeader); // Eat DDS header

//// Swap the header//XGSwap4(ddsh, sizeof(DdsHeader)>>2);

TextureType textureType = TEXTURE_TYPE_FLAT;

if (ddsh->dwCaps2 & Caps2Flag::CUBEMAP)textureType = TEXTURE_TYPE_CUBEMAP;

if ((ddsh->dwCaps2 & Caps2Flag::VOLUME) && (ddsh->dwDepth > 0)){Log("This is volume texture - unsupported here !");return false;}

//// Get the format//uint32_t format;ComponentType componentType;bool specTest = ImageSpec(format, componentType, *ddsh);

//// We do not know this format ?//if (!specTest)return false;

mFormat = format;mComponentType = componentType;mHeight = ddsh->dwHeight;mWidth = ddsh->dwWidth;

if (ddsh->dwMipMapCount == 0)ddsh->dwMipMapCount++;

mMips = ddsh->dwMipMapCount;mSurfaces = 1;

if (textureType == TEXTURE_TYPE_CUBEMAP)mSurfaces = 6;

mIsCompressed = (GL_COMPRESSED_RGBA_S3TC_DXT1_EXT == format ||GL_COMPRESSED_RGB_S3TC_DXT1_EXT == format ||GL_COMPRESSED_RGBA_S3TC_DXT3_EXT == format ||GL_COMPRESSED_RGBA_S3TC_DXT5_EXT == format ||GL_ATC_RGB_AMD == format ||GL_ATC_RGBA_EXPLICIT_ALPHA_AMD == format ||GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD == format ||GL_ETC1_RGB8_OES == format );

uint32_t numComponents = getPixelComponentSize(componentType);

//// Extract surface(s) and mipmaps//for (uint32_t i = 0; i < mSurfaces; i++){uint32_t width = ddsh->dwWidth;uint32_t height = ddsh->dwHeight;

for (uint32_t j = 0; j < mMips; j++){uint32_t size = getImageSize(width, height, format, componentType);

mImage[i].pixels[j] = buff;

if (numComponents == 2){uint16_t *t = (uint16_t*)mImage[i].pixels[j];uint32_t s = size / 2;XGSwap2(t, s);}elseif (numComponents == 4){uint32_t *t = (uint32_t*)mImage[i].pixels[j];uint32_t s = size / 4;XGSwap4(t, s);}

buff += size;width /= 2;height /= 2;}}

return true;}/////////////////////////////////////////////////////////////////////////////////// Deduce InternalFormat from Format and Type//static bool getInternalFormat(uint32_t &internalFormat, uint32_t format, uint32_t type){switch (format){case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;break;

case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;break;

case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:internalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;break;

case GL_ATC_RGB_AMD:internalFormat = GL_ATC_RGB_AMD;break;

case GL_ATC_RGBA_EXPLICIT_ALPHA_AMD:internalFormat = GL_ATC_RGBA_EXPLICIT_ALPHA_AMD;break;

case GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD:internalFormat = GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD;break;

case GL_ETC1_RGB8_OES:internalFormat = GL_ETC1_RGB8_OES;break;

case GL_RGBA:case GL_BGRA:switch (type){case COMPONENT_TYPE_BYTE:case COMPONENT_TYPE_UNSIGNED_BYTE:internalFormat = GL_RGBA;break;case COMPONENT_TYPE_SHORT:case COMPONENT_TYPE_UNSIGNED_SHORT:internalFormat = GL_RGBA;break;case COMPONENT_TYPE_INT:case COMPONENT_TYPE_UNSIGNED_INT:internalFormat = GL_RGBA;break;case COMPONENT_TYPE_FLOAT:internalFormat = GL_RGBA;break;case COMPONENT_TYPE_HALF_FLOAT:internalFormat = GL_RGBA;break;default:Log("Unsupported component type !");return false;}break;

case GL_RGB:case GL_BGR:switch ( type ){case COMPONENT_TYPE_BYTE:case COMPONENT_TYPE_UNSIGNED_BYTE:internalFormat = GL_RGB;break;case COMPONENT_TYPE_SHORT:case COMPONENT_TYPE_UNSIGNED_SHORT:internalFormat = GL_RGB;break;case COMPONENT_TYPE_INT:case COMPONENT_TYPE_UNSIGNED_INT:internalFormat = GL_RGB;break;case COMPONENT_TYPE_FLOAT:internalFormat = GL_RGB;break;case COMPONENT_TYPE_HALF_FLOAT:internalFormat = GL_RGB;break;default:Log("Unsupported component type !");return false;}break;

case GL_ALPHA:switch ( type ){case COMPONENT_TYPE_BYTE:case COMPONENT_TYPE_UNSIGNED_BYTE:internalFormat = GL_ALPHA;break;case COMPONENT_TYPE_SHORT:case COMPONENT_TYPE_UNSIGNED_SHORT:internalFormat = GL_ALPHA;break;case COMPONENT_TYPE_FLOAT:internalFormat = GL_ALPHA;break;case COMPONENT_TYPE_HALF_FLOAT:internalFormat = GL_ALPHA;break;default:Log("Unsupported component type !");return false;}break;

case GL_LUMINANCE:switch ( type ){case COMPONENT_TYPE_BYTE:case COMPONENT_TYPE_UNSIGNED_BYTE:internalFormat = GL_LUMINANCE;break;case COMPONENT_TYPE_SHORT:case COMPONENT_TYPE_UNSIGNED_SHORT:internalFormat = GL_LUMINANCE;break;case COMPONENT_TYPE_INT:case COMPONENT_TYPE_UNSIGNED_INT:internalFormat = GL_LUMINANCE;break;case COMPONENT_TYPE_FLOAT:internalFormat = GL_LUMINANCE;break;case COMPONENT_TYPE_HALF_FLOAT:internalFormat = GL_LUMINANCE;break;default:Log("Unsupported component type !");return false;}break;

case GL_LUMINANCE_ALPHA:switch ( type ){case COMPONENT_TYPE_BYTE:case COMPONENT_TYPE_UNSIGNED_BYTE:internalFormat = GL_LUMINANCE_ALPHA;break;case COMPONENT_TYPE_SHORT:case COMPONENT_TYPE_UNSIGNED_SHORT:internalFormat = GL_LUMINANCE_ALPHA;break;case COMPONENT_TYPE_FLOAT:internalFormat = GL_LUMINANCE_ALPHA;break;case COMPONENT_TYPE_HALF_FLOAT:internalFormat = GL_LUMINANCE_ALPHA;break;default:Log("Unsupported component type !");return false;}break;

default:Log("Unsupported format !");return false;}

return true;}

///////////////////////////////////////////////////////////////////////////////

 

 

  • Up0
  • Down0
frontier
Join Date: 30 Dec 10
Posts: 12
Posted: Mon, 2011-01-10 09:46

Hi,

Thanks a lot 

Would be great if i could get civilized code for complete ATITC texture loading. I have sent you a email.

  • Up0
  • Down0
or Register

Opinions expressed in the content posted here are the personal opinions of the original authors, and do not necessarily reflect those of Qualcomm Incorporated or its subsidiaries (“Qualcomm”). The content is provided for informational purposes only and is not meant to be an endorsement or representation by Qualcomm or any other party. This site may also provide links or references to non-Qualcomm sites and resources. Qualcomm makes no representations, warranties, or other commitments whatsoever about any non-Qualcomm sites or third-party resources that may be referenced, accessible from, or linked to this site.