photon.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
Photon::Photon() :
    m_flags(0)
{
}

inline
void Photon::SetPosition(const sheep::Point3 &position) {
    m_position[0] = static_cast<sheep::float32>(position.m_x);
    m_position[1] = static_cast<sheep::float32>(position.m_y);
    m_position[2] = static_cast<sheep::float32>(position.m_z);
}

inline
sheep::Point3 Photon::GetPosition() const {
    return sheep::Point3(m_position[0], m_position[1], m_position[2]);
}

inline
void Photon::SetPower(const Color3 &power) {
#ifdef COMPRESS_PHOTON_POWER
    power.ConvertToRGBE(&m_power[0], &m_power[1], &m_power[2], &m_power[3]);
#else
    m_power[0] = static_cast<sheep::float32>(power.m_r);
    m_power[1] = static_cast<sheep::float32>(power.m_g);
    m_power[2] = static_cast<sheep::float32>(power.m_b);
#endif  // COMPRESS_PHOTON_POWER
}

inline
void Photon::ScalePower(sheep::Real scale) {
#ifdef COMPRESS_PHOTON_POWER
    Color3 c = Color3::ConvertFromRGBE(m_power[0], m_power[1], m_power[2], m_power[3]);

    c *= scale;

    c.ConvertToRGBE(
        &m_power[0],
        &m_power[1],
        &m_power[2],
        &m_power[3]);
#else
    m_power[0] *= static_cast<sheep::float32>(scale);
    m_power[1] *= static_cast<sheep::float32>(scale);
    m_power[2] *= static_cast<sheep::float32>(scale);
#endif  // COMPRESS_PHOTON_POWER
}

inline
Color3 Photon::GetPower() const {
#ifdef COMPRESS_PHOTON_POWER
    return Color3::ConvertFromRGBE(m_power[0], m_power[1], m_power[2], m_power[3]);
#else
    return Color3(m_power[0], m_power[1], m_power[2]);
#endif  // COMPRESS_PHOTON_POWER
}

inline
void Photon::SetIncidentDirection(const sheep::Vector3 &direction) {
    PackDirection(direction, &m_qphi, &m_qtheta);
}

inline
sheep::Vector3 Photon::GetIncidentDirection() const {
    return UnpackDirection(m_qphi, m_qtheta);
}

inline
void Photon::SetSplittingPlaneAxis(int axis) {
    assert(axis >= 0 && axis < 4);
    m_flags &= ~ sheep::uint16(3);  // reset bits 1 and 0
    m_flags |= axis;    // copy bits 1-0 of axis to bits 1-0 of m_flags
}

inline
int Photon::GetSplittingPlaneAxis() const {
    // Return bits 1 and 0.
    return m_flags & 3;
}

#ifdef ENABLE_RADIANCES_PRECOMPUTATION

inline
bool Photon::HasPrecomputedRadiance() const {
    // Return bit 2.
    return (m_flags & 4) != 0;
}

inline
void Photon::SetPrecomputedRadiance(const Color3 &radiance) {
#ifdef COMPRESS_PRECOMPUTED_RADIANCES
    radiance.ConvertToRGBE(&m_radiance[0], &m_radiance[1], &m_radiance[2], &m_radiance[3]);
#else
    m_radiance[0] = static_cast<sheep::float32>(radiance.m_r);
    m_radiance[1] = static_cast<sheep::float32>(radiance.m_g);
    m_radiance[2] = static_cast<sheep::float32>(radiance.m_b);
#endif  // COMPRESS_PRECOMPUTED_RADIANCES

    m_flags |= 4;   // set bit 2
}

inline
Color3 Photon::GetPrecomputedRadiance() const {
    assert(HasPrecomputedRadiance());

#ifdef COMPRESS_PRECOMPUTED_RADIANCES
    return Color3::ConvertFromRGBE(m_radiance[0], m_radiance[1], m_radiance[2], m_radiance[3]);
#else
    return Color3(m_radiance[0], m_radiance[1], m_radiance[2]);
#endif  // COMPRESS_PRECOMPUTED_RADIANCES
}

