mingzailao
/
mitsuba
mirror of https://github.com/Quartenia/mitsuba.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

documentation updates

metadata
Wenzel Jakob 2011-08-17 15:02:24 -04:00
parent e7225da4ca
commit e86dbea5d5
24 changed files with 68 additions and 357 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/mitsuba/core/aabb_sse.h
View File

@ -22,8 +22,9 @@
MTS_NAMESPACE_BEGIN
/**
* NaN-aware slab test using SSE by Thierry Berger-Perrin (Intersects against
* 4 rays simultaneously). Returns false if none of the rays intersect.
* NaN-aware slab test using SSE by Thierry Berger-Perrin (Intersects
* against 4 rays simultaneously). Returns false if none of the rays
* intersect.
*/
FINLINE bool AABB::rayIntersectPacket(const RayPacket4 &ray,
RayInterval4 &interval) const {

1
include/mitsuba/core/appender.h
View File

@ -27,6 +27,7 @@ MTS_NAMESPACE_BEGIN
* for logging-relevant information
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE Appender : public Object {
public:

1
include/mitsuba/core/bitmap.h
View File

@ -31,6 +31,7 @@ MTS_NAMESPACE_BEGIN
* This class can efficiently handle 1-bit masks
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE Bitmap : public Object {
public:

9
include/mitsuba/core/chisquare.h
View File

@ -46,7 +46,7 @@ MTS_NAMESPACE_BEGIN
*
* Given a probability distribution with the following interface
*
* <code>
* \code
* class MyDistribution {
* // Sample a (optionally weighted) direction. A non-unity weight
* // in the return value is needed when the sampling distribution
@ -56,11 +56,11 @@ MTS_NAMESPACE_BEGIN
* /// Compute the probability density for the specified direction and measure
* Float pdf(const Vector &direction, EMeasure) const;
* };
* </code>
* \endcode
*
* the code in this class might be used as follows
*
* <code>
* \code
* MyDistribution myDistrInstance;
* ChiSquare chiSqr;
*
@ -75,7 +75,8 @@ MTS_NAMESPACE_BEGIN
*
* if (!chiSqr.runTest())
* Log(EError, "Uh oh -- test failed, the implementation is probably incorrect!");
* </code>
* \endcode
* \ingroup libcore
*/
class MTS_EXPORT_CORE ChiSquare : public Object {
public:

2
include/mitsuba/core/class.h
View File

@ -24,6 +24,7 @@ MTS_NAMESPACE_BEGIN
/**
* \headerfile mitsuba/core/class.h mitsuba/mitsuba.h
* \brief Stores meta-information about \ref Object instances.
* \ingroup libcore
*
* This class provides a thin layer of RTTI (run-time type information),
* which is useful for doing things like:
@ -36,7 +37,6 @@ MTS_NAMESPACE_BEGIN
* </ul>
*
* \sa ref, Object
* \ingroup libcore
*/
class MTS_EXPORT_CORE Class {
public:

338
include/mitsuba/core/grid.h
View File

@ -1,338 +0,0 @@
/*
This file is part of Mitsuba, a physically based rendering system.
Copyright (c) 2007-2011 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(__GRID_H)
#define __GRID_H
#include <mitsuba/mitsuba.h>
MTS_NAMESPACE_BEGIN
/**
* \brief Uniform 3D grid for storing and manipulating arbitrary quantities
*
* \ingroup libcore
*/
template <typename ValueType> class Grid {
public:
/// Construct a new grid with the given resolution (initialized to zero)
Grid(const Vector3i &res, const AABB &aabb) : m_res(res), m_aabb(aabb) {
m_slab = res.x*res.y;
m_numCells = m_slab*res.z;
m_cells = new ValueType[m_numCells];
for (int i=0; i<3; ++i)
m_cellWidth[i] = m_aabb.getExtents()[i] / (Float) res[i];
clear();
}
/// Unserialize a grid from a binary data stream
Grid(Stream *stream) {
m_res = Vector3i(stream);
m_aabb = AABB(stream);
m_slab = m_res.x*m_res.y;
m_numCells = m_slab*m_res.z;
m_cells = new ValueType[m_numCells];
stream->read(m_cells, sizeof(ValueType)*m_numCells);
for (int i=0; i<3; ++i)
m_cellWidth[i] = m_aabb.getExtents()[i] / (Float) m_res[i];
}
/// Serialize a grid to a binary data stream
inline void serialize(Stream *stream) const {
m_res.serialize(stream);
m_aabb.serialize(stream);
for (int i=0; i<3; ++i)
stream->writeSingle((float) m_aabb.min[i]);
for (int i=0; i<3; ++i)
stream->writeSingle((float) m_aabb.max[i]);
stream->write(m_cells, sizeof(ValueType)*m_numCells);
}
/// Reset everything to zero
inline void clear() {
memset(m_cells, 0, sizeof(ValueType) * m_numCells);
}
/// Add the values from another grid of identical shape and type
inline void operator+=(const Grid<ValueType> &grid) {
SAssert(grid.m_numCells == m_numCells);
for (size_t i=0; i<m_numCells; ++i)
m_cells[i] += grid.m_cells[i];
}
/// Multiply all entries by a constant
inline void operator*=(Float value) {
for (size_t i=0; i<m_numCells; ++i)
m_cells[i] *= value;
}
/// Return the grid AABB
inline const AABB &getAABB() const { return m_aabb; }
/// Return the grid resolution
inline const Vector3i &getResolution() const { return m_res; }
/// Return the cell size
inline const Vector &getCellWidth() const { return m_cellWidth; }
/// Perform a lookup
inline ValueType &operator()(int x, int y, int z) {
return m_cells[x + y*m_res.x + z*m_slab];
}
/// Perform a lookup (const version)
inline const ValueType &operator()(int x, int y, int z) const {
return m_cells[x + y*m_res.x + z*m_slab];
}
/// Return a pointer to the underlying array
inline ValueType *getData() const { return m_cells; }
/// Return a string representation
std::string toString() const {
std::ostringstream oss;
oss << m_aabb.min.x << " " << m_aabb.max.x << " " << m_res.x << endl;
oss << m_aabb.min.y << " " << m_aabb.max.y << " " << m_res.y << endl;
oss << m_aabb.min.z << " " << m_aabb.max.z << " " << m_res.z << endl;
for (int z=0; z<m_res.z; ++z)
for (int y=0; y<m_res.y; ++y)
for (int x=0; x<m_res.x; ++x)
oss << m_cells[x + y*m_res.x + z*m_slab] << " ";
return oss.str();
}
/// Modify the voxel containing a certain point
void setValue(const Point &p, ValueType value) {
/* Intersect with the voxel grid */
if (!m_aabb.contains(p)) {
std::ostringstream oss;
oss << "The grid " << m_aabb.toString() << " does not contain the "
"position " << p.toString() << "!" << endl;
throw std::runtime_error(oss.str());
}
Vector pos = p - m_aabb.min;
Vector3i dpos(
std::max(0, std::min((int) (pos.x / m_cellWidth.x), m_res.x-1)),
std::max(0, std::min((int) (pos.y / m_cellWidth.y), m_res.y-1)),
std::max(0, std::min((int) (pos.z / m_cellWidth.z), m_res.z-1))
);
m_cells[dpos.x + dpos.y * m_res.x + dpos.z * m_slab] = value;
}
/// Apply the given functor to a grid cell
template <typename Functor> void apply(const Point &p, const Functor &functor) {
/* Intersect with the voxel grid */
if (!m_aabb.contains(p)) {
std::ostringstream oss;
oss << "The grid " << m_aabb.toString() << " does not contain the "
"position " << p.toString() << "!" << endl;
throw std::runtime_error(oss.str());
}
Vector pos = p - m_aabb.min;
Vector3i dpos(
std::max(0, std::min((int) (pos.x / m_cellWidth.x), m_res.x-1)),
std::max(0, std::min((int) (pos.y / m_cellWidth.y), m_res.y-1)),
std::max(0, std::min((int) (pos.z / m_cellWidth.z), m_res.z-1))
);
int index = dpos.x + dpos.y * m_res.x + dpos.z * m_slab;
m_cells[index] = functor(m_cells[index]);
}
/**
* Apply the given functor to a grid cell - don't throw an error if
* the point is not part of the grid. Returns 'true' upon success
*/
template <typename Functor> bool applyIfContained(const Point &p, const Functor &functor) {
if (!m_aabb.contains(p))
return false;
Vector pos = p - m_aabb.min;
Vector3i dpos(
std::max(0, std::min((int) (pos.x / m_cellWidth.x), m_res.x-1)),
std::max(0, std::min((int) (pos.y / m_cellWidth.y), m_res.y-1)),
std::max(0, std::min((int) (pos.z / m_cellWidth.z), m_res.z-1))
);
int index = dpos.x + dpos.y * m_res.x + dpos.z * m_slab;
m_cells[index] = functor(m_cells[index]);
return true;
}
/**
* \brief Rasterize a ray to the grid and apply the functor to
* every traversed cell
*/
template <typename Functor> void rasterize(const Ray &ray, Functor &functor) {
Float mint, maxt, t;
/* Intersect with the voxel grid */
if (!m_aabb.rayIntersect(ray, mint, maxt))
return;
/* Find the covered range in the ray space */
mint = std::max(mint, ray.mint); maxt = std::max(mint, std::min(maxt, ray.maxt));
if (mint == maxt)
return;
/* Compute the discrete coordinates of the first intersected voxel */
Vector pos = ray(mint) - m_aabb.min;
Vector3i dpos(
std::max(0, std::min((int) (pos.x / m_cellWidth.x), m_res.x-1)),
std::max(0, std::min((int) (pos.y / m_cellWidth.y), m_res.y-1)),
std::max(0, std::min((int) (pos.z / m_cellWidth.z), m_res.z-1))
);
t = mint;
/* Precompute useful traversal information */
Vector corner1 = Vector(dpos.x * m_cellWidth.x,
dpos.y * m_cellWidth.y, dpos.z * m_cellWidth.z);
Vector corner2 = Vector((dpos.x+1) * m_cellWidth.x,
(dpos.y+1) * m_cellWidth.y, (dpos.z+1) * m_cellWidth.z);
Vector delta, next;
Vector3i step, bounds;
for (int i=0; i<3; ++i) {
if (std::abs(ray.d[i]) < Epsilon) {
delta[i] = 0; step[i] = 0; next[i] =
std::numeric_limits<Float>::infinity();
} else if (ray.d[i] > 0) {
delta[i] = m_cellWidth[i]/ray.d[i];
next[i] = mint + (corner2[i] - pos[i]) / ray.d[i];
step[i] = 1;
bounds[i] = m_res[i];
} else {
delta[i] = -m_cellWidth[i]/ray.d[i];
next[i] = mint + (corner1[i] - pos[i]) / ray.d[i];
step[i] = -1;
bounds[i] = -1;
}
}
/* Walk through the voxel grid (3D DDA) */
while (true) {
Float nextT = std::min(std::min(std::min(next.x, next.y), next.z), maxt);
const int arrayIdx = dpos.x + dpos.y * m_res.x + dpos.z * m_slab;
m_cells[arrayIdx] = functor(m_cells[arrayIdx], nextT - t);
t = nextT;
if (next.x <= next.y && next.x <= next.z) {
if (next.x > maxt)
break;
dpos.x += step.x;
if (dpos.x == bounds.x)
break;
next.x += delta.x;
} else if (next.y <= next.x && next.y <= next.z) {
if (next.y > maxt)
break;
dpos.y += step.y;
if (dpos.y == bounds.y)
break;
next.y += delta.y;
} else {
if (next.z > maxt)
break;
dpos.z += step.z;
if (dpos.z == bounds.z)
break;
next.z += delta.z;
}
}
}
/// Return a string representation (MATLAB format)
std::string toStringMATLAB() const {
std::ostringstream oss;
oss << "v=reshape([";
for (int z=0; z<m_res.z; ++z) // intentional order (matlab array conventions..)
for (int x=0; x<m_res.x; ++x)
for (int y=0; y<m_res.y; ++y)
oss << m_cells[x + y*m_res.x + z*m_slab] << " ";
oss << "], " << m_res.x << "," << m_res.y << "," << m_res.z << ");" << endl;
oss << "[X Y Z]=meshgrid( ..." << endl;
oss << "\tlinspace(" << m_aabb.min.x << ", " << m_aabb.max.x << ", " << m_res.x << "), ..." << endl;
oss << "\tlinspace(" << m_aabb.min.y << ", " << m_aabb.max.y << ", " << m_res.y << "), ..." << endl;
oss << "\tlinspace(" << m_aabb.min.z << ", " << m_aabb.max.z << ", " << m_res.z << ") ..." << endl;
oss << ");" << endl;
return oss.str();
}
/// Do a lookup using trilinear interpolation
ValueType lookup(const Point &_p) const {
Point p = Point(_p - m_aabb.min);
Float x = p.x / m_cellWidth.x - .5f;
Float y = p.y / m_cellWidth.y - .5f;
Float z = p.z / m_cellWidth.z - .5f;
const int i = (int) x, j = (int) y, k = (int) z,
pos=i+j*m_res.x+k*m_slab;
if (i < 0 || j < 0 || k < 0 || i >= m_res.x-1 ||
j >= m_res.y || k >= m_res.z)
return ValueType();
const Float alpha = x-i,
beta = y-j,
gamma = z-k;
const ValueType
A1 = m_cells[pos],
B1 = (i+1<m_res.x) ? m_cells[pos+1] : ValueType(0),
C1 = (j+1<m_res.y) ? m_cells[pos+m_res.x] : ValueType(0),
D1 = (i+1<m_res.x && j+1<m_res.y) ? m_cells[pos+m_res.x+1] : ValueType(0);
ValueType A2, B2, C2, D2;
if (k + 1 < m_res.z) {
A2 = m_cells[pos+m_slab];
B2 = (i+1<m_res.x) ? m_cells[pos+1+m_slab] : ValueType(0);
C2 = (j+1<m_res.y) ? m_cells[pos+m_res.x+m_slab] : ValueType(0);
D2 = (i+1<m_res.x && j+1<m_res.y) ? m_cells[pos+m_res.x+m_slab+1] : ValueType(0);
} else {
A2 = B2 = C2 = D2 = ValueType(0);
}
return (A1 * ((1-alpha) * (1-beta))
+ B1 * ( alpha * (1-beta))
+ C1 * ((1-alpha) * beta)
+ D1 * alpha * beta) * (1-gamma)
+ (A2 * ((1-alpha) * (1-beta))
+ B2 * ( alpha * (1-beta))
+ C2 * ((1-alpha) * beta)
+ D2 * alpha * beta) * gamma;
}
/// Release all memory
~Grid() {
delete[] m_cells;
}
private:
Vector3i m_res;
AABB m_aabb;
size_t m_numCells;
size_t m_slab;
Vector m_cellWidth;
ValueType *m_cells;
};
MTS_NAMESPACE_END
#endif /* __GRID_H */

1
include/mitsuba/core/logger.h
View File

@ -90,6 +90,7 @@ MTS_NAMESPACE_BEGIN
* registered Appender.
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE Logger : public Object {
public:

3
include/mitsuba/core/lrucache.h
View File

@ -87,7 +87,8 @@ public:
// Obtain value of the cached function for k
V get(const K& k, bool &hit) {
// Attempt to find existing record
const typename cache_type::left_iterator it = m_cache.left.find(k);
const typename cache_type::left_iterator it
= m_cache.left.find(k);
if (it == m_cache.left.end()) {
// We don’t have it:

1
include/mitsuba/core/mmap.h
View File

@ -16,7 +16,6 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#if !defined(__MMAP_H)
#define __MMAP_H

1
include/mitsuba/core/object.h
View File

@ -33,6 +33,7 @@ MTS_NAMESPACE_BEGIN
*
* \sa ref, Class
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE Object {
public:

2
include/mitsuba/core/plugin.h
View File

@ -34,6 +34,7 @@ MTS_NAMESPACE_BEGIN
* <tt>\ref Utility</tt> classes for details
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE Plugin {
typedef void *(*CreateInstanceFunc)(const Properties &props);
@ -88,6 +89,7 @@ private:
* loading external plugins.
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE PluginManager : public Object {
public:

15
include/mitsuba/core/properties.h
View File

@ -25,8 +25,19 @@
MTS_NAMESPACE_BEGIN
/** \brief Associative map for values of various types. Used to
* construct subclasses of <tt>ConfigurableObject</tt>.
/** \brief Associative parameter map for constructing
* subclasses of \ref ConfigurableObject.
*
* Note that the Python bindings for this class do not implement
* the various type-dependent getters and setters. Instead, they
* are accessed just like a normal Python map, e.g:
*
* \code
* myProps = mitsuba.core.Properties("pluginName")
* myProps["stringProperty"] = "hello"
* myProps["spectrumProperty"] = mitsuba.core.Spectrum(1.0)
* \endcode
*
* \ingroup libcore
* \ingroup libpython
*/

1
include/mitsuba/core/quad.h
View File

@ -16,7 +16,6 @@
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#if !defined(__QUADRATURE_H)
#define __QUADRATURE_H

1
include/mitsuba/core/random.h
View File

@ -90,6 +90,7 @@ MTS_NAMESPACE_BEGIN
/**
* \brief %Random number generator based on Mersenne Twister
* by Takuji Nishimura and Makoto Matsumoto.
* \ingroup libpython
*/
class MTS_EXPORT_CORE Random : public SerializableObject {
public:

1
include/mitsuba/core/ray.h
View File

@ -30,6 +30,7 @@ MTS_NAMESPACE_BEGIN
* to alignment purposes and should not be changed.
*
* \ingroup libcore
* \ingroup libpython
*/
struct Ray {
Point o; ///< Ray origin

7
include/mitsuba/core/sched.h
View File

@ -35,6 +35,7 @@ MTS_NAMESPACE_BEGIN
* \brief Abstract work unit -- represents a small amount of information
* that encodes part of a larger processing task.
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE WorkUnit : public Object {
public:
@ -60,6 +61,7 @@ protected:
* \brief Abstract work result -- represents the result of a
* processed <tt>\ref WorkUnit</tt> instance.
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE WorkResult : public Object {
public:
@ -90,6 +92,7 @@ protected:
* and therefore no form of locking is required within instances of this class.
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE WorkProcessor : public SerializableObject {
friend class Scheduler;
@ -166,6 +169,7 @@ protected:
* chunks of globally shared read-only data required during execution.
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE ParallelProcess : public Object {
friend class Scheduler;
@ -319,6 +323,7 @@ class Worker;
* or sent to remote nodes over a network connection.
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE Scheduler : public Object {
friend class Worker;
@ -642,6 +647,7 @@ private:
/**
* \brief Base class of all worker implementations
* \ingroup libpython
*/
class MTS_EXPORT_CORE Worker : public Thread {
friend class Scheduler;
@ -727,6 +733,7 @@ protected:
* it locally.
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE LocalWorker : public Worker {
public:

1
include/mitsuba/core/sched_remote.h
View File

@ -43,6 +43,7 @@ class StreamBackend;
* it to a processing node reachable through a \ref Stream.
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE RemoteWorker : public Worker {
friend class RemoteWorkerReader;

2
include/mitsuba/core/serialization.h
View File

@ -29,6 +29,7 @@ MTS_NAMESPACE_BEGIN
* RTTI macros \ref MTS_IMPLEMENT_CLASS_S or \ref MTS_IMPLEMENT_CLASS_IS.
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE SerializableObject : public Object {
public:
@ -58,6 +59,7 @@ protected:
* object graph has the same structure.
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE InstanceManager : public Object {
friend class SerializableObject;

8
include/mitsuba/core/shvector.h
View File

@ -33,7 +33,9 @@ namespace ublas = boost::numeric::ublas;
struct SHVector;
/**
* \brief Stores the diagonal blocks of a spherical harmonic rotation matrix
* \brief Stores the diagonal blocks of a spherical harmonic
* rotation matrix
*
* \ingroup libcore
*/
struct MTS_EXPORT_CORE SHRotation {
@ -65,14 +67,14 @@ struct MTS_EXPORT_CORE SHRotation {
*
* The Mathematica equivalent of the basis functions implemented here is:
*
* <pre>
* \code
* SphericalHarmonicQ[l_, m_, \[Theta]_, \[Phi]_] :=
* Piecewise[{
* {SphericalHarmonicY[l, m, \[Theta], \[Phi]], m == 0},
* {Sqrt[2]*Re[SphericalHarmonicY[l, m, \[Theta], \[Phi]]], m > 0},
* {Sqrt[2]*Im[SphericalHarmonicY[l, -m, \[Theta], \[Phi]]], m < 0}
* }]
* </pre>
* \endcode
*
* \ingroup libcore
*/

3
include/mitsuba/core/spectrum.h
View File

@ -45,6 +45,7 @@ MTS_NAMESPACE_BEGIN
* that it is a function over the reals (as opposed to the discrete
* spectrum, which only stores samples for a discrete set of wavelengths).
*
* \ingroup libpython
* \ingroup libcore
*/
class MTS_EXPORT_CORE ContinuousSpectrum {
@ -187,6 +188,7 @@ private:
* spectrum.
*
* \ingroup libcore
* \ingroup libpython
*/
class MTS_EXPORT_CORE InterpolatedSpectrum : public ContinuousSpectrum {
public:
@ -290,6 +292,7 @@ private:
* The implementation of this class is based on PBRT.
*
* \ingroup libcore
* \ingroup libpython
*/
struct MTS_EXPORT_CORE Spectrum {
public:

2
include/mitsuba/core/spline.h
View File

@ -25,6 +25,8 @@ MTS_NAMESPACE_BEGIN
/**
* \brief Simple natural cubic spline interpolation
*
* \ingroup libcore
*/
class MTS_EXPORT_CORE CubicSpline : public SerializableObject {
public:

2
include/mitsuba/core/sshstream.h
View File

@ -39,6 +39,8 @@ MTS_NAMESPACE_BEGIN
* pageant.exe is required to load and authenticate the key.
*
* Note: SSH streams are set to use network byte order by default.
*
* \ingroup libcore
*/
class MTS_EXPORT_CORE SSHStream : public Stream {
public:

1
include/mitsuba/core/transform.h
View File

@ -27,6 +27,7 @@ MTS_NAMESPACE_BEGIN
/**
* \brief Encapsulates a 4x4 linear transformation and its inverse
* \ingroup libcore
* \ingroup libpython
*/
struct MTS_EXPORT_CORE Transform {
public:

17
include/mitsuba/core/version.h
View File

@ -21,15 +21,24 @@
MTS_NAMESPACE_BEGIN
/// Current release of Mitsuba
/**
* Current release of Mitsuba
* \ingroup libcore
*/
#define MTS_VERSION "0.3.0"
// Year of this release
/**
* Current release of Mitsuba
* \ingroup libcore
*/
#define MTS_VERSION "0.3.0"
#define MTS_YEAR "2011"
/**
* \brief A simple data structure for representing and comparing
* Mitsuba version strings
* \brief A simple data structure for representing and
* comparing Mitsuba version strings
*
* \ingroup libcore
*/
struct MTS_EXPORT_CORE Version {
public: