void eDeferredRenderer::_visualizeGeometryBuffer(const eRect &area) const
{
eStateManager::push();
eStateManager::bindVertexShader(m_vsQuad);
eStateManager::bindPixelShader(m_psQuad);
eStateManager::setCullingMode(eCULLING_NONE);
eStateManager::setTextureAddressMode(0, eTEXADDRMODE_CLAMP);
eStateManager::setCap(eCAP_ZBUFFER, eFALSE);
eStateManager::setCap(eCAP_BLENDING, eFALSE);
const eInt w = area.getWidth();
const eInt h = area.getHeight();
// Image at top left.
eStateManager::bindTexture(0, m_specularRt);
// renderQuad(eRect(0, h/2, w/2, h-1), area.getDimension());
// Image at top right.
eStateManager::bindTexture(0, m_diffuseRt);
renderQuad(eRect(w/2, h/2, w-1, h-1), area.getDimension());
// Image at bottom left.
eStateManager::bindTexture(0, m_normalsRt);
renderQuad(eRect(0, 0, w/2, h/2), area.getDimension());
// Image at bottom right.
eStateManager::bindTexture(0, m_positionRt);
renderQuad(eRect(w/2, 0, w-1, h/2), area.getDimension());
eStateManager::pop();
}
void DepthDarkening::process() {
privatePort_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (!interactionMode())
analyzeDepthBuffer(&inport_);
// since the blurring is implemented as a separable filter,
// two rendering passes are needed
// first horizontal pass
TextureUnit colorUnit, depthUnit0, depthUnit1;
inport_.bindTextures(colorUnit.getEnum(), depthUnit0.getEnum());
inport_.bindDepthTexture(depthUnit1.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
program_->setUniform("colorTex_", colorUnit.getUnitNumber());
program_->setUniform("depthTex0_", depthUnit0.getUnitNumber());
program_->setUniform("depthTex1_", depthUnit1.getUnitNumber());
inport_.setTextureParameters(program_, "texParams_");
program_->setUniform("sigma_", sigma_.get());
program_->setUniform("lambda_", lambda_.get());
program_->setUniform("minDepth_", minDepth_.get());
program_->setUniform("maxDepth_", maxDepth_.get());
program_->setUniform("dir_", tgt::vec2(1.0,0.0));
renderQuad();
program_->deactivate();
LGL_ERROR;
// second vertical pass
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
inport_.bindColorTexture(colorUnit.getEnum());
privatePort_.bindDepthTexture(depthUnit0.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
program_->setUniform("colorTex_", colorUnit.getUnitNumber());
program_->setUniform("depthTex0_", depthUnit0.getUnitNumber());
program_->setUniform("depthTex1_", depthUnit1.getUnitNumber());
inport_.setTextureParameters(program_, "texParams_");
program_->setUniform("sigma_", sigma_.get());
program_->setUniform("lambda_", lambda_.get());
program_->setUniform("minDepth_", minDepth_.get());
program_->setUniform("maxDepth_", maxDepth_.get());
program_->setUniform("dir_", tgt::vec2(0.0,1.0));
renderQuad();
program_->deactivate();
outport_.deactivateTarget();
LGL_ERROR;
}
void MultiScale::process() {
inport_.bindTextures(GL_TEXTURE0, GL_TEXTURE1);
LGL_ERROR;
// initialize shader
program_->activate();
program_->setUniform("colorTex_", 0);
program_->setUniform("depthTex_", 1);
program_->setIgnoreUniformLocationError(true);
program_->setUniform("colorTexParameters_.dimensions_", tgt::vec2(inport_.getSize()));
program_->setUniform("colorTexParameters_.dimensionsRCP_", tgt::vec2(1.0f) / tgt::vec2(inport_.getSize()));
program_->setUniform("colorTexParameters_.matrix_", tgt::mat4::identity);
program_->setUniform("depthTexParameters_.dimensions_", tgt::vec2(inport_.getSize()));
program_->setUniform("depthTexParameters_.dimensionsRCP_", tgt::vec2(1.0f) / tgt::vec2(inport_.getSize()));
program_->setUniform("depthTexParameters_.matrix_", tgt::mat4::identity);
program_->setIgnoreUniformLocationError(false);
MatStack.matrixMode(tgt::MatrixStack::MODELVIEW);
glDepthFunc(GL_ALWAYS);
if (outport1_.isReady()) {
outport1_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
applyScalingMatrix(scalingMode1_.getValue(), &inport_, &outport1_);
renderQuad();
outport1_.deactivateTarget();
}
if (outport2_.isReady()) {
outport2_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
applyScalingMatrix(scalingMode2_.getValue(), &inport_, &outport2_);
renderQuad();
outport2_.deactivateTarget();
}
if (outport3_.isReady()) {
outport3_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
applyScalingMatrix(scalingMode3_.getValue(), &inport_, &outport3_);
renderQuad();
outport3_.deactivateTarget();
}
if (outport4_.isReady()) {
outport4_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
applyScalingMatrix(scalingMode4_.getValue(), &inport_, &outport4_);
renderQuad();
outport4_.deactivateTarget();
}
glDepthFunc(GL_LESS);
MatStack.loadIdentity();
program_->deactivate();
glActiveTexture(GL_TEXTURE0);
LGL_ERROR;
}
void drawTrails(QuadBuffer *q, int *index) {
int i;
if(index == NULL) {
for(i = 0; i < q->current; i++)
renderQuad(q->quads + i);
} else {
for(i = 0; i < q->current; i++) {
/* printf("drawing quad %d\n", index[i]); */
renderQuad(q->quads + index[i] );
}
}
glDisable(GL_TEXTURE_2D);
}
void PointLightSource::render(const UsefulRenderData& render_data)
{
// If we are inside the sphere affected by the light source, render a full
// quad. Otherwize just render the light sphere
glm::vec4 position_world_space = glm::vec4(absoluteTransform()[3]);
glm::vec3 position_view_space =
glm::vec3(render_data.camera.viewTransform() * position_world_space);
float distance_to_light_source = glm::length(position_view_space);
// Probably not the best way of handling rescaled light sources,
// but works for now..
glm::vec3 scale;
glm::quat rotation;
glm::vec3 translation;
glm::vec3 skew;
glm::vec4 perspective;
glm::decompose(
absoluteTransform(), scale, rotation, translation, skew,perspective);
float transform_scale = scale.x;
if (distance_to_light_source < _sphere_scale * transform_scale)
renderQuad(render_data);
else
renderSphere(render_data);
}
void Gabor::process() {
outport_.resize(tgt::ivec2(resolution_.get(), resolution_.get()));
// activate and clear output render target
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// activate shader and set uniforms:
program_->activate();
setGlobalShaderParameters(program_);
program_->setUniform("orientation_", (angle_.get()/360.0f)*2.0f*tgt::PIf);
program_->setUniform("wavelength_", wavelength_.get());
program_->setUniform("offset_", offset_.get());
program_->setUniform("sigma_", sigma_.get());
program_->setUniform("aRatio_", aspectRatio_.get());
//program_->setUniform("aspectRatio_", aspectRatio_.get());
// render screen aligned quad:
glDepthFunc(GL_ALWAYS);
renderQuad();
glDepthFunc(GL_LESS);
program_->deactivate();
outport_.deactivateTarget();
LGL_ERROR;
}
/*
* Pass the image from inport to outport without changes
*/
void ImageProcessorBypassable::bypass(RenderPort* inport, RenderPort* outport) {
tgtAssert(inport && outport, "null pointer passed");
// activate and clear output render target
outport->activateTarget();
outport->clearTarget();
// bind input rendering to texture units
TextureUnit colorUnit, depthUnit;
inport->bindTextures(colorUnit.getEnum(), depthUnit.getEnum());
// activate shader and set uniforms
tgtAssert(bypassProgram_, "bypass shader not loaded");
bypassProgram_->activate();
setGlobalShaderParameters(bypassProgram_);
inport->setTextureParameters(bypassProgram_, "texParams_");
bypassProgram_->setUniform("colorTex_", colorUnit.getUnitNumber());
bypassProgram_->setUniform("depthTex_", depthUnit.getUnitNumber());
// render screen aligned quad
renderQuad();
// cleanup
bypassProgram_->deactivate();
outport->deactivateTarget();
TextureUnit::setZeroUnit();
// check for OpenGL errors
LGL_ERROR;
}
void RenderLoopFinalizer::process() {
if (loopOutport_.getLoopIteration() == loopOutport_.getNumLoopIterations()-1) {
// last iteration: write input image to outport
outport_.activateTarget();
}
else {
// loop iteration: write input image to loop port
loopOutport_.activateTarget();
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
TextureUnit colorUnit, depthUnit;
inport_.bindTextures(colorUnit.getEnum(), depthUnit.getEnum());
LGL_ERROR;
// initialize shader
shaderPrg_->activate();
// set common uniforms used by all shaders
setGlobalShaderParameters(shaderPrg_);
// pass the remaining uniforms to the shader
shaderPrg_->setUniform("colorTex_", colorUnit.getUnitNumber());
shaderPrg_->setUniform("depthTex_", depthUnit.getUnitNumber());
inport_.setTextureParameters(shaderPrg_, "texParams_");
renderQuad();
shaderPrg_->deactivate();
outport_.deactivateTarget();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void TouchEventSimulator::process() {
// activate and clear output render target
outport_.activateTarget();
outport_.clearTarget();
// bind input rendering to texture units
tgt::TextureUnit colorUnit, depthUnit;
inport_.bindTextures(colorUnit.getEnum(), depthUnit.getEnum());
// activate shader and set uniforms
tgtAssert(program_, "bypass shader not loaded");
program_->activate();
setGlobalShaderParameters(program_);
inport_.setTextureParameters(program_, "texParams_");
program_->setUniform("colorTex_", colorUnit.getUnitNumber());
program_->setUniform("depthTex_", depthUnit.getUnitNumber());
// render screen aligned quad
renderQuad();
// cleanup
program_->deactivate();
outport_.deactivateTarget();
tgt::TextureUnit::setZeroUnit();
// check for OpenGL errors
LGL_ERROR;
}
void RenderLoopInitiator::process() {
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// activate shader
shader_->activate();
TextureUnit colorUnit, depthUnit;
if (loopInport_.getLoopIteration() == 0) {
// first iteration => copy initial input image to outport
inport_.bindTextures(colorUnit.getEnum(), depthUnit.getEnum());
}
else {
// loop iteration => copy loop input image to outport
loopInport_.bindTextures(colorUnit.getEnum(), depthUnit.getEnum());
}
LGL_ERROR;
// set common uniforms
setGlobalShaderParameters(shader_);
// pass texture parameters to the shader
shader_->setUniform("colorTex_", colorUnit.getUnitNumber());
shader_->setUniform("depthTex_", depthUnit.getUnitNumber());
inport_.setTextureParameters(shader_, "texParams_");
// execute shader
renderQuad();
// clean up
shader_->deactivate();
outport_.deactivateTarget();
LGL_ERROR;
}
void Fade::process() {
if (!enableSwitch_.get()){
bypass(&inport_, &outport_);
return;
}
outport_.activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
TextureUnit colorUnit, depthUnit;
inport_.bindTextures(colorUnit.getEnum(), depthUnit.getEnum());
// intialize shader
program_->activate();
setGlobalShaderParameters(program_);
program_->setUniform("colorTex_", colorUnit.getUnitNumber());
program_->setUniform("depthTex_", depthUnit.getUnitNumber());
inport_.setTextureParameters(program_, "texParams_");
program_->setUniform("fading_", 1-fading_.get());
program_->setUniform("fadeColor_",color_.get());
renderQuad();
program_->deactivate();
outport_.deactivateTarget();
LGL_ERROR;
}
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 eDeferredRenderer::_renderAmbientPass(eTexture2d *target, eTexture2d *depthTarget, const eScene &scene, const eRect &area)
{
// calculate the ambient color
eColor ambient;
for (eU32 i=0; i<scene.getLightCount(); i++)
ambient += scene.getLight(i).getAmbient();
// render the ambient light
static eConstBuffer<eVector4, eST_PS> cb;
cb.data = ambient;
eRenderState &rs = eGfx->freshRenderState();
rs.targets[0] = target;
rs.depthTarget = depthTarget;
rs.ps = m_psDefAmbient;
rs.constBufs[eCBI_PASS_AMBIENT] = &cb;
rs.textures[0] = m_rtDiffuse;
rs.textures[3] = m_rtPosition;
rs.textures[4] = m_rtEnvironment;
rs.texFlags[0] = eTMF_CLAMP|eTMF_NEAREST;
rs.texFlags[3] = eTMF_CLAMP|eTMF_NEAREST;
rs.texFlags[4] = eTMF_CLAMP|eTMF_NEAREST;
eGfx->clear(eCM_COLOR, eCOL_YELLOW);
renderQuad(area, area.getSize(), nullptr);
}
void ImageThreshold::process() {
if (!enableSwitch_.get()){
bypass(&inport_, &outport_);
return;
}
outport_.activateTarget();
outport_.clearTarget();
TextureUnit colorUnit, depthUnit;
inport_.bindTextures(colorUnit, depthUnit);
// initialize shader
program_->activate();
setGlobalShaderParameters(program_);
program_->setUniform("colorTex_", colorUnit.getUnitNumber());
program_->setUniform("depthTex_", depthUnit.getUnitNumber());
inport_.setTextureParameters(program_, "texParams_");
program_->setUniform("lowerThreshold_", lowerThreshold_.get());
program_->setUniform("upperThreshold_", upperThreshold_.get());
program_->setUniform("lowerMaskColor_", lowerMaskColor_.get());
program_->setUniform("upperMaskColor_", upperMaskColor_.get());
renderQuad();
program_->deactivate();
outport_.deactivateTarget();
TextureUnit::setZeroUnit();
LGL_ERROR;
}
void eDeferredRenderer::_renderLightPass(eScene &scene, const eCamera &cam, const eRect &area)
{
eStateManager::push();
eStateManager::bindTexture(0, m_diffuseRt);
eStateManager::bindTexture(1, m_normalsRt);
eStateManager::bindTexture(2, m_specularRt);
eStateManager::bindTexture(3, m_positionRt);
eStateManager::bindTexture(4, m_deferredShadowMap);
eStateManager::setTextureFilter(0, eTEXFILTER_NEAREST);
eStateManager::setTextureFilter(1, eTEXFILTER_NEAREST);
eStateManager::setTextureFilter(2, eTEXFILTER_NEAREST);
eStateManager::setTextureFilter(3, eTEXFILTER_NEAREST);
eStateManager::setTextureFilter(4, eTEXFILTER_BILINEAR);
eStateManager::setTextureAddressMode(4, eTEXADDRMODE_CLAMP);
eStateManager::setCap(eCAP_BLENDING, eTRUE);
eStateManager::setBlendModes(eBLEND_ONE, eBLEND_ONE, eBLENDOP_ADD);
eStateManager::bindPixelShader(m_psDefLight);
eStateManager::bindVertexShader(m_vsQuad);
for (eU32 i=0; i<scene.getLightCount(); i++)
{
const eLight &light = scene.getLight(i);
if (light.activateScissor(area.getDimension(), cam))
{
_renderLightDistance(scene, light);
_renderShadowMap(cam, light);
light.activate(m_gfx, cam.getViewMatrix());
renderQuad(area, area.getDimension());
}
}
eStateManager::pop();
}
void StereoMeshEntryExitPoints::jitterEntryPoints() {
shaderProgramJitter_->activate();
tgt::Camera cam = camera_.get();
setGlobalShaderParameters(shaderProgramJitter_, &cam);
// bind texture
TextureUnit entryUnit, entryDepthUnit, exitUnit;
// bind entry points texture and depth texture (have been rendered to temporary port)
tmpPort_.bindColorTexture(entryUnit.getEnum());
shaderProgramJitter_->setUniform("entryPoints_", entryUnit.getUnitNumber());
tmpPort_.bindDepthTexture(entryDepthUnit.getEnum());
shaderProgramJitter_->setUniform("entryPointsDepth_", entryDepthUnit.getUnitNumber());
tmpPort_.setTextureParameters(shaderProgramJitter_, "entryParameters_");
// bind exit points texture
exitPort_.bindColorTexture(exitUnit.getEnum());
shaderProgramJitter_->setUniform("exitPoints_", exitUnit.getUnitNumber());
exitPort_.setTextureParameters(shaderProgramJitter_, "exitParameters_");
shaderProgramJitter_->setUniform("stepLength_", jitterStepLength_.get());
entryPort_.activateTarget("jitteredEntryParams");
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// render screen aligned quad
renderQuad();
shaderProgramJitter_->deactivate();
}
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 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;
}
void RenderColorCube::fillEntryPoints(tgt::RenderTarget *firstBackTarget,
tgt::RenderTarget *firstFrontTarget,
tgt::RenderTarget *output,
const tgt::Geometry *geometry,
tgt::Camera *camera)
{
MatStack.matrixMode(tgt::MatrixStack::PROJECTION);
MatStack.pushMatrix();
MatStack.loadIdentity();
MatStack.matrixMode(tgt::MatrixStack::MODELVIEW);
MatStack.pushMatrix();
MatStack.loadIdentity();
shaderInsideVolume_->activate();
setGlobalShaderParameters(shaderInsideVolume_, camera, output->getSize());
// bind texture
tgt::TextureUnit firstFrontUnit, firstFrontDepthUnit, firstBackUnit, firstBackDepthUnit;
// bind firstFront points texture and depth texture
firstFrontTarget->bindColorTexture(firstFrontUnit.getEnum());
shaderInsideVolume_->setUniform("firstFront_", firstFrontUnit.getUnitNumber());
firstFrontTarget->bindDepthTexture(firstFrontDepthUnit.getEnum());
shaderInsideVolume_->setUniform("firstFrontDepth_", firstFrontDepthUnit.getUnitNumber());
firstFrontTarget->setTextureParameters(shaderInsideVolume_, "firstFrontParameters_");
// bind firstBack points texture
firstBackTarget->bindColorTexture(firstBackUnit.getEnum());
shaderInsideVolume_->setUniform("firstBack_", firstBackUnit.getUnitNumber());
firstBackTarget->bindDepthTexture(firstBackDepthUnit.getEnum());
//shaderInsideVolume_->setUniform("firstBackDepth_", firstBackDepthUnit.getUnitNumber());
firstBackTarget->setTextureParameters(shaderInsideVolume_, "firstBackParameters_");
shaderInsideVolume_->setUniform("near_", camera->getNearDist());
shaderInsideVolume_->setUniform("far_", camera->getFarDist());
tgt::BoundingBox bounds = geometry->getBoundingBox(false);
shaderInsideVolume_->setUniform("llf_", bounds.getLLF());
shaderInsideVolume_->setUniform("urb_", bounds.getURB());
glm::mat4 worldToTextureMatrix = glm::inverse(geometry->getTransformationMatrix());
shaderInsideVolume_->setUniform("worldToTexture_", worldToTextureMatrix);
output->activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// render screen aligned quad
renderQuad();
shaderInsideVolume_->deactivate();
output->deactivateTarget();
MatStack.matrixMode(tgt::MatrixStack::PROJECTION);
MatStack.popMatrix();
MatStack.matrixMode(tgt::MatrixStack::MODELVIEW);
MatStack.popMatrix();
LGL_ERROR;
}
void Rectangle3DOverlay::render(RenderArgs* args) {
if (!_visible) {
return; // do nothing if we're not visible
}
float alpha = getAlpha();
xColor color = getColor();
const float MAX_COLOR = 255.0f;
glm::vec4 rectangleColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
glm::vec3 position = getPosition();
glm::vec2 dimensions = getDimensions();
glm::vec2 halfDimensions = dimensions * 0.5f;
glm::quat rotation = getRotation();
auto batch = args->_batch;
if (batch) {
Transform transform;
transform.setTranslation(position);
transform.setRotation(rotation);
batch->setModelTransform(transform);
auto geometryCache = DependencyManager::get<GeometryCache>();
if (getIsSolid()) {
glm::vec3 topLeft(-halfDimensions.x, -halfDimensions.y, 0.0f);
glm::vec3 bottomRight(halfDimensions.x, halfDimensions.y, 0.0f);
geometryCache->bindSimpleProgram(*batch);
geometryCache->renderQuad(*batch, topLeft, bottomRight, rectangleColor);
} else {
geometryCache->bindSimpleProgram(*batch, false, false, false, true, true);
if (getIsDashedLine()) {
glm::vec3 point1(-halfDimensions.x, -halfDimensions.y, 0.0f);
glm::vec3 point2(halfDimensions.x, -halfDimensions.y, 0.0f);
glm::vec3 point3(halfDimensions.x, halfDimensions.y, 0.0f);
glm::vec3 point4(-halfDimensions.x, halfDimensions.y, 0.0f);
geometryCache->renderDashedLine(*batch, point1, point2, rectangleColor);
geometryCache->renderDashedLine(*batch, point2, point3, rectangleColor);
geometryCache->renderDashedLine(*batch, point3, point4, rectangleColor);
geometryCache->renderDashedLine(*batch, point4, point1, rectangleColor);
} else {
if (halfDimensions != _previousHalfDimensions) {
QVector<glm::vec3> border;
border << glm::vec3(-halfDimensions.x, -halfDimensions.y, 0.0f);
border << glm::vec3(halfDimensions.x, -halfDimensions.y, 0.0f);
border << glm::vec3(halfDimensions.x, halfDimensions.y, 0.0f);
border << glm::vec3(-halfDimensions.x, halfDimensions.y, 0.0f);
border << glm::vec3(-halfDimensions.x, -halfDimensions.y, 0.0f);
geometryCache->updateVertices(_geometryCacheID, border, rectangleColor);
_previousHalfDimensions = halfDimensions;
}
geometryCache->renderVertices(*batch, gpu::LINE_STRIP, _geometryCacheID);
}
}
}
}
void CTargetingComputer::render()
{
// Display surround
renderQuad();
char strFont[256];
if (m_pTarget) {
// Calculate position of targeting reticle
CVector3 pos = m_pTarget->m_ppMasses[0]->m_vecPos;
// Get viewport
int viewport[4];
double modelview[16];
double projection[16];
glGetIntegerv(GL_VIEWPORT,viewport);
glGetDoublev(GL_MODELVIEW_MATRIX,modelview);
glGetDoublev(GL_PROJECTION_MATRIX,projection);
// Project to 2d screen coords
double dX, dY, dZ;
gluProject(pos.X(),pos.Y(),pos.Z(),
modelview, projection,
viewport, &dX, &dY, &dZ);
// If behind, invert and scale everything up lots to force it to the edge
// This could perhaps work better... not too happy, but it's late
if (dZ > 1.0f) {
dX = -(dX - (viewport[2]/2)) * viewport[2] + viewport[2]/2;
dY = -(dY - (viewport[3]/2)) * viewport[3] + viewport[3]/2;
}
// Clip
if (dX < 0) dX = 0;
else if (dX > viewport[2]) dX = viewport[2];
if (dY < 0) dY = 0;
else if (dY > viewport[3]) dY = viewport[3];
// Rescale to 0..1
dX /= viewport[2];
dY /= viewport[3];
double dW = 32.0f / viewport[2];
double dH = 32.0f / viewport[3];
// Render reticle
m_poTargetingReticle->setPosition(dX-dW, (1-dY)-dH, dW*2, dH*2);
m_poTargetingReticle->setTexturePercentage(100.0f);
m_poTargetingReticle->renderQuad();
// Radar imagexs
m_poHoloTarget->renderQuad();
// Calculate range
NSDMath::CVector3 vecTarget = m_pTarget->m_ppMasses[0]->m_vecPos - m_pPlayerShip->m_ppMasses[0]->m_vecPos;
int iRange = static_cast<int>(vecTarget.length());
// Range
sprintf(strFont,"%5d m", iRange);
m_poFont->print("Range:", CVector2(0.03f, 0.25f), 0.0075f, CVector3(0,1,0));
m_poFont->print(strFont, CVector2(0.03f, 0.28f), 0.0075f, CVector3(0,1,0));
// Velocity
sprintf(strFont,"%5d m/s", static_cast<int>(m_pTarget->m_fVel));
g_oTextureManager.render(m_auiOffScreenTexture);
m_poFont->print("Velocity:", CVector2(0.03f, 0.32f), 0.0075f, CVector3(0,1,0));
m_poFont->print(strFont, CVector2(0.03f, 0.35f), 0.0075f, CVector3(0,1,0));
}
}
void GLES2Renderer::renderTextBuffer(const void* verts, PxU32 nbVerts, const PxU16* indices, PxU32 nbIndices, RendererMaterial* material)
{
if(m_quadRender)
{
renderQuad(verts, nbVerts,indices, nbIndices,material);
return;
}
PxU32 positionStride = 0, colorStride = 0, texcoordStride = 0, normalStride = 0;
PxU8* locked_positions = static_cast<PxU8*>(m_textVertexBuffer->lockSemantic(RendererVertexBuffer::SEMANTIC_POSITION, positionStride));
PxU8* locked_texcoords = static_cast<PxU8*>(m_textVertexBuffer->lockSemantic(RendererVertexBuffer::SEMANTIC_TEXCOORD0, texcoordStride));
PxU8* locked_colors = static_cast<PxU8*>(m_textVertexBuffer->lockSemantic(RendererVertexBuffer::SEMANTIC_COLOR, colorStride));
locked_positions += positionStride*m_textVertexBufferOffset;
locked_texcoords += texcoordStride*m_textVertexBufferOffset;
locked_colors += colorStride*m_textVertexBufferOffset;
m_textMaterial = material;
// copy indices
PxU16* locked_indices = static_cast<PxU16*>(m_textIndexBuffer->lock());
locked_indices += m_textIndexBufferOffset;
for (PxU32 i = 0; i < nbIndices; i++)
{
locked_indices[i] = indices[i] + m_textVertexBufferOffset;
}
//memcpy(locked_indices, indices, nbIndices * sizeof(PxU16));
m_textIndexBuffer->unlock();
PxU32 windowWidth, windowHeight;
getWindowSize(windowWidth, windowHeight);
PxReal windowWidthHalf = windowWidth / 2.0f,
windowHeightHalf = windowHeight / 2.0f;
TextVertex* tv = (TextVertex*)verts;
for(PxU32 i = 0; i < nbVerts; ++i,
locked_positions += positionStride,
locked_colors += colorStride,
locked_texcoords += texcoordStride,
tv += 1)
{
PxVec3 pos = PxVec3(tv->p.x / windowWidthHalf - 1.0f, 1.0f - tv->p.y / windowHeightHalf, 0.0f);
memcpy(locked_positions, &(pos), sizeof(tv->p));
memcpy(locked_colors, &(tv->color), sizeof(tv->color));
memcpy(locked_texcoords, &(tv->u), sizeof(PxReal));
memcpy(locked_texcoords + sizeof(PxReal), &(tv->v), sizeof(PxReal));
}
m_textVertexBuffer->unlockSemantic(RendererVertexBuffer::SEMANTIC_COLOR);
m_textVertexBuffer->unlockSemantic(RendererVertexBuffer::SEMANTIC_TEXCOORD0);
m_textVertexBuffer->unlockSemantic(RendererVertexBuffer::SEMANTIC_POSITION);
m_textVertexBufferOffset += nbVerts;
m_textIndexBufferOffset += nbIndices;
RENDERER_ASSERT(m_textVertexBufferOffset < m_textVertexBuffer->getMaxVertices(), "Text vertex buffer too small increase it.");
RENDERER_ASSERT(m_textIndexBufferOffset < m_textIndexBuffer->getMaxIndices(), "Text index buffer too small increase it.");
}
void CBlurCompositor::gaussBlur(ISceneManager* smgr, bool lastCompositor)
{
IVideoDriver* driver = smgr->getVideoDriver();
ITextureManager* tmgr = ITextureManager::getInstance();
IRenderTarget* input = driver->getRenderTarget();
IRenderTarget* output = tmgr->getTempRenderTarget(input->getWidth(), input->getHeight(), input->getFormat());
IMeshNode* quad = smgr->getQuadNode();
quad->setMaterial(&mMaterial);
IPipelineManager* pipelineManager = IPipelineManager::getInstance();
IPipeline* vblurPipeline = pipelineManager->get("gf/gauss_vertical_blur");
IPipeline* hblurPipeline = pipelineManager->get("gf/gauss_horizontal_blur");
// render pass - 1
for (u32 i = 0; i < mPassCount - 1; i++)
{
// vertical blur
mMaterial.setPipeline(vblurPipeline);
renderQuad(driver, smgr, quad, input, output);
// horizontal blur
mMaterial.setPipeline(hblurPipeline);
renderQuad(driver, smgr, quad, output, input);
}
// render last pass
mMaterial.setPipeline(vblurPipeline);
renderQuad(driver, smgr, quad, input, output);
mMaterial.setPipeline(hblurPipeline);
if (lastCompositor)
{
renderQuad(driver, smgr, quad, output, nullptr);
tmgr->releaseTempRenderTarget(output);
}
else
{
renderQuad(driver, smgr, quad, output, input);
}
tmgr->releaseTempRenderTarget(input);
}
void CBlurCompositor::squareBlur(ISceneManager* smgr, bool lastCompositor)
{
IVideoDriver* driver = smgr->getVideoDriver();
ITextureManager* tmgr = ITextureManager::getInstance();
IRenderTarget* input = driver->getRenderTarget();
IRenderTarget* output = nullptr;
IMeshNode* quad = smgr->getQuadNode();
quad->setMaterial(&mMaterial);
if (mPassCount == 1)
{
if (!lastCompositor)
output = tmgr->getTempRenderTarget(input->getWidth(), input->getHeight(), input->getFormat());
renderQuad(driver, smgr, quad, input, output);
tmgr->releaseTempRenderTarget(input);
}
else
{
output = tmgr->getTempRenderTarget(input->getWidth(), input->getHeight(), input->getFormat());
// render pass - 1
for (u32 i = 0; i < mPassCount - 1; i++)
{
renderQuad(driver, smgr, quad, input, output);
std::swap(input, output);
}
// render the last pass
if (!lastCompositor)
{
renderQuad(driver, smgr, quad, input, output);
}
else
{
renderQuad(driver, smgr, quad, input, nullptr);
tmgr->releaseTempRenderTarget(output);
}
tmgr->releaseTempRenderTarget(input);
}
}
void RenderBackground::Process(tgt::RenderTarget *input)
{
privatetarget_->activateTarget();
MatStack.matrixMode(tgt::MatrixStack::PROJECTION);
MatStack.loadIdentity();
MatStack.matrixMode(tgt::MatrixStack::MODELVIEW);
MatStack.loadIdentity();
glClearDepth(1.0);
glDisable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// first the background
renderBackground();
privatetarget_->deactivateTarget();
///
///
glEnable(GL_DEPTH_TEST);
// blending background with input
output_->activateTarget();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// use the shader to to blend the original picture over the background and to keep the
// depth values
tgt::TextureUnit colorUnit0, depthUnit0, colorUnit1, depthUnit1;
privatetarget_->bindTextures(colorUnit0.getEnum(), depthUnit0.getEnum());
input->bindTextures(colorUnit1.getEnum(), depthUnit1.getEnum());
// initialize shader
program_->activate();
setGlobalShaderParameters(program_, 0, output_->getSize());
program_->setUniform("colorTex0_", colorUnit0.getUnitNumber());
program_->setUniform("depthTex0_", depthUnit0.getUnitNumber());
program_->setUniform("colorTex1_", colorUnit1.getUnitNumber());
program_->setUniform("depthTex1_", depthUnit1.getUnitNumber());
privatetarget_->setTextureParameters(program_, "textureParameters0_");
input->setTextureParameters(program_, "textureParameters1_");
glDepthFunc(GL_ALWAYS);
renderQuad();
glDepthFunc(GL_LESS);
program_->deactivate();
output_->deactivateTarget();
tgt::TextureUnit::setZeroUnit();
}
void ShaderBallotBaseTestCase::ShaderPipeline::test(deqp::Context& context)
{
if (m_testedShader == glu::SHADERTYPE_COMPUTE)
{
executeComputeShader(context);
}
else
{
renderQuad(context);
}
}
void EntryExitPoints::jitterEntryPoints() {
// if canvas resolution has changed, regenerate jitter texture
if (!jitterTexture_ ||
(jitterTexture_->getDimensions().x != entryPort_.getSize().x) ||
(jitterTexture_->getDimensions().y != entryPort_.getSize().y))
{
generateJitterTexture();
}
shaderProgramJitter_->activate();
tgt::Camera cam = camera_.get();
setGlobalShaderParameters(shaderProgramJitter_, &cam);
// bind jitter texture
TextureUnit jitterUnit;
jitterUnit.activate();
jitterTexture_->bind();
jitterTexture_->uploadTexture();
shaderProgramJitter_->setUniform("jitterTexture_", jitterUnit.getUnitNumber());
shaderProgramJitter_->setIgnoreUniformLocationError(true);
shaderProgramJitter_->setUniform("jitterParameters_.dimensions_",
tgt::vec2(jitterTexture_->getDimensions().xy()));
shaderProgramJitter_->setUniform("jitterParameters_.dimensionsRCP_",
tgt::vec2(1.0f) / tgt::vec2(jitterTexture_->getDimensions().xy()));
shaderProgramJitter_->setUniform("jitterParameters_.matrix_", tgt::mat4::identity);
shaderProgramJitter_->setIgnoreUniformLocationError(false);
// bind entry points texture and depth texture (have been rendered to temporary port)
TextureUnit entryParams, exitParams, entryParamsDepth;
tmpPort_.bindColorTexture(entryParams.getEnum());
shaderProgramJitter_->setUniform("entryPoints_", entryParams.getUnitNumber());
tmpPort_.bindDepthTexture(entryParamsDepth.getEnum());
shaderProgramJitter_->setUniform("entryPointsDepth_", entryParamsDepth.getUnitNumber());
tmpPort_.setTextureParameters(shaderProgramJitter_, "entryParameters_");
// bind exit points texture
exitPort_.bindColorTexture(exitParams.getEnum());
shaderProgramJitter_->setUniform("exitPoints_", exitParams.getUnitNumber());
exitPort_.setTextureParameters(shaderProgramJitter_, "exitParameters_");
shaderProgramJitter_->setUniform("stepLength_", jitterStepLength_.get());
entryPort_.activateTarget("jitteredEntryParams");
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// render screen aligned quad
renderQuad();
shaderProgramJitter_->deactivate();
}
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 Renderer::renderTile(unsigned x, unsigned y, unsigned flags)
{
const float fx = x * kTileSize;
const float fy = y * kTileSize;
const float ts = kTileSize;
const float ws = kWireSize;
const float off = (ts - ws) / 2.f;
const unsigned backcol = (flags & ETF_ENERGIZED)?kBackgroundColorEnergized:kBackgroundColor;
const unsigned wirecol = (flags & ETF_ENERGIZED)?kWireColorEnergized:kWireColor;
renderQuad(fx, fy, ts - 1.f, ts - 1.f, backcol);
if(flags & ETF_CONNECT_NORTH)
renderQuad(fx + off, fy, ws, ws + off, wirecol);
if(flags & ETF_CONNECT_SOUTH)
renderQuad(fx + off, fy + off, ws, ws + off, wirecol);
if(flags & ETF_CONNECT_EAST)
renderQuad(fx + off, fy + off, ws + off, ws, wirecol);
if(flags & ETF_CONNECT_WEST)
renderQuad(fx, fy + off, ws + off, ws, wirecol);
}
void display ()
{
/////////////////////////////////////////////////////////
//Color + Matrix setup
glClearColor( 1,1,1,1 );
glClear( GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
Shader *shader = shaderDefault;
shader->use();
Int32 uModelview = shader->program->getUniform( "modelview" );
glUniformMatrix4fv( uModelview, 1, false, (GLfloat*) matModelView.top().m );
Int32 uProjection = shader->program->getUniform( "projection" );
glUniformMatrix4fv( uProjection, 1, false, (GLfloat*) matProjection.top().m );
Int32 uColor = shaderDefault->program->getUniform( "color" );
glUniform4f( uColor, 1.0f, 0.0f, 0.0f, 0.0f );
//////////////////////////////////////////////////////////
//Render
renderQuad( shaderDefault, Vec2(100,100), Vec2(200,200) );
//////////////////////////////////////////////////////////
//FPS
//Add to fps
static int fps = 0;
fps++;
//Check if 1 second elapsed
static int lastUpdate = glutGet( GLUT_ELAPSED_TIME );
int now = glutGet( GLUT_ELAPSED_TIME );
if (now - lastUpdate > 1000)
{
std::cout << "Fps: " << fps << std::endl;
lastUpdate = now;
fps = 0;
}
//Check for errors
checkGlError( "display end" );
glutSwapBuffers();
}
