ResInsight/Fwk/AppFwk/cafViewer/cafViewer.cpp

//##################################################################################################
//
//   Custom Visualization Core library
//   Copyright (C) 2011-2013 Ceetron AS
//
//   This library may be used under the terms of either the GNU General Public License or
//   the GNU Lesser General Public License as follows:
//
//   GNU General Public License Usage
//   This library is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
//   This library is distributed in the hope that it will be useful, but WITHOUT ANY
//   WARRANTY; without even the implied warranty of MERCHANTABILITY or
//   FITNESS FOR A PARTICULAR PURPOSE.
//
//   See the GNU General Public License at <<http://www.gnu.org/licenses/gpl.html>>
//   for more details.
//
//   GNU Lesser General Public License Usage
//   This library is free software; you can redistribute it and/or modify
//   it under the terms of the GNU Lesser General Public License as published by
//   the Free Software Foundation; either version 2.1 of the License, or
//   (at your option) any later version.
//
//   This library is distributed in the hope that it will be useful, but WITHOUT ANY
//   WARRANTY; without even the implied warranty of MERCHANTABILITY or
//   FITNESS FOR A PARTICULAR PURPOSE.
//
//   See the GNU Lesser General Public License at <<http://www.gnu.org/licenses/lgpl-2.1.html>>
//   for more details.
//
//##################################################################################################

#include "cafViewer.h"

#include "cafCadNavigation.h"
#include "cafFrameAnimationControl.h"
#include "cafNavigationPolicy.h"
#include "cafPointOfInterestVisualizer.h"

#include "cvfCamera.h"
#include "cvfDebugTimer.h"
#include "cvfDrawable.h"
#include "cvfDrawableGeo.h"
#include "cvfDynamicUniformSet.h"
#include "cvfFramebufferObject.h"
#include "cvfHitItemCollection.h"
#include "cvfManipulatorTrackball.h"
#include "cvfModel.h"
#include "cvfOpenGLCapabilities.h"
#include "cvfOpenGLResourceManager.h"
#include "cvfOverlayImage.h"
#include "cvfPart.h"
#include "cvfRay.h"
#include "cvfRayIntersectSpec.h"
#include "cvfRenderQueueSorter.h"
#include "cvfRenderSequence.h"
#include "cvfRenderbufferObject.h"
#include "cvfRendering.h"
#include "cvfRenderingScissor.h"
#include "cvfScene.h"
#include "cvfShaderSourceProvider.h"
#include "cvfSingleQuadRenderingGenerator.h"
#include "cvfTextureImage.h"
#include "cvfTransform.h"
#include "cvfUniform.h"
#include "cvfUniformSet.h"

#include "cvfqtOpenGLContext.h"
#include "cvfqtPerformanceInfoHud.h"
#include "cvfqtUtils.h"

#include <QDebug>
#include <QHBoxLayout>
#include <QInputEvent>

#include <cmath>

namespace caf
{

class GlobalViewerDynUniformSet: public cvf::DynamicUniformSet
{
public:
    GlobalViewerDynUniformSet()
    {
        m_headlightPosition = new cvf::UniformFloat("u_ecLightPosition", cvf::Vec3f(0.5, 5.0, 7.0));
        m_uniformSet = new cvf::UniformSet();
        m_uniformSet->setUniform(m_headlightPosition.p());
    }

    ~GlobalViewerDynUniformSet() override {}

    void setHeadLightPosition(const cvf::Vec3f posRelativeToCamera) { m_headlightPosition->set(posRelativeToCamera);}


    cvf::UniformSet* uniformSet() override { return m_uniformSet.p(); }
    void        update(cvf::Rendering* rendering) override{};      

private:
    cvf::ref<cvf::UniformSet>   m_uniformSet;
    cvf::ref<cvf::UniformFloat> m_headlightPosition;
};


}

