utilities.inl

Go to the documentation of this file.

/*
    toxic - A Global Illumination Renderer
    Copyright (C) 2003-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of toxic.

    toxic is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    toxic is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with toxic; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

inline
int IntSquareRoot(int n) {
    return static_cast<int>(sqrt(static_cast<double>(n)));
}

inline
bool IsSquare(int n) {
    return sheep::sq(IntSquareRoot(n)) == n;
}

inline
void VectorToSphericalCoords(const sheep::Vector3 &v,
                             sheep::Real *phi,
                             sheep::Real *theta)
{
    assert(v.IsUnitLength());
    assert(phi);
    assert(theta);

    *phi = atan2(v.m_z, v.m_x);

    if(*phi < 0.0)
        *phi += 2.0 * sheep::PI;    //!\todo Turn the multiplication into an addition.

    *theta = acos(v.m_y);

    assert(*phi >= 0.0 && *phi <= 2.0 * sheep::PI);
    assert(*theta >= 0.0 && *theta <= sheep::PI);
}

inline
sheep::Vector3 SphericalCoordsToVector(sheep::Real phi, sheep::Real theta) {
    const sheep::Real sin_theta = sin(theta);

    const sheep::Vector3 v(
        cos(phi) * sin_theta,
        cos(theta),
        sin(phi) * sin_theta);

    assert(v.IsUnitLength());

    return v;
}

inline
void PackSphericalCoords(sheep::Real phi, sheep::Real theta,
                         sheep::uint8 *qphi, sheep::uint8 *qtheta)
{
    assert(qphi);
    assert(qtheta);

    phi = sheep::NormalizeAngle(phi);
    theta = sheep::NormalizeAngle(theta);

    assert(phi >= 0.0 && phi <= 2.0 * sheep::PI);
    assert(theta >= 0.0 && theta <= sheep::PI);

    int qphi1 = static_cast<int>(phi * (128.0 / sheep::PI));
    assert(qphi1 >= 0 && qphi1 <= 256);

    if(qphi1 > 255)
        *qphi = 255;
    else *qphi = static_cast<sheep::uint8>(qphi1);

    int qtheta1 = static_cast<int>(theta * (256.0 / sheep::PI));
    assert(qtheta1 >= 0 && qtheta1 <= 256);

    if(qtheta1 > 255)
        *qtheta = 255;
    else *qtheta = static_cast<sheep::uint8>(qtheta1);
}

inline
void UnpackSphericalCoords(sheep::uint8 qphi, sheep::uint8 qtheta,
                           sheep::Real *phi, sheep::Real *theta)
{
    //!\todo Could be faster with a conversion table.
    *phi = qphi * (sheep::PI / 128.0);
    *theta = qtheta * (sheep::PI / 256.0);

    assert(*phi >= 0.0 && *phi <= 2.0 * sheep::PI);
    assert(*theta >= 0.0 && *theta <= sheep::PI);
}

inline
void PackSphericalCoords(sheep::Real phi, sheep::Real theta,
                         sheep::uint8 *q)
{
    assert(q);

    phi = sheep::NormalizeAngle(phi);
    theta = sheep::NormalizeAngle(theta);

    assert(phi >= 0.0 && phi <= 2.0 * sheep::PI);
    assert(theta >= 0.0 && theta <= sheep::PI);

    int qphi = static_cast<int>(phi * (8.0 / sheep::PI));
    assert(qphi >= 0 && qphi <= 16);

    if(qphi > 15)
        qphi = 15;

    int qtheta = static_cast<int>(theta * (16.0 / sheep::PI));
    assert(qtheta >= 0 && qtheta <= 16);

    if(qtheta > 15)
        qtheta = 15;

    *q = (static_cast<sheep::uint8>(qphi) << 4) + static_cast<sheep::uint8>(qtheta);
}

inline
void UnpackSphericalCoords(sheep::uint8 q,
                           sheep::Real *phi, sheep::Real *theta)
{
    //!\todo Could be faster with a conversion table.
    sheep::uint8 qphi = q >> 4;
    sheep::uint8 qtheta = q & 15;

    *phi = qphi * (sheep::PI / 8.0);
    *theta = qtheta * (sheep::PI / 16.0);

    assert(*phi >= 0.0 && *phi <= 2.0 * sheep::PI);
    assert(*theta >= 0.0 && *theta <= sheep::PI);
}

inline
void PackDirection(const sheep::Vector3 &v,
                   sheep::uint8 *qphi,
                   sheep::uint8 *qtheta)
{
    sheep::Real phi, theta;
    VectorToSphericalCoords(v, &phi, &theta);
    PackSphericalCoords(phi, theta, qphi, qtheta);
}

inline
void PackDirection(const sheep::Vector3 &v, sheep::uint8 *q) {
    sheep::Real phi, theta;
    VectorToSphericalCoords(v, &phi, &theta);
    PackSphericalCoords(phi, theta, q);
}

inline
sheep::Vector3 UnpackDirection(sheep::uint8 qphi, sheep::uint8 qtheta) {
    const sheep::Real sin_theta = ConversionTables::m_sin_theta[qtheta];

    const sheep::Vector3 v(
        ConversionTables::m_cos_phi[qphi] * sin_theta,
        ConversionTables::m_cos_theta[qtheta],
        ConversionTables::m_sin_phi[qphi] * sin_theta);

    assert(v.IsUnitLength());

    return v;
}

inline
sheep::Vector3 UnpackDirection(sheep::uint8 q) {
    return ConversionTables::m_direction[q];
}

---