OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-05 18:16:23 +03:00
Code Packages Releases Activity
occt/src/OpenGl/OpenGl_View_2.cxx

1326 lines
42 KiB
C++
Raw Blame History

// Created on: 2011-09-20
// Created by: Sergey ZERCHANINOV
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <stdio.h>
#include <stdlib.h>
#include <OpenGl_GlCore11.hxx>
#include <OpenGl_tgl_funcs.hxx>
#include <Image_AlienPixMap.hxx>
#include <Visual3d_Layer.hxx>
#include <NCollection_Mat4.hxx>
#include <OpenGl_AspectLine.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_Matrix.hxx>
#include <OpenGl_Workspace.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Trihedron.hxx>
#include <OpenGl_GraduatedTrihedron.hxx>
#include <OpenGl_PrinterContext.hxx>
#include <OpenGl_ShaderManager.hxx>
#include <OpenGl_ShaderProgram.hxx>
#include <OpenGl_Structure.hxx>
#define EPSI 0.0001
namespace
{
static const GLfloat THE_DEFAULT_AMBIENT[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
static const GLfloat THE_DEFAULT_SPOT_DIR[3] = { 0.0f, 0.0f, -1.0f };
static const GLfloat THE_DEFAULT_SPOT_EXPONENT = 0.0f;
static const GLfloat THE_DEFAULT_SPOT_CUTOFF = 180.0f;
};
extern void InitLayerProp (const int theListId); //szvgl: defined in OpenGl_GraphicDriver_Layer.cxx
/*----------------------------------------------------------------------*/
struct OPENGL_CLIP_PLANE
{
GLboolean isEnabled;
GLdouble Equation[4];
DEFINE_STANDARD_ALLOC
};
/*----------------------------------------------------------------------*/
/*
* Fonctions privees
*/
#if !defined(GL_ES_VERSION_2_0)
/*-----------------------------------------------------------------*/
/*
* Set des lumieres
*/
static void bindLight (const OpenGl_Light& theLight,
GLenum& theLightGlId,
Graphic3d_Vec4& theAmbientColor,
const Handle(OpenGl_Workspace)& theWorkspace)
{
// Only 8 lights in OpenGL...
if (theLightGlId > GL_LIGHT7)
{
return;
}
if (theLight.Type == Visual3d_TOLS_AMBIENT)
{
// add RGBA intensity of the ambient light
theAmbientColor += theLight.Color;
return;
}
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
// the light is a headlight?
if (theLight.IsHeadlight)
{
aContext->WorldViewState.Push();
aContext->WorldViewState.SetIdentity();
aContext->ApplyWorldViewMatrix();
}
// setup light type
switch (theLight.Type)
{
case Visual3d_TOLS_DIRECTIONAL:
{
// if the last parameter of GL_POSITION, is zero, the corresponding light source is a Directional one
const OpenGl_Vec4 anInfDir = -theLight.Direction;
// to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE.
glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
glLightfv (theLightGlId, GL_DIFFUSE, theLight.Color.GetData());
glLightfv (theLightGlId, GL_SPECULAR, theLight.Color.GetData());
glLightfv (theLightGlId, GL_POSITION, anInfDir.GetData());
glLightfv (theLightGlId, GL_SPOT_DIRECTION, THE_DEFAULT_SPOT_DIR);
glLightf (theLightGlId, GL_SPOT_EXPONENT, THE_DEFAULT_SPOT_EXPONENT);
glLightf (theLightGlId, GL_SPOT_CUTOFF, THE_DEFAULT_SPOT_CUTOFF);
break;
}
case Visual3d_TOLS_POSITIONAL:
{
// to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE
glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
glLightfv (theLightGlId, GL_DIFFUSE, theLight.Color.GetData());
glLightfv (theLightGlId, GL_SPECULAR, theLight.Color.GetData());
glLightfv (theLightGlId, GL_POSITION, theLight.Position.GetData());
glLightfv (theLightGlId, GL_SPOT_DIRECTION, THE_DEFAULT_SPOT_DIR);
glLightf (theLightGlId, GL_SPOT_EXPONENT, THE_DEFAULT_SPOT_EXPONENT);
glLightf (theLightGlId, GL_SPOT_CUTOFF, THE_DEFAULT_SPOT_CUTOFF);
glLightf (theLightGlId, GL_CONSTANT_ATTENUATION, theLight.ConstAttenuation());
glLightf (theLightGlId, GL_LINEAR_ATTENUATION, theLight.LinearAttenuation());
glLightf (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0);
break;
}
case Visual3d_TOLS_SPOT:
{
glLightfv (theLightGlId, GL_AMBIENT, THE_DEFAULT_AMBIENT);
glLightfv (theLightGlId, GL_DIFFUSE, theLight.Color.GetData());
glLightfv (theLightGlId, GL_SPECULAR, theLight.Color.GetData());
glLightfv (theLightGlId, GL_POSITION, theLight.Position.GetData());
glLightfv (theLightGlId, GL_SPOT_DIRECTION, theLight.Direction.GetData());
glLightf (theLightGlId, GL_SPOT_EXPONENT, theLight.Concentration() * 128.0f);
glLightf (theLightGlId, GL_SPOT_CUTOFF, (theLight.Angle() * 180.0f) / GLfloat(M_PI));
glLightf (theLightGlId, GL_CONSTANT_ATTENUATION, theLight.ConstAttenuation());
glLightf (theLightGlId, GL_LINEAR_ATTENUATION, theLight.LinearAttenuation());
glLightf (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0f);
break;
}
}
// restore matrix in case of headlight
if (theLight.IsHeadlight)
{
aContext->WorldViewState.Pop();
}
glEnable (theLightGlId++);
}
#endif
/*----------------------------------------------------------------------*/
void OpenGl_View::DrawBackground (OpenGl_Workspace& theWorkspace)
{
#if !defined(GL_ES_VERSION_2_0)
if ( (theWorkspace.NamedStatus & OPENGL_NS_WHITEBACK) == 0 &&
( myBgTexture.TexId != 0 || myBgGradient.type != Aspect_GFM_NONE ) )
{
const Standard_Integer aViewWidth = theWorkspace.Width();
const Standard_Integer aViewHeight = theWorkspace.Height();
glPushAttrib( GL_ENABLE_BIT | GL_TEXTURE_BIT );
const Handle(OpenGl_Context)& aContext = theWorkspace.GetGlContext();
aContext->WorldViewState.Push();
aContext->ProjectionState.Push();
aContext->WorldViewState.SetIdentity();
aContext->ProjectionState.SetIdentity();
aContext->ApplyProjectionMatrix();
aContext->ApplyWorldViewMatrix();
if ( glIsEnabled( GL_DEPTH_TEST ) )
glDisable( GL_DEPTH_TEST ); //push GL_ENABLE_BIT
// drawing bg gradient if:
// - gradient fill type is not Aspect_GFM_NONE and
// - either background texture is no specified or it is drawn in Aspect_FM_CENTERED mode
if ( ( myBgGradient.type != Aspect_GFM_NONE ) &&
( myBgTexture.TexId == 0 || myBgTexture.Style == Aspect_FM_CENTERED ||
myBgTexture.Style == Aspect_FM_NONE ) )
{
Tfloat* corner1 = 0;/* -1,-1*/
Tfloat* corner2 = 0;/* 1,-1*/
Tfloat* corner3 = 0;/* 1, 1*/
Tfloat* corner4 = 0;/* -1, 1*/
Tfloat dcorner1[3];
Tfloat dcorner2[3];
switch( myBgGradient.type )
{
case Aspect_GFM_HOR:
corner1 = myBgGradient.color1.rgb;
corner2 = myBgGradient.color2.rgb;
corner3 = myBgGradient.color2.rgb;
corner4 = myBgGradient.color1.rgb;
break;
case Aspect_GFM_VER:
corner1 = myBgGradient.color2.rgb;
corner2 = myBgGradient.color2.rgb;
corner3 = myBgGradient.color1.rgb;
corner4 = myBgGradient.color1.rgb;
break;
case Aspect_GFM_DIAG1:
corner2 = myBgGradient.color2.rgb;
corner4 = myBgGradient.color1.rgb;
dcorner1 [0] = dcorner2[0] = 0.5F * (corner2[0] + corner4[0]);
dcorner1 [1] = dcorner2[1] = 0.5F * (corner2[1] + corner4[1]);
dcorner1 [2] = dcorner2[2] = 0.5F * (corner2[2] + corner4[2]);
corner1 = dcorner1;
corner3 = dcorner2;
break;
case Aspect_GFM_DIAG2:
corner1 = myBgGradient.color2.rgb;
corner3 = myBgGradient.color1.rgb;
dcorner1 [0] = dcorner2[0] = 0.5F * (corner1[0] + corner3[0]);
dcorner1 [1] = dcorner2[1] = 0.5F * (corner1[1] + corner3[1]);
dcorner1 [2] = dcorner2[2] = 0.5F * (corner1[2] + corner3[2]);
corner2 = dcorner1;
corner4 = dcorner2;
break;
case Aspect_GFM_CORNER1:
corner1 = myBgGradient.color2.rgb;
corner2 = myBgGradient.color2.rgb;
corner3 = myBgGradient.color2.rgb;
corner4 = myBgGradient.color1.rgb;
break;
case Aspect_GFM_CORNER2:
corner1 = myBgGradient.color2.rgb;
corner2 = myBgGradient.color2.rgb;
corner3 = myBgGradient.color1.rgb;
corner4 = myBgGradient.color2.rgb;
break;
case Aspect_GFM_CORNER3:
corner1 = myBgGradient.color2.rgb;
corner2 = myBgGradient.color1.rgb;
corner3 = myBgGradient.color2.rgb;
corner4 = myBgGradient.color2.rgb;
break;
case Aspect_GFM_CORNER4:
corner1 = myBgGradient.color1.rgb;
corner2 = myBgGradient.color2.rgb;
corner3 = myBgGradient.color2.rgb;
corner4 = myBgGradient.color2.rgb;
break;
default:
//printf("gradient background type not right\n");
break;
}
// Save GL parameters
glDisable( GL_LIGHTING ); //push GL_ENABLE_BIT
GLint curSM;
glGetIntegerv( GL_SHADE_MODEL, &curSM );
if ( curSM != GL_SMOOTH )
glShadeModel( GL_SMOOTH ); //push GL_LIGHTING_BIT
glBegin(GL_TRIANGLE_FAN);
if( myBgGradient.type != Aspect_GFM_CORNER1 && myBgGradient.type != Aspect_GFM_CORNER3 )
{
glColor3f(corner1[0],corner1[1],corner1[2]); glVertex2f(-1.,-1.);
glColor3f(corner2[0],corner2[1],corner2[2]); glVertex2f( 1.,-1.);
glColor3f(corner3[0],corner3[1],corner3[2]); glVertex2f( 1., 1.);
glColor3f(corner4[0],corner4[1],corner4[2]); glVertex2f(-1., 1.);
}
else //if ( myBgGradient.type == Aspect_GFM_CORNER1 || myBgGradient.type == Aspect_GFM_CORNER3 )
{
glColor3f(corner2[0],corner2[1],corner2[2]); glVertex2f( 1.,-1.);
glColor3f(corner3[0],corner3[1],corner3[2]); glVertex2f( 1., 1.);
glColor3f(corner4[0],corner4[1],corner4[2]); glVertex2f(-1., 1.);
glColor3f(corner1[0],corner1[1],corner1[2]); glVertex2f(-1.,-1.);
}
glEnd();
// Restore GL parameters
if ( curSM != GL_SMOOTH )
glShadeModel( curSM );
}
// drawing bg image if:
// - it is defined and
// - fill type is not Aspect_FM_NONE
if ( myBgTexture.TexId != 0 && myBgTexture.Style != Aspect_FM_NONE )
{
GLfloat texX_range = 1.F; // texture <s> coordinate
GLfloat texY_range = 1.F; // texture <t> coordinate
// Set up for stretching or tiling
GLfloat x_offset, y_offset;
if ( myBgTexture.Style == Aspect_FM_CENTERED )
{
x_offset = (GLfloat)myBgTexture.Width / (GLfloat)aViewWidth;
y_offset = (GLfloat)myBgTexture.Height / (GLfloat)aViewHeight;
}
else
{
x_offset = 1.F;
y_offset = 1.F;
if ( myBgTexture.Style == Aspect_FM_TILED )
{
texX_range = (GLfloat)aViewWidth / (GLfloat)myBgTexture.Width;
texY_range = (GLfloat)aViewHeight / (GLfloat)myBgTexture.Height;
}
}
// OCCT issue 0023000: Improve the way the gradient and textured
// background is managed in 3d viewer (note 0020339)
// Setting this coefficient to -1.F allows to tile textures relatively
// to the top-left corner of the view (value 1.F corresponds to the
// initial behaviour - tiling from the bottom-left corner)
GLfloat aCoef = -1.F;
glEnable( GL_TEXTURE_2D ); //push GL_ENABLE_BIT
glBindTexture( GL_TEXTURE_2D, myBgTexture.TexId ); //push GL_TEXTURE_BIT
glDisable( GL_BLEND ); //push GL_ENABLE_BIT
glColor3fv (theWorkspace.BackgroundColor().rgb);
glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); //push GL_TEXTURE_BIT
// Note that texture is mapped using GL_REPEAT wrapping mode so integer part
// is simply ignored, and negative multiplier is here for convenience only
// and does not result e.g. in texture mirroring
glBegin( GL_QUADS );
glTexCoord2f(0.F, 0.F); glVertex2f( -x_offset, -aCoef * y_offset );
glTexCoord2f(texX_range, 0.F); glVertex2f( x_offset, -aCoef * y_offset );
glTexCoord2f(texX_range, aCoef * texY_range); glVertex2f( x_offset, aCoef * y_offset );
glTexCoord2f(0.F, aCoef * texY_range); glVertex2f( -x_offset, aCoef * y_offset );
glEnd();
}
aContext->WorldViewState.Pop();
aContext->ProjectionState.Pop();
aContext->ApplyProjectionMatrix();
glPopAttrib(); //GL_ENABLE_BIT | GL_TEXTURE_BIT
if (theWorkspace.UseZBuffer())
{
glEnable (GL_DEPTH_TEST);
}
}
#endif
}
/*----------------------------------------------------------------------*/
//call_func_redraw_all_structs_proc
void OpenGl_View::Render (const Handle(OpenGl_PrinterContext)& thePrintContext,
const Handle(OpenGl_Workspace) &theWorkspace,
const Graphic3d_CView& theCView,
const Aspect_CLayer2d& theCUnderLayer,
const Aspect_CLayer2d& theCOverLayer)
{
// ==================================
// Step 1: Prepare for redraw
// ==================================
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
#if !defined(GL_ES_VERSION_2_0)
// store and disable current clipping planes
const Standard_Integer aMaxPlanes = aContext->MaxClipPlanes();
NCollection_Array1<OPENGL_CLIP_PLANE> aOldPlanes (GL_CLIP_PLANE0, GL_CLIP_PLANE0 + aMaxPlanes - 1);
if (aContext->core11 != NULL)
{
for (Standard_Integer aClipPlaneId = aOldPlanes.Lower(); aClipPlaneId <= aOldPlanes.Upper(); ++aClipPlaneId)
{
OPENGL_CLIP_PLANE& aPlane = aOldPlanes.ChangeValue (aClipPlaneId);
aContext->core11->glGetClipPlane (aClipPlaneId, aPlane.Equation);
if (aPlane.isEnabled)
{
aContext->core11fwd->glDisable (aClipPlaneId);
aPlane.isEnabled = GL_TRUE;
}
else
{
aPlane.isEnabled = GL_FALSE;
}
}
}
#endif
// Update states of OpenGl_BVHTreeSelector (frustum culling algorithm).
Standard_Boolean isProjectionMatUpdateNeeded = Standard_False;
Standard_Boolean isOrientationMatUpdateNeeded = Standard_False;
if (myBVHSelector.ProjectionState() != myCamera->ProjectionState())
{
isProjectionMatUpdateNeeded = Standard_True;
myBVHSelector.ChangeProjectionState() = myCamera->ProjectionState();
}
if (myBVHSelector.ModelViewState() != myCamera->ModelViewState())
{
isOrientationMatUpdateNeeded = Standard_True;
myBVHSelector.ChangeModelViewState() = myCamera->ModelViewState();
}
if (isProjectionMatUpdateNeeded
|| isOrientationMatUpdateNeeded)
{
myBVHSelector.SetViewVolume (myCamera);
}
const Handle(OpenGl_ShaderManager) aManager = aContext->ShaderManager();
const Standard_Boolean isSameView = aManager->IsSameView (this); // force camera state update when needed
if (StateInfo (myCurrLightSourceState, aManager->LightSourceState().Index()) != myLastLightSourceState)
{
aManager->UpdateLightSourceStateTo (&myLights);
myLastLightSourceState = StateInfo (myCurrLightSourceState, aManager->LightSourceState().Index());
}
if (myProjectionState != myCamera->ProjectionState()
|| !isSameView)
{
myProjectionState = myCamera->ProjectionState();
aContext->ProjectionState.SetCurrent (myCamera->ProjectionMatrixF());
aContext->ApplyProjectionMatrix();
}
if (myModelViewState != myCamera->ModelViewState()
|| !isSameView)
{
myModelViewState = myCamera->ModelViewState();
aContext->WorldViewState.SetCurrent (myCamera->OrientationMatrixF());
aContext->ApplyWorldViewMatrix();
}
if (aManager->ModelWorldState().Index() == 0)
{
aContext->ShaderManager()->UpdateModelWorldStateTo (OpenGl_Mat4());
}
// ====================================
// Step 2: Redraw background
// ====================================
// Render background
if (theWorkspace->ToRedrawGL())
{
DrawBackground (*theWorkspace);
}
#if !defined(GL_ES_VERSION_2_0)
// Switch off lighting by default
glDisable(GL_LIGHTING);
#endif
// =================================
// Step 3: Draw underlayer
// =================================
RedrawLayer2d (thePrintContext, theWorkspace, theCView, theCUnderLayer);
// =================================
// Step 4: Redraw main plane
// =================================
// Setup face culling
GLboolean isCullFace = GL_FALSE;
if ( myBackfacing )
{
isCullFace = glIsEnabled( GL_CULL_FACE );
if ( myBackfacing < 0 )
{
glEnable( GL_CULL_FACE );
glCullFace( GL_BACK );
}
else
glDisable( GL_CULL_FACE );
}
#if !defined(GL_ES_VERSION_2_0)
// if the view is scaled normal vectors are scaled to unit
// length for correct displaying of shaded objects
const gp_Pnt anAxialScale = myCamera->AxialScale();
if (anAxialScale.X() != 1.F ||
anAxialScale.Y() != 1.F ||
anAxialScale.Z() != 1.F)
{
aContext->SetGlNormalizeEnabled (Standard_True);
}
else
{
aContext->SetGlNormalizeEnabled (Standard_False);
}
// Apply Fog
if ( myFog.IsOn )
{
Standard_Real aFogFrontConverted = (Standard_Real )myFog.Front + myCamera->Distance();
if (myCamera->ZFar() < aFogFrontConverted)
{
aFogFrontConverted = myCamera->ZFar();
myFog.Front = (Standard_ShortReal )(aFogFrontConverted - myCamera->Distance());
}
Standard_Real aFogBackConverted = (Standard_Real )myFog.Back + myCamera->Distance();
if (myCamera->ZFar() < aFogFrontConverted)
{
aFogBackConverted = myCamera->ZFar();
myFog.Back = (Standard_ShortReal )(aFogBackConverted - myCamera->Distance());
}
if (aFogFrontConverted > aFogBackConverted)
{
myFog.Front = (Standard_ShortReal )(aFogFrontConverted - myCamera->Distance());
myFog.Back = (Standard_ShortReal )(aFogBackConverted - myCamera->Distance());
}
glFogi(GL_FOG_MODE, GL_LINEAR);
glFogf(GL_FOG_START, (Standard_ShortReal )aFogFrontConverted);
glFogf(GL_FOG_END, (Standard_ShortReal )aFogBackConverted);
glFogfv(GL_FOG_COLOR, myFog.Color.rgb);
glEnable(GL_FOG);
}
else
glDisable(GL_FOG);
// Apply InteriorShadingMethod
aContext->core11->glShadeModel (myShadingModel == Visual3d_TOM_FACET
|| myShadingModel == Visual3d_TOM_NONE ? GL_FLAT : GL_SMOOTH);
#endif
aManager->SetShadingModel (myShadingModel);
// Apply AntiAliasing
if (myAntiAliasing)
theWorkspace->NamedStatus |= OPENGL_NS_ANTIALIASING;
else
theWorkspace->NamedStatus &= ~OPENGL_NS_ANTIALIASING;
if (!aManager->IsEmpty())
{
aManager->UpdateClippingState();
}
// Redraw 3d scene
if (!myCamera->IsStereo() || !aContext->HasStereoBuffers())
{
// single-pass monographic rendering
// redraw scene with normal orientation and projection
RedrawScene (thePrintContext, theWorkspace);
}
else
{
// two stereographic passes
// safely switch to left Eye buffer
aContext->SetDrawBufferLeft();
aContext->ProjectionState.SetCurrent (myCamera->ProjectionStereoLeftF());
aContext->ApplyProjectionMatrix();
// redraw left Eye
RedrawScene (thePrintContext, theWorkspace);
// reset depth buffer of first rendering pass
if (theWorkspace->UseDepthTest())
{
glClear (GL_DEPTH_BUFFER_BIT);
}
// safely switch to right Eye buffer
aContext->SetDrawBufferRight();
aContext->ProjectionState.SetCurrent (myCamera->ProjectionStereoRightF());
aContext->ApplyProjectionMatrix();
// redraw right Eye
RedrawScene (thePrintContext, theWorkspace);
// switch back to monographic rendering
aContext->SetDrawBufferMono();
}
// ===============================
// Step 5: Trihedron
// ===============================
// Resetting GL parameters according to the default aspects
// in order to synchronize GL state with the graphic driver state
// before drawing auxiliary stuff (trihedrons, overlayer)
// and invoking optional callbacks
theWorkspace->ResetAppliedAspect();
aContext->ChangeClipping().RemoveAll();
if (!aManager->IsEmpty())
{
aManager->ResetMaterialStates();
aManager->RevertClippingState();
// We need to disable (unbind) all shaders programs to ensure
// that all objects without specified aspect will be drawn
// correctly (such as background)
aContext->BindProgram (NULL);
}
// Render trihedron
if (theWorkspace->ToRedrawGL())
{
RedrawTrihedron (theWorkspace);
// Restore face culling
if ( myBackfacing )
{
if ( isCullFace )
{
glEnable ( GL_CULL_FACE );
glCullFace ( GL_BACK );
}
else
glDisable ( GL_CULL_FACE );
}
}
// ===============================
// Step 6: Redraw overlay
// ===============================
const int aMode = 0;
theWorkspace->DisplayCallback (theCView, (aMode | OCC_PRE_OVERLAY));
RedrawLayer2d (thePrintContext, theWorkspace, theCView, theCOverLayer);
theWorkspace->DisplayCallback (theCView, aMode);
// ===============================
// Step 7: Finalize
// ===============================
#if !defined(GL_ES_VERSION_2_0)
// restore clipping planes
if (aContext->core11 != NULL)
{
for (Standard_Integer aClipPlaneId = aOldPlanes.Lower(); aClipPlaneId <= aOldPlanes.Upper(); ++aClipPlaneId)
{
const OPENGL_CLIP_PLANE& aPlane = aOldPlanes.ChangeValue (aClipPlaneId);
aContext->core11->glClipPlane (aClipPlaneId, aPlane.Equation);
if (aPlane.isEnabled)
aContext->core11fwd->glEnable (aClipPlaneId);
else
aContext->core11fwd->glDisable (aClipPlaneId);
}
}
#endif
// ==============================================================
// Step 8: Keep shader manager informed about last View
// ==============================================================
if (!aManager.IsNull())
{
aManager->SetLastView (this);
}
}
// =======================================================================
// function : InvalidateBVHData
// purpose :
// =======================================================================
void OpenGl_View::InvalidateBVHData (const Standard_Integer theLayerId)
{
myZLayers.InvalidateBVHData (theLayerId);
}
/*----------------------------------------------------------------------*/
//ExecuteViewDisplay
void OpenGl_View::RenderStructs (const Handle(OpenGl_Workspace) &AWorkspace)
{
if ( myZLayers.NbStructures() <= 0 )
return;
#if !defined(GL_ES_VERSION_2_0)
glPushAttrib ( GL_DEPTH_BUFFER_BIT );
#endif
//TsmPushAttri(); /* save previous graphics context */
if ( (AWorkspace->NamedStatus & OPENGL_NS_2NDPASSNEED) == 0 )
{
#if !defined(GL_ES_VERSION_2_0)
const int antiAliasingMode = AWorkspace->AntiAliasingMode();
#endif
if ( !myAntiAliasing )
{
#if !defined(GL_ES_VERSION_2_0)
glDisable(GL_POINT_SMOOTH);
glDisable(GL_LINE_SMOOTH);
if( antiAliasingMode & 2 ) glDisable(GL_POLYGON_SMOOTH);
#endif
glBlendFunc (GL_ONE, GL_ZERO);
glDisable (GL_BLEND);
}
else
{
#if !defined(GL_ES_VERSION_2_0)
glEnable(GL_POINT_SMOOTH);
glEnable(GL_LINE_SMOOTH);
if( antiAliasingMode & 2 ) glEnable(GL_POLYGON_SMOOTH);
#endif
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable (GL_BLEND);
}
}
myZLayers.Render (AWorkspace);
#if !defined(GL_ES_VERSION_2_0)
//TsmPopAttri(); /* restore previous graphics context; before update lights */
glPopAttrib();
#endif
}
/*----------------------------------------------------------------------*/
//call_togl_redraw_layer2d
void OpenGl_View::RedrawLayer2d (const Handle(OpenGl_PrinterContext)& thePrintContext,
const Handle(OpenGl_Workspace)& theWorkspace,
const Graphic3d_CView& ACView,
const Aspect_CLayer2d& ACLayer)
{
#if !defined(GL_ES_VERSION_2_0)
if (&ACLayer == NULL
|| ACLayer.ptrLayer == NULL
|| ACLayer.ptrLayer->listIndex == 0) return;
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
GLsizei dispWidth = (GLsizei )ACLayer.viewport[0];
GLsizei dispHeight = (GLsizei )ACLayer.viewport[1];
aContext->WorldViewState.Push();
aContext->ProjectionState.Push();
aContext->WorldViewState.SetIdentity();
aContext->ProjectionState.SetIdentity();
aContext->ApplyWorldViewMatrix();
aContext->ApplyProjectionMatrix();
if (!ACLayer.sizeDependent)
aContext->core11fwd->glViewport (0, 0, dispWidth, dispHeight);
float left = ACLayer.ortho[0];
float right = ACLayer.ortho[1];
float bottom = ACLayer.ortho[2];
float top = ACLayer.ortho[3];
int attach = ACLayer.attach;
const float ratio = !ACLayer.sizeDependent
? float(dispWidth) / float(dispHeight)
: float(theWorkspace->Width()) / float(theWorkspace->Height());
float delta;
if (ratio >= 1.0) {
delta = (float )((top - bottom)/2.0);
switch (attach) {
case 0: /* Aspect_TOC_BOTTOM_LEFT */
top = bottom + 2*delta/ratio;
break;
case 1: /* Aspect_TOC_BOTTOM_RIGHT */
top = bottom + 2*delta/ratio;
break;
case 2: /* Aspect_TOC_TOP_LEFT */
bottom = top - 2*delta/ratio;
break;
case 3: /* Aspect_TOC_TOP_RIGHT */
bottom = top - 2*delta/ratio;
break;
}
}
else {
delta = (float )((right - left)/2.0);
switch (attach) {
case 0: /* Aspect_TOC_BOTTOM_LEFT */
right = left + 2*delta*ratio;
break;
case 1: /* Aspect_TOC_BOTTOM_RIGHT */
left = right - 2*delta*ratio;
break;
case 2: /* Aspect_TOC_TOP_LEFT */
right = left + 2*delta*ratio;
break;
case 3: /* Aspect_TOC_TOP_RIGHT */
left = right - 2*delta*ratio;
break;
}
}
#ifdef _WIN32
// Check printer context that exists only for print operation
if (!thePrintContext.IsNull())
{
// additional transformation matrix could be applied to
// render only those parts of viewport that will be
// passed to a printer as a current "frame" to provide
// tiling; scaling of graphics by matrix helps render a
// part of a view (frame) in same viewport, but with higher
// resolution
// set printing scale/tiling transformation
aContext->ProjectionState.SetCurrent (thePrintContext->ProjTransformation());
aContext->ApplyProjectionMatrix();
// printing operation also assumes other viewport dimension
// to comply with transformation matrix or graphics scaling
// factors for tiling for layer redraw
GLsizei anViewportX = 0;
GLsizei anViewportY = 0;
thePrintContext->GetLayerViewport (anViewportX, anViewportY);
if (anViewportX != 0 && anViewportY != 0)
aContext->core11fwd->glViewport (0, 0, anViewportX, anViewportY);
}
#endif
glOrtho (left, right, bottom, top, -1.0, 1.0);
glPushAttrib (
GL_LIGHTING_BIT | GL_LINE_BIT | GL_POLYGON_BIT |
GL_DEPTH_BUFFER_BIT | GL_CURRENT_BIT | GL_TEXTURE_BIT );
glDisable (GL_DEPTH_TEST);
glDisable (GL_TEXTURE_1D);
glDisable (GL_TEXTURE_2D);
glDisable (GL_LIGHTING);
// TODO: Obsolete code, the display list is always empty now, to be removed
glCallList (ACLayer.ptrLayer->listIndex);
//calling dynamic render of LayerItems
if ( ACLayer.ptrLayer->layerData )
{
InitLayerProp (ACLayer.ptrLayer->listIndex);
((Visual3d_Layer*)ACLayer.ptrLayer->layerData)->RenderLayerItems();
InitLayerProp (0);
}
glPopAttrib ();
aContext->WorldViewState.Pop();
aContext->ProjectionState.Pop();
aContext->ApplyProjectionMatrix();
aContext->ApplyWorldViewMatrix();
if (!ACLayer.sizeDependent)
aContext->core11fwd->glViewport (0, 0, theWorkspace->Width(), theWorkspace->Height());
glFlush ();
#endif
}
/*----------------------------------------------------------------------*/
void OpenGl_View::RedrawTrihedron (const Handle(OpenGl_Workspace) &theWorkspace)
{
// display global trihedron
if (myTrihedron != NULL)
{
myTrihedron->Render (theWorkspace);
}
if (myGraduatedTrihedron != NULL)
{
myGraduatedTrihedron->Render (theWorkspace);
}
}
/*----------------------------------------------------------------------*/
//call_togl_create_bg_texture
void OpenGl_View::CreateBackgroundTexture (const Standard_CString theFilePath,
const Aspect_FillMethod theFillStyle)
{
if (myBgTexture.TexId != 0)
{
// delete existing texture
glDeleteTextures (1, (GLuint* )&(myBgTexture.TexId));
myBgTexture.TexId = 0;
}
// load image from file
Image_AlienPixMap anImageLoaded;
if (!anImageLoaded.Load (theFilePath))
{
return;
}
Image_PixMap anImage;
if (anImageLoaded.RowExtraBytes() == 0 &&
(anImageLoaded.Format() == Image_PixMap::ImgRGB
|| anImageLoaded.Format() == Image_PixMap::ImgRGB32
|| anImageLoaded.Format() == Image_PixMap::ImgRGBA))
{
anImage.InitWrapper (anImageLoaded.Format(), anImageLoaded.ChangeData(),
anImageLoaded.SizeX(), anImageLoaded.SizeY(), anImageLoaded.SizeRowBytes());
}
else
{
// convert image to RGB format
if (!anImage.InitTrash (Image_PixMap::ImgRGB, anImageLoaded.SizeX(), anImageLoaded.SizeY()))
{
return;
}
anImage.SetTopDown (false);
Quantity_Color aSrcColor;
for (Standard_Size aRow = 0; aRow < anImage.SizeY(); ++aRow)
{
for (Standard_Size aCol = 0; aCol < anImage.SizeX(); ++aCol)
{
aSrcColor = anImageLoaded.PixelColor ((Standard_Integer )aCol, (Standard_Integer )aRow);
Image_ColorRGB& aColor = anImage.ChangeValue<Image_ColorRGB> (aRow, aCol);
aColor.r() = Standard_Byte(255.0 * aSrcColor.Red());
aColor.g() = Standard_Byte(255.0 * aSrcColor.Green());
aColor.b() = Standard_Byte(255.0 * aSrcColor.Blue());
}
}
anImageLoaded.Clear();
}
// create MipMapped texture
glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
GLuint aTextureId = 0;
glGenTextures (1, &aTextureId);
glBindTexture (GL_TEXTURE_2D, aTextureId);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
const GLenum aDataFormat = (anImage.Format() == Image_PixMap::ImgRGB) ? GL_RGB : GL_RGBA;
#if !defined(GL_ES_VERSION_2_0)
gluBuild2DMipmaps (GL_TEXTURE_2D, 3/*4*/,
GLint(anImage.SizeX()), GLint(anImage.SizeY()),
aDataFormat, GL_UNSIGNED_BYTE, anImage.Data());
#endif
myBgTexture.TexId = aTextureId;
myBgTexture.Width = (Standard_Integer )anImage.SizeX();
myBgTexture.Height = (Standard_Integer )anImage.SizeY();
myBgTexture.Style = theFillStyle;
}
/*----------------------------------------------------------------------*/
//call_togl_set_bg_texture_style
void OpenGl_View::SetBackgroundTextureStyle (const Aspect_FillMethod AFillStyle)
{
myBgTexture.Style = AFillStyle;
}
/*----------------------------------------------------------------------*/
//call_togl_gradient_background
void OpenGl_View::SetBackgroundGradient (const Quantity_Color& AColor1,
const Quantity_Color& AColor2,
const Aspect_GradientFillMethod AType)
{
Standard_Real R,G,B;
AColor1.Values( R, G, B, Quantity_TOC_RGB );
myBgGradient.color1.rgb[0] = ( Tfloat )R;
myBgGradient.color1.rgb[1] = ( Tfloat )G;
myBgGradient.color1.rgb[2] = ( Tfloat )B;
myBgGradient.color1.rgb[3] = 0.F;
AColor2.Values( R, G, B, Quantity_TOC_RGB );
myBgGradient.color2.rgb[0] = ( Tfloat )R;
myBgGradient.color2.rgb[1] = ( Tfloat )G;
myBgGradient.color2.rgb[2] = ( Tfloat )B;
myBgGradient.color2.rgb[3] = 0.F;
myBgGradient.type = AType;
}
/*----------------------------------------------------------------------*/
//call_togl_set_gradient_type
void OpenGl_View::SetBackgroundGradientType (const Aspect_GradientFillMethod AType)
{
myBgGradient.type = AType;
}
//=======================================================================
//function : AddZLayer
//purpose :
//=======================================================================
void OpenGl_View::AddZLayer (const Standard_Integer theLayerId)
{
myZLayers.AddLayer (theLayerId);
}
//=======================================================================
//function : RemoveZLayer
//purpose :
//=======================================================================
void OpenGl_View::RemoveZLayer (const Standard_Integer theLayerId)
{
myZLayers.RemoveLayer (theLayerId);
}
//=======================================================================
//function : DisplayStructure
//purpose :
//=======================================================================
void OpenGl_View::DisplayStructure (const OpenGl_Structure *theStructure,
const Standard_Integer thePriority)
{
Standard_Integer aZLayer = theStructure->GetZLayer ();
myZLayers.AddStructure (theStructure, aZLayer, thePriority);
}
//=======================================================================
//function : DisplayImmediateStructure
//purpose :
//=======================================================================
void OpenGl_View::DisplayImmediateStructure (const OpenGl_Structure* theStructure)
{
for (OpenGl_SequenceOfStructure::Iterator anIter (myImmediateList);
anIter.More(); anIter.Next())
{
if (anIter.Value() == theStructure)
{
return;
}
}
myImmediateList.Append (theStructure);
}
//=======================================================================
//function : EraseStructure
//purpose :
//=======================================================================
void OpenGl_View::EraseStructure (const OpenGl_Structure *theStructure)
{
Standard_Integer aZLayer = theStructure->GetZLayer ();
myZLayers.RemoveStructure (theStructure, aZLayer);
}
//=======================================================================
//function : EraseImmediateStructure
//purpose :
//=======================================================================
void OpenGl_View::EraseImmediateStructure (const OpenGl_Structure* theStructure)
{
for (OpenGl_SequenceOfStructure::Iterator anIter (myImmediateList);
anIter.More(); anIter.Next())
{
if (anIter.Value() == theStructure)
{
myImmediateList.Remove (anIter);
return;
}
}
}
//=======================================================================
//function : ChangeZLayer
//purpose :
//=======================================================================
void OpenGl_View::ChangeZLayer (const OpenGl_Structure *theStructure,
const Standard_Integer theNewLayerId)
{
Standard_Integer anOldLayer = theStructure->GetZLayer ();
myZLayers.ChangeLayer (theStructure, anOldLayer, theNewLayerId);
}
//=======================================================================
//function : SetZLayerSettings
//purpose :
//=======================================================================
void OpenGl_View::SetZLayerSettings (const Standard_Integer theLayerId,
const Graphic3d_ZLayerSettings theSettings)
{
myZLayers.Layer (theLayerId).SetLayerSettings (theSettings);
}
//=======================================================================
//function : ChangePriority
//purpose :
//=======================================================================
void OpenGl_View::ChangePriority (const OpenGl_Structure *theStructure,
const Standard_Integer theNewPriority)
{
Standard_Integer aLayerId = theStructure->GetZLayer();
myZLayers.ChangePriority (theStructure, aLayerId, theNewPriority);
}
//=======================================================================
//function : RedrawScene
//purpose :
//=======================================================================
void OpenGl_View::RedrawScene (const Handle(OpenGl_PrinterContext)& thePrintContext,
const Handle(OpenGl_Workspace)& theWorkspace)
{
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
if (myZClip.Back.IsOn || myZClip.Front.IsOn)
{
Handle(Graphic3d_ClipPlane) aPlaneBack;
Handle(Graphic3d_ClipPlane) aPlaneFront;
if (myZClip.Back.IsOn)
{
Standard_Real aClipBackConverted = (Standard_Real )myZClip.Front.Limit + myCamera->Distance();
if (myCamera->ZFar() < aClipBackConverted)
{
aClipBackConverted = myCamera->ZFar();
myZClip.Back.Limit = (Standard_ShortReal )(aClipBackConverted - myCamera->Distance());
}
const Graphic3d_ClipPlane::Equation aBackEquation (0.0, 0.0, 1.0, (Standard_ShortReal )aClipBackConverted);
aPlaneBack = new Graphic3d_ClipPlane (aBackEquation);
}
if (myZClip.Front.IsOn)
{
Standard_Real aClipFrontConverted = (Standard_Real )myZClip.Front.Limit + myCamera->Distance();
if (myCamera->ZNear() > aClipFrontConverted)
{
aClipFrontConverted = myCamera->ZNear();
myZClip.Front.Limit = (Standard_ShortReal )(aClipFrontConverted - myCamera->Distance());
}
const Graphic3d_ClipPlane::Equation aFrontEquation (0.0, 0.0, -1.0, (Standard_ShortReal )-aClipFrontConverted);
aPlaneFront = new Graphic3d_ClipPlane (aFrontEquation);
}
// Specify slicing planes with identity transformation
if (!aPlaneBack.IsNull() || !aPlaneFront.IsNull())
{
Graphic3d_SequenceOfHClipPlane aSlicingPlanes;
if (!aPlaneBack.IsNull())
{
aSlicingPlanes.Append (aPlaneBack);
}
if (!aPlaneFront.IsNull())
{
aSlicingPlanes.Append (aPlaneFront);
}
// add planes at loaded view matrix state
aContext->ChangeClipping().AddView (aSlicingPlanes, theWorkspace);
}
}
#ifdef _WIN32
// set printing scale/tiling transformation
if (!thePrintContext.IsNull())
{
aContext->ProjectionState.Push();
aContext->ProjectionState.SetCurrent (thePrintContext->ProjTransformation() * aContext->ProjectionState.Current());
aContext->ApplyProjectionMatrix();
}
#endif
// Specify clipping planes in view transformation space
if (!myClipPlanes.IsEmpty())
{
Graphic3d_SequenceOfHClipPlane aUserPlanes;
Graphic3d_SequenceOfHClipPlane::Iterator aClippingIt (myClipPlanes);
for (; aClippingIt.More(); aClippingIt.Next())
{
const Handle(Graphic3d_ClipPlane)& aClipPlane = aClippingIt.Value();
if (aClipPlane->IsOn())
{
aUserPlanes.Append (aClipPlane);
}
}
if (!aUserPlanes.IsEmpty())
{
aContext->ChangeClipping().AddWorld (aUserPlanes);
}
if (!aContext->ShaderManager()->IsEmpty())
{
aContext->ShaderManager()->UpdateClippingState();
}
}
#if !defined(GL_ES_VERSION_2_0)
// Apply Lights
{
// setup lights
Graphic3d_Vec4 anAmbientColor (THE_DEFAULT_AMBIENT[0],
THE_DEFAULT_AMBIENT[1],
THE_DEFAULT_AMBIENT[2],
THE_DEFAULT_AMBIENT[3]);
GLenum aLightGlId = GL_LIGHT0;
for (OpenGl_ListOfLight::Iterator aLightIt (myLights);
aLightIt.More(); aLightIt.Next())
{
bindLight (aLightIt.Value(), aLightGlId, anAmbientColor, theWorkspace);
}
// apply accumulated ambient color
anAmbientColor.a() = 1.0f;
glLightModelfv (GL_LIGHT_MODEL_AMBIENT, anAmbientColor.GetData());
if (aLightGlId != GL_LIGHT0)
{
glEnable (GL_LIGHTING);
}
// switch off unused lights
for (; aLightGlId <= GL_LIGHT7; ++aLightGlId)
{
glDisable (aLightGlId);
}
}
#endif
// Clear status bitfields
theWorkspace->NamedStatus &= ~(OPENGL_NS_2NDPASSNEED | OPENGL_NS_2NDPASSDO);
// Added PCT for handling of textures
switch (mySurfaceDetail)
{
case Visual3d_TOD_NONE:
theWorkspace->NamedStatus |= OPENGL_NS_FORBIDSETTEX;
theWorkspace->DisableTexture();
// Render the view
RenderStructs (theWorkspace);
break;
case Visual3d_TOD_ENVIRONMENT:
theWorkspace->NamedStatus |= OPENGL_NS_FORBIDSETTEX;
theWorkspace->EnableTexture (myTextureEnv);
// Render the view
RenderStructs (theWorkspace);
theWorkspace->DisableTexture();
break;
case Visual3d_TOD_ALL:
// First pass
theWorkspace->NamedStatus &= ~OPENGL_NS_FORBIDSETTEX;
// Render the view
RenderStructs (theWorkspace);
theWorkspace->DisableTexture();
// Second pass
if (theWorkspace->NamedStatus & OPENGL_NS_2NDPASSNEED)
{
theWorkspace->NamedStatus |= OPENGL_NS_2NDPASSDO;
theWorkspace->EnableTexture (myTextureEnv);
// Remember OpenGl properties
GLint aSaveBlendDst = GL_ONE_MINUS_SRC_ALPHA, aSaveBlendSrc = GL_SRC_ALPHA;
GLint aSaveZbuffFunc;
GLboolean aSaveZbuffWrite;
glGetBooleanv (GL_DEPTH_WRITEMASK, &aSaveZbuffWrite);
glGetIntegerv (GL_DEPTH_FUNC, &aSaveZbuffFunc);
#if !defined(GL_ES_VERSION_2_0)
glGetIntegerv (GL_BLEND_DST, &aSaveBlendDst);
glGetIntegerv (GL_BLEND_SRC, &aSaveBlendSrc);
#endif
GLboolean wasZbuffEnabled = glIsEnabled (GL_DEPTH_TEST);
GLboolean wasBlendEnabled = glIsEnabled (GL_BLEND);
// Change the properties for second rendering pass
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable (GL_BLEND);
glDepthFunc (GL_EQUAL);
glDepthMask (GL_FALSE);
glEnable (GL_DEPTH_TEST);
theWorkspace->NamedStatus |= OPENGL_NS_FORBIDSETTEX;
// Render the view
RenderStructs (theWorkspace);
theWorkspace->DisableTexture();
// Restore properties back
glBlendFunc (aSaveBlendSrc, aSaveBlendDst);
if (!wasBlendEnabled)
glDisable (GL_BLEND);
glDepthFunc (aSaveZbuffFunc);
glDepthMask (aSaveZbuffWrite);
if (!wasZbuffEnabled)
glDisable (GL_DEPTH_FUNC);
}
break;
}
// Apply restored view matrix.
aContext->ApplyWorldViewMatrix();
#ifdef _WIN32
// set printing scale/tiling transformation
if (!thePrintContext.IsNull())
{
aContext->ProjectionState.Pop();
aContext->ApplyProjectionMatrix();
}
#endif
}
View Git Blame Copy Permalink