void InstantRadiosityRenderer::processPixel(uint32_t threadID, uint32_t tileID, const Vec2u& pixel) const {
PixelSensor pixelSensor(getSensor(), pixel, getFramebufferSize());
RaySample raySample;
float positionPdf, directionPdf;
auto We = pixelSensor.sampleExitantRay(getScene(), getFloat2(threadID), getFloat2(threadID), raySample, positionPdf, directionPdf);
auto L = zero<Vec3f>();
if(We != zero<Vec3f>() && raySample.pdf) {
auto I = getScene().intersect(raySample.value);
BSDF bsdf(-raySample.value.dir, I, getScene());
if(I) {
// Direct illumination
for(auto& vpl: m_EmissionVPLBuffer) {
RaySample shadowRay;
auto Le = vpl.pLight->sampleDirectIllumination(getScene(), vpl.emissionVertexSample, I, shadowRay);
if(shadowRay.pdf) {
auto contrib = We * Le * bsdf.eval(shadowRay.value.dir) * abs(dot(I.Ns, shadowRay.value.dir)) /
(vpl.lightPdf * shadowRay.pdf * m_nLightPathCount * raySample.pdf);
if(contrib != zero<Vec3f>()) {
if(!getScene().occluded(shadowRay.value)) {
L += contrib;
}
}
}
}
// Indirect illumination
for(auto& vpl: m_SurfaceVPLBuffer) {
auto dirToVPL = vpl.intersection.P - I.P;
auto dist = length(dirToVPL);
if(dist > 0.f) {
dirToVPL /= dist;
auto fs1 = bsdf.eval(dirToVPL);
auto fs2 = vpl.bsdf.eval(-dirToVPL);
auto geometricFactor = abs(dot(I.Ns, dirToVPL)) * abs(dot(vpl.intersection.Ns, -dirToVPL)) / sqr(dist);
auto contrib = We * vpl.power * fs1 * fs2 * geometricFactor / raySample.pdf;
if(contrib != zero<Vec3f>()) {
Ray shadowRay(I, vpl.intersection, dirToVPL, dist);
if(!getScene().occluded(shadowRay)) {
L += contrib;
}
}
}
}
}
}
accumulate(0, getPixelIndex(pixel.x, pixel.y), Vec4f(L, 1.f));
}
void UniformResamplingRecursiveMISBPTRenderer::connectLightVerticesToSensor(uint32_t threadID, uint32_t tileID, const Vec4u& viewport) const {
auto rcpPathCount = 1.f / m_nLightPathCount;
auto mis = [&](float v) {
return Mis(v);
};
for(const auto& directImportanceSample: m_DirectImportanceSampleTilePartitionning[tileID]) {
auto pLightVertex = &m_LightPathBuffer[directImportanceSample.m_nLightVertexIndex];
auto totalDepth = 1 + pLightVertex->m_nDepth;
if(!acceptPathDepth(totalDepth) || totalDepth > m_nMaxDepth) {
continue;
}
auto pixel = directImportanceSample.m_Pixel;
auto pixelID = BnZ::getPixelIndex(pixel, getFramebufferSize());
PixelSensor sensor(getSensor(), pixel, getFramebufferSize());
auto contrib = rcpPathCount * connectVertices(*pLightVertex,
SensorVertex(&sensor, directImportanceSample.m_LensSample),
getScene(), m_nLightPathCount, mis);
if(isInvalidMeasurementEstimate(contrib)) {
reportInvalidContrib(threadID, tileID, pixelID, [&]() {
debugLog() << "s = " << (pLightVertex->m_nDepth + 1) << ", t = " << 1 << std::endl;
});
}
accumulate(FINAL_RENDER, pixelID, Vec4f(contrib, 0.f));
accumulate(FINAL_RENDER_DEPTH1 + totalDepth - 1u, pixelID, Vec4f(contrib, 0.f));
auto strategyOffset = computeBPTStrategyOffset(totalDepth + 1, pLightVertex->m_nDepth + 1);
accumulate(BPT_STRATEGY_s0_t2 + strategyOffset, pixelID, Vec4f(contrib, 0));
}
}
void UniformResamplingRecursiveMISBPTRenderer::buildDirectImportanceSampleTilePartitionning() {
ThreadRNG rng(*this, 0u);
m_DirectImportanceSampleTilePartitionning.build(
m_LightPathBuffer.size(),
getScene(),
getSensor(),
getFramebufferSize(),
getTileSize(),
getTileCount2(),
[&](std::size_t i) {
return m_LightPathBuffer[i].m_Intersection;
},
[&](std::size_t i) {
return m_LightPathBuffer[i].m_Intersection && m_LightPathBuffer[i].m_fPathPdf > 0.f;
},
rng);
}
void processSample(uint32_t threadID, uint32_t pixelID, uint32_t sampleID,
uint32_t x, uint32_t y) const {
PixelSensor sensor(getSensor(), Vec2u(x, y), getFramebufferSize());
auto pixelSample = getPixelSample(threadID, sampleID);
auto lensSample = getFloat2(threadID);
RaySample raySample;
Intersection I;
sampleExitantRay(
sensor,
getScene(),
lensSample,
pixelSample,
raySample,
I);
auto ray = raySample.value;
accumulate(0, pixelID, Vec4f(ray.dir, 1.f));
}
void kwe::WorldEditorState::update(const double& ms)
{
// Begin internal update
auto win = this->m_application->getWindow();
auto resolution = win->getFramebufferSize();
// Update mouse offset
glm::vec2 currMousePosition = this->m_application->getWindow()->getMousePosition();
this->m_mouseOffset = m_lastMousePosition - currMousePosition;
this->m_lastMousePosition = currMousePosition;
// Render UI
this->renderUI(ms);
// Initialize dragmode as false each frame
this->m_isDragging = false;
for(auto currComponent : this->m_components)
{
currComponent->update(ms, this->m_mouseOffset);
}
// Update shadow distance
//glm::distance(this->m_cameraComponent.getOrigin(), this->m_cameraComponent.getCamera()->getPosition()); WHY I DO THIS I HAVE DISTANCE!!!!!
this->m_sunLight->setMaxShadowDistance(this->m_cameraComponent.getDistance() + 5.0f);
// End internal update
if (this->m_isDragging && !this->m_wasDragging)
{
this->m_application->getWindow()->setMouseVirtual(true);
}
else if (this->m_wasDragging && !this->m_isDragging)
{
this->m_application->getWindow()->setMouseVirtual(false);
}
this->m_wasDragging = this->m_isDragging;
}
void UniformResamplingRecursiveMISBPTRenderer::processSample(uint32_t threadID, uint32_t tileID, uint32_t pixelID, uint32_t sampleID,
uint32_t x, uint32_t y) const {
auto mis = [&](float v) {
return Mis(v);
};
ThreadRNG rng(*this, threadID);
PixelSensor pixelSensor(getSensor(), Vec2u(x, y), getFramebufferSize());
auto pixelSample = getPixelSample(threadID, sampleID);
auto sensorSample = getFloat2(threadID);
auto fImportanceScale = 1.f / getSppCount();
BDPTPathVertex eyeVertex(getScene(), pixelSensor, sensorSample, pixelSample, m_nLightPathCount, mis);
if(eyeVertex.m_Power == zero<Vec3f>() || !eyeVertex.m_fPathPdf) {
return;
}
// Sample the light path to connect with the eye path
auto lightPathIdx = clamp(std::size_t(getFloat(threadID) * m_nLightPathCount),
std::size_t(0),
m_nLightPathCount - 1);
auto pLightPath = m_LightPathBuffer.getSlicePtr(lightPathIdx);
auto maxEyePathDepth = getMaxEyePathDepth();
auto maxLightPathDepth = getMaxLightPathDepth();
auto extendEyePath = [&]() -> bool {
return eyeVertex.m_nDepth < maxEyePathDepth &&
eyeVertex.extend(eyeVertex, getScene(), getSppCount(), false, rng, mis);
};
// Iterate over an eye path
do {
// Intersection with light source
auto totalLength = eyeVertex.m_nDepth;
if(acceptPathDepth(totalLength) && totalLength <= m_nMaxDepth) {
auto contrib = fImportanceScale * computeEmittedRadiance(eyeVertex, getScene(), m_LightSampler, getSppCount(), mis);
if(isInvalidMeasurementEstimate(contrib)) {
reportInvalidContrib(threadID, tileID, pixelID, [&]() {
debugLog() << "s = " << 0 << ", t = " << (eyeVertex.m_nDepth + 1) << std::endl;
});
}
accumulate(FINAL_RENDER, pixelID, Vec4f(contrib, 0));
accumulate(FINAL_RENDER_DEPTH1 + totalLength - 1u, pixelID, Vec4f(contrib, 0));
auto strategyOffset = computeBPTStrategyOffset(totalLength + 1, 0u);
accumulate(BPT_STRATEGY_s0_t2 + strategyOffset, pixelID, Vec4f(contrib, 0));
}
// Connections
if(eyeVertex.m_Intersection) {
// Direct illumination
auto totalLength = eyeVertex.m_nDepth + 1;
if(acceptPathDepth(totalLength) && totalLength <= m_nMaxDepth) {
float lightPdf;
auto pLight = m_LightSampler.sample(getScene(), getFloat(threadID), lightPdf);
auto s2D = getFloat2(threadID);
auto contrib = fImportanceScale * connectVertices(eyeVertex, EmissionVertex(pLight, lightPdf, s2D), getScene(), getSppCount(), mis);
if(isInvalidMeasurementEstimate(contrib)) {
reportInvalidContrib(threadID, tileID, pixelID, [&]() {
debugLog() << "s = " << 1 << ", t = " << (eyeVertex.m_nDepth + 1) << std::endl;
});
}
accumulate(FINAL_RENDER, pixelID, Vec4f(contrib, 0));
accumulate(FINAL_RENDER_DEPTH1 + totalLength - 1u, pixelID, Vec4f(contrib, 0));
auto strategyOffset = computeBPTStrategyOffset(totalLength + 1, 1);
accumulate(BPT_STRATEGY_s0_t2 + strategyOffset, pixelID, Vec4f(contrib, 0));
}
// Connection with each light vertex
for(auto j = 0u; j < maxLightPathDepth; ++j) {
auto pLightVertex = pLightPath + j;
auto totalLength = eyeVertex.m_nDepth + pLightVertex->m_nDepth + 1;
if(pLightVertex->m_fPathPdf > 0.f && acceptPathDepth(totalLength) && totalLength <= m_nMaxDepth) {
auto contrib = fImportanceScale * connectVertices(eyeVertex, *pLightVertex, getScene(), getSppCount(), mis);
if(isInvalidMeasurementEstimate(contrib)) {
reportInvalidContrib(threadID, tileID, pixelID, [&]() {
debugLog() << "s = " << (pLightVertex->m_nDepth + 1) << ", t = " << (eyeVertex.m_nDepth + 1) << std::endl;
});
}
accumulate(FINAL_RENDER, pixelID, Vec4f(contrib, 0));
accumulate(FINAL_RENDER_DEPTH1 + totalLength - 1u, pixelID, Vec4f(contrib, 0));
auto strategyOffset = computeBPTStrategyOffset(totalLength + 1, pLightVertex->m_nDepth + 1);
accumulate(BPT_STRATEGY_s0_t2 + strategyOffset, pixelID, Vec4f(contrib, 0));
}
}
}
} while(extendEyePath());
}
void GLFWView::bind() {
setFramebufferBinding(0);
setViewport(0, 0, getFramebufferSize());
}
void GLFWView::updateAssumedState() {
assumeFramebufferBinding(0);
assumeViewport(0, 0, getFramebufferSize());
}
