void SimpleRaycaster::process() {
// activate and clear output render target
outport_.activateTarget();
outport_.clearTarget();
// retrieve shader from shader property
tgt::Shader* shader = shader_.getShader();
if (!shader || !shader->isLinked()) {
outport_.deactivateTarget();
return;
}
// activate shader and set common uniforms
shader->activate();
tgt::Camera cam = camera_.get();
setGlobalShaderParameters(shader, &cam);
// bind entry and exit params and pass texture units to the shader
TextureUnit entryUnit, entryDepthUnit, exitUnit, exitDepthUnit;
entryPort_.bindTextures(entryUnit, entryDepthUnit);
shader->setUniform("entryPoints_", entryUnit.getUnitNumber());
shader->setUniform("entryPointsDepth_", entryDepthUnit.getUnitNumber());
entryPort_.setTextureParameters(shader, "entryParameters_");
exitPort_.bindTextures(exitUnit, exitDepthUnit);
shader->setUniform("exitPoints_", exitUnit.getUnitNumber());
shader->setUniform("exitPointsDepth_", exitDepthUnit.getUnitNumber());
exitPort_.setTextureParameters(shader, "exitParameters_");
// bind volume texture and pass it to the shader
std::vector<VolumeStruct> volumeTextures;
TextureUnit volUnit;
volumeTextures.push_back(VolumeStruct(
volumePort_.getData(),
&volUnit,
"volume_",
"volumeStruct_",
volumePort_.getTextureClampModeProperty().getValue(),
tgt::vec4(volumePort_.getTextureBorderIntensityProperty().get()),
volumePort_.getTextureFilterModeProperty().getValue())
);
bindVolumes(shader, volumeTextures, &cam, lightPosition_.get());
// bind transfer function and pass it to the shader
TextureUnit transferUnit;
if (transferFunc_.get()) {
transferUnit.activate();
transferFunc_.get()->bind();
transferFunc_.get()->setUniform(shader, "transferFunc_", "transferFuncTex_", transferUnit.getUnitNumber());
}
// render screen aligned quad
renderQuad();
// clean up
shader->deactivate();
outport_.deactivateTarget();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void SimpleRaycaster::process() {
// activate and clear output render target
outport_.activateTarget();
outport_.clearTarget();
// activate shader and set common uniforms
raycastPrg_->activate();
tgt::Camera cam = camera_.get();
setGlobalShaderParameters(raycastPrg_, &cam);
// bind entry and exit params and pass texture units to the shader
TextureUnit entryUnit, entryDepthUnit, exitUnit, exitDepthUnit;
entryPort_.bindTextures(entryUnit, entryDepthUnit);
raycastPrg_->setUniform("entryPoints_", entryUnit.getUnitNumber());
raycastPrg_->setUniform("entryPointsDepth_", entryDepthUnit.getUnitNumber());
entryPort_.setTextureParameters(raycastPrg_, "entryParameters_");
exitPort_.bindTextures(exitUnit, exitDepthUnit);
raycastPrg_->setUniform("exitPoints_", exitUnit.getUnitNumber());
raycastPrg_->setUniform("exitPointsDepth_", exitDepthUnit.getUnitNumber());
exitPort_.setTextureParameters(raycastPrg_, "exitParameters_");
// bind volume texture and pass it to the shader
std::vector<VolumeStruct> volumeTextures;
TextureUnit volUnit;
volumeTextures.push_back(VolumeStruct(
volumePort_.getData()->getVolumeGL(),
&volUnit,
"volume_",
"volumeParameters_",
true)
);
bindVolumes(raycastPrg_, volumeTextures, &cam, lightPosition_.get());
// bind transfer function and pass it to the shader
TextureUnit transferUnit;
if (transferFunc_.get()) {
transferUnit.activate();
transferFunc_.get()->bind();
raycastPrg_->setUniform("transferFunc_", transferUnit.getUnitNumber());
}
// render screen aligned quad
renderQuad();
// clean up
raycastPrg_->deactivate();
outport_.deactivateTarget();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void Z3DImage2DRenderer::render(Z3DEye eye)
{
if (!m_initialized)
return;
bool needRender = hasVolume() && !m_quads.empty();
if (!needRender)
return;
m_image2DShader.bind();
m_rendererBase->setGlobalShaderParameters(m_image2DShader, eye);
bindVolumes(m_image2DShader);
for (size_t i=0; i<m_quads.size(); ++i)
renderTriangleList(m_image2DShader, m_quads[i]);
m_image2DShader.release();
}
/**
* 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 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 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 SingleVolumeRaycaster::process() {
// bind transfer function
tgt::TextureUnit transferUnit;
transferUnit.activate();
LGL_ERROR;
ClassificationModes::bindTexture(classificationMode_.get(), transferFunc_.get(), getSamplingStepSize(volumeInport_.getData()));
portGroup_.activateTargets();
portGroup_.clearTargets();
LGL_ERROR;
// bind entry params
tgt::TextureUnit entryUnit, entryDepthUnit, exitUnit, exitDepthUnit;
entryPort_.bindTextures(entryUnit, entryDepthUnit);
LGL_ERROR;
// bind exit params
exitPort_.bindTextures(exitUnit, exitDepthUnit);
LGL_ERROR;
// 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_",
volumeInport_.getTextureClampModeProperty().getValue(),
tgt::vec4(volumeInport_.getTextureBorderIntensityProperty().get()),
volumeInport_.getTextureFilterModeProperty().getValue())
);
// initialize shader
tgt::Shader* raycastPrg = shaderProp_.getShader();
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_.isSelected("iso") ||
compositingMode1_.isSelected("iso") ||
compositingMode2_.isSelected("iso") )
raycastPrg->setUniform("isoValue_", isoValue_.get());
if (ClassificationModes::usesTransferFunction(classificationMode_.get()))
transferFunc_.get()->setUniform(raycastPrg, "transferFunc_", "transferFuncTex_", transferUnit.getUnitNumber());
if (compositingMode_.isSelected("mida"))
raycastPrg->setUniform("gammaValue_", gammaValue_.get());
if (compositingMode1_.isSelected("mida"))
raycastPrg->setUniform("gammaValue1_", gammaValue1_.get());
if (compositingMode2_.isSelected("mida"))
raycastPrg->setUniform("gammaValue2_", gammaValue2_.get());
LGL_ERROR;
{
PROFILING_BLOCK("raycasting");
renderQuad();
}
raycastPrg->deactivate();
portGroup_.deactivateTargets();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
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 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 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 SingleVolumeRaycaster::process() {
// bind transfer function
tgt::TextureUnit transferUnit;
transferUnit.activate();
LGL_ERROR;
if (transferFunc_.get())
transferFunc_.get()->bind();
portGroup_.activateTargets();
portGroup_.clearTargets();
LGL_ERROR;
// bind entry params
tgt::TextureUnit entryUnit, entryDepthUnit, exitUnit, exitDepthUnit;
entryPort_.bindTextures(entryUnit, entryDepthUnit);
LGL_ERROR;
// bind exit params
exitPort_.bindTextures(exitUnit, exitDepthUnit);
LGL_ERROR;
// 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()->getVolumeGL(),
&volUnit,
"volume_",
"volumeParameters_",
true,
texClampMode_.getValue(),
tgt::vec4(texBorderIntensity_.get()),
texFilterMode_.getValue())
);
updateBrickingParameters(volumeInport_.getData());
TextureUnit brickUnit1, brickUnit2;
addBrickedVolumeModalities(volumeInport_.getData(), volumeTextures, &brickUnit1, &brickUnit2);
// 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_.isSelected("iso") ||
compositingMode1_.isSelected("iso") ||
compositingMode2_.isSelected("iso") )
raycastPrg_->setUniform("isoValue_", isoValue_.get());
if (classificationMode_.get() == "transfer-function")
raycastPrg_->setUniform("transferFunc_", transferUnit.getUnitNumber());
setBrickedVolumeUniforms(raycastPrg_, volumeInport_.getData());
LGL_ERROR;
{
PROFILING_BLOCK("raycasting");
renderQuad();
}
raycastPrg_->deactivate();
portGroup_.deactivateTargets();
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;
}