MercuryObjectBase.cpp

Go to the documentation of this file.

#include "MercuryMessages.h"
#include "MercuryObjectBase.h"
#include "MercuryDisplay.h"
#include "MercuryMath.h"
#include "MercuryScreenManager.h"

MercuryObjectBase::MercuryObjectBase()
:m_parentObject(NULL)
{
}

void MercuryObjectBase::Init()
{
    m_rotMode = RM_NORMAL;
    m_scale.SetX(1);
    m_scale.SetY(1);
    m_scale.SetZ(1);
    m_fVisRadius = -1;
    m_taintedMatrix = true;
    m_drawOrder = 0;
    m_xalign = m_yalign = 0;
}

MercuryPoint MercuryObjectBase::GetGlobalPosition() const
{
    if ( !m_parentObject )
        return m_position;
    return m_parentObject->GetGlobalPosition() + m_position;
}

void MercuryObjectBase::CalculateMatrices()
{
    if ( m_taintedMatrix || (m_rotMode == RM_BILLBOARD) )
    {
        m_localMatrix.Identity();
        
        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,
                                        m_scale.x, m_scale.y, m_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(m_scale.x, m_scale.y, m_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;
}

MercuryPoint MercuryObjectBase::GetTruePosition() const
{
    MercuryPoint pOut;
    MercuryMatrix copy( m_finalMatrix );
    VectorMultiply( copy, gpZero, pOut );
    return pOut;
}

bool MercuryObjectBase::IsHidden() const
{
    if (m_parentObject)
        return m_parentObject->IsHidden()||m_hidden;

    return m_hidden;
}

#include "MercuryObjectFactory.h"

CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetX, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetY, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetZ, (float), float );
CLASS_FUNCTION_NOARGS( MercuryObject, GetX, float );
CLASS_FUNCTION_NOARGS( MercuryObject, GetY, float );
CLASS_FUNCTION_NOARGS( MercuryObject, GetZ, float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, MoveX, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, MoveY, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, MoveZ, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetRotX, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetRotY, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetRotZ, (float), float );
CLASS_FUNCTION_NOARGS( MercuryObject, GetRotX, float );
CLASS_FUNCTION_NOARGS( MercuryObject, GetRotY, float );
CLASS_FUNCTION_NOARGS( MercuryObject, GetRotZ, float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, MoveRotX, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, MoveRotY, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, MoveRotZ, (float), float );

CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetScaleX, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetScaleY, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetScaleZ, (float), float );
CLASS_FUNCTION_NOARGS( MercuryObject, GetScaleX, float );
CLASS_FUNCTION_NOARGS( MercuryObject, GetScaleY, float );
CLASS_FUNCTION_NOARGS( MercuryObject, GetScaleZ, float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, MoveScaleX, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, MoveScaleY, (float), float );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, MoveScaleZ, (float), float );

CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetRotationMode, (RotationMode) (int), int );

CLASS_FUNCTION_NOARGS( MercuryObject, GetParentObject, void* );
CLASS_FUNCTION_NOARGS( MercuryObject, GetHide, bool );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetHide, (bool), bool );

CLASS_FUNCTION_NOARGS( MercuryObject, GetDrawOrder, int );
CLASS_FUNCTION_VOID_ONEARG( MercuryObject, SetDrawOrder, (int), int );

/* 
 * Copyright (c) 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