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

0022819: Redesign of OpenGl driver

Browse Source
This commit is contained in:
SAN, KGV 2012-02-03 12:59:15 +00:00 committed by bugmaster
parent 1d2b1ccb45
commit 2166f0fad8
362 changed files with 19749 additions and 57863 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/Graphic3d/FILES
View File

@ -28,24 +28,6 @@ Graphic3d_CView.cxx
Graphic3d_CView.hxx Graphic3d_CView.hxx
Graphic3d_CGraduatedTrihedron.cxx Graphic3d_CGraduatedTrihedron.cxx
Graphic3d_CGraduatedTrihedron.hxx Graphic3d_CGraduatedTrihedron.hxx
Graphic3d_GraphicDriver_1.cxx
Graphic3d_GraphicDriver_2.cxx
Graphic3d_GraphicDriver_3.cxx
Graphic3d_GraphicDriver_4.cxx
Graphic3d_GraphicDriver_5.cxx
Graphic3d_GraphicDriver_6.cxx
Graphic3d_GraphicDriver_7.cxx
Graphic3d_GraphicDriver_703.cxx
Graphic3d_GraphicDriver_705.cxx
Graphic3d_GraphicDriver_707.cxx
Graphic3d_GraphicDriver_709.cxx
Graphic3d_GraphicDriver_710.cxx
Graphic3d_GraphicDriver_711.cxx
Graphic3d_GraphicDriver_712.cxx
Graphic3d_GraphicDriver_8.cxx
Graphic3d_GraphicDriver_9.cxx
Graphic3d_GraphicDriver_Layer.cxx
Graphic3d_GraphicDriver_Print.cxx
Graphic3d_Structure.pxx Graphic3d_Structure.pxx
Graphic3d_Group.pxx Graphic3d_Group.pxx
Graphic3d_Group_1.cxx Graphic3d_Group_1.cxx
@ -58,7 +40,6 @@ Graphic3d_Group_8.cxx
Graphic3d_Group_9.cxx Graphic3d_Group_9.cxx
Graphic3d_Group_10.cxx Graphic3d_Group_10.cxx
Graphic3d_Group_11.cxx Graphic3d_Group_11.cxx
Graphic3d_Group_12.cxx
Graphic3d_Structure.pxx Graphic3d_Structure.pxx
Graphic3d_DataStructure.pxx Graphic3d_DataStructure.pxx
Graphic3d_StructureManager.pxx Graphic3d_StructureManager.pxx
@ -67,11 +48,9 @@ Graphic3d_CMPLRS.edl
Graphic3d_WOKSteps.edl Graphic3d_WOKSteps.edl
Graphic3d_PrimitiveArray.hxx Graphic3d_PrimitiveArray.hxx
Graphic3d_Group_13.cxx Graphic3d_Group_13.cxx
Graphic3d_GraphicDriver_713.cxx
Graphic3d_TransModeFlags.hxx Graphic3d_TransModeFlags.hxx
Graphic3d_CTransPersStruct.hxx Graphic3d_CTransPersStruct.hxx
Graphic3d_CTransPersStruct.cxx Graphic3d_CTransPersStruct.cxx
Graphic3d_GraphicDriver_Export.cxx
Graphic3d_NListOfHAsciiString.hxx Graphic3d_NListOfHAsciiString.hxx
Graphic3d_AspectText3d.cxx Graphic3d_AspectText3d.cxx
Graphic3d_WNTGraphicDevice.cxx Graphic3d_WNTGraphicDevice.cxx

75
src/Graphic3d/Graphic3d_GraphicDriver.cdl
View File

@ -33,11 +33,10 @@ deferred class GraphicDriver from Graphic3d inherits GraphicDriver from Aspect
---Version: ---Version:
---Purpose: This class allows the definition of a graphic ---Purpose: This class allows the definition of a graphic driver
-- driver and encapsulates the Pex driver, the -- (currently only OpenGl driver is used).
-- OpenGl driver, the Optimizer driver and the Phigs driver.
---Keywords: Pex, OpenGl, Optimizer, Phigs ---Keywords: OpenGl
---Warning: ---Warning:
---References: ---References:
@ -400,7 +399,7 @@ is
AColor2: Color from Quantity; AColor2: Color from Quantity;
FillStyle : GradientFillMethod from Aspect FillStyle : GradientFillMethod from Aspect
) )
is virtual; is deferred;
---Purpose: call_togl_gradient_background ---Purpose: call_togl_gradient_background
@ -418,7 +417,7 @@ is
SetBgGradientStyle( me : mutable; SetBgGradientStyle( me : mutable;
ACView : CView from Graphic3d; ACView : CView from Graphic3d;
FillStyle : GradientFillMethod from Aspect ) FillStyle : GradientFillMethod from Aspect )
is virtual; is deferred;
ClipLimit ( me : mutable; ClipLimit ( me : mutable;
ACView : CView from Graphic3d; ACView : CView from Graphic3d;
@ -714,46 +713,6 @@ is
is deferred; is deferred;
---Purpose: call_togl_quadrangle ---Purpose: call_togl_quadrangle
QuadrangleSet ( me : mutable;
ACGroup : CGroup from Graphic3d;
ListVertex : Array1OfVertex from Graphic3d;
ListEdge : Array1OfEdge from Aspect;
EvalMinMax : Boolean from Standard = Standard_True )
is deferred;
---Purpose: call_togl_polygon_indices
QuadrangleSet ( me : mutable;
ACGroup : CGroup from Graphic3d;
ListVertex : Array1OfVertexN from Graphic3d;
ListEdge : Array1OfEdge from Aspect;
EvalMinMax : Boolean from Standard = Standard_True )
is deferred;
---Purpose: call_togl_polygon_indices
QuadrangleSet ( me : mutable;
ACGroup : CGroup from Graphic3d;
ListVertex : Array1OfVertexNT from Graphic3d;
ListEdge : Array1OfEdge from Aspect;
EvalMinMax : Boolean from Standard = Standard_True )
is deferred;
---Purpose: call_togl_polygon_indices
QuadrangleSet ( me : mutable;
ACGroup : CGroup from Graphic3d;
ListVertex : Array1OfVertexC from Graphic3d;
ListEdge : Array1OfEdge from Aspect;
EvalMinMax : Boolean from Standard = Standard_True )
is deferred;
---Purpose: call_togl_polygon_indices
QuadrangleSet ( me : mutable;
ACGroup : CGroup from Graphic3d;
ListVertex : Array1OfVertexNC from Graphic3d;
ListEdge : Array1OfEdge from Aspect;
EvalMinMax : Boolean from Standard = Standard_True )
is deferred;
---Purpose: call_togl_polygon_indices
---------------------------------------- ----------------------------------------
-- Category: Methods to create Text -- Category: Methods to create Text
-- for Purpose : see Graphic3d_Group.cdl -- for Purpose : see Graphic3d_Group.cdl
@ -884,7 +843,7 @@ is
EnableVBO( me : mutable; EnableVBO( me : mutable;
status : Boolean from Standard ) status : Boolean from Standard )
is virtual; is deferred;
---Purpose: enables/disables usage of OpenGL vertex buffer arrays while drawing primitiev arrays ---Purpose: enables/disables usage of OpenGL vertex buffer arrays while drawing primitiev arrays
---------------------------------------- ----------------------------------------
@ -949,26 +908,6 @@ is
---Purpose: call_togl_graduatedtrihedron_minmaxvalues ---Purpose: call_togl_graduatedtrihedron_minmaxvalues
is deferred; is deferred;
----------------------------------------
-- Category: Internal methods
-- for Purpose : see Graphic3d_Group.cdl
----------------------------------------
Bezier ( me : mutable;
ACGroup : CGroup from Graphic3d;
ListVertex : Array1OfVertex from Graphic3d;
EvalMinMax : Boolean from Standard = Standard_True )
is deferred;
---Purpose: call_togl_bezier
Bezier ( me : mutable;
ACGroup : CGroup from Graphic3d;
ListVertex : Array1OfVertex from Graphic3d;
ListWeight : Array1OfReal from TColStd;
EvalMinMax : Boolean from Standard = Standard_True )
is deferred;
---Purpose: call_togl_bezier_weight
--------------------------- ---------------------------
-- Category: Animation mode -- Category: Animation mode
--------------------------- ---------------------------
@ -1202,7 +1141,7 @@ is
R : ShortReal from Standard; R : ShortReal from Standard;
G : ShortReal from Standard; G : ShortReal from Standard;
B : ShortReal from Standard ) B : ShortReal from Standard )
is virtual; is deferred;
---Purpose: call_togl_set_text_attributes ---Purpose: call_togl_set_text_attributes
Text ( me : mutable; Text ( me : mutable;

55
src/Graphic3d/Graphic3d_GraphicDriver_1.cxx
View File

@ -1,55 +0,0 @@
// File Graphic3d_GraphicDriver_1.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// Modified 02.15.100 : JR : Clutter
// GG 27/12/02 IMP120302 Add new method Begin(Aspect_Display)
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
Standard_Boolean Graphic3d_GraphicDriver::Begin (const Standard_CString ) {
return Standard_True;
}
//RIC120302
Standard_Boolean Graphic3d_GraphicDriver::Begin (const Aspect_Display)
{
return Standard_True;
}
//RIC120302
void Graphic3d_GraphicDriver::End () {
}
void Graphic3d_GraphicDriver::BeginAnimation (const Graphic3d_CView&
)
{
}
void Graphic3d_GraphicDriver::EndAnimation (const Graphic3d_CView&
)
{
}

62
src/Graphic3d/Graphic3d_GraphicDriver_2.cxx
View File

@ -1,62 +0,0 @@
// File Graphic3d_GraphicDriver_2.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// 15/09/97 ; PCT : ajout InquireTextureAvailable() pour les textures
// 11/97 ; CAL : retrait de la dependance avec math
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <TColStd_Array2OfReal.hxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
Standard_Integer Graphic3d_GraphicDriver::InquireLightLimit () {
return Standard_False;
}
void Graphic3d_GraphicDriver::InquireMat (const Graphic3d_CView&
, TColStd_Array2OfReal&
, TColStd_Array2OfReal&
)
{
}
Standard_Integer Graphic3d_GraphicDriver::InquirePlaneLimit ()
{
return Standard_False;
}
Standard_Integer Graphic3d_GraphicDriver::InquireViewLimit ()
{
return Standard_False;
}
Standard_Boolean Graphic3d_GraphicDriver::InquireTextureAvailable ()
{
return Standard_False;
}

66
src/Graphic3d/Graphic3d_GraphicDriver_3.cxx
View File

@ -1,66 +0,0 @@
// File Graphic3d_GraphicDriver_3.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::ClearGroup (const Graphic3d_CGroup& ) {
}
void Graphic3d_GraphicDriver::CloseGroup (const Graphic3d_CGroup& ) {
}
void Graphic3d_GraphicDriver::FaceContextGroup (const Graphic3d_CGroup& , const Standard_Integer NoInsert) {
}
void Graphic3d_GraphicDriver::Group (Graphic3d_CGroup& ) {
}
void Graphic3d_GraphicDriver::LineContextGroup (const Graphic3d_CGroup& , const Standard_Integer ) {
}
void Graphic3d_GraphicDriver::MarkerContextGroup (const Graphic3d_CGroup& , const Standard_Integer ) {
}
void Graphic3d_GraphicDriver::MarkerContextGroup (const Graphic3d_CGroup& , const Standard_Integer, const Standard_Integer, const Standard_Integer, const Handle(TColStd_HArray1OfByte)& ) {
}
void Graphic3d_GraphicDriver::OpenGroup (const Graphic3d_CGroup& ) {
}
void Graphic3d_GraphicDriver::RemoveGroup (const Graphic3d_CGroup& ) {
}
void Graphic3d_GraphicDriver::TextContextGroup (const Graphic3d_CGroup& , const Standard_Integer ) {
}

54
src/Graphic3d/Graphic3d_GraphicDriver_4.cxx
View File

@ -1,54 +0,0 @@
// File Graphic3d_GraphicDriver_4.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::ClearStructure (const Graphic3d_CStructure& ) {
}
void Graphic3d_GraphicDriver::Connect (const Graphic3d_CStructure& , const Graphic3d_CStructure& ) {
}
void Graphic3d_GraphicDriver::ContextStructure (const Graphic3d_CStructure& ) {
}
void Graphic3d_GraphicDriver::Disconnect (const Graphic3d_CStructure& , const Graphic3d_CStructure& ) {
}
void Graphic3d_GraphicDriver::DisplayStructure (const Graphic3d_CView& , const Graphic3d_CStructure& , const Standard_Integer ) {
}
void Graphic3d_GraphicDriver::EraseStructure (const Graphic3d_CView& , const Graphic3d_CStructure& ) {
}
void Graphic3d_GraphicDriver::RemoveStructure (const Graphic3d_CStructure& ) {
}
void Graphic3d_GraphicDriver::Structure (Graphic3d_CStructure& ) {
}

51
src/Graphic3d/Graphic3d_GraphicDriver_5.cxx
View File

@ -1,51 +0,0 @@
// File Graphic3d_GraphicDriver_5.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::DumpGroup (const Graphic3d_CGroup& ) {
}
void Graphic3d_GraphicDriver::DumpStructure (const Graphic3d_CStructure& ) {
}
void Graphic3d_GraphicDriver::DumpView (const Graphic3d_CView& ) {
}
Standard_Boolean Graphic3d_GraphicDriver::ElementExploration (const Graphic3d_CStructure & , const Standard_Integer , Graphic3d_VertexNC& , Graphic3d_Vector& ) {
return Standard_False;
}
Graphic3d_TypeOfPrimitive Graphic3d_GraphicDriver::ElementType (const Graphic3d_CStructure & , const Standard_Integer ) {
return Graphic3d_TOP_UNDEFINED;
}

39
src/Graphic3d/Graphic3d_GraphicDriver_6.cxx
View File

@ -1,39 +0,0 @@
// File Graphic3d_GraphicDriver_6.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::InitPick () {
}
void Graphic3d_GraphicDriver::Pick (Graphic3d_CPick& ) {
}
void Graphic3d_GraphicDriver::PickId (const Graphic3d_CGroup& ) {
}

125
src/Graphic3d/Graphic3d_GraphicDriver_7.cxx
View File

@ -1,125 +0,0 @@
// File Graphic3d_GraphicDriver_7.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// Modified GG 10/11/99 PRO19603 Change the Redraw method (add redraw area capabillity)
// EUG 07/10/99 G003 Add DegenerateStructure() and
// SetBackFacingModel() methods.
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::ActivateView (const Graphic3d_CView& ) {
}
void Graphic3d_GraphicDriver::AntiAliasing (const Graphic3d_CView& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::Background (const Graphic3d_CView& ) {
}
void Graphic3d_GraphicDriver::GradientBackground( const Graphic3d_CView& ACView,
const Quantity_Color& AColor1, const Quantity_Color& AColor2,
const Aspect_GradientFillMethod AType ){
}
void Graphic3d_GraphicDriver::Blink (const Graphic3d_CStructure& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::BoundaryBox (const Graphic3d_CStructure& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::HighlightColor (const Graphic3d_CStructure& , const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::NameSetStructure (const Graphic3d_CStructure& ) {
}
void Graphic3d_GraphicDriver::ClipLimit (const Graphic3d_CView& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::DeactivateView (const Graphic3d_CView& ) {
}
void Graphic3d_GraphicDriver::DepthCueing (const Graphic3d_CView& , const Standard_Boolean ) {
}
Standard_Boolean Graphic3d_GraphicDriver::ProjectRaster (const Graphic3d_CView& , const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal , Standard_Integer& , Standard_Integer& ) {
return Standard_False;
}
Standard_Boolean Graphic3d_GraphicDriver::UnProjectRaster (const Graphic3d_CView& , const Standard_Integer , const Standard_Integer , const Standard_Integer , const Standard_Integer , const Standard_Integer , const Standard_Integer , Standard_ShortReal& , Standard_ShortReal& , Standard_ShortReal& ) {
return Standard_False;
}
Standard_Boolean Graphic3d_GraphicDriver::UnProjectRasterWithRay (const Graphic3d_CView& , const Standard_Integer , const Standard_Integer , const Standard_Integer , const Standard_Integer , const Standard_Integer , const Standard_Integer , Standard_ShortReal& , Standard_ShortReal& , Standard_ShortReal& , Standard_ShortReal& , Standard_ShortReal& , Standard_ShortReal& ) {
return Standard_False;
}
void Graphic3d_GraphicDriver::RatioWindow (const Graphic3d_CView& ) {
}
void Graphic3d_GraphicDriver::Redraw (const Graphic3d_CView& , const Aspect_CLayer2d& , const Aspect_CLayer2d& , const Standard_Integer , const Standard_Integer , const Standard_Integer , const Standard_Integer ) {
}
void Graphic3d_GraphicDriver::RemoveView (const Graphic3d_CView& ) {
}
void Graphic3d_GraphicDriver::SetLight (const Graphic3d_CView& ) {
}
void Graphic3d_GraphicDriver::SetPlane (const Graphic3d_CView& ) {
}
void Graphic3d_GraphicDriver::SetVisualisation (const Graphic3d_CView& ) {
}
void Graphic3d_GraphicDriver::TransformStructure (const Graphic3d_CStructure& ) {
}
void Graphic3d_GraphicDriver :: DegenerateStructure ( const Graphic3d_CStructure& ) {
}
void Graphic3d_GraphicDriver::Transparency (const Graphic3d_CView& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::Update (const Graphic3d_CView& , const Aspect_CLayer2d& , const Aspect_CLayer2d& ) {
}
Standard_Boolean Graphic3d_GraphicDriver::View (Graphic3d_CView& ) {
return Standard_True;
}
void Graphic3d_GraphicDriver::ViewMapping (const Graphic3d_CView& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::ViewOrientation (const Graphic3d_CView& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver :: SetBackFacingModel ( const Graphic3d_CView& ) {
} // end Graphic3d_GraphicDriver :: SetBackFacingModel

36
src/Graphic3d/Graphic3d_GraphicDriver_703.cxx
View File

@ -1,36 +0,0 @@
// File Graphic3d_GraphicDriver_703.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_TypeOfMarker.hxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::Marker (const Graphic3d_CGroup& , const Graphic3d_Vertex& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::MarkerSet (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertex& , const Standard_Boolean ) {
}

61
src/Graphic3d/Graphic3d_GraphicDriver_705.cxx
View File

@ -1,61 +0,0 @@
// File Graphic3d_GraphicDriver_705.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// Modified
// 27/07/97 ; PCT : ajout coordonnee texture
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::Polygon (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertex& , const Graphic3d_TypeOfPolygon , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::Polygon (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertex& , const Graphic3d_Vector& , const Graphic3d_TypeOfPolygon , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::Polygon (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertexN& , const Graphic3d_TypeOfPolygon , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::Polygon (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertexN& , const Graphic3d_Vector& , const Graphic3d_TypeOfPolygon , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::Polygon(const Graphic3d_CGroup& ,const Graphic3d_Array1OfVertexNT& ,const Graphic3d_TypeOfPolygon ,const Standard_Boolean )
{
}
void Graphic3d_GraphicDriver::PolygonHoles (const Graphic3d_CGroup& , const TColStd_Array1OfInteger& , const Graphic3d_Array1OfVertex& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::PolygonHoles (const Graphic3d_CGroup& , const TColStd_Array1OfInteger& , const Graphic3d_Array1OfVertex& , const Graphic3d_Vector& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::PolygonHoles (const Graphic3d_CGroup& , const TColStd_Array1OfInteger& , const Graphic3d_Array1OfVertexN& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::PolygonHoles (const Graphic3d_CGroup& , const TColStd_Array1OfInteger& , const Graphic3d_Array1OfVertexN& , const Graphic3d_Vector& , const Standard_Boolean ) {
}

39
src/Graphic3d/Graphic3d_GraphicDriver_707.cxx
View File

@ -1,39 +0,0 @@
// File Graphic3d_GraphicDriver_707.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// 11/97 ; CAL : ajout polyline par 2 points
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::Polyline (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertex& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::Polyline (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertexC& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::Polyline (const Graphic3d_CGroup& , const Standard_Real , const Standard_Real , const Standard_Real , const Standard_Real , const Standard_Real , const Standard_Real , const Standard_Boolean ) {
}

60
src/Graphic3d/Graphic3d_GraphicDriver_709.cxx
View File

@ -1,60 +0,0 @@
// File Graphic3d_GraphicDriver_709.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// Modified
// 27/08/97 ; PCT : ajout coordonnee texture
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::QuadrangleMesh (const Graphic3d_CGroup& , const Graphic3d_Array2OfVertex& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::QuadrangleMesh (const Graphic3d_CGroup& , const Graphic3d_Array2OfVertexN& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::QuadrangleMesh(const Graphic3d_CGroup& ,const Graphic3d_Array2OfVertexNT& ,const Standard_Boolean )
{
}
void Graphic3d_GraphicDriver::QuadrangleSet (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertex& , const Aspect_Array1OfEdge& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::QuadrangleSet (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertexN& , const Aspect_Array1OfEdge& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::QuadrangleSet (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertexC& , const Aspect_Array1OfEdge& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::QuadrangleSet (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertexNC& , const Aspect_Array1OfEdge& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::QuadrangleSet(const Graphic3d_CGroup& ,const Graphic3d_Array1OfVertexNT& ,const Aspect_Array1OfEdge& ,const Standard_Boolean )
{
}

78
src/Graphic3d/Graphic3d_GraphicDriver_710.cxx
View File

@ -1,78 +0,0 @@
// File Graphic3d_GraphicDriver_710.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <TCollection_AsciiString.hxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::Text (
const Graphic3d_CGroup& ,
const Standard_CString ,
const Graphic3d_Vertex& ,
const Standard_Real ,
const Quantity_PlaneAngle ,
const Graphic3d_TextPath ,
const Graphic3d_HorizontalTextAlignment ,
const Graphic3d_VerticalTextAlignment ,
const Standard_Boolean
)
{
}
void Graphic3d_GraphicDriver::Text (
const Graphic3d_CGroup& ,
const Standard_CString ,
const Graphic3d_Vertex& ,
const Standard_Real ,
const Standard_Boolean
)
{
}
void Graphic3d_GraphicDriver::Text (
const Graphic3d_CGroup& ,
const TCollection_ExtendedString& ,
const Graphic3d_Vertex& ,
const Standard_Real ,
const Quantity_PlaneAngle ,
const Graphic3d_TextPath ,
const Graphic3d_HorizontalTextAlignment ,
const Graphic3d_VerticalTextAlignment ,
const Standard_Boolean
)
{
}
void Graphic3d_GraphicDriver::Text (
const Graphic3d_CGroup& ,
const TCollection_ExtendedString& ,
const Graphic3d_Vertex& ,
const Standard_Real ,
const Standard_Boolean
)
{
}

62
src/Graphic3d/Graphic3d_GraphicDriver_711.cxx
View File

@ -1,62 +0,0 @@
// File Graphic3d_GraphicDriver_711.cxx
// Created Mardi 28 janvier 1997
// Author CAL
//
// Modified
// 27/08/97 ; PCT : ajout coordonne texture
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::TriangleMesh (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertex& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::TriangleMesh (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertexN& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::TriangleMesh(const Graphic3d_CGroup& ,const Graphic3d_Array1OfVertexNT& ,const Standard_Boolean )
{
}
void Graphic3d_GraphicDriver::TriangleSet (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertex& , const Aspect_Array1OfEdge& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::TriangleSet (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertexN& , const Aspect_Array1OfEdge& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::TriangleSet (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertexC& , const Aspect_Array1OfEdge& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::TriangleSet (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertexNC& , const Aspect_Array1OfEdge& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::TriangleSet(const Graphic3d_CGroup& ,const Graphic3d_Array1OfVertexNT& ,const Aspect_Array1OfEdge& ,const Standard_Boolean )
{
}

36
src/Graphic3d/Graphic3d_GraphicDriver_712.cxx
View File

@ -1,36 +0,0 @@
// File Graphic3d_GraphicDriver_712.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::Bezier (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertex& , const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::Bezier (const Graphic3d_CGroup& , const Graphic3d_Array1OfVertex& , const TColStd_Array1OfReal& , const Standard_Boolean ) {
}

53
src/Graphic3d/Graphic3d_GraphicDriver_713.cxx
View File

@ -1,53 +0,0 @@
// File OpenGl_GraphicDriver_713.cxx
// Created 22-10-01
// Author SAV
// 09/07/02 SAV - merged with file Graphic3d_GraphicDriver_713.cxx created 16/06/2000 by ATS for G005 study.
//Following routines are entry points for creation of PARRAY primitives for (used for presentation).
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#define BUC61044 /* 25/10/01 SAV ; added functionality to control gl depth testing
from higher API */
#define BUC61045 /* 25/10/01 SAV ; added functionality to control gl lighting
from higher API */
void Graphic3d_GraphicDriver::SetDepthTestEnabled( const Graphic3d_CView&, const Standard_Boolean ) const {
}
Standard_Boolean Graphic3d_GraphicDriver::IsDepthTestEnabled( const Graphic3d_CView& ) const {
return Standard_True;
}
void Graphic3d_GraphicDriver::ReadDepths( const Graphic3d_CView&,
const Standard_Integer,
const Standard_Integer,
const Standard_Integer,
const Standard_Integer,
const Standard_Address ) const
{
}
void Graphic3d_GraphicDriver::SetGLLightEnabled( const Graphic3d_CView&, const Standard_Boolean ) const {
}
Standard_Boolean Graphic3d_GraphicDriver::IsGLLightEnabled( const Graphic3d_CView& ) const {
return Standard_True;
}
void Graphic3d_GraphicDriver :: PrimitiveArray ( const Graphic3d_CGroup&,const Graphic3d_PrimitiveArray&,const Standard_Boolean) {
}
void Graphic3d_GraphicDriver :: UserDraw ( const Graphic3d_CGroup&,
const Graphic3d_CUserDraw& )
{
}
void Graphic3d_GraphicDriver::EnableVBO( const Standard_Boolean )
{
}

79
src/Graphic3d/Graphic3d_GraphicDriver_8.cxx
View File

@ -1,79 +0,0 @@
// File Graphic3d_GraphicDriver_8.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
Standard_Boolean Graphic3d_GraphicDriver::BeginAddMode (const Graphic3d_CView& ) {
return Standard_True;
}
void Graphic3d_GraphicDriver::EndAddMode (void) {
}
Standard_Boolean Graphic3d_GraphicDriver::BeginImmediatMode (const Graphic3d_CView& , const Aspect_CLayer2d& , const Aspect_CLayer2d& , const Standard_Boolean , const Standard_Boolean ) {
return Standard_True;
}
void Graphic3d_GraphicDriver::BeginPolyline () {
}
void Graphic3d_GraphicDriver::ClearImmediatMode (const Graphic3d_CView&, const Standard_Boolean ) {
}
void Graphic3d_GraphicDriver::Draw (const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::DrawStructure (const Graphic3d_CStructure& ) {
}
void Graphic3d_GraphicDriver::EndImmediatMode (const Standard_Integer ) {
}
void Graphic3d_GraphicDriver::EndPolyline () {
}
void Graphic3d_GraphicDriver::Move (const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::SetLineColor (const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::SetLineType (const Standard_Integer ) {
}
void Graphic3d_GraphicDriver::SetLineWidth (const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::SetMinMax (const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::Transform (const TColStd_Array2OfReal& , const Graphic3d_TypeOfComposition ) {
}

126
src/Graphic3d/Graphic3d_GraphicDriver_9.cxx
View File

@ -1,126 +0,0 @@
// File Graphic3d_GraphicDriver_8.cxx
// Created Mardi 28 janvier 1997
// Author CAL
// modified: 1/07/97 ; PCT : ajout texture mapping
// 16-09-98 ; BGN : Points d'entree du Triedre (S3819, Phase 1)
// 22-09-98 ; BGN : S3989 (anciennement S3819)
// TypeOfTriedron* from Aspect (pas Graphic3d)
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
//SAV 23/12/02 : Added methods to set background image.
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <stdlib.h>
//-Aliases
//-Global data definitions
//-Methods, in order
Standard_Integer Graphic3d_GraphicDriver::CreateTexture(const Graphic3d_TypeOfTexture ,const Handle_AlienImage_AlienImage &,const Standard_CString,const Handle(TColStd_HArray1OfReal)& TexUpperBounds ) const
{
return -1;
}
void Graphic3d_GraphicDriver::DestroyTexture(const Standard_Integer ) const
{
}
void Graphic3d_GraphicDriver::ModifyTexture(const Standard_Integer ,const Graphic3d_CInitTexture& ) const
{
}
void Graphic3d_GraphicDriver::Environment(const Graphic3d_CView& )
{
}
//
// Triedron methods : the Triedron is a non-zoomable object.
//
void Graphic3d_GraphicDriver::ZBufferTriedronSetup (
const Quantity_NameOfColor,
const Quantity_NameOfColor,
const Quantity_NameOfColor,
const Standard_Real,
const Standard_Real,
const Standard_Integer)
{
}
void Graphic3d_GraphicDriver::TriedronDisplay (
const Graphic3d_CView& ,
const Aspect_TypeOfTriedronPosition ,
const Quantity_NameOfColor ,
const Standard_Real,
const Standard_Boolean )
{
}
void Graphic3d_GraphicDriver::TriedronErase (const Graphic3d_CView& )
{
}
void Graphic3d_GraphicDriver::TriedronEcho (const Graphic3d_CView& ,const Aspect_TypeOfTriedronEcho )
{
}
void Graphic3d_GraphicDriver::BackgroundImage( const Standard_CString /*FileName*/,
const Graphic3d_CView& /*ACView*/,
const Aspect_FillMethod /*FillStyle*/)
{
}
void Graphic3d_GraphicDriver::SetBgImageStyle( const Graphic3d_CView& /*ACView*/,
const Aspect_FillMethod /*FillStyle*/)
{
}
void Graphic3d_GraphicDriver::SetBgGradientStyle( const Graphic3d_CView& /*ACView*/,
const Aspect_GradientFillMethod /*FillStyle*/)
{
}
void Graphic3d_GraphicDriver::GraduatedTrihedronDisplay(const Graphic3d_CView&,
const Graphic3d_CGraduatedTrihedron&)
{
}
void Graphic3d_GraphicDriver::GraduatedTrihedronErase(const Graphic3d_CView&)
{
}
void Graphic3d_GraphicDriver::GraduatedTrihedronMinMaxValues(const Standard_ShortReal,
const Standard_ShortReal,
const Standard_ShortReal,
const Standard_ShortReal,
const Standard_ShortReal,
const Standard_ShortReal)
{
}

25
src/Graphic3d/Graphic3d_GraphicDriver_Export.cxx
View File

@ -1,25 +0,0 @@
/************************************************************************/
/* Includes */
/************************************************************************/
#include <Graphic3d_GraphicDriver.jxx>
/************************************************************************/
/* Print Methods */
/************************************************************************/
Standard_Boolean Graphic3d_GraphicDriver::Export (const Standard_CString theFileName,
const Graphic3d_ExportFormat theFormat,
const Graphic3d_SortType theSortType,
const Standard_Integer theW,
const Standard_Integer theH,
const Graphic3d_CView& theView,
const Aspect_CLayer2d& theLayerUnder,
const Aspect_CLayer2d& theLayerOver,
const Standard_Real thePrecision,
const Standard_Address theProgressBarFunc,
const Standard_Address theProgressObject)
{
return Standard_False;
}

89
src/Graphic3d/Graphic3d_GraphicDriver_Layer.cxx
View File

@ -1,89 +0,0 @@
// File Graphic3d_GraphicDriver_Layer.cxx
// Created Mardi 3 novembre 1998
// Author CAL
// 02.15.100 : JR : Clutter
//-Copyright MatraDatavision 1998
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void Graphic3d_GraphicDriver::Layer (Aspect_CLayer2d& ) {
}
void Graphic3d_GraphicDriver::RemoveLayer (const Aspect_CLayer2d& ) {
}
void Graphic3d_GraphicDriver::BeginLayer (const Aspect_CLayer2d& ) {
}
void Graphic3d_GraphicDriver::BeginPolygon2d () {
}
void Graphic3d_GraphicDriver::BeginPolyline2d () {
}
void Graphic3d_GraphicDriver::ClearLayer (const Aspect_CLayer2d& ) {
}
void Graphic3d_GraphicDriver::Draw (const Standard_ShortReal , const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::Edge (const Standard_ShortReal , const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::EndLayer () {
}
void Graphic3d_GraphicDriver::EndPolygon2d () {
}
void Graphic3d_GraphicDriver::EndPolyline2d () {
}
void Graphic3d_GraphicDriver::Move (const Standard_ShortReal , const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::Rectangle (const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::SetColor (const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::SetTransparency (const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::UnsetTransparency () {
}
void Graphic3d_GraphicDriver::SetLineAttributes (const Standard_Integer , const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::SetTextAttributes (const Standard_CString Font, const Standard_Integer AType, const Standard_ShortReal R, const Standard_ShortReal G, const Standard_ShortReal B) {
}
void Graphic3d_GraphicDriver::Text (const Standard_CString , const Standard_ShortReal , const Standard_ShortReal , const Standard_ShortReal ) {
}
void Graphic3d_GraphicDriver::TextSize (const Standard_CString , const Standard_ShortReal , Standard_ShortReal& , Standard_ShortReal& , Standard_ShortReal& ) const {
}

27
src/Graphic3d/Graphic3d_GraphicDriver_Print.cxx
View File

@ -1,27 +0,0 @@
// File Graphic3d_GraphicDriver_Print.c
// Created March 2000
// Author THA
// e-mail t-hartl@muenchen.matra-dtv.fr
/************************************************************************/
/* Includes */
/************************************************************************/
#include <Graphic3d_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
/************************************************************************/
/* Print Methods */
/************************************************************************/
Standard_Boolean Graphic3d_GraphicDriver::Print (const Graphic3d_CView& ,
const Aspect_CLayer2d& ,
const Aspect_CLayer2d& ,
const Aspect_Handle ,
const Standard_Boolean ,
const Standard_CString ,
const Aspect_PrintAlgo ,
const Standard_Real ) const
{
return Standard_False;
}

72
src/Graphic3d/Graphic3d_Group.cdl
View File

@ -606,77 +606,7 @@
-- Warning: Raises GroupDefinitionError if <ListVertex> contains -- Warning: Raises GroupDefinitionError if <ListVertex> contains
-- less than four points. -- less than four points.
raises GroupDefinitionError from Graphic3d is static; raises GroupDefinitionError from Graphic3d is static;
QuadrangleSet ( me : mutable;
ListVertex : Array1OfVertex from Graphic3d;
ListEdge : Array1OfEdge from Aspect;
EvalMinMax : Boolean from Standard = Standard_True )
---Level: Public
---Purpose: Creates a group of quadrangles defined by a table of
-- vertices and a table of edges, visible or not.
-- Category: Methods to create Quadrangle
-- Warning: Raises GroupDefinitionError if <ListVertex> contains
-- less than four points or if <ListEdge> contains
-- less than four edges.
raises GroupDefinitionError from Graphic3d is static;
QuadrangleSet ( me : mutable;
ListVertex : Array1OfVertexN from Graphic3d;
ListEdge : Array1OfEdge from Aspect;
EvalMinMax : Boolean from Standard = Standard_True )
---Level: Public
---Purpose: Creates a group of quadrangles defined by a table of
-- vertices and a table of edges, visible or not.
-- For each vertex the normal is given.
-- Category: Methods to create Quadrangle
-- Warning: Raises GroupDefinitionError if <ListVertex> contains
-- less than four points or if <ListEdge> contains
-- less than four edges.
raises GroupDefinitionError from Graphic3d is static;
QuadrangleSet ( me : mutable;
ListVertex : Array1OfVertexNT from Graphic3d;
ListEdge : Array1OfEdge from Aspect;
EvalMinMax : Boolean from Standard = Standard_True )
---Level: Public
---Purpose: Creates a group of quadrangles defined by a table of
-- vertices and a table of edges, visible or not.
-- For each vertex the normal is given.
-- For each vertex a texture coordinate is given.
-- Category: Methods to create Quadrangle
-- Warning: Raises GroupDefinitionError if <ListVertex> contains
-- less than four points or if <ListEdge> contains
-- less than four edges.
raises GroupDefinitionError from Graphic3d is static;
QuadrangleSet ( me : mutable;
ListVertex : Array1OfVertexC from Graphic3d;
ListEdge : Array1OfEdge from Aspect;
EvalMinMax : Boolean from Standard = Standard_True )
---Level: Public
---Purpose: Creates a group of quadrangles defined by a table of
-- vertices and a table of edges, visible or not.
-- For each vertex the color is given.
-- Category: Methods to create Quadrangle
-- Warning: Raises GroupDefinitionError if <ListVertex> contains
-- less than four points or if <ListEdge> contains
-- less than four edges.
raises GroupDefinitionError from Graphic3d is static;
QuadrangleSet ( me : mutable;
ListVertex : Array1OfVertexNC from Graphic3d;
ListEdge : Array1OfEdge from Aspect;
EvalMinMax : Boolean from Standard = Standard_True )
---Level: Public
---Purpose: Creates a group of quadrangles defined by a table of
-- vertices and a table of edges, visible or not.
-- For each vertex the normal and the color are given.
-- Category: Methods to create Quadrangle
-- Warning: Raises GroupDefinitionError if <ListVertex> contains
-- less than four points or if <ListEdge> contains
-- less than four edges.
raises GroupDefinitionError from Graphic3d is static;
----------------------------------- -----------------------------------
-- Category: Methods to create Text -- Category: Methods to create Text
----------------------------------- -----------------------------------

100
src/Graphic3d/Graphic3d_Group_12.cxx
View File

@ -1,100 +0,0 @@
// File Graphic3d_Group_12.cxx (Curve)
// Created Aout 1994
// Author NW,JPB,CAL
//-Copyright MatraDatavision 1994
//-Version
//-Design Declaration des variables specifiques aux groupes
// de primitives
//-Warning Un groupe est defini dans une structure
// Il s'agit de la plus petite entite editable
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <Graphic3d_Group.jxx>
#include <Graphic3d_Group.pxx>
//-Methods, in order
void Graphic3d_Group::Bezier (const Graphic3d_Array1OfVertex& ListVertex, const Standard_Boolean EvalMinMax) {
if (IsDeleted ()) return;
MyIsEmpty = Standard_False;
Standard_Integer i, j;
i = ListVertex.Length ();
if (i <= 2)
Graphic3d_GroupDefinitionError::Raise ("Bad number of vertices");
// Min-Max Update
if (EvalMinMax) {
Standard_Real X, Y, Z;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
if (X < MyBounds.XMin) MyBounds.XMin = Standard_ShortReal (X);
if (Y < MyBounds.YMin) MyBounds.YMin = Standard_ShortReal (Y);
if (Z < MyBounds.ZMin) MyBounds.ZMin = Standard_ShortReal (Z);
if (X > MyBounds.XMax) MyBounds.XMax = Standard_ShortReal (X);
if (Y > MyBounds.YMax) MyBounds.YMax = Standard_ShortReal (Y);
if (Z > MyBounds.ZMax) MyBounds.ZMax = Standard_ShortReal (Z);
}
}
MyGraphicDriver->Bezier (MyCGroup, ListVertex, EvalMinMax);
Update ();
}
void Graphic3d_Group::Bezier (const Graphic3d_Array1OfVertex& ListVertex, const TColStd_Array1OfReal& ListWeight, const Standard_Boolean EvalMinMax) {
if (IsDeleted ()) return;
MyIsEmpty = Standard_False;
Standard_Integer i, j;
i = ListVertex.Length ();
j = ListWeight.Length ();
if ((i <= 2) || (i != j))
Graphic3d_GroupDefinitionError::Raise ("Bad number of vertices");
// Min-Max Update
if (EvalMinMax) {
Standard_Real X, Y, Z;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
if (X < MyBounds.XMin) MyBounds.XMin = Standard_ShortReal (X);
if (Y < MyBounds.YMin) MyBounds.YMin = Standard_ShortReal (Y);
if (Z < MyBounds.ZMin) MyBounds.ZMin = Standard_ShortReal (Z);
if (X > MyBounds.XMax) MyBounds.XMax = Standard_ShortReal (X);
if (Y > MyBounds.YMax) MyBounds.YMax = Standard_ShortReal (Y);
if (Z > MyBounds.ZMax) MyBounds.ZMax = Standard_ShortReal (Z);
}
}
MyGraphicDriver->Bezier
(MyCGroup, ListVertex, ListWeight, EvalMinMax);
Update ();
}

211
src/Graphic3d/Graphic3d_Group_9.cxx
View File

@ -21,16 +21,9 @@
//-Declarations //-Declarations
// for the class
#include <Graphic3d_Group.jxx> #include <Graphic3d_Group.jxx>
#include <Graphic3d_Group.pxx> #include <Graphic3d_Group.pxx>
#include <Graphic3d_VertexN.hxx>
#include <Graphic3d_VertexC.hxx>
#include <Graphic3d_VertexNT.hxx>
//-Methods, in order
void Graphic3d_Group::QuadrangleMesh (const Graphic3d_Array2OfVertex& ListVertex, const Standard_Boolean EvalMinMax) { void Graphic3d_Group::QuadrangleMesh (const Graphic3d_Array2OfVertex& ListVertex, const Standard_Boolean EvalMinMax) {
if (IsDeleted ()) return; if (IsDeleted ()) return;
@ -141,207 +134,3 @@ Standard_Integer UpperCol = ListVertex.UpperCol ();
Update (); Update ();
} }
void Graphic3d_Group::QuadrangleSet (const Graphic3d_Array1OfVertex& ListVertex, const Aspect_Array1OfEdge& ListEdge, const Standard_Boolean EvalMinMax) {
if (IsDeleted ()) return;
if (! MyContainsFacet) MyStructure->GroupsWithFacet (+1);
MyContainsFacet = Standard_True;
MyIsEmpty = Standard_False;
Standard_Integer i, j;
i = ListVertex.Length ();
j = ListEdge.Length ();
if ((i <= 3) || (j <= 3))
Graphic3d_GroupDefinitionError::Raise ("Bad number of vertices");
// Min-Max Update
if (EvalMinMax) {
Standard_Real X, Y, Z;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
if (X < MyBounds.XMin) MyBounds.XMin = Standard_ShortReal (X);
if (Y < MyBounds.YMin) MyBounds.YMin = Standard_ShortReal (Y);
if (Z < MyBounds.ZMin) MyBounds.ZMin = Standard_ShortReal (Z);
if (X > MyBounds.XMax) MyBounds.XMax = Standard_ShortReal (X);
if (Y > MyBounds.YMax) MyBounds.YMax = Standard_ShortReal (Y);
if (Z > MyBounds.ZMax) MyBounds.ZMax = Standard_ShortReal (Z);
}
}
MyGraphicDriver->QuadrangleSet
(MyCGroup, ListVertex, ListEdge, EvalMinMax);
Update ();
}
void Graphic3d_Group::QuadrangleSet (const Graphic3d_Array1OfVertexN& ListVertex, const Aspect_Array1OfEdge& ListEdge, const Standard_Boolean EvalMinMax) {
if (IsDeleted ()) return;
if (! MyContainsFacet) MyStructure->GroupsWithFacet (+1);
MyContainsFacet = Standard_True;
MyIsEmpty = Standard_False;
Standard_Integer i, j;
i = ListVertex.Length ();
j = ListEdge.Length ();
if ((i <= 3) || (j <= 3))
Graphic3d_GroupDefinitionError::Raise ("Bad number of vertices");
// Min-Max Update
if (EvalMinMax) {
Standard_Real X, Y, Z;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
if (X < MyBounds.XMin) MyBounds.XMin = Standard_ShortReal (X);
if (Y < MyBounds.YMin) MyBounds.YMin = Standard_ShortReal (Y);
if (Z < MyBounds.ZMin) MyBounds.ZMin = Standard_ShortReal (Z);
if (X > MyBounds.XMax) MyBounds.XMax = Standard_ShortReal (X);
if (Y > MyBounds.YMax) MyBounds.YMax = Standard_ShortReal (Y);
if (Z > MyBounds.ZMax) MyBounds.ZMax = Standard_ShortReal (Z);
}
}
MyGraphicDriver->QuadrangleSet
(MyCGroup, ListVertex, ListEdge, EvalMinMax);
Update ();
}
void Graphic3d_Group::QuadrangleSet (const Graphic3d_Array1OfVertexC& ListVertex, const Aspect_Array1OfEdge& ListEdge, const Standard_Boolean EvalMinMax) {
if (IsDeleted ()) return;
if (! MyContainsFacet) MyStructure->GroupsWithFacet (+1);
MyContainsFacet = Standard_True;
MyIsEmpty = Standard_False;
Standard_Integer i, j;
i = ListVertex.Length ();
j = ListEdge.Length ();
if ((i <= 3) || (j <= 3))
Graphic3d_GroupDefinitionError::Raise ("Bad number of vertices");
// Min-Max Update
if (EvalMinMax) {
Standard_Real X, Y, Z;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
if (X < MyBounds.XMin) MyBounds.XMin = Standard_ShortReal (X);
if (Y < MyBounds.YMin) MyBounds.YMin = Standard_ShortReal (Y);
if (Z < MyBounds.ZMin) MyBounds.ZMin = Standard_ShortReal (Z);
if (X > MyBounds.XMax) MyBounds.XMax = Standard_ShortReal (X);
if (Y > MyBounds.YMax) MyBounds.YMax = Standard_ShortReal (Y);
if (Z > MyBounds.ZMax) MyBounds.ZMax = Standard_ShortReal (Z);
}
}
MyGraphicDriver->QuadrangleSet
(MyCGroup, ListVertex, ListEdge, EvalMinMax);
Update ();
}
void Graphic3d_Group::QuadrangleSet (const Graphic3d_Array1OfVertexNC& ListVertex, const Aspect_Array1OfEdge& ListEdge, const Standard_Boolean EvalMinMax) {
if (IsDeleted ()) return;
if (! MyContainsFacet) MyStructure->GroupsWithFacet (+1);
MyContainsFacet = Standard_True;
MyIsEmpty = Standard_False;
Standard_Integer i, j;
i = ListVertex.Length ();
j = ListEdge.Length ();
if ((i <= 3) || (j <= 3))
Graphic3d_GroupDefinitionError::Raise ("Bad number of vertices");
// Min-Max Update
if (EvalMinMax) {
Standard_Real X, Y, Z;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
if (X < MyBounds.XMin) MyBounds.XMin = Standard_ShortReal (X);
if (Y < MyBounds.YMin) MyBounds.YMin = Standard_ShortReal (Y);
if (Z < MyBounds.ZMin) MyBounds.ZMin = Standard_ShortReal (Z);
if (X > MyBounds.XMax) MyBounds.XMax = Standard_ShortReal (X);
if (Y > MyBounds.YMax) MyBounds.YMax = Standard_ShortReal (Y);
if (Z > MyBounds.ZMax) MyBounds.ZMax = Standard_ShortReal (Z);
}
}
MyGraphicDriver->QuadrangleSet
(MyCGroup, ListVertex, ListEdge, EvalMinMax);
Update ();
}
void Graphic3d_Group::QuadrangleSet(const Graphic3d_Array1OfVertexNT& ListVertex,const Aspect_Array1OfEdge& ListEdge,const Standard_Boolean EvalMinMax)
{
if (IsDeleted ()) return;
if (! MyContainsFacet) MyStructure->GroupsWithFacet (+1);
MyContainsFacet = Standard_True;
MyIsEmpty = Standard_False;
Standard_Integer i, j;
i = ListVertex.Length ();
j = ListEdge.Length ();
if ((i <= 3) || (j <= 3))
Graphic3d_GroupDefinitionError::Raise ("Bad number of vertices");
// Min-Max Update
if (EvalMinMax) {
Standard_Real X, Y, Z;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
if (X < MyBounds.XMin) MyBounds.XMin = Standard_ShortReal (X);
if (Y < MyBounds.YMin) MyBounds.YMin = Standard_ShortReal (Y);
if (Z < MyBounds.ZMin) MyBounds.ZMin = Standard_ShortReal (Z);
if (X > MyBounds.XMax) MyBounds.XMax = Standard_ShortReal (X);
if (Y > MyBounds.YMax) MyBounds.YMax = Standard_ShortReal (Y);
if (Z > MyBounds.ZMax) MyBounds.ZMax = Standard_ShortReal (Z);
}
}
MyGraphicDriver->QuadrangleSet
(MyCGroup, ListVertex, ListEdge, EvalMinMax);
Update ();
}

333
src/OpenGl/FILES
View File

@ -1,10 +1,8 @@
EXTERNLIB EXTERNLIB
OpenGl_triedron.cxx
OpenGl_CMPLRS.edl OpenGl_CMPLRS.edl
OpenGl_FontMgr.hxx Handle_OpenGl_GraphicDriver.hxx
OpenGl_FontMgr.cxx OpenGl_GraphicDriver.hxx
OpenGl_AVIWriter.hxx OpenGl_GraphicDriver.cxx
OpenGl_AVIWriter.cxx
OpenGl_GraphicDriver_1.cxx OpenGl_GraphicDriver_1.cxx
OpenGl_GraphicDriver_2.cxx OpenGl_GraphicDriver_2.cxx
OpenGl_GraphicDriver_3.cxx OpenGl_GraphicDriver_3.cxx
@ -12,240 +10,117 @@ OpenGl_GraphicDriver_4.cxx
OpenGl_GraphicDriver_5.cxx OpenGl_GraphicDriver_5.cxx
OpenGl_GraphicDriver_6.cxx OpenGl_GraphicDriver_6.cxx
OpenGl_GraphicDriver_7.cxx OpenGl_GraphicDriver_7.cxx
OpenGl_GraphicDriver_8.cxx
OpenGl_GraphicDriver_9.cxx
OpenGl_GraphicDriver_703.cxx OpenGl_GraphicDriver_703.cxx
OpenGl_GraphicDriver_705.cxx OpenGl_GraphicDriver_705.cxx
OpenGl_GraphicDriver_707.cxx OpenGl_GraphicDriver_707.cxx
OpenGl_GraphicDriver_709.cxx OpenGl_GraphicDriver_709.cxx
OpenGl_GraphicDriver_710.cxx OpenGl_GraphicDriver_710.cxx
OpenGl_GraphicDriver_711.cxx OpenGl_GraphicDriver_711.cxx
OpenGl_GraphicDriver_712.cxx
OpenGl_GraphicDriver_8.cxx
OpenGl_GraphicDriver_9.cxx
OpenGl_GraphicDriver_print.cxx
OpenGl_GraphicDriver_Layer.cxx
OpenGl.cdl
OpenGl_addnames.cxx
OpenGl_animation.hxx
OpenGl_antialias.cxx
OpenGl_applid.cxx
OpenGl_attri.cxx
OpenGl_bintcol.cxx
OpenGl_bintrefl.cxx
OpenGl_bsurfprop.cxx
OpenGl_charexpan.cxx
OpenGl_charspace.cxx
OpenGl_cmn_varargs.hxx
OpenGl_context.hxx
OpenGl_curve.cxx
OpenGl_degeneration.hxx
OpenGl_degmodel.cxx
OpenGl_depthcue.cxx
OpenGl_dind.cxx
OpenGl_edgecol.cxx
OpenGl_edgeflag.cxx
OpenGl_edgetyp.cxx
OpenGl_edgewid.cxx
OpenGl_execstruct.cxx
OpenGl_Extension.hxx
OpenGl_Extension.cxx
OpenGl_facecull.cxx
OpenGl_facedmode.cxx
OpenGl_filters.cxx
OpenGl_funcs.cxx
OpenGl_highlight.cxx
OpenGl_hlind.cxx
OpenGl_ImageBox.hxx
OpenGl_ImageBox.cxx
OpenGl_indexpolygons.cxx
OpenGl_initelem.cxx
OpenGl_inquire.cxx
OpenGl_inquire.hxx
OpenGl_intcol.cxx
OpenGl_intrefl.cxx
OpenGl_intshademtd.cxx
OpenGl_intstyle.cxx
OpenGl_intstyleind.cxx
OpenGl_label.cxx
OpenGl_lightstate.cxx
OpenGl_localtran3.cxx
OpenGl_LightBox.cxx
OpenGl_LightBox.hxx
OpenGl_mrkr.cxx
OpenGl_mrkrcol.cxx
OpenGl_mrkrset.cxx
OpenGl_mrkrsize.cxx
OpenGl_mrkrtype.cxx
OpenGl_pick.cxx
OpenGl_pickid.cxx
OpenGl_polygon.cxx
OpenGl_polygonholes.cxx
OpenGl_polygonoffset.cxx
OpenGl_polyl.cxx
OpenGl_polylcol.cxx
OpenGl_polyltyp.cxx
OpenGl_polylwid.cxx
OpenGl_qstrip.cxx
OpenGl_remnames.cxx
OpenGl_subrs.cxx
OpenGl_subrvis.cxx
OpenGl_surfprop.cxx
OpenGl_telem.hxx
OpenGl_telem_attri.hxx
OpenGl_telem_depthcue.hxx
OpenGl_telem_filters.hxx
OpenGl_telem_highlight.hxx
OpenGl_telem_inquire.hxx
OpenGl_telem_pick.hxx
OpenGl_telem_util.cxx
OpenGl_telem_util.hxx
OpenGl_telem_view.hxx
OpenGl_text.cxx
OpenGl_textcol.cxx
OpenGl_textcolsubtitle.cxx
OpenGl_textdisplaytype.cxx
OpenGl_textfont.cxx
OpenGl_textheight.cxx
OpenGl_textstyle.cxx
OpenGl_TextureBox.hxx
OpenGl_TextureBox.cxx
OpenGl_tgl.hxx
OpenGl_tgl_all.hxx
OpenGl_tgl_elems.hxx
OpenGl_tgl_funcs.hxx
OpenGl_tgl_pick.hxx
OpenGl_tgl_subrs.hxx
OpenGl_tgl_subrvis.hxx
OpenGl_tgl_tox.hxx
OpenGl_tgl_util.cxx
OpenGl_tgl_util.hxx
OpenGl_tgl_utilgr.cxx
OpenGl_tgl_utilgr.hxx
OpenGl_tgl_vis.hxx
OpenGl_tmesh.cxx
OpenGl_tox.cxx
OpenGl_trsf_stack.hxx
OpenGl_tsm.cxx
OpenGl_tsm.hxx
OpenGl_tsm_ws.hxx
OpenGl_txgl.cxx
OpenGl_txgl.hxx
OpenGl_undefined.cxx
OpenGl_view.cxx
OpenGl_vind.cxx
OpenGl_ws.cxx
OpenGl_togl_activateview.cxx
OpenGl_togl_antialiasing.cxx
OpenGl_togl_backfacing.cxx
OpenGl_togl_background.cxx
OpenGl_togl_begin.cxx
OpenGl_togl_begin_animation.cxx
OpenGl_togl_begin_immediat_mode.cxx
OpenGl_togl_begin_layer_mode.cxx
OpenGl_togl_bezier.cxx
OpenGl_togl_bezier_weight.cxx
OpenGl_togl_blink.cxx
OpenGl_togl_boundarybox.cxx
OpenGl_togl_cleargroup.cxx
OpenGl_togl_clearstructure.cxx
OpenGl_togl_cliplimit.cxx
OpenGl_togl_closegroup.cxx
OpenGl_togl_connect.cxx
OpenGl_togl_contextstructure.cxx
OpenGl_togl_curve.cxx
OpenGl_togl_deactivateview.cxx
OpenGl_togl_degeneratestructure.cxx
OpenGl_togl_depthcueing.cxx
OpenGl_togl_disconnect.cxx
OpenGl_togl_displaystructure.cxx
OpenGl_togl_element_exploration.cxx
OpenGl_togl_end.cxx
OpenGl_togl_erasestructure.cxx
OpenGl_togl_facecontextgroup.cxx
OpenGl_togl_group.cxx
OpenGl_togl_highlightcolor.cxx
OpenGl_togl_init_pick.cxx
OpenGl_togl_inquirefacilities.cxx
OpenGl_togl_inquirelight.cxx
OpenGl_togl_inquireplane.cxx
OpenGl_togl_inquireview.cxx
OpenGl_togl_light.cxx
OpenGl_togl_light_exploration.cxx
OpenGl_togl_linecontextgroup.cxx
OpenGl_togl_marker.cxx
OpenGl_togl_marker_set.cxx
OpenGl_togl_markercontextgroup.cxx
OpenGl_togl_namesetstructure.cxx
OpenGl_togl_opengroup.cxx
OpenGl_togl_pick.cxx
OpenGl_togl_pickid.cxx
OpenGl_togl_plane.cxx
OpenGl_togl_polygon.cxx
OpenGl_togl_polygon_holes.cxx
OpenGl_togl_polygon_indices.cxx
OpenGl_togl_polygon_set.cxx
OpenGl_togl_polyline.cxx
OpenGl_togl_print.cxx
OpenGl_togl_project_raster.cxx
OpenGl_togl_quadrangle.cxx
OpenGl_togl_ratio_window.cxx
OpenGl_togl_redraw.cxx
OpenGl_togl_removegroup.cxx
OpenGl_togl_removestructure.cxx
OpenGl_togl_removeview.cxx
OpenGl_togl_set_environment.cxx
OpenGl_togl_setlight.cxx
OpenGl_togl_setplane.cxx
OpenGl_togl_setvisualisation.cxx
OpenGl_togl_structure.cxx
OpenGl_togl_structure_exploration.cxx
OpenGl_togl_text.cxx
OpenGl_togl_textcontextgroup.cxx
OpenGl_togl_texture.cxx
OpenGl_togl_transformstructure.cxx
OpenGl_togl_transparency.cxx
OpenGl_togl_triangle.cxx
OpenGl_togl_triedron.cxx
OpenGl_togl_unproject_raster.cxx
OpenGl_togl_update.cxx
OpenGl_togl_view.cxx
OpenGl_togl_view_exploration.cxx
OpenGl_togl_viewmapping.cxx
OpenGl_togl_vieworientation.cxx
OpenGl_dotexturemap.cxx
OpenGl_texture.cxx
OpenGl_triedron.cxx
OpenGl_triedron.hxx
OpenGl_traces.hxx
OpenGl_togl_parray.cxx
OpenGl_PrimitiveArray.cxx
OpenGl_togl_depthtest.cxx
OpenGl_GraphicDriver_713.cxx OpenGl_GraphicDriver_713.cxx
OpenGl_transform_persistence.cxx OpenGl_GraphicDriver_Layer.cxx
OpenGl_transform_persistence.hxx OpenGl_GraphicDriver_print.cxx
OpenGl_GraphicDriver_Export.cxx OpenGl_GraphicDriver_Export.cxx
OpenGl_textalignment.cxx OpenGl_AspectLine.hxx
OpenGl_togl_userdraw.cxx OpenGl_AspectLine.cxx
OpenGl_userdraw.cxx OpenGl_AspectFace.hxx
OpenGl_callback.hxx OpenGl_AspectFace.cxx
OpenGl_Memory.hxx OpenGl_AspectMarker.hxx
OpenGl_Memory.cxx OpenGl_AspectMarker.cxx
OpenGl_TextRender.hxx OpenGl_AspectText.hxx
OpenGl_TextRender.cxx OpenGl_AspectText.cxx
OpenGl_textzoomable.cxx OpenGl_Group.hxx
OpenGl_textangle.cxx OpenGl_Group.cxx
OpenGl_textfontaspect.cxx OpenGl_Structure.hxx
OpenGl_togl_gradient_background.cxx OpenGl_Structure.cxx
OpenGl_graduatedtrihedron.cxx OpenGl_Element.hxx
OpenGl_graduatedtrihedron.hxx OpenGl_Text.hxx
OpenGl_togl_graduatedtrihedron.cxx OpenGl_Text.cxx
OpenGl_Polyline.hxx
OpenGl_Polyline.cxx
OpenGl_Marker.hxx
OpenGl_Marker.cxx
OpenGl_MarkerSet.hxx
OpenGl_MarkerSet.cxx
OpenGl_Polygon.hxx
OpenGl_Polygon.cxx
OpenGl_QuadrangleStrip.hxx
OpenGl_QuadrangleStrip.cxx
OpenGl_TriangleStrip.hxx
OpenGl_TriangleStrip.cxx
OpenGl_Mesh.hxx
OpenGl_Mesh.cxx
OpenGl_PrimitiveArray.hxx
OpenGl_PrimitiveArray.cxx
Handle_OpenGl_Workspace.hxx
OpenGl_Workspace.hxx
OpenGl_Workspace.cxx
OpenGl_Workspace_1.cxx
OpenGl_Workspace_2.cxx
OpenGl_Workspace_3.cxx
OpenGl_Workspace_4.cxx
OpenGl_Workspace_5.cxx
Handle_OpenGl_View.hxx
OpenGl_View.hxx
OpenGl_View.cxx
OpenGl_View_1.cxx
OpenGl_View_2.cxx
OpenGl_Light.hxx
Handle_OpenGl_Trihedron.hxx
OpenGl_Trihedron.hxx
OpenGl_Trihedron.cxx
Handle_OpenGl_GraduatedTrihedron.hxx
OpenGl_GraduatedTrihedron.hxx
OpenGl_GraduatedTrihedron.cxx
OpenGl_Matrix.hxx
OpenGl_Matrix.cxx
OpenGl_CView.hxx
OpenGl_NamedStatus.hxx
OpenGl_TextParam.hxx
OpenGl_Callback.hxx
OpenGl_PrinterContext.hxx
OpenGl_PrinterContext.cxx
Handle_OpenGl_Display.hxx
OpenGl_Display.hxx
OpenGl_Display.cxx
OpenGl_Display_1.cxx
OpenGl_Display_2.cxx
Handle_OpenGl_Window.hxx
OpenGl_Window.hxx
OpenGl_Window.cxx
OpenGl_PriorityList.hxx
OpenGl_PriorityList.cxx
OpenGl_AVIWriter.hxx
OpenGl_AVIWriter.cxx
OpenGl_tsm.hxx
OpenGl_telem_view.cxx
OpenGl_telem_view.hxx
OpenGl_tgl_all.hxx
OpenGl_FrameBuffer.hxx OpenGl_FrameBuffer.hxx
OpenGl_FrameBuffer.cxx OpenGl_FrameBuffer.cxx
OpenGl_TextureBox.cxx
OpenGl_TextureBox.hxx
OpenGl_ImageBox.cxx
OpenGl_ImageBox.hxx
OpenGl_Memory.hxx
OpenGl_Resource.hxx OpenGl_Resource.hxx
OpenGl_ResourceCleaner.cxx
OpenGl_ResourceCleaner.hxx
OpenGl_ResourceVBO.cxx
OpenGl_ResourceVBO.hxx OpenGl_ResourceVBO.hxx
OpenGl_ResourceTexture.cxx OpenGl_ResourceVBO.cxx
OpenGl_ResourceTexture.hxx OpenGl_ResourceTexture.hxx
OpenGl_PrinterContext.cxx OpenGl_ResourceTexture.cxx
OpenGl_PrinterContext.hxx OpenGl_ResourceCleaner.hxx
OpenGl_ResourceCleaner.cxx
OpenGl_telem_util.hxx
OpenGl_telem_util.cxx
OpenGl_transform_persistence.hxx
OpenGl_FontMgr.hxx
OpenGl_FontMgr.cxx
OpenGl_tgl_funcs.hxx
OpenGl_togl_texture.cxx
OpenGl_togl_inquireplane.cxx
Handle_OpenGl_Context.hxx
OpenGl_Context.hxx
OpenGl_Context.cxx
OpenGl_ArbVBO.hxx
OpenGl_ExtFBO.hxx

15
src/OpenGl/Handle_OpenGl_Context.hxx Normal file
View File

@ -0,0 +1,15 @@
// File: Handle_OpenGl_Context.hxx
// Created: 26 January 2012
// Author: Kirill GAVRILOV
// Copyright: OPEN CASCADE 2012
#ifndef _Handle_OpenGl_Context_Header
#define _Handle_OpenGl_Context_Header
#include <Standard_DefineHandle.hxx>
#include <Handle_Standard_Transient.hxx>
class OpenGl_Context;
DEFINE_STANDARD_HANDLE(OpenGl_Context, Standard_Transient)
#endif // _Handle_OpenGl_Context_Header

19
src/OpenGl/Handle_OpenGl_Display.hxx Normal file
View File

@ -0,0 +1,19 @@
// File: Handle_OpenGl_Display.hxx
// Created: 20 September 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _Handle_OpenGl_Display_Header
#define _Handle_OpenGl_Display_Header
#include <Standard_DefineHandle.hxx>
#include <Handle_MMgt_TShared.hxx>
class OpenGl_Display;
// Handle definition
//
DEFINE_STANDARD_HANDLE(OpenGl_Display,MMgt_TShared)
#endif //_Handle_OpenGl_Display_Header

19
src/OpenGl/Handle_OpenGl_GraduatedTrihedron.hxx Normal file
View File

@ -0,0 +1,19 @@
// File: Handle_OpenGl_GraduatedTrihedron.hxx
// Created: 20 September 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _Handle_OpenGl_GraduatedTrihedron_Header
#define _Handle_OpenGl_GraduatedTrihedron_Header
#include <Standard_DefineHandle.hxx>
#include <Handle_MMgt_TShared.hxx>
class OpenGl_GraduatedTrihedron;
// Handle definition
//
DEFINE_STANDARD_HANDLE(OpenGl_GraduatedTrihedron,MMgt_TShared)
#endif //_Handle_OpenGl_GraduatedTrihedron_Header

18
src/OpenGl/Handle_OpenGl_GraphicDriver.hxx Normal file
View File

@ -0,0 +1,18 @@
// File: Handle_OpenGl_GraphicDriver.hxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _Handle_OpenGl_GraphicDriver_Header
#define _Handle_OpenGl_GraphicDriver_Header
#include <Standard_DefineHandle.hxx>
#include <Handle_Graphic3d_GraphicDriver.hxx>
class OpenGl_GraphicDriver;
// Handle definition
//
DEFINE_STANDARD_HANDLE(OpenGl_GraphicDriver,Graphic3d_GraphicDriver)
#endif //_Handle_OpenGl_GraphicDriver_Header

19
src/OpenGl/Handle_OpenGl_Trihedron.hxx Normal file
View File

@ -0,0 +1,19 @@
// File: Handle_OpenGl_Trihedron.hxx
// Created: 20 September 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _Handle_OpenGl_Trihedron_Header
#define _Handle_OpenGl_Trihedron_Header
#include <Standard_DefineHandle.hxx>
#include <Handle_MMgt_TShared.hxx>
class OpenGl_Trihedron;
// Handle definition
//
DEFINE_STANDARD_HANDLE(OpenGl_Trihedron,MMgt_TShared)
#endif //_Handle_OpenGl_Trihedron_Header

19
src/OpenGl/Handle_OpenGl_View.hxx Normal file
View File

@ -0,0 +1,19 @@
// File: Handle_OpenGl_View.hxx
// Created: 20 September 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _Handle_OpenGl_View_Header
#define _Handle_OpenGl_View_Header
#include <Standard_DefineHandle.hxx>
#include <Handle_MMgt_TShared.hxx>
class OpenGl_View;
// Handle definition
//
DEFINE_STANDARD_HANDLE(OpenGl_View,MMgt_TShared)
#endif //_Handle_OpenGl_View_Header

19
src/OpenGl/Handle_OpenGl_Window.hxx Normal file
View File

@ -0,0 +1,19 @@
// File: Handle_OpenGl_Window.hxx
// Created: 20 September 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _Handle_OpenGl_Window_Header
#define _Handle_OpenGl_Window_Header
#include <Standard_DefineHandle.hxx>
#include <Handle_MMgt_TShared.hxx>
class OpenGl_Window;
// Handle definition
//
DEFINE_STANDARD_HANDLE(OpenGl_Window,MMgt_TShared)
#endif //_Handle_OpenGl_Window_Header

19
src/OpenGl/Handle_OpenGl_Workspace.hxx Normal file
View File

@ -0,0 +1,19 @@
// File: Handle_OpenGl_Workspace.hxx
// Created: 20 September 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _Handle_OpenGl_Workspace_Header
#define _Handle_OpenGl_Workspace_Header
#include <Standard_DefineHandle.hxx>
#include <Handle_OpenGl_Window.hxx>
class OpenGl_Workspace;
// Handle definition
//
DEFINE_STANDARD_HANDLE(OpenGl_Workspace,OpenGl_Window)
#endif //_Handle_OpenGl_Workspace_Header

43
src/OpenGl/OpenGl.cdl
View File

@ -1,43 +0,0 @@
--
-- Package: OpenGl
-- Author: CAL
-- Created: Mercredi 4 Janvier 1995
-- Updated: 20/08/97 ; PCT : ajout texture mapping
-- 27/01/98 ; FMN : Delete GEOMLITE
--
-- Copyright: MatraDatavision 1995
--
-- Purpose: Specifications definitives
--
package OpenGl
---Version:
---Purpose: This package contains the common OpenGl graphic interface.
---Keywords: OpenGl, CInterface
---Warning: No class in this package. It is used only to archive
-- all the objects files in a library.
---References:
uses
OSD,
TColStd,
TCollection,
Aspect,
Quantity,
Graphic3d,
Image,
AlienImage
is
exception Error inherits NumericError from Standard;
class GraphicDriver;
---Purpose: Defines a graphic driver for the opengl interface
end OpenGl;

45
src/OpenGl/OpenGl_ArbVBO.hxx Normal file
View File

@ -0,0 +1,45 @@
// File: OpenGl_ArbVBO.hxx
// Created: 26 January 2012
// Author: Kirill GAVRILOV
// Copyright: OPEN CASCADE 2012
#ifndef _OpenGl_ArbVBO_H__
#define _OpenGl_ArbVBO_H__
#if (defined(_WIN32) || defined(__WIN32__))
#include <windows.h>
#endif
#include <GL/gl.h>
typedef ptrdiff_t GLsizeiptr;
//! VBO is part of OpenGL since 1.5
struct OpenGl_ArbVBO
{
#ifndef GL_ARRAY_BUFFER_ARB
#define GL_ARRAY_BUFFER_ARB 0x8892
#endif
#ifndef GL_STATIC_DRAW_ARB
#define GL_STATIC_DRAW_ARB 0x88E4
#endif
#ifndef GL_ELEMENTS_ARRAY_BUFFER_ARB
#define GL_ELEMENTS_ARRAY_BUFFER_ARB 0x8893
#endif
public:
typedef void (APIENTRY *glBindBuffer_t) (GLenum target, GLuint buffer);
typedef void (APIENTRY *glDeleteBuffers_t) (GLsizei n, const GLuint* buffers);
typedef void (APIENTRY *glGenBuffers_t) (GLsizei n, GLuint* buffers);
typedef void (APIENTRY *glBufferData_t) (GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage);
public:
glGenBuffers_t glGenBuffersARB;
glBindBuffer_t glBindBufferARB;
glBufferData_t glBufferDataARB;
glDeleteBuffers_t glDeleteBuffersARB;
};
#endif // _OpenGl_ArbVBO_H__

217
src/OpenGl/OpenGl_AspectFace.cxx Normal file
View File

@ -0,0 +1,217 @@
// File: OpenGl_AspectFace.cxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_AspectFace.hxx>
#include <InterfaceGraphic_Graphic3d.hxx>
#include <Aspect_PolygonOffsetMode.hxx>
/*----------------------------------------------------------------------*/
static const TEL_CONTEXT_FACE myDefaultAspectFace =
{
Aspect_IS_SOLID,
TOn, TEL_HS_SOLID, TOn, TelCullNone,
{ 0.2F, 0.8F, 0.1F, 0.0F, /* amb, diff, spec, emsv */
1.0F, 10.0F, 0.0F, /* trans, shine, env_reflexion */
0, /* isphysic */
(OPENGL_AMBIENT_MASK | OPENGL_DIFFUSE_MASK | OPENGL_SPECULAR_MASK), /* color_mask */
{{ 1.0F, 1.0F, 1.0F, 1.0F }}, /* ambient color */
{{ 1.0F, 1.0F, 1.0F, 1.0F }}, /* diffuse color */
{{ 1.0F, 1.0F, 1.0F, 1.0F }}, /* specular color */
{{ 1.0F, 1.0F, 1.0F, 1.0F }}, /* emissive color */
{{ 1.0F, 1.0F, 1.0F, 1.0F }} /* material color */
},
{ 0.2F, 0.8F, 0.1F, 0.0F, /* amb, diff, spec, emsv */
1.0F, 10.0F, 0.0F, /* trans, shine, env_reflexion */
0, /* isphysic */
(OPENGL_AMBIENT_MASK | OPENGL_DIFFUSE_MASK | OPENGL_SPECULAR_MASK), /* color_mask */
{{ 1.0F, 1.0F, 1.0F, 1.0F }}, /* ambient color */
{{ 1.0F, 1.0F, 1.0F, 1.0F }}, /* diffuse color */
{{ 1.0F, 1.0F, 1.0F, 1.0F }}, /* specular color */
{{ 1.0F, 1.0F, 1.0F, 1.0F }}, /* emissive color */
{{ 1.0F, 1.0F, 1.0F, 1.0F }} /* material color */
},
0, -1, { Aspect_POM_Fill, 1.0F, 0.0F }
};
/*----------------------------------------------------------------------*/
static void ConvertMaterial (const CALL_DEF_MATERIAL &material, OPENGL_SURF_PROP &surface)
{
/* Cas par cas pour l evaluation */
surface.amb = material.IsAmbient? material.Ambient : 0.F;
surface.diff = material.IsDiffuse? material.Diffuse : 0.F;
surface.spec = material.IsSpecular? material.Specular : 0.F;
surface.emsv = material.IsEmission? material.Emission : 0.F;
/* type de materiel */
surface.isphysic = material.IsPhysic? 1 : 0;
/* Couleur du materiel */
surface.color_mask = 0;
if ( material.IsAmbient )
surface.color_mask |= OPENGL_AMBIENT_MASK;
if ( material.IsDiffuse )
surface.color_mask |= OPENGL_DIFFUSE_MASK;
if ( material.IsSpecular )
surface.color_mask |= OPENGL_SPECULAR_MASK;
if ( material.IsEmission )
surface.color_mask |= OPENGL_EMISSIVE_MASK;
/* Couleur eclairage ambient */
surface.ambcol.rgb[0] = material.ColorAmb.r;
surface.ambcol.rgb[1] = material.ColorAmb.g;
surface.ambcol.rgb[2] = material.ColorAmb.b;
surface.ambcol.rgb[3] = 1.F;
/* Couleur eclairage diffus */
surface.difcol.rgb[0] = material.ColorDif.r;
surface.difcol.rgb[1] = material.ColorDif.g;
surface.difcol.rgb[2] = material.ColorDif.b;
surface.difcol.rgb[3] = 1.F;
/* Couleur eclairage speculaire */
surface.speccol.rgb[0] = material.ColorSpec.r;
surface.speccol.rgb[1] = material.ColorSpec.g;
surface.speccol.rgb[2] = material.ColorSpec.b;
surface.speccol.rgb[3] = 1.F;
/* Couleur d emission */
surface.emscol.rgb[0] = material.ColorEms.r;
surface.emscol.rgb[1] = material.ColorEms.g;
surface.emscol.rgb[2] = material.ColorEms.b;
surface.emscol.rgb[3] = 1.F;
surface.shine = ( float )128 * material.Shininess;
surface.env_reflexion = material.EnvReflexion;
/* Dans la couche C++ :
* prop->trans = 0. => opaque
* prop->trans = 1. => transparent
* in OpenGl it is opposite.
*/
surface.trans = 1.0F - material.Transparency;
}
/*----------------------------------------------------------------------*/
OpenGl_AspectFace::OpenGl_AspectFace ()
: myContext(myDefaultAspectFace)
{}
/*----------------------------------------------------------------------*/
void OpenGl_AspectFace::SetContext (const CALL_DEF_CONTEXTFILLAREA &AContext)
{
//TelInteriorStyle
myContext.InteriorStyle = (Aspect_InteriorStyle) AContext.Style;
//TelEdgeFlag
myContext.Edge = AContext.Edge ? TOn : TOff;
//TelInteriorStyleIndex
switch( AContext.Hatch )
{
case 0 : /* Aspect_HS_HORIZONTAL */
myContext.Hatch = TEL_HS_HORIZONTAL;
break;
case 1 : /* Aspect_HS_HORIZONTAL_WIDE */
myContext.Hatch = TEL_HS_HORIZONTAL_SPARSE;
break;
case 2 : /* Aspect_HS_VERTICAL */
myContext.Hatch = TEL_HS_VERTICAL;
break;
case 3 : /* Aspect_HS_VERTICAL_WIDE */
myContext.Hatch = TEL_HS_VERTICAL_SPARSE;
break;
case 4 : /* Aspect_HS_DIAGONAL_45 */
myContext.Hatch = TEL_HS_DIAG_45;
break;
case 5 : /* Aspect_HS_DIAGONAL_45_WIDE */
myContext.Hatch = TEL_HS_DIAG_45_SPARSE;
break;
case 6 : /* Aspect_HS_DIAGONAL_135 */
myContext.Hatch = TEL_HS_DIAG_135;
break;
case 7 : /* Aspect_HS_DIAGONAL_135_WIDE */
myContext.Hatch = TEL_HS_DIAG_135_SPARSE;
break;
case 8 : /* Aspect_HS_GRID */
myContext.Hatch = TEL_HS_GRID;
break;
case 9 : /* Aspect_HS_GRID_WIDE */
myContext.Hatch = TEL_HS_GRID_SPARSE;
break;
case 10 : /* Aspect_HS_GRID_DIAGONAL */
myContext.Hatch = TEL_HS_CROSS;
break;
case 11 : /* Aspect_HS_GRID_DIAGONAL_WIDE */
myContext.Hatch = TEL_HS_CROSS_SPARSE;
break;
default :
myContext.Hatch = 0;
break;
}
//TelFaceDistinguishingMode
myContext.DistinguishingMode = AContext.Distinguish ? TOn : TOff;
//TelFaceCullingMode
myContext.CullingMode = AContext.BackFace ? TelCullBack : TelCullNone;
//TelSurfaceAreaProperties
ConvertMaterial(AContext.Front,myContext.IntFront);
//TelBackSurfaceAreaProperties
ConvertMaterial(AContext.Back,myContext.IntBack);
//TelInteriorColour
myContext.IntFront.matcol.rgb[0] = (float) AContext.IntColor.r;
myContext.IntFront.matcol.rgb[1] = (float) AContext.IntColor.g;
myContext.IntFront.matcol.rgb[2] = (float) AContext.IntColor.b;
myContext.IntFront.matcol.rgb[3] = 1.f;
//TelBackInteriorColour
myContext.IntBack.matcol.rgb[0] = (float) AContext.BackIntColor.r;
myContext.IntBack.matcol.rgb[1] = (float) AContext.BackIntColor.g;
myContext.IntBack.matcol.rgb[2] = (float) AContext.BackIntColor.b;
myContext.IntBack.matcol.rgb[3] = 1.f;
//TelDoTextureMap
myContext.doTextureMap = AContext.Texture.doTextureMap;
//TelTextureId
myContext.TexId = AContext.Texture.TexId;
//TelPolygonOffset
myContext.PolygonOffset.mode = (Aspect_PolygonOffsetMode) AContext.PolygonOffsetMode;
myContext.PolygonOffset.factor = AContext.PolygonOffsetFactor;
myContext.PolygonOffset.units = AContext.PolygonOffsetUnits;
CALL_DEF_CONTEXTLINE anEdgeContext;
//TelEdgeColour
anEdgeContext.Color.r = (float) AContext.EdgeColor.r;
anEdgeContext.Color.g = (float) AContext.EdgeColor.g;
anEdgeContext.Color.b = (float) AContext.EdgeColor.b;
//TelEdgeType
anEdgeContext.LineType = (Aspect_TypeOfLine) AContext.LineType;
//TelEdgeWidth
anEdgeContext.Width = (float) AContext.Width;
myAspectEdge.SetContext(anEdgeContext);
}
/*----------------------------------------------------------------------*/
void OpenGl_AspectFace::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
{
AWorkspace->SetAspectFace(this);
}
/*----------------------------------------------------------------------*/

73
src/OpenGl/OpenGl_AspectFace.hxx Normal file
View File

@ -0,0 +1,73 @@
// File: OpenGl_AspectFace.hxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _OpenGl_AspectFace_Header
#define _OpenGl_AspectFace_Header
#include <InterfaceGraphic_telem.hxx>
#include <Aspect_InteriorStyle.hxx>
#include <OpenGl_AspectLine.hxx>
#define OPENGL_AMBIENT_MASK (1<<0)
#define OPENGL_DIFFUSE_MASK (1<<1)
#define OPENGL_SPECULAR_MASK (1<<2)
#define OPENGL_EMISSIVE_MASK (1<<3)
struct OPENGL_SURF_PROP
{
float amb, diff, spec, emsv;
float trans, shine;
float env_reflexion;
int isphysic;
unsigned int color_mask;
TEL_COLOUR speccol, difcol, ambcol, emscol, matcol;
IMPLEMENT_MEMORY_OPERATORS
};
struct TEL_CONTEXT_FACE
{
Aspect_InteriorStyle InteriorStyle;
int Edge;
int Hatch;
int DistinguishingMode;
int CullingMode;
OPENGL_SURF_PROP IntFront;
OPENGL_SURF_PROP IntBack;
int doTextureMap;
int TexId;
TEL_POFFSET_PARAM PolygonOffset;
IMPLEMENT_MEMORY_OPERATORS
};
#include <OpenGl_Element.hxx>
class OpenGl_AspectFace : public OpenGl_Element
{
public:
OpenGl_AspectFace ();
virtual ~OpenGl_AspectFace () {}
void SetContext (const CALL_DEF_CONTEXTFILLAREA &AContext);
void SetContext (const TEL_CONTEXT_FACE &AContext) { myContext = AContext; }
void SetAspectEdge (const OpenGl_AspectLine * AnAspectEdge) { myAspectEdge = *AnAspectEdge; }
const TEL_CONTEXT_FACE & Context() const { return myContext; }
const OpenGl_AspectLine * AspectEdge() const { return &myAspectEdge; }
virtual void Render (const Handle(OpenGl_Workspace) &AWorkspace) const;
protected:
TEL_CONTEXT_FACE myContext;
OpenGl_AspectLine myAspectEdge;
public:
IMPLEMENT_MEMORY_OPERATORS
};
#endif //_OpenGl_AspectFace_Header

45
src/OpenGl/OpenGl_AspectLine.cxx Normal file
View File

@ -0,0 +1,45 @@
// File: OpenGl_AspectLine.cxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_AspectLine.hxx>
static const TEL_COLOUR myDefaultColor = {{ 1.0F, 1.0F, 1.0F, 1.0F }};
/*----------------------------------------------------------------------*/
OpenGl_AspectLine::OpenGl_AspectLine ()
: myColor(myDefaultColor),
myType(Aspect_TOL_SOLID),
myWidth(1.0F)
{}
/*----------------------------------------------------------------------*/
OpenGl_AspectLine::OpenGl_AspectLine (const OpenGl_AspectLine &AnOther)
: myColor(AnOther.myColor),
myType(AnOther.myType),
myWidth(AnOther.myWidth)
{}
/*----------------------------------------------------------------------*/
void OpenGl_AspectLine::SetContext (const CALL_DEF_CONTEXTLINE &AContext)
{
myColor.rgb[0] = (float) AContext.Color.r;
myColor.rgb[1] = (float) AContext.Color.g;
myColor.rgb[2] = (float) AContext.Color.b;
myColor.rgb[3] = 1.0f;
myType = (Aspect_TypeOfLine) AContext.LineType;
myWidth = (float) AContext.Width;
}
/*----------------------------------------------------------------------*/
void OpenGl_AspectLine::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
{
AWorkspace->SetAspectLine(this);
}
/*----------------------------------------------------------------------*/

40
src/OpenGl/OpenGl_AspectLine.hxx Normal file
View File

@ -0,0 +1,40 @@
// File: OpenGl_AspectLine.hxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _OpenGl_AspectLine_Header
#define _OpenGl_AspectLine_Header
#include <InterfaceGraphic_telem.hxx>
#include <Aspect_TypeOfLine.hxx>
#include <OpenGl_Element.hxx>
class OpenGl_AspectLine : public OpenGl_Element
{
public:
OpenGl_AspectLine ();
OpenGl_AspectLine (const OpenGl_AspectLine &AnOther);
virtual ~OpenGl_AspectLine () {}
void SetContext (const CALL_DEF_CONTEXTLINE &AContext);
const TEL_COLOUR & Color() const { return myColor; }
Aspect_TypeOfLine Type() const { return myType; }
float Width() const { return myWidth; }
virtual void Render (const Handle(OpenGl_Workspace) &AWorkspace) const;
protected:
TEL_COLOUR myColor;
Aspect_TypeOfLine myType;
float myWidth;
public:
IMPLEMENT_MEMORY_OPERATORS
};
#endif //_OpenGl_AspectLine_Header

37
src/OpenGl/OpenGl_AspectMarker.cxx Normal file
View File

@ -0,0 +1,37 @@
// File: OpenGl_AspectMarker.cxx
// Created: 14 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_AspectMarker.hxx>
static const TEL_COLOUR myDefaultColor = {{ 1.0F, 1.0F, 1.0F, 1.0F }};
/*----------------------------------------------------------------------*/
OpenGl_AspectMarker::OpenGl_AspectMarker ()
: myColor(myDefaultColor),
myType(Aspect_TOM_PLUS),
myScale(1.0F)
{}
/*----------------------------------------------------------------------*/
void OpenGl_AspectMarker::SetContext (const CALL_DEF_CONTEXTMARKER &AContext)
{
myColor.rgb[0] = (float) AContext.Color.r;
myColor.rgb[1] = (float) AContext.Color.g;
myColor.rgb[2] = (float) AContext.Color.b;
myColor.rgb[3] = 1.0f;
myType = (Aspect_TypeOfMarker) AContext.MarkerType;
myScale = (float) AContext.Scale;
}
/*----------------------------------------------------------------------*/
void OpenGl_AspectMarker::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
{
AWorkspace->SetAspectMarker(this);
}
/*----------------------------------------------------------------------*/

39
src/OpenGl/OpenGl_AspectMarker.hxx Normal file
View File

@ -0,0 +1,39 @@
// File: OpenGl_AspectMarker.hxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef OpenGl_AspectMarker_Header
#define OpenGl_AspectMarker_Header
#include <InterfaceGraphic_telem.hxx>
#include <Aspect_TypeOfMarker.hxx>
#include <OpenGl_Element.hxx>
class OpenGl_AspectMarker : public OpenGl_Element
{
public:
OpenGl_AspectMarker ();
virtual ~OpenGl_AspectMarker () {}
void SetContext (const CALL_DEF_CONTEXTMARKER &AContext);
const TEL_COLOUR & Color() const { return myColor; }
Aspect_TypeOfMarker Type() const { return myType; }
float Scale() const { return myScale; }
virtual void Render (const Handle(OpenGl_Workspace) &AWorkspace) const;
protected:
TEL_COLOUR myColor;
Aspect_TypeOfMarker myType;
float myScale;
public:
IMPLEMENT_MEMORY_OPERATORS
};
#endif //OpenGl_AspectMarker_Header

76
src/OpenGl/OpenGl_AspectText.cxx Normal file
View File

@ -0,0 +1,76 @@
// File: OpenGl_AspectText.cxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_AspectText.hxx>
static const TEL_COLOUR myDefaultColor = {{ 1.0F, 1.0F, 1.0F, 1.0F }};
/*----------------------------------------------------------------------*/
OpenGl_AspectText::OpenGl_AspectText ()
: myZoomable(0),
myAngle(0.0F),
myFontAspect(OSD_FA_Regular),
myFont(NULL),
//mySpace(0.3F),
//myExpan(1.0F),
myColor(myDefaultColor),
myStyleType(Aspect_TOST_NORMAL),
myDisplayType(Aspect_TODT_NORMAL),
mySubtitleColor(myDefaultColor)
{
SetFontName( (const char *) "Courier" );
}
/*----------------------------------------------------------------------*/
OpenGl_AspectText::~OpenGl_AspectText ()
{
if (myFont)
delete[] myFont;
}
/*----------------------------------------------------------------------*/
void OpenGl_AspectText::SetContext (const CALL_DEF_CONTEXTTEXT &AContext)
{
myZoomable = (int) AContext.TextZoomable;
myAngle = (float) AContext.TextAngle;
myFontAspect = (OSD_FontAspect) AContext.TextFontAspect;
//mySpace = (float) AContext.Space;
//myExpan = (float) AContext.Expan;
myColor.rgb[0] = (float) AContext.Color.r;
myColor.rgb[1] = (float) AContext.Color.g;
myColor.rgb[2] = (float) AContext.Color.b;
myColor.rgb[3] = 1.0f;
myStyleType = (Aspect_TypeOfStyleText) AContext.Style;
myDisplayType = (Aspect_TypeOfDisplayText) AContext.DisplayType;
mySubtitleColor.rgb[0] = (float) AContext.ColorSubTitle.r;
mySubtitleColor.rgb[1] = (float) AContext.ColorSubTitle.g;
mySubtitleColor.rgb[2] = (float) AContext.ColorSubTitle.b;
mySubtitleColor.rgb[3] = 1.0f;
SetFontName( (const char *) AContext.Font );
}
/*----------------------------------------------------------------------*/
void OpenGl_AspectText::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
{
AWorkspace->SetAspectText(this);
}
/*----------------------------------------------------------------------*/
void OpenGl_AspectText::SetFontName (const char *AFont)
{
if (myFont)
delete[] myFont;
char *fontname = new char[ strlen( AFont ) + 1 ];
strcpy( fontname, AFont );
myFont = fontname;
}
/*----------------------------------------------------------------------*/

55
src/OpenGl/OpenGl_AspectText.hxx Normal file
View File

@ -0,0 +1,55 @@
// File: OpenGl_AspectText.hxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef OpenGl_AspectText_Header
#define OpenGl_AspectText_Header
#include <InterfaceGraphic_telem.hxx>
#include <OSD_FontAspect.hxx>
#include <Aspect_TypeOfStyleText.hxx>
#include <Aspect_TypeOfDisplayText.hxx>
#include <OpenGl_Element.hxx>
class OpenGl_AspectText : public OpenGl_Element
{
public:
OpenGl_AspectText ();
virtual ~OpenGl_AspectText ();
void SetContext (const CALL_DEF_CONTEXTTEXT &AContext);
int IsZoomable() const { return myZoomable; }
float Angle() const { return myAngle; }
OSD_FontAspect FontAspect() const { return myFontAspect; }
const char * Font() const { return myFont; }
const TEL_COLOUR & Color() const { return myColor; }
Aspect_TypeOfStyleText StyleType() const { return myStyleType; }
Aspect_TypeOfDisplayText DisplayType() const { return myDisplayType; }
const TEL_COLOUR & SubtitleColor() const { return mySubtitleColor; }
virtual void Render (const Handle(OpenGl_Workspace) &AWorkspace) const;
protected:
void SetFontName (const char *AFont);
int myZoomable;
float myAngle;
OSD_FontAspect myFontAspect;
const char *myFont;
//float mySpace;
//float myExpan;
TEL_COLOUR myColor;
Aspect_TypeOfStyleText myStyleType;
Aspect_TypeOfDisplayText myDisplayType;
TEL_COLOUR mySubtitleColor;
public:
IMPLEMENT_MEMORY_OPERATORS
};
#endif //OpenGl_AspectText_Header

34
src/OpenGl/OpenGl_CMPLRS.edl
View File

@ -1,10 +1,8 @@
-- --
-- File: OpenGl_CMPLRS.edl -- File: OpenGl_CMPLRS.edl
-- Author: Stephane Callegari -- Author: Stephane Callegari
-- History: 13-12-96 : CAL : Creation -- History: 13-12-96 : CAL : Creation
-- 01-11-97 : BGN : Portage HP/OpenGL -- Copyright: Matra Datavision 1996
-- (avec option +a1 pour C++, et -Aa pour C)
-- Copyright: Matra Datavision 1996
-- --
@ifnotdefined ( %OpenGl_CMPLRS_EDL) then @ifnotdefined ( %OpenGl_CMPLRS_EDL) then
@ -16,28 +14,4 @@
@string %CMPLRS_CXX_Options += %CSF_X11_INCLUDE " " %CSF_OPENGL_INCLUDE " " %CSF_FTGL_INCLUDES " " %CSF_FREETYPE_INCLUDES " " %CSF_GL2PS_INCLUDES " "; @string %CMPLRS_CXX_Options += %CSF_X11_INCLUDE " " %CSF_OPENGL_INCLUDE " " %CSF_FTGL_INCLUDES " " %CSF_FREETYPE_INCLUDES " " %CSF_GL2PS_INCLUDES " ";
@string %CMPLRS_C_Options += %CSF_X11_INCLUDE " " %CSF_OPENGL_INCLUDE " " %CSF_FTGL_INCLUDES " " %CSF_FREETYPE_INCLUDES " " %CSF_GL2PS_INCLUDES " "; @string %CMPLRS_C_Options += %CSF_X11_INCLUDE " " %CSF_OPENGL_INCLUDE " " %CSF_FTGL_INCLUDES " " %CSF_FREETYPE_INCLUDES " " %CSF_GL2PS_INCLUDES " ";
@if ( %Station == "hp" ) then
@string %CMPLRS_C_Options += " -D_HPUX_SOURCE";
@if ( %DebugMode == "False" ) then
@set %CMPLRS_C_ModeOpt = "+O1 -DNo_Exception ";
@set %CMPLRS_F77_ModeOpt = "+O1";
@endif;
@endif;
@if ( %Station == "ao1" ) then
@string %CMPLRS_C_Options += " -DJWR_DEC_TRIFAN_BUG";
@string %CMPLRS_C_Options += " -std1";
@endif;
-- FMN @string %CMPLRS_C_Options += " -DLMC_COLOR";
@string %CMPLRS_C_Options += " -DSILGL -DSILGL_VRS=50";
@endif; @endif;

21
src/OpenGl/OpenGl_CView.hxx Normal file
View File

@ -0,0 +1,21 @@
// File: OpenGl_CView.hxx
// Created: 20 September 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef OpenGl_CView_Header
#define OpenGl_CView_Header
#include <InterfaceGraphic_telem.hxx>
#include <OpenGl_Workspace.hxx>
#include <OpenGl_View.hxx>
struct OpenGl_CView
{
Handle_OpenGl_Workspace WS;
Handle_OpenGl_View View;
IMPLEMENT_MEMORY_OPERATORS
};
#endif //OpenGl_CView_Header

17
src/OpenGl/OpenGl_Callback.hxx Normal file
View File

@ -0,0 +1,17 @@
// File: OpenGl_Callback.hxx
// Created: 25 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _OpenGl_Callback_HeaderFile
#define _OpenGl_Callback_HeaderFile
#include <InterfaceGraphic_Graphic3d.hxx>
#include <OpenGl_Element.hxx>
typedef OpenGl_Element * (*OpenGl_UserDrawCallback)(const CALL_DEF_USERDRAW *);
Standard_EXPORT OpenGl_UserDrawCallback & UserDrawCallback ();
#endif //_OpenGl_Callback_HeaderFile

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

@ -0,0 +1,105 @@
// File: OpenGl_Context.cxx
// Created: 26 January 2012
// Author: Kirill GAVRILOV
// Copyright: OPEN CASCADE 2012
#include <OpenGl_Context.hxx>
IMPLEMENT_STANDARD_HANDLE (OpenGl_Context, Standard_Transient)
IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Context, Standard_Transient)
#if (!defined(_WIN32) && !defined(__WIN32__))
#include <GL/glx.h>
#endif
// =======================================================================
// function : OpenGl_Context
// purpose :
// =======================================================================
OpenGl_Context::OpenGl_Context()
: arbVBO (NULL),
extFBO (NULL)
{
//
}
// =======================================================================
// function : ~OpenGl_Context
// purpose :
// =======================================================================
OpenGl_Context::~OpenGl_Context()
{
//
}
// =======================================================================
// function : CheckExtension
// purpose :
// =======================================================================
Standard_Boolean OpenGl_Context::CheckExtension (const char* theExtName,
const char* theExtString)
{
if (theExtName == NULL
|| theExtString == NULL) {
std::cerr << "CheckExtension called with NULL string! No GL context?\n";
return Standard_False;
}
// Search for theExtName in the extensions string.
// Use of strstr() is not sufficient because extension names can be prefixes of other extension names.
char* aPtrIter = (char* )theExtString;
int anExtNameLen = strlen(theExtName);
const char* aPtrEnd = aPtrIter + strlen(theExtString);
while (aPtrIter < aPtrEnd)
{
int n = strcspn (aPtrIter, " ");
if ((n == anExtNameLen) && (strncmp (theExtName, aPtrIter, n) == 0))
return Standard_True;
aPtrIter += (n + 1);
}
return Standard_False;
}
// =======================================================================
// function : Init
// purpose :
// =======================================================================
void OpenGl_Context::Init()
{
const char* anExtString = (const char* )glGetString (GL_EXTENSIONS);
if (CheckExtension ("GL_ARB_vertex_buffer_object", anExtString))
{
arbVBO = new OpenGl_ArbVBO();
memset(arbVBO, 0, sizeof(OpenGl_ArbVBO)); // nullify whole structure for safety
if (!FindProc ("glGenBuffersARB", arbVBO->glGenBuffersARB)
|| !FindProc ("glBindBufferARB", arbVBO->glBindBufferARB)
|| !FindProc ("glBufferDataARB", arbVBO->glBufferDataARB)
|| !FindProc ("glDeleteBuffersARB", arbVBO->glDeleteBuffersARB))
{
delete arbVBO;
arbVBO = NULL;
}
}
if (CheckExtension ("GL_EXT_framebuffer_object", anExtString))
{
extFBO = new OpenGl_ExtFBO();
memset(extFBO, 0, sizeof(OpenGl_ExtFBO)); // nullify whole structure for safety
if (!FindProc ("glGenFramebuffersEXT", extFBO->glGenFramebuffersEXT)
|| !FindProc ("glDeleteFramebuffersEXT", extFBO->glDeleteFramebuffersEXT)
|| !FindProc ("glBindFramebufferEXT", extFBO->glBindFramebufferEXT)
|| !FindProc ("glFramebufferTexture2DEXT", extFBO->glFramebufferTexture2DEXT)
|| !FindProc ("glCheckFramebufferStatusEXT", extFBO->glCheckFramebufferStatusEXT)
|| !FindProc ("glGenRenderbuffersEXT", extFBO->glGenRenderbuffersEXT)
|| !FindProc ("glDeleteRenderbuffersEXT", extFBO->glDeleteRenderbuffersEXT)
|| !FindProc ("glBindRenderbufferEXT", extFBO->glBindRenderbufferEXT)
|| !FindProc ("glRenderbufferStorageEXT", extFBO->glRenderbufferStorageEXT)
|| !FindProc ("glFramebufferRenderbufferEXT", extFBO->glFramebufferRenderbufferEXT))
{
delete extFBO;
extFBO = NULL;
}
}
}

61
src/OpenGl/OpenGl_Context.hxx Normal file
View File

@ -0,0 +1,61 @@
// File: OpenGl_Context.hxx
// Created: 26 January 2012
// Author: Kirill GAVRILOV
// Copyright: OPEN CASCADE 2012
#ifndef _OpenGl_Context_H__
#define _OpenGl_Context_H__
#include <OpenGl_ArbVBO.hxx>
#include <OpenGl_ExtFBO.hxx>
#include <Standard_Transient.hxx>
#include <Handle_OpenGl_Context.hxx>
#if (!defined(_WIN32) && !defined(__WIN32__))
extern "C" {
extern void (*glXGetProcAddress (const GLubyte* theProcName))();
}
#endif
//! This class provide access to the GL context and available extensions.
class OpenGl_Context : public Standard_Transient
{
public:
OpenGl_Context();
virtual ~OpenGl_Context();
//! Initialize available extensions.
//! GL context should be active!
void Init();
//! Parse theExtString string for presence of theExtName extension.
static Standard_Boolean CheckExtension (const char* theExtName,
const char* theExtString);
//! Auxiliary template to retrieve GL function pointer.
//! The context should be bound before call.
template <typename FuncType_t>
bool FindProc (const char* theFuncName,
FuncType_t& theFuncPtr)
{
#if (defined(_WIN32) || defined(__WIN32__))
theFuncPtr = (FuncType_t )wglGetProcAddress (theFuncName);
#else
theFuncPtr = (FuncType_t )glXGetProcAddress ((const GLubyte* )theFuncName);
#endif
return (theFuncPtr != NULL);
}
public:
OpenGl_ArbVBO* arbVBO;
OpenGl_ExtFBO* extFBO;
public:
DEFINE_STANDARD_RTTI(OpenGl_Window) // Type definition
};
#endif // _OpenGl_Context_H__

299
src/OpenGl/OpenGl_Display.cxx Normal file
View File

@ -0,0 +1,299 @@
// File: OpenGl_Display.cxx
// Created: 20 September 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_Display.hxx>
#include <OSD_Environment.hxx>
#include <TCollection_AsciiString.hxx>
#include <Aspect_GraphicDeviceDefinitionError.hxx>
#include <OpenGl_tgl_all.hxx>
#include <GL/gl.h>
#include <OpenGl_Light.hxx>
IMPLEMENT_STANDARD_HANDLE(OpenGl_Display,MMgt_TShared)
IMPLEMENT_STANDARD_RTTIEXT(OpenGl_Display,MMgt_TShared)
Handle(OpenGl_Display) openglDisplay;
namespace
{
#if (defined(_WIN32) || defined(__WIN32__))
static char* TheDummyDisplay = "DISPLAY";
#endif
static const OpenGl_Facilities myDefaultFacilities = { 1, 1, 1, 1, OpenGLMaxLights, 10000 };
};
/*----------------------------------------------------------------------*/
OpenGl_Display::OpenGl_Display (const Standard_CString theDisplay)
: myDisplay(NULL),
myFacilities(myDefaultFacilities),
myDBuffer(Standard_True),
myDither(Standard_True),
myBackDither(Standard_False),
myWalkthrough(Standard_False),
mySymPerspective(Standard_False),
myOffsetFactor(1.F),
myOffsetUnits(0.F),
myAntiAliasingMode(3),
myLinestyleBase(0),
myPatternBase(0),
myMarkerBase(0),
myFont(-1),
myFontSize(-1)
{
#if (defined(_WIN32) || defined(__WIN32__))
myDisplay = TheDummyDisplay;
#else
if (theDisplay != NULL && *theDisplay != '\0')
{
OSD_Environment aDispEnv ("DISPLAY", theDisplay);
aDispEnv.Build();
}
// Specifies the hardware display name, which determines the
// display and communications domain to be used.
// On a POSIX system, if the display_name is NULL, it defaults
// to the value of the DISPLAY environment variable.
myDisplay = XOpenDisplay (NULL);
#endif
Init();
}
/*----------------------------------------------------------------------*/
OpenGl_Display::OpenGl_Display (const Aspect_Display theDisplay)
: myDisplay(NULL),
myFacilities(myDefaultFacilities),
myDBuffer(Standard_True),
myDither(Standard_True),
myBackDither(Standard_False),
myWalkthrough(Standard_False),
mySymPerspective(Standard_False),
myOffsetFactor(1.F),
myOffsetUnits(0.F),
myAntiAliasingMode(3),
myLinestyleBase(0),
myPatternBase(0),
myMarkerBase(0),
myFont(-1),
myFontSize(-1)
{
#if (defined(_WIN32) || defined(__WIN32__))
myDisplay = TheDummyDisplay;
#else
myDisplay = theDisplay;
#endif
Init();
}
/*----------------------------------------------------------------------*/
OpenGl_Display::~OpenGl_Display ()
{
// Delete line styles
if (myLinestyleBase)
{
glDeleteLists((GLuint)myLinestyleBase,5);
myLinestyleBase = 0;
}
// Delete surface patterns
if (myPatternBase)
{
glDeleteLists((GLuint)myPatternBase,TEL_HS_USER_DEF_START);
myPatternBase = 0;
}
// Delete markers
if (myMarkerBase)
{
glDeleteLists((GLuint)myMarkerBase,60);
myMarkerBase = 0;
}
// Delete user markers
OpenGl_MapOfUserMarker::Iterator itm(myMapOfUM);
for (; itm.More(); itm.Next())
{
const OPENGL_MARKER_DATA &aData = itm.Value();
if (aData.Array)
{
delete[] aData.Array;
}
else if (aData.ListId != 0)
{
glDeleteLists ( aData.ListId, 1 );
}
}
myDisplay = NULL;
}
/*----------------------------------------------------------------------*/
Handle(OpenGl_Window) OpenGl_Display::GetWindow (const Aspect_Drawable AParent) const
{
Handle(OpenGl_Window) aWindow;
if ( myMapOfWindows.IsBound( AParent ) )
{
aWindow = myMapOfWindows.Find( AParent );
}
return aWindow;
}
/*----------------------------------------------------------------------*/
void OpenGl_Display::SetWindow (const Aspect_Drawable AParent, const Handle(OpenGl_Window) &AWindow)
{
if ( !myMapOfWindows.IsBound( AParent ) )
{
myMapOfWindows.Bind( AParent, AWindow );
}
}
/*----------------------------------------------------------------------*/
//GenerateMarkerBitmap
void OpenGl_Display::AddUserMarker (const Standard_Integer AIndex,
const Standard_Integer AMarkWidth,
const Standard_Integer AMarkHeight,
const Handle(TColStd_HArray1OfByte)& ATexture)
{
if (!myMapOfUM.IsBound(AIndex))
{
const OPENGL_MARKER_DATA anEmptyData = { 0, 0, 0, NULL };
myMapOfUM.Bind(AIndex,anEmptyData);
}
OPENGL_MARKER_DATA &aData = myMapOfUM.ChangeFind(AIndex);
if (aData.Array)
{
delete[] aData.Array;
aData.Array = NULL;
}
unsigned char *anArray = new unsigned char[ATexture->Length()];
const int aByteWidth = AMarkWidth / 8;
int i, anIndex = ATexture->Upper() - ATexture->Lower() - aByteWidth + 1;
for ( ; anIndex >= 0; anIndex -= aByteWidth )
for ( i = 0; i < aByteWidth; i++ )
anArray[ATexture->Upper() - ATexture->Lower() - aByteWidth + 1 - anIndex + i ] = ATexture->Value( anIndex + i + 1 );
aData.Width = AMarkWidth;
aData.Height = AMarkHeight;
aData.Array = anArray;
}
/*----------------------------------------------------------------------*/
void OpenGl_Display::UpdateUserMarkers ()
{
OpenGl_MapOfUserMarker::Iterator itm(myMapOfUM);
for (; itm.More(); itm.Next())
{
OPENGL_MARKER_DATA &aData = itm.ChangeValue();
if (aData.Array)
{
if (aData.ListId == 0)
aData.ListId = glGenLists(1);
glNewList( (GLuint)aData.ListId, GL_COMPILE );
GLint w = ( GLsizei ) aData.Width;
GLint h = ( GLsizei ) aData.Height;
glBitmap( w, h,
0.5F * ( float )aData.Width, 0.5F * ( float )aData.Height,
( float )30.0, ( float )30.0,
( GLubyte* )aData.Array );
glEndList();
delete[] aData.Array;
aData.Array = NULL;
}
}
}
/*----------------------------------------------------------------------*/
Standard_Integer OpenGl_Display::GetUserMarkerListIndex (const Standard_Integer AIndex) const
{
if (myMapOfUM.IsBound(AIndex))
{
const OPENGL_MARKER_DATA &aData = myMapOfUM.Find(AIndex);
if (!aData.Array)
return aData.ListId;
}
return -1;
}
/*----------------------------------------------------------------------*/
void OpenGl_Display::Init()
{
if (myDisplay != NULL)
{
#if (!defined(_WIN32) && !defined(__WIN32__))
XSynchronize ((Display* )myDisplay, (getenv("CALL_SYNCHRO_X") != NULL) ? 1 : 0);
if (getenv("CSF_GraphicSync") != NULL)
XSynchronize ((Display* )myDisplay, 1);
// does the server know about OpenGL & GLX?
int aDummy;
if (!XQueryExtension ((Display* )myDisplay, "GLX", &aDummy, &aDummy, &aDummy))
{
#ifdef DEBUG
std::cerr << "This system doesn't appear to support OpenGL\n";
#endif
}
#endif
}
else
{
TCollection_AsciiString msg("OpenGl_Display::Init");
#if (!defined(_WIN32) && !defined(__WIN32__))
msg += " : Cannot connect to X server ";
msg += XDisplayName ((char*) NULL);
#endif
Aspect_GraphicDeviceDefinitionError::Raise(msg.ToCString());
}
if (getenv("CALL_OPENGL_NO_DBF") != NULL)
myDBuffer = Standard_False;
if (getenv("CALL_OPENGL_NO_DITHER") != NULL)
myDither = Standard_False;
if (getenv("CALL_OPENGL_NO_BACKDITHER") != NULL)
myBackDither = Standard_False;
if (getenv("CSF_WALKTHROUGH") != NULL)
myWalkthrough = Standard_True;
/* OCC18942: Test if symmetric perspective projection should be turned on */
if (getenv("CSF_SYM_PERSPECTIVE") != NULL)
mySymPerspective = Standard_True;
const char* pvalue = getenv("CALL_OPENGL_POLYGON_OFFSET");
if (pvalue)
{
float v1, v2;
const int n = sscanf(pvalue, "%f %f", &v1, &v2);
if (n > 0) myOffsetFactor = v1;
if (n > 1) myOffsetUnits = v2;
}
pvalue = getenv("CALL_OPENGL_ANTIALIASING_MODE");
if (pvalue)
{
int v;
if ( sscanf(pvalue,"%d",&v) > 0 ) myAntiAliasingMode = v;
}
}

158
src/OpenGl/OpenGl_Display.hxx Normal file
View File

@ -0,0 +1,158 @@
// File: OpenGl_Display.hxx
// Created: 20 September 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _OpenGl_Display_Header
#define _OpenGl_Display_Header
#include <Handle_OpenGl_Display.hxx>
#include <MMgt_TShared.hxx>
#include <Standard_CString.hxx>
#include <TColStd_HArray1OfByte.hxx>
#include <NCollection_DataMap.hxx>
#include <Aspect_Display.hxx>
#include <Aspect_Drawable.hxx>
#include <Aspect_TypeOfLine.hxx>
#include <Aspect_TypeOfMarker.hxx>
#include <OSD_FontAspect.hxx>
#include <InterfaceGraphic_telem.hxx>
#include <Handle_OpenGl_Window.hxx>
struct OpenGl_Facilities
{
int AntiAliasing;
int DepthCueing;
int DoubleBuffer;
int ZBuffer;
int MaxLights;
int MaxViews;
};
struct OPENGL_MARKER_DATA
{
unsigned int ListId;
unsigned int Width;
unsigned int Height;
unsigned char* Array;
IMPLEMENT_MEMORY_OPERATORS
};
typedef NCollection_DataMap<int,OPENGL_MARKER_DATA> OpenGl_MapOfUserMarker;
class OpenGl_AspectText;
struct OpenGl_TextParam;
class OpenGl_Display : public MMgt_TShared
{
public:
OpenGl_Display (const Standard_CString ADisplay);
OpenGl_Display (const Aspect_Display ADisplay);
virtual ~OpenGl_Display ();
Aspect_Display GetDisplay () const { return myDisplay; }
Handle(OpenGl_Window) GetWindow (const Aspect_Drawable AParent) const;
void SetWindow (const Aspect_Drawable AParent, const Handle(OpenGl_Window) &AWindow);
const OpenGl_Facilities & Facilities () const { return myFacilities; }
Standard_Boolean DBuffer () const { return myDBuffer; }
Standard_Boolean Dither () const { return myDither; }
Standard_Boolean BackDither () const { return myBackDither; }
Standard_Boolean Walkthrough () const { return myWalkthrough; }
Standard_Boolean SymPerspective() const { return mySymPerspective; }
Standard_Boolean PolygonOffset (Standard_ShortReal &AFactor, Standard_ShortReal &AUnits) const
{
AFactor = myOffsetFactor;
AUnits = myOffsetUnits;
return Standard_True;
}
Standard_Integer AntiAliasingMode () const { return myAntiAliasingMode; }
// System attributes
void InitAttributes ();
const char * GetStringForMarker (const Aspect_TypeOfMarker AType, const Tfloat AVal) const;
void SetBaseForMarker () const;
void SetTypeOfLine (const Aspect_TypeOfLine AType) const;
void SetTypeOfHatch (const int AType) const;
// User markers
void AddUserMarker (const Standard_Integer AIndex,
const Standard_Integer AMarkWidth,
const Standard_Integer AMarkHeight,
const Handle(TColStd_HArray1OfByte)& ATexture);
void UpdateUserMarkers ();
Standard_Integer GetUserMarkerListIndex (const Standard_Integer AIndex) const;
// Fonts
int FindFont (const char* AFontName, const OSD_FontAspect AFontAspect, const int ABestSize = -1, const float AXScale = 1.F, const float AYScale = 1.F);
void StringSize (const wchar_t *text, int &width, int &ascent, int &descent);
void RenderText (const wchar_t *text, const int is2d, const float x, const float y, const float z, const OpenGl_AspectText *aspect, const OpenGl_TextParam *param);
friend class OpenGl_Window;
// Type definition
//
DEFINE_STANDARD_RTTI(OpenGl_Display)
protected:
void Init ();
void ExportText (const wchar_t *text, const int is2d, const float x, const float y, const float z, const OpenGl_AspectText *aspect, const OpenGl_TextParam *param, const float height);
#ifdef HAVE_GL2PS
static void getGL2PSFontName(const char *src_font, char *ps_font);
#endif
Aspect_Display myDisplay;
OpenGl_Facilities myFacilities;
Standard_Boolean myDBuffer;
Standard_Boolean myDither;
Standard_Boolean myBackDither;
Standard_Boolean myWalkthrough;
Standard_Boolean mySymPerspective;
Standard_ShortReal myOffsetFactor;
Standard_ShortReal myOffsetUnits;
Standard_Integer myAntiAliasingMode;
#if (defined(_WIN32) || defined(__WIN32__))
NCollection_DataMap<Aspect_Drawable, Handle(OpenGl_Window)> myMapOfWindows;
#else
NCollection_DataMap<Standard_Integer, Handle(OpenGl_Window)> myMapOfWindows;
#endif
unsigned int myLinestyleBase;
unsigned int myPatternBase;
unsigned int myMarkerBase;
OpenGl_MapOfUserMarker myMapOfUM;
Standard_Integer myFont;
Standard_Integer myFontSize;
public:
IMPLEMENT_MEMORY_OPERATORS
};
extern Handle(OpenGl_Display) openglDisplay;
#endif //OpenGl_Workspace_Header

378
src/OpenGl/OpenGl_Display_1.cxx Normal file
View File

@ -0,0 +1,378 @@
// File: OpenGl_Display_1.cxx
// Created: 25 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_Display.hxx>
#include <TCollection_AsciiString.hxx>
#include <TCollection_HAsciiString.hxx>
#include <OpenGl_FontMgr.hxx>
#include <OpenGl_AspectText.hxx>
#ifdef HAVE_GL2PS
#include <gl2ps.h>
#endif
/*-----------------------------------------------------------------------------*/
/*
* Prototypes variables statiques
*/
struct FontMapNode
{
const char * EnumName;
const char * FontName;
OSD_FontAspect FontAspect;
};
static const FontMapNode myFontMap[] =
{
#ifdef WNT
{ "Courier" , "Courier New" , OSD_FA_Regular },
{ "Times-Roman" , "Times New Roman", OSD_FA_Regular },
{ "Times-Bold" , "Times New Roman", OSD_FA_Bold },
{ "Times-Italic" , "Times New Roman", OSD_FA_Italic },
{ "Times-BoldItalic" , "Times New Roman", OSD_FA_BoldItalic },
{ "ZapfChancery-MediumItalic", "Script" , OSD_FA_Regular },
{ "Symbol" , "Symbol" , OSD_FA_Regular },
{ "ZapfDingbats" , "WingDings" , OSD_FA_Regular },
{ "Rock" , "Arial" , OSD_FA_Regular },
{ "Iris" , "Lucida Console" , OSD_FA_Regular }
#else //X11
{ "Courier" , "Courier" , OSD_FA_Regular },
{ "Times-Roman" , "Times" , OSD_FA_Regular },
{ "Times-Bold" , "Times" , OSD_FA_Bold },
{ "Times-Italic" , "Times" , OSD_FA_Italic },
{ "Times-BoldItalic" , "Times" , OSD_FA_BoldItalic },
{ "Arial" , "Helvetica" , OSD_FA_Regular },
{ "ZapfChancery-MediumItalic", "-adobe-itc zapf chancery-medium-i-normal--*-*-*-*-*-*-iso8859-1" , OSD_FA_Regular },
{ "Symbol" , "-adobe-symbol-medium-r-normal--*-*-*-*-*-*-adobe-fontspecific" , OSD_FA_Regular },
{ "ZapfDingbats" , "-adobe-itc zapf dingbats-medium-r-normal--*-*-*-*-*-*-adobe-fontspecific" , OSD_FA_Regular },
{ "Rock" , "-sgi-rock-medium-r-normal--*-*-*-*-p-*-iso8859-1" , OSD_FA_Regular },
{ "Iris" , "--iris-medium-r-normal--*-*-*-*-m-*-iso8859-1" , OSD_FA_Regular }
#endif
};
#define NUM_FONT_ENTRIES (sizeof(myFontMap)/sizeof(FontMapNode))
/*-----------------------------------------------------------------------------*/
/*
* Constants
*/
#ifdef HAVE_GL2PS
void OpenGl_Display::getGL2PSFontName (const char *src_font, char *ps_font)
{
/*
Convert font name used for rendering to some "good" font names
that produce good vector text
*/
static char const *family[] = {"Helvetica", "Courier", "Times"};
static char const *italic[] = {"Oblique", "Oblique", "Italic"};
static char const *base[] = {"", "", "-Roman"};
int font = 0;
int isBold = 0;
int isItalic = 0;
if( strstr( src_font, "Symbol" ) ){
sprintf( ps_font, "%s", "Symbol" );
return;
}
if( strstr( src_font, "ZapfDingbats" ) ){
sprintf( ps_font, "%s", "WingDings" );
return;
}
if ( strstr( src_font, "Courier" ) ){
font = 1;
}
else if ( strstr( src_font, "Times" ) ){
font = 2;
}
if ( strstr( src_font, "Bold" ) ){
isBold = 1;
}
if ( strstr( src_font, "Italic" ) || strstr( src_font, "Oblique" ) ){
isItalic = 1;
}
if ( isBold ){
sprintf( ps_font, "%s-%s", family[font], "Bold");
if ( isItalic ){
sprintf(ps_font, "%s%s", ps_font, italic[font]);
}
}
else if ( isItalic )
{
sprintf( ps_font, "%s-%s", family[font], italic[font] );
}
else
{
sprintf( ps_font, "%s%s", family[font], base[font] );
}
}
#endif
/*-----------------------------------------------------------------------------*/
/*
* Fonctions publiques
*/
/*-----------------------------------------------------------------------------*/
int OpenGl_Display::FindFont (const char* AFontName, const OSD_FontAspect AFontAspect,
const int ABestSize, const float AXScale, const float AYScale)
{
if (!AFontName)
return -1;
if (ABestSize != -1)
myFontSize = ABestSize;
OpenGl_FontMgr* mgr = OpenGl_FontMgr::instance();
Handle(TCollection_HAsciiString) family_name = new TCollection_HAsciiString(AFontName);
myFont = mgr->request_font( family_name, AFontAspect, myFontSize );
if( myFont == -1 )
{
//try to use font names mapping
FontMapNode newTempFont = myFontMap[0];
for ( int i = 0; i < NUM_FONT_ENTRIES; ++i )
{
if ( TCollection_AsciiString(myFontMap[i].EnumName).IsEqual( family_name->ToCString() ) )
{
newTempFont = myFontMap[i];
break;
}
}
family_name = new TCollection_HAsciiString(newTempFont.FontName);
myFont = mgr->request_font( family_name, newTempFont.FontAspect, myFontSize );
}
// Requested family name not found -> serach for any font family with given aspect and height
if ( myFont == -1 )
{
family_name = new TCollection_HAsciiString( "" );
myFont = mgr->request_font( family_name, AFontAspect, myFontSize );
}
// The last resort: trying to use ANY font available in the system
if ( myFont == -1 )
{
myFont = mgr->request_font( family_name, OSD_FA_Undefined, -1 );
}
if ( myFont != -1 )
mgr->setCurrentScale( AXScale, AYScale );
return myFont;
}
/*-----------------------------------------------------------------------------*/
void OpenGl_Display::StringSize (const wchar_t *str, int &width, int &ascent, int &descent)
{
ascent = 0;
descent = 0;
width = 0;
if (myFont != -1) {
OpenGl_FontMgr* mgr = OpenGl_FontMgr::instance();
const FTFont* font = mgr->fontById( myFont );
if ( font ) {
width = int( mgr->computeWidth( myFont, str ) );
ascent = int( font->Ascender() );
descent = int( font->Descender() );
}
}
}
/*-----------------------------------------------------------------------------*/
void OpenGl_Display::RenderText (const wchar_t* str, const int is2d, const float x, const float y, const float z,
const OpenGl_AspectText *aspect, const OpenGl_TextParam *param)
{
OpenGl_FontMgr* mgr = OpenGl_FontMgr::instance();
const FTFont* fnt = mgr->fontById( myFont );
if ( !fnt )
return;
// FTFont changes texture state when it renders and computes size for the text
glPushAttrib(GL_TEXTURE_BIT);
int widthFont, ascentFont, descentFont;
StringSize( str, widthFont, ascentFont, descentFont );
GLdouble xdis = 0.;
switch (param->HAlign)
{
case Graphic3d_HTA_CENTER:
xdis = -0.5 * (GLdouble)widthFont;
break;
case Graphic3d_HTA_RIGHT:
xdis = -(GLdouble)widthFont;
break;
//case Graphic3d_HTA_LEFT:
//default: break;
}
GLdouble ydis = 0.;
switch (param->VAlign)
{
case Graphic3d_VTA_CENTER:
ydis = -0.5 * (GLdouble)ascentFont - descentFont;
break;
case Graphic3d_VTA_TOP:
ydis = -(GLdouble)ascentFont - descentFont;
break;
//case Graphic3d_VTA_BOTTOM:
//default: break;
}
float export_h = 1.;
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
if (is2d)
{
glLoadIdentity();
glTranslatef(x, y, 0.f);
glRotatef( 180, 1, 0, 0 );
}
else
{
const GLdouble identityMatrix[4][4] =
{
{1.,0.,0.,0.},
{0.,1.,0.,0.},
{0.,0.,1.,0.},
{0.,0.,0.,1.}
};
GLdouble projMatrix[4][4], modelMatrix[4][4];
GLint viewport[4];
GLdouble wx, wy, wz;
GLdouble x1, y1, z1;
GLdouble x2, y2, z2;
glGetDoublev( GL_MODELVIEW_MATRIX, (GLdouble*)modelMatrix );
glGetDoublev( GL_PROJECTION_MATRIX, (GLdouble*)projMatrix );
glGetIntegerv( GL_VIEWPORT, (GLint*)viewport );
gluProject( x, y, z,
(GLdouble*)modelMatrix,
(GLdouble*)projMatrix,
(GLint*)viewport,
&wx, &wy, &wz );
glLoadIdentity();
gluUnProject( wx, wy, wz,
(GLdouble*)identityMatrix, (GLdouble*)projMatrix, (GLint*)viewport,
&x1, &y1 , &z1 );
GLdouble h = (GLdouble)fnt->FaceSize();
gluUnProject( wx, wy + h - 1., wz,
(GLdouble*)identityMatrix, (GLdouble*)projMatrix, (GLint*)viewport,
&x2, &y2, &z2 );
h = (y2-y1)/h;
glTranslated( x1, y1 , z1 );
glRotated(aspect->Angle(), 0, 0, 1);
glTranslated(xdis, ydis, 0);
if( !aspect->IsZoomable() )
{
glScaled( h, h, h );
}
else
{
export_h = (float )h;
}
}
GLint renderMode;
glGetIntegerv(GL_RENDER_MODE, &renderMode);
if ( renderMode == GL_FEEDBACK )
{
#ifdef HAVE_GL2PS
export_h = (GLdouble)fnt->FaceSize() / export_h;
glPopMatrix();
ExportText( str, is2d, x, y, z, aspect, param, export_h );
#endif
}
else
{
mgr->render_text( myFont, str, is2d );
glPopMatrix();
}
glPopAttrib();
}
/*-----------------------------------------------------------------------------*/
static const int alignmentforgl2ps[3][3] = { {5,2,8}, {4,1,7}, {6,3,9} };
void OpenGl_Display::ExportText (const wchar_t* text, const int is2d, const float x, const float y, const float z,
const OpenGl_AspectText *aspect, const OpenGl_TextParam *param, const float height)
{
#ifdef HAVE_GL2PS
int vh = 1;
switch (param->HAlign)
{
case Graphic3d_HTA_CENTER: vh = 2; break;
case Graphic3d_HTA_RIGHT: vh = 3; break;
//case Graphic3d_HTA_LEFT:
//default: break;
}
int vv = 1;
switch (param->VAlign)
{
case Graphic3d_VTA_CENTER: vv = 2; break;
case Graphic3d_VTA_TOP: vv = 3; break;
//case Graphic3d_VTA_BOTTOM:
//default: break;
}
const int alignment = alignmentforgl2ps[vh-1][vv-1];
const char* fontname = aspect->Font();
float angle = aspect->Angle();
GLubyte zero = 0;
char ps_font[64];
getGL2PSFontName(fontname, ps_font);
if( is2d )
glRasterPos2f( x, y );
else
glRasterPos3f( x, y, z );
glBitmap( 1, 1, 0, 0, 0, 0, &zero );
//szv: workaround for gl2ps!
const int len = 4 * (wcslen(text) + 1); //szv: should be more than enough
char *astr = new char[len];
wcstombs(astr,text,len);
gl2psTextOpt(astr, ps_font, height, alignment, angle);
delete[] astr;
#endif
}

1949
src/OpenGl/OpenGl_Display_2.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

23
src/OpenGl/OpenGl_Element.hxx Normal file
View File

@ -0,0 +1,23 @@
// File: OpenGl_Element.hxx
// Created: 5 August 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef OpenGl_Element_Header
#define OpenGl_Element_Header
#include <OpenGl_Workspace.hxx>
class OpenGl_Element
{
public:
OpenGl_Element () {}
virtual ~OpenGl_Element () {}
virtual void Render (const Handle(OpenGl_Workspace) &AWorkspace) const = 0;
public:
IMPLEMENT_MEMORY_OPERATORS
};
#endif //OpenGl_Element_Header

68
src/OpenGl/OpenGl_ExtFBO.hxx Normal file
View File

@ -0,0 +1,68 @@
// File: OpenGl_ExtVBO.hxx
// Created: 26 January 2012
// Author: Kirill GAVRILOV
// Copyright: OPEN CASCADE 2012
#ifndef _OpenGl_ExtFBO_H__
#define _OpenGl_ExtFBO_H__
#if (defined(_WIN32) || defined(__WIN32__))
#include <windows.h>
#endif
#include <GL/gl.h>
//! FBO is part of OpenGL since 2.0
struct OpenGl_ExtFBO
{
#ifndef GL_FRAMEBUFFER_EXT
#define GL_FRAMEBUFFER_EXT 0x8D40
#endif
#ifndef GL_COLOR_ATTACHMENT0_EXT
#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0
#endif
#ifndef GL_FRAMEBUFFER_COMPLETE_EXT
#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5
#endif
#ifndef GL_RENDERBUFFER_EXT
#define GL_RENDERBUFFER_EXT 0x8D41
#endif
#ifndef GL_DEPTH_ATTACHMENT_EXT
#define GL_DEPTH_ATTACHMENT_EXT 0x8D00
#endif
public:
typedef void (APIENTRY *glGenFramebuffersEXT_t) (GLsizei n, GLuint* ids);
typedef void (APIENTRY *glDeleteFramebuffersEXT_t) (GLsizei n, GLuint* ids);
typedef void (APIENTRY *glBindFramebufferEXT_t) (GLenum target, GLuint id);
typedef void (APIENTRY *glFramebufferTexture2DEXT_t) (GLenum target, GLenum attachmentPoint,
GLenum textureTarget, GLuint textureId,
GLint level);
typedef GLenum (APIENTRY *glCheckFramebufferStatusEXT_t) (GLenum target);
typedef void (APIENTRY *glGenRenderbuffersEXT_t) (GLsizei n, GLuint* ids);
typedef void (APIENTRY *glDeleteRenderbuffersEXT_t) (GLsizei n, GLuint* ids);
typedef void (APIENTRY *glBindRenderbufferEXT_t) (GLenum target, GLuint id);
typedef void (APIENTRY *glRenderbufferStorageEXT_t) (GLenum target, GLenum internalFormat,
GLsizei width, GLsizei height);
typedef void (APIENTRY *glFramebufferRenderbufferEXT_t) (GLenum target,
GLenum attachmentPoint,
GLenum renderbufferTarget,
GLuint renderbufferId);
public:
glGenFramebuffersEXT_t glGenFramebuffersEXT;
glDeleteFramebuffersEXT_t glDeleteFramebuffersEXT;
glBindFramebufferEXT_t glBindFramebufferEXT;
glFramebufferTexture2DEXT_t glFramebufferTexture2DEXT;
glCheckFramebufferStatusEXT_t glCheckFramebufferStatusEXT;
glGenRenderbuffersEXT_t glGenRenderbuffersEXT;
glDeleteRenderbuffersEXT_t glDeleteRenderbuffersEXT;
glBindRenderbufferEXT_t glBindRenderbufferEXT;
glRenderbufferStorageEXT_t glRenderbufferStorageEXT;
glFramebufferRenderbufferEXT_t glFramebufferRenderbufferEXT;
};
#endif // _OpenGl_ExtFBO_H__

231
src/OpenGl/OpenGl_Extension.cxx
View File

@ -1,231 +0,0 @@
/*
* Fonction
* ~~~~~~~~
* Gestion des extensions sous OpenGL
*
*
* Attention:
* ~~~~~~~~~~~
* Ce package a ete teste sur SGI, OSF, SUN, HP et WNT.
*
* Remarques:
* ~~~~~~~~~~~
* Le InitExtensionGLX permet d'initialiser le display. Ceci est necessaire
* pour travailler sur les extensions de GLX. On ne peut appeler QueryExtensionGLX
* si on n'a pas fait cette manip.
* Par contre QueryExtension gere les extensions a GL, on n'a pas besoin du
* Display.
*
* Pour l'instant on ne gere pas les extensions a GLU et a WGL.
*
* Historique des modifications
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* 14-10-97: FMN ; creation
* 23-10-97: FMN ; ajout gestion glx
* 04-11-97: FMN ; Gestion des differentes versions GLX
* 19-11-97: FMN ; Ajout GetCurrentDisplay
* 04-12-97: FMN ; Ajout supportsOneDotOne
* 22-07-98: FMN ; InitExtensionGLX n'est execute qu'une fois
* 28-07-98: FMN ; Renomme theDisplay en mytheDisplay
*/
/*----------------------------------------------------------------------*/
/*----------------------------------------------------------------------*/
/*
* Includes
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <OpenGl_Extension.hxx>
#define XDEBUG
/*----------------------------------------------------------------------*/
/*
* Types definis
*/
/*----------------------------------------------------------------------*/
/*
* Variables statiques
*/
static Display *mytheDisplay = NULL;
static int screen_num;
static int GLXmajor, GLXminor;
static int GLmajor, GLminor;
static GLboolean flag_InitExtensionGLX = GL_FALSE;
static GLboolean OneDotOne = GL_FALSE;
static GLboolean initOneDotOne = GL_FALSE;
/*----------------------------------------------------------------------*/
/*
* Fonctions publiques
*/
/*----------------------------------------------------------------------*/
extern GLboolean CheckExtension(char *extName, const char *extString)
{
/*
** Search for extName in the extensions string. Use of strstr()
** is not sufficient because extension names can be prefixes of
** other extension names. Could use strtok() but the constant
** string returned by glGetString can be in read-only memory.
*/
char *p = (char *)extString;
char *end;
int extNameLen;
extNameLen = strlen(extName);
end = p + strlen(p);
while (p < end) {
int n = strcspn(p, " ");
if ((extNameLen == n) && (strncmp(extName, p, n) == 0)) {
return GL_TRUE;
}
p += (n + 1);
}
return GL_FALSE;
}
extern GLboolean InitExtensionGLX(Display *display)
{
#ifndef WNT
int dontcare; /* for returned arguments we don't care about */
if (display == NULL) return GL_FALSE;
if (!flag_InitExtensionGLX)
{
/* does the server know about OpenGL & GLX? */
if(!XQueryExtension(display, "GLX", &dontcare, &dontcare, &dontcare)) {
#ifdef DEBUG
fprintf(stderr,"This system doesn't appear to support OpenGL\n");
#endif /* DEBUG */
return GL_FALSE;
}
/* find the glx version */
if(glXQueryVersion(display, &GLXmajor, &GLXminor)) {
#ifdef DEBUG
printf("GLX Version: %d.%d\n", GLXmajor, GLXminor);
#endif /* DEBUG */
} else {
#ifdef DEBUG
fprintf(stderr, "Error: glXQueryVersion() failed.\n");
#endif /* DEBUG */
return GL_FALSE;
}
/* get screen number */
screen_num = DefaultScreen(display);
flag_InitExtensionGLX = GL_TRUE;
mytheDisplay = display;
} /* (!flag_InitExtensionGLX) */
return GL_TRUE;
#else
return GL_FALSE;
#endif /* WNT */
}
/*----------------------------------------------------------------------*/
extern GLboolean QueryExtensionGLX(char *extName)
{
GLboolean result = GL_FALSE;
#ifdef GLX_VERSION_1_1
if (flag_InitExtensionGLX)
{
if ( GLXminor > 1 || GLXmajor > 1 ) /* GLX_VERSION_1_2 */
{
/* Certaines extensions sont par defaut dans la version 1.2 */
if (strcmp(extName,"GLX_EXT_import_context")) return GL_TRUE;
result = CheckExtension(extName, glXQueryExtensionsString(mytheDisplay, screen_num));
}
else if( GLXminor > 0 || GLXmajor > 1 ) /* GLX_VERSION_1_1 */
{
result = CheckExtension(extName, glXQueryExtensionsString(mytheDisplay, screen_num));
}
}
#endif
#ifdef DEBUG
printf("QueryExtensionGLX: %s %d", extName, result);
#endif
return result;
}
/*----------------------------------------------------------------------*/
extern Display *GetCurrentDisplay(void)
{
#ifdef DEBUG
printf("GetCurrentDisplay %x \n", mytheDisplay);
#endif
return mytheDisplay;
}
/*----------------------------------------------------------------------*/
extern GLboolean QueryExtension(char *extName)
{
GLboolean result = GL_FALSE;
if (supportsOneDotOne()) /* GL_VERSION_1_1 ou more */
{
/* Certaines extensions sont par defaut dans la version 1.1 */
/* Certain extensions are the defaut in version 1.1 */
if ((strcmp(extName,"GL_EXT_vertex_array")) ||
(strcmp(extName,"GL_EXT_polygon_offset")) ||
(strcmp(extName,"GL_EXT_blend_logic_op")) ||
(strcmp(extName,"GL_EXT_texture")) ||
(strcmp(extName,"GL_EXT_copy_texture")) ||
(strcmp(extName,"GL_EXT_subtexture")) ||
(strcmp(extName,"GL_EXT_texture_object")))
result = GL_TRUE;
else
result = CheckExtension(extName, (char *)glGetString(GL_EXTENSIONS));
}
else /* GL_VERSION_1_0 */
{
result = CheckExtension(extName, (char *)glGetString(GL_EXTENSIONS));
}
#ifdef DEBUG
printf("QueryExtension: %s %d \n", extName, result);
#endif
return result;
}
/*----------------------------------------------------------------------*/
extern GLboolean supportsOneDotOne(void)
{
const GLubyte *version;
if (!initOneDotOne)
{
version = glGetString(GL_VERSION);
if(sscanf((const char *)version, "%d.%d", &GLmajor, &GLminor) == 2)
{
OneDotOne = (GLmajor>=1 && GLminor >=1);
}
initOneDotOne = GL_TRUE;
}
#ifdef DEBUG
printf("GL Version: %d.%d\n", GLmajor, GLminor);
#endif /* DEBUG */
return OneDotOne;
}
/*----------------------------------------------------------------------*/

140
src/OpenGl/OpenGl_Extension.hxx
View File

@ -1,140 +0,0 @@
/*
* Fonction
* ~~~~~~~~
* Gestion des extensions sous OpenGL
*
*
* Attention:
* ~~~~~~~~~~~
* Ce package a ete teste sur SGI, OSF, SUN, HP et WNT.
*
* Remarques:
* ~~~~~~~~~~~
* Le InitExtensionGLX permet d'initialiser le display. Ceci est necessaire
* pour travailler sur les extensions de GLX. On ne peut appeler QueryExtensionGLX
* si on n'a pas fait cette manip.
* Par contre QueryExtension gere les extensions a GL, on n'a pas besoin du
* Display.
*
* Pour l'instant on ne gere pas les extensions a GLU et a WGL.
*
* Historique des modifications
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* 14-10-97: FMN ; Creation
* 23-10-97: FMN ; Ajout gestion glx
* 19-11-97: FMN ; Ajout GetCurrentDisplay
* 04-12-97: FMN ; Ajout supportsOneDotOne
* 19-06-98: FMN ; Portage Optimizer (C++)
*/
/*----------------------------------------------------------------------*/
#ifndef _OPENGL_EXTENSION_H__
#define _OPENGL_EXTENSION_H__
/*----------------------------------------------------------------------*/
/*
* Includes
*/
#if defined(WNT) && !defined(HAVE_NO_DLL)
# ifdef __OpenGl_DLL
# define EXPORT __declspec(dllexport)
# else
# define EXPORT
# endif /* DLL */
# ifdef STRICT
# undef STRICT
# endif
# define STRICT
# include <windows.h>
#else
# define EXPORT
#endif /* WNT */
#include <GL/gl.h>
#include <GL/glu.h>
#ifdef WNT
# include <windows.h>
# ifndef Display
# define Display char
# endif /* Display */
#else
# include <GL/glx.h>
#endif /* WNT */
#ifdef GL_VERSION_1_1
#define GL_EXT_vertex_array 1
#define GL_EXT_polygon_offset 1
#define GL_EXT_blend_logic_op 1
#define GL_EXT_texture 1
#define GL_EXT_copy_texture 1
#define GL_EXT_subtexture 1
#define GL_EXT_texture_object 1
#endif /* GL_VERSION_1_1 */
#ifndef GLU_VERSION_1_2
#define GLUtesselator GLUtriangulatorObj
#define GLU_TESS_BEGIN 100100
#define GLU_TESS_VERTEX 100101
#define GLU_TESS_END 100102
#define GLU_TESS_ERROR 100103
#define GLU_TESS_COMBINE 100105
#endif
#define INVALID_EXT_FUNCTION_PTR 0xffffffff
/*
* Contournement temporaire glPolygoneOffsetEXT
* La syntaxe change entre OpenGL 1.0 et OpenGL 1.1
*/
#if defined (__sun) || defined (__osf__) || defined (__hp)
#define glPolygonOffsetEXT(a, b) glPolygonOffset(a, b)
#endif
#if defined (__sun)
#define GL_POLYGON_OFFSET_EXT GL_POLYGON_OFFSET_FILL
#endif
#ifdef WNT
#define glPolygonOffsetEXT(a, b) glPolygonOffset(a, b)
#define GL_POLYGON_OFFSET_EXT GL_POLYGON_OFFSET_FILL
#endif /* WNT */
#if defined (__sun) || defined (__osf__) || defined (__hp) || defined (__sgi)
#else
typedef void (APIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode);
#endif
/*----------------------------------------------------------------------*/
/*
* Prototypes
*/
/*
* Points d'entree Public du module
*/
extern GLboolean InitExtensionGLX(Display *display);
extern GLboolean QueryExtensionGLX(char *extName);
extern GLboolean QueryExtension(char *extName);
extern Display *GetCurrentDisplay(void);
extern GLboolean supportsOneDotOne(void);
extern GLboolean CheckExtension(char *extName, const char *extString);
/* Methods defined in OpenGl_GraphicDriver.cxx */
EXPORT GLboolean OpenGl_QueryExtensionGLX (const char *extName);
EXPORT GLboolean OpenGl_QueryExtension (const char *extName);
/*----------------------------------------------------------------------*/
#endif /* _OPENGL_EXTENSION_H__ */

124
src/OpenGl/OpenGl_FrameBuffer.cxx
View File

@ -1,15 +1,13 @@
// File: OpenGl_FrameBuffer.cxx
// Author: Kirill GAVRILOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_FrameBuffer.hxx> #include <OpenGl_FrameBuffer.hxx>
#ifdef DEB #ifdef DEB
#include <iostream> #include <iostream>
#endif #endif
#ifndef WNT
#define glGetProcAddress( x ) glXGetProcAddress( (const GLubyte*) x )
#else
#define glGetProcAddress( x ) wglGetProcAddress( x )
#endif
static inline bool isOddNumber (const GLsizei theNumber) static inline bool isOddNumber (const GLsizei theNumber)
{ {
return theNumber & 0x01; return theNumber & 0x01;
@ -39,43 +37,6 @@ static inline GLsizei getPowerOfTwo (const GLsizei theNumber,
return theThreshold; return theThreshold;
} }
Standard_Boolean OpenGl_FrameBuffer::AreFBOFunctionsValid()
{
return glGenFramebuffersEXT != NULL
&& glDeleteFramebuffersEXT != NULL
&& glBindFramebufferEXT != NULL
&& glFramebufferTexture2DEXT != NULL
&& glCheckFramebufferStatusEXT != NULL
&& glGenRenderbuffersEXT != NULL
&& glBindRenderbufferEXT != NULL
&& glDeleteRenderbuffersEXT != NULL
&& glRenderbufferStorageEXT != NULL
&& glFramebufferRenderbufferEXT != NULL;
}
Standard_Boolean OpenGl_FrameBuffer::InitFBOFunctions()
{
if (AreFBOFunctionsValid())
{
return Standard_True;
}
if (CheckExtension ((char *)"GL_EXT_framebuffer_object", (const char *)glGetString (GL_EXTENSIONS)))
{
glGenFramebuffersEXT = (glGenFramebuffersEXT_t) glGetProcAddress ("glGenFramebuffersEXT");
glDeleteFramebuffersEXT = (glDeleteFramebuffersEXT_t) glGetProcAddress ("glDeleteFramebuffersEXT");
glBindFramebufferEXT = (glBindFramebufferEXT_t) glGetProcAddress ("glBindFramebufferEXT");
glFramebufferTexture2DEXT = (glFramebufferTexture2DEXT_t) glGetProcAddress ("glFramebufferTexture2DEXT");
glCheckFramebufferStatusEXT = (glCheckFramebufferStatusEXT_t) glGetProcAddress ("glCheckFramebufferStatusEXT");
glGenRenderbuffersEXT = (glGenRenderbuffersEXT_t) glGetProcAddress ("glGenRenderbuffersEXT");
glDeleteRenderbuffersEXT = (glDeleteRenderbuffersEXT_t) glGetProcAddress ("glDeleteRenderbuffersEXT");
glBindRenderbufferEXT = (glBindRenderbufferEXT_t) glGetProcAddress ("glBindRenderbufferEXT");
glRenderbufferStorageEXT = (glRenderbufferStorageEXT_t) glGetProcAddress ("glRenderbufferStorageEXT");
glFramebufferRenderbufferEXT = (glFramebufferRenderbufferEXT_t)glGetProcAddress ("glFramebufferRenderbufferEXT");
return AreFBOFunctionsValid();
}
return Standard_False;
}
OpenGl_FrameBuffer::OpenGl_FrameBuffer (GLint theTextureFormat) OpenGl_FrameBuffer::OpenGl_FrameBuffer (GLint theTextureFormat)
: mySizeX (0), : mySizeX (0),
mySizeY (0), mySizeY (0),
@ -84,26 +45,17 @@ OpenGl_FrameBuffer::OpenGl_FrameBuffer (GLint theTextureFormat)
myTextFormat (theTextureFormat), myTextFormat (theTextureFormat),
myGlTextureId (NO_TEXTURE), myGlTextureId (NO_TEXTURE),
myGlFBufferId (NO_FRAMEBUFFER), myGlFBufferId (NO_FRAMEBUFFER),
myGlDepthRBId (NO_RENDERBUFFER), myGlDepthRBId (NO_RENDERBUFFER)
glGenFramebuffersEXT (NULL),
glDeleteFramebuffersEXT (NULL),
glBindFramebufferEXT (NULL),
glFramebufferTexture2DEXT (NULL),
glCheckFramebufferStatusEXT (NULL),
glGenRenderbuffersEXT (NULL),
glDeleteRenderbuffersEXT (NULL),
glBindRenderbufferEXT (NULL),
glRenderbufferStorageEXT (NULL),
glFramebufferRenderbufferEXT (NULL)
{ {
// //
} }
Standard_Boolean OpenGl_FrameBuffer::Init (GLsizei theViewportSizeX, Standard_Boolean OpenGl_FrameBuffer::Init (const Handle(OpenGl_Context)& theGlContext,
GLsizei theViewportSizeX,
GLsizei theViewportSizeY, GLsizei theViewportSizeY,
GLboolean toForcePowerOfTwo) GLboolean toForcePowerOfTwo)
{ {
if (!InitFBOFunctions()) if (theGlContext->extFBO == NULL)
{ {
#ifdef DEB #ifdef DEB
std::cerr << "OpenGl_FrameBuffer, FBO extension not supported!\n"; std::cerr << "OpenGl_FrameBuffer, FBO extension not supported!\n";
@ -112,7 +64,7 @@ Standard_Boolean OpenGl_FrameBuffer::Init (GLsizei theViewportSizeX,
} }
// clean up previous state // clean up previous state
Release(); Release (theGlContext);
// upscale width/height if numbers are odd // upscale width/height if numbers are odd
if (toForcePowerOfTwo) if (toForcePowerOfTwo)
@ -133,41 +85,41 @@ Standard_Boolean OpenGl_FrameBuffer::Init (GLsizei theViewportSizeX,
myVPSizeY = theViewportSizeY; myVPSizeY = theViewportSizeY;
// Create the texture (will be used as color buffer) // Create the texture (will be used as color buffer)
if (!InitTrashTexture()) if (!InitTrashTexture (theGlContext))
{ {
if (!isPowerOfTwo (mySizeX) || !isPowerOfTwo (mySizeY)) if (!isPowerOfTwo (mySizeX) || !isPowerOfTwo (mySizeY))
{ {
return Init (theViewportSizeX, theViewportSizeY, GL_TRUE); return Init (theGlContext, theViewportSizeX, theViewportSizeY, GL_TRUE);
} }
Release(); Release (theGlContext);
return Standard_False; return Standard_False;
} }
// Create RenderBuffer (will be used as depth buffer) // Create RenderBuffer (will be used as depth buffer)
glGenRenderbuffersEXT (1, &myGlDepthRBId); theGlContext->extFBO->glGenRenderbuffersEXT (1, &myGlDepthRBId);
glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, myGlDepthRBId); theGlContext->extFBO->glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, myGlDepthRBId);
glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, mySizeX, mySizeY); theGlContext->extFBO->glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, mySizeX, mySizeY);
// Build FBO and setup it as texture // Build FBO and setup it as texture
glGenFramebuffersEXT (1, &myGlFBufferId); theGlContext->extFBO->glGenFramebuffersEXT (1, &myGlFBufferId);
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, myGlFBufferId); theGlContext->extFBO->glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, myGlFBufferId);
glEnable (GL_TEXTURE_2D); glEnable (GL_TEXTURE_2D);
glBindTexture (GL_TEXTURE_2D, myGlTextureId); glBindTexture (GL_TEXTURE_2D, myGlTextureId);
glFramebufferTexture2DEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, myGlTextureId, 0); theGlContext->extFBO->glFramebufferTexture2DEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, myGlTextureId, 0);
glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, myGlFBufferId); theGlContext->extFBO->glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, myGlFBufferId);
if (glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT) if (theGlContext->extFBO->glCheckFramebufferStatusEXT (GL_FRAMEBUFFER_EXT) != GL_FRAMEBUFFER_COMPLETE_EXT)
{ {
if (!isPowerOfTwo (mySizeX) || !isPowerOfTwo (mySizeY)) if (!isPowerOfTwo (mySizeX) || !isPowerOfTwo (mySizeY))
{ {
return Init (theViewportSizeX, theViewportSizeY, GL_TRUE); return Init (theGlContext, theViewportSizeX, theViewportSizeY, GL_TRUE);
} }
Release(); Release (theGlContext);
return Standard_False; return Standard_False;
} }
UnbindBuffer(); UnbindBuffer (theGlContext);
UnbindTexture(); UnbindTexture();
glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, NO_RENDERBUFFER); theGlContext->extFBO->glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, NO_RENDERBUFFER);
#ifdef DEB #ifdef DEB
std::cerr << "OpenGl_FrameBuffer, created FBO " << mySizeX << "x" << mySizeY std::cerr << "OpenGl_FrameBuffer, created FBO " << mySizeX << "x" << mySizeY
@ -176,12 +128,19 @@ Standard_Boolean OpenGl_FrameBuffer::Init (GLsizei theViewportSizeX,
return Standard_True; return Standard_True;
} }
void OpenGl_FrameBuffer::Release() void OpenGl_FrameBuffer::Release (const Handle(OpenGl_Context)& theGlContext)
{ {
if (IsValidDepthBuffer()) if (IsValidDepthBuffer())
{ {
glDeleteRenderbuffersEXT (1, &myGlDepthRBId); if (!theGlContext.IsNull() && theGlContext->extFBO != NULL)
myGlDepthRBId = NO_RENDERBUFFER; {
theGlContext->extFBO->glDeleteRenderbuffersEXT (1, &myGlDepthRBId);
myGlDepthRBId = NO_RENDERBUFFER;
}
else
{
std::cerr << "OpenGl_FrameBuffer::Release() called with invalid OpenGl_Context!\n";
}
} }
if (IsValidTexture()) if (IsValidTexture())
{ {
@ -191,8 +150,15 @@ void OpenGl_FrameBuffer::Release()
mySizeX = mySizeY = myVPSizeX = myVPSizeY = 0; mySizeX = mySizeY = myVPSizeX = myVPSizeY = 0;
if (IsValidFrameBuffer()) if (IsValidFrameBuffer())
{ {
glDeleteFramebuffersEXT (1, &myGlFBufferId); if (!theGlContext.IsNull() && theGlContext->extFBO != NULL)
myGlFBufferId = NO_FRAMEBUFFER; {
theGlContext->extFBO->glDeleteFramebuffersEXT (1, &myGlFBufferId);
myGlFBufferId = NO_FRAMEBUFFER;
}
else
{
std::cerr << "OpenGl_FrameBuffer::Release() called with invalid OpenGl_Context!\n";
}
} }
} }
@ -210,7 +176,7 @@ Standard_Boolean OpenGl_FrameBuffer::IsProxySuccess() const
return aTestParamX != 0 && aTestParamY != 0; return aTestParamX != 0 && aTestParamY != 0;
} }
Standard_Boolean OpenGl_FrameBuffer::InitTrashTexture() Standard_Boolean OpenGl_FrameBuffer::InitTrashTexture (const Handle(OpenGl_Context)& theGlContext)
{ {
// Check texture size is fit dimension maximum // Check texture size is fit dimension maximum
GLint aMaxTexDim = 2048; GLint aMaxTexDim = 2048;
@ -234,7 +200,7 @@ Standard_Boolean OpenGl_FrameBuffer::InitTrashTexture()
if (!IsProxySuccess()) if (!IsProxySuccess())
{ {
Release(); Release (theGlContext);
return Standard_False; return Standard_False;
} }

84
src/OpenGl/OpenGl_FrameBuffer.hxx
View File

@ -1,37 +1,15 @@
// File: OpenGl_FrameBuffer.hxx
// Author: Kirill GAVRILOV
// Copyright: OPEN CASCADE 2011
#ifndef OPENGL_FRAME_BUFFER_H #ifndef OPENGL_FRAME_BUFFER_H
#define OPENGL_FRAME_BUFFER_H #define OPENGL_FRAME_BUFFER_H
#include <OpenGl_Extension.hxx> #include <OpenGl_Context.hxx>
#include <Standard_Boolean.hxx> #include <Standard_Boolean.hxx>
#include <InterfaceGraphic.hxx> #include <InterfaceGraphic.hxx>
#ifndef GL_FRAMEBUFFER_EXT
#define GL_FRAMEBUFFER_EXT 0x8D40
#endif
#ifndef GL_COLOR_ATTACHMENT0_EXT
#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0
#endif
#ifndef GL_FRAMEBUFFER_COMPLETE_EXT
#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5
#endif
#ifndef GL_RENDERBUFFER_EXT
#define GL_RENDERBUFFER_EXT 0x8D41
#endif
#ifndef GL_DEPTH_ATTACHMENT_EXT
#define GL_DEPTH_ATTACHMENT_EXT 0x8D00
#endif
#ifdef WNT
#define GL_API_ENTRY APIENTRY
#else
#define GL_API_ENTRY
#endif
class OpenGl_FrameBuffer class OpenGl_FrameBuffer
{ {
@ -42,33 +20,13 @@ public:
static const GLuint NO_FRAMEBUFFER = 0; static const GLuint NO_FRAMEBUFFER = 0;
static const GLuint NO_RENDERBUFFER = 0; static const GLuint NO_RENDERBUFFER = 0;
public:
typedef void (GL_API_ENTRY *glGenFramebuffersEXT_t) (GLsizei n, GLuint* ids);
typedef void (GL_API_ENTRY *glDeleteFramebuffersEXT_t) (GLsizei n, GLuint* ids);
typedef void (GL_API_ENTRY *glBindFramebufferEXT_t) (GLenum target, GLuint id);
typedef void (GL_API_ENTRY *glFramebufferTexture2DEXT_t) (GLenum target, GLenum attachmentPoint,
GLenum textureTarget, GLuint textureId,
GLint level);
typedef GLenum (GL_API_ENTRY *glCheckFramebufferStatusEXT_t) (GLenum target);
typedef void (GL_API_ENTRY *glGenRenderbuffersEXT_t) (GLsizei n, GLuint* ids);
typedef void (GL_API_ENTRY *glDeleteRenderbuffersEXT_t) (GLsizei n, GLuint* ids);
typedef void (GL_API_ENTRY *glBindRenderbufferEXT_t) (GLenum target, GLuint id);
typedef void (GL_API_ENTRY *glRenderbufferStorageEXT_t) (GLenum target, GLenum internalFormat,
GLsizei width, GLsizei height);
typedef void (GL_API_ENTRY *glFramebufferRenderbufferEXT_t) (GLenum target,
GLenum attachmentPoint,
GLenum renderbufferTarget,
GLuint renderbufferId);
public: public:
OpenGl_FrameBuffer (GLint theTextureFormat = GL_RGBA8); OpenGl_FrameBuffer (GLint theTextureFormat = GL_RGBA8);
virtual ~OpenGl_FrameBuffer() virtual ~OpenGl_FrameBuffer()
{ {
Release(); Release (Handle(OpenGl_Context)());
} }
//! Texture width. //! Texture width.
@ -109,12 +67,13 @@ public:
//! current implementation will try to generate compatible FBO; //! current implementation will try to generate compatible FBO;
//! 2) FBO rendering will be done in software mode (ForceWare 'hack'); //! 2) FBO rendering will be done in software mode (ForceWare 'hack');
//! 3) FBO rendering will be incorrect (some obsolete Catalyst drivers). //! 3) FBO rendering will be incorrect (some obsolete Catalyst drivers).
Standard_Boolean Init (GLsizei theViewportSizeX, Standard_Boolean Init (const Handle(OpenGl_Context)& theGlContext,
GLsizei theViewportSizeX,
GLsizei theViewportSizeY, GLsizei theViewportSizeY,
GLboolean toForcePowerOfTwo = GL_FALSE); GLboolean toForcePowerOfTwo = GL_FALSE);
//! Release GL objects //! Release GL objects
void Release(); void Release (const Handle(OpenGl_Context)& theGlContext);
//! Setup viewport to render into FBO //! Setup viewport to render into FBO
void SetupViewport() void SetupViewport()
@ -131,15 +90,15 @@ public:
} }
//! Bind frame buffer (to render into the texture). //! Bind frame buffer (to render into the texture).
void BindBuffer() void BindBuffer (const Handle(OpenGl_Context)& theGlContext)
{ {
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, myGlFBufferId); theGlContext->extFBO->glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, myGlFBufferId);
} }
//! Unbind frame buffer. //! Unbind frame buffer.
void UnbindBuffer() void UnbindBuffer (const Handle(OpenGl_Context)& theGlContext)
{ {
glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, NO_FRAMEBUFFER); theGlContext->extFBO->glBindFramebufferEXT (GL_FRAMEBUFFER_EXT, NO_FRAMEBUFFER);
} }
//! Bind the texture. //! Bind the texture.
@ -162,7 +121,7 @@ private:
Standard_Boolean IsProxySuccess() const; Standard_Boolean IsProxySuccess() const;
//! Generate texture with undefined data //! Generate texture with undefined data
Standard_Boolean InitTrashTexture(); Standard_Boolean InitTrashTexture (const Handle(OpenGl_Context)& theGlContext);
Standard_Boolean IsValidTexture() const Standard_Boolean IsValidTexture() const
{ {
@ -179,9 +138,6 @@ private:
return myGlTextureId != NO_RENDERBUFFER; return myGlTextureId != NO_RENDERBUFFER;
} }
Standard_Boolean AreFBOFunctionsValid();
Standard_Boolean InitFBOFunctions();
private: private:
GLsizei mySizeX; // texture width GLsizei mySizeX; // texture width
@ -193,18 +149,6 @@ private:
GLuint myGlFBufferId; // FBO object ID GLuint myGlFBufferId; // FBO object ID
GLuint myGlDepthRBId; // RenderBuffer object for depth ID GLuint myGlDepthRBId; // RenderBuffer object for depth ID
// functions
glGenFramebuffersEXT_t glGenFramebuffersEXT;
glDeleteFramebuffersEXT_t glDeleteFramebuffersEXT;
glBindFramebufferEXT_t glBindFramebufferEXT;
glFramebufferTexture2DEXT_t glFramebufferTexture2DEXT;
glCheckFramebufferStatusEXT_t glCheckFramebufferStatusEXT;
glGenRenderbuffersEXT_t glGenRenderbuffersEXT;
glDeleteRenderbuffersEXT_t glDeleteRenderbuffersEXT;
glBindRenderbufferEXT_t glBindRenderbufferEXT;
glRenderbufferStorageEXT_t glRenderbufferStorageEXT;
glFramebufferRenderbufferEXT_t glFramebufferRenderbufferEXT;
}; };
#endif //OPENGL_FRAME_BUFFER_H #endif //OPENGL_FRAME_BUFFER_H

600
src/OpenGl/OpenGl_graduatedtrihedron.cxx → src/OpenGl/OpenGl_GraduatedTrihedron.cxx
View File

@ -1,10 +1,9 @@
// File: OpenGl_graduatedtrihedron.cxx // File: OpenGl_GraduatedTrihedron.cxx
// Created: 6 March 2011 // Created: 20 September 2011
// Author: Sergey ZERCHANINOV // Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE SA 2011 // Copyright: OPEN CASCADE 2011
#include <OpenGl_tgl_all.hxx> #include <OpenGl_tgl_all.hxx>
#include <OpenGl_graduatedtrihedron.hxx>
#include <stddef.h> #include <stddef.h>
#include <stdio.h> #include <stdio.h>
@ -18,10 +17,6 @@
#include <InterfaceGraphic_Aspect.hxx> #include <InterfaceGraphic_Aspect.hxx>
#include <InterfaceGraphic_Visual3d.hxx> #include <InterfaceGraphic_Visual3d.hxx>
#include <OpenGl_tgl_funcs.hxx>
#include <OpenGl_tgl_subrs.hxx>
#include <OpenGl_TextRender.hxx>
#ifdef HAVE_CONFIG_H #ifdef HAVE_CONFIG_H
#include <config.h> #include <config.h>
#endif #endif
@ -29,236 +24,48 @@
#include <string.h> #include <string.h>
#endif #endif
struct TEL_GRADUATEDTRIHEDRON_DATA #include <OpenGl_Workspace.hxx>
{ #include <OpenGl_View.hxx>
int WsId; #include <OpenGl_GraduatedTrihedron.hxx>
wchar_t *xname, *yname, *zname; #include <OpenGl_AspectLine.hxx>
unsigned char xdrawname, ydrawname, zdrawname;
unsigned char xdrawvalues, ydrawvalues, zdrawvalues;
unsigned char drawgrid;
unsigned char drawaxes;
unsigned int nbx, nby, nbz;
int xoffset, yoffset, zoffset;
int xaxisoffset, yaxisoffset, zaxisoffset;
unsigned char xdrawtickmarks, ydrawtickmarks, zdrawtickmarks;
unsigned int xtickmarklength, ytickmarklength, ztickmarklength;
float gridcolor[3];
float xnamecolor[3];
float ynamecolor[3];
float znamecolor[3];
float xcolor[3];
float ycolor[3];
float zcolor[3];
char* fontOfNames;
OSD_FontAspect styleOfNames;
int sizeOfNames;
char* fontOfValues;
OSD_FontAspect styleOfValues;
int sizeOfValues;
minMaxValuesCallback cbCubicAxes;
void* ptrVisual3dView;
IMPLEMENT_MEMORY_OPERATORS
};
typedef TEL_GRADUATEDTRIHEDRON_DATA* tel_graduatedtrihedron_data;
/* Graduated trihedron data */ IMPLEMENT_STANDARD_HANDLE(OpenGl_GraduatedTrihedron,MMgt_TShared)
static int nbWsIds = 0; /* Number of the views (size of the arrays below */ IMPLEMENT_STANDARD_RTTIEXT(OpenGl_GraduatedTrihedron,MMgt_TShared)
static tel_graduatedtrihedron_data* graduatedTrihedronData = 0; /* The array contains graduated trihedron data of all views */
const OpenGl_AspectLine myDefaultAspectLine;
/* Bounding box */ /* Bounding box */
float xmin = 0.0f, ymin = 0.0f, zmin = 0.0f, xmax = 100.0f, ymax = 100.0f, zmax = 100.0f; float xmin = 0.0f, ymin = 0.0f, zmin = 0.0f, xmax = 100.0f, ymax = 100.0f, zmax = 100.0f;
static void copyData(const Graphic3d_CGraduatedTrihedron *fromData, TEL_GRADUATEDTRIHEDRON_DATA* toData)
{
int len;
/* Names of axes */
/* X-name */
len = fromData->xname.Length();
if (len)
{
Standard_ExtString iname = fromData->xname.ToExtString();
toData->xname = new wchar_t[len+1];
len = 0; while (toData->xname[len] = (wchar_t)(iname[len])) len++;
}
else
toData->xname = NULL;
/* Y-name */
len = fromData->yname.Length();
if (len)
{
Standard_ExtString iname = fromData->yname.ToExtString();
toData->yname = new wchar_t[len+1];
len = 0; while (toData->yname[len] = (wchar_t)(iname[len])) len++;
}
else
toData->yname = NULL;
/* Z-name */
len = fromData->zname.Length();
if (len)
{
Standard_ExtString iname = fromData->zname.ToExtString();
toData->zname = new wchar_t[len+1];
len = 0; while (toData->zname[len] = (wchar_t)(iname[len])) len++;
}
else
toData->zname = NULL;
/* Draw names */
toData->xdrawname = fromData->xdrawname;
toData->ydrawname = fromData->ydrawname;
toData->zdrawname = fromData->zdrawname;
/* Draw values */
toData->xdrawvalues = fromData->xdrawvalues;
toData->ydrawvalues = fromData->ydrawvalues;
toData->zdrawvalues = fromData->zdrawvalues;
/* Draw grid */
toData->drawgrid = fromData->drawgrid;
/* Draw axes */
toData->drawaxes = fromData->drawaxes;
/* Number of splits along axes */
toData->nbx = fromData->nbx;
toData->nby = fromData->nby;
toData->nbz = fromData->nbz;
/* Offset for drawing values */
toData->xoffset = fromData->xoffset;
toData->yoffset = fromData->yoffset;
toData->zoffset = fromData->zoffset;
/* Offset for drawing names of axes */
toData->xaxisoffset = fromData->xaxisoffset;
toData->yaxisoffset = fromData->yaxisoffset;
toData->zaxisoffset = fromData->zaxisoffset;
/* Draw tickmarks */
toData->xdrawtickmarks = fromData->xdrawtickmarks;
toData->ydrawtickmarks = fromData->ydrawtickmarks;
toData->zdrawtickmarks = fromData->zdrawtickmarks;
/* Length of tickmarks */
toData->xtickmarklength = fromData->xtickmarklength;
toData->ytickmarklength = fromData->ytickmarklength;
toData->ztickmarklength = fromData->ztickmarklength;
/* Grid color */
toData->gridcolor[0] = (float) fromData->gridcolor.Red();
toData->gridcolor[1] = (float) fromData->gridcolor.Green();
toData->gridcolor[2] = (float) fromData->gridcolor.Blue();
/* X name color */
toData->xnamecolor[0] = (float) fromData->xnamecolor.Red();
toData->xnamecolor[1] = (float) fromData->xnamecolor.Green();
toData->xnamecolor[2] = (float) fromData->xnamecolor.Blue();
/* Y name color */
toData->ynamecolor[0] = (float) fromData->ynamecolor.Red();
toData->ynamecolor[1] = (float) fromData->ynamecolor.Green();
toData->ynamecolor[2] = (float) fromData->ynamecolor.Blue();
/* Z name color */
toData->znamecolor[0] = (float) fromData->znamecolor.Red();
toData->znamecolor[1] = (float) fromData->znamecolor.Green();
toData->znamecolor[2] = (float) fromData->znamecolor.Blue();
/* X color of axis and values */
toData->xcolor[0] = (float) fromData->xcolor.Red();
toData->xcolor[1] = (float) fromData->xcolor.Green();
toData->xcolor[2] = (float) fromData->xcolor.Blue();
/* Y color of axis and values */
toData->ycolor[0] = (float) fromData->ycolor.Red();
toData->ycolor[1] = (float) fromData->ycolor.Green();
toData->ycolor[2] = (float) fromData->ycolor.Blue();
/* Z color of axis and values */
toData->zcolor[0] = (float) fromData->zcolor.Red();
toData->zcolor[1] = (float) fromData->zcolor.Green();
toData->zcolor[2] = (float) fromData->zcolor.Blue();
/* Font name of names of axes: Courier, Arial, ... */
len = fromData->fontOfNames.Length();
toData->fontOfNames = new char[len+1];
if (len)
strcpy(toData->fontOfNames, fromData->fontOfNames.ToCString());
else
toData->fontOfNames[0] = L'\0';
/* Style of names of axes: OSD_FA_Regular, OSD_FA_Bold, ... */
toData->styleOfNames = fromData->styleOfNames;
/* Size of names of axes: 8, 10, 12, 14, ... */
toData->sizeOfNames = fromData->sizeOfNames;
/* Font name of values: Courier, Arial, ... */
len = fromData->fontOfValues.Length();
toData->fontOfValues = new char[len+1];
if (len)
strcpy(toData->fontOfValues, fromData->fontOfValues.ToCString());
else
toData->fontOfValues[0] = L'\0';
/* Style of values: OSD_FA_Regular, OSD_FA_Bold, ... */
toData->styleOfValues = fromData->styleOfValues;
/* Size of values: 8, 10, 12, 14, ... */
toData->sizeOfValues = fromData->sizeOfValues;
/* Callback - updater of boundary box */
toData->cbCubicAxes = fromData->cbCubicAxes;
toData->ptrVisual3dView = fromData->ptrVisual3dView;
}
static void freeData()
{
if (nbWsIds)
{
int i = 0;
tel_graduatedtrihedron_data gtdata;
for (i = 0; i < nbWsIds; i++)
{
gtdata = graduatedTrihedronData[i];
// Names of axes
if (gtdata->xname)
delete[] gtdata->xname;
if (gtdata->yname)
delete[] gtdata->yname;
if (gtdata->zname)
delete[] gtdata->zname;
// Fonts
if (gtdata->fontOfNames)
delete[] gtdata->fontOfNames;
if (gtdata->fontOfValues)
delete[] gtdata->fontOfValues;
delete gtdata;
}
delete graduatedTrihedronData;
graduatedTrihedronData = 0;
nbWsIds = 0;
}
}
static int getGraduatedTrihedronDataIndex(int WsId)
{
int i = 0;
for (; i < nbWsIds; i++)
{
if (graduatedTrihedronData[i]->WsId == WsId)
return i;
}
return -1;
}
/* Normal of the view (not normalized!) */ /* Normal of the view (not normalized!) */
static float getNormal(float* normal) static float getNormal(float* normal)
{ {
GLint viewport[4]; GLint viewport[4];
GLdouble model_matrix[16], proj_matrix[16]; GLdouble model_matrix[16], proj_matrix[16];
double x1, y1, z1, x2, y2, z2, x3, y3, z3;
double dx1, dy1, dz1, dx2, dy2, dz2, width;
glGetDoublev(GL_MODELVIEW_MATRIX, model_matrix); glGetDoublev(GL_MODELVIEW_MATRIX, model_matrix);
glGetDoublev(GL_PROJECTION_MATRIX, proj_matrix); glGetDoublev(GL_PROJECTION_MATRIX, proj_matrix);
glGetIntegerv(GL_VIEWPORT, viewport); glGetIntegerv(GL_VIEWPORT, viewport);
gluUnProject(viewport[0], viewport[1], 0., model_matrix, proj_matrix, viewport, &x1, &y1, &z1); double x1, y1, z1, x2, y2, z2, x3, y3, z3;
gluUnProject(viewport[0] + viewport[2], viewport[1], 0., model_matrix, proj_matrix, viewport, &x2, &y2, &z2); gluUnProject(viewport[0], viewport[1], 0., model_matrix, proj_matrix, viewport, &x1, &y1, &z1);
gluUnProject(viewport[0], viewport[1] + viewport[3], 0., model_matrix, proj_matrix, viewport, &x3, &y3, &z3); 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);
/* Normal out of user is p1p3^p1p2 */ /* Normal out of user is p1p3^p1p2 */
dx1 = x3 - x1; dy1 = y3 - y1; dz1 = z3 - z1; const double dx1 = x3 - x1;
dx2 = x2 - x1; dy2 = y2 - y1; dz2 = z2 - z1; const double dy1 = y3 - y1;
normal[0] = (float) (dy1 * dz2 - dz1 * dy2); const double dz1 = z3 - z1;
normal[1] = (float) (dz1 * dx2 - dx1 * dz2); const double dx2 = x2 - x1;
normal[2] = (float) (dx1 * dy2 - dy1 * dx2); const double dy2 = y2 - y1;
const double dz2 = z2 - z1;
normal[0] = (float) (dy1 * dz2 - dz1 * dy2);
normal[1] = (float) (dz1 * dx2 - dx1 * dz2);
normal[2] = (float) (dx1 * dy2 - dy1 * dx2);
/* Distance corresponding to 1 pixel */ /* Distance corresponding to 1 pixel */
width = sqrt(dx2 * dx2 + dy2 * dy2 + dz2 * dz2); const float width = (float) sqrt(dx2 * dx2 + dy2 * dy2 + dz2 * dz2);
return (float) width / (float) viewport[2]; return width / (float) viewport[2];
} }
static float getDistance2Corner(float* normal, float* center, float x, float y, float z) static float getDistance2Corner(float* normal, float* center, float x, float y, float z)
@ -314,11 +121,10 @@ static char getFarestCorner(float d000, float d100, float d010, float d001,
return 8; /* d111 */ return 8; /* d111 */
} }
static void drawText(const wchar_t* text, char* font, OSD_FontAspect style, int size, float x, float y, float z) static void drawText(const Handle(OpenGl_Workspace) &AWorkspace, const wchar_t* text, const char* font, OSD_FontAspect style, int size, float x, float y, float z)
{ {
OpenGl_TextRender* textRenderer = OpenGl_TextRender::instance(); AWorkspace->FindFont(font, style, size);
const GLuint fontBase = textRenderer->FindFont((Tchar*) font, style, (float) size); AWorkspace->RenderText(text, 0, x, y, z);
textRenderer->RenderText(text, fontBase, 0, x, y, z);
/* 4 OCC 6.3.1 and older: /* 4 OCC 6.3.1 and older:
GLuint fontBase; GLuint fontBase;
@ -392,90 +198,138 @@ static void drawArrow(float x1, float y1, float z1,
glEnd(); glEnd();
} }
TStatus call_graduatedtrihedron_display(int WsId, const Graphic3d_CGraduatedTrihedron &data) OpenGl_GraduatedTrihedron::OpenGl_GraduatedTrihedron (const Graphic3d_CGraduatedTrihedron &AData)
: myXName(NULL), myYName(NULL), myZName(NULL),
myDrawXName(AData.xdrawname), myDrawYName(AData.ydrawname), myDrawZName(AData.zdrawname),
myDrawXValues(AData.xdrawvalues), myDrawYValues(AData.ydrawvalues), myDrawZValues(AData.zdrawvalues),
myDrawGrid(AData.drawgrid), myDrawAxes(AData.drawaxes),
myNbX(AData.nbx), myNbY(AData.nby), myNbZ(AData.nbz),
myXOffset(AData.xoffset), myYOffset(AData.yoffset), myZOffset(AData.zoffset),
myXAxisOffset(AData.xaxisoffset), myYAxisOffset(AData.yaxisoffset), myZAxisOffset(AData.zaxisoffset),
myDrawXTickmarks(AData.xdrawtickmarks), myDrawYTickmarks(AData.ydrawtickmarks), myDrawZTickmarks(AData.zdrawtickmarks),
myXTickmarkLength(AData.xtickmarklength), myYTickmarkLength(AData.ytickmarklength), myZTickmarkLength(AData.ztickmarklength),
myFontOfNames(NULL),
myStyleOfNames(AData.styleOfNames),
mySizeOfNames(AData.sizeOfNames),
myFontOfValues(NULL),
myStyleOfValues(AData.styleOfValues),
mySizeOfValues(AData.sizeOfValues),
myCbCubicAxes(AData.cbCubicAxes),
myPtrVisual3dView(AData.ptrVisual3dView)
{ {
/* Initialize data for a new view */ /* Names of axes */
int index = getGraduatedTrihedronDataIndex(WsId); /* X-name */
if (index == -1) int len = AData.xname.Length();
if (len)
{ {
/* Extend array for +1 */ Standard_ExtString iname = AData.xname.ToExtString();
tel_graduatedtrihedron_data* newGraduatedTrihedronData = new tel_graduatedtrihedron_data[nbWsIds+1]; wchar_t *xname = new wchar_t[len+1];
len = 0; while (xname[len] = (wchar_t)(iname[len])) len++;
/* Copy existing contents */ myXName = xname;
int i;
for (i = 0; i < nbWsIds; i++)
newGraduatedTrihedronData[i] = graduatedTrihedronData[i];
/* Add new item */
index = nbWsIds++;
newGraduatedTrihedronData[index] = new TEL_GRADUATEDTRIHEDRON_DATA;
newGraduatedTrihedronData[index]->WsId = WsId;
/* Switch to new array */
delete graduatedTrihedronData;
graduatedTrihedronData = newGraduatedTrihedronData;
} }
copyData(&data, graduatedTrihedronData[index]); /* Y-name */
return call_graduatedtrihedron_redraw(WsId); len = AData.yname.Length();
if (len)
{
Standard_ExtString iname = AData.yname.ToExtString();
wchar_t *yname = new wchar_t[len+1];
len = 0; while (yname[len] = (wchar_t)(iname[len])) len++;
myYName = yname;
}
/* Z-name */
len = AData.zname.Length();
if (len)
{
Standard_ExtString iname = AData.zname.ToExtString();
wchar_t *zname = new wchar_t[len+1];
len = 0; while (zname[len] = (wchar_t)(iname[len])) len++;
myZName = zname;
}
/* Grid color */
myGridColor[0] = (float) AData.gridcolor.Red();
myGridColor[1] = (float) AData.gridcolor.Green();
myGridColor[2] = (float) AData.gridcolor.Blue();
/* X name color */
myXNameColor[0] = (float) AData.xnamecolor.Red();
myXNameColor[1] = (float) AData.xnamecolor.Green();
myXNameColor[2] = (float) AData.xnamecolor.Blue();
/* Y name color */
myYNameColor[0] = (float) AData.ynamecolor.Red();
myYNameColor[1] = (float) AData.ynamecolor.Green();
myYNameColor[2] = (float) AData.ynamecolor.Blue();
/* Z name color */
myZNameColor[0] = (float) AData.znamecolor.Red();
myZNameColor[1] = (float) AData.znamecolor.Green();
myZNameColor[2] = (float) AData.znamecolor.Blue();
/* X color of axis and values */
myXColor[0] = (float) AData.xcolor.Red();
myXColor[1] = (float) AData.xcolor.Green();
myXColor[2] = (float) AData.xcolor.Blue();
/* Y color of axis and values */
myYColor[0] = (float) AData.ycolor.Red();
myYColor[1] = (float) AData.ycolor.Green();
myYColor[2] = (float) AData.ycolor.Blue();
/* Z color of axis and values */
myZColor[0] = (float) AData.zcolor.Red();
myZColor[1] = (float) AData.zcolor.Green();
myZColor[2] = (float) AData.zcolor.Blue();
/* Font name of names of axes: Courier, Arial, ... */
len = AData.fontOfNames.Length();
char *fontOfNames = new char[len+1];
if (len)
strcpy(fontOfNames, AData.fontOfNames.ToCString());
else
fontOfNames[0] = '\0';
myFontOfNames = fontOfNames;
/* Font name of values: Courier, Arial, ... */
len = AData.fontOfValues.Length();
char *fontOfValues = new char[len+1];
if (len)
strcpy(fontOfValues, AData.fontOfValues.ToCString());
else
fontOfValues[0] = '\0';
myFontOfValues = fontOfValues;
} }
TStatus call_graduatedtrihedron_erase(int WsId) OpenGl_GraduatedTrihedron::~OpenGl_GraduatedTrihedron ()
{ {
int index = getGraduatedTrihedronDataIndex(WsId); // Names of axes
if (index == -1) if (myXName)
return TSuccess; /* Nothing to remove */ delete[] myXName;
if (myYName)
delete[] myYName;
if (myZName)
delete[] myZName;
/* If trihedron is displayed only in one view, just free the array and set nbWsIds equal to 0. */ // Fonts
if (nbWsIds == 1) if (myFontOfNames)
{ delete[] myFontOfNames;
freeData(); if (myFontOfValues)
return TSuccess; delete[] myFontOfValues;
}
/* Reduce array for -1 */
tel_graduatedtrihedron_data* newGraduatedTrihedronData = new tel_graduatedtrihedron_data[nbWsIds-1];
/* Copy existing contents */
int i, j;
for (i = 0, j = 0; i < nbWsIds; i++)
{
if (graduatedTrihedronData[i]->WsId != WsId)
newGraduatedTrihedronData[j++] = graduatedTrihedronData[i];
}
nbWsIds--;
/* Switch to new array */
delete graduatedTrihedronData;
graduatedTrihedronData = newGraduatedTrihedronData;
return TSuccess;
} }
TStatus call_graduatedtrihedron_redraw(int WsId) //call_graduatedtrihedron_redraw
void OpenGl_GraduatedTrihedron::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
{ {
/* Get index of the trihedron data */ const OpenGl_AspectLine *oldAspectLine = AWorkspace->SetAspectLine(&myDefaultAspectLine);
int index = getGraduatedTrihedronDataIndex(WsId); AWorkspace->AspectLine(Standard_True);
if (index == -1)
return TFailure;
tel_graduatedtrihedron_data data = graduatedTrihedronData[index];
/* Update boundary box */ /* Update boundary box */
if (data->cbCubicAxes) if (myCbCubicAxes)
data->cbCubicAxes(data->ptrVisual3dView); myCbCubicAxes(myPtrVisual3dView);
/* Disable lighting for lines */ /* Disable lighting for lines */
GLboolean light = glIsEnabled(GL_LIGHTING); GLboolean light = glIsEnabled(GL_LIGHTING);
if (light) if (light)
glDisable(GL_LIGHTING); glDisable(GL_LIGHTING);
/* Find the farest point of bounding box */ /* Find the farest point of bounding box */
/* Get normal of the view out of user. */ /* Get normal of the view out of user. */
/* Also, the method return distance corresponding to 1 pixel */ /* Also, the method return distance corresponding to 1 pixel */
float normal[3]; float normal[3];
float dpix = getNormal(normal); float dpix = getNormal(normal);
/* Normalize normal */ /* Normalize normal */
float d = sqrtf(normal[0] * normal[0] + normal[1] * normal[1] + normal[2] * normal[2]); float d = sqrtf(normal[0] * normal[0] + normal[1] * normal[1] + normal[2] * normal[2]);
normal[0] /= d; normal[0] /= d;
@ -790,9 +644,9 @@ TStatus call_graduatedtrihedron_redraw(int WsId)
float step, dx, dy, dz; float step, dx, dy, dz;
/* Grid */ /* Grid */
if (data->drawgrid) if (myDrawGrid)
{ {
glColor3fv(data->gridcolor); glColor3fv(myGridColor);
glBegin(GL_LINES); glBegin(GL_LINES);
/* Boundary grid-lines */ /* Boundary grid-lines */
if (LX1draw == 1) if (LX1draw == 1)
@ -844,11 +698,11 @@ TStatus call_graduatedtrihedron_redraw(int WsId)
/* Intermediate grid-lines */ /* Intermediate grid-lines */
/* X-Grid lines */ /* X-Grid lines */
if (data->nbx > 0) if (myNbX > 0)
{ {
i = data->drawaxes ? 1 : 0; i = myDrawAxes ? 1 : 0;
step = fabsf(LX1[3] - LX1[0]) / (float) data->nbx; step = fabsf(LX1[3] - LX1[0]) / (float) myNbX;
while (i < data->nbx) while (i < myNbX)
{ {
glBegin(GL_LINE_STRIP); glBegin(GL_LINE_STRIP);
glVertex3f(LX1[0] + i * step, LX1[1], LX1[2]); glVertex3f(LX1[0] + i * step, LX1[1], LX1[2]);
@ -859,11 +713,11 @@ TStatus call_graduatedtrihedron_redraw(int WsId)
} }
} }
/* Y-Grid lines */ /* Y-Grid lines */
if (data->nby > 0) if (myNbY > 0)
{ {
i = data->drawaxes ? 1 : 0; i = myDrawAxes ? 1 : 0;
step = fabsf(LY1[4] - LY1[1]) / (float) data->nby; step = fabsf(LY1[4] - LY1[1]) / (float) myNbY;
while (i < data->nby) while (i < myNbY)
{ {
glBegin(GL_LINE_STRIP); glBegin(GL_LINE_STRIP);
glVertex3f(LY1[0], LY1[1] + i * step, LY1[2]); glVertex3f(LY1[0], LY1[1] + i * step, LY1[2]);
@ -874,11 +728,11 @@ TStatus call_graduatedtrihedron_redraw(int WsId)
} }
} }
/* Z-Grid lines */ /* Z-Grid lines */
if (data->nbz > 0) if (myNbZ > 0)
{ {
i = data->drawaxes ? 1 : 0; i = myDrawAxes ? 1 : 0;
step = fabsf(LZ1[5] - LZ1[2]) / (float) data->nbz; step = fabsf(LZ1[5] - LZ1[2]) / (float) myNbZ;
while (i < data->nbz) while (i < myNbZ)
{ {
glBegin(GL_LINE_STRIP); glBegin(GL_LINE_STRIP);
glVertex3f(LZ1[0], LZ1[1], LZ1[2] + i * step); glVertex3f(LZ1[0], LZ1[1], LZ1[2] + i * step);
@ -891,18 +745,18 @@ TStatus call_graduatedtrihedron_redraw(int WsId)
} }
/* Axes (arrows) */ /* Axes (arrows) */
if (data->drawaxes) if (myDrawAxes)
{ {
/* X-axis */ /* X-axis */
glColor3fv(data->xcolor); glColor3fv(myXColor);
drawArrow(xmin, ymin, zmin, xmax, ymin, zmin, normal[0], normal[1], normal[2]); drawArrow(xmin, ymin, zmin, xmax, ymin, zmin, normal[0], normal[1], normal[2]);
/* Y-axis */ /* Y-axis */
glColor3fv(data->ycolor); glColor3fv(myYColor);
drawArrow(xmin, ymin, zmin, xmin, ymax, zmin, normal[0], normal[1], normal[2]); drawArrow(xmin, ymin, zmin, xmin, ymax, zmin, normal[0], normal[1], normal[2]);
/* Z-axis */ /* Z-axis */
glColor3fv(data->zcolor); glColor3fv(myZColor);
drawArrow(xmin, ymin, zmin, xmin, ymin, zmax, normal[0], normal[1], normal[2]); drawArrow(xmin, ymin, zmin, xmin, ymin, zmax, normal[0], normal[1], normal[2]);
} }
@ -910,7 +764,7 @@ TStatus call_graduatedtrihedron_redraw(int WsId)
char textValue[128]; char textValue[128];
wchar_t wtextValue[128]; wchar_t wtextValue[128];
if (data->xdrawname || data->xdrawvalues) if (myDrawXName || myDrawXValues)
{ {
/* Middle point of the first X-axis */ /* Middle point of the first X-axis */
m1[0] = 0.5f * (LX1[0] + LX1[3]); m1[0] = 0.5f * (LX1[0] + LX1[3]);
@ -937,51 +791,51 @@ TStatus call_graduatedtrihedron_redraw(int WsId)
m2[2] = dpix * dz; m2[2] = dpix * dz;
/* Name of X-axis */ /* Name of X-axis */
if (data->xdrawname) if (myDrawXName)
{ {
glColor3fv(data->xnamecolor); glColor3fv(myXNameColor);
offset = data->xaxisoffset + data->xtickmarklength; offset = myXAxisOffset + myXTickmarkLength;
drawText(data->xname, data->fontOfNames, data->styleOfNames, data->sizeOfNames, drawText(AWorkspace, myXName, myFontOfNames, myStyleOfNames, mySizeOfNames,
m1[0], m1[1] + offset * m2[1], m1[2] + offset * m2[2]); m1[0], m1[1] + offset * m2[1], m1[2] + offset * m2[2]);
} }
/* X-values */ /* X-values */
if (data->xdrawvalues && data->nbx > 0) if (myDrawXValues && myNbX > 0)
{ {
glColor3fv(data->xcolor); glColor3fv(myXColor);
i = 0; i = 0;
step = fabsf(LX1[3] - LX1[0]) / (float) data->nbx; step = fabsf(LX1[3] - LX1[0]) / (float) myNbX;
offset = data->xoffset + data->xtickmarklength; offset = myXOffset + myXTickmarkLength;
while (i <= data->nbx) while (i <= myNbX)
{ {
sprintf(textValue, "%g", LX1[0] + i * step); sprintf(textValue, "%g", LX1[0] + i * step);
j = 0; while (wtextValue[j] = textValue[j]) j++; j = 0; while (wtextValue[j] = textValue[j]) j++;
drawText(wtextValue, data->fontOfValues, data->styleOfValues, data->sizeOfValues, drawText(AWorkspace, wtextValue, myFontOfValues, myStyleOfValues, mySizeOfValues,
LX1[0] + i * step, m1[1] + offset * m2[1], m1[2] + offset * m2[2]); LX1[0] + i * step, m1[1] + offset * m2[1], m1[2] + offset * m2[2]);
i++; i++;
} }
} }
/* X-tickmark */ /* X-tickmark */
if (data->xdrawtickmarks && data->nbx > 0) if (myDrawXTickmarks && myNbX > 0)
{ {
glColor3fv(data->gridcolor); glColor3fv(myGridColor);
i = 0; i = 0;
step = fabsf(LX1[3] - LX1[0]) / (float) data->nbx; step = fabsf(LX1[3] - LX1[0]) / (float) myNbX;
while (i <= data->nbx) while (i <= myNbX)
{ {
glBegin(GL_LINES); glBegin(GL_LINES);
glVertex3f(LX1[0] + i * step, m1[1], m1[2]); glVertex3f(LX1[0] + i * step, m1[1], m1[2]);
glVertex3f(LX1[0] + i * step, m1[1] + data->xtickmarklength * m2[1], m1[2] + data->xtickmarklength * m2[2]); glVertex3f(LX1[0] + i * step, m1[1] + myXTickmarkLength * m2[1], m1[2] + myXTickmarkLength * m2[2]);
glEnd(); glEnd();
i++; i++;
} }
} }
} }
if (data->ydrawname || data->ydrawvalues) if (myDrawYName || myDrawYValues)
{ {
/* Middle point of the first Y-axis */ /* Middle point of the first Y-axis */
m1[0] = 0.5f * (LY1[0] + LY1[3]); m1[0] = 0.5f * (LY1[0] + LY1[3]);
@ -1009,51 +863,51 @@ TStatus call_graduatedtrihedron_redraw(int WsId)
m2[2] = dpix * dz; m2[2] = dpix * dz;
/* Name of Y-axis */ /* Name of Y-axis */
if (data->ydrawname) if (myDrawYName)
{ {
glColor3fv(data->ynamecolor); glColor3fv(myYNameColor);
offset = data->yaxisoffset + data->ytickmarklength; offset = myYAxisOffset + myYTickmarkLength;
drawText(data->yname, data->fontOfNames, data->styleOfNames, data->sizeOfNames, drawText(AWorkspace, myYName, myFontOfNames, myStyleOfNames, mySizeOfNames,
m1[0] + offset * m2[0], m1[1], m1[2] + offset * m2[2]); m1[0] + offset * m2[0], m1[1], m1[2] + offset * m2[2]);
} }
/* Y-values */ /* Y-values */
if (data->ydrawvalues && data->nby > 0) if (myDrawYValues && myNbY > 0)
{ {
glColor3fv(data->ycolor); glColor3fv(myYColor);
i = 0; i = 0;
step = fabsf(LY1[4] - LY1[1]) / (float) data->nby; step = fabsf(LY1[4] - LY1[1]) / (float) myNbY;
offset = data->yoffset + data->ytickmarklength; offset = myYOffset + myYTickmarkLength;
while (i <= data->nby) while (i <= myNbY)
{ {
sprintf(textValue, "%g", LY1[1] + i * step); sprintf(textValue, "%g", LY1[1] + i * step);
j = 0; while (wtextValue[j] = textValue[j]) j++; j = 0; while (wtextValue[j] = textValue[j]) j++;
drawText(wtextValue, data->fontOfValues, data->styleOfValues, data->sizeOfValues, drawText(AWorkspace, wtextValue, myFontOfValues, myStyleOfValues, mySizeOfValues,
m1[0] + offset * m2[0], LY1[1] + i * step, m1[2] + offset * m2[2]); m1[0] + offset * m2[0], LY1[1] + i * step, m1[2] + offset * m2[2]);
i++; i++;
} }
} }
/* Y-tickmark */ /* Y-tickmark */
if (data->ydrawtickmarks && data->nby > 0) if (myDrawYTickmarks && myNbY > 0)
{ {
glColor3fv(data->gridcolor); glColor3fv(myGridColor);
i = 0; i = 0;
step = fabsf(LY1[4] - LY1[1]) / (float) data->nby; step = fabsf(LY1[4] - LY1[1]) / (float) myNbY;
while (i <= data->nby) while (i <= myNbY)
{ {
glBegin(GL_LINES); glBegin(GL_LINES);
glVertex3f(m1[0], LY1[1] + i * step, m1[2]); glVertex3f(m1[0], LY1[1] + i * step, m1[2]);
glVertex3f(m1[0] + data->ytickmarklength * m2[0], LY1[1] + i * step, m1[2] + data->ytickmarklength * m2[2]); glVertex3f(m1[0] + myYTickmarkLength * m2[0], LY1[1] + i * step, m1[2] + myYTickmarkLength * m2[2]);
glEnd(); glEnd();
i++; i++;
} }
} }
} }
if (data->zdrawname || data->zdrawvalues) if (myDrawZName || myDrawZValues)
{ {
/* Middle point of the first Z-axis */ /* Middle point of the first Z-axis */
m1[0] = 0.5f * (LZ1[0] + LZ1[3]); m1[0] = 0.5f * (LZ1[0] + LZ1[3]);
@ -1081,44 +935,44 @@ TStatus call_graduatedtrihedron_redraw(int WsId)
m2[1] = dpix * dy; m2[1] = dpix * dy;
/* Name of Z-axis */ /* Name of Z-axis */
if (data->zdrawname) if (myDrawZName)
{ {
glColor3fv(data->znamecolor); glColor3fv(myZNameColor);
offset = data->zaxisoffset + data->ztickmarklength; offset = myZAxisOffset + myZTickmarkLength;
drawText(data->zname, data->fontOfNames, data->styleOfNames, data->sizeOfNames, drawText(AWorkspace, myZName, myFontOfNames, myStyleOfNames, mySizeOfNames,
m1[0] + offset * m2[0], m1[1] + offset * m2[1], m1[2]); m1[0] + offset * m2[0], m1[1] + offset * m2[1], m1[2]);
} }
/* Z-values */ /* Z-values */
if (data->zdrawvalues && data->nbz > 0) if (myDrawZValues && myNbZ > 0)
{ {
glColor3fv(data->zcolor); glColor3fv(myZColor);
i = 0; i = 0;
step = fabsf(LZ1[5] - LZ1[2]) / (float) data->nbz; step = fabsf(LZ1[5] - LZ1[2]) / (float) myNbZ;
offset = data->zoffset + data->ztickmarklength; offset = myZOffset + myZTickmarkLength;
while (i <= data->nbz) while (i <= myNbZ)
{ {
sprintf(textValue, "%g", LZ1[2] + i * step); sprintf(textValue, "%g", LZ1[2] + i * step);
j = 0; while (wtextValue[j] = textValue[j]) j++; j = 0; while (wtextValue[j] = textValue[j]) j++;
drawText(wtextValue, data->fontOfValues, data->styleOfValues, data->sizeOfValues, drawText(AWorkspace, wtextValue, myFontOfValues, myStyleOfValues, mySizeOfValues,
m1[0] + offset * m2[0], m1[1] + offset * m2[1], LZ1[2] + i * step); m1[0] + offset * m2[0], m1[1] + offset * m2[1], LZ1[2] + i * step);
i++; i++;
} }
} }
/* Z-tickmark */ /* Z-tickmark */
if (data->zdrawtickmarks && data->nbz > 0) if (myDrawZTickmarks && myNbZ > 0)
{ {
glColor3fv(data->gridcolor); glColor3fv(myGridColor);
i = 0; i = 0;
step = fabsf(LZ1[5] - LZ1[2]) / (float) data->nbz; step = fabsf(LZ1[5] - LZ1[2]) / (float) myNbZ;
while (i <= data->nbz) while (i <= myNbZ)
{ {
glBegin(GL_LINES); glBegin(GL_LINES);
glVertex3f(m1[0], m1[1], LZ1[2] + i * step); glVertex3f(m1[0], m1[1], LZ1[2] + i * step);
glVertex3f(m1[0] + data->ztickmarklength * m2[0], m1[1] + data->ztickmarklength * m2[1], LZ1[2] + i * step); glVertex3f(m1[0] + myZTickmarkLength * m2[0], m1[1] + myZTickmarkLength * m2[1], LZ1[2] + i * step);
glEnd(); glEnd();
i++; i++;
} }
@ -1128,22 +982,18 @@ TStatus call_graduatedtrihedron_redraw(int WsId)
/* Activate the lighting if it was turned off by this method call */ /* Activate the lighting if it was turned off by this method call */
if (light) if (light)
glEnable(GL_LIGHTING); glEnable(GL_LIGHTING);
return TSuccess; AWorkspace->SetAspectLine(oldAspectLine);
} }
TStatus call_graduatedtrihedron_minmaxvalues(const float xMin, //call_graduatedtrihedron_minmaxvalues
const float yMin, void OpenGl_GraduatedTrihedron::SetMinMax (const Standard_ShortReal xMin, const Standard_ShortReal yMin, const Standard_ShortReal zMin,
const float zMin, const Standard_ShortReal xMax, const Standard_ShortReal yMax, const Standard_ShortReal zMax)
const float xMax,
const float yMax,
const float zMax)
{ {
xmin = xMin; xmin = xMin;
ymin = yMin; ymin = yMin;
zmin = zMin; zmin = zMin;
xmax = xMax; xmax = xMax;
ymax = yMax; ymax = yMax;
zmax = zMax; zmax = zMax;
return TSuccess;
} }

64
src/OpenGl/OpenGl_GraduatedTrihedron.hxx Normal file
View File

@ -0,0 +1,64 @@
// File: OpenGl_GraduatedTrihedron.hxx
// Created: 20 September 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _OpenGl_GraduatedTrihedron_Header
#define _OpenGl_GraduatedTrihedron_Header
#include <Handle_OpenGl_GraduatedTrihedron.hxx>
#include <Graphic3d_CGraduatedTrihedron.hxx>
class OpenGl_View;
class OpenGl_GraduatedTrihedron : public MMgt_TShared
{
public:
OpenGl_GraduatedTrihedron (const Graphic3d_CGraduatedTrihedron &AData);
virtual ~OpenGl_GraduatedTrihedron ();
static void SetMinMax (const Standard_ShortReal xMin, const Standard_ShortReal yMin, const Standard_ShortReal zMin,
const Standard_ShortReal xMax, const Standard_ShortReal yMax, const Standard_ShortReal zMax);
void Render (const Handle(OpenGl_Workspace) &AWorkspace) const;
// Type definition
//
DEFINE_STANDARD_RTTI(OpenGl_GraduatedTrihedron)
protected:
const wchar_t *myXName;
const wchar_t *myYName;
const wchar_t *myZName;
unsigned char myDrawXName, myDrawYName, myDrawZName;
unsigned char myDrawXValues, myDrawYValues, myDrawZValues;
unsigned char myDrawGrid;
unsigned char myDrawAxes;
unsigned int myNbX, myNbY, myNbZ;
int myXOffset, myYOffset, myZOffset;
int myXAxisOffset, myYAxisOffset, myZAxisOffset;
unsigned char myDrawXTickmarks, myDrawYTickmarks, myDrawZTickmarks;
unsigned int myXTickmarkLength, myYTickmarkLength, myZTickmarkLength;
float myGridColor[3];
float myXNameColor[3];
float myYNameColor[3];
float myZNameColor[3];
float myXColor[3];
float myYColor[3];
float myZColor[3];
const char *myFontOfNames;
OSD_FontAspect myStyleOfNames;
int mySizeOfNames;
const char* myFontOfValues;
OSD_FontAspect myStyleOfValues;
int mySizeOfValues;
minMaxValuesCallback myCbCubicAxes;
void* myPtrVisual3dView;
public:
IMPLEMENT_MEMORY_OPERATORS
};
#endif //_OpenGl_GraduatedTrihedron_Header

1337
src/OpenGl/OpenGl_GraphicDriver.cdl
View File

File diff suppressed because it is too large Load Diff

100
src/OpenGl/OpenGl_GraphicDriver.cxx
View File

@ -1,29 +1,24 @@
// File: OpenGl_GraphicDriver.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
// File OpenGl_GraphicDriver.cxx #include <OpenGl_GraphicDriver.hxx>
// Created Mardi 28 janvier 1997
// Author CAL
//-Copyright MatraDatavision 1997 #include <OpenGl_View.hxx>
#include <OpenGl_Workspace.hxx>
//-Version IMPLEMENT_STANDARD_HANDLE(OpenGl_GraphicDriver,Graphic3d_GraphicDriver)
IMPLEMENT_STANDARD_RTTIEXT(OpenGl_GraphicDriver,Graphic3d_GraphicDriver)
//-Design Declaration des variables specifiques aux Drivers namespace
{
//-Warning Un driver encapsule les Pex, Phigs et OpenGl drivers // Global maps - shared by whole TKOpenGl module. To be removed.
static NCollection_DataMap<Standard_Integer, Handle(OpenGl_View)> TheMapOfView (1, NCollection_BaseAllocator::CommonBaseAllocator());
//-References static NCollection_DataMap<Standard_Integer, Handle(OpenGl_Workspace)> TheMapOfWS (1, NCollection_BaseAllocator::CommonBaseAllocator());
static NCollection_DataMap<Standard_Integer, OpenGl_Structure*> TheMapOfStructure (1, NCollection_BaseAllocator::CommonBaseAllocator());
//-Language C++ 2.0 static Standard_Boolean TheToUseVbo = Standard_True;
};
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.ixx>
#include <OpenGl_Extension.hxx>
//-Aliases
//-Global data definitions
// Pour eviter de "mangler" MetaGraphicDriverFactory, le nom de la // Pour eviter de "mangler" MetaGraphicDriverFactory, le nom de la
// fonction qui cree un Graphic3d_GraphicDriver. // fonction qui cree un Graphic3d_GraphicDriver.
@ -32,41 +27,62 @@
// classe Graphic3d_GraphicDevice // classe Graphic3d_GraphicDevice
extern "C" { extern "C" {
#ifdef WNT /* disable MS VC++ warning on C-style function returning C++ object */ #ifdef WNT /* disable MS VC++ warning on C-style function returning C++ object */
#pragma warning(push) #pragma warning(push)
#pragma warning(disable:4190) #pragma warning(disable:4190)
#endif #endif
Standard_EXPORT Handle(Graphic3d_GraphicDriver) MetaGraphicDriverFactory Standard_EXPORT Handle(Graphic3d_GraphicDriver) MetaGraphicDriverFactory (const Standard_CString AShrName)
(const Standard_CString AShrName); {
Standard_EXPORT Handle(Graphic3d_GraphicDriver) MetaGraphicDriverFactory Handle(OpenGl_GraphicDriver) aOpenDriver = new OpenGl_GraphicDriver (AShrName);
(const Standard_CString AShrName) { return aOpenDriver;
Handle(OpenGl_GraphicDriver) aOpenDriver = new OpenGl_GraphicDriver (AShrName); }
return aOpenDriver;
// return new OpenGl_GraphicDriver (AShrName);
}
#ifdef WNT #ifdef WNT
#pragma warning(pop) #pragma warning(pop)
#endif #endif
} }
//-Constructors OpenGl_GraphicDriver::OpenGl_GraphicDriver (const Standard_CString theShrName)
: Graphic3d_GraphicDriver (theShrName)
OpenGl_GraphicDriver::OpenGl_GraphicDriver (const Standard_CString AShrName):Graphic3d_GraphicDriver (AShrName)
{ {
//
} }
//-Methods, in order
Standard_ShortReal OpenGl_GraphicDriver::DefaultTextHeight() const Standard_ShortReal OpenGl_GraphicDriver::DefaultTextHeight() const
{ {
return 16.; return 16.;
} }
GLboolean OpenGl_QueryExtensionGLX (const char *extName) NCollection_DataMap<Standard_Integer, Handle(OpenGl_View)>& OpenGl_GraphicDriver::GetMapOfViews()
{ {
return QueryExtensionGLX(const_cast<char *>(extName)); return TheMapOfView;
} }
GLboolean OpenGl_QueryExtension (const char *extName) NCollection_DataMap<Standard_Integer, Handle(OpenGl_Workspace)>& OpenGl_GraphicDriver::GetMapOfWorkspaces()
{ {
return QueryExtension(const_cast<char *>(extName)); return TheMapOfWS;
}
NCollection_DataMap<Standard_Integer, OpenGl_Structure*>& OpenGl_GraphicDriver::GetMapOfStructures()
{
return TheMapOfStructure;
}
//TsmInitUpdateState
void OpenGl_GraphicDriver::InvalidateAllWorkspaces()
{
for (NCollection_DataMap<Standard_Integer, Handle(OpenGl_Workspace)>::Iterator anIt (OpenGl_GraphicDriver::GetMapOfWorkspaces());
anIt.More(); anIt.Next())
{
anIt.ChangeValue()->Invalidate();
anIt.ChangeValue()->EraseAnimation();
}
}
Standard_Boolean OpenGl_GraphicDriver::ToUseVBO()
{
return TheToUseVbo;
}
void OpenGl_GraphicDriver::EnableVBO (const Standard_Boolean theToTurnOn)
{
TheToUseVbo = theToTurnOn;
} }

317
src/OpenGl/OpenGl_GraphicDriver.hxx Normal file
View File

@ -0,0 +1,317 @@
// File: OpenGl_GraphicDriver.hxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _OpenGl_GraphicDriver_HeaderFile
#define _OpenGl_GraphicDriver_HeaderFile
#include <Graphic3d_GraphicDriver.hxx>
#include <Handle_OpenGl_GraphicDriver.hxx>
#include <Standard_CString.hxx>
#include <Handle_TColStd_HArray1OfByte.hxx>
#include <Handle_TColStd_HArray1OfReal.hxx>
#include <Quantity_PlaneAngle.hxx>
#include <Quantity_NameOfColor.hxx>
#include <Handle_AlienImage_AlienImage.hxx>
#include <Image_CRawBufferData.hxx>
#include <Aspect_Display.hxx>
#include <Aspect_GradientFillMethod.hxx>
#include <Aspect_FillMethod.hxx>
#include <Aspect_CLayer2d.hxx>
#include <Aspect_TypeOfTriedronPosition.hxx>
#include <Aspect_TypeOfTriedronEcho.hxx>
#include <Aspect_Handle.hxx>
#include <Aspect_PrintAlgo.hxx>
#include <Graphic3d_CView.hxx>
#include <Graphic3d_CStructure.hxx>
#include <Graphic3d_CGroup.hxx>
#include <Graphic3d_TypeOfPrimitive.hxx>
#include <Graphic3d_CPick.hxx>
#include <Graphic3d_TypeOfPolygon.hxx>
#include <Graphic3d_TextPath.hxx>
#include <Graphic3d_HorizontalTextAlignment.hxx>
#include <Graphic3d_VerticalTextAlignment.hxx>
#include <Graphic3d_PrimitiveArray.hxx>
#include <Graphic3d_CUserDraw.hxx>
#include <Graphic3d_CGraduatedTrihedron.hxx>
#include <Graphic3d_TypeOfComposition.hxx>
#include <Graphic3d_TypeOfTexture.hxx>
#include <Graphic3d_CInitTexture.hxx>
#include <Graphic3d_ExportFormat.hxx>
#include <Graphic3d_SortType.hxx>
#include <Graphic3d_PtrFrameBuffer.hxx>
#include <Graphic3d_Array1OfVertex.hxx>
#include <Graphic3d_Array1OfVertexN.hxx>
#include <Graphic3d_Array1OfVertexNT.hxx>
#include <Graphic3d_Array1OfVertexC.hxx>
#include <Graphic3d_Array1OfVertexNC.hxx>
#include <Graphic3d_Array2OfVertex.hxx>
#include <Graphic3d_Array2OfVertexN.hxx>
#include <Graphic3d_Array2OfVertexNT.hxx>
#include <NCollection_DataMap.hxx>
class TColStd_Array1OfInteger;
class TColStd_Array1OfReal;
class TColStd_Array2OfReal;
class TColStd_HArray1OfByte;
class Graphic3d_VertexNC;
class Graphic3d_Vector;
class Quantity_Color;
class Graphic3d_Vertex;
class Aspect_Array1OfEdge;
class TCollection_ExtendedString;
class AlienImage_AlienImage;
class TColStd_HArray1OfReal;
class Handle(OpenGl_View);
class Handle(OpenGl_Workspace);
class OpenGl_Structure;
//! This class defines an OpenGl graphic driver <br>
class OpenGl_GraphicDriver : public Graphic3d_GraphicDriver
{
public:
//! Constructor
Standard_EXPORT OpenGl_GraphicDriver (const Standard_CString theShrName);
Standard_EXPORT Standard_Boolean Begin (const Standard_CString ADisplay);
Standard_EXPORT Standard_Boolean Begin (const Aspect_Display ADisplay);
Standard_EXPORT void End ();
Standard_EXPORT Standard_Integer InquireLightLimit ();
Standard_EXPORT void InquireMat (const Graphic3d_CView& ACView, TColStd_Array2OfReal& AMatO, TColStd_Array2OfReal& AMatM);
Standard_EXPORT Standard_Integer InquireViewLimit ();
Standard_EXPORT Standard_Boolean InquireTextureAvailable ();
Standard_EXPORT void Blink (const Graphic3d_CStructure& ACStructure,const Standard_Boolean Create);
Standard_EXPORT void BoundaryBox (const Graphic3d_CStructure& ACStructure, const Standard_Boolean Create);
Standard_EXPORT void HighlightColor (const Graphic3d_CStructure& ACStructure, const Standard_ShortReal R, const Standard_ShortReal G, const Standard_ShortReal B, const Standard_Boolean Create);
Standard_EXPORT void NameSetStructure (const Graphic3d_CStructure& ACStructure);
public: // Methods for graphical groups
Standard_EXPORT void ClearGroup (const Graphic3d_CGroup& ACGroup);
Standard_EXPORT void CloseGroup (const Graphic3d_CGroup& ACGroup);
Standard_EXPORT void FaceContextGroup (const Graphic3d_CGroup& theCGroup,
const Standard_Integer theNoInsert);
Standard_EXPORT void Group (Graphic3d_CGroup& theCGroup);
Standard_EXPORT void LineContextGroup (const Graphic3d_CGroup& theCGroup,
const Standard_Integer theNoInsert);
Standard_EXPORT void MarkerContextGroup (const Graphic3d_CGroup& theCGroup,
const Standard_Integer theNoInsert);
Standard_EXPORT void MarkerContextGroup (const Graphic3d_CGroup& theCGroup,
const Standard_Integer theNoInsert,
const Standard_Integer theMarkWidth,
const Standard_Integer theMarkHeight,
const Handle(TColStd_HArray1OfByte)& theTexture);
Standard_EXPORT void OpenGroup (const Graphic3d_CGroup& theCGroup);
Standard_EXPORT void RemoveGroup (const Graphic3d_CGroup& theCGroup);
Standard_EXPORT void TextContextGroup (const Graphic3d_CGroup& theCGroup,
const Standard_Integer theNoInsert);
public: // Methods for graphical structures
Standard_EXPORT void ClearStructure (const Graphic3d_CStructure& theCStructure);
Standard_EXPORT void ContextStructure (const Graphic3d_CStructure& theCStructure);
Standard_EXPORT void Connect (const Graphic3d_CStructure& theFather,
const Graphic3d_CStructure& theSon);
Standard_EXPORT void Disconnect (const Graphic3d_CStructure& theFather,
const Graphic3d_CStructure& theSon);
Standard_EXPORT void DisplayStructure (const Graphic3d_CView& theCView,
const Graphic3d_CStructure& theCStructure,
const Standard_Integer thePriority);
Standard_EXPORT void EraseStructure (const Graphic3d_CView& theCView,
const Graphic3d_CStructure& theCStructure);
Standard_EXPORT void RemoveStructure (const Graphic3d_CStructure& theCStructure);
Standard_EXPORT void Structure (Graphic3d_CStructure& theCStructure);
public:
Standard_EXPORT void DumpGroup (const Graphic3d_CGroup& theCGroup);
Standard_EXPORT void DumpStructure (const Graphic3d_CStructure& theCStructure);
Standard_EXPORT void DumpView (const Graphic3d_CView& theCView);
Standard_EXPORT Standard_Boolean ElementExploration (const Graphic3d_CStructure& ACStructure, const Standard_Integer ElementNumber, Graphic3d_VertexNC& AVertex, Graphic3d_Vector& AVector);
Standard_EXPORT Graphic3d_TypeOfPrimitive ElementType (const Graphic3d_CStructure& ACStructure, const Standard_Integer ElementNumber);
Standard_EXPORT void InitPick ();
Standard_EXPORT void Pick (Graphic3d_CPick& ACPick);
Standard_EXPORT void PickId (const Graphic3d_CGroup& ACGroup);
Standard_EXPORT void ActivateView (const Graphic3d_CView& ACView);
Standard_EXPORT void AntiAliasing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag);
Standard_EXPORT void Background (const Graphic3d_CView& ACView);
Standard_EXPORT void GradientBackground (const Graphic3d_CView& ACView, const Quantity_Color& AColor1, const Quantity_Color& AColor2, const Aspect_GradientFillMethod FillStyle);
Standard_EXPORT void BackgroundImage (const Standard_CString FileName, const Graphic3d_CView& ACView, const Aspect_FillMethod FillStyle);
Standard_EXPORT void SetBgImageStyle (const Graphic3d_CView& ACView, const Aspect_FillMethod FillStyle);
Standard_EXPORT void SetBgGradientStyle (const Graphic3d_CView& ACView, const Aspect_GradientFillMethod FillStyle);
Standard_EXPORT void ClipLimit (const Graphic3d_CView& ACView, const Standard_Boolean AWait);
Standard_EXPORT void DeactivateView (const Graphic3d_CView& ACView);
Standard_EXPORT void DepthCueing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag);
Standard_EXPORT Standard_Boolean ProjectRaster (const Graphic3d_CView& ACView, const Standard_ShortReal AX, const Standard_ShortReal AY, const Standard_ShortReal AZ, Standard_Integer& AU, Standard_Integer& AV);
Standard_EXPORT Standard_Boolean UnProjectRaster (const Graphic3d_CView& ACView, const Standard_Integer Axm, const Standard_Integer Aym, const Standard_Integer AXM, const Standard_Integer AYM, const Standard_Integer AU, const Standard_Integer AV, Standard_ShortReal& AX, Standard_ShortReal& AY, Standard_ShortReal& AZ);
Standard_EXPORT Standard_Boolean UnProjectRasterWithRay (const Graphic3d_CView& ACView, const Standard_Integer Axm, const Standard_Integer Aym, const Standard_Integer AXM, const Standard_Integer AYM, const Standard_Integer AU, const Standard_Integer AV, Standard_ShortReal& AX, Standard_ShortReal& AY, Standard_ShortReal& AZ, Standard_ShortReal& DX, Standard_ShortReal& DY, Standard_ShortReal& DZ);
Standard_EXPORT void RatioWindow (const Graphic3d_CView& ACView);
Standard_EXPORT void Redraw (const Graphic3d_CView& ACView, const Aspect_CLayer2d& ACUnderLayer, const Aspect_CLayer2d& ACOverLayer, const Standard_Integer x = 0, const Standard_Integer y = 0, const Standard_Integer width = 0, const Standard_Integer height = 0);
Standard_EXPORT void RemoveView (const Graphic3d_CView& ACView);
Standard_EXPORT void SetLight (const Graphic3d_CView& ACView);
Standard_EXPORT void SetPlane (const Graphic3d_CView& ACView);
Standard_EXPORT void SetVisualisation (const Graphic3d_CView& ACView);
Standard_EXPORT void TransformStructure (const Graphic3d_CStructure& ACStructure);
Standard_EXPORT void DegenerateStructure (const Graphic3d_CStructure& ACStructure);
Standard_EXPORT void Transparency (const Graphic3d_CView& ACView, const Standard_Boolean AFlag);
Standard_EXPORT void Update (const Graphic3d_CView& ACView, const Aspect_CLayer2d& ACUnderLayer, const Aspect_CLayer2d& ACOverLayer);
Standard_EXPORT Standard_Boolean View (Graphic3d_CView& ACView);
Standard_EXPORT void ViewMapping (const Graphic3d_CView& ACView, const Standard_Boolean AWait);
Standard_EXPORT void ViewOrientation (const Graphic3d_CView& ACView,const Standard_Boolean AWait);
Standard_EXPORT void Environment (const Graphic3d_CView& ACView);
Standard_EXPORT void Marker (const Graphic3d_CGroup& ACGroup, const Graphic3d_Vertex& APoint, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void MarkerSet (const Graphic3d_CGroup& ACGroup, const Graphic3d_Array1OfVertex& ListVertex, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void Polygon (const Graphic3d_CGroup& ACGroup, const Graphic3d_Array1OfVertex& ListVertex, const Graphic3d_TypeOfPolygon AType = Graphic3d_TOP_CONVEX, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void Polygon (const Graphic3d_CGroup& ACGroup, const Graphic3d_Array1OfVertex& ListVertex, const Graphic3d_Vector& Normal, const Graphic3d_TypeOfPolygon AType = Graphic3d_TOP_CONVEX, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void Polygon (const Graphic3d_CGroup& ACGroup, const Graphic3d_Array1OfVertexN& ListVertex, const Graphic3d_TypeOfPolygon AType = Graphic3d_TOP_CONVEX, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void Polygon (const Graphic3d_CGroup& ACGroup, const Graphic3d_Array1OfVertexN& ListVertex, const Graphic3d_Vector& Normal, const Graphic3d_TypeOfPolygon AType = Graphic3d_TOP_CONVEX, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void Polygon (const Graphic3d_CGroup& ACGroup, const Graphic3d_Array1OfVertexNT& ListVertex, const Graphic3d_TypeOfPolygon AType = Graphic3d_TOP_CONVEX, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void PolygonHoles (const Graphic3d_CGroup& ACGroup, const TColStd_Array1OfInteger& Bounds, const Graphic3d_Array1OfVertex& ListVertex, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void PolygonHoles (const Graphic3d_CGroup& ACGroup, const TColStd_Array1OfInteger& Bounds, const Graphic3d_Array1OfVertex& ListVertex, const Graphic3d_Vector& Normal, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void PolygonHoles (const Graphic3d_CGroup& ACGroup, const TColStd_Array1OfInteger& Bounds, const Graphic3d_Array1OfVertexN& ListVertex, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void PolygonHoles (const Graphic3d_CGroup& ACGroup, const TColStd_Array1OfInteger& Bounds, const Graphic3d_Array1OfVertexN& ListVertex, const Graphic3d_Vector& Normal, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void Polyline (const Graphic3d_CGroup& ACGroup, const Standard_Real X1, const Standard_Real Y1, const Standard_Real Z1, const Standard_Real X2, const Standard_Real Y2, const Standard_Real Z2, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void Polyline (const Graphic3d_CGroup& ACGroup, const Graphic3d_Array1OfVertex& ListVertex, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void Polyline (const Graphic3d_CGroup& ACGroup, const Graphic3d_Array1OfVertexC& ListVertex, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void QuadrangleMesh (const Graphic3d_CGroup& ACGroup, const Graphic3d_Array2OfVertex& ListVertex, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void QuadrangleMesh (const Graphic3d_CGroup& ACGroup, const Graphic3d_Array2OfVertexN& ListVertex, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void QuadrangleMesh (const Graphic3d_CGroup& ACGroup, const Graphic3d_Array2OfVertexNT& ListVertex, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void Text (const Graphic3d_CGroup& ACGroup, const Standard_CString AText, const Graphic3d_Vertex& APoint, const Standard_Real AHeight, const Quantity_PlaneAngle AAngle, const Graphic3d_TextPath ATp, const Graphic3d_HorizontalTextAlignment AHta, const Graphic3d_VerticalTextAlignment AVta, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void Text (const Graphic3d_CGroup& ACGroup, const Standard_CString AText, const Graphic3d_Vertex& APoint, const Standard_Real AHeight, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void Text (const Graphic3d_CGroup& ACGroup, const TCollection_ExtendedString& AText, const Graphic3d_Vertex& APoint, const Standard_Real AHeight, const Quantity_PlaneAngle AAngle, const Graphic3d_TextPath ATp, const Graphic3d_HorizontalTextAlignment AHta, const Graphic3d_VerticalTextAlignment AVta, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void Text (const Graphic3d_CGroup& ACGroup, const TCollection_ExtendedString& AText, const Graphic3d_Vertex& APoint, const Standard_Real AHeight, const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void TriangleMesh (const Graphic3d_CGroup& ACGroup,const Graphic3d_Array1OfVertex& ListVertex,const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void TriangleMesh (const Graphic3d_CGroup& ACGroup,const Graphic3d_Array1OfVertexN& ListVertex,const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void TriangleMesh (const Graphic3d_CGroup& ACGroup,const Graphic3d_Array1OfVertexNT& ListVertex,const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void TriangleSet (const Graphic3d_CGroup& ACGroup,const Graphic3d_Array1OfVertex& ListVertex,const Aspect_Array1OfEdge& ListEdge,const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void TriangleSet (const Graphic3d_CGroup& ACGroup,const Graphic3d_Array1OfVertexN& ListVertex,const Aspect_Array1OfEdge& ListEdge,const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void TriangleSet (const Graphic3d_CGroup& ACGroup,const Graphic3d_Array1OfVertexNT& ListVertex,const Aspect_Array1OfEdge& ListEdge,const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void TriangleSet (const Graphic3d_CGroup& ACGroup,const Graphic3d_Array1OfVertexC& ListVertex,const Aspect_Array1OfEdge& ListEdge,const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void TriangleSet (const Graphic3d_CGroup& ACGroup,const Graphic3d_Array1OfVertexNC& ListVertex,const Aspect_Array1OfEdge& ListEdge,const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void PrimitiveArray (const Graphic3d_CGroup& ACGroup,const Graphic3d_PrimitiveArray& parray,const Standard_Boolean EvalMinMax = Standard_True);
Standard_EXPORT void UserDraw (const Graphic3d_CGroup& ACGroup,const Graphic3d_CUserDraw& AUserDraw);
Standard_EXPORT void ZBufferTriedronSetup (const Quantity_NameOfColor XColor = Quantity_NOC_RED, const Quantity_NameOfColor YColor = Quantity_NOC_GREEN, const Quantity_NameOfColor ZColor = Quantity_NOC_BLUE1, const Standard_Real SizeRatio = 0.8, const Standard_Real AxisDiametr = 0.05, const Standard_Integer NbFacettes = 12);
Standard_EXPORT void TriedronDisplay (const Graphic3d_CView& ACView, const Aspect_TypeOfTriedronPosition APosition = Aspect_TOTP_CENTER, const Quantity_NameOfColor AColor = Quantity_NOC_WHITE, const Standard_Real AScale = 0.02, const Standard_Boolean AsWireframe = Standard_True);
Standard_EXPORT void TriedronErase (const Graphic3d_CView& ACView);
Standard_EXPORT void TriedronEcho (const Graphic3d_CView& ACView, const Aspect_TypeOfTriedronEcho AType = Aspect_TOTE_NONE);
Standard_EXPORT void GraduatedTrihedronDisplay (const Graphic3d_CView& view, const Graphic3d_CGraduatedTrihedron& cubic);
Standard_EXPORT void GraduatedTrihedronErase (const Graphic3d_CView& view);
Standard_EXPORT void GraduatedTrihedronMinMaxValues (const Standard_ShortReal xmin, const Standard_ShortReal ymin, const Standard_ShortReal zmin, const Standard_ShortReal xmax, const Standard_ShortReal ymax, const Standard_ShortReal zmax);
Standard_EXPORT void BeginAnimation (const Graphic3d_CView& ACView);
Standard_EXPORT void EndAnimation (const Graphic3d_CView& ACView);
Standard_EXPORT Standard_Boolean BeginAddMode (const Graphic3d_CView& ACView);
Standard_EXPORT void EndAddMode ();
Standard_EXPORT Standard_Boolean BeginImmediatMode(const Graphic3d_CView& ACView, const Aspect_CLayer2d& ACUnderLayer, const Aspect_CLayer2d& ACOverLayer, const Standard_Boolean DoubleBuffer, const Standard_Boolean RetainMode);
Standard_EXPORT void BeginPolyline ();
Standard_EXPORT void ClearImmediatMode (const Graphic3d_CView& ACView,const Standard_Boolean aFlush = Standard_True);
Standard_EXPORT void Draw (const Standard_ShortReal X, const Standard_ShortReal Y, const Standard_ShortReal Z);
Standard_EXPORT void DrawStructure (const Graphic3d_CStructure& ACStructure);
Standard_EXPORT void EndImmediatMode (const Standard_Integer Synchronize);
Standard_EXPORT void EndPolyline ();
Standard_EXPORT void Move (const Standard_ShortReal X, const Standard_ShortReal Y, const Standard_ShortReal Z);
Standard_EXPORT void SetLineColor (const Standard_ShortReal R, const Standard_ShortReal G, const Standard_ShortReal B);
Standard_EXPORT void SetLineType (const Standard_Integer Type);
Standard_EXPORT void SetLineWidth (const Standard_ShortReal Width);
Standard_EXPORT void SetMinMax (const Standard_ShortReal X1, const Standard_ShortReal Y1, const Standard_ShortReal Z1, const Standard_ShortReal X2, const Standard_ShortReal Y2, const Standard_ShortReal Z2);
Standard_EXPORT void Transform (const TColStd_Array2OfReal& AMatrix, const Graphic3d_TypeOfComposition AType);
Standard_EXPORT void Layer (Aspect_CLayer2d& ACLayer);
Standard_EXPORT void RemoveLayer (const Aspect_CLayer2d& ACLayer);
Standard_EXPORT void BeginLayer (const Aspect_CLayer2d& ACLayer);
Standard_EXPORT void BeginPolygon2d ();
Standard_EXPORT void BeginPolyline2d ();
Standard_EXPORT void ClearLayer (const Aspect_CLayer2d& ACLayer);
Standard_EXPORT void Draw (const Standard_ShortReal X,const Standard_ShortReal Y);
Standard_EXPORT void Edge (const Standard_ShortReal X,const Standard_ShortReal Y);
Standard_EXPORT void EndLayer ();
Standard_EXPORT void EndPolygon2d ();
Standard_EXPORT void EndPolyline2d ();
Standard_EXPORT void Move (const Standard_ShortReal X,const Standard_ShortReal Y);
Standard_EXPORT void Rectangle (const Standard_ShortReal X,const Standard_ShortReal Y,const Standard_ShortReal Width,const Standard_ShortReal Height);
Standard_EXPORT void SetColor (const Standard_ShortReal R,const Standard_ShortReal G,const Standard_ShortReal B);
Standard_EXPORT void SetTransparency (const Standard_ShortReal ATransparency);
Standard_EXPORT void UnsetTransparency ();
Standard_EXPORT void SetLineAttributes (const Standard_Integer Type,const Standard_ShortReal Width);
Standard_EXPORT void SetTextAttributes (const Standard_CString FontName,const Standard_Integer Type,const Standard_ShortReal R,const Standard_ShortReal G,const Standard_ShortReal B);
Standard_EXPORT void Text (const Standard_CString AText,const Standard_ShortReal X,const Standard_ShortReal Y,const Standard_ShortReal AHeight);
Standard_EXPORT void TextSize (const Standard_CString AText,const Standard_ShortReal AHeight,Standard_ShortReal& AWidth,Standard_ShortReal& AnAscent,Standard_ShortReal& ADescent) const;
Standard_EXPORT void SetBackFacingModel (const Graphic3d_CView& aView);
//! print the contents of all layers of the view to the printer. <br>
//! <hPrnDC> : Pass the PrinterDeviceContext (HDC), <br>
//! <showBackground> : When set to FALSE then print the view without background color <br>
//! (background is white) <br>
//! else set to TRUE for printing with current background color. <br>
//! <filename>: If != NULL, then the view will be printed to a file. <br>
//! <printAlgorithm>: Select print algorithm: stretch, tile. <br>
//! <theScaleFactor>: Scaling coefficient, used internally to scale the <br>
//! printings accordingly to the scale factor selected in the printer <br>
//! properties dialog. <br>
//! Returns Standard_True if the data is passed to the printer, otherwise <br>
//! Standard_False if the print operation failed due to the printer errors, <br>
//! or lack of system memory. This might be related to insufficient memory <br>
//! or some internal errors. All this errors are indicated by the message <br>
//! boxes (on level of OpenGl_GraphicDriver). <br>
//! Warning: This function can reuse FBO assigned to the view <br>
//! Please take it into account if you use it for your purposes; <br>
Standard_EXPORT Standard_Boolean Print (const Graphic3d_CView& ACView, const Aspect_CLayer2d& ACUnderLayer, const Aspect_CLayer2d& ACOverLayer, const Aspect_Handle hPrnDC, const Standard_Boolean showBackground, const Standard_CString filename, const Aspect_PrintAlgo printAlgorithm = Aspect_PA_STRETCH, const Standard_Real theScaleFactor = 1.0) const;
Standard_EXPORT void SetDepthTestEnabled (const Graphic3d_CView& view,const Standard_Boolean isEnabled) const;
Standard_EXPORT Standard_Boolean IsDepthTestEnabled (const Graphic3d_CView& view) const;
//! Reads depths of shown pixels of the given rectangle (glReadPixels with GL_DEPTH_COMPONENT) <br>
Standard_EXPORT void ReadDepths (const Graphic3d_CView& view,const Standard_Integer x,const Standard_Integer y,const Standard_Integer width,const Standard_Integer height,const Standard_Address buffer) const;
//! Generate offscreen FBO (needs OpenGL2+ hardware) <br>
//! If not supported on hardware returns NULL. <br>
Standard_EXPORT Graphic3d_PtrFrameBuffer FBOCreate (const Graphic3d_CView& view, const Standard_Integer width, const Standard_Integer height);
//! Remove offscreen FBO <br>
Standard_EXPORT void FBORelease (const Graphic3d_CView& view, Graphic3d_PtrFrameBuffer& fboPtr);
//! Dump active rendering buffer into specified memory buffer. <br>
Standard_EXPORT Standard_Boolean BufferDump (const Graphic3d_CView& view, Image_CRawBufferData& buffer);
Standard_EXPORT void SetGLLightEnabled (const Graphic3d_CView& view,const Standard_Boolean isEnabled) const;
Standard_EXPORT Standard_Boolean IsGLLightEnabled (const Graphic3d_CView& view) const;
//! Clear visualization data in graphical driver and stop <br>
//! displaying the primitives array of the graphical group <theCGroup>. <br>
//! This method is internal and should be used by Graphic3d_Group only. <br>
Standard_EXPORT void RemovePrimitiveArray(const Graphic3d_CGroup& theCGroup,const Graphic3d_PrimitiveArray& thePArray);
Standard_EXPORT Standard_Integer InquirePlaneLimit();
Standard_EXPORT Standard_Integer CreateTexture(const Graphic3d_TypeOfTexture Type,const Handle(AlienImage_AlienImage)& Image,const Standard_CString FileName,const Handle(TColStd_HArray1OfReal)& TexUpperBounds) const;
Standard_EXPORT void DestroyTexture(const Standard_Integer TexId) const;
Standard_EXPORT void ModifyTexture(const Standard_Integer TexId,const Graphic3d_CInitTexture& AValue) const;
Standard_EXPORT Standard_ShortReal DefaultTextHeight() const;
Standard_EXPORT void FBOGetDimensions(const Graphic3d_CView& view,const Graphic3d_PtrFrameBuffer fboPtr,Standard_Integer& width,Standard_Integer& height,Standard_Integer& widthMax,Standard_Integer& heightMax);
Standard_EXPORT void FBOChangeViewport(const Graphic3d_CView& view,Graphic3d_PtrFrameBuffer& fboPtr,const Standard_Integer width,const Standard_Integer height);
Standard_EXPORT Standard_Boolean Export(const Standard_CString theFileName,const Graphic3d_ExportFormat theFormat,const Graphic3d_SortType theSortType,const Standard_Integer theWidth,const Standard_Integer theHeight,const Graphic3d_CView& theView,const Aspect_CLayer2d& theLayerUnder,const Aspect_CLayer2d& theLayerOver,const Standard_Real thePrecision = 0.005,const Standard_Address theProgressBarFunc = NULL,const Standard_Address theProgressObject = NULL);
public:
//! Returns true if VBO usage does not forbidden.
Standard_EXPORT static Standard_Boolean ToUseVBO();
//! VBO usage can be forbidden by this method even if it is supported by GL driver.
//! Notice that disabling of VBO will cause rendering performance degradation.
//! Warning! This method should be called only before any primitives are displayed in GL scene!
Standard_EXPORT void EnableVBO (const Standard_Boolean theToTurnOn);
private:
//! Access the global map of views.
static NCollection_DataMap<Standard_Integer, Handle(OpenGl_View)>& GetMapOfViews();
//! Access the global map of workspaces.
static NCollection_DataMap<Standard_Integer, Handle(OpenGl_Workspace)>& GetMapOfWorkspaces();
//! Access the global map of structures.
static NCollection_DataMap<Standard_Integer, OpenGl_Structure*>& GetMapOfStructures();
//! Invalidates all workspaces - thus they will be redrawn on next update call.
static void InvalidateAllWorkspaces();
public:
DEFINE_STANDARD_RTTI(OpenGl_GraphicDriver)
};
#endif //_OpenGl_GraphicDriver_HeaderFile

121
src/OpenGl/OpenGl_GraphicDriver_1.cxx
View File

@ -1,36 +1,15 @@
// File: OpenGl_GraphicDriver_1.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_GraphicDriver.hxx>
// File OpenGl_GraphicDriver_1.cxx #include <Standard_ErrorHandler.hxx>
// Created Mardi 28 janvier 1997 #include <Standard_Failure.hxx>
// Author CAL
// Modified GG 27/12/02 IMP120302 Add new method Begin(Aspect_Display)
//-Copyright MatraDatavision 1997 #include <OpenGl_CView.hxx>
#include <OpenGl_Display.hxx>
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OpenGl_tgl_funcs.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
//======================================================================= //=======================================================================
//function : Begin //function : Begin
@ -39,24 +18,17 @@
Standard_Boolean OpenGl_GraphicDriver::Begin (const Standard_CString ADisplay) Standard_Boolean OpenGl_GraphicDriver::Begin (const Standard_CString ADisplay)
{ {
try
{
Standard_Boolean Result; openglDisplay = new OpenGl_Display(ADisplay);
return Standard_True;
if (MyTraceLevel) {
PrintFunction ("call_togl_begin");
PrintString ("Display", ADisplay);
} }
Result = call_togl_begin ((Standard_PCharacter)ADisplay); catch (Standard_Failure)
if (MyTraceLevel) { {
PrintIResult ("call_togl_begin", Result);
} }
return Standard_False;
return Result;
} }
//RIC120302
//======================================================================= //=======================================================================
//function : Begin //function : Begin
//purpose : //purpose :
@ -64,34 +36,25 @@ Standard_Boolean OpenGl_GraphicDriver::Begin (const Standard_CString ADisplay)
Standard_Boolean OpenGl_GraphicDriver::Begin (const Aspect_Display ADisplay) Standard_Boolean OpenGl_GraphicDriver::Begin (const Aspect_Display ADisplay)
{ {
try
Standard_Boolean Result; {
openglDisplay = new OpenGl_Display(ADisplay);
if (MyTraceLevel) { return Standard_True;
PrintFunction ("call_togl_begin_display");
} }
Result = call_togl_begin_display (ADisplay); catch (Standard_Failure)
if (MyTraceLevel) { {
PrintIResult ("call_togl_begin_display", Result);
} }
return Standard_False;
return Result;
} }
//RIC120302
//======================================================================= //=======================================================================
//function : End //function : End
//purpose : //purpose :
//======================================================================= //=======================================================================
void OpenGl_GraphicDriver::End () { void OpenGl_GraphicDriver::End ()
{
if (MyTraceLevel) { openglDisplay.Nullify();
PrintFunction ("call_togl_end");
}
call_togl_end ();
} }
//======================================================================= //=======================================================================
@ -99,16 +62,15 @@ void OpenGl_GraphicDriver::End () {
//purpose : //purpose :
//======================================================================= //=======================================================================
void OpenGl_GraphicDriver::BeginAnimation (const Graphic3d_CView& ACView) { void OpenGl_GraphicDriver::BeginAnimation (const Graphic3d_CView& ACView)
{
Graphic3d_CView MyCView = ACView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
if (MyTraceLevel) { {
PrintFunction ("call_togl_begin_animation"); const Standard_Boolean UpdateAM = (ACView.IsDegenerates && !ACView.IsDegeneratesPrev) || (!ACView.IsDegenerates && ACView.IsDegeneratesPrev);
PrintCView (MyCView, 1); aCView->WS->BeginAnimation(ACView.IsDegenerates != 0,UpdateAM);
((Graphic3d_CView*)(&ACView))->IsDegeneratesPrev = ACView.IsDegenerates; //szvgl: temporary
} }
call_togl_begin_animation (&MyCView);
} }
//======================================================================= //=======================================================================
@ -116,14 +78,9 @@ void OpenGl_GraphicDriver::BeginAnimation (const Graphic3d_CView& ACView) {
//purpose : //purpose :
//======================================================================= //=======================================================================
void OpenGl_GraphicDriver::EndAnimation (const Graphic3d_CView& ACView) { void OpenGl_GraphicDriver::EndAnimation (const Graphic3d_CView& ACView)
{
Graphic3d_CView MyCView = ACView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
if (MyTraceLevel) { aCView->WS->EndAnimation();
PrintFunction ("call_togl_end_animation");
PrintCView (MyCView, 1);
}
call_togl_end_animation (&MyCView);
} }

137
src/OpenGl/OpenGl_GraphicDriver_2.cxx
View File

@ -1,125 +1,40 @@
// File: OpenGl_GraphicDriver_2.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_GraphicDriver.hxx>
// File OpenGl_GraphicDriver_2.cxx #include <OpenGl_Display.hxx>
// Created Mardi 28 janvier 1997 #include <OpenGl_CView.hxx>
// Author CAL
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OpenGl_tgl_all.hxx>
#include <OpenGl_tgl_funcs.hxx> #include <OpenGl_tgl_funcs.hxx>
//-Aliases Standard_Integer OpenGl_GraphicDriver::InquireLightLimit ()
{
//-Global data definitions return (openglDisplay.IsNull()? 0 : openglDisplay->Facilities().MaxLights);
//-Methods, in order
Standard_Integer OpenGl_GraphicDriver::InquireLightLimit () {
if (MyTraceLevel) {
PrintFunction ("call_togl_inquirelight");
}
Standard_Integer Result = call_togl_inquirelight ();
if (MyTraceLevel) {
PrintIResult ("call_togl_inquirelight", Result);
}
return Result;
} }
void OpenGl_GraphicDriver::InquireMat (const Graphic3d_CView& ACView, TColStd_Array2OfReal& AMatO, TColStd_Array2OfReal& AMatM) { void OpenGl_GraphicDriver::InquireMat (const Graphic3d_CView& ACView, TColStd_Array2OfReal& AMatO, TColStd_Array2OfReal& AMatM)
{
Graphic3d_CView MyCView = ACView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
Standard_Integer i, j; aCView->View->GetMatrices(AMatO,AMatM,ACView.Orientation.IsCustomMatrix);
CALL_DEF_MATRIX4X4 ori_matrix;
CALL_DEF_MATRIX4X4 map_matrix;
if (MyTraceLevel) {
PrintFunction ("call_togl_inquiremat");
PrintCView (MyCView, 1);
}
if (call_togl_inquiremat (&MyCView, ori_matrix, map_matrix) == 0)
for (i=0; i<=3; i++)
for (j=0; j<=3; j++) {
AMatO (i, j) = Standard_Real (ori_matrix[i][j]);
AMatM (i, j) = Standard_Real (map_matrix[i][j]);
}
else
for (i=0; i<=3; i++)
for (j=0; j<=3; j++) {
if (i == j) {
AMatM (i, j) = 1.0;
AMatO (i, j) = 1.0;
}
else {
AMatM (i, j) = 0.0;
AMatO (i, j) = 0.0;
}
}
if (MyTraceLevel) {
PrintMatrix ("Orientation", AMatO);
PrintMatrix ("Mapping", AMatM);
}
} }
Standard_Integer OpenGl_GraphicDriver::InquirePlaneLimit () { Standard_Integer OpenGl_GraphicDriver::InquireViewLimit ()
{
if (MyTraceLevel) { return (openglDisplay.IsNull()? 0 : openglDisplay->Facilities().MaxViews);
PrintFunction ("call_togl_inquireplane");
}
Standard_Integer Result = call_togl_inquireplane ();
if (MyTraceLevel) {
PrintIResult ("call_togl_inquireplane", Result);
}
return Result;
} }
Standard_Integer OpenGl_GraphicDriver::InquireViewLimit () { Standard_Boolean OpenGl_GraphicDriver::InquireTextureAvailable ()
{
if (MyTraceLevel) { return Standard_True;
PrintFunction ("call_togl_inquireview");
}
Standard_Integer Result = call_togl_inquireview ();
if (MyTraceLevel) {
PrintIResult ("call_togl_inquireview", Result);
}
return Result;
} }
Standard_Integer OpenGl_GraphicDriver::InquirePlaneLimit ()
{
Standard_Boolean OpenGl_GraphicDriver::InquireTextureAvailable () { return call_togl_inquireplane();
if (MyTraceLevel) {
PrintFunction ("call_togl_inquiretexture");
}
Standard_Integer Result = call_togl_inquiretexture ();
if (MyTraceLevel) {
PrintIResult ("call_togl_inquiretexture", Result);
}
return Result;
} }

253
src/OpenGl/OpenGl_GraphicDriver_3.cxx
View File

@ -1,176 +1,107 @@
// File: OpenGl_GraphicDriver_3.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_GraphicDriver.hxx>
// File OpenGl_GraphicDriver_3.cxx #include <TColStd_HArray1OfByte.hxx>
// Created Mardi 28 janvier 1997
// Author CAL
//-Copyright MatraDatavision 1997 #include <OpenGl_Display.hxx>
#include <OpenGl_Structure.hxx>
//-Version void OpenGl_GraphicDriver::ClearGroup (const Graphic3d_CGroup& theCGroup)
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OpenGl_tgl_funcs.hxx>
int GenerateMarkerBitmap( int theId, unsigned int theWidth, unsigned int theHeight, unsigned char* theArray);
//-Aliases
//-Global data definitions
//-Methods, in order
void OpenGl_GraphicDriver::ClearGroup (const Graphic3d_CGroup& ACGroup) {
Graphic3d_CGroup MyCGroup = ACGroup;
if (MyTraceLevel)
{
PrintFunction ("call_togl_cleargroup");
PrintCGroup (MyCGroup, 1);
}
call_togl_cleargroup (&MyCGroup);
}
void OpenGl_GraphicDriver::CloseGroup (const Graphic3d_CGroup& ACGroup) {
Graphic3d_CGroup MyCGroup = ACGroup;
if (MyTraceLevel) {
PrintFunction ("call_togl_closegroup");
PrintCGroup (MyCGroup, 1);
}
call_togl_closegroup (&MyCGroup);
}
void OpenGl_GraphicDriver::FaceContextGroup (const Graphic3d_CGroup& ACGroup, const Standard_Integer NoInsert) {
Graphic3d_CGroup MyCGroup = ACGroup;
if (MyTraceLevel) {
PrintFunction ("call_togl_facecontextgroup");
PrintCGroup (MyCGroup, 1);
PrintInteger ("NoInsert", NoInsert);
}
call_togl_facecontextgroup (&MyCGroup, int (NoInsert));
}
void OpenGl_GraphicDriver::Group (Graphic3d_CGroup& ACGroup) {
Graphic3d_CGroup MyCGroup = ACGroup;
if (MyTraceLevel) {
PrintFunction ("call_togl_group");
PrintCGroup (MyCGroup, 1);
}
call_togl_group (&MyCGroup);
}
void OpenGl_GraphicDriver::LineContextGroup (const Graphic3d_CGroup& ACGroup, const Standard_Integer NoInsert) {
Graphic3d_CGroup MyCGroup = ACGroup;
if (MyTraceLevel) {
PrintFunction ("call_togl_linecontextgroup");
PrintCGroup (MyCGroup, 1);
PrintInteger ("NoInsert", NoInsert);
}
call_togl_linecontextgroup (&MyCGroup, int (NoInsert));
}
void OpenGl_GraphicDriver::MarkerContextGroup (const Graphic3d_CGroup& ACGroup, const Standard_Integer NoInsert) {
Graphic3d_CGroup MyCGroup = ACGroup;
if (MyTraceLevel) {
PrintFunction ("call_togl_markercontextgroup");
PrintCGroup (MyCGroup, 1);
PrintInteger ("NoInsert", NoInsert);
}
call_togl_markercontextgroup (&MyCGroup, int (NoInsert));
}
void OpenGl_GraphicDriver::MarkerContextGroup (const Graphic3d_CGroup& ACGroup,
const Standard_Integer NoInsert,
const Standard_Integer AMarkWidth,
const Standard_Integer AMarkHeight,
const Handle(TColStd_HArray1OfByte)& ATexture )
{ {
if (theCGroup.ptrGroup == NULL)
return;
Graphic3d_CGroup MyCGroup = ACGroup; ((OpenGl_Group* )theCGroup.ptrGroup)->Clear();
InvalidateAllWorkspaces();
int aByteWidth = AMarkWidth / 8;
unsigned char *anArray = (unsigned char*) malloc(ATexture->Length());
for( int anIndex = ATexture->Upper() - ATexture->Lower() - aByteWidth + 1; anIndex >= 0; anIndex -= aByteWidth )
for( int i = 0; i < aByteWidth; i++ )
anArray[ATexture->Upper() - ATexture->Lower() - aByteWidth + 1 - anIndex + i ] = ATexture->Value( anIndex + i + 1 );
GenerateMarkerBitmap( (int)ACGroup.ContextMarker.Scale, AMarkWidth, AMarkHeight, anArray );
if (MyTraceLevel) {
PrintFunction ("call_togl_markercontextgroup");
PrintCGroup (MyCGroup, 1);
PrintInteger ("NoInsert", NoInsert);
}
call_togl_markercontextgroup (&MyCGroup, int (NoInsert));
free(anArray);
} }
void OpenGl_GraphicDriver::CloseGroup (const Graphic3d_CGroup& )
void OpenGl_GraphicDriver::OpenGroup (const Graphic3d_CGroup& ACGroup) { {
// Do nothing
Graphic3d_CGroup MyCGroup = ACGroup;
if (MyTraceLevel) {
PrintFunction ("call_togl_opengroup");
PrintCGroup (MyCGroup, 1);
}
call_togl_opengroup (&MyCGroup);
} }
void OpenGl_GraphicDriver::RemoveGroup (const Graphic3d_CGroup& ACGroup) { void OpenGl_GraphicDriver::FaceContextGroup (const Graphic3d_CGroup& theCGroup,
const Standard_Integer theNoInsert)
Graphic3d_CGroup MyCGroup = ACGroup; {
if (!theCGroup.ContextFillArea.IsDef || theCGroup.ptrGroup == NULL)
if (MyTraceLevel) { return;
PrintFunction ("call_togl_removegroup");
PrintCGroup (MyCGroup, 1);
}
call_togl_removegroup (&MyCGroup);
((OpenGl_Group* )theCGroup.ptrGroup)->SetAspectFace (theCGroup.ContextFillArea, theNoInsert);
InvalidateAllWorkspaces();
} }
void OpenGl_GraphicDriver::TextContextGroup (const Graphic3d_CGroup& ACGroup, const Standard_Integer NoInsert) { void OpenGl_GraphicDriver::Group (Graphic3d_CGroup& theCGroup)
{
Graphic3d_CGroup MyCGroup = ACGroup; OpenGl_Structure* aStructure = (OpenGl_Structure* )theCGroup.Struct->ptrStructure;
if (aStructure)
if (MyTraceLevel) { {
PrintFunction ("call_togl_textcontextgroup"); theCGroup.ptrGroup = aStructure->AddGroup();
PrintCGroup (MyCGroup, 1); InvalidateAllWorkspaces();
PrintInteger ("NoInsert", NoInsert);
} }
call_togl_textcontextgroup (&MyCGroup, int (NoInsert)); }
void OpenGl_GraphicDriver::LineContextGroup (const Graphic3d_CGroup& theCGroup,
const Standard_Integer theNoInsert)
{
if (!theCGroup.ContextLine.IsDef || theCGroup.ptrGroup == NULL) return;
((OpenGl_Group* )theCGroup.ptrGroup)->SetAspectLine (theCGroup.ContextLine, theNoInsert);
InvalidateAllWorkspaces();
}
void OpenGl_GraphicDriver::MarkerContextGroup (const Graphic3d_CGroup& theCGroup,
const Standard_Integer theNoInsert)
{
if (!theCGroup.ContextMarker.IsDef || theCGroup.ptrGroup == NULL) return;
((OpenGl_Group* )theCGroup.ptrGroup)->SetAspectMarker (theCGroup.ContextMarker, theNoInsert);
InvalidateAllWorkspaces();
}
void OpenGl_GraphicDriver::MarkerContextGroup (const Graphic3d_CGroup& theCGroup,
const Standard_Integer theNoInsert,
const Standard_Integer theMarkWidth,
const Standard_Integer theMarkHeight,
const Handle(TColStd_HArray1OfByte)& theTexture)
{
if(!theCGroup.ContextMarker.IsDef)
return;
if (!openglDisplay.IsNull())
openglDisplay->AddUserMarker ((int )theCGroup.ContextMarker.Scale, theMarkWidth, theMarkHeight, theTexture);
if (theCGroup.ptrGroup != NULL)
{
((OpenGl_Group* )theCGroup.ptrGroup)->SetAspectMarker (theCGroup.ContextMarker, theNoInsert);
InvalidateAllWorkspaces();
}
}
void OpenGl_GraphicDriver::OpenGroup (const Graphic3d_CGroup& )
{
// Do nothing
}
void OpenGl_GraphicDriver::RemoveGroup (const Graphic3d_CGroup& theCGroup)
{
OpenGl_Structure* aStructure = (OpenGl_Structure* )theCGroup.Struct->ptrStructure;
if (aStructure == NULL)
return;
aStructure->RemoveGroup ((const OpenGl_Group* )theCGroup.ptrGroup);
InvalidateAllWorkspaces();
}
void OpenGl_GraphicDriver::TextContextGroup (const Graphic3d_CGroup& theCGroup,
const Standard_Integer theNoInsert)
{
if (!theCGroup.ContextText.IsDef || theCGroup.ptrGroup == NULL)
return;
((OpenGl_Group* )theCGroup.ptrGroup)->SetAspectText (theCGroup.ContextText, theNoInsert);
InvalidateAllWorkspaces();
} }

205
src/OpenGl/OpenGl_GraphicDriver_4.cxx
View File

@ -1,142 +1,117 @@
// File: OpenGl_GraphicDriver_4.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_GraphicDriver.hxx>
// File OpenGl_GraphicDriver_4.cxx #include <NCollection_DataMap.hxx>
// Created Mardi 28 janvier 1997 #include <OpenGl_Structure.hxx>
// Author CAL #include <OpenGl_CView.hxx>
//-Copyright MatraDatavision 1997 void OpenGl_GraphicDriver::ClearStructure (const Graphic3d_CStructure& theCStructure)
{
//-Version OpenGl_Structure* aStructure = (OpenGl_Structure* )theCStructure.ptrStructure;
if (aStructure == NULL)
//-Design Declaration des variables specifiques aux Drivers return;
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OpenGl_tgl_funcs.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void OpenGl_GraphicDriver::ClearStructure (const Graphic3d_CStructure& ACStructure) {
Graphic3d_CStructure MyCStructure = ACStructure;
if (MyTraceLevel) {
PrintFunction ("call_togl_clearstructure");
PrintCStructure (MyCStructure, 1);
}
call_togl_clearstructure (&MyCStructure);
aStructure->Clear();
InvalidateAllWorkspaces();
} }
void OpenGl_GraphicDriver::Connect (const Graphic3d_CStructure& AFather, const Graphic3d_CStructure& ASon) { void OpenGl_GraphicDriver::ContextStructure (const Graphic3d_CStructure& theCStructure)
{
OpenGl_Structure* aStructure = (OpenGl_Structure* )theCStructure.ptrStructure;
if (aStructure == NULL)
return;
Graphic3d_CStructure MyFather = AFather; aStructure->SetTransformPersistence (theCStructure.TransformPersistence);
Graphic3d_CStructure MySon = ASon;
if (MyTraceLevel) { if (theCStructure.ContextLine.IsDef)
PrintFunction ("call_togl_connect"); aStructure->SetAspectLine (theCStructure.ContextLine);
PrintString ("AFather", "");
PrintCStructure (MyFather, 1);
PrintString ("ASon", "");
PrintCStructure (MySon, 1);
}
call_togl_connect (&MyFather, &MySon);
if (theCStructure.ContextFillArea.IsDef)
aStructure->SetAspectFace (theCStructure.ContextFillArea);
if (theCStructure.ContextMarker.IsDef)
aStructure->SetAspectMarker (theCStructure.ContextMarker);
if (theCStructure.ContextText.IsDef)
aStructure->SetAspectText (theCStructure.ContextText);
InvalidateAllWorkspaces();
} }
void OpenGl_GraphicDriver::ContextStructure (const Graphic3d_CStructure& ACStructure) { void OpenGl_GraphicDriver::Connect (const Graphic3d_CStructure& theFather,
const Graphic3d_CStructure& theSon)
Graphic3d_CStructure MyCStructure = ACStructure; {
OpenGl_Structure* aFather = (OpenGl_Structure* )theFather.ptrStructure;
if (MyTraceLevel) { OpenGl_Structure* aSon = (OpenGl_Structure* )theSon.ptrStructure;
PrintFunction ("call_togl_contextstructure"); if (aFather && aSon)
PrintCStructure (MyCStructure, 1); aFather->Connect(aSon);
PrintCStructure (MyCStructure, 2);
}
call_togl_contextstructure (&MyCStructure);
} }
void OpenGl_GraphicDriver::Disconnect (const Graphic3d_CStructure& AFather, const Graphic3d_CStructure& ASon) { void OpenGl_GraphicDriver::Disconnect (const Graphic3d_CStructure& theFather,
const Graphic3d_CStructure& theSon)
Graphic3d_CStructure MyFather = AFather; {
Graphic3d_CStructure MySon = ASon; OpenGl_Structure* aFather = (OpenGl_Structure* )theFather.ptrStructure;
OpenGl_Structure* aSon = (OpenGl_Structure* )theSon.ptrStructure;
if (MyTraceLevel) { if (aFather && aSon)
PrintFunction ("call_togl_disconnect"); aFather->Disconnect(aSon);
PrintString ("AFather", "");
PrintCStructure (AFather, 1);
PrintString ("ASon", "");
PrintCStructure (MySon, 1);
}
call_togl_disconnect (&MyFather, &MySon);
} }
void OpenGl_GraphicDriver::DisplayStructure (const Graphic3d_CView& ACView, const Graphic3d_CStructure& ACStructure, const Standard_Integer APriority) { void OpenGl_GraphicDriver::DisplayStructure (const Graphic3d_CView& theCView,
const Graphic3d_CStructure& theCStructure,
Graphic3d_CView MyCView = ACView; const Standard_Integer thePriority)
Graphic3d_CStructure MyCStructure = ACStructure; {
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (MyTraceLevel) { OpenGl_Structure* aStructure = (OpenGl_Structure* )theCStructure.ptrStructure;
PrintFunction ("call_togl_displaystructure"); if (aCView == NULL || aStructure == NULL)
PrintCView (MyCView, 1); return;
PrintCStructure (MyCStructure, 1);
PrintInteger ("Priority", APriority);
}
call_togl_displaystructure (&MyCView, MyCStructure.Id, int (APriority));
aCView->View->DisplayStructure (aStructure, thePriority);
aCView->WS->Invalidate();
} }
void OpenGl_GraphicDriver::EraseStructure (const Graphic3d_CView& ACView, const Graphic3d_CStructure& ACStructure) { void OpenGl_GraphicDriver::EraseStructure (const Graphic3d_CView& theCView,
const Graphic3d_CStructure& theCStructure)
Graphic3d_CView MyCView = ACView; {
Graphic3d_CStructure MyCStructure = ACStructure; const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
OpenGl_Structure* aStructure = (OpenGl_Structure* )theCStructure.ptrStructure;
if (MyTraceLevel) { if (aCView == NULL || aStructure == NULL)
PrintFunction ("call_togl_erasestructure"); return;
PrintCView (MyCView, 1);
PrintCStructure (MyCStructure, 1);
}
call_togl_erasestructure (MyCView.ViewId, MyCStructure.Id);
aCView->View->EraseStructure (aStructure);
aCView->WS->Invalidate();
} }
void OpenGl_GraphicDriver::RemoveStructure (const Graphic3d_CStructure& ACStructure) { void OpenGl_GraphicDriver::RemoveStructure (const Graphic3d_CStructure& theCStructure)
{
Graphic3d_CStructure MyCStructure = ACStructure; if (!GetMapOfStructures().IsBound (theCStructure.Id))
return;
if (MyTraceLevel) {
PrintFunction ("call_togl_removestructure");
PrintCStructure (MyCStructure, 1);
}
call_togl_removestructure (&MyCStructure);
OpenGl_Structure* aStructure = OpenGl_GraphicDriver::GetMapOfStructures().Find (theCStructure.Id);
OpenGl_GraphicDriver::GetMapOfStructures().UnBind (theCStructure.Id);
delete aStructure;
InvalidateAllWorkspaces();
} }
void OpenGl_GraphicDriver::Structure (Graphic3d_CStructure& ACStructure) { void OpenGl_GraphicDriver::Structure (Graphic3d_CStructure& theCStructure)
{
RemoveStructure (theCStructure);
Graphic3d_CStructure MyCStructure = ACStructure; OpenGl_Structure* aStructure = new OpenGl_Structure();
if (MyTraceLevel) {
PrintFunction ("call_togl_structure");
PrintCStructure (MyCStructure, 1);
}
call_togl_structure (&MyCStructure);
aStructure->SetDegenerateModel (theCStructure.ContextFillArea.DegenerationMode,
theCStructure.ContextFillArea.SkipRatio);
Standard_Integer aStatus = 0;
if (theCStructure.highlight) aStatus |= OPENGL_NS_HIGHLIGHT;
if (!theCStructure.visible) aStatus |= OPENGL_NS_HIDE;
if (theCStructure.pick) aStatus |= OPENGL_NS_PICK;
aStructure->SetNamedStatus (aStatus);
theCStructure.ptrStructure = aStructure;
OpenGl_GraphicDriver::GetMapOfStructures().Bind (theCStructure.Id, aStructure);
InvalidateAllWorkspaces();
} }

158
src/OpenGl/OpenGl_GraphicDriver_5.cxx
View File

@ -1,147 +1,33 @@
// File: OpenGl_GraphicDriver_5.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_GraphicDriver.hxx>
// File OpenGl_GraphicDriver_5.cxx void OpenGl_GraphicDriver::DumpGroup (const Graphic3d_CGroup& ACGroup)
// Created Mardi 28 janvier 1997 {
// Author CAL // Do nothing
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OpenGl_tgl_funcs.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void OpenGl_GraphicDriver::DumpGroup (const Graphic3d_CGroup& ACGroup) {
Graphic3d_CGroup MyCGroup = ACGroup;
if (MyTraceLevel) {
PrintFunction ("call_togl_structure_exploration");
PrintCGroup (MyCGroup, 1);
}
call_togl_structure_exploration
(long (MyCGroup.Struct->Id), long (MyCGroup.LabelBegin), long (MyCGroup.LabelEnd));
} }
void OpenGl_GraphicDriver::DumpStructure (const Graphic3d_CStructure& ACStructure) { void OpenGl_GraphicDriver::DumpStructure (const Graphic3d_CStructure& ACStructure)
{
Graphic3d_CStructure MyCStructure = ACStructure; // Do nothing
if (MyTraceLevel) {
PrintFunction ("call_togl_structure_exploration");
PrintCStructure (MyCStructure, 1);
}
call_togl_structure_exploration (long (MyCStructure.Id), 0, 0);
} }
void OpenGl_GraphicDriver::DumpView (const Graphic3d_CView& ACView) { void OpenGl_GraphicDriver::DumpView (const Graphic3d_CView& ACView)
{
Graphic3d_CView MyCView = ACView; // Do nothing
if (MyTraceLevel) {
PrintFunction ("call_togl_view_exploration");
PrintCView (MyCView, 1);
}
call_togl_view_exploration (long (MyCView.ViewId));
} }
Standard_Boolean OpenGl_GraphicDriver::ElementExploration (const Graphic3d_CStructure & ACStructure, const Standard_Integer ElementNumber, Graphic3d_VertexNC& AVertex, Graphic3d_Vector& AVector) { Standard_Boolean OpenGl_GraphicDriver::ElementExploration (const Graphic3d_CStructure & ACStructure, const Standard_Integer ElementNumber, Graphic3d_VertexNC& AVertex, Graphic3d_Vector& AVector)
{
Graphic3d_CStructure MyCStructure = ACStructure; // Do nothing
return (Standard_False);
Quantity_Color AColor;
long AType;
CALL_DEF_POINT Pt;
CALL_DEF_NORMAL Npt, Nfa;
CALL_DEF_COLOR Cpt;
if (MyTraceLevel) {
PrintFunction ("call_togl_element_exploration");
PrintCStructure (MyCStructure, 1);
}
call_togl_element_exploration (MyCStructure.Id, ElementNumber, &AType, &Pt, &Npt, &Cpt, &Nfa);
if (! AType) return (Standard_False);
else {
AVertex.SetCoord
(double (Pt.x), double (Pt.y), double (Pt.z));
AVertex.SetNormal
(double (Npt.dx), double (Npt.dy), double (Npt.dz));
AColor.SetValues
(double (Cpt.r), double (Cpt.g),
double (Cpt.b), Quantity_TOC_RGB);
AVertex.SetColor (AColor);
AVector.SetCoord
(double (Nfa.dx), double (Nfa.dy), double (Nfa.dz));
return (Standard_True);
}
} }
Graphic3d_TypeOfPrimitive OpenGl_GraphicDriver::ElementType (const Graphic3d_CStructure & ACStructure, const Standard_Integer ElementNumber) { Graphic3d_TypeOfPrimitive OpenGl_GraphicDriver::ElementType (const Graphic3d_CStructure & ACStructure, const Standard_Integer ElementNumber)
{
Graphic3d_CStructure MyCStructure = ACStructure; // Do nothing
return Graphic3d_TOP_UNDEFINED;
long AType;
Graphic3d_TypeOfPrimitive top;
if (MyTraceLevel) {
PrintFunction ("call_togl_element_type");
PrintCStructure (MyCStructure, 1);
}
call_togl_element_type (MyCStructure.Id, ElementNumber, &AType);
switch (AType) {
case 0:
top = Graphic3d_TOP_UNDEFINED;
break;
case 1:
top = Graphic3d_TOP_POLYLINE;
break;
case 2:
top = Graphic3d_TOP_POLYGON;
break;
case 3:
top = Graphic3d_TOP_TRIANGLEMESH;
break;
case 4:
top = Graphic3d_TOP_QUADRANGLEMESH;
break;
case 5:
top = Graphic3d_TOP_TEXT;
break;
case 6:
top = Graphic3d_TOP_MARKER;
break;
default:
top = Graphic3d_TOP_UNDEFINED;
break;
}
return (top);
} }

72
src/OpenGl/OpenGl_GraphicDriver_6.cxx
View File

@ -1,65 +1,21 @@
// File OpenGl_GraphicDriver_6.cxx // File: OpenGl_GraphicDriver_6.cxx
// Created Mardi 28 janvier 1997 // Created: 20 October 2011
// Author CAL // Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
//-Copyright MatraDatavision 1997 #include <OpenGl_GraphicDriver.hxx>
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OpenGl_tgl_funcs.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void OpenGl_GraphicDriver::InitPick () {
if (MyTraceLevel) {
PrintFunction ("call_togl_init_pick");
}
call_togl_init_pick ();
void OpenGl_GraphicDriver::InitPick ()
{
// Do nothing
} }
void OpenGl_GraphicDriver::Pick (Graphic3d_CPick& ACPick) { void OpenGl_GraphicDriver::Pick (Graphic3d_CPick& ACPick)
{
Graphic3d_CPick MyCPick = ACPick; // Do nothing
if (MyTraceLevel) {
PrintFunction ("call_togl_pick");
PrintCPick (MyCPick, 1);
}
call_togl_pick (&ACPick);
} }
void OpenGl_GraphicDriver::PickId (const Graphic3d_CGroup& ACGroup) { void OpenGl_GraphicDriver::PickId (const Graphic3d_CGroup& ACGroup)
{
Graphic3d_CGroup MyCGroup = ACGroup; // Do nothing
if (MyTraceLevel) {
PrintFunction ("call_togl_pickid");
PrintCGroup (MyCGroup, 1);
}
call_togl_pickid (&MyCGroup);
} }

826
src/OpenGl/OpenGl_GraphicDriver_7.cxx
View File

@ -1,328 +1,224 @@
// File: OpenGl_GraphicDriver_7.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
// File OpenGl_GraphicDriver_7.cxx #include <OpenGl_GraphicDriver.hxx>
// Created Mardi 28 janvier 1997
// Author CAL
// Modified GG 10/11/99 PRO19603 Change the Redraw method (add redraw area capabillity)
// EUG 07/10/99 G003 Add DegenerateStructure() and
// SetBackFacingModel() methods.
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <InterfaceGraphic_RawBufferData.hxx>
#include <OpenGl_tgl_funcs.hxx>
#include <OpenGl_tsm_ws.hxx>
#include <OpenGl_tgl_tox.hxx>
#include <OpenGl_txgl.hxx>
#include <OpenGl_FrameBuffer.hxx> #include <OpenGl_FrameBuffer.hxx>
//-Aliases #include <OpenGl_Structure.hxx>
#include <OpenGl_CView.hxx>
#include <OpenGl_Display.hxx>
//-Global data definitions /*----------------------------------------------------------------------*/
//-Methods, in order
void OpenGl_GraphicDriver::ActivateView (const Graphic3d_CView& ACView) {
Graphic3d_CView MyCView = ACView;
if (MyTraceLevel) {
PrintFunction ("call_togl_activateview");
PrintCView (MyCView, 1);
}
call_togl_activateview (&MyCView);
void OpenGl_GraphicDriver::ActivateView (const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
aCView->WS->SetActiveView(aCView->View);
} }
void OpenGl_GraphicDriver::AntiAliasing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag) { void OpenGl_GraphicDriver::AntiAliasing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag)
{
Graphic3d_CView MyCView = ACView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
if (MyTraceLevel) { aCView->View->SetAntiAliasing(AFlag);
PrintFunction ("call_togl_antialiasing");
PrintCView (MyCView, 1);
PrintBoolean ("AFlag", AFlag);
}
call_togl_antialiasing (&MyCView, (AFlag ? 1 : 0));
} }
void OpenGl_GraphicDriver::Background (const Graphic3d_CView& ACView) { void OpenGl_GraphicDriver::Background (const Graphic3d_CView& ACView)
{
Graphic3d_CView MyCView = ACView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
if (MyTraceLevel) { {
PrintFunction ("call_togl_background"); aCView->WS->SetBackgroundColor(ACView.DefWindow.Background.r,ACView.DefWindow.Background.g,ACView.DefWindow.Background.b);
PrintCView (MyCView, 1); aCView->WS->Invalidate();
} }
call_togl_background (&MyCView);
} }
void OpenGl_GraphicDriver::GradientBackground(const Graphic3d_CView& ACView, void OpenGl_GraphicDriver::GradientBackground (const Graphic3d_CView& ACView,
const Quantity_Color& AColor1, const Quantity_Color& AColor1,
const Quantity_Color& AColor2, const Quantity_Color& AColor2,
const Aspect_GradientFillMethod AType){ const Aspect_GradientFillMethod AType)
{
Graphic3d_CView MyCView = ACView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
if (MyTraceLevel) {
PrintFunction ("call_togl_gradient_background");
PrintCView (MyCView, 1);
}
Standard_Real R1,G1,B1,R2,G2,B2;
AColor1.Values( R1, G1, B1, Quantity_TOC_RGB );
AColor2.Values( R2, G2, B2, Quantity_TOC_RGB );
TEL_COLOUR tcolor1, tcolor2;
tcolor1.rgb[0] = R1;
tcolor1.rgb[1] = G1;
tcolor1.rgb[2] = B1;
tcolor1.rgb[3] = 0;
tcolor2.rgb[0] = R2;
tcolor2.rgb[1] = G2;
tcolor2.rgb[2] = B2;
tcolor2.rgb[3] = 0;
call_togl_gradient_background (MyCView.WsId, AType, &tcolor1, &tcolor2);
}
void OpenGl_GraphicDriver::Blink (const Graphic3d_CStructure& ACStructure, const Standard_Boolean Create) {
Graphic3d_CStructure MyCStructure = ACStructure;
if (MyTraceLevel) {
PrintFunction ("call_togl_blink");
PrintCStructure (MyCStructure, 1);
PrintBoolean ("Create", Create);
}
call_togl_blink (&MyCStructure, (Create ? 1 : 0));
}
void OpenGl_GraphicDriver::BoundaryBox (const Graphic3d_CStructure& ACStructure, const Standard_Boolean Create) {
Graphic3d_CStructure MyCStructure = ACStructure;
if (MyTraceLevel) {
PrintFunction ("call_togl_boundarybox");
PrintCStructure (MyCStructure, 1);
PrintBoolean ("Create", Create);
}
call_togl_boundarybox (&MyCStructure, (Create ? 1 : 0));
}
void OpenGl_GraphicDriver::HighlightColor (const Graphic3d_CStructure& ACStructure, const Standard_ShortReal R, const Standard_ShortReal G, const Standard_ShortReal B, const Standard_Boolean Create) {
Graphic3d_CStructure MyCStructure = ACStructure;
if (MyTraceLevel) {
PrintFunction ("call_togl_highlightcolor");
PrintCStructure (MyCStructure, 1);
PrintShortReal ("R", R);
PrintShortReal ("G", G);
PrintShortReal ("B", B);
}
CALL_DEF_COLOR acolor;
acolor.r = R;
acolor.g = G;
acolor.b = B;
call_togl_highlightcolor (&MyCStructure, &acolor, (Create ? 1 : 0));
}
void OpenGl_GraphicDriver::NameSetStructure (const Graphic3d_CStructure& ACStructure) {
Graphic3d_CStructure MyCStructure = ACStructure;
if (MyTraceLevel) {
PrintFunction ("call_togl_namesetstructure");
PrintCStructure (MyCStructure, 1);
}
call_togl_namesetstructure (&MyCStructure);
}
void OpenGl_GraphicDriver::ClipLimit (const Graphic3d_CView& ACView, const Standard_Boolean AWait) {
Graphic3d_CView MyCView = ACView;
if (MyTraceLevel) {
PrintFunction ("call_togl_cliplimit");
PrintCView (MyCView, 1);
PrintBoolean ("AWait", AWait);
}
call_togl_cliplimit (&MyCView, (AWait ? 1 : 0));
}
void OpenGl_GraphicDriver::DeactivateView (const Graphic3d_CView& ACView) {
Graphic3d_CView MyCView = ACView;
if (MyTraceLevel) {
PrintFunction ("call_togl_deactivateview");
PrintCView (MyCView, 1);
}
call_togl_deactivateview (&MyCView);
}
void OpenGl_GraphicDriver::DepthCueing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag) {
Graphic3d_CView MyCView = ACView;
if (MyTraceLevel) {
PrintFunction ("call_togl_depthcueing");
PrintCView (MyCView, 1);
PrintBoolean ("AFlag", AFlag);
}
call_togl_depthcueing (&MyCView, (AFlag ? 1 : 0));
}
Standard_Boolean OpenGl_GraphicDriver::ProjectRaster (const Graphic3d_CView& ACView, const Standard_ShortReal AX, const Standard_ShortReal AY, const Standard_ShortReal AZ, Standard_Integer& AU, Standard_Integer& AV) {
Graphic3d_CView MyCView = ACView;
Standard_Integer Result;
if (MyTraceLevel) {
PrintFunction ("call_togl_project_raster");
PrintCView (MyCView, 1);
}
//if we want project something before to dump it into pixmap
if ( ACView.DefBitmap.bitmap ) {
Result = call_togl_adopt_to_rect( ACView.ViewId,
ACView.DefBitmap.width,
ACView.DefBitmap.height );
if (MyTraceLevel) {
PrintIResult ("call_togl_adopt_to_rect", Result);
}
if (Result)
return Standard_False;
}
Result = call_togl_project_raster (ACView.ViewId, AX, AY, AZ, &AU, &AV);
if (MyTraceLevel) {
PrintIResult ("call_togl_project_raster", Result);
}
if ( ACView.DefBitmap.bitmap ) {
Result = call_togl_adopt_to_rect( ACView.ViewId,
ACView.DefWindow.dx,
ACView.DefWindow.dy );
if (MyTraceLevel) {
PrintIResult ("call_togl_adopt_to_rect", Result);
}
if (Result)
return Standard_False;
}
return (Result == 0 ? Standard_True : Standard_False);
}
Standard_Boolean OpenGl_GraphicDriver::UnProjectRaster (const Graphic3d_CView& ACView, const Standard_Integer Axm, const Standard_Integer Aym, const Standard_Integer AXM, const Standard_Integer AYM, const Standard_Integer AU, const Standard_Integer AV, Standard_ShortReal& Ax, Standard_ShortReal& Ay, Standard_ShortReal& Az) {
Graphic3d_CView MyCView = ACView;
Standard_Integer Result;
if (MyTraceLevel) {
PrintFunction ("call_togl_unproject_raster");
PrintCView (MyCView, 1);
}
Result = call_togl_unproject_raster
(ACView.ViewId, Axm, Aym, AXM, AYM, AU, AV, &Ax, &Ay, &Az);
if (MyTraceLevel) {
PrintIResult ("call_togl_unproject_raster", Result);
}
return (Result == 0 ? Standard_True : Standard_False);
}
Standard_Boolean OpenGl_GraphicDriver::UnProjectRasterWithRay (const Graphic3d_CView& ACView, const Standard_Integer Axm, const Standard_Integer Aym, const Standard_Integer AXM, const Standard_Integer AYM, const Standard_Integer AU, const Standard_Integer AV, Standard_ShortReal& Ax, Standard_ShortReal& Ay, Standard_ShortReal& Az, Standard_ShortReal& Dx, Standard_ShortReal& Dy, Standard_ShortReal& Dz) {
Graphic3d_CView MyCView = ACView;
Standard_Integer Result;
if (MyTraceLevel) {
PrintFunction ("call_togl_unproject_raster_with_ray");
PrintCView (MyCView, 1);
}
Result = call_togl_unproject_raster_with_ray
(ACView.ViewId, Axm, Aym, AXM, AYM, AU, AV, &Ax, &Ay, &Az, &Dx, &Dy, &Dz);
if (MyTraceLevel) {
PrintIResult ("call_togl_unproject_raster_with_ray", Result);
}
return (Result == 0 ? Standard_True : Standard_False);
}
void OpenGl_GraphicDriver::RatioWindow (const Graphic3d_CView& ACView) {
Graphic3d_CView MyCView = ACView;
if (MyTraceLevel) {
PrintFunction ("call_togl_ratio_window");
PrintCView (MyCView, 1);
}
call_togl_ratio_window (&MyCView);
}
void OpenGl_GraphicDriver::Redraw (const Graphic3d_CView& ACView, const Aspect_CLayer2d& ACUnderLayer, const Aspect_CLayer2d& ACOverLayer, const Standard_Integer x, const Standard_Integer y, const Standard_Integer width, const Standard_Integer height) {
Graphic3d_CView MyCView = ACView;
Aspect_CLayer2d MyCUnderLayer = ACUnderLayer;
Aspect_CLayer2d MyCOverLayer = ACOverLayer;
if (MyTraceLevel) {
PrintFunction ("call_togl_redraw");
PrintCView (MyCView, 1);
}
//PRO19603
if( width <= 0 || height <= 0 )
call_togl_redraw (&MyCView, &MyCUnderLayer, &MyCOverLayer);
else {
call_togl_redraw_area (&MyCView, &MyCUnderLayer, &MyCOverLayer,
x, y, width, height);
}
//PRO19603
}
Graphic3d_PtrFrameBuffer OpenGl_GraphicDriver::FBOCreate (const Graphic3d_CView& theCView,
const Standard_Integer theWidth,
const Standard_Integer theHeight) {
// activate OpenGL context
CMN_KEY_DATA aData;
if ((TsmGetWSAttri (theCView.WsId, WSWindow, &aData) != TSuccess) ||
(TxglWinset (call_thedisplay, (WINDOW) aData.ldata) != TSuccess))
{ {
return NULL; aCView->View->SetBackgroundGradient(AColor1,AColor2,AType);
aCView->WS->Invalidate();
} }
}
void OpenGl_GraphicDriver::Blink (const Graphic3d_CStructure &, const Standard_Boolean)
{
// Do nothing
}
void OpenGl_GraphicDriver::BoundaryBox (const Graphic3d_CStructure& ACStructure, const Standard_Boolean Create)
{
OpenGl_Structure *astructure = (OpenGl_Structure *)ACStructure.ptrStructure;
if (!astructure)
return;
if ( Create )
astructure->SetHighlightBox(ACStructure.BoundBox);
else
astructure->ClearHighlightBox();
}
void OpenGl_GraphicDriver::HighlightColor (const Graphic3d_CStructure& ACStructure, const Standard_ShortReal R, const Standard_ShortReal G, const Standard_ShortReal B, const Standard_Boolean Create)
{
OpenGl_Structure *astructure = (OpenGl_Structure *)ACStructure.ptrStructure;
if (!astructure)
return;
if ( Create )
astructure->SetHighlightColor(R,G,B);
else
astructure->ClearHighlightColor();
}
void OpenGl_GraphicDriver::NameSetStructure (const Graphic3d_CStructure& ACStructure)
{
OpenGl_Structure *astructure = (OpenGl_Structure *)ACStructure.ptrStructure;
if (astructure)
{
Standard_Integer aStatus = 0;
if (ACStructure.highlight) aStatus |= OPENGL_NS_HIGHLIGHT;
if (!ACStructure.visible) aStatus |= OPENGL_NS_HIDE;
if (ACStructure.pick) aStatus |= OPENGL_NS_PICK;
astructure->SetNamedStatus( aStatus );
}
}
void OpenGl_GraphicDriver::ClipLimit (const Graphic3d_CView& ACView, const Standard_Boolean AWait)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->SetClipLimit(ACView);
if (!AWait && !ACView.DefBitmap.bitmap)
{
aCView->WS->Resize(ACView.DefWindow);
aCView->WS->Invalidate();
}
}
}
void OpenGl_GraphicDriver::DeactivateView (const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
const Handle(OpenGl_View) aDummyView;
aCView->WS->SetActiveView(aDummyView);
}
}
void OpenGl_GraphicDriver::DepthCueing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
aCView->View->SetFog(ACView, AFlag);
}
Standard_Boolean OpenGl_GraphicDriver::ProjectRaster (const Graphic3d_CView& ACView, const Standard_ShortReal AX, const Standard_ShortReal AY, const Standard_ShortReal AZ, Standard_Integer& AU, Standard_Integer& AV)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (!aCView)
return Standard_False;
Standard_Integer aWidth = aCView->WS->Width();
Standard_Integer aHeight = aCView->WS->Height();
//if we want project something before to dump it into pixmap
//For right copution of projection before dumping to pixmap
if ( ACView.DefBitmap.bitmap )
{
aWidth = ACView.DefBitmap.width;
aHeight = ACView.DefBitmap.height;
}
Standard_ShortReal xr, yr;
if (aCView->View->ProjectObjectToRaster(aWidth, aHeight, AX, AY, AZ, xr, yr))
{
AU = (Standard_Integer) xr;
AV = aHeight - (Standard_Integer) yr;
return Standard_True;
}
return Standard_False;
}
Standard_Boolean OpenGl_GraphicDriver::UnProjectRaster (const Graphic3d_CView& ACView, const Standard_Integer Axm, const Standard_Integer Aym, const Standard_Integer AXM, const Standard_Integer AYM, const Standard_Integer AU, const Standard_Integer AV, Standard_ShortReal& Ax, Standard_ShortReal& Ay, Standard_ShortReal& Az)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (!aCView)
return Standard_False;
const Standard_Integer aWidth = aCView->WS->Width();
const Standard_Integer aHeight = aCView->WS->Height();
/*
Patched by P.Dolbey: the window pixel height decreased by one
in order for yr to remain within valid coordinate range [0; Ym -1]
where Ym means window pixel height.
*/
return aCView->View->ProjectRasterToObject( aWidth, aHeight, AU, (AYM-1)-Aym-AV, Ax, Ay, Az );
}
Standard_Boolean OpenGl_GraphicDriver::UnProjectRasterWithRay (const Graphic3d_CView& ACView, const Standard_Integer Axm, const Standard_Integer Aym, const Standard_Integer AXM, const Standard_Integer AYM, const Standard_Integer AU, const Standard_Integer AV, Standard_ShortReal& Ax, Standard_ShortReal& Ay, Standard_ShortReal& Az, Standard_ShortReal& Dx, Standard_ShortReal& Dy, Standard_ShortReal& Dz)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (!aCView)
return Standard_False;
const Standard_Integer aWidth = aCView->WS->Width();
const Standard_Integer aHeight = aCView->WS->Height();
return aCView->View->ProjectRasterToObjectWithRay( aWidth, aHeight, AU, AYM-Aym-AV, Ax, Ay, Az, Dx, Dy, Dz );
}
void OpenGl_GraphicDriver::RatioWindow (const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (!aCView)
if( !ACView.DefBitmap.bitmap )
aCView->WS->Resize(ACView.DefWindow);
}
void OpenGl_GraphicDriver::Redraw (const Graphic3d_CView& ACView, const Aspect_CLayer2d& ACUnderLayer, const Aspect_CLayer2d& ACOverLayer, const Standard_Integer x, const Standard_Integer y, const Standard_Integer width, const Standard_Integer height)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
/*if( width <= 0 || height <= 0 )
aCView->WS->Redraw(ACView, ACUnderLayer, ACOverLayer);
else
aCView->WS->RedrawArea(ACView, ACUnderLayer, ACOverLayer, x, y, width, height);*/
// Always do full redraw
aCView->WS->Redraw(ACView, ACUnderLayer, ACOverLayer);
}
}
Graphic3d_PtrFrameBuffer OpenGl_GraphicDriver::FBOCreate (const Graphic3d_CView& ACView, const Standard_Integer theWidth, const Standard_Integer theHeight)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
return aCView->WS->FBOCreate(theWidth, theHeight);
return (Graphic3d_PtrFrameBuffer)NULL;
}
Graphic3d_PtrFrameBuffer OpenGl_Workspace::FBOCreate (const Standard_Integer theWidth, const Standard_Integer theHeight)
{
// activate OpenGL context
if (!Activate())
return NULL;
// create the FBO // create the FBO
OpenGl_FrameBuffer* aFrameBuffer = new OpenGl_FrameBuffer(); OpenGl_FrameBuffer* aFrameBuffer = new OpenGl_FrameBuffer();
if (!aFrameBuffer->Init (theWidth, theHeight)) if (!aFrameBuffer->Init (GetGlContext(), theWidth, theHeight))
{ {
delete aFrameBuffer; delete aFrameBuffer;
return NULL; return NULL;
@ -330,24 +226,28 @@ Graphic3d_PtrFrameBuffer OpenGl_GraphicDriver::FBOCreate (const Graphic3d_CView&
return (Graphic3d_PtrFrameBuffer )aFrameBuffer; return (Graphic3d_PtrFrameBuffer )aFrameBuffer;
} }
void OpenGl_GraphicDriver::FBORelease (const Graphic3d_CView& theCView, void OpenGl_GraphicDriver::FBORelease (const Graphic3d_CView& ACView, Graphic3d_PtrFrameBuffer& theFBOPtr)
Graphic3d_PtrFrameBuffer& theFBOPtr)
{ {
if (theFBOPtr == NULL) if (theFBOPtr == NULL)
{
return; return;
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->WS->FBORelease(theFBOPtr);
theFBOPtr = NULL;
} }
}
void OpenGl_Workspace::FBORelease (Graphic3d_PtrFrameBuffer theFBOPtr)
{
// activate OpenGL context // activate OpenGL context
CMN_KEY_DATA aData; if (!Activate())
if ((TsmGetWSAttri (theCView.WsId, WSWindow, &aData) != TSuccess) ||
(TxglWinset (call_thedisplay, (WINDOW) aData.ldata) != TSuccess))
{
return; return;
}
// release the object // release the object
OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer* )theFBOPtr; OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer*)theFBOPtr;
aFrameBuffer->Release (GetGlContext());
delete aFrameBuffer; delete aFrameBuffer;
theFBOPtr = NULL;
} }
void OpenGl_GraphicDriver::FBOGetDimensions (const Graphic3d_CView& , void OpenGl_GraphicDriver::FBOGetDimensions (const Graphic3d_CView& ,
@ -386,7 +286,6 @@ void OpenGl_GraphicDriver::FBOChangeViewport (const Graphic3d_CView& ,
#define GL_BGRA 0x80E1 #define GL_BGRA 0x80E1
#endif #endif
static inline GLenum TFormatToGLEnum (const TRawBufferDataFormat theTFormat) static inline GLenum TFormatToGLEnum (const TRawBufferDataFormat theTFormat)
{ {
switch (theTFormat) switch (theTFormat)
@ -414,8 +313,15 @@ static inline GLenum TTypeToGLEnum (const TRawBufferDataType theTType)
} }
} }
Standard_Boolean OpenGl_GraphicDriver::BufferDump (const Graphic3d_CView& theCView, Standard_Boolean OpenGl_GraphicDriver::BufferDump (const Graphic3d_CView& ACView, Image_CRawBufferData& theBuffer)
Image_CRawBufferData& theBuffer) {
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
return aCView->WS->BufferDump((OpenGl_FrameBuffer *)ACView.ptrFBO,theBuffer);
return Standard_False;
}
Standard_Boolean OpenGl_Workspace::BufferDump (OpenGl_FrameBuffer *theFBOPtr, Image_CRawBufferData& theBuffer)
{ {
GLenum aFormat = TFormatToGLEnum (theBuffer.format); GLenum aFormat = TFormatToGLEnum (theBuffer.format);
GLenum aType = TTypeToGLEnum (theBuffer.type); GLenum aType = TTypeToGLEnum (theBuffer.type);
@ -429,19 +335,15 @@ Standard_Boolean OpenGl_GraphicDriver::BufferDump (const Graphic3d_CView& theCVi
} }
// activate OpenGL context // activate OpenGL context
CMN_KEY_DATA aData; if (!Activate())
if ((TsmGetWSAttri (theCView.WsId, WSWindow, &aData) != TSuccess) ||
(TxglWinset (call_thedisplay, (WINDOW) aData.ldata) != TSuccess))
{
return Standard_False; return Standard_False;
}
// bind FBO if used // bind FBO if used
OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer* )theCView.ptrFBO; OpenGl_FrameBuffer* aFrameBuffer = theFBOPtr;
GLint aReadBufferPrev = GL_BACK; GLint aReadBufferPrev = GL_BACK;
if (aFrameBuffer != NULL && aFrameBuffer->IsValid()) if (aFrameBuffer != NULL && aFrameBuffer->IsValid())
{ {
aFrameBuffer->BindBuffer(); aFrameBuffer->BindBuffer (GetGlContext());
} }
else else
{ {
@ -465,7 +367,7 @@ Standard_Boolean OpenGl_GraphicDriver::BufferDump (const Graphic3d_CView& theCVi
if (aFrameBuffer != NULL && aFrameBuffer->IsValid()) if (aFrameBuffer != NULL && aFrameBuffer->IsValid())
{ {
aFrameBuffer->UnbindBuffer(); aFrameBuffer->UnbindBuffer (GetGlContext());
} }
else else
{ {
@ -474,169 +376,133 @@ Standard_Boolean OpenGl_GraphicDriver::BufferDump (const Graphic3d_CView& theCVi
return Standard_True; return Standard_True;
} }
void OpenGl_GraphicDriver::RemoveView (const Graphic3d_CView& ACView) { void OpenGl_GraphicDriver::RemoveView (const Graphic3d_CView& ACView)
{
if (GetMapOfViews().IsBound (ACView.ViewId))
GetMapOfViews().UnBind (ACView.ViewId);
Graphic3d_CView MyCView = ACView; if (GetMapOfWorkspaces().IsBound (ACView.WsId))
GetMapOfWorkspaces().UnBind (ACView.WsId);
if (MyTraceLevel) {
PrintFunction ("call_togl_removeview");
PrintCView (MyCView, 1);
}
call_togl_removeview (&MyCView);
OpenGl_CView *aCView = (OpenGl_CView *)ACView.ptrView;
delete aCView;
((Graphic3d_CView *)&ACView)->ptrView = NULL;
} }
void OpenGl_GraphicDriver::SetLight (const Graphic3d_CView& ACView) { void OpenGl_GraphicDriver::SetLight (const Graphic3d_CView& ACView)
{
Graphic3d_CView MyCView = ACView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
if (MyTraceLevel) { aCView->View->SetLights(ACView.Context);
PrintFunction ("call_togl_setlight");
PrintCView (MyCView, 1);
}
call_togl_setlight (&MyCView);
} }
void OpenGl_GraphicDriver::SetPlane (const Graphic3d_CView& ACView) { void OpenGl_GraphicDriver::SetPlane (const Graphic3d_CView& ACView)
{
Graphic3d_CView MyCView = ACView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
if (MyTraceLevel) { aCView->View->SetClippingPlanes(ACView.Context);
PrintFunction ("call_togl_setplane");
PrintCView (MyCView, 1);
}
call_togl_setplane (&MyCView);
} }
void OpenGl_GraphicDriver::SetVisualisation (const Graphic3d_CView& ACView) { void OpenGl_GraphicDriver::SetVisualisation (const Graphic3d_CView& ACView)
{
Graphic3d_CView MyCView = ACView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
if (MyTraceLevel) {
PrintFunction ("call_togl_setvisualisation");
PrintCView (MyCView, 1);
}
call_togl_setvisualisation (&MyCView);
}
void OpenGl_GraphicDriver::TransformStructure (const Graphic3d_CStructure& ACStructure) {
Graphic3d_CStructure MyCStructure = ACStructure;
if (MyTraceLevel) {
PrintFunction ("call_togl_transformstructure");
PrintCStructure (MyCStructure, 1);
}
call_togl_transformstructure (&MyCStructure);
}
void OpenGl_GraphicDriver :: DegenerateStructure (
const Graphic3d_CStructure& ACStructure
) {
Graphic3d_CStructure MyCStructure = ACStructure;
if ( MyTraceLevel ) {
PrintFunction ( "call_togl_degeneratestructure" );
PrintCStructure ( MyCStructure, 1 );
} // end if
call_togl_degeneratestructure ( &MyCStructure );
} // end OpenGl_GraphicDriver :: DegenerateStructure
void OpenGl_GraphicDriver::Transparency (const Graphic3d_CView& ACView, const Standard_Boolean AFlag) {
Graphic3d_CView MyCView = ACView;
if (MyTraceLevel) {
PrintFunction ("call_togl_transparency");
PrintCView (MyCView, 1);
PrintBoolean ("AFlag", AFlag);
}
call_togl_transparency (MyCView.WsId, MyCView.ViewId, (AFlag ? 1 : 0));
}
void OpenGl_GraphicDriver::Update (const Graphic3d_CView& ACView, const Aspect_CLayer2d& ACUnderLayer, const Aspect_CLayer2d& ACOverLayer) {
Graphic3d_CView MyCView = ACView;
Aspect_CLayer2d MyCUnderLayer = ACUnderLayer;
Aspect_CLayer2d MyCOverLayer = ACOverLayer;
if (MyTraceLevel) {
PrintFunction ("call_togl_update");
PrintCView (MyCView, 1);
}
call_togl_update (&MyCView, &MyCUnderLayer, &MyCOverLayer);
}
Standard_Boolean OpenGl_GraphicDriver::View (Graphic3d_CView& ACView) {
Graphic3d_CView MyCView = ACView;
Standard_Integer Result;
if (MyTraceLevel) {
PrintFunction ("call_togl_view");
PrintCView (MyCView, 1);
}
Result = call_togl_view (&MyCView);
if (MyTraceLevel) {
PrintIResult ("call_togl_view", Result);
}
return (Result == 1 ? Standard_True : Standard_False);
}
void OpenGl_GraphicDriver::ViewMapping (const Graphic3d_CView& ACView, const Standard_Boolean AWait) {
Graphic3d_CView MyCView = ACView;
Standard_Integer Result;
if (MyTraceLevel) {
PrintFunction ("call_togl_viewmapping");
PrintCView (MyCView, 1);
PrintBoolean ("AWait", AWait);
}
Result = call_togl_viewmapping (&MyCView, (AWait ? 1 : 0));
if (MyTraceLevel) {
PrintIResult ("call_togl_viewmapping", Result);
}
}
void OpenGl_GraphicDriver::ViewOrientation (const Graphic3d_CView& ACView, const Standard_Boolean AWait) {
Graphic3d_CView MyCView = ACView;
Standard_Integer Result;
if (MyTraceLevel) {
PrintFunction ("call_togl_vieworientation");
PrintCView (MyCView, 1);
PrintBoolean ("AWait", AWait);
}
Result = call_togl_vieworientation (&MyCView, (AWait ? 1 : 0));
if (MyTraceLevel) {
PrintIResult ("call_togl_viewmapping", Result);
}
}
void OpenGl_GraphicDriver :: SetBackFacingModel ( const Graphic3d_CView& aView )
{ {
Graphic3d_CView myView = aView; aCView->View->SetVisualisation(ACView.Context);
aCView->WS->UseZBuffer() = ( ACView.Context.Visualization == 0? (ACView.Context.ZBufferActivity == 1) : (ACView.Context.ZBufferActivity != 0) );
}
}
if ( MyTraceLevel ) { void OpenGl_GraphicDriver::TransformStructure (const Graphic3d_CStructure& ACStructure)
{
OpenGl_Structure *astructure = (OpenGl_Structure *)ACStructure.ptrStructure;
if (astructure)
astructure->SetTransformation(&(ACStructure.Transformation[0][0]));
}
PrintFunction ( "call_togl_backfacing" ); void OpenGl_GraphicDriver::DegenerateStructure (const Graphic3d_CStructure& ACStructure)
PrintCView ( myView, 1 ); {
OpenGl_Structure *astructure = (OpenGl_Structure *)ACStructure.ptrStructure;
if (astructure)
astructure->SetDegenerateModel( ACStructure.ContextFillArea.DegenerationMode, ACStructure.ContextFillArea.SkipRatio );
}
} // end if void OpenGl_GraphicDriver::Transparency (const Graphic3d_CView& ACView, const Standard_Boolean AFlag)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
aCView->WS->UseTransparency(AFlag);
}
call_togl_backfacing ( &myView ); void OpenGl_GraphicDriver::Update (const Graphic3d_CView& ACView, const Aspect_CLayer2d& ACUnderLayer, const Aspect_CLayer2d& ACOverLayer)
} // end Graphic3d_GraphicDriver :: SetBackFacingModel {
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
aCView->WS->Update(ACView,ACUnderLayer,ACOverLayer);
}
Standard_Boolean OpenGl_GraphicDriver::View (Graphic3d_CView& ACView)
{
if (openglDisplay.IsNull())
return Standard_False;
if (GetMapOfViews().IsBound (ACView.ViewId))
GetMapOfViews().UnBind (ACView.ViewId);
if (GetMapOfWorkspaces().IsBound (ACView.WsId))
GetMapOfWorkspaces().UnBind (ACView.WsId);
Handle(OpenGl_Workspace) aWS = Handle(OpenGl_Workspace)::DownCast(openglDisplay->GetWindow( ACView.DefWindow.XWindow ));
if ( aWS.IsNull() )
{
aWS = new OpenGl_Workspace( openglDisplay, ACView.DefWindow, ACView.GContext );
openglDisplay->SetWindow( ACView.DefWindow.XWindow, aWS );
}
GetMapOfWorkspaces().Bind (ACView.WsId, aWS);
Handle(OpenGl_View) aView = new OpenGl_View( ACView.Context );
GetMapOfViews().Bind (ACView.ViewId, aView);
OpenGl_CView *aCView = new OpenGl_CView;
aCView->View = aView;
aCView->WS = aWS;
ACView.ptrView = aCView;
return Standard_True;
}
void OpenGl_GraphicDriver::ViewMapping (const Graphic3d_CView& ACView, const Standard_Boolean AWait)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->SetMapping(ACView);
if (!AWait && !ACView.DefBitmap.bitmap)
{
aCView->WS->Resize(ACView.DefWindow);
aCView->WS->Invalidate();
}
}
}
void OpenGl_GraphicDriver::ViewOrientation (const Graphic3d_CView& ACView, const Standard_Boolean AWait)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->SetOrientation(ACView);
if (!AWait && !ACView.DefBitmap.bitmap)
{
aCView->WS->Resize(ACView.DefWindow);
aCView->WS->Invalidate();
}
}
}
void OpenGl_GraphicDriver::SetBackFacingModel (const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
aCView->View->SetBackfacing(ACView.Backfacing);
}

588
src/OpenGl/OpenGl_GraphicDriver_703.cxx
View File

@ -1,508 +1,140 @@
// File: OpenGl_GraphicDriver_703.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
// File OpenGl_GraphicDriver_703.cxx #include <OpenGl_GraphicDriver.hxx>
// Created Mardi 28 janvier 1997
// Author CAL
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_TypeOfMarker.hxx> #include <Aspect_TypeOfMarker.hxx>
#include <OpenGl_Group.hxx>
#include <OpenGl_MarkerSet.hxx>
#include <Graphic3d_Array1OfVertex.hxx>
#include <Aspect_DriverDefinitionError.hxx> static void OpenGl_CreateMarkers(const Graphic3d_CGroup& ACGroup, const Standard_Integer NbPoints, const Graphic3d_Vertex *Points)
#include <OpenGl_tgl_funcs.hxx>
int GenerateMarkerBitmap( unsigned int theWidth, unsigned int theHeight, unsigned char* theArray);
//-Aliases
//-Global data definitions
//-Methods, in order
void OpenGl_GraphicDriver::Marker (const Graphic3d_CGroup& ACGroup, const Graphic3d_Vertex& APoint, const Standard_Boolean )
{ {
OpenGl_MarkerSet *amarkerset = new OpenGl_MarkerSet( NbPoints, Points );
Graphic3d_CGroup MyCGroup = ACGroup; ((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelMarkerSet, amarkerset );
CALL_DEF_MARKER amarker;
amarker.x = float (APoint.X ());
amarker.y = float (APoint.Y ());
amarker.z = float (APoint.Z ());
Standard_Real AMR, AMG, AMB, R, G, B;
Aspect_TypeOfMarker AMType;
Standard_Real AMScale, AScale;
// Sauvegarde des valeurs initiales
AMR = R = Standard_Real (MyCGroup.ContextMarker.Color.r);
AMG = G = Standard_Real (MyCGroup.ContextMarker.Color.g);
AMB = B = Standard_Real (MyCGroup.ContextMarker.Color.b);
AMType = Aspect_TypeOfMarker (MyCGroup.ContextMarker.MarkerType);
AMScale = AScale = Standard_Real (MyCGroup.ContextMarker.Scale);
int noinsert = 0;
Standard_Real H, L, S;
Standard_Real LastS;
Standard_Real Limit=0, Delta;
switch (AMType)
{
case Aspect_TOM_POINT :
case Aspect_TOM_PLUS :
case Aspect_TOM_STAR :
case Aspect_TOM_O :
case Aspect_TOM_X :
case Aspect_TOM_USERDEFINED:
if (MyTraceLevel)
{
PrintFunction ("call_togl_marker");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker (&MyCGroup, &amarker);
break;
case Aspect_TOM_O_POINT :
MyCGroup.ContextMarker.IsDef = 1;
// we draw the circle
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_O);
call_togl_markercontextgroup (&MyCGroup, noinsert);
MyCGroup.ContextMarker.IsSet = 1;
if (MyTraceLevel) {
PrintFunction ("call_togl_marker");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker (&MyCGroup, &amarker);
// we draw the point
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_POINT);
call_togl_markercontextgroup (&MyCGroup, noinsert);
if (MyTraceLevel) {
PrintFunction ("call_togl_marker");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker (&MyCGroup, &amarker);
break;
case Aspect_TOM_O_PLUS :
MyCGroup.ContextMarker.IsDef = 1;
// we draw the circle
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_O);
call_togl_markercontextgroup (&MyCGroup, noinsert);
MyCGroup.ContextMarker.IsSet = 1;
if (MyTraceLevel) {
PrintFunction ("call_togl_marker");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker (&MyCGroup, &amarker);
// we draw the plus
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_PLUS);
call_togl_markercontextgroup (&MyCGroup, noinsert);
if (MyTraceLevel) {
PrintFunction ("call_togl_marker");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker (&MyCGroup, &amarker);
break;
case Aspect_TOM_O_STAR :
MyCGroup.ContextMarker.IsDef = 1;
// we draw the circle
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_O);
call_togl_markercontextgroup (&MyCGroup, noinsert);
MyCGroup.ContextMarker.IsSet = 1;
if (MyTraceLevel) {
PrintFunction ("call_togl_marker");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker (&MyCGroup, &amarker);
// we draw the star
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_STAR);
call_togl_markercontextgroup (&MyCGroup, noinsert);
if (MyTraceLevel) {
PrintFunction ("call_togl_marker");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker (&MyCGroup, &amarker);
break;
case Aspect_TOM_O_X :
MyCGroup.ContextMarker.IsDef = 1;
// we draw the circle
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_O);
call_togl_markercontextgroup (&MyCGroup, noinsert);
MyCGroup.ContextMarker.IsSet = 1;
if (MyTraceLevel) {
PrintFunction ("call_togl_marker");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker (&MyCGroup, &amarker);
// we draw the cross
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_X);
call_togl_markercontextgroup (&MyCGroup, noinsert);
if (MyTraceLevel) {
PrintFunction ("call_togl_marker");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker (&MyCGroup, &amarker);
break;
case Aspect_TOM_BALL :
MyCGroup.ContextMarker.IsDef = 1;
// we draw a set of circles
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_O);
Delta = 0.1;
while (AScale >= 1.0) {
Quantity_Color::RgbHls (R, G, B, H, L, S);
// Modification de la saturation de 5 %
LastS = S;
S = S - S * 0.05;
if (S < 0.0) S = LastS;
Quantity_Color::HlsRgb (H, L, S, R, G, B);
MyCGroup.ContextMarker.Color.r = float (R);
MyCGroup.ContextMarker.Color.g = float (G);
MyCGroup.ContextMarker.Color.b = float (B);
MyCGroup.ContextMarker.Scale = float (AScale);
call_togl_markercontextgroup (&MyCGroup, noinsert);
MyCGroup.ContextMarker.IsSet = 1;
if (MyTraceLevel) {
PrintFunction ("call_togl_marker");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker (&MyCGroup, &amarker);
AScale -= Delta;
}
break;
case Aspect_TOM_RING1 :
case Aspect_TOM_RING2 :
case Aspect_TOM_RING3 :
MyCGroup.ContextMarker.IsDef = 1;
// we draw a set of circles
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_O);
if (AMType == Aspect_TOM_RING1)
Limit = AScale - AScale * 0.8;
if (AMType == Aspect_TOM_RING2)
Limit = AScale - AScale * 0.5;
if (AMType == Aspect_TOM_RING3)
Limit = AScale - AScale * 0.2;
Delta = 0.1;
while (AScale > Limit && AScale >= 1.0) {
MyCGroup.ContextMarker.Scale = float (AScale);
call_togl_markercontextgroup (&MyCGroup, noinsert);
MyCGroup.ContextMarker.IsSet = 1;
if (MyTraceLevel) {
PrintFunction ("call_togl_marker");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker (&MyCGroup, &amarker);
AScale -= Delta;
}
break ;
default:
break ;
}
// Restauration des valeurs initiales
MyCGroup.ContextMarker.Color.r = float (AMR);
MyCGroup.ContextMarker.Color.g = float (AMR);
MyCGroup.ContextMarker.Color.b = float (AMR);
MyCGroup.ContextMarker.MarkerType = int (AMType);
MyCGroup.ContextMarker.Scale = float (AMScale);
} }
void OpenGl_GraphicDriver::MarkerSet (const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::Marker (const Graphic3d_CGroup& ACGroup, const Graphic3d_Vertex& APoint, const Standard_Boolean )
const Graphic3d_Array1OfVertex& ListVertex,
const Standard_Boolean )
{ {
// const Standard_Boolean EvalMinMax) { if (!ACGroup.ptrGroup)
return;
Graphic3d_CGroup MyCGroup = ACGroup; const Aspect_TypeOfMarker AType = Aspect_TypeOfMarker (ACGroup.ContextMarker.MarkerType);
//static void (*fp2) (Graphic3d_CGroup *, CALL_DEF_LISTMARKERS *) = NULL;
//if (! fp2) {
//OSD_Function osdfp = NULL;
//osdfp = MySharedLibrary.DlSymb ("call_togl_marker_set");
//fp2 = (void (*)(Graphic3d_CGroup *, CALL_DEF_LISTMARKERS *)) osdfp;
//if (! osdfp)
//Aspect_DriverDefinitionError::Raise
//(MySharedLibrary.DlError ());
//}
//static void (*fp3) (Graphic3d_CGroup *, int) = NULL;
//if (! fp3) {
//OSD_Function osdfp = NULL;
//osdfp = MySharedLibrary.DlSymb ("call_togl_markercontextgroup");
//fp3 = (void (*)(Graphic3d_CGroup *, int)) osdfp;
//if (! osdfp)
//Aspect_DriverDefinitionError::Raise
//(MySharedLibrary.DlError ());
//}
Standard_Integer Lower = ListVertex.Lower ();
CALL_DEF_LISTMARKERS almarkers;
almarkers.NbMarkers = int (ListVertex.Length ());
almarkers.Markers = (CALL_DEF_MARKER *) &ListVertex (Lower);
Standard_Real AMR, AMG, AMB, R, G, B;
Aspect_TypeOfMarker AMType;
Standard_Real AMScale, AScale;
// Sauvegarde des valeurs initiales
AMR = R = Standard_Real (MyCGroup.ContextMarker.Color.r);
AMG = G = Standard_Real (MyCGroup.ContextMarker.Color.g);
AMB = B = Standard_Real (MyCGroup.ContextMarker.Color.b);
AMType = Aspect_TypeOfMarker (MyCGroup.ContextMarker.MarkerType);
AMScale = AScale = Standard_Real (MyCGroup.ContextMarker.Scale);
int noinsert = 0;
Standard_Real H, L, S;
Standard_Real LastS;
Standard_Real Limit=0, Delta;
switch (AMType) {
switch (AType)
{
case Aspect_TOM_POINT : case Aspect_TOM_POINT :
case Aspect_TOM_PLUS : case Aspect_TOM_PLUS :
case Aspect_TOM_STAR : case Aspect_TOM_STAR :
case Aspect_TOM_O : case Aspect_TOM_O :
case Aspect_TOM_X : case Aspect_TOM_X :
case Aspect_TOM_USERDEFINED:
if (MyTraceLevel) {
PrintFunction ("call_togl_marker_set");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker_set (&MyCGroup, &almarkers);
break;
case Aspect_TOM_O_POINT : case Aspect_TOM_O_POINT :
MyCGroup.ContextMarker.IsDef = 1;
// we draw the circle
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_O);
call_togl_markercontextgroup (&MyCGroup, noinsert);
MyCGroup.ContextMarker.IsSet = 1;
if (MyTraceLevel) {
PrintFunction ("call_togl_marker_set");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker_set (&MyCGroup, &almarkers);
// we draw the point
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_POINT);
call_togl_markercontextgroup (&MyCGroup, noinsert);
if (MyTraceLevel) {
PrintFunction ("call_togl_marker_set");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker_set (&MyCGroup, &almarkers);
break;
case Aspect_TOM_O_PLUS : case Aspect_TOM_O_PLUS :
MyCGroup.ContextMarker.IsDef = 1;
// we draw the circle
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_O);
call_togl_markercontextgroup (&MyCGroup, noinsert);
MyCGroup.ContextMarker.IsSet = 1;
if (MyTraceLevel) {
PrintFunction ("call_togl_marker_set");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker_set (&MyCGroup, &almarkers);
// we draw the plus
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_PLUS);
call_togl_markercontextgroup (&MyCGroup, noinsert);
if (MyTraceLevel) {
PrintFunction ("call_togl_marker_set");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker_set (&MyCGroup, &almarkers);
break;
case Aspect_TOM_O_STAR : case Aspect_TOM_O_STAR :
MyCGroup.ContextMarker.IsDef = 1;
// we draw the circle
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_O);
call_togl_markercontextgroup (&MyCGroup, noinsert);
MyCGroup.ContextMarker.IsSet = 1;
if (MyTraceLevel) {
PrintFunction ("call_togl_marker_set");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker_set (&MyCGroup, &almarkers);
// we draw the star
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_STAR);
call_togl_markercontextgroup (&MyCGroup, noinsert);
if (MyTraceLevel) {
PrintFunction ("call_togl_marker_set");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker_set (&MyCGroup, &almarkers);
break;
case Aspect_TOM_O_X : case Aspect_TOM_O_X :
MyCGroup.ContextMarker.IsDef = 1;
// we draw the circle
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_O);
call_togl_markercontextgroup (&MyCGroup, noinsert);
MyCGroup.ContextMarker.IsSet = 1;
if (MyTraceLevel) {
PrintFunction ("call_togl_marker_set");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker_set (&MyCGroup, &almarkers);
// we draw the cross
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_X);
call_togl_markercontextgroup (&MyCGroup, noinsert);
if (MyTraceLevel) {
PrintFunction ("call_togl_marker_set");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker_set (&MyCGroup, &almarkers);
break;
case Aspect_TOM_BALL :
MyCGroup.ContextMarker.IsDef = 1;
// we draw a set of circles
MyCGroup.ContextMarker.MarkerType =
int (Aspect_TOM_O);
Delta = 0.1;
while (AScale >= 1.0) {
Quantity_Color::RgbHls (R, G, B, H, L, S);
// Modification de la saturation de 5 %
LastS = S;
S = S - S * 0.05;
if (S < 0.0) S = LastS;
Quantity_Color::HlsRgb (H, L, S, R, G, B);
MyCGroup.ContextMarker.Color.r = float (R);
MyCGroup.ContextMarker.Color.g = float (G);
MyCGroup.ContextMarker.Color.b = float (B);
MyCGroup.ContextMarker.Scale = float (AScale);
call_togl_markercontextgroup (&MyCGroup, noinsert);
MyCGroup.ContextMarker.IsSet = 1;
if (MyTraceLevel) {
PrintFunction ("call_togl_marker_set");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker_set (&MyCGroup, &almarkers);
AScale -= Delta;
}
break;
case Aspect_TOM_RING1 : case Aspect_TOM_RING1 :
case Aspect_TOM_RING2 : case Aspect_TOM_RING2 :
case Aspect_TOM_RING3 : case Aspect_TOM_RING3 :
MyCGroup.ContextMarker.IsDef = 1; case Aspect_TOM_USERDEFINED:
OpenGl_CreateMarkers(ACGroup, 1, &APoint);
break;
case Aspect_TOM_BALL :
{
const Standard_Real Delta = 0.1;
Standard_Real R, G, B, H, L, S, AScale;
R = Standard_Real (ACGroup.ContextMarker.Color.r);
G = Standard_Real (ACGroup.ContextMarker.Color.g);
B = Standard_Real (ACGroup.ContextMarker.Color.b);
AScale = Standard_Real (ACGroup.ContextMarker.Scale);
// we draw a set of circles // we draw a set of circles
MyCGroup.ContextMarker.MarkerType = CALL_DEF_CONTEXTMARKER AContext;
int (Aspect_TOM_O); AContext.MarkerType = int (Aspect_TOM_O);
if (AMType == Aspect_TOM_RING1) while (AScale >= 1.0)
Limit = AScale - AScale * 0.8; {
if (AMType == Aspect_TOM_RING2) Quantity_Color::RgbHls (R, G, B, H, L, S);
Limit = AScale - AScale * 0.5; // Modification de la saturation de 5 %
if (AMType == Aspect_TOM_RING3) S *= 0.95;
Limit = AScale - AScale * 0.2; Quantity_Color::HlsRgb (H, L, S, R, G, B);
Delta = 0.1; AContext.Color.r = float (R);
while (AScale > Limit && AScale >= 1.0) { AContext.Color.g = float (G);
MyCGroup.ContextMarker.Scale = float (AScale); AContext.Color.b = float (B);
call_togl_markercontextgroup (&MyCGroup, noinsert); AContext.Scale = float (AScale);
((OpenGl_Group *)ACGroup.ptrGroup)->SetAspectMarker(AContext, Standard_False);
MyCGroup.ContextMarker.IsSet = 1; OpenGl_CreateMarkers(ACGroup, 1, &APoint);
AScale -= Delta;
if (MyTraceLevel) {
PrintFunction ("call_togl_marker_set");
PrintCGroup (MyCGroup, 1);
}
call_togl_marker_set (&MyCGroup, &almarkers);
AScale -= Delta;
} }
break; break;
}
default:
break;
}
}
void OpenGl_GraphicDriver::MarkerSet (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertex& ListVertex,
const Standard_Boolean )
{
if (!ACGroup.ptrGroup)
return;
const Standard_Integer nb = ListVertex.Length();
const Graphic3d_Vertex *arr = &ListVertex( ListVertex.Lower() );
const Aspect_TypeOfMarker AType = Aspect_TypeOfMarker (ACGroup.ContextMarker.MarkerType);
switch (AType)
{
case Aspect_TOM_POINT :
case Aspect_TOM_PLUS :
case Aspect_TOM_STAR :
case Aspect_TOM_O :
case Aspect_TOM_X :
case Aspect_TOM_O_POINT :
case Aspect_TOM_O_PLUS :
case Aspect_TOM_O_STAR :
case Aspect_TOM_O_X :
case Aspect_TOM_RING1 :
case Aspect_TOM_RING2 :
case Aspect_TOM_RING3 :
case Aspect_TOM_USERDEFINED:
OpenGl_CreateMarkers(ACGroup, nb, arr);
break;
case Aspect_TOM_BALL :
{
const Standard_Real Delta = 0.1;
Standard_Real R, G, B, H, L, S, AScale;
R = Standard_Real (ACGroup.ContextMarker.Color.r);
G = Standard_Real (ACGroup.ContextMarker.Color.g);
B = Standard_Real (ACGroup.ContextMarker.Color.b);
AScale = Standard_Real (ACGroup.ContextMarker.Scale);
// we draw a set of circles
CALL_DEF_CONTEXTMARKER AContext;
AContext.MarkerType = int (Aspect_TOM_O);
while (AScale >= 1.0)
{
Quantity_Color::RgbHls (R, G, B, H, L, S);
// Modification de la saturation de 5 %
S *= 0.95;
Quantity_Color::HlsRgb (H, L, S, R, G, B);
AContext.Color.r = float (R);
AContext.Color.g = float (G);
AContext.Color.b = float (B);
AContext.Scale = float (AScale);
((OpenGl_Group *)ACGroup.ptrGroup)->SetAspectMarker(AContext, Standard_False);
OpenGl_CreateMarkers(ACGroup, nb, arr);
AScale -= Delta;
}
break;
}
default: default:
break; break;
} }
// Restauration des valeurs initiales
MyCGroup.ContextMarker.Color.r = float (AMR);
MyCGroup.ContextMarker.Color.g = float (AMR);
MyCGroup.ContextMarker.Color.b = float (AMR);
MyCGroup.ContextMarker.MarkerType = int (AMType);
MyCGroup.ContextMarker.Scale = float (AMScale);
} }

659
src/OpenGl/OpenGl_GraphicDriver_705.cxx
View File

@ -1,610 +1,89 @@
// File: OpenGl_GraphicDriver_705.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
// File OpenGl_GraphicDriver_705.cxx #include <OpenGl_GraphicDriver.hxx>
// Created Mardi 28 janvier 1997
// Author CAL
// Modified
// 27/07/97 ; PCT : ajout coordonnee texture
//-Copyright MatraDatavision 1997 #include <OpenGl_Group.hxx>
#include <OpenGl_Polygon.hxx>
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OpenGl_tgl_funcs.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void OpenGl_GraphicDriver::Polygon (const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::Polygon (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertex& ListVertex, const Graphic3d_Array1OfVertex& AListVertex,
const Graphic3d_TypeOfPolygon AType,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Integer i;
Standard_Integer Lower = ListVertex.Lower ();
CALL_DEF_FACET afacet;
i = ListVertex.Length ();
afacet.TypeFacet = int (AType);
afacet.NormalIsDefined = 0;
afacet.ColorIsDefined = 0;
afacet.NbPoints = int (i);
afacet.TypePoints = 1;
afacet.UPoints.Points = (CALL_DEF_POINT *) &ListVertex (Lower);
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon (&MyCGroup, &afacet);
}
void OpenGl_GraphicDriver::Polygon (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertex& ListVertex,
const Graphic3d_Vector& Normal,
const Graphic3d_TypeOfPolygon AType,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Integer i;
Standard_Integer Lower = ListVertex.Lower ();
CALL_DEF_FACET afacet;
i = ListVertex.Length ();
afacet.TypeFacet = int (AType);
afacet.NormalIsDefined = 1;
afacet.ColorIsDefined = 0;
Normal.Coord (X, Y, Z);
afacet.Normal.dx = float (X);
afacet.Normal.dy = float (Y);
afacet.Normal.dz = float (Z);
afacet.NbPoints = int (i);
afacet.TypePoints = 1;
afacet.UPoints.Points = (CALL_DEF_POINT *) &ListVertex (Lower);
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon (&MyCGroup, &afacet);
}
void OpenGl_GraphicDriver::Polygon (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexN& ListVertex,
const Graphic3d_TypeOfPolygon AType,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Real DX, DY, DZ;
Standard_Integer i, j;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
CALL_DEF_FACET afacet;
CALL_DEF_POINTN *points;
i = ListVertex.Length ();
// Allocation dynamique
points = new CALL_DEF_POINTN [i];
afacet.TypeFacet = int (AType);
afacet.NormalIsDefined = 0;
afacet.ColorIsDefined = 0;
afacet.NbPoints = int (i);
afacet.TypePoints = 2;
afacet.UPoints.PointsN = points;
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
ListVertex (i).Normal (DX, DY, DZ);
points[j].Normal.dx = float (DX);
points[j].Normal.dy = float (DY);
points[j].Normal.dz = float (DZ);
}
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon (&MyCGroup, &afacet);
// Desallocation dynamique
delete [] points;
}
void OpenGl_GraphicDriver::Polygon (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexN& ListVertex,
const Graphic3d_Vector& Normal,
const Graphic3d_TypeOfPolygon AType,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Real DX, DY, DZ;
Standard_Integer i, j;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
CALL_DEF_FACET afacet;
CALL_DEF_POINTN *points;
i = ListVertex.Length ();
// Allocation dynamique
points = new CALL_DEF_POINTN [i];
afacet.TypeFacet = int (AType);
afacet.NormalIsDefined = 1;
afacet.ColorIsDefined = 0;
Normal.Coord (DX, DY, DZ);
afacet.Normal.dx = float (DX);
afacet.Normal.dy = float (DY);
afacet.Normal.dz = float (DZ);
afacet.NbPoints = int (i);
afacet.TypePoints = 2;
afacet.UPoints.PointsN = points;
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
ListVertex (i).Normal (DX, DY, DZ);
points[j].Normal.dx = float (DX);
points[j].Normal.dy = float (DY);
points[j].Normal.dz = float (DZ);
}
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon (&MyCGroup, &afacet);
// Desallocation dynamique
delete [] points;
}
void OpenGl_GraphicDriver::Polygon(const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexNT& ListVertex,
const Graphic3d_TypeOfPolygon AType, const Graphic3d_TypeOfPolygon AType,
const Standard_Boolean ) const Standard_Boolean )
{ {
if (ACGroup.ptrGroup)
Graphic3d_CGroup MyCGroup = ACGroup; {
OpenGl_Polygon *apolygon = new OpenGl_Polygon( AListVertex, AType );
((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelPolygon, apolygon );
Standard_Real X, Y, Z;
Standard_Real DX, DY, DZ;
Standard_Real TX, TY;
Standard_Integer i, j;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
CALL_DEF_FACET afacet;
CALL_DEF_POINTNT *points;
i = ListVertex.Length ();
// Allocation dynamique
points = new CALL_DEF_POINTNT [i];
afacet.TypeFacet = int (AType);
afacet.NormalIsDefined = 0;
afacet.ColorIsDefined = 0;
afacet.NbPoints = int (i);
afacet.TypePoints = 5;
afacet.UPoints.PointsNT = points;
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
ListVertex (i).Normal (DX, DY, DZ);
points[j].Normal.dx = float (DX);
points[j].Normal.dy = float (DY);
points[j].Normal.dz = float (DZ);
ListVertex (i).TextureCoordinate(TX, TY);
points[j].TextureCoord.tx = float(TX);
points[j].TextureCoord.ty = float(TY);
} }
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon (&MyCGroup, &afacet);
// Desallocation dynamique
delete [] points;
} }
void OpenGl_GraphicDriver::Polygon (const Graphic3d_CGroup& ,
void OpenGl_GraphicDriver::PolygonHoles (const Graphic3d_CGroup& ACGroup, const Graphic3d_Array1OfVertex& ,
const TColStd_Array1OfInteger& Bounds, const Graphic3d_Vector& ,
const Graphic3d_Array1OfVertex& ListVertex, const Graphic3d_TypeOfPolygon ,
const Standard_Boolean ) const Standard_Boolean )
{ {
// Do nothing
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Integer i, ii;
Standard_Integer j;
Standard_Integer k, kk;
Standard_Integer nb_points;
Standard_Integer begin_points;
Standard_Integer end_points;
Standard_Integer Lower, Upper;
CALL_DEF_LISTFACETS alfacets;
CALL_DEF_FACET *facets;
CALL_DEF_POINT *points;
i = ListVertex.Length ();
j = Bounds.Length ();
// Allocation dynamique
points = new CALL_DEF_POINT [i];
facets = new CALL_DEF_FACET [j];
alfacets.NbFacets = int (j);
alfacets.LFacets = facets;
begin_points = ListVertex.Lower ();
end_points = ListVertex.Upper ();
Lower = Bounds.Lower ();
Upper = Bounds.Upper ();
nb_points = 0;
// Parcours des facettes
for (k=0, kk=Lower; kk<=Upper; k++, kk++) {
facets[k].TypeFacet = 0; /* TOP_UNKNOWN */
facets[k].NormalIsDefined = 0;
facets[k].ColorIsDefined = 0;
facets[k].NbPoints = int (Bounds.Value (kk));
facets[k].TypePoints = 1;
facets[k].UPoints.Points = (points + nb_points);
// Parcours des sommets
for (i=0, ii=begin_points;
((ii<=end_points) || (i==facets[k].NbPoints-1));
i++, ii++) {
ListVertex (ii).Coord (X, Y, Z);
points[nb_points+i].x = float (X);
points[nb_points+i].y = float (Y);
points[nb_points+i].z = float (Z);
}
begin_points += facets[k].NbPoints;
nb_points += facets[k].NbPoints;
}
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_holes");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_holes (&MyCGroup, &alfacets);
// Desallocation dynamique
delete [] points;
delete [] facets;
} }
void OpenGl_GraphicDriver::PolygonHoles (const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::Polygon (const Graphic3d_CGroup& ,
const TColStd_Array1OfInteger& Bounds, const Graphic3d_Array1OfVertexN& ,
const Graphic3d_Array1OfVertex& ListVertex, const Graphic3d_TypeOfPolygon ,
const Graphic3d_Vector& Normal, const Standard_Boolean )
const Standard_Boolean )
{ {
// Do nothing
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Real NX, NY, NZ;
Standard_Integer i, ii;
Standard_Integer j;
Standard_Integer k, kk;
Standard_Integer nb_points;
Standard_Integer begin_points;
Standard_Integer end_points;
Standard_Integer Lower, Upper;
CALL_DEF_LISTFACETS alfacets;
CALL_DEF_FACET *facets;
CALL_DEF_POINT *points;
i = ListVertex.Length ();
j = Bounds.Length ();
// Allocation dynamique
points = new CALL_DEF_POINT [i];
facets = new CALL_DEF_FACET [j];
alfacets.NbFacets = int (j);
alfacets.LFacets = facets;
begin_points = ListVertex.Lower ();
end_points = ListVertex.Upper ();
Lower = Bounds.Lower ();
Upper = Bounds.Upper ();
nb_points = 0;
Normal.Coord (NX, NY, NZ);
// Parcours des facettes
for (k=0, kk=Lower; kk<=Upper; k++, kk++) {
facets[k].TypeFacet = 0; /* TOP_UNKNOWN */
facets[k].ColorIsDefined = 0;
facets[k].NormalIsDefined = 1;
facets[k].Normal.dx = float (NX);
facets[k].Normal.dy = float (NY);
facets[k].Normal.dz = float (NZ);
facets[k].NbPoints = int (Bounds.Value (kk));
facets[k].TypePoints = 1;
facets[k].UPoints.Points = (points + nb_points);
// Parcours des sommets
for (i=0, ii=begin_points;
((ii<=end_points) || (i==facets[k].NbPoints-1));
i++, ii++) {
ListVertex (ii).Coord (X, Y, Z);
points[nb_points+i].x = float (X);
points[nb_points+i].y = float (Y);
points[nb_points+i].z = float (Z);
}
begin_points += facets[k].NbPoints;
nb_points += facets[k].NbPoints;
}
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_holes");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_holes (&MyCGroup, &alfacets);
// Desallocation dynamique
delete [] points;
delete [] facets;
} }
void OpenGl_GraphicDriver::PolygonHoles (const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::Polygon (const Graphic3d_CGroup& ,
const TColStd_Array1OfInteger& Bounds, const Graphic3d_Array1OfVertexN& ,
const Graphic3d_Array1OfVertexN& ListVertex, const Graphic3d_Vector& ,
const Standard_Boolean ) const Graphic3d_TypeOfPolygon ,
const Standard_Boolean )
{ {
// Do nothing
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Real DX, DY, DZ;
Standard_Integer i, ii;
Standard_Integer j;
Standard_Integer k, kk;
Standard_Integer nb_points;
Standard_Integer begin_points;
Standard_Integer end_points;
Standard_Integer Lower, Upper;
CALL_DEF_LISTFACETS alfacets;
CALL_DEF_FACET *facets;
CALL_DEF_POINTN *points;
i = ListVertex.Length ();
j = Bounds.Length ();
// Allocation dynamique
points = new CALL_DEF_POINTN [i];
facets = new CALL_DEF_FACET [j];
alfacets.NbFacets = int (j);
alfacets.LFacets = facets;
begin_points = ListVertex.Lower ();
end_points = ListVertex.Upper ();
Lower = Bounds.Lower ();
Upper = Bounds.Upper ();
nb_points = 0;
// Parcours des facettes
for (k=0, kk=Lower; kk<=Upper; k++, kk++) {
facets[k].TypeFacet = 0; /* TOP_UNKNOWN */
facets[k].NormalIsDefined = 0;
facets[k].ColorIsDefined = 0;
facets[k].NbPoints = int (Bounds.Value (kk));
facets[k].TypePoints = 2;
facets[k].UPoints.PointsN = (points + nb_points);
// Parcours des sommets
for (i=0, ii=begin_points;
((ii<=end_points) || (i==facets[k].NbPoints-1));
i++, ii++) {
ListVertex (ii).Coord (X, Y, Z);
points[nb_points+i].Point.x = float (X);
points[nb_points+i].Point.y = float (Y);
points[nb_points+i].Point.z = float (Z);
ListVertex (ii).Normal (DX, DY, DZ);
points[nb_points+i].Normal.dx = float (DX);
points[nb_points+i].Normal.dy = float (DY);
points[nb_points+i].Normal.dz = float (DZ);
}
begin_points += facets[k].NbPoints;
nb_points += facets[k].NbPoints;
}
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_holes");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_holes (&MyCGroup, &alfacets);
// Desallocation dynamique
delete [] points;
delete [] facets;
} }
void OpenGl_GraphicDriver::PolygonHoles (const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::Polygon (const Graphic3d_CGroup& ,
const TColStd_Array1OfInteger& Bounds, const Graphic3d_Array1OfVertexNT& ,
const Graphic3d_Array1OfVertexN& ListVertex, const Graphic3d_TypeOfPolygon ,
const Graphic3d_Vector& Normal, const Standard_Boolean )
const Standard_Boolean )
{ {
// Do nothing
Graphic3d_CGroup MyCGroup = ACGroup; }
Standard_Real X, Y, Z; void OpenGl_GraphicDriver::PolygonHoles (const Graphic3d_CGroup& ,
Standard_Real DX, DY, DZ; const TColStd_Array1OfInteger& ,
Standard_Real NX, NY, NZ; const Graphic3d_Array1OfVertex& ,
const Standard_Boolean )
Standard_Integer i, ii; {
Standard_Integer j; // Do nothing
Standard_Integer k, kk; }
Standard_Integer nb_points;
Standard_Integer begin_points; void OpenGl_GraphicDriver::PolygonHoles (const Graphic3d_CGroup& ,
Standard_Integer end_points; const TColStd_Array1OfInteger& ,
Standard_Integer Lower, Upper; const Graphic3d_Array1OfVertex& ,
const Graphic3d_Vector& ,
CALL_DEF_LISTFACETS alfacets; const Standard_Boolean )
CALL_DEF_FACET *facets; {
CALL_DEF_POINTN *points; // Do nothing
}
i = ListVertex.Length ();
j = Bounds.Length (); void OpenGl_GraphicDriver::PolygonHoles (const Graphic3d_CGroup& ,
const TColStd_Array1OfInteger& ,
// Allocation dynamique const Graphic3d_Array1OfVertexN& ,
points = new CALL_DEF_POINTN [i]; const Standard_Boolean )
facets = new CALL_DEF_FACET [j]; {
// Do nothing
alfacets.NbFacets = int (j); }
alfacets.LFacets = facets;
void OpenGl_GraphicDriver::PolygonHoles (const Graphic3d_CGroup& ,
begin_points = ListVertex.Lower (); const TColStd_Array1OfInteger& ,
end_points = ListVertex.Upper (); const Graphic3d_Array1OfVertexN& ,
const Graphic3d_Vector& ,
Lower = Bounds.Lower (); const Standard_Boolean )
Upper = Bounds.Upper (); {
// Do nothing
nb_points = 0;
Normal.Coord (NX, NY, NZ);
// Parcours des facettes
for (k=0, kk=Lower; kk<=Upper; k++, kk++) {
facets[k].TypeFacet = 0; /* TOP_UNKNOWN */
facets[k].ColorIsDefined = 0;
facets[k].NormalIsDefined = 1;
facets[k].Normal.dx = float (NX);
facets[k].Normal.dy = float (NY);
facets[k].Normal.dz = float (NZ);
facets[k].NbPoints = int (Bounds.Value (kk));
facets[k].TypePoints = 2;
facets[k].UPoints.PointsN = (points + nb_points);
// Parcours des sommets
for (i=0, ii=begin_points;
((ii<=end_points) || (i==facets[k].NbPoints-1));
i++, ii++) {
ListVertex (ii).Coord (X, Y, Z);
points[nb_points+i].Point.x = float (X);
points[nb_points+i].Point.y = float (Y);
points[nb_points+i].Point.z = float (Z);
ListVertex (ii).Normal (DX, DY, DZ);
points[nb_points+i].Normal.dx = float (DX);
points[nb_points+i].Normal.dy = float (DY);
points[nb_points+i].Normal.dz = float (DZ);
}
begin_points += facets[k].NbPoints;
nb_points += facets[k].NbPoints;
}
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_holes");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_holes (&MyCGroup, &alfacets);
// Desallocation dynamique
delete [] points;
delete [] facets;
} }

162
src/OpenGl/OpenGl_GraphicDriver_707.cxx
View File

@ -1,147 +1,47 @@
// File: OpenGl_GraphicDriver_707.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
// File OpenGl_GraphicDriver_707.cxx #include <OpenGl_GraphicDriver.hxx>
// Created Mardi 28 janvier 1997
// Author CAL
//-Copyright MatraDatavision 1997 #include <OpenGl_Group.hxx>
#include <OpenGl_Polyline.hxx>
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OpenGl_tgl_funcs.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void OpenGl_GraphicDriver::Polyline (const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::Polyline (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertex& ListVertex, const Graphic3d_Array1OfVertex& AListVertex,
const Standard_Boolean ) const Standard_Boolean )
{ {
if (ACGroup.ptrGroup)
Graphic3d_CGroup MyCGroup = ACGroup; {
OpenGl_Polyline *apolyline = new OpenGl_Polyline( AListVertex );
Standard_Integer i; ((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelPolyline, apolyline );
Standard_Integer Lower = ListVertex.Lower ();
CALL_DEF_LISTPOINTS alpoints;
i = ListVertex.Length ();
alpoints.NbPoints = int (i);
alpoints.TypePoints = 1;
alpoints.UPoints.Points = (CALL_DEF_POINT *) &ListVertex (Lower);
if (MyTraceLevel) {
PrintFunction ("call_togl_polyline");
PrintCGroup (MyCGroup, 1);
} }
call_togl_polyline (&MyCGroup, &alpoints);
} }
void OpenGl_GraphicDriver::Polyline (const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::Polyline (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexC& ListVertex, const Graphic3d_Array1OfVertexC& AListVertex,
const Standard_Boolean ) const Standard_Boolean )
{ {
if (ACGroup.ptrGroup)
Graphic3d_CGroup MyCGroup = ACGroup; {
OpenGl_Polyline *apolyline = new OpenGl_Polyline( AListVertex );
((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelPolyline, apolyline );
Standard_Real X, Y, Z;
Standard_Real R, G, B;
Standard_Integer i, j;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
CALL_DEF_LISTPOINTS alpoints;
CALL_DEF_POINTC *points;
i = ListVertex.Length ();
// Allocation dynamique
points = new CALL_DEF_POINTC [i];
alpoints.NbPoints = int (i);
alpoints.TypePoints = 3;
alpoints.UPoints.PointsC= points;
Lower = ListVertex.Lower ();
Upper = ListVertex.Upper ();
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
(ListVertex (i).Color ()).Values (R, G, B, Quantity_TOC_RGB);
points[j].Color.r = float (R);
points[j].Color.g = float (G);
points[j].Color.b = float (B);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
} }
if (MyTraceLevel) {
PrintFunction ("call_togl_polyline");
PrintCGroup (MyCGroup, 1);
}
call_togl_polyline (&MyCGroup, &alpoints);
// Desallocation dynamique
delete [] points;
} }
void OpenGl_GraphicDriver::Polyline (const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::Polyline (const Graphic3d_CGroup& ACGroup,
const Standard_Real X1, const Standard_Real X1,
const Standard_Real Y1, const Standard_Real Y1,
const Standard_Real Z1, const Standard_Real Z1,
const Standard_Real X2, const Standard_Real X2,
const Standard_Real Y2, const Standard_Real Y2,
const Standard_Real Z2, const Standard_Real Z2,
const Standard_Boolean ) const Standard_Boolean )
{ {
if (ACGroup.ptrGroup)
Graphic3d_CGroup TheGroup = ACGroup; {
OpenGl_Polyline *apolyline = new OpenGl_Polyline( X1, Y1, Z1, X2, Y2, Z2 );
CALL_DEF_LISTPOINTS alpoints; ((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelPolyline, apolyline );
}
CALL_DEF_POINT *points;
// Allocation dynamique
points = new CALL_DEF_POINT [2];
alpoints.NbPoints = 2;
alpoints.TypePoints = 1;
alpoints.UPoints.Points = points;
points[0].x = float (X1);
points[0].y = float (Y1);
points[0].z = float (Z1);
points[1].x = float (X2);
points[1].y = float (Y2);
points[1].z = float (Z2);
call_togl_polyline (&TheGroup, &alpoints);
// Desallocation dynamique
delete [] points;
} }

637
src/OpenGl/OpenGl_GraphicDriver_709.cxx
View File

@ -1,627 +1,42 @@
// File: OpenGl_GraphicDriver_709.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
// File OpenGl_GraphicDriver_709.cxx #include <OpenGl_GraphicDriver.hxx>
// Created Mardi 28 janvier 1997
// Author CAL
// Modified
// 27/08/97 ; PCT : ajout coordonnee texture
//-Copyright MatraDatavision 1997 #include <OpenGl_Group.hxx>
#include <OpenGl_QuadrangleStrip.hxx>
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OpenGl_tgl_funcs.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void OpenGl_GraphicDriver::QuadrangleMesh (const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::QuadrangleMesh (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array2OfVertex& ListVertex, const Graphic3d_Array2OfVertex& ListVertex,
const Standard_Boolean ) const Standard_Boolean )
{ {
if (ACGroup.ptrGroup)
Graphic3d_CGroup MyCGroup = ACGroup; {
OpenGl_QuadrangleStrip *aqstrip = new OpenGl_QuadrangleStrip( ListVertex );
Standard_Real X, Y, Z; ((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelQuadrangle, aqstrip );
}
Standard_Integer i, j, k;
Standard_Integer LowerRow = ListVertex.LowerRow ();
Standard_Integer UpperRow = ListVertex.UpperRow ();
Standard_Integer LowerCol = ListVertex.LowerCol ();
Standard_Integer UpperCol = ListVertex.UpperCol ();
CALL_DEF_QUAD aquad;
CALL_DEF_POINT *points;
i = ListVertex.RowLength ();
j = ListVertex.ColLength ();
// Allocation dynamique
points = new CALL_DEF_POINT [i*j];
aquad.NbPoints = int (i*j);
aquad.TypePoints = 1;
aquad.SizeRow = int (i);
aquad.SizeCol = int (j);
aquad.UPoints.Points = points;
// Parcours des sommets
k = 0;
for (i=LowerRow; i<=UpperRow; i++)
for (j=LowerCol; j<=UpperCol; j++) {
ListVertex (i, j).Coord (X, Y, Z);
points[k].x = float (X);
points[k].y = float (Y);
points[k].z = float (Z);
k++;
}
if (MyTraceLevel) {
PrintFunction ("call_togl_quadrangle");
PrintCGroup (MyCGroup, 1);
}
call_togl_quadrangle (&MyCGroup, &aquad);
// Desallocation dynamique
delete [] points;
} }
void OpenGl_GraphicDriver::QuadrangleMesh (const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::QuadrangleMesh (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array2OfVertexN& ListVertex, const Graphic3d_Array2OfVertexN& ListVertex,
const Standard_Boolean ) const Standard_Boolean )
{ {
if (ACGroup.ptrGroup)
Graphic3d_CGroup MyCGroup = ACGroup; {
OpenGl_QuadrangleStrip *aqstrip = new OpenGl_QuadrangleStrip( ListVertex );
Standard_Real X, Y, Z; ((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelQuadrangle, aqstrip );
Standard_Real DX, DY, DZ; }
Standard_Integer i, j, k;
Standard_Integer LowerRow = ListVertex.LowerRow ();
Standard_Integer UpperRow = ListVertex.UpperRow ();
Standard_Integer LowerCol = ListVertex.LowerCol ();
Standard_Integer UpperCol = ListVertex.UpperCol ();
CALL_DEF_QUAD aquad;
CALL_DEF_POINTN *points;
i = ListVertex.RowLength ();
j = ListVertex.ColLength ();
// Allocation dynamique
points = new CALL_DEF_POINTN [i*j];
aquad.NbPoints = int (i*j);
aquad.TypePoints = 2;
aquad.SizeRow = int (i);
aquad.SizeCol = int (j);
aquad.UPoints.PointsN = points;
// Parcours des sommets
k = 0;
for (i=LowerRow; i<=UpperRow; i++)
for (j=LowerCol; j<=UpperCol; j++) {
ListVertex (i, j).Coord (X, Y, Z);
points[k].Point.x = float (X);
points[k].Point.y = float (Y);
points[k].Point.z = float (Z);
ListVertex (i, j).Normal (DX, DY, DZ);
points[k].Normal.dx = float (DX);
points[k].Normal.dy = float (DY);
points[k].Normal.dz = float (DZ);
k++;
}
if (MyTraceLevel) {
PrintFunction ("call_togl_quadrangle");
PrintCGroup (MyCGroup, 1);
}
call_togl_quadrangle (&MyCGroup, &aquad);
// Desallocation dynamique
delete [] points;
} }
void OpenGl_GraphicDriver::QuadrangleMesh(const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::QuadrangleMesh(const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array2OfVertexNT& ListVertex, const Graphic3d_Array2OfVertexNT& ListVertex,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Real DX, DY, DZ;
Standard_Integer i, j, k;
Standard_Integer LowerRow = ListVertex.LowerRow ();
Standard_Integer UpperRow = ListVertex.UpperRow ();
Standard_Integer LowerCol = ListVertex.LowerCol ();
Standard_Integer UpperCol = ListVertex.UpperCol ();
CALL_DEF_QUAD aquad;
CALL_DEF_POINTNT *points;
i = ListVertex.RowLength ();
j = ListVertex.ColLength ();
// Allocation dynamique
points = new CALL_DEF_POINTNT [i*j];
aquad.NbPoints = int (i*j);
aquad.TypePoints = 5;
aquad.SizeRow = int (i);
aquad.SizeCol = int (j);
aquad.UPoints.PointsNT = points;
// Parcours des sommets
k = 0;
for (i=LowerRow; i<=UpperRow; i++)
for (j=LowerCol; j<=UpperCol; j++) {
ListVertex (i, j).Coord (X, Y, Z);
points[k].Point.x = float (X);
points[k].Point.y = float (Y);
points[k].Point.z = float (Z);
ListVertex (i, j).Normal (DX, DY, DZ);
points[k].Normal.dx = float (DX);
points[k].Normal.dy = float (DY);
points[k].Normal.dz = float (DZ);
ListVertex (i, j).TextureCoordinate(DX,DY);
points[k].TextureCoord.tx = float(DX);
points[k].TextureCoord.ty = float(DY);
k++;
}
if (MyTraceLevel) {
PrintFunction ("call_togl_quadrangle");
PrintCGroup (MyCGroup, 1);
}
call_togl_quadrangle (&MyCGroup, &aquad);
// Desallocation dynamique
delete [] points;
}
void OpenGl_GraphicDriver::QuadrangleSet (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertex& ListVertex,
const Aspect_Array1OfEdge& ListEdge,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Integer i, j, k;
Standard_Integer Lower, Upper;
Standard_Integer OffSet;
CALL_DEF_LISTPOINTS alpoints;
CALL_DEF_LISTEDGES aledges;
CALL_DEF_EDGE *edges;
// Permettra une generalisation plus facile a une methode du style
// PolygonSet (ListVertex, ListEdge, Bounds).
int *integers;
CALL_DEF_LISTINTEGERS albounds;
i = ListVertex.Length ();
j = ListEdge.Length ();
k = int (j/4);
Lower = ListVertex.Lower ();
Upper = ListVertex.Upper ();
OffSet = Lower;
// Allocation dynamique
edges = new CALL_DEF_EDGE [j];
integers= new int [k];
alpoints.NbPoints = int (i);
alpoints.TypePoints = 1;
alpoints.UPoints.Points = (CALL_DEF_POINT *) &ListVertex (Lower);
aledges.NbEdges = int (j);
aledges.Edges = edges;
albounds.NbIntegers = int (k);
albounds.Integers = integers;
Lower = ListEdge.Lower ();
Upper = ListEdge.Upper ();
// Parcours des aretes
for (j=0, i=Lower; i<=Upper; i++, j++) {
edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
edges[j].Type = int (ListEdge (i).Type ());
}
// Parcours des limites (ici toutes les limites sont egales a 4.
for (j=0; j<albounds.NbIntegers; j++) integers[j] = 4;
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_indices");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
// Desallocation dynamique
delete [] edges;
delete [] integers;
}
void OpenGl_GraphicDriver::QuadrangleSet (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexN& ListVertex,
const Aspect_Array1OfEdge& ListEdge,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Real DX, DY, DZ;
Standard_Integer i, j, k;
Standard_Integer Lower, Upper;
Standard_Integer OffSet;
CALL_DEF_LISTPOINTS alpoints;
CALL_DEF_POINTN *points;
CALL_DEF_LISTEDGES aledges;
CALL_DEF_EDGE *edges;
// Permettra une generalisation plus facile a une methode du style
// PolygonSet (ListVertex, ListEdge, Bounds).
int *integers;
CALL_DEF_LISTINTEGERS albounds;
i = ListVertex.Length ();
j = ListEdge.Length ();
k = int (j/4);
Lower = ListVertex.Lower ();
Upper = ListVertex.Upper ();
OffSet = Lower;
// Allocation dynamique
points = new CALL_DEF_POINTN [i];
edges = new CALL_DEF_EDGE [j];
integers= new int [k];
alpoints.NbPoints = int (i);
alpoints.TypePoints = 2;
alpoints.UPoints.PointsN= points;
aledges.NbEdges = int (j);
aledges.Edges = edges;
albounds.NbIntegers = int (k);
albounds.Integers = integers;
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
ListVertex (i).Normal (DX, DY, DZ);
points[j].Normal.dx = float (DX);
points[j].Normal.dy = float (DY);
points[j].Normal.dz = float (DZ);
}
Lower = ListEdge.Lower ();
Upper = ListEdge.Upper ();
// Parcours des aretes
for (j=0, i=Lower; i<=Upper; i++, j++) {
edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
edges[j].Type = int (ListEdge (i).Type ());
}
// Parcours des limites (ici toutes les limites sont egales a 4.
for (j=0; j<albounds.NbIntegers; j++) integers[j] = 4;
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_indices");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
// Desallocation dynamique
delete [] points;
delete [] edges;
delete [] integers;
}
void OpenGl_GraphicDriver::QuadrangleSet (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexC& ListVertex,
const Aspect_Array1OfEdge& ListEdge,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Real R, G, B;
Standard_Integer i, j, k;
Standard_Integer Lower, Upper;
Standard_Integer OffSet;
CALL_DEF_LISTPOINTS alpoints;
CALL_DEF_POINTC *points;
CALL_DEF_LISTEDGES aledges;
CALL_DEF_EDGE *edges;
// Permettra une generalisation plus facile a une methode du style
// PolygonSet (ListVertex, ListEdge, Bounds).
int *integers;
CALL_DEF_LISTINTEGERS albounds;
i = ListVertex.Length ();
j = ListEdge.Length ();
k = int (j/4);
Lower = ListVertex.Lower ();
Upper = ListVertex.Upper ();
OffSet = Lower;
// Allocation dynamique
points = new CALL_DEF_POINTC [i];
edges = new CALL_DEF_EDGE [j];
integers= new int [k];
alpoints.NbPoints = int (i);
alpoints.TypePoints = 3;
alpoints.UPoints.PointsC= points;
aledges.NbEdges = int (j);
aledges.Edges = edges;
albounds.NbIntegers = int (k);
albounds.Integers = integers;
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
(ListVertex (i).Color ()).Values (R, G, B, Quantity_TOC_RGB);
points[j].Color.r = float (R);
points[j].Color.g = float (G);
points[j].Color.b = float (B);
}
Lower = ListEdge.Lower ();
Upper = ListEdge.Upper ();
// Parcours des aretes
for (j=0, i=Lower; i<=Upper; i++, j++) {
edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
edges[j].Type = int (ListEdge (i).Type ());
}
// Parcours des limites (ici toutes les limites sont egales a 4.
for (j=0; j<albounds.NbIntegers; j++) integers[j] = 4;
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_indices");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
// Desallocation dynamique
delete [] points;
delete [] edges;
delete [] integers;
}
void OpenGl_GraphicDriver::QuadrangleSet (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexNC& ListVertex,
const Aspect_Array1OfEdge& ListEdge,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Real R, G, B;
Standard_Real DX, DY, DZ;
Standard_Integer i, j, k;
Standard_Integer Lower, Upper;
Standard_Integer OffSet;
CALL_DEF_LISTPOINTS alpoints;
CALL_DEF_POINTNC *points;
CALL_DEF_LISTEDGES aledges;
CALL_DEF_EDGE *edges;
// Permettra une generalisation plus facile a une methode du style
// PolygonSet (ListVertex, ListEdge, Bounds).
int *integers;
CALL_DEF_LISTINTEGERS albounds;
i = ListVertex.Length ();
j = ListEdge.Length ();
k = int (j/4);
Lower = ListVertex.Lower ();
Upper = ListVertex.Upper ();
OffSet = Lower;
// Allocation dynamique
points = new CALL_DEF_POINTNC [i];
edges = new CALL_DEF_EDGE [j];
integers= new int [k];
alpoints.NbPoints = int (i);
alpoints.TypePoints = 4;
alpoints.UPoints.PointsNC= points;
aledges.NbEdges = int (j);
aledges.Edges = edges;
albounds.NbIntegers = int (k);
albounds.Integers = integers;
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
ListVertex (i).Normal (DX, DY, DZ);
points[j].Normal.dx = float (DX);
points[j].Normal.dy = float (DY);
points[j].Normal.dz = float (DZ);
(ListVertex (i).Color ()).Values (R, G, B, Quantity_TOC_RGB);
points[j].Color.r = float (R);
points[j].Color.g = float (G);
points[j].Color.b = float (B);
}
Lower = ListEdge.Lower ();
Upper = ListEdge.Upper ();
// Parcours des aretes
for (j=0, i=Lower; i<=Upper; i++, j++) {
edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
edges[j].Type = int (ListEdge (i).Type ());
}
// Parcours des limites (ici toutes les limites sont egales a 4.
for (j=0; j<albounds.NbIntegers; j++) integers[j] = 4;
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_indices");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
// Desallocation dynamique
delete [] points;
delete [] edges;
delete [] integers;
}
void OpenGl_GraphicDriver::QuadrangleSet(const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexNT& ListVertex,
const Aspect_Array1OfEdge& ListEdge,
const Standard_Boolean ) const Standard_Boolean )
{ {
if (ACGroup.ptrGroup)
Graphic3d_CGroup MyCGroup = ACGroup; {
OpenGl_QuadrangleStrip *aqstrip = new OpenGl_QuadrangleStrip( ListVertex );
((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelQuadrangle, aqstrip );
Standard_Real X, Y, Z;
Standard_Real DX, DY, DZ;
Standard_Integer i, j, k;
Standard_Integer Lower, Upper;
Standard_Integer OffSet;
CALL_DEF_LISTPOINTS alpoints;
CALL_DEF_POINTNT *points;
CALL_DEF_LISTEDGES aledges;
CALL_DEF_EDGE *edges;
// Permettra une generalisation plus facile a une methode du style
// PolygonSet (ListVertex, ListEdge, Bounds).
int *integers;
CALL_DEF_LISTINTEGERS albounds;
i = ListVertex.Length ();
j = ListEdge.Length ();
k = int (j/4);
Lower = ListVertex.Lower ();
Upper = ListVertex.Upper ();
OffSet = Lower;
// Allocation dynamique
points = new CALL_DEF_POINTNT [i];
edges = new CALL_DEF_EDGE [j];
integers= new int [k];
alpoints.NbPoints = int (i);
alpoints.TypePoints = 5;
alpoints.UPoints.PointsNT= points;
aledges.NbEdges = int (j);
aledges.Edges = edges;
albounds.NbIntegers = int (k);
albounds.Integers = integers;
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
ListVertex (i).Normal (DX, DY, DZ);
points[j].Normal.dx = float (DX);
points[j].Normal.dy = float (DY);
points[j].Normal.dz = float (DZ);
ListVertex (i).TextureCoordinate(DX,DY);
points[j].TextureCoord.tx = float(DX);
points[j].TextureCoord.ty = float(DY);
} }
Lower = ListEdge.Lower ();
Upper = ListEdge.Upper ();
// Parcours des aretes
for (j=0, i=Lower; i<=Upper; i++, j++) {
edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
edges[j].Type = int (ListEdge (i).Type ());
}
// Parcours des limites (ici toutes les limites sont egales a 4.
for (j=0; j<albounds.NbIntegers; j++) integers[j] = 4;
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_indices");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
// Desallocation dynamique
delete [] points;
delete [] edges;
delete [] integers;
} }

94
src/OpenGl/OpenGl_GraphicDriver_710.cxx
View File

@ -1,37 +1,13 @@
// File: OpenGl_GraphicDriver_710.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#define NOVIRTUAL #include <OpenGl_GraphicDriver.hxx>
// File OpenGl_GraphicDriver_710.cxx
// Created Mardi 28 janvier 1997
// Author CAL
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
#include <OpenGl_Group.hxx>
#include <Aspect_DriverDefinitionError.hxx> #include <OpenGl_Text.hxx>
#include <OpenGl_tgl_funcs.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void OpenGl_GraphicDriver::Text void OpenGl_GraphicDriver::Text
( (
@ -76,29 +52,15 @@ void OpenGl_GraphicDriver::Text
const Standard_Boolean const Standard_Boolean
) )
{ {
Graphic3d_CGroup MyCGroup = ACGroup; if (ACGroup.ptrGroup)
{
Standard_Real theHeight = AHeight;
if (theHeight < 0.)
theHeight = DefaultTextHeight();
CALL_DEF_TEXT atext; OpenGl_Text *atext = new OpenGl_Text( AText, APoint, theHeight, AHta, AVta );
((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelText, atext );
Standard_Real X, Y, Z;
APoint.Coord (X, Y, Z);
atext.Position.x = float (X);
atext.Position.y = float (Y);
atext.Position.z = float (Z);
atext.Height = float (AHeight);
if (atext.Height < 0)
atext.Height = DefaultTextHeight();
atext.Angle = float (AAngle);
atext.Path = int (ATp);
atext.HAlign = int (AHta);
atext.VAlign = int (AVta);
atext.string = (unsigned short *)AText.ToExtString ();
if (MyTraceLevel) {
PrintFunction ("call_togl_text");
PrintCGroup (MyCGroup, 1);
} }
call_togl_text (&MyCGroup, &atext);
} }
void OpenGl_GraphicDriver::Text void OpenGl_GraphicDriver::Text
@ -110,27 +72,13 @@ void OpenGl_GraphicDriver::Text
const Standard_Boolean const Standard_Boolean
) )
{ {
Graphic3d_CGroup MyCGroup = ACGroup; if (ACGroup.ptrGroup)
{
Standard_Real theHeight = AHeight;
if (theHeight < 0.)
theHeight = DefaultTextHeight();
CALL_DEF_TEXT atext; OpenGl_Text *atext = new OpenGl_Text( AText, APoint, theHeight, Graphic3d_HTA_LEFT, Graphic3d_VTA_BOTTOM );
((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelText, atext );
Standard_Real X, Y, Z;
APoint.Coord (X, Y, Z);
atext.Position.x = float (X);
atext.Position.y = float (Y);
atext.Position.z = float (Z);
atext.Height = float (AHeight);
if (atext.Height < 0)
atext.Height = DefaultTextHeight();
atext.Angle = float (M_PI / 2.);
atext.Path = int (Graphic3d_TP_RIGHT);
atext.HAlign = int (Graphic3d_HTA_LEFT);
atext.VAlign = int (Graphic3d_VTA_BOTTOM);
atext.string = (unsigned short *)AText.ToExtString ();
if (MyTraceLevel) {
PrintFunction ("call_togl_text");
PrintCGroup (MyCGroup, 1);
} }
call_togl_text (&MyCGroup, &atext);
} }

680
src/OpenGl/OpenGl_GraphicDriver_711.cxx
View File

@ -1,617 +1,103 @@
// File OpenGl_GraphicDriver_711.cxx // File: OpenGl_GraphicDriver_711.cxx
// Created Mardi 28 janvier 1997 // Created: 20 October 2011
// Author CAL // Author: Sergey ZERCHANINOV
// // Copyright: OPEN CASCADE 2011
// Modified
// 27/08/97 ; PCT : ajout coordonne texture
//-Copyright MatraDatavision 1997 #include <OpenGl_GraphicDriver.hxx>
//-Version #include <OpenGl_Group.hxx>
#include <OpenGl_TriangleStrip.hxx>
//-Design Declaration des variables specifiques aux Drivers #include <OpenGl_Mesh.hxx>
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OSD_Timer.hxx>
#include <OpenGl_tgl_funcs.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void OpenGl_GraphicDriver::TriangleMesh (const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::TriangleMesh (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertex& ListVertex, const Graphic3d_Array1OfVertex& ListVertex,
const Standard_Boolean ) const Standard_Boolean )
{ {
if (ACGroup.ptrGroup)
Graphic3d_CGroup MyCGroup = ACGroup; {
OpenGl_TriangleStrip *atstrip = new OpenGl_TriangleStrip( ListVertex );
Standard_Integer Lower = ListVertex.Lower (); ((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelTriangleMesh, atstrip );
CALL_DEF_TRIKE atrike;
atrike.NbPoints = int (ListVertex.Length ());
atrike.TypePoints = 1;
atrike.UPoints.Points = (CALL_DEF_POINT *) &ListVertex (Lower);
if (MyTraceLevel) {
PrintFunction ("call_togl_triangle");
PrintCGroup (MyCGroup, 1);
} }
call_togl_triangle (&MyCGroup, &atrike);
} }
void OpenGl_GraphicDriver::TriangleMesh (const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::TriangleMesh (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexN& ListVertex, const Graphic3d_Array1OfVertexN& ListVertex,
const Standard_Boolean ) const Standard_Boolean )
{ {
if (ACGroup.ptrGroup)
Graphic3d_CGroup MyCGroup = ACGroup; {
OpenGl_TriangleStrip *atstrip = new OpenGl_TriangleStrip( ListVertex );
Standard_Real X, Y, Z; ((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelTriangleMesh, atstrip );
Standard_Real DX, DY, DZ;
Standard_Integer i, j;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
CALL_DEF_TRIKE atrike;
CALL_DEF_POINTN *points;
i = ListVertex.Length ();
// Allocation dynamique
points = new CALL_DEF_POINTN [i];
atrike.NbPoints = int (i);
atrike.TypePoints = 2;
atrike.UPoints.PointsN = points;
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
ListVertex (i).Normal (DX, DY, DZ);
points[j].Normal.dx = float (DX);
points[j].Normal.dy = float (DY);
points[j].Normal.dz = float (DZ);
} }
if (MyTraceLevel) {
PrintFunction ("call_togl_triangle");
PrintCGroup (MyCGroup, 1);
}
call_togl_triangle (&MyCGroup, &atrike);
// Desallocation dynamique
delete [] points;
} }
void OpenGl_GraphicDriver::TriangleMesh(const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::TriangleMesh(const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexNT& ListVertex,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Real DX, DY, DZ;
Standard_Integer i, j;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
CALL_DEF_TRIKE atrike;
CALL_DEF_POINTNT *points;
i = ListVertex.Length ();
// Allocation dynamique
points = new CALL_DEF_POINTNT [i];
atrike.NbPoints = int (i);
atrike.TypePoints = 5;
atrike.UPoints.PointsNT = points;
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
ListVertex (i).Normal (DX, DY, DZ);
points[j].Normal.dx = float (DX);
points[j].Normal.dy = float (DY);
points[j].Normal.dz = float (DZ);
ListVertex (i).TextureCoordinate(DX,DY);
points[j].TextureCoord.tx = float(DX);
points[j].TextureCoord.ty = float(DY);
}
if (MyTraceLevel) {
PrintFunction ("call_togl_triangle");
PrintCGroup (MyCGroup, 1);
}
call_togl_triangle (&MyCGroup, &atrike);
// Desallocation dynamique
delete [] points;
}
void OpenGl_GraphicDriver::TriangleSet (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertex& ListVertex,
const Aspect_Array1OfEdge& ListEdge,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
OSD_Timer theTimer;
Standard_Real seconds, CPUtime;
Standard_Integer minutes, hours;
Standard_Integer i, j, k;
Standard_Integer Lower, Upper;
Standard_Integer OffSet;
CALL_DEF_LISTPOINTS alpoints;
CALL_DEF_LISTEDGES aledges;
CALL_DEF_EDGE *edges;
// Permettra une generalisation plus facile a une methode du style
// PolygonSet (ListVertex, ListEdge, Bounds).
int *integers;
CALL_DEF_LISTINTEGERS albounds;
theTimer.Reset();theTimer.Start();
i = ListVertex.Length ();
j = ListEdge.Length ();
k = int (j/3);
Lower = ListVertex.Lower ();
Upper = ListVertex.Upper ();
OffSet = Lower;
// Allocation dynamique
edges = new CALL_DEF_EDGE [j];
integers= new int [k];
#ifdef a
alpoints.NbPoints = int (i);
#else
alpoints.NbPoints = i;
#endif
alpoints.TypePoints = 1;
alpoints.UPoints.Points = (CALL_DEF_POINT *) &ListVertex (Lower);
#ifdef a
aledges.NbEdges = int (j);
#else
aledges.NbEdges = j;
#endif
aledges.Edges = edges;
#ifdef a
albounds.NbIntegers = int (k);
#else
albounds.NbIntegers = k;
#endif
albounds.Integers = integers;
Lower = ListEdge.Lower ();
Upper = ListEdge.Upper ();
// Parcours des aretes
for (j=0, i=Lower; i<=Upper; i++, j++) {
#ifdef a
edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
edges[j].Type = int (ListEdge (i).Type ());
#else
edges[j].Index1 = ListEdge (i).FirstIndex ()-OffSet;
edges[j].Index2 = ListEdge (i).LastIndex ()-OffSet;
edges[j].Type = ListEdge (i).Type ();
#endif
}
// Parcours des limites (ici toutes les limites sont egales a 3.
for (j=0; j<albounds.NbIntegers; j++) integers[j] = 3;
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_indices");
PrintCGroup (MyCGroup, 1);
}
theTimer.Stop();
theTimer.Show(seconds, minutes, hours, CPUtime);
#ifdef TRACE
cout<<"opengl_driver general stuff in : sec: "<<seconds<< "; min: " << minutes <<endl;
#endif
theTimer.Reset();theTimer.Start();
call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
theTimer.Stop();
theTimer.Show(seconds, minutes, hours, CPUtime);
#ifdef TRACE
cout<<"call_togl_polygon_indices in : sec: "<<seconds<< "; min: " << minutes <<endl;
#endif
// Desallocation dynamique
delete [] edges;
delete [] integers;
}
void OpenGl_GraphicDriver::TriangleSet (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexN& ListVertex,
const Aspect_Array1OfEdge& ListEdge,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Real DX, DY, DZ;
Standard_Integer i, j, k;
Standard_Integer Lower, Upper;
Standard_Integer OffSet;
CALL_DEF_LISTPOINTS alpoints;
CALL_DEF_POINTN *points;
CALL_DEF_LISTEDGES aledges;
CALL_DEF_EDGE *edges;
// Permettra une generalisation plus facile a une methode du style
// PolygonSet (ListVertex, ListEdge, Bounds).
int *integers;
CALL_DEF_LISTINTEGERS albounds;
i = ListVertex.Length ();
j = ListEdge.Length ();
k = int (j/3);
Lower = ListVertex.Lower ();
Upper = ListVertex.Upper ();
OffSet = Lower;
// Allocation dynamique
points = new CALL_DEF_POINTN [i];
edges = new CALL_DEF_EDGE [j];
integers= new int [k];
alpoints.NbPoints = int (i);
alpoints.TypePoints = 2;
alpoints.UPoints.PointsN= points;
aledges.NbEdges = int (j);
aledges.Edges = edges;
albounds.NbIntegers = int (k);
albounds.Integers = integers;
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
ListVertex (i).Normal (DX, DY, DZ);
points[j].Normal.dx = float (DX);
points[j].Normal.dy = float (DY);
points[j].Normal.dz = float (DZ);
}
Lower = ListEdge.Lower ();
Upper = ListEdge.Upper ();
// Parcours des aretes
for (j=0, i=Lower; i<=Upper; i++, j++) {
edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
edges[j].Type = int (ListEdge (i).Type ());
}
// Parcours des limites (ici toutes les limites sont egales a 3.
for (j=0; j<albounds.NbIntegers; j++) integers[j] = 3;
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_indices");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
// Desallocation dynamique
delete [] points;
delete [] edges;
delete [] integers;
}
void OpenGl_GraphicDriver::TriangleSet (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexC& ListVertex,
const Aspect_Array1OfEdge& ListEdge,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Real R, G, B;
Standard_Integer i, j, k;
Standard_Integer Lower, Upper;
Standard_Integer OffSet;
CALL_DEF_LISTPOINTS alpoints;
CALL_DEF_POINTC *points;
CALL_DEF_LISTEDGES aledges;
CALL_DEF_EDGE *edges;
// Permettra une generalisation plus facile a une methode du style
// PolygonSet (ListVertex, ListEdge, Bounds).
int *integers;
CALL_DEF_LISTINTEGERS albounds;
i = ListVertex.Length ();
j = ListEdge.Length ();
k = int (j/3);
Lower = ListVertex.Lower ();
Upper = ListVertex.Upper ();
OffSet = Lower;
// Allocation dynamique
points = new CALL_DEF_POINTC [i];
edges = new CALL_DEF_EDGE [j];
integers= new int [k];
alpoints.NbPoints = int (i);
alpoints.TypePoints = 3;
alpoints.UPoints.PointsC= points;
aledges.NbEdges = int (j);
aledges.Edges = edges;
albounds.NbIntegers = int (k);
albounds.Integers = integers;
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
(ListVertex (i).Color ()).Values (R, G, B, Quantity_TOC_RGB);
points[j].Color.r = float (R);
points[j].Color.g = float (G);
points[j].Color.b = float (B);
}
Lower = ListEdge.Lower ();
Upper = ListEdge.Upper ();
// Parcours des aretes
for (j=0, i=Lower; i<=Upper; i++, j++) {
edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
edges[j].Type = int (ListEdge (i).Type ());
}
// Parcours des limites (ici toutes les limites sont egales a 3.
for (j=0; j<albounds.NbIntegers; j++) integers[j] = 3;
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_indices");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
// Desallocation dynamique
delete [] points;
delete [] edges;
delete [] integers;
}
void OpenGl_GraphicDriver::TriangleSet (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexNC& ListVertex,
const Aspect_Array1OfEdge& ListEdge,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Real X, Y, Z;
Standard_Real R, G, B;
Standard_Real DX, DY, DZ;
Standard_Integer i, j, k;
Standard_Integer Lower, Upper;
Standard_Integer OffSet;
CALL_DEF_LISTPOINTS alpoints;
CALL_DEF_POINTNC *points;
CALL_DEF_LISTEDGES aledges;
CALL_DEF_EDGE *edges;
// Permettra une generalisation plus facile a une methode du style
// PolygonSet (ListVertex, ListEdge, Bounds).
int *integers;
CALL_DEF_LISTINTEGERS albounds;
i = ListVertex.Length ();
j = ListEdge.Length ();
k = int (j/3);
Lower = ListVertex.Lower ();
Upper = ListVertex.Upper ();
OffSet = Lower;
// Allocation dynamique
points = new CALL_DEF_POINTNC [i];
edges = new CALL_DEF_EDGE [j];
integers= new int [k];
alpoints.NbPoints = int (i);
alpoints.TypePoints = 4;
alpoints.UPoints.PointsNC= points;
aledges.NbEdges = int (j);
aledges.Edges = edges;
albounds.NbIntegers = int (k);
albounds.Integers = integers;
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) {
ListVertex (i).Coord (X, Y, Z);
points[j].Point.x = float (X);
points[j].Point.y = float (Y);
points[j].Point.z = float (Z);
ListVertex (i).Normal (DX, DY, DZ);
points[j].Normal.dx = float (DX);
points[j].Normal.dy = float (DY);
points[j].Normal.dz = float (DZ);
(ListVertex (i).Color ()).Values (R, G, B, Quantity_TOC_RGB);
points[j].Color.r = float (R);
points[j].Color.g = float (G);
points[j].Color.b = float (B);
}
Lower = ListEdge.Lower ();
Upper = ListEdge.Upper ();
// Parcours des aretes
for (j=0, i=Lower; i<=Upper; i++, j++) {
edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
edges[j].Type = int (ListEdge (i).Type ());
}
// Parcours des limites (ici toutes les limites sont egales a 3.
for (j=0; j<albounds.NbIntegers; j++) integers[j] = 3;
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_indices");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
// Desallocation dynamique
delete [] points;
delete [] edges;
delete [] integers;
}
void OpenGl_GraphicDriver::TriangleSet(const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexNT& ListVertex, const Graphic3d_Array1OfVertexNT& ListVertex,
const Standard_Boolean )
{
if (ACGroup.ptrGroup)
{
OpenGl_TriangleStrip *atstrip = new OpenGl_TriangleStrip( ListVertex );
((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelTriangleMesh, atstrip );
}
}
void OpenGl_GraphicDriver::TriangleSet (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertex& ListVertex,
const Aspect_Array1OfEdge& ListEdge, const Aspect_Array1OfEdge& ListEdge,
const Standard_Boolean ) const Standard_Boolean )
{ {
if (ACGroup.ptrGroup)
Graphic3d_CGroup MyCGroup = ACGroup; {
Standard_Real X, Y, Z; OpenGl_Mesh *amesh = new OpenGl_Mesh (ListVertex, ListEdge);
Standard_Real DX, DY, DZ; ((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelPolygonIndices, amesh );
}
Standard_Integer i, j, k; }
Standard_Integer Lower, Upper;
Standard_Integer OffSet; void OpenGl_GraphicDriver::TriangleSet (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertexN& ListVertex,
CALL_DEF_LISTPOINTS alpoints; const Aspect_Array1OfEdge& ListEdge,
CALL_DEF_POINTNT *points; const Standard_Boolean )
CALL_DEF_LISTEDGES aledges; {
CALL_DEF_EDGE *edges; if (ACGroup.ptrGroup)
{
// Permettra une generalisation plus facile a une methode du style OpenGl_Mesh *amesh = new OpenGl_Mesh (ListVertex, ListEdge);
// PolygonSet (ListVertex, ListEdge, Bounds). ((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelPolygonIndices, amesh );
int *integers; }
CALL_DEF_LISTINTEGERS albounds; }
i = ListVertex.Length (); void OpenGl_GraphicDriver::TriangleSet (const Graphic3d_CGroup& ACGroup,
j = ListEdge.Length (); const Graphic3d_Array1OfVertexC& ListVertex,
k = int (j/3); const Aspect_Array1OfEdge& ListEdge,
const Standard_Boolean )
Lower = ListVertex.Lower (); {
Upper = ListVertex.Upper (); if (ACGroup.ptrGroup)
OffSet = Lower; {
OpenGl_Mesh *amesh = new OpenGl_Mesh (ListVertex, ListEdge);
// Allocation dynamique ((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelPolygonIndices, amesh );
points = new CALL_DEF_POINTNT [i]; }
edges = new CALL_DEF_EDGE [j]; }
integers= new int [k];
void OpenGl_GraphicDriver::TriangleSet (const Graphic3d_CGroup& ACGroup,
alpoints.NbPoints = int (i); const Graphic3d_Array1OfVertexNC& ListVertex,
alpoints.TypePoints = 5; const Aspect_Array1OfEdge& ListEdge,
alpoints.UPoints.PointsNT= points; const Standard_Boolean )
{
aledges.NbEdges = int (j); if (ACGroup.ptrGroup)
aledges.Edges = edges; {
OpenGl_Mesh *amesh = new OpenGl_Mesh (ListVertex, ListEdge);
albounds.NbIntegers = int (k); ((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelPolygonIndices, amesh );
albounds.Integers = integers; }
}
// Parcours des sommets
for (j=0, i=Lower; i<=Upper; i++, j++) { void OpenGl_GraphicDriver::TriangleSet(const Graphic3d_CGroup& ACGroup,
ListVertex (i).Coord (X, Y, Z); const Graphic3d_Array1OfVertexNT& ListVertex,
points[j].Point.x = float (X); const Aspect_Array1OfEdge& ListEdge,
points[j].Point.y = float (Y); const Standard_Boolean )
points[j].Point.z = float (Z); {
ListVertex (i).Normal (DX, DY, DZ); if (ACGroup.ptrGroup)
points[j].Normal.dx = float (DX); {
points[j].Normal.dy = float (DY); OpenGl_Mesh *amesh = new OpenGl_Mesh (ListVertex, ListEdge);
points[j].Normal.dz = float (DZ); ((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelPolygonIndices, amesh );
ListVertex (i).TextureCoordinate(DX,DY);
points[j].TextureCoord.tx = float(DX);
points[j].TextureCoord.ty = float(DY);
} }
Lower = ListEdge.Lower ();
Upper = ListEdge.Upper ();
// Parcours des aretes
for (j=0, i=Lower; i<=Upper; i++, j++) {
edges[j].Index1 = int (ListEdge (i).FirstIndex ()-OffSet);
edges[j].Index2 = int (ListEdge (i).LastIndex ()-OffSet);
edges[j].Type = int (ListEdge (i).Type ());
}
// Parcours des limites (ici toutes les limites sont egales a 3.
for (j=0; j<albounds.NbIntegers; j++) integers[j] = 3;
if (MyTraceLevel) {
PrintFunction ("call_togl_polygon_indices");
PrintCGroup (MyCGroup, 1);
}
call_togl_polygon_indices (&MyCGroup, &alpoints, &aledges, &albounds);
// Desallocation dynamique
delete [] points;
delete [] edges;
delete [] integers;
} }

98
src/OpenGl/OpenGl_GraphicDriver_712.cxx
View File

@ -1,98 +0,0 @@
// File OpenGl_GraphicDriver_712.cxx
// Created Mardi 28 janvier 1997
// Author CAL
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OpenGl_tgl_funcs.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
void OpenGl_GraphicDriver::Bezier (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertex& ListVertex,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Integer Lower = ListVertex.Lower ();
CALL_DEF_LISTPOINTS alpoints;
alpoints.NbPoints = int (ListVertex.Length ());
alpoints.TypePoints = 1;
alpoints.UPoints.Points = (CALL_DEF_POINT *) &ListVertex (Lower);
if (MyTraceLevel) {
PrintFunction ("call_togl_bezier");
PrintCGroup (MyCGroup, 1);
}
call_togl_bezier (&MyCGroup, &alpoints);
}
void OpenGl_GraphicDriver::Bezier (const Graphic3d_CGroup& ACGroup,
const Graphic3d_Array1OfVertex& ListVertex,
const TColStd_Array1OfReal& ListWeight,
const Standard_Boolean )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Standard_Integer i, j;
Standard_Integer Lower = ListVertex.Lower ();
Standard_Integer Upper = ListVertex.Upper ();
CALL_DEF_LISTREALS alweights;
float *weights;
CALL_DEF_LISTPOINTS alpoints;
j = ListWeight.Length ();
alpoints.NbPoints = int (ListVertex.Length ());
alpoints.TypePoints = 1;
alpoints.UPoints.Points = (CALL_DEF_POINT *) &ListVertex (Lower);
weights = new float [j];
alweights.NbReals = j;
alweights.Reals = weights;
Lower = ListWeight.Lower ();
Upper = ListWeight.Upper ();
// Parcours des poids
for (j=0, i=Lower; i<=Upper; i++, j++)
weights[j] = float (ListWeight (i));
if (MyTraceLevel) {
PrintFunction ("call_togl_bezier_weight");
PrintCGroup (MyCGroup, 1);
}
call_togl_bezier_weight (&MyCGroup, &alpoints, &alweights);
// Desallocation dynamique
delete [] weights;
}

134
src/OpenGl/OpenGl_GraphicDriver_713.cxx
View File

@ -1,80 +1,67 @@
// File OpenGl_GraphicDriver_713.cxx // File: OpenGl_GraphicDriver_713.cxx
// Created 22-10-01 // Created: 20 October 2011
// Author SAV // Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
// SAV 09/07/02 merged with OpenGl_GraphicDriver_713.cxx created 16/06/2000 by ATS,SPK,GG : G005 #include <OpenGl_GraphicDriver.hxx>
// implementation of PARRAY method
#include <OpenGl_GraphicDriver.jxx> #include <OpenGl_Callback.hxx>
#include <OpenGl_Group.hxx>
#include <OpenGl_PrimitiveArray.hxx>
#include <Aspect_DriverDefinitionError.hxx> #include <OpenGl_CView.hxx>
void OpenGl_GraphicDriver::SetDepthTestEnabled( const Graphic3d_CView& ACView, const Standard_Boolean isEnabled ) const
#include <OpenGl_tgl_funcs.hxx>
#include <OpenGl_telem_util.hxx>
#define BUC61044 /* 25/10/01 SAV ; added functionality to control gl depth testing
from higher API */
#define BUC61045 /* 25/10/01 SAV ; added functionality to control gl lighting
from higher API */
void OpenGl_GraphicDriver::SetDepthTestEnabled( const Graphic3d_CView& view,
const Standard_Boolean isEnabled ) const
{ {
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
#ifdef BUC61044 if (aCView)
Graphic3d_CView MyCView = view; aCView->WS->UseDepthTest() = isEnabled;
call_togl_depthtest( &MyCView, isEnabled );
#endif
} }
Standard_Boolean OpenGl_GraphicDriver Standard_Boolean OpenGl_GraphicDriver::IsDepthTestEnabled( const Graphic3d_CView& ACView ) const
::IsDepthTestEnabled( const Graphic3d_CView& view ) const
{ {
#ifdef BUC61044 const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
Graphic3d_CView MyCView = view; if (aCView)
return call_togl_isdepthtest (&MyCView) != 0; return aCView->WS->UseDepthTest();
#endif return Standard_False;
} }
void OpenGl_GraphicDriver::ReadDepths( const Graphic3d_CView& view, void OpenGl_GraphicDriver::ReadDepths( const Graphic3d_CView& ACView,
const Standard_Integer x, const Standard_Integer x,
const Standard_Integer y, const Standard_Integer y,
const Standard_Integer width, const Standard_Integer width,
const Standard_Integer height, const Standard_Integer height,
const Standard_Address buffer ) const const Standard_Address buffer ) const
{ {
TelReadDepths (view.WsId, x, y, width, height, (float*) buffer); const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
aCView->WS->ReadDepths(x, y, width, height, (float*) buffer);
} }
void OpenGl_GraphicDriver::SetGLLightEnabled( const Graphic3d_CView& view, void OpenGl_GraphicDriver::SetGLLightEnabled( const Graphic3d_CView& ACView, const Standard_Boolean isEnabled ) const
const Standard_Boolean isEnabled ) const
{ {
#ifdef BUC61045 const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
Graphic3d_CView MyCView = view; if (aCView)
call_togl_gllight( &MyCView, isEnabled ); aCView->WS->UseGLLight() = isEnabled;
#endif
} }
Standard_Boolean OpenGl_GraphicDriver Standard_Boolean OpenGl_GraphicDriver::IsGLLightEnabled( const Graphic3d_CView& ACView ) const
::IsGLLightEnabled( const Graphic3d_CView& view ) const
{ {
#ifdef BUC61045 const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
Graphic3d_CView MyCView = view; if (aCView)
return call_togl_isgllight (&MyCView) != 0; return aCView->WS->UseGLLight();
#endif return Standard_False;
} }
void OpenGl_GraphicDriver :: PrimitiveArray( const Graphic3d_CGroup& ACGroup, void OpenGl_GraphicDriver::PrimitiveArray( const Graphic3d_CGroup& ACGroup,
const Graphic3d_PrimitiveArray& parray, const Graphic3d_PrimitiveArray& parray,
const Standard_Boolean EvalMinMax ) const Standard_Boolean EvalMinMax )
{ {
Graphic3d_CGroup MyCGroup = ACGroup; if ( ACGroup.ptrGroup && parray )
{
if( parray ) call_togl_parray (&MyCGroup,parray); OpenGl_PrimitiveArray *aparray = new OpenGl_PrimitiveArray( (CALL_DEF_PARRAY *) parray );
((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelParray, aparray );
}
} }
//======================================================================= //=======================================================================
@ -85,25 +72,30 @@ void OpenGl_GraphicDriver :: PrimitiveArray( const Graphic3d_CGroup& ACGroup,
// Graphic3d_Group only. // Graphic3d_Group only.
//======================================================================= //=======================================================================
void OpenGl_GraphicDriver::RemovePrimitiveArray (const Graphic3d_CGroup& theCGroup, void OpenGl_GraphicDriver::RemovePrimitiveArray (const Graphic3d_CGroup& ACGroup,
const Graphic3d_PrimitiveArray& thePArray) const Graphic3d_PrimitiveArray& thePArray)
{ {
Graphic3d_CGroup MyCGroup = theCGroup; if ( ACGroup.ptrGroup && thePArray )
if (thePArray != NULL) call_togl_parray_remove (&MyCGroup, thePArray); {
((OpenGl_Group *)ACGroup.ptrGroup)->RemovePrimitiveArray( (CALL_DEF_PARRAY *) thePArray );
}
} }
void OpenGl_GraphicDriver :: UserDraw ( const Graphic3d_CGroup& ACGroup, static OpenGl_UserDrawCallback MyUserDrawCallback = NULL;
const Graphic3d_CUserDraw& AUserDraw )
{
Graphic3d_CGroup MyCGroup = ACGroup;
Graphic3d_CUserDraw MyUserDraw = AUserDraw;
call_togl_userdraw (&MyCGroup,&MyUserDraw); OpenGl_UserDrawCallback& UserDrawCallback ()
{
return MyUserDrawCallback;
} }
extern int VBOenabled; void OpenGl_GraphicDriver::UserDraw ( const Graphic3d_CGroup& ACGroup,
const Graphic3d_CUserDraw& AUserDraw )
void OpenGl_GraphicDriver :: EnableVBO( const Standard_Boolean flag )
{ {
VBOenabled = flag; if (ACGroup.ptrGroup && MyUserDrawCallback)
{
OpenGl_Element *auserdraw = (*MyUserDrawCallback)(&AUserDraw);
if (auserdraw != 0)
((OpenGl_Group *)ACGroup.ptrGroup)->AddElement( TelUserdraw, auserdraw );
}
} }

254
src/OpenGl/OpenGl_GraphicDriver_8.cxx
View File

@ -1,242 +1,132 @@
// File OpenGl_GraphicDriver_8.cxx // File: OpenGl_GraphicDriver_8.cxx
// Created Mardi 28 janvier 1997 // Created: 20 October 2011
// Author CAL // Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
//-Copyright MatraDatavision 1997 #include <OpenGl_GraphicDriver.hxx>
//-Version #include <OpenGl_CView.hxx>
#include <OpenGl_Structure.hxx>
//-Design Declaration des variables specifiques aux Drivers static Handle(OpenGl_Workspace) myImmediateWS;
//-Warning Un driver encapsule les Pex et OpenGl drivers /*----------------------------------------------------------------------*/
//-References Standard_Boolean OpenGl_GraphicDriver::BeginAddMode (const Graphic3d_CView& ACView)
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OpenGl_tgl_funcs.hxx>
//-Aliases
//-Global data definitions
//-Methods, in order
Standard_Boolean OpenGl_GraphicDriver::BeginAddMode (const Graphic3d_CView& ACView)
{ {
if (ACView.ViewId == -1)
return Standard_False;
Graphic3d_CView MyCView = ACView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
Standard_Boolean Result; if (aCView && aCView->WS->BeginAddMode())
{
if (MyTraceLevel) { myImmediateWS = aCView->WS;
PrintFunction ("call_togl_begin_ajout_mode"); return Standard_True;
PrintCView (MyCView, 1);
} }
Result = call_togl_begin_ajout_mode (&MyCView);
if (MyTraceLevel) {
PrintIResult ("call_togl_begin_ajout_mode", Result);
}
return Result;
return Standard_False;
} }
void OpenGl_GraphicDriver::EndAddMode (void) void OpenGl_GraphicDriver::EndAddMode (void)
{ {
if (!myImmediateWS.IsNull())
if (MyTraceLevel) { {
PrintFunction ("call_togl_end_ajout_mode"); myImmediateWS->EndAddMode();
myImmediateWS.Nullify();
} }
call_togl_end_ajout_mode ();
} }
Standard_Boolean OpenGl_GraphicDriver::BeginImmediatMode (const Graphic3d_CView& ACView, const Aspect_CLayer2d& ACUnderLayer, const Aspect_CLayer2d& ACOverLayer, const Standard_Boolean DoubleBuffer, const Standard_Boolean RetainMode) Standard_Boolean OpenGl_GraphicDriver::BeginImmediatMode (const Graphic3d_CView& ACView, const Aspect_CLayer2d& ACUnderLayer, const Aspect_CLayer2d& ACOverLayer, const Standard_Boolean DoubleBuffer, const Standard_Boolean RetainMode)
{ {
if (ACView.ViewId == -1)
return Standard_False;
Graphic3d_CView MyCView = ACView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
Aspect_CLayer2d MyCUnderLayer = ACUnderLayer; if (aCView && aCView->WS->BeginImmediatMode(ACView, DoubleBuffer, RetainMode))
Aspect_CLayer2d MyCOverLayer = ACOverLayer; {
Standard_Boolean Result; myImmediateWS = aCView->WS;
return Standard_True;
if (MyTraceLevel) {
PrintFunction ("call_togl_begin_immediat_mode");
PrintCView (MyCView, 1);
PrintBoolean ("DoubleBuffer", DoubleBuffer);
PrintBoolean ("RetainMode", RetainMode);
} }
Result = call_togl_begin_immediat_mode
(&MyCView, &MyCUnderLayer, &MyCOverLayer,
(DoubleBuffer ? 1 : 0), (RetainMode ? 1 : 0));
if (MyTraceLevel) {
PrintIResult ("call_togl_begin_immediat_mode", Result);
}
return Result;
return Standard_False;
} }
void OpenGl_GraphicDriver::BeginPolyline () void OpenGl_GraphicDriver::BeginPolyline ()
{ {
if (!myImmediateWS.IsNull())
if (MyTraceLevel) { myImmediateWS->BeginPolyline();
PrintFunction ("call_togl_begin_polyline");
}
call_togl_begin_polyline ();
} }
void OpenGl_GraphicDriver::ClearImmediatMode (const Graphic3d_CView& ACView, void OpenGl_GraphicDriver::ClearImmediatMode (const Graphic3d_CView& ACView, const Standard_Boolean aFlush)
const Standard_Boolean aFlush)
{ {
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
Graphic3d_CView MyCView = ACView; if (aCView)
aCView->WS->ClearImmediatMode(ACView,aFlush);
if (MyTraceLevel) {
PrintFunction ("call_togl_clear_immediat_mode");
PrintCView (MyCView, 1);
}
call_togl_clear_immediat_mode (&MyCView, aFlush);
} }
void OpenGl_GraphicDriver::Draw (const Standard_ShortReal X, const Standard_ShortReal Y, const Standard_ShortReal Z) void OpenGl_GraphicDriver::Draw (const Standard_ShortReal X, const Standard_ShortReal Y, const Standard_ShortReal Z)
{ {
if (!myImmediateWS.IsNull())
myImmediateWS->Draw(X,Y,Z);
if (MyTraceLevel) {
PrintFunction ("call_togl_draw");
PrintShortReal ("X", X);
PrintShortReal ("Y", Y);
PrintShortReal ("Z", Z);
}
call_togl_draw (X, Y, Z);
} }
void OpenGl_GraphicDriver::DrawStructure (const Graphic3d_CStructure& ACStructure) { void OpenGl_GraphicDriver::DrawStructure (const Graphic3d_CStructure& ACStructure)
{
Graphic3d_CStructure MyCStructure = ACStructure; OpenGl_Structure *astructure = (OpenGl_Structure *)ACStructure.ptrStructure;
if (!astructure)
if (MyTraceLevel) { return;
PrintFunction ("call_togl_draw_structure");
PrintCStructure (MyCStructure, 1);
}
call_togl_draw_structure (ACStructure.Id);
if (!myImmediateWS.IsNull())
myImmediateWS->DrawStructure(astructure);
} }
void OpenGl_GraphicDriver::EndImmediatMode (const Standard_Integer Synchronize) void OpenGl_GraphicDriver::EndImmediatMode (const Standard_Integer Synchronize)
{ {
if (!myImmediateWS.IsNull())
if (MyTraceLevel) { {
PrintFunction ("call_togl_end_immediat_mode"); myImmediateWS->EndImmediatMode();
PrintInteger ("Synchronize", Synchronize); myImmediateWS.Nullify();
} }
call_togl_end_immediat_mode (int (Synchronize));
} }
void OpenGl_GraphicDriver::EndPolyline () void OpenGl_GraphicDriver::EndPolyline ()
{ {
if (!myImmediateWS.IsNull())
if (MyTraceLevel) { myImmediateWS->EndPolyline();
PrintFunction ("call_togl_end_polyline");
}
call_togl_end_polyline ();
} }
void OpenGl_GraphicDriver::Move (const Standard_ShortReal X, const Standard_ShortReal Y, const Standard_ShortReal Z) void OpenGl_GraphicDriver::Move (const Standard_ShortReal X, const Standard_ShortReal Y, const Standard_ShortReal Z)
{ {
if (!myImmediateWS.IsNull())
if (MyTraceLevel) { myImmediateWS->Move(X,Y,Z);
PrintFunction ("call_togl_move");
PrintShortReal ("X", X);
PrintShortReal ("Y", Y);
PrintShortReal ("Z", Z);
}
call_togl_move (X, Y, Z);
} }
void OpenGl_GraphicDriver::SetLineColor (const Standard_ShortReal R, const Standard_ShortReal G, const Standard_ShortReal B) void OpenGl_GraphicDriver::SetLineColor (const Standard_ShortReal R, const Standard_ShortReal G, const Standard_ShortReal B)
{ {
if (!myImmediateWS.IsNull())
if (MyTraceLevel) { myImmediateWS->SetLineColor(R,G,B);
PrintFunction ("call_togl_set_linecolor");
PrintShortReal ("R", R);
PrintShortReal ("G", G);
PrintShortReal ("B", B);
}
call_togl_set_linecolor (R, G, B);
} }
void OpenGl_GraphicDriver::SetLineType (const Standard_Integer Type) void OpenGl_GraphicDriver::SetLineType (const Standard_Integer Type)
{ {
if (!myImmediateWS.IsNull())
if (MyTraceLevel) { myImmediateWS->SetLineType(Type);
PrintFunction ("call_togl_set_linetype");
PrintInteger ("Type", Type);
}
call_togl_set_linetype (long (Type));
} }
void OpenGl_GraphicDriver::SetLineWidth (const Standard_ShortReal Width) void OpenGl_GraphicDriver::SetLineWidth (const Standard_ShortReal Width)
{ {
if (!myImmediateWS.IsNull())
if (MyTraceLevel) { myImmediateWS->SetLineWidth(Width);
PrintFunction ("call_togl_set_linewidth");
PrintShortReal ("Width", Width);
}
call_togl_set_linewidth (float (Width));
} }
void OpenGl_GraphicDriver::SetMinMax (const Standard_ShortReal X1, const Standard_ShortReal Y1, const Standard_ShortReal Z1, const Standard_ShortReal X2, const Standard_ShortReal Y2, const Standard_ShortReal Z2) void OpenGl_GraphicDriver::SetMinMax (const Standard_ShortReal X1, const Standard_ShortReal Y1, const Standard_ShortReal Z1, const Standard_ShortReal X2, const Standard_ShortReal Y2, const Standard_ShortReal Z2)
{ {
if (!myImmediateWS.IsNull())
if (MyTraceLevel) { myImmediateWS->SetMinMax(X1,Y1,Z1,X2,Y2,Z2);
PrintFunction ("call_togl_set_minmax");
PrintShortReal ("X1", X1);
PrintShortReal ("Y1", Y1);
PrintShortReal ("Z1", Z1);
PrintShortReal ("X2", X2);
PrintShortReal ("Y2", Y2);
PrintShortReal ("Z2", Z2);
}
call_togl_set_minmax (X1, Y1, Z1, X2, Y2, Z2);
} }
void OpenGl_GraphicDriver::Transform (const TColStd_Array2OfReal& AMatrix, const Graphic3d_TypeOfComposition AType) void OpenGl_GraphicDriver::Transform (const TColStd_Array2OfReal& AMatrix, const Graphic3d_TypeOfComposition AType)
{ {
if (!myImmediateWS.IsNull())
float theMatrix[4][4]; myImmediateWS->Transform(AMatrix,AType);
Standard_Integer i, j;
Standard_Integer lr, lc;
lr = AMatrix.LowerRow ();
lc = AMatrix.LowerCol ();
for (i=0; i<=3; i++)
for (j=0; j<=3; j++)
theMatrix[i][j] = float (AMatrix (i+lr, j+lc));
if (MyTraceLevel) {
PrintFunction ("call_togl_transform");
PrintMatrix ("AMatrix", AMatrix);
}
call_togl_transform (theMatrix, (AType == Graphic3d_TOC_REPLACE) ? 1 : 0);
} }

319
src/OpenGl/OpenGl_GraphicDriver_9.cxx
View File

@ -1,53 +1,137 @@
// File OpenGl_GraphicDriver_9.cxx // File: OpenGl_GraphicDriver_9.cxx
// Created 1/08/97 // Created: 20 October 2011
// Author PCT // Author: Sergey ZERCHANINOV
// Modified // Copyright: OPEN CASCADE 2011
// 16-09-98 ; BGN : Points d'entree du Triedre (S3819, Phase 1)
// 22-09-98 ; BGN : S3989 (anciennement S3819)
// TypeOfTriedron* from Aspect (pas Graphic3d)
//-Copyright MatraDatavision 1997
//-Version
//-Design Declaration des variables specifiques aux Drivers
//-Warning Un driver encapsule les Pex et OpenGl drivers
//-References
//-Language C++ 2.0
//-Declarations
// for the class
#define IMP131100 //GG_Enable to creates more than one texture
// with the same name.
#define OCC1188 //SAV added methods to set background image
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <Quantity_NameOfColor.hxx>
#include <AlienImage.hxx>
#include <Standard_Integer.hxx>
#include <OpenGl_GraphicDriver.hxx>
#include <OpenGl_CView.hxx>
#include <OpenGl_Trihedron.hxx>
#include <OpenGl_GraduatedTrihedron.hxx>
#include <OpenGl_TextureBox.hxx>
#include <OpenGl_tgl_funcs.hxx> #include <OpenGl_tgl_funcs.hxx>
#include <stdlib.h> #include <Quantity_NameOfColor.hxx>
#include <stdio.h> #include <TColStd_HArray1OfReal.hxx>
#include <AlienImage_AlienImage.hxx>
#include <Image_Image.hxx> #include <Image_Image.hxx>
void OpenGl_GraphicDriver::Environment(const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->SetTextureEnv(ACView.Context.TexEnvId);
aCView->View->SetSurfaceDetail((Visual3d_TypeOfSurfaceDetail)ACView.Context.SurfaceDetail);
}
}
//-Aliases //
// Triedron methods : the Triedron is a non-zoomable object.
//
//-Global data definitions void OpenGl_GraphicDriver::ZBufferTriedronSetup (
const Quantity_NameOfColor XColor,
const Quantity_NameOfColor YColor,
const Quantity_NameOfColor ZColor,
const Standard_Real SizeRatio,
const Standard_Real AxisDiametr,
const Standard_Integer NbFacettes)
{
OpenGl_Trihedron::Setup(XColor,YColor,ZColor,SizeRatio,AxisDiametr,NbFacettes);
}
//-Methods, in order void OpenGl_GraphicDriver::TriedronDisplay (
const Graphic3d_CView& ACView,
const Aspect_TypeOfTriedronPosition APosition,
const Quantity_NameOfColor AColor,
const Standard_Real AScale,
const Standard_Boolean AsWireframe )
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->TriedronDisplay(APosition, AColor, AScale, AsWireframe);
aCView->WS->Invalidate();
}
}
void OpenGl_GraphicDriver::TriedronErase (const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->TriedronErase();
aCView->WS->Invalidate();
}
}
void OpenGl_GraphicDriver::TriedronEcho (const Graphic3d_CView& ACView,const Aspect_TypeOfTriedronEcho AType )
{
// Do nothing
}
void OpenGl_GraphicDriver::BackgroundImage( const Standard_CString FileName,
const Graphic3d_CView& ACView,
const Aspect_FillMethod FillStyle )
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->CreateBackgroundTexture( FileName, FillStyle );
aCView->WS->Invalidate();
}
}
void OpenGl_GraphicDriver::SetBgImageStyle( const Graphic3d_CView& ACView,
const Aspect_FillMethod FillStyle )
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->SetBackgroundTextureStyle( FillStyle );
aCView->WS->Invalidate();
}
}
void OpenGl_GraphicDriver::SetBgGradientStyle(const Graphic3d_CView& ACView,const Aspect_GradientFillMethod FillType)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->SetBackgroundGradientType(FillType);
aCView->WS->Invalidate();
}
}
void OpenGl_GraphicDriver::GraduatedTrihedronDisplay(const Graphic3d_CView& ACView, const Graphic3d_CGraduatedTrihedron& cubic)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->GraduatedTrihedronDisplay(cubic);
aCView->WS->Invalidate();
}
}
void OpenGl_GraphicDriver::GraduatedTrihedronErase(const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->GraduatedTrihedronErase();
aCView->WS->Invalidate();
}
}
void OpenGl_GraphicDriver::GraduatedTrihedronMinMaxValues(const Standard_ShortReal xmin,
const Standard_ShortReal ymin,
const Standard_ShortReal zmin,
const Standard_ShortReal xmax,
const Standard_ShortReal ymax,
const Standard_ShortReal zmax)
{
OpenGl_GraduatedTrihedron::SetMinMax(xmin, ymin, zmin, xmax, ymax, zmax);
}
// Helper function, returns the nearest power of two greater than the argument value // Helper function, returns the nearest power of two greater than the argument value
inline Standard_Integer GetNearestPow2(Standard_Integer theValue) inline Standard_Integer GetNearestPow2(Standard_Integer theValue)
@ -59,13 +143,13 @@ inline Standard_Integer GetNearestPow2(Standard_Integer theValue)
return aRes; return aRes;
} }
Standard_Integer OpenGl_GraphicDriver::CreateTexture(const Graphic3d_TypeOfTexture Type,const Handle_AlienImage_AlienImage &Image,const Standard_CString FileName,const Handle(TColStd_HArray1OfReal)& TexUpperBounds) const Standard_Integer OpenGl_GraphicDriver::CreateTexture (const Graphic3d_TypeOfTexture Type,
const Handle_AlienImage_AlienImage &Image,
const Standard_CString FileName,
const Handle(TColStd_HArray1OfReal)& TexUpperBounds) const
{ {
// transmutation de l'image en un bon tableau RGBA pour la toolkit des textures
// lamentable d'un point de vue vitesse...
Handle(Image_Image) MyPic = Image->ToImage(); Handle(Image_Image) MyPic = Image->ToImage();
//TODO: The temporary fix in order to make AIS_TexturedShape work. To be improved in next release.
Standard_Integer aGlWidth = (Type == Graphic3d_TOT_2D_MIPMAP) ? MyPic->Width() : GetNearestPow2(MyPic->Width()); Standard_Integer aGlWidth = (Type == Graphic3d_TOT_2D_MIPMAP) ? MyPic->Width() : GetNearestPow2(MyPic->Width());
Standard_Integer aGlHeight = (Type == Graphic3d_TOT_2D_MIPMAP) ? MyPic->Height() : GetNearestPow2(MyPic->Height()); Standard_Integer aGlHeight = (Type == Graphic3d_TOT_2D_MIPMAP) ? MyPic->Height() : GetNearestPow2(MyPic->Height());
@ -81,15 +165,10 @@ Standard_Integer OpenGl_GraphicDriver::CreateTexture(const Graphic3d_TypeOfTextu
if (MyImageData == NULL) if (MyImageData == NULL)
return -1; return -1;
#ifdef IMP131100
static Standard_Integer textureRank=0; static Standard_Integer textureRank=0;
char textureName[16]; char textureName[16];
Standard_PCharacter fileName = textureName; Standard_PCharacter fileName = textureName;
sprintf(fileName,"Tex%d",++textureRank); sprintf(fileName,"Tex%d",++textureRank);
#else
Standard_CString fileName = FileName
#endif
for (j = MyPic->Height() - 1; j >= 0; j--) for (j = MyPic->Height() - 1; j >= 0; j--)
for (i = 0; i < aGlWidth; i++){ for (i = 0; i < aGlWidth; i++){
@ -150,141 +229,3 @@ void OpenGl_GraphicDriver::ModifyTexture(const Standard_Integer TexId,const Grap
{ {
call_togl_modify_texture(TexId, (CALL_DEF_INIT_TEXTURE *)&AValue); call_togl_modify_texture(TexId, (CALL_DEF_INIT_TEXTURE *)&AValue);
} }
void OpenGl_GraphicDriver::Environment(const Graphic3d_CView& ACView)
{
call_togl_environment((CALL_DEF_VIEW *)&ACView);
}
//
// Triedron methods : the Triedron is a non-zoomable object.
//
void OpenGl_GraphicDriver::ZBufferTriedronSetup (
const Quantity_NameOfColor XColor,
const Quantity_NameOfColor YColor,
const Quantity_NameOfColor ZColor,
const Standard_Real SizeRatio,
const Standard_Real AxisDiametr,
const Standard_Integer NbFacettes)
{
float Xrgb[3];
float Yrgb[3];
float Zrgb[3];
Standard_Real R,G,B;
Quantity_Color(XColor).Values(R, G, B, Quantity_TOC_RGB);
Xrgb[0] = float (R);
Xrgb[1] = float (G);
Xrgb[2] = float (B);
Quantity_Color(YColor).Values(R, G, B, Quantity_TOC_RGB);
Yrgb[0] = float (R);
Yrgb[1] = float (G);
Yrgb[2] = float (B);
Quantity_Color(ZColor).Values(R, G, B, Quantity_TOC_RGB);
Zrgb[0] = float (R);
Zrgb[1] = float (G);
Zrgb[2] = float (B);
call_togl_ztriedron_setup(Xrgb, Yrgb, Zrgb,
(Standard_ShortReal)(SizeRatio), (Standard_ShortReal)(AxisDiametr), NbFacettes);
}
void OpenGl_GraphicDriver::TriedronDisplay (
const Graphic3d_CView& ACView,
const Aspect_TypeOfTriedronPosition APosition,
const Quantity_NameOfColor AColor,
const Standard_Real AScale,
const Standard_Boolean AsWireframe )
{
Standard_Real R,G,B;
float r,g,b;
Quantity_Color Color(AColor);
Color.Values(R,G,B,Quantity_TOC_RGB);
r = float (R);
g = float (G);
b = float (B);
call_togl_triedron_display((CALL_DEF_VIEW *)&ACView,(int)APosition, r,g,b, (float)AScale, AsWireframe);
}
void OpenGl_GraphicDriver::TriedronErase (const Graphic3d_CView& ACView)
{
call_togl_triedron_erase((CALL_DEF_VIEW *)&ACView);
}
void OpenGl_GraphicDriver::TriedronEcho (const Graphic3d_CView& ACView,const Aspect_TypeOfTriedronEcho AType )
{
call_togl_triedron_echo( (CALL_DEF_VIEW *)&ACView,AType );
}
void OpenGl_GraphicDriver::BackgroundImage( const Standard_CString FileName,
const Graphic3d_CView& ACView,
const Aspect_FillMethod FillStyle )
{
#ifdef OCC1188
Graphic3d_CView MyCView = ACView;
Standard_Integer width, height;
Handle(Image_Image) image;
Standard_Boolean result = AlienImage::LoadImageFile( FileName, image, width, height );
if ( result ) {
unsigned char *data = (unsigned char*)malloc( width * height * 3 );
unsigned char *pdata = data;
Standard_Integer i,j;
Quantity_Color color;
if ( data != NULL ) {
for ( j = height - 1; j >= 0; j-- )
for ( i = 0; i < width; i++ ) {
color = image->PixelColor( i, j );
*pdata++ = (int)( 255 * color.Red() );
*pdata++ = (int)( 255 * color.Green() );
*pdata++ = (int)( 255 * color.Blue() );
}
call_togl_create_bg_texture( (CALL_DEF_VIEW*)&MyCView, width, height, data, (int)FillStyle );
// delete data here
free( data );
}
}
#endif // OCC1188
}
void OpenGl_GraphicDriver::SetBgImageStyle( const Graphic3d_CView& ACView,
const Aspect_FillMethod FillStyle )
{
#ifdef OCC1188
Graphic3d_CView MyCView = ACView;
call_togl_set_bg_texture_style( (CALL_DEF_VIEW*)&MyCView, (int)FillStyle );
#endif //OCC1188
}
void OpenGl_GraphicDriver::SetBgGradientStyle(const Graphic3d_CView& ACView,const Aspect_GradientFillMethod FillType)
{
call_togl_set_gradient_type( ACView.WsId, FillType);
}
void OpenGl_GraphicDriver::GraduatedTrihedronDisplay(const Graphic3d_CView& view,
const Graphic3d_CGraduatedTrihedron& cubic)
{
call_togl_graduatedtrihedron_display((CALL_DEF_VIEW*)&view, cubic);
}
void OpenGl_GraphicDriver::GraduatedTrihedronErase(const Graphic3d_CView& view)
{
call_togl_graduatedtrihedron_erase((CALL_DEF_VIEW*)&view);
}
void OpenGl_GraphicDriver::GraduatedTrihedronMinMaxValues(const Standard_ShortReal xmin,
const Standard_ShortReal ymin,
const Standard_ShortReal zmin,
const Standard_ShortReal xmax,
const Standard_ShortReal ymax,
const Standard_ShortReal zmax)
{
call_togl_graduatedtrihedron_minmaxvalues(xmin, ymin, zmin, xmax, ymax, zmax);
}

2
src/OpenGl/OpenGl_GraphicDriver_Export.cxx
View File

@ -2,7 +2,7 @@
/* Includes */ /* Includes */
/************************************************************************/ /************************************************************************/
#include <OpenGl_GraphicDriver.jxx> #include <OpenGl_GraphicDriver.hxx>
#include <OSD_Localizer.hxx> #include <OSD_Localizer.hxx>
#ifdef HAVE_GL2PS #ifdef HAVE_GL2PS

530
src/OpenGl/OpenGl_GraphicDriver_Layer.cxx
View File

@ -1,229 +1,331 @@
// File: OpenGl_GraphicDriver_Layer.cxx
// Created: 20 October 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
// File OpenGl_GraphicDriver_Layer.cxx #include <OpenGl_GraphicDriver.hxx>
// Created Mardi 3 novembre 1998
// Author CAL
//-Copyright MatraDatavision 1998 #include <OSD_FontAspect.hxx>
//-Version #include <OpenGl_tgl_all.hxx>
//-Design Declaration des variables specifiques aux Drivers #include <OpenGl_Display.hxx>
#include <OpenGl_AspectText.hxx>
#include <OpenGl_TextParam.hxx>
//-Warning Un driver encapsule les Pex et OpenGl drivers /*----------------------------------------------------------------------*/
//-References struct OpenGl_LAYER_PROP
//-Language C++ 2.0
//-Declarations
// for the class
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <OpenGl_tgl_funcs.hxx>
//-Aliases
#define NO_DEBUG
//-Global data definitions
//-Methods, in order
void OpenGl_GraphicDriver::Layer (Aspect_CLayer2d& ACLayer) {
Aspect_CLayer2d MyCLayer = ACLayer;
if (MyTraceLevel) {
PrintFunction ("call_togl_layer2d");
PrintInteger ("ALayerType", int (ACLayer.layerType));
}
call_togl_layer2d (&MyCLayer);
ACLayer = MyCLayer;
#ifdef DEBUG
cout << "OpenGl_GraphicDriver::Layer" << endl;
call_def_ptrLayer ptrLayer;
ptrLayer = (call_def_ptrLayer) MyCLayer.ptrLayer;
if (ptrLayer == NULL)
cout << "\tptrLayer == NULL" << endl;
else
cout << "\tptrLayer->listIndex = " << ptrLayer->listIndex << endl;
#endif
}
void OpenGl_GraphicDriver::RemoveLayer (const Aspect_CLayer2d& ACLayer) {
Aspect_CLayer2d MyCLayer = ACLayer;
if (MyTraceLevel) {
PrintFunction ("call_togl_removelayer2d");
PrintInteger ("ALayerType", int (ACLayer.layerType));
}
call_togl_removelayer2d (&MyCLayer);
}
void OpenGl_GraphicDriver::BeginLayer (const Aspect_CLayer2d& ACLayer) {
Aspect_CLayer2d MyCLayer = ACLayer;
if (MyTraceLevel) {
PrintFunction ("call_togl_begin_layer2d");
PrintInteger ("ALayerType", int (ACLayer.layerType));
}
call_togl_begin_layer2d (&MyCLayer);
}
void OpenGl_GraphicDriver::BeginPolygon2d () {
if (MyTraceLevel) {
PrintFunction ("call_togl_begin_polygon2d");
}
call_togl_begin_polygon2d ();
}
void OpenGl_GraphicDriver::BeginPolyline2d () {
if (MyTraceLevel) {
PrintFunction ("call_togl_begin_polyline2d");
}
call_togl_begin_polyline2d ();
}
void OpenGl_GraphicDriver::ClearLayer (const Aspect_CLayer2d& ACLayer) {
Aspect_CLayer2d MyCLayer = ACLayer;
if (MyTraceLevel) {
PrintFunction ("call_togl_clear_layer2d");
PrintInteger ("ALayerType", int (ACLayer.layerType));
}
call_togl_clear_layer2d (&MyCLayer);
}
void OpenGl_GraphicDriver::Draw (const Standard_ShortReal X, const Standard_ShortReal Y) {
if (MyTraceLevel) {
PrintFunction ("call_togl_draw2d");
PrintShortReal ("X", X);
PrintShortReal ("Y", Y);
}
call_togl_draw2d (X, Y);
}
void OpenGl_GraphicDriver::Edge (const Standard_ShortReal X, const Standard_ShortReal Y) {
if (MyTraceLevel) {
PrintFunction ("call_togl_edge2d");
PrintShortReal ("X", X);
PrintShortReal ("Y", Y);
}
call_togl_edge2d (X, Y);
}
void OpenGl_GraphicDriver::EndLayer () {
if (MyTraceLevel) {
PrintFunction ("call_togl_end_layer2d");
}
call_togl_end_layer2d ();
}
void OpenGl_GraphicDriver::EndPolygon2d () {
if (MyTraceLevel) {
PrintFunction ("call_togl_end_polygon2d");
}
call_togl_end_polygon2d ();
}
void OpenGl_GraphicDriver::EndPolyline2d () {
if (MyTraceLevel) {
PrintFunction ("call_togl_end_polyline2d");
}
call_togl_end_polyline2d ();
}
void OpenGl_GraphicDriver::Move (const Standard_ShortReal X, const Standard_ShortReal Y) {
if (MyTraceLevel) {
PrintFunction ("call_togl_move2d");
PrintShortReal ("X", X);
PrintShortReal ("Y", Y);
}
call_togl_move2d (X, Y);
}
void OpenGl_GraphicDriver::Rectangle (const Standard_ShortReal X, const Standard_ShortReal Y, const Standard_ShortReal Width, const Standard_ShortReal Height) {
if (MyTraceLevel) {
PrintFunction ("call_togl_rectangle2d");
PrintShortReal ("X", X);
PrintShortReal ("Y", Y);
PrintShortReal ("Width", Width);
PrintShortReal ("Height", Height);
}
call_togl_rectangle2d (X, Y, Width, Height);
}
void OpenGl_GraphicDriver::SetColor (const Standard_ShortReal R, const Standard_ShortReal G, const Standard_ShortReal B) {
if (MyTraceLevel) {
PrintFunction ("call_togl_set_color");
PrintShortReal ("R", R);
PrintShortReal ("G", G);
PrintShortReal ("B", B);
}
call_togl_set_color (R, G, B);
}
void OpenGl_GraphicDriver::SetTransparency (const Standard_ShortReal ATransparency) {
if (MyTraceLevel) {
PrintFunction ("call_togl_set_transparency");
PrintShortReal ("Transparency", ATransparency);
}
call_togl_set_transparency (ATransparency);
}
void OpenGl_GraphicDriver::UnsetTransparency () {
if (MyTraceLevel) {
PrintFunction ("call_togl_unset_transparency");
}
call_togl_unset_transparency ();
}
void OpenGl_GraphicDriver::SetLineAttributes (const Standard_Integer Type, const Standard_ShortReal Width) {
if (MyTraceLevel) {
PrintFunction ("call_togl_set_line_attributes");
PrintInteger ("Type", Type);
PrintShortReal ("Width", Width);
}
call_togl_set_line_attributes (Type, Width);
}
void OpenGl_GraphicDriver::SetTextAttributes (const Standard_CString Font, const Standard_Integer AType, const Standard_ShortReal R, const Standard_ShortReal G, const Standard_ShortReal B) {
if (MyTraceLevel) {
PrintFunction ("call_togl_set_text_attributes");
PrintString ("Font", Font);
PrintInteger ("Type", AType);
PrintShortReal ("R", R);
PrintShortReal ("G", G);
PrintShortReal ("B", B);
}
call_togl_set_text_attributes ((Tchar*)Font, AType, R, G, B);
}
void OpenGl_GraphicDriver::Text (const Standard_CString AText, const Standard_ShortReal X, const Standard_ShortReal Y, const Standard_ShortReal Height)
{ {
if (MyTraceLevel) { int ListId;
PrintFunction ("call_togl_text2d");
PrintString ("Text", AText); TEL_COLOUR Color;
PrintShortReal ("X", X); int NbPoints;
PrintShortReal ("Y", Y); int LineType;
PrintShortReal ("Height", Height); float LineWidth;
int FontCurrent;
Standard_Boolean FontChanged;
OpenGl_AspectText AspectText;
OpenGl_TextParam TextParam;
};
/*----------------------------------------------------------------------*/
static const TEL_COLOUR myDefaultColor = {{ 1.F, 1.F, 1.F, 1.F }};
static const CALL_DEF_CONTEXTTEXT myDefaultContextText =
{
1, //IsDef
1, //IsSet
"Courier", //Font
0.3F, //Space
1.F, //Expan
{ 1.F, 1.F, 1.F }, //Color
(int)Aspect_TOST_NORMAL, //Style
(int)Aspect_TODT_NORMAL, //DisplayType
{ 1.F, 1.F, 1.F }, //ColorSubTitle
0, //TextZoomable
0.F, //TextAngle
(int)OSD_FA_Regular //TextFontAspect
};
static Standard_Boolean TheLayerIsOpen = Standard_False;
static OpenGl_LAYER_PROP TheLayerProp;
/*----------------------------------------------------------------------*/
void InitLayerProp (const int AListId)
{
TheLayerProp.ListId = AListId;
if (AListId)
{
TheLayerProp.Color = myDefaultColor;
TheLayerProp.NbPoints = 0;
TheLayerProp.LineType = -1;
TheLayerProp.LineWidth = -1.F;
TheLayerProp.FontCurrent = 0;
TheLayerProp.FontChanged = Standard_False;
TheLayerProp.AspectText.SetContext(myDefaultContextText);
TheLayerProp.TextParam.Height = -1;
TheLayerProp.TextParam.HAlign = Graphic3d_HTA_LEFT;
TheLayerProp.TextParam.VAlign = Graphic3d_VTA_BOTTOM;
} }
const Standard_ShortReal h = (Height < 0)? DefaultTextHeight() : Height; }
/*----------------------------------------------------------------------*/
void OpenGl_GraphicDriver::Layer (Aspect_CLayer2d& ACLayer)
{
ACLayer.ptrLayer = (call_def_ptrLayer) malloc (sizeof (CALL_DEF_PTRLAYER));
ACLayer.ptrLayer->listIndex = glGenLists(1);
}
/*----------------------------------------------------------------------*/
void OpenGl_GraphicDriver::RemoveLayer (const Aspect_CLayer2d& ACLayer)
{
if (!ACLayer.ptrLayer) return;
if (!ACLayer.ptrLayer->listIndex) return;
if (TheLayerProp.ListId == ACLayer.ptrLayer->listIndex)
EndLayer();
glDeleteLists (ACLayer.ptrLayer->listIndex, 1);
ACLayer.ptrLayer->listIndex = 0;
//szvgl: memory leak here?
//free ( ACLayer.ptrLayer );
//ACLayer.ptrLayer = NULL;
}
/*----------------------------------------------------------------------*/
void OpenGl_GraphicDriver::BeginLayer (const Aspect_CLayer2d& ACLayer)
{
call_def_ptrLayer ptrLayer = (call_def_ptrLayer) ACLayer.ptrLayer;
if (!ptrLayer) return;
InitLayerProp(ptrLayer->listIndex);
if (!TheLayerProp.ListId) return;
glEnable(GL_TEXTURE_2D);
//GLboolean stat = glIsEnabled( GL_TEXTURE_2D );
glNewList (TheLayerProp.ListId, GL_COMPILE);
TheLayerIsOpen = Standard_True;
}
void OpenGl_GraphicDriver::BeginPolygon2d ()
{
if (!TheLayerProp.ListId) return;
TheLayerProp.NbPoints = 0;
glBegin (GL_POLYGON);
}
void OpenGl_GraphicDriver::BeginPolyline2d ()
{
if (!TheLayerProp.ListId) return;
TheLayerProp.NbPoints = 0;
glBegin (GL_LINE_STRIP);
}
void OpenGl_GraphicDriver::ClearLayer (const Aspect_CLayer2d& ACLayer)
{
if (!ACLayer.ptrLayer) return;
InitLayerProp(ACLayer.ptrLayer->listIndex);
if (!TheLayerProp.ListId) return;
glNewList (TheLayerProp.ListId, GL_COMPILE);
glEndList ();
}
void OpenGl_GraphicDriver::Draw (const Standard_ShortReal X, const Standard_ShortReal Y)
{
if (!TheLayerProp.ListId) return;
TheLayerProp.NbPoints++;
glVertex3f (X, Y, 0.F);
}
void OpenGl_GraphicDriver::Edge (const Standard_ShortReal X, const Standard_ShortReal Y)
{
if (!TheLayerProp.ListId) return;
TheLayerProp.NbPoints++;
glVertex3f (X, Y, 0.F);
}
void OpenGl_GraphicDriver::EndLayer ()
{
if (!TheLayerProp.ListId) return;
if (TheLayerIsOpen)
{
glEndList();
TheLayerIsOpen = Standard_False;
}
TheLayerProp.ListId = 0;
}
void OpenGl_GraphicDriver::EndPolygon2d ()
{
if (!TheLayerProp.ListId) return;
glEnd ();
}
void OpenGl_GraphicDriver::EndPolyline2d ()
{
if (!TheLayerProp.ListId) return;
glEnd ();
}
void OpenGl_GraphicDriver::Move (const Standard_ShortReal X, const Standard_ShortReal Y)
{
if (!TheLayerProp.ListId) return;
if (TheLayerProp.NbPoints)
{
glEnd ();
TheLayerProp.NbPoints = 0;
glBegin (GL_LINE_STRIP);
}
TheLayerProp.NbPoints++;
glVertex3f (X, Y, 0.F);
}
void OpenGl_GraphicDriver::Rectangle (const Standard_ShortReal X, const Standard_ShortReal Y, const Standard_ShortReal Width, const Standard_ShortReal Height)
{
if (!TheLayerProp.ListId) return;
glRectf (X, Y, X + Width, Y + Height);
}
void OpenGl_GraphicDriver::SetColor (const Standard_ShortReal R, const Standard_ShortReal G, const Standard_ShortReal B)
{
if (!TheLayerProp.ListId) return;
TheLayerProp.Color.rgb[0] = R;
TheLayerProp.Color.rgb[1] = G;
TheLayerProp.Color.rgb[2] = B;
glColor3fv (TheLayerProp.Color.rgb);
}
void OpenGl_GraphicDriver::SetTransparency (const Standard_ShortReal ATransparency)
{
if (!TheLayerProp.ListId) return;
TheLayerProp.Color.rgb[3] = ATransparency;
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4fv (TheLayerProp.Color.rgb);
}
void OpenGl_GraphicDriver::UnsetTransparency ()
{
if (!TheLayerProp.ListId) return;
TheLayerProp.Color.rgb[3] = 1.F;
glDisable (GL_BLEND);
}
void OpenGl_GraphicDriver::SetLineAttributes (const Standard_Integer Type, const Standard_ShortReal Width)
{
if (!TheLayerProp.ListId || openglDisplay.IsNull()) return;
if (TheLayerProp.LineType != Type)
{
TheLayerProp.LineType = Type;
openglDisplay->SetTypeOfLine((Aspect_TypeOfLine) Type);
}
if (TheLayerProp.LineWidth != Width)
{
TheLayerProp.LineWidth = Width;
glLineWidth ((GLfloat) Width);
}
}
void OpenGl_GraphicDriver::SetTextAttributes (const Standard_CString Font, const Standard_Integer AType, const Standard_ShortReal R, const Standard_ShortReal G, const Standard_ShortReal B)
{
if (!TheLayerProp.ListId || openglDisplay.IsNull()) return;
if ( strcmp ( TheLayerProp.AspectText.Font(), Font ) != 0 ||
(int)TheLayerProp.AspectText.DisplayType() != AType )
{
CALL_DEF_CONTEXTTEXT aContextText = myDefaultContextText;
aContextText.Font = (char*)Font;
aContextText.DisplayType = AType;
aContextText.Color.r = R;
aContextText.Color.g = G;
aContextText.Color.b = B;
TheLayerProp.AspectText.SetContext(aContextText);
TheLayerProp.FontCurrent = openglDisplay->FindFont(TheLayerProp.AspectText.Font(), TheLayerProp.AspectText.FontAspect(), TheLayerProp.TextParam.Height);
TheLayerProp.FontChanged = Standard_True;
}
}
void OpenGl_GraphicDriver::Text (const Standard_CString AText, const Standard_ShortReal X, const Standard_ShortReal Y, const Standard_ShortReal AHeight)
{
if (!TheLayerProp.ListId || openglDisplay.IsNull()) return;
const Standard_ShortReal height = (AHeight < 0)? DefaultTextHeight() : AHeight;
if ( TheLayerProp.TextParam.Height != height || TheLayerProp.FontChanged || TheLayerProp.FontCurrent == 0 )
{
TheLayerProp.TextParam.Height = (int )height;
TheLayerProp.FontCurrent = openglDisplay->FindFont(TheLayerProp.AspectText.Font(), TheLayerProp.AspectText.FontAspect(), (int )height);
TheLayerProp.FontChanged = Standard_False;
}
TCollection_ExtendedString estr(AText); TCollection_ExtendedString estr(AText);
call_togl_text2d ((Techar *)estr.ToExtString(), X, Y, h); const Techar *s = (const Techar *)estr.ToExtString();
//szv: conversion of Techar to wchar_t
wchar_t *s1 = (wchar_t*)s;
if (sizeof(Techar) != sizeof(wchar_t))
{
Tint i = 0; while (s[i++]);
s1 = new wchar_t[i];
i = 0; while (s1[i++] = (wchar_t)(*s++));
}
openglDisplay->RenderText(s1, 1, (float)X, (float)Y, 0.F, &TheLayerProp.AspectText, &TheLayerProp.TextParam);
//szv: delete temporary wide string
if (sizeof(Techar) != sizeof(wchar_t))
delete[] s1;
} }
void OpenGl_GraphicDriver::TextSize (const Standard_CString AText, const Standard_ShortReal AHeight, Standard_ShortReal& AWidth, Standard_ShortReal& AnAscent, Standard_ShortReal& ADescent) const void OpenGl_GraphicDriver::TextSize (const Standard_CString AText, const Standard_ShortReal AHeight, Standard_ShortReal& AWidth, Standard_ShortReal& AnAscent, Standard_ShortReal& ADescent) const
{ {
TCollection_ExtendedString estr(AText); if (!TheLayerProp.ListId || openglDisplay.IsNull()) return;
call_togl_textsize2d ((Techar *)estr.ToExtString(), AHeight, &AWidth, &AnAscent, &ADescent);
if (MyTraceLevel) { const Standard_ShortReal height = (AHeight < 0)? DefaultTextHeight() : AHeight;
PrintFunction ("call_togl_textsize2d");
PrintString ("Text", AText); if ( TheLayerProp.TextParam.Height != height || TheLayerProp.FontChanged || TheLayerProp.FontCurrent == 0 )
PrintShortReal ("AHeight", AHeight); {
PrintShortReal ("AWidth", AWidth); TheLayerProp.TextParam.Height = (int )height;
PrintShortReal ("AnAscent", AnAscent); TheLayerProp.FontCurrent = openglDisplay->FindFont(TheLayerProp.AspectText.Font(), TheLayerProp.AspectText.FontAspect(), (int )height);
PrintShortReal ("ADescent", ADescent); TheLayerProp.FontChanged = Standard_False;
} }
TCollection_ExtendedString estr(AText);
const Techar *s = (const Techar *)estr.ToExtString();
//szv: conversion of Techar to wchar_t
wchar_t *s1 = (wchar_t*)s;
if (sizeof(Techar) != sizeof(wchar_t))
{
Tint i = 0; while (s[i++]);
s1 = new wchar_t[i];
i = 0; while (s1[i++] = (wchar_t)(*s++));
}
int aWidth = 0, anAscent = 0, aDescent = 0;
openglDisplay->StringSize(s1, aWidth, anAscent, aDescent);
//szv: delete temporary wide string
if (sizeof(Techar) != sizeof(wchar_t))
delete[] s1;
AWidth = (Standard_ShortReal) aWidth;
AnAscent = (Standard_ShortReal) anAscent;
ADescent = (Standard_ShortReal) aDescent;
} }

42
src/OpenGl/OpenGl_GraphicDriver_print.cxx
View File

@ -1,22 +1,12 @@
// File OpenGl_GraphicDriver_print.c // File: OpenGl_GraphicDriver_print.cxx
// Created March 2000 // Created: 20 October 2011
// Author THA // Author: Sergey ZERCHANINOV
// e-mail t-hartl@muenchen.matra-dtv.fr // Copyright: OPEN CASCADE 2011
/************************************************************************/ #include <OpenGl_GraphicDriver.hxx>
/* Includes */
/************************************************************************/
#include <OpenGl_GraphicDriver.jxx>
#include <Aspect_DriverDefinitionError.hxx>
#include <Standard_NotImplemented.hxx> #include <Standard_NotImplemented.hxx>
#include <OpenGl_CView.hxx>
#include <OpenGl_tgl_funcs.hxx>
/************************************************************************/
/* Print Methods */
/************************************************************************/
Standard_Boolean OpenGl_GraphicDriver::Print Standard_Boolean OpenGl_GraphicDriver::Print
(const Graphic3d_CView& ACView, (const Graphic3d_CView& ACView,
@ -28,22 +18,12 @@ Standard_Boolean OpenGl_GraphicDriver::Print
const Aspect_PrintAlgo printAlgorithm, const Aspect_PrintAlgo printAlgorithm,
const Standard_Real theScaleFactor) const const Standard_Real theScaleFactor) const
{ {
#ifdef WNT #ifdef WNT
Graphic3d_CView MyCView = ACView; const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
Aspect_CLayer2d MyCUnderLayer = ACUnderLayer; if (aCView)
Aspect_CLayer2d MyCOverLayer = ACOverLayer; return aCView->WS->Print(ACView,ACUnderLayer,ACOverLayer,hPrintDC,showBackground,filename,printAlgorithm,theScaleFactor);
if (MyTraceLevel) {
PrintFunction ("call_togl_print");
PrintCView (MyCView, 1);
}
return call_togl_print (&MyCView, &MyCUnderLayer, &MyCOverLayer,
hPrintDC, (int)showBackground, filename,
(int)printAlgorithm, (float)theScaleFactor);
#else #else
Standard_NotImplemented::Raise ("OpenGl_GraphicDriver::Print is implemented " Standard_NotImplemented::Raise ("OpenGl_GraphicDriver::Print is implemented only on Windows");
"only on Windows");
return Standard_False;
#endif #endif
return Standard_False;
} }

282
src/OpenGl/OpenGl_Group.cxx Normal file
View File

@ -0,0 +1,282 @@
// File: OpenGl_Group.cxx
// Created: 1 August 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_Group.hxx>
#include <OpenGl_TextureBox.hxx>
#include <OpenGl_PrimitiveArray.hxx>
/*----------------------------------------------------------------------*/
OpenGl_Group::OpenGl_Group ()
: myAspectLine(NULL),
myAspectFace(NULL),
myAspectMarker(NULL),
myAspectText(NULL),
myFirst(NULL), myLast(NULL)
{
}
OpenGl_Group::~OpenGl_Group()
{
Clear();
}
/*----------------------------------------------------------------------*/
void OpenGl_Group::SetAspectLine (const CALL_DEF_CONTEXTLINE& theContext,
const Standard_Boolean theIsGlobal)
{
if (theIsGlobal || myFirst == NULL)
{
if (myAspectLine == NULL)
myAspectLine = new OpenGl_AspectLine();
myAspectLine->SetContext (theContext);
}
else
{
OpenGl_AspectLine* anAspectLine = new OpenGl_AspectLine();
anAspectLine->SetContext (theContext);
AddElement (TelNil/*TelAspectLine*/, anAspectLine);
}
}
/*----------------------------------------------------------------------*/
void OpenGl_Group::SetAspectFace (const CALL_DEF_CONTEXTFILLAREA& theContext,
const Standard_Boolean theIsGlobal)
{
if (theIsGlobal || myFirst == NULL)
{
if (myAspectFace == NULL)
myAspectFace = new OpenGl_AspectFace();
myAspectFace->SetContext (theContext);
}
else
{
OpenGl_AspectFace* anAspectFace = new OpenGl_AspectFace();
anAspectFace->SetContext (theContext);
AddElement (TelNil/*TelAspectFace*/, anAspectFace);
}
}
/*----------------------------------------------------------------------*/
void OpenGl_Group::SetAspectMarker (const CALL_DEF_CONTEXTMARKER& theContext,
const Standard_Boolean theIsGlobal)
{
if (theIsGlobal || myFirst == NULL)
{
if (myAspectMarker == NULL)
myAspectMarker = new OpenGl_AspectMarker();
myAspectMarker->SetContext (theContext);
}
else
{
OpenGl_AspectMarker* anAspectMarker = new OpenGl_AspectMarker();
anAspectMarker->SetContext (theContext);
AddElement (TelNil/*TelAspectMarker*/, anAspectMarker);
}
}
/*----------------------------------------------------------------------*/
void OpenGl_Group::SetAspectText (const CALL_DEF_CONTEXTTEXT& theContext,
const Standard_Boolean theIsGlobal)
{
if (theIsGlobal || myFirst == NULL)
{
if (myAspectText == NULL)
myAspectText = new OpenGl_AspectText();
myAspectText->SetContext (theContext);
}
else
{
OpenGl_AspectText* anAspectText = new OpenGl_AspectText();
anAspectText->SetContext (theContext);
AddElement ( TelNil/*TelAspectText*/, anAspectText);
}
}
/*----------------------------------------------------------------------*/
void OpenGl_Group::AddElement (const TelType AType, OpenGl_Element *AElem )
{
OpenGl_ElementNode *node = new OpenGl_ElementNode();
node->type = AType;
node->elem = AElem;
node->next = NULL;
(myLast? myLast->next : myFirst) = node;
myLast = node;
}
/*----------------------------------------------------------------------*/
void OpenGl_Group::Clear ()
{
if (myAspectLine)
{
// Delete line context
delete myAspectLine;
myAspectLine = NULL;
}
if (myAspectFace)
{
// Delete face context
delete myAspectFace;
myAspectFace = NULL;
}
if (myAspectMarker)
{
// Delete marker context
delete myAspectMarker;
myAspectMarker = NULL;
}
if (myAspectText)
{
// Delete text context
delete myAspectText;
myAspectText = NULL;
}
// Delete elements
while (myFirst)
{
OpenGl_ElementNode *next = myFirst->next;
delete myFirst->elem;
delete myFirst;
myFirst = next;
}
myLast = NULL;
}
/*----------------------------------------------------------------------*/
void OpenGl_Group::RemovePrimitiveArray (CALL_DEF_PARRAY *APArray)
{
OpenGl_ElementNode *prevnode = NULL, *node = myFirst;
while (node)
{
if (node->type == TelParray)
{
CALL_DEF_PARRAY *aCurPArray = ((const OpenGl_PrimitiveArray *)node->elem)->PArray();
// validate for correct pointer
if (aCurPArray->num_bounds == APArray->num_bounds &&
aCurPArray->num_edges == APArray->num_edges &&
aCurPArray->num_vertexs == APArray->num_vertexs &&
aCurPArray->type == APArray->type)
{
(prevnode? prevnode->next : myFirst) = node->next;
if (!myFirst) myLast = NULL;
delete node->elem;
delete node;
break;
}
}
prevnode = node;
node = node->next;
}
}
/*----------------------------------------------------------------------*/
void OpenGl_Group::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
{
// Is rendering in ADD or IMMEDIATE mode?
const Standard_Boolean isImmediate = (AWorkspace->NamedStatus & (OPENGL_NS_ADD | OPENGL_NS_IMMEDIATE)) != 0;
// Setup aspects
const OpenGl_AspectLine *aspect_line = AWorkspace->AspectLine(Standard_False);
const OpenGl_AspectFace *aspect_face = AWorkspace->AspectFace(Standard_False);
const OpenGl_AspectMarker *aspect_marker = AWorkspace->AspectMarker(Standard_False);
const OpenGl_AspectText *aspect_text = AWorkspace->AspectText(Standard_False);
if (myAspectLine)
AWorkspace->SetAspectLine(myAspectLine);
if (myAspectFace)
AWorkspace->SetAspectFace(myAspectFace);
if (myAspectMarker)
AWorkspace->SetAspectMarker(myAspectMarker);
if (myAspectText)
AWorkspace->SetAspectText(myAspectText);
// Render group elements
OpenGl_ElementNode *node = myFirst;
while (node)
{
switch (node->type)
{
case TelPolyline:
case TelMarker:
case TelMarkerSet:
case TelText:
{
glDisable(GL_LIGHTING);
if (isImmediate)
{
glDepthMask(GL_FALSE);
}
else if ( (AWorkspace->NamedStatus & OPENGL_NS_ANIMATION) != 0 &&
(AWorkspace->NamedStatus & OPENGL_NS_WIREFRAME) == 0 &&
AWorkspace->DegenerateModel != 0 )
{
glDisable( GL_DEPTH_TEST );
if ( AWorkspace->NamedStatus & OPENGL_NS_TEXTURE ) DisableTexture();
AWorkspace->NamedStatus |= OPENGL_NS_WIREFRAME;
}
node->elem->Render( AWorkspace );
if ( !isImmediate && (AWorkspace->NamedStatus & OPENGL_NS_TEXTURE) != 0 ) EnableTexture();
break;
}
case TelPolygon:
case TelPolygonIndices:
case TelQuadrangle:
case TelTriangleMesh:
{
if (isImmediate)
{
glDepthMask(GL_FALSE);
}
else if ( (AWorkspace->NamedStatus & OPENGL_NS_ANIMATION) != 0 &&
(AWorkspace->NamedStatus & OPENGL_NS_WIREFRAME) != 0 &&
AWorkspace->DegenerateModel < 2 )
{
if ( AWorkspace->NamedStatus & OPENGL_NS_TEXTURE ) EnableTexture ();
glEnable( GL_DEPTH_TEST );
AWorkspace->NamedStatus &= ~OPENGL_NS_WIREFRAME;
}
if ( AWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT )
AWorkspace->DisablePolygonOffset();
node->elem->Render( AWorkspace );
if ( AWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT )
AWorkspace->EnablePolygonOffset();
break;
}
default:
{
node->elem->Render( AWorkspace );
break;
}
}
node = node->next;
}
// Restore aspects
AWorkspace->SetAspectLine(aspect_line);
AWorkspace->SetAspectFace(aspect_face);
AWorkspace->SetAspectMarker(aspect_marker);
AWorkspace->SetAspectText(aspect_text);
}
/*----------------------------------------------------------------------*/

59
src/OpenGl/OpenGl_Group.hxx Normal file
View File

@ -0,0 +1,59 @@
// File: OpenGl_Group.hxx
// Created: 1 August 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _OpenGl_Group_Header
#define _OpenGl_Group_Header
#include <InterfaceGraphic_Graphic3d.hxx>
#include <OpenGl_Element.hxx>
#include <OpenGl_AspectLine.hxx>
#include <OpenGl_AspectFace.hxx>
#include <OpenGl_AspectMarker.hxx>
#include <OpenGl_AspectText.hxx>
#include <OpenGl_tsm.hxx>
struct OpenGl_ElementNode
{
TelType type;
OpenGl_Element *elem;
OpenGl_ElementNode *next;
IMPLEMENT_MEMORY_OPERATORS
};
class OpenGl_Group : public OpenGl_Element
{
public:
OpenGl_Group ();
virtual ~OpenGl_Group();
void SetAspectLine (const CALL_DEF_CONTEXTLINE &AContext, const Standard_Boolean IsGlobal = Standard_True);
void SetAspectFace (const CALL_DEF_CONTEXTFILLAREA &AContext, const Standard_Boolean IsGlobal = Standard_True);
void SetAspectMarker (const CALL_DEF_CONTEXTMARKER &AContext, const Standard_Boolean IsGlobal = Standard_True);
void SetAspectText (const CALL_DEF_CONTEXTTEXT &AContext, const Standard_Boolean IsGlobal = Standard_True);
void AddElement (const TelType, OpenGl_Element * );
void Clear ();
void RemovePrimitiveArray (CALL_DEF_PARRAY *APArray);
virtual void Render (const Handle(OpenGl_Workspace) &AWorkspace) const;
protected:
OpenGl_AspectLine *myAspectLine;
OpenGl_AspectFace *myAspectFace;
OpenGl_AspectMarker *myAspectMarker;
OpenGl_AspectText *myAspectText;
OpenGl_ElementNode *myFirst, *myLast;
public:
IMPLEMENT_MEMORY_OPERATORS
};
#endif //_OpenGl_Group_Header

30
src/OpenGl/OpenGl_Light.hxx Normal file
View File

@ -0,0 +1,30 @@
// File: OpenGl_Light.hxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef OpenGl_Light_Header
#define OpenGl_Light_Header
#include <NCollection_List.hxx>
#include <InterfaceGraphic_telem.hxx>
#define OpenGLMaxLights 8
struct OpenGl_Light
{
TLightType type;
int HeadLight;
TEL_COLOUR col;
Tfloat pos[3];
Tfloat dir[3];
Tfloat shine;
Tfloat atten[2];
Tfloat angle;
IMPLEMENT_MEMORY_OPERATORS
};
typedef NCollection_List<OpenGl_Light> OpenGl_ListOfLight;
#endif //OpenGl_Light_Header

605
src/OpenGl/OpenGl_LightBox.cxx
View File

@ -1,605 +0,0 @@
/***********************************************************************
FONCTION :
----------
Gestion des light sous OpenGL
REMARQUES:
----------
- We can't take in account GL_QUADRATIC_ATTENUATION.
- Position des lumieres. Il faut faire le glLight(GL_POSITION) apres la
gestion des matrices de transformation (GL_MODELVIEW).
- Se mefier de GL_POSITION pour les lumieres directionelle. GL_POSITION
indique bien la position ou se trouve la lumiere. Comme on a une direction
comme valeur il faut l'inverser.
FONCTIONNEMENT:
---------------
- La variable lightOn permet d'optimiser le changement d'etat des lumieres.
Ceci permet d'eviter d'appeler glIsEnable(GL_LIGHTING). Il faut bien sur
que l'on utilise les 2 points d'entree LightOn() et LightOff().
L'init de la variable est faite par call_func_redraw_all_structs (OpenGl_funcs.c)
HISTORIQUE DES MODIFICATIONS :
--------------------------------
20-06-97 : PCT ; creation
30-06-96 : FMN ; Integration
18-07-96 : FMN, PCT ; Correction indice, ajout IsLightOn()
25-07-97 : CAL ; Portage NT (include OpenGl_tgl_all.h)
07-10-97 : FMN ; Simplification WNT
************************************************************************/
/*----------------------------------------------------------------------*/
/*
* Includes
*/
#include <OpenGl_tgl_all.hxx>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <memory.h>
#include <OpenGl_LightBox.hxx>
#include <OpenGl_Memory.hxx>
/*----------------------------------------------------------------------*/
/*
* Constantes
*/
#ifndef DEBUG
#define DEBUG 0
#endif
#define NO_PRINT_DEBUG
#define GROW_SIZE_WKS 10
#define GROW_SIZE_LIGHT 8
/*----------------------------------------------------------------------*/
/*
* Types definis
*/
struct TEL_LIGHT_DATA
{
Tint LightID;
TEL_LIGHT light;
IMPLEMENT_MEMORY_OPERATORS
};
struct TEL_LIGHT_WKS
{
Tint wks;
int lights_count;
int lights_size;
TEL_LIGHT_DATA *lights;
IMPLEMENT_MEMORY_OPERATORS
};
/*----------------------------------------------------------------------*/
/*
* Variables statiques
*/
static TEL_LIGHT_WKS *wks = NULL;
static int wks_count = 0;
static int wks_size = 0;
static GLfloat default_amb[4] = { 0.0, 0.0, 0.0, 1.0 };
static GLfloat default_sptdir[3] = { 0.0, 0.0, -1.0 };
static GLfloat default_sptexpo = 0.0;
static GLfloat default_sptcutoff = 180.0;
static GLboolean lightOn = GL_FALSE;
/*----------------------------------------------------------------------*/
/*
* Fonctions privees
*/
/*-----------------------------------------------------------------*/
/*
* Set des lumieres
*/
static void bind_light(TEL_LIGHT *lptr, int *gl_lid)
{
GLfloat data_amb[4];
GLfloat data_diffu[4];
GLfloat data_pos[4];
GLfloat data_sptdir[3];
GLfloat data_sptexpo;
GLfloat data_sptcutoff;
GLfloat data_constantattenuation;
GLfloat data_linearattenuation;
GLint cur_matrix;
/* on n'a droit qu'a 8 lights avec OpenGL... */
if (*gl_lid > GL_LIGHT7) return;
/* la light est une headlight ? */
if (lptr->HeadLight)
{
glGetIntegerv(GL_MATRIX_MODE, &cur_matrix);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
}
/* set la light en fonction de son type */
switch (lptr->type)
{
case TLightAmbient:
data_amb[0] = lptr->col.rgb[0];
data_amb[1] = lptr->col.rgb[1];
data_amb[2] = lptr->col.rgb[2];
data_amb[3] = 1.0;
/*------------------------- Ambient ---------------------------*/
/*
* The GL_AMBIENT parameter refers to RGBA intensity of the ambient
* light.
*/
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, data_amb);
#if DEBUG
printf("OpenGL_LightBox::bind_light:LightAmbient \n");
printf("\tGL_LIGHT_MODEL_AMBIENT %f %f %f \n", data_amb[0], data_amb[1], data_amb[2]);
#endif
break;
case TLightDirectional:
data_diffu[0] = lptr->col.rgb[0];
data_diffu[1] = lptr->col.rgb[1];
data_diffu[2] = lptr->col.rgb[2];
data_diffu[3] = 1.0;
/*------------------------- Direction ---------------------------*/
/* From Open GL Programming Rev 1 Guide Chapt 6 :
Lighting The Mathematics of Lighting ( p 168 )
Directional Light Source ( Infinite ) :
if the last parameter of GL_POSITION , w , is zero, the
corresponding light source is a Directional one.
GL_SPOT_CUTOFF a 180 signifie que ce n'est pas un spot.
To create a realistic effect, set the GL_SPECULAR parameter
to the same value as the GL_DIFFUSE.
*/
data_pos[0] = -lptr->dir[0];
data_pos[1] = -lptr->dir[1];
data_pos[2] = -lptr->dir[2];
data_pos[3] = 0.0;
glLightfv(*gl_lid, GL_AMBIENT, default_amb);
glLightfv(*gl_lid, GL_DIFFUSE, data_diffu);
glLightfv(*gl_lid, GL_SPECULAR, data_diffu);
glLightfv(*gl_lid, GL_POSITION, data_pos);
glLightfv(*gl_lid, GL_SPOT_DIRECTION, default_sptdir);
glLightf(*gl_lid, GL_SPOT_EXPONENT, default_sptexpo);
glLightf(*gl_lid, GL_SPOT_CUTOFF, default_sptcutoff);
#if DEBUG
printf("OpenGL_LightBox::bind_light:LightDirection \n");
printf("\tGL_AMBIENT %f %f %f \n", default_amb[0], default_amb[1], default_amb[2]);
printf("\tGL_DIFFUSE %f %f %f \n", data_diffu[0], data_diffu[1], data_diffu[2]);
printf("\tGL_SPECULAR %f %f %f \n", data_diffu[0], data_diffu[1], data_diffu[2]);
printf("\tGL_POSITION %f %f %f \n", data_pos[0], data_pos[1], data_pos[2]);
#endif
break;
case TLightPositional:
data_diffu[0] = lptr->col.rgb[0];
data_diffu[1] = lptr->col.rgb[1];
data_diffu[2] = lptr->col.rgb[2];
data_diffu[3] = 1.0;
/*------------------------- Position -----------------------------*/
/* From Open GL Programming Rev 1 Guide Chapt 6 :
Lighting The Mathematics of Lighting ( p 168 )
Positional Light Source :
if the last parameter of GL_POSITION , w , is nonzero,
the corresponding light source is a Positional one.
GL_SPOT_CUTOFF a 180 signifie que ce n'est pas un spot.
To create a realistic effect, set the GL_SPECULAR parameter
to the same value as the GL_DIFFUSE.
*/
data_pos[0] = lptr->pos[0];
data_pos[1] = lptr->pos[1];
data_pos[2] = lptr->pos[2];
data_pos[3] = 1.0;
data_constantattenuation = lptr->atten[0];
data_linearattenuation = lptr->atten[1];
glLightfv(*gl_lid, GL_AMBIENT, default_amb);
glLightfv(*gl_lid, GL_DIFFUSE, data_diffu);
glLightfv(*gl_lid, GL_SPECULAR, data_diffu);
glLightfv(*gl_lid, GL_POSITION, data_pos);
glLightfv(*gl_lid, GL_SPOT_DIRECTION, default_sptdir);
glLightf(*gl_lid, GL_SPOT_EXPONENT, default_sptexpo);
glLightf(*gl_lid, GL_SPOT_CUTOFF, default_sptcutoff);
glLightf(*gl_lid, GL_CONSTANT_ATTENUATION, data_constantattenuation);
glLightf(*gl_lid, GL_LINEAR_ATTENUATION, data_linearattenuation);
glLightf(*gl_lid, GL_QUADRATIC_ATTENUATION, 0.0);
#if DEBUG
printf("OpenGL_LightBox::bind_light:LightPosition \n");
printf("\tGL_AMBIENT %f %f %f \n", default_amb[0], default_amb[1], default_amb[2]);
printf("\tGL_DIFFUSE %f %f %f \n", data_diffu[0], data_diffu[1], data_diffu[2]);
printf("\tGL_SPECULAR %f %f %f \n", data_diffu[0], data_diffu[1], data_diffu[2]);
printf("\tGL_POSITION %f %f %f \n", data_pos[0], data_pos[1], data_pos[2]);
#endif
break;
case TLightSpot:
data_diffu[0] = lptr->col.rgb[0];
data_diffu[1] = lptr->col.rgb[1];
data_diffu[2] = lptr->col.rgb[2];
data_diffu[3] = 1.0;
data_pos[0] = lptr->pos[0];
data_pos[1] = lptr->pos[1];
data_pos[2] = lptr->pos[2];
data_pos[3] = 1.0;
data_sptdir[0] = lptr->dir[0];
data_sptdir[1] = lptr->dir[1];
data_sptdir[2] = lptr->dir[2];
data_sptexpo = ( float )lptr->shine * 128.0F;
data_sptcutoff = ( float )(lptr->angle * 180.0F)/( float )M_PI;
data_constantattenuation = lptr->atten[0];
data_linearattenuation = lptr->atten[1];
glLightfv(*gl_lid, GL_AMBIENT, default_amb);
glLightfv(*gl_lid, GL_DIFFUSE, data_diffu);
glLightfv(*gl_lid, GL_SPECULAR, data_diffu);
glLightfv(*gl_lid, GL_POSITION, data_pos);
glLightfv(*gl_lid, GL_SPOT_DIRECTION, data_sptdir);
glLightf(*gl_lid, GL_SPOT_EXPONENT, data_sptexpo);
glLightf(*gl_lid, GL_SPOT_CUTOFF, data_sptcutoff);
glLightf(*gl_lid, GL_CONSTANT_ATTENUATION, data_constantattenuation);
glLightf(*gl_lid, GL_LINEAR_ATTENUATION, data_linearattenuation);
glLightf(*gl_lid, GL_QUADRATIC_ATTENUATION, 0.0);
#if DEBUG
printf("OpenGL_LightBox::bind_light:LightSpot \n");
printf("\tGL_AMBIENT %f %f %f \n", default_amb[0], default_amb[1], default_amb[2]);
printf("\tGL_DIFFUSE %f %f %f \n", data_diffu[0], data_diffu[1], data_diffu[2]);
printf("\tGL_SPECULAR %f %f %f \n", data_diffu[0], data_diffu[1], data_diffu[2]);
printf("\tGL_POSITION %f %f %f \n", data_pos[0], data_pos[1], data_pos[2]);
printf("\tGL_SPOT_DIRECTION %f %f %f \n", data_sptdir[0], data_sptdir[1], data_sptdir[2]);
printf("\tGL_SPOT_EXPONENT %f \n", data_sptexpo);
printf("\tGL_SPOT_CUTOFF %f \n", data_sptcutoff);
printf("\tGL_CONSTANT_ATTENUATION %f \n", data_constantattenuation);
printf("\tGL_LINEAR_ATTENUATION %f \n", data_linearattenuation);
#endif
break;
}
if (lptr->type != TLightAmbient)
{
#if DEBUG
printf("OpenGL_LightBox::bind_light:glEnable %d \n", *gl_lid);
#endif
glEnable(*gl_lid);
(*gl_lid)++;
}
/* si la light etait une headlight alors restaure la matrice precedente */
if (lptr->HeadLight)
{
glPopMatrix();
glMatrixMode(cur_matrix);
}
}
/*-----------------------------------------------------------------*/
/*
* recherche de la liste de lampe d'une wks, creation d'une liste si non existante
*/
static int find_wks(Tint WksID, int alloc)
{
int i;
/* recherche la wks dans la liste si elle existe */
for (i=0; i<wks_count; i++)
if (wks[i].wks == WksID)
return i;
if (!alloc) return -1;
/* la wks n'existe pas => on fait de la place si yen a plus */
if (wks_count == wks_size )
{
wks_size += GROW_SIZE_WKS;
if (!wks)
wks = new TEL_LIGHT_WKS[wks_size];
else
#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
wks = (TEL_LIGHT_WKS*)realloc(wks, wks_size*sizeof(TEL_LIGHT_WKS));
#else
wks = cmn_resizemem<TEL_LIGHT_WKS>(wks, wks_size);
#endif
if (!wks)
return -1;
}
wks[wks_count].wks = WksID;
wks[wks_count].lights = NULL;
wks[wks_count].lights_size = 0;
wks[wks_count].lights_count = 0;
return wks_count++;
}
/*-----------------------------------------------------------------*/
/*
* recherche une lampe d'une wks, creation d'une lampe si elle n'existe pas
*/
static int find_light(int WksIdx, Tint LightID, int alloc)
{
int i;
TEL_LIGHT_DATA *lights;
/* recherche la light dans la liste de la wks */
lights = wks[WksIdx].lights;
for (i=0; i<wks[WksIdx].lights_count; i++)
if (lights[i].LightID == LightID)
return i;
if (!alloc) return -1;
/* la lampe n'existe pas => on cree une lampe */
if (wks[WksIdx].lights_count == wks[WksIdx].lights_size)
{
wks[WksIdx].lights_size += GROW_SIZE_LIGHT;
if (!wks[WksIdx].lights)
wks[WksIdx].lights = new TEL_LIGHT_DATA[wks[WksIdx].lights_size];
else
wks[WksIdx].lights =
#if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)
(TEL_LIGHT_DATA*)realloc( wks[WksIdx].lights,
wks[WksIdx].lights_size*sizeof(TEL_LIGHT_DATA) );
#else
cmn_resizemem<TEL_LIGHT_DATA>( wks[WksIdx].lights,
wks[WksIdx].lights_size );
#endif
if (!wks[WksIdx].lights)
return -1;
}
return wks[WksIdx].lights_count++;
}
/*----------------------------------------------------------------------*/
/*
* Fonctions publiques
*/
/*-----------------------------------------------------------------*/
/*
* Ajout d'une lumiere dans la Wks
*/
TStatus AddLight(Tint WksID, Tint LightID, tel_light light)
{
int wks_entry;
int light_entry;
#if DEBUG
printf("AddLight %d dans wks %d [wds_count=%d]\n", LightID, WksID, wks_count);
#endif
/* obtient le numero de la liste de lights de la wks */
wks_entry = find_wks(WksID, 1);
if (wks_entry == -1) return TFailure;
/* recherche le numero de la lampe si elle existe */
light_entry = find_light(wks_entry, LightID, 1);
if (light_entry == -1) return TFailure;
/* met a jour la light */
wks[wks_entry].lights[light_entry].LightID = LightID;
wks[wks_entry].lights[light_entry].light = *light;
#if DEBUG
printf("ajout ok\n");
#endif
return TSuccess;
}
/*-----------------------------------------------------------------*/
/*
* Maj des lumieres de la Wks
*/
TStatus UpdateLight(Tint WksID)
{
int wks_entry;
int i;
int gl_lid;
#if DEBUG
printf("UpdateLight %d\n", WksID);
#endif
/* vire toutes les lights des le depart avant une re-init complete */
for (i=GL_LIGHT0; i<=GL_LIGHT7; i++)
glDisable(i);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, default_amb);
/* recherche la liste de light de la wks */
wks_entry = find_wks(WksID, 0);
if (wks_entry == -1) return TFailure;
#if DEBUG
printf("*** Update: nb = %d\n", wks[wks_entry].lights_count);
#endif
/* set les lights */
gl_lid = GL_LIGHT0;
for (i=0; i<wks[wks_entry].lights_count; i++)
{
#if DEBUG
printf("binding light %d\n", i);
#endif
bind_light(&wks[wks_entry].lights[i].light, &gl_lid);
}
if (wks[wks_entry].lights_count > 0) LightOn();
#if DEBUG
printf("update ok\n");
#endif
return TSuccess;
}
/*-----------------------------------------------------------------*/
/*
* Remove une lumiere de la Wks
*/
TStatus RemoveLight(Tint WksID, Tint LightID)
{
int wks_entry;
int light_entry;
/* recherche de la wks */
wks_entry = find_wks(WksID, 0);
if (wks_entry == -1) return TFailure;
/* recherche de la light */
light_entry = find_light(wks_entry, LightID, 0);
if (light_entry == -1) return TFailure;
/* retire la light */
memcpy(&wks[wks_entry].lights[light_entry],
&wks[wks_entry].lights[light_entry+1],
(wks[wks_entry].lights_count - light_entry - 1)*sizeof(TEL_LIGHT_DATA));
wks[wks_entry].lights_count--;
#if DEBUG
printf("RemoveLight %d dans wks %d [wds_count=%d]\n", LightID, WksID, wks_count);
#endif
return TSuccess;
}
/*-----------------------------------------------------------------*/
/*
* Remove des lumieres de la Wks
*/
TStatus RemoveWksLight(Tint WksID)
{
int wks_entry;
/* recherche de la wks */
wks_entry = find_wks(WksID, 0);
if (wks_entry == -1) return TFailure;
/* destruction de toute la wks */
free(wks[wks_entry].lights);
memcpy(&wks[wks_entry],
&wks[wks_entry+1],
(wks_count - wks_entry - 1)*sizeof(TEL_LIGHT_WKS));
wks_count--;
return TSuccess;
}
/*-----------------------------------------------------------------*/
/*
* Reset de toutes les lights d'une Wks
*/
TStatus ResetWksLight(Tint WksID)
{
int wks_entry;
/* recherche de la wks */
wks_entry = find_wks(WksID, 0);
if (wks_entry == -1) return TFailure;
/* destruction de toutes les lights */
wks[wks_entry].lights_count = 0;
return TSuccess;
}
/*-----------------------------------------------------------------*/
/*
* Enable des lights
*/
void LightOn(void)
{
#ifdef PRINT_DEBUG
if(IsLightOn())
printf("LightOn(): lighting already enabled!");
else
printf("LightOn() succeeded");
#endif
glEnable(GL_LIGHTING);
}
/*-----------------------------------------------------------------*/
/*
* Disable des lights
*/
void LightOff(void)
{
#ifdef PRINT_DEBUG
if(!IsLightOn())
printf("LightOff(): lighting already disabled!");
else
printf("LightOff() succeeded");
#endif
glDisable(GL_LIGHTING);
}
/*-----------------------------------------------------------------*/
/*
* IsEnable des lights
*/
GLboolean IsLightOn(void)
{
return glIsEnabled(GL_LIGHTING);
}
/*-----------------------------------------------------------------*/

112
src/OpenGl/OpenGl_LightBox.hxx
View File

@ -1,112 +0,0 @@
/***********************************************************************
FONCTION :
----------
Gestion des light sous OpenGL
REMARQUES:
----------
HISTORIQUE DES MODIFICATIONS :
--------------------------------
20-06-97 : PCT ; creation
30-06-97 : FMN ; Integration
18-07-97 : FMN ; Ajout IsLightOn()
02-10-97 : FMN ; Ajout gl.h pour WNT
************************************************************************/
/*----------------------------------------------------------------------*/
#ifndef __OPENGL_LIGHTBOX_H_
#define __OPENGL_LIGHTBOX_H_
/*----------------------------------------------------------------------*/
/*
* Includes
*/
#include <GL/gl.h>
#include <OpenGl_tgl_all.hxx>
#include <OpenGl_telem.hxx>
#include <OpenGl_tsm.hxx>
/*----------------------------------------------------------------------*/
/*
* Constantes
*/
#define OpenGLMaxLights 8
/*----------------------------------------------------------------------*/
/*
* Types definis
*/
typedef struct
{
TLightType type;
int HeadLight;
TEL_COLOUR col;
Tfloat pos[3];
Tfloat dir[3];
Tfloat shine;
Tfloat atten[2];
Tfloat angle;
} TEL_LIGHT, *tel_light;
/*----------------------------------------------------------------------*/
/*
* Prototypes
*/
/*
* Ajout d'une lumiere dans la Wks
*/
extern TStatus AddLight(Tint WksID, Tint LightID, tel_light light);
/*
* Maj des lumieres de la Wks
*/
extern TStatus UpdateLight(Tint WksID);
/*
* Remove une lumiere de la Wks
*/
extern TStatus RemoveLight(Tint WksID, Tint LightID);
/*
* Remove des lumieres de la Wks
*/
extern TStatus RemoveWksLight(Tint WksID);
/*
* Reset de toutes les lights d'une Wks
*/
extern TStatus ResetWksLight(Tint WksID);
/*
* Enable des lights
*/
extern void LightOn(void);
/*
* Disable des lights
*/
extern void LightOff(void);
/*
* IsEnable des lights
*/
extern GLboolean IsLightOn(void);
/*----------------------------------------------------------------------*/
#endif /* __OPENGL_LIGHTBOX_H_ */
/*----------------------------------------------------------------------*/

93
src/OpenGl/OpenGl_Marker.cxx Normal file
View File

@ -0,0 +1,93 @@
// File: OpenGl_Marker.cxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_Marker.hxx>
#include <OpenGl_tgl_all.hxx>
#include <GL/gl.h>
#include <OpenGl_AspectMarker.hxx>
#include <OpenGl_Structure.hxx>
#include <OpenGl_Display.hxx>
/*----------------------------------------------------------------------*/
void OpenGl_Marker::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
{
const OpenGl_AspectMarker *aspect_marker = AWorkspace->AspectMarker( Standard_True );
// Use highlight colours
glColor3fv( (AWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT)? AWorkspace->HighlightColor->rgb : aspect_marker->Color().rgb );
switch ( aspect_marker->Type() )
{
case Aspect_TOM_O_POINT :
{
const char *str = AWorkspace->GetDisplay()->GetStringForMarker( Aspect_TOM_O, aspect_marker->Scale() );
glRasterPos3fv( myPoint.xyz );
AWorkspace->GetDisplay()->SetBaseForMarker();
glCallLists( strlen( str ), GL_UNSIGNED_BYTE, (const GLubyte *) str );
}
case Aspect_TOM_POINT :
{
glPointSize( aspect_marker->Scale() );
glBegin( GL_POINTS );
glVertex3fv( myPoint.xyz );
glEnd();
break;
}
default:
{
glRasterPos3fv( myPoint.xyz );
switch ( aspect_marker->Type() )
{
case Aspect_TOM_RING1 :
case Aspect_TOM_RING2 :
case Aspect_TOM_RING3 :
{
const float ADelta = 0.1f;
float AScale = aspect_marker->Scale();
float ALimit = 0.f;
if (aspect_marker->Type() == Aspect_TOM_RING1)
ALimit = AScale * 0.2f;
else if (aspect_marker->Type() == Aspect_TOM_RING2)
ALimit = AScale * 0.5f;
else
ALimit = AScale * 0.8f;
AWorkspace->GetDisplay()->SetBaseForMarker();
while (AScale > ALimit && AScale >= 1.f)
{
const char *str = AWorkspace->GetDisplay()->GetStringForMarker( Aspect_TOM_O, AScale );
glCallLists( strlen( str ), GL_UNSIGNED_BYTE, (const GLubyte *) str );
AScale -= ADelta;
}
break;
}
case Aspect_TOM_USERDEFINED :
{
glCallList( openglDisplay->GetUserMarkerListIndex( (int)aspect_marker->Scale() ) );
break;
}
default :
{
AWorkspace->GetDisplay()->SetBaseForMarker();
const char *str = AWorkspace->GetDisplay()->GetStringForMarker( aspect_marker->Type(), aspect_marker->Scale() );
glCallLists( strlen( str ), GL_UNSIGNED_BYTE, (const GLubyte *)str );
}
}
GLint mode;
glGetIntegerv( GL_RENDER_MODE, &mode );
if( mode==GL_FEEDBACK )
{
glBegin( GL_POINTS );
glVertex3fv( myPoint.xyz );
glEnd();
/* it is necessary to indicate end of marker information*/
}
}
}
}
/*----------------------------------------------------------------------*/

30
src/OpenGl/OpenGl_Marker.hxx Normal file
View File

@ -0,0 +1,30 @@
// File: OpenGl_Marker.hxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef OpenGl_Marker_Header
#define OpenGl_Marker_Header
#include <InterfaceGraphic_telem.hxx>
#include <OpenGl_Element.hxx>
class OpenGl_Marker : public OpenGl_Element
{
public:
OpenGl_Marker (const TEL_POINT &APoint) : myPoint(APoint) {}
virtual ~OpenGl_Marker () {}
virtual void Render (const Handle(OpenGl_Workspace) &AWorkspace) const;
protected:
TEL_POINT myPoint;
public:
IMPLEMENT_MEMORY_OPERATORS
};
#endif //OpenGl_Marker_Header

129
src/OpenGl/OpenGl_MarkerSet.cxx Normal file
View File

@ -0,0 +1,129 @@
// File: OpenGl_MarkerSet.cxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_MarkerSet.hxx>
#include <OpenGl_tgl_all.hxx>
#include <GL/gl.h>
#include <OpenGl_AspectMarker.hxx>
#include <OpenGl_Structure.hxx>
#include <OpenGl_Display.hxx>
/*----------------------------------------------------------------------*/
OpenGl_MarkerSet::OpenGl_MarkerSet (const Standard_Integer ANbPoints, const Graphic3d_Vertex *APoints)
: myNbPoints(ANbPoints),
myPoints(new TEL_POINT[ANbPoints])
{
memcpy( myPoints, APoints, ANbPoints*sizeof(TEL_POINT) );
}
/*----------------------------------------------------------------------*/
OpenGl_MarkerSet::~OpenGl_MarkerSet ()
{
if (myPoints)
delete[] myPoints;
}
/*----------------------------------------------------------------------*/
void OpenGl_MarkerSet::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
{
const OpenGl_AspectMarker *aspect_marker = AWorkspace->AspectMarker( Standard_True );
// Use highlight colors
glColor3fv( (AWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT)? AWorkspace->HighlightColor->rgb : aspect_marker->Color().rgb );
const TEL_POINT *ptr;
Tint i;
switch ( aspect_marker->Type() )
{
case Aspect_TOM_O_POINT :
{
const char *str = AWorkspace->GetDisplay()->GetStringForMarker( Aspect_TOM_O, aspect_marker->Scale() );
AWorkspace->GetDisplay()->SetBaseForMarker();
for( i = 0, ptr = myPoints; i < myNbPoints; i++, ptr++ )
{
glRasterPos3fv( ptr->xyz );
glCallLists( strlen( str ), GL_UNSIGNED_BYTE, (const GLubyte *) str );
}
}
case Aspect_TOM_POINT :
{
glPointSize( aspect_marker->Scale() );
glBegin( GL_POINTS );
for( i = 0, ptr = myPoints; i < myNbPoints; i++, ptr++ )
glVertex3fv( ptr->xyz );
glEnd();
break;
}
default:
{
switch ( aspect_marker->Type() )
{
case Aspect_TOM_RING1 :
case Aspect_TOM_RING2 :
case Aspect_TOM_RING3 :
{
const float ADelta = 0.1f;
float AScale = aspect_marker->Scale();
float ALimit = 0.f;
if (aspect_marker->Type() == Aspect_TOM_RING1)
ALimit = AScale * 0.2f;
else if (aspect_marker->Type() == Aspect_TOM_RING2)
ALimit = AScale * 0.5f;
else
ALimit = AScale * 0.8f;
AWorkspace->GetDisplay()->SetBaseForMarker();
for( i = 0, ptr = myPoints; i < myNbPoints; i++, ptr++ )
{
glRasterPos3fv( ptr->xyz );
AScale = aspect_marker->Scale();
while (AScale > ALimit && AScale >= 1.f)
{
const char *str = AWorkspace->GetDisplay()->GetStringForMarker( Aspect_TOM_O, AScale );
glCallLists( strlen( str ), GL_UNSIGNED_BYTE, (const GLubyte *) str );
AScale -= ADelta;
}
}
break;
}
case Aspect_TOM_USERDEFINED :
{
for( i = 0, ptr = myPoints; i < myNbPoints; i++, ptr++ )
{
glRasterPos3fv( ptr->xyz );
glCallList( openglDisplay->GetUserMarkerListIndex( (int)aspect_marker->Scale() ) );
}
break;
}
default :
{
AWorkspace->GetDisplay()->SetBaseForMarker();
const char *str = AWorkspace->GetDisplay()->GetStringForMarker( aspect_marker->Type(), aspect_marker->Scale() );
for( i = 0, ptr = myPoints; i < myNbPoints; i++, ptr++ )
{
glRasterPos3fv( ptr->xyz );
glCallLists( strlen( str ), GL_UNSIGNED_BYTE, (const GLubyte *) str );
}
}
}
GLint mode;
glGetIntegerv( GL_RENDER_MODE, &mode );
if( mode==GL_FEEDBACK )
{
glBegin( GL_POINTS );
for( i = 0, ptr = myPoints; i < myNbPoints; i++, ptr++ )
glVertex3fv( ptr->xyz );
glEnd();
}
}
}
}
/*----------------------------------------------------------------------*/

33
src/OpenGl/OpenGl_MarkerSet.hxx Normal file
View File

@ -0,0 +1,33 @@
// File: OpenGl_MarkerSet.hxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef OpenGl_MarkerSet_Header
#define OpenGl_MarkerSet_Header
#include <InterfaceGraphic_telem.hxx>
#include <OpenGl_Element.hxx>
#include <Graphic3d_Vertex.hxx>
class OpenGl_MarkerSet : public OpenGl_Element
{
public:
OpenGl_MarkerSet (const Standard_Integer ANbPoints, const Graphic3d_Vertex *APoints);
virtual ~OpenGl_MarkerSet ();
virtual void Render (const Handle(OpenGl_Workspace) &AWorkspace) const;
protected:
Tint myNbPoints;
TEL_POINT *myPoints;
public:
IMPLEMENT_MEMORY_OPERATORS
};
#endif //OpenGl_MarkerSet_Header

31
src/OpenGl/OpenGl_Matrix.cxx Normal file
View File

@ -0,0 +1,31 @@
// File: OpenGl_Matrix.cxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#include <OpenGl_Matrix.hxx>
/*----------------------------------------------------------------------*/
void OpenGl_Multiplymat3 (OpenGl_Matrix *c, const OpenGl_Matrix *a, const OpenGl_Matrix *b)
{
int row, col, i;
for (row = 0; row < 4; row++) {
for (col = 0; col < 4; col++) {
float sum = 0.F;
for (i = 0; i < 4; i++)
sum += a->mat[row][i] * b->mat[i][col];
c->mat[row][col] = sum;
}
}
}
/*----------------------------------------------------------------------*/
void OpenGl_Transposemat3 (OpenGl_Matrix *c, const OpenGl_Matrix *a)
{
Tint row, col;
for (row = 0; row < 4; row++)
for (col = 0; col < 4; col++)
c->mat[row][col] = a->mat[col][row];
}

20
src/OpenGl/OpenGl_Matrix.hxx Normal file
View File

@ -0,0 +1,20 @@
// File: OpenGl_Matrix.hxx
// Created: 20 September 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef OpenGl_Matrix_Header
#define OpenGl_Matrix_Header
#include <InterfaceGraphic_telem.hxx>
struct OpenGl_Matrix
{
float mat[4][4];
IMPLEMENT_MEMORY_OPERATORS
};
Standard_EXPORT void OpenGl_Multiplymat3 (OpenGl_Matrix *c, const OpenGl_Matrix *a, const OpenGl_Matrix *b);
Standard_EXPORT void OpenGl_Transposemat3 (OpenGl_Matrix *c, const OpenGl_Matrix *a);
#endif //OpenGl_Matrix_Header

6
src/OpenGl/OpenGl_Memory.cxx
View File

@ -1,6 +0,0 @@
#include <OpenGl_Memory.hxx>
OpenGl_MemoryMgr::OpenGl_MemoryMgr(){}
OpenGl_MemoryMgr::OpenGl_MemoryMgr(const OpenGl_MemoryMgr&){}
OpenGl_MemoryMgr::~OpenGl_MemoryMgr(){}

14
src/OpenGl/OpenGl_Memory.hxx
View File

@ -2,13 +2,6 @@
#define OPENGL_MEMORY_H #define OPENGL_MEMORY_H
#include <OpenGl_tgl_all.hxx> #include <OpenGl_tgl_all.hxx>
#include <Standard_TypeDef.hxx>
#include <NCollection_DataMap.hxx>
#include <NCollection_Stack.hxx>
#include <NCollection_List.hxx>
#include <NCollection_Array1.hxx>
#include <NCollection_Vector.hxx>
template <class XType> XType *cmn_resizemem( XType *ptr, Tint size ) template <class XType> XType *cmn_resizemem( XType *ptr, Tint size )
{ {
@ -24,11 +17,4 @@ template <class XType> XType *cmn_resizemem( XType *ptr, Tint size )
return ptr; return ptr;
} }
class OpenGl_MemoryMgr {
private:
OpenGl_MemoryMgr();
OpenGl_MemoryMgr(const OpenGl_MemoryMgr&);
~OpenGl_MemoryMgr();
};
#endif //OPENGL_MEMORY_H #endif //OPENGL_MEMORY_H

925
src/OpenGl/OpenGl_Mesh.cxx Normal file
View File

@ -0,0 +1,925 @@
// File: OpenGl_Mesh.cxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#define OCC749 /* SAV 19/09/02 added processing of colored vertices */
#define OCC7824 /* ASL 26/01/05 transparency of polygon with colors assigned to vertices */
/*----------------------------------------------------------------------*/
/*
* Includes
*/
#include <OpenGl_tgl_all.hxx>
#include <GL/gl.h>
#include <OpenGl_Mesh.hxx>
#include <OpenGl_telem_util.hxx>
#include <OpenGl_TextureBox.hxx>
#include <OpenGl_AspectFace.hxx>
#include <OpenGl_Structure.hxx>
#include <float.h>
static long s_Rand = 1L;
# define OPENGL_RAND() ( ( unsigned )( s_Rand = s_Rand * 214013L + 2531011L ) )
/*----------------------------------------------------------------------*/
/*
* Prototypes
*/
typedef TEL_INDEXPOLY_DATA* tel_indexpoly_data;
void set_drawable_items ( GLboolean*, int, const float );
/*----------------------------------------------------------------------*/
void OpenGl_Mesh::draw_indexpoly (const Tint front_lighting_model,
const Aspect_InteriorStyle interior_style,
const TEL_COLOUR *edge_colour,
const OPENGL_SURF_PROP *prop,
const Handle(OpenGl_Workspace) &AWorkspace) const
{
Tint i, j, k, a, newList = 0;
Tint lighting_model;
/* Following pointers have been provided for performance improvement */
Tint *ind;
tel_point pfn, pvn, pv;
tel_colour pvc, pfc;
tel_texture_coord pvt;
ind = myData.indices;
pfn = myData.fnormals;
pvn = myData.vnormals;
pvc = myData.vcolours;
pfc = myData.fcolours;
pv = myData.vertices;
pvt = myData.vtexturecoord;
if ( AWorkspace->DegenerateModel < 2 && interior_style != Aspect_IS_EMPTY )
{
if ( AWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT )
{
pvc = 0;
pfc = 0;
}
if ( interior_style == Aspect_IS_HIDDENLINE)
{
pvc = 0;
pfc = 0;
}
if ( front_lighting_model )
glEnable(GL_LIGHTING);
else
glDisable(GL_LIGHTING);
lighting_model = front_lighting_model;
if ( (AWorkspace->NamedStatus & OPENGL_NS_ANIMATION) == 0 )
goto doDraw; /* Disable object display list out of animation */
/* window's context and bitmap's one */
if ( myDS->model != lighting_model || !myDS->list ||
myDS->model == -1 || ( AWorkspace->DegenerateModel && myDS->skipRatio != AWorkspace->SkipRatio ))
{
myDS->skipRatio = AWorkspace->SkipRatio;
myDS->model = lighting_model;
myDS->degMode = AWorkspace->DegenerateModel;
if ( AWorkspace->SkipRatio <= 0.f ) {
if ( !myDS->list ) myDS->list = glGenLists ( 1 );
glNewList ( myDS->list, GL_COMPILE_AND_EXECUTE );
newList = 1;
doDraw:
if ( !lighting_model )
{
if ( myData.num_bounds == 3 )
glBegin ( GL_TRIANGLES );
else if ( myData.num_bounds == 4 )
glBegin ( GL_QUADS );
else glBegin ( GL_POLYGON );
if ( pvc )
{
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i )
{
a = j + myData.num_bounds;
for ( ; j < a; ++j )
{
glColor3fv ( pvc[ ind[ j ] ].rgb );
glVertex3fv ( pv[ ind[ j ] ].xyz );
}
}
}
else if ( pfc )
{
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i )
{
a = j + myData.num_bounds;
glColor3fv ( pfc[ i ].rgb );
for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
}
}
else
{
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i )
{
a = j + myData.num_bounds;
for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
}
}
glEnd ();
}
else
{
/* lighting_model != TelLModelNone */
if ( myData.num_bounds == 3 )
glBegin ( GL_TRIANGLES );
else if ( myData.num_bounds == 4 )
glBegin ( GL_QUADS );
else glBegin ( GL_POLYGON );
#ifdef OCC749
for ( i = a = 0; i < myData.num_facets; ++i ) {
j = a; a += myData.num_bounds;
if( pfn ) glNormal3fv ( pfn[ i ].xyz );
if( pfc && !prop->isphysic ) {
GLfloat diff[4], ambi[4], emsv[4], r, g, b;
ambi[3] = diff[3] = emsv[3] = prop->trans;
r = pfc[ i ].rgb[0]; g = pfc[ i ].rgb[1]; b = pfc[ i ].rgb[2];
if( prop->color_mask & OPENGL_AMBIENT_MASK ) {
ambi[0] = prop->amb * r;
ambi[1] = prop->amb * g;
ambi[2] = prop->amb * b;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambi);
}
if( prop->color_mask & OPENGL_DIFFUSE_MASK ) {
diff[0] = prop->diff * r;
diff[1] = prop->diff * g;
diff[2] = prop->diff * b;
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diff);
}
if( prop->color_mask & OPENGL_EMISSIVE_MASK ) {
emsv[0] = prop->emsv * r;
emsv[1] = prop->emsv * g;
emsv[2] = prop->emsv * b;
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emsv);
}
}
for ( ; j < a; ++j ) {
k = ind[ j ];
if( pvn ) glNormal3fv ( pvn[ k ].xyz );
if( pvc && !prop->isphysic ) {
GLfloat diff[4], ambi[4], emsv[4], r, g, b;
ambi[3] = diff[3] = emsv[3] = prop->trans;
r = pvc[ k ].rgb[0]; g = pvc[ k ].rgb[1]; b = pvc[ k ].rgb[2];
if( prop->color_mask & OPENGL_AMBIENT_MASK ) {
ambi[0] = prop->amb * r;
ambi[1] = prop->amb * g;
ambi[2] = prop->amb * b;
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambi);
}
if( prop->color_mask & OPENGL_DIFFUSE_MASK ) {
diff[0] = prop->diff * r;
diff[1] = prop->diff * g;
diff[2] = prop->diff * b;
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diff);
}
if( prop->color_mask & OPENGL_EMISSIVE_MASK ) {
emsv[0] = prop->emsv * r;
emsv[1] = prop->emsv * g;
emsv[2] = prop->emsv * b;
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emsv);
}
}
if( pvt && (AWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0 ) glTexCoord2fv ( pvt[ k ].xy );
glVertex3fv ( pv[ k ].xyz );
} /* end for ( j . . . ) */
} /* end for ( i . . . ) */
glEnd ();
#else
if ( pvn ) {
if ( pvt && (AWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0 )
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
a = j + myData.num_bounds;
for ( ; j < a; ++j ) {
glNormal3fv ( pvn[ ind[ j ] ].xyz );
glTexCoord2fv ( pvt[ ind[ j ] ].xy );
glVertex3fv ( pv[ ind[ j ] ].xyz );
} /* end for ( j . . . ) */
} /* end for ( i . . . ) */
else
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
a = j + myData.num_bounds;
for ( ; j < a; ++j ) {
glNormal3fv ( pvn[ ind[ j ] ].xyz );
glVertex3fv ( pv[ ind[ j ] ].xyz );
} /* end for ( j . . . ) */
} /* end for ( i . . . ) */
} else { /* !pvn */
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
a = j + myData.num_bounds;
glNormal3fv ( pfn[ i ].xyz );
for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
} /* end for */
} /* end else */
glEnd ();
#endif /* OCC749 */
} /* end else */
} else if ( AWorkspace->SkipRatio < 1.f ) {
if ( !myDS->dlist ) myDS->dlist = glGenLists ( 1 );
glNewList ( myDS->dlist, GL_COMPILE_AND_EXECUTE );
newList = 1;
set_drawable_items ( myDS->bDraw, myData.num_facets, AWorkspace->SkipRatio );
if ( !lighting_model ) {
if ( myData.num_bounds == 3 )
glBegin ( GL_TRIANGLES );
else if ( myData.num_bounds == 4 )
glBegin ( GL_QUADS );
else glBegin ( GL_POLYGON );
if ( pvc ) {
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
a = j + myData.num_bounds;
if ( myDS->bDraw[ i ] )
for ( ; j < a; ++j ) {
glColor3fv ( pvc[ ind[ j ] ].rgb );
glVertex3fv ( pv[ ind[ j ] ].xyz );
} /* end for ( j . . . ) */
else j = a;
} /* end for ( i . . . ) */
} else if ( pfc ) {
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
a = j + myData.num_bounds;
if ( myDS->bDraw[ i ] ) {
glColor3fv ( pfc[ i ].rgb );
for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
} else j = a;
} /* end for */
} else {
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
a = j + myData.num_bounds;
if ( myDS->bDraw[ i ] )
for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
else j = a;
} /* end for */
} /* end else */
glEnd ();
} else { /* lighting_model != TelLModelNone */
if ( myData.num_bounds == 3 )
glBegin ( GL_TRIANGLES );
else if ( myData.num_bounds == 4 )
glBegin ( GL_QUADS );
else glBegin ( GL_POLYGON );
if ( pvn ) {
if ( pvt && (AWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0 )
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
a = j + myData.num_bounds;
if ( myDS->bDraw[ i ] )
for ( ; j < a; ++j ) {
glNormal3fv ( pvn[ ind[ j ] ].xyz );
glTexCoord2fv ( pvt[ ind[ j ] ].xy );
glVertex3fv ( pv[ ind[ j ] ].xyz );
} /* end for ( j . . . ) */
else j = a;
} /* end for ( i . . . ) */
else
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
a = j + myData.num_bounds;
if ( myDS->bDraw[ i ] )
for ( ; j < a; ++j ) {
glNormal3fv ( pvn[ ind[ j ] ].xyz );
glVertex3fv ( pv[ ind[ j ] ].xyz );
} /* end for ( j . . . ) */
else j = a;
} /* end for ( i . . . ) */
} else { /* !pvn */
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
a = j + myData.num_bounds;
if ( myDS->bDraw[ i ] ) {
glNormal3fv ( pfn[ i ].xyz );
for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
} else j = a;
} /* end for */
} /* end else */
glEnd ();
} /* end else */
} else {
if ( !myDS->dlist ) myDS->dlist = glGenLists ( 1 );
glNewList ( myDS->dlist, GL_COMPILE_AND_EXECUTE );
newList = 1;
} /* end else */
if ( newList ) glEndList ();
if ( AWorkspace->DegenerateModel ) return;
} else {
glCallList ( AWorkspace->SkipRatio <= 0.f ? myDS->list : myDS->dlist );
if ( AWorkspace->DegenerateModel ) return;
} /* end else */
}
i = 0;
switch ( AWorkspace->DegenerateModel )
{
default:
break;
case 2: /* XXX_TDM_WIREFRAME */
i = 1;
break;
case 3: /* XXX_TDM_MARKER */
draw_degenerates_as_points ( AWorkspace->SkipRatio );
return;
case 4: /* XXX_TDM_BBOX */
draw_degenerates_as_bboxs ();
return;
}
draw_edges ( edge_colour, interior_style, i, AWorkspace );
}
/*----------------------------------------------------------------------*/
void OpenGl_Mesh::draw_edges (const TEL_COLOUR *edge_colour, const Aspect_InteriorStyle interior_style,
Tint forceDraw, const Handle(OpenGl_Workspace) &AWorkspace) const
{
const OpenGl_AspectFace *aspect_face = AWorkspace->AspectFace( Standard_True );
if ( interior_style != Aspect_IS_HIDDENLINE && !forceDraw && aspect_face->Context().Edge == TOff )
return;
glDisable(GL_LIGHTING);
const GLboolean texture_on = IsTextureEnabled();
if (texture_on) DisableTexture();
// Setup line aspect
const OpenGl_AspectLine *aspect_line_old = AWorkspace->SetAspectLine( aspect_face->AspectEdge() );
AWorkspace->AspectLine( Standard_True );
tel_point pv = myData.vertices;
Tint *ind = myData.indices;
Tint *vis = myData.edge_vis;
Tint i, j, a, newList = 0;
if ( !forceDraw ) {
glColor3fv ( edge_colour -> rgb );
glPushAttrib ( GL_POLYGON_BIT );
glPolygonMode ( GL_FRONT_AND_BACK, GL_LINE );
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
a = j + myData.num_bounds;
glBegin ( GL_POLYGON );
for ( ; j < a; ++j ) {
glEdgeFlag ( ( GLboolean )( vis[ j ] == 1 ? GL_TRUE : GL_FALSE ) );
glVertex3fv ( pv[ ind[ j ] ].xyz );
} /* end for */
glEnd();
glEdgeFlag ( GL_TRUE );
} /* end for */
glPopAttrib ();
} else {
if ( (AWorkspace->NamedStatus & OPENGL_NS_ANIMATION) == 0 )
goto doDraw; /* Disable object display list out of animation */
if ( myDS->degMode != 2 || myDS->skipRatio != AWorkspace->SkipRatio || !myDS->dlist ) {
if ( !myDS->dlist ) myDS->dlist = glGenLists ( 1 );
myDS->degMode = 2;
myDS->skipRatio = AWorkspace->SkipRatio;
glNewList ( myDS->dlist, GL_COMPILE_AND_EXECUTE );
newList = 1;
doDraw:
glPushAttrib ( GL_POLYGON_BIT | GL_DEPTH_BUFFER_BIT );
glEdgeFlag ( GL_TRUE );
glDisable ( GL_DEPTH_TEST );
glPolygonMode ( GL_FRONT_AND_BACK, GL_LINE );
if ( AWorkspace->SkipRatio <= 0.f )
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
a = j + myData.num_bounds;
glBegin ( GL_POLYGON );
for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
glEnd();
} /* end for */
else if ( AWorkspace->SkipRatio < 1.f ) {
set_drawable_items ( myDS->bDraw, myData.num_facets, AWorkspace->SkipRatio );
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
a = j + myData.num_bounds;
if ( myDS->bDraw[ i ] ) {
glBegin ( GL_POLYGON );
for ( ; j < a; ++j ) glVertex3fv ( pv[ ind[ j ] ].xyz );
glEnd();
} else j = a;
} /* end for */
} /* end if */
glPopAttrib ();
if ( newList ) glEndList ();
} else glCallList ( myDS->dlist );
} /* end else */
// Restore line context
AWorkspace->SetAspectLine( aspect_line_old );
if (texture_on) EnableTexture();
}
/*----------------------------------------------------------------------*/
void OpenGl_Mesh::draw_degenerates_as_points (const float aSkipRatio) const
{
Tint* ind, *vis;
Tint i, j, n, a, newList = 0;
GLfloat pt[ 3 ];
tel_point pv;
pv = myData.vertices;
ind = myData.indices;
vis = myData.edge_vis;
glDisable(GL_LIGHTING);
if ( myDS->degMode != 3 || myDS->skipRatio != aSkipRatio || !myDS->dlist ) {
if ( !myDS->dlist ) myDS->dlist = glGenLists ( 1 );
myDS->degMode = 3;
myDS->skipRatio = aSkipRatio;
glNewList ( myDS->dlist, GL_COMPILE_AND_EXECUTE );
newList = 1;
if ( aSkipRatio <= 0.f ) {
glBegin ( GL_POINTS );
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
n = myData.num_bounds;
a = j + n;
for ( pt [ 0 ] = pt[ 1 ] = pt[ 2 ] = 0.; j < a; ++j ) {
pt[ 0 ] += pv[ ind[ j ] ].xyz[ 0 ];
pt[ 1 ] += pv[ ind[ j ] ].xyz[ 1 ];
pt[ 2 ] += pv[ ind[ j ] ].xyz[ 2 ];
} /* end for ( j ) */
pt[ 0 ] /= n;
pt[ 1 ] /= n;
pt[ 2 ] /= n;
glVertex3fv ( pt );
} /* end for ( i ) */
glEnd ();
} else if ( aSkipRatio < 1.f ) {
set_drawable_items ( myDS->bDraw, myData.num_facets, aSkipRatio );
glBegin ( GL_POINTS );
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
n = myData.num_bounds;
a = j + n;
if ( myDS->bDraw[ i ] ) {
for ( pt [ 0 ] = pt[ 1 ] = pt[ 2 ] = 0.; j < a; ++j ) {
pt[ 0 ] += pv[ ind[ j ] ].xyz[ 0 ];
pt[ 1 ] += pv[ ind[ j ] ].xyz[ 1 ];
pt[ 2 ] += pv[ ind[ j ] ].xyz[ 2 ];
} /* end for ( j ) */
pt[ 0 ] /= n;
pt[ 1 ] /= n;
pt[ 2 ] /= n;
glVertex3fv ( pt );
} else j = a;
} /* end for ( i ) */
glEnd ();
} /* end if */
glEndList ();
} else glCallList ( myDS->dlist );
}
void OpenGl_Mesh::draw_degenerates_as_bboxs () const
{
Tint* ind, *vis;
Tint i, j, n, a, newList = 0;
GLfloat minp[ 3 ] = { FLT_MAX, FLT_MAX, FLT_MAX };
GLfloat maxp[ 3 ] = { FLT_MIN, FLT_MIN, FLT_MIN };
tel_point pv;
pv = myData.vertices;
ind = myData.indices;
vis = myData.edge_vis;
glDisable(GL_LIGHTING);
if ( myDS->degMode != 4 || !myDS->dlist ) {
if ( !myDS->dlist ) myDS->dlist = glGenLists ( 1 );
myDS->degMode = 4;
glNewList ( myDS->dlist, GL_COMPILE_AND_EXECUTE );
newList = 1;
for ( i = 0, j = 0, a = 0; i < myData.num_facets; ++i ) {
n = myData.num_bounds;
a = j + n;
for ( ; j < a; ++j ) {
if ( pv[ ind[ j ] ].xyz[ 0 ] < minp[ 0 ] )
minp[ 0 ] = pv[ ind[ j ] ].xyz[ 0 ] ;
if ( pv[ ind[ j ] ].xyz[ 1 ] < minp[ 1 ] )
minp[ 1 ] = pv[ ind[ j ] ].xyz[ 1 ] ;
if ( pv[ ind[ j ] ].xyz[ 2 ] < minp[ 2 ] )
minp[ 2 ] = pv[ ind[ j ] ].xyz[ 2 ] ;
if ( pv[ ind[ j ] ].xyz[ 0 ] > maxp[ 0 ] )
maxp[ 0 ] = pv[ ind[ j ] ].xyz[ 0 ] ;
if ( pv[ ind[ j ] ].xyz[ 1 ] > maxp[ 1 ] )
maxp[ 1 ] = pv[ ind[ j ] ].xyz[ 1 ] ;
if ( pv[ ind[ j ] ].xyz[ 2 ] > maxp[ 2 ] )
maxp[ 2 ] = pv[ ind[ j ] ].xyz[ 2 ] ;
} /* end for ( j ) */
} /* end for ( i ) */
/* OCC11904 -- Temporarily disable environment mapping */
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_TEXTURE_1D);
glDisable(GL_TEXTURE_2D);
glBegin ( GL_LINE_STRIP );
glVertex3fv ( minp );
glVertex3f ( minp[ 0 ], maxp[ 1 ], minp[ 2 ] );
glVertex3f ( minp[ 0 ], maxp[ 1 ], maxp[ 2 ] );
glVertex3f ( minp[ 0 ], minp[ 1 ], maxp[ 2 ] );
glVertex3f ( minp[ 0 ], minp[ 1 ], minp[ 2 ] );
glVertex3f ( maxp[ 0 ], minp[ 1 ], minp[ 2 ] );
glVertex3f ( maxp[ 0 ], maxp[ 1 ], minp[ 2 ] );
glVertex3f ( maxp[ 0 ], maxp[ 1 ], maxp[ 2 ] );
glVertex3f ( maxp[ 0 ], minp[ 1 ], maxp[ 2 ] );
glVertex3f ( maxp[ 0 ], minp[ 1 ], minp[ 2 ] );
glVertex3f ( maxp[ 0 ], minp[ 1 ], maxp[ 2 ] );
glVertex3f ( minp[ 0 ], minp[ 1 ], maxp[ 2 ] );
glVertex3f ( minp[ 0 ], maxp[ 1 ], maxp[ 2 ] );
glVertex3fv ( maxp );
glVertex3f ( maxp[ 0 ], maxp[ 1 ], minp[ 2 ] );
glVertex3f ( minp[ 0 ], maxp[ 1 ], minp[ 2 ] );
glEnd();
glPopAttrib();
glEndList ();
} else glCallList ( myDS->dlist );
}
/*----------------------------------------------------------------------*/
void set_drawable_items ( GLboolean* pbDraw, int n, const float aSkipRatio )
{
memset ( pbDraw, 0, sizeof ( GLboolean ) * n );
int i = ( int )( ( 1.0F - aSkipRatio ) * n );
while ( i-- ) pbDraw[ OPENGL_RAND() % n ] = 1;
}
/*----------------------------------------------------------------------*/
OpenGl_Mesh::OpenGl_Mesh (const Graphic3d_Array1OfVertex& AListVertex, const Aspect_Array1OfEdge& AListEdge)
{
const Standard_Integer nv = AListVertex.Length();
// Dynamic allocation
TEL_POINT *points = new TEL_POINT[nv];
memcpy( points, &AListVertex(AListVertex.Lower()), nv*sizeof(TEL_POINT) );
Init (nv,points,NULL,NULL,NULL,AListEdge,3);
}
/*----------------------------------------------------------------------*/
OpenGl_Mesh::OpenGl_Mesh (const Graphic3d_Array1OfVertexN& AListVertex, const Aspect_Array1OfEdge& AListEdge)
{
const Standard_Integer nv = AListVertex.Length ();
// Dynamic allocation
TEL_POINT *points = new TEL_POINT[nv];
TEL_POINT *normals = new TEL_POINT[nv];
Standard_Integer i = 0, j = AListVertex.Lower();
Standard_Real X, Y, Z;
for ( ; i < nv; i++, j++)
{
AListVertex(j).Coord(X, Y, Z);
points[i].xyz[0] = float (X);
points[i].xyz[1] = float (Y);
points[i].xyz[2] = float (Z);
AListVertex(j).Normal(X, Y, Z);
normals[i].xyz[0] = float (X);
normals[i].xyz[1] = float (Y);
normals[i].xyz[2] = float (Z);
}
Init (nv,points,normals,NULL,NULL,AListEdge,3);
}
/*----------------------------------------------------------------------*/
OpenGl_Mesh::OpenGl_Mesh (const Graphic3d_Array1OfVertexC& AListVertex, const Aspect_Array1OfEdge& AListEdge)
{
const Standard_Integer nv = AListVertex.Length ();
// Dynamic allocation
TEL_POINT *points = new TEL_POINT[nv];
TEL_COLOUR *colors = new TEL_COLOUR[nv];
Standard_Integer i = 0, j = AListVertex.Lower();
Standard_Real X, Y, Z;
for ( ; i < nv; i++, j++)
{
AListVertex(j).Coord(X, Y, Z);
points[i].xyz[0] = float (X);
points[i].xyz[1] = float (Y);
points[i].xyz[2] = float (Z);
AListVertex(j).Color().Values (X, Y, Z, Quantity_TOC_RGB);
colors[i].rgb[0] = float (X);
colors[i].rgb[1] = float (Y);
colors[i].rgb[2] = float (Z);
colors[i].rgb[3] = 1.0F;
}
Init (nv,points,NULL,colors,NULL,AListEdge,3);
}
/*----------------------------------------------------------------------*/
OpenGl_Mesh::OpenGl_Mesh (const Graphic3d_Array1OfVertexNC& AListVertex, const Aspect_Array1OfEdge& AListEdge)
{
const Standard_Integer nv = AListVertex.Length ();
// Dynamic allocation
TEL_POINT *points = new TEL_POINT[nv];
TEL_POINT *normals = new TEL_POINT[nv];
TEL_COLOUR *colors = new TEL_COLOUR[nv];
Standard_Integer i = 0, j = AListVertex.Lower();
Standard_Real X, Y, Z;
for ( ; i < nv; i++, j++)
{
AListVertex(j).Coord(X, Y, Z);
points[i].xyz[0] = float (X);
points[i].xyz[1] = float (Y);
points[i].xyz[2] = float (Z);
AListVertex(j).Normal(X, Y, Z);
normals[i].xyz[0] = float (X);
normals[i].xyz[1] = float (Y);
normals[i].xyz[2] = float (Z);
AListVertex(j).Color().Values (X, Y, Z, Quantity_TOC_RGB);
colors[i].rgb[0] = float (X);
colors[i].rgb[1] = float (Y);
colors[i].rgb[2] = float (Z);
colors[i].rgb[3] = 1.0F;
}
Init (nv,points,normals,colors,NULL,AListEdge,3);
}
/*----------------------------------------------------------------------*/
OpenGl_Mesh::OpenGl_Mesh (const Graphic3d_Array1OfVertexNT& AListVertex, const Aspect_Array1OfEdge& AListEdge)
{
const Standard_Integer nv = AListVertex.Length ();
// Dynamic allocation
TEL_POINT *points = new TEL_POINT[nv];
TEL_POINT *normals = new TEL_POINT[nv];
TEL_TEXTURE_COORD *tcoords = new TEL_TEXTURE_COORD[nv];
Standard_Integer i = 0, j = AListVertex.Lower();
Standard_Real X, Y, Z;
for ( ; i < nv; i++, j++)
{
AListVertex(j).Coord(X, Y, Z);
points[i].xyz[0] = float (X);
points[i].xyz[1] = float (Y);
points[i].xyz[2] = float (Z);
AListVertex(j).Normal(X, Y, Z);
normals[i].xyz[0] = float (X);
normals[i].xyz[1] = float (Y);
normals[i].xyz[2] = float (Z);
AListVertex(j).TextureCoordinate(X, Y);
tcoords[i].xy[0] = float(X);
tcoords[i].xy[1] = float(Y);
}
Init (nv,points,normals,NULL,tcoords,AListEdge,3);
}
/*----------------------------------------------------------------------*/
void OpenGl_Mesh::Init (const Tint ANbVertices, tel_point AVertices,
tel_point AVNormals, tel_colour AVColors, tel_texture_coord ATCoords,
const Aspect_Array1OfEdge& AListEdge, const Tint ANbBounds)
{
// Get number of bounds in a facet
myData.num_bounds = ANbBounds;
// Get number of vertices
myData.num_vertices = ANbVertices;
// Get vertices
myData.vertices = AVertices;
// Get number of edges
const Standard_Integer nb_edges = AListEdge.Length ();
myData.indices = new Tint[nb_edges];
myData.edge_vis = new Tint[nb_edges];
const Standard_Integer LowerE = AListEdge.Lower ();
const Standard_Integer UpperE = AListEdge.Upper ();
// Loop on edges
Standard_Integer i, j;
for (j=0, i=LowerE; i<=UpperE; i++, j++)
{
myData.indices[j] = AListEdge(i).FirstIndex() - LowerE; //LastIndex unused
myData.edge_vis[j] = AListEdge(i).Type() ? TOff : TOn;
}
// Get number of facets
myData.num_facets = nb_edges / ANbBounds;
myData.vnormals = AVNormals;
if (AVNormals)
{
myData.vertex_flag = TEL_VT_NORMAL;
for( i = 0; i < ANbVertices; i++ )
vecnrm( myData.vnormals[i].xyz );
}
else
{
myData.vertex_flag = TEL_VT_NONE;
}
myData.vcolours = AVColors;
myData.vtexturecoord = ATCoords;
myData.facet_flag = TEL_FA_NONE;
myData.fnormals = new TEL_POINT[myData.num_facets];
for( i = 0, j = 0; i < myData.num_facets; i++ )
{
TelGetPolygonNormal( myData.vertices, &myData.indices[j], myData.num_bounds, myData.fnormals[i].xyz );
j += myData.num_bounds;
}
myData.fcolours = NULL;
myDS = new DS_INTERNAL();
myDS->list = 0;
myDS->dlist = 0;
myDS->degMode = 0;
myDS->model = -1;
myDS->skipRatio = 0.0F;
myDS->bDraw = new unsigned char[myData.num_facets];
}
/*----------------------------------------------------------------------*/
OpenGl_Mesh::~OpenGl_Mesh ()
{
if( myData.edge_vis )
delete[] myData.edge_vis;
if( myData.indices )
delete[] myData.indices;
if( myData.fcolours )
delete[] myData.fcolours;
if( myData.fnormals )
delete[] myData.fnormals;
if( myData.vertices )
delete[] myData.vertices;
if( myData.vcolours )
delete[] myData.vcolours;
if( myData.vnormals )
delete[] myData.vnormals;
if( myData.vtexturecoord )
delete[] myData.vtexturecoord;
if ( myDS )
{
if ( GET_GL_CONTEXT() != NULL )
{
if ( myDS->list ) glDeleteLists ( myDS->list, 1 );
if ( myDS->dlist ) glDeleteLists ( myDS->dlist, 1 );
}
if ( myDS->bDraw )
delete[] myDS->bDraw;
delete myDS;
}
}
/*----------------------------------------------------------------------*/
void OpenGl_Mesh::Render (const Handle(OpenGl_Workspace) &AWorkspace) const
{
const OpenGl_AspectFace *aspect_face = AWorkspace->AspectFace( Standard_True );
Tint front_lighting_model = aspect_face->Context().IntFront.color_mask;
const TEL_COLOUR *interior_colour = &aspect_face->Context().IntFront.matcol;
const TEL_COLOUR *edge_colour = &aspect_face->AspectEdge()->Color();
// Use highlight colors
if ( AWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT )
{
edge_colour = interior_colour = AWorkspace->HighlightColor;
front_lighting_model = 0;
}
glColor3fv( interior_colour->rgb );
draw_indexpoly( front_lighting_model,
aspect_face->Context().InteriorStyle,
edge_colour,
&aspect_face->Context().IntFront,
AWorkspace );
}
/*----------------------------------------------------------------------*/

78
src/OpenGl/OpenGl_Mesh.hxx Normal file
View File

@ -0,0 +1,78 @@
// File: OpenGl_Mesh.hxx
// Created: 13 July 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef OpenGl_Mesh_Header
#define OpenGl_Mesh_Header
#include <InterfaceGraphic_telem.hxx>
#include <Graphic3d_Array1OfVertex.hxx>
#include <Graphic3d_Array1OfVertexN.hxx>
#include <Graphic3d_Array1OfVertexC.hxx>
#include <Graphic3d_Array1OfVertexNC.hxx>
#include <Graphic3d_Array1OfVertexNT.hxx>
#include <Aspect_Array1OfEdge.hxx>
#include <Aspect_InteriorStyle.hxx>
#include <OpenGl_Element.hxx>
#include <OpenGl_AspectFace.hxx>
struct TEL_INDEXPOLY_DATA
{
Tint num_vertices; /* Number of vertices */
Tint num_facets; /* Number of facets (triangles, quadrangles or polygons) */
Tint num_bounds; /* Number of bounds in a facet (3, 4 or more) */
Tint facet_flag; /* TEL_FA_NONE or TEL_FA_NORMAL */
Tint vertex_flag; /* TEL_VT_NONE or TEL_VT_NORMAL */
Tint *edge_vis; /* Edge visibility indicators for each edge */
Tint *indices; /* Connectivity array */
tel_point fnormals; /* Facet normals */
tel_colour fcolours; /* Facet colour values */
tel_point vertices; /* Vertices */
tel_colour vcolours; /* Vertex colour values */
tel_point vnormals; /* Vertex normals */
tel_texture_coord vtexturecoord; /* Texture Coordinates */
IMPLEMENT_MEMORY_OPERATORS
};
class OpenGl_Mesh : public OpenGl_Element
{
public:
OpenGl_Mesh (const Graphic3d_Array1OfVertex& AListVertex, const Aspect_Array1OfEdge& AListEdge);
OpenGl_Mesh (const Graphic3d_Array1OfVertexN& AListVertex, const Aspect_Array1OfEdge& AListEdge);
OpenGl_Mesh (const Graphic3d_Array1OfVertexC& AListVertex, const Aspect_Array1OfEdge& AListEdge);
OpenGl_Mesh (const Graphic3d_Array1OfVertexNC& AListVertex, const Aspect_Array1OfEdge& AListEdge);
OpenGl_Mesh (const Graphic3d_Array1OfVertexNT& AListVertex, const Aspect_Array1OfEdge& AListEdge);
virtual ~OpenGl_Mesh ();
virtual void Render (const Handle(OpenGl_Workspace) &AWorkspace) const;
protected:
void Init (const Tint ANbVertices, tel_point AVertices,
tel_point AVNormals, tel_colour AVColors, tel_texture_coord ATCoords,
const Aspect_Array1OfEdge& AListEdge, const Tint ANbBounds);
void draw_indexpoly (const Tint, /* front_lighting_model, */
const Aspect_InteriorStyle, /* interior_style, */
const TEL_COLOUR *, /* edge_colour, */
const OPENGL_SURF_PROP *,
const Handle(OpenGl_Workspace) &) const;
void draw_degenerates_as_points (const float) const;
void draw_degenerates_as_bboxs () const;
void draw_edges (const TEL_COLOUR *, const Aspect_InteriorStyle, Tint, const Handle(OpenGl_Workspace) &) const;
TEL_INDEXPOLY_DATA myData;
DS_INTERNAL *myDS;
public:
IMPLEMENT_MEMORY_OPERATORS
};
#endif //OpenGl_Mesh_Header

29
src/OpenGl/OpenGl_NamedStatus.hxx Normal file
View File

@ -0,0 +1,29 @@
// File: OpenGl_NamedStatus.hxx
// Created: 20 September 2011
// Author: Sergey ZERCHANINOV
// Copyright: OPEN CASCADE 2011
#ifndef _OpenGl_NamedStatus_Header
#define _OpenGl_NamedStatus_Header
// Dynamic fields
#define OPENGL_NS_HIDE (1<<0)
#define OPENGL_NS_PICK (1<<1)
#define OPENGL_NS_HIGHLIGHT (1<<2)
#define OPENGL_NS_WIREFRAME (1<<3)
#define OPENGL_NS_RESMAT (1<<4)
#define OPENGL_NS_ADD (1<<5)
#define OPENGL_NS_IMMEDIATE (1<<6)
#define OPENGL_NS_TEXTURE (1<<7)
#define OPENGL_NS_ANTIALIASING (1<<8)
#define OPENGL_NS_ANIMATION (1<<9)
#define OPENGL_NS_UPDATEAM (1<<10)
#define OPENGL_NS_DEGENERATION (1<<11)
#define OPENGL_NS_2NDPASSNEED (1<<12)
#define OPENGL_NS_2NDPASSDO (1<<13)
#define OPENGL_NS_FORBIDSETTEX (1<<14)
#define OPENGL_NS_FLIST (1<<15)
#define OPENGL_NS_WHITEBACK (1<<16)
#define OPENGL_NS_ISBITMAP (1<<17)
#endif //_OpenGl_NamedStatus_Header

Some files were not shown because too many files have changed in this diff Show More