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

0024381: Visualization, TKOpenGl - revise matrices stack and usage of temporary matrices

Browse Source 
0025301: Visualization, TKOpenGl - transpose matrix manually before glUniformMatrix4fv()

OpenGl_View::ReleaseGlResources() - release GL resources of trihedron, do not destroy it
This commit is contained in:
duv 2014-11-03 23:18:25 +03:00 committed by bugmaster
parent 00ea319b16
commit c827ea3a68
38 changed files with 1968 additions and 955 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/NCollection/NCollection_Mat4.hxx
View File

@ -425,6 +425,28 @@ public:
return true;
}
// Converts NCollection_Mat4 with different element type.
template <typename Other_t>
void Convert (const NCollection_Mat4<Other_t>& theOther)
{
for (int anIdx = 0; anIdx < 16; ++anIdx)
{
myMat[anIdx] = static_cast<Element_t> (theOther.myMat[anIdx]);
}
}
//! Maps plain C array to matrix type.
static NCollection_Mat4<Element_t>& Map (Element_t* theData)
{
return *reinterpret_cast<NCollection_Mat4<Element_t>*> (theData);
}
//! Maps plain C array to matrix type.
static const NCollection_Mat4<Element_t>& Map (const Element_t* theData)
{
return *reinterpret_cast<const NCollection_Mat4<Element_t>*> (theData);
}
private:
Element_t myMat[16];
@ -432,6 +454,10 @@ private:
private:
static Element_t myIdentityArray[16];
// All instantiations are friend to each other
template<class OtherType> friend class NCollection_Mat4;
};
template<typename Element_t>

9
src/OpenGl/FILES
View File

@ -157,3 +157,12 @@ OpenGl_ArbTexBindless.hxx
Handle_OpenGl_Sampler.hxx
OpenGl_Sampler.hxx
OpenGl_Sampler.cxx
OpenGl_Utils.hxx
OpenGl_Quadric.hxx
OpenGl_Quadric.cxx
OpenGl_Cylinder.hxx
OpenGl_Cylinder.cxx
OpenGl_Disk.hxx
OpenGl_Disk.cxx
OpenGl_Sphere.hxx
OpenGl_Sphere.cxx

10
src/OpenGl/OpenGl_CappingAlgo.cxx
View File

