void RenderProcessor::adjustRenderOutportDimensions() {
// detect largest inport dimension
tgt::ivec2 dim(-1);
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->hasRenderTarget() && (rp->getSize().x >= dim.x && rp->getSize().y >= dim.y))
dim = rp->getSize();
}
if (dim == tgt::ivec2(-1))
return;
// assign largest inport dimension to all render outports without size origin
bool assigned = false;
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->isConnected() && (rp->getSizeOrigin() == 0)) {
rp->resize(dim);
assigned = true;
}
}
// assign size to private ports
if (assigned) {
const std::vector<RenderPort*> privatePorts = getPrivateRenderPorts();
for (size_t i=0; i<privatePorts.size(); ++i) {
privatePorts[i]->resize(dim);
}
}
}
void RenderProcessor::adjustRenderOutportSizes() {
// detect dimension of first connected render inport
tgt::ivec2 inputDim(-1);
const std::vector<Port*> inports = getInports();
for (size_t i=0; i<inports.size() && inputDim == tgt::ivec2(-1); ++i) {
RenderPort* rp = dynamic_cast<RenderPort*>(inports[i]);
if (rp && rp->hasRenderTarget()){
inputDim = rp->getSize();
break;
}
}
// - assign inport dimension to all connected render outports, which are not size receivers
// - if a outport is a size receiver, assign its received rendering size to it
tgt::ivec2 resizeDim = tgt::ivec2(-1);
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->hasRenderTarget())
continue;
if (rp->getRenderSizePropagation() == RenderPort::RENDERSIZE_DEFAULT) {
if (inputDim != rp->getSize() && inputDim != tgt::ivec2(-1)) {
rp->resize(inputDim);
if (resizeDim == tgt::ivec2(-1))
resizeDim = inputDim;
}
}
else if (rp->getRenderSizePropagation() == RenderPort::RENDERSIZE_RECEIVER) {
RenderSizeReceiveProperty* receiveProp = rp->getSizeReceiveProperty();
tgtAssert(receiveProp, "Render outport is size receiver, but has no SizeReceiveProperty");
if (receiveProp->get() != rp->getSize()) {
rp->resize(receiveProp->get());
if (resizeDim == tgt::ivec2(-1))
resizeDim = receiveProp->get();
}
}
else if (rp->getRenderSizePropagation() == RenderPort::RENDERSIZE_STATIC) {
// nothing to do
}
else {
LERROR("Render outport has invalid render size propgation mode: " << rp->getQualifiedName());
}
}
// resize private render ports to resizeDim
if (resizeDim != tgt::ivec2(-1)) {
for (size_t i=0; i<privateRenderPorts_.size(); i++)
privateRenderPorts_.at(i)->resize(resizeDim);
}
}
// Parameters currently set:
// - screenDim_
// - screenDimRCP_
// - cameraPosition_ (camera position in world coordinates)
void RenderProcessor::setGlobalShaderParameters(tgt::Shader* shader, const tgt::Camera* camera, tgt::ivec2 screenDim) {
shader->setIgnoreUniformLocationError(true);
if (screenDim == tgt::ivec2(-1)) {
RenderPort* rp = 0;
for (size_t i=0; i<getOutports().size(); ++i) {
rp = dynamic_cast<RenderPort*>(getOutports()[i]);
if (rp && rp->hasRenderTarget())
break;
}
if (rp) {
screenDim = rp->getSize();
}
}
shader->setUniform("screenDim_", tgt::vec2(screenDim));
shader->setUniform("screenDimRCP_", 1.f / tgt::vec2(screenDim));
// camera position in world coordinates, and corresponding transformation matrices
if (camera) {
shader->setUniform("cameraPosition_", camera->getPosition());
shader->setUniform("viewMatrix_", camera->getViewMatrix());
shader->setUniform("projectionMatrix_", camera->getProjectionMatrix());
tgt::mat4 viewInvert;
if(camera->getViewMatrix().invert(viewInvert))
shader->setUniform("viewMatrixInverse_", viewInvert);
tgt::mat4 projInvert;
if(camera->getProjectionMatrix().invert(projInvert))
shader->setUniform("projectionMatrixInverse_", projInvert);
}
shader->setIgnoreUniformLocationError(false);
LGL_ERROR;
}
void VolumeRaycaster::rescaleRendering(RenderPort& srcPort, RenderPort& destPort) {
// activate and clear output render target
destPort.activateTarget();
destPort.clearTarget();
// activate shader and set uniforms
tgtAssert(rescaleShader_, "bypass shader not loaded");
rescaleShader_->activate();
setGlobalShaderParameters(rescaleShader_, 0, destPort.getSize());
// bind input rendering to texture units
tgt::TextureUnit colorUnit, depthUnit;
srcPort.bindTextures(colorUnit.getEnum(), depthUnit.getEnum(), GL_LINEAR);
srcPort.setTextureParameters(rescaleShader_, "texParams_");
rescaleShader_->setUniform("colorTex_", colorUnit.getUnitNumber());
rescaleShader_->setUniform("depthTex_", depthUnit.getUnitNumber());
// render screen aligned quad
renderQuad();
// cleanup
rescaleShader_->deactivate();
destPort.deactivateTarget();
TextureUnit::setZeroUnit();
// check for OpenGL errors
LGL_ERROR;
}
