Torque3D support .alpha.jpg?

//-----------------------------------------------------------------------------
// Torque Shader Engine
// Copyright (C) GarageGames.com, Inc.
//-----------------------------------------------------------------------------

#include "ljpeg/jpeglib.h"

#include "core/stream/fileStream.h"
#include "core/util/path.h"

#include "gfx/bitmap/gBitmap.h"


using namespace Torque;

static GBitmap *sImportJpgImage(const Path &inPath);

static bool sReadJPG(Stream &stream, GBitmap *bitmap);
static bool sWriteJPG(GBitmap *bitmap, Stream &stream, U32 compressionLevel);

static struct _privateRegisterJPG
{
   _privateRegisterJPG()
   {
      GBitmap::Registration reg;

      reg.extensions.push_back( "jpeg" );
      reg.extensions.push_back( "jpg" );

      reg.readFunc = sReadJPG;
      reg.writeFunc = sWriteJPG;

      GBitmap::sRegisterFormat( reg );
   }
} sStaticRegisterJPG;

//-----------------------------------------------------------------------------
/// This gives us a chance to handle it before invoking the Resource<GBitmap>::create() function
/// This will only accept the .jpg extension.  If you want to handle others, you'll have to change
/// this function to look for them.
static bool  sJPGHandleLoadSignal(const Path &inPath, void **outPtr)
{
   static const String  sgJPGStr( "jpg" );

   const String   &ext = inPath.getExtension();

   if ( (outPtr == NULL) || (ext.isNotEmpty() && sgJPGStr.compare( ext, 3, String::NoCase ) ) )
      return true;

#ifdef TORQUE_DEBUG_RES_MANAGER
   Con::printf( "[Bitmap] sJPGHandleLoadSignal - [%s]", inPath.getFullPath().c_str() );
#endif

   Path  fullPath( inPath );

   if ( ext.isEmpty() )
      fullPath.setExtension( sgJPGStr );

   GBitmap *res = sImportJpgImage( fullPath );

   *outPtr = res;

   return( res == NULL );
}

static ResourceRegisterLoadSignal<GBitmap> sgAuto( sJPGHandleLoadSignal );

static GBitmap *sImportJpgImage( const Path &inPath )
{
	FileStream  stream;
   stream.open(inPath.getFullPath(), Torque::FS::File::Read);

   if (stream.getStatus() != Stream::Ok)
	{
      return NULL;
	}

   GBitmap* bmp = new GBitmap;
   const String extension = inPath.getExtension();
	bool readSuccess = bmp->readBitmap(extension, stream);
	if (readSuccess && bmp->getFormat() == GFXFormatR8G8B8)
	{
		Path inPathAlpha = inPath;
		inPathAlpha.setFileName(inPathAlpha.getFileName() + ".alpha");

		stream.close();
		stream.open(inPathAlpha.getFullPath(), Torque::FS::File::Read);

		if (stream.getStatus() == Stream::Ok)
		{
			GBitmap* bmpAlpha = new GBitmap;
			bool readSuccess = bmpAlpha->readBitmap(extension, stream);

			S32 w = bmp->getWidth();
			S32 h = bmp->getHeight();
			if (readSuccess && bmpAlpha->getWidth() == w && bmpAlpha->getHeight() == h && bmpAlpha->getBytesPerPixel() == 1)
			{
				GBitmap* bmp2 = new GBitmap(w, h, false, GFXFormatR8G8B8A8);
				U8* rgbBits = bmp->getWritableBits();
				U8* alphaBits = bmpAlpha->getWritableBits();
				U8* bmpBits = bmp2->getWritableBits();
				for (S32 wi = 0; wi < w; wi++)
				{
					for (S32 hi = 0; hi < h; hi++)
					{
						bmpBits[wi * 4 + hi * 4 * w + 0] = rgbBits[wi * 3 + hi * 3 * w + 0];
						bmpBits[wi * 4 + hi * 4 * w + 1] = rgbBits[wi * 3 + hi * 3 * w + 1];
						bmpBits[wi * 4 + hi * 4 * w + 2] = rgbBits[wi * 3 + hi * 3 * w + 2];
						bmpBits[wi * 4 + hi * 4 * w + 3] = alphaBits[wi + hi * w];
					}
				}
				delete bmpAlpha;
				delete bmp;
				bmp = bmp2;
			}
		}
	}
	else
	{
		delete bmp;
		bmp = NULL;
	}

	return bmp;
}