MercuryTexture.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryTexture.h"
#include "MercuryLog.h"
#include "MercuryFiles.h"
#include "MercuryLog.h"
#include "MercuryMath.h"
#include "MercuryDisplay.h"

//for PNG Loading
#if defined(WIN32)
#  include <png.h>
#  if defined(_MSC_VER)
#    pragma comment(lib, "libpng.lib")
#  endif
#  pragma warning(disable: 4611) /* interaction between '_setjmp' and C++ object destruction is non-portable */
#else
#  include <png.h>
#endif

//Add supported image formats to the loade along with their finger print.
//ADDIMAGELOADER( LoadBMP, (*"BM8") );
//ADDIMAGELOADER( LoadPNG, (*"‰PN") );

#define     MC_TEXTUREID        1

int ColorBytesToSize(ColorBytes cb)
{
    switch (cb)
    {
    case LUMINANCE_ALPHA:
        return 2;
    case RGB:
        return 3;
    case DEPTH_COMPONENT24:
        return 3;
    case RGBA:
        return 4;
    case RGBA_FLOAT:
        return 16;
    default:
        ASSERT(!"Invalid Color Byte")
    };
    return 0;
}

MercuryTexture::MercuryTexture()
:MercuryObject()
{
    Init();
}

MercuryTexture::MercuryTexture(const MercuryTexture& texture)
:MercuryObject()
{
    Init();
    *this = texture;
}

MercuryTexture::~MercuryTexture()
{
    SendRemoveMessage();
}

void MercuryTexture::Message( int Message, PStack & data, const MString & name )
{
    switch ( Message ) 
    {
    case MC_TEXTUREID:
        {
            const MercuryTexture* t = (const MercuryTexture*)data.PeekItem(0).GetValueV();
            const ImageAttrs* imageAttrs = (const ImageAttrs*)data.PeekItem(1).GetValueV();
            if(this == t)
            {
                m_imageAttrs = *imageAttrs;
                SetMatrixTainted(true);
                MercuryMessageHandler::UnregisterMessage( MC_TEXTUREID, "GetTextureID" );
                m_state = LOADED;
            }
        }
        break;
    }
}

void MercuryTexture::AutoDestroy()
{
    SendRemoveMessage();
    if (GetID() > 0)
        m_imageAttrs.m_ID = 0;
}

void MercuryTexture::SendRemoveMessage()
{
    PStack stack;
    stack.PushItemBack(PSElement(GetPath()));
    stack.PushItemBack(PSElement((void*)this));
    MESSAGEMAN->PostSystemMessage("UnregisterTexture", stack, 0);
    m_state = UNLOADED;
}

void MercuryTexture::SendLoadMessage()
{
    PStack stack;
    stack.PushItemBack(PSElement(GetPath()));
    stack.PushItemBack(PSElement((void*)this));
    MercuryMessageHandler::RegisterMessage( MC_TEXTUREID, "GetTextureID" );
    MESSAGEMAN->PostSystemMessage("LoadTexture", stack, 0);
    m_state = UNLOADED;
}

void MercuryTexture::SendLoadFromRaw(RawImageData* data)
{
    PStack stack;
    stack.PushItemBack(PSElement(GetPath()));
    stack.PushItemBack(PSElement((void*)this));
    stack.PushItemBack(PSElement((void*)data));
    MercuryMessageHandler::RegisterMessage( MC_TEXTUREID, "GetTextureID" );
    MESSAGEMAN->PostSystemMessage("LoadTextureRaw", stack, 0);
    m_state = UNLOADED;
}

void MercuryTexture::operator=(const MercuryTexture& texture)
{
    if (!texture.m_path.empty())
    {
        //If we have an ID we should unregister
        if (GetID() > 0)
            SendRemoveMessage();
    
        m_attrs = texture.m_attrs;
        m_imageAttrs = texture.m_imageAttrs;

        //We need to register this texture incase the previous one is destroyed
        SendLoadMessage();
    }
}

