UVWPoint.h

Go to the documentation of this file.

//! @file UVWPoint.h
//! @brief CUVWPoint is a point that have u, v, w coordinates
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(AFX_UVWPOINT_H__87AE9F02_44D4_11D3_A382_B19716B5FB20__INCLUDED_)
#define AFX_UVWPOINT_H__87AE9F02_44D4_11D3_A382_B19716B5FB20__INCLUDED_
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "Point.h"
#include "3DVector.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
//! @class CUVWPoint
//! @brief CUVWPoint is a point that have u, v, w for handling object texturing.
class DLL_3DFUNCTION CUVWPoint : public CPt  
{
public:
    real u, v, w;
 
    CUVWPoint();
    CUVWPoint(real u, real v, real w);
 
    void Init(real u, real v, real w);
    
    // Access operators
    real& operator[](int i);
    const real& operator[](int i) const;
    real* ValPtr();
 
    void GetUVCoordinate(float& u, float& v);
 
    virtual void To4DPoint(C4DPoint& pt) const;
    virtual CPt& operator=(const C4DPoint& pt);
    virtual void Serialize(CXArchive& ar);
    virtual CPt& operator=(const CPt& refpoint); // virtual copy operator (must be defined to allow low level copy)
 
    CUVWPoint& operator=(const CUVWPoint& coord);
    bool operator==(const CUVWPoint& coord) const;
    CUVWPoint operator-(const CUVWPoint& uvw) const;
    CUVWPoint operator+(const CUVWPoint& uvw) const;
    void operator-=(const CUVWPoint& uvw);
    void operator+=(const CUVWPoint& uvw);
 
    void operator*=(const real& weight);
 
    operator C3DVector() const;
    operator C3DPoint() const;
    static C3DVector Vector(const CUVWPoint& A, const CUVWPoint& B); // Return AB vector from UVW
 
    void GetFloat2(float *values2f) const;  // Get point and fill 3 floats
    void SetFloat2(const float *values2f);  // Set point from 2 floats
    void GetDouble2(double *values2d) const; // Get point and fill 2 doubles
    void SetDouble2(const double *values2d); // Set point from 2 doubles
    void GetFloat3(float *values3f) const;  // Get point and fill 3 floats
    void SetFloat3(const float *values3f);  // Set point from 3 floats
    void GetDouble3(double *values3d) const; // Get point and fill 3 doubles
    void SetDouble3(const double *values3d); // Set point from 3 doubles
 
#ifdef _DEBUG
    virtual void Dump() const;
    bool IsKindOf(unsigned int classid) const;
    virtual unsigned int ClassID() const;
#endif
};
 
template <> class CHashMethods<CUVWPoint>
{
public:
    static inline bool HashCompare(const CUVWPoint& pt1, const CUVWPoint& pt2)
    {
        if (pt1.u != pt2.u || pt1.v != pt2.v || pt1.w != pt2.w)
            return false;
 
        return true;
    }
 
    static inline unsigned int HashValue(const CUVWPoint& hash)
    {
        return CHashMethods<real>::HashValue(hash.u + hash.v + hash.w);
    }
};
 
//////////////////////////////////////////////////////////
// CUVWPoint implementation
inline C3DVector CUVWPoint::Vector(const CUVWPoint& pt1, const CUVWPoint& pt2)
{
    C3DVector vector;
    vector.x = pt2.u - pt1.u;
    vector.y = pt2.v - pt1.v;
    vector.z = pt2.w - pt1.w;
    return vector;
}
 
inline CUVWPoint::CUVWPoint()
{
    u = 0.0f;
    v = 0.0f;
    w = 0.0f;
}
 
inline CUVWPoint::CUVWPoint(real u, real v, real w)
{
    this->u = u;
    this->v = v;
    this->w = w;
}
 
inline void CUVWPoint::Init(real u, real v, real w)
{
    this->u = (real)u;
    this->v = (real)v;
    this->w = (real)w;
}
 
// Access operators
inline real& CUVWPoint::operator[](int i)
{
    return (&u)[i];
}
 
inline const real& CUVWPoint::operator[](int i) const
{
    return (&u)[i];
}
 
inline real* CUVWPoint::ValPtr()
{
    return(&u);
}
 
inline CUVWPoint& CUVWPoint::operator=(const CUVWPoint& coord)
{
    CPt::operator=(coord);
    u = coord.u;
    v = coord.v;
    w = coord.w;
 
    return *this;
}
 
inline CPt& CUVWPoint::operator=(const CPt& refpoint)
{
    XASSERT(refpoint.IsKindOf(CUVWPoint::ClassID()));
 
    this->u = ((CUVWPoint&)refpoint).u;
    this->v = ((CUVWPoint&)refpoint).v;
    this->w = ((CUVWPoint&)refpoint).w;
 
    return CPt::operator=(refpoint);
}
 
inline bool CUVWPoint::operator==(const CUVWPoint& coord) const
{
    if (u != coord.u)
        return false;
 
    if (v != coord.v)
        return false;
 
    if (w != coord.w)
        return false;
 
    return true;
}
 
inline CUVWPoint CUVWPoint::operator-(const CUVWPoint& uvw) const
{
    return CUVWPoint(u - uvw.u, v - uvw.v, w - uvw.w);
}
 
inline CUVWPoint CUVWPoint::operator+(const CUVWPoint& uvw) const
{
    return CUVWPoint(u + uvw.u, v + uvw.v, w + uvw.w);
}
 
inline void CUVWPoint::operator-=(const CUVWPoint& uvw)
{
    u -= uvw.u;
    v -= uvw.v;
    w -= uvw.w;
}
 
inline void CUVWPoint::operator+=(const CUVWPoint& uvw)
{
    u += uvw.u;
    v += uvw.v;
    v += uvw.w;
}
 
inline void CUVWPoint::operator*=(const real& weight)
{
    u *= weight;
    v *= weight;
    w *= weight;
}
 
inline CUVWPoint::operator C3DVector() const
{
    return C3DVector(u, v, w);
}
 
inline CUVWPoint::operator C3DPoint() const
{
    return C3DPoint(u, v, w);
}
 
inline void CUVWPoint::GetFloat2(float *values2f) const
{
    values2f[0] = u;
    values2f[1] = v;
}
 
inline void CUVWPoint::SetFloat2(const float *values2f)
{
    u = values2f[0];
    v = values2f[1];
    w = (real)0.0;
}
 
inline void CUVWPoint::GetDouble2(double *values2d) const
{
    values2d[0] = u;
    values2d[1] = v;
}
 
inline void CUVWPoint::SetDouble2(const double *values2d)
{
    u = (real)values2d[0];
    v = (real)values2d[1];
    w = (real)0.0;
}
 
inline void CUVWPoint::GetFloat3(float *values3f) const
{
    values3f[0] = u;
    values3f[1] = v;
    values3f[1] = w;
}
 
inline void CUVWPoint::SetFloat3(const float *values3f)
{
    u = values3f[0];
    v = values3f[1];
    w = values3f[2];
}
 
inline void CUVWPoint::GetDouble3(double *values3d) const
{
    values3d[0] = u;
    values3d[1] = v;
    values3d[1] = w;
}
 
inline void CUVWPoint::SetDouble3(const double *values3d)
{
    u = (real)values3d[0];
    v = (real)values3d[1];
    w = (real)values3d[2];
}
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(AFX_UVWPOINT_H__87AE9F02_44D4_11D3_A382_B19716B5FB20__INCLUDED_)