@ -230,9 +230,11 @@ void OpenGl_CappingAlgo::RenderPlane (const Handle(OpenGl_Workspace)& theWorkspa
theWorkspace->AspectFace (Standard_True);
// set identity model matrix
const OpenGl_Matrix* aModelMatrix = theWorkspace->SetStructureMatrix (&OpenGl_IdentityMatrix);
aContext->ModelWorldState.Push();
aContext->ModelWorldState.SetCurrent (OpenGl_Mat4::Map (*aPlaneRes->Orientation()->mat));
aContext->ApplyModelViewMatrix();
#if !defined(GL_ES_VERSION_2_0)
glMultMatrixf ((const GLfloat*)aPlaneRes->Orientation());
glNormal3f (0.0f, 1.0f, 0.0f);
glEnableClientState (GL_VERTEX_ARRAY);
glVertexPointer (4, GL_FLOAT, 0, (GLfloat* )&THE_CAPPING_PLN_VERTS);
@ -243,7 +245,9 @@ void OpenGl_CappingAlgo::RenderPlane (const Handle(OpenGl_Workspace)& theWorkspa
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
#endif
theWorkspace->SetStructureMatrix (aModelMatrix, true);
aContext->ModelWorldState.Pop();
aContext->ApplyModelViewMatrix();
theWorkspace->SetAspectFace (aFaceAspect);
// set delayed resource release

34
src/OpenGl/OpenGl_Clipping.cxx
View File

@ -55,37 +55,27 @@ void OpenGl_Clipping::Add (Graphic3d_SequenceOfHClipPlane& thePlanes,
const EquationCoords& theCoordSpace,
const Handle(OpenGl_Workspace)& theWS)
{
#if !defined(GL_ES_VERSION_2_0)
GLint aMatrixMode;
glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);
Handle(OpenGl_Context) aContext = theWS->GetGlContext();
OpenGl_Matrix aCurrentMx;
glGetFloatv (GL_MODELVIEW_MATRIX, (GLfloat*) &aCurrentMx);
if (aMatrixMode != GL_MODELVIEW)
if (EquationCoords_View == theCoordSpace)
{
glMatrixMode (GL_MODELVIEW);
aContext->WorldViewState.Push();
aContext->WorldViewState.SetIdentity();
}
switch (theCoordSpace)
{
case EquationCoords_View: glLoadMatrixf ((const GLfloat*) &OpenGl_IdentityMatrix); break;
case EquationCoords_World: glLoadMatrixf ((const GLfloat*) theWS->ViewMatrix()); break;
}
// Set either identity or pure view matrix.
aContext->ApplyWorldViewMatrix();
Add (thePlanes, theCoordSpace);
// restore model-view matrix
glLoadMatrixf ((GLfloat*) &aCurrentMx);
// restore context matrix state
if (aMatrixMode != GL_MODELVIEW)
if (EquationCoords_View == theCoordSpace)
{
glMatrixMode (aMatrixMode);
aContext->WorldViewState.Pop();
}
#else
Add (thePlanes, theCoordSpace);
#endif
// Restore combined model-view matrix.
aContext->ApplyModelViewMatrix();
}
// =======================================================================

82
src/OpenGl/OpenGl_Context.cxx
View File

@ -2213,3 +2213,85 @@ Standard_Boolean OpenGl_Context::SetGlNormalizeEnabled (Standard_Boolean isEnabl
return anOldGlNormalize;
}
// =======================================================================
// function : ApplyModelWorldMatrix
// purpose :
// =======================================================================
void OpenGl_Context::ApplyModelWorldMatrix()
{
#if !defined(GL_ES_VERSION_2_0)
if (core11 != NULL)
{
core11->glMatrixMode (GL_MODELVIEW);
core11->glLoadMatrixf (ModelWorldState.Current());
}
#endif
if (!myShaderManager->IsEmpty())
{
myShaderManager->UpdateModelWorldStateTo (ModelWorldState.Current());
}
}
// =======================================================================
// function : ApplyWorldViewMatrix
// purpose :
// =======================================================================
void OpenGl_Context::ApplyWorldViewMatrix()
{
#if !defined(GL_ES_VERSION_2_0)
if (core11 != NULL)
{
core11->glMatrixMode (GL_MODELVIEW);
core11->glLoadMatrixf (WorldViewState.Current());
}
#endif
if (!myShaderManager->IsEmpty())
{
myShaderManager->UpdateWorldViewStateTo (WorldViewState.Current());
}
}
// =======================================================================
// function : ApplyModelViewMatrix
// purpose :
// =======================================================================
void OpenGl_Context::ApplyModelViewMatrix()
{
#if !defined(GL_ES_VERSION_2_0)
if (core11 != NULL)
{
OpenGl_Mat4 aModelView = WorldViewState.Current() * ModelWorldState.Current();
core11->glMatrixMode (GL_MODELVIEW);
core11->glLoadMatrixf (aModelView.GetData());
}
#endif
if (!myShaderManager->IsEmpty())
{
myShaderManager->UpdateModelWorldStateTo (ModelWorldState.Current());
myShaderManager->UpdateWorldViewStateTo (WorldViewState.Current());
}
}
// =======================================================================
// function : ApplyProjectionMatrix
// purpose :
// =======================================================================
void OpenGl_Context::ApplyProjectionMatrix()
{
#if !defined(GL_ES_VERSION_2_0)
if (core11 != NULL)
{
core11->glMatrixMode (GL_PROJECTION);
core11->glLoadMatrixf (ProjectionState.Current().GetData());
}
#endif
if (!myShaderManager->IsEmpty())
{
myShaderManager->UpdateProjectionStateTo (ProjectionState.Current());
}
}

19
src/OpenGl/OpenGl_Context.hxx
View File

@ -37,6 +37,7 @@
#include <Handle_OpenGl_Context.hxx>
#include <OpenGl_Clipping.hxx>
#include <OpenGl_GlCore11.hxx>
#include <OpenGl_Utils.hxx>
//! Forward declarations
struct OpenGl_GlFunctions;
@ -384,6 +385,18 @@ public:
//! @return old value of the flag
Standard_EXPORT Standard_Boolean SetGlNormalizeEnabled (Standard_Boolean isEnabled);
//! Applies matrix stored in ModelWorldState to OpenGl.
void ApplyModelWorldMatrix();
//! Applies matrix stored in WorldViewState to OpenGl.
void ApplyWorldViewMatrix();
//! Applies combination of matrices stored in ModelWorldState and WorldViewState to OpenGl.
void ApplyModelViewMatrix();
//! Applies matrix stored in ProjectionState to OpenGl.
void ApplyProjectionMatrix();
public:
//! @return messenger instance
@ -572,6 +585,12 @@ private: //! @name fields tracking current state
Standard_Integer myRenderMode; //!< value for active rendering mode
Standard_Integer myDrawBuffer; //!< current draw buffer
public:
OpenGl_Utils::MatrixState<Standard_ShortReal> ModelWorldState; //!< state of orientation matrix
OpenGl_Utils::MatrixState<Standard_ShortReal> WorldViewState; //!< state of orientation matrix
OpenGl_Utils::MatrixState<Standard_ShortReal> ProjectionState; //!< state of projection matrix
private:
//! Copying allowed only within Handles

71
src/OpenGl/OpenGl_Cylinder.cxx Normal file
View File

@ -0,0 +1,71 @@
// Created on: 2014-10-15
// Created by: Denis Bogolepov
// Copyright (c) 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 <OpenGl_Cylinder.hxx>
// =======================================================================
// function : OpenGl_Cylinder
// purpose :
// =======================================================================
OpenGl_Cylinder::OpenGl_Cylinder()
: myBotRad (1.0f),
myTopRad (1.0f),
myHeight (1.0f)
{
//
}
// =======================================================================
// function : Init
// purpose :
// =======================================================================
Standard_Boolean OpenGl_Cylinder::Init (const Standard_ShortReal theBotRad,
const Standard_ShortReal theTopRad,
const Standard_ShortReal theHeight,
const Standard_Integer theNbSlices,
const Standard_Integer theNbStacks)
{
myBotRad = theBotRad;
myTopRad = theTopRad;
myHeight = theHeight;
return OpenGl_Quadric::init (theNbSlices, theNbStacks);
}
// =======================================================================
// function : evalVertex
// purpose :
// =======================================================================
OpenGl_Vec3 OpenGl_Cylinder::evalVertex (const Standard_ShortReal theU,
const Standard_ShortReal theV) const
{
const Standard_ShortReal aU = static_cast<Standard_ShortReal> (theU * M_PI * 2.0);
const Standard_ShortReal aRadius = myBotRad + (myTopRad - myBotRad) * theV;
return OpenGl_Vec3 (cosf (aU) * aRadius,
sinf (aU) * aRadius,
theV * myHeight);
}
// =======================================================================
// function : evalNormal
// purpose :
// =======================================================================
OpenGl_Vec3 OpenGl_Cylinder::evalNormal (const Standard_ShortReal theU,
const Standard_ShortReal /*theV*/) const
{
const Standard_ShortReal aU = static_cast<Standard_ShortReal> (theU * M_PI * 2.0);
return OpenGl_Vec3 (cosf (aU) * myHeight,
sinf (aU) * myHeight,
myBotRad - myTopRad).Normalized();
}

54
src/OpenGl/OpenGl_Cylinder.hxx Normal file
View File

@ -0,0 +1,54 @@
// Created on: 2014-10-15
// Created by: Denis Bogolepov
// Copyright (c) 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.
#ifndef OpenGl_Cylinder_Header
#define OpenGl_Cylinder_Header
#include <OpenGl_Quadric.hxx>
//! Tool class for generating cylinder tessellation of quadric surface.
class OpenGl_Cylinder : public OpenGl_Quadric
{
public:
//! Create undefined cylinder primitive.
Standard_EXPORT OpenGl_Cylinder();
//! Initialize cylinder primitive.
Standard_EXPORT Standard_Boolean Init (const Standard_ShortReal theBotRad,
const Standard_ShortReal theTopRad,
const Standard_ShortReal theHeight,
const Standard_Integer theNbSlices = 10,
const Standard_Integer theNbStacks = 10);
protected:
//! Returns surface point for the given parameters.
Standard_EXPORT virtual OpenGl_Vec3 evalVertex (const Standard_ShortReal theU,
const Standard_ShortReal theV) const Standard_OVERRIDE;
//! Returns surface normal for the given parameters.
Standard_EXPORT virtual OpenGl_Vec3 evalNormal (const Standard_ShortReal theU,
const Standard_ShortReal theV) const Standard_OVERRIDE;
private:
Standard_ShortReal myBotRad; //!< Radius of the cylinder at bottom
Standard_ShortReal myTopRad; //!< Radius of the cylinder at top
Standard_ShortReal myHeight; //!< Height of the cylinder
};
#endif // OpenGl_Cylinder_Header

63
src/OpenGl/OpenGl_Disk.cxx Normal file
View File

@ -0,0 +1,63 @@
// Created on: 2014-10-15
// Created by: Denis Bogolepov
// Copyright (c) 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 <OpenGl_Disk.hxx>
// =======================================================================
// function : OpenGl_Disk
// purpose :
// =======================================================================
OpenGl_Disk::OpenGl_Disk()
: myInnerRadius (1.0f),
myOuterRadius (1.0f)
{
//
}
// =======================================================================
// function : Init
// purpose :
// =======================================================================
Standard_Boolean OpenGl_Disk::Init (const Standard_ShortReal theInnerRadius,
const Standard_ShortReal theOuterRadius,
const Standard_Integer theNbSlices,
const Standard_Integer theNbStacks)
{
myInnerRadius = theInnerRadius;
myOuterRadius = theOuterRadius;
return OpenGl_Quadric::init (theNbSlices, theNbStacks);
}
// =======================================================================
// function : evalVertex
// purpose :
// =======================================================================
OpenGl_Vec3 OpenGl_Disk::evalVertex (const Standard_ShortReal theU,
const Standard_ShortReal theV) const
{
const Standard_ShortReal aU = static_cast<Standard_ShortReal> (theU * M_PI * 2.0);
const Standard_ShortReal aRadius = myInnerRadius + (myOuterRadius - myInnerRadius) * theV;
return OpenGl_Vec3 (cosf (aU) * aRadius, sinf (aU) * aRadius, 0.0f);
}
// =======================================================================
// function : evalNormal
// purpose :
// =======================================================================
OpenGl_Vec3 OpenGl_Disk::evalNormal (const Standard_ShortReal /*theU*/,
const Standard_ShortReal /*theV*/) const
{
return OpenGl_Vec3 (0.0f, 0.0f, -1.0f);
}

52
src/OpenGl/OpenGl_Disk.hxx Normal file
View File

@ -0,0 +1,52 @@
// Created on: 2014-10-15
// Created by: Denis Bogolepov
// Copyright (c) 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.
#ifndef OpenGl_Disk_Header
#define OpenGl_Disk_Header
#include <OpenGl_Quadric.hxx>
//! Tool class for generating disk (circle) tessellation.
class OpenGl_Disk : public OpenGl_Quadric
{
public:
//! Create uninitialized disk (circle) primitive.
Standard_EXPORT OpenGl_Disk();
//! Initialize disk (circle) primitive.
Standard_EXPORT Standard_Boolean Init (const Standard_ShortReal theInnerRadius,
const Standard_ShortReal theOuterRadius,
const Standard_Integer theNbSlices = 10,
const Standard_Integer theNbStacks = 10);
protected:
//! Returns surface point for the given parameters.
Standard_EXPORT virtual OpenGl_Vec3 evalVertex (const Standard_ShortReal theU,
const Standard_ShortReal theV) const Standard_OVERRIDE;
//! Returns surface normal for the given parameters.
Standard_EXPORT virtual OpenGl_Vec3 evalNormal (const Standard_ShortReal theU,
const Standard_ShortReal theV) const Standard_OVERRIDE;
private:
Standard_ShortReal myInnerRadius; //!< Inner radius of the disk
Standard_ShortReal myOuterRadius; //!< Outer radius of the disk
};
#endif // OpenGl_Disk_Header

75
src/OpenGl/OpenGl_Flipper.cxx
View File

@ -65,7 +65,6 @@ void OpenGl_Flipper::Release (OpenGl_Context*)
void OpenGl_Flipper::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
{
// Check if rendering is to be in immediate mode
const Standard_Boolean isImmediate = (theWorkspace->NamedStatus & OPENGL_NS_IMMEDIATE) != 0;
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
#if !defined(GL_ES_VERSION_2_0)
@ -74,67 +73,17 @@ void OpenGl_Flipper::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
if (!myIsEnabled)
{
// Restore transformation
if (isImmediate)
{
if (aCurrMode != GL_MODELVIEW)
{
glMatrixMode (GL_MODELVIEW);
}
// restore matrix state
aContext->WorldViewState.Pop();
glPopMatrix();
// Apply since we probably in the middle of something.
aContext->ApplyModelViewMatrix();
if (aCurrMode != GL_MODELVIEW)
{
glMatrixMode (aCurrMode);
}
Tmatrix3 aModelWorldState = { { 1.f, 0.f, 0.f, 0.f },
{ 0.f, 1.f, 0.f, 0.f },
{ 0.f, 0.f, 1.f, 0.f },
{ 0.f, 0.f, 0.f, 1.f } };
aContext->ShaderManager()->RevertModelWorldStateTo (&aModelWorldState);
}
else
{
// Update current model-view matrix in the top of the stack
// replacing it with StructureMatrixT*ViewMatrix from the workspace.
theWorkspace->UpdateModelViewMatrix();
}
return;
}
if (isImmediate)
{
if (!aContext->ShaderManager()->IsEmpty())
{
Tmatrix3 aWorldView;
glGetFloatv (GL_MODELVIEW_MATRIX, *aWorldView);
Tmatrix3 aProjection;
glGetFloatv (GL_PROJECTION_MATRIX, *aProjection);
aContext->ShaderManager()->UpdateWorldViewStateTo (&aWorldView);
aContext->ShaderManager()->UpdateProjectionStateTo (&aProjection);
}
if (aCurrMode != GL_MODELVIEW)
{
glMatrixMode (GL_MODELVIEW);
}
glPushMatrix();
if (aCurrMode != GL_MODELVIEW)
{
glMatrixMode (aCurrMode);
}
}
OpenGl_Mat4 aMatrixMV;
glGetFloatv (GL_MODELVIEW_MATRIX, aMatrixMV.ChangeData());
aContext->WorldViewState.Push();
OpenGl_Mat4 aMatrixMV = aContext->WorldViewState.Current() * aContext->ModelWorldState.Current();
const OpenGl_Vec4 aMVReferenceOrigin = aMatrixMV * myReferenceOrigin;
const OpenGl_Vec4 aMVReferenceX = aMatrixMV * OpenGl_Vec4 (myReferenceX.xyz() + myReferenceOrigin.xyz(), 1.0f);
@ -189,16 +138,8 @@ void OpenGl_Flipper::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
aMatrixMV = aMatrixMV * aTransform;
// load transformed model-view matrix
if (aCurrMode != GL_MODELVIEW)
{
glMatrixMode (GL_MODELVIEW);
}
aContext->WorldViewState.SetCurrent (aMatrixMV);
aContext->ApplyWorldViewMatrix();
glLoadMatrixf ((GLfloat*) aMatrixMV);
if (aCurrMode != GL_MODELVIEW)
{
glMatrixMode (aCurrMode);
}
#endif
}

42
src/OpenGl/OpenGl_GraduatedTrihedron.cxx
View File

@ -15,11 +15,6 @@
#include <OpenGl_GlCore11.hxx>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <InterfaceGraphic_Graphic3d.hxx>
#include <InterfaceGraphic_Aspect.hxx>
#include <InterfaceGraphic_Visual3d.hxx>
@ -28,10 +23,11 @@
#include <string.h>
#endif
#include <OpenGl_AspectLine.hxx>
#include <OpenGl_GraduatedTrihedron.hxx>
#include <OpenGl_Utils.hxx>
#include <OpenGl_Workspace.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_GraduatedTrihedron.hxx>
#include <OpenGl_AspectLine.hxx>
const OpenGl_AspectLine myDefaultAspectLine;
@ -55,9 +51,35 @@ static float getNormal(float* normal)
glGetIntegerv(GL_VIEWPORT, viewport);
double x1, y1, z1, x2, y2, z2, x3, y3, z3;
gluUnProject(viewport[0], viewport[1], 0., model_matrix, proj_matrix, viewport, &x1, &y1, &z1);
gluUnProject(viewport[0] + viewport[2], viewport[1], 0., model_matrix, proj_matrix, viewport, &x2, &y2, &z2);
gluUnProject(viewport[0], viewport[1] + viewport[3], 0., model_matrix, proj_matrix, viewport, &x3, &y3, &z3);
OpenGl_Utils::UnProject<Standard_Real> (viewport[0],
viewport[1],
0.0,
OpenGl_Mat4d::Map (model_matrix),
OpenGl_Mat4d::Map (proj_matrix),
viewport,
x1,
y1,
z1);
OpenGl_Utils::UnProject<Standard_Real> (viewport[0] + viewport[2],
viewport[1],
0.0,
OpenGl_Mat4d::Map (model_matrix),
OpenGl_Mat4d::Map (proj_matrix),
viewport,
x2,
y2,
z2);
OpenGl_Utils::UnProject<Standard_Real> (viewport[0],
viewport[1] + viewport[3],
0.0,
OpenGl_Mat4d::Map (model_matrix),
OpenGl_Mat4d::Map (proj_matrix),
viewport,
x3,
y3,
z3);
/* Normal out of user is p1p3^p1p2 */
const double dx1 = x3 - x1;

9
src/OpenGl/OpenGl_PrimitiveArray.cxx
View File

@ -604,9 +604,13 @@ OpenGl_PrimitiveArray::OpenGl_PrimitiveArray (const OpenGl_GraphicDriver*
myAttribs (theAttribs),
myBounds (theBounds),
myDrawMode (DRAW_MODE_NONE),
myIsVboInit (Standard_False),
myUID (theDriver->GetNextPrimitiveArrayUID())
myIsVboInit (Standard_False)
{
if (theDriver != NULL)
{
myUID = theDriver->GetNextPrimitiveArrayUID();
}
if (!myIndices.IsNull()
&& myIndices->NbElements < 1)
{
@ -673,6 +677,7 @@ OpenGl_PrimitiveArray::~OpenGl_PrimitiveArray()
// =======================================================================
void OpenGl_PrimitiveArray::Release (OpenGl_Context* theContext)
{
myIsVboInit = Standard_False;
if (!myVboIndices.IsNull())
{
if (theContext)

8
src/OpenGl/OpenGl_PrinterContext.cxx
View File

@ -51,14 +51,12 @@ OpenGl_PrinterContext::~OpenGl_PrinterContext()
}
// =======================================================================
// function : LoadProjTransformation
// function : ProjTransformation
// purpose :
// =======================================================================
void OpenGl_PrinterContext::LoadProjTransformation()
OpenGl_Mat4 OpenGl_PrinterContext::ProjTransformation()
{
#if !defined(GL_ES_VERSION_2_0)
glLoadMatrixf ((GLfloat* )myProjMatrixGl);
#endif
return OpenGl_Mat4::Map (myProjMatrixGl);
}
// =======================================================================

5
src/OpenGl/OpenGl_PrinterContext.hxx
View File

@ -19,6 +19,7 @@
#include <Standard_DefineHandle.hxx>
#include <TColStd_Array2OfReal.hxx>
#include <Handle_Standard_Transient.hxx>
#include <OpenGl_Vec.hxx>
//! Class provides specific information for redrawing view to offscreen buffer
//! on printing. The information is: projection matrixes for tiling,
@ -44,8 +45,8 @@ public:
//! theProjTransform parameter should be an 4x4 array.
bool SetProjTransformation (const TColStd_Array2OfReal& theProjTransform);
//! Setup view projection transformation matrix (glLoadMatrixf).
void LoadProjTransformation();
//! Returns projection matrix.
OpenGl_Mat4 ProjTransformation();
//! Get text/markers scale factor
inline void GetScale (Standard_ShortReal& theScaleX,

105
src/OpenGl/OpenGl_Quadric.cxx Normal file
View File

@ -0,0 +1,105 @@
// Created on: 2014-10-15
// Created by: Denis Bogolepov
// Copyright (c) 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 <OpenGl_Quadric.hxx>
#include <NCollection_AlignedAllocator.hxx>
// =======================================================================
// function : OpenGl_Quadric
// purpose :
// =======================================================================
OpenGl_Quadric::OpenGl_Quadric()
: OpenGl_PrimitiveArray (NULL, Graphic3d_TOPA_TRIANGLES, NULL, NULL, NULL),
myNbSlices (0),
myNbStacks (0)
{
myDrawMode = GL_TRIANGLES;
}
// =======================================================================
// function : init
// purpose :
// =======================================================================
Standard_Boolean OpenGl_Quadric::init (const Standard_Integer theNbSlices,
const Standard_Integer theNbStacks)
{
myNbSlices = theNbSlices;
myNbStacks = theNbStacks;
return createArrays();
}
// =======================================================================
// function : Release
// purpose :
// =======================================================================
void OpenGl_Quadric::Release (OpenGl_Context* theContext)
{
myNbSlices = 0;
myNbStacks = 0;
OpenGl_PrimitiveArray::Release (theContext);
}
// =======================================================================
// function : createArrays
// purpose :
// =======================================================================
Standard_Boolean OpenGl_Quadric::createArrays() const
{
// Evaluate surface points and normals
Graphic3d_Attribute anAttribsInfo[] =
{
{ Graphic3d_TOA_POS, Graphic3d_TOD_VEC3 },
{ Graphic3d_TOA_NORM, Graphic3d_TOD_VEC3 }
};
Handle(NCollection_AlignedAllocator) anAlloc = new NCollection_AlignedAllocator (16);
myAttribs = new Graphic3d_Buffer (anAlloc);
myIndices = new Graphic3d_IndexBuffer (anAlloc);
if (!myAttribs->Init (NbVertices(), anAttribsInfo, 2)
|| !myIndices->Init<GLuint> (NbTriangles() * 3))
{
return Standard_False;
}
const Standard_ShortReal aStepU = 1.0f / myNbSlices;
const Standard_ShortReal aStepV = 1.0f / myNbStacks;
for (Standard_Integer aU = 0; aU <= myNbSlices; ++aU)
{
const Standard_ShortReal aParamU = aU * aStepU;
for (Standard_Integer aV = 0; aV <= myNbStacks; ++aV)
{
const Standard_ShortReal aParamV = aV * aStepV;
const Standard_Integer aVertId = aU * (myNbStacks + 1) + aV;
Graphic3d_Vec3* aVertData = reinterpret_cast<Graphic3d_Vec3* >(myAttribs->changeValue (aVertId));
aVertData[0] = evalVertex (aParamU, aParamV);
aVertData[1] = evalNormal (aParamU, aParamV);
}
}
// Extract triangle indices
for (Standard_Integer aU = 0, aLastIndex = -1; aU < myNbSlices; ++aU)
{
for (Standard_Integer aV = 0; aV < myNbStacks; ++aV)
{
myIndices->ChangeValue<GLuint> (++aLastIndex) = aU * (myNbStacks + 1) + aV;
myIndices->ChangeValue<GLuint> (++aLastIndex) = (aU + 1) * (myNbStacks + 1) + aV;
myIndices->ChangeValue<GLuint> (++aLastIndex) = (aU + 1) * (myNbStacks + 1) + (aV + 1);
myIndices->ChangeValue<GLuint> (++aLastIndex) = (aU + 1) * (myNbStacks + 1) + (aV + 1);
myIndices->ChangeValue<GLuint> (++aLastIndex) = aU * (myNbStacks + 1) + (aV + 1);
myIndices->ChangeValue<GLuint> (++aLastIndex) = aU * (myNbStacks + 1) + aV;
}
}
return Standard_True;
}

74
src/OpenGl/OpenGl_Quadric.hxx Normal file
View File

@ -0,0 +1,74 @@
// Created on: 2014-10-15
// Created by: Denis Bogolepov
// Copyright (c) 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.
#ifndef OpenGl_Quadric_Header
#define OpenGl_Quadric_Header
#include <OpenGl_PrimitiveArray.hxx>
//! Class for rendering of arbitrary primitive array.
//! Tool class for generating tessellation of quadric surface.
class OpenGl_Quadric : public OpenGl_PrimitiveArray
{
public:
//! Creates undefined abstract quadric surface
Standard_EXPORT OpenGl_Quadric();
//! Returns true if quadric has been defined
Standard_Boolean IsDefined() const { return myNbSlices != 0; }
//! Returns number of slices
Standard_Integer NbSlices() const { return myNbSlices; }
//! Returns number of stacks
Standard_Integer NbStacks() const { return myNbStacks; }
//! Returns total number of vertices
Standard_Integer NbVertices() const { return (myNbSlices + 1) * (myNbStacks + 1); }
//! Returns total number of triangles
Standard_Integer NbTriangles() const { return myNbSlices * myNbStacks * 2; }
//! Release GL resources
virtual void Release (OpenGl_Context* theContext) Standard_OVERRIDE;
protected:
//! Returns surface point for the given parameters.
virtual OpenGl_Vec3 evalVertex (const Standard_ShortReal theU,
const Standard_ShortReal theV) const = 0;
//! Returns surface normal for the given parameters.
virtual OpenGl_Vec3 evalNormal (const Standard_ShortReal theU,
const Standard_ShortReal theV) const = 0;
//! Initialize primitive.
Standard_EXPORT Standard_Boolean init (const Standard_Integer theNbSlices,
const Standard_Integer theNbStacks);
private:
//! Initialize arrays.
Standard_Boolean createArrays() const;
private:
Standard_Integer myNbSlices; //!< Number of slices (u partitions)
Standard_Integer myNbStacks; //!< Number of stacks (v partitions)
};
#endif // OpenGl_Quadric_Header

12
src/OpenGl/OpenGl_ShaderManager.cxx
View File

@ -384,7 +384,7 @@ void OpenGl_ShaderManager::SetShadingModel (const Visual3d_TypeOfModel theModel)
// function : SetProjectionState
// purpose : Sets new state of OCCT projection transform
// =======================================================================
void OpenGl_ShaderManager::UpdateProjectionStateTo (const Tmatrix3* theProjectionMatrix)
void OpenGl_ShaderManager::UpdateProjectionStateTo (const OpenGl_Mat4& theProjectionMatrix)
{
myProjectionState.Set (theProjectionMatrix);
myProjectionState.Update();
@ -394,7 +394,7 @@ void OpenGl_ShaderManager::UpdateProjectionStateTo (const Tmatrix3* theProjectio
// function : SetModelWorldState
// purpose : Sets new state of OCCT model-world transform
// =======================================================================
void OpenGl_ShaderManager::UpdateModelWorldStateTo (const Tmatrix3* theModelWorldMatrix)
void OpenGl_ShaderManager::UpdateModelWorldStateTo (const OpenGl_Mat4& theModelWorldMatrix)
{
myModelWorldState.Set (theModelWorldMatrix);
myModelWorldState.Update();
@ -404,7 +404,7 @@ void OpenGl_ShaderManager::UpdateModelWorldStateTo (const Tmatrix3* theModelWorl
// function : SetWorldViewState
// purpose : Sets new state of OCCT world-view transform
// =======================================================================
void OpenGl_ShaderManager::UpdateWorldViewStateTo (const Tmatrix3* theWorldViewMatrix)
void OpenGl_ShaderManager::UpdateWorldViewStateTo (const OpenGl_Mat4& theWorldViewMatrix)
{
myWorldViewState.Set (theWorldViewMatrix);
myWorldViewState.Update();
@ -414,7 +414,7 @@ void OpenGl_ShaderManager::UpdateWorldViewStateTo (const Tmatrix3* theWorldViewM
// function : RevertProjectionStateTo
// purpose : Reverts state of OCCT projection transform
// =======================================================================
void OpenGl_ShaderManager::RevertProjectionStateTo (const Tmatrix3* theProjectionMatrix)
void OpenGl_ShaderManager::RevertProjectionStateTo (const OpenGl_Mat4& theProjectionMatrix)
{
myProjectionState.Set (theProjectionMatrix);
myProjectionState.Revert();
@ -424,7 +424,7 @@ void OpenGl_ShaderManager::RevertProjectionStateTo (const Tmatrix3* theProjectio
// function : RevertModelWorldStateTo
// purpose : Reverts state of OCCT model-world transform
// =======================================================================
void OpenGl_ShaderManager::RevertModelWorldStateTo (const Tmatrix3* theModelWorldMatrix)
void OpenGl_ShaderManager::RevertModelWorldStateTo (const OpenGl_Mat4& theModelWorldMatrix)
{
myModelWorldState.Set (theModelWorldMatrix);
myModelWorldState.Revert();
@ -434,7 +434,7 @@ void OpenGl_ShaderManager::RevertModelWorldStateTo (const Tmatrix3* theModelWorl
// function : RevertWorldViewStateTo
// purpose : Reverts state of OCCT world-view transform
// =======================================================================
void OpenGl_ShaderManager::RevertWorldViewStateTo (const Tmatrix3* theWorldViewMatrix)
void OpenGl_ShaderManager::RevertWorldViewStateTo (const OpenGl_Mat4& theWorldViewMatrix)
{
myWorldViewState.Set (theWorldViewMatrix);
myWorldViewState.Revert();

12
src/OpenGl/OpenGl_ShaderManager.hxx
View File

@ -162,10 +162,10 @@ public:
Standard_EXPORT const OpenGl_ProjectionState& ProjectionState() const;
//! Updates state of OCCT projection transform.
Standard_EXPORT void UpdateProjectionStateTo (const Tmatrix3* theProjectionMatrix);
Standard_EXPORT void UpdateProjectionStateTo (const OpenGl_Mat4& theProjectionMatrix);
//! Reverts state of OCCT projection transform.
Standard_EXPORT void RevertProjectionStateTo (const Tmatrix3* theProjectionMatrix);
Standard_EXPORT void RevertProjectionStateTo (const OpenGl_Mat4& theProjectionMatrix);
//! Pushes current state of OCCT projection transform to specified program.
Standard_EXPORT void PushProjectionState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
@ -176,10 +176,10 @@ public:
Standard_EXPORT const OpenGl_ModelWorldState& ModelWorldState() const;
//! Updates state of OCCT model-world transform.
Standard_EXPORT void UpdateModelWorldStateTo (const Tmatrix3* theModelWorldMatrix);
Standard_EXPORT void UpdateModelWorldStateTo (const OpenGl_Mat4& theModelWorldMatrix);
//! Reverts state of OCCT model-world transform.
Standard_EXPORT void RevertModelWorldStateTo (const Tmatrix3* theModelWorldMatrix);
Standard_EXPORT void RevertModelWorldStateTo (const OpenGl_Mat4& theModelWorldMatrix);
//! Pushes current state of OCCT model-world transform to specified program.
Standard_EXPORT void PushModelWorldState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
@ -190,10 +190,10 @@ public:
Standard_EXPORT const OpenGl_WorldViewState& WorldViewState() const;
//! Updates state of OCCT world-view transform.
Standard_EXPORT void UpdateWorldViewStateTo (const Tmatrix3* theWorldViewMatrix);
Standard_EXPORT void UpdateWorldViewStateTo (const OpenGl_Mat4& theWorldViewMatrix);
//! Reverts state of OCCT world-view transform.
Standard_EXPORT void RevertWorldViewStateTo (const Tmatrix3* theWorldViewMatrix);
Standard_EXPORT void RevertWorldViewStateTo (const OpenGl_Mat4& theWorldViewMatrix);
//! Pushes current state of OCCT world-view transform to specified program.
Standard_EXPORT void PushWorldViewState (const Handle(OpenGl_ShaderProgram)& theProgram) const;

40
src/OpenGl/OpenGl_ShaderProgram.cxx
View File

@ -1071,7 +1071,7 @@ Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)&
return Standard_False;
}
theCtx->core20->glUniformMatrix4fv (theLocation, 1, theTranspose, theValue);
theCtx->core20->glUniformMatrix4fv (theLocation, 1, GL_FALSE, theTranspose ? theValue.Transposed() : theValue);
return Standard_True;
}
@ -1096,43 +1096,7 @@ Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)&
const OpenGl_Matrix& theValue,
GLboolean theTranspose)
{
if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
{
return Standard_False;
}
theCtx->core20->glUniformMatrix4fv (theLocation, 1, theTranspose, *theValue.mat);
return Standard_True;
}
// =======================================================================
// function : SetUniform
// purpose : Specifies the value of the floating-point uniform 4x4 matrix
// =======================================================================
Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
const GLchar* theName,
const Tmatrix3& theValue,
GLboolean theTranspose)
{
return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue, theTranspose);
}
// =======================================================================
// function : SetUniform
// purpose : Specifies the value of the floating-point uniform 4x4 matrix
// =======================================================================
Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
GLint theLocation,
const Tmatrix3& theValue,
GLboolean theTranspose)
{
if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
{
return Standard_False;
}
theCtx->core20->glUniformMatrix4fv (theLocation, 1, theTranspose, *theValue);
return Standard_True;
return SetUniform (theCtx, theLocation, OpenGl_Mat4::Map (*theValue.mat), theTranspose);
}
// =======================================================================

12
src/OpenGl/OpenGl_ShaderProgram.hxx
View File

@ -442,18 +442,6 @@ public:
const OpenGl_Matrix& theValue,
GLboolean theTranspose = GL_FALSE);
//! Specifies the value of the float uniform 4x4 matrix.
Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
const GLchar* theName,
const Tmatrix3& theValue,
GLboolean theTranspose = GL_FALSE);
//! Specifies the value of the float uniform 4x4 matrix.
Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
GLint theLocation,
const Tmatrix3& theValue,
GLboolean theTranspose = GL_FALSE);
//! Specifies the value of the float uniform array
Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
GLint theLocation,

36
src/OpenGl/OpenGl_ShaderStates.cxx
View File

@ -79,9 +79,9 @@ OpenGl_ProjectionState::OpenGl_ProjectionState()
// function : Set
// purpose : Sets new OCCT projection state
// =======================================================================
void OpenGl_ProjectionState::Set (const Tmatrix3* theProjectionMatrix)
void OpenGl_ProjectionState::Set (const OpenGl_Mat4& theProjectionMatrix)
{
memcpy (myProjectionMatrix, theProjectionMatrix, sizeof (Tmatrix3));
myProjectionMatrix = theProjectionMatrix;
myInverseNeedUpdate = true;
}
@ -89,7 +89,7 @@ void OpenGl_ProjectionState::Set (const Tmatrix3* theProjectionMatrix)
// function : ProjectionMatrix
// purpose : Returns current projection matrix
// =======================================================================
const Tmatrix3& OpenGl_ProjectionState::ProjectionMatrix() const
const OpenGl_Mat4& OpenGl_ProjectionState::ProjectionMatrix() const
{
return myProjectionMatrix;
}
@ -98,15 +98,15 @@ const Tmatrix3& OpenGl_ProjectionState::ProjectionMatrix() const
// function : ProjectionMatrixInverse
// purpose : Returns inverse of current projection matrix
// =======================================================================
const Tmatrix3& OpenGl_ProjectionState::ProjectionMatrixInverse() const
const OpenGl_Mat4& OpenGl_ProjectionState::ProjectionMatrixInverse() const
{
if (!myInverseNeedUpdate)
{
return myProjectionMatrixInverse;
}
reinterpret_cast<const NCollection_Mat4<float>*> (*myProjectionMatrix)->Inverted (
*(reinterpret_cast<NCollection_Mat4<float>*> (*myProjectionMatrixInverse)));
myProjectionMatrix.Inverted (myProjectionMatrixInverse);
return myProjectionMatrixInverse;
}
@ -124,9 +124,9 @@ OpenGl_ModelWorldState::OpenGl_ModelWorldState()
// function : Set
// purpose : Sets new model-world matrix
// =======================================================================
void OpenGl_ModelWorldState::Set (const Tmatrix3* theModelWorldMatrix)
void OpenGl_ModelWorldState::Set (const OpenGl_Mat4& theModelWorldMatrix)
{
memcpy (myModelWorldMatrix, theModelWorldMatrix, sizeof (Tmatrix3));
myModelWorldMatrix = theModelWorldMatrix;
myInverseNeedUpdate = true;
}
@ -134,7 +134,7 @@ void OpenGl_ModelWorldState::Set (const Tmatrix3* theModelWorldMatrix)
// function : ModelWorldMatrix
// purpose : Returns current model-world matrix
// =======================================================================
const Tmatrix3& OpenGl_ModelWorldState::ModelWorldMatrix() const
const OpenGl_Mat4& OpenGl_ModelWorldState::ModelWorldMatrix() const
{
return myModelWorldMatrix;
}
@ -143,15 +143,15 @@ const Tmatrix3& OpenGl_ModelWorldState::ModelWorldMatrix() const
// function : ModelWorldMatrixInverse
// purpose : Returns inverse of current model-world matrix
// =======================================================================
const Tmatrix3& OpenGl_ModelWorldState::ModelWorldMatrixInverse() const
const OpenGl_Mat4& OpenGl_ModelWorldState::ModelWorldMatrixInverse() const
{
if (!myInverseNeedUpdate)
{
return myModelWorldMatrix;
}
reinterpret_cast<const NCollection_Mat4<float>*> (*myModelWorldMatrix)->Inverted (
*(reinterpret_cast<NCollection_Mat4<float>*> (*myModelWorldMatrixInverse)));
myModelWorldMatrix.Inverted (myModelWorldMatrixInverse);
return myModelWorldMatrixInverse;
}
@ -169,9 +169,9 @@ OpenGl_WorldViewState::OpenGl_WorldViewState()
// function : Set
// purpose : Sets new world-view matrix
// =======================================================================
void OpenGl_WorldViewState::Set (const Tmatrix3* theWorldViewMatrix)
void OpenGl_WorldViewState::Set (const OpenGl_Mat4& theWorldViewMatrix)
{
memcpy (myWorldViewMatrix, theWorldViewMatrix, sizeof (Tmatrix3));
myWorldViewMatrix = theWorldViewMatrix;
myInverseNeedUpdate = true;
}
@ -179,7 +179,7 @@ void OpenGl_WorldViewState::Set (const Tmatrix3* theWorldViewMatrix)
// function : WorldViewMatrix
// purpose : Returns current world-view matrix
// =======================================================================
const Tmatrix3& OpenGl_WorldViewState::WorldViewMatrix() const
const OpenGl_Mat4& OpenGl_WorldViewState::WorldViewMatrix() const
{
return myWorldViewMatrix;
}
@ -188,15 +188,15 @@ const Tmatrix3& OpenGl_WorldViewState::WorldViewMatrix() const
// function : WorldViewMatrixInverse
// purpose : Returns inverse of current world-view matrix
// =======================================================================
const Tmatrix3& OpenGl_WorldViewState::WorldViewMatrixInverse() const
const OpenGl_Mat4& OpenGl_WorldViewState::WorldViewMatrixInverse() const
{
if (!myInverseNeedUpdate)
{
return myWorldViewMatrix;
}
reinterpret_cast<const NCollection_Mat4<float>*> (*myWorldViewMatrix)->Inverted (
*(reinterpret_cast<NCollection_Mat4<float>*> (*myWorldViewMatrixInverse)));
myWorldViewMatrix.Inverted (myWorldViewMatrixInverse);
return myWorldViewMatrixInverse;
}

37
src/OpenGl/OpenGl_ShaderStates.hxx
View File

@ -20,6 +20,7 @@
#include <OpenGl_Element.hxx>
#include <OpenGl_Light.hxx>
#include <OpenGl_Vec.hxx>
#include <NCollection_List.hxx>
@ -57,19 +58,19 @@ public:
OpenGl_ProjectionState();
//! Sets new projection matrix.
void Set (const Tmatrix3* theProjectionMatrix);
void Set (const OpenGl_Mat4& theProjectionMatrix);
//! Returns current projection matrix.
const Tmatrix3& ProjectionMatrix() const;
const OpenGl_Mat4& ProjectionMatrix() const;
//! Returns inverse of current projection matrix.
const Tmatrix3& ProjectionMatrixInverse() const;
const OpenGl_Mat4& ProjectionMatrixInverse() const;
private:
Tmatrix3 myProjectionMatrix; //!< OCCT projection matrix
mutable Tmatrix3 myProjectionMatrixInverse; //!< Inverse of OCCT projection matrix
bool myInverseNeedUpdate; //!< Is inversed matrix outdated?
OpenGl_Mat4 myProjectionMatrix; //!< OCCT projection matrix
mutable OpenGl_Mat4 myProjectionMatrixInverse; //!< Inverse of OCCT projection matrix
bool myInverseNeedUpdate; //!< Is inversed matrix outdated?
};
@ -82,19 +83,19 @@ public:
OpenGl_ModelWorldState();
//! Sets new model-world matrix.
void Set (const Tmatrix3* theModelWorldMatrix);
void Set (const OpenGl_Mat4& theModelWorldMatrix);
//! Returns current model-world matrix.
const Tmatrix3& ModelWorldMatrix() const;
const OpenGl_Mat4& ModelWorldMatrix() const;
//! Returns inverse of current model-world matrix.
const Tmatrix3& ModelWorldMatrixInverse() const;
const OpenGl_Mat4& ModelWorldMatrixInverse() const;
private:
Tmatrix3 myModelWorldMatrix; //!< OCCT model-world matrix
mutable Tmatrix3 myModelWorldMatrixInverse; //!< Inverse of OCCT model-world matrix
bool myInverseNeedUpdate; //!< Is inversed matrix outdated?
OpenGl_Mat4 myModelWorldMatrix; //!< OCCT model-world matrix
mutable OpenGl_Mat4 myModelWorldMatrixInverse; //!< Inverse of OCCT model-world matrix
bool myInverseNeedUpdate; //!< Is inversed matrix outdated?
};
@ -107,19 +108,19 @@ public:
OpenGl_WorldViewState();
//! Sets new world-view matrix.
void Set (const Tmatrix3* theWorldViewMatrix);
void Set (const OpenGl_Mat4& theWorldViewMatrix);
//! Returns current world-view matrix.
const Tmatrix3& WorldViewMatrix() const;
const OpenGl_Mat4& WorldViewMatrix() const;
//! Returns inverse of current world-view matrix.
const Tmatrix3& WorldViewMatrixInverse() const;
const OpenGl_Mat4& WorldViewMatrixInverse() const;
private:
Tmatrix3 myWorldViewMatrix; //!< OCCT world-view matrix
mutable Tmatrix3 myWorldViewMatrixInverse; //!< Inverse of OCCT world-view matrix
bool myInverseNeedUpdate; //!< Is inversed matrix outdated?
OpenGl_Mat4 myWorldViewMatrix; //!< OCCT world-view matrix
mutable OpenGl_Mat4 myWorldViewMatrixInverse; //!< Inverse of OCCT world-view matrix
bool myInverseNeedUpdate; //!< Is inversed matrix outdated?
};

66
src/OpenGl/OpenGl_Sphere.cxx Normal file
View File

@ -0,0 +1,66 @@
// Created on: 2014-10-15
// Created by: Denis Bogolepov
// Copyright (c) 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 <OpenGl_Sphere.hxx>
// =======================================================================
// function : OpenGl_Sphere
// purpose :
// =======================================================================
OpenGl_Sphere::OpenGl_Sphere()
: myRadius (1.0f)
{
//
}
// =======================================================================
// function : Init
// purpose :
// =======================================================================
Standard_Boolean OpenGl_Sphere::Init (const Standard_ShortReal theRadius,
const Standard_Integer theNbSlices,
const Standard_Integer theNbStacks)
{
myRadius = theRadius;
return OpenGl_Quadric::init (theNbSlices, theNbStacks);
}
// =======================================================================
// function : evalVertex
// purpose :
// =======================================================================
OpenGl_Vec3 OpenGl_Sphere::evalVertex (const Standard_ShortReal theU,
const Standard_ShortReal theV) const
{
const Standard_ShortReal aU = static_cast<Standard_ShortReal> (theU * M_PI * 2.0);
const Standard_ShortReal aV = static_cast<Standard_ShortReal> (theV * M_PI);
return OpenGl_Vec3 (myRadius * cosf (aU) * sinf (aV),
-myRadius * sinf (aU) * sinf (aV),
myRadius * cosf (aV));
}
// =======================================================================
// function : evalNormal
// purpose :
// =======================================================================
OpenGl_Vec3 OpenGl_Sphere::evalNormal (const Standard_ShortReal theU,
const Standard_ShortReal theV) const
{
const Standard_ShortReal aU = static_cast<Standard_ShortReal> (theU * M_PI * 2.0);
const Standard_ShortReal aV = static_cast<Standard_ShortReal> (theV * M_PI);
return OpenGl_Vec3 (cosf (aU) * sinf (aV),
-sinf (aU) * sinf (aV),
cosf (aV));
}

50
src/OpenGl/OpenGl_Sphere.hxx Normal file
View File

@ -0,0 +1,50 @@
// Created on: 2014-10-15
// Created by: Denis Bogolepov
// Copyright (c) 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.
#ifndef OpenGl_Sphere_Header
#define OpenGl_Sphere_Header
#include <OpenGl_Quadric.hxx>
//! Tool class for generating sphere tessellation.
class OpenGl_Sphere : public OpenGl_Quadric
{
public:
//! Creates undefined sphere primitive.
Standard_EXPORT OpenGl_Sphere();
//! Initialize sphere primitive.
Standard_EXPORT Standard_Boolean Init (const Standard_ShortReal theRadius,
const Standard_Integer theNbSlices = 10,
const Standard_Integer theNbStacks = 10);
protected:
//! Returns surface point for the given parameters.
Standard_EXPORT virtual OpenGl_Vec3 evalVertex (const Standard_ShortReal theU,
const Standard_ShortReal theV) const Standard_OVERRIDE;
//! Returns surface normal for the given parameters.
Standard_EXPORT virtual OpenGl_Vec3 evalNormal (const Standard_ShortReal theU,
const Standard_ShortReal theV) const Standard_OVERRIDE;
protected:
Standard_ShortReal myRadius; //!< Sphere radius
};
#endif // OpenGl_Sphere_Header

126
src/OpenGl/OpenGl_Structure.cxx
View File

@ -117,19 +117,6 @@ public:
/*----------------------------------------------------------------------*/
// =======================================================================
// function : call_util_transpose_mat
// purpose :
// =======================================================================
static void call_util_transpose_mat (float tmat[16], float mat[4][4])
{
int i, j;
for (i=0; i<4; i++)
for (j=0; j<4; j++)
tmat[j*4+i] = mat[i][j];
}
// =======================================================================
// function : OpenGl_Structure
// purpose :
@ -645,24 +632,22 @@ void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) con
return;
}
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
// Render named status
const Standard_Integer aNamedStatus = theWorkspace->NamedStatus;
theWorkspace->NamedStatus |= myNamedStatus;
// Is rendering in ADD or IMMEDIATE mode?
const Standard_Boolean isImmediate = (theWorkspace->NamedStatus & OPENGL_NS_IMMEDIATE) != 0;
// Do we need to restore GL_NORMALIZE?
Standard_Boolean anOldGlNormalize = aContext->IsGlNormalizeEnabled();
const Standard_Boolean anOldGlNormalize = aCtx->IsGlNormalizeEnabled();
// Apply local transformation
GLint aMatrixMode = 0;
const OpenGl_Matrix* aLocalTrsf = NULL;
if (myTransformation)
{
#if !defined(GL_ES_VERSION_2_0)
OpenGl_Matrix aModelWorld;
OpenGl_Transposemat3 (&aModelWorld, myTransformation);
aCtx->ModelWorldState.Push();
aCtx->ModelWorldState.SetCurrent (OpenGl_Mat4::Map ((Standard_ShortReal* )aModelWorld.mat));
Standard_ShortReal aScaleX = OpenGl_Vec3 (myTransformation->mat[0][0],
myTransformation->mat[0][1],
@ -670,51 +655,20 @@ void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) con
// Scale transform detected.
if (Abs (aScaleX - 1.f) > Precision::Confusion())
{
anOldGlNormalize = aContext->SetGlNormalizeEnabled (Standard_True);
aCtx->SetGlNormalizeEnabled (Standard_True);
}
if (isImmediate)
{
Tmatrix3 aModelWorld;
call_util_transpose_mat (*aModelWorld, myTransformation->mat);
glGetIntegerv (GL_MATRIX_MODE, &aMatrixMode);
if (!aContext->ShaderManager()->IsEmpty())
{
Tmatrix3 aWorldView;
glGetFloatv (GL_MODELVIEW_MATRIX, *aWorldView);
Tmatrix3 aProjection;
glGetFloatv (GL_PROJECTION_MATRIX, *aProjection);
aContext->ShaderManager()->UpdateModelWorldStateTo (&aModelWorld);
aContext->ShaderManager()->UpdateWorldViewStateTo (&aWorldView);
aContext->ShaderManager()->UpdateProjectionStateTo (&aProjection);
}
glMatrixMode (GL_MODELVIEW);
glPushMatrix ();
glScalef (1.0f, 1.0f, 1.0f);
glMultMatrixf (*aModelWorld);
}
else
{
glMatrixMode (GL_MODELVIEW);
glPushMatrix();
aLocalTrsf = theWorkspace->SetStructureMatrix (myTransformation);
}
#endif
}
// Apply transform persistence
const TEL_TRANSFORM_PERSISTENCE *aTransPersistence = NULL;
if ( myTransPers && myTransPers->mode != 0 )
{
aTransPersistence = theWorkspace->ActiveView()->BeginTransformPersistence (aContext, myTransPers);
aTransPersistence = theWorkspace->ActiveView()->BeginTransformPersistence (aCtx, myTransPers);
}
// Take into account transform persistence
aCtx->ApplyModelViewMatrix();
// Apply aspects
const OpenGl_AspectLine *anAspectLine = theWorkspace->AspectLine (Standard_False);
const OpenGl_AspectFace *anAspectFace = theWorkspace->AspectFace (Standard_False);
@ -740,7 +694,7 @@ void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) con
// Apply correction for mirror transform
if (myIsMirrored)
{
glFrontFace (GL_CW);
aCtx->core11fwd->glFrontFace (GL_CW);
}
// Apply highlight color
@ -784,12 +738,12 @@ void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) con
if (!aUserPlanes.IsNull() && !aUserPlanes->IsEmpty())
{
// add planes at loaded view matrix state
aContext->ChangeClipping().AddWorld (*aUserPlanes, theWorkspace);
aCtx->ChangeClipping().AddWorld (*aUserPlanes, theWorkspace);
// Set OCCT state uniform variables
if (!aContext->ShaderManager()->IsEmpty())
if (!aCtx->ShaderManager()->IsEmpty())
{
aContext->ShaderManager()->UpdateClippingState();
aCtx->ShaderManager()->UpdateClippingState();
}
}
@ -802,10 +756,12 @@ void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) con
// Reset correction for mirror transform
if (myIsMirrored)
glFrontFace (GL_CCW); // default
{
aCtx->core11fwd->glFrontFace (GL_CCW);
}
// Render capping for structure groups
if (!aContext->Clipping().Planes().IsEmpty())
if (!aCtx->Clipping().Planes().IsEmpty())
{
OpenGl_CappingAlgo::RenderCapping (theWorkspace, aGroups);
}
@ -813,15 +769,22 @@ void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) con
// Revert structure clippings
if (!aUserPlanes.IsNull() && !aUserPlanes->IsEmpty())
{
aContext->ChangeClipping().Remove (*aUserPlanes);
aCtx->ChangeClipping().Remove (*aUserPlanes);
// Set OCCT state uniform variables
if (!aContext->ShaderManager()->IsEmpty())
if (!aCtx->ShaderManager()->IsEmpty())
{
aContext->ShaderManager()->RevertClippingState();
aCtx->ShaderManager()->RevertClippingState();
}
}
// Apply local transformation
if (myTransformation)
{
aCtx->ModelWorldState.Pop();
aCtx->SetGlNormalizeEnabled (anOldGlNormalize);
}
// Restore highlight color
theWorkspace->HighlightColor = aHighlightColor;
@ -834,36 +797,7 @@ void OpenGl_Structure::Render (const Handle(OpenGl_Workspace) &theWorkspace) con
// Restore transform persistence
if ( myTransPers && myTransPers->mode != 0 )
{
theWorkspace->ActiveView()->BeginTransformPersistence (aContext, aTransPersistence);
}
// Restore local transformation
if (myTransformation)
{
#if !defined(GL_ES_VERSION_2_0)
aContext->SetGlNormalizeEnabled (anOldGlNormalize);
if (isImmediate)
{
glPopMatrix ();
glMatrixMode (aMatrixMode);
Tmatrix3 aModelWorldState = { { 1.f, 0.f, 0.f, 0.f },
{ 0.f, 1.f, 0.f, 0.f },
{ 0.f, 0.f, 1.f, 0.f },
{ 0.f, 0.f, 0.f, 1.f } };
aContext->ShaderManager()->RevertModelWorldStateTo (&aModelWorldState);
}
else
{
theWorkspace->SetStructureMatrix (aLocalTrsf, true);
glMatrixMode (GL_MODELVIEW);
glPopMatrix();
}
#endif
theWorkspace->ActiveView()->BeginTransformPersistence (aCtx, aTransPersistence);
}
// Apply highlight box

