mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
Rename ApplicationCode to ApplicationLibCode
This commit is contained in:
Gaute Lindkvist
@@ -0,0 +1,19 @@
|
||||
|
||||
set (SOURCE_GROUP_HEADER_FILES
|
||||
${CMAKE_CURRENT_LIST_DIR}/RivWindowEdgeAxesOverlayItem.h
|
||||
)
|
||||
|
||||
set (SOURCE_GROUP_SOURCE_FILES
|
||||
${CMAKE_CURRENT_LIST_DIR}/RivWindowEdgeAxesOverlayItem.cpp
|
||||
|
||||
)
|
||||
|
||||
list(APPEND CODE_HEADER_FILES
|
||||
${SOURCE_GROUP_HEADER_FILES}
|
||||
)
|
||||
|
||||
list(APPEND CODE_SOURCE_FILES
|
||||
${SOURCE_GROUP_SOURCE_FILES}
|
||||
)
|
||||
|
||||
source_group( "ModelVisualization\\WindowEdgeAxesOverlayItem" FILES ${SOURCE_GROUP_HEADER_FILES} ${SOURCE_GROUP_SOURCE_FILES} ${CMAKE_CURRENT_LIST_DIR}/CMakeLists_files.cmake )
|
||||
@@ -0,0 +1,707 @@
|
||||
/////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// 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 "RivWindowEdgeAxesOverlayItem.h"
|
||||
|
||||
#include "cvfBufferObjectManaged.h"
|
||||
#include "cvfCamera.h"
|
||||
#include "cvfFont.h"
|
||||
#include "cvfGeometryBuilderDrawableGeo.h"
|
||||
#include "cvfGeometryUtils.h"
|
||||
#include "cvfGlyph.h"
|
||||
#include "cvfMatrixState.h"
|
||||
#include "cvfOpenGL.h"
|
||||
#include "cvfOpenGLResourceManager.h"
|
||||
#include "cvfRenderStateDepth.h"
|
||||
#include "cvfRenderStateLine.h"
|
||||
#include "cvfShaderProgram.h"
|
||||
#include "cvfShaderProgramGenerator.h"
|
||||
#include "cvfShaderSourceProvider.h"
|
||||
#include "cvfShaderSourceRepository.h"
|
||||
#include "cvfTextDrawer.h"
|
||||
#include "cvfUniform.h"
|
||||
#include "cvfViewport.h"
|
||||
|
||||
#ifndef CVF_OPENGL_ES
|
||||
#include "cvfRenderState_FF.h"
|
||||
#endif
|
||||
|
||||
#include "cafTickMarkGenerator.h"
|
||||
#include "cvfRenderStateBlending.h"
|
||||
#include "cvfScalarMapper.h"
|
||||
#include <array>
|
||||
|
||||
using namespace cvf;
|
||||
|
||||
//==================================================================================================
|
||||
///
|
||||
/// \class cvf::OverlayColorLegend
|
||||
/// \ingroup Render
|
||||
///
|
||||
///
|
||||
///
|
||||
//==================================================================================================
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Constructor
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RivWindowEdgeAxesOverlayItem::RivWindowEdgeAxesOverlayItem( Font* font )
|
||||
: m_windowSize( 600, 600 )
|
||||
, m_textColor( Color3::BLACK )
|
||||
, m_lineColor( Color3::BLACK )
|
||||
, m_frameColor( Color3::WHITE )
|
||||
, m_lineWidth( 1 )
|
||||
, m_font( font )
|
||||
, m_isSwitchingYAxisValueSign( true )
|
||||
, m_showAxisLines( false )
|
||||
, m_domainAxes( XZ_AXES )
|
||||
{
|
||||
CVF_ASSERT( font );
|
||||
CVF_ASSERT( !font->isEmpty() );
|
||||
|
||||
setLayoutFixedPosition( { 0, 0 } );
|
||||
updateGeomerySizes();
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
RivWindowEdgeAxesOverlayItem::~RivWindowEdgeAxesOverlayItem()
|
||||
{
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::setDisplayCoordTransform( const caf::DisplayCoordTransform* displayCoordTransform )
|
||||
{
|
||||
m_dispalyCoordsTransform = displayCoordTransform;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::updateGeomerySizes()
|
||||
{
|
||||
String str = String::number( -1.999e-17 );
|
||||
m_textSize = m_font->textExtent( str );
|
||||
m_pixelSpacing = 5.0f;
|
||||
m_tickLineLength = m_textSize.y() * 0.3f;
|
||||
m_frameBorderHeight = m_pixelSpacing + m_textSize.y() + m_pixelSpacing + m_tickLineLength + m_lineWidth;
|
||||
m_frameBorderWidth = m_pixelSpacing + m_textSize.x() + m_pixelSpacing + m_tickLineLength + m_lineWidth;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::updateFromCamera( const Camera* camera )
|
||||
{
|
||||
if ( !camera || camera->projection() != Camera::ORTHO )
|
||||
{
|
||||
m_domainCoordsXValues.clear();
|
||||
m_domainCoordsYValues.clear();
|
||||
m_windowTickXValues.clear();
|
||||
m_windowTickYValues.clear();
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
m_windowSize = Vec2ui( camera->viewport()->width(), camera->viewport()->height() );
|
||||
Vec3d windowOrigoInDomain;
|
||||
Vec3d windowMaxInDomain;
|
||||
camera->unproject( Vec3d( 0, 0, 0 ), &windowOrigoInDomain );
|
||||
camera->unproject( Vec3d( m_windowSize.x(), m_windowSize.y(), 0 ), &windowMaxInDomain );
|
||||
|
||||
if ( m_dispalyCoordsTransform.notNull() )
|
||||
{
|
||||
windowOrigoInDomain = m_dispalyCoordsTransform->transformToDomainCoord( windowOrigoInDomain );
|
||||
windowMaxInDomain = m_dispalyCoordsTransform->transformToDomainCoord( windowMaxInDomain );
|
||||
}
|
||||
|
||||
double domainMinX = windowOrigoInDomain.x();
|
||||
double domainMaxX = windowMaxInDomain.x();
|
||||
|
||||
double domainMinY = m_domainAxes == XY_AXES ? windowOrigoInDomain.y() : windowOrigoInDomain.z();
|
||||
double domainMaxY = m_domainAxes == XY_AXES ? windowMaxInDomain.y() : windowMaxInDomain.z();
|
||||
|
||||
int xTickMaxCount = m_windowSize.x() / ( 2 * m_textSize.x() );
|
||||
int yTickMaxCount = m_windowSize.y() / ( 2 * m_textSize.x() );
|
||||
|
||||
double minDomainXStepSize = ( domainMaxX - domainMinX ) / xTickMaxCount;
|
||||
caf::TickMarkGenerator xTickCreator( domainMinX, domainMaxX, minDomainXStepSize );
|
||||
m_domainCoordsXValues = xTickCreator.tickMarkValues();
|
||||
|
||||
double minDomainYStepSize = ( domainMaxY - domainMinY ) / yTickMaxCount;
|
||||
caf::TickMarkGenerator yTickCreator( domainMinY, domainMaxY, minDomainYStepSize );
|
||||
m_domainCoordsYValues = yTickCreator.tickMarkValues();
|
||||
|
||||
m_windowTickXValues.clear();
|
||||
Vec3d windowPoint;
|
||||
for ( double domainX : m_domainCoordsXValues )
|
||||
{
|
||||
Vec3d displayDomainTick;
|
||||
if ( m_domainAxes == XY_AXES )
|
||||
{
|
||||
displayDomainTick = Vec3d( domainX, domainMinY, 0 );
|
||||
}
|
||||
else
|
||||
{
|
||||
displayDomainTick = Vec3d( domainX, 0, domainMinY );
|
||||
}
|
||||
if ( m_dispalyCoordsTransform.notNull() )
|
||||
{
|
||||
displayDomainTick = m_dispalyCoordsTransform->transformToDisplayCoord( displayDomainTick );
|
||||
}
|
||||
camera->project( displayDomainTick, &windowPoint );
|
||||
m_windowTickXValues.push_back( windowPoint.x() );
|
||||
}
|
||||
|
||||
m_windowTickYValues.clear();
|
||||
for ( double domainY : m_domainCoordsYValues )
|
||||
{
|
||||
Vec3d displayDomainTick;
|
||||
|
||||
if ( m_domainAxes == XY_AXES )
|
||||
{
|
||||
displayDomainTick = Vec3d( domainMinX, domainY, 0 );
|
||||
}
|
||||
else
|
||||
{
|
||||
displayDomainTick = Vec3d( domainMinX, 0, domainY );
|
||||
}
|
||||
|
||||
if ( m_dispalyCoordsTransform.notNull() )
|
||||
{
|
||||
displayDomainTick = m_dispalyCoordsTransform->transformToDisplayCoord( displayDomainTick );
|
||||
}
|
||||
camera->project( displayDomainTick, &windowPoint );
|
||||
m_windowTickYValues.push_back( windowPoint.y() );
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
cvf::Vec2ui RivWindowEdgeAxesOverlayItem::sizeHint()
|
||||
{
|
||||
return m_windowSize;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Set color of the text and lines to be rendered
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::setTextColor( const Color3f& color )
|
||||
{
|
||||
m_textColor = color;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Returns the color of the text and lines
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
const Color3f& RivWindowEdgeAxesOverlayItem::textColor() const
|
||||
{
|
||||
return m_textColor;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Hardware rendering using shader programs
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::render( OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size )
|
||||
{
|
||||
renderGeneric( oglContext, position, size, false );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Software rendering using software
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::renderSoftware( OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size )
|
||||
{
|
||||
renderGeneric( oglContext, position, size, true );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
bool RivWindowEdgeAxesOverlayItem::pick( int oglXCoord, int oglYCoord, const Vec2i& position, const Vec2ui& size )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Set up camera/viewport and render
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::renderGeneric( OpenGLContext* oglContext,
|
||||
const Vec2i& position,
|
||||
const Vec2ui& size,
|
||||
bool software )
|
||||
{
|
||||
if ( size.x() <= 0 || size.y() <= 0 || ( m_windowTickXValues.size() == 0 && m_windowTickYValues.size() == 0 ) )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
Camera camera;
|
||||
camera.setViewport( position.x(), position.y(), size.x(), size.y() );
|
||||
camera.setProjectionAsPixelExact2D();
|
||||
camera.setViewMatrix( Mat4d::IDENTITY );
|
||||
camera.applyOpenGL();
|
||||
camera.viewport()->applyOpenGL( oglContext, Viewport::CLEAR_DEPTH );
|
||||
|
||||
TextDrawer textDrawer( m_font.p() );
|
||||
addTextToTextDrawer( &textDrawer );
|
||||
|
||||
if ( software )
|
||||
{
|
||||
renderSoftwareFrameAndTickLines( oglContext );
|
||||
textDrawer.renderSoftware( oglContext, camera );
|
||||
}
|
||||
else
|
||||
{
|
||||
const MatrixState matrixState( camera );
|
||||
renderShaderFrameAndTickLines( oglContext, matrixState );
|
||||
|
||||
textDrawer.render( oglContext, camera );
|
||||
}
|
||||
|
||||
CVF_CHECK_OGL( oglContext );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::addTextToTextDrawer( TextDrawer* textDrawer )
|
||||
{
|
||||
textDrawer->setVerticalAlignment( TextDrawer::CENTER );
|
||||
textDrawer->setTextColor( m_textColor );
|
||||
|
||||
// Bottom X - axis text
|
||||
{
|
||||
const float textYTop = m_windowSize.y() - m_pixelSpacing - m_textSize.y() * 0.5f;
|
||||
const float textYBott = m_pixelSpacing + m_textSize.y() * 0.5f;
|
||||
|
||||
size_t numTicks = m_domainCoordsXValues.size();
|
||||
size_t i;
|
||||
for ( i = 0; i < numTicks; i++ )
|
||||
{
|
||||
float textX = static_cast<float>( m_windowTickXValues[i] );
|
||||
|
||||
double tickValue = m_domainCoordsXValues[i];
|
||||
String valueString;
|
||||
|
||||
valueString = String::number( tickValue, 'f', 0 );
|
||||
auto labelSize = m_font->textExtent( valueString );
|
||||
|
||||
Vec2f pos( textX - labelSize.x() * 0.5f, textYBott );
|
||||
textDrawer->addText( valueString, pos );
|
||||
pos[1] = textYTop;
|
||||
textDrawer->addText( valueString, pos );
|
||||
}
|
||||
}
|
||||
|
||||
// Right Y - axis texts
|
||||
{
|
||||
const float textXRight = m_windowSize.x() - m_pixelSpacing - m_textSize.x();
|
||||
const float textXLeft = m_frameBorderWidth - m_tickLineLength - m_pixelSpacing;
|
||||
|
||||
size_t numTicks = m_domainCoordsYValues.size();
|
||||
size_t i;
|
||||
for ( i = 0; i < numTicks; i++ )
|
||||
{
|
||||
float textY = static_cast<float>( m_windowTickYValues[i] );
|
||||
|
||||
double tickValue = m_isSwitchingYAxisValueSign ? -m_domainCoordsYValues[i] : m_domainCoordsYValues[i];
|
||||
String valueString;
|
||||
|
||||
valueString = String::number( tickValue, 'f', 0 );
|
||||
auto labelSize = m_font->textExtent( valueString );
|
||||
|
||||
Vec2f pos( textXRight, textY );
|
||||
textDrawer->addText( valueString, pos );
|
||||
Vec2f posl( textXLeft - labelSize.x(), textY );
|
||||
textDrawer->addText( valueString, posl );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
std::array<Vec3f, 8> RivWindowEdgeAxesOverlayItem::frameVertexArray()
|
||||
{
|
||||
float windowWidth = static_cast<float>( m_windowSize.x() );
|
||||
float windowHeight = static_cast<float>( m_windowSize.y() );
|
||||
|
||||
// 3 2
|
||||
// 7 6
|
||||
//
|
||||
// 4 5
|
||||
// 0 1
|
||||
|
||||
std::array<Vec3f, 8> vertexArray = {
|
||||
Vec3f( 0.0f, 0.0f, 0.0f ),
|
||||
Vec3f( windowWidth, 0.0f, 0.0f ),
|
||||
Vec3f( windowWidth, windowHeight, 0.0f ),
|
||||
Vec3f( 0.0f, windowHeight, 0.0f ),
|
||||
|
||||
Vec3f( m_frameBorderWidth, m_frameBorderHeight, 0.0f ),
|
||||
Vec3f( windowWidth - m_frameBorderWidth, m_frameBorderHeight, 0.0f ),
|
||||
Vec3f( windowWidth - m_frameBorderWidth, windowHeight - m_frameBorderHeight, 0.0f ),
|
||||
Vec3f( m_frameBorderWidth, windowHeight - m_frameBorderHeight, 0.0f ),
|
||||
};
|
||||
|
||||
return vertexArray;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Draw the legend using immediate mode OpenGL
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::renderSoftwareFrameAndTickLines( OpenGLContext* oglContext )
|
||||
{
|
||||
RenderStateDepth depth( false );
|
||||
depth.applyOpenGL( oglContext );
|
||||
|
||||
RenderStateLighting_FF lighting( false );
|
||||
lighting.applyOpenGL( oglContext );
|
||||
|
||||
RenderStateBlending blend;
|
||||
blend.configureTransparencyBlending();
|
||||
blend.applyOpenGL( oglContext );
|
||||
|
||||
// Frame vertices
|
||||
|
||||
std::array<Vec3f, 8> vertexArray = frameVertexArray();
|
||||
|
||||
glColor4fv( m_frameColor.ptr() );
|
||||
glBegin( GL_TRIANGLE_FAN );
|
||||
glVertex3fv( vertexArray[0].ptr() );
|
||||
glVertex3fv( vertexArray[1].ptr() );
|
||||
glVertex3fv( vertexArray[5].ptr() );
|
||||
glVertex3fv( vertexArray[4].ptr() );
|
||||
glEnd();
|
||||
glBegin( GL_TRIANGLE_FAN );
|
||||
glVertex3fv( vertexArray[1].ptr() );
|
||||
glVertex3fv( vertexArray[2].ptr() );
|
||||
glVertex3fv( vertexArray[6].ptr() );
|
||||
glVertex3fv( vertexArray[5].ptr() );
|
||||
glEnd();
|
||||
glBegin( GL_TRIANGLE_FAN );
|
||||
glVertex3fv( vertexArray[3].ptr() );
|
||||
glVertex3fv( vertexArray[0].ptr() );
|
||||
glVertex3fv( vertexArray[4].ptr() );
|
||||
glVertex3fv( vertexArray[7].ptr() );
|
||||
glEnd();
|
||||
glBegin( GL_TRIANGLE_FAN );
|
||||
glVertex3fv( vertexArray[2].ptr() );
|
||||
glVertex3fv( vertexArray[3].ptr() );
|
||||
glVertex3fv( vertexArray[7].ptr() );
|
||||
glVertex3fv( vertexArray[6].ptr() );
|
||||
glEnd();
|
||||
|
||||
// Render Line around
|
||||
|
||||
{
|
||||
cvf::Color4f lineColorWithAlpha( m_lineColor, m_showAxisLines ? 0.25f : 1.0f );
|
||||
glColor4fv( lineColorWithAlpha.ptr() );
|
||||
glBegin( GL_LINES );
|
||||
// Frame lines
|
||||
glVertex3fv( vertexArray[7].ptr() );
|
||||
glVertex3fv( vertexArray[4].ptr() );
|
||||
glVertex3fv( vertexArray[4].ptr() );
|
||||
glVertex3fv( vertexArray[5].ptr() );
|
||||
glVertex3fv( vertexArray[5].ptr() );
|
||||
glVertex3fv( vertexArray[6].ptr() );
|
||||
glVertex3fv( vertexArray[6].ptr() );
|
||||
glVertex3fv( vertexArray[7].ptr() );
|
||||
|
||||
// X - axis Tick lines
|
||||
for ( double txpos : m_windowTickXValues )
|
||||
{
|
||||
if ( m_showAxisLines )
|
||||
{
|
||||
Vec3f p1( Vec3f::ZERO );
|
||||
Vec3f p2( Vec3f::ZERO );
|
||||
|
||||
p1[0] = (float)txpos;
|
||||
p1[1] = m_frameBorderHeight - m_tickLineLength;
|
||||
p2[0] = (float)txpos;
|
||||
p2[1] = m_windowSize.y() - m_frameBorderHeight + m_tickLineLength;
|
||||
|
||||
glVertex3fv( p1.ptr() );
|
||||
glVertex3fv( p2.ptr() );
|
||||
}
|
||||
else
|
||||
{
|
||||
Vec3f p1( Vec3f::ZERO );
|
||||
Vec3f p2( Vec3f::ZERO );
|
||||
|
||||
p1[0] = (float)txpos;
|
||||
p1[1] = m_frameBorderHeight;
|
||||
p2[0] = (float)txpos;
|
||||
p2[1] = m_frameBorderHeight - m_tickLineLength;
|
||||
|
||||
glVertex3fv( p1.ptr() );
|
||||
glVertex3fv( p2.ptr() );
|
||||
|
||||
p1[0] = (float)txpos;
|
||||
p1[1] = m_windowSize.y() - m_frameBorderHeight;
|
||||
p2[0] = (float)txpos;
|
||||
p2[1] = m_windowSize.y() - m_frameBorderHeight + m_tickLineLength;
|
||||
|
||||
glVertex3fv( p1.ptr() );
|
||||
glVertex3fv( p2.ptr() );
|
||||
}
|
||||
}
|
||||
|
||||
// Left Y - axis Tick lines
|
||||
for ( double typos : m_windowTickYValues )
|
||||
{
|
||||
if ( m_showAxisLines )
|
||||
{
|
||||
Vec3f p1( Vec3f::ZERO );
|
||||
Vec3f p2( Vec3f::ZERO );
|
||||
|
||||
p1[0] = m_frameBorderWidth - m_tickLineLength;
|
||||
p1[1] = (float)typos;
|
||||
p2[0] = m_windowSize.x() - m_frameBorderWidth + m_tickLineLength;
|
||||
p2[1] = (float)typos;
|
||||
|
||||
glVertex3fv( p1.ptr() );
|
||||
glVertex3fv( p2.ptr() );
|
||||
}
|
||||
else
|
||||
{
|
||||
Vec3f p1( Vec3f::ZERO );
|
||||
Vec3f p2( Vec3f::ZERO );
|
||||
|
||||
p1[0] = m_frameBorderWidth;
|
||||
p1[1] = (float)typos;
|
||||
p2[0] = m_frameBorderWidth - m_tickLineLength;
|
||||
p2[1] = (float)typos;
|
||||
|
||||
glVertex3fv( p1.ptr() );
|
||||
glVertex3fv( p2.ptr() );
|
||||
|
||||
p1[0] = m_windowSize.x() - m_frameBorderWidth;
|
||||
p1[1] = (float)typos;
|
||||
p2[0] = m_windowSize.x() - m_frameBorderWidth + m_tickLineLength;
|
||||
p2[1] = (float)typos;
|
||||
|
||||
glVertex3fv( p1.ptr() );
|
||||
glVertex3fv( p2.ptr() );
|
||||
}
|
||||
}
|
||||
|
||||
glEnd();
|
||||
}
|
||||
|
||||
// Reset render states
|
||||
|
||||
RenderStateLighting_FF resetLighting;
|
||||
resetLighting.applyOpenGL( oglContext );
|
||||
RenderStateDepth resetDepth;
|
||||
resetDepth.applyOpenGL( oglContext );
|
||||
RenderStateBlending resetblend;
|
||||
resetblend.applyOpenGL( oglContext );
|
||||
CVF_CHECK_OGL( oglContext );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
/// Draw the frame using shader programs
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::renderShaderFrameAndTickLines( OpenGLContext* oglContext, const MatrixState& matrixState )
|
||||
{
|
||||
CVF_CALLSITE_OPENGL( oglContext );
|
||||
|
||||
RenderStateDepth depth( false );
|
||||
depth.applyOpenGL( oglContext );
|
||||
|
||||
RenderStateLine line( static_cast<float>( m_lineWidth ) );
|
||||
line.applyOpenGL( oglContext );
|
||||
|
||||
RenderStateBlending blend;
|
||||
blend.configureTransparencyBlending();
|
||||
blend.applyOpenGL( oglContext );
|
||||
|
||||
// Shader program
|
||||
|
||||
ref<ShaderProgram> shaderProgram = oglContext->resourceManager()->getLinkedUnlitColorShaderProgram( oglContext );
|
||||
CVF_TIGHT_ASSERT( shaderProgram.notNull() );
|
||||
|
||||
if ( shaderProgram->useProgram( oglContext ) )
|
||||
{
|
||||
shaderProgram->clearUniformApplyTracking();
|
||||
shaderProgram->applyFixedUniforms( oglContext, matrixState );
|
||||
}
|
||||
|
||||
// Frame vertices
|
||||
std::array<Vec3f, 8> vertexArray = frameVertexArray();
|
||||
|
||||
glBindBuffer( GL_ARRAY_BUFFER, 0 );
|
||||
glEnableVertexAttribArray( ShaderProgram::VERTEX );
|
||||
glVertexAttribPointer( ShaderProgram::VERTEX, 3, GL_FLOAT, GL_FALSE, 0, vertexArray.data() );
|
||||
|
||||
// Draw frame background
|
||||
|
||||
UniformFloat backgroundColorUniform( "u_color", m_frameColor );
|
||||
shaderProgram->applyUniform( oglContext, backgroundColorUniform );
|
||||
|
||||
// Triangle indices for the frame background
|
||||
|
||||
static const ushort backgroundTriangleIndices[] = { 0, 1, 5, 0, 5, 4, 1, 2, 6, 1, 6, 5,
|
||||
3, 0, 4, 3, 4, 7, 2, 3, 6, 3, 7, 6 };
|
||||
|
||||
glDrawRangeElements( GL_TRIANGLES, 0, 7, 24, GL_UNSIGNED_SHORT, backgroundTriangleIndices );
|
||||
|
||||
// Draw frame border lines
|
||||
|
||||
UniformFloat uniformColor( "u_color", Color4f( m_lineColor, m_showAxisLines ? 0.25f : 1.0f ) );
|
||||
shaderProgram->applyUniform( oglContext, uniformColor );
|
||||
|
||||
static const ushort frameLineIndices[] = { 7, 4, 4, 5, 5, 6, 6, 7 };
|
||||
|
||||
glDrawRangeElements( GL_LINES, 0, 7, 8, GL_UNSIGNED_SHORT, frameLineIndices );
|
||||
|
||||
// Render tickmarks
|
||||
|
||||
static const ushort tickLineIndices[] = { 0, 1 };
|
||||
|
||||
// X - axis Tick lines
|
||||
|
||||
for ( double txpos : m_windowTickXValues )
|
||||
{
|
||||
if ( m_showAxisLines )
|
||||
{
|
||||
vertexArray[0][0] = (float)txpos;
|
||||
vertexArray[0][1] = m_frameBorderHeight - m_tickLineLength;
|
||||
vertexArray[1][0] = (float)txpos;
|
||||
vertexArray[1][1] = m_windowSize.y() - m_frameBorderHeight + m_tickLineLength;
|
||||
|
||||
glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
|
||||
}
|
||||
else
|
||||
{
|
||||
vertexArray[0][0] = (float)txpos;
|
||||
vertexArray[0][1] = m_frameBorderHeight;
|
||||
vertexArray[1][0] = (float)txpos;
|
||||
vertexArray[1][1] = m_frameBorderHeight - m_tickLineLength;
|
||||
|
||||
glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
|
||||
|
||||
vertexArray[0][0] = (float)txpos;
|
||||
vertexArray[0][1] = m_windowSize.y() - m_frameBorderHeight;
|
||||
vertexArray[1][0] = (float)txpos;
|
||||
vertexArray[1][1] = m_windowSize.y() - m_frameBorderHeight + m_tickLineLength;
|
||||
|
||||
glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
|
||||
}
|
||||
}
|
||||
|
||||
// Left Y - axis Tick lines
|
||||
|
||||
for ( double typos : m_windowTickYValues )
|
||||
{
|
||||
if ( m_showAxisLines )
|
||||
{
|
||||
vertexArray[0][0] = m_frameBorderWidth - m_tickLineLength;
|
||||
vertexArray[0][1] = (float)typos;
|
||||
vertexArray[1][0] = m_windowSize.x() - m_frameBorderWidth + m_tickLineLength;
|
||||
vertexArray[1][1] = (float)typos;
|
||||
glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
|
||||
}
|
||||
else
|
||||
{
|
||||
vertexArray[0][0] = m_frameBorderWidth;
|
||||
vertexArray[0][1] = (float)typos;
|
||||
vertexArray[1][0] = m_frameBorderWidth - m_tickLineLength;
|
||||
vertexArray[1][1] = (float)typos;
|
||||
|
||||
glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
|
||||
|
||||
vertexArray[0][0] = m_windowSize.x() - m_frameBorderWidth;
|
||||
vertexArray[0][1] = (float)typos;
|
||||
vertexArray[1][0] = m_windowSize.x() - m_frameBorderWidth + m_tickLineLength;
|
||||
vertexArray[1][1] = (float)typos;
|
||||
|
||||
glDrawRangeElements( GL_LINES, 0, 1, 2, GL_UNSIGNED_SHORT, tickLineIndices );
|
||||
}
|
||||
}
|
||||
|
||||
glDisableVertexAttribArray( ShaderProgram::VERTEX );
|
||||
|
||||
CVF_TIGHT_ASSERT( shaderProgram.notNull() );
|
||||
shaderProgram->useNoProgram( oglContext );
|
||||
|
||||
// Reset render states
|
||||
RenderStateDepth resetDepth;
|
||||
resetDepth.applyOpenGL( oglContext );
|
||||
|
||||
RenderStateLine resetLine;
|
||||
resetLine.applyOpenGL( oglContext );
|
||||
|
||||
RenderStateBlending resetblend;
|
||||
resetblend.applyOpenGL( oglContext );
|
||||
|
||||
CVF_CHECK_OGL( oglContext );
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::setLineColor( const Color3f& lineColor )
|
||||
{
|
||||
m_lineColor = lineColor;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
const Color3f& RivWindowEdgeAxesOverlayItem::lineColor() const
|
||||
{
|
||||
return m_lineColor;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::setFrameColor( const Color4f& frameColor )
|
||||
{
|
||||
m_frameColor = frameColor;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::setDomainAxes( DomainAxes axes )
|
||||
{
|
||||
m_domainAxes = axes;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::setIsSwitchingYAxisSign( bool switchSign )
|
||||
{
|
||||
m_isSwitchingYAxisValueSign = switchSign;
|
||||
}
|
||||
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
///
|
||||
//--------------------------------------------------------------------------------------------------
|
||||
void RivWindowEdgeAxesOverlayItem::setShowAxisLines( bool showAxisLines )
|
||||
{
|
||||
m_showAxisLines = showAxisLines;
|
||||
}
|
||||
@@ -0,0 +1,147 @@
|
||||
//##################################################################################################
|
||||
//
|
||||
// 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 "cafDisplayCoordTransform.h"
|
||||
#include "cvfArray.h"
|
||||
#include "cvfCamera.h"
|
||||
#include "cvfOverlayItem.h"
|
||||
#include "cvfRect.h"
|
||||
#include "cvfString.h"
|
||||
|
||||
namespace caf
|
||||
{
|
||||
class DisplayCoordTransform;
|
||||
}
|
||||
|
||||
namespace cvf
|
||||
{
|
||||
class Font;
|
||||
class ShaderProgram;
|
||||
class MatrixState;
|
||||
class TextDrawer;
|
||||
class ScalarMapper;
|
||||
} // namespace cvf
|
||||
|
||||
//==================================================================================================
|
||||
//
|
||||
// Overlay color legend
|
||||
//
|
||||
//==================================================================================================
|
||||
class RivWindowEdgeAxesOverlayItem : public cvf::OverlayItem
|
||||
{
|
||||
using Font = cvf::Font;
|
||||
using Vec2ui = cvf::Vec2ui;
|
||||
using ScalarMapper = cvf::ScalarMapper;
|
||||
using OpenGLContext = cvf::OpenGLContext;
|
||||
using Vec2i = cvf::Vec2i;
|
||||
using Color3f = cvf::Color3f;
|
||||
using Color4f = cvf::Color4f;
|
||||
using String = cvf::String;
|
||||
using Vec2f = cvf::Vec2f;
|
||||
using Vec3f = cvf::Vec3f;
|
||||
using Rectf = cvf::Rectf;
|
||||
using DoubleArray = cvf::DoubleArray;
|
||||
using MatrixState = cvf::MatrixState;
|
||||
using TextDrawer = cvf::TextDrawer;
|
||||
using Camera = cvf::Camera;
|
||||
|
||||
public:
|
||||
enum DomainAxes
|
||||
{
|
||||
XY_AXES,
|
||||
XZ_AXES
|
||||
};
|
||||
|
||||
public:
|
||||
RivWindowEdgeAxesOverlayItem( Font* font );
|
||||
~RivWindowEdgeAxesOverlayItem() override;
|
||||
|
||||
void setDisplayCoordTransform( const caf::DisplayCoordTransform* displayCoordTransform );
|
||||
void updateFromCamera( const Camera* camera );
|
||||
|
||||
void setTextColor( const Color3f& color );
|
||||
const Color3f& textColor() const;
|
||||
void setLineColor( const Color3f& lineColor );
|
||||
const Color3f& lineColor() const;
|
||||
void setFrameColor( const Color4f& frameColor );
|
||||
void setDomainAxes( DomainAxes axes );
|
||||
void setIsSwitchingYAxisSign( bool switchSign );
|
||||
int frameBorderWidth() { return static_cast<int>( m_frameBorderWidth ); }
|
||||
int frameBorderHeight() { return static_cast<int>( m_frameBorderHeight ); }
|
||||
|
||||
void setShowAxisLines( bool showAxisLines );
|
||||
|
||||
protected:
|
||||
Vec2ui sizeHint() override;
|
||||
void render( OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size ) override;
|
||||
void renderSoftware( OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size ) override;
|
||||
bool pick( int oglXCoord, int oglYCoord, const Vec2i& position, const Vec2ui& size ) override;
|
||||
|
||||
private:
|
||||
void updateGeomerySizes();
|
||||
void renderGeneric( OpenGLContext* oglContext, const Vec2i& position, const Vec2ui& size, bool software );
|
||||
void renderSoftwareFrameAndTickLines( OpenGLContext* oglContext );
|
||||
void renderShaderFrameAndTickLines( OpenGLContext* oglContext, const MatrixState& matrixState );
|
||||
void addTextToTextDrawer( TextDrawer* textDrawer );
|
||||
|
||||
std::array<Vec3f, 8> frameVertexArray();
|
||||
|
||||
private:
|
||||
cvf::cref<caf::DisplayCoordTransform> m_dispalyCoordsTransform;
|
||||
|
||||
Vec2ui m_windowSize; // Pixel size of the window
|
||||
Vec2ui m_textSize;
|
||||
Color3f m_textColor;
|
||||
Color3f m_lineColor;
|
||||
Color4f m_frameColor;
|
||||
int m_lineWidth;
|
||||
cvf::ref<Font> m_font;
|
||||
|
||||
float m_frameBorderHeight;
|
||||
float m_frameBorderWidth;
|
||||
float m_tickLineLength;
|
||||
float m_pixelSpacing;
|
||||
bool m_isSwitchingYAxisValueSign;
|
||||
bool m_showAxisLines;
|
||||
DomainAxes m_domainAxes;
|
||||
|
||||
std::vector<double> m_domainCoordsXValues;
|
||||
std::vector<double> m_domainCoordsYValues;
|
||||
std::vector<double> m_windowTickXValues;
|
||||
std::vector<double> m_windowTickYValues;
|
||||
};
|
||||
Reference in New Issue
Block a user