I'm optimizing my game and I've just implemented compressed (DXTn) texture loading in OpenGL. I've worked my way removing bugs but I can't figure out this one: objects w/ DXTn + mipmapped textures are not being rendered. It's not like they are appearing with a flat color, they just don't appear at all. DXTn textured objs render and mipmapped non-compressed textures render just fine.
The texture in question is 256x256 I generate the mips all the way down 4x4, i.e 1 block. I've checked on gDebugger and it display all the levels (7) just fine. I'm using GL_LINEAR_MIPMAP_NEAREST for min filter and GL_LINEAR for mag one.
The texture is being compressed and mipmaps being created offline with Paint.NET tool using super sampling method. (I also tried bilinear just in case)
Source follow:
[SNIPPET 1: Loading DDS into sys memory + Initializing Object]
// Read header
DDSHeader header;
file.read(reinterpret_cast<char*>(&header), sizeof(DDSHeader));
uint pos = static_cast<uint>(file.tellg());
file.seekg(0, std::ios_base::end);
uint dataSizeInBytes = static_cast<uint>(file.tellg()) - pos;
file.seekg(pos, std::ios_base::beg);
// Read file data
mData = new unsigned char[dataSizeInBytes];
file.read(reinterpret_cast<char*>(mData), dataSizeInBytes);
file.close();
mMipmapCount = header.mipmapcount;
mHeight = header.height;
mWidth = header.width;
mCompressionType = header.pf.fourCC;
// Only support files divisible by 4 (for compression blocks algorithms)
massert(mWidth % 4 == 0 && mHeight % 4 == 0);
massert(mCompressionType == NO_COMPRESSION || mCompressionType == COMPRESSION_DXT1 || mCompressionType == COMPRESSION_DXT3 ||
mCompressionType == COMPRESSION_DXT5);
// Allow textures up to 65536x65536
massert(header.mipmapcount <= MAX_MIPMAP_LEVELS);
mTextureFilter = TextureFilter::LINEAR;
if (mMipmapCount > 0)
{
mMipmapFilter = MipmapFilter::NEAREST;
}
else
{
mMipmapFilter = MipmapFilter::NO_MIPMAP;
}
mBitsPerPixel = header.pf.bitcount;
if (mCompressionType == NO_COMPRESSION)
{
if (header.pf.flags & DDPF_ALPHAPIXELS)
{
// The only format supported w/ alpha is A8R8G8B8
massert(header.pf.amask == 0xFF000000 && header.pf.rmask == 0xFF0000 &&
header.pf.gmask == 0xFF00 && header.pf.bmask == 0xFF);
mInternalFormat = GL_RGBA8;
mFormat = GL_BGRA;
mDataType = GL_UNSIGNED_BYTE;
}
else
{
massert(header.pf.rmask == 0xFF0000 && header.pf.gmask == 0xFF00 && header.pf.bmask == 0xFF);
mInternalFormat = GL_RGB8;
mFormat = GL_BGR;
mDataType = GL_UNSIGNED_BYTE;
}
}
else
{
uint blockSizeInBytes = 16;
switch (mCompressionType)
{
case COMPRESSION_DXT1:
blockSizeInBytes = 8;
if (header.pf.flags & DDPF_ALPHAPIXELS)
{
mInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
}
else
{
mInternalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
}
break;
case COMPRESSION_DXT3:
mInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
break;
case COMPRESSION_DXT5:
mInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
break;
default:
// Not Supported (DXT2, DXT4 or any compression format)
massert(false);
}
}
[SNIPPET 2: Uploading into video memory]
massert(mData != NULL);
glGenTextures(1, &mHandle);
massert(mHandle!=0);
glBindTexture(GL_TEXTURE_2D, mHandle);
commitFiltering();
uint offset = 0;
Renderer* renderer = Renderer::getInstance();
switch (mInternalFormat)
{
case GL_RGB:
case GL_RGBA:
case GL_RGB8:
case GL_RGBA8:
for (uint i = 0; i < mMipmapCount + 1; ++i)
{
uint width = std::max(1U, mWidth >> i);
uint height = std::max(1U, mHeight >> i);
glTexImage2D(GL_TEXTURE_2D, i, mInternalFormat, width, height, mHasBorder, mFormat, mDataType, &mData[offset]);
offset += width * height * (mBitsPerPixel / 8);
}
break;
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
{
uint blockSize = 16;
if (mInternalFormat == GL_COMPRESSED_RGB_S3TC_DXT1_EXT || mInternalFormat == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT)
{
blockSize = 8;
}
uint width = mWidth;
uint height = mHeight;
for (uint i = 0; i < mMipmapCount + 1; ++i)
{
uint nBlocks = ((width + 3) / 4) * ((height + 3) / 4);
// Only POT textures allowed for mipmapping
massert(width % 4 == 0 && height % 4 == 0);
glCompressedTexImage2D(GL_TEXTURE_2D, i, mInternalFormat, width, height, mHasBorder, nBlocks * blockSize, &mData[offset]);
offset += nBlocks * blockSize;
if (width <= 4 && height <= 4)
{
break;
}
width = std::max(4U, width / 2);
height = std::max(4U, height / 2);
}
break;
}
default:
// Not Supported
massert(false);
}
Also I don't understand the "+3" in the block size computation but looking for a solution for my problema I've encountered people defining it as that. I guess it won't make a differente for POT textures but I put just in case.
Thanks.
