// Creation / loading methods
void GLES2Texture::createInternalResourcesImpl(void)
{
_createGLTexResource();
_createSurfaceList();
// Get final internal format
mFormat = getBuffer(0,0)->getFormat();
}
//* Creation / loading methods ********************************************
void GLTexture::createInternalResourcesImpl(void)
{
if (!GLEW_VERSION_1_2 && mTextureType == TEX_TYPE_3D)
OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED,
"3D Textures not supported before OpenGL 1.2",
"GLTexture::createInternalResourcesImpl");
// Convert to nearest power-of-two size if required
mWidth = GLPixelUtil::optionalPO2(mWidth);
mHeight = GLPixelUtil::optionalPO2(mHeight);
mDepth = GLPixelUtil::optionalPO2(mDepth);
// Adjust format if required
mFormat = TextureManager::getSingleton().getNativeFormat(mTextureType, mFormat, mUsage);
// Check requested number of mipmaps
size_t maxMips = GLPixelUtil::getMaxMipmaps(mWidth, mHeight, mDepth, mFormat);
mNumMipmaps = mNumRequestedMipmaps;
if(mNumMipmaps>maxMips)
mNumMipmaps = maxMips;
// Generate texture name
glGenTextures( 1, &mTextureID );
// Set texture type
glBindTexture( getGLTextureTarget(), mTextureID );
// This needs to be set otherwise the texture doesn't get rendered
if (GLEW_VERSION_1_2)
glTexParameteri( getGLTextureTarget(), GL_TEXTURE_MAX_LEVEL, mNumMipmaps );
// Set some misc default parameters so NVidia won't complain, these can of course be changed later
glTexParameteri(getGLTextureTarget(), GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(getGLTextureTarget(), GL_TEXTURE_MAG_FILTER, GL_NEAREST);
if (GLEW_VERSION_1_2)
{
glTexParameteri(getGLTextureTarget(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(getGLTextureTarget(), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
// If we can do automip generation and the user desires this, do so
mMipmapsHardwareGenerated =
Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP);
// NVIDIA 175.16 drivers break hardware mip generation for non-compressed
// textures - disable until fixed
// Leave hardware gen on compressed textures since that's the only way we
// can realistically do it since GLU doesn't support DXT
// However DON'T do this on Apple, their drivers aren't subject to this
// problem yet and in fact software generation appears to cause a crash
// in some cases which I've yet to track down
#if OGRE_PLATFORM != OGRE_PLATFORM_APPLE
if (Root::getSingleton().getRenderSystem()->getCapabilities()->getVendor() == GPU_NVIDIA
&& !PixelUtil::isCompressed(mFormat))
{
mMipmapsHardwareGenerated = false;
}
#endif
if((mUsage & TU_AUTOMIPMAP) &&
mNumRequestedMipmaps && mMipmapsHardwareGenerated)
{
glTexParameteri( getGLTextureTarget(), GL_GENERATE_MIPMAP, GL_TRUE );
}
// Allocate internal buffer so that glTexSubImageXD can be used
// Internal format
GLenum format = GLPixelUtil::getClosestGLInternalFormat(mFormat, mHwGamma);
size_t width = mWidth;
size_t height = mHeight;
size_t depth = mDepth;
if(PixelUtil::isCompressed(mFormat))
{
// Compressed formats
size_t size = PixelUtil::getMemorySize(mWidth, mHeight, mDepth, mFormat);
// Provide temporary buffer filled with zeroes as glCompressedTexImageXD does not
// accept a 0 pointer like normal glTexImageXD
// Run through this process for every mipmap to pregenerate mipmap piramid
uint8 *tmpdata = new uint8[size];
memset(tmpdata, 0, size);
for(size_t mip=0; mip<=mNumMipmaps; mip++)
{
size = PixelUtil::getMemorySize(width, height, depth, mFormat);
switch(mTextureType)
{
case TEX_TYPE_1D:
glCompressedTexImage1DARB(GL_TEXTURE_1D, mip, format,
width, 0,
size, tmpdata);
break;
case TEX_TYPE_2D:
glCompressedTexImage2DARB(GL_TEXTURE_2D, mip, format,
width, height, 0,
size, tmpdata);
break;
case TEX_TYPE_3D:
glCompressedTexImage3DARB(GL_TEXTURE_3D, mip, format,
width, height, depth, 0,
size, tmpdata);
break;
case TEX_TYPE_CUBE_MAP:
for(int face=0; face<6; face++) {
glCompressedTexImage2DARB(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format,
width, height, 0,
size, tmpdata);
}
break;
};
if(width>1) width = width/2;
if(height>1) height = height/2;
if(depth>1) depth = depth/2;
}
delete [] tmpdata;
}
else
{
// Run through this process to pregenerate mipmap piramid
for(size_t mip=0; mip<=mNumMipmaps; mip++)
{
// Normal formats
switch(mTextureType)
{
case TEX_TYPE_1D:
glTexImage1D(GL_TEXTURE_1D, mip, format,
width, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
break;
case TEX_TYPE_2D:
glTexImage2D(GL_TEXTURE_2D, mip, format,
width, height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
break;
case TEX_TYPE_3D:
glTexImage3D(GL_TEXTURE_3D, mip, format,
width, height, depth, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
break;
case TEX_TYPE_CUBE_MAP:
for(int face=0; face<6; face++) {
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format,
width, height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
}
break;
};
if(width>1) width = width/2;
if(height>1) height = height/2;
if(depth>1) depth = depth/2;
}
}
_createSurfaceList();
// Get final internal format
mFormat = getBuffer(0,0)->getFormat();
}
//* Creation / loading methods ********************************************
void GLTexture::createInternalResourcesImpl(void)
{
if (!GLEW_VERSION_1_2 && mTextureType == TEX_TYPE_3D)
OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED,
"3D Textures not supported before OpenGL 1.2",
"GLTexture::createInternalResourcesImpl");
if (!GLEW_VERSION_2_0 && mTextureType == TEX_TYPE_2D_ARRAY)
OGRE_EXCEPT(Exception::ERR_NOT_IMPLEMENTED,
"2D texture arrays not supported before OpenGL 2.0",
"GLTexture::createInternalResourcesImpl");
// Convert to nearest power-of-two size if required
mWidth = GLPixelUtil::optionalPO2(mWidth);
mHeight = GLPixelUtil::optionalPO2(mHeight);
mDepth = GLPixelUtil::optionalPO2(mDepth);
// Adjust format if required
mFormat = TextureManager::getSingleton().getNativeFormat(mTextureType, mFormat, mUsage);
// Check requested number of mipmaps
size_t maxMips = GLPixelUtil::getMaxMipmaps(mWidth, mHeight, mDepth, mFormat);
mNumMipmaps = mNumRequestedMipmaps;
if(mNumMipmaps>maxMips)
mNumMipmaps = maxMips;
// Check if we can do HW mipmap generation
mMipmapsHardwareGenerated =
Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP);
// Generate texture name
glGenTextures( 1, &mTextureID );
// Set texture type
mGLSupport.getStateCacheManager()->bindGLTexture( getGLTextureTarget(), mTextureID );
// This needs to be set otherwise the texture doesn't get rendered
if (GLEW_VERSION_1_2)
mGLSupport.getStateCacheManager()->setTexParameteri(getGLTextureTarget(),
GL_TEXTURE_MAX_LEVEL, mNumMipmaps);
// Set some misc default parameters so NVidia won't complain, these can of course be changed later
mGLSupport.getStateCacheManager()->setTexParameteri(getGLTextureTarget(), GL_TEXTURE_MIN_FILTER, GL_NEAREST);
mGLSupport.getStateCacheManager()->setTexParameteri(getGLTextureTarget(), GL_TEXTURE_MAG_FILTER, GL_NEAREST);
if (GLEW_VERSION_1_2)
{
mGLSupport.getStateCacheManager()->setTexParameteri(getGLTextureTarget(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
mGLSupport.getStateCacheManager()->setTexParameteri(getGLTextureTarget(), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
if((mUsage & TU_AUTOMIPMAP) &&
mNumRequestedMipmaps && mMipmapsHardwareGenerated)
{
mGLSupport.getStateCacheManager()->setTexParameteri( getGLTextureTarget(), GL_GENERATE_MIPMAP, GL_TRUE );
}
// Allocate internal buffer so that glTexSubImageXD can be used
// Internal format
GLenum format = GLPixelUtil::getClosestGLInternalFormat(mFormat, mHwGamma);
uint32 width = mWidth;
uint32 height = mHeight;
uint32 depth = mDepth;
if(PixelUtil::isCompressed(mFormat))
{
// Compressed formats
GLsizei size = static_cast<GLsizei>(PixelUtil::getMemorySize(mWidth, mHeight, mDepth, mFormat));
// Provide temporary buffer filled with zeroes as glCompressedTexImageXD does not
// accept a 0 pointer like normal glTexImageXD
// Run through this process for every mipmap to pregenerate mipmap piramid
uint8 *tmpdata = new uint8[size];
memset(tmpdata, 0, size);
for(uint8 mip=0; mip<=mNumMipmaps; mip++)
{
size = static_cast<GLsizei>(PixelUtil::getMemorySize(width, height, depth, mFormat));
switch(mTextureType)
{
case TEX_TYPE_1D:
glCompressedTexImage1DARB(GL_TEXTURE_1D, mip, format,
width, 0,
size, tmpdata);
break;
case TEX_TYPE_2D:
glCompressedTexImage2DARB(GL_TEXTURE_2D, mip, format,
width, height, 0,
size, tmpdata);
break;
case TEX_TYPE_2D_ARRAY:
case TEX_TYPE_3D:
glCompressedTexImage3DARB(getGLTextureTarget(), mip, format,
width, height, depth, 0,
size, tmpdata);
break;
case TEX_TYPE_CUBE_MAP:
for(int face=0; face<6; face++) {
glCompressedTexImage2DARB(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format,
width, height, 0,
size, tmpdata);
}
break;
case TEX_TYPE_2D_RECT:
break;
};
if(width>1)
width = width/2;
if(height>1)
height = height/2;
if(depth>1 && mTextureType != TEX_TYPE_2D_ARRAY)
depth = depth/2;
}
delete [] tmpdata;
}
else
{
// Run through this process to pregenerate mipmap pyramid
for(uint8 mip=0; mip<=mNumMipmaps; mip++)
{
// Normal formats
switch(mTextureType)
{
case TEX_TYPE_1D:
glTexImage1D(GL_TEXTURE_1D, mip, format,
width, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
break;
case TEX_TYPE_2D:
glTexImage2D(GL_TEXTURE_2D, mip, format,
width, height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
break;
case TEX_TYPE_2D_ARRAY:
case TEX_TYPE_3D:
glTexImage3D(getGLTextureTarget(), mip, format,
width, height, depth, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
break;
case TEX_TYPE_CUBE_MAP:
for(int face=0; face<6; face++) {
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format,
width, height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
}
break;
case TEX_TYPE_2D_RECT:
break;
};
if(width>1)
width = width/2;
if(height>1)
height = height/2;
if(depth>1 && mTextureType != TEX_TYPE_2D_ARRAY)
depth = depth/2;
}
}
_createSurfaceList();
// Get final internal format
mFormat = getBuffer(0,0)->getFormat();
}
// Creation / loading methods
void GL3PlusTexture::createInternalResourcesImpl(void)
{
// set HardwareBuffer::Usage for TU_RENDERTARGET if nothing else specified
if((mUsage & TU_RENDERTARGET) && (mUsage & ~TU_RENDERTARGET) == 0)
mUsage |= HardwareBuffer::HBU_DYNAMIC;
// Adjust format if required.
mFormat = TextureManager::getSingleton().getNativeFormat(mTextureType, mFormat, mUsage);
// Check requested number of mipmaps.
uint32 maxMips = getMaxMipmaps();
if (PixelUtil::isCompressed(mFormat) && (mNumMipmaps == 0))
mNumRequestedMipmaps = 0;
mNumMipmaps = mNumRequestedMipmaps;
if (mNumMipmaps > maxMips)
mNumMipmaps = maxMips;
// Create a texture object and identify its GL type.
OGRE_CHECK_GL_ERROR(glGenTextures(1, &mTextureID));
GLenum texTarget = getGL3PlusTextureTarget();
// Calculate size for all mip levels of the texture.
uint32 width, height, depth;
if ((mWidth * PixelUtil::getNumElemBytes(mFormat)) & 3) {
// Standard alignment of 4 is not right for some formats.
OGRE_CHECK_GL_ERROR(glPixelStorei(GL_UNPACK_ALIGNMENT, 1));
}
// Bind texture object to its type, making it the active texture object
// for that type.
mRenderSystem->_getStateCacheManager()->bindGLTexture( texTarget, mTextureID );
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_BASE_LEVEL, 0);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_MAX_LEVEL, mNumMipmaps);
// Set some misc default parameters, these can of course be changed later.
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget,
GL_TEXTURE_MIN_FILTER, GL_NEAREST);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget,
GL_TEXTURE_MAG_FILTER, GL_NEAREST);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget,
GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget,
GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// Set up texture swizzling.
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_R, GL_RED);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
if (PixelUtil::isLuminance(mFormat) && (mRenderSystem->hasMinGLVersion(3, 3) || mRenderSystem->checkExtension("GL_ARB_texture_swizzle")))
{
if (PixelUtil::getComponentCount(mFormat) == 2)
{
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_R, GL_RED);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_G, GL_RED);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_B, GL_RED);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_A, GL_GREEN);
}
else
{
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_R, GL_RED);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_G, GL_RED);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_B, GL_RED);
mRenderSystem->_getStateCacheManager()->setTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_A, GL_ONE);
}
}
GLenum format = GL3PlusPixelUtil::getGLInternalFormat(mFormat, mHwGamma);
GLenum datatype = GL3PlusPixelUtil::getGLOriginDataType(mFormat);
width = mWidth;
height = mHeight;
depth = mDepth;
// Allocate texture storage so that glTexSubImageXD can be
// used to upload the texture.
if (PixelUtil::isCompressed(mFormat))
{
// Compressed formats
GLsizei size;
for (uint32 mip = 0; mip <= mNumMipmaps; mip++)
{
size = static_cast<GLsizei>(PixelUtil::getMemorySize(width, height, depth, mFormat));
// std::stringstream str;
// str << "GL3PlusTexture::create - " << StringConverter::toString(mTextureID)
// << " bytes: " << StringConverter::toString(PixelUtil::getMemorySize(mWidth, mHeight, mDepth, mFormat))
// << " Mip: " + StringConverter::toString(mip)
// << " Width: " << StringConverter::toString(width)
// << " Height: " << StringConverter::toString(height)
// << " Format " << PixelUtil::getFormatName(mFormat)
// << " Internal Format: 0x" << std::hex << format
// << " Origin Format: 0x" << std::hex << GL3PlusPixelUtil::getGLOriginFormat(mFormat)
// << " Data type: 0x" << std::hex << datatype;
// LogManager::getSingleton().logMessage(LML_NORMAL, str.str());
switch(mTextureType)
{
case TEX_TYPE_1D:
OGRE_CHECK_GL_ERROR(glCompressedTexImage1D(GL_TEXTURE_1D, mip, format,
width, 0,
size, NULL));
break;
case TEX_TYPE_2D:
OGRE_CHECK_GL_ERROR(glCompressedTexImage2D(GL_TEXTURE_2D,
mip,
format,
width, height,
0,
size,
NULL));
break;
case TEX_TYPE_2D_RECT:
OGRE_CHECK_GL_ERROR(glCompressedTexImage2D(GL_TEXTURE_RECTANGLE,
mip,
format,
width, height,
0,
size,
NULL));
break;
case TEX_TYPE_2D_ARRAY:
case TEX_TYPE_3D:
OGRE_CHECK_GL_ERROR(glCompressedTexImage3D(texTarget, mip, format,
width, height, depth, 0,
size, NULL));
break;
case TEX_TYPE_CUBE_MAP:
for(int face = 0; face < 6; face++) {
OGRE_CHECK_GL_ERROR(glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format,
width, height, 0,
size, NULL));
}
break;
default:
break;
};
if (width > 1)
{
width = width / 2;
}
if (height > 1)
{
height = height / 2;
}
if (depth > 1 && mTextureType != TEX_TYPE_2D_ARRAY)
{
depth = depth / 2;
}
}
}
else
{
if (mRenderSystem->hasMinGLVersion(4, 2) || mRenderSystem->checkExtension("GL_ARB_texture_storage"))
{
switch(mTextureType)
{
case TEX_TYPE_1D:
OGRE_CHECK_GL_ERROR(glTexStorage1D(GL_TEXTURE_1D, GLsizei(mNumMipmaps+1), format, GLsizei(width)));
break;
case TEX_TYPE_2D:
case TEX_TYPE_2D_RECT:
OGRE_CHECK_GL_ERROR(glTexStorage2D(GL_TEXTURE_2D, GLsizei(mNumMipmaps+1), format, GLsizei(width), GLsizei(height)));
break;
case TEX_TYPE_CUBE_MAP:
OGRE_CHECK_GL_ERROR(glTexStorage2D(GL_TEXTURE_CUBE_MAP, GLsizei(mNumMipmaps+1), format, GLsizei(width), GLsizei(height)));
break;
case TEX_TYPE_2D_ARRAY:
OGRE_CHECK_GL_ERROR(glTexStorage3D(GL_TEXTURE_2D_ARRAY, GLsizei(mNumMipmaps+1), format, GLsizei(width), GLsizei(height), GLsizei(depth)));
break;
case TEX_TYPE_3D:
OGRE_CHECK_GL_ERROR(glTexStorage3D(GL_TEXTURE_3D, GLsizei(mNumMipmaps+1), format, GLsizei(width), GLsizei(height), GLsizei(depth)));
break;
}
}
else
{
GLenum originFormat = GL3PlusPixelUtil::getGLOriginFormat(mFormat);
// Run through this process to pregenerate mipmap pyramid
for(uint32 mip = 0; mip <= mNumMipmaps; mip++)
{
// std::stringstream str;
// str << "GL3PlusTexture::create - " << StringConverter::toString(mTextureID)
// << " bytes: " << StringConverter::toString(PixelUtil::getMemorySize(width, height, depth, mFormat))
// << " Mip: " + StringConverter::toString(mip)
// << " Width: " << StringConverter::toString(width)
// << " Height: " << StringConverter::toString(height)
// << " Format " << PixelUtil::getFormatName(mFormat)
// << " Internal Format: 0x" << std::hex << format
// << " Origin Format: 0x" << std::hex << GL3PlusPixelUtil::getGLOriginFormat(mFormat)
// << " Data type: 0x" << std::hex << datatype;
// LogManager::getSingleton().logMessage(LML_NORMAL, str.str());
// Normal formats
switch(mTextureType)
{
case TEX_TYPE_1D:
OGRE_CHECK_GL_ERROR(glTexImage1D(GL_TEXTURE_1D, mip, format,
width, 0,
originFormat, datatype, NULL));
break;
case TEX_TYPE_2D:
OGRE_CHECK_GL_ERROR(glTexImage2D(GL_TEXTURE_2D,
mip,
format,
width, height,
0,
originFormat,
datatype, NULL));
break;
case TEX_TYPE_2D_RECT:
OGRE_CHECK_GL_ERROR(glTexImage2D(GL_TEXTURE_RECTANGLE,
mip,
format,
width, height,
0,
originFormat,
datatype, NULL));
break;
case TEX_TYPE_3D:
case TEX_TYPE_2D_ARRAY:
OGRE_CHECK_GL_ERROR(glTexImage3D(texTarget, mip, format,
width, height, depth, 0,
originFormat, datatype, NULL));
break;
case TEX_TYPE_CUBE_MAP:
for(int face = 0; face < 6; face++) {
OGRE_CHECK_GL_ERROR(glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format,
width, height, 0,
originFormat, datatype, NULL));
}
break;
default:
break;
};
if (width > 1)
{
width = width / 2;
}
if (height > 1)
{
height = height / 2;
}
if (depth > 1 && mTextureType != TEX_TYPE_2D_ARRAY)
{
depth = depth / 2;
}
}
}
}
// Reset unpack alignment to defaults
OGRE_CHECK_GL_ERROR(glPixelStorei(GL_UNPACK_ALIGNMENT, 4));
_createSurfaceList();
// Generate mipmaps after all texture levels have been loaded
// This is required for compressed formats such as DXT
if (PixelUtil::isCompressed(mFormat) && mUsage & TU_AUTOMIPMAP)
{
OGRE_CHECK_GL_ERROR(glGenerateMipmap(getGL3PlusTextureTarget()));
}
// Get final internal format.
mFormat = getBuffer(0,0)->getFormat();
}
// Creation / loading methods
void GL3PlusTexture::createInternalResourcesImpl(void)
{
// Adjust format if required
mFormat = TextureManager::getSingleton().getNativeFormat(mTextureType, mFormat, mUsage);
// Check requested number of mipmaps
size_t maxMips = GL3PlusPixelUtil::getMaxMipmaps(mWidth, mHeight, mDepth, mFormat);
if(PixelUtil::isCompressed(mFormat) && (mNumMipmaps == 0))
mNumRequestedMipmaps = 0;
mNumMipmaps = mNumRequestedMipmaps;
if (mNumMipmaps > maxMips)
mNumMipmaps = maxMips;
// Generate texture name
OGRE_CHECK_GL_ERROR(glGenTextures(1, &mTextureID));
GLenum texTarget = getGL3PlusTextureTarget();
// Set texture type
OGRE_CHECK_GL_ERROR(glBindTexture(texTarget, mTextureID));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_BASE_LEVEL, 0));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_MAX_LEVEL, (mMipmapsHardwareGenerated && (mUsage & TU_AUTOMIPMAP)) ? maxMips : mNumMipmaps ));
// Set some misc default parameters, these can of course be changed later
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget,
GL_TEXTURE_MIN_FILTER, GL_NEAREST));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget,
GL_TEXTURE_MAG_FILTER, GL_NEAREST));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget,
GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget,
GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
// Set up texture swizzling
if(mGLSupport.checkExtension("GL_ARB_texture_swizzle") || gl3wIsSupported(3, 3))
{
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_R, GL_RED));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_G, GL_GREEN));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_B, GL_BLUE));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_A, GL_ALPHA));
if(mFormat == PF_BYTE_LA)
{
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_R, GL_RED));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_G, GL_RED));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_B, GL_RED));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_A, GL_GREEN));
}
else if(mFormat == PF_L8 || mFormat == PF_L16)
{
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_R, GL_RED));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_G, GL_RED));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_B, GL_RED));
OGRE_CHECK_GL_ERROR(glTexParameteri(texTarget, GL_TEXTURE_SWIZZLE_A, GL_RED));
}
}
// If we can do automip generation and the user desires this, do so
mMipmapsHardwareGenerated =
Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP);
// Allocate internal buffer so that glTexSubImageXD can be used
// Internal format
GLenum format = GL3PlusPixelUtil::getClosestGLInternalFormat(mFormat, mHwGamma);
GLenum datatype = GL3PlusPixelUtil::getGLOriginDataType(mFormat);
size_t width = mWidth;
size_t height = mHeight;
size_t depth = mDepth;
if (PixelUtil::isCompressed(mFormat))
{
// Compressed formats
size_t size = PixelUtil::getMemorySize(mWidth, mHeight, mDepth, mFormat);
// Provide temporary buffer filled with zeroes as glCompressedTexImageXD does not
// accept a 0 pointer like normal glTexImageXD
// Run through this process for every mipmap to pregenerate mipmap pyramid
uint8* tmpdata = new uint8[size];
memset(tmpdata, 0, size);
for (size_t mip = 0; mip <= mNumMipmaps; mip++)
{
size = PixelUtil::getMemorySize(width, height, depth, mFormat);
switch(mTextureType)
{
case TEX_TYPE_1D:
OGRE_CHECK_GL_ERROR(glCompressedTexImage1D(GL_TEXTURE_1D, mip, format,
width, 0,
size, tmpdata));
break;
case TEX_TYPE_2D:
OGRE_CHECK_GL_ERROR(glCompressedTexImage2D(GL_TEXTURE_2D,
mip,
format,
width, height,
0,
size,
tmpdata));
break;
case TEX_TYPE_2D_RECT:
OGRE_CHECK_GL_ERROR(glCompressedTexImage2D(GL_TEXTURE_RECTANGLE,
mip,
format,
width, height,
0,
size,
tmpdata));
break;
case TEX_TYPE_2D_ARRAY:
case TEX_TYPE_3D:
OGRE_CHECK_GL_ERROR(glCompressedTexImage3D(texTarget, mip, format,
width, height, depth, 0,
size, tmpdata));
break;
case TEX_TYPE_CUBE_MAP:
for(int face = 0; face < 6; face++) {
OGRE_CHECK_GL_ERROR(glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format,
width, height, 0,
size, tmpdata));
}
break;
default:
break;
};
// LogManager::getSingleton().logMessage("GL3PlusTexture::create - " + StringConverter::toString(mTextureID) +
// " Mip: " + StringConverter::toString(mip) +
// " Width: " + StringConverter::toString(width) +
// " Height: " + StringConverter::toString(height) +
// " Internal Format: " + StringConverter::toString(format)
// );
if(width > 1)
{
width = width / 2;
}
if(height > 1)
{
height = height / 2;
}
if(depth > 1)
{
depth = depth / 2;
}
}
delete [] tmpdata;
}
else
{
if((mGLSupport.checkExtension("GL_ARB_texture_storage") || gl3wIsSupported(4, 2)) && mTextureType == TEX_TYPE_2D)
{
OGRE_CHECK_GL_ERROR(glTexStorage2D(GL_TEXTURE_2D, GLint(mNumMipmaps+1), format, GLsizei(width), GLsizei(height)));
}
else
{
// Run through this process to pregenerate mipmap pyramid
for(size_t mip = 0; mip <= mNumMipmaps; mip++)
{
// Normal formats
switch(mTextureType)
{
case TEX_TYPE_1D:
OGRE_CHECK_GL_ERROR(glTexImage1D(GL_TEXTURE_1D, mip, format,
width, 0,
GL_RGBA, datatype, 0));
break;
case TEX_TYPE_2D:
OGRE_CHECK_GL_ERROR(glTexImage2D(GL_TEXTURE_2D,
mip,
format,
width, height,
0,
GL3PlusPixelUtil::getGLOriginFormat(mFormat),
datatype, 0));
break;
case TEX_TYPE_2D_RECT:
OGRE_CHECK_GL_ERROR(glTexImage2D(GL_TEXTURE_RECTANGLE,
mip,
format,
width, height,
0,
GL3PlusPixelUtil::getGLOriginFormat(mFormat),
datatype, 0));
break;
case TEX_TYPE_3D:
case TEX_TYPE_2D_ARRAY:
OGRE_CHECK_GL_ERROR(glTexImage3D(texTarget, mip, format,
width, height, depth, 0,
GL_RGBA, datatype, 0));
break;
case TEX_TYPE_CUBE_MAP:
for(int face = 0; face < 6; face++) {
OGRE_CHECK_GL_ERROR(glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format,
width, height, 0,
GL3PlusPixelUtil::getGLOriginFormat(mFormat), datatype, 0));
}
break;
default:
break;
};
if (width > 1)
{
width = width / 2;
}
if (height > 1)
{
height = height / 2;
}
if (depth > 1)
{
depth = depth / 2;
}
}
}
}
_createSurfaceList();
// Get final internal format
mFormat = getBuffer(0,0)->getFormat();
}
// Creation / loading methods
void GLES2Texture::createInternalResourcesImpl(void)
{
// Convert to nearest power-of-two size if required
mWidth = GLES2PixelUtil::optionalPO2(mWidth);
mHeight = GLES2PixelUtil::optionalPO2(mHeight);
mDepth = GLES2PixelUtil::optionalPO2(mDepth);
// Adjust format if required
mFormat = TextureManager::getSingleton().getNativeFormat(mTextureType, mFormat, mUsage);
// Check requested number of mipmaps
size_t maxMips = GLES2PixelUtil::getMaxMipmaps(mWidth, mHeight, mDepth, mFormat);
if(PixelUtil::isCompressed(mFormat) && (mNumMipmaps == 0))
mNumRequestedMipmaps = 0;
mNumMipmaps = mNumRequestedMipmaps;
if (mNumMipmaps > maxMips)
mNumMipmaps = maxMips;
// Generate texture name
glGenTextures(1, &mTextureID);
GL_CHECK_ERROR;
// Set texture type
glBindTexture(getGLES2TextureTarget(), mTextureID);
GL_CHECK_ERROR;
// If we can do automip generation and the user desires this, do so
mMipmapsHardwareGenerated =
Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP) && !PixelUtil::isCompressed(mFormat);
#if GL_APPLE_texture_max_level && OGRE_PLATFORM != OGRE_PLATFORM_NACL
glTexParameteri( getGLES2TextureTarget(), GL_TEXTURE_MAX_LEVEL_APPLE, (mMipmapsHardwareGenerated && (mUsage & TU_AUTOMIPMAP)) ? maxMips : mNumMipmaps );
#endif
// Set some misc default parameters, these can of course be changed later
glTexParameteri(getGLES2TextureTarget(),
GL_TEXTURE_MIN_FILTER, GL_NEAREST);
GL_CHECK_ERROR;
glTexParameteri(getGLES2TextureTarget(),
GL_TEXTURE_MAG_FILTER, GL_NEAREST);
GL_CHECK_ERROR;
glTexParameteri(getGLES2TextureTarget(),
GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
GL_CHECK_ERROR;
glTexParameteri(getGLES2TextureTarget(),
GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
GL_CHECK_ERROR;
// Allocate internal buffer so that glTexSubImageXD can be used
// Internal format
GLenum format = GLES2PixelUtil::getGLOriginFormat(mFormat);
GLenum internalformat = GLES2PixelUtil::getClosestGLInternalFormat(mFormat, mHwGamma);
GLenum datatype = GLES2PixelUtil::getGLOriginDataType(mFormat);
size_t width = mWidth;
size_t height = mHeight;
size_t depth = mDepth;
if (PixelUtil::isCompressed(mFormat))
{
// Compressed formats
size_t size = PixelUtil::getMemorySize(mWidth, mHeight, mDepth, mFormat);
// Provide temporary buffer filled with zeroes as glCompressedTexImageXD does not
// accept a 0 pointer like normal glTexImageXD
// Run through this process for every mipmap to pregenerate mipmap pyramid
uint8* tmpdata = new uint8[size];
memset(tmpdata, 0, size);
for (size_t mip = 0; mip <= mNumMipmaps; mip++)
{
// LogManager::getSingleton().logMessage("GLES2Texture::create - Mip: " + StringConverter::toString(mip) +
// " Width: " + StringConverter::toString(width) +
// " Height: " + StringConverter::toString(height) +
// " Internal Format: " + StringConverter::toString(internalformat, 0, ' ', std::ios::hex) +
// " Format: " + StringConverter::toString(format, 0, ' ', std::ios::hex) +
// " Datatype: " + StringConverter::toString(datatype, 0, ' ', std::ios::hex)
// );
size = PixelUtil::getMemorySize(width, height, depth, mFormat);
switch(mTextureType)
{
case TEX_TYPE_1D:
case TEX_TYPE_2D:
glCompressedTexImage2D(GL_TEXTURE_2D,
mip,
internalformat,
width, height,
0,
size,
tmpdata);
GL_CHECK_ERROR;
break;
case TEX_TYPE_CUBE_MAP:
for(int face = 0; face < 6; face++) {
glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, internalformat,
width, height, 0,
size, tmpdata);
GL_CHECK_ERROR;
}
break;
case TEX_TYPE_3D:
default:
break;
};
if(width > 1)
{
width = width / 2;
}
if(height > 1)
{
height = height / 2;
}
if(depth > 1)
{
depth = depth / 2;
}
}
delete [] tmpdata;
}
else
{
// Run through this process to pregenerate mipmap pyramid
for(size_t mip = 0; mip <= mNumMipmaps; mip++)
{
// LogManager::getSingleton().logMessage("GLES2Texture::create - Mip: " + StringConverter::toString(mip) +
// " Name: " + mName +
// " ID: " + StringConverter::toString(mTextureID) +
// " Width: " + StringConverter::toString(width) +
// " Height: " + StringConverter::toString(height) +
// " Internal Format: " + StringConverter::toString(internalformat, 0, ' ', std::ios::hex) +
// " Format: " + StringConverter::toString(format, 0, ' ', std::ios::hex) +
// " Datatype: " + StringConverter::toString(datatype, 0, ' ', std::ios::hex)
// );
// Normal formats
switch(mTextureType)
{
case TEX_TYPE_1D:
case TEX_TYPE_2D:
#if OGRE_PLATFORM == OGRE_PLATFORM_NACL
if(internalformat != format)
{
LogManager::getSingleton().logMessage("glTexImage2D: format != internalFormat, "
"format=" + StringConverter::toString(format) +
", internalFormat=" + StringConverter::toString(internalformat));
}
#endif
glTexImage2D(GL_TEXTURE_2D,
mip,
internalformat,
width, height,
0,
format,
datatype, 0);
GL_CHECK_ERROR;
break;
case TEX_TYPE_CUBE_MAP:
for(int face = 0; face < 6; face++) {
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, internalformat,
width, height, 0,
format, datatype, 0);
}
break;
case TEX_TYPE_3D:
default:
break;
};
if (width > 1)
{
width = width / 2;
}
if (height > 1)
{
height = height / 2;
}
}
}
_createSurfaceList();
// Get final internal format
mFormat = getBuffer(0,0)->getFormat();
}
// Creation / loading methods
void GLESTexture::createInternalResourcesImpl(void)
{
// Convert to nearest power-of-two size if required
mWidth = GLESPixelUtil::optionalPO2(mWidth);
mHeight = GLESPixelUtil::optionalPO2(mHeight);
mDepth = GLESPixelUtil::optionalPO2(mDepth);
// Adjust format if required
mFormat = TextureManager::getSingleton().getNativeFormat(TEX_TYPE_2D, mFormat, mUsage);
// Check requested number of mipmaps
size_t maxMips = GLESPixelUtil::getMaxMipmaps(mWidth, mHeight, mDepth, mFormat);
if(PixelUtil::isCompressed(mFormat) && (mNumMipmaps == 0))
mNumRequestedMipmaps = 0;
mNumMipmaps = mNumRequestedMipmaps;
if (mNumMipmaps > maxMips)
mNumMipmaps = maxMips;
// Generate texture name
glGenTextures(1, &mTextureID);
GL_CHECK_ERROR;
// Set texture type
glBindTexture(GL_TEXTURE_2D, mTextureID);
GL_CHECK_ERROR;
// Set some misc default parameters, these can of course be changed later
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
GL_CHECK_ERROR;
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MAG_FILTER, GL_NEAREST);
GL_CHECK_ERROR;
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
GL_CHECK_ERROR;
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
GL_CHECK_ERROR;
// If we can do automip generation and the user desires this, do so
mMipmapsHardwareGenerated =
Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP) && !PixelUtil::isCompressed(mFormat);
if ((mUsage & TU_AUTOMIPMAP) &&
mNumRequestedMipmaps && mMipmapsHardwareGenerated)
{
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
GL_CHECK_ERROR;
}
// Allocate internal buffer so that glTexSubImageXD can be used
// Internal format
GLenum format = GLESPixelUtil::getClosestGLInternalFormat(mFormat, mHwGamma);
GLenum datatype = GLESPixelUtil::getGLOriginDataType(mFormat);
size_t width = mWidth;
size_t height = mHeight;
size_t depth = mDepth;
if (PixelUtil::isCompressed(mFormat))
{
// Compressed formats
size_t size = PixelUtil::getMemorySize(mWidth, mHeight, mDepth, mFormat);
// Provide temporary buffer filled with zeroes as glCompressedTexImageXD does not
// accept a 0 pointer like normal glTexImageXD
// Run through this process for every mipmap to pregenerate mipmap pyramid
uint8* tmpdata = new uint8[size];
memset(tmpdata, 0, size);
for (size_t mip = 0; mip <= mNumMipmaps; mip++)
{
size = PixelUtil::getMemorySize(width, height, depth, mFormat);
glCompressedTexImage2D(GL_TEXTURE_2D,
mip,
format,
width, height,
0,
size,
tmpdata);
GL_CHECK_ERROR;
// LogManager::getSingleton().logMessage("GLESTexture::create - Mip: " + StringConverter::toString(mip) +
// " Width: " + StringConverter::toString(width) +
// " Height: " + StringConverter::toString(height) +
// " Internal Format: " + StringConverter::toString(format)
// );
if(width > 1)
{
width = width / 2;
}
if(height > 1)
{
height = height / 2;
}
if(depth > 1)
{
depth = depth / 2;
}
}
delete [] tmpdata;
}
else
{
// Run through this process to pregenerate mipmap pyramid
for(size_t mip = 0; mip <= mNumMipmaps; mip++)
{
glTexImage2D(GL_TEXTURE_2D,
mip,
format,
width, height,
0,
format,
datatype, 0);
GL_CHECK_ERROR;
if (width > 1)
{
width = width / 2;
}
if (height > 1)
{
height = height / 2;
}
}
}
_createSurfaceList();
// Get final internal format
mFormat = getBuffer(0,0)->getFormat();
}
//* Creation / loading methods ********************************************
void GLTexture::createInternalResourcesImpl(void)
{
// Convert to nearest power-of-two size if required
mWidth = GLPixelUtil::optionalPO2(mWidth);
mHeight = GLPixelUtil::optionalPO2(mHeight);
mDepth = GLPixelUtil::optionalPO2(mDepth);
// Adjust format if required
mFormat = TextureManager::getSingleton().getNativeFormat(mTextureType, mFormat, mUsage);
// Check requested number of mipmaps
size_t maxMips = GLPixelUtil::getMaxMipmaps(mWidth, mHeight, mDepth, mFormat);
mNumMipmaps = mNumRequestedMipmaps;
if(mNumMipmaps>maxMips)
mNumMipmaps = maxMips;
// Generate texture name
glGenTextures( 1, &mTextureID );
// Set texture type
glBindTexture( getGLTextureTarget(), mTextureID );
// This needs to be set otherwise the texture doesn't get rendered
glTexParameteri( getGLTextureTarget(), GL_TEXTURE_MAX_LEVEL, mNumMipmaps );
// Set some misc default parameters so NVidia won't complain, these can of course be changed later
glTexParameteri(getGLTextureTarget(), GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(getGLTextureTarget(), GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(getGLTextureTarget(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(getGLTextureTarget(), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
// If we can do automip generation and the user desires this, do so
mMipmapsHardwareGenerated =
Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP);
if((mUsage & TU_AUTOMIPMAP) &&
mNumRequestedMipmaps && mMipmapsHardwareGenerated)
{
glTexParameteri( getGLTextureTarget(), GL_GENERATE_MIPMAP, GL_TRUE );
}
// Allocate internal buffer so that glTexSubImageXD can be used
// Internal format
GLenum format = GLPixelUtil::getClosestGLInternalFormat(mFormat);
size_t width = mWidth;
size_t height = mHeight;
size_t depth = mDepth;
if(PixelUtil::isCompressed(mFormat))
{
// Compressed formats
size_t size = PixelUtil::getMemorySize(mWidth, mHeight, mDepth, mFormat);
// Provide temporary buffer filled with zeroes as glCompressedTexImageXD does not
// accept a 0 pointer like normal glTexImageXD
// Run through this process for every mipmap to pregenerate mipmap piramid
uint8 *tmpdata = new uint8[size];
memset(tmpdata, 0, size);
for(size_t mip=0; mip<=mNumMipmaps; mip++)
{
size = PixelUtil::getMemorySize(width, height, depth, mFormat);
switch(mTextureType)
{
case TEX_TYPE_1D:
glCompressedTexImage1DARB(GL_TEXTURE_1D, mip, format,
width, 0,
size, tmpdata);
break;
case TEX_TYPE_2D:
glCompressedTexImage2DARB(GL_TEXTURE_2D, mip, format,
width, height, 0,
size, tmpdata);
break;
case TEX_TYPE_3D:
glCompressedTexImage3DARB(GL_TEXTURE_3D, mip, format,
width, height, depth, 0,
size, tmpdata);
break;
case TEX_TYPE_CUBE_MAP:
for(int face=0; face<6; face++) {
glCompressedTexImage2DARB(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format,
width, height, 0,
size, tmpdata);
}
break;
};
if(width>1) width = width/2;
if(height>1) height = height/2;
if(depth>1) depth = depth/2;
}
delete [] tmpdata;
}
else
{
// Run through this process to pregenerate mipmap piramid
for(size_t mip=0; mip<=mNumMipmaps; mip++)
{
// Normal formats
switch(mTextureType)
{
case TEX_TYPE_1D:
glTexImage1D(GL_TEXTURE_1D, mip, format,
width, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
break;
case TEX_TYPE_2D:
glTexImage2D(GL_TEXTURE_2D, mip, format,
width, height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
break;
case TEX_TYPE_3D:
glTexImage3D(GL_TEXTURE_3D, mip, format,
width, height, depth, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
break;
case TEX_TYPE_CUBE_MAP:
for(int face=0; face<6; face++) {
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, format,
width, height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, 0);
}
break;
};
if(width>1) width = width/2;
if(height>1) height = height/2;
if(depth>1) depth = depth/2;
}
}
_createSurfaceList();
// Get final internal format
mFormat = getBuffer(0,0)->getFormat();
}
