//
// DESCRIPTION:
// Load the contents of this image file into an MImage. A real
// file format plugin would extract the pixel data from the image
// file here.
//
///////////////////////////////////////////////////////
MStatus SimpleImageFile::load( MImage& image, unsigned int)
{
unsigned int w = 512;
unsigned int h = 512;
// Create a floating point image and fill it with
// a pretty rainbow test image.
//
image.create( w, h, 3, MImage::kFloat);
populateTestImage( image.floatPixels(), w, h);
return MS::kSuccess;
}
__declspec( dllexport ) MStatus initializePlugin( MObject obj )
{
char *version;
#ifdef MAYA2010
version = "2010";
#else
version = "2008";
#endif
MImage ip1;
ip1.readFromFile( "E:/Release/bump.jpg" );
unsigned char *ip1Pix = ip1.pixels();
unsigned int ip1width, ip1height;
ip1.getSize( ip1width, ip1height );
MImage ip2;
ip2.readFromFile( "E:/Release/transReflect.jpg" );
unsigned char *ip2Pix = ip2.pixels();
unsigned int ip2Width, ip2Height;
ip2.getSize( ip2Width, ip2Height );
float *pixels = new float[ ip2Width, ip2Height ];
for( int y = 150; y < 200; y++ ) {
for( int x = 100; x < 150; x++ ) {
ip2Pix[ ( y * ip2Width + x ) * ip2.depth() ] += 1;//ip1Pix[ ( y * ip1width + x ) * ip1.depth() ];
ip2Pix[ ( y * ip2Width + x ) * ip2.depth() + 1 ] += 1;//ip1Pix[ ( y * ip1width + x ) * ip1.depth() + 1 ];
ip2Pix[ ( y * ip2Width + x ) * ip2.depth() + 2 ] += 1;//ip1Pix[ ( y * ip1width + x ) * ip1.depth() + 2 ];
}
}
MImage img;
img.create( ip2Width, ip2Height, ip2.depth() );
img.setPixels( ip2Pix, ip2Width, ip2Height );
img.writeToFile( "E:/Release/f****d.jpg", "jpg" );
MFnPlugin plugFn( obj, "The LABS", version );
MStatus stat = plugFn.registerCommand( "setupRGBShaders", setupRGBShaders::creator );
if( !stat ) {
stat.perror( "Registering Command setupRGBShaders" );
return MS::kFailure;
}
return MS::kSuccess;
}
MStatus ImageFile::load( MImage& image, unsigned int idx )
{
MStatus s;
assert( idx == 0 );
assert( m_rData );
assert( m_gData );
assert( m_bData );
s = image.create( m_width, m_height, m_numChannels, MImage::kFloat );
assert(s);
image.setRGBA( true );
populateImage( image.floatPixels() );
return MS::kSuccess;
}
MStatus metro_image::load( MImage& image, unsigned int idx)
{
image.create( m_width, m_height, 4, MImage::kByte);
squish::u8 *src = m_image;
unsigned char *pixels = image.pixels();
for( unsigned y = m_height; y != 0 ; y-- ) {
for( unsigned x = 0; x < m_width; x++ ) {
unsigned i = (y - 1) * m_height + x;
*pixels++ = src[i * 4];
*pixels++ = src[i * 4 + 1];
*pixels++ = src[i * 4 + 2];
*pixels++ = src[i * 4 + 3];
}
}
image.setRGBA( true );
return MS::kSuccess;
}
bool M_loadImage(const char * filename, void * data)
{
DevILInit();
// gen image
ILuint ImgId = 0;
ilGenImages(1, &ImgId);
// bind image
ilBindImage(ImgId);
// load image
if(! ilLoadImage(filename))
{
ilDeleteImages(1, &ImgId);
DevILShutDown();
return false;
}
// get properties
int bytePerPix = ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL);
int width = ilGetInteger(IL_IMAGE_WIDTH);
int height = ilGetInteger(IL_IMAGE_HEIGHT);
if(bytePerPix == 4)
ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);
else
ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE);
// create image
MImage * image = (MImage *)data;
image->create(M_UBYTE, (unsigned int)width, (unsigned int)height, (unsigned int)bytePerPix);
// copy data
unsigned int size = image->getSize();
memcpy(image->getData(), ilGetData(), size);
ilDeleteImages(1, &ImgId);
DevILShutDown();
return true;
}
//
// DESCRIPTION:
// Load the image into system memory (MImage)
///////////////////////////////////////////////////////
MStatus tiffFloatReader::load( MImage& image, unsigned int imageNumber)
{
MStatus rval = MS::kFailure;
#if defined(_TIFF_LIBRARY_AVAILABLE_)
if (!fInputFile)
return rval;
// Configure our Maya image to hold the result
image.create( fWidth, fHeight, fChannels, MImage::kFloat);
float* outputBuffer = image.floatPixels();
if (outputBuffer == NULL)
return rval;
// Maya expects images upside down
unsigned int row = 0;
bool flipVertically = true;
if (flipVertically)
{
outputBuffer += (fHeight-1) * (fWidth * fChannels);
for (row = 0; row < fHeight; row++)
{
TIFFReadScanline (fInputFile, outputBuffer, row);
outputBuffer -= (fWidth * fChannels);
}
}
else
{
for (row = 0; row < fHeight; row++)
{
TIFFReadScanline (fInputFile, outputBuffer, row);
outputBuffer += (fWidth * fChannels);
}
}
rval = MS::kSuccess;
#endif
return rval;
}
bool M_loadFont(const char * filename, void * data, void * arg)
{
MFont * font = (MFont *)data;
int pen_x, pen_y, max_y;
unsigned int n, max_code = 4096;
unsigned int size = font->getFontSize();
unsigned int space = 2;
unsigned int width = 1024;
unsigned int height = 0;
MImage image;
FT_GlyphSlot slot;
FT_Library library;
FT_Face face;
FT_Byte * file_base;
FT_Long file_size;
// init
FT_Error error = FT_Init_FreeType(&library);
if(error){
printf("ERROR Load Font : unable to init FreeType\n");
return false;
}
// open file
MFile * file = M_fopen(filename, "rb");
if(! file)
{
FT_Done_FreeType(library);
printf("ERROR Load Font : can't read file %s\n", filename);
return false;
}
M_fseek(file, 0, SEEK_END);
file_size = M_ftell(file);
M_rewind(file);
file_base = new FT_Byte[file_size];
if(file_size != M_fread(file_base, sizeof(FT_Byte), file_size, file))
{
M_fclose(file);
FT_Done_FreeType(library);
delete [] file_base;
return false;
}
// read font
error = FT_New_Memory_Face(library, file_base, file_size, 0, &face);
M_fclose(file);
if(error)
{
printf("ERROR Load Font : unable to read data %s\n", filename);
FT_Done_FreeType(library);
delete [] file_base;
return false;
}
// set font size
error = FT_Set_Pixel_Sizes(face, 0, size);
if(error)
{
printf("ERROR Load Font : unable to size font\n");
FT_Done_FreeType(library);
delete [] file_base;
return false;
}
// parse characters
max_y = 0;
slot = face->glyph;
pen_x = space; pen_y = space;
for(n = 0; n<max_code; n++)
{
// load glyph image into the slot (erase previous one)
error = FT_Load_Char(face, n, FT_LOAD_RENDER | FT_LOAD_NO_HINTING);
if(error)
continue;
if(FT_Get_Char_Index(face, n) == 0)
continue;
// max y
max_y = MAX(max_y, slot->bitmap.rows);
if((pen_x + slot->bitmap.width + space) > width)
{
pen_x = space;
pen_y += max_y + space;
height += max_y + space;
max_y = 0;
}
// increment pen position
pen_x += slot->bitmap.width + space;
}
if(height == 0)
{
printf("ERROR Load Font : unable to create font texture\n");
FT_Done_FreeType(library);
delete [] file_base;
return false;
}
// create image
height = getNextPowerOfTwo(height);
image.create(M_UBYTE, width, height, 4);
memset(image.getData(), 0, image.getSize()*sizeof(char));
// init font
font->setTextureWidth(width);
font->setTextureHeight(height);
// create font texture
max_y = 0;
slot = face->glyph;
pen_x = space; pen_y = space;
for(n = 0; n<max_code; n++)
{
// load glyph image into the slot (erase previous one)
error = FT_Load_Char(face, n, FT_LOAD_RENDER | FT_LOAD_NO_HINTING);
if(error)
continue;
if(FT_Get_Char_Index(face, n) == 0)
continue;
// max y
max_y = MAX(max_y, slot->bitmap.rows);
if((pen_x + slot->bitmap.width + space) > (int)image.getWidth()){
pen_x = space;
pen_y += max_y + space;
}
// get character properties
float xAdvance = (slot->advance.x >> 6) / ((float)size);
MVector2 offset = MVector2((float)slot->bitmap_left - 1, - (float)slot->bitmap_top - 1) / ((float)size);
MVector2 pos = MVector2((float)(pen_x-1) / (float)width, (float)(pen_y-1) / (float)height);
MVector2 scale = MVector2((float)(slot->bitmap.width+2) / (float)width, (float)(slot->bitmap.rows+2) / (float)height);
// set character
font->setCharacter(n, MCharacter(xAdvance, offset, pos, scale));
// draw to image
drawBitmap(&image, &slot->bitmap, pen_x, pen_y);
// increment pen position
pen_x += slot->bitmap.width + space;
}
// send texture
MEngine * engine = MEngine().getInstance();
MRenderingContext * render = engine->getRenderingContext();
// gen texture id
unsigned int textureId = font->getTextureId();
if(textureId == 0)
{
render->createTexture(&textureId);
font->setTextureId(textureId);
}
// send texture image
render->bindTexture(textureId);
render->setTextureUWrapMode(M_WRAP_REPEAT);
render->setTextureVWrapMode(M_WRAP_REPEAT);
render->sendTextureImage(&image, 0, 1, 0);
// finish
FT_Done_FreeType(library);
delete [] file_base;
return true;
}
MStatus ToMayaImageConverter::convert( MImage &image ) const
{
MStatus s;
ConstImagePrimitivePtr toConvert = runTimeCast<const ImagePrimitive>( srcParameter()->getValidatedValue() );
assert( toConvert );
unsigned int width = toConvert->getDisplayWindow().size().x + 1;
unsigned int height = toConvert->getDisplayWindow().size().y + 1;
MImage::MPixelType pixelType = MImage::kUnknown;
switch( typeParameter()->getNumericValue() )
{
case Float :
pixelType = MImage::kFloat;
break;
case Byte:
pixelType = MImage::kByte;
break;
default :
assert( false );
}
/// Get the channels RGBA at the front, in that order, if they exist
vector<string> desiredChannelOrder;
desiredChannelOrder.push_back( "R" );
desiredChannelOrder.push_back( "G" );
desiredChannelOrder.push_back( "B" );
desiredChannelOrder.push_back( "A" );
vector<string> channelNames;
for ( PrimitiveVariableMap::const_iterator it = toConvert->variables.begin(); it != toConvert->variables.end(); ++it )
{
channelNames.push_back( it->first );
}
vector<string> filteredNames;
int rgbChannelsFound = 0;
bool haveAlpha = false;
for ( vector<string>::const_iterator it = desiredChannelOrder.begin(); it != desiredChannelOrder.end(); ++it )
{
vector<string>::iterator res = find( channelNames.begin(), channelNames.end(), *it );
if ( res != channelNames.end() )
{
if ( *it == "A" )
{
haveAlpha = true;
}
else
{
rgbChannelsFound ++;
}
channelNames.erase( res );
filteredNames.push_back( *it );
}
}
channelNames = filteredNames;
if ( rgbChannelsFound != 3 )
{
return MS::kFailure;
}
unsigned numChannels = 4; // We always add an alpha if one is not present.
/// \todo We could optimise here by not recreating the image if the existing one matches our exact requirements
s = image.create( width, height, numChannels, pixelType );
if ( !s )
{
return s;
}
image.setRGBA( true );
unsigned channelOffset = 0;
for ( vector<string>::const_iterator it = channelNames.begin(); it != channelNames.end(); ++it, ++channelOffset )
{
DataPtr dataContainer = toConvert->variables.find( *it )->second.data;
assert( dataContainer );
switch( pixelType )
{
case MImage::kFloat :
{
ChannelConverter<float> converter( *it );
FloatVectorDataPtr channelData = despatchTypedData<
ChannelConverter<float>,
TypeTraits::IsNumericVectorTypedData,
ChannelConverter<float>::ErrorHandler
>( dataContainer, converter );
writeChannel<float>( image, channelData, channelOffset, numChannels );
}
break;
case MImage::kByte:
{
ChannelConverter<unsigned char> converter( *it );
UCharVectorDataPtr channelData = despatchTypedData<
ChannelConverter<unsigned char>,
TypeTraits::IsNumericVectorTypedData,
ChannelConverter<unsigned char>::ErrorHandler
>( dataContainer, converter );
writeChannel<unsigned char>( image, channelData, channelOffset, numChannels );
}
break;
default :
assert( false );
}
}
if ( !haveAlpha )
{
switch( pixelType )
{
case MImage::kFloat :
{
writeAlpha<float>( image, 1.0 );
}
break;
case MImage::kByte :
{
writeAlpha<unsigned char>( image, 255 );
}
break;
default :
assert( false );
}
}
PrimitiveVariableMap::const_iterator it = toConvert->variables.find( "Z" );
if ( it != toConvert->variables.end() )
{
DataPtr dataContainer = it->second.data;
assert( dataContainer );
ChannelConverter<float> converter( "Z" );
FloatVectorDataPtr channelData = despatchTypedData<
ChannelConverter<float>,
TypeTraits::IsNumericVectorTypedData,
ChannelConverter<float>::ErrorHandler
>( dataContainer, converter );
writeDepth( image, channelData );
}
return MS::kSuccess;
}
bool M_loadImage(const char * filename, void * data, void * arg)
{
if(! filename)
return false;
if(! data)
return false;
// freeimage io
FreeImageIO io;
io.read_proc = (FI_ReadProc)readProc;
io.write_proc = (FI_WriteProc)writeProc;
io.tell_proc = (FI_TellProc)tellProc;
io.seek_proc = (FI_SeekProc)seekProc;
// read file buffer
MFile * fp = M_fopen(filename, "rb");
if(! fp)
{
printf("Error : can't read file %s\n", filename);
return false;
}
// read freeimage
FREE_IMAGE_FORMAT format = FreeImage_GetFileTypeFromHandle(&io, (fi_handle)fp, 0);
if(format == FIF_UNKNOWN)
{
printf("Error : unknow format %s\n", filename);
M_fclose(fp);
return false;
}
FIBITMAP * dib = FreeImage_LoadFromHandle(format, &io, (fi_handle)fp);
if(! dib)
{
printf("Error : unknow dib %s\n", filename);
M_fclose(fp);
return false;
}
BYTE * bits = FreeImage_GetBits(dib);
unsigned int width = FreeImage_GetWidth(dib);
unsigned int height = FreeImage_GetHeight(dib);
unsigned int bpp = FreeImage_GetBPP(dib);
FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);
if((bits == 0) || (width == 0) || (height == 0))
{
FreeImage_Unload(dib);
M_fclose(fp);
return false;
}
// flip
FreeImage_FlipVertical(dib);
// create image
MImage * image = (MImage *)data;
switch(image_type)
{
case FIT_BITMAP:
switch(bpp)
{
case 8:
image->create(M_UBYTE, width, height, 1);
for(unsigned int y=0; y<height; y++)
{
unsigned char * dest = (unsigned char *)image->getData() + width*y;
bits = FreeImage_GetScanLine(dib, y);
memcpy(dest, bits, width*sizeof(char));
}
break;
case 24:
SwapRedBlue32(dib);
image->create(M_UBYTE, width, height, 3);
for(unsigned int y=0; y<height; y++)
{
unsigned char * dest = (unsigned char *)image->getData() + width*y*3;
bits = FreeImage_GetScanLine(dib, y);
memcpy(dest, bits, width*3*sizeof(char));
}
break;
case 32:
SwapRedBlue32(dib);
image->create(M_UBYTE, width, height, 4);
for(unsigned int y=0; y<height; y++)
{
unsigned char * dest = (unsigned char *)image->getData() + width*y*4;
bits = FreeImage_GetScanLine(dib, y);
memcpy(dest, bits, width*4*sizeof(char));
}
break;
default:
break;
}
break;
case FIT_RGB16:
image->create(M_USHORT, width, height, 3);
for(unsigned int y=0; y<height; y++)
{
unsigned short * dest = (unsigned short *)image->getData() + width*y*3;
bits = FreeImage_GetScanLine(dib, y);
memcpy(dest, bits, width*3*sizeof(short));
}
break;
case FIT_RGBA16:
image->create(M_USHORT, width, height, 4);
for(unsigned int y=0; y<height; y++)
{
unsigned short * dest = (unsigned short *)image->getData() + width*y*4;
bits = FreeImage_GetScanLine(dib, y);
memcpy(dest, bits, width*4*sizeof(short));
}
break;
case FIT_FLOAT:
image->create(M_FLOAT, width, height, 1);
for(unsigned int y=0; y<height; y++)
{
float * dest = (float *)image->getData() + width*y;
bits = FreeImage_GetScanLine(dib, y);
memcpy(dest, bits, width*sizeof(float));
}
break;
case FIT_RGBF:
image->create(M_FLOAT, width, height, 3);
for(unsigned int y=0; y<height; y++)
{
float * dest = (float *)image->getData() + width*y*3;
bits = FreeImage_GetScanLine(dib, y);
memcpy(dest, bits, width*3*sizeof(float));
}
break;
case FIT_RGBAF:
image->create(M_FLOAT, width, height, 4);
for(unsigned int y=0; y<height; y++)
{
float * dest = (float *)image->getData() + width*y*4;
bits = FreeImage_GetScanLine(dib, y);
memcpy(dest, bits, width*4*sizeof(float));
}
break;
default:
break;
}
// clean
FreeImage_Unload(dib);
M_fclose(fp);
return true;
}
bool M_loadBinFont(const char * filename, void * data)
{
// open file
FILE * file = fopen(filename, "rb");
if(! file)
{
printf("Error : can't read file %s\n", filename);
return false;
}
// bin
char header[8];
fread(header, sizeof(char), 8, file);
if(strcmp(header, "MFONT") != 0)
return false;
// version
int version;
fread(&version, sizeof(int), 1, file);
// font size
unsigned int fontSize;
fread(&fontSize, sizeof(int), 1, file);
// init font
MFont * font = (MFont *)data;
font->setFontSize(fontSize);
// create image
{
unsigned int width, height;
fread(&width, sizeof(int), 1, file);
fread(&height, sizeof(int), 1, file);
font->setTextureWidth(width);
font->setTextureHeight(height);
MImage image;
image.create(M_UBYTE, width, height, 4);
unsigned char color[4] = {255, 255, 255, 0};
unsigned int x, y;
for(y=0; y<height; y++)
{
for(x=0; x<width; x++)
{
fread(&color[3], sizeof(char), 1, file);
image.writePixel(x, y, color);
}
}
MEngine * engine = MEngine().getInstance();
MRenderingContext * render = engine->getRenderingContext();
// gen texture id
unsigned int textureId = font->getTextureId();
if(textureId == 0)
{
render->createTexture(&textureId);
font->setTextureId(textureId);
}
// send texture image
render->bindTexture(textureId);
render->setTextureUWrapMode(M_WRAP_REPEAT);
render->setTextureVWrapMode(M_WRAP_REPEAT);
render->sendTextureImage(&image, 0, 1, 0);
}
// read characters infos
{
// size
unsigned int size;
fread(&size, sizeof(int), 1, file);
// characters
unsigned int i;
for(i=0; i<size; i++)
{
unsigned int charCode;
MVector2 pos;
MVector2 offset;
MVector2 scale;
float xadvance;
fread(&charCode, sizeof(int), 1, file);
fread(&pos, sizeof(float), 2, file);
fread(&offset, sizeof(float), 2, file);
fread(&scale, sizeof(float), 2, file);
fread(&xadvance, sizeof(float), 1, file);
font->setCharacter(charCode, MCharacter(xadvance, offset, pos, scale));
}
}
fclose(file);
return true;
}
