mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-08 07:03:25 -06:00
707 lines
25 KiB
C++
707 lines
25 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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 );
|
|
}
|
|
|
|
// For extreme zoom factors we might end up with both variables as zero. Return to avoid divide by zero.
|
|
if ( windowOrigoInDomain == windowMaxInDomain ) return;
|
|
|
|
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;
|
|
}
|