MercuryObjectBase.h

Go to the documentation of this file.

#ifndef MERCURYOBJECTBASE_H
#define MERCURYOBJECTBASE_H

//#include "MercuryUtil.h"
#include "MercuryTypes.h"


enum RotationMode
{
    RM_NORMAL,
    RM_BILLBOARD,
    RM_MATRIX,
    RM_QUATERNION,
    RM_OFF
};

class MercuryObjectBase 
{
public:
    MercuryObjectBase();
    virtual ~MercuryObjectBase() {};
    virtual void Init();

    virtual void CalculateMatrices();

    void Debug( const float z );

    //Position
    inline void SetX(const float x) { m_taintedMatrix |= m_position.SetX(x); }
    inline void SetY(const float y) { m_taintedMatrix |= m_position.SetY(y); }
    inline void SetZ(const float z) { m_taintedMatrix |= m_position.SetZ(z); }
    inline void SetPosition(const MercuryPoint& position) { m_taintedMatrix = true; m_position = position; }
    inline float GetX() const { return m_position.GetX(); }
    inline float GetY() const { return m_position.GetY(); }
    inline float GetZ() const { return m_position.GetZ(); }
    inline const MercuryPoint& GetPosition() const { return m_position; }
    inline void MoveX(const float x) { m_taintedMatrix |= m_position.SetX(x + m_position.GetX()); }
    inline void MoveY(const float y) { m_taintedMatrix |= m_position.SetY(y + m_position.GetY()); }
    inline void MoveZ(const float z) { m_taintedMatrix |= m_position.SetZ(z + m_position.GetZ()); }

    //Rotation
    inline void SetRotX(const float x) { m_taintedMatrix |= m_rotation.SetX(x); }
    inline void SetRotY(const float y) { m_taintedMatrix |= m_rotation.SetY(y); }
    inline void SetRotZ(const float z) { m_taintedMatrix |= m_rotation.SetZ(z); }
    inline void SetRot(const MercuryPoint& rotation) { m_taintedMatrix = true; m_rotation = rotation; }
    inline float GetRotX() const { return m_rotation.GetX(); }
    inline float GetRotY() const { return m_rotation.GetY(); }
    inline float GetRotZ() const { return m_rotation.GetZ(); }
    inline const MercuryPoint& GetRot() const { return m_rotation; }
    inline void MoveRotX(const float x) { m_taintedMatrix |= m_rotation.SetX(x + m_rotation.GetX()); }
    inline void MoveRotY(const float y) { m_taintedMatrix |= m_rotation.SetY(y + m_rotation.GetY()); }
    inline void MoveRotZ(const float z) { m_taintedMatrix |= m_rotation.SetZ(z + m_rotation.GetZ()); }
    inline RotationMode GetRotMode() const { return m_rotMode; }

    //Scale
    inline void SetScaleX(const float x) { m_taintedMatrix |= m_scale.SetX(x); }
    inline void SetScaleY(const float y) { m_taintedMatrix |= m_scale.SetY(y); }
    inline void SetScaleZ(const float z) { m_taintedMatrix |= m_scale.SetZ(z); }
    inline void SetScale(const MercuryPoint& scale) { m_taintedMatrix = true; m_scale = scale; }
    inline float GetScaleX() const { return m_scale.GetX(); }
    inline float GetScaleY() const { return m_scale.GetY(); }
    inline float GetScaleZ() const { return m_scale.GetZ(); }
    inline const MercuryPoint& GetScale() const { return m_scale; }
    inline void MoveScaleX(const float x) { m_taintedMatrix |= m_scale.SetX(x + m_scale.GetX()); }
    inline void MoveScaleY(const float y) { m_taintedMatrix |= m_scale.SetY(y + m_scale.GetY()); }
    inline void MoveScaleZ(const float z) { m_taintedMatrix |= m_scale.SetZ(z + m_scale.GetZ()); }

    //Parent Stuffs
    inline void SetParentObject(MercuryObjectBase* parent) { m_parentObject = parent; }
    MercuryPoint GetGlobalPosition() const;
    inline MercuryObjectBase * GetParentObject() { return m_parentObject; }

    void SetRotationMode( const RotationMode mode ) { m_taintedMatrix = true; m_rotMode = mode; }

    inline void SetAfterMatrix( const float* inmat ) { m_taintedMatrix = true; m_matrix = inmat; }
    inline const MercuryMatrix& GetAfterMatrix( ) const { return m_matrix; }

    inline void SetRotationQuaternion( const MQuaternion& q) { m_taintedMatrix = true; m_rotQuat = q; }
    inline const MQuaternion& GetRotationQuaternion() const { return m_rotQuat; }
    
    inline void SetAlignX(float x) { if (x != m_xalign) { m_taintedMatrix = true; m_xalign = x; } }
    inline void SetAlignY(float y) { if (y != m_yalign) { m_taintedMatrix = true; m_yalign = y; } }

    inline void SetHide(bool hide) { m_hidden = hide; }
    inline bool GetHide() const { return m_hidden; }
    bool IsHidden() const;

    //Lower numbers are drawn first.
    virtual void SetDrawOrder(int order) { m_drawOrder = order; }
    inline int GetDrawOrder() const { return m_drawOrder; }

    inline bool operator<(const MercuryObjectBase& r) const { return m_drawOrder < r.m_drawOrder; }
    inline bool operator>=(const MercuryObjectBase& r) const { return m_drawOrder >= r.m_drawOrder; }

    inline bool IsMatrixTainted() const { return m_taintedMatrix; }
    void SetMatrixTainted(bool taint) { m_taintedMatrix = taint; }
    const MercuryMatrix& GetLocalMatrix() const { return m_localMatrix; }
    const MercuryMatrix& GetFinalMatrix() const { return m_finalMatrix; }
    MercuryPoint GetTruePosition() const;

protected:

    float m_fVisRadius;

    bool m_hidden;
    int m_drawOrder;
    
    MercuryObjectBase* m_parentObject;

    MercuryMatrix m_localMatrix;
    MercuryMatrix m_finalMatrix;

//private:
    MercuryPoint m_scale;
    MercuryPoint m_position;
    MercuryPoint m_rotation;

    MercuryMatrix m_matrix; //After-matrix.  This is used for any additional manual changes)
    MQuaternion m_rotQuat;

    RotationMode m_rotMode;

    float m_xalign, m_yalign;

    bool m_taintedMatrix;
};

#endif

/* 
 * 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