SPT_Space3.h

Go to the documentation of this file.

/******************************************************************************
SPT_Space3.h

A Space class represents a point in 3D.

Modified from "RADIOSITY A Programmer's Perspective" by Ian Ashdown (1994)

Sukitti Punak   (10/24/2003)
Latest Update   (11/20/2003)
******************************************************************************/
#ifndef SPT_SPACE3_H
#define SPT_SPACE3_H

#include <iostream>
#include <cassert>

using std::ostream;

//=============================================================================
// CLASS:   SPtSpace3  ********************************************************
// DECLARATION PART  **********************************************************
// Desc:  3-D coordinates

template< typename T >
class SPtSpace3
{
    // Overloaded Operator   --------------------------------------------------
    friend ostream &operator<<( ostream &output, const SPtSpace3< T > &s )
    {
        output << "(" << s.x << "," << s.y << "," << s.z << ")'";
        return output;
    }


// Data Members  --------------------------------------------------------------
protected:
    T x;    // X-axis coordinate
    T y;    // Y-axis coordinate
    T z;    // Z-axis coordinate

// Member Functions  ----------------------------------------------------------
public:
    // Constructor
    SPtSpace3( T = 0, T = 0, T = 0 );

    // Get/Set member functions
    inline const T &GetX() const;
    inline const T &GetY() const;
    inline const T &GetZ() const;
    inline const T &Get( int ) const;
    inline void GetXYZ( T, T, T ) const;
    inline void SetX( T );
    inline void SetY( T );
    inline void SetZ( T );
    inline void Set( int, T );
    inline void SetXYZ( T, T, T );

    // Overloaded Operators
    inline T &operator[]( int );        
    inline const T &operator[]( int ) const;

};
// END CLASS:   SPtSpace3  ====================================================
// END DECLARATION PART  ======================================================



//=============================================================================
// CLASS:   SPtSpace3  ********************************************************
// DEFINITION PART  ***********************************************************
// Constructor(s)
template< typename T >
SPtSpace3< T >::SPtSpace3( T xval, T yval, T zval ) : x( xval ), y( yval ), z( zval ) { }

//-----------------------------------------------------------------------------
// Get/Set Member Functions
template< typename T >
inline const T &SPtSpace3< T >::GetX() const { return x; }
//-----------------------------------------------------------------------------
template< typename T >
inline const T &SPtSpace3< T >::GetY() const { return y; }
//-----------------------------------------------------------------------------
template< typename T >
inline const T &SPtSpace3< T >::GetZ() const { return z; }
//-----------------------------------------------------------------------------
template< typename T >
inline const T &SPtSpace3< T >::Get( int i ) const
{
    assert( 0 <= i && i < 3 );
    switch ( i ) {
        case 0: return x;
        case 1: return y;
        case 2: return z;
    }
    return x;
}
//-----------------------------------------------------------------------------
template< typename T >
inline void SPtSpace3< T >::GetXYZ( T vx, T vy, T vz ) const    { x = vx; y = vy; z = vz; };
//-----------------------------------------------------------------------------
template< typename T >
inline void SPtSpace3< T >::SetX( T val ) { x = val; }
//-----------------------------------------------------------------------------
template< typename T >
inline void SPtSpace3< T >::SetY( T val ) { y = val; }
//-----------------------------------------------------------------------------
template< typename T >
inline void SPtSpace3< T >::SetZ( T val ) { z = val; }
//-----------------------------------------------------------------------------
template< typename T >
inline void SPtSpace3< T >::Set( int, T val )
{
    assert( 0 <= i && i < 3 );
    switch ( i ) {
        case 0: x = val; break;
        case 1: y = val; break;
        case 2: z = val; break;
    }
}
//-----------------------------------------------------------------------------
template< typename T >
inline void SPtSpace3< T >::SetXYZ( T xval, T yval, T zval )
{   x = xval;   y = yval;   z = zval;   }


// Overloaded Operators     ***************************************************
//-----------------------------------------------------------------------------
template< typename T >
T &SPtSpace3< T >::operator []( int i )
{
    assert( 0 <= i && i < 3 );
    switch ( i ) {
        case 0: return x;
        case 1: return y;
        case 2: return z;
    }
    return x;
}
//-----------------------------------------------------------------------------
template< typename T >
const T &SPtSpace3< T >::operator []( int i ) const
{
    assert( 0 <= i && i < 3 );
    switch ( i ) {
        case 0: return x;
        case 1: return y;
        case 2: return z;
    }
    return x;
}

/*
// Friend Functions     *******************************************************
// Overloaded Operator  *******************************************************
template< typename T >
ostream &operator<<( ostream &output, const SPtSpace3< T > &s )
{
    output << "(" << s.x << "," << s.y << "," << s.z << ")'";
    return output;
}
// END CLASS:   SPtSpace3  ====================================================
// END DEFINITION PART  =======================================================
*/
#endif