inline
void Photon::SetSurfaceNormal(const sheep::Vector3 &normal) {
    PackDirection(normal, &m_qnormal);
}

inline
sheep::Vector3 Photon::GetSurfaceNormal() const {
    return UnpackDirection(m_qnormal);
}

#endif  // ENABLE_RADIANCES_PRECOMPUTATION

inline
void Photon::WriteToStream(sheep::BinaryStream &os) const {
    // Position (12 bytes).
    os.Write(m_position[0]);
    os.Write(m_position[1]);
    os.Write(m_position[2]);

#ifdef COMPRESS_PHOTON_POWER
    // Compressed power (4 bytes).
    os.Write(m_power[0]);
    os.Write(m_power[1]);
    os.Write(m_power[2]);
    os.Write(m_power[3]);
#else
    // Full precision power (12 bytes).
    os.Write(m_power[0]);
    os.Write(m_power[1]);
    os.Write(m_power[2]);
#endif  // COMPRESS_PHOTON_POWER

    // Compressed incident direction (2 bytes).
    os.Write(m_qphi);
    os.Write(m_qtheta);

#ifdef ENABLE_RADIANCES_PRECOMPUTATION
#ifdef COMPRESS_PRECOMPUTED_RADIANCES
    // Compressed precomputed radiance (4 bytes).
    os.Write(m_radiance[0]);
    os.Write(m_radiance[1]);
    os.Write(m_radiance[2]);
    os.Write(m_radiance[3]);
#else
    // Full precision precomputed radiance (12 bytes).
    os.Write(m_radiance[0]);
    os.Write(m_radiance[1]);
    os.Write(m_radiance[2]);
#endif  // COMPRESS_PRECOMPUTED_RADIANCES
    // Normal of the surface at the photon position (1 byte).
    os.Write(m_qnormal);
#endif  // ENABLE_RADIANCES_PRECOMPUTATION

    // Various flags and data (2 bytes).
    os.Write(m_flags);

    // Ignore padding bytes.
}

inline
void Photon::ReadFromStream(sheep::BinaryStream &is) {
    // Position (12 bytes).
    is.Read(&m_position[0]);
    is.Read(&m_position[1]);
    is.Read(&m_position[2]);

#ifdef COMPRESS_PHOTON_POWER
    // Compressed power (4 bytes).
    is.Read(&m_power[0]);
    is.Read(&m_power[1]);
    is.Read(&m_power[2]);
    is.Read(&m_power[3]);
#else
    // Full precision power (12 bytes).
    is.Read(&m_power[0]);
    is.Read(&m_power[1]);
    is.Read(&m_power[2]);
#endif  // COMPRESS_PHOTON_POWER

    // Compressed incident direction (2 bytes).
    is.Read(&m_qphi);
    is.Read(&m_qtheta);

#ifdef ENABLE_RADIANCES_PRECOMPUTATION
#ifdef COMPRESS_PRECOMPUTED_RADIANCES
    // Compressed precomputed radiance (4 bytes).
    is.Read(&m_radiance[0]);
    is.Read(&m_radiance[1]);
    is.Read(&m_radiance[2]);
    is.Read(&m_radiance[3]);
#else
    // Full precision precomputed radiance (12 bytes).
    is.Read(&m_radiance[0]);
    is.Read(&m_radiance[1]);
    is.Read(&m_radiance[2]);
#endif  // COMPRESS_PRECOMPUTED_RADIANCES
    // Normal of the surface at the photon position (1 byte).
    is.Read(&m_qnormal);
#endif  // ENABLE_RADIANCES_PRECOMPUTATION

    // Various flags and data (2 bytes).
    is.Read(&m_flags);

    // Leave padding bytes undefined.
}

---