eng_volume.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2007 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#ifndef ENG_VOLUME_HH
#define ENG_VOLUME_HH 1

namespace eng {

class SphereVolume;
class BoxVolume;

class Volume : public Shared
{
public:
                            Volume( void ) { }
    virtual                 ~Volume() { }

// Abstract methods:
// Space-neutral Vector3 is used, not WorldVertex nor LocalVertex.
    virtual SphereVolume    ToSphereVolume( void ) const = 0;
    virtual BoxVolume       ToBoxVolume( void ) const = 0;
    virtual bool            IfInside( const Vector3& v ) const = 0;
    virtual bool            IfInside( const Volume& volume ) const = 0;  
    virtual bool            IfOutside( const Volume& volume ) const = 0;  
    virtual Vector3         GetPosition( void ) const = 0;
    virtual void            SetPosition( const Vector3& position ) = 0;

// Virtual default methods:
    virtual bool IfOutside( const Vector3& v ) const
    {
        return not IfInside(v);
    }

    virtual bool IfIntersecting( const Volume& volume ) const
    {
        // Logical, inefficient, infrequent.
        return (not IfInside(volume)) && (not IfOutside(volume));
    }
};

class SphereVolume : public Volume
{
public:
                    SphereVolume( const Vector3& position, const fp radius );
                    ~SphereVolume();

// Implement abstract methods:
    SphereVolume    ToSphereVolume( void ) const { return *this; }
    BoxVolume       ToBoxVolume( void ) const;
    bool            IfInside( const Vector3& v ) const;
    bool            IfOutside( const Vector3& v ) const { return not IfInside(v); }  // fix compile
    bool            IfInside( const Volume& volume ) const;
    bool            IfOutside( const Volume& volume ) const;
  //bool            IfIntersecting( const Volume& volume ) const;  // default
    Vector3         GetPosition( void ) const { return mPosition; }
    void            SetPosition( const Vector3& position ) { mPosition = position; }

// Specific methods:
    bool            IfInside( const SphereVolume& volume ) const;
    bool            IfOutside( const SphereVolume& volume ) const;
    fp              GetRadius( void ) const { return mRadius; }
    void            Grow( const Vector3& v );
    friend bool inline operator==( const SphereVolume& a, const SphereVolume& b )
    {
        return (a.mPosition == b.mPosition) && (a.mRadius == b.mRadius);
    }
    friend bool inline operator!=( const SphereVolume& a, const SphereVolume& b )
    {
        return not (a == b);
    }
#if DEBUG
bool Check( void ) const;
#endif

private:
    Vector3     mPosition;
    fp          mRadius;
};

ostream& operator<<( ostream& strm, const SphereVolume& sphereVolume );

class BoxVolume : public Volume
{
public:
                    BoxVolume( void );
                    BoxVolume( const Vector3& minimum, const Vector3& maximum );
                    BoxVolume( const SphereVolume& sphereVolume );
                    ~BoxVolume();

// Implement abstract methods:
    SphereVolume    ToSphereVolume( void ) const;
    BoxVolume       ToBoxVolume( void ) const { return BoxVolume(*this); }
    bool            IfInside( const Vector3& v ) const;
    bool            IfOutside( const Vector3& v ) const { return not IfInside(v); }  // fix compile
    bool            IfInside( const Volume& volume ) const;
    bool            IfOutside( const Volume& volume ) const;
    bool            IfIntersecting( const Volume& volume ) const;
    Vector3         GetPosition( void ) const;
    void            SetPosition( const Vector3& position );

// Specific methods:
    fp              GetRadius( void ) const;
    bool            IfOutside( const BoxVolume& other ) const;
    bool            IfInside( const BoxVolume& other ) const;  // BoxVolume arg
    bool            IfIntersecting( const BoxVolume& other ) const;
    void            Set( const Vector3& v1, const Vector3& v2 );
    void            Grow( const Vector3& v );
    void            Grow( const BoxVolume& other );
    Vector3         GetCenter( void ) const;
    Vector3         GetMidOffset( void ) const;
    bool            IfEmpty( void ) const;  // if volume is empty
    bool            IfZero( void ) const;   // if equals (0,0,0,0,0,0)
    bool            IfCube( void ) const;
    friend bool inline operator==( const BoxVolume& a, const BoxVolume& b )
    {
        return (a.mMin == b.mMin)
            && (a.mMax == b.mMax);
    }
    friend bool inline operator!=( const BoxVolume& a, const BoxVolume& b )
    {
        return not (a == b);
    }

#if DEBUG
bool Check( void ) const;
#endif

public:
    Vector3     mMin;
    Vector3     mMax;
};

ostream& operator<<( ostream& strm, const BoxVolume& boxVolume );

class BSPVolume : private Volume
{
#if 0 // FUTURE
public:
                    BSPVolume( SharedPtr<BSP> bsp );
                    ~BSPVolume();

// Implement abstract methods:
    SphereVolume    ToSphereVolume( void ) const;
    BoxVolume       ToBoxVolume( void ) const;
    bool            IfInside( const Vector3& v ) const;
    bool            IfInside( const Volume& volume ) const;
    bool            IfOutside( const Volume& volume ) const;
    Vector3         GetPosition( void ) const;
    void            SetPosition( const Vector3& position );

// Cloning a BSPVolume will be cheap since root is a SharedPtr.
// All that's needed is to translate position to make it per-Object.

private:
    Vector3         mPosition;
    SharedPtr<Node>     mRoot;
#endif // FUTURE
};


INLINE fp
ApproxRadiusOfBox( const fp x_width, const fp y_width, const fp z_width )
{
    // (w/2,w/2,w/2) defines a corner of an expanded box (relative to center).
    // (1,1,1) = sqrt(1+1+1) = 1.732051.
    // approxRadius = maxWidth * 1.732051.

    const fp maxWidth = Max( x_width, Max(y_width,z_width) );
    return maxWidth * 0.5 * eng::defs::BOX_WIDTH_TO_RADIUS_SCALE;
}

} // namespace eng

#endif // ENG_VOLUME_HH

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:09 2007