std::list<caf::Viewer*> caf::Viewer::sm_viewers;
cvf::ref<cvf::OpenGLContextGroup> caf::Viewer::sm_openGLContextGroup;

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
caf::Viewer::Viewer(const QGLFormat& format, QWidget* parent)
    #if QT_VERSION >= 0x050000
    :   caf::OpenGLWidget(contextGroup(), format, nullptr, sharedWidget()),
    #else
    :   caf::OpenGLWidget(contextGroup(), format, new QWidget(parent), sharedWidget()),
    #endif
    m_navigationPolicy(nullptr),
    m_navigationPolicyEnabled(true),
    m_defaultPerspectiveNearPlaneDistance(0.05),
    m_maxClipPlaneDistance(cvf::UNDEFINED_DOUBLE),
    m_cameraFieldOfViewYDeg(40.0),
    m_paintCounter(0),
    m_releaseOGLResourcesEachFrame(false),
    m_isOverlayPaintingEnabled(true),
    m_offscreenViewportWidth(0),
    m_offscreenViewportHeight(0),
    m_parallelProjectionLightDirection(0, 0, -1), // Light directly from behind
    m_comparisonViewOffset(0, 0, 0),
    m_comparisonWindowNormalizedRect(0.5f, 0.0f, 0.5f, 1.0f),
    m_isComparisonFollowingAnimation(true),
    m_isComparisonViewActiveFlag(false)
{
    #if QT_VERSION >= 0x050000
    m_layoutWidget = new QWidget(parent);
    #else
    m_layoutWidget = parentWidget();
    #endif
    
    QHBoxLayout* layout = new QHBoxLayout(m_layoutWidget);

    layout->addWidget(this);
    layout->setContentsMargins(0, 0, 0, 0);

    setAutoFillBackground(false);
    setMouseTracking(true);

    // Needed to get keystrokes
    setFocusPolicy(Qt::ClickFocus);

    m_globalUniformSet = new GlobalViewerDynUniformSet();

    m_mainCamera = new cvf::Camera;
    m_mainCamera->setFromLookAt(cvf::Vec3d(0,0,-1), cvf::Vec3d(0,0,0), cvf::Vec3d(0,1,0));
    m_comparisonMainCamera = new cvf::Camera;
    m_comparisonMainCamera->setFromLookAt(cvf::Vec3d(0,0,-1), cvf::Vec3d(0,0,0), cvf::Vec3d(0,1,0));

    m_renderingSequence = new cvf::RenderSequence();
    m_renderingSequence->setDefaultFFLightPositional(cvf::Vec3f(0.5, 5.0, 7.0));

    m_mainRendering = new cvf::Rendering("Main Rendering");
    m_comparisonMainRendering = new cvf::Rendering("Comparison Rendering");
    m_overlayItemsRendering  = new cvf::Rendering("Overlay Rendering");
    m_overlayItemsRendering->setClearMode(cvf::Viewport::DO_NOT_CLEAR);

    m_comparisonRenderingScissor = new cvf::RenderingScissor;
    m_comparisonMainRendering->setRenderingScissor(m_comparisonRenderingScissor.p());

    m_animationControl = new caf::FrameAnimationControl(this);
    connect(m_animationControl, SIGNAL(changeFrame(int)), SLOT(slotSetCurrentFrame(int)));
    connect(m_animationControl, SIGNAL(endAnimation()), SLOT(slotEndAnimation()));


    this->setNavigationPolicy(new caf::CadNavigation);

    m_overlayTextureImage = new cvf::TextureImage;
    m_overlayImage = new cvf::OverlayImage(m_overlayTextureImage.p());
    m_overlayImage->setBlending(cvf::OverlayImage::TEXTURE_ALPHA);
    m_overlayImage->setLayoutFixedPosition(cvf::Vec2i(0,0));

    setupMainRendering();
    setupRenderingSequence();

    m_showPerfInfoHud = false;

    sm_viewers.push_back(this);
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
caf::Viewer::~Viewer()
{
    this->cvfShutdownOpenGLContext();
    sm_viewers.remove(this);

    // To delete the layout widget
    if (m_layoutWidget) m_layoutWidget->deleteLater();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setupMainRendering()
{
    m_mainRendering->setCamera(m_mainCamera.p());
    m_comparisonMainRendering->setCamera(m_comparisonMainCamera.p());
    m_overlayItemsRendering->setCamera(m_mainCamera.p());

    m_mainRendering->setRenderQueueSorter(new cvf::RenderQueueSorterBasic(cvf::RenderQueueSorterBasic::EFFECT_ONLY));
    m_comparisonMainRendering->setRenderQueueSorter(new cvf::RenderQueueSorterBasic(cvf::RenderQueueSorterBasic::EFFECT_ONLY));
    m_overlayItemsRendering->setRenderQueueSorter(new cvf::RenderQueueSorterBasic(cvf::RenderQueueSorterBasic::EFFECT_ONLY));

    m_mainRendering->addGlobalDynamicUniformSet(m_globalUniformSet.p());
    m_comparisonMainRendering->addGlobalDynamicUniformSet(m_globalUniformSet.p());

    // Set fixed function rendering if QGLFormat does not support directRendering
    if (!this->format().directRendering())
    {
        m_mainRendering->renderEngine()->enableForcedImmediateMode(true);
        m_comparisonMainRendering->renderEngine()->enableForcedImmediateMode(true);
        m_overlayItemsRendering->renderEngine()->enableForcedImmediateMode(true);
    }

    if (contextGroup()->capabilities() &&
        contextGroup()->capabilities()->hasCapability(cvf::OpenGLCapabilities::FRAMEBUFFER_OBJECT))
    {
        m_offscreenFbo = new cvf::FramebufferObject;

        m_mainRendering->setTargetFramebuffer(m_offscreenFbo.p());
        m_comparisonMainRendering->setTargetFramebuffer(m_offscreenFbo.p());
        m_overlayItemsRendering->setTargetFramebuffer(m_offscreenFbo.p());

        cvf::ref<cvf::RenderbufferObject> rbo = new cvf::RenderbufferObject(cvf::RenderbufferObject::DEPTH_COMPONENT24, 1, 1);
        m_offscreenFbo->attachDepthRenderbuffer(rbo.p());

        m_offscreenTexture = new cvf::Texture(cvf::Texture::TEXTURE_2D, cvf::Texture::RGBA);
        m_offscreenTexture->setSize(1, 1);
        m_offscreenFbo->attachColorTexture2d(0, m_offscreenTexture.p());
    }

    updateOverlayImagePresence();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setupRenderingSequence()
{
    m_renderingSequence->addRendering(m_mainRendering.p());
    m_renderingSequence->addRendering(m_comparisonMainRendering.p());
    m_renderingSequence->addRendering(m_overlayItemsRendering.p());

    if (m_offscreenFbo.notNull())
    {
        // Setup second rendering drawing the texture on the screen
        // -------------------------------------------------------------------------
        cvf::SingleQuadRenderingGenerator quadRenderGen;
        cvf::ref<cvf::Sampler> sampler = new cvf::Sampler;
        sampler->setWrapMode(cvf::Sampler::CLAMP_TO_EDGE);
        sampler->setMinFilter(cvf::Sampler::NEAREST);
        sampler->setMagFilter(cvf::Sampler::NEAREST);

        quadRenderGen.addTexture(m_offscreenTexture.p(), sampler.p(), "u_texture2D");
        quadRenderGen.addFragmentShaderCode(cvf::ShaderSourceProvider::instance()->getSourceFromRepository(cvf::ShaderSourceRepository::fs_Unlit));
        quadRenderGen.addFragmentShaderCode(cvf::ShaderSourceProvider::instance()->getSourceFromRepository(cvf::ShaderSourceRepository::src_Texture));

        m_quadRendering = quadRenderGen.generate();
        m_renderingSequence->addRendering(m_quadRendering.p());
    }

    updateCamera(width(), height());
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
caf::Viewer* caf::Viewer::sharedWidget()
{
    if (sm_viewers.size() > 0)
    {
        return *(sm_viewers.begin());
    }

    return nullptr;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
cvf::OpenGLContextGroup* caf::Viewer::contextGroup()
{
    if (sm_openGLContextGroup.isNull())
    {
        sm_openGLContextGroup = new cvf::OpenGLContextGroup();
    }

    return sm_openGLContextGroup.p();
}

//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Camera* caf::Viewer::mainCamera()
{
    return m_mainCamera.p();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
cvf::Camera* caf::Viewer::comparisonMainCamera()
{
    return m_comparisonMainCamera.p();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setComparisonViewEyePointOffset(const cvf::Vec3d& offset)
{
    m_comparisonViewOffset = offset;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
const cvf::Vec3d caf::Viewer::comparisonViewEyePointOffset()
{
    return m_comparisonViewOffset;
}

//--------------------------------------------------------------------------------------------------
/// setNormalizedComparisonViewRect
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setComparisonViewVisibleNormalizedRect( const cvf::Rectf& visibleRect )
{
    m_comparisonWindowNormalizedRect = visibleRect;

    updateCamera(width(), height());
    update();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
cvf::Rectf caf::Viewer::comparisonViewVisibleNormalizedRect() const 
{
    return m_comparisonWindowNormalizedRect;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool caf::Viewer::isComparisonViewActive() const
{
    return m_isComparisonViewActiveFlag;
}

//--------------------------------------------------------------------------------------------------
/// Set the scene to be rendered when the animation is inactive (Stopped)
//--------------------------------------------------------------------------------------------------
void  caf::Viewer::setMainScene(cvf::Scene* scene, bool isForComparisonView )
{
    appendAllStaticModelsToFrame(scene, isForComparisonView);
    if ( !isForComparisonView )
    {
        m_mainScene = scene;
        m_mainRendering->setScene(scene);
    }
    else
    {
        m_comparisonMainScene = scene;
        m_comparisonMainRendering->setScene(scene);
        updateComparisonViewActiveFlag();
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
cvf::Scene* caf::Viewer::mainScene( bool isForComparisonView)
{
    if (!isForComparisonView)
    {
        return m_mainScene.p();
    }
    else
    {
        return m_comparisonMainScene.p();
    }
}

//--------------------------------------------------------------------------------------------------
/// Return the currently rendered scene
//--------------------------------------------------------------------------------------------------
cvf::Scene* caf::Viewer::currentScene(bool isForComparisonView)
{
    if (!isForComparisonView)
    {
        return m_mainRendering->scene();
    }
    else
    {
        return m_comparisonMainRendering->scene();
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::updateCamera(int width, int height)
{
    if (width < 1 || height < 1) return;

    m_mainCamera->viewport()->set(0, 0, width, height);
    m_comparisonMainCamera->viewport()->set(0, 0, width, height);
    m_comparisonRenderingScissor->setScissorRectangle(static_cast<int>(width  * m_comparisonWindowNormalizedRect.min().x()),
                                                      static_cast<int>(height * m_comparisonWindowNormalizedRect.min().y()),
                                                      static_cast<int>(width  * m_comparisonWindowNormalizedRect.width()),
                                                      static_cast<int>(height * m_comparisonWindowNormalizedRect.height()));

    if (m_mainCamera->projection() == cvf::Camera::PERSPECTIVE)
    {
        m_mainCamera->setProjectionAsPerspective(m_cameraFieldOfViewYDeg, m_mainCamera->nearPlane(), m_mainCamera->farPlane());
    }
    else
    {
        m_mainCamera->setProjectionAsOrtho(m_mainCamera->frontPlaneFrustumHeight(), m_mainCamera->nearPlane(), m_mainCamera->farPlane());
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool caf::Viewer::canRender() const
{
    if (m_renderingSequence->renderingCount() < 1) return false;

    if (m_mainCamera.isNull()) return false;
    if (m_mainCamera->viewport()->width() < 1) return false;
    if (m_mainCamera->viewport()->height() < 1) return false;

    return true;
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::optimizeClippingPlanes()
{
    double nearPlaneDist = HUGE_VAL;
    double farPlaneDist = HUGE_VAL;

    cvf::Vec3d navPointOfinterest = m_navigationPolicy->pointOfInterest();

    if ( calculateNearFarPlanes(m_mainRendering.p(), navPointOfinterest, &farPlaneDist, &nearPlaneDist) )
    {
        if ( m_mainCamera->projection() == cvf::Camera::PERSPECTIVE )
        {
            m_mainCamera->setProjectionAsPerspective(m_cameraFieldOfViewYDeg, nearPlaneDist, farPlaneDist);
        }
        else
        {
            m_mainCamera->setProjectionAsOrtho(m_mainCamera->frontPlaneFrustumHeight(), nearPlaneDist, farPlaneDist);
        }
    }

    copyCameraView(m_mainCamera.p(), m_comparisonMainCamera.p() );
    m_comparisonMainCamera->viewport()->setClearColor(m_mainCamera->viewport()->clearColor());

    if ( m_comparisonMainRendering->scene() )
    {
        cvf::Vec3d camUp;
        cvf::Vec3d camEye;
        cvf::Vec3d camViewRefPoint;

        m_comparisonMainCamera->toLookAt( &camEye, &camViewRefPoint, &camUp );
        camEye += m_comparisonViewOffset;
        camViewRefPoint += m_comparisonViewOffset;
        m_comparisonMainCamera->setFromLookAt(camEye, camViewRefPoint, camUp);
        navPointOfinterest += m_comparisonViewOffset;

        if ( calculateNearFarPlanes(m_comparisonMainRendering.p(), navPointOfinterest, &farPlaneDist, &nearPlaneDist) )
        {
            if ( m_comparisonMainCamera->projection() == cvf::Camera::PERSPECTIVE )
            {
                m_comparisonMainCamera->setProjectionAsPerspective(m_cameraFieldOfViewYDeg, nearPlaneDist, farPlaneDist);
            }
            else
            {
                m_comparisonMainCamera->setProjectionAsOrtho(m_comparisonMainCamera->frontPlaneFrustumHeight(), nearPlaneDist, farPlaneDist);
            }
        }
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool caf::Viewer::calculateNearFarPlanes(const cvf::Rendering* rendering, 
                                         const cvf::Vec3d& navPointOfinterest, 
                                         double *farPlaneDist, 
                                         double *nearPlaneDist)
{
    cvf::BoundingBox bb = rendering->boundingBox();

    if ( !bb.isValid() ) return false;

    cvf::Vec3d eye     = rendering->camera()->position();
    cvf::Vec3d viewdir = rendering->camera()->direction();

    cvf::Vec3d bboxCorners[8];
    bb.cornerVertices(bboxCorners);

    // Find the distance to the bbox corners most behind and most in front of camera

    double maxDistEyeToCornerAlongViewDir = -HUGE_VAL;
    double minDistEyeToCornerAlongViewDir = HUGE_VAL;
    for ( int bcIdx = 0; bcIdx < 8; ++bcIdx )
    {
        double distEyeBoxCornerAlongViewDir = (bboxCorners[bcIdx] - eye)*viewdir;

        if ( distEyeBoxCornerAlongViewDir > maxDistEyeToCornerAlongViewDir )
        {
            maxDistEyeToCornerAlongViewDir = distEyeBoxCornerAlongViewDir;
        }

        if ( distEyeBoxCornerAlongViewDir < minDistEyeToCornerAlongViewDir )
        {
            minDistEyeToCornerAlongViewDir = distEyeBoxCornerAlongViewDir; // Sometimes negative-> behind camera
        }
    }

    (*farPlaneDist) = CVF_MIN(maxDistEyeToCornerAlongViewDir * 1.2, m_maxClipPlaneDistance);

    // Near-plane:

    bool isOrthoNearPlaneFollowingCamera = false;

    // If we have perspective projection, set the near plane just in front of camera, and not behind

    if ( rendering->camera()->projection() == cvf::Camera::PERSPECTIVE || isOrthoNearPlaneFollowingCamera )
    {
        // Choose the one furthest from the camera of: 0.8*bbox distance, m_minPerspectiveNearPlaneDistance.
        (*nearPlaneDist) = CVF_MAX(m_defaultPerspectiveNearPlaneDistance, 0.8*minDistEyeToCornerAlongViewDir);

        // If we are zooming into a detail, allow the near-plane to move towards camera beyond the m_minPerspectiveNearPlaneDistance
        if ( (*nearPlaneDist) == m_defaultPerspectiveNearPlaneDistance // We are inside the bounding box
            && m_navigationPolicy.notNull() && m_navigationPolicyEnabled )
        {
            double pointOfInterestDist = (eye - navPointOfinterest).length();
            (*nearPlaneDist) = CVF_MIN((*nearPlaneDist), pointOfInterestDist*0.2);
        }

        // Guard against the zero nearplane possibility
        if ( (*nearPlaneDist) <= 0 ) (*nearPlaneDist) = m_defaultPerspectiveNearPlaneDistance;
    }
    else // Orthographic projection. Set to encapsulate the complete boundingbox, possibly setting a negative nearplane
    {
        if ( minDistEyeToCornerAlongViewDir >= 0 )
        {
            (*nearPlaneDist) = CVF_MIN(0.8 * minDistEyeToCornerAlongViewDir, m_maxClipPlaneDistance);
        }
        else
        {
            (*nearPlaneDist) = CVF_MAX(1.2 * minDistEyeToCornerAlongViewDir, -m_maxClipPlaneDistance);
        }
    }

    if ( (*farPlaneDist) <= (*nearPlaneDist) ) (*farPlaneDist) = (*nearPlaneDist) + 1.0;

    return true;
}

//--------------------------------------------------------------------------------------------------
/// Forward all events classified as QInputEvent to the navigation policy
//--------------------------------------------------------------------------------------------------
bool caf::Viewer::event(QEvent* e)
{
    #if QT_VERSION >= 0x050000
    // The most reliable way we have found of detecting when an OpenGL context is about to be destroyed is
    // hooking into the QEvent::PlatformSurface event and checking for the SurfaceAboutToBeDestroyed event type.
    // From the Qt doc: 
    //   The underlying native surface will be destroyed immediately after this event.
    //   The SurfaceAboutToBeDestroyed event type is useful as a means of stopping rendering to a platform window before it is destroyed.
    if ( e->type() == QEvent::PlatformSurface )
    {
        QPlatformSurfaceEvent* platformSurfaceEvent = static_cast<QPlatformSurfaceEvent*>(e);
        if ( platformSurfaceEvent->surfaceEventType() == QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed )
        {
            cvfShutdownOpenGLContext();
        }
    }
    #endif

    if (e && m_navigationPolicy.notNull() && m_navigationPolicyEnabled)
    {
        switch (e->type())
        {
        case QEvent::ContextMenu:
        case QEvent::KeyPress:
        case QEvent::KeyRelease:
        case QEvent::ShortcutOverride:
        case QEvent::MouseButtonPress:
        case QEvent::MouseButtonRelease:
        case QEvent::MouseButtonDblClick:
        case QEvent::MouseMove:
        case QEvent::TabletMove:     
        case QEvent::TabletPress:     
        case QEvent::TabletRelease:
        case QEvent::TabletEnterProximity:
        case QEvent::TabletLeaveProximity:
        case QEvent::Wheel:
        case QEvent::TouchBegin:
        case QEvent::TouchUpdate:    
        case QEvent::TouchEnd:
            if (m_navigationPolicy->handleInputEvent(static_cast<QInputEvent*>(e)))
                return true;
            else return QGLWidget::event(e);
            break;
        default:
            return QGLWidget::event(e); 
            break;
        }
    }
    else return QGLWidget::event(e); 
}

//--------------------------------------------------------------------------------------------------
/// Set the pointer to the navigation policy to be used. Stored as a cvf::ref internally
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setNavigationPolicy(caf::NavigationPolicy* navigationPolicy)
{
    m_navigationPolicy = navigationPolicy;

    if (m_navigationPolicy.notNull())  m_navigationPolicy->setViewer(this);
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
const caf::NavigationPolicy* caf::Viewer::getNavigationPolicy() const
{
    return m_navigationPolicy.p();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::RayIntersectSpec> caf::Viewer::rayIntersectSpecFromWindowCoordinates( int winPosX, int winPosY )
{
    bool mousePosIsWithinComparisonView = isMousePosWithinComparisonView(winPosX, winPosY);

    return this->rayIntersectSpecFromWindowCoordinates(winPosX, winPosY, mousePosIsWithinComparisonView);
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::RayIntersectSpec> caf::Viewer::rayIntersectSpecFromWindowCoordinates(int winPosX, int winPosY, bool isForComparisonView)
{
    int translatedMousePosX = winPosX;
    int translatedMousePosY = height() - winPosY;

    cvf::Rendering* renderingToInvestigate = isForComparisonView ? m_comparisonMainRendering.p(): m_mainRendering.p();
    
    return renderingToInvestigate->rayIntersectSpecFromWindowCoordinates(translatedMousePosX, translatedMousePosY);
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool caf::Viewer::rayPick(int winPosX, int winPosY, cvf::HitItemCollection* pickedPoints, cvf::Vec3d* globalRayOrigin/*=nullptr*/)
{
    CVF_ASSERT(m_mainRendering.notNull());

    bool mousePosIsWithinComparisonView = isMousePosWithinComparisonView(winPosX, winPosY);

    cvf::Rendering* renderingToInvestigate = mousePosIsWithinComparisonView ? m_comparisonMainRendering.p(): m_mainRendering.p();

    cvf::ref<cvf::RayIntersectSpec> ris = rayIntersectSpecFromWindowCoordinates(winPosX, winPosY);

    if (ris.notNull())
    {
        bool retVal = renderingToInvestigate->rayIntersect(*ris, pickedPoints);
        if (retVal && globalRayOrigin)
        {
            CVF_ASSERT(ris->ray() != nullptr);
            *globalRayOrigin = ris->ray()->origin();
        }
        return retVal;
    }
    else
    {
        return false;
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool caf::Viewer::isMousePosWithinComparisonView(int winPosX, int winPosY)
{
    bool mousePosIsWithinComparisonView = false;

    int translatedMousePosX = winPosX;
    int translatedMousePosY = height() - winPosY;

    if ( m_comparisonMainRendering.notNull() && m_comparisonMainRendering->scene() )
    {
        if ( cvf::RenderingScissor* sciss = m_comparisonMainRendering->renderingScissor() )
        {
            cvf::Recti scissorRect(sciss->x(), sciss->y(), sciss->width(), sciss->height());
            if ( scissorRect.contains(cvf::Vec2i(translatedMousePosX, translatedMousePosY)) )
            {
                mousePosIsWithinComparisonView = true;
            }
        }
        else // Whole screen is covered
        {
            mousePosIsWithinComparisonView = true;
        }
    }    
    
    return mousePosIsWithinComparisonView;
}

//--------------------------------------------------------------------------------------------------
///  
//--------------------------------------------------------------------------------------------------
void caf::Viewer::resizeGL(int width, int height)
{
    if (width < 1 || height < 1) return;

    if (m_offscreenFbo.notNull())
    {
        m_offscreenFbo->resizeAttachedBuffers(width, height);
    

        m_offscreenViewportWidth = width;
        m_offscreenViewportHeight = height;
    }

    if (m_quadRendering.notNull())
    {
        m_quadRendering->camera()->viewport()->set(0, 0, width, height);
    }

    updateCamera(width, height);
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::enablePerfInfoHud(bool enable)
{
    m_showPerfInfoHud = enable;
    updateOverlayImagePresence();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool caf::Viewer::isPerfInfoHudEnabled()
{
    return m_showPerfInfoHud;
}

//--------------------------------------------------------------------------------------------------
///  
//--------------------------------------------------------------------------------------------------
void caf::Viewer::paintEvent(QPaintEvent* event)
{
    makeCurrent();

    cvf::ref<cvf::OpenGLContext> myOglContext = cvfOpenGLContext();
    CVF_CHECK_OGL(myOglContext.p());
    CVF_ASSERT(myOglContext->isContextValid());

    QPainter painter(this);

    if (m_renderingSequence.isNull() || !canRender())
    {
        QColor bgClr(128, 128, 128);
        painter.fillRect(rect(), bgClr);
        return;
    }

    // If Qt overlay painting is enabled, paint to an QImage, and set it to the cvf::OverlayImage

    if (m_isOverlayPaintingEnabled || m_showPerfInfoHud)
    {
        // Set up image to draw to, and painter 
        if (m_overlayPaintingQImage.size() != this->size())
        {
            m_overlayPaintingQImage = QImage(this->size(), QImage::Format_ARGB32);
        }

        m_overlayPaintingQImage.fill(Qt::transparent);
        QPainter overlayPainter(&m_overlayPaintingQImage);

        // Call virtual method to allow subclasses to paint on the OpenGlCanvas

        if (m_isOverlayPaintingEnabled)
        {
            this->paintOverlayItems(&overlayPainter); 
        }

        // Draw performance overlay

        if (m_showPerfInfoHud )
        {
            cvfqt::PerformanceInfoHud hud;
            hud.addStrings(m_renderingSequence->performanceInfo());
            hud.addStrings(*m_mainCamera);
            hud.addString(QString("PaintCount: %1").arg(m_paintCounter++));
            hud.draw(&overlayPainter, width(), height());
        }

        // Convert the QImage into the cvf::TextureImage, 
        // handling vertical mirroring and (possible) byteswapping

        if (((int)m_overlayTextureImage->height()) != this->height() || ((int)m_overlayTextureImage->width() != this->width()))
        {
            m_overlayTextureImage->allocate(this->width(), this->height());
        }

        cvfqt::Utils::toTextureImage(m_overlayPaintingQImage, m_overlayTextureImage.p());
        
        m_overlayImage->setImage(m_overlayTextureImage.p());
        m_overlayImage->setPixelSize(cvf::Vec2ui(this->width(), this->height()));
    }
   
#if QT_VERSION >= 0x040600
    // Qt 4.6
    painter.beginNativePainting();
#endif

    if (isShadersSupported())
    {
        cvfqt::OpenGLContext::saveOpenGLState(myOglContext.p());
    }

    optimizeClippingPlanes();

    m_renderingSequence->removeRendering(m_comparisonMainRendering.p());
    if ( m_comparisonMainRendering->scene() )
    {
        m_renderingSequence->insertRendering( m_overlayItemsRendering.p(), m_comparisonMainRendering.p());
    }

    if ( m_poiVisualizationManager.notNull() )
    {
        m_poiVisualizationManager->update(m_navigationPolicy->pointOfInterest()); // Todo: Must be inserted in comparison scene as well, using the display offset
        m_mainRendering->scene()->addModel(m_poiVisualizationManager->model());
    }

    // Do normal drawing
    m_renderingSequence->render(myOglContext.p());
    CVF_CHECK_OGL(cvfOpenGLContext());

    if (  m_poiVisualizationManager.notNull() )
    {
        m_mainRendering->scene()->removeModel(m_poiVisualizationManager->model());
    }

    if (isShadersSupported())
    {
        cvfqt::OpenGLContext::restoreOpenGLState(myOglContext.p());
    }

#if QT_VERSION >= 0x040600
    // Qt 4.6
    painter.endNativePainting();
#endif

 
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setDefaultPerspectiveNearPlaneDistance(double dist)
{
    m_defaultPerspectiveNearPlaneDistance = dist;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setMaxClipPlaneDistance(double dist)
{
    m_maxClipPlaneDistance = dist;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setView(const cvf::Vec3d& alongDirection, const cvf::Vec3d& upDirection)
{
    if (m_navigationPolicy.notNull() && m_navigationPolicyEnabled)
    {
        m_navigationPolicy->setView(alongDirection, upDirection); 

        navigationPolicyUpdate();
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::zoomAll()
{
    cvf::BoundingBox bb = m_mainRendering->boundingBox();
    if (!bb.isValid())
    {
      return;
    }

    cvf::Vec3d eye, vrp, up;
    m_mainCamera->toLookAt(&eye, &vrp, &up);

    cvf::Vec3d newEye = m_mainCamera->computeFitViewEyePosition(bb, vrp-eye, up, 0.9, m_cameraFieldOfViewYDeg, m_mainCamera->viewport()->aspectRatio());
    m_mainCamera->setFromLookAt(newEye, bb.center(), up);
    
    updateParallelProjectionHeightFromMoveZoom(bb.center());

    if (m_navigationPolicy.notNull()) m_navigationPolicy->setPointOfInterest(bb.center());

    navigationPolicyUpdate();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::addFrame(cvf::Scene* scene, bool isForComparisonView)
{
    appendAllStaticModelsToFrame(scene, isForComparisonView);

    if ( !isForComparisonView )
    {
        m_frameScenes.push_back(scene);
    }
    else
    {
        m_comparisonFrameScenes.push_back(scene);
    }

    m_animationControl->setNumFrames( static_cast<int>( frameCount() ) );
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::removeAllFrames(bool isForComparisonView)
{
    if ( !isForComparisonView )
    {
        m_frameScenes.clear();
        m_mainRendering->setScene(m_mainScene.p());
    }
    else
    {
        m_comparisonFrameScenes.clear();
        m_comparisonMainRendering->setScene(m_comparisonMainScene.p());
        updateComparisonViewActiveFlag();
    }

    m_animationControl->setNumFrames(static_cast<int>(frameCount()));
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool caf::Viewer::isAnimationActive(bool isForComparisonView)
{
    if ( !isForComparisonView )
    {
        cvf::Scene* currentScene = m_mainRendering->scene();

        if ( !currentScene )
        {
            return false;
        }

        if ( m_mainScene.notNull() && m_mainScene.p() == currentScene )
        {
            return false;
        }

        return true;
    }
    else
    {
        cvf::Scene* currentScene = m_comparisonMainRendering->scene();

        if ( !currentScene )
        {
            return false;
        }

        if ( m_comparisonMainScene.notNull() && m_comparisonMainScene.p() == currentScene )
        {
            return false;
        }

        return true;
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::updateComparisonViewActiveFlag()
{
    m_isComparisonViewActiveFlag = m_comparisonMainRendering->scene() != nullptr;
    this->setProperty("cafViewer_IsComparisonViewActive", QVariant(m_isComparisonViewActiveFlag));
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setCurrentComparisonFrame(int frameIndex)
{
    if (m_frameScenes.size() == 0) return;

    unsigned clampedFrameIndex = static_cast<unsigned>(clampFrameIndex(frameIndex));

    if (m_releaseOGLResourcesEachFrame)
    {
        releaseOGlResourcesForCurrentFrame();
    }

    if ( m_comparisonFrameScenes.size() > clampedFrameIndex &&  m_comparisonFrameScenes.at(clampedFrameIndex) != nullptr )
    {
        m_comparisonMainRendering->setScene(m_comparisonFrameScenes.at(clampedFrameIndex));
        updateComparisonViewActiveFlag();
    }
    else
    {
        m_comparisonMainRendering->setScene(nullptr);
        updateComparisonViewActiveFlag();
    }

    update();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setComparisonViewToFollowAnimation(bool isToFollow)
{
    m_isComparisonFollowingAnimation = isToFollow;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::slotSetCurrentFrame(int frameIndex)
{
    if (m_frameScenes.size() == 0) return;

    unsigned clampedFrameIndex = static_cast<unsigned>(clampFrameIndex(frameIndex));

    if (m_releaseOGLResourcesEachFrame)
    {
        releaseOGlResourcesForCurrentFrame();
    }

    if (m_frameScenes.size() > clampedFrameIndex &&  m_frameScenes.at(clampedFrameIndex) != nullptr )
    {
        m_mainRendering->setScene(m_frameScenes.at(clampedFrameIndex));
    }
    else 
    {
        m_mainRendering->setScene(nullptr);
    }

    if ( m_isComparisonFollowingAnimation )
    {
        if ( m_comparisonFrameScenes.size() > clampedFrameIndex &&  m_comparisonFrameScenes.at(clampedFrameIndex) != nullptr )
        {
            m_comparisonMainRendering->setScene(m_comparisonFrameScenes.at(clampedFrameIndex));
            updateComparisonViewActiveFlag();
        }
        else
        {
            m_comparisonMainRendering->setScene(nullptr);
            updateComparisonViewActiveFlag();
        }
    }

    update();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::releaseOGlResourcesForCurrentFrame()
{
    if (isAnimationActive())
    {
        cvf::Scene* currentScene = m_mainRendering->scene();
        makeCurrent();
        cvf::uint modelCount = currentScene->modelCount();
        for (cvf::uint i = 0; i < modelCount; ++i)
        {
            cvf::Collection<cvf::Part> partCollection; 
            currentScene->model(i)->allParts(&partCollection);
            for (size_t pIdx = 0; pIdx < partCollection.size(); ++pIdx)
            {
                if (partCollection[pIdx].notNull() && partCollection[pIdx]->drawable())
                {
                    partCollection[pIdx]->drawable()->releaseBufferObjectsGPU();
                }
            }
        }
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::slotEndAnimation()
{
    if(m_releaseOGLResourcesEachFrame)
    {
        releaseOGlResourcesForCurrentFrame();
    }

    m_mainRendering->setScene(m_mainScene.p());

    update();
}

//--------------------------------------------------------------------------------------------------
/// This only updates the boundingboxes yet. Might want to do other things as well
//--------------------------------------------------------------------------------------------------
void caf::Viewer::updateCachedValuesInScene()
{
    if (m_mainScene.notNull())
    {
        cvf::uint midx;
        for (midx = 0; midx <  m_mainScene->modelCount() ; ++midx)
        {
            m_mainScene->model(midx)->updateBoundingBoxesRecursive();
        }
    }
    size_t sIdx;
    for (sIdx = 0; sIdx < m_frameScenes.size(); ++sIdx)
    {
        cvf::uint midx;
        for (midx = 0; midx <  m_frameScenes[sIdx]->modelCount() ; ++midx)
        {
             m_frameScenes[sIdx]->model(midx)->updateBoundingBoxesRecursive();
        }
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool caf::Viewer::isShadersSupported()
{
    QGLFormat::OpenGLVersionFlags flags = QGLFormat::openGLVersionFlags();
    bool hasOpenGL_2_0 = QGLFormat::OpenGL_Version_2_0 & flags;

    if (hasOpenGL_2_0)
    {
        return true;
    }

    return false;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
QImage caf::Viewer::snapshotImage()
{
    // Qt5 : Call paintEvent() manually to make sure invisible widgets are rendered properly
    // If this call is skipped, we get an assert in cvf::FramebufferObject::bind()
    paintEvent(nullptr);

    QImage image;
    if (m_offscreenFbo.notNull() && m_offscreenViewportWidth > 0 && m_offscreenViewportHeight > 0)
    {
        cvf::ref<cvf::OpenGLContext> myOglContext = cvfOpenGLContext();

        m_offscreenFbo->bind(myOglContext.p());

        GLint iOldPackAlignment = 0;
        glGetIntegerv(GL_PACK_ALIGNMENT, &iOldPackAlignment);
        glPixelStorei(GL_PACK_ALIGNMENT, 1);
        CVF_CHECK_OGL(myOglContext.p());

        cvf::UByteArray arr(3 * m_offscreenViewportWidth * m_offscreenViewportHeight);

        glReadPixels(0, 0, static_cast<GLsizei>(m_offscreenViewportWidth), static_cast<GLsizei>(m_offscreenViewportHeight), GL_RGB, GL_UNSIGNED_BYTE, arr.ptr());
        CVF_CHECK_OGL(myOglContext.p());

        glPixelStorei(GL_PACK_ALIGNMENT, iOldPackAlignment);
        CVF_CHECK_OGL(myOglContext.p());

        cvf::FramebufferObject::useDefaultWindowFramebuffer(myOglContext.p());

        cvf::TextureImage texImage;
        texImage.setFromRgb(arr.ptr(), m_offscreenViewportWidth, m_offscreenViewportHeight);

        image = cvfqt::Utils::toQImage(texImage);
    }
    else
    {
        // Code moved from RimView::snapshotWindowContent()

        GLint currentReadBuffer;
        glGetIntegerv(GL_READ_BUFFER, &currentReadBuffer);

        glReadBuffer(GL_FRONT);
        image = this->grabFrameBuffer();

        glReadBuffer(currentReadBuffer);
    }

    return image;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
cvf::Scene* caf::Viewer::frame(size_t frameIndex, bool isForComparisonView)
{
    if ( !isForComparisonView )
    {
        if ( frameIndex < m_frameScenes.size() )
            return m_frameScenes[frameIndex].p();
        else
            return nullptr;
    }
    else
    {
        if ( frameIndex < m_comparisonFrameScenes.size() )
            return m_comparisonFrameScenes[frameIndex].p();
        else
            return nullptr;
    }
}

//--------------------------------------------------------------------------------------------------
/// Helper function used to write out the name of all parts in a rendering sequence
//--------------------------------------------------------------------------------------------------
void caf::Viewer::debugShowRenderingSequencePartNames()
{
    qDebug() << "\n\n";
    size_t globalPartCount = 0;

    cvf::uint rIdx = m_renderingSequence->renderingCount();
    for (rIdx = 0; rIdx < m_renderingSequence->renderingCount(); rIdx++)
    {
        cvf::Rendering* rendering = m_renderingSequence->rendering(rIdx);
        if (rendering && rendering->scene())
        {
            cvf::uint mIdx;
            for (mIdx = 0; mIdx < rendering->scene()->modelCount(); mIdx++)
            {
                cvf::Model* model = rendering->scene()->model(mIdx);
                if (model)
                {
                    cvf::Collection<cvf::Part> parts;
                    model->allParts(&parts);

                    size_t pIdx;
                    for (pIdx = 0; pIdx < parts.size(); pIdx++)
                    {
                        cvf::Part* part = parts.at(pIdx);

                        qDebug() << QString("%1").arg(globalPartCount++) << cvfqt::Utils::toQString(part->name());
                    }
                }
            }
        }
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::enableNavigationPolicy(bool enable)
{
    m_navigationPolicyEnabled = enable;
    if (enable && m_navigationPolicy.notNull()) m_navigationPolicy->init(); 
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
QSize caf::Viewer::sizeHint() const
{
    return QSize(500, 400);
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::enableForcedImmediateMode(bool enable)
{
    cvf::uint rIdx = m_renderingSequence->renderingCount();
    for (rIdx = 0; rIdx < m_renderingSequence->renderingCount(); rIdx++)
    {
        cvf::Rendering* rendering = m_renderingSequence->rendering(rIdx);
        if (rendering && rendering->scene())
        {
            rendering->renderEngine()->enableForcedImmediateMode(enable);
        }
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
int caf::Viewer::currentFrameIndex() const
{
    if (m_animationControl)
    {
        int clampedFrameIndex = clampFrameIndex(m_animationControl->currentFrame());
        return clampedFrameIndex;
    }
    else return 0;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
bool caf::Viewer::isOverlayPaintingEnabled() const
{
    return m_isOverlayPaintingEnabled;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::enableOverlayPainting(bool val)
{
    m_isOverlayPaintingEnabled = val;
    updateOverlayImagePresence();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
cvf::Rendering* caf::Viewer::overlayItemsRendering()
{
    return m_overlayItemsRendering.p();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::updateOverlayImagePresence()
{
    if (m_isOverlayPaintingEnabled || m_showPerfInfoHud)
    {
         m_overlayItemsRendering->addOverlayItem(m_overlayImage.p());
    }
    else
    {
        m_overlayItemsRendering->removeOverlayItem(m_overlayImage.p());
    }
}

//--------------------------------------------------------------------------------------------------
/// Create a virtual method so it is possible to override this function in derived classes
//--------------------------------------------------------------------------------------------------
void caf::Viewer::navigationPolicyUpdate()
{
    update();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::addStaticModelOnce(cvf::Model* model, bool isForComparisonView)
{
    if ( !isForComparisonView )
    {
        if ( m_staticModels.contains(model) ) return;

        m_staticModels.push_back(model);
    }
    else
    {
        if ( m_comparisonStaticModels.contains(model) ) return;

        m_comparisonStaticModels.push_back(model);
    }

    appendModelToAllFrames(model, isForComparisonView);

    updateCachedValuesInScene();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::removeStaticModel(cvf::Model* model)
{
    if ( m_staticModels.contains(model) || m_comparisonStaticModels.contains(model) )
    {
        removeModelFromAllFrames(model);

        m_staticModels.erase(model);
        m_comparisonStaticModels.erase(model);

        updateCachedValuesInScene();
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::removeAllStaticModels()
{
    for (size_t i = 0; i < m_staticModels.size(); i++)
    {
        removeModelFromAllFrames(m_staticModels.at(i));
    }
    
    for (size_t i = 0; i < m_comparisonStaticModels.size(); i++)
    {
        removeModelFromAllFrames(m_comparisonStaticModels.at(i));
    }

    m_staticModels.clear();
    m_comparisonStaticModels.clear();

    updateCachedValuesInScene();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setEnableMask(unsigned int mask, bool isForComparisonView /*= false */)
{
    if (!isForComparisonView)
    {
        m_mainRendering->setEnableMask(mask);
    }
    else
    {
        m_comparisonMainRendering->setEnableMask(mask);
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::removeModelFromAllFrames(cvf::Model* model)
{
    for (size_t i = 0; i < m_frameScenes.size(); i++)
    {
        cvf::Scene* scene = m_frameScenes.at(i);

        scene->removeModel(model);
    }

    if (m_mainScene.notNull())
    {
        m_mainScene->removeModel(model);
    }

    for (size_t i = 0; i < m_comparisonFrameScenes.size(); i++)
    {
        cvf::Scene* scene = m_comparisonFrameScenes.at(i);

        scene->removeModel(model);
    }

    if (m_comparisonMainScene.notNull())
    {
        m_comparisonMainScene->removeModel(model);
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::appendModelToAllFrames(cvf::Model* model, bool isForComparisonView )
{
    if ( !isForComparisonView )
    {
        for ( size_t i = 0; i < m_frameScenes.size(); i++ )
        {
            cvf::Scene* scene = m_frameScenes.at(i);

            scene->addModel(model);
        }

        if ( m_mainScene.notNull() )
        {
            m_mainScene->addModel(model);
        }
    }
    else
    {
        for ( size_t i = 0; i < m_comparisonFrameScenes.size(); i++ )
        {
            cvf::Scene* scene = m_comparisonFrameScenes.at(i);

            scene->addModel(model);
        }

        if ( m_comparisonMainScene.notNull() )
        {
            m_comparisonMainScene->addModel(model);
        }
    }
}   

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::appendAllStaticModelsToFrame(cvf::Scene* scene, bool isForComparisonView )
{
    if (!scene) return;

    if ( !isForComparisonView )
    {
        for ( size_t i = 0; i < m_staticModels.size(); i++ )
        {
            scene->addModel(m_staticModels.at(i));
        }
    }
    else
    {
        for ( size_t i = 0; i < m_comparisonStaticModels.size(); i++ )
        {
            scene->addModel(m_comparisonStaticModels.at(i));
        }
    }
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
cvf::OverlayItem* caf::Viewer::overlayItem(int winPosX, int winPosY)
{
    if (m_overlayItemsRendering.isNull()) return nullptr;

    int translatedMousePosX = winPosX;
    int translatedMousePosY = height() - winPosY;

    return m_overlayItemsRendering->overlayItemFromWindowCoordinates(translatedMousePosX, translatedMousePosY);
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::enableParallelProjection(bool enableOrtho)
{
    if (enableOrtho && m_mainCamera->projection() == cvf::Camera::PERSPECTIVE)
    {
        cvf::Vec3d pointOfInterest;

        if (m_navigationPolicy.isNull() || !m_navigationPolicyEnabled)
        {
            using namespace cvf;

            Vec3d eye, vrp, up;
            m_mainCamera->toLookAt(&eye, &vrp, &up);

            Vec3d eyeToFocus = pointOfInterest - eye;
            Vec3d camDir = vrp - eye;
            camDir.normalize();

            double distToFocusPlane =  0.5*(m_mainCamera->farPlane() - m_mainCamera->nearPlane());
            pointOfInterest = camDir *distToFocusPlane;
        }
        else
        {
            pointOfInterest = m_navigationPolicy->pointOfInterest();
        }
        m_mainCamera->setProjectionAsOrtho(1.0, m_mainCamera->nearPlane(), m_mainCamera->farPlane());
        this->updateParallelProjectionHeightFromMoveZoom(pointOfInterest);

        // Set a fake directional light by putting the point far away from the scene
        float sceneDepth = m_mainCamera->farPlane() -  m_mainCamera->nearPlane();
        this->m_renderingSequence->setDefaultFFLightPositional(-m_parallelProjectionLightDirection* 10*sceneDepth);
        m_globalUniformSet->setHeadLightPosition(-m_parallelProjectionLightDirection* 10*sceneDepth);

        this->update();
    }
    else if (!enableOrtho && m_mainCamera->projection() == cvf::Camera::ORTHO)
    {
        // We currently expect all the navigation policies to do walk-based navigation and not fiddle with the field of view
        // so we do not need to update the camera position based on orthoHeight and fieldOfView. 
        // We assume the camera is in a sensible position.

        // Set dummy near and far plane. These will be updated by the optimize clipping planes
        m_mainCamera->setProjectionAsPerspective(m_cameraFieldOfViewYDeg, 0.1, 1.0);

        this->m_renderingSequence->setDefaultFFLightPositional(cvf::Vec3f(0.5, 5.0, 7.0));
        m_globalUniformSet->setHeadLightPosition(cvf::Vec3f(0.5, 5.0, 7.0));

        this->update();
    }
}

//--------------------------------------------------------------------------------------------------
/// Direction in camera coordinates default is (0, 0, -1) directly from behind
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setParallelProjectionHeadLightDirection(const cvf::Vec3f& direction)
{
    m_parallelProjectionLightDirection = direction;

    float sceneDepth = m_mainCamera->farPlane() -  m_mainCamera->nearPlane();
    this->m_renderingSequence->setDefaultFFLightPositional(-m_parallelProjectionLightDirection* 10*sceneDepth);
    m_globalUniformSet->setHeadLightPosition(-m_parallelProjectionLightDirection* 10*sceneDepth);

    this->update();
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setPointOfInterestVisualizer(PointOfInterestVisualizer* poiVisualizer)
{
    m_poiVisualizationManager = poiVisualizer;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------

double calculateOrthoHeight(double perspectiveViewAngleYDeg, double focusPlaneDist)
{
   return 2 * (cvf::Math::tan( cvf::Math::toRadians(0.5 * perspectiveViewAngleYDeg) ) * focusPlaneDist);
}
//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------

double calculateDistToPlaneOfOrthoHeight(double perspectiveViewAngleYDeg, double orthoHeight)
{
   return orthoHeight / (2 * (cvf::Math::tan( cvf::Math::toRadians(0.5 * perspectiveViewAngleYDeg) )));
}


//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------

double distToPlaneOfInterest(const cvf::Camera* camera, const cvf::Vec3d& pointOfInterest)
{
    using namespace cvf;
    CVF_ASSERT(camera);

    Vec3d eye, vrp, up;
    camera->toLookAt(&eye, &vrp, &up);

    Vec3d camDir = vrp - eye;
    camDir.normalize();

    Vec3d eyeToFocus = pointOfInterest - eye;
    double distToFocusPlane = eyeToFocus*camDir;

    return distToFocusPlane;
}

//--------------------------------------------------------------------------------------------------
/// Update the ortho projection view height from a walk based camera manipulation.
/// Using pointOfInterest, the perspective Y-field Of View along with the camera position
//--------------------------------------------------------------------------------------------------
void caf::Viewer::updateParallelProjectionHeightFromMoveZoom(const cvf::Vec3d& pointOfInterest)
{
    using namespace cvf;
    cvf::Camera* camera = m_mainCamera.p();

    if (!camera || camera->projection() != Camera::ORTHO) return;

    // Negative distance can occur. If so, do not set a negative ortho.

    double distToFocusPlane = cvf::Math::abs( distToPlaneOfInterest(camera, pointOfInterest));    

    double orthoHeight = calculateOrthoHeight(m_cameraFieldOfViewYDeg, distToFocusPlane);

    camera->setProjectionAsOrtho(orthoHeight, camera->nearPlane(), camera->farPlane());
}

//--------------------------------------------------------------------------------------------------
/// Update the camera eye position from point of interest, keeping the ortho height fixed and in sync 
/// with distToPlaneOfInterest  from a walk based camera manipulation in ortho projection.
//--------------------------------------------------------------------------------------------------
void caf::Viewer::updateParallelProjectionCameraPosFromPointOfInterestMove(const cvf::Vec3d& pointOfInterest)
{
    using namespace cvf;
    cvf::Camera* camera = m_mainCamera.p();

    if (!camera || camera->projection() != Camera::ORTHO) return;

    
    double orthoHeight = camera->frontPlaneFrustumHeight();
    //Trace::show(String::number(orthoHeight));

    double neededDistToFocusPlane = calculateDistToPlaneOfOrthoHeight(m_cameraFieldOfViewYDeg, orthoHeight);

    Vec3d eye, vrp, up;
    camera->toLookAt(&eye, &vrp, &up);
    Vec3d camDir = vrp - eye;
    camDir.normalize();

    double existingDistToFocusPlane = distToPlaneOfInterest(camera, pointOfInterest);

    Vec3d newEye = eye + (existingDistToFocusPlane - neededDistToFocusPlane) * camDir;

    //Trace::show(String::number(newEye.x()) + ", " + String::number(newEye.y()) + ", " +String::number(newEye.z()));
    camera->setFromLookAt(newEye, newEye + 10.0*camDir, up);

}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
int caf::Viewer::clampFrameIndex(int frameIndex) const
{
    int clampedFrameIndex = frameIndex;
    int frameCountInt = static_cast<int>(frameCount());

    if (clampedFrameIndex >= frameCountInt)
    {
        clampedFrameIndex = frameCountInt - 1;
    }
    else if (clampedFrameIndex < 0)
    {
        clampedFrameIndex = 0;
    }

    return clampedFrameIndex;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void caf::Viewer::copyCameraView(cvf::Camera* srcCamera, cvf::Camera* dstCamera)
{
    if (srcCamera->projection() == cvf::Camera::PERSPECTIVE)
    {
        dstCamera->setProjectionAsPerspective(srcCamera->fieldOfViewYDeg(), srcCamera->nearPlane(), srcCamera->farPlane());
    }
    else
    {
        dstCamera->setProjectionAsOrtho(srcCamera->frontPlaneFrustumHeight(), srcCamera->nearPlane(), srcCamera->farPlane());
    }

    dstCamera->setViewMatrix(srcCamera->viewMatrix());
}