LightPropertyWidget::LightPropertyWidget(FloatVec4Property* prop, QWidget* parent)
: QPropertyWidget(prop, parent)
, property_(prop)
, noUpdateFromProp_(false)
{
light_ = new LightWidget(this);
followCam_ = new QCheckBox(tr("Follow Camera"), this);
if (BoolMetaData* follow = dynamic_cast<BoolMetaData*>(property_->getMetaDataContainer().getMetaData("FollowCamera")))
followCam_->setChecked(follow->getValue());
else
followCam_->setChecked(false);
layout_->setDirection(QBoxLayout::TopToBottom);
layout_->addWidget(light_);
layout_->addWidget(followCam_);
connect(light_, SIGNAL(lightWidgetChanged(tgt::vec4)), this, SLOT(changeWidgetLight(tgt::vec4)));
CameraProperty* camProp = getCamera();
if(camProp) {
camProp->onChange(CallMemberAction<LightPropertyWidget>(this, &LightPropertyWidget::cameraUpdate));
light_->setLightPosition(camProp->get().getViewMatrix().getRotationalPart() * property_->get());
cameraUpdate();
}
addVisibilityControls();
// we have to add this widget to the property to enable automatic metadata serialization
property_->addWidget(this);
}
void AbstractCameraManager::on_propertySlider_changed(int val) {
if( selectedItem == NULL ) return;
CameraProperty* prop = reinterpret_cast<CameraProperty*>( sender()->property("CameraProperty").value<quintptr>() );
prop->setValueFromSlider(val);
cameraTree_recursiveSetProperty(selectedItem, prop);
reinterpret_cast<QTreeWidgetItem*>( sender()->property("TreeWidgetItem").value<quintptr>() )->setText(Ui::PropertyValue, prop->formatValue() );
}
void LinkEvaluatorCameraFrustumId::eval(Property* src, Property* dst) throw (VoreenException) {
CameraProperty* srcProp = dynamic_cast<CameraProperty*>(src);
CameraProperty* dstProp = dynamic_cast<CameraProperty*>(dst);
tgt::Camera cam = dstProp->get();
cam.setFrustum(srcProp->get().getFrustum());
dstProp->set(cam);
}
void LinkEvaluatorCameraOrientationId::eval(Property* src, Property* dst) throw (VoreenException) {
CameraProperty* dstCast = static_cast<CameraProperty*>(dst);
CameraProperty* srcCast = static_cast<CameraProperty*>(src);
tgt::Camera cam = dstCast->get();
tgt::Camera srcCam = srcCast->get();
cam.positionCamera(cam.getFocus() - cam.getFocalLength() * srcCam.getLook(), cam.getFocus(), srcCam.getUpVector());
dstCast->set(cam);
}
void RenderProcessor::portResized(RenderPort* /*p*/, tgt::ivec2 newsize) {
// cycle prevention
if (portResizeVisited_)
return;
portResizeVisited_ = true;
// propagate to predecessing RenderProcessors
const std::vector<Port*> inports = getInports();
for(size_t i=0; i<inports.size(); ++i) {
RenderPort* rp = dynamic_cast<RenderPort*>(inports[i]);
if (rp)
rp->resize(newsize);
}
//distribute to outports:
const std::vector<Port*> outports = getOutports();
for(size_t i=0; i<outports.size(); ++i) {
RenderPort* rp = dynamic_cast<RenderPort*>(outports[i]);
if (rp)
rp->resize(newsize);
}
//distribute to private ports:
const std::vector<RenderPort*> pports = getPrivateRenderPorts();
for (size_t i=0; i<pports.size(); ++i) {
RenderPort* rp = pports[i];
rp->resize(newsize);
}
// notify camera properties about viewport change
if(newsize != tgt::ivec2(0,0)) {
const std::vector<Property*> properties = getProperties();
for (size_t i=0; i<properties.size(); ++i) {
CameraProperty* cameraProp = dynamic_cast<CameraProperty*>(properties[i]);
if (cameraProp) {
cameraProp->viewportChanged(newsize);
}
}
}
invalidate();
portResizeVisited_ = false;
}
//-----------------------------------------------------------------------------
//
void LinkEvaluatorCameraPosId::eval(Property* src, Property* dst) throw (VoreenException) {
bool camToProp = true;
CameraProperty* camProp = dynamic_cast<CameraProperty*>(src);
FloatVec3Property* vecProp = dynamic_cast<FloatVec3Property*>(dst);
if(!camProp) {
camToProp = false;
camProp = dynamic_cast<CameraProperty*>(dst);
vecProp = dynamic_cast<FloatVec3Property*>(src);
}
tgt::Camera cam = camProp->get();
if(camToProp)
vecProp->set(cam.getPosition());
else {
cam.setPosition(vecProp->get());
camProp->set(cam);
}
}
void CameraWidget::applyOrientationAndDistanceAnimated(std::vector<float> keyframe) {
tgtAssert(track_, "No trackball");
CameraProperty* camera = track_->getCamera();
tgt::quat newQuat;
newQuat.x = keyframe[0];
newQuat.y = keyframe[1];
newQuat.z = keyframe[2];
newQuat.w = keyframe[3];
float newDist = keyframe[4];
float t = 0.1f;
tgt::quat oldQuat = camera->get().getQuat();
float oldDist = camera->get().getFocalLength();
resetCameraPosition();
tgt::quat initQuat = camera->get().getQuat();
initQuat.invert();
cameraProp_->toggleInteractionMode(true, comboOrientation_);
// todo: use timer
for (int i = 0; i <= 9; ++i) {
tgt::quat tmp = tgt::slerpQuat(oldQuat, newQuat, std::min(t, 1.f));
float tmpDist = t*(newDist - oldDist) + oldDist;
resetCameraPosition();
track_->zoomAbsolute(tmpDist);
track_->rotate(initQuat);
track_->rotate(tmp);
cameraProp_->invalidate();
cameraProp_->notifyChange();
qApp->processEvents();
t += 0.1f;
}
cameraProp_->toggleInteractionMode(false, comboOrientation_);
resetCameraPosition();
track_->zoomAbsolute(newDist);
track_->rotate(initQuat);
track_->rotate(newQuat);
cameraProp_->notifyChange();
}
void AbstractCameraManager::on_propertyCheckbox_changed(int state) {
if( selectedItem == NULL ) return;
CameraProperty* prop = reinterpret_cast<CameraProperty*>( sender()->property("CameraProperty").value<quintptr>() );
qDebug() << sender() << prop->getName().c_str();
prop->setAuto(state == Qt::Checked);
cameraTree_recursiveSetProperty(selectedItem, prop);
//(de)activate slider
if( prop->getType() == CameraManager::AUTOTRIGGER ) return;
QSlider* slider = reinterpret_cast<QSlider*>( sender()->property("TreeWidgetSlider").value<quintptr>() );
qDebug() << "Qslider" << slider;
if(state != Qt::Checked) {
slider->setEnabled(true);
slider->setValue(prop->getValueToSlider());
} else {
slider->setEnabled(false);
}
}
void LinkEvaluatorCameraLookId::eval(Property* src, Property* dst) throw (VoreenException) {
bool camToProp = true;
CameraProperty* camProp = dynamic_cast<CameraProperty*>(src);
FloatVec3Property* vecProp = dynamic_cast<FloatVec3Property*>(dst);
if(!camProp) {
camToProp = false;
camProp = dynamic_cast<CameraProperty*>(dst);
vecProp = dynamic_cast<FloatVec3Property*>(src);
}
tgt::Camera cam = camProp->get();
if(camToProp)
vecProp->set(cam.getLook());
else {
if(length(vecProp->get()) == 0.f) {
LERRORC("voreen.LinkEvaluatorCameraLookId", "Can not use 0 vector to set look vector of camera");
return;
}
cam.setFocus(cam.getPosition() + cam.getFocalLength() * normalize(vecProp->get()));
camProp->set(cam);
}
}
void LinkEvaluatorCameraId::eval(Property* src, Property* dst) throw (VoreenException) {
CameraProperty* dstCast = static_cast<CameraProperty*>(dst);
CameraProperty* srcCast = static_cast<CameraProperty*>(src);
tgt::Camera cam = dstCast->get();
tgt::Camera srcCam = srcCast->get();
cam.setPosition(srcCam.getPosition());
cam.setFocus(srcCam.getFocus());
cam.setUpVector(srcCam.getUpVector());
cam.setFrustum(srcCam.getFrustum());
cam.setProjectionMode(srcCam.getProjectionMode());
cam.setStereoEyeMode(srcCam.getStereoEyeMode(), false);
cam.setStereoEyeSeparation(srcCam.getStereoEyeSeparation(), false);
cam.setStereoAxisMode(srcCam.getStereoAxisMode());
dstCast->set(cam);
dstCast->getTrackball()->setMoveCenter(srcCast->getTrackball()->getMoveCenter());
dstCast->getTrackball()->setCenter(srcCast->getTrackball()->getCenter());
dstCast->setMaxValue(srcCast->getMaxValue());
}
void LinkEvaluatorCameraId::eval(Property* src, Property* dst) throw (VoreenException) {
CameraProperty* dstCast = static_cast<CameraProperty*>(dst);
CameraProperty* srcCast = static_cast<CameraProperty*>(src);
tgt::Camera cam = dstCast->get();
tgt::Camera srcCam = srcCast->get();
cam.setPosition(srcCam.getPosition());
cam.setFocus(srcCam.getFocus());
cam.setUpVector(srcCam.getUpVector());
cam.setFrustum(srcCam.getFrustum());
cam.setProjectionMode(srcCam.getProjectionMode());
cam.setStereoEyeMode(srcCam.getStereoEyeMode(), false);
cam.setStereoEyeSeparation(srcCam.getStereoEyeSeparation(), false);
cam.setStereoAxisMode(srcCam.getStereoAxisMode(), false);
cam.enableOffset(srcCam.isOffsetEnabled());
cam.setOffset(srcCam.getOffset());
dstCast->setMinValue(srcCast->getMinValue());
dstCast->setMaxValue(srcCast->getMaxValue());
dstCast->setAdaptOnChange(srcCast->getAdaptOnChange());
dstCast->setTrackballCenterBehaviour(srcCast->getTrackballCenterBehaviour());
dstCast->getTrackball().setCenter(srcCast->getTrackball().getCenter());
dstCast->setSceneBounds(srcCast->getSceneBounds());
// order is important: only now set cam and cause further link execution
dstCast->set(cam);
}
void setShaderUniforms(Shader& shader, const CameraProperty& property, std::string name) {
shader.setUniform(name + ".worldToView", property.viewMatrix());
shader.setUniform(name + ".viewToWorld", property.inverseViewMatrix());
shader.setUniform(name + ".worldToClip", property.projectionMatrix() * property.viewMatrix());
shader.setUniform(name + ".viewToClip", property.projectionMatrix());
shader.setUniform(name + ".clipToView", property.inverseProjectionMatrix());
shader.setUniform(name + ".clipToWorld",
property.inverseViewMatrix() * property.inverseProjectionMatrix());
shader.setUniform(name + ".position", property.getLookFrom());
shader.setUniform(name + ".nearPlane", property.getNearPlaneDist());
shader.setUniform(name + ".farPlane", property.getFarPlaneDist());
}
