void RenderEngine::EndSceneEdit(const EditActionList &editActions) {
boost::unique_lock<boost::mutex> lock(engineMutex);
assert (started);
assert (editMode);
// Check if I have to stop the LuxRays Context
bool contextStopped;
if (editActions.Has(GEOMETRY_EDIT) ||
(editActions.Has(INSTANCE_TRANS_EDIT) &&
!renderConfig->scene->dataSet->DoesAllAcceleratorsSupportUpdate())) {
// Stop all intersection devices
ctx->Stop();
// To avoid reference to the DataSet de-allocated inside UpdateDataSet()
ctx->SetDataSet(NULL);
contextStopped = true;
} else
contextStopped = false;
// Pre-process scene data
renderConfig->scene->Preprocess(ctx, film->GetWidth(), film->GetHeight());
if (contextStopped) {
// Set the LuxRays DataSet
ctx->SetDataSet(renderConfig->scene->dataSet);
// Restart all intersection devices
ctx->Start();
} else if (renderConfig->scene->dataSet->DoesAllAcceleratorsSupportUpdate() &&
editActions.Has(INSTANCE_TRANS_EDIT)) {
// Update the DataSet
ctx->UpdateDataSet();
}
// Only at this point I can safely trace the auto-focus ray
if (editActions.Has(CAMERA_EDIT))
renderConfig->scene->camera->UpdateFocus(renderConfig->scene);
samplesCount = 0;
elapsedTime = 0.0f;
startTime = WallClockTime();
film->ResetConvergenceTest();
convergence = 0.f;
lastConvergenceTestTime = startTime;
lastConvergenceTestSamplesCount = 0;
editMode = false;
EndSceneEditLockLess(editActions);
}
void RenderEngine::EndEdit(const EditActionList &editActions) {
boost::unique_lock<boost::mutex> lock(engineMutex);
assert (started);
assert (editMode);
bool dataSetUpdated;
if (editActions.Has(GEOMETRY_EDIT) ||
((renderConfig->scene->dataSet->GetAcceleratorType() != ACCEL_MQBVH) &&
editActions.Has(INSTANCE_TRANS_EDIT))) {
// To avoid reference to the DataSet de-allocated inside UpdateDataSet()
ctx->SetDataSet(NULL);
// For all other accelerator, I have to rebuild the DataSet
renderConfig->scene->UpdateDataSet(ctx);
// Set the LuxRays SataSet
ctx->SetDataSet(renderConfig->scene->dataSet);
dataSetUpdated = true;
} else
dataSetUpdated = false;
// Restart all intersection devices
ctx->Start();
if (!dataSetUpdated &&
(renderConfig->scene->dataSet->GetAcceleratorType() == ACCEL_MQBVH) &&
editActions.Has(INSTANCE_TRANS_EDIT)) {
// Update the DataSet
ctx->UpdateDataSet();
}
samplesCount = 0;
elapsedTime = 0.0f;
startTime = WallClockTime();
film->ResetConvergenceTest();
convergence = 0.f;
lastConvergenceTestTime = startTime;
lastConvergenceTestSamplesCount = 0;
editMode = false;
EndEditLockLess(editActions);
}
void RenderSession::EndSceneEdit() {
assert (started);
assert (editMode);
// Make a copy of the edit actions
const EditActionList editActions = renderConfig->scene->editActions;
if ((renderEngine->GetEngineType() != RTPATHOCL) &&
(renderEngine->GetEngineType() != RTBIASPATHOCL)) {
SLG_LOG("[RenderSession] Edit actions: " << editActions);
// RTPATHOCL and RTBIASPATHOCL handle film Reset on their own
if (editActions.HasAnyAction())
film->Reset();
}
renderEngine->EndSceneEdit(editActions);
editMode = false;
}
void RTPathOCLRenderEngine::EndSceneEdit(const EditActionList &editActions) {
const bool requireSync = editActions.HasAnyAction() && !editActions.HasOnly(CAMERA_EDIT);
editMutex.lock();
if (requireSync) {
// This is required to move the rendering thread forward
frameBarrier->wait();
editCanStart.wait(editMutex);
}
PathOCLRenderEngine::EndSceneEdit(editActions);
updateActions.AddActions(editActions.GetActions());
editMutex.unlock();
if (requireSync) {
// This is required to move the rendering thread forward
frameBarrier->wait();
}
}
void PathOCLRenderThread::EndEdit(const EditActionList &editActions) {
//--------------------------------------------------------------------------
// Update OpenCL buffers
//--------------------------------------------------------------------------
if (editActions.Has(FILM_EDIT)) {
// Resize the Framebuffer
InitFrameBuffer();
}
if (editActions.Has(CAMERA_EDIT)) {
// Update Camera
InitCamera();
}
if (editActions.Has(GEOMETRY_EDIT)) {
// Update Scene Geometry
InitGeometry();
}
if (editActions.Has(MATERIALS_EDIT) || editActions.Has(MATERIAL_TYPES_EDIT)) {
// Update Scene Materials
InitMaterials();
}
if (editActions.Has(AREALIGHTS_EDIT)) {
// Update Scene Area Lights
InitAreaLights();
}
if (editActions.Has(INFINITELIGHT_EDIT)) {
// Update Scene Infinite Light
InitInfiniteLight();
}
if (editActions.Has(SUNLIGHT_EDIT)) {
// Update Scene Sun Light
InitSunLight();
}
if (editActions.Has(SKYLIGHT_EDIT)) {
// Update Scene Sun Light
InitSkyLight();
}
//--------------------------------------------------------------------------
// Recompile Kernels if required
//--------------------------------------------------------------------------
if (editActions.Has(FILM_EDIT) || editActions.Has(MATERIAL_TYPES_EDIT))
InitKernels();
if (editActions.Size() > 0)
SetKernelArgs();
//--------------------------------------------------------------------------
// Execute initialization kernels
//--------------------------------------------------------------------------
if (editActions.Size() > 0) {
cl::CommandQueue &oclQueue = intersectionDevice->GetOpenCLQueue();
// Clear the frame buffer
oclQueue.enqueueNDRangeKernel(*initFBKernel, cl::NullRange,
cl::NDRange(RoundUp<unsigned int>(frameBufferPixelCount, initFBWorkGroupSize)),
cl::NDRange(initFBWorkGroupSize));
// Initialize the tasks buffer
oclQueue.enqueueNDRangeKernel(*initKernel, cl::NullRange,
cl::NDRange(renderEngine->taskCount), cl::NDRange(initWorkGroupSize));
}
// Reset statistics in order to be more accurate
intersectionDevice->ResetPerformaceStats();
StartRenderThread();
}
void RTBiasPathOCLRenderThread::UpdateOCLBuffers(const EditActionList &updateActions) {
//--------------------------------------------------------------------------
// Update OpenCL buffers
//--------------------------------------------------------------------------
if (updateActions.Has(CAMERA_EDIT)) {
// Update Camera
InitCamera();
}
if (updateActions.Has(GEOMETRY_EDIT)) {
// Update Scene Geometry
InitGeometry();
}
if (updateActions.Has(IMAGEMAPS_EDIT)) {
// Update Image Maps
InitImageMaps();
}
if (updateActions.Has(MATERIALS_EDIT) || updateActions.Has(MATERIAL_TYPES_EDIT)) {
// Update Scene Textures and Materials
InitTextures();
InitMaterials();
}
if (updateActions.Has(GEOMETRY_EDIT) ||
updateActions.Has(MATERIALS_EDIT) || updateActions.Has(MATERIAL_TYPES_EDIT)) {
// Update Mesh <=> Material links
InitMeshMaterials();
}
if (updateActions.Has(LIGHTS_EDIT)) {
// Update Scene Lights
InitLights();
}
// A material types edit can enable/disable PARAM_HAS_PASSTHROUGH parameter
// and change the size of the structure allocated
if (updateActions.Has(MATERIAL_TYPES_EDIT))
AdditionalInit();
//--------------------------------------------------------------------------
// Recompile Kernels if required
//--------------------------------------------------------------------------
// The following actions can require a kernel re-compilation:
// - Dynamic code generation of textures and materials;
// - Material types edit;
// - Light types edit;
// - Image types edit;
// - Geometry type edit;
// - etc.
InitKernels();
SetKernelArgs();
if (updateActions.Has(MATERIAL_TYPES_EDIT) ||
updateActions.Has(LIGHT_TYPES_EDIT)) {
// Execute initialization kernels. Initialize OpenCL structures.
// NOTE: I can only after having compiled and set arguments.
cl::CommandQueue &initQueue = intersectionDevice->GetOpenCLQueue();
RTBiasPathOCLRenderEngine *engine = (RTBiasPathOCLRenderEngine *)renderEngine;
initQueue.enqueueNDRangeKernel(*initSeedKernel, cl::NullRange,
cl::NDRange(RoundUp<u_int>(engine->taskCount, initSeedWorkGroupSize)),
cl::NDRange(initSeedWorkGroupSize));
}
// Reset statistics in order to be more accurate
intersectionDevice->ResetPerformaceStats();
}