119 lines
3.5 KiB
C++
119 lines
3.5 KiB
C++
/*
|
|
This file is part of Mitsuba, a physically based rendering system.
|
|
|
|
Copyright (c) 2007-2012 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/sampler.h>
|
|
|
|
MTS_NAMESPACE_BEGIN
|
|
|
|
Sampler::Sampler(const Properties &props)
|
|
: ConfigurableObject(props), m_sampleCount(0), m_sampleIndex(0) { }
|
|
|
|
Sampler::Sampler(Stream *stream, InstanceManager *manager)
|
|
: ConfigurableObject(stream, manager) {
|
|
m_sampleCount = stream->readSize();
|
|
size_t n1DArrays = stream->readSize();
|
|
for (size_t i=0; i<n1DArrays; ++i)
|
|
request1DArray(stream->readSize());
|
|
size_t n2DArrays = stream->readSize();
|
|
for (size_t i=0; i<n2DArrays; ++i)
|
|
request2DArray(stream->readSize());
|
|
}
|
|
|
|
void Sampler::serialize(Stream *stream, InstanceManager *manager) const {
|
|
ConfigurableObject::serialize(stream, manager);
|
|
|
|
stream->writeSize(m_sampleCount);
|
|
stream->writeSize(m_req1D.size());
|
|
for (size_t i=0; i<m_req1D.size(); ++i)
|
|
stream->writeSize(m_req1D[i]);
|
|
stream->writeSize(m_req2D.size());
|
|
for (size_t i=0; i<m_req2D.size(); ++i)
|
|
stream->writeSize(m_req2D[i]);
|
|
}
|
|
|
|
void Sampler::setFilmResolution(const Vector2i &, bool) { }
|
|
|
|
void Sampler::generate(const Point2i &) {
|
|
m_sampleIndex = 0;
|
|
m_dimension1DArray = m_dimension2DArray = 0;
|
|
}
|
|
|
|
void Sampler::advance() {
|
|
m_sampleIndex++;
|
|
m_dimension1DArray = m_dimension2DArray = 0;
|
|
}
|
|
|
|
ref<Sampler> Sampler::clone() {
|
|
Log(EError, "%s::clone() is not implemented!",
|
|
getClass()->getName().c_str());
|
|
return NULL;
|
|
}
|
|
|
|
void Sampler::setSampleIndex(size_t sampleIndex) {
|
|
m_sampleIndex = sampleIndex;
|
|
m_dimension1DArray = m_dimension2DArray = 0;
|
|
}
|
|
|
|
void Sampler::request1DArray(size_t size) {
|
|
m_req1D.push_back(size);
|
|
m_sampleArrays1D.push_back(new Float[m_sampleCount * size]);
|
|
}
|
|
|
|
void Sampler::request2DArray(size_t size) {
|
|
m_req2D.push_back(size);
|
|
m_sampleArrays2D.push_back(new Point2[m_sampleCount * size]);
|
|
}
|
|
|
|
Point2 *Sampler::next2DArray(size_t size) {
|
|
Assert(m_sampleIndex < m_sampleCount);
|
|
if (m_dimension2DArray < m_req2D.size()) {
|
|
Assert(m_req2D[m_dimension2DArray] == size);
|
|
return m_sampleArrays2D[m_dimension2DArray++] + m_sampleIndex * size;
|
|
} else {
|
|
Log(EError, "Tried to retrieve a size-" SIZE_T_FMT " 2D sample array,"
|
|
" which was not previously allocated.", size);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
Float *Sampler::next1DArray(size_t size) {
|
|
Assert(m_sampleIndex < m_sampleCount);
|
|
if (m_dimension1DArray < m_req1D.size()) {
|
|
Assert(m_req1D[m_dimension1DArray] == size);
|
|
return m_sampleArrays1D[m_dimension1DArray++] + m_sampleIndex * size;
|
|
} else {
|
|
Log(EError, "Tried to retrieve a size-" SIZE_T_FMT " 1D sample array,"
|
|
" which was not previously allocated.", size);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
Sampler::~Sampler() {
|
|
for (size_t i=0; i<m_sampleArrays1D.size(); i++) {
|
|
if (m_sampleArrays1D[i])
|
|
delete[] m_sampleArrays1D[i];
|
|
}
|
|
for (size_t i=0; i<m_sampleArrays2D.size(); i++) {
|
|
if (m_sampleArrays2D[i])
|
|
delete[] m_sampleArrays2D[i];
|
|
}
|
|
}
|
|
|
|
MTS_IMPLEMENT_CLASS(Sampler, true, ConfigurableObject)
|
|
MTS_NAMESPACE_END
|