[5] | 1 | /* |
---|
| 2 | ----------------------------------------------------------------------------- |
---|
| 3 | This source file is part of OGRE |
---|
| 4 | (Object-oriented Graphics Rendering Engine) |
---|
| 5 | For the latest info, see http://www.ogre3d.org/ |
---|
| 6 | |
---|
| 7 | Copyright (c) 2000-2006 Torus Knot Software Ltd |
---|
| 8 | Also see acknowledgements in Readme.html |
---|
| 9 | |
---|
| 10 | This program is free software; you can redistribute it and/or modify it under |
---|
| 11 | the terms of the GNU Lesser General Public License as published by the Free Software |
---|
| 12 | Foundation; either version 2 of the License, or (at your option) any later |
---|
| 13 | version. |
---|
| 14 | |
---|
| 15 | This program is distributed in the hope that it will be useful, but WITHOUT |
---|
| 16 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
---|
| 17 | FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. |
---|
| 18 | |
---|
| 19 | You should have received a copy of the GNU Lesser General Public License along with |
---|
| 20 | this program; if not, write to the Free Software Foundation, Inc., 59 Temple |
---|
| 21 | Place - Suite 330, Boston, MA 02111-1307, USA, or go to |
---|
| 22 | http://www.gnu.org/copyleft/lesser.txt. |
---|
| 23 | |
---|
| 24 | You may alternatively use this source under the terms of a specific version of |
---|
| 25 | the OGRE Unrestricted License provided you have obtained such a license from |
---|
| 26 | Torus Knot Software Ltd. |
---|
| 27 | ----------------------------------------------------------------------------- |
---|
| 28 | */ |
---|
| 29 | #include "OgreStableHeaders.h" |
---|
| 30 | #include "OgreImage.h" |
---|
| 31 | #include "OgreArchiveManager.h" |
---|
| 32 | #include "OgreException.h" |
---|
| 33 | #include "OgreImageCodec.h" |
---|
| 34 | #include "OgreColourValue.h" |
---|
| 35 | |
---|
| 36 | #include "OgreImageResampler.h" |
---|
| 37 | |
---|
| 38 | namespace Ogre { |
---|
| 39 | ImageCodec::~ImageCodec() { |
---|
| 40 | } |
---|
| 41 | |
---|
| 42 | //----------------------------------------------------------------------------- |
---|
| 43 | Image::Image() |
---|
| 44 | : m_uWidth(0), |
---|
| 45 | m_uHeight(0), |
---|
| 46 | m_uDepth(0), |
---|
| 47 | m_uSize(0), |
---|
| 48 | m_uNumMipmaps(0), |
---|
| 49 | m_uFlags(0), |
---|
| 50 | m_pBuffer( NULL ), |
---|
| 51 | m_bAutoDelete( true ) |
---|
| 52 | { |
---|
| 53 | } |
---|
| 54 | |
---|
| 55 | //----------------------------------------------------------------------------- |
---|
| 56 | Image::Image( const Image &img ) |
---|
| 57 | : m_pBuffer( NULL ), |
---|
| 58 | m_bAutoDelete( true ) |
---|
| 59 | { |
---|
| 60 | // call assignment operator |
---|
| 61 | *this = img; |
---|
| 62 | } |
---|
| 63 | |
---|
| 64 | //----------------------------------------------------------------------------- |
---|
| 65 | Image::~Image() |
---|
| 66 | { |
---|
| 67 | //Only delete if this was not a dynamic image (meaning app holds & destroys buffer) |
---|
| 68 | if( m_pBuffer && m_bAutoDelete ) |
---|
| 69 | { |
---|
| 70 | delete[] m_pBuffer; |
---|
| 71 | m_pBuffer = NULL; |
---|
| 72 | } |
---|
| 73 | } |
---|
| 74 | |
---|
| 75 | //----------------------------------------------------------------------------- |
---|
| 76 | Image & Image::operator = ( const Image &img ) |
---|
| 77 | { |
---|
| 78 | if( m_pBuffer && m_bAutoDelete ) |
---|
| 79 | { |
---|
| 80 | delete[] m_pBuffer; |
---|
| 81 | m_pBuffer = NULL; |
---|
| 82 | } |
---|
| 83 | m_uWidth = img.m_uWidth; |
---|
| 84 | m_uHeight = img.m_uHeight; |
---|
| 85 | m_uDepth = img.m_uDepth; |
---|
| 86 | m_eFormat = img.m_eFormat; |
---|
| 87 | m_uSize = img.m_uSize; |
---|
| 88 | m_uFlags = img.m_uFlags; |
---|
| 89 | m_ucPixelSize = img.m_ucPixelSize; |
---|
| 90 | m_uNumMipmaps = img.m_uNumMipmaps; |
---|
| 91 | m_bAutoDelete = img.m_bAutoDelete; |
---|
| 92 | //Only create/copy when previous data was not dynamic data |
---|
| 93 | if( m_bAutoDelete ) |
---|
| 94 | { |
---|
| 95 | m_pBuffer = new uchar[ m_uSize ]; |
---|
| 96 | memcpy( m_pBuffer, img.m_pBuffer, m_uSize ); |
---|
| 97 | } |
---|
| 98 | else |
---|
| 99 | { |
---|
| 100 | m_pBuffer = img.m_pBuffer; |
---|
| 101 | } |
---|
| 102 | |
---|
| 103 | return *this; |
---|
| 104 | } |
---|
| 105 | |
---|
| 106 | //----------------------------------------------------------------------------- |
---|
| 107 | Image & Image::flipAroundY() |
---|
| 108 | { |
---|
| 109 | if( !m_pBuffer ) |
---|
| 110 | { |
---|
| 111 | OGRE_EXCEPT( |
---|
| 112 | Exception::ERR_INTERNAL_ERROR, |
---|
| 113 | "Can not flip an unitialized texture", |
---|
| 114 | "Image::flipAroundY" ); |
---|
| 115 | } |
---|
| 116 | |
---|
| 117 | m_uNumMipmaps = 0; // Image operations lose precomputed mipmaps |
---|
| 118 | |
---|
| 119 | uchar *pTempBuffer1 = NULL; |
---|
| 120 | ushort *pTempBuffer2 = NULL; |
---|
| 121 | uchar *pTempBuffer3 = NULL; |
---|
| 122 | uint *pTempBuffer4 = NULL; |
---|
| 123 | |
---|
| 124 | uchar *src1 = m_pBuffer, *dst1 = NULL; |
---|
| 125 | ushort *src2 = (ushort *)m_pBuffer, *dst2 = NULL; |
---|
| 126 | uchar *src3 = m_pBuffer, *dst3 = NULL; |
---|
| 127 | uint *src4 = (uint *)m_pBuffer, *dst4 = NULL; |
---|
| 128 | |
---|
| 129 | ushort y; |
---|
| 130 | switch (m_ucPixelSize) |
---|
| 131 | { |
---|
| 132 | case 1: |
---|
| 133 | pTempBuffer1 = new uchar[m_uWidth * m_uHeight]; |
---|
| 134 | for (y = 0; y < m_uHeight; y++) |
---|
| 135 | { |
---|
| 136 | dst1 = (pTempBuffer1 + ((y * m_uWidth) + m_uWidth - 1)); |
---|
| 137 | for (ushort x = 0; x < m_uWidth; x++) |
---|
| 138 | memcpy(dst1--, src1++, sizeof(uchar)); |
---|
| 139 | } |
---|
| 140 | |
---|
| 141 | memcpy(m_pBuffer, pTempBuffer1, m_uWidth * m_uHeight * sizeof(uchar)); |
---|
| 142 | delete [] pTempBuffer1; |
---|
| 143 | break; |
---|
| 144 | |
---|
| 145 | case 2: |
---|
| 146 | pTempBuffer2 = new ushort[m_uWidth * m_uHeight]; |
---|
| 147 | for (y = 0; y < m_uHeight; y++) |
---|
| 148 | { |
---|
| 149 | dst2 = (pTempBuffer2 + ((y * m_uWidth) + m_uWidth - 1)); |
---|
| 150 | for (ushort x = 0; x < m_uWidth; x++) |
---|
| 151 | memcpy(dst2--, src2++, sizeof(ushort)); |
---|
| 152 | } |
---|
| 153 | |
---|
| 154 | memcpy(m_pBuffer, pTempBuffer2, m_uWidth * m_uHeight * sizeof(ushort)); |
---|
| 155 | delete [] pTempBuffer2; |
---|
| 156 | break; |
---|
| 157 | |
---|
| 158 | case 3: |
---|
| 159 | pTempBuffer3 = new uchar[m_uWidth * m_uHeight * 3]; |
---|
| 160 | for (y = 0; y < m_uHeight; y++) |
---|
| 161 | { |
---|
| 162 | size_t offset = ((y * m_uWidth) + (m_uWidth - 1)) * 3; |
---|
| 163 | dst3 = pTempBuffer3; |
---|
| 164 | dst3 += offset; |
---|
| 165 | for (size_t x = 0; x < m_uWidth; x++) |
---|
| 166 | { |
---|
| 167 | memcpy(dst3, src3, sizeof(uchar) * 3); |
---|
| 168 | dst3 -= 3; src3 += 3; |
---|
| 169 | } |
---|
| 170 | } |
---|
| 171 | |
---|
| 172 | memcpy(m_pBuffer, pTempBuffer3, m_uWidth * m_uHeight * sizeof(uchar) * 3); |
---|
| 173 | delete [] pTempBuffer3; |
---|
| 174 | break; |
---|
| 175 | |
---|
| 176 | case 4: |
---|
| 177 | pTempBuffer4 = new uint[m_uWidth * m_uHeight]; |
---|
| 178 | for (y = 0; y < m_uHeight; y++) |
---|
| 179 | { |
---|
| 180 | dst4 = (pTempBuffer4 + ((y * m_uWidth) + m_uWidth - 1)); |
---|
| 181 | for (ushort x = 0; x < m_uWidth; x++) |
---|
| 182 | memcpy(dst4--, src4++, sizeof(uint)); |
---|
| 183 | } |
---|
| 184 | |
---|
| 185 | memcpy(m_pBuffer, pTempBuffer4, m_uWidth * m_uHeight * sizeof(uint)); |
---|
| 186 | delete [] pTempBuffer4; |
---|
| 187 | break; |
---|
| 188 | |
---|
| 189 | default: |
---|
| 190 | OGRE_EXCEPT( |
---|
| 191 | Exception::ERR_INTERNAL_ERROR, |
---|
| 192 | "Unknown pixel depth", |
---|
| 193 | "Image::flipAroundY" ); |
---|
| 194 | break; |
---|
| 195 | } |
---|
| 196 | |
---|
| 197 | return *this; |
---|
| 198 | |
---|
| 199 | } |
---|
| 200 | |
---|
| 201 | //----------------------------------------------------------------------------- |
---|
| 202 | Image & Image::flipAroundX() |
---|
| 203 | { |
---|
| 204 | if( !m_pBuffer ) |
---|
| 205 | { |
---|
| 206 | OGRE_EXCEPT( |
---|
| 207 | Exception::ERR_INTERNAL_ERROR, |
---|
| 208 | "Can not flip an unitialized texture", |
---|
| 209 | "Image::flipAroundX" ); |
---|
| 210 | } |
---|
| 211 | |
---|
| 212 | m_uNumMipmaps = 0; // Image operations lose precomputed mipmaps |
---|
| 213 | |
---|
| 214 | size_t rowSpan = m_uWidth * m_ucPixelSize; |
---|
| 215 | |
---|
| 216 | uchar *pTempBuffer = new uchar[ rowSpan * m_uHeight ]; |
---|
| 217 | uchar *ptr1 = m_pBuffer, *ptr2 = pTempBuffer + ( ( m_uHeight - 1 ) * rowSpan ); |
---|
| 218 | |
---|
| 219 | for( ushort i = 0; i < m_uHeight; i++ ) |
---|
| 220 | { |
---|
| 221 | memcpy( ptr2, ptr1, rowSpan ); |
---|
| 222 | ptr1 += rowSpan; ptr2 -= rowSpan; |
---|
| 223 | } |
---|
| 224 | |
---|
| 225 | memcpy( m_pBuffer, pTempBuffer, rowSpan * m_uHeight); |
---|
| 226 | |
---|
| 227 | delete [] pTempBuffer; |
---|
| 228 | |
---|
| 229 | return *this; |
---|
| 230 | } |
---|
| 231 | |
---|
| 232 | //----------------------------------------------------------------------------- |
---|
| 233 | Image& Image::loadDynamicImage( uchar* pData, size_t uWidth, size_t uHeight, |
---|
| 234 | size_t depth, |
---|
| 235 | PixelFormat eFormat, bool autoDelete, |
---|
| 236 | size_t numFaces, size_t numMipMaps) |
---|
| 237 | { |
---|
| 238 | |
---|
| 239 | if( m_pBuffer && m_bAutoDelete ) |
---|
| 240 | { |
---|
| 241 | delete[] m_pBuffer; |
---|
| 242 | m_pBuffer = NULL; |
---|
| 243 | } |
---|
| 244 | // Set image metadata |
---|
| 245 | m_uWidth = uWidth; |
---|
| 246 | m_uHeight = uHeight; |
---|
| 247 | m_uDepth = depth; |
---|
| 248 | m_eFormat = eFormat; |
---|
| 249 | m_ucPixelSize = static_cast<uchar>(PixelUtil::getNumElemBytes( m_eFormat )); |
---|
| 250 | m_uNumMipmaps = numMipMaps; |
---|
| 251 | m_uFlags = 0; |
---|
| 252 | // Set flags |
---|
| 253 | if (PixelUtil::isCompressed(eFormat)) |
---|
| 254 | m_uFlags |= IF_COMPRESSED; |
---|
| 255 | if (m_uDepth != 1) |
---|
| 256 | m_uFlags |= IF_3D_TEXTURE; |
---|
| 257 | if(numFaces == 6) |
---|
| 258 | m_uFlags |= IF_CUBEMAP; |
---|
| 259 | if(numFaces != 6 && numFaces != 1) |
---|
| 260 | OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, |
---|
| 261 | "Number of faces currently must be 6 or 1.", |
---|
| 262 | "Image::loadDynamicImage"); |
---|
| 263 | |
---|
| 264 | m_uSize = calculateSize(numMipMaps, numFaces, uWidth, uHeight, depth, eFormat); |
---|
| 265 | m_pBuffer = pData; |
---|
| 266 | m_bAutoDelete = autoDelete; |
---|
| 267 | |
---|
| 268 | return *this; |
---|
| 269 | |
---|
| 270 | } |
---|
| 271 | |
---|
| 272 | //----------------------------------------------------------------------------- |
---|
| 273 | Image & Image::loadRawData( |
---|
| 274 | DataStreamPtr& stream, |
---|
| 275 | size_t uWidth, size_t uHeight, size_t uDepth, |
---|
| 276 | PixelFormat eFormat, |
---|
| 277 | size_t numFaces, size_t numMipMaps) |
---|
| 278 | { |
---|
| 279 | |
---|
| 280 | size_t size = calculateSize(numMipMaps, numFaces, uWidth, uHeight, uDepth, eFormat); |
---|
| 281 | if (size != stream->size()) |
---|
| 282 | { |
---|
| 283 | OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, |
---|
| 284 | "Stream size does not match calculated image size", |
---|
| 285 | "Image::loadRawData"); |
---|
| 286 | } |
---|
| 287 | |
---|
| 288 | uchar *buffer = new uchar[ size ]; |
---|
| 289 | stream->read(buffer, size); |
---|
| 290 | |
---|
| 291 | return loadDynamicImage(buffer, |
---|
| 292 | uWidth, uHeight, uDepth, |
---|
| 293 | eFormat, true, numFaces, numMipMaps); |
---|
| 294 | |
---|
| 295 | } |
---|
| 296 | |
---|
| 297 | //----------------------------------------------------------------------------- |
---|
| 298 | Image & Image::load(const String& strFileName, const String& group) |
---|
| 299 | { |
---|
| 300 | |
---|
| 301 | if( m_pBuffer && m_bAutoDelete ) |
---|
| 302 | { |
---|
| 303 | delete[] m_pBuffer; |
---|
| 304 | m_pBuffer = NULL; |
---|
| 305 | } |
---|
| 306 | |
---|
| 307 | String strExt; |
---|
| 308 | |
---|
| 309 | size_t pos = strFileName.find_last_of("."); |
---|
| 310 | if( pos == String::npos ) |
---|
| 311 | OGRE_EXCEPT( |
---|
| 312 | Exception::ERR_INVALIDPARAMS, |
---|
| 313 | "Unable to load image file '" + strFileName + "' - invalid extension.", |
---|
| 314 | "Image::load" ); |
---|
| 315 | |
---|
| 316 | while( pos != strFileName.length() - 1 ) |
---|
| 317 | strExt += strFileName[++pos]; |
---|
| 318 | |
---|
| 319 | Codec * pCodec = Codec::getCodec(strExt); |
---|
| 320 | if( !pCodec ) |
---|
| 321 | OGRE_EXCEPT( |
---|
| 322 | Exception::ERR_INVALIDPARAMS, |
---|
| 323 | "Unable to load image file '" + strFileName + "' - invalid extension.", |
---|
| 324 | "Image::load" ); |
---|
| 325 | |
---|
| 326 | DataStreamPtr encoded = |
---|
| 327 | ResourceGroupManager::getSingleton().openResource(strFileName, group); |
---|
| 328 | |
---|
| 329 | Codec::DecodeResult res = pCodec->decode(encoded); |
---|
| 330 | |
---|
| 331 | ImageCodec::ImageData* pData = |
---|
| 332 | static_cast<ImageCodec::ImageData*>(res.second.getPointer()); |
---|
| 333 | |
---|
| 334 | // Get the format and compute the pixel size |
---|
| 335 | m_uWidth = pData->width; |
---|
| 336 | m_uHeight = pData->height; |
---|
| 337 | m_uDepth = pData->depth; |
---|
| 338 | m_uSize = pData->size; |
---|
| 339 | m_eFormat = pData->format; |
---|
| 340 | m_uNumMipmaps = pData->num_mipmaps; |
---|
| 341 | m_ucPixelSize = static_cast<uchar>(PixelUtil::getNumElemBytes( m_eFormat )); |
---|
| 342 | m_uFlags = pData->flags; |
---|
| 343 | |
---|
| 344 | // re-use the decoded buffer |
---|
| 345 | m_pBuffer = res.first->getPtr(); |
---|
| 346 | // ensure we don't delete when stream is closed |
---|
| 347 | res.first->setFreeOnClose(false); |
---|
| 348 | |
---|
| 349 | return *this; |
---|
| 350 | |
---|
| 351 | } |
---|
| 352 | //----------------------------------------------------------------------------- |
---|
| 353 | void Image::save(const String& filename) |
---|
| 354 | { |
---|
| 355 | if( !m_pBuffer ) |
---|
| 356 | { |
---|
| 357 | OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "No image data loaded", |
---|
| 358 | "Image::save"); |
---|
| 359 | } |
---|
| 360 | |
---|
| 361 | String strExt; |
---|
| 362 | size_t pos = filename.find_last_of("."); |
---|
| 363 | if( pos == String::npos ) |
---|
| 364 | OGRE_EXCEPT( |
---|
| 365 | Exception::ERR_INVALIDPARAMS, |
---|
| 366 | "Unable to save image file '" + filename + "' - invalid extension.", |
---|
| 367 | "Image::save" ); |
---|
| 368 | |
---|
| 369 | while( pos != filename.length() - 1 ) |
---|
| 370 | strExt += filename[++pos]; |
---|
| 371 | |
---|
| 372 | Codec * pCodec = Codec::getCodec(strExt); |
---|
| 373 | if( !pCodec ) |
---|
| 374 | OGRE_EXCEPT( |
---|
| 375 | Exception::ERR_INVALIDPARAMS, |
---|
| 376 | "Unable to save image file '" + filename + "' - invalid extension.", |
---|
| 377 | "Image::save" ); |
---|
| 378 | |
---|
| 379 | ImageCodec::ImageData* imgData = new ImageCodec::ImageData(); |
---|
| 380 | imgData->format = m_eFormat; |
---|
| 381 | imgData->height = m_uHeight; |
---|
| 382 | imgData->width = m_uWidth; |
---|
| 383 | imgData->depth = m_uDepth; |
---|
| 384 | // Wrap in CodecDataPtr, this will delete |
---|
| 385 | Codec::CodecDataPtr codeDataPtr(imgData); |
---|
| 386 | // Wrap memory, be sure not to delete when stream destroyed |
---|
| 387 | MemoryDataStreamPtr wrapper(new MemoryDataStream(m_pBuffer, m_uSize, false)); |
---|
| 388 | |
---|
| 389 | pCodec->codeToFile(wrapper, filename, codeDataPtr); |
---|
| 390 | } |
---|
| 391 | //----------------------------------------------------------------------------- |
---|
| 392 | Image & Image::load(DataStreamPtr& stream, const String& type ) |
---|
| 393 | { |
---|
| 394 | if( m_pBuffer && m_bAutoDelete ) |
---|
| 395 | { |
---|
| 396 | delete[] m_pBuffer; |
---|
| 397 | m_pBuffer = NULL; |
---|
| 398 | } |
---|
| 399 | |
---|
| 400 | String strType = type; |
---|
| 401 | |
---|
| 402 | Codec * pCodec = Codec::getCodec(strType); |
---|
| 403 | if( !pCodec ) |
---|
| 404 | OGRE_EXCEPT( |
---|
| 405 | Exception::ERR_INVALIDPARAMS, |
---|
| 406 | "Unable to load image - invalid extension.", |
---|
| 407 | "Image::load" ); |
---|
| 408 | |
---|
| 409 | Codec::DecodeResult res = pCodec->decode(stream); |
---|
| 410 | |
---|
| 411 | ImageCodec::ImageData* pData = |
---|
| 412 | static_cast<ImageCodec::ImageData*>(res.second.getPointer()); |
---|
| 413 | |
---|
| 414 | m_uWidth = pData->width; |
---|
| 415 | m_uHeight = pData->height; |
---|
| 416 | m_uDepth = pData->depth; |
---|
| 417 | m_uSize = pData->size; |
---|
| 418 | m_uNumMipmaps = pData->num_mipmaps; |
---|
| 419 | m_uFlags = pData->flags; |
---|
| 420 | |
---|
| 421 | // Get the format and compute the pixel size |
---|
| 422 | m_eFormat = pData->format; |
---|
| 423 | m_ucPixelSize = static_cast<uchar>(PixelUtil::getNumElemBytes( m_eFormat )); |
---|
| 424 | // Just use internal buffer of returned memory stream |
---|
| 425 | m_pBuffer = res.first->getPtr(); |
---|
| 426 | // Make sure stream does not delete |
---|
| 427 | res.first->setFreeOnClose(false); |
---|
| 428 | |
---|
| 429 | return *this; |
---|
| 430 | } |
---|
| 431 | |
---|
| 432 | //----------------------------------------------------------------------------- |
---|
| 433 | uchar* Image::getData() |
---|
| 434 | { |
---|
| 435 | return m_pBuffer; |
---|
| 436 | } |
---|
| 437 | |
---|
| 438 | //----------------------------------------------------------------------------- |
---|
| 439 | const uchar* Image::getData() const |
---|
| 440 | { |
---|
| 441 | assert( m_pBuffer ); |
---|
| 442 | return m_pBuffer; |
---|
| 443 | } |
---|
| 444 | |
---|
| 445 | //----------------------------------------------------------------------------- |
---|
| 446 | size_t Image::getSize() const |
---|
| 447 | { |
---|
| 448 | return m_uSize; |
---|
| 449 | } |
---|
| 450 | |
---|
| 451 | //----------------------------------------------------------------------------- |
---|
| 452 | size_t Image::getNumMipmaps() const |
---|
| 453 | { |
---|
| 454 | return m_uNumMipmaps; |
---|
| 455 | } |
---|
| 456 | |
---|
| 457 | //----------------------------------------------------------------------------- |
---|
| 458 | bool Image::hasFlag(const ImageFlags imgFlag) const |
---|
| 459 | { |
---|
| 460 | if(m_uFlags & imgFlag) |
---|
| 461 | { |
---|
| 462 | return true; |
---|
| 463 | } |
---|
| 464 | else |
---|
| 465 | { |
---|
| 466 | return false; |
---|
| 467 | } |
---|
| 468 | } |
---|
| 469 | |
---|
| 470 | //----------------------------------------------------------------------------- |
---|
| 471 | size_t Image::getDepth() const |
---|
| 472 | { |
---|
| 473 | return m_uDepth; |
---|
| 474 | } |
---|
| 475 | //----------------------------------------------------------------------------- |
---|
| 476 | size_t Image::getWidth() const |
---|
| 477 | { |
---|
| 478 | return m_uWidth; |
---|
| 479 | } |
---|
| 480 | |
---|
| 481 | //----------------------------------------------------------------------------- |
---|
| 482 | size_t Image::getHeight() const |
---|
| 483 | { |
---|
| 484 | return m_uHeight; |
---|
| 485 | } |
---|
| 486 | //----------------------------------------------------------------------------- |
---|
| 487 | size_t Image::getNumFaces(void) const |
---|
| 488 | { |
---|
| 489 | if(hasFlag(IF_CUBEMAP)) |
---|
| 490 | return 6; |
---|
| 491 | return 1; |
---|
| 492 | } |
---|
| 493 | //----------------------------------------------------------------------------- |
---|
| 494 | size_t Image::getRowSpan() const |
---|
| 495 | { |
---|
| 496 | return m_uWidth * m_ucPixelSize; |
---|
| 497 | } |
---|
| 498 | |
---|
| 499 | //----------------------------------------------------------------------------- |
---|
| 500 | PixelFormat Image::getFormat() const |
---|
| 501 | { |
---|
| 502 | return m_eFormat; |
---|
| 503 | } |
---|
| 504 | |
---|
| 505 | //----------------------------------------------------------------------------- |
---|
| 506 | uchar Image::getBPP() const |
---|
| 507 | { |
---|
| 508 | return m_ucPixelSize * 8; |
---|
| 509 | } |
---|
| 510 | |
---|
| 511 | //----------------------------------------------------------------------------- |
---|
| 512 | bool Image::getHasAlpha(void) const |
---|
| 513 | { |
---|
| 514 | return PixelUtil::getFlags(m_eFormat) & PFF_HASALPHA; |
---|
| 515 | } |
---|
| 516 | //----------------------------------------------------------------------------- |
---|
| 517 | void Image::applyGamma( unsigned char *buffer, Real gamma, size_t size, uchar bpp ) |
---|
| 518 | { |
---|
| 519 | if( gamma == 1.0f ) |
---|
| 520 | return; |
---|
| 521 | |
---|
| 522 | //NB only 24/32-bit supported |
---|
| 523 | if( bpp != 24 && bpp != 32 ) return; |
---|
| 524 | |
---|
| 525 | uint stride = bpp >> 3; |
---|
| 526 | |
---|
| 527 | for( size_t i = 0, j = size / stride; i < j; i++, buffer += stride ) |
---|
| 528 | { |
---|
| 529 | float r, g, b; |
---|
| 530 | |
---|
| 531 | r = (float)buffer[0]; |
---|
| 532 | g = (float)buffer[1]; |
---|
| 533 | b = (float)buffer[2]; |
---|
| 534 | |
---|
| 535 | r = r * gamma; |
---|
| 536 | g = g * gamma; |
---|
| 537 | b = b * gamma; |
---|
| 538 | |
---|
| 539 | float scale = 1.0f, tmp; |
---|
| 540 | |
---|
| 541 | if( r > 255.0f && (tmp=(255.0f/r)) < scale ) |
---|
| 542 | scale = tmp; |
---|
| 543 | if( g > 255.0f && (tmp=(255.0f/g)) < scale ) |
---|
| 544 | scale = tmp; |
---|
| 545 | if( b > 255.0f && (tmp=(255.0f/b)) < scale ) |
---|
| 546 | scale = tmp; |
---|
| 547 | |
---|
| 548 | r *= scale; g *= scale; b *= scale; |
---|
| 549 | |
---|
| 550 | buffer[0] = (uchar)r; |
---|
| 551 | buffer[1] = (uchar)g; |
---|
| 552 | buffer[2] = (uchar)b; |
---|
| 553 | } |
---|
| 554 | } |
---|
| 555 | //----------------------------------------------------------------------------- |
---|
| 556 | void Image::resize(ushort width, ushort height, Filter filter) |
---|
| 557 | { |
---|
| 558 | // resizing dynamic images is not supported |
---|
| 559 | assert(m_bAutoDelete); |
---|
| 560 | assert(m_uDepth == 1); |
---|
| 561 | |
---|
| 562 | // reassign buffer to temp image, make sure auto-delete is true |
---|
| 563 | Image temp; |
---|
| 564 | temp.loadDynamicImage(m_pBuffer, m_uWidth, m_uHeight, 1, m_eFormat, true); |
---|
| 565 | // do not delete[] m_pBuffer! temp will destroy it |
---|
| 566 | |
---|
| 567 | // set new dimensions, allocate new buffer |
---|
| 568 | m_uWidth = width; |
---|
| 569 | m_uHeight = height; |
---|
| 570 | m_uSize = PixelUtil::getMemorySize(m_uWidth, m_uHeight, 1, m_eFormat); |
---|
| 571 | m_pBuffer = new uchar[m_uSize]; |
---|
| 572 | m_uNumMipmaps = 0; // Loses precomputed mipmaps |
---|
| 573 | |
---|
| 574 | // scale the image from temp into our resized buffer |
---|
| 575 | Image::scale(temp.getPixelBox(), getPixelBox(), filter); |
---|
| 576 | } |
---|
| 577 | //----------------------------------------------------------------------- |
---|
| 578 | void Image::scale(const PixelBox &src, const PixelBox &scaled, Filter filter) |
---|
| 579 | { |
---|
| 580 | assert(PixelUtil::isAccessible(src.format)); |
---|
| 581 | assert(PixelUtil::isAccessible(scaled.format)); |
---|
| 582 | MemoryDataStreamPtr buf; // For auto-delete |
---|
| 583 | PixelBox temp; |
---|
| 584 | switch (filter) |
---|
| 585 | { |
---|
| 586 | default: |
---|
| 587 | case FILTER_NEAREST: |
---|
| 588 | if(src.format == scaled.format) |
---|
| 589 | { |
---|
| 590 | // No intermediate buffer needed |
---|
| 591 | temp = scaled; |
---|
| 592 | } |
---|
| 593 | else |
---|
| 594 | { |
---|
| 595 | // Allocate temporary buffer of destination size in source format |
---|
| 596 | temp = PixelBox(scaled.getWidth(), scaled.getHeight(), scaled.getDepth(), src.format); |
---|
| 597 | buf.bind(new MemoryDataStream(temp.getConsecutiveSize())); |
---|
| 598 | temp.data = buf->getPtr(); |
---|
| 599 | } |
---|
| 600 | // super-optimized: no conversion |
---|
| 601 | switch (PixelUtil::getNumElemBytes(src.format)) |
---|
| 602 | { |
---|
| 603 | case 1: NearestResampler<1>::scale(src, temp); break; |
---|
| 604 | case 2: NearestResampler<2>::scale(src, temp); break; |
---|
| 605 | case 3: NearestResampler<3>::scale(src, temp); break; |
---|
| 606 | case 4: NearestResampler<4>::scale(src, temp); break; |
---|
| 607 | case 6: NearestResampler<6>::scale(src, temp); break; |
---|
| 608 | case 8: NearestResampler<8>::scale(src, temp); break; |
---|
| 609 | case 12: NearestResampler<12>::scale(src, temp); break; |
---|
| 610 | case 16: NearestResampler<16>::scale(src, temp); break; |
---|
| 611 | default: |
---|
| 612 | // never reached |
---|
| 613 | assert(false); |
---|
| 614 | } |
---|
| 615 | if(temp.data != scaled.data) |
---|
| 616 | { |
---|
| 617 | // Blit temp buffer |
---|
| 618 | PixelUtil::bulkPixelConversion(temp, scaled); |
---|
| 619 | } |
---|
| 620 | break; |
---|
| 621 | |
---|
| 622 | case FILTER_LINEAR: |
---|
| 623 | case FILTER_BILINEAR: |
---|
| 624 | switch (src.format) |
---|
| 625 | { |
---|
| 626 | case PF_L8: case PF_A8: case PF_BYTE_LA: |
---|
| 627 | case PF_R8G8B8: case PF_B8G8R8: |
---|
| 628 | case PF_R8G8B8A8: case PF_B8G8R8A8: |
---|
| 629 | case PF_A8B8G8R8: case PF_A8R8G8B8: |
---|
| 630 | case PF_X8B8G8R8: case PF_X8R8G8B8: |
---|
| 631 | if(src.format == scaled.format) |
---|
| 632 | { |
---|
| 633 | // No intermediate buffer needed |
---|
| 634 | temp = scaled; |
---|
| 635 | } |
---|
| 636 | else |
---|
| 637 | { |
---|
| 638 | // Allocate temp buffer of destination size in source format |
---|
| 639 | temp = PixelBox(scaled.getWidth(), scaled.getHeight(), scaled.getDepth(), src.format); |
---|
| 640 | buf.bind(new MemoryDataStream(temp.getConsecutiveSize())); |
---|
| 641 | temp.data = buf->getPtr(); |
---|
| 642 | } |
---|
| 643 | // super-optimized: byte-oriented math, no conversion |
---|
| 644 | switch (PixelUtil::getNumElemBytes(src.format)) |
---|
| 645 | { |
---|
| 646 | case 1: LinearResampler_Byte<1>::scale(src, temp); break; |
---|
| 647 | case 2: LinearResampler_Byte<2>::scale(src, temp); break; |
---|
| 648 | case 3: LinearResampler_Byte<3>::scale(src, temp); break; |
---|
| 649 | case 4: LinearResampler_Byte<4>::scale(src, temp); break; |
---|
| 650 | default: |
---|
| 651 | // never reached |
---|
| 652 | assert(false); |
---|
| 653 | } |
---|
| 654 | if(temp.data != scaled.data) |
---|
| 655 | { |
---|
| 656 | // Blit temp buffer |
---|
| 657 | PixelUtil::bulkPixelConversion(temp, scaled); |
---|
| 658 | } |
---|
| 659 | break; |
---|
| 660 | case PF_FLOAT32_RGB: |
---|
| 661 | case PF_FLOAT32_RGBA: |
---|
| 662 | if (scaled.format == PF_FLOAT32_RGB || scaled.format == PF_FLOAT32_RGBA) |
---|
| 663 | { |
---|
| 664 | // float32 to float32, avoid unpack/repack overhead |
---|
| 665 | LinearResampler_Float32::scale(src, scaled); |
---|
| 666 | break; |
---|
| 667 | } |
---|
| 668 | // else, fall through |
---|
| 669 | default: |
---|
| 670 | // non-optimized: floating-point math, performs conversion but always works |
---|
| 671 | LinearResampler::scale(src, scaled); |
---|
| 672 | } |
---|
| 673 | break; |
---|
| 674 | } |
---|
| 675 | } |
---|
| 676 | |
---|
| 677 | //----------------------------------------------------------------------------- |
---|
| 678 | |
---|
| 679 | ColourValue Image::getColourAt(int x, int y, int z) |
---|
| 680 | { |
---|
| 681 | ColourValue rval; |
---|
| 682 | PixelUtil::unpackColour(&rval, m_eFormat, &m_pBuffer[m_ucPixelSize * (z * m_uWidth * m_uHeight + m_uWidth * y + x)]); |
---|
| 683 | return rval; |
---|
| 684 | } |
---|
| 685 | |
---|
| 686 | //----------------------------------------------------------------------------- |
---|
| 687 | |
---|
| 688 | PixelBox Image::getPixelBox(size_t face, size_t mipmap) const |
---|
| 689 | { |
---|
| 690 | // Image data is arranged as: |
---|
| 691 | // face 0, top level (mip 0) |
---|
| 692 | // face 0, mip 1 |
---|
| 693 | // face 0, mip 2 |
---|
| 694 | // face 1, top level (mip 0) |
---|
| 695 | // face 1, mip 1 |
---|
| 696 | // face 1, mip 2 |
---|
| 697 | // etc |
---|
| 698 | if(mipmap > getNumMipmaps()) |
---|
| 699 | OGRE_EXCEPT( Exception::ERR_NOT_IMPLEMENTED, |
---|
| 700 | "Mipmap index out of range", |
---|
| 701 | "Image::getPixelBox" ) ; |
---|
| 702 | if(face >= getNumFaces()) |
---|
| 703 | OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Face index out of range", |
---|
| 704 | "Image::getPixelBox"); |
---|
| 705 | // Calculate mipmap offset and size |
---|
| 706 | uint8 *offset = const_cast<uint8*>(getData()); |
---|
| 707 | // Base offset is number of full faces |
---|
| 708 | size_t width = getWidth(), height=getHeight(), depth=getDepth(); |
---|
| 709 | size_t numMips = getNumMipmaps(); |
---|
| 710 | |
---|
| 711 | // Figure out the offsets |
---|
| 712 | size_t fullFaceSize = 0; |
---|
| 713 | size_t finalFaceSize = 0; |
---|
| 714 | size_t finalWidth, finalHeight, finalDepth; |
---|
| 715 | for(size_t mip=0; mip <= numMips; ++mip) |
---|
| 716 | { |
---|
| 717 | if (mip == mipmap) |
---|
| 718 | { |
---|
| 719 | finalFaceSize = fullFaceSize; |
---|
| 720 | finalWidth = width; |
---|
| 721 | finalHeight = height; |
---|
| 722 | finalDepth = depth; |
---|
| 723 | } |
---|
| 724 | fullFaceSize += PixelUtil::getMemorySize(width, height, depth, getFormat()); |
---|
| 725 | |
---|
| 726 | /// Half size in each dimension |
---|
| 727 | if(width!=1) width /= 2; |
---|
| 728 | if(height!=1) height /= 2; |
---|
| 729 | if(depth!=1) depth /= 2; |
---|
| 730 | } |
---|
| 731 | // Advance pointer by number of full faces, plus mip offset into |
---|
| 732 | offset += face * fullFaceSize; |
---|
| 733 | offset += finalFaceSize; |
---|
| 734 | // Return subface as pixelbox |
---|
| 735 | PixelBox src(finalWidth, finalHeight, finalDepth, getFormat(), offset); |
---|
| 736 | return src; |
---|
| 737 | } |
---|
| 738 | //----------------------------------------------------------------------------- |
---|
| 739 | size_t Image::calculateSize(size_t mipmaps, size_t faces, size_t width, size_t height, size_t depth, |
---|
| 740 | PixelFormat format) |
---|
| 741 | { |
---|
| 742 | size_t size = 0; |
---|
| 743 | for(size_t mip=0; mip<=mipmaps; ++mip) |
---|
| 744 | { |
---|
| 745 | size += PixelUtil::getMemorySize(width, height, depth, format)*faces; |
---|
| 746 | if(width!=1) width /= 2; |
---|
| 747 | if(height!=1) height /= 2; |
---|
| 748 | if(depth!=1) depth /= 2; |
---|
| 749 | } |
---|
| 750 | return size; |
---|
| 751 | } |
---|
| 752 | |
---|
| 753 | } |
---|