---

VecUtil.h

Go to the documentation of this file.

/*
    File:           VecUtil.h
    
    Function:       Contains a grab-bag of useful graphics
                    vector routines.

    Author(s):      Andrew Willmott

    Copyright:      (c) 1996-2000, Andrew Willmott
    
 */
 
#ifndef __VecUtil__
#define __VecUtil__

#include "gcl/Geometry.h"
#include "gcl/Colour.h"


// --- Min & Max routines -----------------------------------------------------

inline GCLReal  MaxElt(const Vector &v);
inline GCLReal  MinElt(const Vector &v);

inline Int      MaxEltIndex(const Vector &v);
inline Int      MinEltIndex(const Vector &v);

inline Void     FindMaxElts(const Vector &a, const Vector &b, Vector &c);
inline Void     FindMinElts(const Vector &a, const Vector &b, Vector &c);

inline ClrReal  MaxCmpt(const Colour &c);
inline ClrReal  MinCmpt(const Colour &c);

inline Int      MaxCmptIndex(const Colour &c);
inline Int      MinCmptIndex(const Colour &c);

inline Void     FindMaxCmpts(const Colour &a, const Colour &b, Colour &c);
inline Void     FindMinCmpts(const Colour &a, const Colour &b, Colour &c);

// --- Bounding box utility routines ------------------------------------------

inline GCLReal  BoxVol(const Vector &min, const Vector &max);
inline GCLReal  BoxArea(const Vector &min, const Vector &max);
Void            UpdateBounds(const Point& pt, Point& min, Point& max);

// --- Miscellaneous ----------------------------------------------------------

Void CalcTriAreaNormal(
        const Point &a,
        const Point &b, 
        const Point &c,
        Vector      &n
    );

inline Bool PlaneIntersection(
        const Point     &start,
        const Vector    &direction,
        GCLReal         d, 
        const Vector    &normal, 
        GCLReal         &t
    )
{
    GCLReal normDotDirection = dot(normal, direction);
    
    if (normDotDirection == 0.0)
        return(false);

    t = (d + dot(normal, start)) / -normDotDirection;

    return(true);
}

Bool PointIsInsideTriangle(
        const Point     &v0,      
        const Point     &v1,      
        const Point     &v2,      
        const Point     &point,
        Vector          *coords = 0
    );

inline Vector FindOrthoVector(const Vector &v)
{
    Vector u;
    
    // we choose the axis that is most orthogonal to v,
    // and return the cross product of it and v. Really!

    if (abs(v[0]) < abs(v[1]))
        if (abs(v[0]) < abs(v[2]))
        {   u[0] =     0; u[1] =  v[2]; u[2] = -v[1]; }
        else
        {   u[0] =  v[1]; u[1] = -v[0]; u[2] =     0; }
    else
        if (abs(v[1]) < abs(v[2]))
        {   u[0] = -v[2]; u[1] =     0; u[2] =  v[0]; }
        else
        {   u[0] =  v[1]; u[1] = -v[0]; u[2] =     0; }
        
    return(u);
}

Vector RandomVector();

Bool Refract(
        GCLReal         fromIndex, 
        GCLReal         toIndex,
        const Vector    &v,
        const Vector    &n, 
        GCLReal         cosNV,
        Vector          &refractDir
    );

Void UnitSquareToUnitDisc(Coord in, Coord &out);
Void UnitDiskToUnitSquare(Coord in, Coord &out);
Void UnitSquareToUnitDisc(Coord in, Coord &out);
Void UnitDiskToUnitSquare(Coord in, Coord &out);
// What the names say: code from Shirley & Chiu, minimises adjacency,
// fractional area and aspect ratio distortions.

GCLReal ProjectToBox(Point &min, Point &max, Point &p, Vector &r);


// --- Inlines ----------------------------------------------------------------

inline GCLReal MaxElt(const Vector &v)
{
    return(Max(Max(v[0], v[1]), v[2]));
}

inline GCLReal MinElt(const Vector &v)
{
    return(Min(Min(v[0], v[1]), v[2]));
}

inline Int MinEltIndex(const Vector &v)
{
    if (v[0] < v[1])
        if (v[0] < v[2])
            return(0);
        else
            return(2);
    else
        if (v[1] < v[2])
            return(1);
        else
            return(2);
}

inline Int MaxEltIndex(const Vector &v)
{
    if (v[0] > v[1])
        if (v[0] > v[2])
            return(0);
        else
            return(2);
    else
        if (v[1] > v[2])
            return(1);
        else
            return(2);
}

inline Int MinCmptIndex(const Colour &c)
{
    if (c[0] < c[1])
        if (c[0] < c[2])
            return(0);
        else
            return(2);
    else
        if (c[1] < c[2])
            return(1);
        else
            return(2);
}

inline Int MaxCmptIndex(const Colour &c)
{
    if (c[0] > c[1])
        if (c[0] > c[2])
            return(0);
        else
            return(2);
    else
        if (c[1] > c[2])
            return(1);
        else
            return(2);
}

inline Void FindMaxElts(const Vector &a, const Vector &b, Vector &c)
{
    c[0] = Max(a[0], b[0]);
    c[1] = Max(a[1], b[1]);
    c[2] = Max(a[2], b[2]);
}

inline Void FindMinElts(const Vector &a, const Vector &b, Vector &c)
{
    c[0] = Min(a[0], b[0]);
    c[1] = Min(a[1], b[1]);
    c[2] = Min(a[2], b[2]);
}

inline ClrReal MaxCmpt(const Colour &c)
{
    return(Max(Max(c[0], c[1]), c[2]));
}

inline ClrReal MinCmpt(const Colour &c)
{
    return(Min(Min(c[0], c[1]), c[2]));
}

inline Void FindMaxCmpts(const Colour &a, const Colour &b, Colour &c)
{
    c[0] = Max(a[0], b[0]);
    c[1] = Max(a[1], b[1]);
    c[2] = Max(a[2], b[2]);
}

inline Void FindMinCmpts(const Colour &a, const Colour &b, Colour &c)
{
    c[0] = Min(a[0], b[0]);
    c[1] = Min(a[1], b[1]);
    c[2] = Min(a[2], b[2]);
}

inline GCLReal BoxVol(const Vector &min, const Vector &max)
{
    Vector t = max;

    t -= min;

    return(t[0] * t[1] * t[2]);
}

inline GCLReal BoxArea(const Vector &min, const Vector &max)
{
    Vector t = max;

    t -= min;

    return(2 * (t[0] * t[1] + t[1] * t[2] + t[2] * t[0]));
}

#endif

---