void VolumeRaycasterCL::volumeRaycast(const Volume* volume, const Layer* entryPoints,
const Layer* exitPoints, const Layer* transferFunction,
Layer* outImage,
const VECTOR_CLASS<cl::Event>* waitForEvents /*= nullptr*/,
cl::Event* event /*= nullptr*/) {
size2_t localWorkGroupSize(workGroupSize_);
size2_t globalWorkGroupSize(getGlobalWorkGroupSize(outputSize_.x, localWorkGroupSize.x),
getGlobalWorkGroupSize(outputSize_.y, localWorkGroupSize.y));
if (useGLSharing_) {
// SyncCLGL will synchronize with OpenGL upon creation and destruction
SyncCLGL glSync;
const LayerCLGL* entryCL = entryPoints->getRepresentation<LayerCLGL>();
const LayerCLGL* exitCL = exitPoints->getRepresentation<LayerCLGL>();
LayerCLGL* outImageCL = outImage->getEditableRepresentation<LayerCLGL>();
const VolumeCLGL* volumeCL = volume->getRepresentation<VolumeCLGL>();
const LayerCLGL* transferFunctionCL = transferFunction->getRepresentation<LayerCLGL>();
const LayerCLBase* background;
if (background_) {
background = background_->getRepresentation<LayerCLGL>();
glSync.addToAquireGLObjectList(static_cast<const LayerCLGL*>(background));
} else {
background = defaultBackground_.getRepresentation<LayerCL>();
}
// Shared objects must be acquired before use.
glSync.addToAquireGLObjectList(entryCL);
glSync.addToAquireGLObjectList(exitCL);
glSync.addToAquireGLObjectList(outImageCL);
glSync.addToAquireGLObjectList(volumeCL);
glSync.addToAquireGLObjectList(transferFunctionCL);
// Acquire all of the objects at once
glSync.aquireAllObjects();
volumeRaycast(volume, volumeCL, background, entryCL, exitCL, transferFunctionCL, outImageCL,
globalWorkGroupSize, localWorkGroupSize, waitForEvents, event);
} else {
const LayerCL* entryCL = entryPoints->getRepresentation<LayerCL>();
const LayerCL* exitCL = exitPoints->getRepresentation<LayerCL>();
LayerCL* outImageCL = outImage->getEditableRepresentation<LayerCL>();
const VolumeCL* volumeCL = volume->getRepresentation<VolumeCL>();
const LayerCL* transferFunctionCL = transferFunction->getRepresentation<LayerCL>();
// const LayerCL* background = background_->getRepresentation<LayerCL>();
const LayerCL* background;
if (background_) {
background = background_->getRepresentation<LayerCL>();
} else {
background = defaultBackground_.getRepresentation<LayerCL>();
}
volumeRaycast(volume, volumeCL, background, entryCL, exitCL, transferFunctionCL, outImageCL,
globalWorkGroupSize, localWorkGroupSize, waitForEvents, event);
}
}
void RunningImageMeanAndStandardDeviationCL::computeMeanAndStandardDeviation(const uvec2& nSamples, const LayerCLBase* samples, int iteration, const LayerCLBase* prevMean, LayerCLBase* nextMean, const LayerCLBase* prevStandardDeviation, LayerCLBase* nextStandardDeviation, const size2_t& workGroupSize, const VECTOR_CLASS<cl::Event> *waitForEvents, cl::Event *event) {
size_t workGroupSizeX = static_cast<size_t>(workGroupSize.x); size_t workGroupSizeY = static_cast<size_t>(workGroupSize.y);
size_t globalWorkSizeX = getGlobalWorkGroupSize(nSamples.x, workGroupSizeX);
size_t globalWorkSizeY = getGlobalWorkGroupSize(nSamples.y, workGroupSizeY);
int argIndex = 0;
kernel_->setArg(argIndex++, nSamples);
kernel_->setArg(argIndex++, *samples);
kernel_->setArg(argIndex++, static_cast<float>(iteration+1));
kernel_->setArg(argIndex++, *prevMean);
kernel_->setArg(argIndex++, *nextMean);
kernel_->setArg(argIndex++, *prevStandardDeviation);
kernel_->setArg(argIndex++, *nextStandardDeviation);
OpenCL::getPtr()->getQueue().enqueueNDRangeKernel(*kernel_, cl::NullRange, size2_t(globalWorkSizeX, globalWorkSizeY) , size2_t(workGroupSizeX, workGroupSizeY), waitForEvents, event);
}
void MWC64XRandomNumberGenerator::generateNumbers(BufferCL* rndState, BufferCLBase* data, const VECTOR_CLASS<cl::Event>* waitForEvents /*= nullptr*/, cl::Event* event /*= nullptr*/) {
int argIndex = 0;
kernel_->setArg(argIndex++, *rndState);
kernel_->setArg(argIndex++, static_cast<int>(randomState_.getSize()));
kernel_->setArg(argIndex++, *data);
size_t globalWorkSizeX = getGlobalWorkGroupSize(randomState_.getSize(), workGroupSize_);
OpenCL::getPtr()->getQueue().enqueueNDRangeKernel(*kernel_, cl::NullRange, globalWorkSizeX, workGroupSize_, waitForEvents, event);
}
void UniformSampleGenerator2DCL::generateSamples(const size2_t& nSamples, size_t nElements, const BufferCLBase* samplesCL, const VECTOR_CLASS<cl::Event>* waitForEvents, cl::Event* event) {
auto globalWorkSize = getGlobalWorkGroupSize(nElements, getWorkGroupSize());
int argIndex = 0;
kernel_->setArg(argIndex++, vec2(nSamples));
kernel_->setArg(argIndex++, static_cast<int>(nElements));
kernel_->setArg(argIndex++, *samplesCL);
OpenCL::getPtr()->getQueue().enqueueNDRangeKernel(*kernel_, cl::NullRange, globalWorkSize, getWorkGroupSize(), waitForEvents, event);
}
void VolumeMaxCLProcessor::process() {
if (!kernel_) return;
auto volume = inport_.getData();
const size3_t dim{volume->getDimensions()};
const size3_t outDim{glm::ceil(vec3(dim) / static_cast<float>(volumeRegionSize_.get()))};
// const DataFormatBase* volFormat = inport_.getData()->getDataFormat(); // Not used
if (!volumeOut_ || volumeOut_->getDimensions() != outDim) {
volumeOut_ = std::make_shared<Volume>(outDim, DataUInt8::get());
// volumeOut_ = std::unique_ptr<Volume>( new Volume(outDim, DataUInt32::get()) );
// volumeOut_ = std::unique_ptr<Volume>( new Volume(outDim, DataFloat32::get()) );
// Use same transformation to make sure that they are render at the same location
volumeOut_->setModelMatrix(volume->getModelMatrix());
volumeOut_->setWorldMatrix(volume->getWorldMatrix());
outport_.setData(volumeOut_);
}
size3_t localWorkGroupSize(workGroupSize_.get());
size3_t globalWorkGroupSize(getGlobalWorkGroupSize(outDim.x, localWorkGroupSize.x),
getGlobalWorkGroupSize(outDim.y, localWorkGroupSize.y),
getGlobalWorkGroupSize(outDim.z, localWorkGroupSize.z));
if (useGLSharing_.get()) {
SyncCLGL glSync;
const VolumeCLGL* volumeCL = volume->getRepresentation<VolumeCLGL>();
VolumeCLGL* volumeOutCL = volumeOut_->getEditableRepresentation<VolumeCLGL>();
glSync.addToAquireGLObjectList(volumeCL);
glSync.addToAquireGLObjectList(volumeOutCL);
glSync.aquireAllObjects();
executeVolumeOperation(volume.get(), volumeCL, volumeOutCL, outDim, globalWorkGroupSize,
localWorkGroupSize);
} else {
const VolumeCL* volumeCL = volume->getRepresentation<VolumeCL>();
VolumeCL* volumeOutCL = volumeOut_->getEditableRepresentation<VolumeCL>();
executeVolumeOperation(volume.get(), volumeCL, volumeOutCL, outDim, globalWorkGroupSize,
localWorkGroupSize);
}
}
void PhotonTracerCL::tracePhotons(PhotonData* photonData, const VolumeCLBase* volumeCL, const Buffer<glm::u8>& volumeStruct, const BufferCL* axisAlignedBoundingBoxCL, const LayerCLBase* transferFunctionCL, const AdvancedMaterialProperty& material, float stepSize, const BufferCLBase* lightSamplesCL, const BufferCLBase* intersectionPointsCL, size_t nLightSamples, const BufferCLBase* photonsToRecomputeIndicesCL, int nInvalidPhotons, BufferCLBase* photonsCL, int photonOffset, int batch, int maxInteractions, const VECTOR_CLASS<cl::Event> *waitForEvents, cl::Event *event /*= nullptr*/) {
cl::Kernel* kernel;
cl_uint tracerArg = 0;
if (photonsToRecomputeIndicesCL) {
kernel = recomputePhotonTracerKernel_;
kernel->setArg(tracerArg++, *photonsToRecomputeIndicesCL);
kernel->setArg(tracerArg++, nInvalidPhotons);
} else {
kernel = photonTracerKernel_;
}
kernel->setArg(tracerArg++, *volumeCL);
kernel->setArg(tracerArg++, volumeStruct);
kernel->setArg(tracerArg++, *axisAlignedBoundingBoxCL);
kernel->setArg(tracerArg++, *transferFunctionCL);
kernel->setArg(tracerArg++, *transferFunctionCL); // TODO: Replace with scattering or remove
kernel->setArg(tracerArg++, material.getCombinedMaterialParameters());
kernel->setArg(tracerArg++, *(randomState_.getEditableRepresentation<BufferCL>()));
kernel->setArg(tracerArg++, stepSize);
kernel->setArg(tracerArg++, *photonsCL);
kernel->setArg(tracerArg++, photonData->iteration());
kernel->setArg(tracerArg++, photonOffset);
kernel->setArg(tracerArg++, batch);
kernel->setArg(tracerArg++, *lightSamplesCL);
kernel->setArg(tracerArg++, *intersectionPointsCL);
kernel->setArg(tracerArg++, static_cast<int>(nLightSamples));
kernel->setArg(tracerArg++, maxInteractions);
kernel->setArg(tracerArg++, material.getPhaseFunctionEnum());
//kernel->setArg(tracerArg++, 1); // Random light sampling
kernel->setArg(tracerArg++, photonData->iteration() > 1 ? 1 : 0); // Random light sampling
kernel->setArg(tracerArg++, static_cast<int>(photonData->getNumberOfPhotons()));
auto globalWorkSize = getGlobalWorkGroupSize(nLightSamples, workGroupSize_.x*workGroupSize_.y);
if (photonsToRecomputeIndicesCL) {
globalWorkSize = getGlobalWorkGroupSize(nInvalidPhotons, workGroupSize_.x*workGroupSize_.y);
}
//size_t globalWorkSizeY = getGlobalWorkGroupSize(nPhotons.y, workGroupSize_.y);
OpenCL::getPtr()->getQueue().enqueueNDRangeKernel(*kernel, cl::NullRange, globalWorkSize,
workGroupSize_.x*workGroupSize_.y, waitForEvents, event);
}
void MWC64XSeedGenerator::generateSeeds(BufferCLBase* randomSeedBufferCL, int nRandomSeeds, size_t localWorkGroupSize) {
try
{
kernel_->setArg(0, *randomSeedBufferCL);
kernel_->setArg(1, nRandomSeeds);
size_t globalWorkSizeX = getGlobalWorkGroupSize(nRandomSeeds, localWorkGroupSize);
OpenCL::getPtr()->getQueue().enqueueNDRangeKernel(*kernel_, 0, globalWorkSizeX, localWorkGroupSize);
}
catch (cl::Error& err)
{
LogError(getCLErrorString(err));
}
}
void MeshEntryExitPointsCL::computeEntryExitPoints(
const mat4& NDCToTextureMat, const mat4& worldToTextureMat, const BufferCLBase* vertices,
const BufferCLBase* indices, int nIndices, const LayerCLBase* entryPointsCL,
const LayerCLBase* exitPointsCL, const uvec2& outportDim,
const VECTOR_CLASS<cl::Event>* waitForEvents /*= nullptr*/, cl::Event* event /*= nullptr*/) {
size2_t localWorkGroupSize(workGroupSize_);
size2_t globalWorkGroupSize(getGlobalWorkGroupSize(outportDim.x, localWorkGroupSize.x),
getGlobalWorkGroupSize(outportDim.y, localWorkGroupSize.y));
try {
cl_uint arg = 0;
kernel_->setArg(arg++, NDCToTextureMat);
kernel_->setArg(arg++, worldToTextureMat);
kernel_->setArg(arg++, *vertices);
kernel_->setArg(arg++, *indices);
kernel_->setArg(arg++, nIndices);
kernel_->setArg(arg++, *entryPointsCL);
kernel_->setArg(arg++, *exitPointsCL);
OpenCL::getPtr()->getQueue().enqueueNDRangeKernel(
*kernel_, cl::NullRange, globalWorkGroupSize, localWorkGroupSize, waitForEvents, event);
} catch (cl::Error& err) {
LogError(getCLErrorString(err));
}
}
