OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #4855 from OPM/feature-screen-space-co-visualization

Browse Source 
Screen-space co-visualization
This commit is contained in:
Jacob Støren 2019-10-14 08:20:44 +02:00 committed by GitHub
commit 33bf572755
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
27 changed files with 1534 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ApplicationCode/ModelVisualization/GridBox/RivGridBoxGenerator.cpp
View File

@ -43,7 +43,8 @@ RivGridBoxGenerator::RivGridBoxGenerator()
: m_gridColor( cvf::Color3f::LIGHT_GRAY )
, m_gridLegendColor( cvf::Color3f::BLACK )
{
m_gridBoxModel = new cvf::ModelBasicList;
m_gridBoxModel = new cvf::ModelBasicList();
m_gridBoxModel->setName( "GridBoxModel" );
m_scaleZ = 1.0;
m_displayModelOffset = cvf::Vec3d::ZERO;

66
ApplicationCode/ProjectDataModel/Rim2dIntersectionView.cpp
View File

@ -184,7 +184,7 @@ bool Rim2dIntersectionView::isTimeStepDependentDataVisible() const
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::update3dInfo()
{
if ( !m_viewer ) return;
if ( !nativeOrOverrideViewer() ) return;
QString overlayInfoText;
@ -192,12 +192,12 @@ void Rim2dIntersectionView::update3dInfo()
m_intersection->firstAncestorOrThisOfType( eclView );
if ( eclView && !eclView->overlayInfoConfig()->isActive() )
{
m_viewer->showInfoText( false );
m_viewer->showHistogram( false );
m_viewer->showAnimationProgress( false );
m_viewer->showVersionInfo( false );
nativeOrOverrideViewer()->showInfoText( false );
nativeOrOverrideViewer()->showHistogram( false );
nativeOrOverrideViewer()->showAnimationProgress( false );
nativeOrOverrideViewer()->showVersionInfo( false );
m_viewer->update();
nativeOrOverrideViewer()->update();
return;
}
if ( eclView && eclView->overlayInfoConfig()->showCaseInfo() )
@ -233,11 +233,11 @@ void Rim2dIntersectionView::update3dInfo()
{
if ( eclView->overlayInfoConfig()->showAnimProgress() )
{
m_viewer->showAnimationProgress( true );
nativeOrOverrideViewer()->showAnimationProgress( true );
}
else
{
m_viewer->showAnimationProgress( false );
nativeOrOverrideViewer()->showAnimationProgress( false );
}
if ( eclView->overlayInfoConfig()->showResultInfo() )
@ -250,11 +250,11 @@ void Rim2dIntersectionView::update3dInfo()
{
if ( geoView->overlayInfoConfig()->showAnimProgress() )
{
m_viewer->showAnimationProgress( true );
nativeOrOverrideViewer()->showAnimationProgress( true );
}
else
{
m_viewer->showAnimationProgress( false );
nativeOrOverrideViewer()->showAnimationProgress( false );
}
if ( geoView->overlayInfoConfig()->showResultInfo() )
@ -296,9 +296,9 @@ void Rim2dIntersectionView::update3dInfo()
}
overlayInfoText += "</p>";
m_viewer->setInfoText( overlayInfoText );
m_viewer->showInfoText( true );
m_viewer->update();
nativeOrOverrideViewer()->setInfoText( overlayInfoText );
nativeOrOverrideViewer()->showInfoText( true );
nativeOrOverrideViewer()->update();
}
//--------------------------------------------------------------------------------------------------
@ -475,18 +475,18 @@ void Rim2dIntersectionView::axisLabels( cvf::String* xLabel, cvf::String* yLabel
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::createDisplayModel()
{
if ( m_viewer.isNull() ) return;
if ( !nativeOrOverrideViewer() ) return;
if ( !m_intersection() ) return;
updateScaleTransform();
m_viewer->removeAllFrames();
nativeOrOverrideViewer()->removeAllFrames( isUsingOverrideViewer() );
int tsCount = this->timeStepCount();
for ( int i = 0; i < tsCount; ++i )
{
m_viewer->addFrame( new cvf::Scene() );
nativeOrOverrideViewer()->addFrame( new cvf::Scene(), isUsingOverrideViewer() );
}
m_flatIntersectionPartMgr = new RivIntersectionPartMgr( m_intersection(), true );
@ -529,13 +529,13 @@ void Rim2dIntersectionView::createDisplayModel()
}
}
m_viewer->addStaticModelOnce( m_intersectionVizModel.p() );
nativeOrOverrideViewer()->addStaticModelOnce( m_intersectionVizModel.p(), isUsingOverrideViewer() );
m_intersectionVizModel->updateBoundingBoxesRecursive();
if ( this->hasUserRequestedAnimation() )
{
m_viewer->setCurrentFrame( m_currentTimeStep );
if ( viewer() ) viewer()->setCurrentFrame( m_currentTimeStep );
updateCurrentTimeStep();
}
@ -555,7 +555,7 @@ void Rim2dIntersectionView::updateCurrentTimeStep()
if ( m_flatSimWellPipePartMgr.notNull() )
{
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
{
@ -588,7 +588,7 @@ void Rim2dIntersectionView::updateCurrentTimeStep()
if ( m_flatWellpathPartMgr.notNull() )
{
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
{
@ -627,9 +627,9 @@ void Rim2dIntersectionView::updateLegends()
{
m_legendObjectToSelect = nullptr;
if ( !m_viewer ) return;
if ( !nativeOrOverrideViewer() ) return;
m_viewer->removeAllColorLegends();
nativeOrOverrideViewer()->removeAllColorLegends();
if ( !hasResults() ) return;
@ -678,7 +678,7 @@ void Rim2dIntersectionView::updateLegends()
if ( legend )
{
m_viewer->addColorLegendToBottomLeftCorner( legend );
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner( legend );
}
}
@ -687,15 +687,15 @@ void Rim2dIntersectionView::updateLegends()
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::resetLegendsInViewer()
{
m_viewer->showAxisCross( false );
m_viewer->showAnimationProgress( true );
m_viewer->showHistogram( false );
m_viewer->showInfoText( false );
m_viewer->showVersionInfo( false );
m_viewer->showEdgeTickMarksXZ( true, m_showAxisLines() );
nativeOrOverrideViewer()->showAxisCross( false );
nativeOrOverrideViewer()->showAnimationProgress( true );
nativeOrOverrideViewer()->showHistogram( false );
nativeOrOverrideViewer()->showInfoText( false );
nativeOrOverrideViewer()->showVersionInfo( false );
nativeOrOverrideViewer()->showEdgeTickMarksXZ( true, m_showAxisLines() );
m_viewer->setMainScene( new cvf::Scene() );
m_viewer->enableNavigationRotation( false );
nativeOrOverrideViewer()->setMainScene( new cvf::Scene(), isUsingOverrideViewer() );
nativeOrOverrideViewer()->enableNavigationRotation( false );
m_ternaryLegendConfig()->recreateLegend();
m_legendConfig()->recreateLegend();
@ -730,7 +730,7 @@ void Rim2dIntersectionView::updateScaleTransform()
this->scaleTransform()->setLocalTransform( scale );
if ( m_viewer ) m_viewer->updateCachedValuesInScene();
if ( nativeOrOverrideViewer() ) nativeOrOverrideViewer()->updateCachedValuesInScene();
}
//--------------------------------------------------------------------------------------------------
@ -766,7 +766,7 @@ void Rim2dIntersectionView::fieldChangedByUi( const caf::PdmFieldHandle* changed
}
else if ( changedField == &m_showAxisLines )
{
m_viewer->showEdgeTickMarksXZ( true, m_showAxisLines() );
nativeOrOverrideViewer()->showEdgeTickMarksXZ( true, m_showAxisLines() );
this->loadDataAndUpdate();
}
}

312
ApplicationCode/ProjectDataModel/Rim3dView.cpp
View File

@ -21,6 +21,7 @@
#include "RiaFieldHandleTools.h"
#include "RiaGuiApplication.h"
#include "RiaOptionItemFactory.h"
#include "RiaPreferences.h"
#include "RiaViewRedrawScheduler.h"
@ -36,6 +37,7 @@
#include "RimTools.h"
#include "RimViewController.h"
#include "RimViewLinker.h"
#include "RimViewManipulator.h"
#include "RimViewNameConfig.h"
#include "RimWellPathCollection.h"
@ -127,6 +129,16 @@ Rim3dView::Rim3dView( void )
CAF_PDM_InitField( &m_showZScaleLabel, "ShowZScale", true, "Show Z Scale Label", "", "", "" );
CAF_PDM_InitField( &m_isComparisonViewEnabled, "EnableComparisonView", false, "Enable", "", "", "" );
CAF_PDM_InitFieldNoDefault( &m_comparisonView, "ComparisonView", "Comparison View", "", "", "" );
CAF_PDM_InitField( &m_isComparisonViewLinkingTimestep,
"EnableComparisonViewTimestepLinking",
true,
"Link Timestep",
"",
"",
"" );
m_crossSectionVizModel = new cvf::ModelBasicList;
m_crossSectionVizModel->setName( "CrossSectionModel" );
@ -165,6 +177,32 @@ RiuViewer* Rim3dView::viewer() const
return m_viewer;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuViewer* Rim3dView::nativeOrOverrideViewer() const
{
if ( m_overrideViewer ) return m_overrideViewer;
return m_viewer;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim3dView::setOverrideViewer( RiuViewer* overrideViewer )
{
m_overrideViewer = overrideViewer;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool Rim3dView::isUsingOverrideViewer() const
{
return m_overrideViewer != nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -299,6 +337,11 @@ void Rim3dView::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOr
gridGroup->add( &meshMode );
gridGroup->add( &surfaceMode );
caf::PdmUiGroup* compViewGroup = uiOrdering.addNewGroup( "Comparison View" );
compViewGroup->add( &m_isComparisonViewEnabled );
compViewGroup->add( &m_comparisonView );
compViewGroup->add( &m_isComparisonViewLinkingTimestep );
uiOrdering.skipRemainingFields( true );
}
@ -345,6 +388,15 @@ void Rim3dView::setCurrentTimeStepAndUpdate( int frameIndex )
this->updateCurrentTimeStep();
if ( Rim3dView* depView = prepareComparisonView() )
{
depView->updateCurrentTimeStep();
depView->appendAnnotationsToModel();
depView->appendMeasurementToModel();
restoreComparisonView();
}
RimProject* project;
firstAncestorOrThisOfTypeAsserted( project );
project->mainPlotCollection()->updateCurrentTimeStepInPlots();
@ -353,6 +405,20 @@ void Rim3dView::setCurrentTimeStepAndUpdate( int frameIndex )
appendMeasurementToModel();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool Rim3dView::isTimeStepDependentDataVisibleInThisOrComparisonView() const
{
Rim3dView* otherView = activeComparisonView();
if ( !otherView && isUsingOverrideViewer() )
{
otherView = dynamic_cast<Rim3dView*>( nativeOrOverrideViewer()->ownerReservoirView() );
}
return ( isTimeStepDependentDataVisible() || ( otherView && otherView->isTimeStepDependentDataVisible() ) );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -387,11 +453,18 @@ void Rim3dView::updateCurrentTimeStepAndRedraw()
{
this->updateCurrentTimeStep();
if ( Rim3dView* depView = prepareComparisonView() )
{
depView->updateCurrentTimeStep();
restoreComparisonView();
}
RimProject* project;
firstAncestorOrThisOfTypeAsserted( project );
project->mainPlotCollection()->updateCurrentTimeStepInPlots();
if ( m_viewer ) m_viewer->update();
if ( nativeOrOverrideViewer() ) nativeOrOverrideViewer()->update();
}
//--------------------------------------------------------------------------------------------------
@ -399,10 +472,12 @@ void Rim3dView::updateCurrentTimeStepAndRedraw()
//--------------------------------------------------------------------------------------------------
void Rim3dView::createDisplayModelAndRedraw()
{
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
this->clampCurrentTimestep();
updateScaleTransform();
createDisplayModel();
createHighlightAndGridBoxDisplayModel();
updateDisplayModelVisibility();
@ -410,8 +485,32 @@ void Rim3dView::createDisplayModelAndRedraw()
if ( m_cameraPosition().isIdentity() )
{
setDefaultView();
m_cameraPosition = m_viewer->mainCamera()->viewMatrix();
m_cameraPointOfInterest = m_viewer->pointOfInterest();
m_cameraPosition = nativeOrOverrideViewer()->mainCamera()->viewMatrix();
m_cameraPointOfInterest = nativeOrOverrideViewer()->pointOfInterest();
}
if ( Rim3dView* depView = prepareComparisonView() )
{
depView->createDisplayModelAndRedraw();
if ( isTimeStepDependentDataVisibleInThisOrComparisonView() )
{
// To make the override viewer see the new frame (skeletons) created by createDisplayModelAndRedraw
// But avoid any call back down to this Rim3dView, instead do the update manually to not confuse the
// m_currentTimeStep
nativeOrOverrideViewer()->caf::Viewer::slotSetCurrentFrame( currentTimeStep() );
depView->updateCurrentTimeStep();
}
restoreComparisonView();
}
else if ( !isUsingOverrideViewer() && viewer() )
{
// Remove the comparison scene data when
// we do not have a comparison view
// and are not doing override generation
viewer()->setMainScene( nullptr, true );
viewer()->removeAllFrames( true );
}
}
@ -662,6 +761,24 @@ void Rim3dView::fieldChangedByUi( const caf::PdmFieldHandle* changedField,
m_viewer->showZScaleLabel( m_showZScaleLabel() );
m_viewer->update();
}
else if ( changedField == &m_isComparisonViewEnabled )
{
createDisplayModelAndRedraw();
}
else if ( changedField == &m_comparisonView )
{
if ( m_isComparisonViewEnabled() )
{
createDisplayModelAndRedraw();
}
}
else if ( changedField == &m_isComparisonViewLinkingTimestep )
{
if ( m_isComparisonViewEnabled() && m_comparisonView() )
{
createDisplayModelAndRedraw();
}
}
}
//--------------------------------------------------------------------------------------------------
@ -743,7 +860,7 @@ void Rim3dView::addMeasurementToModel( cvf::ModelBasicList* wellPathModelBasicLi
else
{
cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
m_measurementPartManager->appendGeometryPartsToModel( m_viewer->mainCamera(),
m_measurementPartManager->appendGeometryPartsToModel( nativeOrOverrideViewer()->mainCamera(),
wellPathModelBasicList,
transForm.p(),
ownerCase()->allCellsBoundingBox() );
@ -784,13 +901,34 @@ bool Rim3dView::isMasterView() const
//--------------------------------------------------------------------------------------------------
void Rim3dView::updateGridBoxData()
{
if ( m_viewer && ownerCase() )
if ( viewer() && ownerCase() )
{
m_viewer->updateGridBoxData( scaleZ(),
ownerCase()->displayModelOffset(),
backgroundColor(),
showActiveCellsOnly() ? ownerCase()->activeCellsBoundingBox()
: ownerCase()->allCellsBoundingBox() );
using BBox = cvf::BoundingBox;
BBox masterDomainBBox = showActiveCellsOnly() ? ownerCase()->activeCellsBoundingBox()
: ownerCase()->allCellsBoundingBox();
BBox combinedDomainBBox = masterDomainBBox;
if ( Rim3dView* depView = activeComparisonView() )
{
viewer()->setComparisonViewEyePointOffset(
RimViewManipulator::calculateEquivalentCamPosOffset( this, depView ) );
RimCase* destinationOwnerCase = depView->ownerCase();
if ( destinationOwnerCase )
{
BBox depDomainBBox = depView->showActiveCellsOnly() ? destinationOwnerCase->activeCellsBoundingBox()
: destinationOwnerCase->allCellsBoundingBox();
if ( depDomainBBox.isValid() )
{
combinedDomainBBox.add( depDomainBBox.min() );
combinedDomainBBox.add( depDomainBBox.max() );
}
}
}
viewer()->updateGridBoxData( scaleZ(), ownerCase()->displayModelOffset(), backgroundColor(), combinedDomainBBox );
}
}
@ -799,9 +937,9 @@ void Rim3dView::updateGridBoxData()
//--------------------------------------------------------------------------------------------------
void Rim3dView::updateAnnotationItems()
{
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
m_viewer->updateAnnotationItems();
nativeOrOverrideViewer()->updateAnnotationItems();
}
}
@ -812,26 +950,24 @@ void Rim3dView::updateScaling()
{
if ( scaleZ < 1 ) scaleZ = 1;
this->updateGridBoxData();
if ( m_viewer )
if ( viewer() )
{
cvf::Vec3d poi = m_viewer->pointOfInterest();
cvf::Vec3d poi = viewer()->pointOfInterest();
cvf::Vec3d eye, dir, up;
eye = m_viewer->mainCamera()->position();
dir = m_viewer->mainCamera()->direction();
up = m_viewer->mainCamera()->up();
eye = viewer()->mainCamera()->position();
dir = viewer()->mainCamera()->direction();
up = viewer()->mainCamera()->up();
eye[2] = poi[2] * scaleZ() / this->scaleTransform()->worldTransform()( 2, 2 ) + ( eye[2] - poi[2] );
poi[2] = poi[2] * scaleZ() / this->scaleTransform()->worldTransform()( 2, 2 );
m_viewer->mainCamera()->setFromLookAt( eye, eye + dir, up );
m_viewer->setPointOfInterest( poi );
viewer()->mainCamera()->setFromLookAt( eye, eye + dir, up );
viewer()->setPointOfInterest( poi );
updateScaleTransform();
createDisplayModelAndRedraw();
m_viewer->update();
viewer()->update();
updateZScaleLabel();
}
@ -844,7 +980,7 @@ void Rim3dView::updateZScaleLabel()
{
// Update Z scale label
int scale = static_cast<int>( scaleZ() );
m_viewer->setZScale( scale );
nativeOrOverrideViewer()->setZScale( scale );
}
//--------------------------------------------------------------------------------------------------
@ -855,7 +991,7 @@ void Rim3dView::updateMeasurement()
if ( m_viewer )
{
appendMeasurementToModel();
m_viewer->update();
nativeOrOverrideViewer()->update();
}
}
@ -866,9 +1002,9 @@ void Rim3dView::createHighlightAndGridBoxDisplayModelWithRedraw()
{
createHighlightAndGridBoxDisplayModel();
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
m_viewer->update();
nativeOrOverrideViewer()->update();
}
}
@ -877,7 +1013,9 @@ void Rim3dView::createHighlightAndGridBoxDisplayModelWithRedraw()
//--------------------------------------------------------------------------------------------------
void Rim3dView::createHighlightAndGridBoxDisplayModel()
{
m_viewer->removeStaticModel( m_highlightVizModel.p() );
if ( !nativeOrOverrideViewer() ) return;
nativeOrOverrideViewer()->removeStaticModel( m_highlightVizModel.p() );
m_highlightVizModel->removeAllParts();
@ -891,10 +1029,12 @@ void Rim3dView::createHighlightAndGridBoxDisplayModel()
}
m_highlightVizModel->updateBoundingBoxesRecursive();
m_viewer->addStaticModelOnce( m_highlightVizModel.p() );
nativeOrOverrideViewer()->addStaticModelOnce( m_highlightVizModel.p(), isUsingOverrideViewer() );
}
m_viewer->showGridBox( m_showGridBox() );
this->updateGridBoxData();
if ( viewer() ) viewer()->showGridBox( m_showGridBox() );
}
//--------------------------------------------------------------------------------------------------
@ -918,10 +1058,10 @@ void Rim3dView::setShowGridBox( bool showGridBox )
//--------------------------------------------------------------------------------------------------
void Rim3dView::applyBackgroundColorAndFontChanges()
{
if ( m_viewer != nullptr )
if ( viewer() != nullptr )
{
m_viewer->mainCamera()->viewport()->setClearColor( cvf::Color4f( backgroundColor() ) );
m_viewer->updateFonts();
viewer()->mainCamera()->viewport()->setClearColor( cvf::Color4f( backgroundColor() ) );
viewer()->updateFonts();
}
updateGridBoxData();
updateAnnotationItems();
@ -941,7 +1081,7 @@ void Rim3dView::performAutoNameUpdate()
//--------------------------------------------------------------------------------------------------
void Rim3dView::updateDisplayModelVisibility()
{
if ( m_viewer.isNull() ) return;
if ( viewer() == nullptr || isUsingOverrideViewer() ) return;
const cvf::uint uintSurfaceBit = surfaceBit;
const cvf::uint uintMeshSurfaceBit = meshSurfaceBit;
@ -982,8 +1122,10 @@ void Rim3dView::updateDisplayModelVisibility()
mask |= intersectionFaultMeshBit;
}
m_viewer->setEnableMask( mask );
m_viewer->update();
viewer()->setEnableMask( mask, false );
viewer()->setEnableMask( mask, true );
viewer()->update();
}
//--------------------------------------------------------------------------------------------------
@ -1048,6 +1190,37 @@ bool Rim3dView::applyFontSize( RiaDefines::FontSettingType fontSettingType,
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> Rim3dView::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions,
bool* useOptionsOnly )
{
QList<caf::PdmOptionItemInfo> options;
if ( fieldNeedingOptions == &m_comparisonView )
{
RimProject* proj;
this->firstAncestorOrThisOfType( proj );
if ( proj )
{
std::vector<Rim3dView*> views;
proj->allViews( views );
for ( auto view : views )
{
if ( view != this ) RiaOptionItemFactory::appendOptionItemFromViewNameAndCaseName( view, &options );
}
if ( !options.empty() )
{
options.push_front( caf::PdmOptionItemInfo( "None", nullptr ) );
}
}
}
return options;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -1132,9 +1305,9 @@ void Rim3dView::setMdiWindowGeometry( const RimMdiWindowGeometry& windowGeometry
//--------------------------------------------------------------------------------------------------
void Rim3dView::appendAnnotationsToModel()
{
if ( !m_viewer ) return;
if ( !nativeOrOverrideViewer() ) return;
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
cvf::String name = "Annotations";
@ -1154,9 +1327,9 @@ void Rim3dView::appendAnnotationsToModel()
//--------------------------------------------------------------------------------------------------
void Rim3dView::appendMeasurementToModel()
{
if ( !m_viewer ) return;
if ( !nativeOrOverrideViewer() ) return;
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
cvf::String name = "Measurement";
@ -1170,3 +1343,62 @@ void Rim3dView::appendMeasurementToModel()
frameScene->addModel( model.p() );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim3dView* Rim3dView::activeComparisonView() const
{
if ( m_isComparisonViewEnabled() )
{
return m_comparisonView();
}
else
{
return nullptr;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim3dView* Rim3dView::prepareComparisonView()
{
Rim3dView* depView = activeComparisonView();
if ( !depView )
{
return nullptr;
}
if (isUsingOverrideViewer())
{
return nullptr;
}
m_comparisonViewOrgTimestep = depView->currentTimeStep();
depView->m_currentTimeStep = currentTimeStep();
depView->clampCurrentTimestep();
m_comparisonViewOrgZScale = depView->scaleZ();
depView->scaleZ = scaleZ();
viewer()->setComparisonViewEyePointOffset( RimViewManipulator::calculateEquivalentCamPosOffset( this, depView ) );
depView->setOverrideViewer( viewer() );
return depView;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim3dView::restoreComparisonView()
{
Rim3dView* depView = activeComparisonView();
CVF_ASSERT( depView );
depView->setOverrideViewer( nullptr );
depView->m_currentTimeStep = m_comparisonViewOrgTimestep;
depView->scaleZ = m_comparisonViewOrgZScale;
}

54
ApplicationCode/ProjectDataModel/Rim3dView.h
View File

@ -28,6 +28,7 @@
#include "cafAppEnum.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmPtrField.h"
#include "cafPdmFieldCvfColor.h"
#include "cafPdmFieldCvfMat4d.h"
@ -145,6 +146,7 @@ public:
}
void setCurrentTimeStep( int frameIdx );
void setCurrentTimeStepAndUpdate( int frameIdx ) override;
bool isTimeStepDependentDataVisibleInThisOrComparisonView() const;
virtual bool isTimeStepDependentDataVisible() const = 0;
// Updating
@ -172,6 +174,9 @@ public:
int fontSize,
bool forceChange = false ) override;
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions,
bool* useOptionsOnly ) override;
protected:
static void removeModelByName( cvf::Scene* scene, const cvf::String& modelName );
@ -193,7 +198,10 @@ protected:
void addAnnotationsToModel( cvf::ModelBasicList* wellPathModelBasicList );
void addMeasurementToModel( cvf::ModelBasicList* wellPathModelBasicList );
void createHighlightAndGridBoxDisplayModel();
// Override viewer
RiuViewer* nativeOrOverrideViewer() const;
bool isUsingOverrideViewer() const;
// Implementation of RimNameConfigHolderInterface
void performAutoNameUpdate() override;
@ -202,15 +210,14 @@ protected:
virtual void axisLabels( cvf::String* xLabel, cvf::String* yLabel, cvf::String* zLabel ) = 0;
virtual void createDisplayModel() = 0;
virtual void createPartCollectionFromSelection( cvf::Collection<cvf::Part>* parts ) = 0;
virtual void createDisplayModel() = 0;
virtual void updateDisplayModelVisibility();
virtual void clampCurrentTimestep() = 0;
virtual void clampCurrentTimestep() = 0;
virtual void updateCurrentTimeStep() = 0;
virtual void onTimeStepChanged() = 0;
virtual void updateCurrentTimeStep() = 0;
virtual void onTimeStepChanged() = 0;
virtual void updateStaticCellColors() = 0;
virtual void createPartCollectionFromSelection( cvf::Collection<cvf::Part>* parts ) = 0;
virtual void updateStaticCellColors() = 0;
virtual void updateScaleTransform() = 0;
virtual cvf::Transform* scaleTransform() = 0;
@ -221,8 +228,6 @@ protected: // Fields
caf::PdmField<int> m_currentTimeStep;
protected:
QPointer<RiuViewer> m_viewer;
cvf::ref<cvf::ModelBasicList> m_wellPathPipeVizModel;
cvf::ref<cvf::ModelBasicList> m_crossSectionVizModel;
cvf::ref<cvf::ModelBasicList> m_highlightVizModel;
@ -263,22 +268,44 @@ private:
{
m_cameraPosition = cameraPosition;
}
void setCameraPointOfInterest( const cvf::Vec3d& cameraPointOfInterest ) override
{
m_cameraPointOfInterest = cameraPointOfInterest;
}
QString timeStepName( int frameIdx ) const override;
void endAnimation() override;
QString timeStepName( int frameIdx ) const override;
void endAnimation() override;
caf::PdmObjectHandle* implementingPdmObject() override
{
return this;
}
void handleMdiWindowClosed() override;
void setMdiWindowGeometry( const RimMdiWindowGeometry& windowGeometry ) override;
// Pure private methods
void createHighlightAndGridBoxDisplayModel();
void appendAnnotationsToModel();
void appendMeasurementToModel();
// Pure private methods : Override viewer and comparison view
void setOverrideViewer( RiuViewer* overrideViewer );
Rim3dView* activeComparisonView() const;
Rim3dView* prepareComparisonView();
void restoreComparisonView();
private:
QPointer<RiuViewer> m_viewer;
QPointer<RiuViewer> m_overrideViewer;
int m_comparisonViewOrgTimestep;
double m_comparisonViewOrgZScale;
caf::PdmField<QString> m_name_OBSOLETE;
caf::PdmChildField<RimViewNameConfig*> m_nameConfig;
caf::PdmField<bool> m_disableLighting;
@ -287,4 +314,7 @@ private:
caf::PdmField<cvf::Color3f> m_backgroundColor;
caf::PdmField<bool> m_showGridBox;
caf::PdmField<bool> m_showZScaleLabel;
caf::PdmField<bool> m_isComparisonViewEnabled;
caf::PdmPtrField<Rim3dView*> m_comparisonView;
caf::PdmField<bool> m_isComparisonViewLinkingTimestep;
};

47
ApplicationCode/ProjectDataModel/RimEclipseContourMapView.cpp
View File

@ -140,9 +140,9 @@ void RimEclipseContourMapView::setDefaultCustomName()
void RimEclipseContourMapView::updatePickPointAndRedraw()
{
appendPickPointVisToModel();
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
m_viewer->update();
nativeOrOverrideViewer()->update();
}
}
@ -285,7 +285,7 @@ void RimEclipseContourMapView::setFaultVisParameters()
//--------------------------------------------------------------------------------------------------
void RimEclipseContourMapView::createContourMapGeometry()
{
if ( m_viewer && m_contourMapProjection->isChecked() )
if ( nativeOrOverrideViewer() && m_contourMapProjection->isChecked() )
{
m_contourMapProjectionPartMgr->createProjectionGeometry();
}
@ -296,9 +296,9 @@ void RimEclipseContourMapView::createContourMapGeometry()
//--------------------------------------------------------------------------------------------------
void RimEclipseContourMapView::appendContourMapProjectionToModel()
{
if ( m_viewer && m_contourMapProjection->isChecked() )
if ( nativeOrOverrideViewer() && m_contourMapProjection->isChecked() )
{
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
cvf::String name = "ContourMapProjection";
@ -322,9 +322,9 @@ void RimEclipseContourMapView::appendContourMapProjectionToModel()
//--------------------------------------------------------------------------------------------------
void RimEclipseContourMapView::appendContourLinesToModel()
{
if ( m_viewer && m_contourMapProjection->isChecked() )
if ( nativeOrOverrideViewer() && m_contourMapProjection->isChecked() )
{
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
cvf::String name = "ContourMapLines";
@ -349,9 +349,9 @@ void RimEclipseContourMapView::appendContourLinesToModel()
//--------------------------------------------------------------------------------------------------
void RimEclipseContourMapView::appendPickPointVisToModel()
{
if ( m_viewer && m_contourMapProjection->isChecked() )
if ( nativeOrOverrideViewer() && m_contourMapProjection->isChecked() )
{
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
cvf::String name = "ContourMapPickPoint";
@ -375,9 +375,16 @@ void RimEclipseContourMapView::appendPickPointVisToModel()
//--------------------------------------------------------------------------------------------------
void RimEclipseContourMapView::updateLegends()
{
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
m_viewer->removeAllColorLegends();
if ( !isUsingOverrideViewer() )
{
nativeOrOverrideViewer()->removeAllColorLegends();
}
else if ( m_contourMapProjection && m_contourMapProjection->legendConfig() )
{
nativeOrOverrideViewer()->removeColorLegend( m_contourMapProjection->legendConfig()->titledOverlayFrame() );
}
if ( m_contourMapProjection && m_contourMapProjection->isChecked() )
{
@ -387,12 +394,12 @@ void RimEclipseContourMapView::updateLegends()
m_contourMapProjection->updateLegend();
if ( projectionLegend->showLegend() )
{
m_viewer->addColorLegendToBottomLeftCorner( projectionLegend->titledOverlayFrame() );
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner( projectionLegend->titledOverlayFrame() );
}
}
}
m_viewer->showScaleLegend( m_showScaleLegend() );
nativeOrOverrideViewer()->showScaleLegend( m_showScaleLegend() );
}
}
@ -401,11 +408,11 @@ void RimEclipseContourMapView::updateLegends()
//--------------------------------------------------------------------------------------------------
void RimEclipseContourMapView::updateViewWidgetAfterCreation()
{
if ( m_viewer )
if ( viewer() )
{
m_viewer->showAxisCross( false );
m_viewer->showEdgeTickMarksXY( true, m_showAxisLines() );
m_viewer->enableNavigationRotation( false );
viewer()->showAxisCross( false );
viewer()->showEdgeTickMarksXY( true, m_showAxisLines() );
viewer()->enableNavigationRotation( false );
}
Rim3dView::updateViewWidgetAfterCreation();
@ -426,9 +433,9 @@ void RimEclipseContourMapView::updateViewFollowingRangeFilterUpdates()
void RimEclipseContourMapView::onLoadDataAndUpdate()
{
RimEclipseView::onLoadDataAndUpdate();
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
m_viewer->setView( cvf::Vec3d( 0, 0, -1 ), cvf::Vec3d( 0, 1, 0 ) );
nativeOrOverrideViewer()->setView( cvf::Vec3d( 0, 0, -1 ), cvf::Vec3d( 0, 1, 0 ) );
}
}
@ -443,7 +450,7 @@ void RimEclipseContourMapView::fieldChangedByUi( const caf::PdmFieldHandle* chan
if ( changedField == &m_showAxisLines )
{
m_viewer->showEdgeTickMarksXY( true, m_showAxisLines() );
viewer()->showEdgeTickMarksXY( true, m_showAxisLines() );
scheduleCreateDisplayModelAndRedraw();
}
else if ( changedField == backgroundColorField() )

71
ApplicationCode/ProjectDataModel/RimEclipseView.cpp
View File

@ -338,7 +338,7 @@ void RimEclipseView::updateScaleTransform()
this->scaleTransform()->setLocalTransform( scale );
m_simWellsPartManager->setScaleTransform( this->scaleTransform() );
if ( m_viewer ) m_viewer->updateCachedValuesInScene();
if ( nativeOrOverrideViewer() ) nativeOrOverrideViewer()->updateCachedValuesInScene();
}
//--------------------------------------------------------------------------------------------------
@ -350,7 +350,7 @@ void RimEclipseView::createDisplayModel()
{
clearReservoirCellVisibilities();
if ( m_viewer.isNull() ) return;
if ( nativeOrOverrideViewer() == nullptr ) return;
#if 0 // Debug info
static int callCount = 0;
@ -369,7 +369,7 @@ void RimEclipseView::createDisplayModel()
// Find the number of time frames the animation needs to show the requested data.
if ( isTimeStepDependentDataVisible() && currentGridCellResults()->maxTimeStepCount() > 0 )
if ( ( isTimeStepDependentDataVisibleInThisOrComparisonView() && currentGridCellResults()->maxTimeStepCount() > 0 ) )
{
CVF_ASSERT( currentGridCellResults() );
@ -395,7 +395,7 @@ void RimEclipseView::createDisplayModel()
// Remove all existing animation frames from the viewer.
// The parts are still cached in the RivReservoir geometry and friends
m_viewer->removeAllFrames();
nativeOrOverrideViewer()->removeAllFrames( isUsingOverrideViewer() );
wellCollection()->scheduleIsWellPipesVisibleRecalculation();
@ -517,7 +517,7 @@ void RimEclipseView::createDisplayModel()
m_crossSectionCollection->appendPartsToModel( *this,
m_crossSectionVizModel.p(),
m_reservoirGridPartManager->scaleTransform() );
m_viewer->addStaticModelOnce( m_crossSectionVizModel.p() );
nativeOrOverrideViewer()->addStaticModelOnce( m_crossSectionVizModel.p(), isUsingOverrideViewer() );
// Well path model
@ -532,7 +532,7 @@ void RimEclipseView::createDisplayModel()
m_wellPathsPartManager->appendStaticFracturePartsToModel( m_wellPathPipeVizModel.p(),
currentActiveCellInfo()->geometryBoundingBox() );
m_wellPathPipeVizModel->updateBoundingBoxesRecursive();
m_viewer->addStaticModelOnce( m_wellPathPipeVizModel.p() );
nativeOrOverrideViewer()->addStaticModelOnce( m_wellPathPipeVizModel.p(), isUsingOverrideViewer() );
// Create Scenes from the frameModels
// Animation frames for results display, starts from frame 1
@ -547,16 +547,16 @@ void RimEclipseView::createDisplayModel()
scene->addModel( model );
if ( frameIndex == 0 )
m_viewer->setMainScene( scene.p() );
nativeOrOverrideViewer()->setMainScene( scene.p(), isUsingOverrideViewer() );
else
m_viewer->addFrame( scene.p() );
nativeOrOverrideViewer()->addFrame( scene.p(), isUsingOverrideViewer() );
}
// If the animation was active before recreating everything, make viewer view current frame
if ( frameModels.size() > 1 && this->hasUserRequestedAnimation() )
{
m_viewer->setCurrentFrame( m_currentTimeStep );
if ( viewer() && !isUsingOverrideViewer() ) viewer()->setCurrentFrame( m_currentTimeStep );
}
else
{
@ -716,9 +716,9 @@ void RimEclipseView::updateVisibleGeometriesAndCellColors()
}
}
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
this->removeModelByName( frameScene, frameParts->name() );
@ -792,9 +792,9 @@ void RimEclipseView::updateVisibleGeometriesAndCellColors()
//--------------------------------------------------------------------------------------------------
void RimEclipseView::appendWellsAndFracturesToModel()
{
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
// Simulation Wells
@ -1161,12 +1161,28 @@ std::vector<size_t> RimEclipseView::indicesToVisibleGrids() const
//--------------------------------------------------------------------------------------------------
void RimEclipseView::updateLegends()
{
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
m_viewer->removeAllColorLegends();
if ( !isUsingOverrideViewer() )
{
nativeOrOverrideViewer()->removeAllColorLegends();
}
else
{
nativeOrOverrideViewer()->removeColorLegend( this->cellEdgeResult()->legendConfig()->titledOverlayFrame() );
nativeOrOverrideViewer()->removeColorLegend( fractureColors()->activeLegend()->titledOverlayFrame() );
nativeOrOverrideViewer()->removeColorLegend(
m_virtualPerforationResult->legendConfig()->titledOverlayFrame() );
nativeOrOverrideViewer()->removeColorLegend( this->cellResult()->legendConfig()->titledOverlayFrame() );
nativeOrOverrideViewer()->removeColorLegend( this->cellResult()->ternaryLegendConfig()->titledOverlayFrame() );
nativeOrOverrideViewer()->removeColorLegend(
this->currentFaultResultColors()->legendConfig()->titledOverlayFrame() );
nativeOrOverrideViewer()->removeColorLegend(
this->currentFaultResultColors()->ternaryLegendConfig()->titledOverlayFrame() );
}
}
if ( !m_eclipseCase || !m_viewer || !m_eclipseCase->eclipseCaseData() )
if ( !m_eclipseCase || !nativeOrOverrideViewer() || !m_eclipseCase->eclipseCaseData() )
{
return;
}
@ -1222,7 +1238,8 @@ void RimEclipseView::updateLegends()
this->cellEdgeResult()->legendConfig()->setTitle( QString( "Edge Results: \n" ) +
this->cellEdgeResult()->resultVariableUiShortName() );
m_viewer->addColorLegendToBottomLeftCorner( this->cellEdgeResult()->legendConfig()->titledOverlayFrame() );
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner(
this->cellEdgeResult()->legendConfig()->titledOverlayFrame() );
}
else
{
@ -1255,7 +1272,7 @@ void RimEclipseView::updateLegends()
if ( fractureColors()->isChecked() && stimPlanLegend->titledOverlayFrame() )
{
m_viewer->addColorLegendToBottomLeftCorner( stimPlanLegend->titledOverlayFrame() );
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner( stimPlanLegend->titledOverlayFrame() );
}
}
}
@ -1266,7 +1283,7 @@ void RimEclipseView::updateLegends()
updateVirtualConnectionLegendRanges();
RimRegularLegendConfig* virtLegend = m_virtualPerforationResult->legendConfig();
m_viewer->addColorLegendToBottomLeftCorner( virtLegend->titledOverlayFrame() );
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner( virtLegend->titledOverlayFrame() );
}
}
@ -1296,7 +1313,7 @@ void RimEclipseView::updateMinMaxValuesAndAddLegendToView( QString
}
resultColors->legendConfig()->setTitle( title );
m_viewer->addColorLegendToBottomLeftCorner( resultColors->legendConfig()->titledOverlayFrame() );
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner( resultColors->legendConfig()->titledOverlayFrame() );
}
size_t maxTimeStepCount = cellResultsData->maxTimeStepCount();
@ -1306,7 +1323,8 @@ void RimEclipseView::updateMinMaxValuesAndAddLegendToView( QString
resultColors->ternaryLegendConfig()->titledOverlayFrame() )
{
resultColors->ternaryLegendConfig()->setTitle( legendLabel );
m_viewer->addColorLegendToBottomLeftCorner( resultColors->ternaryLegendConfig()->titledOverlayFrame() );
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner(
resultColors->ternaryLegendConfig()->titledOverlayFrame() );
}
}
}
@ -1549,9 +1567,9 @@ void RimEclipseView::updateDisplayModelForWellResults()
createDisplayModel();
updateDisplayModelVisibility();
if ( hasUserRequestedAnimation() && m_viewer )
if ( hasUserRequestedAnimation() && nativeOrOverrideViewer() )
{
m_viewer->animationControl()->setCurrentFrame( m_currentTimeStep );
nativeOrOverrideViewer()->animationControl()->setCurrentFrame( m_currentTimeStep );
}
RiuMainWindow::instance()->refreshAnimationActions();
@ -1815,14 +1833,15 @@ void RimEclipseView::resetLegendsInViewer()
this->cellResult()->ternaryLegendConfig()->recreateLegend();
this->cellEdgeResult()->legendConfig()->recreateLegend();
m_viewer->removeAllColorLegends();
nativeOrOverrideViewer()->removeAllColorLegends();
if ( cellResultNormalLegendConfig )
{
m_viewer->addColorLegendToBottomLeftCorner( cellResultNormalLegendConfig->titledOverlayFrame() );
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner( cellResultNormalLegendConfig->titledOverlayFrame() );
}
m_viewer->addColorLegendToBottomLeftCorner( this->cellEdgeResult()->legendConfig()->titledOverlayFrame() );
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner(
this->cellEdgeResult()->legendConfig()->titledOverlayFrame() );
}
//--------------------------------------------------------------------------------------------------

47
ApplicationCode/ProjectDataModel/RimGeoMechContourMapView.cpp
View File

@ -136,9 +136,9 @@ void RimGeoMechContourMapView::setDefaultCustomName()
void RimGeoMechContourMapView::updatePickPointAndRedraw()
{
appendPickPointVisToModel();
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
m_viewer->update();
nativeOrOverrideViewer()->update();
}
}
@ -278,7 +278,7 @@ void RimGeoMechContourMapView::updateGeometry()
//--------------------------------------------------------------------------------------------------
void RimGeoMechContourMapView::createContourMapGeometry()
{
if ( m_viewer && m_contourMapProjection->isChecked() )
if ( nativeOrOverrideViewer() && m_contourMapProjection->isChecked() )
{
m_contourMapProjectionPartMgr->createProjectionGeometry();
}
@ -289,9 +289,9 @@ void RimGeoMechContourMapView::createContourMapGeometry()
//--------------------------------------------------------------------------------------------------
void RimGeoMechContourMapView::appendContourMapProjectionToModel()
{
if ( m_viewer && m_contourMapProjection->isChecked() )
if ( nativeOrOverrideViewer() && m_contourMapProjection->isChecked() )
{
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
cvf::String name = "ContourMapProjection";
@ -315,9 +315,9 @@ void RimGeoMechContourMapView::appendContourMapProjectionToModel()
//--------------------------------------------------------------------------------------------------
void RimGeoMechContourMapView::appendContourLinesToModel()
{
if ( m_viewer && m_contourMapProjection->isChecked() )
if ( nativeOrOverrideViewer() && m_contourMapProjection->isChecked() )
{
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
cvf::String name = "ContourMapLines";
@ -342,9 +342,9 @@ void RimGeoMechContourMapView::appendContourLinesToModel()
//--------------------------------------------------------------------------------------------------
void RimGeoMechContourMapView::appendPickPointVisToModel()
{
if ( m_viewer && m_contourMapProjection->isChecked() )
if ( nativeOrOverrideViewer() && m_contourMapProjection->isChecked() )
{
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
cvf::String name = "ContourMapPickPoint";
@ -368,9 +368,16 @@ void RimGeoMechContourMapView::appendPickPointVisToModel()
//--------------------------------------------------------------------------------------------------
void RimGeoMechContourMapView::updateLegends()
{
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
m_viewer->removeAllColorLegends();
if ( !isUsingOverrideViewer() )
{
nativeOrOverrideViewer()->removeAllColorLegends();
}
else if ( m_contourMapProjection && m_contourMapProjection->legendConfig() )
{
nativeOrOverrideViewer()->removeColorLegend( m_contourMapProjection->legendConfig()->titledOverlayFrame() );
}
if ( m_contourMapProjection && m_contourMapProjection->isChecked() )
{
@ -380,12 +387,12 @@ void RimGeoMechContourMapView::updateLegends()
m_contourMapProjection->updateLegend();
if ( projectionLegend->showLegend() )
{
m_viewer->addColorLegendToBottomLeftCorner( projectionLegend->titledOverlayFrame() );
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner( projectionLegend->titledOverlayFrame() );
}
}
}
m_viewer->showScaleLegend( m_showScaleLegend() );
nativeOrOverrideViewer()->showScaleLegend( m_showScaleLegend() );
}
}
@ -394,11 +401,11 @@ void RimGeoMechContourMapView::updateLegends()
//--------------------------------------------------------------------------------------------------
void RimGeoMechContourMapView::updateViewWidgetAfterCreation()
{
if ( m_viewer )
if ( viewer() )
{
m_viewer->showAxisCross( false );
m_viewer->showEdgeTickMarksXY( true, m_showAxisLines() );
m_viewer->enableNavigationRotation( false );
viewer()->showAxisCross( false );
viewer()->showEdgeTickMarksXY( true, m_showAxisLines() );
viewer()->enableNavigationRotation( false );
}
Rim3dView::updateViewWidgetAfterCreation();
@ -419,9 +426,9 @@ void RimGeoMechContourMapView::updateViewFollowingRangeFilterUpdates()
void RimGeoMechContourMapView::onLoadDataAndUpdate()
{
RimGeoMechView::onLoadDataAndUpdate();
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
m_viewer->setView( cvf::Vec3d( 0, 0, -1 ), cvf::Vec3d( 0, 1, 0 ) );
nativeOrOverrideViewer()->setView( cvf::Vec3d( 0, 0, -1 ), cvf::Vec3d( 0, 1, 0 ) );
}
}
@ -436,7 +443,7 @@ void RimGeoMechContourMapView::fieldChangedByUi( const caf::PdmFieldHandle* chan
if ( changedField == &m_showAxisLines )
{
m_viewer->showEdgeTickMarksXY( true, m_showAxisLines() );
viewer()->showEdgeTickMarksXY( true, m_showAxisLines() );
scheduleCreateDisplayModelAndRedraw();
}
else if ( changedField == backgroundColorField() )

60
ApplicationCode/ProjectDataModel/RimGeoMechView.cpp
View File

@ -188,7 +188,7 @@ void RimGeoMechView::updateScaleTransform()
this->scaleTransform()->setLocalTransform( scale );
if ( m_viewer ) m_viewer->updateCachedValuesInScene();
if ( nativeOrOverrideViewer() ) nativeOrOverrideViewer()->updateCachedValuesInScene();
}
//--------------------------------------------------------------------------------------------------
@ -233,7 +233,7 @@ QString RimGeoMechView::createAutoName() const
//--------------------------------------------------------------------------------------------------
void RimGeoMechView::createDisplayModel()
{
if ( m_viewer.isNull() ) return;
if ( nativeOrOverrideViewer() == nullptr ) return;
if ( !( m_geomechCase && m_geomechCase->geoMechData() && m_geomechCase->geoMechData()->femParts() ) ) return;
@ -244,25 +244,26 @@ void RimGeoMechView::createDisplayModel()
// Remove all existing animation frames from the viewer.
// The parts are still cached in the RivReservoir geometry and friends
m_viewer->removeAllFrames();
nativeOrOverrideViewer()->removeAllFrames( isUsingOverrideViewer() );
if ( isTimeStepDependentDataVisible() )
if ( isTimeStepDependentDataVisibleInThisOrComparisonView() )
{
// Create empty frames in the viewer
int frameCount = geoMechCase()->geoMechData()->femPartResults()->frameCount();
for ( int frameIndex = 0; frameIndex < frameCount; frameIndex++ )
{
cvf::ref<cvf::Scene> scene = new cvf::Scene;
scene->addModel( new cvf::ModelBasicList );
m_viewer->addFrame( scene.p() );
cvf::ref<cvf::Scene> scene = new cvf::Scene;
cvf::ref<cvf::ModelBasicList> emptyModel = new cvf::ModelBasicList;
emptyModel->setName( "EmptyModel" );
scene->addModel( emptyModel.p() );
nativeOrOverrideViewer()->addFrame( scene.p(), isUsingOverrideViewer() );
}
}
// Set the Main scene in the viewer. Used when the animation is in "Stopped" state
cvf::ref<cvf::Scene> mainScene = new cvf::Scene;
m_viewer->setMainScene( mainScene.p() );
// Grid model
cvf::ref<cvf::ModelBasicList> mainSceneGridVizModel = new cvf::ModelBasicList;
@ -271,6 +272,7 @@ void RimGeoMechView::createDisplayModel()
mainSceneGridVizModel->updateBoundingBoxesRecursive();
mainScene->addModel( mainSceneGridVizModel.p() );
nativeOrOverrideViewer()->setMainScene( mainScene.p(), isUsingOverrideViewer() );
// Well path model
@ -279,19 +281,19 @@ void RimGeoMechView::createDisplayModel()
m_wellPathPipeVizModel->removeAllParts();
addWellPathsToModel( m_wellPathPipeVizModel.p(), femBBox );
m_viewer->addStaticModelOnce( m_wellPathPipeVizModel.p() );
nativeOrOverrideViewer()->addStaticModelOnce( m_wellPathPipeVizModel.p(), isUsingOverrideViewer() );
// Cross sections
m_crossSectionVizModel->removeAllParts();
m_crossSectionCollection->appendPartsToModel( *this, m_crossSectionVizModel.p(), scaleTransform() );
m_viewer->addStaticModelOnce( m_crossSectionVizModel.p() );
nativeOrOverrideViewer()->addStaticModelOnce( m_crossSectionVizModel.p(), isUsingOverrideViewer() );
// If the animation was active before recreating everything, make viewer view current frame
if ( isTimeStepDependentDataVisible() )
if ( isTimeStepDependentDataVisibleInThisOrComparisonView() )
{
m_viewer->setCurrentFrame( m_currentTimeStep );
if ( viewer() && !isUsingOverrideViewer() ) viewer()->setCurrentFrame( m_currentTimeStep );
}
else
{
@ -318,11 +320,11 @@ void RimGeoMechView::updateCurrentTimeStep()
{
updateLegends();
if ( this->isTimeStepDependentDataVisible() )
if ( this->isTimeStepDependentDataVisibleInThisOrComparisonView() )
{
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
cvf::Scene* frameScene = m_viewer->frame( m_currentTimeStep );
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
{
{
@ -391,7 +393,7 @@ void RimGeoMechView::updateCurrentTimeStep()
m_vizLogic->updateStaticCellColors( -1 );
m_crossSectionCollection->applySingleColorEffect();
m_viewer->animationControl()->slotPause(); // To avoid animation timer spinning in the background
nativeOrOverrideViewer()->animationControl()->slotPause(); // To avoid animation timer spinning in the background
}
m_overlayInfoConfig()->update3DInfo();
@ -421,8 +423,8 @@ void RimGeoMechView::resetLegendsInViewer()
{
this->cellResult()->legendConfig->recreateLegend();
m_viewer->removeAllColorLegends();
m_viewer->addColorLegendToBottomLeftCorner( this->cellResult()->legendConfig->titledOverlayFrame() );
nativeOrOverrideViewer()->removeAllColorLegends();
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner( this->cellResult()->legendConfig->titledOverlayFrame() );
}
//--------------------------------------------------------------------------------------------------
@ -430,15 +432,23 @@ void RimGeoMechView::resetLegendsInViewer()
//--------------------------------------------------------------------------------------------------
void RimGeoMechView::updateLegends()
{
if ( m_viewer )
if ( nativeOrOverrideViewer() )
{
m_viewer->removeAllColorLegends();
if ( !isUsingOverrideViewer() )
{
nativeOrOverrideViewer()->removeAllColorLegends();
}
else
{
nativeOrOverrideViewer()->removeColorLegend( cellResult()->legendConfig->titledOverlayFrame() );
nativeOrOverrideViewer()->removeColorLegend( m_tensorResults->arrowColorLegendConfig->titledOverlayFrame() );
}
this->updateLegendTextAndRanges( cellResult()->legendConfig(), m_currentTimeStep() );
if ( cellResult()->hasResult() && cellResult()->legendConfig()->showLegend() )
{
m_viewer->addColorLegendToBottomLeftCorner( cellResult()->legendConfig->titledOverlayFrame() );
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner( cellResult()->legendConfig->titledOverlayFrame() );
}
if ( tensorResults()->showTensors() )
@ -448,7 +458,7 @@ void RimGeoMechView::updateLegends()
if ( tensorResults()->vectorColors() == RimTensorResults::RESULT_COLORS &&
tensorResults()->arrowColorLegendConfig()->showLegend() )
{
m_viewer->addColorLegendToBottomLeftCorner(
nativeOrOverrideViewer()->addColorLegendToBottomLeftCorner(
m_tensorResults->arrowColorLegendConfig->titledOverlayFrame() );
}
}
@ -678,10 +688,10 @@ void RimGeoMechView::convertCameraPositionFromOldProjectFiles()
viewerToViewInterface->setCameraPointOfInterest( newPointOfInterest );
}
if ( m_viewer )
if ( viewer() )
{
m_viewer->mainCamera()->setViewMatrix( this->cameraPosition() );
m_viewer->setPointOfInterest( this->cameraPointOfInterest() );
viewer()->mainCamera()->setViewMatrix( this->cameraPosition() );
viewer()->setPointOfInterest( this->cameraPointOfInterest() );
}
}
}

24
ApplicationCode/ProjectDataModel/RimProject.cpp
View File

@ -675,6 +675,30 @@ void RimProject::allNotLinkedViews( std::vector<RimGridView*>& views )
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimProject::allViews( std::vector<Rim3dView*>& views ) const
{
std::vector<RimCase*> cases;
allCases( cases );
for ( size_t caseIdx = 0; caseIdx < cases.size(); caseIdx++ )
{
RimCase* rimCase = cases[caseIdx];
if ( !rimCase ) continue;
std::vector<Rim3dView*> caseViews = rimCase->views();
for ( size_t viewIdx = 0; viewIdx < caseViews.size(); viewIdx++ )
{
if ( caseViews[viewIdx] )
{
views.push_back( caseViews[viewIdx] );
}
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

1
ApplicationCode/ProjectDataModel/RimProject.h
View File

@ -124,6 +124,7 @@ public:
std::vector<RimSummaryCaseCollection*> summaryGroups() const;
RimSummaryCaseMainCollection* firstSummaryCaseMainCollection() const;
void allViews(std::vector<Rim3dView*>& views) const;
void allVisibleViews( std::vector<Rim3dView*>& views ) const;
void allVisibleGridViews( std::vector<RimGridView*>& views ) const;
void allNotLinkedViews( std::vector<RimGridView*>& views );

25
ApplicationCode/ProjectDataModel/RimViewManipulator.cpp
View File

@ -128,6 +128,31 @@ void RimViewManipulator::applySourceViewCameraOnDestinationViews( RimGridView*
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec3d RimViewManipulator::calculateEquivalentCamPosOffset( Rim3dView* sourceView, Rim3dView* destView )
{
cvf::Vec3d soffset = cvf::Vec3d::ZERO;
RimCase* sourceOwnerCase = sourceView->ownerCase();
if ( sourceOwnerCase )
{
soffset = sourceOwnerCase->displayModelOffset();
soffset.z() *= sourceView->scaleZ();
}
cvf::Vec3d doffset = cvf::Vec3d::ZERO;
RimCase* destinationOwnerCase = destView->ownerCase();
if ( destinationOwnerCase )
{
doffset = destinationOwnerCase->displayModelOffset();
doffset.z() *= sourceView->scaleZ();
}
return soffset - doffset;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

3
ApplicationCode/ProjectDataModel/RimViewManipulator.h
View File

@ -19,6 +19,7 @@
#pragma once
#include <vector>
#include "cvfVector3.h"
namespace cvf
{
@ -26,12 +27,14 @@ class BoundingBox;
}
class RimGridView;
class Rim3dView;
class RimViewManipulator
{
public:
static void applySourceViewCameraOnDestinationViews( RimGridView* sourceView,
std::vector<RimGridView*>& destinationViews );
static cvf::Vec3d calculateEquivalentCamPosOffset(Rim3dView* sourceView, Rim3dView* destView);
private:
static bool isBoundingBoxesOverlappingOrClose( const cvf::BoundingBox& sourceBB, const cvf::BoundingBox& destBB );

2
ApplicationCode/UserInterface/CMakeLists_files.cmake
View File

@ -83,6 +83,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RiuMeasurementViewEventFilter.h
${CMAKE_CURRENT_LIST_DIR}/RiuDraggableOverlayFrame.h
${CMAKE_CURRENT_LIST_DIR}/RiuMdiMaximizeWindowGuard.h
${CMAKE_CURRENT_LIST_DIR}/RiuMainWindowTools.h
${CMAKE_CURRENT_LIST_DIR}/RiuComparisonViewMover.h
)
set (SOURCE_GROUP_SOURCE_FILES
@ -165,6 +166,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RiuWellPathComponentPlotItem.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuDraggableOverlayFrame.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuMdiMaximizeWindowGuard.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuMainWindowTools.cpp
${CMAKE_CURRENT_LIST_DIR}/RiuComparisonViewMover.cpp
)
list(APPEND CODE_HEADER_FILES

147
ApplicationCode/UserInterface/RiuComparisonViewMover.cpp Normal file
View File

@ -0,0 +1,147 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- Equinor ASA
//
// ResInsight 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.
//
// ResInsight 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.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RiuComparisonViewMover.h"
#include "cafViewer.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuComparisonViewMover::RiuComparisonViewMover( caf::Viewer* viewer )
: QObject( viewer )
, m_viewer( viewer )
, m_dragState( NONE )
, m_highlightHandle( NONE )
{
viewer->installEventFilter( this );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RiuComparisonViewMover::eventFilter( QObject* watched, QEvent* event )
{
if ( !m_viewer->currentScene( true ) ) return false;
switch ( event->type() )
{
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
case QEvent::MouseMove:
{
QMouseEvent* mEv = static_cast<QMouseEvent*>( event );
if ( mEv->type() == QEvent::MouseButtonPress && mEv->button() == Qt::LeftButton )
{
DragState handle = findHandleUnderMouse( mEv->pos() );
m_dragState = handle;
}
else if ( mEv->type() == QEvent::MouseButtonRelease && mEv->button() == Qt::LeftButton )
{
m_dragState = NONE;
}
else if ( mEv->type() == QEvent::MouseMove )
{
m_highlightHandle = findHandleUnderMouse( mEv->pos() );
if ( m_dragState == LEFT_EDGE )
{
QPointF mousePos = mEv->windowPos();
QPointF normMousePos = {mousePos.x() / m_viewer->width(), mousePos.y() / m_viewer->height()};
cvf::Rectf orgCompViewWindow = m_viewer->comparisonViewVisibleNormalizedRect();
m_viewer->setComparisonViewVisibleNormalizedRect(
cvf::Rectf( normMousePos.x(),
orgCompViewWindow.min().y(),
( orgCompViewWindow.min().x() + orgCompViewWindow.width() ) -
normMousePos.x(),
orgCompViewWindow.height() ) );
return true;
}
else
{
m_viewer->update();
}
}
}
}
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuComparisonViewMover::paintMoverHandles( QPainter* painter )
{
if ( !m_viewer->currentScene( true ) ) return;
const int handleThickness = 7;
cvf::Rectf normalizedComparisonRect = m_viewer->comparisonViewVisibleNormalizedRect();
int viewerWidth = m_viewer->width();
int viewerHeight = m_viewer->height();
int leftEdgePos = viewerWidth * normalizedComparisonRect.min().x();
int width = viewerWidth * normalizedComparisonRect.width();
int height = viewerHeight * normalizedComparisonRect.height();
int topEdgePosOgl = viewerHeight * normalizedComparisonRect.max().y();
int topEdgePosQt = height - topEdgePosOgl;
int bottomEdgePosQt = height - viewerHeight * normalizedComparisonRect.min().y();
painter->setPen( QColor( 0, 0, 0, 30 ) );
painter->drawRect( leftEdgePos, topEdgePosQt, width - 1, height - 1 );
QColor handleColor( 0, 0, 0, 50 );
if ( m_highlightHandle == LEFT_EDGE || m_dragState == LEFT_EDGE )
{
handleColor = QColor( 255, 255, 255, 50 );
}
painter->fillRect( leftEdgePos - handleThickness * 0.4,
bottomEdgePosQt - 8 * handleThickness,
handleThickness,
handleThickness * 6,
handleColor );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuComparisonViewMover::DragState RiuComparisonViewMover::findHandleUnderMouse( const QPoint& mousePos )
{
const int handleThickness = 7;
cvf::Rectf normalizedComparisonRect = m_viewer->comparisonViewVisibleNormalizedRect();
int viewerWidth = m_viewer->width();
int viewerHeight = m_viewer->height();
int leftEdgePos = viewerWidth * normalizedComparisonRect.min().x();
int height = viewerHeight * normalizedComparisonRect.height();
int bottomEdgePosQt = height - viewerHeight * normalizedComparisonRect.min().y();
if ( ( leftEdgePos - handleThickness * 0.4 ) < mousePos.x() &&
mousePos.x() < ( leftEdgePos + handleThickness * 0.5 ) &&
( bottomEdgePosQt - 8 * handleThickness ) < mousePos.y() &&
mousePos.y() < ( bottomEdgePosQt - 2 * handleThickness ) )
{
return LEFT_EDGE;
}
return NONE;
}

58
ApplicationCode/UserInterface/RiuComparisonViewMover.h Normal file
View File

@ -0,0 +1,58 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- Equinor ASA
//
// ResInsight 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.
//
// ResInsight 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.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "cvfBase.h"
#include "cvfObject.h"
#include <QPointer>
#include <QMouseEvent>
#include <QPainter>
namespace caf
{
class Viewer;
}
class RiuComparisonViewMover : public QObject
{
public:
RiuComparisonViewMover( caf::Viewer* viewer );
virtual bool eventFilter( QObject* watched, QEvent* event ) override;
void paintMoverHandles( QPainter* painter );
private:
enum DragState
{
NONE,
COMPLETE_BOX,
LEFT_EDGE,
RIGHT_EDGE,
TOP_EDGE,
BOTTOM_EDGE,
};
DragState findHandleUnderMouse( const QPoint& mousePos );
QPointer<caf::Viewer> m_viewer;
DragState m_dragState;
DragState m_highlightHandle;
};

2
ApplicationCode/UserInterface/RiuMainWindow.cpp
View File

@ -933,7 +933,7 @@ void RiuMainWindow::refreshAnimationActions()
{
enableAnimControls = true;
if ( activeView->isTimeStepDependentDataVisible() )
if ( activeView->isTimeStepDependentDataVisibleInThisOrComparisonView() )
{
timeStepStrings = activeView->ownerCase()->timeStepStrings();
}

90
ApplicationCode/UserInterface/RiuViewer.cpp
View File

@ -37,6 +37,7 @@
#include "WindowEdgeAxesOverlayItem/RivWindowEdgeAxesOverlayItem.h"
#include "RiuCadNavigation.h"
#include "RiuComparisonViewMover.h"
#include "RiuGeoQuestNavigation.h"
#include "RiuRmsNavigation.h"
#include "RiuSimpleHistogramWidget.h"
@ -101,7 +102,7 @@ RiuViewer::RiuViewer( const QGLFormat& format, QWidget* parent )
m_axisCross = new cvf::OverlayAxisCross( m_mainCamera.p(), standardFont );
m_axisCross->setAxisLabels( "X", "Y", "Z" );
m_axisCross->setLayout( cvf::OverlayItem::VERTICAL, cvf::OverlayItem::BOTTOM_RIGHT );
m_mainRendering->addOverlayItem( m_axisCross.p() );
overlayItemsRendering()->addOverlayItem( m_axisCross.p() );
m_showAxisCross = true;
this->enableOverlayPainting( true );
@ -168,7 +169,8 @@ RiuViewer::RiuViewer( const QGLFormat& format, QWidget* parent )
// which solves the problem
setContextMenuPolicy( Qt::PreventContextMenu );
m_gridBoxGenerator = new RivGridBoxGenerator;
m_gridBoxGenerator = new RivGridBoxGenerator;
m_comparisonGridBoxGenerator = new RivGridBoxGenerator;
m_cursorPositionDomainCoords = cvf::Vec3d::UNDEFINED;
m_windowEdgeAxisOverlay = new RivWindowEdgeAxesOverlayItem( standardFont );
@ -178,6 +180,8 @@ RiuViewer::RiuViewer( const QGLFormat& format, QWidget* parent )
m_scaleLegend = new caf::OverlayScaleLegend( standardFont );
m_scaleLegend->setOrientation( caf::OverlayScaleLegend::HORIZONTAL );
m_comparisonWindowMover = new RiuComparisonViewMover( this );
}
//--------------------------------------------------------------------------------------------------
@ -195,6 +199,7 @@ RiuViewer::~RiuViewer()
delete m_animationProgress;
delete m_histogramWidget;
delete m_gridBoxGenerator;
delete m_comparisonGridBoxGenerator;
}
//--------------------------------------------------------------------------------------------------
@ -333,19 +338,15 @@ void RiuViewer::setOwnerReservoirView( RiuViewerToViewInterface* owner )
m_viewerCommands->setOwnerView( dynamic_cast<Rim3dView*>( owner ) );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuViewer::setEnableMask( unsigned int mask )
{
m_mainRendering->setEnableMask( mask );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuViewer::paintOverlayItems( QPainter* painter )
{
// Update the legend layout on every redraw as the legends stores their own position,
// and when they are shared between views the positions are overwritten.
updateLegendLayout();
int columnWidth = 200;
int edgeAxisFrameBorderWidth = m_showWindowEdgeAxes ? m_windowEdgeAxisOverlay->frameBorderWidth() : 0;
@ -443,6 +444,8 @@ void RiuViewer::paintOverlayItems( QPainter* painter )
}
}
}
m_comparisonWindowMover->paintMoverHandles( painter );
}
//--------------------------------------------------------------------------------------------------
@ -516,10 +519,12 @@ void RiuViewer::setHistogramPercentiles( double pmin, double pmax, double mean )
void RiuViewer::showGridBox( bool enable )
{
this->removeStaticModel( m_gridBoxGenerator->model() );
this->removeStaticModel( m_comparisonGridBoxGenerator->model() );
if ( enable )
{
this->addStaticModelOnce( m_gridBoxGenerator->model() );
this->addStaticModelOnce( m_gridBoxGenerator->model(), false );
this->addStaticModelOnce( m_comparisonGridBoxGenerator->model(), true );
}
}
@ -554,7 +559,7 @@ void RiuViewer::removeAllColorLegends()
{
for ( size_t i = 0; i < m_visibleLegends.size(); i++ )
{
m_mainRendering->removeOverlayItem( m_visibleLegends[i].p() );
overlayItemsRendering()->removeOverlayItem( m_visibleLegends[i].p() );
}
m_visibleLegends.clear();
@ -567,10 +572,10 @@ void RiuViewer::addColorLegendToBottomLeftCorner( caf::TitledOverlayFrame* added
{
RiaGuiApplication* app = RiaGuiApplication::instance();
CVF_ASSERT( app );
RiaPreferences* preferences = app->preferences();
cvf::Rendering* firstRendering = m_mainRendering.p();
RiaPreferences* preferences = app->preferences();
cvf::Rendering* overlayRendering = overlayItemsRendering();
CVF_ASSERT( preferences );
CVF_ASSERT( firstRendering );
CVF_ASSERT( overlayRendering );
if ( addedLegend )
{
@ -579,17 +584,27 @@ void RiuViewer::addColorLegendToBottomLeftCorner( caf::TitledOverlayFrame* added
cvf::Color3f frameColor( backgroundColor.r(), backgroundColor.g(), backgroundColor.b() );
updateLegendTextAndTickMarkColor( addedLegend );
firstRendering->addOverlayItem( addedLegend );
overlayRendering->addOverlayItem( addedLegend );
addedLegend->enableBackground( preferences->showLegendBackground() );
addedLegend->setBackgroundColor( backgroundColor );
addedLegend->setBackgroundFrameColor(
cvf::Color4f( RiaColorTools::computeOffsetColor( frameColor, 0.3f ), 0.9f ) );
addedLegend->setFont( app->defaultSceneFont() );
m_visibleLegends.push_back( addedLegend );
if ( !m_visibleLegends.contains( addedLegend ) )
{
m_visibleLegends.push_back( addedLegend );
}
}
}
updateLegendLayout();
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuViewer::removeColorLegend( caf::TitledOverlayFrame* legend )
{
overlayItemsRendering()->removeOverlayItem( legend );
m_visibleLegends.erase( legend );
}
//--------------------------------------------------------------------------------------------------
@ -759,11 +774,11 @@ void RiuViewer::setCurrentFrame( int frameIndex )
//--------------------------------------------------------------------------------------------------
void RiuViewer::showAxisCross( bool enable )
{
m_mainRendering->removeOverlayItem( m_axisCross.p() );
overlayItemsRendering()->removeOverlayItem( m_axisCross.p() );
if ( enable )
{
m_mainRendering->addOverlayItem( m_axisCross.p() );
overlayItemsRendering()->addOverlayItem( m_axisCross.p() );
}
m_showAxisCross = enable;
}
@ -796,6 +811,7 @@ void RiuViewer::optimizeClippingPlanes()
}
m_gridBoxGenerator->updateFromCamera( mainCamera() );
m_comparisonGridBoxGenerator->updateFromCamera( comparisonMainCamera() );
m_scaleLegend->setDisplayCoordTransform( m_rimView->displayCoordTransform().p() );
m_scaleLegend->updateFromCamera( mainCamera() );
@ -809,7 +825,6 @@ void RiuViewer::optimizeClippingPlanes()
void RiuViewer::resizeGL( int width, int height )
{
caf::Viewer::resizeGL( width, height );
this->updateLegendLayout();
}
//--------------------------------------------------------------------------------------------------
@ -892,6 +907,17 @@ void RiuViewer::updateGridBoxData( double scaleZ,
m_gridBoxGenerator->createGridBoxParts();
m_comparisonGridBoxGenerator->setScaleZ( scaleZ );
cvf::Vec3d unscaledComparisonOffset = comparisonViewEyePointOffset();
unscaledComparisonOffset.z() /= scaleZ;
m_comparisonGridBoxGenerator->setDisplayModelOffset( displayModelOffset - unscaledComparisonOffset );
m_comparisonGridBoxGenerator->updateFromBackgroundColor( backgroundColor );
m_comparisonGridBoxGenerator->setGridBoxDomainCoordBoundingBox( domainCoordBoundingBox );
m_comparisonGridBoxGenerator->createGridBoxParts();
m_selectionVisualizerManager->updateVisibleEditors();
}
@ -900,19 +926,17 @@ void RiuViewer::updateGridBoxData( double scaleZ,
//--------------------------------------------------------------------------------------------------
void RiuViewer::showEdgeTickMarksXY( bool enable, bool showAxisLines )
{
m_mainRendering->removeOverlayItem( m_windowEdgeAxisOverlay.p() );
overlayItemsRendering()->removeOverlayItem( m_windowEdgeAxisOverlay.p() );
if ( enable )
{
m_windowEdgeAxisOverlay->setDomainAxes( RivWindowEdgeAxesOverlayItem::XY_AXES );
m_windowEdgeAxisOverlay->setIsSwitchingYAxisSign( false );
m_windowEdgeAxisOverlay->setShowAxisLines( showAxisLines );
m_mainRendering->addOverlayItem( m_windowEdgeAxisOverlay.p() );
overlayItemsRendering()->addOverlayItem( m_windowEdgeAxisOverlay.p() );
}
m_showWindowEdgeAxes = enable;
updateLegendLayout();
}
//--------------------------------------------------------------------------------------------------
@ -920,19 +944,17 @@ void RiuViewer::showEdgeTickMarksXY( bool enable, bool showAxisLines )
//--------------------------------------------------------------------------------------------------
void RiuViewer::showEdgeTickMarksXZ( bool enable, bool showAxisLines )
{
m_mainRendering->removeOverlayItem( m_windowEdgeAxisOverlay.p() );
overlayItemsRendering()->removeOverlayItem( m_windowEdgeAxisOverlay.p() );
if ( enable )
{
m_windowEdgeAxisOverlay->setDomainAxes( RivWindowEdgeAxesOverlayItem::XZ_AXES );
m_windowEdgeAxisOverlay->setIsSwitchingYAxisSign( true );
m_windowEdgeAxisOverlay->setShowAxisLines( showAxisLines );
m_mainRendering->addOverlayItem( m_windowEdgeAxisOverlay.p() );
overlayItemsRendering()->addOverlayItem( m_windowEdgeAxisOverlay.p() );
}
m_showWindowEdgeAxes = enable;
updateLegendLayout();
}
//--------------------------------------------------------------------------------------------------
@ -1043,14 +1065,12 @@ void RiuViewer::showScaleLegend( bool show )
else
m_scaleLegend->setRenderSize( {50, 280} );
m_mainRendering->addOverlayItem( m_scaleLegend.p() );
overlayItemsRendering()->addOverlayItem( m_scaleLegend.p() );
}
else
{
m_mainRendering->removeOverlayItem( m_scaleLegend.p() );
overlayItemsRendering()->removeOverlayItem( m_scaleLegend.p() );
}
updateLegendLayout();
}
//--------------------------------------------------------------------------------------------------
@ -1075,12 +1095,12 @@ void RiuViewer::clearHoverCursor()
void RiuViewer::updateFonts()
{
cvf::Font* standardFont = RiaGuiApplication::instance()->defaultSceneFont();
m_mainRendering->removeOverlayItem( m_axisCross.p() );
overlayItemsRendering()->removeOverlayItem( m_axisCross.p() );
m_axisCross = new cvf::OverlayAxisCross( m_mainCamera.p(), standardFont );
m_axisCross->setAxisLabels( "X", "Y", "Z" );
m_axisCross->setLayout( cvf::OverlayItem::VERTICAL, cvf::OverlayItem::BOTTOM_RIGHT );
m_mainRendering->addOverlayItem( m_axisCross.p() );
overlayItemsRendering()->addOverlayItem( m_axisCross.p() );
m_showAxisCross = true;
QFont font = QApplication::font();

10
ApplicationCode/UserInterface/RiuViewer.h
View File

@ -40,6 +40,8 @@ class RiuViewerCommands;
class RivGridBoxGenerator;
class RivWindowEdgeAxesOverlayItem;
class RiuComparisonViewMover;
class QLabel;
namespace caf
@ -79,7 +81,6 @@ public:
void setOwnerReservoirView( RiuViewerToViewInterface* owner );
RiuViewerToViewInterface* ownerReservoirView();
RimViewWindow* ownerViewWindow() const override;
void setEnableMask( unsigned int mask );
void showInfoText( bool enable );
void showVersionInfo( bool enable );
@ -107,6 +108,7 @@ public:
void removeAllColorLegends();
void addColorLegendToBottomLeftCorner( caf::TitledOverlayFrame* legend );
void removeColorLegend( caf::TitledOverlayFrame* legend );
void enableNavigationRotation( bool disable );
void updateNavigationPolicy();
@ -185,7 +187,9 @@ private:
RiuViewerCommands* m_viewerCommands;
RivGridBoxGenerator* m_gridBoxGenerator;
RivGridBoxGenerator* m_gridBoxGenerator;
RivGridBoxGenerator* m_comparisonGridBoxGenerator;
cvf::ref<RivWindowEdgeAxesOverlayItem> m_windowEdgeAxisOverlay;
bool m_showWindowEdgeAxes;
@ -197,4 +201,6 @@ private:
cvf::ref<caf::OverlayScaleLegend> m_scaleLegend;
static std::unique_ptr<QCursor> s_hoverCursor;
RiuComparisonViewMover* m_comparisonWindowMover;
};

438
Fwk/AppFwk/cafViewer/cafViewer.cpp
View File

@ -76,6 +76,7 @@
#include <QDebug>
#include <QHBoxLayout>
#include <QInputEvent>
#include "cvfRenderingScissor.h"
namespace caf
{
@ -103,6 +104,7 @@ private:
cvf::ref<cvf::UniformFloat> m_headlightPosition;
};
}
std::list<caf::Viewer*> caf::Viewer::sm_viewers;
@ -127,7 +129,9 @@ caf::Viewer::Viewer(const QGLFormat& format, QWidget* parent)
m_isOverlayPaintingEnabled(true),
m_offscreenViewportWidth(0),
m_offscreenViewportHeight(0),
m_parallelProjectionLightDirection(0, 0, -1) // Light directly from behind
m_parallelProjectionLightDirection(0, 0, -1), // Light directly from behind
m_comparisonViewOffset(0, 0, 0),
m_comparisonWindowNormalizedRect(0.5f, 0.0f, 0.5f, 1.0f)
{
#if QT_VERSION >= 0x050000
m_layoutWidget = new QWidget(parent);
@ -150,10 +154,19 @@ caf::Viewer::Viewer(const QGLFormat& format, QWidget* parent)
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();
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)));
@ -193,20 +206,32 @@ caf::Viewer::~Viewer()
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());
@ -225,6 +250,8 @@ void caf::Viewer::setupMainRendering()
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())
{
@ -282,30 +309,94 @@ cvf::Camera* caf::Viewer::mainCamera()
}
//--------------------------------------------------------------------------------------------------
/// Set the scene to be rendered when the animation is inactive (Stopped)
///
//--------------------------------------------------------------------------------------------------
void caf::Viewer::setMainScene(cvf::Scene* scene)
cvf::Camera* caf::Viewer::comparisonMainCamera()
{
appendAllStaticModelsToFrame(scene);
m_mainScene = scene;
m_mainRendering->setScene(scene);
return m_comparisonMainCamera.p();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Scene* caf::Viewer::mainScene()
void caf::Viewer::setComparisonViewEyePointOffset(const cvf::Vec3d& offset)
{
return m_mainScene.p();
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;
}
//--------------------------------------------------------------------------------------------------
/// 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);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
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()
cvf::Scene* caf::Viewer::currentScene(bool isForComparisonView)
{
return m_mainRendering->scene();
if (!isForComparisonView)
{
return m_mainRendering->scene();
}
else
{
return m_comparisonMainRendering->scene();
}
}
//--------------------------------------------------------------------------------------------------
@ -316,6 +407,11 @@ 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)
{
@ -347,11 +443,66 @@ bool caf::Viewer::canRender() const
//--------------------------------------------------------------------------------------------------
void caf::Viewer::optimizeClippingPlanes()
{
cvf::BoundingBox bb = m_mainRendering->boundingBox();
if (!bb.isValid()) return;
double nearPlaneDist = HUGE_VAL;
double farPlaneDist = HUGE_VAL;
cvf::Vec3d eye = m_mainCamera->position();
cvf::Vec3d viewdir = m_mainCamera->direction();
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() );
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);
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);
@ -360,68 +511,60 @@ void caf::Viewer::optimizeClippingPlanes()
double maxDistEyeToCornerAlongViewDir = -HUGE_VAL;
double minDistEyeToCornerAlongViewDir = HUGE_VAL;
for (int bcIdx = 0; bcIdx < 8; ++bcIdx )
for ( int bcIdx = 0; bcIdx < 8; ++bcIdx )
{
double distEyeBoxCornerAlongViewDir = (bboxCorners[bcIdx] - eye)*viewdir;
if (distEyeBoxCornerAlongViewDir > maxDistEyeToCornerAlongViewDir)
if ( distEyeBoxCornerAlongViewDir > maxDistEyeToCornerAlongViewDir )
{
maxDistEyeToCornerAlongViewDir = distEyeBoxCornerAlongViewDir;
}
if (distEyeBoxCornerAlongViewDir < minDistEyeToCornerAlongViewDir)
if ( distEyeBoxCornerAlongViewDir < minDistEyeToCornerAlongViewDir )
{
minDistEyeToCornerAlongViewDir = distEyeBoxCornerAlongViewDir; // Sometimes negative-> behind camera
}
}
double farPlaneDist = CVF_MIN(maxDistEyeToCornerAlongViewDir * 1.2, m_maxClipPlaneDistance);
(*farPlaneDist) = CVF_MIN(maxDistEyeToCornerAlongViewDir * 1.2, m_maxClipPlaneDistance);
// Near-plane:
bool isOrthoNearPlaneFollowingCamera = false;
double nearPlaneDist = HUGE_VAL;
// If we have perspective projection, set the near plane just in front of camera, and not behind
if (m_mainCamera->projection() == cvf::Camera::PERSPECTIVE || isOrthoNearPlaneFollowingCamera)
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);
(*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)
if ( (*nearPlaneDist) == m_defaultPerspectiveNearPlaneDistance // We are inside the bounding box
&& m_navigationPolicy.notNull() && m_navigationPolicyEnabled )
{
double pointOfInterestDist = (eye - m_navigationPolicy->pointOfInterest()).length();
nearPlaneDist = CVF_MIN(nearPlaneDist, pointOfInterestDist*0.2);
double pointOfInterestDist = (eye - navPointOfinterest).length();
(*nearPlaneDist) = CVF_MIN((*nearPlaneDist), pointOfInterestDist*0.2);
}
// Guard against the zero nearplane possibility
if (nearPlaneDist <= 0) nearPlaneDist = m_defaultPerspectiveNearPlaneDistance;
if ( nearPlaneDist <= 0 ) (*nearPlaneDist) = m_defaultPerspectiveNearPlaneDistance;
}
else // Orthographic projection. Set to encapsulate the complete boundingbox, possibly setting a negative nearplane
{
if(minDistEyeToCornerAlongViewDir >= 0)
if ( minDistEyeToCornerAlongViewDir >= 0 )
{
nearPlaneDist = CVF_MIN(0.8 * minDistEyeToCornerAlongViewDir, m_maxClipPlaneDistance);
(*nearPlaneDist) = CVF_MIN(0.8 * minDistEyeToCornerAlongViewDir, m_maxClipPlaneDistance);
}
else
{
nearPlaneDist = CVF_MAX(1.2 * minDistEyeToCornerAlongViewDir, -m_maxClipPlaneDistance);
(*nearPlaneDist) = CVF_MAX(1.2 * minDistEyeToCornerAlongViewDir, -m_maxClipPlaneDistance);
}
}
if (farPlaneDist <= nearPlaneDist) farPlaneDist = nearPlaneDist + 1.0;
if ( (*farPlaneDist) <= (*nearPlaneDist) ) (*farPlaneDist) = (*nearPlaneDist) + 1.0;
if (m_mainCamera->projection() == cvf::Camera::PERSPECTIVE)
{
m_mainCamera->setProjectionAsPerspective(m_cameraFieldOfViewYDeg, nearPlaneDist, farPlaneDist);
}
else
{
m_mainCamera->setProjectionAsOrtho(m_mainCamera->frontPlaneFrustumHeight(), nearPlaneDist, farPlaneDist);
}
return true;
}
//--------------------------------------------------------------------------------------------------
@ -644,9 +787,15 @@ void caf::Viewer::paintEvent(QPaintEvent* event)
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());
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());
}
@ -728,22 +877,39 @@ void caf::Viewer::zoomAll()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void caf::Viewer::addFrame(cvf::Scene* scene)
void caf::Viewer::addFrame(cvf::Scene* scene, bool isForComparisonView)
{
appendAllStaticModelsToFrame(scene);
appendAllStaticModelsToFrame(scene, isForComparisonView);
m_frameScenes.push_back(scene);
m_animationControl->setNumFrames(static_cast<int>(m_frameScenes.size()));
if ( !isForComparisonView )
{
m_frameScenes.push_back(scene);
}
else
{
m_comparisonFrameScenes.push_back(scene);
}
m_animationControl->setNumFrames( static_cast<int>( frameCount() ) );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void caf::Viewer::removeAllFrames()
void caf::Viewer::removeAllFrames(bool isForComparisonView)
{
m_frameScenes.clear();
m_animationControl->setNumFrames(0);
m_mainRendering->setScene(m_mainScene.p());
if ( !isForComparisonView )
{
m_frameScenes.clear();
m_mainRendering->setScene(m_mainScene.p());
}
else
{
m_comparisonFrameScenes.clear();
m_comparisonMainRendering->setScene(m_comparisonMainScene.p());
}
m_animationControl->setNumFrames(static_cast<int>(frameCount()));
}
@ -776,15 +942,29 @@ void caf::Viewer::slotSetCurrentFrame(int frameIndex)
int clampedFrameIndex = clampFrameIndex(frameIndex);
if (m_frameScenes.at(clampedFrameIndex) == nullptr) return;
//if (m_frameScenes.at(clampedFrameIndex) == nullptr) return;
if (m_releaseOGLResourcesEachFrame)
{
releaseOGlResourcesForCurrentFrame();
}
m_mainRendering->setScene(m_frameScenes.at(clampedFrameIndex));
if (m_frameScenes.size() > clampedFrameIndex && m_frameScenes.at(clampedFrameIndex) != nullptr )
{
m_mainRendering->setScene(m_frameScenes.at(clampedFrameIndex));
}
else
{
m_mainRendering->setScene(nullptr);
}
if (m_comparisonFrameScenes.size() > clampedFrameIndex && m_comparisonFrameScenes.at(clampedFrameIndex) != nullptr )
{
m_comparisonMainRendering->setScene(m_comparisonFrameScenes.at(clampedFrameIndex));
}
else
{
m_comparisonMainRendering->setScene(nullptr);
}
update();
}
@ -881,10 +1061,6 @@ QImage caf::Viewer::snapshotImage()
m_offscreenFbo->bind(myOglContext.p());
// TODO: Consider refactor this code
// Creating a QImage from the bits in current frame buffer can be done by
// this->grabFrameBuffer()
GLint iOldPackAlignment = 0;
glGetIntegerv(GL_PACK_ALIGNMENT, &iOldPackAlignment);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
@ -924,12 +1100,22 @@ QImage caf::Viewer::snapshotImage()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Scene* caf::Viewer::frame(size_t frameIndex)
cvf::Scene* caf::Viewer::frame(size_t frameIndex, bool isForComparisonView)
{
if (frameIndex < m_frameScenes.size())
return m_frameScenes[frameIndex].p();
if ( !isForComparisonView )
{
if ( frameIndex < m_frameScenes.size() )
return m_frameScenes[frameIndex].p();
else
return nullptr;
}
else
return nullptr;
{
if ( frameIndex < m_comparisonFrameScenes.size() )
return m_comparisonFrameScenes[frameIndex].p();
else
return nullptr;
}
}
//--------------------------------------------------------------------------------------------------
@ -1031,6 +1217,14 @@ void caf::Viewer::enableOverlayPainting(bool val)
updateOverlayImagePresence();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Rendering* caf::Viewer::overlayItemsRendering()
{
return m_overlayItemsRendering.p();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -1038,11 +1232,11 @@ void caf::Viewer::updateOverlayImagePresence()
{
if (m_isOverlayPaintingEnabled || m_showPerfInfoHud)
{
m_mainRendering->addOverlayItem(m_overlayImage.p());
m_overlayItemsRendering->addOverlayItem(m_overlayImage.p());
}
else
{
m_mainRendering->removeOverlayItem(m_overlayImage.p());
m_overlayItemsRendering->removeOverlayItem(m_overlayImage.p());
}
}
@ -1057,13 +1251,22 @@ void caf::Viewer::navigationPolicyUpdate()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void caf::Viewer::addStaticModelOnce(cvf::Model* model)
void caf::Viewer::addStaticModelOnce(cvf::Model* model, bool isForComparisonView)
{
if (m_staticModels.contains(model)) return;
if ( !isForComparisonView )
{
if ( m_staticModels.contains(model) ) return;
m_staticModels.push_back(model);
m_staticModels.push_back(model);
}
else
{
if ( m_comparisonStaticModels.contains(model) ) return;
appendModelToAllFrames(model);
m_comparisonStaticModels.push_back(model);
}
appendModelToAllFrames(model, isForComparisonView);
updateCachedValuesInScene();
}
@ -1076,6 +1279,7 @@ void caf::Viewer::removeStaticModel(cvf::Model* model)
removeModelFromAllFrames(model);
m_staticModels.erase(model);
m_comparisonStaticModels.erase(model);
updateCachedValuesInScene();
}
@ -1089,12 +1293,33 @@ void caf::Viewer::removeAllStaticModels()
{
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);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -1111,34 +1336,75 @@ void caf::Viewer::removeModelFromAllFrames(cvf::Model* model)
{
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)
void caf::Viewer::appendModelToAllFrames(cvf::Model* model, bool isForComparisonView )
{
for (size_t i = 0; i < m_frameScenes.size(); i++)
if ( !isForComparisonView )
{
cvf::Scene* scene = m_frameScenes.at(i);
for ( size_t i = 0; i < m_frameScenes.size(); i++ )
{
cvf::Scene* scene = m_frameScenes.at(i);
scene->addModel(model);
scene->addModel(model);
}
if ( m_mainScene.notNull() )
{
m_mainScene->addModel(model);
}
}
if (m_mainScene.notNull())
else
{
m_mainScene->addModel(model);
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)
void caf::Viewer::appendAllStaticModelsToFrame(cvf::Scene* scene, bool isForComparisonView )
{
for (size_t i = 0; i < m_staticModels.size(); i++)
if (!scene) return;
if ( !isForComparisonView )
{
scene->addModel(m_staticModels.at(i));
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));
}
}
}
@ -1147,12 +1413,12 @@ void caf::Viewer::appendAllStaticModelsToFrame(cvf::Scene* scene)
//--------------------------------------------------------------------------------------------------
cvf::OverlayItem* caf::Viewer::overlayItem(int winPosX, int winPosY)
{
if (m_mainRendering.isNull()) return nullptr;
if (m_overlayItemsRendering.isNull()) return nullptr;
int translatedMousePosX = winPosX;
int translatedMousePosY = height() - winPosY;
return m_mainRendering->overlayItemFromWindowCoordinates(translatedMousePosX, translatedMousePosY);
return m_overlayItemsRendering->overlayItemFromWindowCoordinates(translatedMousePosX, translatedMousePosY);
}
@ -1341,3 +1607,19 @@ int caf::Viewer::clampFrameIndex(int frameIndex) const
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());
}

56
Fwk/AppFwk/cafViewer/cafViewer.h
View File

@ -42,9 +42,11 @@
#include "cvfObject.h"
#include "cvfCollection.h"
#include "cvfVector3.h"
#include "cvfRect.h"
#include "cvfOpenGL.h"
#include "cafOpenGLWidget.h"
#include "cvfRenderingScissor.h"
namespace cvf {
@ -76,6 +78,7 @@ namespace caf
{
class GlobalViewerDynUniformSet;
class ScissorChanger;
class Viewer : public caf::OpenGLWidget
{
@ -86,24 +89,33 @@ public:
QWidget* layoutWidget() { return m_layoutWidget; } // Use this when putting it into something
cvf::Camera* mainCamera();
cvf::Camera* comparisonMainCamera();
void setComparisonViewEyePointOffset(const cvf::Vec3d& offset);
const cvf::Vec3d comparisonViewEyePointOffset();
void setComparisonViewVisibleNormalizedRect( const cvf::Rectf& visibleRect );
cvf::Rectf comparisonViewVisibleNormalizedRect() const;
// Set the main scene : the scene active when the animation is not active. (Stopped)
void setMainScene(cvf::Scene* scene);
cvf::Scene* mainScene();
cvf::Scene* currentScene(); // The scene currently rendered
void setMainScene(cvf::Scene* scene, bool isForComparisonView = false);
cvf::Scene* mainScene( bool isForComparisonView = false );
cvf::Scene* currentScene( bool isForComparisonView = false ); // The scene currently rendered
// Frame scenes for animation control
void addFrame(cvf::Scene* scene);
size_t frameCount() const { return m_frameScenes.size(); }
cvf::Scene* frame(size_t frameIndex);
void removeAllFrames();
void addFrame(cvf::Scene* scene, bool isForComparisonView = false);
size_t frameCount() const { return std::max( m_frameScenes.size(), m_comparisonFrameScenes.size() ) ; }
cvf::Scene* frame(size_t frameIndex, bool isForComparisonView = false);
void removeAllFrames(bool isForComparisonView = false);
int currentFrameIndex() const;
// Static models to be shown in all frames
void addStaticModelOnce(cvf::Model* model);
void addStaticModelOnce(cvf::Model* model, bool isForComparisonView = false);
void removeStaticModel(cvf::Model* model);
void removeAllStaticModels();
// Part enable/ disable mask
void setEnableMask( unsigned int mask, bool isForComparisonView = false );
// Recursively traverse all the scenes managed by the viewer and make sure all cached values are up-to-date
// Use when changing the contents inside the objects in the scene.
@ -145,6 +157,7 @@ public:
bool isOverlayPaintingEnabled() const;
void enableOverlayPainting(bool val);
cvf::Rendering* overlayItemsRendering();
// Performance information for debugging etc.
void enablePerfInfoHud(bool enable);
@ -157,6 +170,8 @@ public:
QImage snapshotImage();
static void copyCameraView(cvf::Camera* srcCamera, cvf::Camera* dstCamera);
public slots:
virtual void slotSetCurrentFrame(int frameIndex);
virtual void slotEndAnimation();
@ -171,6 +186,11 @@ protected:
// Overridable methods to setup the render system
virtual void optimizeClippingPlanes();
bool calculateNearFarPlanes(const cvf::Rendering* rendering,
const cvf::Vec3d& navPointOfinterest,
double *farPlaneDist,
double *nearPlaneDist);
// Standard overrides. Not for overriding
void resizeGL(int width, int height) override;
void paintEvent(QPaintEvent* event) override;
@ -195,8 +215,8 @@ private:
void setupMainRendering();
void setupRenderingSequence();
void appendAllStaticModelsToFrame(cvf::Scene* scene);
void appendModelToAllFrames(cvf::Model* model);
void appendAllStaticModelsToFrame(cvf::Scene* scene, bool isForComparisonView = false);
void appendModelToAllFrames(cvf::Model* model, bool isForComparisonView = false);
void removeModelFromAllFrames(cvf::Model* model);
void updateCamera(int width, int height);
@ -219,14 +239,27 @@ private:
// System to make sure we share OpenGL resources
static Viewer* sharedWidget();
static cvf::OpenGLContextGroup* contextGroup();
static std::list<Viewer*> sm_viewers;
static cvf::ref<cvf::OpenGLContextGroup>
sm_openGLContextGroup;
caf::FrameAnimationControl* m_animationControl;
cvf::Collection<cvf::Scene> m_frameScenes;
cvf::Collection<cvf::Model> m_staticModels;
cvf::ref<cvf::Rendering> m_comparisonMainRendering;
cvf::ref<cvf::Camera> m_comparisonMainCamera;
cvf::ref<cvf::Scene> m_comparisonMainScene;
cvf::Collection<cvf::Scene> m_comparisonFrameScenes;
cvf::Collection<cvf::Model> m_comparisonStaticModels;
cvf::Vec3d m_comparisonViewOffset;
cvf::ref<cvf::RenderingScissor> m_comparisonRenderingScissor;
cvf::Rectf m_comparisonWindowNormalizedRect;
// Poi visualization
cvf::ref<PointOfInterestVisualizer> m_poiVisualizationManager;
@ -241,6 +274,9 @@ private:
int m_offscreenViewportWidth;
int m_offscreenViewportHeight;
cvf::ref<cvf::Rendering> m_quadRendering;
cvf::ref<cvf::Rendering> m_overlayItemsRendering;
};
} // End namespace caf

2
Fwk/VizFwk/LibRender/CMakeLists.txt
View File

@ -97,6 +97,7 @@ cvfUniformSet.h
cvfVertexAttribute.h
cvfVertexBundle.h
cvfViewport.h
cvfRenderingScissor.h
)
set(CEE_SOURCE_FILES
@ -172,6 +173,7 @@ cvfUniformSet.cpp
cvfVertexAttribute.cpp
cvfVertexBundle.cpp
cvfViewport.cpp
cvfRenderingScissor.cpp
)
add_library(${PROJECT_NAME} ${CEE_HEADER_FILES} ${CEE_SOURCE_FILES})

179
Fwk/VizFwk/LibRender/cvfRenderingScissor.cpp Normal file
View File

@ -0,0 +1,179 @@
//##################################################################################################
//
// 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 "cvfRenderingScissor.h"
#include "cvfOpenGL.h"
namespace cvf {
//==================================================================================================
///
/// \class cvf::RenderingScissor
/// \ingroup Render
///
/// An OpenGL Scissor.
///
/// Stores scissoring settings that are applied to the OpenGl state when calling applyOpenGL()
/// unApplyOpenGL will restore the scissoring settings to what they where before the call to applyOpenGl()
///
//==================================================================================================
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RenderingScissor::RenderingScissor()
: m_x(0),
m_y(0),
m_width(0),
m_height(0),
m_scissorEnabledStateToRestore(false)
{
m_scissorBoxToRestore[0] = 0;
m_scissorBoxToRestore[1] = 0;
m_scissorBoxToRestore[2] = -1;
m_scissorBoxToRestore[3] = -1;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RenderingScissor::setScissorRectangle(int x, int y, uint width, uint height)
{
m_x = x;
m_y = y;
m_width = width;
m_height = height;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int RenderingScissor::x() const
{
return m_x;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int RenderingScissor::y() const
{
return m_y;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
uint RenderingScissor::width() const
{
return m_width;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
uint RenderingScissor::height() const
{
return m_height;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RenderingScissor::applyOpenGL(OpenGLContext* oglContext, Viewport::ClearMode clearMode, const Color4f& clearColor)
{
CVF_CHECK_OGL(oglContext);
m_scissorEnabledStateToRestore = glIsEnabled(GL_SCISSOR_TEST);
glGetIntegerv(GL_SCISSOR_BOX, m_scissorBoxToRestore);
glScissor(static_cast<GLsizei>(m_x),
static_cast<GLsizei>(m_y),
static_cast<GLsizei>(m_width),
static_cast<GLsizei>(m_height));
glEnable(GL_SCISSOR_TEST);
GLbitfield clearFlags = Viewport::clearFlagsOpenGL(clearMode);
if (clearFlags != 0)
{
if ( clearFlags & GL_COLOR_BUFFER_BIT )
{
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glClearColor(clearColor.r(), clearColor.g(), clearColor.b(), clearColor.a());
}
if ( clearFlags & GL_DEPTH_BUFFER_BIT )
{
glDepthMask(GL_TRUE);
#ifndef CVF_OPENGL_ES
glClearDepth(1.0f);
#endif // CVF_OPENGL_ES
}
if ( clearFlags & GL_STENCIL_BUFFER_BIT )
{
glStencilMask(0xffffffff);
glClearStencil(0);
}
glClear(clearFlags);
}
CVF_CHECK_OGL(oglContext);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RenderingScissor::unApplyOpenGL(OpenGLContext* oglContext)
{
if ( m_scissorEnabledStateToRestore )
{
glEnable(GL_SCISSOR_TEST);
}
else
{
glDisable(GL_SCISSOR_TEST);
}
glScissor(m_scissorBoxToRestore[0],
m_scissorBoxToRestore[1],
m_scissorBoxToRestore[2],
m_scissorBoxToRestore[3]);
}
}

81
Fwk/VizFwk/LibRender/cvfRenderingScissor.h Normal file
View File

@ -0,0 +1,81 @@
//##################################################################################################
//
// 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.
//
//##################################################################################################
#pragma once
#include "cvfBase.h"
#include "cvfObject.h"
#include "cvfViewport.h"
namespace cvf {
class OpenGLContext;
//==================================================================================================
//
// OpenGL Scissoring
//
//==================================================================================================
class RenderingScissor : public Object
{
public:
RenderingScissor();
~RenderingScissor(){}
void setScissorRectangle(int x, int y, uint width, uint height);
int x() const;
int y() const;
uint width() const;
uint height() const;
void applyOpenGL(OpenGLContext* oglContext, Viewport::ClearMode clearMode, const Color4f& clearColor);
void unApplyOpenGL(OpenGLContext* oglContext);
private:
int m_x;
int m_y;
uint m_width;
uint m_height;
int m_scissorBoxToRestore[4];
bool m_scissorEnabledStateToRestore;
};
}

58
Fwk/VizFwk/LibRender/cvfViewport.cpp
View File

@ -61,7 +61,7 @@ namespace cvf {
///
//--------------------------------------------------------------------------------------------------
Viewport::Viewport()
: m_x(0),
: m_x(0),
m_y(0),
m_width(0),
m_height(0),
@ -206,9 +206,9 @@ void Viewport::applyOpenGL(OpenGLContext* oglContext, ClearMode clearMode)
if (clearFlags & GL_DEPTH_BUFFER_BIT)
{
glDepthMask(GL_TRUE);
#ifndef CVF_OPENGL_ES
#ifndef CVF_OPENGL_ES
glClearDepth(m_clearDepth);
#endif // CVF_OPENGL_ES
#endif // CVF_OPENGL_ES
}
if (clearFlags & GL_STENCIL_BUFFER_BIT)
@ -227,32 +227,32 @@ void Viewport::applyOpenGL(OpenGLContext* oglContext, ClearMode clearMode)
// Do the actual clear
glClear(clearFlags);
// {
// // Code to draw a full screen quad into color buffer using FF
// // Experimented with this code when seeing problems with rendering to texture on ATI Catalys 11.3 where
// // it seemed that lazy clearing of color buffer was causing problems with depth peeling and glGenerateMipmap()
// glMatrixMode(GL_PROJECTION);
// glLoadIdentity();
// glMatrixMode(GL_MODELVIEW);
// glLoadIdentity();
//
// glDisable(GL_DEPTH_TEST);
// glDepthMask(GL_FALSE);
// glDisable(GL_LIGHTING);
// glColor3f(0, 1, 0);
//
// glBegin(GL_QUADS);
// {
// glVertex2f(-1.0, -1.0);
// glVertex2f( 1.0, -1.0);
// glVertex2f( 1.0, 1.0);
// glVertex2f(-1.0, 1.0);
// }
// glEnd();
//
// glEnable(GL_DEPTH_TEST);
// glDepthMask(GL_TRUE);
// }
// {
// // Code to draw a full screen quad into color buffer using FF
// // Experimented with this code when seeing problems with rendering to texture on ATI Catalys 11.3 where
// // it seemed that lazy clearing of color buffer was causing problems with depth peeling and glGenerateMipmap()
// glMatrixMode(GL_PROJECTION);
// glLoadIdentity();
// glMatrixMode(GL_MODELVIEW);
// glLoadIdentity();
//
// glDisable(GL_DEPTH_TEST);
// glDepthMask(GL_FALSE);
// glDisable(GL_LIGHTING);
// glColor3f(0, 1, 0);
//
// glBegin(GL_QUADS);
// {
// glVertex2f(-1.0, -1.0);
// glVertex2f( 1.0, -1.0);
// glVertex2f( 1.0, 1.0);
// glVertex2f(-1.0, 1.0);
// }
// glEnd();
//
// glEnable(GL_DEPTH_TEST);
// glDepthMask(GL_TRUE);
// }
// Restore scissor settings
if (!scissorWasOn) glDisable(GL_SCISSOR_TEST);

3
Fwk/VizFwk/LibRender/cvfViewport.h
View File

@ -85,8 +85,7 @@ public:
String debugString() const;
private:
cvfGLbitfield clearFlagsOpenGL(ClearMode clearMode);
static cvfGLbitfield clearFlagsOpenGL(ClearMode clearMode);
private:
int m_x;

26
Fwk/VizFwk/LibViewing/cvfRendering.cpp
View File

@ -57,6 +57,7 @@
#include "cvfRayIntersectSpec.h"
#include "cvfHitItemCollection.h"
#include "cvfLogManager.h"
#include "cvfRenderingScissor.h"
namespace cvf {
@ -214,7 +215,17 @@ void Rendering::render(OpenGLContext* oglContext)
// Setup camera and view
// -------------------------------------------------------------------------
m_camera->viewport()->applyOpenGL(oglContext, m_clearMode);
if (m_renderingScissor.notNull())
{
m_camera->viewport()->applyOpenGL(oglContext, Viewport::DO_NOT_CLEAR);
m_renderingScissor->applyOpenGL(oglContext, m_clearMode, m_camera->viewport()->clearColor());
}
else
{
m_camera->viewport()->applyOpenGL(oglContext, m_clearMode);
}
m_camera->applyOpenGL();
// Update dynamic uniforms and dynamic uniform sets
@ -261,6 +272,11 @@ void Rendering::render(OpenGLContext* oglContext)
size_t numPartsToDraw = std::min(m_maxNumPartsToDraw, renderQueue.count());
m_renderEngine.render(oglContext, &renderQueue, numPartsToDraw, *m_camera, globalUniformSet);
if (m_renderingScissor.notNull())
{
m_renderingScissor->unApplyOpenGL(oglContext);
}
if (renderTimer.notNull())
{
m_performanceInfo.renderEngineTime = renderTimer->lapTime();
@ -662,6 +678,14 @@ Viewport::ClearMode Rendering::clearMode() const
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rendering::setRenderingScissor(RenderingScissor* scissor)
{
m_renderingScissor = scissor;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

6
Fwk/VizFwk/LibViewing/cvfRendering.h
View File

@ -61,7 +61,7 @@ class UniformSet;
class RayIntersectSpec;
class HitItemCollection;
class OpenGLContext;
class RenderingScissor;
//==================================================================================================
@ -106,6 +106,7 @@ public:
void setClearMode(Viewport::ClearMode clearMode);
Viewport::ClearMode clearMode() const;
void setRenderingScissor(RenderingScissor* scissor);
void setEffectOverride(Effect* effect);
Effect* effectOverride();
@ -160,7 +161,8 @@ private:
uint m_enableMask; // Mask will be compared against the contained scene's models and the model's parts when determining visible parts
Viewport::ClearMode m_clearMode;
ref<Effect> m_effectOverride; // Can hold an overriding effect. All parts drawn by this rendering will use this effect
ref<RenderingScissor> m_renderingScissor; // Can hold a scissor used on the rendered scene. Will not affect overly items
Collection<DynamicUniformSet> m_dynamicUniformSets; // Collection of user added dynamic uniform sets
Collection<DynamicUniformSet> m_globalDynamicUniformSets; // Collection of global user added dynamic uniform sets
ref<UniformSet> m_combinedGlobalUniformSet; // Global uniform set, this is the combination of the uniform sets from all the dynamic uniform sets