void RawImageData::CorrectSize()
{
    attrs.m_width_original = attrs.m_width;
    attrs.m_height_original = attrs.m_height;

    //cube maps have 6 times as much shit in the data as everything else
    if (attrs.m_cube)
    {
        printf ("*******CorrectSize:\npdata = %lu\nwidth = %lu\nheight = %lu\ncolorbytes = %lu\nCorrectSize\n", data, attrs.m_width, attrs.m_height, (unsigned int)(ColorBytesToSize(attrs.m_ColorByteType)));
        return;
    }
    
    attrs.m_height = makePow2(attrs.m_height);
    attrs.m_width = makePow2(attrs.m_width);

    attrs.m_resizeFactor.SetX( (float)attrs.m_width_original / attrs.m_width );
    attrs.m_resizeFactor.SetY( (float)attrs.m_height_original / attrs.m_height );

    unsigned char* resized;
    int chunk = attrs.m_width_original * ColorBytesToSize(attrs.m_ColorByteType);
    int newchunk = attrs.m_width * ColorBytesToSize(attrs.m_ColorByteType);
    int newsize = attrs.m_height * attrs.m_width * ColorBytesToSize(attrs.m_ColorByteType);

    if ((attrs.m_height_original != attrs.m_height) || (attrs.m_width_original != attrs.m_width))
    {
        resized = new unsigned char[newsize];

        memset(resized, 0, newsize);
        for (unsigned int i = 0; i < (unsigned)attrs.m_height_original; i++)
        {
            memcpy(&resized[i * newchunk], &data[i * chunk], chunk); 
        }
        SAFE_DELETE(data);
        data = new unsigned char[newsize];
        memcpy(data, resized, newsize);
        SAFE_DELETE(resized);
    }
}

void RawImageData::ToRGBA()
{
    if (data == NULL)   
    {
        LOG.Warn("Texture data null, not converting to RGBA.");
        return;
    }

    const unsigned int size = attrs.m_width*attrs.m_height*ColorBytesToSize(RGBA);
    unsigned char* tmpdata = new unsigned char[size];
    switch(attrs.m_ColorByteType)
    {
    case RGB:
        {
//          unsigned int osize = GetWidth()*GetHeight()*RGB;
            unsigned int opos = 0;
            for (unsigned int i = 0; i < size; i++)
            {
                if(((i+1)%4) == 0)
                {
                    tmpdata[i] = 255; //alpha
                }
                else
                {
                    tmpdata[i] = data[opos++];
                }
            }
            SAFE_DELETE(data);
            attrs.m_ColorByteType = RGBA;
            data = new unsigned char[size];
            memcpy(data, tmpdata, size);
        }
        break;
    default:
        break;
    }
    SAFE_DELETE(tmpdata);
}

void MercuryTexture::CalculateMatrices()
{
    if ( IsMatrixTainted() )
    {
        m_localMatrix.Identity();

        MercuryPoint scale = GetScale()*m_imageAttrs.m_resizeFactor;
        const MercuryPoint& position = GetPosition();
        const MercuryPoint& rotation = GetRot();

        if( GetRotMode() == RM_NORMAL )
        {
            m_localMatrix.Transotale( position.x, position.y, position.z,
                                        rotation.x, rotation.y, rotation.z,
                                        scale.x, scale.y, scale.z );
            SetMatrixTainted(false);
        }
        else
        {

            m_localMatrix.Translate(position.x, position.y, position.z);

            switch ( GetRotMode() )
            {
            case RM_OFF:
                break;
            case RM_BILLBOARD:
                {
                    static const MercuryPoint look(0,0,1);
                    static MercuryPoint directionProj;
                    static float angle;
                    static MercuryPoint axis;
                    static MercuryMatrix world;

                    //http://www.lighthouse3d.com/opengl/billboarding/index.php?billCyl
                    directionProj = GetGlobalPosition() - DISPLAY->GetLastCameraPosition();
                    directionProj.NormalizeSelf();

                    axis = look.CrossProduct(directionProj);
                    angle = ACOS(DotProduct(look, directionProj));

                    //The destroys the previous matrix
                    world.RotateAngAxis(angle*RADDEG, axis.x, axis.y, axis.z);

                    m_localMatrix *= world;
                }
                break;
            case RM_MATRIX:
                m_localMatrix *= GetAfterMatrix();
                break;
            case RM_QUATERNION:
                {
                    MercuryMatrix m;
                    GetRotationQuaternion().toMatrix4(m);
                    m_localMatrix *= m;
                }
                break;
            default:
                break;
            };

            m_localMatrix.Scale(scale.x, scale.y, scale.z);
            SetMatrixTainted(false);
        }
    }

    m_finalMatrix = TextureStack.GetTop() *= m_localMatrix;
}

