MercurySprite.cpp

Go to the documentation of this file.

#include "MercuryDisplay.h"
#include "MercurySprite.h"
#include "MercuryUtil.h"
#include "MercuryLog.h"
#include "MercuryPoly.h"
#include "MercuryTextureManager.h"
#include "MercuryScreenManager.h"
#include "MercuryObjectFactory.h"

#define MC_TEXTURELOADED 0

void MercurySprite::Init()
{
    MercuryObject::Init();

    //Sprites draw from the center by default
    SetHAlignment(CENTER);
    SetVAlignment(VCENTER);

    m_origHeight = m_height = 1;
    m_origWidth = m_width = 1;

    m_material.m_diffuse.SetA(1.0f);
    m_material.m_diffuse.SetB(1.0f);
    m_material.m_diffuse.SetG(1.0f);
    m_material.m_diffuse.SetR(1.0f);
    SetMaterial(&m_material);

    MercuryNormal normal;
    normal.SetZ(-1);
    normal.SetX(0);
    normal.SetY(0);

    m_mesh.SetName("GenericSpriteMesh");
    MESHMAN.RegMesh( &m_mesh, "SpriteDummy", false );
    m_mesh.SetNumVertices(4);

    //Upper left
    m_mesh[0].SetNormal(normal);

    //Lower left
    m_mesh[1].SetY(1);
    m_mesh[1].SetNormal(normal);

    //Lower Right
    m_mesh[2].SetX(1);
    m_mesh[2].SetY(1);
    m_mesh[2].SetNormal(normal);

    //Upper right
    m_mesh[3].SetX(1);
    m_mesh[3].SetNormal(normal);

    m_mesh.GetVertex(1)->SetV(1);
    m_mesh.GetVertex(2)->SetU(1);
    m_mesh.GetVertex(3)->SetU(1);
    m_mesh.GetVertex(2)->SetV(1);

    m_mesh.SetMaterial(&m_material);
    m_drawable = true;

    m_state = LOADED;

    m_glState.Disable(MGLS_ALL);
    m_glState.Enable(MGLS_DEPTHWRITE | MGLS_DEPTHTEST | MGLS_COLORWRITE | MGLS_BLEND | MGLS_TEXTURING | MGLS_OPAQUE);
}

void MercurySprite::Message( int Message, PStack & data, const MString & name )
{
    switch ( Message ) 
    {
    case MC_TEXTURELOADED:
        {
            const MercuryTexture* t = (const MercuryTexture*)data.PeekItem(0).GetValueV();
            const ImageAttrs* imageAttrs = (const ImageAttrs*)data.PeekItem(1).GetValueV();
            const MercuryTexture *tt = m_material.GetTexture(0);
            if(tt == t)
            {
                SetImageAttrs(*imageAttrs);
                m_state = LOADED;
                MercuryMessageHandler::UnregisterMessage( MC_TEXTURELOADED, "GetTextureID" );
            }
        }
        break;
    }
}

bool MercurySprite::Command( PStack & ret, const char * command, PStack & args )
{
    if ( strcmp( command, "LoadImage" ) == 0 )
    {
        MString Parameter = args.PopItem().GetValueS();
        while( args.GetSize() )
            Parameter = Parameter + "," + args.PopItem().GetValueS();
        LoadImage( Parameter );
        return true;
    }
    return MercuryObject::Command( ret, command, args );
}

void MercurySprite::EnumerateCommands( MVector< MString > & toAdd )
{
    toAdd.push_back( "LoadImage" );
    MercuryObject::EnumerateCommands( toAdd );
}

