MercuryVertex.h

Go to the documentation of this file.

#ifndef MERCURYVERTEX_H
#define MERCURYVERTEX_H

#include "MercuryTypes.h"
#include "MercuryVector.h"

class MercuryPoly;

typedef MercuryPoint MercuryNormal;

class MercuryVertex
{
public:
    MercuryVertex();
    MercuryVertex( const float ix, const float iy, const float iz, const float iu, const float iv );

    //Act like an old vertice, which was a point
    inline const float GetX() const { return x; }
    inline const float GetY() const { return y; }
    inline const float GetZ() const { return z; }
    inline void SetX(const float ix) { x = ix; }
    inline void SetY(const float iy) { y = iy; }
    inline void SetZ(const float iz) { z = iz; }
    inline void ConvertToVector3( MercuryPoint & out ) const { out[0] = x; out[1] = y; out[2] = z; }
    inline void ConvertFromVector3( const MercuryPoint & in ) { x = in[0]; y = in[1]; z = in[2]; }
    inline MercuryPoint& GetPointHandle() { return *(MercuryPoint*)&x; }

    inline MercuryVertex& operator += ( const MercuryVertex& other ) { x+=other.x; y+=other.y; z+=other.z; return *this; }
    inline MercuryVertex& operator -= ( const MercuryVertex& other ) { x-=other.x; y-=other.y; z-=other.z; return *this; }
    inline MercuryVertex& operator *= ( float f ) { x*=f; y*=f; z*=f; return *this; }
    inline MercuryVertex& operator /= ( float f ) { x/=f; y/=f; z/=f; return *this; }

    inline MercuryVertex operator + ( const MercuryVertex& other ) const { return MercuryVertex( x+other.x, y+other.y, z+other.z, m_uv[0], m_uv[1] ); }
    inline MercuryVertex operator - ( const MercuryVertex& other ) const { return MercuryVertex( x-other.x, y-other.y, z-other.z, m_uv[0], m_uv[1] ); }
    inline MercuryVertex operator * ( float f ) const { return MercuryVertex( x*f, y*f, z*f, m_uv[0], m_uv[1] ); }
    inline MercuryVertex operator / ( float f ) const { return MercuryVertex( x/f, y/f, z/f, m_uv[0], m_uv[1] ); }

    MercuryVertex CrossProduct(const MercuryVertex& second);

    inline void GetUV(float* uv) const { uv[0] = m_uv[0]; uv[1] = m_uv[1]; }
    inline void SetUV(const float* uv) { m_uv[0] = uv[0]; m_uv[1] = uv[1]; }
    inline void SetU(const float u) { m_uv[0] = u; }
    inline void SetV(const float v) { m_uv[1] = v; }
    inline const MercuryNormal& GetNormal() const { return m_normal; }

    inline void GetNormal(MercuryNormal*& normal) { normal = &m_normal; }

    void SetNormal(MercuryNormal normal) { m_normal = normal; }

    /*  This must stay organized in this fashion so that we can quickly send
        data to OpenGL as a tightly packed interleaved arrays.
        u,v,n1,n2,n3,v1,v2,v3
    */
    float m_uv[2]; //Origional UV points.
    MercuryNormal m_normal;

    //as similar to a point as possible
    float x;
    float y;
    float z;
} M_ALIGN(32);

//This vertex wrapper will contain extra information needed for
//things like normal recalculation
struct MercuryVertWrapper
{
    MDeque<MercuryPoly*> m_sharingPolys;
    MDequeIterator<MercuryPoly*> FindSharingPoly(MercuryPoly* p);
    MercuryVertex* m_vertex;
};

#endif

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