void MercuryTexture::Prerender()
{
    TextureStack.Push();
    CalculateMatrices();
    TextureStack.Pop();
}


void CaclulateDiv2Texture( const RawImageData & riIn, RawImageData & riOut )
{
    riOut.attrs.m_ColorByteType = riIn.attrs.m_ColorByteType;
    unsigned cbsize = ColorBytesToSize( riIn.attrs.m_ColorByteType );

    if( riIn.attrs.m_height != 1 && riIn.attrs.m_width != 1 )
    {
        unsigned oHeight = riOut.attrs.m_height = riIn.attrs.m_height / 2;
        unsigned oWidth = riOut.attrs.m_width = riIn.attrs.m_width / 2;
        riOut.data = new unsigned char[riOut.attrs.m_width * riOut.attrs.m_height * cbsize];

        for( unsigned y = 0; y < riOut.attrs.m_height; ++y )
            for( unsigned x = 0; x < riOut.attrs.m_width; ++x )
                for( unsigned b = 0; b < cbsize; ++b )
                {
                    riOut.data[(x+y*oWidth)*cbsize + b] = (
                        (unsigned)riIn.data[((x*2+y*2*riIn.attrs.m_width))*cbsize + b] +
                        (unsigned)riIn.data[((x*2)+1+y*2*riIn.attrs.m_width)*cbsize + b] +
                        (unsigned)riIn.data[(x*2+(y*2+1)*riIn.attrs.m_width)*cbsize + b] +
                        (unsigned)riIn.data[((x*2)+1+(y*2+1)*riIn.attrs.m_width)*cbsize + b] ) / 4;
                }
    } else if( riIn.attrs.m_height != 1 )
    {
        unsigned oHeight = riOut.attrs.m_height = riIn.attrs.m_height / 2;
        unsigned oWidth = riOut.attrs.m_width = riIn.attrs.m_width;
        riOut.data = new unsigned char[riOut.attrs.m_width * riOut.attrs.m_height * cbsize];

        for( unsigned y = 0; y < riOut.attrs.m_height; ++y )
            for( unsigned x = 0; x < riOut.attrs.m_width; ++x )
                for( unsigned b = 0; b < cbsize; ++b )
                {
                    riOut.data[(x+y*oWidth)*cbsize + b] = (
                        (unsigned)riIn.data[(x*2+y*2*riIn.attrs.m_width)*cbsize + b] +
                        (unsigned)riIn.data[(x*2+(y+1)*2*riIn.attrs.m_width)*cbsize + b] ) / 2;
                }
    } else if( riIn.attrs.m_width != 1 )
    {
        unsigned oHeight = riOut.attrs.m_height = riIn.attrs.m_height;
        unsigned oWidth = riOut.attrs.m_width = riIn.attrs.m_width / 2;
        riOut.data = new unsigned char[riOut.attrs.m_width * riOut.attrs.m_height * cbsize];

        for( unsigned y = 0; y < riOut.attrs.m_height; ++y )
            for( unsigned x = 0; x < riOut.attrs.m_width; ++x )
                for( unsigned b = 0; b < cbsize; ++b )
                {
                    riOut.data[(x+y*oWidth)*cbsize + b] = (
                        (unsigned)riIn.data[(x*2+y*2*riIn.attrs.m_width)*cbsize + b] +
                        (unsigned)riIn.data[((x+1)*2+y*2*riIn.attrs.m_width)*cbsize + b] ) / 2;
                }
    }
}

/* (c) 2005 Joshua Allen
 * (c) 2006 Charles Lohr
 * All rights reserved.
 * 
 * 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, and/or sell copies of the Software, and to permit persons to
 * whom the Software is furnished to do so, provided that the above
 * copyright notice(s) and this permission notice appear in all copies of
 * the Software and that both the above copyright notice(s) and this
 * permission notice appear in supporting documentation.
 * 
 * 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 OF
 * THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
 * INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT
 * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

---

Hosted by