missed photon files
Wenzel Jakob
parent
a8f5628aef
commit
852d232cae
|
|
@ -0,0 +1,179 @@
|
|||
/*
|
||||
This file is part of Mitsuba, a physically based rendering system.
|
||||
|
||||
Copyright (c) 2007-2010 by Wenzel Jakob and others.
|
||||
|
||||
Mitsuba is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License Version 3
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
Mitsuba 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 this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#if !defined(__PHOTON_H)
|
||||
#define __PHOTON_H
|
||||
|
||||
#include <mitsuba/core/serialization.h>
|
||||
#include <mitsuba/core/aabb.h>
|
||||
|
||||
MTS_NAMESPACE_BEGIN
|
||||
|
||||
/** \brief Memory-efficient photon representation
|
||||
*
|
||||
* Requires 24 bytes when Mitsuba is compiled with single precision
|
||||
* and RGB-based color spectra.
|
||||
*/
|
||||
struct Photon {
|
||||
friend class PhotonMap;
|
||||
public:
|
||||
// ======================================================================
|
||||
/// @{ \name Photon attributes
|
||||
// ======================================================================
|
||||
|
||||
float pos[3]; //!< Photon position in single precision
|
||||
#if defined(DOUBLE_PRECISION) || SPECTRUM_SAMPLES > 3
|
||||
Spectrum power; //!< Accurate spectral photon power representation
|
||||
#else
|
||||
uint8_t power[4]; //!< Photon power stored in Greg Ward's RGBE format
|
||||
#endif
|
||||
uint8_t theta; //!< Discretized photon direction (\a theta component)
|
||||
uint8_t phi; //!< Discretized photon direction (\a phi component)
|
||||
uint8_t thetaN; //!< Discretized surface normal (\a theta component)
|
||||
uint8_t phiN; //!< Discretized surface normal (\a phi component)
|
||||
uint16_t depth; //!< Photon depth (number of preceding interactions)
|
||||
uint8_t axis; //!< Split axis in the associated KD-tree
|
||||
uint8_t unused; //!< Unused 8-bit field (needed for alignment)
|
||||
|
||||
/// @}
|
||||
// ======================================================================
|
||||
|
||||
/// Dummy constructor
|
||||
inline Photon() { }
|
||||
|
||||
/// Construct from a photon interaction
|
||||
Photon(const Point &pos, const Normal &normal,
|
||||
const Vector &dir, const Spectrum &power,
|
||||
uint16_t depth);
|
||||
|
||||
/// Unserialize from a binary data stream
|
||||
Photon(Stream *stream);
|
||||
|
||||
/// @}
|
||||
// ======================================================================
|
||||
|
||||
/// Return the depth (in # of interactions)
|
||||
inline int getDepth() const {
|
||||
return depth;
|
||||
}
|
||||
|
||||
/// Compute the squared distance between this photon and some point.
|
||||
inline float distSquared(const float *q) const {
|
||||
float dist1 = pos[0]-q[0], dist2 = pos[1]-q[1],
|
||||
dist3 = pos[2]-q[2];
|
||||
return dist1*dist1 + dist2*dist2 + dist3*dist3;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert the photon direction from quantized spherical coordinates
|
||||
* to a floating point vector value. Precomputation idea based on
|
||||
* Jensen's implementation.
|
||||
*/
|
||||
inline Vector getDirection() const {
|
||||
return Vector(
|
||||
m_cosPhi[phi] * m_sinTheta[theta],
|
||||
m_sinPhi[phi] * m_sinTheta[theta],
|
||||
m_cosTheta[theta]
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert the normal direction from quantized spherical coordinates
|
||||
* to a floating point vector value.
|
||||
*/
|
||||
inline Normal getNormal() const {
|
||||
return Normal(
|
||||
m_cosPhi[phiN] * m_sinTheta[thetaN],
|
||||
m_sinPhi[phiN] * m_sinTheta[thetaN],
|
||||
m_cosTheta[thetaN]
|
||||
);
|
||||
}
|
||||
|
||||
/// Return the photon position as a vector
|
||||
inline Point getPosition() const {
|
||||
return Point(pos[0], pos[1], pos[2]);
|
||||
}
|
||||
|
||||
/// Convert the photon power from RGBE to floating point
|
||||
inline Spectrum getPower() const {
|
||||
#if defined(DOUBLE_PRECISION) || SPECTRUM_SAMPLES > 3
|
||||
return power;
|
||||
#else
|
||||
Spectrum result;
|
||||
result.fromRGBE(power);
|
||||
return result;
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Serialize to a binary data stream
|
||||
inline void serialize(Stream *stream) const {
|
||||
stream->writeSingleArray(pos, 3);
|
||||
#if defined(DOUBLE_PRECISION) || SPECTRUM_SAMPLES > 3
|
||||
power.serialize(stream);
|
||||
stream->writeUChar(phi);
|
||||
stream->writeUChar(theta);
|
||||
stream->writeUChar(phiN);
|
||||
stream->writeUChar(thetaN);
|
||||
#else
|
||||
stream->write(power, 8);
|
||||
#endif
|
||||
stream->writeUShort(depth);
|
||||
stream->writeUChar(axis);
|
||||
}
|
||||
|
||||
/// Return a string representation (for debugging)
|
||||
std::string toString() const {
|
||||
std::ostringstream oss;
|
||||
oss << "Photon[pos = [" << pos[0] << ", "
|
||||
<< pos[1] << ", " << pos[2] << "]"
|
||||
<< ", power = " << getPower().toString()
|
||||
<< ", direction = " << getDirection().toString()
|
||||
<< ", normal = " << getNormal().toString()
|
||||
<< ", axis = " << axis
|
||||
<< ", depth = " << depth
|
||||
<< "]";
|
||||
return oss.str();
|
||||
}
|
||||
|
||||
protected:
|
||||
// ======================================================================
|
||||
/// @{ \name Precomputed lookup tables
|
||||
// ======================================================================
|
||||
|
||||
static Float m_cosTheta[256];
|
||||
static Float m_sinTheta[256];
|
||||
static Float m_cosPhi[256];
|
||||
static Float m_sinPhi[256];
|
||||
static Float m_expTable[256];
|
||||
static bool m_precompTableReady;
|
||||
|
||||
/// @}
|
||||
// ======================================================================
|
||||
|
||||
/// Initialize the precomputed lookup tables
|
||||
static bool createPrecompTables();
|
||||
};
|
||||
|
||||
#if defined(SINGLE_PRECISION) && SPECTRUM_SAMPLES == 3
|
||||
/* Compiler sanity check */
|
||||
BOOST_STATIC_ASSERT(sizeof(Photon) == 24);
|
||||
#endif
|
||||
|
||||
MTS_NAMESPACE_END
|
||||
|
||||
#endif /* __PHOTON_H */
|
||||
|
|
@ -0,0 +1,112 @@
|
|||
/*
|
||||
This file is part of Mitsuba, a physically based rendering system.
|
||||
|
||||
Copyright (c) 2007-2010 by Wenzel Jakob and others.
|
||||
|
||||
Mitsuba is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License Version 3
|
||||
as published by the Free Software Foundation.
|
||||
|
||||
Mitsuba 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 this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <mitsuba/render/photon.h>
|
||||
|
||||
MTS_NAMESPACE_BEGIN
|
||||
|
||||
/* Precompute cosine/sine values for quick conversions
|
||||
from quantized spherical coordinates to floating
|
||||
point vectors. */
|
||||
Float Photon::m_cosTheta[256];
|
||||
Float Photon::m_sinTheta[256];
|
||||
Float Photon::m_cosPhi[256];
|
||||
Float Photon::m_sinPhi[256];
|
||||
Float Photon::m_expTable[256];
|
||||
|
||||
bool Photon::m_precompTableReady = Photon::createPrecompTables();
|
||||
|
||||
bool Photon::createPrecompTables() {
|
||||
for (int i=0; i<256; i++) {
|
||||
Float angle = (Float) i * ((Float) M_PI / 256.0f);
|
||||
m_cosPhi[i] = std::cos(2.0f * angle);
|
||||
m_sinPhi[i] = std::sin(2.0f * angle);
|
||||
m_cosTheta[i] = std::cos(angle);
|
||||
m_sinTheta[i] = std::sin(angle);
|
||||
m_expTable[i] = std::ldexp((Float) 1, i - (128+8));
|
||||
}
|
||||
m_expTable[0] = 0;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
Photon::Photon(Stream *stream) {
|
||||
stream->readSingleArray(pos, 3);
|
||||
#if defined(DOUBLE_PRECISION) || SPECTRUM_SAMPLES > 3
|
||||
power = Spectrum(stream);
|
||||
phi = stream->readUChar();
|
||||
theta = stream->readUChar();
|
||||
phiN = stream->readUChar();
|
||||
thetaN = stream->readUChar();
|
||||
#else
|
||||
stream->read(power, 8);
|
||||
#endif
|
||||
depth = stream->readUShort();
|
||||
axis = stream->readUChar();
|
||||
unused = 0;
|
||||
}
|
||||
|
||||
Photon::Photon(const Point &p, const Normal &normal,
|
||||
const Vector &dir, const Spectrum &P,
|
||||
uint16_t _depth) {
|
||||
if (P.isNaN())
|
||||
SLog(EWarn, "Creating an invalid photon with power: %s", P.toString().c_str());
|
||||
|
||||
/* Possibly convert to single precision floating point
|
||||
(if Mitsuba is configured to use double precision) */
|
||||
pos[0] = (float) p.x;
|
||||
pos[1] = (float) p.y;
|
||||
pos[2] = (float) p.z;
|
||||
depth = _depth;
|
||||
unused = 0;
|
||||
axis = -1;
|
||||
|
||||
/* Convert the direction into an approximate spherical
|
||||
coordinate format to reduce storage requirements */
|
||||
theta = (uint8_t) std::min(255,
|
||||
(int) (std::acos(dir.z) * (256.0 / M_PI)));
|
||||
|
||||
int tmp = std::min(255,
|
||||
(int) (std::atan2(dir.y, dir.x) * (256.0 / (2.0 * M_PI))));
|
||||
if (tmp < 0)
|
||||
phi = (uint8_t) (tmp + 256);
|
||||
else
|
||||
phi = (uint8_t) tmp;
|
||||
|
||||
if (normal.isZero()) {
|
||||
thetaN = phiN = 0;
|
||||
} else {
|
||||
thetaN = (uint8_t) std::min(255,
|
||||
(int) (std::acos(normal.z) * (256.0 / M_PI)));
|
||||
tmp = std::min(255,
|
||||
(int) (std::atan2(normal.y, normal.x) * (256.0 / (2.0 * M_PI))));
|
||||
if (tmp < 0)
|
||||
phiN = (uint8_t) (tmp + 256);
|
||||
else
|
||||
phiN = (uint8_t) tmp;
|
||||
}
|
||||
|
||||
#if defined(DOUBLE_PRECISION) || SPECTRUM_SAMPLES > 3
|
||||
power = P;
|
||||
#else
|
||||
/* Pack the photon power into Greg Ward's RGBE format */
|
||||
P.toRGBE(power);
|
||||
#endif
|
||||
}
|
||||
|
||||
MTS_NAMESPACE_END
|
||||
Loading…
Reference in New Issue