Method createDDSFileFromGBitmap

Engine/source/gfx/bitmap/ddsFile.cpp:660–726

//------------------------------------------------------------------------------

DDSFile *DDSFile::createDDSFileFromGBitmap( const GBitmap *gbmp )
{
   if( gbmp == NULL )
      return NULL;

   DDSFile *ret = new DDSFile;

   // Set up the DDSFile properties that matter. Since this is a GBitmap, there
   // are assumptions that can be made
   ret->mHeight = gbmp->getHeight();
   ret->mWidth = gbmp->getWidth();
   ret->mDepth = 0;
   ret->mFormat = gbmp->getFormat();
   ret->mFlags.set(RGBData);
   ret->mBytesPerPixel = gbmp->getBytesPerPixel();
   ret->mMipMapCount = gbmp->getNumMipLevels();
   ret->mHasTransparency = gbmp->getHasTransparency();

   // ASSUMPTION!!!
   // This _most likely_ does not belong here, but it is safe to assume that if
   // a GBitmap is 24-bit, and it's being converted to a DDS, it is most likely
   // going to be either:
   // a) Uploaded as a 32-bit texture, and just needs to be padded to RGBX
   // b) Uploaded as a compressed format, and needs to be padded to 32-bits anyway
   if( ret->mFormat == GFXFormatR8G8B8 )
   {
      ret->mFormat = GFXFormatR8G8B8X8;
      ret->mBytesPerPixel = 4;
   }

   if( ret->mMipMapCount > 1 )
      ret->mFlags.set(MipMapsFlag);

   // One surface per GBitmap
   ret->mSurfaces.push_back( new SurfaceData() );

   // Load the mips
   for( S32 i = 0; i < ret->mMipMapCount; i++ )
   {
      const U32 mipSz = ret->getSurfaceSize(i);
      ret->mSurfaces.last()->mMips.push_back( new U8[mipSz] );

      U8 *mipMem = ret->mSurfaces.last()->mMips.last();
      
      // If this is a straight copy, just do it, otherwise (ugh)
      if( ret->mFormat == gbmp->getFormat() )
         dMemcpy( mipMem, gbmp->getBits(i), mipSz );
      else
      {
         // Assumption:
         AssertFatal( gbmp->getBytesPerPixel() + 1 == ret->mBytesPerPixel, "Assumption failed, not 24->32 bit straight convert." );

         for( S32 pxl = 0; pxl < gbmp->getWidth(i) * gbmp->getHeight(i); pxl++ )
         {
            U8 *dst = &mipMem[pxl * ret->mBytesPerPixel];
            const U8 *src = &gbmp->getBits(i)[pxl * gbmp->getBytesPerPixel()];
            dMemcpy( dst, src, gbmp->getBytesPerPixel() * sizeof(U8) );
            dst[ret->mBytesPerPixel - 1] = 255;