void PixelToBufferProcessor::handleInteractionEventsChanged() {
if (handleInteractionEvents_.get()) {
addInteractionHandler(this);
} else {
removeInteractionHandler(this);
}
}
OcclusionSlicer::OcclusionSlicer()
: VolumeSlicer()
, shaderProp_("slicing.shader", "Slicing shader", "sl_occlusion.frag", "sl_singlevolume.vert")
, occlusionbuffer0_(Port::OUTPORT, "image.occlusionbuffer0", "OcclusionBuffer0 Output", false, Processor::INVALID_RESULT,
//RenderPort::RENDERSIZE_DEFAULT, GL_RGBA16F_ARB)
RenderPort::RENDERSIZE_DEFAULT)
, occlusionbuffer1_(Port::OUTPORT, "image.occlusionbuffer1", "OcclusionBuffer1 Output", false, Processor::INVALID_RESULT,
/*RenderPort::RENDERSIZE_DEFAULT, GL_RGBA16F_ARB)*/
RenderPort::RENDERSIZE_DEFAULT)
, outport_(Port::OUTPORT, "image.eyebuffer", "EyeBuffer Output", true, Processor::INVALID_RESULT, RenderPort::RENDERSIZE_RECEIVER)
, cameraHandler_("cameraHandler", "Camera Handler", &camera_)
, sigma_("sigma", "Sigma", 100.0f, 0.0f, 1000.0f)
, radius_("radius", "Radius", 5, 0, 50)
{
addInteractionHandler(cameraHandler_);
addPrivateRenderPort(occlusionbuffer0_);
addPrivateRenderPort(occlusionbuffer1_);
addPort(outport_);
addProperty(shaderProp_);
addProperty(sigma_);
addProperty(radius_);
addProperty(lightPosition_);
}
void PointLightSourceProcessor::handleInteractionEventsChanged() {
if (interactionEvents_.get() > 0) {
addInteractionHandler(&lightInteractionHandler_);
} else {
removeInteractionHandler(&lightInteractionHandler_);
}
lightInteractionHandler_.setHandleEventsOptions(interactionEvents_.get());
}
SingleVolumeSlicer::SingleVolumeSlicer()
: VolumeSlicer()
, shaderProp_("slicing.shader", "Slicing shader", "sl_singlevolume.frag", "sl_singlevolume.vert")
, outport_(Port::OUTPORT, "image.output", "Image Output", false, Processor::INVALID_RESULT, RenderPort::RENDERSIZE_RECEIVER, GL_RGBA16F_ARB)
, cameraHandler_("cameraHandler", "Camera Handler", &camera_)
{
addInteractionHandler(cameraHandler_);
addProperty(shaderProp_);
addPort(outport_);
}
StereoMeshEntryExitPoints::StereoMeshEntryExitPoints()
: RenderProcessor()
, entryPort_(Port::OUTPORT, "image.entrypoints", "Entry-points Output", true, Processor::INVALID_RESULT, RenderPort::RENDERSIZE_RECEIVER)
, exitPort_(Port::OUTPORT, "image.exitpoints", "Exit-points Output", true, Processor::INVALID_RESULT, RenderPort::RENDERSIZE_RECEIVER)
, inport_(Port::INPORT, "proxgeometry.geometry", "Proxy Geometry Input")
, tmpPort_(Port::OUTPORT, "image.tmp", "image.tmp", false)
, supportCameraInsideVolume_("supportCameraInsideVolume", "Support camera in volume", true)
, jitterEntryPoints_("jitterEntryPoints", "Jitter entry params", false)
, useFloatRenderTargets_("useFloatRenderTargets", "Use float render targets", false)
, useCulling_("useCulling", "Use culling", true)
, jitterStepLength_("jitterStepLength", "Jitter step length", 0.005f, 0.0005f, 0.025f)
, camera_("camera", "Camera", tgt::Camera(vec3(0.f, 0.f, 3.5f), vec3(0.f, 0.f, 0.f), vec3(0.f, 1.f, 0.f)))
, cameraLeft_("cameraLeft", "Camera Left", tgt::Camera(vec3(0.f, 0.f, 3.5f), vec3(0.f, 0.f, 0.f), vec3(0.f, 1.f, 0.f)))
, cameraRight_("cameraRight", "Camera Right", tgt::Camera(vec3(0.f, 0.f, 3.5f), vec3(0.f, 0.f, 0.f), vec3(0.f, 1.f, 0.f)))
, eyeSeparation_("eyeSeparation", "Eye separation", 0.f, 0.f, 1.f)
, cameraDistance_("cameraDistance", "Camera distance", 0.f, 0.f, 5.f)
, shaderProgram_(0)
, shaderProgramJitter_(0)
{
addProperty(supportCameraInsideVolume_);
// jittering
addProperty(jitterEntryPoints_);
jitterEntryPoints_.onChange(CallMemberAction<StereoMeshEntryExitPoints>(this, &StereoMeshEntryExitPoints::onJitterEntryPointsChanged));
onJitterEntryPointsChanged(); // set initial state
jitterStepLength_.setStepping(0.001f);
jitterStepLength_.setNumDecimals(3);
addProperty(jitterStepLength_);
addProperty(useFloatRenderTargets_);
addProperty(useCulling_);
addProperty(camera_);
addProperty(cameraLeft_);
addProperty(cameraRight_);
addProperty(eyeSeparation_);
addProperty(cameraDistance_);
cameraHandler_ = new StereoCameraInteractionHandler("cameraHandler", "Camera",
&camera_, &cameraLeft_, &cameraRight_, &eyeSeparation_, &cameraDistance_);
addInteractionHandler(cameraHandler_);
addPort(entryPort_);
addPort(exitPort_);
addPort(inport_);
addPrivateRenderPort(&tmpPort_);
}
AlignedSliceProxyGeometry::AlignedSliceProxyGeometry()
: Processor()
, sliceAlignment_("sliceAlignmentProp", "Slice Alignment")
, sliceIndex_("sliceIndex", "Slice Number", 0, 0, 10000, Processor::VALID)
, floatSliceIndex_("floatSliceIndex", "Slice Number (Float)", 0.0f, 0.0f, 10000.0f, Processor::VALID)
, restrictToMainVolume_("restrictToMainVolume", "Restrict Rendering to Main Volume", false)
, camera_("camera", "Camera")
, alignCameraButton_("alignCameraButton", "Align Camera")
, plane_("plane", "Plane", vec3(1.0f, 0.0f, 0.0f), vec3(-5.0f), vec3(5.0f))
, planeDist_("planeDist", "Plane Distance", 0.0f, -1000.0f, 1000.0f)
, mwheelCycleHandler_("mouseWheelHandler", "Slice Cycling", &sliceIndex_)
, inport_(Port::INPORT, "volume", "Volume Input")
, secondaryVolumePort_(Port::INPORT, "secondaryVolumes", "Secondary Volumes", true)
, geomPort_(Port::OUTPORT, "geometry", "Geometry Output")
, textPort_(Port::OUTPORT, "text", "Text Output")
{
addInteractionHandler(mwheelCycleHandler_);
sliceAlignment_.addOption("xy-plane", "XY-Plane (axial)", XY_PLANE);
sliceAlignment_.addOption("xz-plane", "XZ-Plane (coronal)", XZ_PLANE);
sliceAlignment_.addOption("yz-plane", "YZ-Plane (sagittal)", YZ_PLANE);
sliceAlignment_.onChange( CallMemberAction<AlignedSliceProxyGeometry>(this, &AlignedSliceProxyGeometry::updateSliceProperties) );
addProperty(sliceAlignment_);
addProperty(sliceIndex_);
addProperty(floatSliceIndex_);
addProperty(restrictToMainVolume_);
addProperty(camera_);
addProperty(alignCameraButton_);
alignCameraButton_.onChange( CallMemberAction<AlignedSliceProxyGeometry>(this, &AlignedSliceProxyGeometry::alignCamera) );
sliceIndex_.onChange( CallMemberAction<AlignedSliceProxyGeometry>(this, &AlignedSliceProxyGeometry::indexChanged) );
floatSliceIndex_.onChange( CallMemberAction<AlignedSliceProxyGeometry>(this, &AlignedSliceProxyGeometry::floatIndexChanged) );
addProperty(plane_);
plane_.setInvalidationLevel(VALID); //output only properties
addProperty(planeDist_);
planeDist_.setInvalidationLevel(VALID);
addPort(inport_);
addPort(secondaryVolumePort_);
addPort(geomPort_);
addPort(textPort_);
}
/*
constructor
*/
EntryExitPoints::EntryExitPoints()
: VolumeRenderer(),
shaderProgram_(0),
shaderProgramJitter_(0),
shaderProgramClipping_(0),
supportCameraInsideVolume_("supportCameraInsideVolume",
"Support camera in volume", true),
jitterEntryPoints_("jitterEntryPoints", "Jitter entry params", false),
filterJitterTexture_("filterJitterTexture", "Filter jitter texture", true),
jitterStepLength_("jitterStepLength", "Jitter step length",
0.005f, 0.0005f, 0.025f),
jitterTexture_(0),
camera_("camera", "Camera", tgt::Camera(vec3(0.f, 0.f, 3.5f), vec3(0.f, 0.f, 0.f), vec3(0.f, 1.f, 0.f))),
entryPort_(Port::OUTPORT, "image.entrypoints"),
exitPort_(Port::OUTPORT, "image.exitpoints"),
inport_(Port::INPORT, "volumehandle.volumehandle"),
cpPort_(Port::INPORT, "coprocessor.proxygeometry"),
tmpPort_(Port::OUTPORT, "image.tmp", false)
{
addProperty(supportCameraInsideVolume_);
//
// jittering
//
addProperty(jitterEntryPoints_);
jitterEntryPoints_.onChange(CallMemberAction<EntryExitPoints>(this, &EntryExitPoints::onJitterEntryPointsChanged));
onJitterEntryPointsChanged(); // set initial state
jitterStepLength_.setStepping(0.001f);
jitterStepLength_.setNumDecimals(3);
addProperty(jitterStepLength_);
addProperty(filterJitterTexture_);
filterJitterTexture_.onChange(CallMemberAction<EntryExitPoints>(this, &EntryExitPoints::onFilterJitterTextureChanged));
addProperty(camera_);
cameraHandler_ = new CameraInteractionHandler("cameraHandler", "Camera", &camera_);
addInteractionHandler(cameraHandler_);
addPort(entryPort_);
addPort(exitPort_);
addPort(inport_);
addPort(cpPort_);
addPrivateRenderPort(&tmpPort_);
}
DepthPeelingProcessor::DepthPeelingProcessor()
: RenderProcessor()
, inport_(Port::INPORT, "image.input")
, outport_(Port::OUTPORT, "image.output")
, tempPort_(Port::OUTPORT, "image.temp")
, cpPort_(Port::INPORT, "coprocessor.geometryrenderers", true)
, shaderPrg_(0)
, camera_("camera", "Camera", tgt::Camera(vec3(0.f, 0.f, 3.5f), vec3(0.f, 0.f, 0.f), vec3(0.f, 1.f, 0.f)))
{
addProperty(camera_);
cameraHandler_ = new CameraInteractionHandler("cameraHandler", "Camera Handler", &camera_);
addInteractionHandler(cameraHandler_);
addPort(inport_);
addPort(outport_);
addPrivateRenderPort(tempPort_);
addPort(cpPort_);
}
MeshSlabClipping::MeshSlabClipping()
: Processor()
, inport_(Port::INPORT, "geometry.geometry")
, outport_(Port::OUTPORT, "geometry.clippedgeometry")
, normal_("slabNormal", "Slab Normal", tgt::vec3(0, 1, 0), tgt::vec3(-1), tgt::vec3(1))
, position_("slabPosition", "Slab Position", 0.0f, -10.0f, 10.0f)
, thickness_("slabThickness", "Slab Thickness", 0.5f, 0.0f, 3.0f)
, wheelInteractionHandler_("wheelInteractionHandler", "Slab Position", &position_,
tgt::Event::MODIFIER_NONE, false, false)
{
addPort(inport_);
addPort(outport_);
thickness_.onChange(CallMemberAction<MeshSlabClipping>(this, &MeshSlabClipping::thicknessChanged));
addProperty(normal_);
addProperty(position_);
addProperty(thickness_);
addInteractionHandler(wheelInteractionHandler_);
}
HalfAngleSlicer::HalfAngleSlicer()
: VolumeSlicer()
, shaderProp_("slicing.prg", "Slicing shader", "sl_halfslicing.frag", "sl_singlevolume.vert")
, outport_(Port::OUTPORT, "image.output", "Image Output", false, Processor::INVALID_RESULT, RenderPort::RENDERSIZE_RECEIVER, GL_RGBA16F_ARB)
, lightport_(Port::OUTPORT, "image.lightport", "Light Image Input", false, Processor::INVALID_RESULT, RenderPort::RENDERSIZE_DEFAULT, GL_RGBA16F_ARB)
, lightCamera_(tgt::Camera(tgt::vec3(0.f, -3.5f, -3.5f), tgt::vec3(0.f, 0.f, 0.f), tgt::vec3(0.f, 1.f, 0.f)))
, eyeCamera_("eyeCamera", "Eye Camera", tgt::Camera(tgt::vec3(0.f, 0.f, 3.5f), tgt::vec3(0.f, 0.f, 0.f), tgt::vec3(0.f, 1.f, 0.f)))
, cameraHandler_("cameraHandler", "Camera Handler", &eyeCamera_)
, halfLight_("halfLight", "Light source position", tgt::vec4(0.f, -3.5f, -3.5f, 1.f), tgt::vec4(-15), tgt::vec4(15))
, invert_(false)
{
removeProperty(&camera_);
addInteractionHandler(cameraHandler_);
halfLight_.setViews(Property::View(Property::LIGHT_POSITION | Property::DEFAULT));
addProperty(shaderProp_);
addProperty(eyeCamera_);
addProperty(halfLight_);
addPort(outport_);
addPrivateRenderPort(lightport_);
}
MultiplanarSliceRenderer::MultiplanarSliceRenderer()
: SliceRendererBase(),
renderXYSlice_("renderSlice.XY", "Render XY Slice", true),
renderXZSlice_("renderSlice.XZ", "Render XZ Slice", false),
renderYZSlice_("renderSlice.YZ", "Render YZ Slice", false),
sliceNumberXY_("sliceNumber.XY", "XY Slice Number", 0, 0, 10000),
sliceNumberXZ_("sliceNumber.XZ", "XZ Slice Number", 0, 0, 10000),
sliceNumberYZ_("sliceNumber.YZ", "YZ Slice Number", 0, 0, 10000),
camProp_("camera", "Camera", tgt::Camera(tgt::vec3(0.0f, 0.0f, 3.5f), tgt::vec3(0.0f, 0.0f, 0.0f), tgt::vec3(0.0f, 1.0f, 0.0f)), true),
cameraHandler_(0)
{
addProperty(renderXYSlice_);
addProperty(sliceNumberXY_);
addProperty(renderXZSlice_);
addProperty(sliceNumberXZ_);
addProperty(renderYZSlice_);
addProperty(sliceNumberYZ_);
addProperty(camProp_);
cameraHandler_ = new CameraInteractionHandler("cameraHandler", "Camera Handler", &camProp_);
addInteractionHandler(cameraHandler_);
}
void Processor::addInteractionHandler(InteractionHandler& handler) {
addInteractionHandler(&handler);
}