void MercurySprite::LoadImage(MString path)
{
    if ( path.substr( 0,5 ) == "QUAD:" )
    {
        float ReadOut[6];
        int i = 5, j = 0;
        MString cl = "";
        while ( (unsigned)i < path.length() )
        {
            if ( path.substr( i, 1 ) == "," )
            {
                ReadOut[j] = float( atof( cl.c_str() ) );
                cl = "";
                j++;
            } else 
                cl += path.substr( i, 1 );
            i++;
        }
        ReadOut[j] = float( atof( cl.c_str() ) );

        m_material.ClearTextures();
        SetHeight(int(ReadOut[1]));
        SetWidth(int(ReadOut[0]));
        
        m_material.m_diffuse.SetR( ReadOut[2] );
        m_material.m_diffuse.SetG( ReadOut[3] );
        m_material.m_diffuse.SetB( ReadOut[4] );
        m_material.m_diffuse.SetA( ReadOut[5] );

        CalculateRealColor();
    } else
    {
        m_state = UNLOADED;
        //eves drop on texture loading
        m_material.ClearTextures();
        m_material.AddTexture( MercuryTextureManager::CreateTexture(path) );
        //eves drop on texture loading
        MercuryMessageHandler::RegisterMessage( MC_TEXTURELOADED, "GetTextureID" );
    }
}

void MercurySprite::LoadMaterial(const MercuryMaterial& material)
{
    m_material = material;
    if (m_material.NumTextures() > 0)
    {
        SetHeight(m_material.GetTexture( 0 )->GetHeight() );
        SetWidth(m_material.GetTexture( 0 )->GetWidth() );
    }
}

void MercurySprite::MakeOrthoLine( const MercuryPoint &from, const MercuryPoint &to, float fWidth )
{
    MercuryPoint vec = (to-from);
    
    SetWidth( (int)vec.Magnitude() );
    SetHeight( (int)fWidth );
    SetRotZ( ATAN2( vec.y, vec.x ) * 180 / 3.14159f );
    SetPosition( from + vec * .5 );
}

void MercurySprite::SetImageAttrs(const ImageAttrs& attrs)
{
    SetHeight(attrs.m_height_original);
    SetWidth(attrs.m_width_original);
}

void MercurySprite::Draw() 
{
    ASSERT(!GetName().empty());
    DISPLAY->SendMatrixData(GetFinalMatrix());
    DISPLAY->DrawSprite(m_mesh);
}

void MercurySprite::CalculateMatrices()
{
    if ( m_taintedMatrix || (m_rotMode == RM_BILLBOARD) )
    {
        m_localMatrix.Identity();

        MercuryPoint scale = m_scale;
        scale.x *= m_origWidth;
        scale.y *= m_origHeight;
        
        if( m_rotMode == RM_NORMAL )
        {
            m_localMatrix.Transotale( m_position.x, m_position.y, m_position.z,
                                        m_rotation.x, m_rotation.y, m_rotation.z,
                                        scale.x, scale.y, scale.z );

            //this must be done after scaling
            if ((m_xalign != 0) || (m_yalign != 0))
                m_localMatrix.Translate(m_xalign, m_yalign, 0);
            m_taintedMatrix = false;
        }
        else
        {

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

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

                    //http://www.lighthouse3d.com/opengl/billboarding/index.php?billCyl
                    MercuryPoint gp(GetGlobalPosition());
                    MercuryPoint lcp;

                    MercuryScreen* screen = SCREENMAN->GetCurrentScreen();
                    if (screen)
                    {
                        MercuryCamera* camera = screen->GetCamera();
                        if (camera)
                        {
                            lcp = camera->GetPosition();
//                          up = camera->GetUp();
                        }   
                    }

                    directionProj = GetGlobalPosition() - lcp;
                    directionProj.NormalizeSelf();

                    axis = up.CrossProduct(directionProj);
                    angle = ACOS(DotProduct(up, 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 *= m_matrix;
                break;
            case RM_QUATERNION:
                {
                    MercuryMatrix m;
                    m_rotQuat.toMatrix4(m);
                    m_localMatrix *= m;
                }
                break;
            default:
                break;
            };

            m_localMatrix.Scale(scale.x, scale.y, scale.z);
            if ((m_xalign != 0) || (m_yalign != 0))
                m_localMatrix.Translate(m_xalign, m_yalign, 0);
            m_taintedMatrix = false;
        }
    }

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

REGISTER_OBJECT_TYPE( MercurySprite );

/* 
 * Copyright (c) 2005-2006, Joshua Allen
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by