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)); } }