void ToneMapping::process() {
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
TextureUnit colorUnit, depthUnit;
inport_.bindColorTexture(colorUnit.getEnum());
if (toneMappingMethod_.get() == "rahman-retinex") {
glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glGenerateMipmapEXT(GL_TEXTURE_2D);
}
inport_.bindDepthTexture(depthUnit.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
// set uniforms
program_->setUniform("colorTex_", colorUnit.getUnitNumber());
program_->setUniform("depthTex_", depthUnit.getUnitNumber());
inport_.setTextureParameters(program_, "textureParameters_");
// set method specific uniforms
if (toneMappingMethod_.get() == "s-curve") {
program_->setUniform("sigma_", scurveSigma_.get());
program_->setUniform("power_", scurvePower_.get());
}
if (toneMappingMethod_.get() == "rahman-retinex") {
if(rahmanTotalUpdate_ || inport_.hasChanged()){
wTotal_ = 0.0f;
float i = 0.0f;
while(i<rahmanIterations_.get()){
wTotal_ += pow(rahmanIterations_.get() - i + 1, rahmanFrequency_.get());
i++;
}
rahmanTotalUpdate_ = false;
}
//colorUnit.activate();
//glGenerateMipmapEXT(GL_TEXTURE_2D);
program_->setUniform("frequency_", rahmanFrequency_.get());
program_->setUniform("subtractionFactor_", rahmanSubtractionFactor_.get());
program_->setUniform("iterations_", rahmanIterations_.get());
program_->setUniform("maxLevel_", rahmanMaxLevel_.get());
program_->setUniform("wTotal_", wTotal_);
}
renderQuad();
program_->deactivate();
outport_.deactivateTarget();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void MultiVolumeRaycaster::updateResult(DataContainer& dataContainer) {
ImageRepresentationGL::ScopedRepresentation image1(dataContainer, p_sourceImage1.getValue());
ImageRepresentationGL::ScopedRepresentation image2(dataContainer, p_sourceImage2.getValue());
ImageRepresentationGL::ScopedRepresentation image3(dataContainer, p_sourceImage3.getValue());
ScopedTypedData<CameraData> camera(dataContainer, p_camera.getValue());
ScopedTypedData<RenderData> geometryImage(dataContainer, p_geometryImageId.getValue(), true);
ScopedTypedData<LightSourceData> light(dataContainer, p_lightId.getValue());
std::vector<const ImageRepresentationGL*> images;
if (image1) {
images.push_back(image1);
if (getInvalidationLevel() & INVALID_VOXEL_HIERARCHY1){
_vhm1->createHierarchy(image1, p_transferFunction1.getTF());
validate(INVALID_VOXEL_HIERARCHY1);
}
}
if (image2) {
images.push_back(image2);
if (getInvalidationLevel() & INVALID_VOXEL_HIERARCHY2){
_vhm2->createHierarchy(image2, p_transferFunction2.getTF());
validate(INVALID_VOXEL_HIERARCHY2);
}
}
if (image3) {
images.push_back(image3);
if (getInvalidationLevel() & INVALID_VOXEL_HIERARCHY3){
_vhm3->createHierarchy(image3, p_transferFunction3.getTF());
validate(INVALID_VOXEL_HIERARCHY3);
}
}
if (images.size() >= 3 && camera != nullptr) {
auto eepp = computeEntryExitPoints(images, camera, geometryImage);
dataContainer.addData(p_outputImageId.getValue() + ".entrypoints", eepp.first);
dataContainer.addData(p_outputImageId.getValue() + ".exitpoints", eepp.second);
auto rc = performRaycasting(dataContainer, images, camera, eepp.first, eepp.second, light);
dataContainer.addData(p_outputImageId.getValue(), rc);
}
else {
LDEBUG("No suitable input data found!");
}
}
void Property::propertyModified() {
NetworkLock lock(this);
onChangeCallback_.invokeAll();
setPropertyModified(true);
PropertyOwner* owner = getOwner();
if (owner) {
// Evaluate property links
if (Processor* processor = owner->getProcessor()) {
processor->notifyObserversAboutPropertyChange(this);
}
// Invalidate Owner
if (getInvalidationLevel() > InvalidationLevel::Valid) {
owner->invalidate(getInvalidationLevel(), this);
}
}
updateWidgets();
}
void SimpleRaycaster::beforeProcess() {
VolumeRaycaster::beforeProcess();
// rebuild shader, if changed
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
rebuildShader();
// assign volume to transfer function
transferFunc_.setVolumeHandle(volumePort_.getData());
LGL_ERROR;
}
void PredicateVolumeExplorer::updateResult(DataContainer& data) {
// launch sub-renderers if necessary
if (getInvalidationLevel() & BITSET_INVALID) {
_predicateEvaluation.process(data);
ImageRepresentationLocal::ScopedRepresentation repLocal(data, _predicateEvaluation.p_outputImage.getValue());
_bitmaskHandle = repLocal.getDataHandle();
validate(BITSET_INVALID);
}
VolumeExplorer::updateResult(data);
}
void SingleVolumeRaycaster::beforeProcess() {
VolumeRaycaster::beforeProcess();
// compile program if needed
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM) {
PROFILING_BLOCK("compile");
compile();
}
LGL_ERROR;
transferFunc_.setVolumeHandle(volumeInport_.getData());
}
void UnsharpMasking::initialize() throw (tgt::Exception) {
ImageProcessorBypassable::initialize(); //call parent's initialize method, initializes first shader program (blur)
program_->deactivate();
//initialize second shader program (masking)
secondProgram_ = ShdrMgr.loadSeparate("passthrough.vert", "image/unsharpmaskingmask.frag", generateHeader(), false);
invalidate(Processor::INVALID_PROGRAM);
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
secondProgram_->rebuild();
secondProgram_->deactivate();
}
void ImageProcessorBypassable::initialize() throw (tgt::Exception) {
ImageProcessor::initialize(); //call parent's initialize method, initializes first shader program
program_->deactivate();
//initialize bypass shader program
bypassProgram_ = ShdrMgr.loadSeparate("passthrough.vert", "copyimage.frag", generateHeader(), false);
if (!bypassProgram_)
throw VoreenException("ImageProcessorBypassable: Failed to load shaders 'passthrough.vert' and 'copyimage.frag'");
invalidate(Processor::INVALID_PROGRAM);
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
bypassProgram_->rebuild();
bypassProgram_->deactivate();
}
void ButtonOverlayProcessor::process() {
if (!outport_.isReady())
return;
if (!inport_.isReady())
return;
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
if(outport_.getSize() != oldSize_) {
regenerateOverlay_ = true;
oldSize_ = outport_.getSize();
}
if(regenerateOverlay_)
renderOverlayImage();
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
TextureUnit colorUnit0, depthUnit0, colorUnit1, depthUnit1;
overlayPort_.bindTextures(colorUnit0.getEnum(), depthUnit0.getEnum());
inport_.bindTextures(colorUnit1.getEnum(), depthUnit1.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
program_->setUniform("colorTex0_", colorUnit0.getUnitNumber());
program_->setUniform("depthTex0_", depthUnit0.getUnitNumber());
program_->setUniform("colorTex1_", colorUnit1.getUnitNumber());
program_->setUniform("depthTex1_", depthUnit1.getUnitNumber());
overlayPort_.setTextureParameters(program_, "textureParameters0_");
inport_.setTextureParameters(program_, "textureParameters1_");
glDepthFunc(GL_ALWAYS);
renderQuad();
glDepthFunc(GL_LESS);
outport_.deactivateTarget();
program_->deactivate();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void UnaryImageProcessor::process() {
if (!enableSwitch_.get()) {
bypass(&inport_, &outport_);
return;
}
outport_.activateTarget();
// compile program if needed
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
LGL_ERROR;
// initialize shader
if (!program_ || !program_->isLinked())
return;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
TextureUnit colorUnit, depthUnit;
inport_.bindTextures(colorUnit.getEnum(), depthUnit.getEnum());
program_->activate();
setGlobalShaderParameters(program_);
program_->setIgnoreUniformLocationError(true);
program_->setUniform("colorTex_", colorUnit.getUnitNumber());
program_->setUniform("depthTex_", depthUnit.getUnitNumber());
inport_.setTextureParameters(program_, "texParams_");
program_->setIgnoreUniformLocationError(false);
glDepthFunc(GL_ALWAYS);
renderQuad();
glDepthFunc(GL_LESS);
program_->deactivate();
outport_.deactivateTarget();
glActiveTexture(GL_TEXTURE0);
LGL_ERROR;
}
void BinaryImageProcessor::process() {
// compile program if needed
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
LGL_ERROR;
if(!program_ || !program_->isLinked())
return;
outport_.activateTarget();
outport_.clearTarget();
TextureUnit colorUnit0, depthUnit0, colorUnit1, depthUnit1;
inport0_.bindTextures(colorUnit0.getEnum(), depthUnit0.getEnum());
inport1_.bindTextures(colorUnit1.getEnum(), depthUnit1.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
program_->setIgnoreUniformLocationError(true);
program_->setUniform("colorTex0_", colorUnit0.getUnitNumber());
program_->setUniform("depthTex0_", depthUnit0.getUnitNumber());
program_->setUniform("colorTex1_", colorUnit1.getUnitNumber());
program_->setUniform("depthTex1_", depthUnit1.getUnitNumber());
inport0_.setTextureParameters(program_, "texParams0_");
inport1_.setTextureParameters(program_, "texParams1_");
program_->setIgnoreUniformLocationError(false);
glDepthFunc(GL_ALWAYS);
renderQuad();
glDepthFunc(GL_LESS);
program_->deactivate();
outport_.deactivateTarget();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void ImageMasking::process() {
outport_.activateTarget();
outport_.clearTarget();
TextureUnit colorUnit, depthUnit, maskUnit;
inport_.bindTextures(colorUnit.getEnum(), depthUnit.getEnum());
inportMask_.bindColorTexture(maskUnit.getEnum());
// compile program if needed
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
LGL_ERROR;
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
program_->setIgnoreUniformLocationError(true);
program_->setUniform("colorTex_", colorUnit.getUnitNumber());
program_->setUniform("depthTex_", depthUnit.getUnitNumber());
program_->setUniform("colorTexMask_", maskUnit.getUnitNumber());
inport_.setTextureParameters(program_, "texParams_");
inportMask_.setTextureParameters(program_, "texParamsMask_");
program_->setIgnoreUniformLocationError(false);
program_->setUniform("maskColor_", maskColor_.get());
glDepthFunc(GL_ALWAYS);
renderQuad();
glDepthFunc(GL_LESS);
program_->deactivate();
outport_.deactivateTarget();
glActiveTexture(GL_TEXTURE0);
LGL_ERROR;
}
void HalfAngleSlicer::process() {
// compile program if needed
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
LGL_ERROR;
lightport_.activateTarget();
glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
lightport_.deactivateTarget();
outport_.activateTarget();
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
outport_.deactivateTarget();
// bind transfer function
TextureUnit transferUnit;
transferUnit.activate();
if (transferFunc_.get())
transferFunc_.get()->bind();
transferFunc_.setVolumeHandle(volumeInport_.getData());
// vector containing the volumes to bind; is passed to bindVolumes()
std::vector<VolumeStruct> volumeTextures;
// add main volume
TextureUnit volUnit;
volumeTextures.push_back(VolumeStruct(
volumeInport_.getData(),
&volUnit,
"volume_","volumeStruct_")
);
// initialize slicing shader
tgt::Shader* slicingPrg = shaderProp_.getShader();
slicingPrg->activate();
// fragment shader uniforms
transferFunc_.get()->setUniform(slicingPrg, "transferFunc_", "transferFuncTex_", transferUnit.getUnitNumber());
// set common uniforms used by all shaders
tgt::Camera cam = eyeCamera_.get();
// bind the volumes and pass the necessary information to the shader
bindVolumes(slicingPrg, volumeTextures, &cam, lightPosition_.get());
setupUniforms(slicingPrg);
// correct slice distance for this technique
sliceDistance_ *= 0.5f*std::sqrt(1.f + dot(eyeCamera_.get().getLook(), lightCamera_.getLook()));
slicingPrg->setUniform("dPlaneIncr_", sliceDistance_);
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
tgt::loadMatrix(eyeCamera_.get().getProjectionMatrix(outport_.getSize()));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
tgt::loadMatrix(eyeCamera_.get().getViewMatrix());
slicingPrg->activate();
glEnable(GL_BLEND);
unsigned int numSlices = static_cast<unsigned int>(maxLength_ / sliceDistance_);
TextureUnit lightBufferUnit;
slicingPrg->setUniform("lightBuf_", lightBufferUnit.getUnitNumber());
slicingPrg->setUniform("lightMat_", lightCamera_.getViewMatrix());
lightport_.setTextureParameters(slicingPrg, "lightBufParameters_");
for (unsigned int curSlice = 0; curSlice < numSlices; curSlice++) {
outport_.activateTarget();
// FIRST PASS
if(invert_)
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
else
glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE);
lightBufferUnit.activate();
glEnable(GL_TEXTURE_2D);
lightport_.bindColorTexture();
tgt::Camera cam = eyeCamera_.get();
setGlobalShaderParameters(slicingPrg, &cam);
slicingPrg->setUniform("secondPass_", false);
glBegin(GL_POLYGON);
for (unsigned int curPoint=0; curPoint<6; curPoint++)
glVertex2i(curPoint, curSlice);
glEnd();
outport_.deactivateTarget();
// SECOND PASS
lightport_.activateTarget();
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glPushMatrix();
tgt::loadMatrix(lightCamera_.getViewMatrix());
setGlobalShaderParameters(slicingPrg, &lightCamera_);
slicingPrg->setUniform("secondPass_", true);
glBegin(GL_POLYGON);
for (unsigned int curPoint=0; curPoint<6; curPoint++)
glVertex2i(curPoint, curSlice);
glEnd();
glPopMatrix();
lightport_.deactivateTarget();
}
glBlendFunc(GL_ONE, GL_ZERO);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
slicingPrg->deactivate();
glClearColor(0.0, 0.0, 0.0, 0.0);
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void RGBRaycaster::process() {
if (!volumePort_.isReady())
return;
if (!outport_.isReady())
return;
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// compile program
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
LGL_ERROR;
TextureUnit entryUnit, entryDepthUnit, exitUnit, exitDepthUnit;
// bind entry params
entryPort_.bindTextures(entryUnit.getEnum(), entryDepthUnit.getEnum());
// bind exit params
exitPort_.bindTextures(exitUnit.getEnum(), exitDepthUnit.getEnum());
// vector containing the volumes to bind; is passed to bindVolumes()
std::vector<VolumeStruct> volumeTextures;
// add main volume
TextureUnit volUnit;
volumeTextures.push_back(VolumeStruct(
volumePort_.getData(),
&volUnit,
"volumeStruct_")
);
// bind transfer function
TextureUnit transferUnit;
transferUnit.activate();
if (transferFunc_.get())
transferFunc_.get()->bind();
// initialize shader
raycastPrg_->activate();
// set common uniforms used by all shaders
tgt::Camera cam = camera_.get();
setGlobalShaderParameters(raycastPrg_, &cam);
// bind the volumes and pass the necessary information to the shader
bindVolumes(raycastPrg_, volumeTextures, &cam, lightPosition_.get());
// pass the remaining uniforms to the shader
raycastPrg_->setUniform("entryPoints_", entryUnit.getUnitNumber());
raycastPrg_->setUniform("entryPointsDepth_", entryDepthUnit.getUnitNumber());
entryPort_.setTextureParameters(raycastPrg_, "entryParameters_");
raycastPrg_->setUniform("exitPoints_", exitUnit.getUnitNumber());
raycastPrg_->setUniform("exitPointsDepth_", exitDepthUnit.getUnitNumber());
exitPort_.setTextureParameters(raycastPrg_, "exitParameters_");
transferFunc_.get()->setUniform(raycastPrg_, "transferFunc_", transferUnit.getUnitNumber());
raycastPrg_->setUniform("applyColorModulation_", applyColorModulation_.get());
renderQuad();
raycastPrg_->deactivate();
TextureUnit::setZeroUnit();
outport_.deactivateTarget();
LGL_ERROR;
}
void CurvatureRaycaster::process() {
// compile program if needed
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
LGL_ERROR;
// bind transfer function
TextureUnit transferUnit;
transferUnit.activate();
if (transferFunc_.get())
transferFunc_.get()->bind();
portGroup_.activateTargets();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
LGL_ERROR;
transferFunc_.setVolumeHandle(volumeInport_.getData());
TextureUnit entryUnit, entryDepthUnit, exitUnit, exitDepthUnit;
// bind entry params
entryPort_.bindTextures(entryUnit.getEnum(), entryDepthUnit.getEnum());
LGL_ERROR;
// bind exit params
exitPort_.bindTextures(exitUnit.getEnum(), exitDepthUnit.getEnum());
LGL_ERROR;
// vector containing the volumes to bind; is passed to bindVolumes()
std::vector<VolumeStruct> volumeTextures;
// add main volume
TextureUnit volUnit, volUnit2;
volumeTextures.push_back(VolumeStruct(
volumeInport_.getData(),
&volUnit,
"volumeStruct_")
);
volumeTextures.push_back(VolumeStruct(
gradientInport_.getData(),
&volUnit2,
"gradientVolumeParameters_")
);
// segmentation volume
//VolumeHandle* volumeSeg = volumeInport_.getData()->getRelatedVolumeHandle(Modality::MODALITY_SEGMENTATION);
VolumeHandle* volumeSeg = 0;
bool usingSegmentation = (maskingMode_.get() == "Segmentation") && volumeSeg;
TextureUnit segUnit;
if (usingSegmentation) {
// Important to set the correct texture unit before getRepresentation<VolumeGL>() is called or
// glTexParameter() might influence the wrong texture.
segUnit.activate();
volumeTextures.push_back(VolumeStruct(volumeSeg,
&segUnit,
"segmentationParameters_"));
// set texture filtering for this texture unit
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
// initialize shader
raycastPrg_->activate();
// set common uniforms used by all shaders
tgt::Camera cam = camera_.get();
setGlobalShaderParameters(raycastPrg_, &cam);
// bind the volumes and pass the necessary information to the shader
bindVolumes(raycastPrg_, volumeTextures, &cam, lightPosition_.get());
// pass the remaining uniforms to the shader
raycastPrg_->setUniform("entryPoints_", entryUnit.getUnitNumber());
raycastPrg_->setUniform("entryPointsDepth_", entryDepthUnit.getUnitNumber());
entryPort_.setTextureParameters(raycastPrg_, "entryParameters_");
raycastPrg_->setUniform("exitPoints_", exitUnit.getUnitNumber());
raycastPrg_->setUniform("exitPointsDepth_", exitDepthUnit.getUnitNumber());
exitPort_.setTextureParameters(raycastPrg_, "exitParameters_");
if (compositingMode_.get() == "iso" ||
compositingMode1_.get() == "iso" ||
compositingMode2_.get() == "iso")
raycastPrg_->setUniform("isoValue_", isoValue_.get());
if (classificationMode_.get() == "transfer-function")
transferFunc_.get()->setUniform(raycastPrg_, "transferFunc_", transferUnit.getUnitNumber());
// curvature uniforms
GLint curvatureType = -1;
if (curvatureType_.get() == "first") curvatureType = 0;
else if (curvatureType_.get() == "second") curvatureType = 1;
else if (curvatureType_.get() == "mean") curvatureType = 2;
else if (curvatureType_.get() == "gauss") curvatureType = 3;
raycastPrg_->setUniform("curvatureType_", curvatureType);
raycastPrg_->setUniform("curvatureFactor_", curvatureFactor_.get());
raycastPrg_->setUniform("silhouetteWidth_", silhouetteWidth_.get());
raycastPrg_->setUniform("minGradientLength_", minGradientLength_.get());
LGL_ERROR;
renderQuad();
raycastPrg_->deactivate();
if (usingSegmentation) {
// restore default texture filtering mode
segUnit.activate();
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
LGL_ERROR;
}
void ExplosionCompositor::process() {
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
if (loopOutport_.getLoopIteration() == 0) {
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
interalPort_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
TextureUnit colorUnit0, depthUnit0, colorUnit1, depthUnit1;
if ((loopOutport_.getLoopIteration() % 2) == 0) {
// outport <-- inport + internal
outport_.activateTarget();
inport0_.bindTextures(colorUnit0.getEnum(), depthUnit0.getEnum());
interalPort_.bindTextures(colorUnit1.getEnum(), depthUnit1.getEnum());
}
else {
// internal <-- inport + outport
interalPort_.activateTarget();
inport0_.bindTextures(colorUnit0.getEnum(), depthUnit0.getEnum());
outport_.bindTextures(colorUnit1.getEnum(), depthUnit1.getEnum());
}
if (loopOutport_.getLoopIteration() == (loopOutport_.getNumLoopIterations()-1)){
outport_.activateTarget();
}
glDepthFunc(GL_ALWAYS);
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
if (compositingMode_.get() != "take-second") {
program_->setUniform("colorTex0_", colorUnit0.getUnitNumber());
program_->setUniform("depthTex0_", depthUnit0.getUnitNumber());
//inport0_.setTextureParameters(program_, "textureParameters0_");
outport_.setTextureParameters(program_, "textureParameters0_");
}
if (compositingMode_.get() != "take-first") {
program_->setUniform("colorTex1_", colorUnit1.getUnitNumber());
program_->setUniform("depthTex1_", depthUnit1.getUnitNumber());
//interalPort_.setTextureParameters(program_, "textureParameters1_");
outport_.setTextureParameters(program_, "textureParameters1_");
}
if (compositingMode_.get() == "weighted-average")
program_->setUniform("weightingFactor_", weightingFactor_.get());
renderQuad();
glDepthFunc(GL_LESS);
program_->deactivate();
outport_.deactivateTarget();
interalPort_.deactivateTarget();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void TransFuncOverlay::beforeProcess() {
ImageProcessor::beforeProcess();
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
}
void OcclusionSlicer::process() {
// compile program if needed
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
LGL_ERROR;
occlusionbuffer0_.activateTarget();
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
occlusionbuffer1_.activateTarget();
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
outport_.activateTarget();
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
LGL_ERROR;
// bind transfer function
TextureUnit transferUnit;
transferUnit.activate();
if (transferFunc_.get())
transferFunc_.get()->bind();
transferFunc_.setVolumeHandle(volumeInport_.getData());
// vector containing the volumes to bind; is passed to bindVolumes()
std::vector<VolumeStruct> volumeTextures;
// add main volume
TextureUnit volUnit;
volumeTextures.push_back(VolumeStruct(
volumeInport_.getData(),
&volUnit,
"volume_","volumeStruct_")
);
// initialize slicing shader
tgt::Shader* slicingPrg = shaderProp_.getShader();
slicingPrg->activate();
// fragment shader uniforms
TextureUnit occlusionUnit;
transferFunc_.get()->setUniform(slicingPrg, "transferFunc_", "transferFuncTex_", transferUnit.getUnitNumber());
slicingPrg->setUniform("occlusion_", occlusionUnit.getUnitNumber());
occlusionbuffer1_.setTextureParameters(slicingPrg, "occlusionParams_");
//clipping uniforms
setupUniforms(slicingPrg);
// set common uniforms used by all shaders
tgt::Camera cam = camera_.get();
setGlobalShaderParameters(slicingPrg, &cam);
slicingPrg->setUniform("sigma_", sigma_.get());
slicingPrg->setUniform("radius_", radius_.get());
slicingPrg->setUniform("lightPos_", lightPosition_.get().xyz());
// bind the volumes and pass the necessary information to the shader
bindVolumes(slicingPrg, volumeTextures, &cam, lightPosition_.get());
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
tgt::loadMatrix(camera_.get().getProjectionMatrix(outport_.getSize()));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
tgt::loadMatrix(camera_.get().getViewMatrix());
unsigned int numSlices = static_cast<unsigned int>(maxLength_ / sliceDistance_);
slicingPrg->activate();
for (unsigned int curSlice=0; curSlice<numSlices; curSlice++) {
// first pass
slicingPrg->setUniform("secondPass_", false);
outport_.activateTarget();
glEnable(GL_BLEND);
glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE);
occlusionbuffer0_.bindColorTexture(occlusionUnit.getEnum());
glBegin(GL_POLYGON);
for (unsigned int curPoint=0; curPoint<6; curPoint++)
glVertex2i(curPoint, curSlice);
glEnd();
glDisable(GL_BLEND);
outport_.deactivateTarget();
// second pass
slicingPrg->setUniform("secondPass_", true);
occlusionbuffer1_.activateTarget();
slicingPrg->setUniform("blurDirection_", tgt::vec2(1.f, 0.f));
glBegin(GL_POLYGON);
for (unsigned int curPoint=0; curPoint<6; curPoint++)
glVertex2i(curPoint, curSlice);
glEnd();
occlusionbuffer1_.deactivateTarget();
occlusionbuffer0_.activateTarget();
occlusionbuffer1_.bindColorTexture(occlusionUnit.getEnum());
slicingPrg->setUniform("blurDirection_", tgt::vec2(0.f, 1.f));
glBegin(GL_POLYGON);
for (unsigned int curPoint=0; curPoint<6; curPoint++)
glVertex2i(curPoint, curSlice);
glEnd();
occlusionbuffer0_.deactivateTarget();
}
slicingPrg->deactivate();
glEnable(GL_DEPTH_TEST);
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glBlendFunc(GL_ONE, GL_ZERO);
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void MultiVolumeRaycaster::process() {
// compile program if needed
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
LGL_ERROR;
// bind transfer function
TextureUnit transferUnit1, transferUnit2, transferUnit3, transferUnit4;
transferUnit1.activate();
if (transferFunc1_.get())
transferFunc1_.get()->bind();
transferUnit2.activate();
if (transferFunc2_.get())
transferFunc2_.get()->bind();
transferUnit3.activate();
if (transferFunc3_.get())
transferFunc3_.get()->bind();
transferUnit4.activate();
if (transferFunc4_.get())
transferFunc4_.get()->bind();
portGroup_.activateTargets();
portGroup_.clearTargets();
LGL_ERROR;
transferFunc1_.setVolumeHandle(volumeInport1_.getData());
transferFunc2_.setVolumeHandle(volumeInport2_.getData());
transferFunc3_.setVolumeHandle(volumeInport3_.getData());
transferFunc4_.setVolumeHandle(volumeInport4_.getData());
TextureUnit entryUnit, entryDepthUnit, exitUnit, exitDepthUnit;
// bind entry params
entryPort_.bindTextures(entryUnit.getEnum(), entryDepthUnit.getEnum());
LGL_ERROR;
// bind exit params
exitPort_.bindTextures(exitUnit.getEnum(), exitDepthUnit.getEnum());
LGL_ERROR;
// vector containing the volumes to bind; is passed to bindVolumes()
std::vector<VolumeStruct> volumeTextures;
std::vector<const VolumeHandleBase*> volumeHandles;
// bind volumes
TextureUnit volUnit1, volUnit2, volUnit3, volUnit4;
if (volumeInport1_.isReady()) {
volumeInport1_.getData()->getRepresentation<VolumeGL>();
volumeTextures.push_back(VolumeStruct(
volumeInport1_.getData(),
&volUnit1,
"volumeStruct1_",
texClampMode1_.getValue(),
tgt::vec4(texBorderIntensity_.get()),
texFilterMode1_.getValue())
);
volumeHandles.push_back(volumeInport1_.getData());
}
if (volumeInport2_.isReady()) {
volumeInport2_.getData()->getRepresentation<VolumeGL>();
volumeTextures.push_back(VolumeStruct(
volumeInport2_.getData(),
&volUnit2,
"volumeStruct2_",
texClampMode2_.getValue(),
tgt::vec4(texBorderIntensity_.get()),
texFilterMode2_.getValue())
);
volumeHandles.push_back(volumeInport2_.getData());
}
if (volumeInport3_.isReady()) {
volumeInport3_.getData()->getRepresentation<VolumeGL>();
volumeTextures.push_back(VolumeStruct(
volumeInport3_.getData(),
&volUnit3,
"volumeStruct3_",
texClampMode3_.getValue(),
tgt::vec4(texBorderIntensity_.get()),
texFilterMode3_.getValue())
);
volumeHandles.push_back(volumeInport3_.getData());
}
if (volumeInport4_.isReady()) {
volumeInport4_.getData()->getRepresentation<VolumeGL>();
volumeTextures.push_back(VolumeStruct(
volumeInport4_.getData(),
&volUnit4,
"volumeStruct4_",
texClampMode4_.getValue(),
tgt::vec4(texBorderIntensity_.get()),
texFilterMode4_.getValue())
);
volumeHandles.push_back(volumeInport4_.getData());
}
// initialize shader
raycastPrg_->activate();
// set common uniforms used by all shaders
tgt::Camera cam = camera_.get();
setGlobalShaderParameters(raycastPrg_, &cam);
// bind the volumes and pass the necessary information to the shader
bindVolumes(raycastPrg_, volumeTextures, &cam, lightPosition_.get());
// pass the remaining uniforms to the shader
raycastPrg_->setUniform("entryPoints_", entryUnit.getUnitNumber());
raycastPrg_->setUniform("entryPointsDepth_", entryDepthUnit.getUnitNumber());
entryPort_.setTextureParameters(raycastPrg_, "entryParameters_");
raycastPrg_->setUniform("exitPoints_", exitUnit.getUnitNumber());
raycastPrg_->setUniform("exitPointsDepth_", exitDepthUnit.getUnitNumber());
exitPort_.setTextureParameters(raycastPrg_, "exitParameters_");
if (compositingMode_.get() == "iso" ||
compositingMode1_.get() == "iso" ||
compositingMode2_.get() == "iso")
raycastPrg_->setUniform("isoValue_", isoValue_.get());
if(volumeInport1_.isReady())
transferFunc1_.get()->setUniform(raycastPrg_, "transferFunc_", transferUnit1.getUnitNumber());
if(volumeInport2_.isReady())
transferFunc2_.get()->setUniform(raycastPrg_, "transferFunc2_", transferUnit2.getUnitNumber());
if(volumeInport3_.isReady())
transferFunc3_.get()->setUniform(raycastPrg_, "transferFunc3_", transferUnit3.getUnitNumber());
if(volumeInport4_.isReady())
transferFunc4_.get()->setUniform(raycastPrg_, "transferFunc4_", transferUnit4.getUnitNumber());
// determine ray step length in world coords
if (volumeTextures.size() > 0) {
float voxelSizeWorld = 999.f;
float voxelSizeTexture = 999.f;
for(size_t i=0; i<volumeHandles.size(); ++i) {
const VolumeHandleBase* volume = volumeHandles[i];
tgtAssert(volume, "No volume");
tgt::ivec3 volDim = volume->getDimensions();
tgt::vec3 cubeSizeWorld = volume->getCubeSize() * volume->getPhysicalToWorldMatrix().getScalingPart();
float tVoxelSizeWorld = tgt::max(cubeSizeWorld / tgt::vec3(volDim));
if (tVoxelSizeWorld < voxelSizeWorld) {
voxelSizeWorld = tVoxelSizeWorld;
voxelSizeTexture = tgt::max(1.f / tgt::vec3(volDim));
}
}
float samplingStepSizeWorld = voxelSizeWorld / samplingRate_.get();
float samplingStepSizeTexture = voxelSizeTexture / samplingRate_.get();
if (interactionMode()) {
samplingStepSizeWorld /= interactionQuality_.get();
samplingStepSizeTexture /= interactionQuality_.get();
}
raycastPrg_->setUniform("samplingStepSize_", samplingStepSizeWorld);
if (compositingMode_.isSelected("dvr") ||
(compositingMode1_.isSelected("dvr") && outport1_.isConnected()) ||
(compositingMode2_.isSelected("dvr") && outport2_.isConnected()) ) {
// adapts the compositing of the multivolume RC to the one of the singlevolume RC (see below).
raycastPrg_->setUniform("mvOpacityCorrectionFactor_", samplingStepSizeTexture / samplingStepSizeWorld);
}
LGL_ERROR;
}
LGL_ERROR;
renderQuad();
raycastPrg_->deactivate();
portGroup_.deactivateTargets();
if (outport_.isConnected())
outport_.validateResult();
if (outport1_.isConnected())
outport1_.validateResult();
if (outport2_.isConnected())
outport2_.validateResult();
glActiveTexture(GL_TEXTURE0);
LGL_ERROR;
}
void TextOverlay::process() {
if (!inport_.isReady())
outport_.activateTarget();
else
privatePort_.activateTarget();
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClearDepth(1.0);
glDisable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
#ifndef VRN_MODULE_FONTRENDERING
LWARNING("Empty output, enable module 'fontrendering'.");
#endif
if(enabled_.get())
renderOverlay();
if (!inport_.isReady())
outport_.deactivateTarget();
else
privatePort_.deactivateTarget();
glEnable(GL_DEPTH_TEST);
// skip if there's nothing to render above
if (inport_.isReady()) {
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
TextureUnit colorUnit0, colorUnit1, depthUnit0, depthUnit1;
privatePort_.bindTextures(colorUnit0.getEnum(), depthUnit0.getEnum());
inport_.bindTextures(colorUnit1.getEnum(), depthUnit1.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
program_->setUniform("colorTex0_", colorUnit0.getUnitNumber());
program_->setUniform("colorTex1_", colorUnit1.getUnitNumber());
program_->setUniform("depthTex1_", depthUnit1.getUnitNumber());
privatePort_.setTextureParameters(program_, "textureParameters0_");
inport_.setTextureParameters(program_, "textureParameters1_");
program_->setUniform("option_", blendMode_.getValue());
ImageProcessor::renderQuad();
outport_.deactivateTarget();
TextureUnit::setZeroUnit();
program_->deactivate();
}
LGL_ERROR;
}
void GeometryRenderer::render() {
tgtAssert(inport_.hasData(), "No geometry");
if(useShader_.get() && (!shaderProp_.hasValidShader() || getInvalidationLevel() >= Processor::INVALID_PROGRAM))
compile();
if(useShader_.get() && !shaderProp_.hasValidShader()) {
LERROR("Shader for geometry failed to compile");
return;
}
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPolygonMode(GL_FRONT_AND_BACK, polygonMode_.getValue());
glShadeModel(GL_SMOOTH);
if (polygonMode_.isSelected("point"))
glPointSize(pointSize_.get());
else if (polygonMode_.isSelected("line"))
glLineWidth(lineWidth_.get());
if (mapTexture_.get() && texPort_.isReady()) {
texPort_.bindColorTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, textureMode_.getValue());
}
if (enableLighting_.get()) {
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, tgt::vec4(0.f).elem);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, lightPosition_.get().elem);
glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient_.get().elem);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse_.get().elem);
glLightfv(GL_LIGHT0, GL_SPECULAR, lightSpecular_.get().elem);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, materialShininess_.get());
LGL_ERROR;
}
// for triangle meshes, we need to use a correctly layouted shader
if(useShader_.get()) {
tgt::Shader* prog = shaderProp_.getShader();
prog->activate();
setGlobalShaderParameters(prog, &camera_);
prog->setIgnoreUniformLocationError(true);
prog->setUniform("enableLighting_", enableLighting_.get());
if(enableLighting_.get()) {
prog->setUniform("lightPosition_", lightPosition_.get());
prog->setUniform("lightSource_.ambientColor_", lightAmbient_.get().xyz());
prog->setUniform("lightSource_.diffuseColor_", lightDiffuse_.get().xyz());
prog->setUniform("lightSource_.specularColor_", lightSpecular_.get().xyz());
//prog->setUniform("lightSource_.attenuation_", tgt::vec3(1.f, 0.f, 0.f));
prog->setUniform("shininess_", materialShininess_.get());
}
prog->setUniform("enableClipping_", enableClipping_.get());
if(enableClipping_.get())
prog->setUniform("plane_", tgt::vec4(normalize(planeNormal_.get()), planeDistance_.get()));
}
inport_.getData()->render();
if(useShader_.get())
shaderProp_.getShader()->deactivate();
glPopAttrib();
}
void SingleVolumeSlicer::process() {
// compile program if needed
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
LGL_ERROR;
// bind transfer function
TextureUnit transferUnit;
transferUnit.activate();
if (transferFunc_.get())
transferFunc_.get()->bind();
transferFunc_.setVolumeHandle(volumeInport_.getData());
// vector containing the volumes to bind; is passed to bindVolumes()
std::vector<VolumeStruct> volumeTextures;
// add main volume
TextureUnit volUnit;
volumeTextures.push_back(VolumeStruct(
volumeInport_.getData(),
&volUnit,
"volume_","volumeStruct_")
);
// initialize slicing shader
tgt::Shader* slicingPrg = shaderProp_.getShader();
slicingPrg->activate();
// fragment shader uniforms
transferFunc_.get()->setUniform(slicingPrg, "transferFunc_", "transferFuncTex_", transferUnit.getUnitNumber());
setupUniforms(slicingPrg);
// set common uniforms used by all shaders
tgt::Camera cam = camera_.get();
setGlobalShaderParameters(slicingPrg, &cam);
// bind the volumes and pass the necessary information to the shader
bindVolumes(slicingPrg, volumeTextures, &cam, lightPosition_.get());
glDisable(GL_DEPTH_TEST);
MatStack.matrixMode(tgt::MatrixStack::PROJECTION);
MatStack.pushMatrix();
MatStack.loadMatrix(camera_.get().getProjectionMatrix(outport_.getSize()));
MatStack.matrixMode(tgt::MatrixStack::MODELVIEW);
MatStack.pushMatrix();
MatStack.loadMatrix(camera_.get().getViewMatrix());
unsigned int numSlices = static_cast<unsigned int>(maxLength_ / sliceDistance_);
slicingPrg->activate();
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE);
for (unsigned int curSlice=0; curSlice<numSlices; curSlice++) {
glBegin(GL_POLYGON);
for (unsigned int curPoint=0; curPoint<6; curPoint++)
glVertex2i(curPoint, curSlice);
glEnd();
}
glBlendFunc(GL_ONE, GL_ZERO);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
MatStack.popMatrix();
MatStack.matrixMode(tgt::MatrixStack::PROJECTION);
MatStack.popMatrix();
MatStack.matrixMode(tgt::MatrixStack::MODELVIEW);
slicingPrg->deactivate();
outport_.deactivateTarget();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void GeometryRenderer::process() {
if(useShader_.get() && getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
}
bool PropertyOwner::isValid() const {
return (getInvalidationLevel() == 0);
}
/**
* Performs the raycasting.
*
* Initialize two texture units with the entry and exit params and renders
* a screen aligned quad.
*/
void IDRaycaster::process() {
if (!volumePort_.isReady())
return;
if(getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
LGL_ERROR;
idMapPort_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// don't render when in interaction mode
if (interactionMode()) {
idMapPort_.deactivateTarget();
TextureUnit::setZeroUnit();
return;
}
TextureUnit entryUnit, entryDepthUnit, exitUnit, exitDepthUnit, firstHitPointUnit;
// bind entry params
entryPort_.bindTextures(entryUnit.getEnum(), entryDepthUnit.getEnum());
// bind first hit points
firstHitpointsPort_.bindColorTexture(firstHitPointUnit.getEnum());
// bind exit params
exitPort_.bindTextures(exitUnit.getEnum(), exitDepthUnit.getEnum());
// vector containing the volumes to bind
std::vector<VolumeStruct> volumes;
TextureUnit volUnit;
volumes.push_back(VolumeStruct(
volumePort_.getData(),
&volUnit,
"segmentation_","segmentationParameters_",
GL_CLAMP_TO_EDGE,
tgt::vec4(0.f),
GL_NEAREST)
);
// initialize shader
raycastPrg_->activate();
tgt::Camera cam = camera_.get();
setGlobalShaderParameters(raycastPrg_, &cam);
bindVolumes(raycastPrg_, volumes, &cam, lightPosition_.get());
raycastPrg_->setUniform("entryPoints_", entryUnit.getUnitNumber());
raycastPrg_->setUniform("entryPointsDepth_", entryDepthUnit.getUnitNumber());
entryPort_.setTextureParameters(raycastPrg_, "entryParameters_");
raycastPrg_->setUniform("firstHitPoints_", firstHitPointUnit.getUnitNumber());
firstHitpointsPort_.setTextureParameters(raycastPrg_, "firstHitParameters_");
raycastPrg_->setUniform("exitPoints_", exitUnit.getUnitNumber());
raycastPrg_->setUniform("exitPointsDepth_", exitDepthUnit.getUnitNumber());
entryPort_.setTextureParameters(raycastPrg_, "exitParameters_");
raycastPrg_->setUniform("penetrationDepth_", penetrationDepth_.get());
renderQuad();
raycastPrg_->deactivate();
idMapPort_.deactivateTarget();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void Compositor::process() {
if(!inport1_.isReady() && pipeThroughIfSecondNotReady_.get()) {
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// bind input image to tex unit
TextureUnit imageUnit, imageUnitDepth;
inport0_.bindTextures(imageUnit.getEnum(), imageUnitDepth.getEnum());
// copy input image to outport
copyShader_->activate();
setGlobalShaderParameters(copyShader_);
inport0_.setTextureParameters(copyShader_, "texParams_");
copyShader_->setUniform("colorTex_", imageUnit.getUnitNumber());
copyShader_->setUniform("depthTex_", imageUnitDepth.getUnitNumber());
renderQuad();
copyShader_->deactivate();
outport_.deactivateTarget();
tgt::TextureUnit::setZeroUnit();
LGL_ERROR;
return;
}
else if(!inport1_.isReady())
return;
if (getInvalidationLevel() >= Processor::INVALID_PROGRAM)
compile();
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDepthFunc(GL_ALWAYS);
TextureUnit colorUnit, depthUnit;
TextureUnit colorUnit1, depthUnit1;
inport0_.bindTextures(colorUnit.getEnum(), depthUnit.getEnum());
inport1_.bindTextures(colorUnit1.getEnum(), depthUnit1.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
if (compositingMode_.get() != "take-second") {
program_->setUniform("colorTex0_", colorUnit.getUnitNumber());
program_->setUniform("depthTex0_", depthUnit.getUnitNumber());
inport0_.setTextureParameters(program_, "textureParameters0_");
}
if (compositingMode_.get() != "take-first") {
program_->setUniform("colorTex1_", colorUnit1.getUnitNumber());
program_->setUniform("depthTex1_", depthUnit1.getUnitNumber());
inport1_.setTextureParameters(program_, "textureParameters1_");
}
if (compositingMode_.get() == "take-second-if-ready") {
if(inport1_.isReady()) {
program_->setUniform("colorTex0_", colorUnit1.getUnitNumber());
program_->setUniform("depthTex0_", depthUnit1.getUnitNumber());
inport1_.setTextureParameters(program_, "textureParameters0_");
}
else if(inport0_.isReady()){
program_->setUniform("colorTex0_", colorUnit.getUnitNumber());
program_->setUniform("depthTex0_", depthUnit.getUnitNumber());
inport0_.setTextureParameters(program_, "textureParameters0_");
}
}
if (compositingMode_.get() == "weighted-average")
program_->setUniform("weightingFactor_", weightingFactor_.get());
if (compositingMode_.get() == "add") {
program_->setUniform("weightFirst_", weightFirst_.get());
program_->setUniform("weightSecond_", weightSecond_.get());
program_->setUniform("addDepth_", addDepth_.get());
}
renderQuad();
glDepthFunc(GL_LESS);
program_->deactivate();
outport_.deactivateTarget();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
