mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-19 20:24:49 +00:00
3aef90a6bc
GBitmap Changes: Added all other formats to gbitmap that we support gbitmap now supports cubemaps added converters for all these other formats added stb_image_resize for extrudemips so we can extrude mipmaps for all other formats GFXTextureManager Can now directly make cubemaps and texture arrays based on the GFXTextureProfile API implementations for all functions that cubemaps and arrays needed
580 lines
22 KiB
C++
580 lines
22 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2012 GarageGames, LLC
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "platform/platform.h"
|
|
#include "gfx/gl/gfxGLTextureManager.h"
|
|
#include "gfx/gl/gfxGLEnumTranslate.h"
|
|
#include "gfx/gfxCardProfile.h"
|
|
#include "core/util/safeDelete.h"
|
|
#include "gfx/gl/gfxGLUtils.h"
|
|
|
|
#include <squish.h>
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor
|
|
//-----------------------------------------------------------------------------
|
|
GFXGLTextureManager::GFXGLTextureManager()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Destructor
|
|
//-----------------------------------------------------------------------------
|
|
GFXGLTextureManager::~GFXGLTextureManager()
|
|
{
|
|
SAFE_DELETE_ARRAY( mHashTable );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// createTexture
|
|
//-----------------------------------------------------------------------------
|
|
GFXTextureObject *GFXGLTextureManager::_createTextureObject( U32 height,
|
|
U32 width,
|
|
U32 depth,
|
|
GFXFormat format,
|
|
GFXTextureProfile *profile,
|
|
U32 numMipLevels,
|
|
bool forceMips,
|
|
S32 antialiasLevel,
|
|
U32 arraySize,
|
|
GFXTextureObject *inTex )
|
|
{
|
|
AssertFatal(format >= 0 && format < GFXFormat_COUNT, "GFXGLTextureManager::_createTexture - invalid format!");
|
|
|
|
GFXGLTextureObject *retTex;
|
|
if ( inTex )
|
|
{
|
|
AssertFatal( dynamic_cast<GFXGLTextureObject*>( inTex ), "GFXGLTextureManager::_createTexture() - Bad inTex type!" );
|
|
retTex = static_cast<GFXGLTextureObject*>( inTex );
|
|
retTex->release();
|
|
retTex->reInit();
|
|
}
|
|
else
|
|
{
|
|
retTex = new GFXGLTextureObject( GFX, profile );
|
|
retTex->registerResourceWithDevice( GFX );
|
|
}
|
|
|
|
innerCreateTexture(retTex, height, width, depth, format, profile, numMipLevels, forceMips, arraySize);
|
|
|
|
return retTex;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// innerCreateTexture
|
|
//-----------------------------------------------------------------------------
|
|
// This just creates the texture, no info is actually loaded to it. We do that later.
|
|
void GFXGLTextureManager::innerCreateTexture( GFXGLTextureObject *retTex,
|
|
U32 height,
|
|
U32 width,
|
|
U32 depth,
|
|
GFXFormat format,
|
|
GFXTextureProfile *profile,
|
|
U32 numMipLevels,
|
|
bool forceMips,
|
|
U32 arraySize)
|
|
{
|
|
// No 24 bit formats. They trigger various oddities because hardware (and Apple's drivers apparently...) don't natively support them.
|
|
if (format == GFXFormatR8G8B8)
|
|
format = GFXFormatR8G8B8A8;
|
|
else if (format == GFXFormatR8G8B8_SRGB)
|
|
format = GFXFormatR8G8B8A8_SRGB;
|
|
|
|
retTex->mProfile = profile;
|
|
retTex->mFormat = format;
|
|
retTex->mIsZombie = false;
|
|
retTex->mIsNPoT2 = false;
|
|
|
|
const bool isCube = profile->isCubeMap();
|
|
GLenum binding;
|
|
|
|
if (isCube)
|
|
{
|
|
binding = (arraySize > 1) ? GL_TEXTURE_CUBE_MAP_ARRAY : GL_TEXTURE_CUBE_MAP;
|
|
}
|
|
else
|
|
{
|
|
const bool is3D = (depth > 1);
|
|
const bool is1D = (height == 1 && width > 1);
|
|
|
|
if (is3D)
|
|
binding = GL_TEXTURE_3D;
|
|
else if (is1D)
|
|
binding = (arraySize > 1) ? GL_TEXTURE_1D_ARRAY : GL_TEXTURE_1D;
|
|
else
|
|
binding = (arraySize > 1) ? GL_TEXTURE_2D_ARRAY : GL_TEXTURE_2D;
|
|
}
|
|
|
|
if((profile->testFlag(GFXTextureProfile::RenderTarget) || profile->testFlag(GFXTextureProfile::ZTarget)) && (!isPow2(width) || !isPow2(height)) && !depth)
|
|
retTex->mIsNPoT2 = true;
|
|
retTex->mBinding = binding;
|
|
|
|
// Bind it
|
|
PRESERVE_TEXTURE(binding);
|
|
glBindTexture(retTex->getBinding(), retTex->getHandle());
|
|
|
|
// Create it
|
|
// @todo OPENGL - Creating mipmaps for compressed formats. Not supported on OpenGL ES and bugged on AMD. We use mipmaps present on file.
|
|
if( forceMips && !retTex->mIsNPoT2 && !ImageUtil::isCompressedFormat(format) )
|
|
{
|
|
retTex->mMipLevels = numMipLevels > 1 ? numMipLevels : 0;
|
|
}
|
|
else if(profile->testFlag(GFXTextureProfile::NoMipmap) || numMipLevels == 1)
|
|
{
|
|
retTex->mMipLevels = 1;
|
|
}
|
|
else if (profile->testFlag(GFXTextureProfile::RenderTarget))
|
|
{
|
|
if (numMipLevels == 0) //auto
|
|
numMipLevels = mFloor(mLog2(mMax(width, height))) + 1;
|
|
else if (numMipLevels > 1) //capped
|
|
numMipLevels = mMin(numMipLevels, mFloor(mLog2(mMax(width, height))) + 1);
|
|
retTex->mMipLevels = mClampF(numMipLevels, 1, 13);
|
|
}
|
|
else
|
|
{
|
|
retTex->mMipLevels = numMipLevels;
|
|
}
|
|
|
|
// @todo OPENGL - OpenGL ES2 not support mipmaps on NPOT textures
|
|
#if 0
|
|
if(!retTex->mIsNPoT2)
|
|
{
|
|
if(!isPow2(width))
|
|
width = getNextPow2(width);
|
|
if(!isPow2(height))
|
|
height = getNextPow2(height);
|
|
if(depth && !isPow2(depth))
|
|
depth = getNextPow2(depth);
|
|
}
|
|
#endif
|
|
|
|
AssertFatal(GFXGLTextureInternalFormat[format] != GL_ZERO, "GFXGLTextureManager::innerCreateTexture - invalid internal format");
|
|
AssertFatal(GFXGLTextureFormat[format] != GL_ZERO, "GFXGLTextureManager::innerCreateTexture - invalid format");
|
|
AssertFatal(GFXGLTextureType[format] != GL_ZERO, "GFXGLTextureManager::innerCreateTexture - invalid type");
|
|
|
|
//calculate num mipmaps
|
|
if(retTex->mMipLevels == 0)
|
|
retTex->mMipLevels = getMaxMipmaps(width, height, 1);
|
|
|
|
glTexParameteri(binding, GL_TEXTURE_MAX_LEVEL, retTex->mMipLevels-1 );
|
|
|
|
bool hasTexStorage = false;
|
|
// not supported when creating these.
|
|
if (arraySize > 1 || isCube || profile->isDynamic())
|
|
hasTexStorage = false;
|
|
|
|
const bool isCompressed = ImageUtil::isCompressedFormat(format);
|
|
|
|
// --- Allocation by binding ---
|
|
if (binding == GL_TEXTURE_CUBE_MAP)
|
|
{
|
|
// Single cubemap: prefer glTexStorage2D if available, else per-face texImage2D
|
|
if (hasTexStorage)
|
|
{
|
|
// Some drivers accept texStorage2D with GL_TEXTURE_CUBE_MAP
|
|
glTexStorage2D(GL_TEXTURE_CUBE_MAP, retTex->mMipLevels, GFXGLTextureInternalFormat[format], width, height);
|
|
}
|
|
else
|
|
{
|
|
// Explicitly allocate each face/level
|
|
for (U32 face = 0; face < 6; ++face)
|
|
{
|
|
for (U32 mip = 0; mip < retTex->mMipLevels; ++mip)
|
|
{
|
|
U32 mipW = getMax(1u, width >> mip);
|
|
U32 mipH = getMax(1u, height >> mip);
|
|
|
|
if (isCompressed)
|
|
{
|
|
U32 size = getCompressedSurfaceSize(format, width, height, mip);
|
|
glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, GFXGLTextureInternalFormat[format], mipW, mipH, 0, size, nullptr);
|
|
}
|
|
else
|
|
{
|
|
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mip, GFXGLTextureInternalFormat[format], mipW, mipH, 0, GFXGLTextureFormat[format], GFXGLTextureType[format], nullptr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (binding == GL_TEXTURE_CUBE_MAP_ARRAY)
|
|
{
|
|
// cube-map array: layers = arraySize * 6
|
|
U32 layers = getMax(1u, arraySize) * 6u;
|
|
if (hasTexStorage)
|
|
{
|
|
glTexStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, retTex->mMipLevels, GFXGLTextureInternalFormat[format], width, height, layers);
|
|
}
|
|
else
|
|
{
|
|
// fallback to glTexImage3D with NULL data
|
|
for (U32 mip = 0; mip < retTex->mMipLevels; ++mip)
|
|
{
|
|
U32 mipW = getMax(1u, width >> mip);
|
|
U32 mipH = getMax(1u, height >> mip);
|
|
glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, mip, GFXGLTextureInternalFormat[format], mipW, mipH, layers, 0, GFXGLTextureFormat[format], GFXGLTextureType[format], NULL);
|
|
}
|
|
}
|
|
}
|
|
else if (binding == GL_TEXTURE_2D_ARRAY)
|
|
{
|
|
// 2D texture array: depth = arraySize (layers)
|
|
U32 layers = getMax(1u, arraySize);
|
|
if (hasTexStorage)
|
|
{
|
|
glTexStorage3D(GL_TEXTURE_2D_ARRAY, retTex->mMipLevels, GFXGLTextureInternalFormat[format], width, height, layers);
|
|
}
|
|
else
|
|
{
|
|
for (U32 mip = 0; mip < retTex->mMipLevels; ++mip)
|
|
{
|
|
U32 mipW = getMax(1u, width >> mip);
|
|
U32 mipH = getMax(1u, height >> mip);
|
|
glTexImage3D(GL_TEXTURE_2D_ARRAY, mip, GFXGLTextureInternalFormat[format], mipW, mipH, layers, 0, GFXGLTextureFormat[format], GFXGLTextureType[format], NULL);
|
|
}
|
|
}
|
|
}
|
|
else if (binding == GL_TEXTURE_1D_ARRAY)
|
|
{
|
|
// 1D array stored as GL_TEXTURE_1D_ARRAY. glTexStorage2D can be used for 1D arrays with height=layers on many drivers.
|
|
U32 layers = getMax(1u, arraySize);
|
|
if (hasTexStorage)
|
|
{
|
|
// glTexStorage2D works for GL_TEXTURE_1D_ARRAY (width, layers)
|
|
glTexStorage2D(GL_TEXTURE_1D_ARRAY, retTex->mMipLevels, GFXGLTextureInternalFormat[format], getMax(width, height), layers);
|
|
}
|
|
else
|
|
{
|
|
// fallback: allocate as 2D where the "height" dimension is layers via glTexImage2D? Not ideal.
|
|
// Safer: use glTexImage2D with target GL_TEXTURE_1D_ARRAY is invalid; instead use glTexImage3D with depth=layers
|
|
for (U32 mip = 0; mip < retTex->mMipLevels; ++mip)
|
|
{
|
|
U32 mipW = getMax(1u, getMax(width, height) >> mip);
|
|
glTexImage3D(GL_TEXTURE_1D_ARRAY, mip, GFXGLTextureInternalFormat[format], mipW, layers, 1, 0, GFXGLTextureFormat[format], GFXGLTextureType[format], NULL);
|
|
}
|
|
}
|
|
}
|
|
else if (binding == GL_TEXTURE_1D)
|
|
{
|
|
if (hasTexStorage)
|
|
glTexStorage1D(GL_TEXTURE_1D, retTex->mMipLevels, GFXGLTextureInternalFormat[format], getMax(width, height));
|
|
else
|
|
{
|
|
for (U32 mip = 0; mip < retTex->mMipLevels; ++mip)
|
|
{
|
|
U32 mipW = getMax(1u, getMax(width, height) >> mip);
|
|
glTexImage1D(GL_TEXTURE_1D, mip, GFXGLTextureInternalFormat[format], mipW, 0, GFXGLTextureFormat[format], GFXGLTextureType[format], NULL);
|
|
}
|
|
}
|
|
}
|
|
else if (binding == GL_TEXTURE_3D)
|
|
{
|
|
if (hasTexStorage)
|
|
glTexStorage3D(GL_TEXTURE_3D, retTex->mMipLevels, GFXGLTextureInternalFormat[format], width, height, depth);
|
|
else
|
|
{
|
|
for (U32 mip = 0; mip < retTex->mMipLevels; ++mip)
|
|
{
|
|
U32 mipW = getMax(1u, width >> mip);
|
|
U32 mipH = getMax(1u, height >> mip);
|
|
U32 mipD = getMax(1u, depth >> mip);
|
|
glTexImage3D(GL_TEXTURE_3D, mip, GFXGLTextureInternalFormat[format], mipW, mipH, mipD, 0, GFXGLTextureFormat[format], GFXGLTextureType[format], NULL);
|
|
}
|
|
}
|
|
}
|
|
else // GL_TEXTURE_2D (default)
|
|
{
|
|
if (hasTexStorage)
|
|
glTexStorage2D(GL_TEXTURE_2D, retTex->mMipLevels, GFXGLTextureInternalFormat[format], width, height);
|
|
else
|
|
{
|
|
for (U32 mip = 0; mip < retTex->mMipLevels; ++mip)
|
|
{
|
|
U32 mipW = getMax(1u, width >> mip);
|
|
U32 mipH = getMax(1u, height >> mip);
|
|
|
|
if (isCompressed)
|
|
{
|
|
U32 size = getCompressedSurfaceSize(format, width, height, mip);
|
|
glCompressedTexImage2D(GL_TEXTURE_2D, mip, GFXGLTextureInternalFormat[format], mipW, mipH, 0, size, nullptr);
|
|
}
|
|
else
|
|
{
|
|
glTexImage2D(GL_TEXTURE_2D, mip, GFXGLTextureInternalFormat[format], mipW, mipH, 0, GFXGLTextureFormat[format], GFXGLTextureType[format], NULL);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Complete the texture
|
|
// Complete the texture - this does get changed later but we need to complete the texture anyway
|
|
|
|
if(retTex->mMipLevels == 1)
|
|
glTexParameteri(binding, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
else
|
|
glTexParameteri(binding, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
|
|
glTexParameteri(binding, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexParameteri(binding, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTexParameteri(binding, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
if(binding == GL_TEXTURE_3D)
|
|
glTexParameteri(binding, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
|
|
|
|
if(GFXGLTextureSwizzle[format])
|
|
glTexParameteriv(binding, GL_TEXTURE_SWIZZLE_RGBA, GFXGLTextureSwizzle[format]);
|
|
|
|
GLint texHeight = 0, texWidth = 0, texDepth = 0;
|
|
|
|
GLenum queryTarget = binding;
|
|
if (binding == GL_TEXTURE_CUBE_MAP)
|
|
{
|
|
// Query a specific face, e.g. +X
|
|
queryTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
|
|
}
|
|
|
|
glGetTexLevelParameteriv(queryTarget, 0, GL_TEXTURE_WIDTH, &texWidth);
|
|
glGetTexLevelParameteriv(queryTarget, 0, GL_TEXTURE_HEIGHT, &texHeight);
|
|
if (binding == GL_TEXTURE_3D)
|
|
glGetTexLevelParameteriv(GL_TEXTURE_3D, 0, GL_TEXTURE_DEPTH, &texDepth);
|
|
|
|
retTex->mTextureSize.set(texWidth, texHeight, texDepth);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// loadTexture - GBitmap
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static void _textureUpload(const S32 width, const S32 height,const S32 bytesPerPixel,const GFXGLTextureObject* texture, const GFXFormat fmt, const U8* data,const S32 mip=0, const U32 face = 0, Swizzle<U8, 4> *pSwizzle = NULL)
|
|
{
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, texture->getBuffer());
|
|
U32 bufSize = width * height * bytesPerPixel;
|
|
glBufferData(GL_PIXEL_UNPACK_BUFFER, bufSize, NULL, GL_STREAM_DRAW);
|
|
|
|
if(pSwizzle)
|
|
{
|
|
PROFILE_SCOPE(Swizzle32_Upload);
|
|
U8* pboMemory = (U8*)dMalloc(bufSize);
|
|
pSwizzle->ToBuffer(pboMemory, data, bufSize);
|
|
glBufferSubData(GL_PIXEL_UNPACK_BUFFER, 0, bufSize, pboMemory);
|
|
dFree(pboMemory);
|
|
}
|
|
else
|
|
{
|
|
PROFILE_SCOPE(SwizzleNull_Upload);
|
|
glBufferSubData(GL_PIXEL_UNPACK_BUFFER, 0, bufSize, data);
|
|
}
|
|
|
|
if(texture->getBinding() == GL_TEXTURE_CUBE_MAP)
|
|
glTexSubImage2D(GFXGLFaceType[face], mip, 0, 0, width, height, GFXGLTextureFormat[fmt], GFXGLTextureType[fmt], NULL);
|
|
else if (texture->getBinding() == GL_TEXTURE_2D)
|
|
glTexSubImage2D(texture->getBinding(), mip, 0, 0, width, height, GFXGLTextureFormat[fmt], GFXGLTextureType[fmt], NULL);
|
|
else
|
|
glTexSubImage1D(texture->getBinding(), mip, 0, (width > 1 ? width : height), GFXGLTextureFormat[fmt], GFXGLTextureType[fmt], NULL);
|
|
|
|
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
|
|
}
|
|
|
|
bool GFXGLTextureManager::_loadTexture(GFXTextureObject *aTexture, GBitmap *pDL)
|
|
{
|
|
PROFILE_SCOPE(GFXGLTextureManager_loadTextureGBitmap);
|
|
GFXGLTextureObject *texture = static_cast<GFXGLTextureObject*>(aTexture);
|
|
|
|
const GLenum target = texture->getBinding();
|
|
|
|
AssertFatal(target == GL_TEXTURE_1D || target == GL_TEXTURE_2D || target == GL_TEXTURE_CUBE_MAP,
|
|
"GFXGLTextureManager::_loadTexture(GBitmap) - This method can only be used with 1D/2D and CubeMap textures");
|
|
|
|
if(texture->getBinding() == GL_TEXTURE_3D)
|
|
return false;
|
|
//
|
|
//// No 24bit formats.
|
|
//if(pDL->getFormat() == GFXFormatR8G8B8)
|
|
// pDL->setFormat(GFXFormatR8G8B8A8);
|
|
//else if (pDL->getFormat() == GFXFormatR8G8B8_SRGB)
|
|
// pDL->setFormat(GFXFormatR8G8B8A8_SRGB);
|
|
|
|
// Bind to edit
|
|
PRESERVE_TEXTURE(texture->getBinding());
|
|
glBindTexture(texture->getBinding(), texture->getHandle());
|
|
|
|
const U32 mipLevels = texture->getMipLevels();
|
|
const bool isCubemap = (target == GL_TEXTURE_CUBE_MAP) && pDL->getNumFaces() > 1;
|
|
U32 faceCount = isCubemap ? 6 : 1;
|
|
|
|
for (U32 mip = 0; mip < mipLevels; mip++)
|
|
{
|
|
const GLsizei width = getMax(1u, pDL->getWidth(mip));
|
|
const GLsizei height = getMax(1u, pDL->getHeight(mip));
|
|
for (U32 face = 0; face < faceCount; ++face)
|
|
{
|
|
_textureUpload(width, height, pDL->getBytesPerPixel(), texture, pDL->getFormat(), pDL->getBits(mip,face), mip, face);
|
|
}
|
|
}
|
|
|
|
if(!ImageUtil::isCompressedFormat(pDL->getFormat()))
|
|
glGenerateMipmap(texture->getBinding());
|
|
|
|
glBindTexture(target, 0);
|
|
return true;
|
|
}
|
|
|
|
bool GFXGLTextureManager::_loadTexture(GFXTextureObject *aTexture, DDSFile *dds)
|
|
{
|
|
PROFILE_SCOPE(GFXGLTextureManager_loadTextureDDS);
|
|
GFXGLTextureObject* texture = static_cast<GFXGLTextureObject*>(aTexture);
|
|
|
|
const GLenum target = texture->getBinding();
|
|
|
|
const bool isCube = texture->getBinding() == GL_TEXTURE_CUBE_MAP && dds->isCubemap();
|
|
const bool isCompressed = ImageUtil::isCompressedFormat(texture->mFormat);
|
|
|
|
AssertFatal(target == GL_TEXTURE_1D || target == GL_TEXTURE_2D || target == GL_TEXTURE_CUBE_MAP,
|
|
"GFXGLTextureManager::_loadTexture(DDS) - This method can only be used with 1D/2D and CubeMap textures");
|
|
|
|
if (texture->getBinding() == GL_TEXTURE_3D)
|
|
return false;
|
|
|
|
PRESERVE_TEXTURE(target);
|
|
glBindTexture(target, texture->getHandle());
|
|
|
|
const U32 numFaces = isCube ? 6 : 1;
|
|
const U32 numMips = dds->mSurfaces[0]->mMips.size();
|
|
const GFXFormat fmt = texture->mFormat;
|
|
|
|
for (U32 face = 0; face < numFaces; ++face)
|
|
{
|
|
// Skip empty surfaces
|
|
if (!dds->mSurfaces[face])
|
|
continue;
|
|
|
|
for (U32 mip = 0; mip < numMips; ++mip)
|
|
{
|
|
const U32 mipWidth = getMax(1u, dds->getWidth(mip));
|
|
const U32 mipHeight = getMax(1u, dds->getHeight(mip));
|
|
|
|
GLenum uploadTarget = target;
|
|
if (isCube)
|
|
uploadTarget = GFXGLFaceType[face];
|
|
|
|
if (isCompressed)
|
|
{
|
|
// Handle NPOT workaround
|
|
if ((!isPow2(mipWidth) || !isPow2(mipHeight)) && GFX->getCardProfiler()->queryProfile("GL::Workaround::noCompressedNPoTTextures"))
|
|
{
|
|
U8* uncompressedTex = new U8[mipWidth * mipHeight * 4];
|
|
ImageUtil::decompress(dds->mSurfaces[face]->mMips[mip], uncompressedTex, mipWidth, mipHeight, fmt);
|
|
glTexSubImage2D(uploadTarget,
|
|
mip, 0, 0, mipWidth, mipHeight, GL_RGBA, GL_UNSIGNED_BYTE, uncompressedTex
|
|
);
|
|
delete[] uncompressedTex;
|
|
}
|
|
else
|
|
{
|
|
glCompressedTexImage2D(uploadTarget,
|
|
mip, GFXGLTextureInternalFormat[fmt], mipWidth, mipHeight, 0,
|
|
dds->getSurfaceSize(mip), dds->mSurfaces[face]->mMips[mip]
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Swizzle<U8, 4>* pSwizzle = nullptr;
|
|
if (fmt == GFXFormatR8G8B8A8 || fmt == GFXFormatR8G8B8X8 || fmt == GFXFormatR8G8B8A8_SRGB ||
|
|
fmt == GFXFormatR8G8B8A8_LINEAR_FORCE || fmt == GFXFormatB8G8R8A8)
|
|
pSwizzle = &Swizzles::bgra;
|
|
|
|
_textureUpload(
|
|
mipWidth, mipHeight, dds->mBytesPerPixel, texture, fmt,
|
|
dds->mSurfaces[face]->mMips[mip], mip, face, pSwizzle);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if (numMips != 1 && !isCompressed)
|
|
glGenerateMipmap(texture->getBinding());
|
|
|
|
glBindTexture(target, 0);
|
|
return true;
|
|
}
|
|
|
|
bool GFXGLTextureManager::_loadTexture(GFXTextureObject *aTexture, void *raw)
|
|
{
|
|
PROFILE_SCOPE(GFXGLTextureManager_loadTextureRaw);
|
|
if(aTexture->getDepth() < 1)
|
|
return false;
|
|
|
|
GFXGLTextureObject* texture = static_cast<GFXGLTextureObject*>(aTexture);
|
|
|
|
PRESERVE_3D_TEXTURE();
|
|
glBindTexture(texture->getBinding(), texture->getHandle());
|
|
glTexSubImage3D(GL_TEXTURE_3D, 0, 0, 0, 0, texture->getWidth(), texture->getHeight(), texture->getDepth(), GFXGLTextureFormat[texture->mFormat], GFXGLTextureType[texture->mFormat], raw);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool GFXGLTextureManager::_freeTexture(GFXTextureObject *texture, bool zombify /*= false*/)
|
|
{
|
|
if(zombify)
|
|
static_cast<GFXGLTextureObject*>(texture)->zombify();
|
|
else
|
|
static_cast<GFXGLTextureObject*>(texture)->release();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool GFXGLTextureManager::_refreshTexture(GFXTextureObject *texture)
|
|
{
|
|
U32 usedStrategies = 0;
|
|
GFXGLTextureObject* realTex = static_cast<GFXGLTextureObject*>(texture);
|
|
|
|
if(texture->mProfile->doStoreBitmap())
|
|
{
|
|
if(realTex->isZombie())
|
|
{
|
|
realTex->resurrect();
|
|
innerCreateTexture(realTex, texture->getHeight(), texture->getWidth(), texture->getDepth(), texture->mFormat, texture->mProfile, texture->mMipLevels);
|
|
}
|
|
if(texture->mBitmap)
|
|
_loadTexture(texture, texture->mBitmap);
|
|
|
|
if(texture->mDDS)
|
|
return false;
|
|
|
|
usedStrategies++;
|
|
}
|
|
|
|
if(texture->mProfile->isRenderTarget() || texture->mProfile->isDynamic() || texture->mProfile->isZTarget() || !usedStrategies)
|
|
{
|
|
realTex->release();
|
|
realTex->resurrect();
|
|
innerCreateTexture(realTex, texture->getHeight(), texture->getWidth(), texture->getDepth(), texture->mFormat, texture->mProfile, texture->mMipLevels);
|
|
realTex->reloadFromCache();
|
|
usedStrategies++;
|
|
}
|
|
|
|
AssertFatal(usedStrategies < 2, "GFXGLTextureManager::_refreshTexture - Inconsistent profile flags (store bitmap and dynamic/target");
|
|
|
|
return true;
|
|
}
|