101
src/OpenGl/OpenGl_Text.cxx
View File

@ -21,6 +21,7 @@
#include <OpenGl_ShaderStates.hxx>
#include <OpenGl_Sampler.hxx>
#include <OpenGl_Text.hxx>
#include <OpenGl_Utils.hxx>
#include <OpenGl_Workspace.hxx>
#include <Font_FontMgr.hxx>
@ -32,12 +33,12 @@
namespace
{
static const GLdouble THE_IDENTITY_MATRIX[4][4] =
static const GLdouble THE_IDENTITY_MATRIX[16] =
{
{1.,0.,0.,0.},
{0.,1.,0.,0.},
{0.,0.,1.,0.},
{0.,0.,0.,1.}
1.0, 0.0, 0.0, 0.0,
0.0, 1.0, 0.0, 0.0,
0.0, 0.0, 1.0, 0.0,
0.0, 0.0, 0.0, 1.0
};
#ifdef HAVE_GL2PS
@ -455,27 +456,33 @@ void OpenGl_Text::setupMatrix (const Handle(OpenGl_PrinterContext)& thePrintCtx,
{
// setup matrix
#if !defined(GL_ES_VERSION_2_0)
OpenGl_Mat4d aModViewMat;
if (myIs2d)
{
glLoadIdentity();
glTranslatef (myPoint.x() + theDVec.x(), myPoint.y() + theDVec.y(), 0.0f);
glScalef (1.0f, -1.0f, 1.0f);
glRotatef (theTextAspect.Angle(), 0.0, 0.0, 1.0);
OpenGl_Utils::Translate<GLdouble> (aModViewMat, myPoint.x() + theDVec.x(), myPoint.y() + theDVec.y(), 0.f);
OpenGl_Utils::Scale<GLdouble> (aModViewMat, 1.f, -1.f, 1.f);
OpenGl_Utils::Rotate<GLdouble> (aModViewMat, theTextAspect.Angle(), 0.f, 0.f, 1.f);
}
else
{
// align coordinates to the nearest integer
// to avoid extra interpolation issues
GLdouble anObjX, anObjY, anObjZ;
gluUnProject (std::floor (myWinX + (GLdouble )theDVec.x()),
std::floor (myWinY + (GLdouble )theDVec.y()),
myWinZ + (GLdouble )theDVec.z(),
(GLdouble* )THE_IDENTITY_MATRIX, myProjMatrix, myViewport,
&anObjX, &anObjY, &anObjZ);
OpenGl_Utils::UnProject<Standard_Real> (std::floor (myWinX + theDVec.x()),
std::floor (myWinY + theDVec.y()),
myWinZ + theDVec.z(),
OpenGl_Mat4d::Map (THE_IDENTITY_MATRIX),
OpenGl_Mat4d::Map (myProjMatrix),
myViewport,
anObjX,
anObjY,
anObjZ);
OpenGl_Utils::Translate<GLdouble> (aModViewMat, anObjX, anObjY, anObjZ);
OpenGl_Utils::Rotate<GLdouble> (aModViewMat, theTextAspect.Angle(), 0.0, 0.0, 1.0);
glLoadIdentity();
theCtx->core11->glTranslated (anObjX, anObjY, anObjZ);
theCtx->core11->glRotated (theTextAspect.Angle(), 0.0, 0.0, 1.0);
if (!theTextAspect.IsZoomable())
{
#ifdef _WIN32
@ -489,12 +496,15 @@ void OpenGl_Text::setupMatrix (const Handle(OpenGl_PrinterContext)& thePrintCtx,
// text should be scaled in all directions with same
// factor to save its proportions, so use height (y) scaling
// as it is better for keeping text/3d graphics proportions
theCtx->core11->glScaled ((GLfloat )aTextScaley, (GLfloat )aTextScaley, (GLfloat )aTextScaley);
OpenGl_Utils::Scale<GLdouble> (aModViewMat, aTextScaley, aTextScaley, aTextScaley);
}
#endif
theCtx->core11->glScaled (myScaleHeight, myScaleHeight, myScaleHeight);
OpenGl_Utils::Scale<GLdouble> (aModViewMat, myScaleHeight, myScaleHeight, myScaleHeight);
}
}
theCtx->WorldViewState.SetCurrent<Standard_Real> (aModViewMat);
theCtx->ApplyWorldViewMatrix();
#endif
}
@ -660,30 +670,49 @@ void OpenGl_Text::render (const Handle(OpenGl_PrinterContext)& thePrintCtx,
myExportHeight = 1.0f;
myScaleHeight = 1.0f;
theCtx->WorldViewState.Push();
#if !defined(GL_ES_VERSION_2_0)
glMatrixMode (GL_MODELVIEW);
glPushMatrix();
myModelMatrix.Convert (theCtx->WorldViewState.Current() * theCtx->ModelWorldState.Current());
if (!myIs2d)
{
// retrieve active matrices for project/unproject calls
glGetDoublev (GL_MODELVIEW_MATRIX, myModelMatrix);
glGetDoublev (GL_PROJECTION_MATRIX, myProjMatrix);
glGetIntegerv (GL_VIEWPORT, myViewport);
gluProject (myPoint.x(), myPoint.y(), myPoint.z(),
myModelMatrix, myProjMatrix, myViewport,
&myWinX, &myWinY, &myWinZ);
myProjMatrix.Convert (theCtx->ProjectionState.Current());
OpenGl_Utils::Project<Standard_Real> (myPoint.x(),
myPoint.y(),
myPoint.z(),
myModelMatrix,
myProjMatrix,
myViewport,
myWinX,
myWinY,
myWinZ);
// compute scale factor for constant text height
GLdouble x1, y1, z1;
gluUnProject (myWinX, myWinY, myWinZ,
(GLdouble* )THE_IDENTITY_MATRIX, myProjMatrix, myViewport,
&x1, &y1, &z1);
OpenGl_Utils::UnProject<Standard_Real> (myWinX,
myWinY,
myWinZ,
OpenGl_Mat4d::Map (THE_IDENTITY_MATRIX),
myProjMatrix,
myViewport,
x1,
y1,
z1);
GLdouble x2, y2, z2;
const GLdouble h = (GLdouble )myFont->FTFont()->PointSize();
gluUnProject (myWinX, myWinY + h, myWinZ,
(GLdouble* )THE_IDENTITY_MATRIX, myProjMatrix, myViewport,
&x2, &y2, &z2);
OpenGl_Utils::UnProject<Standard_Real> (myWinX,
myWinY + h,
myWinZ,
OpenGl_Mat4d::Map (THE_IDENTITY_MATRIX),
myProjMatrix,
myViewport,
x2,
y2,
z2);
myScaleHeight = (y2 - y1) / h;
if (theTextAspect.IsZoomable())
@ -708,7 +737,6 @@ void OpenGl_Text::render (const Handle(OpenGl_PrinterContext)& thePrintCtx,
glDisable (GL_DEPTH_TEST);
}
// setup alpha test
GLint aTexEnvParam = GL_REPLACE;
glGetTexEnviv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &aTexEnvParam);
@ -823,7 +851,10 @@ void OpenGl_Text::render (const Handle(OpenGl_PrinterContext)& thePrintCtx,
// revert OpenGL state
glPopAttrib(); // enable bit
glPopMatrix(); // model view matrix was modified
// model view matrix was modified
theCtx->WorldViewState.Pop();
theCtx->ApplyModelViewMatrix();
// revert custom OpenGL sampler
if (!aSampler.IsNull() && aSampler->IsValid())

4
src/OpenGl/OpenGl_Text.hxx
View File

@ -137,8 +137,8 @@ protected:
protected:
mutable GLdouble myProjMatrix[16];
mutable GLdouble myModelMatrix[16];
mutable OpenGl_Mat4d myProjMatrix;
mutable OpenGl_Mat4d myModelMatrix;
mutable GLint myViewport[4];
mutable GLdouble myWinX;
mutable GLdouble myWinY;

664
src/OpenGl/OpenGl_Trihedron.cxx
View File

@ -13,21 +13,12 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <OpenGl_Trihedron.hxx>
#include <OpenGl_GlCore11.hxx>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <InterfaceGraphic_Graphic3d.hxx> /* pour CALL_DEF_STRUCTURE */
#include <InterfaceGraphic_Aspect.hxx> /* pour CALL_DEF_VIEW */
#include <InterfaceGraphic_Visual3d.hxx>
#include <OpenGl_transform_persistence.hxx>
#include <OpenGl_Workspace.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Trihedron.hxx>
#include <OpenGl_Workspace.hxx>
static const OpenGl_TextParam THE_LABEL_PARAMS =
{
@ -59,12 +50,6 @@ static const CALL_DEF_CONTEXTTEXT myDefaultContextText =
Font_FA_Regular //TextFontAspect
};
/*----------------------------------------------------------------------*/
/*
* Variables statiques
*/
/* Default parameters for ZBUFFER triheron */
static TEL_COLOUR theXColor = {{ 1.F, 0.F, 0.F, 0.6F }};
static TEL_COLOUR theYColor = {{ 0.F, 1.F, 0.F, 0.6F }};
static TEL_COLOUR theZColor = {{ 0.F, 0.F, 1.F, 0.6F }};
@ -72,26 +57,18 @@ static float theRatio = 0.8f;
static float theDiameter = 0.05f;
static int theNbFacettes = 12;
/*----------------------------------------------------------------------*/
/*
* affichage d'un triedre non zoomable a partir des index dans les tables
* des structures non zoomables.
*
* Triedre = Objet non Zoomable :
* on recalcule ses dimensions et son origine en fonction de la taille
* de la fenetre; on positionne selon le choix de l'init;
* et on inhibe seulement les translations.
*
*/
//call_triedron_redraw
// =======================================================================
// function : redraw
// purpose :
// =======================================================================
void OpenGl_Trihedron::redraw (const Handle(OpenGl_Workspace)& theWorkspace) const
{
#if !defined(GL_ES_VERSION_2_0)
const Standard_Real U = theWorkspace->ActiveView()->Height();
const Standard_Real V = theWorkspace->ActiveView()->Width();
Handle(OpenGl_Context) aContext = theWorkspace->GetGlContext();
/* la taille des axes est 1 proportion (fixee a l'init du triedre) */
/* de la dimension la plus petite de la window. */
const GLdouble L = ( U < V ? U : V ) * myScale;
@ -100,45 +77,40 @@ void OpenGl_Trihedron::redraw (const Handle(OpenGl_Workspace)& theWorkspace) con
* On inhibe les translations; on conserve les autres transformations.
*/
aContext->WorldViewState.Push();
aContext->ProjectionState.Push();
/* on lit les matrices de transformation et de projection de la vue */
/* pour annuler les translations (dernieres colonnes des matrices). */
GLdouble modelMatrix[4][4];
glGetDoublev( GL_MODELVIEW_MATRIX, (GLdouble *) modelMatrix );
GLdouble projMatrix[4][4];
glGetDoublev( GL_PROJECTION_MATRIX, (GLdouble *) projMatrix );
OpenGl_Mat4d aModelMatrix;
aModelMatrix.Convert (aContext->WorldViewState.Current());
OpenGl_Mat4d aProjMatrix;
/* on annule la translation qui peut etre affectee a la vue */
modelMatrix[3][0] = 0.;
modelMatrix[3][1] = 0.;
modelMatrix[3][2] = 0.;
aModelMatrix.ChangeValue (0, 3) = 0.0;
aModelMatrix.ChangeValue (1, 3) = 0.0;
aModelMatrix.ChangeValue (2, 3) = 0.0;
projMatrix[0][0] = 2.0 / U;
projMatrix[0][1] = 0.0;
projMatrix[0][2] = 0.0;
projMatrix[0][3] = 0.0;
aProjMatrix.ChangeValue (0, 0) = 2.0 / U;
aProjMatrix.ChangeValue (1, 0) = 0.0;
aProjMatrix.ChangeValue (2, 0) = 0.0;
aProjMatrix.ChangeValue (3, 0) = 0.0;
projMatrix[1][0] = 0.0;
projMatrix[1][1] = 2.0 / V;
projMatrix[1][2] = 0.0;
projMatrix[1][3] = 0.0;
aProjMatrix.ChangeValue (0, 1) = 0.0;
aProjMatrix.ChangeValue (1, 1) = 2.0 / V;
aProjMatrix.ChangeValue (2, 1) = 0.0;
aProjMatrix.ChangeValue (3, 1) = 0.0;
projMatrix[2][0] = 0.0;
projMatrix[2][1] = 0.0;
projMatrix[2][2] = -2.0 * 1e-7;
projMatrix[2][3] = 0.0;
aProjMatrix.ChangeValue (0, 2) = 0.0;
aProjMatrix.ChangeValue (1, 2) = 0.0;
aProjMatrix.ChangeValue (2, 2) = -2.0 * 1e-7;
aProjMatrix.ChangeValue (3, 2) = 0.0;
projMatrix[3][0] = 0.0;
projMatrix[3][1] = 0.0;
projMatrix[3][2] = 0.0;
projMatrix[3][3] = 1.0;
/* sauvegarde du contexte des matrices avant chargement */
glMatrixMode (GL_MODELVIEW);
glPushMatrix ();
glLoadMatrixd( (GLdouble *) modelMatrix );
glMatrixMode ( GL_PROJECTION );
glPushMatrix ();
glLoadMatrixd( (GLdouble *) projMatrix );
aProjMatrix.ChangeValue (0, 3) = 0.0;
aProjMatrix.ChangeValue (1, 3) = 0.0;
aProjMatrix.ChangeValue (2, 3) = 0.0;
aProjMatrix.ChangeValue (3, 3) = 1.0;
/*
* Positionnement de l'origine du triedre selon le choix de l'init
@ -149,26 +121,43 @@ void OpenGl_Trihedron::redraw (const Handle(OpenGl_Workspace)& theWorkspace) con
switch (myPos)
{
case Aspect_TOTP_LEFT_LOWER :
glTranslated( -0.5*U + L , -0.5*V + L , 0. );
break;
{
OpenGl_Utils::Translate (aProjMatrix,
-0.5 * U + L, -0.5 * V + L, 0.0);
}
break;
case Aspect_TOTP_LEFT_UPPER :
glTranslated( -0.5*U + L , +0.5*V - L -L/3., 0. );
break;
{
OpenGl_Utils::Translate (aProjMatrix,
-0.5 * U + L, 0.5 * V - L - L/3.0, 0.0);
}
break;
case Aspect_TOTP_RIGHT_LOWER :
glTranslated( 0.5*U - L -L/3. , -0.5*V + L , 0. );
break;
{
OpenGl_Utils::Translate (aProjMatrix,
0.5 * U - L - L/3.0, -0.5 * V + L, 0.0);
}
break;
case Aspect_TOTP_RIGHT_UPPER :
glTranslated( 0.5*U - L -L/3. , +0.5*V - L -L/3. , 0. );
break;
{
OpenGl_Utils::Translate (aProjMatrix,
0.5 * U - L - L/3.0, 0.5 * V - L - L/3.0, 0.0);
}
break;
//case Aspect_TOTP_CENTER :
default :
break;
}
aContext->ProjectionState.SetCurrent<Standard_Real> (aProjMatrix);
aContext->WorldViewState.SetCurrent<Standard_Real> (aModelMatrix);
aContext->ApplyProjectionMatrix();
aContext->ApplyWorldViewMatrix();
/*
* Creation du triedre
*/
@ -283,316 +272,258 @@ void OpenGl_Trihedron::redraw (const Handle(OpenGl_Workspace)& theWorkspace) con
/*
* restauration du contexte des matrices
*/
glMatrixMode (GL_PROJECTION);
glPopMatrix ();
glMatrixMode (GL_MODELVIEW);
glPopMatrix ();
aContext->WorldViewState.Pop();
aContext->ProjectionState.Pop();
aContext->ApplyProjectionMatrix();
#endif
}
/*******************************************************
* Draws ZBUFFER trihedron mode
*******************************************************/
//call_zbuffer_triedron_redraw
// =======================================================================
// function : redrawZBuffer
// purpose :
// =======================================================================
void OpenGl_Trihedron::redrawZBuffer (const Handle(OpenGl_Workspace)& theWorkspace) const
{
#if !defined(GL_ES_VERSION_2_0)
const Standard_Real U = theWorkspace->ActiveView()->Height();
const Standard_Real V = theWorkspace->ActiveView()->Width();
Handle(OpenGl_Context) aContext = theWorkspace->GetGlContext();
const Handle(OpenGl_View)& aView = theWorkspace->ActiveView();
GLdouble modelMatrix[4][4];
glGetDoublev( GL_MODELVIEW_MATRIX, (GLdouble *) modelMatrix );
GLdouble projMatrix[4][4];
glGetDoublev( GL_PROJECTION_MATRIX, (GLdouble *) projMatrix );
OpenGl_Mat4d aModelMatrix, aProjMatrix;
aContext->WorldViewState.Push();
aContext->ProjectionState.Push();
aModelMatrix.Convert (aContext->WorldViewState.Current());
/* Check position in the ViewPort */
/* PCD 29/09/2008 */
/* Simple code modification recommended by Fotis Sioutis and Peter Dolbey */
/* to remove the irritating default behaviour of triedrons using V3d_ZBUFFER */
/* which causes the glyph to jump around the screen when the origin moves offscreen. */
GLboolean isWithinView = GL_FALSE;
/* la taille des axes est 1 proportion (fixee a l'init du triedre) */
/* de la dimension la plus petite de la window. */
GLdouble L = ( U < V ? U : V ) * myScale;
if (!isWithinView)
GLdouble U = 1.0;
GLdouble V = 1.0;
if (aView->Height() < aView->Width())
{
/* Annulate translation matrix */
modelMatrix[3][0] = 0.;
modelMatrix[3][1] = 0.;
modelMatrix[3][2] = 0.;
projMatrix[0][0] = 2.0 / U;
projMatrix[0][1] = 0.0;
projMatrix[0][2] = 0.0;
projMatrix[0][3] = 0.0;
projMatrix[1][0] = 0.0;
projMatrix[1][1] = 2.0 / V;
projMatrix[1][2] = 0.0;
projMatrix[1][3] = 0.0;
projMatrix[2][0] = 0.0;
projMatrix[2][1] = 0.0;
projMatrix[2][2] = -2.0 * 1e-7;
projMatrix[2][3] = 0.0;
projMatrix[3][0] = 0.0;
projMatrix[3][1] = 0.0;
projMatrix[3][2] = 0.0;
projMatrix[3][3] = 1.0;
/* save matrix */
glMatrixMode (GL_MODELVIEW);
glPushMatrix ();
//glLoadIdentity ();
glLoadMatrixd( (GLdouble *) modelMatrix);
glMatrixMode ( GL_PROJECTION );
glPushMatrix ();
//glLoadIdentity();
glLoadMatrixd( (GLdouble *) projMatrix);
/*
* Define position in the view
*/
switch (myPos)
{
case Aspect_TOTP_LEFT_LOWER :
glTranslated( -0.5*U + L , -0.5*V + L , 0. );
break;
case Aspect_TOTP_LEFT_UPPER :
glTranslated( -0.5*U + L , +0.5*V - L -L/3. , 0. );
break;
case Aspect_TOTP_RIGHT_LOWER :
glTranslated( 0.5*U - L -L/3. , -0.5*V + L , 0. );
break;
case Aspect_TOTP_RIGHT_UPPER :
glTranslated( 0.5*U - L -L/3. , +0.5*V - L -L/3. , 0. );
break;
//case Aspect_TOTP_CENTER :
default :
break;
}
L *= myRatio;
V = aView->Width() / aView->Height();
}
const OpenGl_AspectLine *AspectLine = theWorkspace->AspectLine( Standard_True );
const TEL_COLOUR &aLineColor = AspectLine->Color();
/*
* Creation the trihedron
*/
#define CYLINDER_LENGTH 0.75f
const GLuint startList = glGenLists(4);
GLUquadricObj* aQuadric = gluNewQuadric();
const GLboolean aIsDepthEnabled = glIsEnabled(GL_DEPTH_TEST);
GLboolean aIsDepthMaskEnabled;
/*PCD 02/07/07 */
/* GL_DEPTH_WRITEMASK is not a valid argument to glIsEnabled, the */
/* original code is shown to be broken when run under an OpenGL debugger */
/* like GLIntercept. This is the correct way to retrieve the mask value. */
glGetBooleanv(GL_DEPTH_WRITEMASK, &aIsDepthMaskEnabled);
const GLdouble aCylinderLength = L * CYLINDER_LENGTH;
const GLdouble aCylinderDiametr = L * myDiameter;
const GLdouble aConeDiametr = aCylinderDiametr * 2.;
const GLdouble aConeLength = L * (1 - CYLINDER_LENGTH);
/* Correct for owerlapping */
/* aCylinderLength += aConeLength - 1.2*aCylinderDiametr*aConeLength/aConeDiametr;*/
/* Create cylinder for axis */
gluQuadricDrawStyle(aQuadric, GLU_FILL); /* smooth shaded */
gluQuadricNormals(aQuadric, GLU_FLAT);
/* Axis */
glNewList(startList, GL_COMPILE);
gluCylinder(aQuadric, aCylinderDiametr, aCylinderDiametr, aCylinderLength, myNbFacettes, 1);
glEndList();
/* Cone */
glNewList(startList + 1, GL_COMPILE);
gluCylinder(aQuadric, aConeDiametr, 0., aConeLength, myNbFacettes, 1);
glEndList();
/* Central sphere */
glNewList(startList + 2, GL_COMPILE);
gluSphere(aQuadric, aCylinderDiametr * 2., myNbFacettes, myNbFacettes);
glEndList();
/* End disk */
gluQuadricOrientation(aQuadric,GLU_INSIDE); /*szv*/
glNewList(startList + 3, GL_COMPILE);
gluDisk(aQuadric, aCylinderDiametr, aConeDiametr, myNbFacettes, 1/*szv:2*/);
glEndList();
/* Store previous attributes */
glPushAttrib(GL_LIGHTING_BIT | GL_POLYGON_BIT);
glEnable(GL_LIGHTING);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
/*Fotis Sioutis | 2008-01-21 10:55
In the function call_zbuffer_triedron_redraw of TKOpengl,
the z buffered trihedron changes colors in case there
is an object in the scene that has an explicit material
attached to it.In the trihedron display loop,
GL_COLOR_MATERIAL is enabled, but only the GL_DIFFUSE
parameter is utilized in glColorMaterial(...).
This causes the last ambient,specular and emission values
used, to stay at the stack and applied to the trihedron
(which causes the color change).
A fix is proposed , to change GL_DIFFUSE to
GL_AMBIENT_AND_DIFFUSE in glColorMaterial call in
line 946.The above of course will leave unchanged
the SPECULAR and EMISSION values.
Another proposal which would fix 100% the problem
is to use glMaterial instead of glColor on the trihedron
drawing loop. */
const GLfloat aNULLColor[] = { 0.f, 0.f, 0.f, 0.f }; /* FS 21/01/08 */
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, aNULLColor);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, aNULLColor);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, aNULLColor);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 0.f);
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
if (!aIsDepthEnabled) {
glEnable(GL_DEPTH_TEST);
glClear(GL_DEPTH_BUFFER_BIT);
}
if (!aIsDepthMaskEnabled) {
/* This is how the depthmask needs to be re-enabled...*/
glDepthMask(GL_TRUE);
/* ...and not this stuff below */
}
/* Position des Axes */
GLdouble TriedronAxeX[3] = { 1.0, 0.0, 0.0 };
GLdouble TriedronAxeY[3] = { 0.0, 1.0, 0.0 };
TriedronAxeX[0] = L;
TriedronAxeY[1] = L;
glMatrixMode(GL_MODELVIEW);
/* PCD 17/06/07 */
GLint df;
glGetIntegerv (GL_DEPTH_FUNC, &df);
int i;
for (i = 0; i < 2; i++) /* PCD 11/02/08 Two pass method */
else
{
if (i == 0) /* First pass */
{
glDepthFunc(GL_ALWAYS);
}
else
{
glDepthFunc(GL_LEQUAL);
}
U = aView->Height() / aView->Width();
}
glPushMatrix();
glPushMatrix();
glPushMatrix();
GLdouble aScale = myScale;
glColor3fv(aLineColor.rgb);
glCallList(startList+2);
// Annulate translation matrix
aModelMatrix.ChangeValue (0, 3) = 0.0;
aModelMatrix.ChangeValue (1, 3) = 0.0;
aModelMatrix.ChangeValue (2, 3) = 0.0;
aProjMatrix.ChangeValue (0, 0) = 2.0 / U;
aProjMatrix.ChangeValue (1, 0) = 0.0;
aProjMatrix.ChangeValue (2, 0) = 0.0;
aProjMatrix.ChangeValue (3, 0) = 0.0;
aProjMatrix.ChangeValue (0, 1) = 0.0;
aProjMatrix.ChangeValue (1, 1) = 2.0 / V;
aProjMatrix.ChangeValue (2, 1) = 0.0;
aProjMatrix.ChangeValue (3, 1) = 0.0;
aProjMatrix.ChangeValue (0, 2) = 0.0;
aProjMatrix.ChangeValue (1, 2) = 0.0;
aProjMatrix.ChangeValue (2, 2) = -2.0 * 1e-2;
aProjMatrix.ChangeValue (3, 2) = 0.0;
aProjMatrix.ChangeValue (0, 3) = 0.0;
aProjMatrix.ChangeValue (1, 3) = 0.0;
aProjMatrix.ChangeValue (2, 3) = 0.0;
aProjMatrix.ChangeValue (3, 3) = 1.0;
// Define position in the view
switch (myPos)
{
case Aspect_TOTP_LEFT_LOWER:
{
OpenGl_Utils::Translate<Standard_Real> (aProjMatrix,
-0.5 * U + aScale, -0.5 * V + aScale, 0.0);
break;
}
case Aspect_TOTP_LEFT_UPPER:
{
OpenGl_Utils::Translate<Standard_Real> (aProjMatrix,
-0.5 * U + aScale, 0.5 * V - aScale - aScale / 3.0, 0.0);
break;
}
case Aspect_TOTP_RIGHT_LOWER:
{
OpenGl_Utils::Translate<Standard_Real> (aProjMatrix,
0.5 * U - aScale - aScale / 3.0, -0.5 * V + aScale, 0.0);
break;
}
case Aspect_TOTP_RIGHT_UPPER:
{
OpenGl_Utils::Translate<Standard_Real> (aProjMatrix,
0.5 * U - aScale - aScale / 3.0, 0.5 * V - aScale - aScale / 3.0, 0.0);
break;
}
//case Aspect_TOTP_CENTER:
default:
break;
}
aScale *= myRatio;
aContext->ProjectionState.SetCurrent<Standard_Real> (aProjMatrix);
aContext->ApplyProjectionMatrix();
const OpenGl_AspectLine* anAspectLine = theWorkspace->AspectLine (Standard_True);
const TEL_COLOUR& aLineColor = anAspectLine->Color();
// Create the trihedron
const Standard_Real THE_CYLINDER_LENGTH = 0.75;
const GLdouble aCylinderLength = aScale * THE_CYLINDER_LENGTH;
const GLdouble aCylinderDiametr = aScale * myDiameter;
const GLdouble aConeDiametr = aCylinderDiametr * 2.0;
const GLdouble aConeLength = aScale * (1.0 - THE_CYLINDER_LENGTH);
// Position des Axes
GLdouble aTriedronAxeX[3] = { aScale, 0.0, 0.0 };
GLdouble aTriedronAxeY[3] = { 0.0, aScale, 0.0 };
if (!myDisk.IsDefined())
{
myDisk.Init (static_cast<GLfloat> (aCylinderDiametr),
static_cast<GLfloat> (aConeDiametr),
myNbFacettes, 1);
}
if (!mySphere.IsDefined())
{
mySphere.Init (static_cast<GLfloat> (aCylinderDiametr * 2.0), myNbFacettes, myNbFacettes);
}
if (!myCone.IsDefined())
{
myCone.Init (static_cast<GLfloat> (aConeDiametr), 0.0f, static_cast<GLfloat> (aConeLength), myNbFacettes, 1);
}
if (!myCylinder.IsDefined())
{
myCylinder.Init (static_cast<GLfloat> (aCylinderDiametr),
static_cast<GLfloat> (aCylinderDiametr),
static_cast<GLfloat> (aCylinderLength),
myNbFacettes, 1);
}
GLboolean wasDepthMaskEnabled = GL_FALSE;
GLint aDepthFuncBack = 0, aCullFaceModeBack = GL_BACK;
const GLboolean wasDepthEnabled = aContext->core11fwd->glIsEnabled (GL_DEPTH_TEST);
const GLboolean wasCullFaceEnabled = aContext->core11fwd->glIsEnabled (GL_CULL_FACE);
aContext->core11fwd->glGetIntegerv (GL_DEPTH_FUNC, &aDepthFuncBack);
aContext->core11fwd->glGetIntegerv (GL_CULL_FACE_MODE, &aCullFaceModeBack);
aContext->core11fwd->glGetBooleanv (GL_DEPTH_WRITEMASK, &wasDepthMaskEnabled);
if (!wasDepthEnabled)
{
aContext->core11fwd->glEnable (GL_DEPTH_TEST);
aContext->core11fwd->glClear (GL_DEPTH_BUFFER_BIT);
}
if (!wasDepthMaskEnabled)
{
aContext->core11fwd->glDepthMask (GL_TRUE);
}
aContext->core11fwd->glCullFace (GL_BACK);
if (!wasCullFaceEnabled)
{
aContext->core11fwd->glEnable (GL_CULL_FACE);
}
OpenGl_AspectFace anAspectC;
OpenGl_AspectFace anAspectX;
OpenGl_AspectFace anAspectY;
OpenGl_AspectFace anAspectZ;
memcpy (anAspectX.ChangeIntFront().matcol.rgb, myXColor.rgb, sizeof (TEL_COLOUR));
memcpy (anAspectY.ChangeIntFront().matcol.rgb, myYColor.rgb, sizeof (TEL_COLOUR));
memcpy (anAspectZ.ChangeIntFront().matcol.rgb, myZColor.rgb, sizeof (TEL_COLOUR));
memcpy (anAspectC.ChangeIntFront().matcol.rgb, aLineColor.rgb, sizeof (TEL_COLOUR));
for (Standard_Integer aPass = 0; aPass < 2; ++aPass)
{
OpenGl_Mat4d aModelViewX (aModelMatrix);
OpenGl_Mat4d aModelViewY (aModelMatrix);
OpenGl_Mat4d aModelViewZ (aModelMatrix);
aContext->core11fwd->glDepthFunc (aPass == 0 ? GL_ALWAYS : GL_LEQUAL);
const OpenGl_AspectFace* anOldAspect = theWorkspace->SetAspectFace (&anAspectC);
// Origin
aContext->WorldViewState.SetCurrent<Standard_Real> (aModelMatrix);
aContext->ApplyWorldViewMatrix();
mySphere.Render (theWorkspace);
// Z axis
glColor4fv(myZColor.rgb);
glCallList(startList);
glTranslated(0, 0, L * CYLINDER_LENGTH);
glCallList(startList + 3);
glCallList(startList + 1);
glPopMatrix();
theWorkspace->SetAspectFace (&anAspectZ);
myCylinder.Render (theWorkspace);
OpenGl_Utils::Translate (aModelViewZ, 0.0, 0.0, aScale * THE_CYLINDER_LENGTH);
aContext->WorldViewState.SetCurrent<Standard_Real> (aModelViewZ);
aContext->ApplyWorldViewMatrix();
myDisk.Render (theWorkspace);
myCone.Render (theWorkspace);
// X axis
glRotated(90.0, TriedronAxeY[0], TriedronAxeY[1], TriedronAxeY[2]);
glColor4fv(myXColor.rgb);
glCallList(startList);
glTranslated(0, 0, L * CYLINDER_LENGTH);
glCallList(startList + 3);
glCallList(startList + 1);
glPopMatrix();
theWorkspace->SetAspectFace (&anAspectX);
OpenGl_Utils::Rotate (aModelViewX, 90.0, aTriedronAxeY[0], aTriedronAxeY[1], aTriedronAxeY[2]);
aContext->WorldViewState.SetCurrent<Standard_Real> (aModelViewX);
aContext->ApplyWorldViewMatrix();
myCylinder.Render (theWorkspace);
OpenGl_Utils::Translate (aModelViewX, 0.0, 0.0, aScale * THE_CYLINDER_LENGTH);
aContext->WorldViewState.SetCurrent<Standard_Real> (aModelViewX);
aContext->ApplyWorldViewMatrix();
myDisk.Render (theWorkspace);
myCone.Render (theWorkspace);
// Y axis
glRotated(-90.0, TriedronAxeX[0], TriedronAxeX[1], TriedronAxeX[2]);
glColor4fv(myYColor.rgb);
glCallList(startList);
glTranslated(0, 0, L * CYLINDER_LENGTH);
glCallList(startList + 3);
glCallList(startList + 1);
glPopMatrix();
theWorkspace->SetAspectFace (&anAspectY);
OpenGl_Utils::Rotate (aModelViewY, -90.0, aTriedronAxeX[0], aTriedronAxeX[1], aTriedronAxeX[2]);
aContext->WorldViewState.SetCurrent<Standard_Real> (aModelViewY);
aContext->ApplyWorldViewMatrix();
myCylinder.Render (theWorkspace);
OpenGl_Utils::Translate (aModelViewY, 0.0, 0.0, aScale * THE_CYLINDER_LENGTH);
aContext->WorldViewState.SetCurrent<Standard_Real> (aModelViewY);
aContext->ApplyWorldViewMatrix();
myDisk.Render (theWorkspace);
myCone.Render (theWorkspace);
theWorkspace->SetAspectFace (anOldAspect);
}
if (!aIsDepthEnabled)
glDisable(GL_DEPTH_TEST);
if (!wasDepthEnabled)
{
aContext->core11fwd->glDisable (GL_DEPTH_TEST);
}
if (!wasDepthMaskEnabled)
{
aContext->core11fwd->glDepthMask (GL_FALSE);
}
if (!wasCullFaceEnabled)
{
aContext->core11fwd->glDisable (GL_CULL_FACE);
}
aContext->core11fwd->glCullFace (aCullFaceModeBack);
if (!aIsDepthMaskEnabled)
glDepthMask(GL_FALSE);
glDisable(GL_CULL_FACE);
glDisable(GL_COLOR_MATERIAL);
gluDeleteQuadric(aQuadric);
glColor3fv (aLineColor.rgb);
/* Always write the text */
glDepthFunc(GL_ALWAYS);
glPopAttrib();
/* fleches au bout des axes (= cones de la couleur demandee) */
//const GLdouble l = 0.75*L; /* distance a l'origine */
const GLdouble rayon = L/30. ; /* rayon de la base du cone */
//const double Angle = 2. * M_PI/ myNbFacettes;
glDeleteLists(startList, 4);
glDisable(GL_LIGHTING);
// Always write the text
aContext->core11fwd->glDepthFunc (GL_ALWAYS);
// draw axes labels
myLabelX.SetPosition (OpenGl_Vec3(float(L + rayon), 0.0f, float(-rayon)));
myLabelY.SetPosition (OpenGl_Vec3(float(rayon), float(L + 3.0 * rayon), float(2.0 * rayon)));
myLabelZ.SetPosition (OpenGl_Vec3(float(-2.0 * rayon), float(0.5 * rayon), float(L + 3.0 * rayon)));
const GLdouble rayon = aScale / 30.0;
myLabelX.SetPosition (OpenGl_Vec3(float(aScale + 2.0 * rayon), 0.0f, float(-rayon)));
myLabelY.SetPosition (OpenGl_Vec3(float(rayon), float(aScale + 3.0 * rayon), float(2.0 * rayon)));
myLabelZ.SetPosition (OpenGl_Vec3(float(-2.0 * rayon), float(0.5 * rayon), float(aScale + 3.0 * rayon)));
aContext->WorldViewState.SetCurrent<Standard_Real> (aModelMatrix);
aContext->ApplyWorldViewMatrix();
myLabelX.Render (theWorkspace);
myLabelY.Render (theWorkspace);
myLabelZ.Render (theWorkspace);
/*PCD 17/06/07 */
glDepthFunc(df);
aContext->core11fwd->glDepthFunc (aDepthFuncBack);
if (!isWithinView) { /* restore matrix */
glMatrixMode (GL_PROJECTION);
glPopMatrix ();
glMatrixMode (GL_MODELVIEW);
glPopMatrix ();
}
#endif
aContext->WorldViewState.Pop();
aContext->ProjectionState.Pop();
aContext->ApplyProjectionMatrix();
}
/*----------------------------------------------------------------------*/
/*----------------------------------------------------------------------*/
/*
* Fonctions publiques
*/
/*
* initialisation d'un triedre non zoomable dans une vue.
* ou modification des valeurs deja initialisees.
*/
//call_triedron_init
// =======================================================================
// function : OpenGl_Trihedron
// purpose :
// =======================================================================
OpenGl_Trihedron::OpenGl_Trihedron (const Aspect_TypeOfTriedronPosition thePosition,
const Quantity_NameOfColor theColor,
const Standard_Real theScale,
@ -629,13 +560,10 @@ OpenGl_Trihedron::OpenGl_Trihedron (const Aspect_TypeOfTriedronPosition thePosit
myNbFacettes = theNbFacettes;
}
/*----------------------------------------------------------------------*/
/*
* destruction du triedre non zoomable d'une vue.
*/
//call_triedron_erase
// =======================================================================
// function : ~OpenGl_Trihedron
// purpose :
// =======================================================================
OpenGl_Trihedron::~OpenGl_Trihedron()
{
}
@ -651,20 +579,16 @@ void OpenGl_Trihedron::Release (OpenGl_Context* theCtx)
myLabelZ.Release (theCtx);
myAspectLine.Release (theCtx);
myAspectText.Release (theCtx);
myCone .Release (theCtx);
myDisk .Release (theCtx);
mySphere .Release (theCtx);
myCylinder.Release (theCtx);
}
/*----------------------------------------------------------------------*/
/*
* affichage d'un triedre non zoomable dans la wks awsid
*
* Triedre = Objet non Zoomable;
* on cree cette fonction pour pouvoir travailler par les structures
* utilisees par les fonctions Tsm* et TEL_VIEW_REP
*
*/
//call_triedron_redraw_from_wsid
// =======================================================================
// function : Render
// purpose :
// =======================================================================
void OpenGl_Trihedron::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
{
const OpenGl_AspectLine* aPrevAspectLine = theWorkspace->SetAspectLine (&myAspectLine);

20
src/OpenGl/OpenGl_Trihedron.hxx
View File

@ -21,9 +21,13 @@
#include <Aspect_TypeOfTriedronPosition.hxx>
#include <OpenGl_AspectLine.hxx>
#include <OpenGl_AspectText.hxx>
#include <OpenGl_Cylinder.hxx>
#include <OpenGl_Disk.hxx>
#include <OpenGl_Sphere.hxx>
#include <OpenGl_Text.hxx>
#include <Quantity_NameOfColor.hxx>
//! Class render trihedron
class OpenGl_Trihedron : public OpenGl_Element
{
public:
@ -57,7 +61,7 @@ protected:
Aspect_TypeOfTriedronPosition myPos;
Standard_Real myScale;
Standard_Boolean myIsWireframe;
// Parameters for zbuffered mode
// Parameters for z-buffered mode
TEL_COLOUR myXColor;
TEL_COLOUR myYColor;
TEL_COLOUR myZColor;
@ -65,11 +69,15 @@ protected:
float myDiameter;
int myNbFacettes;
OpenGl_AspectLine myAspectLine;
OpenGl_AspectText myAspectText;
mutable OpenGl_Text myLabelX;
mutable OpenGl_Text myLabelY;
mutable OpenGl_Text myLabelZ;
OpenGl_AspectLine myAspectLine;
OpenGl_AspectText myAspectText;
mutable OpenGl_Text myLabelX;
mutable OpenGl_Text myLabelY;
mutable OpenGl_Text myLabelZ;
mutable OpenGl_Cylinder myCylinder;
mutable OpenGl_Sphere mySphere;
mutable OpenGl_Cylinder myCone;
mutable OpenGl_Disk myDisk;
public:

518
src/OpenGl/OpenGl_Utils.hxx Normal file
View File

@ -0,0 +1,518 @@
// Created on: 2014-09-30
// Created by: Denis BOGOLEPOV
// Copyright (c) 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.
#ifndef _OpenGl_Utils_H__
#define _OpenGl_Utils_H__
#include <OpenGl_Vec.hxx>
#include <NCollection_Vector.hxx>
//! Helper class that implements some functionality of GLU library.
namespace OpenGl_Utils
{
//! Matrix type selector.
template<class T>
struct MatrixType {
//
};
template<>
struct MatrixType<Standard_Real> {
typedef OpenGl_Mat4d Mat4;
};
template<>
struct MatrixType<Standard_ShortReal> {
typedef OpenGl_Mat4 Mat4;
};
//! Vector type selector.
template<class T>
struct VectorType {
//
};
template<>
struct VectorType<Standard_Real> {
typedef OpenGl_Vec2d Vec2;
typedef OpenGl_Vec3d Vec3;
typedef OpenGl_Vec4d Vec4;
};
template<>
struct VectorType<Standard_ShortReal> {
typedef OpenGl_Vec2 Vec2;
typedef OpenGl_Vec3 Vec3;
typedef OpenGl_Vec4 Vec4;
};
//! Software implementation for OpenGL matrix stack.
template<class T>
class MatrixState
{
public:
//! Constructs matrix state object.
MatrixState()
: myStack (8),
myStackHead (-1)
{
//
}
//! Pushes current matrix into stack.
void Push()
{
if (++myStackHead >= myStack.Size())
{
myStack.Append (myCurrent);
}
else
{
myStack.SetValue (myStackHead, myCurrent);
}
}
//! Pops matrix from stack to current.
void Pop()
{
Standard_ASSERT_RETURN (myStackHead != -1, "Matrix stack already empty when MatrixState.Pop() called.", );
myCurrent = myStack.Value (myStackHead--);
}
//! @return current matrix.
const typename MatrixType<T>::Mat4& Current()
{
return myCurrent;
}
//! Sets given matrix as current.
void SetCurrent (const typename MatrixType<T>::Mat4& theNewCurrent)
{
myCurrent = theNewCurrent;
}
//! Sets given matrix as current.
template <typename Other_t>
void SetCurrent (const typename MatrixType<Other_t>::Mat4& theNewCurrent)
{
myCurrent.Convert (theNewCurrent);
}
//! Sets current matrix to identity.
void SetIdentity()
{
myCurrent = typename MatrixType<T>::Mat4();
}
private:
NCollection_Vector<typename MatrixType<T>::Mat4> myStack; //!< Collection used to maintenance matrix stack
typename MatrixType<T>::Mat4 myCurrent; //!< Current matrix
Standard_Integer myStackHead; //!< Index of stack head
};
//! Constructs a 3D orthographic projection matrix.
template<class T>
static void Ortho (typename MatrixType<T>::Mat4& theOut,
const T theLeft, const T theRight, const T theBottom, const T theTop, const T theZNear, const T theZFar);
//! Constructs a 2D orthographic projection matrix.
template<class T>
static void Ortho2D (typename MatrixType<T>::Mat4& theOut,
const T theLeft, const T theRight, const T theBottom, const T theTop);
//! Maps object coordinates to window coordinates.
template<class T>
static Standard_Boolean Project (const T theObjX,
const T theObjY,
const T theObjZ,
const typename MatrixType<T>::Mat4& theModViewMat,
const typename MatrixType<T>::Mat4& theProjectMat,
const Standard_Integer theViewport[4],
T& theWinX,
T& theWinY,
T& theWinZ);
//! Maps window coordinates to object coordinates.
template<class T>
static Standard_Boolean UnProject (const T theWinX,
const T theWinY,
const T theWinZ,
const typename MatrixType<T>::Mat4& theModViewMat,
const typename MatrixType<T>::Mat4& theProjectMat,
const Standard_Integer theViewport[4],
T& theObjX,
T& theObjY,
T& theObjZ);
//! Constructs a 4x4 rotation matrix.
template<class T>
static void ConstructRotate (typename MatrixType<T>::Mat4& theOut,
T theA,
T theX,
T theY,
T theZ);
//! Constructs a 4x4 rotation matrix.
template<class T>
static void Rotate (typename MatrixType<T>::Mat4& theOut,
T theA,
T theX,
T theY,
T theZ);
//! Constructs a 4x4 scaling matrix.
template<class T>
static void Scale (typename MatrixType<T>::Mat4& theOut,
T theX,
T theY,
T theZ);
//! Constructs a 4x4 translation matrix.
template<class T>
static void Translate (typename MatrixType<T>::Mat4& theOut,
T theX,
T theY,
T theZ);
}
// =======================================================================
// function : Rotate
// purpose : Constructs a 4x4 rotation matrix
// =======================================================================
template<class T>
void OpenGl_Utils::Rotate (typename MatrixType<T>::Mat4& theOut,
T theA,
T theX,
T theY,
T theZ)
{
typename MatrixType<T>::Mat4 aMat;
ConstructRotate (aMat, theA, theX, theY, theZ);
theOut = theOut * aMat;
}
// =======================================================================
// function : Translate
// purpose : Constructs a 4x4 translation matrix
// =======================================================================
template<class T>
void OpenGl_Utils::Translate (typename MatrixType<T>::Mat4& theOut,
T theX,
T theY,
T theZ)
{
theOut.ChangeValue (0, 3) = theOut.GetValue (0, 0) * theX +
theOut.GetValue (0, 1) * theY +
theOut.GetValue (0, 2) * theZ +
theOut.GetValue (0, 3);
theOut.ChangeValue (1, 3) = theOut.GetValue (1, 0) * theX +
theOut.GetValue (1, 1) * theY +
theOut.GetValue (1, 2) * theZ +
theOut.GetValue (1, 3);
theOut.ChangeValue (2, 3) = theOut.GetValue (2, 0) * theX +
theOut.GetValue (2, 1) * theY +
theOut.GetValue (2, 2) * theZ +
theOut.GetValue (2, 3);
theOut.ChangeValue (3, 3) = theOut.GetValue (3, 0) * theX +
theOut.GetValue (3, 1) * theY +
theOut.GetValue (3, 2) * theZ +
theOut.GetValue (3, 3);
}
// =======================================================================
// function : Scale
// purpose : Constructs a 4x4 scaling matrix
// =======================================================================
template<class T>
void OpenGl_Utils::Scale (typename MatrixType<T>::Mat4& theOut,
T theX,
T theY,
T theZ)
{
theOut.ChangeValue (0, 0) *= theX;
theOut.ChangeValue (1, 0) *= theX;
theOut.ChangeValue (2, 0) *= theX;
theOut.ChangeValue (3, 0) *= theX;
theOut.ChangeValue (0, 1) *= theY;
theOut.ChangeValue (1, 1) *= theY;
theOut.ChangeValue (2, 1) *= theY;
theOut.ChangeValue (3, 1) *= theY;
theOut.ChangeValue (0, 2) *= theZ;
theOut.ChangeValue (1, 2) *= theZ;
theOut.ChangeValue (2, 2) *= theZ;
theOut.ChangeValue (3, 2) *= theZ;
}
// =======================================================================
// function : ConstructRotate
// purpose : Constructs a 4x4 rotation matrix
// =======================================================================
template<class T>
void OpenGl_Utils::ConstructRotate (typename MatrixType<T>::Mat4& theOut, T theA, T theX, T theY, T theZ)
{
const T aSin = std::sin (theA * static_cast<T> (M_PI / 180.0));
const T aCos = std::cos (theA * static_cast<T> (M_PI / 180.0));
const Standard_Boolean isOnlyX = (theX != static_cast<T> (0.0))
&& (theY == static_cast<T> (0.0))
&& (theZ == static_cast<T> (0.0));
const Standard_Boolean isOnlyY = (theX == static_cast<T> (0.0))
&& (theY != static_cast<T> (0.0))
&& (theZ == static_cast<T> (0.0));
const Standard_Boolean isOnlyZ = (theX == static_cast<T> (0.0))
&& (theY == static_cast<T> (0.0))
&& (theZ != static_cast<T> (0.0));
if (isOnlyX) // Rotation only around X
{
theOut.SetValue (1, 1, aCos);
theOut.SetValue (2, 2, aCos);
if (theX < static_cast<T> (0.0))
{
theOut.SetValue (1, 2, aSin);
theOut.SetValue (2, 1, -aSin);
}
else
{
theOut.SetValue (1, 2, -aSin);
theOut.SetValue (2, 1, aSin);
}
return;
}
else if (isOnlyY) // Rotation only around Y
{
theOut.SetValue (0, 0, aCos);
theOut.SetValue (2, 2, aCos);
if (theY < static_cast<T> (0.0))
{
theOut.SetValue (0, 2, -aSin);
theOut.SetValue (2, 0, aSin);
}
else
{
theOut.SetValue (0, 2, aSin);
theOut.SetValue (2, 0, -aSin);
}
return;
}
else if (isOnlyZ) // Rotation only around Z
{
theOut.SetValue (0, 0, aCos);
theOut.SetValue (1, 1, aCos);
if (theZ < static_cast<T> (0.0))
{
theOut.SetValue (0, 1, aSin);
theOut.SetValue (1, 0, -aSin);
}
else
{
theOut.SetValue (0, 1, -aSin);
theOut.SetValue (1, 0, aSin);
}
return;
}
T aNorm = std::sqrt (theX * theX + theY * theY + theZ * theZ);
if (aNorm <= static_cast<T> (1.0e-4))
{
return; // negligible rotation
}
aNorm = static_cast<T> (1.0) / aNorm;
theX *= aNorm;
theY *= aNorm;
theZ *= aNorm;
const T aXX = theX * theX;
const T aYY = theY * theY;
const T aZZ = theZ * theZ;
const T aXY = theX * theY;
const T aYZ = theY * theZ;
const T aZX = theZ * theX;
const T aSinX = theX * aSin;
const T aSinY = theY * aSin;
const T aSinZ = theZ * aSin;
const T aOneMinusCos = static_cast<T> (1.0) - aCos;
theOut.SetValue (0, 0, aOneMinusCos * aXX + aCos);
theOut.SetValue (0, 1, aOneMinusCos * aXY - aSinZ);
theOut.SetValue (0, 2, aOneMinusCos * aZX + aSinY);
theOut.SetValue (1, 0, aOneMinusCos * aXY + aSinZ);
theOut.SetValue (1, 1, aOneMinusCos * aYY + aCos);
theOut.SetValue (1, 2, aOneMinusCos * aYZ - aSinX);
theOut.SetValue (2, 0, aOneMinusCos * aZX - aSinY);
theOut.SetValue (2, 1, aOneMinusCos * aYZ + aSinX);
theOut.SetValue (2, 2, aOneMinusCos * aZZ + aCos);
}
// =======================================================================
// function : Ortho
// purpose : Constructs a 3D orthographic projection matrix
// =======================================================================
template<class T>
void OpenGl_Utils::Ortho (typename MatrixType<T>::Mat4& theOut,
const T theLeft, const T theRight, const T theBottom, const T theTop, const T theZNear, const T theZFar)
{
theOut.InitIdentity();
T* aData = theOut.ChangeData();
const T anInvDx = static_cast<T> (1.0) / (theRight - theLeft);
const T anInvDy = static_cast<T> (1.0) / (theTop - theBottom);
const T anInvDz = static_cast<T> (1.0) / (theZFar - theZNear);
aData[0] = static_cast<T> ( 2.0) * anInvDx;
aData[5] = static_cast<T> ( 2.0) * anInvDy;
aData[10] = static_cast<T> (-2.0) * anInvDz;
aData[12] = -(theRight + theLeft) * anInvDx;
aData[13] = -(theTop + theBottom) * anInvDy;
aData[14] = -(theZFar + theZNear) * anInvDz;
}
// =======================================================================
// function : Ortho2D
// purpose : Constructs a 2D orthographic projection matrix
// =======================================================================
template<class T>
void OpenGl_Utils::Ortho2D (typename MatrixType<T>::Mat4& theOut,
const T theLeft, const T theRight, const T theBottom, const T theTop)
{
Ortho (theOut, theLeft, theRight, theBottom, theTop, static_cast<T> (-1.0), static_cast<T> (1.0));
}
// =======================================================================
// function : Project
// purpose : Maps object coordinates to window coordinates
// =======================================================================
template<class T>
static Standard_Boolean OpenGl_Utils::Project (const T theObjX,
const T theObjY,
const T theObjZ,
const typename MatrixType<T>::Mat4& theModViewMat,
const typename MatrixType<T>::Mat4& theProjectMat,
const Standard_Integer theViewport[4],
T& theWinX,
T& theWinY,
T& theWinZ)
{
typename VectorType<T>::Vec4 anIn (theObjX, theObjY, theObjZ, static_cast<T> (1.0));
typename VectorType<T>::Vec4 anOut = theProjectMat * (theModViewMat * anIn);
if (anOut.w() == static_cast<T> (0.0))
{
return Standard_False;
}
anOut.w() = static_cast<T> (1.0) / anOut.w();
anOut.x() *= anOut.w();
anOut.y() *= anOut.w();
anOut.z() *= anOut.w();
// Map x, y and z to range 0-1
anOut.x() = anOut.x() * 0.5 + 0.5;
anOut.y() = anOut.y() * 0.5 + 0.5;
anOut.z() = anOut.z() * 0.5 + 0.5;
// Map x,y to viewport
anOut.x() = anOut.x() * theViewport[2] + theViewport[0];
anOut.y() = anOut.y() * theViewport[3] + theViewport[1];
theWinX = anOut.x();
theWinY = anOut.y();
theWinZ = anOut.z();
return Standard_True;
}
// =======================================================================
// function : UnProject
// purpose : Maps window coordinates to object coordinates
// =======================================================================
template<class T>
static Standard_Boolean OpenGl_Utils::UnProject (const T theWinX,
const T theWinY,
const T theWinZ,
const typename MatrixType<T>::Mat4& theModViewMat,
const typename MatrixType<T>::Mat4& theProjectMat,
const Standard_Integer theViewport[4],
T& theObjX,
T& theObjY,
T& theObjZ)
{
typename MatrixType<T>::Mat4 anUnviewMat;
if (!(theProjectMat * theModViewMat).Inverted (anUnviewMat))
{
return Standard_False;
}
typename VectorType<T>::Vec4 anIn (theWinX, theWinY, theWinZ, static_cast<T> (1.0));
// Map x and y from window coordinates
anIn.x() = (anIn.x() - theViewport[0]) / theViewport[2];
anIn.y() = (anIn.y() - theViewport[1]) / theViewport[3];
// Map to range -1 to 1
anIn.x() = anIn.x() * static_cast<T> (2.0) - static_cast<T> (1.0);
anIn.y() = anIn.y() * static_cast<T> (2.0) - static_cast<T> (1.0);
anIn.z() = anIn.z() * static_cast<T> (2.0) - static_cast<T> (1.0);
typename VectorType<T>::Vec4 anOut = anUnviewMat * anIn;
if (anOut.w() == static_cast<T> (0.0))
{
return Standard_False;
}
anOut.w() = static_cast<T> (1.0) / anOut.w();
anOut.x() *= anOut.w();
anOut.y() *= anOut.w();
anOut.z() *= anOut.w();
theObjX = anOut.x();
theObjY = anOut.y();
theObjZ = anOut.z();
return Standard_True;
}
#endif // _OpenGl_Utils_H__

194
src/OpenGl/OpenGl_View.cxx
View File

@ -24,6 +24,7 @@
#include <OpenGl_Trihedron.hxx>
#include <OpenGl_transform_persistence.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Utils.hxx>
#include <OpenGl_Workspace.hxx>
#include <Graphic3d_TextureEnv.hxx>
@ -86,12 +87,20 @@ OpenGl_View::OpenGl_View (const CALL_DEF_VIEWCONTEXT &AContext,
OpenGl_View::~OpenGl_View ()
{
ReleaseGlResources (NULL); // ensure ReleaseGlResources() was called within valid context
OpenGl_Element::Destroy (NULL, myTrihedron);
OpenGl_Element::Destroy (NULL, myGraduatedTrihedron);
}
void OpenGl_View::ReleaseGlResources (const Handle(OpenGl_Context)& theCtx)
{
OpenGl_Element::Destroy (theCtx.operator->(), myTrihedron);
OpenGl_Element::Destroy (theCtx.operator->(), myGraduatedTrihedron);
if (myTrihedron != NULL)
{
myTrihedron->Release (theCtx.operator->());
}
if (myGraduatedTrihedron != NULL)
{
myGraduatedTrihedron->Release (theCtx.operator->());
}
if (!myTextureEnv.IsNull())
{
@ -243,27 +252,12 @@ void OpenGl_View::EndTransformPersistence(const Handle(OpenGl_Context)& theCtx)
{
if (myIsTransPers)
{
#if !defined(GL_ES_VERSION_2_0)
// restore matrix
glMatrixMode (GL_PROJECTION);
glPopMatrix();
glMatrixMode (GL_MODELVIEW);
glPopMatrix();
theCtx->WorldViewState.Pop();
theCtx->ProjectionState.Pop();
theCtx->ApplyProjectionMatrix();
myIsTransPers = Standard_False;
// Note: the approach of accessing OpenGl matrices is used now since the matrix
// manipulation are made with help of OpenGl methods. This might be replaced by
// direct computation of matrices by OCC subroutines.
Tmatrix3 aResultWorldView;
glGetFloatv (GL_MODELVIEW_MATRIX, *aResultWorldView);
Tmatrix3 aResultProjection;
glGetFloatv (GL_PROJECTION_MATRIX, *aResultProjection);
// Set OCCT state uniform variables
theCtx->ShaderManager()->RevertWorldViewStateTo (&aResultWorldView);
theCtx->ShaderManager()->RevertProjectionStateTo (&aResultProjection);
#endif
}
}
@ -281,24 +275,19 @@ const TEL_TRANSFORM_PERSISTENCE* OpenGl_View::BeginTransformPersistence (const H
return aTransPersPrev;
}
#if !defined(GL_ES_VERSION_2_0)
GLint aViewport[4];
GLdouble aModelMatrix[4][4];
GLdouble aProjMatrix[4][4];
glGetIntegerv (GL_VIEWPORT, aViewport);
glGetDoublev (GL_MODELVIEW_MATRIX, (GLdouble* )aModelMatrix);
glGetDoublev (GL_PROJECTION_MATRIX, (GLdouble *)aProjMatrix);
OpenGl_Mat4d aModelMatrix, aProjMatrix;
theCtx->core11fwd->glGetIntegerv (GL_VIEWPORT, aViewport);
aModelMatrix.Convert (theCtx->ModelWorldState.Current() * theCtx->WorldViewState.Current());
aProjMatrix .Convert (theCtx->ProjectionState.Current());
const GLdouble aViewportW = (GLdouble )aViewport[2];
const GLdouble aViewportH = (GLdouble )aViewport[3];
if (myIsTransPers)
{
// pop matrix stack - it will be overridden later
glMatrixMode (GL_PROJECTION);
glPopMatrix();
glMatrixMode (GL_MODELVIEW);
glPopMatrix();
theCtx->WorldViewState.Pop();
theCtx->ProjectionState.Pop();
}
else
{
@ -306,21 +295,22 @@ const TEL_TRANSFORM_PERSISTENCE* OpenGl_View::BeginTransformPersistence (const H
}
// push matrices into stack and reset them
glMatrixMode (GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glMatrixMode (GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
theCtx->WorldViewState.Push();
theCtx->ProjectionState.Push();
// get the window's (fixed) coordinates for theTransPers->point before matrixes modifications
GLdouble aWinX = 0.0, aWinY = 0.0, aWinZ = 0.0;
if ((theTransPers->mode & TPF_PAN) != TPF_PAN)
{
gluProject (theTransPers->pointX, theTransPers->pointY, theTransPers->pointZ,
(GLdouble* )aModelMatrix, (GLdouble* )aProjMatrix, aViewport,
&aWinX, &aWinY, &aWinZ);
OpenGl_Utils::Project<Standard_Real> (theTransPers->pointX,
theTransPers->pointY,
theTransPers->pointZ,
aModelMatrix,
aProjMatrix,
aViewport,
aWinZ,
aWinY,
aWinZ);
}
// prevent zooming
@ -329,22 +319,22 @@ const TEL_TRANSFORM_PERSISTENCE* OpenGl_View::BeginTransformPersistence (const H
{
// compute fixed-zoom multiplier
// actually function works ugly with TelPerspective!
const GLdouble aDet2 = 0.002 / (aViewportW > aViewportH ? aProjMatrix[1][1] : aProjMatrix[0][0]);
aProjMatrix[0][0] *= aDet2;
aProjMatrix[1][1] *= aDet2;
aProjMatrix[2][2] *= aDet2;
const GLdouble aDet2 = 0.002 / (aViewportW > aViewportH ? aProjMatrix.GetValue (1, 1) : aProjMatrix.GetValue (0, 0));
aProjMatrix.ChangeValue (0, 0) *= aDet2;
aProjMatrix.ChangeValue (1, 1) *= aDet2;
aProjMatrix.ChangeValue (2, 2) *= aDet2;
}
// prevent translation - annulate translate matrix
if ((theTransPers->mode & TPF_PAN)
|| (theTransPers->mode == TPF_TRIEDRON))
{
aModelMatrix[3][0] = 0.0;
aModelMatrix[3][1] = 0.0;
aModelMatrix[3][2] = 0.0;
aProjMatrix [3][0] = 0.0;
aProjMatrix [3][1] = 0.0;
aProjMatrix [3][2] = 0.0;
aModelMatrix.SetValue (0, 3, 0.0);
aModelMatrix.SetValue (1, 3, 0.0);
aModelMatrix.SetValue (2, 3, 0.0);
aProjMatrix .SetValue (0, 3, 0.0);
aProjMatrix .SetValue (1, 3, 0.0);
aProjMatrix .SetValue (2, 3, 0.0);
}
// prevent scaling-on-axis
@ -356,33 +346,31 @@ const TEL_TRANSFORM_PERSISTENCE* OpenGl_View::BeginTransformPersistence (const H
const double aScaleZ = anAxialScale.Z();
for (int i = 0; i < 3; ++i)
{
aModelMatrix[0][i] /= aScaleX;
aModelMatrix[1][i] /= aScaleY;
aModelMatrix[2][i] /= aScaleZ;
aModelMatrix.ChangeValue (0, i) /= aScaleX;
aModelMatrix.ChangeValue (1, i) /= aScaleY;
aModelMatrix.ChangeValue (2, i) /= aScaleZ;
}
}
// prevent rotating - annulate rotate matrix
if (theTransPers->mode & TPF_ROTATE)
{
aModelMatrix[0][0] = 1.0;
aModelMatrix[1][1] = 1.0;
aModelMatrix[2][2] = 1.0;
aModelMatrix.SetValue (0, 0, 1.0);
aModelMatrix.SetValue (1, 1, 1.0);
aModelMatrix.SetValue (2, 2, 1.0);
aModelMatrix[1][0] = 0.0;
aModelMatrix[2][0] = 0.0;
aModelMatrix[0][1] = 0.0;
aModelMatrix[2][1] = 0.0;
aModelMatrix[0][2] = 0.0;
aModelMatrix[1][2] = 0.0;
aModelMatrix.SetValue (1, 0, 0.0);
aModelMatrix.SetValue (2, 0, 0.0);
aModelMatrix.SetValue (0, 1, 0.0);
aModelMatrix.SetValue (2, 1, 0.0);
aModelMatrix.SetValue (0, 2, 0.0);
aModelMatrix.SetValue (1, 2, 0.0);
}
// load computed matrices
glMatrixMode (GL_MODELVIEW);
glMultMatrixd ((GLdouble* )aModelMatrix);
glMatrixMode (GL_PROJECTION);
glMultMatrixd ((GLdouble* )aProjMatrix);
theCtx->ModelWorldState.SetIdentity();
theCtx->WorldViewState.SetCurrent<Standard_Real> (aModelMatrix);
theCtx->ProjectionState.SetCurrent<Standard_Real> (aProjMatrix);
if (theTransPers->mode == TPF_TRIEDRON)
{
@ -391,48 +379,58 @@ const TEL_TRANSFORM_PERSISTENCE* OpenGl_View::BeginTransformPersistence (const H
&& theTransPers->pointY != 0.0)
{
GLdouble aW1, aH1, aW2, aH2, aDummy;
glMatrixMode (GL_PROJECTION);
gluUnProject ( 0.5 * aViewportW, 0.5 * aViewportH, 0.0,
(GLdouble* )THE_IDENTITY_MATRIX, (GLdouble* )aProjMatrix, aViewport,
&aW1, &aH1, &aDummy);
gluUnProject (-0.5 * aViewportW, -0.5 * aViewportH, 0.0,
(GLdouble* )THE_IDENTITY_MATRIX, (GLdouble* )aProjMatrix, aViewport,
&aW2, &aH2, &aDummy);
OpenGl_Mat4d anIdentity;
OpenGl_Utils::UnProject<Standard_Real> (0.5 * aViewportW,
0.5 * aViewportH,
0.0,
anIdentity,
aProjMatrix,
aViewport,
aW1,
aH1,
aDummy);
OpenGl_Utils::UnProject<Standard_Real> (-0.5 * aViewportW,
-0.5 * aViewportH,
0.0,
anIdentity,
aProjMatrix,
aViewport,
aW2,
aH2,
aDummy);
GLdouble aMoveX = 0.5 * (aW1 - aW2 - theTransPers->pointZ);
GLdouble aMoveY = 0.5 * (aH1 - aH2 - theTransPers->pointZ);
aMoveX = (theTransPers->pointX > 0.0) ? aMoveX : -aMoveX;
aMoveY = (theTransPers->pointY > 0.0) ? aMoveY : -aMoveY;
theCtx->core11->glTranslated (aMoveX, aMoveY, 0.0);
OpenGl_Utils::Translate<Standard_Real> (aProjMatrix, aMoveX, aMoveY, 0.0);
theCtx->ProjectionState.SetCurrent<Standard_Real> (aProjMatrix);
}
}
else if ((theTransPers->mode & TPF_PAN) != TPF_PAN)
{
// move to thePoint using saved win-coordinates ('marker-behaviour')
GLdouble aMoveX, aMoveY, aMoveZ;
glGetDoublev (GL_MODELVIEW_MATRIX, (GLdouble* )aModelMatrix);
glGetDoublev (GL_PROJECTION_MATRIX, (GLdouble* )aProjMatrix);
gluUnProject (aWinX, aWinY, aWinZ,
(GLdouble* )aModelMatrix, (GLdouble* )aProjMatrix, aViewport,
&aMoveX, &aMoveY, &aMoveZ);
glMatrixMode (GL_MODELVIEW);
theCtx->core11->glTranslated (aMoveX, aMoveY, aMoveZ);
OpenGl_Utils::UnProject<Standard_Real> (aWinX,
aWinY,
aWinZ,
aModelMatrix,
aProjMatrix,
aViewport,
aMoveX,
aMoveY,
aMoveZ);
OpenGl_Utils::Translate<Standard_Real> (aModelMatrix, aMoveX, aMoveY, aMoveZ);
theCtx->WorldViewState.SetCurrent<Standard_Real> (aModelMatrix);
}
// Note: the approach of accessing OpenGl matrices is used now since the matrix
// manipulation are made with help of OpenGl methods. This might be replaced by
// direct computation of matrices by OCC subroutines.
Tmatrix3 aResultWorldView;
glGetFloatv (GL_MODELVIEW_MATRIX, *aResultWorldView);
Tmatrix3 aResultProjection;
glGetFloatv (GL_PROJECTION_MATRIX, *aResultProjection);
// Set OCCT state uniform variables
theCtx->ShaderManager()->UpdateWorldViewStateTo (&aResultWorldView);
theCtx->ShaderManager()->UpdateProjectionStateTo (&aResultProjection);
#endif
theCtx->ApplyProjectionMatrix();
return aTransPersPrev;
}

6
src/OpenGl/OpenGl_View.hxx
View File

@ -108,6 +108,7 @@ class OpenGl_View : public MMgt_TShared
void SetClipPlanes (const Graphic3d_SequenceOfHClipPlane &thePlanes) { myClipPlanes = thePlanes; }
void SetVisualisation (const CALL_DEF_VIEWCONTEXT &AContext);
const Handle(Graphic3d_Camera)& Camera() { return myCamera; }
void SetCamera (const Handle(Graphic3d_Camera)& theCamera) { myCamera = theCamera; }
void SetClipLimit (const Graphic3d_CView& theCView);
@ -221,6 +222,7 @@ protected:
void RenderStructs (const Handle(OpenGl_Workspace) &AWorkspace);
void RedrawLayer2d (const Handle(OpenGl_PrinterContext)& thePrintContext,
const Handle(OpenGl_Workspace) &theWorkspace,
const Graphic3d_CView& theCView,
const Aspect_CLayer2d& theCLayer);
void RedrawTrihedron (const Handle(OpenGl_Workspace) &theWorkspace);
@ -235,9 +237,7 @@ protected:
//! @param theProjection [in] view projection matrix.
//! @param theOrientation [in] view orientation matrix.
void RedrawScene (const Handle(OpenGl_PrinterContext)& thePrintContext,
const Handle(OpenGl_Workspace)& theWorkspace,
const OpenGl_Matrix* theProjection,
const OpenGl_Matrix* theOrientation);
const Handle(OpenGl_Workspace)& theWorkspace);
Handle(OpenGl_LineAttributes) myLineAttribs;
Handle(OpenGl_Texture) myTextureEnv;

173
src/OpenGl/OpenGl_View_2.cxx
View File

@ -69,9 +69,10 @@ struct OPENGL_CLIP_PLANE
/*
* Set des lumieres
*/
static void bind_light (const OpenGl_Light& theLight,
GLenum& theLightGlId,
Graphic3d_Vec4& theAmbientColor)
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)
@ -86,14 +87,16 @@ static void bind_light (const OpenGl_Light& theLight,
return;
}
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
// the light is a headlight?
GLint aMatrixModeOld = 0;
if (theLight.IsHeadlight)
{
glGetIntegerv (GL_MATRIX_MODE, &aMatrixModeOld);
glMatrixMode (GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
aContext->WorldViewState.Push();
aContext->WorldViewState.SetIdentity();
aContext->ApplyWorldViewMatrix();
}
// setup light type
@ -148,8 +151,7 @@ static void bind_light (const OpenGl_Light& theLight,
// restore matrix in case of headlight
if (theLight.IsHeadlight)
{
glPopMatrix();
glMatrixMode (aMatrixModeOld);
aContext->WorldViewState.Pop();
}
glEnable (theLightGlId++);
@ -169,12 +171,16 @@ void OpenGl_View::DrawBackground (OpenGl_Workspace& theWorkspace)
glPushAttrib( GL_ENABLE_BIT | GL_TEXTURE_BIT );
glMatrixMode( GL_PROJECTION );
glPushMatrix();
glLoadIdentity();
glMatrixMode( GL_MODELVIEW );
glPushMatrix();
glLoadIdentity();
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
@ -335,10 +341,10 @@ void OpenGl_View::DrawBackground (OpenGl_Workspace& theWorkspace)
glEnd();
}
glPopMatrix();
glMatrixMode( GL_PROJECTION );
glPopMatrix();
glMatrixMode( GL_MODELVIEW );
aContext->WorldViewState.Pop();
aContext->ProjectionState.Pop();
aContext->ApplyProjectionMatrix();
glPopAttrib(); //GL_ENABLE_BIT | GL_TEXTURE_BIT
@ -388,6 +394,7 @@ void OpenGl_View::Render (const Handle(OpenGl_PrinterContext)& thePrintContext,
}
#endif
// Update states of OpenGl_BVHTreeSelector (frustum culling algorithm).
Standard_Boolean isProjectionMatUpdateNeeded = Standard_False;
Standard_Boolean isOrientationMatUpdateNeeded = Standard_False;
if (myBVHSelector.ProjectionState() != myCamera->ProjectionState())
@ -401,7 +408,12 @@ void OpenGl_View::Render (const Handle(OpenGl_PrinterContext)& thePrintContext,
myBVHSelector.ChangeModelViewState() = myCamera->ModelViewState();
}
// Set OCCT state uniform variables
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)
@ -414,30 +426,21 @@ void OpenGl_View::Render (const Handle(OpenGl_PrinterContext)& thePrintContext,
|| !isSameView)
{
myProjectionState = myCamera->ProjectionState();
aManager->UpdateProjectionStateTo ((const Tmatrix3*)myCamera->ProjectionMatrixF().GetData());
aContext->ProjectionState.SetCurrent (myCamera->ProjectionMatrixF());
aContext->ApplyProjectionMatrix();
}
if (myModelViewState != myCamera->ModelViewState()
|| !isSameView)
{
myModelViewState = myCamera->ModelViewState();
aManager->UpdateWorldViewStateTo ((const Tmatrix3*)myCamera->OrientationMatrixF().GetData());
aContext->WorldViewState.SetCurrent (myCamera->OrientationMatrixF());
aContext->ApplyWorldViewMatrix();
}
if (aManager->ModelWorldState().Index() == 0)
{
Tmatrix3 aModelWorldState = { { 1.f, 0.f, 0.f, 0.f },
{ 0.f, 1.f, 0.f, 0.f },
{ 0.f, 0.f, 1.f, 0.f },
{ 0.f, 0.f, 0.f, 1.f } };
aContext->ShaderManager()->UpdateModelWorldStateTo (&aModelWorldState);
}
if (isProjectionMatUpdateNeeded
|| isOrientationMatUpdateNeeded)
{
myBVHSelector.SetViewVolume (myCamera);
aContext->ShaderManager()->UpdateModelWorldStateTo (OpenGl_Mat4());
}
// ====================================
@ -459,7 +462,7 @@ void OpenGl_View::Render (const Handle(OpenGl_PrinterContext)& thePrintContext,
// Step 3: Draw underlayer
// =================================
RedrawLayer2d (thePrintContext, theCView, theCUnderLayer);
RedrawLayer2d (thePrintContext, theWorkspace, theCView, theCUnderLayer);
// =================================
// Step 4: Redraw main plane
@ -548,25 +551,21 @@ void OpenGl_View::Render (const Handle(OpenGl_PrinterContext)& thePrintContext,
if (!myCamera->IsStereo() || !aContext->HasStereoBuffers())
{
// single-pass monographic rendering
const OpenGl_Matrix* aProj = (const OpenGl_Matrix*) &myCamera->ProjectionMatrixF();
const OpenGl_Matrix* aOrient = (const OpenGl_Matrix*) &myCamera->OrientationMatrixF();
// redraw scene with normal orientation and projection
RedrawScene (thePrintContext, theWorkspace, aProj, aOrient);
RedrawScene (thePrintContext, theWorkspace);
}
else
{
// two stereographic passes
const OpenGl_Matrix* aLProj = (const OpenGl_Matrix*) &myCamera->ProjectionStereoLeftF();
const OpenGl_Matrix* aRProj = (const OpenGl_Matrix*) &myCamera->ProjectionStereoRightF();
const OpenGl_Matrix* aOrient = (const OpenGl_Matrix*) &myCamera->OrientationMatrixF();
// safely switch to left Eye buffer
aContext->SetDrawBufferLeft();
aContext->ProjectionState.SetCurrent (myCamera->ProjectionStereoLeftF());
aContext->ApplyProjectionMatrix();
// redraw left Eye
RedrawScene (thePrintContext, theWorkspace, aLProj, aOrient);
RedrawScene (thePrintContext, theWorkspace);
// reset depth buffer of first rendering pass
if (theWorkspace->UseDepthTest())
@ -576,8 +575,11 @@ void OpenGl_View::Render (const Handle(OpenGl_PrinterContext)& thePrintContext,
// safely switch to right Eye buffer
aContext->SetDrawBufferRight();
aContext->ProjectionState.SetCurrent (myCamera->ProjectionStereoRightF());
aContext->ApplyProjectionMatrix();
// redraw right Eye
RedrawScene (thePrintContext, theWorkspace, aRProj, aOrient);
RedrawScene (thePrintContext, theWorkspace);
// switch back to monographic rendering
aContext->SetDrawBufferMono();
@ -631,7 +633,7 @@ void OpenGl_View::Render (const Handle(OpenGl_PrinterContext)& thePrintContext,
const int aMode = 0;
theWorkspace->DisplayCallback (theCView, (aMode | OCC_PRE_OVERLAY));
RedrawLayer2d (thePrintContext, theCView, theCOverLayer);
RedrawLayer2d (thePrintContext, theWorkspace, theCView, theCOverLayer);
theWorkspace->DisplayCallback (theCView, aMode);
@ -728,6 +730,7 @@ void OpenGl_View::RenderStructs (const Handle(OpenGl_Workspace) &AWorkspace)
//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)
{
@ -736,16 +739,19 @@ void OpenGl_View::RedrawLayer2d (const Handle(OpenGl_PrinterContext)& thePrintCo
|| 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];
glMatrixMode( GL_MODELVIEW );
glPushMatrix ();
glLoadIdentity ();
aContext->WorldViewState.Push();
aContext->ProjectionState.Push();
glMatrixMode (GL_PROJECTION);
glPushMatrix ();
glLoadIdentity ();
aContext->WorldViewState.SetIdentity();
aContext->ProjectionState.SetIdentity();
aContext->ApplyWorldViewMatrix();
aContext->ApplyProjectionMatrix();
if (!ACLayer.sizeDependent)
glViewport (0, 0, dispWidth, dispHeight);
@ -809,7 +815,10 @@ void OpenGl_View::RedrawLayer2d (const Handle(OpenGl_PrinterContext)& thePrintCo
// tiling; scaling of graphics by matrix helps render a
// part of a view (frame) in same viewport, but with higher
// resolution
thePrintContext->LoadProjTransformation();
// 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
@ -846,11 +855,11 @@ void OpenGl_View::RedrawLayer2d (const Handle(OpenGl_PrinterContext)& thePrintCo
glPopAttrib ();
glMatrixMode (GL_PROJECTION);
glPopMatrix ();
aContext->WorldViewState.Pop();
aContext->ProjectionState.Pop();
glMatrixMode( GL_MODELVIEW );
glPopMatrix ();
aContext->ApplyProjectionMatrix();
aContext->ApplyWorldViewMatrix();
if (!ACLayer.sizeDependent)
glViewport (0, 0, (GLsizei) ACView.DefWindow.dx, (GLsizei) ACView.DefWindow.dy);
@ -1111,9 +1120,7 @@ void OpenGl_View::ChangePriority (const OpenGl_Structure *theStructure,
//=======================================================================
void OpenGl_View::RedrawScene (const Handle(OpenGl_PrinterContext)& thePrintContext,
const Handle(OpenGl_Workspace)& theWorkspace,
const OpenGl_Matrix* theProjection,
const OpenGl_Matrix* theOrientation)
const Handle(OpenGl_Workspace)& theWorkspace)
{
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
@ -1165,37 +1172,16 @@ void OpenGl_View::RedrawScene (const Handle(OpenGl_PrinterContext)& thePrintCont
}
}
#if !defined(GL_ES_VERSION_2_0)
// Setup view projection
glMatrixMode (GL_PROJECTION);
#ifdef _WIN32
// add printing scale/tiling transformation
// set printing scale/tiling transformation
if (!thePrintContext.IsNull())
{
thePrintContext->LoadProjTransformation();
}
else
#endif
glLoadIdentity();
glMultMatrixf ((const GLfloat*)theProjection);
if (!thePrintContext.IsNull())
{
// update shader uniform projection matrix with new data
Tmatrix3 aResultProjection;
glGetFloatv (GL_PROJECTION_MATRIX, *aResultProjection);
aContext->ShaderManager()->UpdateProjectionStateTo (&aResultProjection);
// force shader uniform restore on next frame
myProjectionState = 0;
aContext->ProjectionState.Push();
aContext->ProjectionState.SetCurrent (thePrintContext->ProjTransformation() * aContext->ProjectionState.Current());
aContext->ApplyProjectionMatrix();
}
#endif
// Setup view orientation
theWorkspace->SetViewMatrix (theOrientation);
// Specify clipping planes in view transformation space
if (!myClipPlanes.IsEmpty())
{
@ -1233,7 +1219,7 @@ void OpenGl_View::RedrawScene (const Handle(OpenGl_PrinterContext)& thePrintCont
for (OpenGl_ListOfLight::Iterator aLightIt (myLights);
aLightIt.More(); aLightIt.Next())
{
bind_light (aLightIt.Value(), aLightGlId, anAmbientColor);
bindLight (aLightIt.Value(), aLightGlId, anAmbientColor, theWorkspace);
}
// apply accumulated ambient color
@ -1325,4 +1311,17 @@ void OpenGl_View::RedrawScene (const Handle(OpenGl_PrinterContext)& thePrintCont
}
break;
}
// Apply restored view matrix.
aContext->ApplyWorldViewMatrix();
#ifdef _WIN32
// set printing scale/tiling transformation
if (!thePrintContext.IsNull())
{
aContext->ProjectionState.Pop();
aContext->ApplyProjectionMatrix();
}
#endif
}

29
src/OpenGl/OpenGl_Window.cxx
View File

@ -14,13 +14,12 @@
// commercial license or contractual agreement.
#include <OpenGl_GlCore12.hxx>
#include <InterfaceGraphic.hxx>
#include <OpenGl_Window.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_GraphicDriver.hxx>
#include <OpenGl_Window.hxx>
#include <OpenGl_Utils.hxx>
#include <Aspect_GraphicDeviceDefinitionError.hxx>
#include <TCollection_AsciiString.hxx>
@ -690,18 +689,30 @@ void OpenGl_Window::ReadDepths (const Standard_Integer theX, const Standard_
if (theDepths == NULL || !Activate())
return;
#if !defined(GL_ES_VERSION_2_0)
glMatrixMode (GL_PROJECTION);
glLoadIdentity();
gluOrtho2D (0.0, (GLdouble )myWidth, 0.0, (GLdouble )myHeight);
glMatrixMode (GL_MODELVIEW);
glLoadIdentity();
OpenGl_Mat4 aProjectMat;
OpenGl_Utils::Ortho2D<Standard_ShortReal> (aProjectMat,
0.f, static_cast<GLfloat> (myWidth), 0.f, static_cast<GLfloat> (myHeight));
myGlContext->WorldViewState.Push();
myGlContext->ProjectionState.Push();
myGlContext->WorldViewState.SetIdentity();
myGlContext->ProjectionState.SetCurrent (aProjectMat);
myGlContext->ApplyProjectionMatrix();
myGlContext->ApplyWorldViewMatrix();
#if !defined(GL_ES_VERSION_2_0)
glRasterPos2i (theX, theY);
DisableFeatures();
glReadPixels (theX, theY, theWidth, theHeight, GL_DEPTH_COMPONENT, GL_FLOAT, theDepths);
EnableFeatures();
#endif
myGlContext->WorldViewState.Pop();
myGlContext->ProjectionState.Pop();
myGlContext->ApplyProjectionMatrix();
}
// =======================================================================

48
src/OpenGl/OpenGl_Workspace.cxx
View File

@ -27,6 +27,7 @@
#include <OpenGl_Structure.hxx>
#include <OpenGl_Sampler.hxx>
#include <OpenGl_Texture.hxx>
#include <OpenGl_Utils.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Workspace.hxx>
@ -368,12 +369,13 @@ void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)&
// setup texture matrix
glMatrixMode (GL_TEXTURE);
glLoadIdentity();
OpenGl_Mat4 aTextureMat;
const Graphic3d_Vec2& aScale = aParams->Scale();
const Graphic3d_Vec2& aTrans = aParams->Translation();
glScalef ( aScale.x(), aScale.y(), 1.0f);
glTranslatef (-aTrans.x(), -aTrans.y(), 0.0f);
glRotatef (-aParams->Rotation(), 0.0f, 0.0f, 1.0f);
OpenGl_Utils::Scale (aTextureMat, aScale.x(), aScale.y(), 1.0f);
OpenGl_Utils::Translate (aTextureMat, -aTrans.x(), -aTrans.y(), 0.0f);
OpenGl_Utils::Rotate (aTextureMat, -aParams->Rotation(), 0.0f, 0.0f, 1.0f);
glLoadMatrixf (aTextureMat);
// setup generation of texture coordinates
switch (aParams->GenMode())
@ -400,9 +402,10 @@ void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)&
}
case Graphic3d_TOTM_EYE:
{
glMatrixMode (GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
myGlContext->WorldViewState.Push();
myGlContext->WorldViewState.SetIdentity();
myGlContext->ApplyWorldViewMatrix();
glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv (GL_S, GL_EYE_PLANE, aParams->GenPlaneS().GetData());
@ -412,7 +415,9 @@ void OpenGl_Workspace::setTextureParams (Handle(OpenGl_Texture)&
glTexGeni (GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGenfv (GL_T, GL_EYE_PLANE, aParams->GenPlaneT().GetData());
}
glPopMatrix();
myGlContext->WorldViewState.Pop();
break;
}
case Graphic3d_TOTM_SPRITE:
@ -830,14 +835,19 @@ void OpenGl_Workspace::redraw1 (const Graphic3d_CView& theCView,
void OpenGl_Workspace::copyBackToFront()
{
#if !defined(GL_ES_VERSION_2_0)
glMatrixMode (GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D (0.0, (GLdouble )myWidth, 0.0, (GLdouble )myHeight);
glMatrixMode (GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
OpenGl_Mat4 aProjectMat;
OpenGl_Utils::Ortho2D<Standard_ShortReal> (aProjectMat,
0.f, static_cast<GLfloat> (myWidth), 0.f, static_cast<GLfloat> (myHeight));
myGlContext->WorldViewState.Push();
myGlContext->ProjectionState.Push();
myGlContext->WorldViewState.SetIdentity();
myGlContext->ProjectionState.SetCurrent (aProjectMat);
myGlContext->ApplyProjectionMatrix();
myGlContext->ApplyWorldViewMatrix();
DisableFeatures();
@ -849,11 +859,9 @@ void OpenGl_Workspace::copyBackToFront()
EnableFeatures();
glMatrixMode (GL_PROJECTION);
glPopMatrix();
glMatrixMode (GL_MODELVIEW);
glPopMatrix();
myGlContext->WorldViewState.Pop();
myGlContext->ProjectionState.Pop();
myGlContext->ApplyProjectionMatrix();
glDrawBuffer (GL_BACK);
#endif

4
src/OpenGl/OpenGl_Workspace_5.cxx
View File

@ -279,11 +279,11 @@ const OpenGl_Matrix * OpenGl_Workspace::SetStructureMatrix (const OpenGl_Matrix
{
if (aRevert)
{
myGlContext->ShaderManager()->RevertModelWorldStateTo (&lmat.mat);
myGlContext->ShaderManager()->RevertModelWorldStateTo (OpenGl_Mat4::Map (*lmat.mat));
}
else
{
myGlContext->ShaderManager()->UpdateModelWorldStateTo (&lmat.mat);
myGlContext->ShaderManager()->UpdateModelWorldStateTo (OpenGl_Mat4::Map (*lmat.mat));
}
}

31
src/OpenGl/OpenGl_Workspace_Raytrace.cxx
View File

@ -2394,22 +2394,21 @@ Standard_Boolean OpenGl_Workspace::Raytrace (const Graphic3d_CView& theCView,
myView->DrawBackground (*this);
myView->RedrawLayer2d (myPrintContext, theCView, theCUnderLayer);
myView->RedrawLayer2d (myPrintContext, this, theCView, theCUnderLayer);
#if !defined(GL_ES_VERSION_2_0)
// Generate ray-traced image
glMatrixMode (GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
myGlContext->WorldViewState.Push();
myGlContext->ProjectionState.Push();
glMatrixMode (GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
#endif
myGlContext->WorldViewState.SetIdentity();
myGlContext->ProjectionState.SetIdentity();
myGlContext->ApplyProjectionMatrix();
myGlContext->ApplyWorldViewMatrix();
glEnable (GL_BLEND);
glBlendFunc (GL_ONE, GL_SRC_ALPHA);
// Generate ray-traced image
if (myIsRaytraceDataValid)
{
myRaytraceScreenQuad.Bind (myGlContext);
@ -2447,12 +2446,10 @@ Standard_Boolean OpenGl_Workspace::Raytrace (const Graphic3d_CView& theCView,
if (wasDepthTestEnabled)
glEnable (GL_DEPTH_TEST);
#if !defined(GL_ES_VERSION_2_0)
glMatrixMode (GL_PROJECTION);
glPopMatrix();
glMatrixMode (GL_MODELVIEW);
glPopMatrix();
#endif
myGlContext->WorldViewState.Pop();
myGlContext->ProjectionState.Pop();
myGlContext->ApplyProjectionMatrix();
// Redraw trihedron
myView->RedrawTrihedron (this);
@ -2460,7 +2457,7 @@ Standard_Boolean OpenGl_Workspace::Raytrace (const Graphic3d_CView& theCView,
// Redraw overlay
const int aMode = 0;
DisplayCallback (theCView, (aMode | OCC_PRE_OVERLAY));
myView->RedrawLayer2d (myPrintContext, theCView, theCOverLayer);
myView->RedrawLayer2d (myPrintContext, this, theCView, theCOverLayer);
DisplayCallback (theCView, aMode);
// Swap the buffers