OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0024776: Visualization - inherit OpenGl_View from Graphic3d_CView

Browse Source 
Expose interface of OpenGl_View (OpenGL graphics rendering methods) to client code
and collecting all high-level API methods of application views in V3d_View class.

1) Exposing interface of OpenGl_View:

The OpenGl_View inherits from new class Graphic3d_CView.
Graphic3d_CView is an interface class that declares abstract methods for managing displayed structures,
display properties and a base layer code that implements computation
and management of HLR (or more broadly speaking view-depended) structures.

In new implementation it takes place of eliminated Visual3d_View.
As before the instance of Graphic3d_CView is still completely managed by V3d_View classes.
It can be accessed through V3d_View interface but normally this should not be required as all its methods are completely wrapped.

In more details, a concrete specialization of Graphic3d_CView is created and returned by graphical driver on request.
Right after creation the views is directly used for setting rendering properties and adding graphical structures to be displayed.

The rendering of graphics is possible after mapping a window and activating the view.
The direct setting of properties makes obsolete usage of intermediate structures with display parameter
like Visual3d_ContextView and etc (the whole package of Visual3d become redundant).

2) Collecting all high-level API methods of application views in V3d package:

The patch includes elimination of Visual3d layer.
All of its methods that could be previously used by application are now exposed and should be accessed on the level of V3d entities.
- Introduced new class Graphic3d_CView.
  This is a base class for render views.
  Made possible to specialize concrete instances of the class by graphical driver.
- Moved all methods managing rendering views into interface of Graphic3d_CView.
  The corresponding methods were removed from interface of graphical driver.

3) Eliminated Visual3d package:

- Logic of managing display of structures was put from Visual3d_ViewManager into Graphic3d_StructureManager.
- Removed Visual3d_View class. Logic of managing computed structures was put into base layer of Graphi3d_CView.
- Removed all intermediate structures for storing view parameters e.g. Visual3d_ContextView.
  All settings are kept by instances of Graphic3d_CView
- Removed Visual3d_Light intermediate class.
  All light properties are still stored in Graphic3d_CLight structure.
  The structure is directly access by instance of V3d_Light classes.
- Moved all needed enumerations into Graphic3d package.

4) Update package D3DHost to new changes.

5) Update code of OCCT samples to new changes.
This commit is contained in:
apl 2015-09-22 11:49:33 +03:00 committed by kgv
parent 97d87ffa94
commit c357e42610
159 changed files with 9998 additions and 14088 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
adm/UDLIST
View File

@ -212,7 +212,6 @@ n StdPrs
n StdSelect
n TColQuantity
n V3d
n Visual3d
n Voxel
n WNT
n Xw

4
samples/CSharp/OCCTProxy_D3D/OCCTProxyD3D.cpp
View File

@ -10,10 +10,10 @@
#include <Graphic3d_Camera.hxx>
#include <Graphic3d_TextureParams.hxx>
#include <D3DHost_GraphicDriver.hxx>
#include <D3DHost_View.hxx>
//for object display
#include <V3d_Viewer.hxx>
#include <V3d_View.hxx>
#include <Visual3d_View.hxx>
#include <AIS_InteractiveContext.hxx>
#include <AIS_Shape.hxx>
//topology
@ -106,7 +106,7 @@ public:
aWNTWindow->SetPos (0, 0, theWinSizeX, theWinSizeY);
myView()->MustBeResized();
myView()->Invalidate();
return System::IntPtr(myGraphicDriver()->D3dColorSurface (myView()->View()));
return System::IntPtr(Handle(D3DHost_View)::DownCast (myView()->View())->D3dColorSurface());
}
/// <summary>

1
samples/mfc/standard/03_Viewer2d/src/StdAfx.h
View File

@ -148,7 +148,6 @@
#include <TColgp_HArray1OfPnt2d.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS.hxx>
#include <Visual3d_ViewManager.hxx>
#include <V3d_View.hxx>
#include <V3d_Viewer.hxx>
#include <WNT_Window.hxx>

2
samples/mfc/standard/Common/OCC_3dView.cpp
View File

@ -8,8 +8,6 @@
#include "OCC_3dBaseDoc.h"
#include <res\OCC_Resource.h>
#include <Visual3d_View.hxx>
#include <Graphic3d_ExportFormat.hxx>
#include <Graphic3d_Camera.hxx>

2
samples/mfc/standard/Common/OCC_BaseDoc.cpp
View File

@ -42,7 +42,7 @@ void OCC_BaseDoc::ExportView (const Handle(V3d_View)& theView) const
else if (!(aFileExt.CompareNoCase (L"svg"))) anExportFormat = Graphic3d_EF_SVG;
else anExportFormat = Graphic3d_EF_PGF;
theView->View()->Export (aFileName.ToCString(), anExportFormat);
theView->Export (aFileName.ToCString(), anExportFormat);
}
else
{

1
samples/mfc/standard/Common/StdAfx.h
View File

@ -114,7 +114,6 @@
#include <TopTools_HSequenceOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <Visual3d_View.hxx>
#include <V3d_Viewer.hxx>
#include <V3d_View.hxx>
#include <WNT_Window.hxx>

3
samples/qt/Common/src/View.cxx
View File

@ -17,7 +17,6 @@
#include <QMdiSubWindow>
#include <QStyleFactory>
#include <Visual3d_View.hxx>
#include <Graphic3d_ExportFormat.hxx>
#include <Graphic3d_GraphicDriver.hxx>
#include <Graphic3d_TextureEnv.hxx>
@ -1147,7 +1146,7 @@ bool View::dump(Standard_CString theFile)
exFormat = Graphic3d_EF_PGF;
try
{
myView->View()->Export( theFile, exFormat );
myView->Export( theFile, exFormat );
}
catch(...)
{

20
src/AIS/AIS_InteractiveContext.cxx
View File

@ -61,8 +61,6 @@
#include <UnitsAPI.hxx>
#include <V3d_View.hxx>
#include <V3d_Viewer.hxx>
#include <Visual3d_View.hxx>
#include <Visual3d_ViewManager.hxx>
//#include <AIS_DataMapIteratorOfDataMapOfInteractiveInteger.hxx>
namespace
@ -93,7 +91,7 @@ namespace
AIS_InteractiveContext::AIS_InteractiveContext(const Handle(V3d_Viewer)& MainViewer):
mgrSelector(new SelectMgr_SelectionManager()),
myMainPM(new PrsMgr_PresentationManager3d(MainViewer->Viewer())),
myMainPM(new PrsMgr_PresentationManager3d(MainViewer->StructureManager())),
myMainVwr(MainViewer),
myMainSel(new StdSelect_ViewerSelector3d()),
myWasLastMain(Standard_False),
@ -353,8 +351,8 @@ void AIS_InteractiveContext::ObjectsForView (AIS_ListOfInteractive& theListOfIO
const Standard_Boolean theIsVisibleInView,
const AIS_DisplayStatus theStatus) const
{
const Graphic3d_CView* aCView = reinterpret_cast<const Graphic3d_CView* >(theView->View()->CView());
const Standard_Integer aViewId = aCView->ViewId;
Handle(Graphic3d_CView) aViewImpl = theView->View();
const Standard_Integer aViewId = aViewImpl->Identification();
for (AIS_DataMapIteratorOfDataMapOfIOStatus anObjIter (myObjects); anObjIter.More(); anObjIter.Next())
{
if (theStatus != AIS_DS_None
@ -364,7 +362,7 @@ void AIS_InteractiveContext::ObjectsForView (AIS_ListOfInteractive& theListOfIO
continue;
}
Handle(Graphic3d_ViewAffinity) anAffinity = myMainVwr->Viewer()->ObjectAffinity (anObjIter.Key());
Handle(Graphic3d_ViewAffinity) anAffinity = myMainVwr->StructureManager()->ObjectAffinity (anObjIter.Key());
const Standard_Boolean isVisible = anAffinity->IsVisible (aViewId);
if (isVisible == theIsVisibleInView)
{
@ -406,9 +404,9 @@ void AIS_InteractiveContext::SetViewAffinity (const Handle(AIS_InteractiveObject
return;
}
Handle(Graphic3d_ViewAffinity) anAffinity = myMainVwr->Viewer()->ObjectAffinity (theIObj);
const Graphic3d_CView* aCView = reinterpret_cast<const Graphic3d_CView* >(theView->View()->CView());
anAffinity->SetVisible (aCView->ViewId, theIsVisible == Standard_True);
Handle(Graphic3d_ViewAffinity) anAffinity = myMainVwr->StructureManager()->ObjectAffinity (theIObj);
Handle(Graphic3d_CView) aViewImpl = theView->View();
anAffinity->SetVisible (aViewImpl->Identification(), theIsVisible == Standard_True);
if (theIsVisible)
{
theView->View()->ChangeHiddenObjects()->Remove (theIObj.get());
@ -470,7 +468,7 @@ void AIS_InteractiveContext::Display (const Handle(AIS_InteractiveObject)& theIO
{
Handle(AIS_GlobalStatus) aStatus = new AIS_GlobalStatus (AIS_DS_Displayed, theDispMode, theSelectionMode);
myObjects.Bind (theIObj, aStatus);
Handle(Graphic3d_ViewAffinity) anAffinity = myMainVwr->Viewer()->RegisterObject (theIObj);
Handle(Graphic3d_ViewAffinity) anAffinity = myMainVwr->StructureManager()->RegisterObject (theIObj);
myMainPM->Display(theIObj, theDispMode);
if (theSelectionMode != -1)
{
@ -2532,7 +2530,7 @@ void AIS_InteractiveContext::ClearGlobal (const Handle(AIS_InteractiveObject)& t
mgrSelector->Remove (anObj);
myObjects.UnBind (theIObj);
myMainVwr->Viewer()->UnregisterObject (theIObj);
myMainVwr->StructureManager()->UnregisterObject (theIObj);
for (myMainVwr->InitDefinedViews(); myMainVwr->MoreDefinedViews(); myMainVwr->NextDefinedViews())
{
myMainVwr->DefinedView()->View()->ChangeHiddenObjects()->Remove (theIObj.get());

1
src/AIS/AIS_InteractiveContext_1.cxx
View File

@ -52,7 +52,6 @@
#include <V3d_SpotLight.hxx>
#include <V3d_View.hxx>
#include <V3d_Viewer.hxx>
#include <Visual3d_View.hxx>
typedef NCollection_DataMap<Handle(AIS_InteractiveObject), NCollection_Handle<SelectMgr_SequenceOfOwner> > AIS_MapOfObjSelectedOwners;

2
src/AIS/AIS_InteractiveContext_2.cxx
View File

@ -687,7 +687,7 @@ Standard_Integer AIS_InteractiveContext::PurgeDisplay()
//=======================================================================
Standard_Integer AIS_InteractiveContext::PurgeViewer(const Handle(V3d_Viewer)& Vwr)
{
Handle(Graphic3d_StructureManager) GSM = Vwr->Viewer();
Handle(Graphic3d_StructureManager) GSM = Vwr->StructureManager();
Standard_Integer NbCleared(0);
Graphic3d_MapOfStructure SOS;
GSM->DisplayedStructures(SOS);

1
src/AIS/AIS_LocalContext.cxx
View File

@ -47,7 +47,6 @@
#include <TopoDS_Shape.hxx>
#include <V3d_View.hxx>
#include <V3d_Viewer.hxx>
#include <Visual3d_View.hxx>
#include <stdio.h>
static TCollection_AsciiString AIS_Local_SelName(const Standard_Address address,

1
src/AIS/AIS_LocalContext_1.cxx
View File

@ -52,7 +52,6 @@
#include <TColStd_MapOfTransient.hxx>
#include <TopoDS_Shape.hxx>
#include <V3d_View.hxx>
#include <Visual3d_View.hxx>
static Standard_Integer GetHiMod(const Handle(AIS_InteractiveObject)& IO)
{

1
src/Aspect/Aspect_GraphicCallbackProc.hxx
View File

@ -19,6 +19,7 @@
#include <Aspect_Display.hxx>
#include <Aspect_Drawable.hxx>
#include <Aspect_RenderingContext.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Transient.hxx>
// The flags below provide additional information to define the moment when

59
src/D3DHost/D3DHost_GraphicDriver.cxx
View File

@ -16,10 +16,7 @@
#include <d3d9.h>
#include <D3DHost_GraphicDriver.hxx>
#include <D3DHost_Workspace.hxx>
#include <OpenGl_CView.hxx>
#include <Visual3d_View.hxx>
#include <D3DHost_View.hxx>
#ifdef _MSC_VER
#pragma comment (lib, "D3D9.lib")
@ -48,57 +45,19 @@ D3DHost_GraphicDriver::~D3DHost_GraphicDriver()
// function : View
// purpose :
// =======================================================================
Standard_Boolean D3DHost_GraphicDriver::View (Graphic3d_CView& theCView)
Handle(Graphic3d_CView) D3DHost_GraphicDriver::CreateView (const Handle(Graphic3d_StructureManager)& theMgr)
{
Handle(OpenGl_Context) aShareCtx = GetSharedContext();
OpenGl_CView* aCView = (OpenGl_CView* )theCView.ptrView;
if (aCView != NULL
&& myMapOfView.Contains (aCView->View))
{
Handle(D3DHost_Workspace) anOldWS = Handle(D3DHost_Workspace)::DownCast (aCView->WS);
Handle(D3DHost_Workspace) aWS = new D3DHost_Workspace (this, theCView.DefWindow, theCView.GContext, myCaps, aShareCtx);
theCView.ptrFBO = aWS->D3dWglBuffer().operator->();
aCView->WS = aWS;
aWS->SetActiveView (aCView->View, theCView.ViewId);
Handle(D3DHost_View) aView = new D3DHost_View (theMgr, this, myCaps, myDeviceLostFlag, &myStateCounter);
myMapOfWS.Remove (anOldWS);
myMapOfWS.Add (aWS);
return Standard_True;
}
Handle(D3DHost_Workspace) aWS = new D3DHost_Workspace (this, theCView.DefWindow, theCView.GContext, myCaps, aShareCtx);
Handle(OpenGl_View) aView = new OpenGl_View (theCView.Context, &myStateCounter);
myMapOfWS .Add (aWS);
myMapOfView.Add (aView);
aCView = new OpenGl_CView();
aCView->View = aView;
aCView->WS = aWS;
theCView.ptrFBO = aWS->D3dWglBuffer().operator->();
theCView.ptrView = aCView;
aWS->SetActiveView (aCView->View, theCView.ViewId);
return Standard_True;
}
// =======================================================================
// function : D3dColorSurface
// purpose :
// =======================================================================
IDirect3DSurface9* D3DHost_GraphicDriver::D3dColorSurface (const Handle(Visual3d_View)& theView) const
{
Graphic3d_CView* aCView = (Graphic3d_CView* )(theView->CView());
if (aCView == NULL
|| aCView->ptrView == NULL)
for (TColStd_SequenceOfInteger::Iterator aLayerIt (myLayerSeq); aLayerIt.More(); aLayerIt.Next())
{
return NULL;
const Graphic3d_ZLayerId aLayerID = aLayerIt.Value();
const Graphic3d_ZLayerSettings& aSettings = myMapOfZLayerSettings.Find (aLayerID);
aView->AddZLayer (aLayerID);
aView->SetZLayerSettings (aLayerID, aSettings);
}
Handle(D3DHost_Workspace) aWS = Handle(D3DHost_Workspace)::DownCast (((OpenGl_CView* )aCView->ptrView)->WS);
if (aWS.IsNull()
|| aWS->D3dWglBuffer().IsNull())
{
return NULL;
}
return aWS->D3dWglBuffer()->D3dColorSurface();
return aView;
}

10
src/D3DHost/D3DHost_GraphicDriver.hxx
View File

@ -18,9 +18,6 @@
#include <OpenGl_GraphicDriver.hxx>
class Visual3d_View;
struct IDirect3DSurface9;
//! This class defines D3D host for an OpenGl graphic driver
class D3DHost_GraphicDriver : public OpenGl_GraphicDriver
{
@ -32,11 +29,8 @@ public:
//! Destructor.
Standard_EXPORT virtual ~D3DHost_GraphicDriver();
//! Create new view.
Standard_EXPORT virtual Standard_Boolean View (Graphic3d_CView& theCView);
//! Return D3D surface for specified view.
Standard_EXPORT IDirect3DSurface9* D3dColorSurface (const Handle(Visual3d_View)& theCView) const;
//! Create instance of D3D host view.
Standard_EXPORT virtual Handle(Graphic3d_CView) CreateView (const Handle(Graphic3d_StructureManager)& theMgr) Standard_OVERRIDE;
public:

161
src/D3DHost/D3DHost_Workspace.cxx → src/D3DHost/D3DHost_View.cxx
View File

@ -13,17 +13,16 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <d3d9.h>
#include <D3DHost_Workspace.hxx>
#include <D3DHost_View.hxx>
#include <D3DHost_GraphicDriver.hxx>
#include <TCollection_ExtendedString.hxx>
// =======================================================================
// function : d3dFormatError
// purpose :
// =======================================================================
TCollection_AsciiString D3DHost_Workspace::d3dFormatError (HRESULT theErrCode)
TCollection_AsciiString D3DHost_View::d3dFormatError (HRESULT theErrCode)
{
switch (theErrCode)
{
@ -38,15 +37,15 @@ TCollection_AsciiString D3DHost_Workspace::d3dFormatError (HRESULT theErrCode)
}
// =======================================================================
// function : D3DHost_Workspace
// function : D3DHost_View
// purpose :
// =======================================================================
D3DHost_Workspace::D3DHost_Workspace (const Handle(OpenGl_GraphicDriver)& theDriver,
const CALL_DEF_WINDOW& theCWindow,
Aspect_RenderingContext theGContext,
const Handle(OpenGl_Caps)& theCaps,
const Handle(OpenGl_Context)& theShareCtx)
: OpenGl_Workspace (theDriver, theCWindow, theGContext, theCaps, theShareCtx),
D3DHost_View::D3DHost_View (const Handle(Graphic3d_StructureManager)& theMgr,
const Handle(D3DHost_GraphicDriver)& theDriver,
const Handle(OpenGl_Caps)& theCaps,
Standard_Boolean& theDeviceLostFlag,
OpenGl_StateCounter* theCounter)
: OpenGl_View (theMgr, theDriver, theCaps, theDeviceLostFlag, theCounter),
myD3dLib (NULL),
myD3dDevice (NULL),
myRefreshRate (D3DPRESENT_RATE_DEFAULT),
@ -64,20 +63,17 @@ D3DHost_Workspace::D3DHost_Workspace (const Handle(OpenGl_GraphicDriver)& theDri
myD3dParams.AutoDepthStencilFormat = D3DFMT_D16_LOCKABLE;
myD3dParams.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
myD3dParams.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
d3dInit (theCWindow);
d3dCreateRenderTarget();
}
// =======================================================================
// function : ~D3DHost_Workspace
// function : ~D3DHost_View
// purpose :
// =======================================================================
D3DHost_Workspace::~D3DHost_Workspace()
D3DHost_View::~D3DHost_View()
{
if (!myD3dWglFbo.IsNull())
{
myD3dWglFbo->Release (myGlContext.operator->());
myD3dWglFbo->Release (myWorkspace->GetGlContext().operator->());
myD3dWglFbo.Nullify();
}
if (myD3dDevice != NULL)
@ -92,11 +88,40 @@ D3DHost_Workspace::~D3DHost_Workspace()
}
}
// =======================================================================
// function : SetWindow
// purpose :
// =======================================================================
void D3DHost_View::SetWindow (const Handle(Aspect_Window)& theWindow,
const Aspect_RenderingContext theContext,
const Aspect_GraphicCallbackProc& theDisplayCB,
const Standard_Address theClientData)
{
if (!myD3dWglFbo.IsNull())
{
myD3dWglFbo->Release (myWorkspace->GetGlContext().operator->());
myD3dWglFbo.Nullify();
}
if (myD3dDevice != NULL)
{
myD3dDevice->Release();
myD3dDevice = NULL;
}
OpenGl_View::SetWindow (theWindow, theContext, theDisplayCB, theClientData);
if (!myWindow.IsNull())
{
d3dInit();
d3dCreateRenderTarget();
}
}
// =======================================================================
// function : d3dInitLib
// purpose :
// =======================================================================
bool D3DHost_Workspace::d3dInitLib()
bool D3DHost_View::d3dInitLib()
{
if (myD3dLib == NULL)
{
@ -127,15 +152,15 @@ bool D3DHost_Workspace::d3dInitLib()
// function : d3dInit
// purpose :
// =======================================================================
bool D3DHost_Workspace::d3dInit (const CALL_DEF_WINDOW& theCWindow)
bool D3DHost_View::d3dInit()
{
if (!d3dInitLib())
{
myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
GL_DEBUG_TYPE_ERROR_ARB,
0,
GL_DEBUG_SEVERITY_HIGH_ARB,
"Direct3DCreate9 failed!");
myWorkspace->GetGlContext()->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
GL_DEBUG_TYPE_ERROR_ARB,
0,
GL_DEBUG_SEVERITY_HIGH_ARB,
"Direct3DCreate9 failed!");
return false;
}
@ -148,13 +173,13 @@ bool D3DHost_Workspace::d3dInit (const CALL_DEF_WINDOW& theCWindow)
myRefreshRate = myCurrMode.RefreshRate;
}
myD3dParams.Windowed = TRUE;
myD3dParams.BackBufferWidth = theCWindow.dx;
myD3dParams.BackBufferHeight = theCWindow.dy;
myD3dParams.hDeviceWindow = (HWND )theCWindow.XWindow;
myD3dParams.BackBufferWidth = myWindow->Width();
myD3dParams.BackBufferHeight = myWindow->Height();
myD3dParams.hDeviceWindow = (HWND )myWindow->PlatformWindow()->NativeHandle();
// create the Video Device
HRESULT isOK = myD3dLib->CreateDevice (anAdapterId, D3DDEVTYPE_HAL,
(HWND )theCWindow.XWindow,
(HWND )myWindow->PlatformWindow()->NativeHandle(),
D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_MULTITHREADED | D3DCREATE_FPU_PRESERVE,
&myD3dParams, &myD3dDevice);
if (isOK < 0)
@ -169,7 +194,7 @@ bool D3DHost_Workspace::d3dInit (const CALL_DEF_WINDOW& theCWindow)
// function : d3dReset
// purpose :
// =======================================================================
bool D3DHost_Workspace::d3dReset (const CALL_DEF_WINDOW& theCWindow)
bool D3DHost_View::d3dReset()
{
if (myD3dDevice == NULL)
{
@ -177,9 +202,9 @@ bool D3DHost_Workspace::d3dReset (const CALL_DEF_WINDOW& theCWindow)
}
myD3dParams.Windowed = TRUE;
myD3dParams.BackBufferWidth = theCWindow.dx;
myD3dParams.BackBufferHeight = theCWindow.dy;
myD3dParams.hDeviceWindow = (HWND )theCWindow.XWindow;
myD3dParams.BackBufferWidth = myWindow->Width();
myD3dParams.BackBufferHeight = myWindow->Height();
myD3dParams.hDeviceWindow = (HWND )myWindow->PlatformWindow()->NativeHandle();
myD3dParams.FullScreen_RefreshRateInHz = !myD3dParams.Windowed ? myRefreshRate : 0;
HRESULT isOK = myD3dDevice->Reset(&myD3dParams);
@ -190,13 +215,17 @@ bool D3DHost_Workspace::d3dReset (const CALL_DEF_WINDOW& theCWindow)
// function : d3dCreateRenderTarget
// purpose :
// =======================================================================
bool D3DHost_Workspace::d3dCreateRenderTarget()
bool D3DHost_View::d3dCreateRenderTarget()
{
if (myD3dWglFbo.IsNull())
{
myD3dWglFbo = new D3DHost_FrameBuffer();
}
if (!myD3dWglFbo->Init (myGlContext, myD3dDevice, myIsD3dEx, myWidth, myHeight))
if (!myD3dWglFbo->Init (myWorkspace->GetGlContext(),
myD3dDevice,
myIsD3dEx,
myWindow->Width(),
myWindow->Height()))
{
return false;
}
@ -209,7 +238,7 @@ bool D3DHost_Workspace::d3dCreateRenderTarget()
// function : d3dBeginRender
// purpose :
// =======================================================================
void D3DHost_Workspace::d3dBeginRender()
void D3DHost_View::d3dBeginRender()
{
if (myD3dDevice == NULL)
{
@ -225,7 +254,7 @@ void D3DHost_Workspace::d3dBeginRender()
// function : d3dEndRender
// purpose :
// =======================================================================
void D3DHost_Workspace::d3dEndRender()
void D3DHost_View::d3dEndRender()
{
if (myD3dDevice != NULL)
{
@ -237,7 +266,7 @@ void D3DHost_Workspace::d3dEndRender()
// function : d3dSwap
// purpose :
// =======================================================================
bool D3DHost_Workspace::d3dSwap()
bool D3DHost_View::d3dSwap()
{
if (myD3dDevice == NULL)
{
@ -249,11 +278,11 @@ bool D3DHost_Workspace::d3dSwap()
{
TCollection_ExtendedString aMsg = TCollection_ExtendedString()
+ "Direct3D9, Present device failed, " + d3dFormatError (isOK);
myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
GL_DEBUG_TYPE_ERROR_ARB,
0,
GL_DEBUG_SEVERITY_HIGH_ARB,
aMsg);
myWorkspace->GetGlContext()->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
GL_DEBUG_TYPE_ERROR_ARB,
0,
GL_DEBUG_SEVERITY_HIGH_ARB,
aMsg);
}
return isOK == D3D_OK;
}
@ -262,20 +291,21 @@ bool D3DHost_Workspace::d3dSwap()
// function : Redraw
// purpose :
// =======================================================================
void D3DHost_Workspace::Redraw (const Graphic3d_CView& theCView)
void D3DHost_View::Redraw()
{
if (!Activate()
if (!myWorkspace->Activate()
|| myD3dDevice == NULL)
{
return;
}
Handle(OpenGl_Context) aCtx = myWorkspace->GetGlContext();
myToFlipOutput = Standard_True;
myD3dWglFbo->LockSurface (myGlContext);
OpenGl_Workspace::Redraw (theCView);
myD3dWglFbo->UnlockSurface (myGlContext);
myD3dWglFbo->LockSurface (aCtx);
OpenGl_View::Redraw();
myD3dWglFbo->UnlockSurface (aCtx);
myToFlipOutput = Standard_False;
if (myGlContext->caps->buffersNoSwap)
if (aCtx->caps->buffersNoSwap)
{
return;
}
@ -296,27 +326,28 @@ void D3DHost_Workspace::Redraw (const Graphic3d_CView& theCView)
// function : RedrawImmediate
// purpose :
// =======================================================================
void D3DHost_Workspace::RedrawImmediate (const Graphic3d_CView& theCView)
void D3DHost_View::RedrawImmediate()
{
Handle(OpenGl_Context) aCtx = myWorkspace->GetGlContext();
if (!myTransientDrawToFront
|| !myBackBufferRestored
|| (myGlContext->caps->buffersNoSwap && !myMainSceneFbos[0]->IsValid()))
|| (aCtx->caps->buffersNoSwap && !myMainSceneFbos[0]->IsValid()))
{
Redraw (theCView);
Redraw();
return;
}
else if (!Activate()
else if (!myWorkspace->Activate()
|| myD3dDevice == NULL)
{
return;
}
myToFlipOutput = Standard_True;
myD3dWglFbo->LockSurface (myGlContext);
OpenGl_Workspace::RedrawImmediate (theCView);
myD3dWglFbo->UnlockSurface (myGlContext);
myD3dWglFbo->LockSurface (aCtx);
OpenGl_View::RedrawImmediate();
myD3dWglFbo->UnlockSurface (aCtx);
myToFlipOutput = Standard_False;
if (myGlContext->caps->buffersNoSwap)
if (aCtx->caps->buffersNoSwap)
{
return;
}
@ -337,24 +368,24 @@ void D3DHost_Workspace::RedrawImmediate (const Graphic3d_CView& theCView)
// function : Resize
// purpose :
// =======================================================================
void D3DHost_Workspace::Resize (const CALL_DEF_WINDOW& theCWindow)
void D3DHost_View::Resized()
{
const Standard_Integer aWidthOld = myWidth;
const Standard_Integer aHeightOld = myHeight;
OpenGl_Workspace::Resize (theCWindow);
if (aWidthOld == myWidth
&& aHeightOld == myHeight)
const Standard_Integer aWidthOld = myWindow->Width();
const Standard_Integer aHeightOld = myWindow->Height();
OpenGl_View::Resized();
if (aWidthOld == myWindow->Width()
&& aHeightOld == myWindow->Height())
{
return;
}
if (!myD3dWglFbo.IsNull())
{
myD3dWglFbo->Release (myGlContext.operator->());
myD3dWglFbo->Release (myWorkspace->GetGlContext().operator->());
}
if (!myGlContext->caps->buffersNoSwap)
if (!myWorkspace->GetGlContext()->caps->buffersNoSwap)
{
d3dReset (theCWindow);
d3dReset();
}
d3dCreateRenderTarget();
}

59
src/D3DHost/D3DHost_Workspace.hxx → src/D3DHost/D3DHost_View.hxx
View File

@ -13,38 +13,52 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _D3DHost_Workspace_HeaderFile
#define _D3DHost_Workspace_HeaderFile
#ifndef _D3DHost_View_HeaderFile
#define _D3DHost_View_HeaderFile
#include <d3d9.h>
#include <OpenGl_Workspace.hxx>
#include <D3DHost_FrameBuffer.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Workspace.hxx>
//! The D3D host containing OpenGL viewer.
class D3DHost_Workspace : public OpenGl_Workspace
class D3DHost_GraphicDriver;
//! The D3D host view implementation that overrides rendering methods.
class D3DHost_View : public OpenGl_View
{
public:
//! Main constructor.
Standard_EXPORT D3DHost_Workspace (const Handle(OpenGl_GraphicDriver)& theDriver,
const CALL_DEF_WINDOW& theCWindow,
Aspect_RenderingContext theGContext,
const Handle(OpenGl_Caps)& theCaps,
const Handle(OpenGl_Context)& theShareCtx);
//! Constructor.
Standard_EXPORT D3DHost_View (const Handle(Graphic3d_StructureManager)& theMgr,
const Handle(D3DHost_GraphicDriver)& theDriver,
const Handle(OpenGl_Caps)& theCaps,
Standard_Boolean& theDeviceLostFlag,
OpenGl_StateCounter* theCounter);
//! Destroy D3D connection and OpenGL workspace.
Standard_EXPORT virtual ~D3DHost_Workspace();
//! Default destructor.
Standard_EXPORT virtual ~D3DHost_View();
//! Creates and maps rendering window to the view.
//! @param theWindow [in] the window.
//! @param theContext [in] the rendering context. If NULL the context will be created internally.
//! @param theDisplayCB [in] the display callback function. If is not a NULL value, then the callback will be
//! invoked at the end of the OCC graphic traversal and just before the swap of buffers.
//! @param theClientData [in] the client data for the callback.
Standard_EXPORT virtual void SetWindow (const Handle(Aspect_Window)& theWindow,
const Aspect_RenderingContext theContext,
const Aspect_GraphicCallbackProc& theDisplayCB,
const Standard_Address theClientData) Standard_OVERRIDE;
//! Resizes the window.
Standard_EXPORT virtual void Resize (const CALL_DEF_WINDOW& theCWindow) Standard_OVERRIDE;
Standard_EXPORT virtual void Resized() Standard_OVERRIDE;
//! Redraw the all content.
Standard_EXPORT virtual void Redraw (const Graphic3d_CView& theCView) Standard_OVERRIDE;
Standard_EXPORT virtual void Redraw() Standard_OVERRIDE;
//! Redraw only immediate layer.
Standard_EXPORT virtual void RedrawImmediate (const Graphic3d_CView& theCView) Standard_OVERRIDE;
Standard_EXPORT virtual void RedrawImmediate() Standard_OVERRIDE;
public:
@ -57,6 +71,9 @@ public:
//! Return D3D/WGL FBO.
const Handle(D3DHost_FrameBuffer)& D3dWglBuffer() const { return myD3dWglFbo; }
//! Return D3D surface.
IDirect3DSurface9* D3dColorSurface() const { return myD3dWglFbo->D3dColorSurface(); }
protected:
//! Auxiliary method.
@ -66,11 +83,11 @@ protected:
Standard_EXPORT bool d3dInitLib();
//! Initialize Direct3D output device.
Standard_EXPORT bool d3dInit (const CALL_DEF_WINDOW& theCWindow);
Standard_EXPORT bool d3dInit();
//! Reset Direct3D output settings. Could be used to switch windowed/fullscreen modes.
//! Use very carefully! Most objects should be released before and recreated after!
Standard_EXPORT bool d3dReset (const CALL_DEF_WINDOW& theCWindow);
Standard_EXPORT bool d3dReset();
//! (Re-)create D3D surface.
Standard_EXPORT bool d3dCreateRenderTarget();
@ -97,10 +114,10 @@ protected:
public:
DEFINE_STANDARD_RTTI(D3DHost_Workspace, OpenGl_Workspace)
DEFINE_STANDARD_RTTI(D3DHost_View, OpenGl_View)
};
DEFINE_STANDARD_HANDLE(D3DHost_Workspace, OpenGl_Workspace)
DEFINE_STANDARD_HANDLE(D3DHost_View, OpenGl_View)
#endif // _D3DHost_Workspace_HeaderFile
#endif // #ifndef _D3DHost_View_HeaderFile

4
src/D3DHost/FILES
View File

@ -2,5 +2,5 @@ D3DHost_GraphicDriver.hxx
D3DHost_GraphicDriver.cxx
D3DHost_FrameBuffer.hxx
D3DHost_FrameBuffer.cxx
D3DHost_Workspace.hxx
D3DHost_Workspace.cxx
D3DHost_View.hxx
D3DHost_View.cxx

7
src/Graphic3d/FILES
View File

@ -56,6 +56,7 @@ Graphic3d_CStructure.hxx
Graphic3d_CStructurePtr.hxx
Graphic3d_CTexture.hxx
Graphic3d_CUserDraw.hxx
Graphic3d_CView.cxx
Graphic3d_CView.hxx
Graphic3d_CycleError.hxx
Graphic3d_DataStructure.pxx
@ -145,19 +146,25 @@ Graphic3d_TransformError.hxx
Graphic3d_TransformPers.hxx
Graphic3d_TransformUtils.hxx
Graphic3d_TransModeFlags.hxx
Graphic3d_TypeOfAnswer.hxx
Graphic3d_TypeOfBackfacingModel.hxx
Graphic3d_TypeOfBackground.hxx
Graphic3d_TypeOfComposition.hxx
Graphic3d_TypeOfConnection.hxx
Graphic3d_TypeOfLightSource.hxx
Graphic3d_TypeOfMaterial.hxx
Graphic3d_TypeOfPolygon.hxx
Graphic3d_TypeOfPrimitive.hxx
Graphic3d_TypeOfPrimitiveArray.hxx
Graphic3d_TypeOfReflection.hxx
Graphic3d_TypeOfShaderObject.hxx
Graphic3d_TypeOfShadingModel.hxx
Graphic3d_TypeOfStructure.hxx
Graphic3d_TypeOfSurfaceDetail.hxx
Graphic3d_TypeOfTexture.hxx
Graphic3d_TypeOfTextureFilter.hxx
Graphic3d_TypeOfTextureMode.hxx
Graphic3d_TypeOfVisualization.hxx
Graphic3d_Vec.hxx
Graphic3d_Vec2.hxx
Graphic3d_Vec3.hxx

2
src/Graphic3d/Graphic3d_CAspectFillArea.hxx
View File

@ -15,9 +15,9 @@
#ifndef _Graphic3d_CAspectFillArea_HeaderFile
#define _Graphic3d_CAspectFillArea_HeaderFile
#include <InterfaceGraphic_Visual3d.hxx>
#include <Graphic3d_CTexture.hxx>
#include <Graphic3d_ShaderProgram.hxx>
#include <InterfaceGraphic_Graphic3d.hxx>
class Graphic3d_CAspectFillArea
{

2
src/Graphic3d/Graphic3d_CAspectLine.hxx
View File

@ -15,9 +15,9 @@
#ifndef _Graphic3d_CAspectLine_HeaderFile
#define _Graphic3d_CAspectLine_HeaderFile
#include <InterfaceGraphic_Visual3d.hxx>
#include <Graphic3d_CTexture.hxx>
#include <Graphic3d_ShaderProgram.hxx>
#include <InterfaceGraphic_Graphic3d.hxx>
class Graphic3d_CAspectLine
{

2
src/Graphic3d/Graphic3d_CAspectMarker.hxx
View File

@ -16,10 +16,10 @@
#define _Graphic3d_CAspectMarker_HeaderFile
#include <Aspect_TypeOfMarker.hxx>
#include <InterfaceGraphic_Visual3d.hxx>
#include <Graphic3d_CTexture.hxx>
#include <Graphic3d_MarkerImage.hxx>
#include <Graphic3d_ShaderProgram.hxx>
#include <InterfaceGraphic_Graphic3d.hxx>
class Graphic3d_CAspectMarker
{

2
src/Graphic3d/Graphic3d_CAspectText.hxx
View File

@ -15,9 +15,9 @@
#ifndef _Graphic3d_CAspectText_HeaderFile
#define _Graphic3d_CAspectText_HeaderFile
#include <InterfaceGraphic_Visual3d.hxx>
#include <Graphic3d_CTexture.hxx>
#include <Graphic3d_ShaderProgram.hxx>
#include <InterfaceGraphic_Graphic3d.hxx>
class Graphic3d_CAspectText
{

25
src/Graphic3d/Graphic3d_CLight.hxx
View File

@ -14,9 +14,10 @@
#ifndef _Graphic3d_CLight_HeaderFile
#define _Graphic3d_CLight_HeaderFile
#include <InterfaceGraphic_Graphic3d.hxx>
#include <InterfaceGraphic_Visual3d.hxx>
#include <Graphic3d_TypeOfLightSource.hxx>
#include <Graphic3d_Vec.hxx>
#include <InterfaceGraphic_Graphic3d.hxx>
#include <NCollection_List.hxx>
//! Light definition
struct Graphic3d_CLight
@ -24,14 +25,14 @@ struct Graphic3d_CLight
public:
Graphic3d_Vec4 Color; //!< light color
Graphic3d_Vec4 Position; //!< light position
Graphic3d_Vec4 Direction; //!< direction of directional/spot light
Graphic3d_Vec4 Params; //!< packed light parameters
Standard_Integer Type; //!< Visual3d_TypeOfLightSource enumeration
Standard_Boolean IsHeadlight; //!< flag to mark head light
Standard_ShortReal Smoothness; //!< radius (cone angle) for point (directional) light
Standard_ShortReal Intensity; //!< intensity multiplier for light
Graphic3d_Vec4 Color; //!< light color
Graphic3d_Vec4 Position; //!< light position
Graphic3d_Vec4 Direction; //!< direction of directional/spot light
Graphic3d_Vec4 Params; //!< packed light parameters
Graphic3d_TypeOfLightSource Type; //!< Graphic3d_TypeOfLightSource enumeration
Standard_Boolean IsHeadlight; //!< flag to mark head light
Standard_ShortReal Smoothness; //!< radius (cone angle) for point (directional) light
Standard_ShortReal Intensity; //!< intensity multiplier for light
//! Const attenuation factor of positional light source
Standard_ShortReal ConstAttenuation() const { return Params.x(); }
@ -62,7 +63,7 @@ public:
Position (0.0f, 0.0f, 0.0f, 1.0f),
Direction (0.0f, 0.0f, 0.0f, 0.0f),
Params (0.0f, 0.0f, 0.0f, 0.0f),
Type (0),
Type (Graphic3d_TOLS_AMBIENT),
IsHeadlight (Standard_False),
Smoothness (0.0f),
Intensity (1.0f)
@ -76,4 +77,6 @@ public:
};
typedef NCollection_List<Graphic3d_CLight> Graphic3d_ListOfCLight;
#endif // Graphic3d_CLight_HeaderFile

1
src/Graphic3d/Graphic3d_CStructure.hxx
View File

@ -24,6 +24,7 @@
#include <Graphic3d_TransformPers.hxx>
#include <Graphic3d_Vec3.hxx>
#include <Graphic3d_ZLayerId.hxx>
#include <InterfaceGraphic_Graphic3d.hxx>
class Graphic3d_GraphicDriver;
class Graphic3d_StructureManager;

1079
src/Graphic3d/Graphic3d_CView.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

668
src/Graphic3d/Graphic3d_CView.hxx
View File

@ -1,4 +1,4 @@
// Copyright (c) 1999-2014 OPEN CASCADE SAS
// Copyright (c) 2015 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
@ -14,128 +14,578 @@
#ifndef _Graphic3d_CView_HeaderFile
#define _Graphic3d_CView_HeaderFile
#include <InterfaceGraphic_Graphic3d.hxx>
#include <InterfaceGraphic_Visual3d.hxx>
#include <Graphic3d_RenderingParams.hxx>
#include <Graphic3d_TextureEnv.hxx>
#include <Aspect_GraphicCallbackProc.hxx>
#include <Aspect_Handle.hxx>
#include <Aspect_PrintAlgo.hxx>
#include <Aspect_RenderingContext.hxx>
#include <Aspect_TypeOfTriedronEcho.hxx>
#include <Aspect_TypeOfTriedronPosition.hxx>
#include <Aspect_TypeOfUpdate.hxx>
#include <Aspect_Window.hxx>
#include <Graphic3d_BufferType.hxx>
#include <Graphic3d_Camera.hxx>
#include <Graphic3d_CLight.hxx>
#include <Graphic3d_CStructure.hxx>
#include <Graphic3d_DataStructureManager.hxx>
#include <Graphic3d_ExportFormat.hxx>
#include <Graphic3d_GraduatedTrihedron.hxx>
#include <Graphic3d_MapOfStructure.hxx>
#include <Graphic3d_NMapOfTransient.hxx>
#include <Graphic3d_PtrFrameBuffer.hxx>
#include <Graphic3d_RenderingParams.hxx>
#include <Graphic3d_SequenceOfHClipPlane.hxx>
#include <Graphic3d_SequenceOfStructure.hxx>
#include <Graphic3d_SortType.hxx>
#include <Graphic3d_Structure.hxx>
#include <Graphic3d_StructureManagerPtr.hxx>
#include <Graphic3d_TextureEnv.hxx>
#include <Graphic3d_TypeOfAnswer.hxx>
#include <Graphic3d_TypeOfBackfacingModel.hxx>
#include <Graphic3d_TypeOfShadingModel.hxx>
#include <Graphic3d_TypeOfSurfaceDetail.hxx>
#include <Graphic3d_TypeOfVisualization.hxx>
#include <Graphic3d_Vec3.hxx>
#include <Graphic3d_ZLayerId.hxx>
#include <Graphic3d_ZLayerSettings.hxx>
#include <Image_PixMap.hxx>
#include <Quantity_NameOfColor.hxx>
#include <Standard_Address.hxx>
#include <Standard_Transient.hxx>
class CALL_DEF_VIEWCONTEXT
class Graphic3d_CView;
class Graphic3d_GraphicDriver;
class Graphic3d_StructureManager;
DEFINE_STANDARD_HANDLE (Graphic3d_CView, Graphic3d_DataStructureManager)
//! Base class of a graphical view that carries out rendering process for a concrete
//! implementation of graphical driver. Provides virtual interfaces for redrawing its
//! contents, management of displayed structures and render settings. The source code
//! of the class itself implements functionality related to management of
//! computed (HLR or "view-dependent") structures.
class Graphic3d_CView : public Graphic3d_DataStructureManager
{
public:
//! Constructor.
Standard_EXPORT Graphic3d_CView (const Handle(Graphic3d_StructureManager)& theMgr);
//! Destructor.
Standard_EXPORT virtual ~Graphic3d_CView();
//! Returns the identification number of the view.
Standard_Integer Identification() const { return myId; }
//! Activates the view. Map the associated window on the screen and post the view in this window.
//! Warning: Raises ViewDefinitionError if the associated window isn't defined.
Standard_EXPORT virtual void Activate();
//! Deactivates the view. Unmap the associated window on the screen and unpost the view in this window.
//! Warning: Raises ViewDefinitionError if the associated window isn't defined.
Standard_EXPORT virtual void Deactivate();
//! Returns the activity flag of the view.
Standard_Boolean IsActive() const { return myIsActive; }
//! Erases the view and removes from graphic driver.
//! No more graphic operations are allowed in this view after the call.
Standard_EXPORT virtual void Remove();
//! Returns true if the view was removed.
Standard_Boolean IsRemoved() const { return myIsRemoved; }
public:
CALL_DEF_VIEWCONTEXT()
: Aliasing (0),
BackZClipping (0),
FrontZClipping (0),
DepthCueing (0),
ZClipFrontPlane (0.0f),
ZClipBackPlane (0.0f),
DepthFrontPlane (0.0f),
DepthBackPlane (0.0f),
Model (0),
Visualization (0),
NbActiveLight (0),
ActiveLight (NULL),
SurfaceDetail (0),
ClipPlanes()
//! Returns visualization type of the view.
Graphic3d_TypeOfVisualization VisualizationType() const { return myVisualization; }
//! Sets visualization type of the view.
void SetVisualizationType (const Graphic3d_TypeOfVisualization theType) { myVisualization = theType; }
//! Switches computed HLR mode in the view
Standard_EXPORT void SetComputedMode (const Standard_Boolean theMode);
//! Returns the computed HLR mode state
Standard_Boolean ComputedMode() const { return myIsInComputedMode; }
//! Computes the new presentation of the structure displayed in this view with the type Graphic3d_TOS_COMPUTED.
Standard_EXPORT void ReCompute (const Handle(Graphic3d_Structure)& theStructure);
//! Updates screen in function of modifications of the structures.
Standard_EXPORT void Update (const Aspect_TypeOfUpdate theUpdateMode);
//! Returns Standard_True if one of the structures displayed in the view contains Polygons, Triangles or Quadrangles.
Standard_EXPORT Standard_Boolean ContainsFacet() const;
//! Returns Standard_True if one of the structures in the set contains Polygons, Triangles or Quadrangles.
Standard_EXPORT Standard_Boolean ContainsFacet (const Graphic3d_MapOfStructure& theSet) const;
//! Returns the set of structures displayed in this view.
Standard_EXPORT void DisplayedStructures (Graphic3d_MapOfStructure& theStructures) const;
//! Returns number of displayed structures in the view.
Standard_Integer NumberOfDisplayedStructures() const { return myStructsDisplayed.Extent(); }
//! Returns map of objects hidden within this specific view (not viewer-wise).
const Handle(Graphic3d_NMapOfTransient)& HiddenObjects() const { return myHiddenObjects; }
//! Returns map of objects hidden within this specific view (not viewer-wise).
Handle(Graphic3d_NMapOfTransient)& ChangeHiddenObjects() { return myHiddenObjects; }
//! Returns Standard_True in case if the structure with the given <theStructId> is
//! in list of structures to be computed and stores computed struct to <theComputedStruct>.
Standard_EXPORT Standard_Boolean IsComputed (const Standard_Integer theStructId,
Handle(Graphic3d_Structure)& theComputedStruct) const;
//! Returns the coordinates of the boundary box of all
//! structures displayed in the view.
//! If <theToIgnoreInfiniteFlag> is TRUE, then the boundary box
//! also includes minimum and maximum limits of graphical elements
//! forming parts of infinite structures.
Standard_EXPORT Bnd_Box MinMaxValues (const Standard_Boolean theToIgnoreInfiniteFlag = Standard_False) const;
//! Returns the coordinates of the boundary box of all structures in the set <theSet>.
//! If <theToIgnoreInfiniteFlag> is TRUE, then the boundary box
//! also includes minimum and maximum limits of graphical elements
//! forming parts of infinite structures.
Standard_EXPORT Bnd_Box MinMaxValues (const Graphic3d_MapOfStructure& theSet,
const Standard_Boolean theToIgnoreInfiniteFlag = Standard_False) const;
//! Returns the structure manager handle which manage structures associated with this view.
const Handle(Graphic3d_StructureManager)& StructureManager() const { return myStructureManager; }
private:
friend class Graphic3d_StructureManager;
//! Is it possible to display the structure in the view?
Standard_EXPORT Graphic3d_TypeOfAnswer acceptDisplay (const Graphic3d_TypeOfStructure theStructType) const;
//! Computes the new presentation of the structures displayed in this view with the type Graphic3d_TOS_COMPUTED.
Standard_EXPORT void Compute();
//! Clears the structure in this view.
Standard_EXPORT void Clear (const Handle(Graphic3d_Structure)& theStructure, const Standard_Boolean theWithDestruction);
//! Connects the structures.
Standard_EXPORT void Connect (const Handle(Graphic3d_Structure)& theMother,
const Handle(Graphic3d_Structure)& theDaughter);
//! Disconnects the structures.
Standard_EXPORT void Disconnect (const Handle(Graphic3d_Structure)& theMother,
const Handle(Graphic3d_Structure)& theDaughter);
//! Displays the structure in the view.
Standard_EXPORT void Display (const Handle(Graphic3d_Structure)& theStructure);
//! Display the structure in the view.
Standard_EXPORT void Display (const Handle(Graphic3d_Structure)& theStructure,
const Aspect_TypeOfUpdate theUpdateMode);
//! Erases the structure from the view.
Standard_EXPORT void Erase (const Handle(Graphic3d_Structure)& theStructure);
//! Erases the structure from the view.
Standard_EXPORT void Erase (const Handle(Graphic3d_Structure)& theStructure,
const Aspect_TypeOfUpdate theUpdateMode);
//! Highlights the structure in the view.
Standard_EXPORT void Highlight (const Handle(Graphic3d_Structure)& theStructure,
const Aspect_TypeOfHighlightMethod theMethod);
//! Transforms the structure in the view.
Standard_EXPORT void SetTransform (const Handle(Graphic3d_Structure)& theStructure,
const TColStd_Array2OfReal& theTrsf);
//! Suppress the highlighting on the structure <AStructure>
//! in the view <me>.
Standard_EXPORT void UnHighlight (const Handle(Graphic3d_Structure)& theStructure);
//! Returns an index != 0 if the structure have another structure computed for the view <me>.
Standard_EXPORT Standard_Integer IsComputed (const Handle(Graphic3d_Structure)& theStructure) const;
//! Returns true if the structure is displayed in the view.
Standard_EXPORT Standard_Boolean IsDisplayed (const Handle(Graphic3d_Structure)& theStructure) const;
//! Changes the display priority of the structure.
Standard_EXPORT void ChangePriority (const Handle(Graphic3d_Structure)& theStructure,
const Standard_Integer theOldPriority,
const Standard_Integer theNewPriority);
//! Change Z layer of already displayed structure in the view.
Standard_EXPORT void ChangeZLayer (const Handle(Graphic3d_Structure)& theStructure,
const Graphic3d_ZLayerId theLayerId);
//! Returns an index != 0 if the structure have the same owner than another structure
//! in the sequence of the computed structures.
Standard_EXPORT Standard_Integer HaveTheSameOwner (const Handle(Graphic3d_Structure)& theStructure) const;
public:
//! Redraw content of the view.
virtual void Redraw() = 0;
//! Redraw immediate content of the view.
virtual void RedrawImmediate() = 0;
//! Invalidates content of the view but does not redraw it.
virtual void Invalidate() = 0;
//! Return true if view content cache has been invalidated.
virtual Standard_Boolean IsInvalidated() = 0;
//! Handle changing size of the rendering window.
virtual void Resized() = 0;
//! @param theDrawToFrontBuffer Advanced option to modify rendering mode:
//! 1. TRUE. Drawing immediate mode structures directly to the front buffer over the scene image.
//! Fast, so preferred for interactive work (used by default).
//! However these extra drawings will be missed in image dump since it is performed from back buffer.
//! Notice that since no pre-buffering used the V-Sync will be ignored and rendering could be seen
//! in run-time (in case of slow hardware) and/or tearing may appear.
//! So this is strongly recommended to draw only simple (fast) structures.
//! 2. FALSE. Drawing immediate mode structures to the back buffer.
//! The complete scene is redrawn first, so this mode is slower if scene contains complex data and/or V-Sync
//! is turned on. But it works in any case and is especially useful for view dump because the dump image is read
//! from the back buffer.
//! @return previous mode.
virtual Standard_Boolean SetImmediateModeDrawToFront (const Standard_Boolean theDrawToFrontBuffer) = 0;
//! Creates and maps rendering window to the view.
//! @param theView [in] the view to associate with the window.
//! @param theWindow [in] the window.
//! @param theContext [in] the rendering context. If NULL the context will be created internally.
//! @param theDisplayCB [in] the display callback function. If is not a NULL value, then the callback will be
//! invoked at the end of the OCC graphic traversal and just before the swap of buffers.
//! @param theClientData [in] the client data for the callback.
virtual void SetWindow (const Handle(Aspect_Window)& theWindow,
const Aspect_RenderingContext theContext = NULL,
const Aspect_GraphicCallbackProc& theDisplayCB = NULL,
const Standard_Address theClientData = NULL) = 0;
//! Returns the window associated to the view.
virtual Handle(Aspect_Window) Window() const = 0;
//! Returns True if the window associated to the view is defined.
virtual Standard_Boolean IsDefined() const = 0;
//! Displays z-buffer trihedron.
virtual void TriedronDisplay (const Aspect_TypeOfTriedronPosition thePosition = Aspect_TOTP_CENTER,
const Quantity_NameOfColor theColor = Quantity_NOC_WHITE,
const Standard_Real theScale = 0.02,
const Standard_Boolean theAsWireframe = Standard_True) = 0;
//! Erases z-buffer trihedron.
virtual void TriedronErase() = 0;
//! Setup parameters of z-buffer trihedron.
virtual void ZBufferTriedronSetup (const Quantity_NameOfColor theXColor = Quantity_NOC_RED,
const Quantity_NameOfColor theYColor = Quantity_NOC_GREEN,
const Quantity_NameOfColor theZColor = Quantity_NOC_BLUE1,
const Standard_Real theSizeRatio = 0.8,
const Standard_Real theAxisDiametr = 0.05,
const Standard_Integer theNbFacettes = 12) = 0;
//! Displays trihedron echo.
virtual void TriedronEcho (const Aspect_TypeOfTriedronEcho theType = Aspect_TOTE_NONE) = 0;
//! Returns data of a graduated trihedron
virtual const Graphic3d_GraduatedTrihedron& GetGraduatedTrihedron() = 0;
//! Displays Graduated Trihedron.
virtual void GraduatedTrihedronDisplay (const Graphic3d_GraduatedTrihedron& theTrihedronData) = 0;
//! Erases Graduated Trihedron.
virtual void GraduatedTrihedronErase() = 0;
//! Sets minimum and maximum points of scene bounding box for Graduated Trihedron stored in graphic view object.
//! @param theMin [in] the minimum point of scene.
//! @param theMax [in] the maximum point of scene.
virtual void GraduatedTrihedronMinMaxValues (const Graphic3d_Vec3 theMin, const Graphic3d_Vec3 theMax) = 0;
//! Reads depths of shown pixels of the given rectangle.
virtual void ReadDepths (const Standard_Integer theX,
const Standard_Integer theY,
const Standard_Integer theWidth,
const Standard_Integer theHeight,
const Standard_Address theBuffer) const = 0;
//! Dump active rendering buffer into specified memory buffer.
virtual Standard_Boolean BufferDump (Image_PixMap& theImage, const Graphic3d_BufferType& theBufferType) = 0;
//! Print the contents of the view to the printer.
//! @param thePrinterDC pass the PrinterDeviceContext (HDC)
//! @param theToShowBackground when set to FALSE then print the view without background
//! color (background is white) else set to TRUE for printing
//! with current background color
//! @param theFileName if != NULL, then the view will be printed to a file
//! @param thePrintAlgorithm select print algorithm: stretch, tile
//! @param theScaleFactor scaling coefficient, used internally to scale the printings
//! accordingly to the scale factor selected in the printer properties dialog
//! @return Standard_True if the data is passed to the printer, otherwise Standard_False if
//! the print operation failed due to the printer errors, or lack of system memory. This might be related
//! to insufficient memory or some internal errors.
//! All this errors are indicated by the message boxes (on level of OpenGl_GraphicDriver).
//! Warning: This function can reuse FBO assigned to the view, please take it into account
//! if you use it for your purposes.
virtual Standard_Boolean Print (const Aspect_Handle thePrinterDC,
const Standard_Boolean theToShowBackground,
const Standard_CString theFileName,
const Aspect_PrintAlgo thePrintAlgorithm = Aspect_PA_STRETCH,
const Standard_Real theScaleFactor = 1.0) = 0;
//! Export scene into the one of the Vector graphics formats (SVG, PS, PDF...).
//! In contrast to Bitmaps, Vector graphics is scalable (so you may got quality benefits
//! on printing to laser printer). Notice however that results may differ a lot and
//! do not contain some elements.
virtual Standard_Boolean Export (const Standard_CString theFileName,
const Graphic3d_ExportFormat theFormat,
const Graphic3d_SortType theSortType = Graphic3d_ST_BSP_Tree) = 0;
//! Marks BVH tree and the set of BVH primitives of correspondent priority list with id theLayerId as outdated.
virtual void InvalidateBVHData (const Standard_Integer theLayerId) = 0;
//! Add a new top-level z layer with ID <theLayerId> for
//! the view. Z layers allow drawing structures in higher layers
//! in foreground of structures in lower layers. To add a structure
//! to desired layer on display it is necessary to set the layer
//! ID for the structure.
virtual void AddZLayer (const Graphic3d_ZLayerId theLayerId) = 0;
//! Remove Z layer from the specified view. All structures
//! displayed at the moment in layer will be displayed in default layer
//! ( the bottom-level z layer ). To unset layer ID from associated
//! structures use method UnsetZLayer (...).
virtual void RemoveZLayer (const Graphic3d_ZLayerId theLayerId) = 0;
//! Sets the settings for a single Z layer of specified view.
virtual void SetZLayerSettings (const Graphic3d_ZLayerId theLayerId,
const Graphic3d_ZLayerSettings& theSettings) = 0;
//! Returns pointer to an assigned framebuffer object.
virtual Graphic3d_PtrFrameBuffer FBO() const = 0;
//! Sets framebuffer object for offscreen rendering.
virtual void SetFBO (const Graphic3d_PtrFrameBuffer theFBO) = 0;
//! Generate offscreen FBO in the graphic library.
//! If not supported on hardware returns NULL.
virtual Graphic3d_PtrFrameBuffer FBOCreate (const Standard_Integer theWidth,
const Standard_Integer theHeight) = 0;
//! Remove offscreen FBO from the graphic library
virtual void FBORelease (Graphic3d_PtrFrameBuffer& theFBOPtr) = 0;
//! Read offscreen FBO configuration.
virtual void FBOGetDimensions (const Graphic3d_PtrFrameBuffer theFBOPtr,
Standard_Integer& theWidth,
Standard_Integer& theHeight,
Standard_Integer& theWidthMax,
Standard_Integer& theHeightMax) = 0;
//! Change offscreen FBO viewport.
virtual void FBOChangeViewport (Graphic3d_PtrFrameBuffer& theFBOPtr,
const Standard_Integer theWidth,
const Standard_Integer theHeight) = 0;
public:
//! Copy visualization settings from another view.
//! Method is used for cloning views in viewer when its required to create view
//! with same view properties.
Standard_EXPORT virtual void CopySettings (const Handle(Graphic3d_CView)& theOther);
//! Returns current rendering parameters and effect settings.
const Graphic3d_RenderingParams& RenderingParams() const { return myRenderParams; }
//! Returns reference to current rendering parameters and effect settings.
Graphic3d_RenderingParams& ChangeRenderingParams() { return myRenderParams; }
//! Returns true if anti-aliasing is enabled for the view.
virtual Standard_Boolean IsAntialiasingEnabled() const = 0;
//! Enable or disable anti-aliasing in the view.
virtual void SetAntialiasingEnabled (const Standard_Boolean theIsEnabled) = 0;
//! Returns background fill color.
virtual Aspect_Background Background() const = 0;
//! Sets background fill color.
virtual void SetBackground (const Aspect_Background& theBackground) = 0;
//! Returns gradient background fill colors.
virtual Aspect_GradientBackground GradientBackground() const = 0;
//! Sets gradient background fill colors.
virtual void SetGradientBackground (const Aspect_GradientBackground& theBackground) = 0;
//! Returns background image texture file path.
virtual TCollection_AsciiString BackgroundImage() = 0;
//! Sets background image texture file path.
virtual void SetBackgroundImage (const TCollection_AsciiString& theFilePath) = 0;
//! Returns background image fill style.
virtual Aspect_FillMethod BackgroundImageStyle() const = 0;
//! Sets background image fill style.
virtual void SetBackgroundImageStyle (const Aspect_FillMethod theFillStyle) = 0;
//! Returns environment texture set for the view.
virtual Handle(Graphic3d_TextureEnv) TextureEnv() const = 0;
//! Sets environment texture for the view.
virtual void SetTextureEnv (const Handle(Graphic3d_TextureEnv)& theTextureEnv) = 0;
//! Returns the state of frustum culling optimization.
virtual Standard_Boolean IsCullingEnabled() const = 0;
//! Enables or disables frustum culling optimization.
virtual void SetCullingEnabled (const Standard_Boolean theIsEnabled) = 0;
//! Returns shading model of the view.
virtual Graphic3d_TypeOfShadingModel ShadingModel() const = 0;
//! Sets shading model of the view.
virtual void SetShadingModel (const Graphic3d_TypeOfShadingModel theModel) = 0;
//! Returns surface detail type of the view.
virtual Graphic3d_TypeOfSurfaceDetail SurfaceDetailType() const = 0;
//! Sets surface detail type of the view.
virtual void SetSurfaceDetailType (const Graphic3d_TypeOfSurfaceDetail theType) = 0;
//! Return backfacing model used for the view.
virtual Graphic3d_TypeOfBackfacingModel BackfacingModel() const = 0;
//! Sets backfacing model for the view.
virtual void SetBackfacingModel (const Graphic3d_TypeOfBackfacingModel theModel) = 0;
//! Returns camera object of the view.
virtual const Handle(Graphic3d_Camera)& Camera() const = 0;
//! Sets camera used by the view.
virtual void SetCamera (const Handle(Graphic3d_Camera)& theCamera) = 0;
//! Returns the activity of back z-clipping plane.
virtual Standard_Boolean BackZClippingIsOn() const = 0;
//! Activates the back Z-clipping plane.
virtual void SetBackZClippingOn (const Standard_Boolean theIsOn) = 0;
//! Returns the definition of the back Z-clipping plane.
virtual Standard_Real ZClippingBackPlane() const = 0;
//! Sets the definition of the back Z-clipping plane.
virtual void SetZClippingBackPlane (const Standard_Real theValue) = 0;
//! Returns the activity of front z-clipping plane.
virtual Standard_Boolean FrontZClippingIsOn() const = 0;
//! Activates the front Z-clipping plane.
virtual void SetFrontZClippingOn (const Standard_Boolean theIsOn) = 0;
//! Returns the definition of the front Z-clipping plane.
virtual Standard_Real ZClippingFrontPlane() const = 0;
//! Sets the definition of the front Z-clipping plane.
virtual void SetZClippingFrontPlane (const Standard_Real theValue) = 0;
//! Returns the activity of depth cueing.
virtual Standard_Boolean DepthCueingIsOn() const = 0;
//! Sets the activity of depth cueing.
virtual void SetDepthCueingOn (const Standard_Boolean theIsOn) = 0;
//! Returns the back depth cueing plane.
virtual Standard_Real DepthCueingBackPlane() const = 0;
//! Set the back depth cueing plane.
virtual void SetDepthCueingBackPlane (const Standard_Real theValue) = 0;
//! Returns the front depth cueing plane.
virtual Standard_Real DepthCueingFrontPlane() const = 0;
//! Set the front depth cueing plane.
virtual void SetDepthCueingFrontPlane (const Standard_Real theValue) = 0;
//! Returns true if GL lighting is enabled.
virtual Standard_Boolean IsGLLightEnabled() const = 0;
//! Sets GL lighting enabled or disable state.
virtual void SetGLLightEnabled (const Standard_Boolean theIsEnabled) = 0;
//! Returns list of lights of the view.
virtual const Graphic3d_ListOfCLight& Lights() const = 0;
//! Sets list of lights for the view.
virtual void SetLights (const Graphic3d_ListOfCLight& theLights) = 0;
//! Returns list of clip planes set for the view.
virtual const Graphic3d_SequenceOfHClipPlane& ClipPlanes() const = 0;
//! Sets list of clip planes for the view.
virtual void SetClipPlanes (const Graphic3d_SequenceOfHClipPlane& thePlanes) = 0;
private:
//! Adds the structure to display lists of the view.
virtual void displayStructure (const Handle(Graphic3d_CStructure)& theStructure,
const Standard_Integer thePriority) = 0;
//! Erases the structure from display lists of the view.
virtual void eraseStructure (const Handle(Graphic3d_CStructure)& theStructure) = 0;
//! Change Z layer of a structure already presented in view.
virtual void changeZLayer (const Handle(Graphic3d_CStructure)& theCStructure,
const Graphic3d_ZLayerId theNewLayerId) = 0;
//! Changes the priority of a structure within its Z layer in the specified view.
virtual void changePriority (const Handle(Graphic3d_CStructure)& theCStructure,
const Standard_Integer theNewPriority) = 0;
protected:
struct CachedMinMax
{
//
}
CachedMinMax() { Invalidate(); }
public:
Bnd_Box& BoundingBox (const Standard_Boolean theToIgnoreInfiniteFlag)
{
return !theToIgnoreInfiniteFlag ? myBoundingBox[0] : myBoundingBox[1];
}
Standard_Boolean& IsOutdated (const Standard_Boolean theToIgnoreInfiniteFlag)
{
return !theToIgnoreInfiniteFlag ? myIsOutdated[0] : myIsOutdated[1];
}
void Invalidate()
{
myIsOutdated[0] = Standard_True;
myIsOutdated[1] = Standard_True;
}
int Aliasing;
Standard_Boolean myIsOutdated [2];
Bnd_Box myBoundingBox[2];
};
int BackZClipping;
int FrontZClipping;
protected:
int DepthCueing;
Standard_Integer myId;
Graphic3d_RenderingParams myRenderParams;
Handle(Graphic3d_StructureManager) myStructureManager;
Graphic3d_SequenceOfStructure myStructsToCompute;
Graphic3d_SequenceOfStructure myStructsComputed;
Graphic3d_MapOfStructure myStructsDisplayed;
Handle(Graphic3d_NMapOfTransient) myHiddenObjects;
Standard_Boolean myIsInComputedMode;
Standard_Boolean myIsActive;
Standard_Boolean myIsRemoved;
Graphic3d_TypeOfVisualization myVisualization;
mutable CachedMinMax myMinMax;
float ZClipFrontPlane;
float ZClipBackPlane;
private:
float DepthFrontPlane;
float DepthBackPlane;
int Model;
int Visualization;
int NbActiveLight;
Graphic3d_CLight* ActiveLight;
Handle(Graphic3d_TextureEnv) TextureEnv;
int SurfaceDetail;
Graphic3d_SequenceOfHClipPlane ClipPlanes;
Handle(Graphic3d_Camera) Camera;
DEFINE_STANDARD_RTTI (Graphic3d_CView, Graphic3d_DataStructureManager)
};
class Graphic3d_CView
{
public:
Graphic3d_CView()
: WsId (-1),
ViewId (0),
ptrView (NULL),
IsDeleted (0),
IsOpen (0),
Active (0),
ptrUnderLayer (NULL),
ptrOverLayer (NULL),
Backfacing (0),
GContext (NULL),
GDisplayCB (NULL),
GClientData (NULL),
ptrFBO (NULL),
WasRedrawnGL (0),
IsCullingEnabled (Standard_True)
{
memset (&DefWindow, 0, sizeof(DefWindow));
}
public:
int WsId;
int ViewId;
void* ptrView;
int IsDeleted;
int IsOpen;
int Active;
CALL_DEF_VIEWCONTEXT Context;
CALL_DEF_WINDOW DefWindow;
void* ptrUnderLayer;
void* ptrOverLayer;
int Backfacing;
Aspect_RenderingContext GContext;
Aspect_GraphicCallbackProc GDisplayCB;
void* GClientData;
void* ptrFBO;
//! Was the window redrawn by standard OpenGL?
mutable int WasRedrawnGL;
//! Specifies rendering parameters and effects.
Graphic3d_RenderingParams RenderParams;
//! Enables/disables frustum culling.
Standard_Boolean IsCullingEnabled;
};
#endif // Graphic3d_CView_HeaderFile
#endif // _Graphic3d_CView_HeaderFile

43
src/Graphic3d/Graphic3d_Camera.cxx
View File

@ -235,6 +235,11 @@ gp_Dir Graphic3d_Camera::Direction() const
// =======================================================================
void Graphic3d_Camera::SetScale (const Standard_Real theScale)
{
if (Scale() == theScale)
{
return;
}
myScale = theScale;
switch (myProjType)
@ -281,7 +286,7 @@ Standard_Real Graphic3d_Camera::Scale() const
// =======================================================================
void Graphic3d_Camera::SetProjectionType (const Projection theProjectionType)
{
Projection anOldType = myProjType;
Projection anOldType = ProjectionType();
if (anOldType == theProjectionType)
{
@ -311,7 +316,13 @@ void Graphic3d_Camera::SetProjectionType (const Projection theProjectionType)
// =======================================================================
void Graphic3d_Camera::SetFOVy (const Standard_Real theFOVy)
{
if (FOVy() == theFOVy)
{
return;
}
myFOVy = theFOVy;
InvalidateProjection();
}
@ -329,6 +340,12 @@ void Graphic3d_Camera::SetZRange (const Standard_Real theZNear,
Standard_ASSERT_RAISE (theZFar > 0.0, "Only positive Z-Far is allowed for perspective camera");
}
if (ZNear() == theZNear
&& ZFar () == theZFar)
{
return;
}
myZNear = theZNear;
myZFar = theZFar;
@ -341,7 +358,13 @@ void Graphic3d_Camera::SetZRange (const Standard_Real theZNear,
// =======================================================================
void Graphic3d_Camera::SetAspect (const Standard_Real theAspect)
{
if (Aspect() == theAspect)
{
return;
}
myAspect = theAspect;
InvalidateProjection();
}
@ -351,8 +374,15 @@ void Graphic3d_Camera::SetAspect (const Standard_Real theAspect)
// =======================================================================
void Graphic3d_Camera::SetZFocus(const FocusType theType, const Standard_Real theZFocus)
{
if (ZFocusType() == theType
&& ZFocus () == theZFocus)
{
return;
}
myZFocusType = theType;
myZFocus = theZFocus;
myZFocus = theZFocus;
InvalidateProjection();
}
@ -362,8 +392,15 @@ void Graphic3d_Camera::SetZFocus(const FocusType theType, const Standard_Real th
// =======================================================================
void Graphic3d_Camera::SetIOD (const IODType theType, const Standard_Real theIOD)
{
if (IODType() == theType
&& IOD () == theIOD)
{
return;
}
myIODType = theType;
myIOD = theIOD;
myIOD = theIOD;
InvalidateProjection();
}

8
src/Graphic3d/Graphic3d_GraduatedTrihedron.hxx
View File

@ -24,7 +24,7 @@
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
class Visual3d_View;
class Graphic3d_CView;
//! Class that stores style for one graduated trihedron axis such as colors, lengths and customization flags.
//! It is used in Graphic3d_GraduatedTrihedron.
@ -111,7 +111,7 @@ class Graphic3d_GraduatedTrihedron
{
public:
typedef void (*MinMaxValuesCallback) (Visual3d_View*);
typedef void (*MinMaxValuesCallback) (Graphic3d_CView*);
public:
@ -138,7 +138,7 @@ public:
myAxes (0) = Graphic3d_AxisAspect ("X", Quantity_NOC_RED, Quantity_NOC_RED);
myAxes (1) = Graphic3d_AxisAspect ("Y", Quantity_NOC_GREEN, Quantity_NOC_GREEN);
myAxes (2) = Graphic3d_AxisAspect ("Z", Quantity_NOC_BLUE1, Quantity_NOC_BLUE1);
PtrVisual3dView = NULL;
PtrView = NULL;
}
public:
@ -196,7 +196,7 @@ public:
public:
MinMaxValuesCallback CubicAxesCallback; //!< Callback function to define boundary box of displayed objects
Visual3d_View* PtrVisual3dView;
Graphic3d_CView* PtrView;
protected:

8
src/Graphic3d/Graphic3d_GraphicDriver.cxx
View File

@ -14,7 +14,6 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_GraphicDriver.hxx>
#include <Graphic3d_Structure.hxx>
#include <Graphic3d_StructureManager.hxx>
@ -79,10 +78,9 @@ void Graphic3d_GraphicDriver::PrintCStructure (const Graphic3d_CStructure& ACStr
void Graphic3d_GraphicDriver::PrintCView (const Graphic3d_CView& ACView, const Standard_Integer AField) const {
if (AField) {
cout << "\tws id " << ACView.WsId << ", "
<< "view id " << ACView.ViewId << "\n";
cout << "\tXwindow id " << ACView.DefWindow.XWindow << ", "
<< "activity " << ACView.Active << "\n";
cout << "view id " << ACView.Identification() << "\n";
cout << "\tXwindow id " << (ACView.Window().IsNull() ? 0 : ACView.Window()->NativeHandle()) << ", "
<< "activity " << ACView.IsActive() << "\n";
cout << flush;
}

233
src/Graphic3d/Graphic3d_GraphicDriver.hxx
View File

@ -49,14 +49,17 @@
#include <Graphic3d_ZLayerSettings.hxx>
#include <Graphic3d_CLight.hxx>
#include <TColStd_Array2OfReal.hxx>
#include <TColStd_SequenceOfInteger.hxx>
class Graphic3d_CView;
class Graphic3d_GraphicDriver;
class Graphic3d_TransformError;
class Graphic3d_Structure;
class Graphic3d_StructureManager;
class Graphic3d_ViewManager;
class Quantity_Color;
class TCollection_AsciiString;
class Graphic3d_GraphicDriver;
DEFINE_STANDARD_HANDLE(Graphic3d_GraphicDriver, MMgt_TShared)
//! This class allows the definition of a graphic driver
@ -68,218 +71,63 @@ public:
//! call_togl_inquirelight
Standard_EXPORT virtual Standard_Integer InquireLightLimit() = 0;
virtual Standard_Integer InquireLightLimit() = 0;
//! call_togl_inquireplane
Standard_EXPORT virtual Standard_Integer InquirePlaneLimit() = 0;
virtual Standard_Integer InquirePlaneLimit() = 0;
//! call_togl_inquireview
Standard_EXPORT virtual Standard_Integer InquireViewLimit() = 0;
//! call_togl_displaystructure
Standard_EXPORT virtual void DisplayStructure (const Graphic3d_CView& theCView, const Handle(Graphic3d_Structure)& theStructure, const Standard_Integer thePriority) = 0;
//! call_togl_erasestructure
Standard_EXPORT virtual void EraseStructure (const Graphic3d_CView& theCView, const Handle(Graphic3d_Structure)& theStructure) = 0;
//! call_togl_removestructure
Standard_EXPORT virtual void RemoveStructure (Handle(Graphic3d_CStructure)& theCStructure) = 0;
virtual Standard_Integer InquireViewLimit() = 0;
//! Creates new empty graphic structure
Standard_EXPORT virtual Handle(Graphic3d_CStructure) Structure (const Handle(Graphic3d_StructureManager)& theManager) = 0;
virtual Handle(Graphic3d_CStructure) CreateStructure (const Handle(Graphic3d_StructureManager)& theManager) = 0;
//! call_togl_activateview
Standard_EXPORT virtual void ActivateView (const Graphic3d_CView& ACView) = 0;
//! Removes structure from graphic driver and releases its resources.
virtual void RemoveStructure (Handle(Graphic3d_CStructure)& theCStructure) = 0;
//! call_togl_antialiasing
Standard_EXPORT virtual void AntiAliasing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag) = 0;
//! Creates new view for this graphic driver.
virtual Handle(Graphic3d_CView) CreateView (const Handle(Graphic3d_StructureManager)& theMgr) = 0;
//! call_togl_background
Standard_EXPORT virtual void Background (const Graphic3d_CView& ACView) = 0;
//! call_togl_gradient_background
Standard_EXPORT virtual void GradientBackground (const Graphic3d_CView& ACView, const Quantity_Color& AColor1, const Quantity_Color& AColor2, const Aspect_GradientFillMethod FillStyle) = 0;
Standard_EXPORT virtual void BackgroundImage (const Standard_CString FileName, const Graphic3d_CView& ACView, const Aspect_FillMethod FillStyle) = 0;
Standard_EXPORT virtual void SetBgImageStyle (const Graphic3d_CView& ACView, const Aspect_FillMethod FillStyle) = 0;
Standard_EXPORT virtual void SetBgGradientStyle (const Graphic3d_CView& ACView, const Aspect_GradientFillMethod FillStyle) = 0;
//! call_togl_cliplimit
Standard_EXPORT virtual void ClipLimit (const Graphic3d_CView& ACView, const Standard_Boolean AWait) = 0;
//! call_togl_deactivateview
Standard_EXPORT virtual void DeactivateView (const Graphic3d_CView& ACView) = 0;
//! call_togl_cliplimit
Standard_EXPORT virtual void DepthCueing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag) = 0;
//! call_togl_ratio_window
Standard_EXPORT virtual void RatioWindow (const Graphic3d_CView& ACView) = 0;
//! Redraw content of the view
Standard_EXPORT virtual void Redraw (const Graphic3d_CView& theCView, const Standard_Integer theX = 0, const Standard_Integer theY = 0, const Standard_Integer theWidth = 0, const Standard_Integer theHeight = 0) = 0;
//! Redraw layer of immediate presentations
Standard_EXPORT virtual void RedrawImmediate (const Graphic3d_CView& theCView) = 0;
//! Invalidates content of the view but does not redraw it
Standard_EXPORT virtual void Invalidate (const Graphic3d_CView& theCView) = 0;
//! Removes view from graphic driver and releases its resources.
virtual void RemoveView (const Handle(Graphic3d_CView)& theView) = 0;
//! Returns true if cached view content has been invalidated.
Standard_EXPORT virtual Standard_Boolean IsInvalidated (const Graphic3d_CView& theCView) const = 0;
//! call_togl_removeview
Standard_EXPORT virtual void RemoveView (const Graphic3d_CView& ACView) = 0;
//! call_togl_setlight
Standard_EXPORT virtual void SetLight (const Graphic3d_CView& ACView) = 0;
//! Pass clip planes to the associated graphic driver view.
Standard_EXPORT virtual void SetClipPlanes (const Graphic3d_CView& theCView) = 0;
//! Inform graphic driver if camera assigned to view changes.
Standard_EXPORT virtual void SetCamera (const Graphic3d_CView& theCView) = 0;
//! call_togl_setvisualisation
Standard_EXPORT virtual void SetVisualisation (const Graphic3d_CView& ACView) = 0;
//! call_togl_view
Standard_EXPORT virtual Standard_Boolean View (Graphic3d_CView& ACView) = 0;
Standard_EXPORT virtual void Environment (const Graphic3d_CView& ACView) = 0;
//! enables/disables usage of OpenGL vertex buffer arrays while drawing primitiev arrays
Standard_EXPORT virtual void EnableVBO (const Standard_Boolean status) = 0;
virtual void EnableVBO (const Standard_Boolean status) = 0;
//! Returns information about GPU memory usage.
Standard_EXPORT virtual Standard_Boolean MemoryInfo (Standard_Size& theFreeBytes, TCollection_AsciiString& theInfo) const = 0;
virtual Standard_Boolean MemoryInfo (Standard_Size& theFreeBytes, TCollection_AsciiString& theInfo) const = 0;
//! call_togl_ztriedron_setup
Standard_EXPORT virtual void ZBufferTriedronSetup (const Graphic3d_CView& theCView, 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) = 0;
//! call_togl_triedron_display
Standard_EXPORT virtual 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) = 0;
//! call_togl_triedron_erase
Standard_EXPORT virtual void TriedronErase (const Graphic3d_CView& ACView) = 0;
//! call_togl_triedron_echo
Standard_EXPORT virtual void TriedronEcho (const Graphic3d_CView& ACView, const Aspect_TypeOfTriedronEcho AType = Aspect_TOTE_NONE) = 0;
//! call_togl_graduatedtrihedron_display
Standard_EXPORT virtual void GraduatedTrihedronDisplay (const Graphic3d_CView& theView, const Graphic3d_GraduatedTrihedron& theCubic) = 0;
//! call_togl_graduatedtrihedron_erase
Standard_EXPORT virtual void GraduatedTrihedronErase (const Graphic3d_CView& theView) = 0;
//! Sets minimum and maximum points of scene bounding box for Graduated Trihedron
//! stored in graphic view object.
//! @param theView [in] current graphic view
//! @param theMin [in] the minimum point of scene.
//! @param theMax [in] the maximum point of scene.
Standard_EXPORT virtual void GraduatedTrihedronMinMaxValues (const Graphic3d_CView& theView, const Graphic3d_Vec3 theMin, const Graphic3d_Vec3 theMax) = 0;
//! @param theDrawToFrontBuffer Advanced option to modify rendering mode:
//! 1. TRUE. Drawing immediate mode structures directly to the front buffer over the scene image.
//! Fast, so preferred for interactive work (used by default).
//! However these extra drawings will be missed in image dump since it is performed from back buffer.
//! Notice that since no pre-buffering used the V-Sync will be ignored and rendering could be seen
//! in run-time (in case of slow hardware) and/or tearing may appear.
//! So this is strongly recommended to draw only simple (fast) structures.
//! 2. FALSE. Drawing immediate mode structures to the back buffer.
//! The complete scene is redrawn first, so this mode is slower if scene contains complex data and/or V-Sync is turned on.
//! But it works in any case and is especially useful for view dump because the dump image is read from the back buffer.
//! @return previous mode.
Standard_EXPORT virtual Standard_Boolean SetImmediateModeDrawToFront (const Graphic3d_CView& theCView, const Standard_Boolean theDrawToFrontBuffer) = 0;
Standard_EXPORT virtual Standard_ShortReal DefaultTextHeight() const = 0;
virtual Standard_ShortReal DefaultTextHeight() const = 0;
//! call_togl_textsize2d
Standard_EXPORT virtual void TextSize (const Standard_CString AText, const Standard_ShortReal AHeight, Standard_ShortReal& AWidth, Standard_ShortReal& AnAscent, Standard_ShortReal& ADescent) const = 0;
//! call_togl_backfacing
Standard_EXPORT virtual void SetBackFacingModel (const Graphic3d_CView& aView) = 0;
//! Reads depths of shown pixels of the given
//! rectangle (glReadPixels with GL_DEPTH_COMPONENT)
Standard_EXPORT virtual 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 = 0;
//! Generate offscreen FBO in the graphic library.
//! If not supported on hardware returns NULL.
Standard_EXPORT virtual Graphic3d_PtrFrameBuffer FBOCreate (const Graphic3d_CView& view, const Standard_Integer width, const Standard_Integer height) = 0;
//! Remove offscreen FBO from the graphic library
Standard_EXPORT virtual void FBORelease (const Graphic3d_CView& view, Graphic3d_PtrFrameBuffer& fboPtr) = 0;
//! Read offscreen FBO configuration.
Standard_EXPORT virtual void FBOGetDimensions (const Graphic3d_CView& view, const Graphic3d_PtrFrameBuffer fboPtr, Standard_Integer& width, Standard_Integer& height, Standard_Integer& widthMax, Standard_Integer& heightMax) = 0;
//! Change offscreen FBO viewport.
Standard_EXPORT virtual void FBOChangeViewport (const Graphic3d_CView& view, Graphic3d_PtrFrameBuffer& fboPtr, const Standard_Integer width, const Standard_Integer height) = 0;
//! Dump active rendering buffer into specified memory buffer.
Standard_EXPORT virtual Standard_Boolean BufferDump (const Graphic3d_CView& theCView, Image_PixMap& theImage, const Graphic3d_BufferType& theBufferType) = 0;
//! call_togl_gllight
Standard_EXPORT virtual void SetGLLightEnabled (const Graphic3d_CView& view, const Standard_Boolean isEnabled) const = 0;
//! call_togl_isgllight
Standard_EXPORT virtual Standard_Boolean IsGLLightEnabled (const Graphic3d_CView& view) const = 0;
//! print the contents of all layers of the view to the printer.
//! <hPrnDC> : Pass the PrinterDeviceContext (HDC),
//! <showBackground> : When set to FALSE then print the view without background color
//! (background is white)
//! else set to TRUE for printing with current background color.
//! <filename>: If != NULL, then the view will be printed to a file.
//! <printAlgorithm>: Select print algorithm: stretch, tile.
//! <theScaleFactor>: Scaling coefficient, used internally to scale the
//! printings accordingly to the scale factor selected in the printer
//! properties dialog.
//! Returns Standard_True if the data is passed to the printer, otherwise
//! Standard_False if the print operation failed due to the printer errors,
//! or insufficient system memory available.
Standard_EXPORT virtual Standard_Boolean Print (const Graphic3d_CView& ACView, 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 = 0;
virtual void TextSize (const Standard_CString AText, const Standard_ShortReal AHeight, Standard_ShortReal& AWidth, Standard_ShortReal& AnAscent, Standard_ShortReal& ADescent) const = 0;
//! Export scene into the one of the Vector graphics formats (SVG, PS, PDF...).
//! In contrast to Bitmaps, Vector graphics is scalable (so you may got quality benefits on printing to laser printer).
//! Notice however that results may differ a lot and do not contain some elements.
Standard_EXPORT virtual 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 Standard_Real thePrecision = 0.005, const Standard_Address theProgressBarFunc = NULL, const Standard_Address theProgressObject = NULL) = 0;
//! Marks BVH tree and the set of BVH primitives of correspondent priority list with id theLayerId as outdated.
Standard_EXPORT virtual void InvalidateBVHData (Graphic3d_CView& theCView, const Standard_Integer theLayerId) = 0;
//! Add a new top-level z layer with ID <theLayerId> for
//! the view. Z layers allow drawing structures in higher layers
//! in foreground of structures in lower layers. To add a structure
//! to desired layer on display it is necessary to set the layer
//! ID for the structure.
Standard_EXPORT virtual void AddZLayer (const Graphic3d_CView& theCView, const Graphic3d_ZLayerId theLayerId) = 0;
//! Remove Z layer from the specified view. All structures
//! displayed at the moment in layer will be displayed in default layer
//! ( the bottom-level z layer ). To unset layer ID from associated
//! structures use method UnsetZLayer (...).
Standard_EXPORT virtual void RemoveZLayer (const Graphic3d_CView& theCView, const Graphic3d_ZLayerId theLayerId) = 0;
//! Unset Z layer ID for all structures. The structure
//! indexes will be set to default layer ( the bottom-level z layer
//! with ID = 0 ).
Standard_EXPORT virtual void UnsetZLayer (const Graphic3d_ZLayerId theLayerId) = 0;
virtual void AddZLayer (const Graphic3d_ZLayerId theLayerId) = 0;
//! Change Z layer of a structure already presented in view.
Standard_EXPORT virtual void ChangeZLayer (const Graphic3d_CStructure& theCStructure, const Graphic3d_CView& theCView, const Graphic3d_ZLayerId theNewLayerId) = 0;
//! Sets the settings for a single Z layer of specified view.
Standard_EXPORT virtual void SetZLayerSettings (const Graphic3d_CView& theCView, const Graphic3d_ZLayerId theLayerId, const Graphic3d_ZLayerSettings& theSettings) = 0;
//! Removes Z layer. All structures displayed at the moment in layer will be displayed in
//! default layer (the bottom-level z layer). By default, there are always default
//! bottom-level layer that can't be removed. The passed theLayerId should be not less than 0
//! (reserved for default layers that can not be removed).
virtual void RemoveZLayer (const Graphic3d_ZLayerId theLayerId) = 0;
//! Returns list of Z layers defined for the graphical driver.
virtual void ZLayers (TColStd_SequenceOfInteger& theLayerSeq) const = 0;
//! Sets the settings for a single Z layer.
virtual void SetZLayerSettings (const Graphic3d_ZLayerId theLayerId, const Graphic3d_ZLayerSettings& theSettings) = 0;
//! Returns the settings of a single Z layer.
virtual Graphic3d_ZLayerSettings ZLayerSettings (const Graphic3d_ZLayerId theLayerId) = 0;
//! Returns view associated with the window if it is exists and is activated.
//! Returns Standard_True if the view associated to the window exists.
virtual Standard_Boolean ViewExists (const Handle(Aspect_Window)& theWindow, Handle(Graphic3d_CView)& theView) = 0;
//! Changes the priority of a structure within its Z layer in the specified view.
Standard_EXPORT virtual void ChangePriority (const Graphic3d_CStructure& theCStructure, const Graphic3d_CView& theCView, const Standard_Integer theNewPriority) = 0;
Standard_EXPORT void PrintBoolean (const Standard_CString AComment, const Standard_Boolean AValue) const;
Standard_EXPORT void PrintCLight (const Graphic3d_CLight& ACLight, const Standard_Integer AField) const;
@ -311,15 +159,12 @@ public:
Standard_EXPORT void ResetDeviceLostFlag();
DEFINE_STANDARD_RTTI(Graphic3d_GraphicDriver,MMgt_TShared)
protected:
//! Initialises the Driver
//! Initializes the Driver
Standard_EXPORT Graphic3d_GraphicDriver(const Handle(Aspect_DisplayConnection)& theDisp);
Standard_Integer MyTraceLevel;

5
src/Graphic3d/Graphic3d_Group.cxx
View File

@ -259,10 +259,7 @@ void Graphic3d_Group::Update() const
return;
}
if (myStructure->StructureManager()->UpdateMode() == Aspect_TOU_ASAP)
{
myStructure->StructureManager()->Update();
}
myStructure->StructureManager()->Update (myStructure->StructureManager()->UpdateMode());
}
// =======================================================================

8
src/Graphic3d/Graphic3d_MaterialAspect.hxx
View File

@ -95,14 +95,6 @@ public:
//! one of reflection modes (ambient, diffuse, specular or emissive)
//! enabled. See also SetReflectionModeOn() and SetReflectionModeOff() methods.
//!
//! NOTE: In order for transparency specified through this method to
//! take effect, it is necessary to enable transparency
//! in the viewer. This can be done either directly -
//! see Visual3d_ViewManager::SetTransparency(Standard_Boolean),
//! or indirectly - by calling AIS_InteractiveObject::SetTransparency()
//! before an object is added to an interactive context, or by
//! calling AIS_InteractiveContext::SetTransparency() for a given
//! interactive object already displayed.
//! Category: Methods to modify the class definition
//! Warning: Raises MaterialDefinitionError if <AValue> is a
//! negative value or greater than 1.0.

7
src/Graphic3d/Graphic3d_Structure.cxx
View File

@ -53,7 +53,7 @@ Graphic3d_Structure::Graphic3d_Structure (const Handle(Graphic3d_StructureManage
myOwner (NULL),
myVisual (Graphic3d_TOS_ALL)
{
myCStructure = theManager->GraphicDriver()->Structure (theManager);
myCStructure = theManager->GraphicDriver()->CreateStructure (theManager);
// default aspects
Handle(Graphic3d_AspectLine3d) aAspectLine3d = new Graphic3d_AspectLine3d();
@ -2033,10 +2033,7 @@ void Graphic3d_Structure::Update() const
return;
}
if (myStructureManager->UpdateMode() == Aspect_TOU_ASAP)
{
myStructureManager->Update();
}
myStructureManager->Update (myStructureManager->UpdateMode());
}
//=============================================================================

381
src/Graphic3d/Graphic3d_StructureManager.cxx
View File

@ -42,6 +42,7 @@ static Standard_Integer StructureManager_CurrentId = 0;
#include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
Graphic3d_StructureManager::Graphic3d_StructureManager (const Handle(Graphic3d_GraphicDriver)& theDriver)
: myViewGenId (0, 31)
{
Standard_Real Coef;
@ -81,17 +82,17 @@ Standard_Integer Limit = Graphic3d_StructureManager::Limit ();
Aspect_GenId theGenId(
Standard_Integer (Structure_IDMIN+Coef*(StructureManager_CurrentId)),
Standard_Integer (Structure_IDMIN+Coef*(StructureManager_CurrentId+1)-1));
MyStructGenId = theGenId;
myStructGenId = theGenId;
MyId = StructureManager_CurrentId;
myId = StructureManager_CurrentId;
MyAspectLine3d = new Graphic3d_AspectLine3d ();
MyAspectText3d = new Graphic3d_AspectText3d ();
MyAspectMarker3d = new Graphic3d_AspectMarker3d ();
MyAspectFillArea3d = new Graphic3d_AspectFillArea3d ();
myAspectLine3d = new Graphic3d_AspectLine3d ();
myAspectText3d = new Graphic3d_AspectText3d ();
myAspectMarker3d = new Graphic3d_AspectMarker3d ();
myAspectFillArea3d = new Graphic3d_AspectFillArea3d ();
MyUpdateMode = Aspect_TOU_WAIT;
MyGraphicDriver = theDriver;
myUpdateMode = Aspect_TOU_WAIT;
myGraphicDriver = theDriver;
}
@ -99,103 +100,150 @@ Standard_Integer Limit = Graphic3d_StructureManager::Limit ();
void Graphic3d_StructureManager::Destroy () {
MyDisplayedStructure.Clear ();
MyHighlightedStructure.Clear ();
StructureManager_ArrayId[MyId] = 0;
myDisplayedStructure.Clear ();
myHighlightedStructure.Clear ();
myDefinedViews.Clear();
StructureManager_ArrayId[myId] = 0;
}
//-Methods, in order
void Graphic3d_StructureManager::SetUpdateMode (const Aspect_TypeOfUpdate AType) {
MyUpdateMode = AType;
// ========================================================================
// function : SetUpdateMode
// purpose :
// ========================================================================
void Graphic3d_StructureManager::SetUpdateMode (const Aspect_TypeOfUpdate theType)
{
myUpdateMode = theType;
}
Aspect_TypeOfUpdate Graphic3d_StructureManager::UpdateMode () const {
return (MyUpdateMode);
// ========================================================================
// function : UpdateMode
// purpose :
// ========================================================================
Aspect_TypeOfUpdate Graphic3d_StructureManager::UpdateMode() const
{
return myUpdateMode;
}
// ========================================================================
// function : Update
// purpose :
// ========================================================================
void Graphic3d_StructureManager::Update (const Aspect_TypeOfUpdate theMode) const
{
for (Graphic3d_IndexedMapOfView::Iterator aViewIt (myDefinedViews); aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->Update (theMode);
}
}
// ========================================================================
// function : Remove
// purpose :
// ========================================================================
void Graphic3d_StructureManager::Remove()
{
// clear all structures whilst views are alive for correct GPU memory management
myDisplayedStructure.Clear();
myHighlightedStructure.Clear();
// clear list of managed views
myDefinedViews.Clear();
}
// ========================================================================
// function : Erase
// purpose :
// ========================================================================
void Graphic3d_StructureManager::Erase()
{
for (Graphic3d_MapIteratorOfMapOfStructure anIt (myDisplayedStructure); anIt.More(); anIt.Next())
{
anIt.Key()->Erase();
}
}
void Graphic3d_StructureManager::SetPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& CTX) {
MyAspectLine3d = CTX;
myAspectLine3d = CTX;
}
void Graphic3d_StructureManager::SetPrimitivesAspect (const Handle(Graphic3d_AspectFillArea3d)& CTX) {
MyAspectFillArea3d = CTX;
myAspectFillArea3d = CTX;
}
void Graphic3d_StructureManager::SetPrimitivesAspect (const Handle(Graphic3d_AspectText3d)& CTX) {
MyAspectText3d = CTX;
myAspectText3d = CTX;
}
void Graphic3d_StructureManager::SetPrimitivesAspect (const Handle(Graphic3d_AspectMarker3d)& CTX) {
MyAspectMarker3d = CTX;
myAspectMarker3d = CTX;
}
void Graphic3d_StructureManager::PrimitivesAspect (Handle(Graphic3d_AspectLine3d)& CTXL, Handle(Graphic3d_AspectText3d)& CTXT, Handle(Graphic3d_AspectMarker3d)& CTXM, Handle(Graphic3d_AspectFillArea3d)& CTXF) const {
CTXL = MyAspectLine3d;
CTXT = MyAspectText3d;
CTXM = MyAspectMarker3d;
CTXF = MyAspectFillArea3d;
CTXL = myAspectLine3d;
CTXT = myAspectText3d;
CTXM = myAspectMarker3d;
CTXF = myAspectFillArea3d;
}
Handle(Graphic3d_AspectLine3d) Graphic3d_StructureManager::Line3dAspect () const {
return (MyAspectLine3d);
return (myAspectLine3d);
}
Handle(Graphic3d_AspectText3d) Graphic3d_StructureManager::Text3dAspect () const {
return (MyAspectText3d);
return (myAspectText3d);
}
Handle(Graphic3d_AspectMarker3d) Graphic3d_StructureManager::Marker3dAspect () const {
return (MyAspectMarker3d);
return (myAspectMarker3d);
}
Handle(Graphic3d_AspectFillArea3d) Graphic3d_StructureManager::FillArea3dAspect () const {
return (MyAspectFillArea3d);
return (myAspectFillArea3d);
}
void Graphic3d_StructureManager::Remove (const Standard_Integer AnId) {
void Graphic3d_StructureManager::Remove (const Standard_Integer theId) {
MyStructGenId.Free (AnId);
myStructGenId.Free (theId);
}
void Graphic3d_StructureManager::DisplayedStructures (Graphic3d_MapOfStructure& SG) const {
SG.Assign(MyDisplayedStructure);
SG.Assign(myDisplayedStructure);
//JMBStandard_Integer Length = MyDisplayedStructure.Length ();
//JMBStandard_Integer Length = myDisplayedStructure.Length ();
//JMBfor (Standard_Integer i=1; i<=Length; i++)
//JMB SG.Add (MyDisplayedStructure.Value (i));
//JMB SG.Add (myDisplayedStructure.Value (i));
}
Standard_Integer Graphic3d_StructureManager::NumberOfDisplayedStructures () const {
Standard_Integer Length = MyDisplayedStructure.Extent ();
Standard_Integer Length = myDisplayedStructure.Extent ();
return (Length);
@ -203,19 +251,19 @@ Standard_Integer Length = MyDisplayedStructure.Extent ();
//Handle(Graphic3d_Structure) Graphic3d_StructureManager::DisplayedStructure (const Standard_Integer AnIndex) const {
//return (MyDisplayedStructure.Value (AnIndex));
//return (myDisplayedStructure.Value (AnIndex));
//}
void Graphic3d_StructureManager::HighlightedStructures (Graphic3d_MapOfStructure& SG) const {
SG.Assign(MyHighlightedStructure);
SG.Assign(myHighlightedStructure);
}
Standard_Integer Graphic3d_StructureManager::NewIdentification () {
Standard_Integer Id = MyStructGenId.Next ();
Standard_Integer Id = myStructGenId.Next ();
return Id;
@ -228,7 +276,7 @@ Handle(Graphic3d_Structure) Graphic3d_StructureManager::Identification (const St
Handle(Graphic3d_Structure) StructNull;
Graphic3d_MapIteratorOfMapOfStructure it( MyDisplayedStructure);
Graphic3d_MapIteratorOfMapOfStructure it( myDisplayedStructure);
Handle(Graphic3d_Structure) SGfound;
@ -250,7 +298,7 @@ Handle(Graphic3d_Structure) Graphic3d_StructureManager::Identification (const St
Standard_Integer Graphic3d_StructureManager::Identification () const {
return (MyId);
return (myId);
}
@ -268,7 +316,7 @@ Standard_Integer Graphic3d_StructureManager::CurrentId () {
const Handle(Graphic3d_GraphicDriver)& Graphic3d_StructureManager::GraphicDriver () const {
return (MyGraphicDriver);
return (myGraphicDriver);
}
@ -277,7 +325,7 @@ void Graphic3d_StructureManager::RecomputeStructures()
// Go through all unique structures including child (connected) ones and ensure that they are computed.
Graphic3d_MapOfStructure aStructNetwork;
for (Graphic3d_MapIteratorOfMapOfStructure anIter(MyDisplayedStructure); anIter.More(); anIter.Next())
for (Graphic3d_MapIteratorOfMapOfStructure anIter(myDisplayedStructure); anIter.More(); anIter.Next())
{
Handle(Graphic3d_Structure) aStructure = anIter.Key();
anIter.Key()->Network (anIter.Key(), Graphic3d_TOC_DESCENDANT, aStructNetwork);
@ -320,3 +368,244 @@ Handle(Graphic3d_ViewAffinity) Graphic3d_StructureManager::ObjectAffinity (const
myRegisteredObjects.Find (theObject.operator->(), aResult);
return aResult;
}
// ========================================================================
// function : Identification
// purpose :
// ========================================================================
Standard_Integer Graphic3d_StructureManager::Identification (Graphic3d_CView* theView)
{
if (myDefinedViews.Contains (theView))
{
return theView->Identification();
}
myDefinedViews.Add (theView);
return myViewGenId.Next();
}
// ========================================================================
// function : UnIdentification
// purpose :
// ========================================================================
void Graphic3d_StructureManager::UnIdentification (Graphic3d_CView* theView)
{
if (myDefinedViews.Contains (theView))
{
myDefinedViews.Swap (myDefinedViews.FindIndex (theView), myDefinedViews.Size());
myDefinedViews.RemoveLast();
myViewGenId.Free (theView->Identification());
}
}
// ========================================================================
// function : DefinedViews
// purpose :
// ========================================================================
const Graphic3d_IndexedMapOfView& Graphic3d_StructureManager::DefinedViews() const
{
return myDefinedViews;
}
// ========================================================================
// function : MaxNumOfViews
// purpose :
// ========================================================================
Standard_Integer Graphic3d_StructureManager::MaxNumOfViews() const
{
return myViewGenId.Upper() - myViewGenId.Lower() + 1;
}
// ========================================================================
// function : ReCompute
// purpose :
// ========================================================================
void Graphic3d_StructureManager::ReCompute (const Handle(Graphic3d_Structure)& theStructure)
{
if (!myDisplayedStructure.Contains (theStructure))
{
return;
}
// Recompute structure for all defined views
for (Standard_Integer aViewIt = 1; aViewIt <= myDefinedViews.Extent(); ++aViewIt)
{
ReCompute (theStructure, myDefinedViews (aViewIt));
}
}
// ========================================================================
// function : ReCompute
// purpose :
// ========================================================================
void Graphic3d_StructureManager::ReCompute (const Handle(Graphic3d_Structure)& theStructure,
const Handle(Graphic3d_DataStructureManager)& theProjector)
{
Handle(Graphic3d_CView) aView = Handle(Graphic3d_CView)::DownCast (theProjector);
if (aView.IsNull()
|| !myDefinedViews.Contains (aView.operator->())
|| !myDisplayedStructure.Contains (theStructure))
{
return;
}
aView->ReCompute (theStructure);
}
// ========================================================================
// function : Clear
// purpose :
// ========================================================================
void Graphic3d_StructureManager::Clear (const Handle(Graphic3d_Structure)& theStructure,
const Standard_Boolean theWithDestruction)
{
for (Graphic3d_IndexedMapOfView::Iterator aViewIt (myDefinedViews); aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->Clear (theStructure, theWithDestruction);
}
}
// ========================================================================
// function : Connect
// purpose :
// ========================================================================
void Graphic3d_StructureManager::Connect (const Handle(Graphic3d_Structure)& theMother,
const Handle(Graphic3d_Structure)& theDaughter)
{
for (Graphic3d_IndexedMapOfView::Iterator aViewIt (myDefinedViews); aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->Connect (theMother, theDaughter);
}
}
// ========================================================================
// function : Disconnect
// purpose :
// ========================================================================
void Graphic3d_StructureManager::Disconnect (const Handle(Graphic3d_Structure)& theMother,
const Handle(Graphic3d_Structure)& theDaughter)
{
for (Graphic3d_IndexedMapOfView::Iterator aViewIt (myDefinedViews); aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->Disconnect (theMother, theDaughter);
}
}
// ========================================================================
// function : Display
// purpose :
// ========================================================================
void Graphic3d_StructureManager::Display (const Handle(Graphic3d_Structure)& theStructure)
{
myDisplayedStructure.Add (theStructure);
for (Graphic3d_IndexedMapOfView::Iterator aViewIt (myDefinedViews); aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->Display (theStructure);
}
}
// ========================================================================
// function : Erase
// purpose :
// ========================================================================
void Graphic3d_StructureManager::Erase (const Handle(Graphic3d_Structure)& theStructure)
{
myDisplayedStructure .Remove(theStructure);
myHighlightedStructure.Remove (theStructure);
// Erase structure in all defined views
for (Graphic3d_IndexedMapOfView::Iterator aViewIt (myDefinedViews); aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->Erase (theStructure);
}
}
// ========================================================================
// function : Erase
// purpose :
// ========================================================================
void Graphic3d_StructureManager::Highlight (const Handle(Graphic3d_Structure)& theStructure,
const Aspect_TypeOfHighlightMethod theMethod)
{
myHighlightedStructure.Add (theStructure);
// Highlight in all defined views
for (Graphic3d_IndexedMapOfView::Iterator aViewIt (myDefinedViews); aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->Highlight (theStructure, theMethod);
}
}
// ========================================================================
// function : UnHighlight
// purpose :
// ========================================================================
void Graphic3d_StructureManager::UnHighlight (const Handle(Graphic3d_Structure)& theStructure)
{
myHighlightedStructure.Remove (theStructure);
// UnHighlight in all defined views
for (Graphic3d_IndexedMapOfView::Iterator aViewIt (myDefinedViews); aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->UnHighlight (theStructure);
}
}
// ========================================================================
// function : UnHighlight
// purpose :
// ========================================================================
void Graphic3d_StructureManager::UnHighlight()
{
for (Graphic3d_MapIteratorOfMapOfStructure anIt (myHighlightedStructure); anIt.More(); anIt.Next())
{
anIt.Key()->UnHighlight();
}
}
// ========================================================================
// function : SetTransform
// purpose :
// ========================================================================
void Graphic3d_StructureManager::SetTransform (const Handle(Graphic3d_Structure)& theStructure,
const TColStd_Array2OfReal& theTrsf)
{
for (Graphic3d_IndexedMapOfView::Iterator aViewIt (myDefinedViews); aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->SetTransform (theStructure, theTrsf);
}
}
// ========================================================================
// function : ChangeDisplayPriority
// purpose :
// ========================================================================
void Graphic3d_StructureManager::ChangeDisplayPriority (const Handle(Graphic3d_Structure)& theStructure,
const Standard_Integer theOldPriority,
const Standard_Integer theNewPriority)
{
for (Graphic3d_IndexedMapOfView::Iterator aViewIt (myDefinedViews); aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->ChangePriority (theStructure, theOldPriority, theNewPriority);
}
}
//=======================================================================
//function : ChangeZLayer
//purpose :
//=======================================================================
void Graphic3d_StructureManager::ChangeZLayer (const Handle(Graphic3d_Structure)& theStructure,
const Graphic3d_ZLayerId theLayerId)
{
if (!myDisplayedStructure.Contains (theStructure))
{
return;
}
for (Graphic3d_IndexedMapOfView::Iterator aViewIt (myDefinedViews); aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->ChangeZLayer (theStructure, theLayerId);
}
}

328
src/Graphic3d/Graphic3d_StructureManager.hxx
View File

@ -17,22 +17,26 @@
#ifndef _Graphic3d_StructureManager_HeaderFile
#define _Graphic3d_StructureManager_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
#include <Aspect_TypeOfUpdate.hxx>
#include <Graphic3d_MapOfStructure.hxx>
#include <Graphic3d_MapOfObject.hxx>
#include <Aspect_GenId.hxx>
#include <MMgt_TShared.hxx>
#include <Aspect_TypeOfHighlightMethod.hxx>
#include <Aspect_TypeOfUpdate.hxx>
#include <Graphic3d_CView.hxx>
#include <Graphic3d_MapOfObject.hxx>
#include <Graphic3d_MapOfStructure.hxx>
#include <Graphic3d_ViewAffinity.hxx>
#include <Graphic3d_ZLayerId.hxx>
#include <Graphic3d_ZLayerSettings.hxx>
#include <MMgt_TShared.hxx>
#include <NCollection_IndexedMap.hxx>
#include <Standard.hxx>
#include <Standard_Boolean.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <Aspect_TypeOfHighlightMethod.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Type.hxx>
#include <TColStd_Array2OfReal.hxx>
#include <Graphic3d_ViewAffinity.hxx>
#include <TColStd_SequenceOfInteger.hxx>
typedef NCollection_IndexedMap<Graphic3d_CView*> Graphic3d_IndexedMapOfView;
class Graphic3d_AspectLine3d;
class Graphic3d_AspectText3d;
class Graphic3d_AspectMarker3d;
@ -43,7 +47,6 @@ class Graphic3d_Structure;
class Graphic3d_DataStructureManager;
class Standard_Transient;
class Graphic3d_StructureManager;
DEFINE_STANDARD_HANDLE(Graphic3d_StructureManager, MMgt_TShared)
@ -55,226 +58,209 @@ DEFINE_STANDARD_HANDLE(Graphic3d_StructureManager, MMgt_TShared)
//! Destroy, Highlight, Visible
class Graphic3d_StructureManager : public MMgt_TShared
{
public:
//! Initializes the ViewManager.
//! Currently creating of more than 100 viewer instances
//! is not supported and leads to InitializationError and
//! initialization failure.
//! This limitation might be addressed in some future OCCT releases.
//! Warning: Raises InitialisationError if the initialization
//! of the ViewManager failed.
Standard_EXPORT Graphic3d_StructureManager (const Handle(Graphic3d_GraphicDriver)& theDriver);
//! Deletes the manager <me>.
Standard_EXPORT virtual void Destroy();
~Graphic3d_StructureManager()
{
Destroy();
}
//! Modifies the default attributes for lines
//! in the visualiser.
Standard_EXPORT void SetPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& CTX);
//! Modifies the default attributes for faces
//! in the visualiser.
Standard_EXPORT void SetPrimitivesAspect (const Handle(Graphic3d_AspectFillArea3d)& CTX);
//! Modifies the default attributes for text
//! in the visualiser.
Standard_EXPORT void SetPrimitivesAspect (const Handle(Graphic3d_AspectText3d)& CTX);
//! Modifies the default attributes for markers
//! in the visualiser.
Standard_EXPORT void SetPrimitivesAspect (const Handle(Graphic3d_AspectMarker3d)& CTX);
//! Modifies the screen update mode.
//!
//! TOU_ASAP as soon as possible
//! TOU_WAIT on demand (with the Update function)
//! TOU_ASAP - as soon as possible
//! TOU_WAIT - on demand (with the Update function)
//! Note : Dynamic Operations and Update Mode
//! Use SetUpdateMode to control when changes to
//! the display are made. Use one of the following
//! functions to update one or more views:
//! - Update all views of the viewer: Visual3d_ViewManager::Update ()
//! - Update one view of the viewer: Visual3d_View::Update () Use one of
//! the following functions to update the entire display:
//! - Redraw all structures in all views: Visual3d_ViewManager::Redraw ()
//! - Redraw all structures in one view: Visual3d_View::Redraw () Update)
Standard_EXPORT void SetUpdateMode (const Aspect_TypeOfUpdate AType);
//! Updates screen in function of modifications of
//! the structures.
//! Warning: Not necessary if the update mode is TOU_ASAP.
Standard_EXPORT virtual void Update() const = 0;
//! Returns the set of structures displayed in
//! visualiser <me>.
Standard_EXPORT void DisplayedStructures (Graphic3d_MapOfStructure& SG) const;
//! Returns the set of highlighted structures
//! in a visualiser <me>.
Standard_EXPORT void HighlightedStructures (Graphic3d_MapOfStructure& SG) const;
//! Returns the values of the current default attributes.
Standard_EXPORT Handle(Graphic3d_AspectFillArea3d) FillArea3dAspect() const;
//! Returns maximum number of managers defineable.
Standard_EXPORT static Standard_Integer Limit();
//! Returns the values of the current default attributes.
Standard_EXPORT Handle(Graphic3d_AspectLine3d) Line3dAspect() const;
//! Returns the values of the current default attributes.
Standard_EXPORT Handle(Graphic3d_AspectMarker3d) Marker3dAspect() const;
//! Returns the values of the current default attributes.
Standard_EXPORT void PrimitivesAspect (Handle(Graphic3d_AspectLine3d)& CTXL, Handle(Graphic3d_AspectText3d)& CTXT, Handle(Graphic3d_AspectMarker3d)& CTXM, Handle(Graphic3d_AspectFillArea3d)& CTXF) const;
//! Returns the values of the current default attributes.
Standard_EXPORT Handle(Graphic3d_AspectText3d) Text3dAspect() const;
//! - Update all views of the viewer: Graphic3d_StructureManager::Update()
//! - Update one view of the viewer: Graphic3d_View::Update()
//! Use one of the following functions to update the entire display:
//! - Redraw all structures in all views: Graphic3d_StructureManager::Redraw()
//! - Redraw all structures in one view: Graphic3d_View::Redraw()
Standard_EXPORT void SetUpdateMode (const Aspect_TypeOfUpdate theType);
//! Returns the screen update mode.
//!
//! TOU_ASAP as soon as possible
//! TOU_WAIT on demand (Update)
Standard_EXPORT Aspect_TypeOfUpdate UpdateMode() const;
//! Changes the display priority of the structure <AStructure>.
Standard_EXPORT virtual void ChangeDisplayPriority (const Handle(Graphic3d_Structure)& AStructure, const Standard_Integer OldPriority, const Standard_Integer NewPriority) = 0;
//! Change Z layer for structure. The z layer mechanism allows
//! to display structures in higher layers in overlay of structures in
//! lower layers.
Standard_EXPORT virtual void ChangeZLayer (const Handle(Graphic3d_Structure)& theStructure, const Graphic3d_ZLayerId theLayerId) = 0;
//! Sets the settings for a single Z layer for all managed views.
Standard_EXPORT virtual void SetZLayerSettings (const Graphic3d_ZLayerId theLayerId, const Graphic3d_ZLayerSettings& theSettings) = 0;
//! Returns the settings of a single Z layer.
Standard_EXPORT virtual Graphic3d_ZLayerSettings ZLayerSettings (const Graphic3d_ZLayerId theLayerId) = 0;
//! Add a new top-level Z layer and get its ID as
//! <theLayerId> value. The method returns Standard_False if the layer
//! can not be created. The z layer mechanism allows to display
//! structures in higher layers in overlay of structures in lower layers.
Standard_EXPORT virtual Standard_Boolean AddZLayer (Graphic3d_ZLayerId& theLayerId) = 0;
//! Remove Z layer with ID <theLayerId>. Method returns
//! Standard_False if the layer can not be removed or doesn't exists.
//! By default, there is always a default bottom-level layer that can't
//! be removed.
Standard_EXPORT virtual Standard_Boolean RemoveZLayer (const Graphic3d_ZLayerId theLayerId) = 0;
//! Return all Z layer ids in sequence ordered by level
//! from lowest layer to highest. The first layer ID in sequence is
//! the default layer that can't be removed.
Standard_EXPORT virtual void GetAllZLayers (TColStd_SequenceOfInteger& theLayerSeq) const = 0;
//! Updates screen in function of modifications of the structures.
Standard_EXPORT virtual void Update (const Aspect_TypeOfUpdate theMode = Aspect_TOU_ASAP) const;
//! Deletes and erases the 3D structure manager.
Standard_EXPORT virtual void Remove();
//! Erases all the structures.
Standard_EXPORT virtual void Erase();
//! Returns the set of structures displayed in
//! visualiser <me>.
Standard_EXPORT void DisplayedStructures (Graphic3d_MapOfStructure& SG) const;
//! Returns the set of highlighted structures
//! in a visualiser <me>.
Standard_EXPORT void HighlightedStructures (Graphic3d_MapOfStructure& SG) const;
//! Returns the values of the current default attributes.
Standard_EXPORT Handle(Graphic3d_AspectFillArea3d) FillArea3dAspect() const;
//! Returns maximum number of managers defineable.
Standard_EXPORT static Standard_Integer Limit();
//! Returns the values of the current default attributes.
Standard_EXPORT Handle(Graphic3d_AspectLine3d) Line3dAspect() const;
//! Returns the values of the current default attributes.
Standard_EXPORT Handle(Graphic3d_AspectMarker3d) Marker3dAspect() const;
//! Returns the values of the current default attributes.
Standard_EXPORT void PrimitivesAspect (Handle(Graphic3d_AspectLine3d)& CTXL, Handle(Graphic3d_AspectText3d)& CTXT, Handle(Graphic3d_AspectMarker3d)& CTXM, Handle(Graphic3d_AspectFillArea3d)& CTXF) const;
//! Returns the values of the current default attributes.
Standard_EXPORT Handle(Graphic3d_AspectText3d) Text3dAspect() const;
//! Returns a current identifier available.
Standard_EXPORT static Standard_Integer CurrentId();
//! Forces a new construction of the structure <AStructure>
//! if <AStructure> is displayed and TOS_COMPUTED.
Standard_EXPORT virtual void ReCompute (const Handle(Graphic3d_Structure)& AStructure) = 0;
//! Forces a new construction of the structure <AStructure>
//! if <AStructure> is displayed in <AProjector> and TOS_COMPUTED.
Standard_EXPORT virtual void ReCompute (const Handle(Graphic3d_Structure)& AStructure, const Handle(Graphic3d_DataStructureManager)& AProjector) = 0;
//! Clears the structure <AStructure>.
Standard_EXPORT virtual void Clear (const Handle(Graphic3d_Structure)& AStructure, const Standard_Boolean WithDestruction) = 0;
//! Connects the structures <AMother> and <ADaughter>.
Standard_EXPORT virtual void Connect (const Handle(Graphic3d_Structure)& AMother, const Handle(Graphic3d_Structure)& ADaughter) = 0;
//! Disconnects the structures <AMother> and <ADaughter>.
Standard_EXPORT virtual void Disconnect (const Handle(Graphic3d_Structure)& AMother, const Handle(Graphic3d_Structure)& ADaughter) = 0;
//! Display the structure <AStructure>.
Standard_EXPORT virtual void Display (const Handle(Graphic3d_Structure)& AStructure) = 0;
//! Erases the structure <AStructure>.
Standard_EXPORT virtual void Erase (const Handle(Graphic3d_Structure)& AStructure) = 0;
//! Highlights the structure <AStructure>.
Standard_EXPORT virtual void Highlight (const Handle(Graphic3d_Structure)& AStructure, const Aspect_TypeOfHighlightMethod AMethod) = 0;
//! Transforms the structure <AStructure>.
Standard_EXPORT virtual void SetTransform (const Handle(Graphic3d_Structure)& AStructure, const TColStd_Array2OfReal& ATrsf) = 0;
//! Forces a new construction of the structure.
//! if <theStructure> is displayed and TOS_COMPUTED.
Standard_EXPORT virtual void ReCompute (const Handle(Graphic3d_Structure)& theStructure);
//! Forces a new construction of the structure.
//! if <theStructure> is displayed in <theProjector> and TOS_COMPUTED.
Standard_EXPORT virtual void ReCompute (const Handle(Graphic3d_Structure)& theStructure, const Handle(Graphic3d_DataStructureManager)& theProjector);
//! Clears the structure.
Standard_EXPORT virtual void Clear (const Handle(Graphic3d_Structure)& theStructure, const Standard_Boolean theWithDestruction);
//! Connects the structures.
Standard_EXPORT virtual void Connect (const Handle(Graphic3d_Structure)& theMother, const Handle(Graphic3d_Structure)& theDaughter);
//! Disconnects the structures.
Standard_EXPORT virtual void Disconnect (const Handle(Graphic3d_Structure)& theMother, const Handle(Graphic3d_Structure)& theDaughter);
//! Display the structure.
Standard_EXPORT virtual void Display (const Handle(Graphic3d_Structure)& theStructure);
//! Erases the structure.
Standard_EXPORT virtual void Erase (const Handle(Graphic3d_Structure)& theStructure);
//! Highlights the structure.
Standard_EXPORT virtual void Highlight (const Handle(Graphic3d_Structure)& theStructure, const Aspect_TypeOfHighlightMethod theMethod);
//! Transforms the structure.
Standard_EXPORT virtual void SetTransform (const Handle(Graphic3d_Structure)& theStructure, const TColStd_Array2OfReal& theTrsf);
//! Changes the display priority of the structure <AStructure>.
Standard_EXPORT virtual void ChangeDisplayPriority (const Handle(Graphic3d_Structure)& theStructure, const Standard_Integer theOldPriority, const Standard_Integer theNewPriority);
//! Change Z layer for structure. The Z layer mechanism allows to display structures in higher
//! layers in overlay of structures in lower layers.
Standard_EXPORT virtual void ChangeZLayer (const Handle(Graphic3d_Structure)& theStructure, const Graphic3d_ZLayerId theLayerId);
//! Returns the graphic driver of <me>.
Standard_EXPORT const Handle(Graphic3d_GraphicDriver)& GraphicDriver() const;
//! Attaches the view to this structure manager and sets its identification number within the manager.
Standard_EXPORT Standard_Integer Identification (Graphic3d_CView* theView);
//! Detach the view from this structure manager and release its identification.
Standard_EXPORT void UnIdentification (Graphic3d_CView* theView);
//! Returns the group of views defined in the structure manager.
Standard_EXPORT const Graphic3d_IndexedMapOfView& DefinedViews() const;
//! Returns the theoretical maximum number of definable views in the manager.
//! Warning: It's not possible to accept an infinite number of definable views because each
//! view must have an identification and we have different managers.
Standard_EXPORT Standard_Integer MaxNumOfViews() const;
//! Returns the identification number of the manager.
Standard_EXPORT virtual Standard_Integer Identification() const;
//! Returns the structure with the identification number <AId>.
Standard_EXPORT virtual Handle(Graphic3d_Structure) Identification (const Standard_Integer AId) const;
//! Returns a new identification number for a new structure in the manager.
Standard_EXPORT Standard_Integer NewIdentification();
//! Suppresses the highlighting on all the structures in <me>.
Standard_EXPORT virtual void UnHighlight() = 0;
//! Suppress the highlighting on the structure <AStructure>.
Standard_EXPORT virtual void UnHighlight (const Handle(Graphic3d_Structure)& AStructure) = 0;
Standard_EXPORT virtual void UnHighlight (const Handle(Graphic3d_Structure)& AStructure);
//! Suppresses the highlighting on all the structures in <me>.
Standard_EXPORT virtual void UnHighlight();
Standard_EXPORT void RecomputeStructures();
//! Recomputes all structures from theStructures.
Standard_EXPORT void RecomputeStructures (const Graphic3d_MapOfStructure& theStructures);
Standard_EXPORT Handle(Graphic3d_ViewAffinity) RegisterObject (const Handle(Standard_Transient)& theObject);
Standard_EXPORT void UnregisterObject (const Handle(Standard_Transient)& theObject);
Standard_EXPORT Handle(Graphic3d_ViewAffinity) ObjectAffinity (const Handle(Standard_Transient)& theObject) const;
friend class Graphic3d_Structure;
friend class Graphic3d_Structure;
DEFINE_STANDARD_RTTI(Graphic3d_StructureManager,MMgt_TShared)
protected:
//! Initialises the ViewManager.
//! Currently creating of more than 100 viewer instances
//! is not supported and leads to InitializationError and
//! initialisation failure.
//! This limitation might be addressed in some future OCCT releases.
//! Warning: Raises InitialisationError if the initialisation
//! of the ViewManager failed.
Standard_EXPORT Graphic3d_StructureManager(const Handle(Graphic3d_GraphicDriver)& theDriver);
//! Returns the number of structures displayed in
//! visualiser <me>.
//! Returns the structure displayed in visualiser <me>.
//! visualizer <me>.
//! Returns the structure displayed in visualizer <me>.
Standard_EXPORT Standard_Integer NumberOfDisplayedStructures() const;
Standard_Integer MyId;
Aspect_TypeOfUpdate MyUpdateMode;
Handle(Graphic3d_AspectLine3d) MyAspectLine3d;
Handle(Graphic3d_AspectText3d) MyAspectText3d;
Handle(Graphic3d_AspectMarker3d) MyAspectMarker3d;
Handle(Graphic3d_AspectFillArea3d) MyAspectFillArea3d;
Graphic3d_MapOfStructure MyDisplayedStructure;
Graphic3d_MapOfObject myRegisteredObjects;
Graphic3d_MapOfStructure MyHighlightedStructure;
Aspect_GenId MyStructGenId;
Handle(Graphic3d_GraphicDriver) MyGraphicDriver;
private:
//! Frees the identifieur <AnId>.
Standard_EXPORT void Remove (const Standard_Integer AnId);
//! Frees the identifier of a structure.
void Remove (const Standard_Integer theId);
protected:
Standard_Integer myId;
Aspect_GenId myStructGenId;
Aspect_GenId myViewGenId;
Aspect_TypeOfUpdate myUpdateMode;
Handle(Graphic3d_AspectLine3d) myAspectLine3d;
Handle(Graphic3d_AspectText3d) myAspectText3d;
Handle(Graphic3d_AspectMarker3d) myAspectMarker3d;
Handle(Graphic3d_AspectFillArea3d) myAspectFillArea3d;
Graphic3d_MapOfStructure myDisplayedStructure;
Graphic3d_MapOfStructure myHighlightedStructure;
Graphic3d_MapOfObject myRegisteredObjects;
Handle(Graphic3d_GraphicDriver) myGraphicDriver;
Graphic3d_IndexedMapOfView myDefinedViews;
};
#endif // _Graphic3d_StructureManager_HeaderFile

2
src/Graphic3d/Graphic3d_TextureEnv.hxx
View File

@ -31,7 +31,7 @@ class TCollection_AsciiString;
class Graphic3d_TextureEnv;
DEFINE_STANDARD_HANDLE(Graphic3d_TextureEnv, Graphic3d_TextureRoot)
//! This class provides environment texture usable only in Visual3d_ContextView
//! This class provides environment texture.
class Graphic3d_TextureEnv : public Graphic3d_TextureRoot
{

14
src/Visual3d/Visual3d_TypeOfAnswer.hxx → src/Graphic3d/Graphic3d_TypeOfAnswer.hxx
View File

@ -14,8 +14,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Visual3d_TypeOfAnswer_HeaderFile
#define _Visual3d_TypeOfAnswer_HeaderFile
#ifndef _Graphic3d_TypeOfAnswer_HeaderFile
#define _Graphic3d_TypeOfAnswer_HeaderFile
//! The answer of the method AcceptDisplay
//! AcceptDisplay means is it possible to display the
@ -23,11 +23,11 @@
//! TOA_YES yes
//! TOA_NO no
//! TOA_COMPUTE yes but we have to compute the representation
enum Visual3d_TypeOfAnswer
enum Graphic3d_TypeOfAnswer
{
Visual3d_TOA_YES,
Visual3d_TOA_NO,
Visual3d_TOA_COMPUTE
Graphic3d_TOA_YES,
Graphic3d_TOA_NO,
Graphic3d_TOA_COMPUTE
};
#endif // _Visual3d_TypeOfAnswer_HeaderFile
#endif // _Graphic3d_TypeOfAnswer_HeaderFile

14
src/Visual3d/Visual3d_TypeOfBackfacingModel.hxx → src/Graphic3d/Graphic3d_TypeOfBackfacingModel.hxx
View File

@ -14,19 +14,19 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Visual3d_TypeOfBackfacingModel_HeaderFile
#define _Visual3d_TypeOfBackfacingModel_HeaderFile
#ifndef _Graphic3d_TypeOfBackfacingModel_HeaderFile
#define _Graphic3d_TypeOfBackfacingModel_HeaderFile
//! Modes of display of back faces in the view
//!
//! TOBM_AUTOMATIC graphic's structure setting is in use
//! TOBM_FORCE force display of back faces
//! TOBM_DISABLE disable display of back faces
enum Visual3d_TypeOfBackfacingModel
enum Graphic3d_TypeOfBackfacingModel
{
Visual3d_TOBM_AUTOMATIC,
Visual3d_TOBM_FORCE,
Visual3d_TOBM_DISABLE
Graphic3d_TOBM_AUTOMATIC,
Graphic3d_TOBM_FORCE,
Graphic3d_TOBM_DISABLE
};
#endif // _Visual3d_TypeOfBackfacingModel_HeaderFile
#endif // _Graphic3d_TypeOfBackfacingModel_HeaderFile

16
src/Visual3d/Visual3d_TypeOfLightSource.hxx → src/Graphic3d/Graphic3d_TypeOfLightSource.hxx
View File

@ -14,8 +14,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Visual3d_TypeOfLightSource_HeaderFile
#define _Visual3d_TypeOfLightSource_HeaderFile
#ifndef _Graphic3d_TypeOfLightSource_HeaderFile
#define _Graphic3d_TypeOfLightSource_HeaderFile
//! Definition of all the type of light sources
//!
@ -23,12 +23,12 @@
//! TOLS_DIRECTIONAL directional light
//! TOLS_POSITIONAL positional light
//! TOLS_SPOT spot light
enum Visual3d_TypeOfLightSource
enum Graphic3d_TypeOfLightSource
{
Visual3d_TOLS_AMBIENT,
Visual3d_TOLS_DIRECTIONAL,
Visual3d_TOLS_POSITIONAL,
Visual3d_TOLS_SPOT
Graphic3d_TOLS_AMBIENT,
Graphic3d_TOLS_DIRECTIONAL,
Graphic3d_TOLS_POSITIONAL,
Graphic3d_TOLS_SPOT
};
#endif // _Visual3d_TypeOfLightSource_HeaderFile
#endif // _Graphic3d_TypeOfLightSource_HeaderFile

24
src/Visual3d/Visual3d_TypeOfModel.hxx → src/Graphic3d/Graphic3d_TypeOfShadingModel.hxx
View File

@ -14,20 +14,20 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Visual3d_TypeOfModel_HeaderFile
#define _Visual3d_TypeOfModel_HeaderFile
#ifndef _Graphic3d_TypeOfShadingModel_HeaderFile
#define _Graphic3d_TypeOfShadingModel_HeaderFile
//! Definition of the rendering (colour shading) model
//! Visual3d_TOM_NONE No lighting, only white ambient light
//! Visual3d_TOM_FACET No interpolation, constant shading (Flat Shading)
//! Visual3d_TOM_VERTEX Interpolation of color based on normals (Gouraud Shading)
//! Visual3d_TOM_FRAGMENT Interpolation of color based on normals (Phong Shading)
enum Visual3d_TypeOfModel
//! Graphic3d_TOSM_NONE No lighting, only white ambient light
//! Graphic3d_TOSM_FACET No interpolation, constant shading (Flat Shading)
//! Graphic3d_TOSM_VERTEX Interpolation of color based on normals (Gouraud Shading)
//! Graphic3d_TOSM_FRAGMENT Interpolation of color based on normals (Phong Shading)
enum Graphic3d_TypeOfShadingModel
{
Visual3d_TOM_NONE,
Visual3d_TOM_FACET,
Visual3d_TOM_VERTEX,
Visual3d_TOM_FRAGMENT
Graphic3d_TOSM_NONE,
Graphic3d_TOSM_FACET,
Graphic3d_TOSM_VERTEX,
Graphic3d_TOSM_FRAGMENT
};
#endif // _Visual3d_TypeOfModel_HeaderFile
#endif // _Graphic3d_TypeOfShadingModel_HeaderFile

14
src/Visual3d/Visual3d_TypeOfSurfaceDetail.hxx → src/Graphic3d/Graphic3d_TypeOfSurfaceDetail.hxx
View File

@ -14,19 +14,19 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Visual3d_TypeOfSurfaceDetail_HeaderFile
#define _Visual3d_TypeOfSurfaceDetail_HeaderFile
#ifndef _Graphic3d_TypeOfSurfaceDetail_HeaderFile
#define _Graphic3d_TypeOfSurfaceDetail_HeaderFile
//! Modes of visualisation of objects in a view
//!
//! TOD_NONE no texture mapping
//! TOD_ENVIRONMENT only environnement mapping
//! TOD_ALL environnement + texture mapping
enum Visual3d_TypeOfSurfaceDetail
enum Graphic3d_TypeOfSurfaceDetail
{
Visual3d_TOD_NONE,
Visual3d_TOD_ENVIRONMENT,
Visual3d_TOD_ALL
Graphic3d_TOD_NONE,
Graphic3d_TOD_ENVIRONMENT,
Graphic3d_TOD_ALL
};
#endif // _Visual3d_TypeOfSurfaceDetail_HeaderFile
#endif // _Graphic3d_TypeOfSurfaceDetail_HeaderFile

12
src/Visual3d/Visual3d_TypeOfVisualization.hxx → src/Graphic3d/Graphic3d_TypeOfVisualization.hxx
View File

@ -14,17 +14,17 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Visual3d_TypeOfVisualization_HeaderFile
#define _Visual3d_TypeOfVisualization_HeaderFile
#ifndef _Graphic3d_TypeOfVisualization_HeaderFile
#define _Graphic3d_TypeOfVisualization_HeaderFile
//! Modes of visualisation of objects in a view
//!
//! TOV_WIREFRAME wireframe visualisation
//! TOV_SHADING shaded visualisation
enum Visual3d_TypeOfVisualization
enum Graphic3d_TypeOfVisualization
{
Visual3d_TOV_WIREFRAME,
Visual3d_TOV_SHADING
Graphic3d_TOV_WIREFRAME,
Graphic3d_TOV_SHADING
};
#endif // _Visual3d_TypeOfVisualization_HeaderFile
#endif // _Graphic3d_TypeOfVisualization_HeaderFile

2
src/InterfaceGraphic/FILES
View File

@ -1,6 +1,4 @@
InterfaceGraphic.hxx
InterfaceGraphic_Aspect.hxx
InterfaceGraphic_Graphic3d.hxx
InterfaceGraphic_telem.hxx
InterfaceGraphic_tgl_all.hxx
InterfaceGraphic_Visual3d.hxx

58
src/InterfaceGraphic/InterfaceGraphic_Aspect.hxx
View File

@ -1,58 +0,0 @@
// Copyright (c) 1991-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef InterfaceGraphic_AspectHeader
#define InterfaceGraphic_AspectHeader
#include <Aspect_Drawable.hxx>
#include <Aspect_RenderingContext.hxx>
/* WINDOW */
typedef struct {
int IsDefined;
Aspect_Drawable XWindow;
Aspect_Drawable XParentWindow;
int dx, dy;
int left, top;
struct {
float r, g, b;
} Background;
} CALL_DEF_WINDOW;
typedef struct {
int listIndex;
void* layerData;
} CALL_DEF_PTRLAYER, *call_def_ptrLayer;
/* LAYER */
typedef struct {
CALL_DEF_PTRLAYER* ptrLayer;
int layerType;
int attach;
int sizeDependent;
float ortho[4];
float viewport[2];
} CALL_DEF_LAYER;
#endif /* InterfaceGraphic_AspectHeader */

74
src/InterfaceGraphic/InterfaceGraphic_Visual3d.hxx
View File

@ -1,74 +0,0 @@
// Copyright (c) 1991-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef InterfaceGraphic_Visual3dHeader
#define InterfaceGraphic_Visual3dHeader
#include <InterfaceGraphic_Aspect.hxx>
#include <InterfaceGraphic_Graphic3d.hxx>
#include <Aspect_RenderingContext.hxx>
#include <Aspect_GraphicCallbackProc.hxx>
#include <Standard_Transient.hxx>
typedef float CALL_DEF_MATRIX4X4[4][4];
/* SOMMET */
typedef struct {
float x, y, z;
} CALL_DEF_VERTEX;
/* ORIENTATION */
typedef struct {
CALL_DEF_VERTEX ViewReferencePoint;
CALL_DEF_VERTEX ViewReferencePlane;
CALL_DEF_VERTEX ViewReferenceUp;
float ViewScaleX;
float ViewScaleY;
float ViewScaleZ;
float ModelViewMatrix[4][4];
unsigned IsCustomMatrix;
} CALL_DEF_VIEWORIENTATION;
/* MAPPING */
typedef struct {
int Projection;
CALL_DEF_VERTEX ProjectionReferencePoint;
float ViewPlaneDistance;
float BackPlaneDistance;
float FrontPlaneDistance;
struct {
float um, vm, uM, vM;
} WindowLimit;
float ProjectionMatrix[4][4];
unsigned IsCustomMatrix;
} CALL_DEF_VIEWMAPPING;
#endif /* InterfaceGraphic_Visual3dHeader */

13
src/OpenGl/FILES
View File

@ -28,20 +28,20 @@ OpenGl_PrimitiveArray.hxx
OpenGl_PrimitiveArray.cxx
OpenGl_Workspace.hxx
OpenGl_Workspace.cxx
OpenGl_Workspace_2.cxx
OpenGl_Workspace_5.cxx
OpenGl_View.hxx
OpenGl_View.cxx
OpenGl_View_2.cxx
OpenGl_View_Print.cxx
OpenGl_View_Raytrace.cxx
OpenGl_View_Redraw.cxx
OpenGl_Light.hxx
OpenGl_Trihedron.hxx
OpenGl_Trihedron.cxx
OpenGl_GraduatedTrihedron.hxx
OpenGl_GraduatedTrihedron.cxx
OpenGl_MapOfZLayerSettings.hxx
OpenGl_Matrix.hxx
OpenGl_Matrix.cxx
OpenGl_MatrixState.hxx
OpenGl_CView.hxx
OpenGl_NamedStatus.hxx
OpenGl_TextParam.hxx
OpenGl_PrinterContext.hxx
@ -113,10 +113,6 @@ OpenGl_LayerList.hxx
OpenGl_LayerFilter.hxx
OpenGl_GraphicDriver.cxx
OpenGl_GraphicDriver.hxx
OpenGl_GraphicDriver_4.cxx
OpenGl_GraphicDriver_7.cxx
OpenGl_GraphicDriver_713.cxx
OpenGl_GraphicDriver_Export.cxx
OpenGl_IndexBuffer.cxx
OpenGl_IndexBuffer.hxx
OpenGl_Layer.cxx
@ -151,6 +147,5 @@ OpenGl_VertexBuffer.lxx
OpenGl_VertexBufferCompat.cxx
OpenGl_VertexBufferCompat.hxx
OpenGl_VertexBufferEditor.hxx
OpenGl_View_Raytrace.cxx
OpenGl_TextBuilder.hxx
OpenGl_TextBuilder.cxx

31
src/OpenGl/OpenGl_CView.hxx
View File

@ -1,31 +0,0 @@
// Created on: 2011-09-20
// Created by: Sergey ZERCHANINOV
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#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;
DEFINE_STANDARD_ALLOC
};
#endif //OpenGl_CView_Header

86
src/OpenGl/OpenGl_Context.cxx
View File

@ -220,7 +220,7 @@ OpenGl_Context::~OpenGl_Context()
myUnusedResources->RemoveFirst();
}
}
else
else if (myShaderManager->IsSameContext (this))
{
myShaderManager->SetContext (NULL);
}
@ -2722,3 +2722,87 @@ void OpenGl_Context::ApplyProjectionMatrix()
myShaderManager->UpdateProjectionStateTo (ProjectionState.Current());
}
}
// =======================================================================
// function : EnableFeatures
// purpose :
// =======================================================================
void OpenGl_Context::EnableFeatures() const
{
//
}
// =======================================================================
// function : DisableFeatures
// purpose :
// =======================================================================
void OpenGl_Context::DisableFeatures() const
{
#if !defined(GL_ES_VERSION_2_0)
glPixelTransferi (GL_MAP_COLOR, GL_FALSE);
#endif
/*
* Disable stuff that's likely to slow down glDrawPixels.
* (Omit as much of this as possible, when you know in advance
* that the OpenGL state will already be set correctly.)
*/
glDisable(GL_DITHER);
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glDisable(GL_TEXTURE_2D);
glDisable(GL_STENCIL_TEST);
#if !defined(GL_ES_VERSION_2_0)
glDisable(GL_LIGHTING);
glDisable(GL_ALPHA_TEST);
glDisable(GL_FOG);
glDisable(GL_LOGIC_OP);
glDisable(GL_TEXTURE_1D);
glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
glPixelTransferi(GL_RED_SCALE, 1);
glPixelTransferi(GL_RED_BIAS, 0);
glPixelTransferi(GL_GREEN_SCALE, 1);
glPixelTransferi(GL_GREEN_BIAS, 0);
glPixelTransferi(GL_BLUE_SCALE, 1);
glPixelTransferi(GL_BLUE_BIAS, 0);
glPixelTransferi(GL_ALPHA_SCALE, 1);
glPixelTransferi(GL_ALPHA_BIAS, 0);
/*
* Disable extensions that could slow down glDrawPixels.
* (Actually, you should check for the presence of the proper
* extension before making these calls. I've omitted that
* code for simplicity.)
*/
if ((myGlVerMajor >= 1) && (myGlVerMinor >= 2))
{
#ifdef GL_EXT_convolution
if (CheckExtension ("GL_CONVOLUTION_1D_EXT"))
glDisable(GL_CONVOLUTION_1D_EXT);
if (CheckExtension ("GL_CONVOLUTION_2D_EXT"))
glDisable(GL_CONVOLUTION_2D_EXT);
if (CheckExtension ("GL_SEPARABLE_2D_EXT"))
glDisable(GL_SEPARABLE_2D_EXT);
#endif
#ifdef GL_EXT_histogram
if (CheckExtension ("GL_SEPARABLE_2D_EXT"))
glDisable(GL_HISTOGRAM_EXT);
if (CheckExtension ("GL_MINMAX_EXT"))
glDisable(GL_MINMAX_EXT);
#endif
#ifdef GL_EXT_texture3D
if (CheckExtension ("GL_TEXTURE_3D_EXT"))
glDisable(GL_TEXTURE_3D_EXT);
#endif
}
#endif
}

4
src/OpenGl/OpenGl_Context.hxx
View File

@ -573,6 +573,10 @@ public: //! @name methods to alter or retrieve current state
return myIsGlDebugCtx;
}
Standard_EXPORT void EnableFeatures() const;
Standard_EXPORT void DisableFeatures() const;
private:
//! Wrapper to system function to retrieve GL function pointer by name.

85
src/OpenGl/OpenGl_GraduatedTrihedron.cxx
View File

@ -15,8 +15,6 @@
#include <OpenGl_GlCore11.hxx>
#include <InterfaceGraphic_Graphic3d.hxx>
#include <InterfaceGraphic_Aspect.hxx>
#include <InterfaceGraphic_Visual3d.hxx>
#include <OpenGl_GraduatedTrihedron.hxx>
@ -50,7 +48,8 @@ namespace
// =======================================================================
OpenGl_GraduatedTrihedron::OpenGl_GraduatedTrihedron()
: myMin (0.0f, 0.0f, 0.0f),
myMax (100.0f, 100.0f, 100.0f)
myMax (100.0f, 100.0f, 100.0f),
myIsInitialized (Standard_False)
{
//
}
@ -59,38 +58,10 @@ OpenGl_GraduatedTrihedron::OpenGl_GraduatedTrihedron()
// function : SetValues
// purpose :
// =======================================================================
void OpenGl_GraduatedTrihedron::SetValues (const Handle(OpenGl_Context)& theCtx,
const Graphic3d_GraduatedTrihedron& theData)
void OpenGl_GraduatedTrihedron::SetValues (const Graphic3d_GraduatedTrihedron& theData)
{
Release (theCtx.operator->());
myData = theData;
// Initialize text label parameters for x, y, and z axes
myAxes[0] = Axis (myData.XAxisAspect(), OpenGl_Vec3 (1.0f, 0.0f, 0.0f));
myAxes[1] = Axis (myData.YAxisAspect(), OpenGl_Vec3 (0.0f, 1.0f, 0.0f));
myAxes[2] = Axis (myData.ZAxisAspect(), OpenGl_Vec3 (0.0f, 0.0f, 1.0f));
// Initialize constant primitives: text, arrows.
myAxes[0].InitArrow (theCtx, myData.ArrowsLength(), OpenGl_Vec3 (0.0f, 0.0f, 1.0f));
myAxes[1].InitArrow (theCtx, myData.ArrowsLength(), OpenGl_Vec3 (0.0f, 0.0f, 1.0f));
myAxes[2].InitArrow (theCtx, myData.ArrowsLength(), OpenGl_Vec3 (1.0f, 0.0f, 0.0f));
for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
{
myAxes[anIt].Label.SetFontSize (theCtx, theData.NamesSize());
}
myLabelValues.SetFontSize (theCtx, theData.ValuesSize());
myAspectLabels.SetFontAspect (theData.NamesFontAspect());
myAspectLabels.ChangeFontName() = theData.NamesFont();
myAspectValues.SetFontAspect (theData.ValuesFontAspect());
myAspectValues.ChangeFontName() = theData.ValuesFont();
// Grid aspect
myGridLineAspect.ChangeColor().rgb[0] = (Standard_ShortReal) theData.GridColor().Red();
myGridLineAspect.ChangeColor().rgb[1] = (Standard_ShortReal) theData.GridColor().Green();
myGridLineAspect.ChangeColor().rgb[2] = (Standard_ShortReal) theData.GridColor().Blue();
myData = theData;
myIsInitialized = Standard_False;
}
// =======================================================================
@ -114,6 +85,45 @@ void OpenGl_GraduatedTrihedron::Release (OpenGl_Context* theCtx)
myLabelValues.Release (theCtx);
}
// =======================================================================
// function : initResources
// purpose :
// =======================================================================
void OpenGl_GraduatedTrihedron::initGlResources (const Handle(OpenGl_Context)& theCtx) const
{
myAxes[0].Release (theCtx.operator->());
myAxes[1].Release (theCtx.operator->());
myAxes[2].Release (theCtx.operator->());
myLabelValues.Release (theCtx.operator->());
// Initialize text label parameters for x, y, and z axes
myAxes[0] = Axis (myData.XAxisAspect(), OpenGl_Vec3 (1.0f, 0.0f, 0.0f));
myAxes[1] = Axis (myData.YAxisAspect(), OpenGl_Vec3 (0.0f, 1.0f, 0.0f));
myAxes[2] = Axis (myData.ZAxisAspect(), OpenGl_Vec3 (0.0f, 0.0f, 1.0f));
// Initialize constant primitives: text, arrows.
myAxes[0].InitArrow (theCtx, myData.ArrowsLength(), OpenGl_Vec3 (0.0f, 0.0f, 1.0f));
myAxes[1].InitArrow (theCtx, myData.ArrowsLength(), OpenGl_Vec3 (0.0f, 0.0f, 1.0f));
myAxes[2].InitArrow (theCtx, myData.ArrowsLength(), OpenGl_Vec3 (1.0f, 0.0f, 0.0f));
for (Standard_Integer anIt = 0; anIt < 3; ++anIt)
{
myAxes[anIt].Label.SetFontSize (theCtx, myData.NamesSize());
}
myLabelValues.SetFontSize (theCtx, myData.ValuesSize());
myAspectLabels.SetFontAspect (myData.NamesFontAspect());
myAspectLabels.ChangeFontName() = myData.NamesFont();
myAspectValues.SetFontAspect (myData.ValuesFontAspect());
myAspectValues.ChangeFontName() = myData.ValuesFont();
// Grid aspect
myGridLineAspect.ChangeColor().rgb[0] = (Standard_ShortReal) myData.GridColor().Red();
myGridLineAspect.ChangeColor().rgb[1] = (Standard_ShortReal) myData.GridColor().Green();
myGridLineAspect.ChangeColor().rgb[2] = (Standard_ShortReal) myData.GridColor().Blue();
}
// =======================================================================
// method : getNormal
// purpose : Normal of the view (not normalized!)
@ -546,6 +556,11 @@ void OpenGl_GraduatedTrihedron::renderTickmarkLabels (const Handle(OpenGl_Worksp
void OpenGl_GraduatedTrihedron::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
{
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
if (!myIsInitialized)
{
initGlResources (theWorkspace->GetGlContext());
myIsInitialized = Standard_True;
}
// Update boundary box
OpenGl_Vec3 anOldMin = myMin;
@ -553,7 +568,7 @@ void OpenGl_GraduatedTrihedron::Render (const Handle(OpenGl_Workspace)& theWorks
if (myData.CubicAxesCallback)
{
myData.CubicAxesCallback (myData.PtrVisual3dView);
myData.CubicAxesCallback (myData.PtrView);
if (!myAxes[0].Line.IsInitialized()
|| !myAxes[1].Line.IsInitialized()
|| !myAxes[2].Line.IsInitialized()

19
src/OpenGl/OpenGl_GraduatedTrihedron.hxx
View File

@ -26,7 +26,6 @@
#include <OpenGl_PrimitiveArray.hxx>
#include <OpenGl_Text.hxx>
class Visual3d_View;
class OpenGl_View;
//! This class allows to render Graduated Trihedron, i.e. trihedron with grid.
@ -54,8 +53,7 @@ public:
virtual void Release (OpenGl_Context* theCtx);
//! Setup configuration.
void SetValues (const Handle(OpenGl_Context)& theCtx,
const Graphic3d_GraduatedTrihedron& theData);
void SetValues (const Graphic3d_GraduatedTrihedron& theData);
//! Sets up-to-date values of scene bounding box.
//! Can be used in callback mechanism to get up-to-date values.
@ -131,6 +129,10 @@ private:
private:
//! Initialize or update GL resources for rendering trihedron.
//! @param theContext [in] the GL context.
void initGlResources (const Handle(OpenGl_Context)& theContext) const;
//! Gets normal of the view out of user.
//! @param theContext [in] OpenGL Context
//! @param theNormal [out] normal of the view out of user
@ -211,11 +213,9 @@ protected: //! @name Scene bounding box values
protected:
Axis myAxes[3]; //!< Axes for trihedron
Graphic3d_GraduatedTrihedron myData;
OpenGl_AspectLine myGridLineAspect; //!< Color grid properties
mutable Axis myAxes[3]; //!< Axes for trihedron
mutable Graphic3d_GraduatedTrihedron myData;
mutable OpenGl_AspectLine myGridLineAspect; //!< Color grid properties
protected: //! @name Labels properties
@ -225,6 +225,8 @@ protected: //! @name Labels properties
private:
mutable Standard_Boolean myIsInitialized;
enum AxisFlags
{
XOO_XYO = 1 << 1,
@ -237,7 +239,6 @@ private:
XOZ_XYZ = 1 << 8,
XYO_XYZ = 1 << 9
};
};
#endif //_OpenGl_GraduatedTrihedron_Header

613
src/OpenGl/OpenGl_GraphicDriver.cxx
View File

@ -18,7 +18,6 @@
#include <OpenGl_Flipper.hxx>
#include <OpenGl_GraduatedTrihedron.hxx>
#include <OpenGl_Group.hxx>
#include <OpenGl_CView.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_StencilTest.hxx>
#include <OpenGl_Text.hxx>
@ -26,10 +25,19 @@
#include <OpenGl_Workspace.hxx>
#include <Aspect_GraphicDeviceDefinitionError.hxx>
#include <Aspect_IdentDefinitionError.hxx>
#include <Message_Messenger.hxx>
#include <OSD_Environment.hxx>
#include <Standard_NotImplemented.hxx>
#if defined(_WIN32)
#include <WNT_Window.hxx>
#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
#include <Cocoa_Window.hxx>
#else
#include <Xw_Window.hxx>
#endif
#if !defined(_WIN32) && !defined(__ANDROID__) && (!defined(__APPLE__) || defined(MACOSX_USE_GLX))
#include <X11/Xlib.h> // XOpenDisplay()
#endif
@ -38,7 +46,6 @@
#include <EGL/egl.h>
#endif
namespace
{
static const Handle(OpenGl_Context) TheNullGlCtx;
@ -59,7 +66,6 @@ OpenGl_GraphicDriver::OpenGl_GraphicDriver (const Handle(Aspect_DisplayConnectio
#endif
myCaps (new OpenGl_Caps()),
myMapOfView (1, NCollection_BaseAllocator::CommonBaseAllocator()),
myMapOfWS (1, NCollection_BaseAllocator::CommonBaseAllocator()),
myMapOfStructure (1, NCollection_BaseAllocator::CommonBaseAllocator()),
myUserDrawCallback (NULL)
{
@ -89,6 +95,46 @@ OpenGl_GraphicDriver::OpenGl_GraphicDriver (const Handle(Aspect_DisplayConnectio
{
Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_GraphicDriver: default context can not be initialized!");
}
// default layers are always presented in display layer sequence it can not be removed
Graphic3d_ZLayerSettings anUnderlaySettings;
anUnderlaySettings.Flags = 0;
anUnderlaySettings.IsImmediate = false;
myLayerIds.Add (Graphic3d_ZLayerId_BotOSD);
myLayerSeq.Append (Graphic3d_ZLayerId_BotOSD);
myMapOfZLayerSettings.Bind (Graphic3d_ZLayerId_BotOSD, anUnderlaySettings);
Graphic3d_ZLayerSettings aDefSettings;
aDefSettings.Flags = Graphic3d_ZLayerDepthTest
| Graphic3d_ZLayerDepthWrite;
aDefSettings.IsImmediate = false;
myLayerIds.Add (Graphic3d_ZLayerId_Default);
myLayerSeq.Append (Graphic3d_ZLayerId_Default);
myMapOfZLayerSettings.Bind (Graphic3d_ZLayerId_Default, aDefSettings);
Graphic3d_ZLayerSettings aTopSettings;
aTopSettings.Flags = Graphic3d_ZLayerDepthTest
| Graphic3d_ZLayerDepthWrite;
aTopSettings.IsImmediate = true;
myLayerIds.Add (Graphic3d_ZLayerId_Top);
myLayerSeq.Append (Graphic3d_ZLayerId_Top);
myMapOfZLayerSettings.Bind (Graphic3d_ZLayerId_Top, aTopSettings);
Graphic3d_ZLayerSettings aTopmostSettings;
aTopmostSettings.Flags = Graphic3d_ZLayerDepthTest
| Graphic3d_ZLayerDepthWrite
| Graphic3d_ZLayerDepthClear;
aTopmostSettings.IsImmediate = true;
myLayerIds.Add (Graphic3d_ZLayerId_Topmost);
myLayerSeq.Append (Graphic3d_ZLayerId_Topmost);
myMapOfZLayerSettings.Bind (Graphic3d_ZLayerId_Topmost, aTopmostSettings);
Graphic3d_ZLayerSettings anOsdSettings;
anOsdSettings.Flags = 0;
anOsdSettings.IsImmediate = true;
myLayerIds.Add (Graphic3d_ZLayerId_TopOSD);
myLayerSeq.Append (Graphic3d_ZLayerId_TopOSD);
myMapOfZLayerSettings.Bind (Graphic3d_ZLayerId_TopOSD, anOsdSettings);
}
// =======================================================================
@ -107,11 +153,17 @@ OpenGl_GraphicDriver::~OpenGl_GraphicDriver()
void OpenGl_GraphicDriver::ReleaseContext()
{
Handle(OpenGl_Context) aCtxShared;
for (NCollection_Map<Handle(OpenGl_Workspace)>::Iterator aWindowIter (myMapOfWS);
aWindowIter.More(); aWindowIter.Next())
for (NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIter (myMapOfView);
aViewIter.More(); aViewIter.Next())
{
const Handle(OpenGl_Workspace)& aWindow = aWindowIter.ChangeValue();
const Handle(OpenGl_Context)& aCtx = aWindow->GetGlContext();
const Handle(OpenGl_View)& aView = aViewIter.ChangeValue();
const Handle(OpenGl_Window)& aWindow = aView->GlWindow();
if (aWindow.IsNull())
{
continue;
}
const Handle(OpenGl_Context)& aCtx = aWindow->GetGlContext();
if (aCtx->MakeCurrent()
&& aCtxShared.IsNull())
{
@ -138,12 +190,17 @@ void OpenGl_GraphicDriver::ReleaseContext()
}
myDeviceLostFlag = myDeviceLostFlag || !myMapOfStructure.IsEmpty();
for (NCollection_Map<Handle(OpenGl_Workspace)>::Iterator aWindowIter (myMapOfWS);
aWindowIter.More(); aWindowIter.Next())
for (NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIter (myMapOfView);
aViewIter.More(); aViewIter.Next())
{
const Handle(OpenGl_Workspace)& aWindow = aWindowIter.ChangeValue();
const Handle(OpenGl_Context)& aCtx = aWindow->GetGlContext();
aCtx->forcedRelease();
const Handle(OpenGl_View)& aView = aViewIter.ChangeValue();
const Handle(OpenGl_Window)& aWindow = aView->GlWindow();
if (aWindow.IsNull())
{
continue;
}
aWindow->GetGlContext()->forcedRelease();
}
#if defined(HAVE_EGL) || defined(__ANDROID__)
@ -364,13 +421,24 @@ void OpenGl_GraphicDriver::EnableVBO (const Standard_Boolean theToTurnOn)
// =======================================================================
const Handle(OpenGl_Context)& OpenGl_GraphicDriver::GetSharedContext() const
{
if (myMapOfWS.IsEmpty())
if (myMapOfView.IsEmpty())
{
return TheNullGlCtx;
}
NCollection_Map<Handle(OpenGl_Workspace)>::Iterator anIter (myMapOfWS);
return anIter.Value()->GetGlContext();
NCollection_Map<Handle(OpenGl_View)>::Iterator anIter (myMapOfView);
for (; anIter.More(); anIter.Next())
{
Handle(OpenGl_Window) aWindow = anIter.Value()->GlWindow();
if (aWindow.IsNull())
{
continue;
}
return aWindow->GetGlContext();
}
return TheNullGlCtx;
}
// =======================================================================
@ -391,227 +459,6 @@ Standard_Boolean OpenGl_GraphicDriver::MemoryInfo (Standard_Size& theF
return !theInfo.IsEmpty();
}
// =======================================================================
// function : SetImmediateModeDrawToFront
// purpose :
// =======================================================================
Standard_Boolean OpenGl_GraphicDriver::SetImmediateModeDrawToFront (const Graphic3d_CView& theCView,
const Standard_Boolean theDrawToFrontBuffer)
{
if (theCView.ViewId == -1)
{
return Standard_False;
}
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView != NULL)
{
return aCView->WS->SetImmediateModeDrawToFront (theDrawToFrontBuffer);
}
return Standard_False;
}
// =======================================================================
// function : Print
// purpose :
// =======================================================================
Standard_Boolean OpenGl_GraphicDriver::Print (const Graphic3d_CView& theCView,
const Aspect_Handle thePrintDC,
const Standard_Boolean theToShowBackground,
const Standard_CString theFilename,
const Aspect_PrintAlgo thePrintAlgorithm,
const Standard_Real theScaleFactor) const
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView == NULL
|| !myPrintContext.IsNull())
{
return Standard_False;
}
Standard_Boolean isPrinted = Standard_False;
myPrintContext = new OpenGl_PrinterContext();
#ifdef _WIN32
isPrinted = aCView->WS->Print (myPrintContext,
theCView,
thePrintDC,
theToShowBackground,
theFilename,
thePrintAlgorithm,
theScaleFactor);
#else
Standard_NotImplemented::Raise ("OpenGl_GraphicDriver::Print is implemented only on Windows");
#endif
myPrintContext.Nullify();
return isPrinted;
}
// =======================================================================
// function : ZBufferTriedronSetup
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::ZBufferTriedronSetup (const Graphic3d_CView& theCView,
const Quantity_NameOfColor theXColor,
const Quantity_NameOfColor theYColor,
const Quantity_NameOfColor theZColor,
const Standard_Real theSizeRatio,
const Standard_Real theAxisDiametr,
const Standard_Integer theNbFacets)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView == NULL)
{
return;
}
OpenGl_Trihedron& aTrih = aCView->View->ChangeTrihedron();
aTrih.SetArrowsColors (theXColor, theYColor, theZColor);
aTrih.SetSizeRatio (theSizeRatio);
aTrih.SetNbFacets (theNbFacets);
aTrih.SetArrowDiameter (theAxisDiametr);
}
// =======================================================================
// function : TriedronDisplay
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::TriedronDisplay (const Graphic3d_CView& theCView,
const Aspect_TypeOfTriedronPosition thePosition,
const Quantity_NameOfColor theColor,
const Standard_Real theScale,
const Standard_Boolean theAsWireframe)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView != NULL)
{
aCView->View->TriedronDisplay (thePosition, theColor, theScale, theAsWireframe);
}
}
// =======================================================================
// function : TriedronErase
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::TriedronErase (const Graphic3d_CView& theCView)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView != NULL)
{
aCView->View->TriedronErase (aCView->WS->GetGlContext());
}
}
// =======================================================================
// function : TriedronEcho
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::TriedronEcho (const Graphic3d_CView& ,
const Aspect_TypeOfTriedronEcho )
{
// do nothing
}
// =======================================================================
// function : Environment
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::Environment (const Graphic3d_CView& theCView)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView == NULL)
{
return;
}
aCView->View->SetTextureEnv (aCView->WS->GetGlContext(), theCView.Context.TextureEnv);
aCView->View->SetSurfaceDetail ((Visual3d_TypeOfSurfaceDetail)theCView.Context.SurfaceDetail);
}
// =======================================================================
// function : BackgroundImage
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::BackgroundImage (const Standard_CString theFileName,
const Graphic3d_CView& theCView,
const Aspect_FillMethod theFillStyle)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView != NULL)
{
aCView->View->CreateBackgroundTexture (theFileName, theFillStyle);
}
}
// =======================================================================
// function : SetBgImageStyle
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::SetBgImageStyle (const Graphic3d_CView& theCView,
const Aspect_FillMethod theFillStyle)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView != NULL)
{
aCView->View->SetBackgroundTextureStyle (theFillStyle);
}
}
// =======================================================================
// function : SetBgGradientStyle
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::SetBgGradientStyle (const Graphic3d_CView& theCView,
const Aspect_GradientFillMethod theFillType)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView != NULL)
{
aCView->View->SetBackgroundGradientType (theFillType);
}
}
// =======================================================================
// function : GraduatedTrihedronDisplay
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::GraduatedTrihedronDisplay (const Graphic3d_CView& theCView,
const Graphic3d_GraduatedTrihedron& theCubic)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView != NULL)
{
aCView->View->GraduatedTrihedronDisplay (aCView->WS->GetGlContext(), theCubic);
}
}
// =======================================================================
// function : GraduatedTrihedronErase
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::GraduatedTrihedronErase (const Graphic3d_CView& theCView)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView != NULL)
{
aCView->View->GraduatedTrihedronErase (aCView->WS->GetGlContext());
}
}
// =======================================================================
// function : GraduatedTrihedronMinMaxValues
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::GraduatedTrihedronMinMaxValues (const Graphic3d_CView& theView,
const Graphic3d_Vec3 theMin,
const Graphic3d_Vec3 theMax)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theView.ptrView;
if (aCView != NULL)
{
aCView->View->ChangeGraduatedTrihedron().SetMinMax (theMin, theMax);
}
}
// =======================================================================
// function : SetBuffersNoSwap
// purpose :
@ -661,3 +508,297 @@ void OpenGl_GraphicDriver::TextSize (const Standard_CString theText,
NCollection_String aText = (Standard_Utf16Char* )anExtText.ToExtString();
OpenGl_Text::StringSize (aCtx, aText, aTextAspect, aTextParam, theWidth, theAscent, theDescent);
}
//=======================================================================
//function : AddZLayer
//purpose :
//=======================================================================
void OpenGl_GraphicDriver::AddZLayer (const Graphic3d_ZLayerId theLayerId)
{
if (theLayerId < 1)
{
Standard_ASSERT_RAISE (theLayerId > 0,
"OpenGl_GraphicDriver::AddZLayer, "
"negative and zero IDs are reserved");
}
myLayerIds.Add (theLayerId);
myLayerSeq.Append (theLayerId);
// Default z-layer settings
myMapOfZLayerSettings.Bind (theLayerId, Graphic3d_ZLayerSettings());
// Add layer to all views
NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIt (myMapOfView);
for (; aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->AddZLayer (theLayerId);
}
}
//=======================================================================
//function : RemoveZLayer
//purpose :
//=======================================================================
void OpenGl_GraphicDriver::RemoveZLayer (const Graphic3d_ZLayerId theLayerId)
{
Standard_ASSERT_RAISE (theLayerId > 0,
"OpenGl_GraphicDriver::AddZLayer, "
"negative and zero IDs are reserved"
"and can not be removed");
Standard_ASSERT_RAISE (myLayerIds.Contains (theLayerId),
"OpenGl_GraphicDriver::RemoveZLayer, "
"Layer with theLayerId does not exist");
// Remove layer from all of the views
NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIt (myMapOfView);
for (; aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->RemoveZLayer (theLayerId);
}
// Unset Z layer for all of the structures.
NCollection_DataMap<Standard_Integer, OpenGl_Structure*>::Iterator aStructIt (myMapOfStructure);
for( ; aStructIt.More (); aStructIt.Next ())
{
OpenGl_Structure* aStruct = aStructIt.ChangeValue ();
if (aStruct->ZLayer() == theLayerId)
aStruct->SetZLayer (Graphic3d_ZLayerId_Default);
}
// Remove index
for (int aIdx = 1; aIdx <= myLayerSeq.Length (); aIdx++)
{
if (myLayerSeq (aIdx) == theLayerId)
{
myLayerSeq.Remove (aIdx);
break;
}
}
myMapOfZLayerSettings.UnBind (theLayerId);
myLayerIds.Remove (theLayerId);
}
//=======================================================================
//function : ZLayers
//purpose :
//=======================================================================
void OpenGl_GraphicDriver::ZLayers (TColStd_SequenceOfInteger& theLayerSeq) const
{
theLayerSeq.Assign (myLayerSeq);
}
//=======================================================================
//function : SetZLayerSettings
//purpose :
//=======================================================================
void OpenGl_GraphicDriver::SetZLayerSettings (const Graphic3d_ZLayerId theLayerId,
const Graphic3d_ZLayerSettings& theSettings)
{
// Change Z layer settings in all managed views
NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIt (myMapOfView);
for (; aViewIt.More(); aViewIt.Next())
{
aViewIt.Value()->SetZLayerSettings (theLayerId, theSettings);
}
if (myMapOfZLayerSettings.IsBound (theLayerId))
{
myMapOfZLayerSettings.ChangeFind (theLayerId) = theSettings;
}
else
{
myMapOfZLayerSettings.Bind (theLayerId, theSettings);
}
}
//=======================================================================
//function : ZLayerSettings
//purpose :
//=======================================================================
Graphic3d_ZLayerSettings OpenGl_GraphicDriver::ZLayerSettings (const Graphic3d_ZLayerId theLayerId)
{
Standard_ASSERT_RAISE (myLayerIds.Contains (theLayerId),
"OpenGl_GraphicDriver::ZLayerSettings, "
"Layer with theLayerId does not exist");
return myMapOfZLayerSettings.Find (theLayerId);
}
// =======================================================================
// function : Structure
// purpose :
// =======================================================================
Handle(Graphic3d_CStructure) OpenGl_GraphicDriver::CreateStructure (const Handle(Graphic3d_StructureManager)& theManager)
{
Handle(OpenGl_Structure) aStructure = new OpenGl_Structure (theManager);
myMapOfStructure.Bind (aStructure->Id, aStructure.operator->());
return aStructure;
}
// =======================================================================
// function : Structure
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::RemoveStructure (Handle(Graphic3d_CStructure)& theCStructure)
{
OpenGl_Structure* aStructure = NULL;
if (!myMapOfStructure.Find (theCStructure->Id, aStructure))
{
return;
}
myMapOfStructure.UnBind (theCStructure->Id);
aStructure->Release (GetSharedContext());
theCStructure.Nullify();
}
// =======================================================================
// function : View
// purpose :
// =======================================================================
Handle(Graphic3d_CView) OpenGl_GraphicDriver::CreateView (const Handle(Graphic3d_StructureManager)& theMgr)
{
Handle(OpenGl_View) aView = new OpenGl_View (theMgr, this, myCaps, myDeviceLostFlag, &myStateCounter);
myMapOfView.Add (aView);
for (TColStd_SequenceOfInteger::Iterator aLayerIt (myLayerSeq); aLayerIt.More(); aLayerIt.Next())
{
const Graphic3d_ZLayerId aLayerID = aLayerIt.Value();
const Graphic3d_ZLayerSettings& aSettings = myMapOfZLayerSettings.Find (aLayerID);
aView->AddZLayer (aLayerID);
aView->SetZLayerSettings (aLayerID, aSettings);
}
return aView;
}
// =======================================================================
// function : RemoveView
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::RemoveView (const Handle(Graphic3d_CView)& theView)
{
Handle(OpenGl_Context) aCtx = GetSharedContext();
Handle(OpenGl_View) aView = Handle(OpenGl_View)::DownCast (theView);
if (aView.IsNull())
{
return;
}
if (!myMapOfView.Remove (aView))
{
return;
}
Handle(OpenGl_Window) aWindow = aView->GlWindow();
if (!aWindow.IsNull()
&& aWindow->GetGlContext()->MakeCurrent())
{
aCtx = aWindow->GetGlContext();
}
else
{
// try to hijack another context if any
const Handle(OpenGl_Context)& anOtherCtx = GetSharedContext();
if (!anOtherCtx.IsNull()
&& anOtherCtx != aWindow->GetGlContext())
{
aCtx = anOtherCtx;
aCtx->MakeCurrent();
}
}
aView->ReleaseGlResources (aCtx);
if (myMapOfView.IsEmpty())
{
// The last view removed but some objects still present.
// Release GL resources now without object destruction.
for (NCollection_DataMap<Standard_Integer, OpenGl_Structure*>::Iterator aStructIt (myMapOfStructure);
aStructIt.More (); aStructIt.Next())
{
OpenGl_Structure* aStruct = aStructIt.ChangeValue();
aStruct->ReleaseGlResources (aCtx);
}
myDeviceLostFlag = !myMapOfStructure.IsEmpty();
}
}
// =======================================================================
// function : Window
// purpose :
// =======================================================================
Handle(OpenGl_Window) OpenGl_GraphicDriver::CreateRenderWindow (const Handle(Aspect_Window)& theWindow,
const Aspect_RenderingContext theContext)
{
Handle(OpenGl_Context) aShareCtx = GetSharedContext();
Handle(OpenGl_Window) aWindow = new OpenGl_Window (this, theWindow, theContext, myCaps, aShareCtx);
return aWindow;
}
//=======================================================================
//function : ViewExists
//purpose :
//=======================================================================
Standard_Boolean OpenGl_GraphicDriver::ViewExists (const Handle(Aspect_Window)& AWindow, Handle(Graphic3d_CView)& theView)
{
Standard_Boolean isExist = Standard_False;
// Parse the list of views to find
// a view with the specified window
#if defined(_WIN32)
const Handle(WNT_Window) THEWindow = Handle(WNT_Window)::DownCast (AWindow);
Aspect_Handle TheSpecifiedWindowId = THEWindow->HWindow ();
#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
const Handle(Cocoa_Window) THEWindow = Handle(Cocoa_Window)::DownCast (AWindow);
#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
UIView* TheSpecifiedWindowId = THEWindow->HView();
#else
NSView* TheSpecifiedWindowId = THEWindow->HView();
#endif
#elif defined(__ANDROID__)
int TheSpecifiedWindowId = -1;
#else
const Handle(Xw_Window) THEWindow = Handle(Xw_Window)::DownCast (AWindow);
int TheSpecifiedWindowId = int (THEWindow->XWindow ());
#endif
NCollection_Map<Handle(OpenGl_View)>::Iterator aViewIt (myMapOfView);
for(; aViewIt.More(); aViewIt.Next())
{
const Handle(OpenGl_View)& aView = aViewIt.Value();
if (aView->IsDefined() && aView->IsActive())
{
const Handle(Aspect_Window) AspectWindow = aView->Window();
#if defined(_WIN32)
const Handle(WNT_Window) theWindow = Handle(WNT_Window)::DownCast (AspectWindow);
Aspect_Handle TheWindowIdOfView = theWindow->HWindow ();
#elif defined(__APPLE__) && !defined(MACOSX_USE_GLX)
const Handle(Cocoa_Window) theWindow = Handle(Cocoa_Window)::DownCast (AspectWindow);
#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
UIView* TheWindowIdOfView = theWindow->HView();
#else
NSView* TheWindowIdOfView = theWindow->HView();
#endif
#elif defined(__ANDROID__)
int TheWindowIdOfView = 0;
#else
const Handle(Xw_Window) theWindow = Handle(Xw_Window)::DownCast (AspectWindow);
int TheWindowIdOfView = int (theWindow->XWindow ());
#endif // WNT
// Comparaison on window IDs
if (TheWindowIdOfView == TheSpecifiedWindowId)
{
isExist = Standard_True;
theView = aView;
}
}
}
return isExist;
}

196
src/OpenGl/OpenGl_GraphicDriver.hxx
View File

@ -17,15 +17,6 @@
#define _OpenGl_GraphicDriver_HeaderFile
#include <Graphic3d_GraphicDriver.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_PrinterContext.hxx>
#include <Standard_CString.hxx>
#include <TColStd_HArray1OfByte.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Quantity_PlaneAngle.hxx>
#include <Quantity_NameOfColor.hxx>
#include <Aspect_Display.hxx>
#include <Aspect_DisplayConnection.hxx>
@ -35,6 +26,7 @@
#include <Aspect_TypeOfTriedronEcho.hxx>
#include <Aspect_Handle.hxx>
#include <Aspect_PrintAlgo.hxx>
#include <Aspect_RenderingContext.hxx>
#include <gp_Ax2.hxx>
#include <Graphic3d_CView.hxx>
#include <Graphic3d_CStructure.hxx>
@ -51,12 +43,18 @@
#include <Graphic3d_Array2OfVertex.hxx>
#include <Graphic3d_BufferType.hxx>
#include <NCollection_DataMap.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_MapOfZLayerSettings.hxx>
#include <Quantity_PlaneAngle.hxx>
#include <Quantity_NameOfColor.hxx>
#include <Standard_CString.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_Array2OfReal.hxx>
#include <TColStd_HArray1OfByte.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_MapOfInteger.hxx>
class Aspect_Window;
class Graphic3d_Vector;
class Quantity_Color;
class Graphic3d_Vertex;
@ -66,6 +64,7 @@ class OpenGl_Element;
class OpenGl_Structure;
class OpenGl_Text;
class OpenGl_View;
class OpenGl_Window;
//! Tool class to implement consistent state counter
//! for objects inside the same driver instance.
@ -83,6 +82,7 @@ private:
};
class OpenGl_GraphicDriver;
DEFINE_STANDARD_HANDLE(OpenGl_GraphicDriver,Graphic3d_GraphicDriver)
//! This class defines an OpenGl graphic driver
@ -118,159 +118,49 @@ public:
Standard_EXPORT Standard_Integer InquireLightLimit ();
Standard_EXPORT Standard_Integer InquireViewLimit ();
public: // Methods for graphical structures
public:
Standard_EXPORT void DisplayStructure (const Graphic3d_CView& theCView,
const Handle(Graphic3d_Structure)& theStructure,
const Standard_Integer thePriority);
Standard_EXPORT void EraseStructure (const Graphic3d_CView& theCView,
const Handle(Graphic3d_Structure)& theStructure);
Standard_EXPORT void RemoveStructure (Handle(Graphic3d_CStructure)& theCStructure);
Standard_EXPORT Handle(Graphic3d_CStructure) Structure (const Handle(Graphic3d_StructureManager)& theManager);
Standard_EXPORT virtual Handle(Graphic3d_CStructure) CreateStructure (const Handle(Graphic3d_StructureManager)& theManager) Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean SetImmediateModeDrawToFront (const Graphic3d_CView& theCView,
const Standard_Boolean theDrawToFrontBuffer);
Standard_EXPORT virtual void RemoveStructure (Handle(Graphic3d_CStructure)& theCStructure) Standard_OVERRIDE;
Standard_EXPORT virtual Handle(Graphic3d_CView) CreateView (const Handle(Graphic3d_StructureManager)& theMgr) Standard_OVERRIDE;
Standard_EXPORT virtual void RemoveView (const Handle(Graphic3d_CView)& theView) Standard_OVERRIDE;
Standard_EXPORT virtual Handle(OpenGl_Window) CreateRenderWindow (const Handle(Aspect_Window)& theWindow, const Aspect_RenderingContext theContext);
public:
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 void RatioWindow (const Graphic3d_CView& ACView);
Standard_EXPORT void Redraw (const Graphic3d_CView& theCView,
const Standard_Integer theX = 0,
const Standard_Integer theY = 0,
const Standard_Integer theWidth = 0,
const Standard_Integer theHeight = 0);
Standard_EXPORT void RedrawImmediate (const Graphic3d_CView& theCView);
Standard_EXPORT void Invalidate (const Graphic3d_CView& theCView);
Standard_EXPORT Standard_Boolean IsInvalidated (const Graphic3d_CView& theCView) const;
Standard_EXPORT void RemoveView (const Graphic3d_CView& ACView);
Standard_EXPORT void SetLight (const Graphic3d_CView& ACView);
Standard_EXPORT void SetClipPlanes (const Graphic3d_CView& theCView);
Standard_EXPORT void SetCamera (const Graphic3d_CView& theCView);
Standard_EXPORT void SetVisualisation (const Graphic3d_CView& ACView);
Standard_EXPORT Standard_Boolean View (Graphic3d_CView& ACView);
Standard_EXPORT void Environment (const Graphic3d_CView& ACView);
Standard_EXPORT void ZBufferTriedronSetup (const Graphic3d_CView& theCView,
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);
//! Displays Graduated trihedron
//! @param theView [in] the graphic view
//! @param theCubic [in] Graduated Trihedon parameters.
//! @sa OpenGl_GraduatedTrihedron
//! @sa Graphic3d_GraduatedTrihedron
Standard_EXPORT void GraduatedTrihedronDisplay (const Graphic3d_CView& theView, const Graphic3d_GraduatedTrihedron& theCubic);
//! Erases Graduated Trihedron from the view.
//! theView [in] graphic view
//! @sa OpenGl_GraduatedTrihedron
Standard_EXPORT void GraduatedTrihedronErase (const Graphic3d_CView& theView);
//! Sets minimum and maximum points of scene bounding box for Graduated Trihedron
//! stored in graphic view object.
//! @param theView [in] current graphic view
//! @param theMin [in] the minimum point of scene.
//! @param theMax [in] the maximum point of scene.
//! @sa OpenGl_GraduatedTrihedron
Standard_EXPORT void GraduatedTrihedronMinMaxValues (const Graphic3d_CView& theView,
const Graphic3d_Vec3 theMin, const Graphic3d_Vec3 theMax);
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.
//! @param thePrinterDC pass the PrinterDeviceContext (HDC)
//! @param theToShowBackground when set to FALSE then print the view without background color (background is white) else set to TRUE for printing with current background color
//! @param theFileName if != NULL, then the view will be printed to a file
//! @param thePrintAlgorithm select print algorithm: stretch, tile
//! @param theScaleFactor scaling coefficient, used internally to scale the printings accordingly to the scale factor selected in the printer properties dialog
//! @return Standard_True if the data is passed to the printer, otherwise Standard_False if the print operation failed due to the printer errors,
//! or lack of system memory. This might be related to insufficient memory or some internal errors.
//! All this errors are indicated by the message boxes (on level of OpenGl_GraphicDriver).
//! Warning: This function can reuse FBO assigned to the view, please take it into account if you use it for your purposes.
Standard_EXPORT Standard_Boolean Print (const Graphic3d_CView& theCView,
const Aspect_Handle thePrinterDC,
const Standard_Boolean theToShowBackground,
const Standard_CString theFileName,
const Aspect_PrintAlgo thePrintAlgorithm = Aspect_PA_STRETCH,
const Standard_Real theScaleFactor = 1.0) const;
//! Reads depths of shown pixels of the given rectangle (glReadPixels with GL_DEPTH_COMPONENT)
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).
//! If not supported on hardware returns NULL.
Standard_EXPORT Graphic3d_PtrFrameBuffer FBOCreate (const Graphic3d_CView& view, const Standard_Integer width, const Standard_Integer height);
//! Remove offscreen FBO
Standard_EXPORT void FBORelease (const Graphic3d_CView& view, Graphic3d_PtrFrameBuffer& fboPtr);
//! Dump active rendering buffer into specified memory buffer.
Standard_EXPORT Standard_Boolean BufferDump (const Graphic3d_CView& theCView,
Image_PixMap& theImage,
const Graphic3d_BufferType& theBufferType);
Standard_EXPORT void SetGLLightEnabled (const Graphic3d_CView& view,const Standard_Boolean isEnabled) const;
Standard_EXPORT Standard_Boolean IsGLLightEnabled (const Graphic3d_CView& view) const;
Standard_EXPORT Standard_Integer InquirePlaneLimit();
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 Standard_Boolean ViewExists (const Handle(Aspect_Window)& theWindow, Handle(Graphic3d_CView)& theView) Standard_OVERRIDE;
Standard_EXPORT void FBOChangeViewport(const Graphic3d_CView& view,Graphic3d_PtrFrameBuffer& fboPtr,const Standard_Integer width,const Standard_Integer height);
public:
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 Standard_Real thePrecision = 0.005,const Standard_Address theProgressBarFunc = NULL,const Standard_Address theProgressObject = NULL);
//! Adds a new top-level z layer with ID theLayerId for all views. Z layers allow drawing structures in higher layers
//! in foreground of structures in lower layers. To add a structure to desired layer on display it is necessary to
//! set the layer index for the structure. The passed theLayerId should be not less than 0 (reserved for default layers).
Standard_EXPORT void AddZLayer (const Graphic3d_ZLayerId theLayerId) Standard_OVERRIDE;
//! Add a new top-level z layer with ID theLayerId for the view. Z layers allow drawing structures in higher layers in foreground of structures in lower layers.
//! To add a structure to desired layer on display it is necessary to set the layer index for the structure.
Standard_EXPORT void AddZLayer (const Graphic3d_CView& theCView,
const Graphic3d_ZLayerId theLayerId);
//! Removes Z layer. All structures displayed at the moment in layer will be displayed in
//! default layer (the bottom-level z layer). By default, there are always default
//! bottom-level layer that can't be removed. The passed theLayerId should be not less than 0
//! (reserved for default layers that can not be removed).
Standard_EXPORT void RemoveZLayer (const Graphic3d_ZLayerId theLayerId) Standard_OVERRIDE;
//! Remove Z layer from the specified view.
//! All structures displayed at the moment in layer will be displayed in default layer (the bottom-level z layer).
//! To unset layer index from associated structures use method UnsetZLayer (...).
Standard_EXPORT void RemoveZLayer (const Graphic3d_CView& theCView,
const Graphic3d_ZLayerId theLayerId);
//! Returns list of Z layers defined for the graphical driver.
Standard_EXPORT void ZLayers (TColStd_SequenceOfInteger& theLayerSeq) const Standard_OVERRIDE;
//! Unset Z layer ID for all structures.
//! The structure indexes will be set to default layer (the bottom-level z layer with ID = 0).
Standard_EXPORT void UnsetZLayer (const Graphic3d_ZLayerId theLayerId);
//! Sets the settings for a single Z layer.
Standard_EXPORT void SetZLayerSettings (const Graphic3d_ZLayerId theLayerId, const Graphic3d_ZLayerSettings& theSettings) Standard_OVERRIDE;
//! Change Z layer of a structure already presented in view.
//! It is recommended to update z layer of already displayed structures with this method before setting new z layer index to the structure.
//! This is usually done by viewer manager.
Standard_EXPORT void ChangeZLayer (const Graphic3d_CStructure& theCStructure,
const Graphic3d_CView& theCView,
const Graphic3d_ZLayerId theNewLayerId);
//! Sets the settings for a single Z layer of specified view.
Standard_EXPORT void SetZLayerSettings (const Graphic3d_CView& theCView,
const Graphic3d_ZLayerId theLayerId,
const Graphic3d_ZLayerSettings& theSettings);
//! Changes priority of a structure within its Z layer for the specified view.
Standard_EXPORT void ChangePriority (const Graphic3d_CStructure& theCStructure,
const Graphic3d_CView& theCView,
const Standard_Integer theNewPriority);
//! Returns the settings of a single Z layer.
Standard_EXPORT virtual Graphic3d_ZLayerSettings ZLayerSettings (const Graphic3d_ZLayerId theLayerId) Standard_OVERRIDE;
public:
@ -311,10 +201,6 @@ public:
//! Could return NULL-handle if no window created by this driver.
Standard_EXPORT const Handle(OpenGl_Context)& GetSharedContext() const;
//! Marks BVH tree for given priority list as dirty and
//! marks primitive set for rebuild.
Standard_EXPORT void InvalidateBVHData (Graphic3d_CView& theCView, const Standard_Integer theLayerId);
#if defined(HAVE_EGL) || defined(__ANDROID__)
Aspect_Display getRawGlDisplay() const { return myEglDisplay; }
Aspect_RenderingContext getRawGlContext() const { return myEglContext; }
@ -336,11 +222,15 @@ protected:
Handle(OpenGl_Caps) myCaps;
NCollection_Map<Handle(OpenGl_View)> myMapOfView;
NCollection_Map<Handle(OpenGl_Workspace)> myMapOfWS;
NCollection_DataMap<Standard_Integer, OpenGl_Structure*> myMapOfStructure;
mutable Handle(OpenGl_PrinterContext) myPrintContext;
OpenGl_UserDrawCallback_t myUserDrawCallback;
public:
TColStd_MapOfInteger myLayerIds;
TColStd_SequenceOfInteger myLayerSeq;
OpenGl_MapOfZLayerSettings myMapOfZLayerSettings;
public:
//! State counter for OpenGl structures.

114
src/OpenGl/OpenGl_GraphicDriver_4.cxx
View File

@ -1,114 +0,0 @@
// Created on: 2011-10-20
// Created by: Sergey ZERCHANINOV
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <OpenGl_GraphicDriver.hxx>
#include <NCollection_DataMap.hxx>
#include <OpenGl_Structure.hxx>
#include <OpenGl_CView.hxx>
void OpenGl_GraphicDriver::DisplayStructure (const Graphic3d_CView& theCView,
const Handle(Graphic3d_Structure)& theStructure,
const Standard_Integer thePriority)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView == NULL)
return;
aCView->View->DisplayStructure (theStructure, thePriority);
}
void OpenGl_GraphicDriver::EraseStructure (const Graphic3d_CView& theCView,
const Handle(Graphic3d_Structure)& theStructure)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView == NULL)
return;
aCView->View->EraseStructure (theStructure);
}
void OpenGl_GraphicDriver::RemoveStructure (Handle(Graphic3d_CStructure)& theCStructure)
{
OpenGl_Structure* aStructure = NULL;
if (!myMapOfStructure.Find (theCStructure->Id, aStructure))
{
return;
}
myMapOfStructure.UnBind (theCStructure->Id);
aStructure->Release (GetSharedContext());
theCStructure.Nullify();
}
Handle(Graphic3d_CStructure) OpenGl_GraphicDriver::Structure (const Handle(Graphic3d_StructureManager)& theManager)
{
Handle(OpenGl_Structure) aStructure = new OpenGl_Structure (theManager);
myMapOfStructure.Bind (aStructure->Id, aStructure.operator->());
return aStructure;
}
//=======================================================================
//function : ChangeZLayer
//purpose :
//=======================================================================
void OpenGl_GraphicDriver::ChangeZLayer (const Graphic3d_CStructure& theCStructure,
const Graphic3d_CView& theCView,
const Graphic3d_ZLayerId theNewLayerId)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)theCView.ptrView;
if (!myMapOfStructure.IsBound (theCStructure.Id) || !aCView)
return;
OpenGl_Structure* aStructure = myMapOfStructure.Find (theCStructure.Id);
aCView->View->ChangeZLayer (aStructure, theNewLayerId);
}
//=======================================================================
//function : UnsetZLayer
//purpose :
//=======================================================================
void OpenGl_GraphicDriver::UnsetZLayer (const Graphic3d_ZLayerId theLayerId)
{
NCollection_DataMap<Standard_Integer, OpenGl_Structure*>::Iterator aStructIt (myMapOfStructure);
for( ; aStructIt.More (); aStructIt.Next ())
{
OpenGl_Structure* aStruct = aStructIt.ChangeValue ();
if (aStruct->ZLayer() == theLayerId)
aStruct->SetZLayer (Graphic3d_ZLayerId_Default);
}
}
//=======================================================================
//function : ChangePriority
//purpose :
//=======================================================================
void OpenGl_GraphicDriver::ChangePriority (const Graphic3d_CStructure& theCStructure,
const Graphic3d_CView& theCView,
const Standard_Integer theNewPriority)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)theCView.ptrView;
if (!myMapOfStructure.IsBound (theCStructure.Id) || !aCView)
return;
OpenGl_Structure* aStructure = myMapOfStructure.Find (theCStructure.Id);
aCView->View->ChangePriority (aStructure, theNewPriority);
}

599
src/OpenGl/OpenGl_GraphicDriver_7.cxx
View File

@ -1,599 +0,0 @@
// Created on: 2011-10-20
// Created by: Sergey ZERCHANINOV
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <OpenGl_GraphicDriver.hxx>
#include <OpenGl_FrameBuffer.hxx>
#include <OpenGl_Structure.hxx>
#include <OpenGl_CView.hxx>
#include <OpenGl_Text.hxx>
/*----------------------------------------------------------------------*/
void OpenGl_GraphicDriver::ActivateView (const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
aCView->WS->SetActiveView(aCView->View, ACView.ViewId);
}
void OpenGl_GraphicDriver::AntiAliasing (const Graphic3d_CView& ACView, const Standard_Boolean AFlag)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
aCView->View->SetAntiAliasing(AFlag);
}
void OpenGl_GraphicDriver::Background (const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->WS->SetBackgroundColor(ACView.DefWindow.Background.r,ACView.DefWindow.Background.g,ACView.DefWindow.Background.b);
}
}
void OpenGl_GraphicDriver::GradientBackground (const Graphic3d_CView& ACView,
const Quantity_Color& AColor1,
const Quantity_Color& AColor2,
const Aspect_GradientFillMethod AType)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->SetBackgroundGradient(AColor1,AColor2,AType);
}
}
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->WS->Resize(ACView.DefWindow);
}
}
}
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, -1);
}
}
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);
}
void OpenGl_GraphicDriver::RatioWindow (const Graphic3d_CView& theCView)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView != NULL)
aCView->WS->Resize (theCView.DefWindow);
}
void OpenGl_GraphicDriver::Redraw (const Graphic3d_CView& ACView,
const Standard_Integer /*x*/,
const Standard_Integer /*y*/,
const Standard_Integer /*width*/,
const Standard_Integer /*height*/)
{
if (ACView.RenderParams.Method == Graphic3d_RM_RAYTRACING
&& !myCaps->vboDisable
&& !myCaps->keepArrayData)
{
if (ACView.WasRedrawnGL)
{
myDeviceLostFlag = Standard_True;
}
myCaps->keepArrayData = Standard_True;
}
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);
}
}
void OpenGl_GraphicDriver::RedrawImmediate (const Graphic3d_CView& theCView)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView != NULL)
{
aCView->WS->RedrawImmediate (theCView);
}
}
void OpenGl_GraphicDriver::Invalidate (const Graphic3d_CView& theCView)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView != NULL)
{
aCView->WS->Invalidate();
}
}
Standard_Boolean OpenGl_GraphicDriver::IsInvalidated (const Graphic3d_CView& theCView) const
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
return aCView == NULL
|| aCView->WS->IsInvalidated();
}
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
const Handle(OpenGl_Context)& aCtx = GetGlContext();
OpenGl_FrameBuffer* aFrameBuffer = new OpenGl_FrameBuffer();
if (!aFrameBuffer->Init (aCtx, theWidth, theHeight))
{
aFrameBuffer->Release (aCtx.operator->());
delete aFrameBuffer;
return NULL;
}
return (Graphic3d_PtrFrameBuffer )aFrameBuffer;
}
void OpenGl_GraphicDriver::FBORelease (const Graphic3d_CView& ACView, Graphic3d_PtrFrameBuffer& theFBOPtr)
{
if (theFBOPtr == NULL)
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
if (!Activate()
|| theFBOPtr == NULL)
{
return;
}
// release the object
OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer*)theFBOPtr;
if (aFrameBuffer != NULL)
{
aFrameBuffer->Release (GetGlContext().operator->());
}
delete aFrameBuffer;
}
void OpenGl_GraphicDriver::FBOGetDimensions (const Graphic3d_CView& ,
const Graphic3d_PtrFrameBuffer theFBOPtr,
Standard_Integer& theWidth, Standard_Integer& theHeight,
Standard_Integer& theWidthMax, Standard_Integer& theHeightMax)
{
if (theFBOPtr == NULL)
{
return;
}
const OpenGl_FrameBuffer* aFrameBuffer = (const OpenGl_FrameBuffer* )theFBOPtr;
theWidth = aFrameBuffer->GetVPSizeX(); // current viewport size
theHeight = aFrameBuffer->GetVPSizeY();
theWidthMax = aFrameBuffer->GetSizeX(); // texture size
theHeightMax = aFrameBuffer->GetSizeY();
}
void OpenGl_GraphicDriver::FBOChangeViewport (const Graphic3d_CView& ,
Graphic3d_PtrFrameBuffer& theFBOPtr,
const Standard_Integer theWidth, const Standard_Integer theHeight)
{
if (theFBOPtr == NULL)
{
return;
}
OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer* )theFBOPtr;
aFrameBuffer->ChangeViewport (theWidth, theHeight);
}
inline bool getDataFormat (const Image_PixMap& theData,
GLenum& thePixelFormat,
GLenum& theDataType)
{
thePixelFormat = GL_RGB;
theDataType = GL_UNSIGNED_BYTE;
switch (theData.Format())
{
#if !defined(GL_ES_VERSION_2_0)
case Image_PixMap::ImgGray:
thePixelFormat = GL_DEPTH_COMPONENT;
theDataType = GL_UNSIGNED_BYTE;
return true;
case Image_PixMap::ImgGrayF:
thePixelFormat = GL_DEPTH_COMPONENT;
theDataType = GL_FLOAT;
return true;
case Image_PixMap::ImgBGR:
thePixelFormat = GL_BGR;
theDataType = GL_UNSIGNED_BYTE;
return true;
case Image_PixMap::ImgBGRA:
case Image_PixMap::ImgBGR32:
thePixelFormat = GL_BGRA;
theDataType = GL_UNSIGNED_BYTE;
return true;
case Image_PixMap::ImgBGRF:
thePixelFormat = GL_BGR;
theDataType = GL_FLOAT;
return true;
case Image_PixMap::ImgBGRAF:
thePixelFormat = GL_BGRA;
theDataType = GL_FLOAT;
return true;
#else
case Image_PixMap::ImgGray:
case Image_PixMap::ImgGrayF:
case Image_PixMap::ImgBGR:
case Image_PixMap::ImgBGRA:
case Image_PixMap::ImgBGR32:
case Image_PixMap::ImgBGRF:
case Image_PixMap::ImgBGRAF:
return false;
#endif
case Image_PixMap::ImgRGB:
thePixelFormat = GL_RGB;
theDataType = GL_UNSIGNED_BYTE;
return true;
case Image_PixMap::ImgRGBA:
case Image_PixMap::ImgRGB32:
thePixelFormat = GL_RGBA;
theDataType = GL_UNSIGNED_BYTE;
return true;
case Image_PixMap::ImgRGBF:
thePixelFormat = GL_RGB;
theDataType = GL_FLOAT;
return true;
case Image_PixMap::ImgRGBAF:
thePixelFormat = GL_RGBA;
theDataType = GL_FLOAT;
return true;
case Image_PixMap::ImgAlpha:
case Image_PixMap::ImgAlphaF:
return false; // GL_ALPHA is no more supported in core context
case Image_PixMap::ImgUNKNOWN:
return false;
}
return false;
}
Standard_Boolean OpenGl_GraphicDriver::BufferDump (const Graphic3d_CView& theCView,
Image_PixMap& theImage,
const Graphic3d_BufferType& theBufferType)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
return (aCView != NULL) && aCView->WS->BufferDump ((OpenGl_FrameBuffer* )theCView.ptrFBO, theImage, theBufferType);
}
//! Compute aligned number greater or equal to specified one
inline Standard_Size getAligned (const Standard_Size theNumber,
const Standard_Size theAlignment)
{
return theNumber + theAlignment - 1 - (theNumber - 1) % theAlignment;
}
Standard_Boolean OpenGl_Workspace::BufferDump (OpenGl_FrameBuffer* theFBOPtr,
Image_PixMap& theImage,
const Graphic3d_BufferType& theBufferType)
{
GLenum aFormat, aType;
if (theImage.IsEmpty()
|| !getDataFormat (theImage, aFormat, aType)
|| !Activate())
{
return Standard_False;
}
#if !defined(GL_ES_VERSION_2_0)
GLint aReadBufferPrev = GL_BACK;
if (theBufferType == Graphic3d_BT_Depth
&& aFormat != GL_DEPTH_COMPONENT)
{
return Standard_False;
}
#endif
// bind FBO if used
if (theFBOPtr != NULL && theFBOPtr->IsValid())
{
theFBOPtr->BindBuffer (GetGlContext());
}
else
{
#if !defined(GL_ES_VERSION_2_0)
glGetIntegerv (GL_READ_BUFFER, &aReadBufferPrev);
GLint aDrawBufferPrev = GL_BACK;
glGetIntegerv (GL_DRAW_BUFFER, &aDrawBufferPrev);
glReadBuffer (aDrawBufferPrev);
#endif
}
// setup alignment
const GLint anAligment = Min (GLint(theImage.MaxRowAligmentBytes()), 8); // limit to 8 bytes for OpenGL
glPixelStorei (GL_PACK_ALIGNMENT, anAligment);
bool isBatchCopy = !theImage.IsTopDown();
const GLint anExtraBytes = GLint(theImage.RowExtraBytes());
GLint aPixelsWidth = GLint(theImage.SizeRowBytes() / theImage.SizePixelBytes());
Standard_Size aSizeRowBytesEstim = getAligned (theImage.SizePixelBytes() * aPixelsWidth, anAligment);
if (anExtraBytes < anAligment)
{
aPixelsWidth = 0;
}
else if (aSizeRowBytesEstim != theImage.SizeRowBytes())
{
aPixelsWidth = 0;
isBatchCopy = false;
}
#if !defined(GL_ES_VERSION_2_0)
glPixelStorei (GL_PACK_ROW_LENGTH, aPixelsWidth);
#else
if (aPixelsWidth != 0)
{
isBatchCopy = false;
}
#endif
if (!isBatchCopy)
{
// copy row by row
for (Standard_Size aRow = 0; aRow < theImage.SizeY(); ++aRow)
{
// Image_PixMap rows indexation always starts from the upper corner
// while order in memory depends on the flag and processed by ChangeRow() method
glReadPixels (0, GLint(theImage.SizeY() - aRow - 1), GLsizei (theImage.SizeX()), 1, aFormat, aType, theImage.ChangeRow (aRow));
}
}
else
{
glReadPixels (0, 0, GLsizei (theImage.SizeX()), GLsizei (theImage.SizeY()), aFormat, aType, theImage.ChangeData());
}
glPixelStorei (GL_PACK_ALIGNMENT, 1);
#if !defined(GL_ES_VERSION_2_0)
glPixelStorei (GL_PACK_ROW_LENGTH, 0);
#endif
if (theFBOPtr != NULL && theFBOPtr->IsValid())
{
theFBOPtr->UnbindBuffer (GetGlContext());
}
else
{
#if !defined(GL_ES_VERSION_2_0)
glReadBuffer (aReadBufferPrev);
#endif
}
return Standard_True;
}
void OpenGl_GraphicDriver::RemoveView (const Graphic3d_CView& theCView)
{
Handle(OpenGl_Context) aCtx = GetSharedContext();
OpenGl_CView* aCView = (OpenGl_CView* )theCView.ptrView;
if (aCView == NULL
|| aCView->View.IsNull()
|| aCView->WS.IsNull())
{
return;
}
Handle(OpenGl_View) aView = aCView->View;
Handle(OpenGl_Workspace) aWindow = aCView->WS;
if (!myMapOfWS .Remove (aWindow)
|| !myMapOfView.Remove (aView))
{
return;
}
if (aWindow->GetGlContext()->MakeCurrent())
{
aCtx = aWindow->GetGlContext();
}
else
{
// try to hijack another context if any
const Handle(OpenGl_Context)& anOtherCtx = GetSharedContext();
if (!anOtherCtx.IsNull()
&& anOtherCtx != aWindow->GetGlContext())
{
aCtx = anOtherCtx;
aCtx->MakeCurrent();
}
}
aView->ReleaseGlResources (aCtx);
if (myMapOfWS.IsEmpty())
{
// The last view removed but some objects still present.
// Release GL resources now without object destruction.
for (NCollection_DataMap<Standard_Integer, OpenGl_Structure*>::Iterator aStructIt (myMapOfStructure);
aStructIt.More (); aStructIt.Next())
{
OpenGl_Structure* aStruct = aStructIt.ChangeValue();
aStruct->ReleaseGlResources (aCtx);
}
myDeviceLostFlag = !myMapOfStructure.IsEmpty();
}
delete aCView;
((Graphic3d_CView *)&theCView)->ptrView = NULL;
aCtx.Nullify();
aView.Nullify();
aWindow.Nullify();
}
void OpenGl_GraphicDriver::SetLight (const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
aCView->View->SetLights(ACView.Context);
}
void OpenGl_GraphicDriver::SetClipPlanes (const Graphic3d_CView& theCView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)theCView.ptrView;
if (aCView)
{
aCView->View->SetClipPlanes (theCView.Context.ClipPlanes);
}
}
//=======================================================================
//function : SetCamera
//purpose :
//=======================================================================
void OpenGl_GraphicDriver::SetCamera (const Graphic3d_CView& theCView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)theCView.ptrView;
if (aCView)
{
aCView->View->SetCamera (theCView.Context.Camera);
}
}
void OpenGl_GraphicDriver::SetVisualisation (const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
{
aCView->View->SetVisualisation(ACView.Context);
}
}
// =======================================================================
// function : InvalidateBVHData
// purpose :
// =======================================================================
void OpenGl_GraphicDriver::InvalidateBVHData (Graphic3d_CView& theCView, const Standard_Integer theLayerId)
{
OpenGl_CView *aCView = (OpenGl_CView *)theCView.ptrView;
if(aCView)
{
aCView->View->InvalidateBVHData (theLayerId);
}
}
Standard_Boolean OpenGl_GraphicDriver::View (Graphic3d_CView& theCView)
{
Handle(OpenGl_Context) aShareCtx = GetSharedContext();
OpenGl_CView* aCView = (OpenGl_CView* )theCView.ptrView;
if (aCView != NULL
&& myMapOfView.Contains (aCView->View))
{
Handle(OpenGl_Workspace) anOldWS = aCView->WS;
Handle(OpenGl_Workspace) aWS = new OpenGl_Workspace (this, theCView.DefWindow, theCView.GContext, myCaps, aShareCtx);
aCView->WS = aWS;
aWS->SetActiveView (aCView->View, theCView.ViewId);
myMapOfWS.Remove (anOldWS);
myMapOfWS.Add (aWS);
return Standard_True;
}
Handle(OpenGl_Workspace) aWS = new OpenGl_Workspace (this, theCView.DefWindow, theCView.GContext, myCaps, aShareCtx);
Handle(OpenGl_View) aView = new OpenGl_View (theCView.Context, &myStateCounter);
myMapOfWS .Add (aWS);
myMapOfView.Add (aView);
aCView = new OpenGl_CView();
aCView->View = aView;
aCView->WS = aWS;
theCView.ptrView = aCView;
aWS->SetActiveView (aCView->View, theCView.ViewId);
return Standard_True;
}
void OpenGl_GraphicDriver::SetBackFacingModel (const Graphic3d_CView& ACView)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
aCView->View->SetBackfacing(ACView.Backfacing);
}
//=======================================================================
//function : AddZLayer
//purpose :
//=======================================================================
void OpenGl_GraphicDriver::AddZLayer (const Graphic3d_CView& theCView,
const Graphic3d_ZLayerId theLayerId)
{
const OpenGl_CView *aCView = (const OpenGl_CView *)theCView.ptrView;
if (aCView)
aCView->View->AddZLayer (theLayerId);
}
//=======================================================================
//function : RemoveZLayer
//purpose :
//=======================================================================
void OpenGl_GraphicDriver::RemoveZLayer (const Graphic3d_CView& theCView,
const Graphic3d_ZLayerId theLayerId)
{
const OpenGl_CView* aCView = (const OpenGl_CView *)theCView.ptrView;
if (aCView)
aCView->View->RemoveZLayer (theLayerId);
}
//=======================================================================
//function : SetZLayerSettings
//purpose :
//=======================================================================
Standard_EXPORT void OpenGl_GraphicDriver::SetZLayerSettings (const Graphic3d_CView& theCView,
const Graphic3d_ZLayerId theLayerId,
const Graphic3d_ZLayerSettings& theSettings)
{
const OpenGl_CView* aCView = (const OpenGl_CView* )theCView.ptrView;
if (aCView)
aCView->View->SetZLayerSettings (theLayerId, theSettings);
}

48
src/OpenGl/OpenGl_GraphicDriver_713.cxx
View File

@ -1,48 +0,0 @@
// Created on: 2011-10-20
// Created by: Sergey ZERCHANINOV
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <OpenGl_GraphicDriver.hxx>
#include <OpenGl_Group.hxx>
#include <OpenGl_PrimitiveArray.hxx>
#include <OpenGl_CView.hxx>
void OpenGl_GraphicDriver::ReadDepths( const Graphic3d_CView& ACView,
const Standard_Integer x,
const Standard_Integer y,
const Standard_Integer width,
const Standard_Integer height,
const Standard_Address buffer ) const
{
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& ACView, const Standard_Boolean isEnabled ) const
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
aCView->WS->UseGLLight() = isEnabled;
}
Standard_Boolean OpenGl_GraphicDriver::IsGLLightEnabled( const Graphic3d_CView& ACView ) const
{
const OpenGl_CView *aCView = (const OpenGl_CView *)ACView.ptrView;
if (aCView)
return aCView->WS->UseGLLight();
return Standard_False;
}

141
src/OpenGl/OpenGl_GraphicDriver_Export.cxx
View File

@ -1,141 +0,0 @@
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <OpenGl_GraphicDriver.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_CView.hxx>
#include <Standard_CLocaleSentry.hxx>
#ifdef HAVE_GL2PS
#include <gl2ps.h>
#endif
/************************************************************************/
/* Print Methods */
/************************************************************************/
#ifdef HAVE_GL2PS
Standard_Boolean OpenGl_GraphicDriver::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 Standard_Real /*thePrecision*/,
const Standard_Address /*theProgressBarFunc*/,
const Standard_Address /*theProgressObject*/)
{
// gl2psBeginPage() will call OpenGL functions
// so we should activate correct GL context before redraw scene call
const OpenGl_CView* aCView = (const OpenGl_CView* )theView.ptrView;
if (aCView == NULL || !aCView->WS->GetGlContext()->MakeCurrent())
{
return Standard_False;
}
Standard_Integer aFormat = -1;
Standard_Integer aSortType = Graphic3d_ST_BSP_Tree;
switch (theFormat)
{
case Graphic3d_EF_PostScript:
aFormat = GL2PS_PS;
break;
case Graphic3d_EF_EnhPostScript:
aFormat = GL2PS_EPS;
break;
case Graphic3d_EF_TEX:
aFormat = GL2PS_TEX;
break;
case Graphic3d_EF_PDF:
aFormat = GL2PS_PDF;
break;
case Graphic3d_EF_SVG:
aFormat = GL2PS_SVG;
break;
case Graphic3d_EF_PGF:
aFormat = GL2PS_PGF;
break;
case Graphic3d_EF_EMF:
//aFormat = GL2PS_EMF;
aFormat = GL2PS_PGF + 1; // 6
break;
default:
// unsupported format
return Standard_False;
}
switch (theSortType)
{
case Graphic3d_ST_Simple:
aSortType = GL2PS_SIMPLE_SORT;
break;
case Graphic3d_ST_BSP_Tree:
aSortType = GL2PS_BSP_SORT;
break;
}
GLint aViewport[4];
aViewport[0] = 0;
aViewport[1] = 0;
aViewport[2] = theWidth;
aViewport[3] = theHeight;
GLint aBufferSize = 1024 * 1024;
GLint anErrCode = GL2PS_SUCCESS;
// gl2ps uses standard write functions and do not check locale
Standard_CLocaleSentry aLocaleSentry;
while (aBufferSize > 0)
{
// current patch for EMF support in gl2ps uses WinAPI functions to create file
FILE* aFileH = (theFormat != Graphic3d_EF_EMF) ? fopen (theFileName, "wb") : NULL;
anErrCode = gl2psBeginPage ("", "", aViewport, aFormat, aSortType,
GL2PS_DRAW_BACKGROUND | GL2PS_OCCLUSION_CULL | GL2PS_BEST_ROOT/* | GL2PS_SIMPLE_LINE_OFFSET*/,
GL_RGBA, 0, NULL,
0, 0, 0, aBufferSize, aFileH, theFileName);
if (anErrCode != GL2PS_SUCCESS)
{
// initialization failed
if (aFileH != NULL)
fclose (aFileH);
break;
}
Redraw (theView);
anErrCode = gl2psEndPage();
if (aFileH != NULL)
fclose (aFileH);
if (anErrCode == GL2PS_OVERFLOW)
aBufferSize *= 2;
else
break;
}
return anErrCode == GL2PS_SUCCESS;
}
#else
Standard_Boolean OpenGl_GraphicDriver::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 Standard_Real /*thePrecision*/,
const Standard_Address /*theProgressBarFunc*/,
const Standard_Address /*theProgressObject*/)
{
return Standard_False;
}
#endif

1
src/OpenGl/OpenGl_Group.cxx
View File

@ -18,6 +18,7 @@
#include <OpenGl_GraphicDriver.hxx>
#include <OpenGl_Flipper.hxx>
#include <OpenGl_PrimitiveArray.hxx>
#include <OpenGl_SceneGeometry.hxx>
#include <OpenGl_StencilTest.hxx>
#include <OpenGl_Structure.hxx>
#include <OpenGl_Text.hxx>

6
src/OpenGl/OpenGl_Layer.cxx
View File

@ -135,7 +135,7 @@ void OpenGl_Layer::InvalidateBVHData()
void OpenGl_Layer::renderAll (const Handle(OpenGl_Workspace)& theWorkspace) const
{
const Standard_Integer aNbPriorities = myArray.Length();
const Standard_Integer aViewId = theWorkspace->ActiveViewId();
const Standard_Integer aViewId = theWorkspace->View()->Identification();
for (Standard_Integer aPriorityIter = 0; aPriorityIter < aNbPriorities; ++aPriorityIter)
{
const OpenGl_IndexedMapOfStructure& aStructures = myArray (aPriorityIter);
@ -189,11 +189,11 @@ void OpenGl_Layer::renderTraverse (const Handle(OpenGl_Workspace)& theWorkspace)
}
}
OpenGl_BVHTreeSelector& aSelector = theWorkspace->ActiveView()->BVHTreeSelector();
OpenGl_BVHTreeSelector& aSelector = theWorkspace->View()->BVHTreeSelector();
traverse (aSelector);
const Standard_Integer aNbPriorities = myArray.Length();
const Standard_Integer aViewId = theWorkspace->ActiveViewId();
const Standard_Integer aViewId = theWorkspace->View()->Identification();
for (Standard_Integer aPriorityIter = 0; aPriorityIter < aNbPriorities; ++aPriorityIter)
{
const OpenGl_IndexedMapOfStructure& aStructures = myArray (aPriorityIter);

13
src/OpenGl/OpenGl_LayerList.cxx
View File

@ -160,10 +160,9 @@ void OpenGl_LayerList::AddStructure (const OpenGl_Structure* theStruct,
//purpose :
//=======================================================================
void OpenGl_LayerList::RemoveStructure (const Handle(Graphic3d_Structure)& theStructure)
void OpenGl_LayerList::RemoveStructure (const OpenGl_Structure* theStructure)
{
const OpenGl_Structure* aStruct = reinterpret_cast<const OpenGl_Structure* > (theStructure->CStructure().operator->());
const Graphic3d_ZLayerId aLayerId = aStruct->ZLayer();
const Graphic3d_ZLayerId aLayerId = theStructure->ZLayer();
Standard_Integer aSeqPos = myLayers.Lower();
myLayerIds.Find (aLayerId, aSeqPos);
@ -174,7 +173,7 @@ void OpenGl_LayerList::RemoveStructure (const Handle(Graphic3d_Structure)& theSt
// remove structure from associated list
// if the structure is not found there,
// scan through layers and remove it
if (aLayer.Remove (aStruct, aPriority))
if (aLayer.Remove (theStructure, aPriority))
{
--myNbStructures;
if (aLayer.LayerSettings().IsImmediate)
@ -182,7 +181,7 @@ void OpenGl_LayerList::RemoveStructure (const Handle(Graphic3d_Structure)& theSt
--myImmediateNbStructures;
}
if (aStruct->IsRaytracable())
if (theStructure->IsRaytracable())
{
++myModificationState;
}
@ -200,7 +199,7 @@ void OpenGl_LayerList::RemoveStructure (const Handle(Graphic3d_Structure)& theSt
continue;
}
if (aLayerEx.Remove (aStruct, aPriority))
if (aLayerEx.Remove (theStructure, aPriority))
{
--myNbStructures;
if (aLayerEx.LayerSettings().IsImmediate)
@ -208,7 +207,7 @@ void OpenGl_LayerList::RemoveStructure (const Handle(Graphic3d_Structure)& theSt
--myImmediateNbStructures;
}
if (aStruct->IsRaytracable())
if (theStructure->IsRaytracable())
{
++myModificationState;
}

2
src/OpenGl/OpenGl_LayerList.hxx
View File

@ -63,7 +63,7 @@ public:
Standard_Boolean isForChangePriority = Standard_False);
//! Remove structure from structure list and return its previous priority
void RemoveStructure (const Handle(Graphic3d_Structure)& theStructure);
void RemoveStructure (const OpenGl_Structure* theStructure);
//! Change structure z layer
//! If the new layer is not presented, the structure will be displayed

21
src/OpenGl/OpenGl_Light.hxx
View File

@ -17,12 +17,27 @@
#define OpenGl_Light_Header
#include <Graphic3d_CLight.hxx>
#include <Visual3d_TypeOfLightSource.hxx>
#include <NCollection_List.hxx>
#define OpenGLMaxLights 8
typedef Graphic3d_CLight OpenGl_Light;
typedef NCollection_List<OpenGl_Light> OpenGl_ListOfLight;
typedef Graphic3d_CLight OpenGl_Light;
typedef Graphic3d_ListOfCLight OpenGl_ListOfLight;
static inline OpenGl_ListOfLight& OpenGl_NoShadingLight()
{
static OpenGl_ListOfLight aLights;
if (aLights.IsEmpty())
{
OpenGl_Light aLight;
aLight.Type = Graphic3d_TOLS_AMBIENT;
aLight.IsHeadlight = Standard_False;
aLight.Color.r() = 1.;
aLight.Color.g() = 1.;
aLight.Color.b() = 1.;
aLights.Append (aLight);
}
return aLights;
}
#endif // OpenGl_Light_Header

8
src/Visual3d/Visual3d_MapOfZLayerSettings.hxx → src/OpenGl/OpenGl_MapOfZLayerSettings.hxx
View File

@ -11,14 +11,14 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Visual3d_MapOfZLayerSettings_HeaderFile
#define _Visual3d_MapOfZLayerSettings_HeaderFile
#ifndef _OpenGl_MapOfZLayerSettings_HeaderFile
#define _OpenGl_MapOfZLayerSettings_HeaderFile
#include <Standard_TypeDef.hxx>
#include <NCollection_Map.hxx>
#include <Graphic3d_ZLayerId.hxx>
#include <Graphic3d_ZLayerSettings.hxx>
typedef NCollection_DataMap<Graphic3d_ZLayerId, Graphic3d_ZLayerSettings> Visual3d_MapOfZLayerSettings;
typedef NCollection_DataMap<Graphic3d_ZLayerId, Graphic3d_ZLayerSettings> OpenGl_MapOfZLayerSettings;
#endif // _Visual3d_MapOfZLayerSettings_HeaderFile
#endif // _OpenGl_MapOfZLayerSettings_HeaderFile

40
src/OpenGl/OpenGl_ShaderManager.cxx
View File

@ -206,7 +206,7 @@ const char THE_FRAG_CLIP_PLANES[] =
// purpose : Creates new empty shader manager
// =======================================================================
OpenGl_ShaderManager::OpenGl_ShaderManager (OpenGl_Context* theContext)
: myShadingModel (Visual3d_TOM_VERTEX),
: myShadingModel (Graphic3d_TOSM_VERTEX),
myContext (theContext),
myLastView (NULL)
{
@ -340,7 +340,7 @@ Standard_Boolean OpenGl_ShaderManager::IsEmpty() const
// =======================================================================
void OpenGl_ShaderManager::switchLightPrograms()
{
TCollection_AsciiString aKey (myShadingModel == Visual3d_TOM_FRAGMENT ? "p_" : "g_");
TCollection_AsciiString aKey (myShadingModel == Graphic3d_TOSM_FRAGMENT ? "p_" : "g_");
const OpenGl_ListOfLight* aLights = myLightSourceState.LightSources();
if (aLights != NULL)
{
@ -348,15 +348,15 @@ void OpenGl_ShaderManager::switchLightPrograms()
{
switch (aLightIter.Value().Type)
{
case Visual3d_TOLS_AMBIENT:
case Graphic3d_TOLS_AMBIENT:
break; // skip ambient
case Visual3d_TOLS_DIRECTIONAL:
case Graphic3d_TOLS_DIRECTIONAL:
aKey += "d";
break;
case Visual3d_TOLS_POSITIONAL:
case Graphic3d_TOLS_POSITIONAL:
aKey += "p";
break;
case Visual3d_TOLS_SPOT:
case Graphic3d_TOLS_SPOT:
aKey += "s";
break;
}
@ -385,7 +385,7 @@ void OpenGl_ShaderManager::UpdateLightSourceStateTo (const OpenGl_ListOfLight* t
// function : SetShadingModel
// purpose :
// =======================================================================
void OpenGl_ShaderManager::SetShadingModel (const Visual3d_TypeOfModel theModel)
void OpenGl_ShaderManager::SetShadingModel (const Graphic3d_TypeOfShadingModel theModel)
{
myShadingModel = theModel;
switchLightPrograms();
@ -530,7 +530,7 @@ void OpenGl_ShaderManager::PushLightSourceState (const Handle(OpenGl_ShaderProgr
for (OpenGl_ListOfLight::Iterator anIter (*myLightSourceState.LightSources()); anIter.More(); anIter.Next())
{
const OpenGl_Light& aLight = anIter.Value();
if (aLight.Type == Visual3d_TOLS_AMBIENT)
if (aLight.Type == Graphic3d_TOLS_AMBIENT)
{
anAmbient += aLight.Color;
continue;
@ -546,10 +546,10 @@ void OpenGl_ShaderManager::PushLightSourceState (const Handle(OpenGl_ShaderProgr
OpenGl_ShaderLightParameters& aLightParams = aLightParamsArray[aLightsNb];
aLightParams.Color = aLight.Color;
aLightParams.Position = aLight.Type == Visual3d_TOLS_DIRECTIONAL
aLightParams.Position = aLight.Type == Graphic3d_TOLS_DIRECTIONAL
? -aLight.Direction
: aLight.Position;
if (aLight.Type == Visual3d_TOLS_SPOT)
if (aLight.Type == Graphic3d_TOLS_SPOT)
{
aLightParams.Direction = aLight.Direction;
}
@ -826,7 +826,7 @@ const OpenGl_SurfaceDetailState& OpenGl_ShaderManager::SurfaceDetailState() cons
// function : UpdateSurfaceDetailStateTo
// purpose : Updates state of OCCT surface detail
// =======================================================================
void OpenGl_ShaderManager::UpdateSurfaceDetailStateTo (const Visual3d_TypeOfSurfaceDetail theDetail)
void OpenGl_ShaderManager::UpdateSurfaceDetailStateTo (const Graphic3d_TypeOfSurfaceDetail theDetail)
{
mySurfaceDetailState.Set (theDetail);
mySurfaceDetailState.Update();
@ -1327,7 +1327,7 @@ Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFlat (Handle(OpenGl_Shad
// =======================================================================
TCollection_AsciiString OpenGl_ShaderManager::stdComputeLighting (const Standard_Boolean theHasVertColor)
{
bool aLightsMap[Visual3d_TOLS_SPOT + 1] = { false, false, false, false };
bool aLightsMap[Graphic3d_TOLS_SPOT + 1] = { false, false, false, false };
TCollection_AsciiString aLightsFunc, aLightsLoop;
const OpenGl_ListOfLight* aLights = myLightSourceState.LightSources();
if (aLights != NULL)
@ -1337,16 +1337,16 @@ TCollection_AsciiString OpenGl_ShaderManager::stdComputeLighting (const Standard
{
switch (aLightIter.Value().Type)
{
case Visual3d_TOLS_AMBIENT:
case Graphic3d_TOLS_AMBIENT:
--anIndex;
break; // skip ambient
case Visual3d_TOLS_DIRECTIONAL:
case Graphic3d_TOLS_DIRECTIONAL:
aLightsLoop = aLightsLoop + EOL" directionalLight (" + anIndex + ", theNormal, theView, theIsFront);";
break;
case Visual3d_TOLS_POSITIONAL:
case Graphic3d_TOLS_POSITIONAL:
aLightsLoop = aLightsLoop + EOL" pointLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
break;
case Visual3d_TOLS_SPOT:
case Graphic3d_TOLS_SPOT:
aLightsLoop = aLightsLoop + EOL" spotLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
break;
}
@ -1360,10 +1360,10 @@ TCollection_AsciiString OpenGl_ShaderManager::stdComputeLighting (const Standard
aTypeBit = true;
switch (aLightIter.Value().Type)
{
case Visual3d_TOLS_AMBIENT: break;
case Visual3d_TOLS_DIRECTIONAL: aLightsFunc += THE_FUNC_directionalLight; break;
case Visual3d_TOLS_POSITIONAL: aLightsFunc += THE_FUNC_pointLight; break;
case Visual3d_TOLS_SPOT: aLightsFunc += THE_FUNC_spotLight; break;
case Graphic3d_TOLS_AMBIENT: break;
case Graphic3d_TOLS_DIRECTIONAL: aLightsFunc += THE_FUNC_directionalLight; break;
case Graphic3d_TOLS_POSITIONAL: aLightsFunc += THE_FUNC_pointLight; break;
case Graphic3d_TOLS_SPOT: aLightsFunc += THE_FUNC_spotLight; break;
}
}
}

20
src/OpenGl/OpenGl_ShaderManager.hxx
View File

@ -18,6 +18,8 @@
#include <Graphic3d_ShaderProgram.hxx>
#include <Graphic3d_StereoMode.hxx>
#include <Graphic3d_TypeOfShadingModel.hxx>
#include <Graphic3d_TypeOfSurfaceDetail.hxx>
#include <NCollection_DataMap.hxx>
#include <NCollection_Sequence.hxx>
@ -29,7 +31,7 @@
#include <OpenGl_AspectText.hxx>
#include <OpenGl_AspectMarker.hxx>
#include <OpenGl_Texture.hxx>
#include <Visual3d_TypeOfModel.hxx>
class OpenGl_View;
@ -257,7 +259,7 @@ public:
Standard_EXPORT const OpenGl_SurfaceDetailState& SurfaceDetailState() const;
//! Updates state of OCCT surface detail.
Standard_EXPORT void UpdateSurfaceDetailStateTo (const Visual3d_TypeOfSurfaceDetail theDetail);
Standard_EXPORT void UpdateSurfaceDetailStateTo (const Graphic3d_TypeOfSurfaceDetail theDetail);
public:
@ -272,8 +274,14 @@ public:
myContext = theCtx;
}
//! Returns true when provided context is the same as used one by shader manager.
bool IsSameContext (OpenGl_Context* theCtx) const
{
return myContext == theCtx;
}
//! Sets shading model.
Standard_EXPORT void SetShadingModel(const Visual3d_TypeOfModel theModel);
Standard_EXPORT void SetShadingModel (const Graphic3d_TypeOfShadingModel theModel);
//! Sets last view manger used with.
//! Helps to handle matrix states in multi-view configurations.
@ -301,7 +309,7 @@ protected:
{
aBits |= OpenGl_PO_ClipPlanes;
}
if (theEnableEnvMap && mySurfaceDetailState.Detail() == Visual3d_TOD_ENVIRONMENT)
if (theEnableEnvMap && mySurfaceDetailState.Detail() == Graphic3d_TOD_ENVIRONMENT)
{
// Environment map overwrites material texture
aBits |= OpenGl_PO_TextureEnv;
@ -355,7 +363,7 @@ protected:
Standard_Boolean prepareStdProgramLight (Handle(OpenGl_ShaderProgram)& theProgram,
const Standard_Integer theBits)
{
return myShadingModel == Visual3d_TOM_FRAGMENT
return myShadingModel == Graphic3d_TOSM_FRAGMENT
? prepareStdProgramPhong (theProgram, theBits)
: prepareStdProgramGouraud (theProgram, theBits);
}
@ -385,7 +393,7 @@ protected:
protected:
Visual3d_TypeOfModel myShadingModel; //!< lighting shading model
Graphic3d_TypeOfShadingModel myShadingModel; //!< lighting shading model
OpenGl_ShaderProgramList myProgramList; //!< The list of shader programs
Handle(OpenGl_SetOfShaderPrograms) myLightPrograms; //!< pointer to active lighting programs matrix
OpenGl_SetOfShaderPrograms myFlatPrograms; //!< programs matrix without lighting

10
src/OpenGl/OpenGl_ShaderStates.hxx
View File

@ -16,12 +16,12 @@
#ifndef _OpenGl_State_HeaderFile
#define _OpenGl_State_HeaderFile
#include <Graphic3d_TypeOfSurfaceDetail.hxx>
#include <InterfaceGraphic_tgl_all.hxx>
#include <NCollection_List.hxx>
#include <OpenGl_Element.hxx>
#include <OpenGl_Light.hxx>
#include <OpenGl_Vec.hxx>
#include <Visual3d_TypeOfSurfaceDetail.hxx>
//! Defines interface for OpenGL state.
class OpenGl_StateInterface
@ -189,21 +189,21 @@ class OpenGl_SurfaceDetailState : public OpenGl_StateInterface
public:
//! Creates new surface detail state.
OpenGl_SurfaceDetailState (const Visual3d_TypeOfSurfaceDetail theDetail = Visual3d_TOD_NONE)
OpenGl_SurfaceDetailState (const Graphic3d_TypeOfSurfaceDetail theDetail = Graphic3d_TOD_NONE)
: myDetail (theDetail)
{
//
}
//! Sets new surface detail.
void Set (const Visual3d_TypeOfSurfaceDetail theDetail) { myDetail = theDetail; }
void Set (const Graphic3d_TypeOfSurfaceDetail theDetail) { myDetail = theDetail; }
//! Returns surface detail.
const Visual3d_TypeOfSurfaceDetail Detail() const { return myDetail; }
const Graphic3d_TypeOfSurfaceDetail Detail() const { return myDetail; }
private:
Visual3d_TypeOfSurfaceDetail myDetail; //!< OCCT surface detail
Graphic3d_TypeOfSurfaceDetail myDetail; //!< OCCT surface detail
};

2
src/OpenGl/OpenGl_Text.cxx
View File

@ -416,7 +416,7 @@ void OpenGl_Text::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
aTextAspect, aTextAspect->ShaderProgramRes (aCtx));
}
myOrientationMatrix = theWorkspace->ActiveView()->Camera()->OrientationMatrix();
myOrientationMatrix = theWorkspace->View()->Camera()->OrientationMatrix();
myProjMatrix.Convert (aCtx->ProjectionState.Current());
// use highlight color or colors from aspect

2
src/OpenGl/OpenGl_Trihedron.cxx
View File

@ -40,7 +40,7 @@ namespace
void OpenGl_Trihedron::resetTransformations (const Handle(OpenGl_Workspace)& theWorkspace) const
{
const Handle(OpenGl_Context)& aContext = theWorkspace->GetGlContext();
const Handle(OpenGl_View)& aView = theWorkspace->ActiveView();
const OpenGl_View* aView = theWorkspace->View();
GLdouble anU = 1.0;
GLdouble aV = 1.0;
if (aView->Height() < aView->Width())

2
src/OpenGl/OpenGl_Trihedron.hxx
View File

@ -74,7 +74,7 @@ public:
protected:
//! Invalidate Primitve Arrays.
//! Invalidate Primitive Arrays.
void invalidate();
void redraw(const Handle(OpenGl_Workspace)& theWorkspace) const;

743
src/OpenGl/OpenGl_View.cxx
View File

@ -13,67 +13,109 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <NCollection_Mat4.hxx>
#include <OpenGl_View.hxx>
#include <Aspect_GraphicCallbackProc.hxx>
#include <Aspect_RenderingContext.hxx>
#include <Aspect_Window.hxx>
#include <Graphic3d_AspectFillArea3d.hxx>
#include <Graphic3d_Texture2Dmanual.hxx>
#include <Graphic3d_TextureEnv.hxx>
#include <Graphic3d_Mat4d.hxx>
#include <NCollection_Mat4.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_FrameBuffer.hxx>
#include <OpenGl_GlCore11.hxx>
#include <OpenGl_GraduatedTrihedron.hxx>
#include <OpenGl_GraphicDriver.hxx>
#include <OpenGl_ShaderManager.hxx>
#include <OpenGl_Texture.hxx>
#include <OpenGl_Trihedron.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Window.hxx>
#include <OpenGl_Workspace.hxx>
#include <Standard_CLocaleSentry.hxx>
#include <Graphic3d_TextureEnv.hxx>
#include <Graphic3d_Mat4d.hxx>
#ifdef HAVE_GL2PS
#include <gl2ps.h>
#endif
/*----------------------------------------------------------------------*/
namespace
{
static const OPENGL_ZCLIP myDefaultZClip = { { Standard_True, 0.F }, { Standard_True, 1.F } };
static const OPENGL_FOG myDefaultFog = { Standard_False, 0.F, 1.F, { { 0.F, 0.F, 0.F, 1.F } } };
static const OPENGL_ZCLIP myDefaultZClip = { { Standard_False, 0.F }, { Standard_False, 1.F } };
static const OPENGL_FOG myDefaultFog = { Standard_False, 0.F, 1.F, { { 0.F, 0.F, 0.F, 1.F } } };
static const TEL_COLOUR myDefaultBg = { { 0.F, 0.F, 0.F, 1.F } };
}
/*----------------------------------------------------------------------*/
OpenGl_View::OpenGl_View (const CALL_DEF_VIEWCONTEXT &AContext,
OpenGl_StateCounter* theCounter)
: mySurfaceDetail(Visual3d_TOD_ALL),
myBackfacing(0),
//shield_indicator = TOn,
//shield_colour = { { 0.F, 0.F, 0.F, 1.F } },
//border_indicator = TOff,
//border_colour = { { 0.F, 0.F, 0.F, 1.F } },
//active_status = TOn,
myZClip(myDefaultZClip),
myCamera(AContext.Camera),
myFog(myDefaultFog),
myToShowTrihedron (false),
myToShowGradTrihedron (false),
myVisualization(AContext.Visualization),
myShadingModel ((Visual3d_TypeOfModel )AContext.Model),
myAntiAliasing(Standard_False),
myWorldViewProjState(),
myStateCounter (theCounter),
// =======================================================================
// function : Constructor
// purpose :
// =======================================================================
OpenGl_View::OpenGl_View (const Handle(Graphic3d_StructureManager)& theMgr,
const Handle(OpenGl_GraphicDriver)& theDriver,
const Handle(OpenGl_Caps)& theCaps,
Standard_Boolean& theDeviceLostFlag,
OpenGl_StateCounter* theCounter)
: Graphic3d_CView (theMgr),
myDriver (theDriver.operator->()),
myCaps (theCaps),
myDeviceLostFlag (theDeviceLostFlag),
myWasRedrawnGL (Standard_False),
myAntiAliasing (Standard_False),
myCulling (Standard_True),
myShadingModel (Graphic3d_TOSM_FACET),
mySurfaceDetail (Graphic3d_TOD_ALL),
myBackfacing (Graphic3d_TOBM_AUTOMATIC),
myBgColor (myDefaultBg),
myFog (myDefaultFog),
myZClip (myDefaultZClip),
myCamera (new Graphic3d_Camera()),
myFBO (NULL),
myUseGLLight (Standard_True),
myToShowTrihedron (false),
myToShowGradTrihedron (false),
myStateCounter (theCounter),
myLastLightSourceState (0, 0),
myFrameCounter (0),
myHasFboBlit (Standard_True),
myTransientDrawToFront (Standard_True),
myBackBufferRestored (Standard_False),
myIsImmediateDrawn (Standard_False),
myTextureParams (new OpenGl_AspectFace()),
myBgGradientArray (new OpenGl_BackgroundArray (Graphic3d_TOB_GRADIENT)),
myBgTextureArray (new OpenGl_BackgroundArray (Graphic3d_TOB_TEXTURE)),
// ray-tracing fields initialization
myRaytraceInitStatus (OpenGl_RT_NONE),
myIsRaytraceDataValid (Standard_False),
myRaytraceInitStatus (OpenGl_RT_NONE),
myIsRaytraceDataValid (Standard_False),
myIsRaytraceWarnTextures (Standard_False),
myToUpdateEnvironmentMap (Standard_False),
myLayerListState (0)
{
myCurrLightSourceState = myStateCounter->Increment();
myWorkspace = new OpenGl_Workspace (this, NULL);
// AA mode
const char* anAaEnv = ::getenv ("CALL_OPENGL_ANTIALIASING_MODE");
if (anAaEnv != NULL)
{
int v;
if (sscanf (anAaEnv, "%d", &v) > 0) myAntiAliasing = v;
}
myCurrLightSourceState = myStateCounter->Increment();
myMainSceneFbos[0] = new OpenGl_FrameBuffer();
myMainSceneFbos[1] = new OpenGl_FrameBuffer();
myImmediateSceneFbos[0] = new OpenGl_FrameBuffer();
myImmediateSceneFbos[1] = new OpenGl_FrameBuffer();
myDisplayCallback.Func = NULL;
myDisplayCallback.Data = NULL;
}
/*----------------------------------------------------------------------*/
// =======================================================================
// function : Destructor
// purpose :
// =======================================================================
OpenGl_View::~OpenGl_View()
{
ReleaseGlResources (NULL); // ensure ReleaseGlResources() was called within valid context
@ -82,6 +124,10 @@ OpenGl_View::~OpenGl_View()
OpenGl_Element::Destroy (NULL, myTextureParams);
}
// =======================================================================
// function : ReleaseGlResources
// purpose :
// =======================================================================
void OpenGl_View::ReleaseGlResources (const Handle(OpenGl_Context)& theCtx)
{
myTrihedron .Release (theCtx.operator->());
@ -106,107 +152,126 @@ void OpenGl_View::ReleaseGlResources (const Handle(OpenGl_Context)& theCtx)
myBgTextureArray->Release (theCtx.operator->());
}
myMainSceneFbos[0] ->Release (theCtx.operator->());
myMainSceneFbos[1] ->Release (theCtx.operator->());
myImmediateSceneFbos[0]->Release (theCtx.operator->());
myImmediateSceneFbos[1]->Release (theCtx.operator->());
myFullScreenQuad .Release (theCtx.operator->());
myFullScreenQuadFlip .Release (theCtx.operator->());
releaseRaytraceResources (theCtx);
}
void OpenGl_View::SetTextureEnv (const Handle(OpenGl_Context)& theCtx,
const Handle(Graphic3d_TextureEnv)& theTexture)
// =======================================================================
// function : Remove
// purpose :
// =======================================================================
void OpenGl_View::Remove()
{
if (!myTextureEnv.IsNull())
{
theCtx->DelayedRelease (myTextureEnv);
myTextureEnv.Nullify();
}
if (theTexture.IsNull())
if (IsRemoved())
{
return;
}
myTextureEnv = new OpenGl_Texture (theTexture->GetParams());
Handle(Image_PixMap) anImage = theTexture->GetImage();
myDriver->RemoveView (this);
myWindow.Nullify();
Graphic3d_CView::Remove();
}
// =======================================================================
// function : SetTextureEnv
// purpose :
// =======================================================================
void OpenGl_View::SetTextureEnv (const Handle(Graphic3d_TextureEnv)& theTextureEnv)
{
Handle(OpenGl_Context) aCtx = myWorkspace->GetGlContext();
if (!aCtx.IsNull() && !myTextureEnv.IsNull())
{
aCtx->DelayedRelease (myTextureEnv);
}
myToUpdateEnvironmentMap = Standard_True;
myTextureEnvData = theTextureEnv;
myTextureEnv.Nullify();
initTextureEnv (aCtx);
}
// =======================================================================
// function : initTextureEnv
// purpose :
// =======================================================================
void OpenGl_View::initTextureEnv (const Handle(OpenGl_Context)& theContext)
{
if (myTextureEnvData.IsNull()
|| theContext.IsNull()
|| !theContext->MakeCurrent())
{
return;
}
myTextureEnv = new OpenGl_Texture (myTextureEnvData->GetParams());
Handle(Image_PixMap) anImage = myTextureEnvData->GetImage();
if (!anImage.IsNull())
myTextureEnv->Init (theCtx, *anImage.operator->(), theTexture->Type());
myToUpdateEnvironmentMap = Standard_True;
}
void OpenGl_View::SetSurfaceDetail (const Visual3d_TypeOfSurfaceDetail theMode)
{
mySurfaceDetail = theMode;
myToUpdateEnvironmentMap = Standard_True;
{
myTextureEnv->Init (theContext, *anImage.operator->(), myTextureEnvData->Type());
}
}
// =======================================================================
// function : SetBackfacing
// function : SetImmediateModeDrawToFront
// purpose :
// =======================================================================
void OpenGl_View::SetBackfacing (const Standard_Integer theMode)
Standard_Boolean OpenGl_View::SetImmediateModeDrawToFront (const Standard_Boolean theDrawToFrontBuffer)
{
myBackfacing = theMode;
const Standard_Boolean aPrevMode = myTransientDrawToFront;
myTransientDrawToFront = theDrawToFrontBuffer;
return aPrevMode;
}
// =======================================================================
// function : SetLights
// function : SetWindow
// purpose :
// =======================================================================
void OpenGl_View::SetLights (const CALL_DEF_VIEWCONTEXT& theViewCtx)
void OpenGl_View::SetWindow (const Handle(Aspect_Window)& theWindow,
const Aspect_RenderingContext theContext,
const Aspect_GraphicCallbackProc& theDisplayCB,
const Standard_Address theClientData)
{
myLights.Clear();
for (Standard_Integer aLightIt = 0; aLightIt < theViewCtx.NbActiveLight; ++aLightIt)
{
myLights.Append (theViewCtx.ActiveLight[aLightIt]);
}
myCurrLightSourceState = myStateCounter->Increment();
myWindow = myDriver->CreateRenderWindow (theWindow, theContext);
Standard_ASSERT_RAISE (!myWindow.IsNull(),
"OpenGl_View::SetWindow, "
"Failed to create OpenGl window.");
myDisplayCallback.Func = theDisplayCB;
myDisplayCallback.Data = theClientData;
myWorkspace = new OpenGl_Workspace (this, myWindow);
myWorldViewProjState.Reset();
myToUpdateEnvironmentMap = Standard_True;
myHasFboBlit = Standard_True;
Invalidate();
// Environment texture resource does not support lazy initialization.
initTextureEnv (myWorkspace->GetGlContext());
}
/*----------------------------------------------------------------------*/
//call_togl_setvisualisation
void OpenGl_View::SetVisualisation (const CALL_DEF_VIEWCONTEXT &AContext)
// =======================================================================
// function : Resized
// purpose :
// =======================================================================
void OpenGl_View::Resized()
{
myVisualization = AContext.Visualization;
myShadingModel = (Visual3d_TypeOfModel )AContext.Model;
if (myWindow.IsNull())
return;
myWindow->Resize();
}
/*----------------------------------------------------------------------*/
//call_togl_cliplimit
void OpenGl_View::SetClipLimit (const Graphic3d_CView& theCView)
{
myZClip.Back.Limit = theCView.Context.ZClipBackPlane;
myZClip.Front.Limit = theCView.Context.ZClipFrontPlane;
myZClip.Back.IsOn = (theCView.Context.BackZClipping != 0);
myZClip.Front.IsOn = (theCView.Context.FrontZClipping != 0);
}
/*----------------------------------------------------------------------*/
void OpenGl_View::SetFog (const Graphic3d_CView& theCView,
const Standard_Boolean theFlag)
{
if (!theFlag)
{
myFog.IsOn = Standard_False;
}
else
{
myFog.IsOn = Standard_True;
myFog.Front = theCView.Context.DepthFrontPlane;
myFog.Back = theCView.Context.DepthBackPlane;
myFog.Color.rgb[0] = theCView.DefWindow.Background.r;
myFog.Color.rgb[1] = theCView.DefWindow.Background.g;
myFog.Color.rgb[2] = theCView.DefWindow.Background.b;
myFog.Color.rgb[3] = 1.0f;
}
}
/*----------------------------------------------------------------------*/
// =======================================================================
// function : TriedronDisplay
// purpose :
// =======================================================================
void OpenGl_View::TriedronDisplay (const Aspect_TypeOfTriedronPosition thePosition,
const Quantity_NameOfColor theColor,
const Standard_Real theScale,
@ -219,27 +284,463 @@ void OpenGl_View::TriedronDisplay (const Aspect_TypeOfTriedronPosition thePositi
myTrihedron.SetLabelsColor (theColor);
}
/*----------------------------------------------------------------------*/
void OpenGl_View::TriedronErase (const Handle(OpenGl_Context)& theCtx)
// =======================================================================
// function : TriedronErase
// purpose :
// =======================================================================
void OpenGl_View::TriedronErase()
{
myToShowTrihedron = false;
myTrihedron.Release (theCtx.operator->());
myTrihedron.Release (myWorkspace->GetGlContext().operator->());
}
/*----------------------------------------------------------------------*/
void OpenGl_View::GraduatedTrihedronDisplay (const Handle(OpenGl_Context)& theCtx,
const Graphic3d_GraduatedTrihedron& theData)
// =======================================================================
// function : ZBufferTriedronSetup
// purpose :
// =======================================================================
void OpenGl_View::ZBufferTriedronSetup (const Quantity_NameOfColor theXColor,
const Quantity_NameOfColor theYColor,
const Quantity_NameOfColor theZColor,
const Standard_Real theSizeRatio,
const Standard_Real theAxisDiametr,
const Standard_Integer theNbFacettes)
{
myTrihedron.SetArrowsColors (theXColor, theYColor, theZColor);
myTrihedron.SetSizeRatio (theSizeRatio);
myTrihedron.SetNbFacets (theNbFacettes);
myTrihedron.SetArrowDiameter (theAxisDiametr);
}
// =======================================================================
// function : TriedronEcho
// purpose :
// =======================================================================
void OpenGl_View::TriedronEcho (const Aspect_TypeOfTriedronEcho /*theType*/)
{
// do nothing
}
// =======================================================================
// function : SetMinMaxValuesCallback
// purpose :
// =======================================================================
static void SetMinMaxValuesCallback (Graphic3d_CView* theView)
{
OpenGl_View* aView = dynamic_cast<OpenGl_View*>(theView);
if (aView == NULL)
return;
Bnd_Box aBox = theView->MinMaxValues();
if (!aBox.IsVoid())
{
gp_Pnt aMin = aBox.CornerMin();
gp_Pnt aMax = aBox.CornerMax();
Graphic3d_Vec3 aMinVec ((Standard_ShortReal )aMin.X(), (Standard_ShortReal )aMin.Y(), (Standard_ShortReal )aMin.Z());
Graphic3d_Vec3 aMaxVec ((Standard_ShortReal )aMax.X(), (Standard_ShortReal )aMax.Y(), (Standard_ShortReal )aMax.Z());
aView->GraduatedTrihedronMinMaxValues (aMinVec, aMaxVec);
}
}
// =======================================================================
// function : GraduatedTrihedronDisplay
// purpose :
// =======================================================================
void OpenGl_View::GraduatedTrihedronDisplay (const Graphic3d_GraduatedTrihedron& theTrihedronData)
{
myGTrihedronData = theTrihedronData;
myGTrihedronData.PtrView = this;
myGTrihedronData.CubicAxesCallback = SetMinMaxValuesCallback;
myGraduatedTrihedron.SetValues (myGTrihedronData);
myToShowGradTrihedron = true;
myGraduatedTrihedron.SetValues (theCtx, theData);
}
/*----------------------------------------------------------------------*/
void OpenGl_View::GraduatedTrihedronErase (const Handle(OpenGl_Context)& theCtx)
// =======================================================================
// function : GraduatedTrihedronErase
// purpose :
// =======================================================================
void OpenGl_View::GraduatedTrihedronErase()
{
myGTrihedronData.PtrView = NULL;
myGraduatedTrihedron.Release (myWorkspace->GetGlContext().operator->());
myToShowGradTrihedron = false;
myGraduatedTrihedron.Release (theCtx.operator->());
}
// =======================================================================
// function : GraduatedTrihedronMinMaxValues
// purpose :
// =======================================================================
void OpenGl_View::GraduatedTrihedronMinMaxValues (const Graphic3d_Vec3 theMin, const Graphic3d_Vec3 theMax)
{
myGraduatedTrihedron.SetMinMax (theMin, theMax);
}
// =======================================================================
// function : ReadDepths
// purpose :
// =======================================================================
void OpenGl_View::ReadDepths (const Standard_Integer theX,
const Standard_Integer theY,
const Standard_Integer theWidth,
const Standard_Integer theHeight,
const Standard_Address theBuffer) const
{
if (myWindow.IsNull())
return;
myWindow->ReadDepths (theX, theY, theWidth, theHeight, (float*)theBuffer);
}
// =======================================================================
// function : BufferDump
// purpose :
// =======================================================================
Standard_Boolean OpenGl_View::BufferDump (Image_PixMap& theImage, const Graphic3d_BufferType& theBufferType)
{
return myWorkspace->BufferDump (myFBO, theImage, theBufferType);
}
// =======================================================================
// function : Background
// purpose :
// =======================================================================
Aspect_Background OpenGl_View::Background() const
{
return Aspect_Background (Quantity_Color (myBgColor.rgb[0], myBgColor.rgb[1], myBgColor.rgb[2], Quantity_TOC_RGB));
}
// =======================================================================
// function : SetBackground
// purpose :
// =======================================================================
void OpenGl_View::SetBackground (const Aspect_Background& theBackground)
{
Quantity_Color aBgColor = theBackground.Color();
myBgColor.rgb[0] = static_cast<float> (aBgColor.Red());
myBgColor.rgb[1] = static_cast<float> (aBgColor.Green());
myBgColor.rgb[2] = static_cast<float> (aBgColor.Blue());
myFog.Color = myBgColor;
}
// =======================================================================
// function : GradientBackground
// purpose :
// =======================================================================
Aspect_GradientBackground OpenGl_View::GradientBackground() const
{
Quantity_Color aColor1, aColor2;
aColor1.SetValues (myBgGradientArray->GradientColor (0).r(),
myBgGradientArray->GradientColor (0).g(),
myBgGradientArray->GradientColor (0).b(), Quantity_TOC_RGB);
aColor2.SetValues (myBgGradientArray->GradientColor (1).r(),
myBgGradientArray->GradientColor (1).g(),
myBgGradientArray->GradientColor (1).b(), Quantity_TOC_RGB);
return Aspect_GradientBackground (aColor1, aColor2, myBgGradientArray->GradientFillMethod());
}
// =======================================================================
// function : SetGradientBackground
// purpose :
// =======================================================================
void OpenGl_View::SetGradientBackground (const Aspect_GradientBackground& theBackground)
{
Quantity_Color aColor1, aColor2;
theBackground.Colors (aColor1, aColor2);
myBgGradientArray->SetGradientParameters (aColor1, aColor2, theBackground.BgGradientFillMethod());
}
// =======================================================================
// function : SetBackgroundImage
// purpose :
// =======================================================================
void OpenGl_View::SetBackgroundImage (const TCollection_AsciiString& theFilePath)
{
// Prepare aspect for texture storage
myBackgroundImagePath = theFilePath;
Handle(Graphic3d_AspectFillArea3d) anAspect = new Graphic3d_AspectFillArea3d();
Handle(Graphic3d_Texture2Dmanual) aTextureMap = new Graphic3d_Texture2Dmanual (TCollection_AsciiString (theFilePath));
aTextureMap->EnableRepeat();
aTextureMap->DisableModulate();
aTextureMap->GetParams()->SetGenMode (Graphic3d_TOTM_MANUAL,
Graphic3d_Vec4 (0.0f, 0.0f, 0.0f, 0.0f),
Graphic3d_Vec4 (0.0f, 0.0f, 0.0f, 0.0f));
anAspect->SetTextureMap (aTextureMap);
anAspect->SetInteriorStyle (Aspect_IS_SOLID);
// Enable texture mapping
if (aTextureMap->IsDone())
{
anAspect->SetTextureMapOn();
}
else
{
anAspect->SetTextureMapOff();
return;
}
// Set texture parameters
myTextureParams->SetAspect (anAspect);
}
// =======================================================================
// function : BackgroundImageStyle
// purpose :
// =======================================================================
Aspect_FillMethod OpenGl_View::BackgroundImageStyle() const
{
return myBgTextureArray->TextureFillMethod();
}
// =======================================================================
// function : SetBackgroundImageStyle
// purpose :
// =======================================================================
void OpenGl_View::SetBackgroundImageStyle (const Aspect_FillMethod theFillStyle)
{
myBgTextureArray->SetTextureFillMethod (theFillStyle);
}
//=======================================================================
//function : AddZLayer
//purpose :
//=======================================================================
void OpenGl_View::AddZLayer (const Graphic3d_ZLayerId theLayerId)
{
myZLayers.AddLayer (theLayerId);
}
//=======================================================================
//function : RemoveZLayer
//purpose :
//=======================================================================
void OpenGl_View::RemoveZLayer (const Graphic3d_ZLayerId theLayerId)
{
myZLayers.RemoveLayer (theLayerId);
}
//=======================================================================
//function : SetZLayerSettings
//purpose :
//=======================================================================
void OpenGl_View::SetZLayerSettings (const Graphic3d_ZLayerId theLayerId,
const Graphic3d_ZLayerSettings& theSettings)
{
myZLayers.SetLayerSettings (theLayerId, theSettings);
}
//=======================================================================
//function : FBO
//purpose :
//=======================================================================
Graphic3d_PtrFrameBuffer OpenGl_View::FBO() const
{
return reinterpret_cast<Graphic3d_PtrFrameBuffer> (myFBO);
}
//=======================================================================
//function : SetFBO
//purpose :
//=======================================================================
void OpenGl_View::SetFBO (const Graphic3d_PtrFrameBuffer theFBO)
{
myFBO = reinterpret_cast<OpenGl_FrameBuffer*> (theFBO);
}
//=======================================================================
//function : FBOCreate
//purpose :
//=======================================================================
Graphic3d_PtrFrameBuffer OpenGl_View::FBOCreate (const Standard_Integer theWidth,
const Standard_Integer theHeight)
{
return myWorkspace->FBOCreate (theWidth, theHeight);
}
//=======================================================================
//function : FBORelease
//purpose :
//=======================================================================
void OpenGl_View::FBORelease (Graphic3d_PtrFrameBuffer& theFBOPtr)
{
myWorkspace->FBORelease (theFBOPtr);
}
//=======================================================================
//function : FBOGetDimensions
//purpose :
//=======================================================================
void OpenGl_View::FBOGetDimensions (const Graphic3d_PtrFrameBuffer theFBOPtr,
Standard_Integer& theWidth,
Standard_Integer& theHeight,
Standard_Integer& theWidthMax,
Standard_Integer& theHeightMax)
{
const OpenGl_FrameBuffer* aFrameBuffer = (const OpenGl_FrameBuffer* )theFBOPtr;
theWidth = aFrameBuffer->GetVPSizeX(); // current viewport size
theHeight = aFrameBuffer->GetVPSizeY();
theWidthMax = aFrameBuffer->GetSizeX(); // texture size
theHeightMax = aFrameBuffer->GetSizeY();
}
//=======================================================================
//function : FBOChangeViewport
//purpose :
//=======================================================================
void OpenGl_View::FBOChangeViewport (Graphic3d_PtrFrameBuffer& theFBOPtr,
const Standard_Integer theWidth,
const Standard_Integer theHeight)
{
OpenGl_FrameBuffer* aFrameBuffer = (OpenGl_FrameBuffer* )theFBOPtr;
aFrameBuffer->ChangeViewport (theWidth, theHeight);
}
// =======================================================================
// function : Export
// purpose :
// =======================================================================
#ifdef HAVE_GL2PS
Standard_Boolean OpenGl_View::Export (const Standard_CString theFileName,
const Graphic3d_ExportFormat theFormat,
const Graphic3d_SortType theSortType)
{
// gl2psBeginPage() will call OpenGL functions
// so we should activate correct GL context before redraw scene call
if (!myWorkspace->Activate())
{
return Standard_False;
}
Standard_Integer aFormat = -1;
Standard_Integer aSortType = Graphic3d_ST_BSP_Tree;
switch (theFormat)
{
case Graphic3d_EF_PostScript:
aFormat = GL2PS_PS;
break;
case Graphic3d_EF_EnhPostScript:
aFormat = GL2PS_EPS;
break;
case Graphic3d_EF_TEX:
aFormat = GL2PS_TEX;
break;
case Graphic3d_EF_PDF:
aFormat = GL2PS_PDF;
break;
case Graphic3d_EF_SVG:
aFormat = GL2PS_SVG;
break;
case Graphic3d_EF_PGF:
aFormat = GL2PS_PGF;
break;
case Graphic3d_EF_EMF:
//aFormat = GL2PS_EMF;
aFormat = GL2PS_PGF + 1; // 6
break;
default:
// unsupported format
return Standard_False;
}
switch (theSortType)
{
case Graphic3d_ST_Simple:
aSortType = GL2PS_SIMPLE_SORT;
break;
case Graphic3d_ST_BSP_Tree:
aSortType = GL2PS_BSP_SORT;
break;
}
GLint aViewport[4];
aViewport[0] = 0;
aViewport[1] = 0;
aViewport[2] = myWindow->Width();
aViewport[3] = myWindow->Height();
GLint aBufferSize = 1024 * 1024;
GLint anErrCode = GL2PS_SUCCESS;
// gl2ps uses standard write functions and do not check locale
Standard_CLocaleSentry aLocaleSentry;
while (aBufferSize > 0)
{
// current patch for EMF support in gl2ps uses WinAPI functions to create file
FILE* aFileH = (theFormat != Graphic3d_EF_EMF) ? fopen (theFileName, "wb") : NULL;
anErrCode = gl2psBeginPage ("", "", aViewport, aFormat, aSortType,
GL2PS_DRAW_BACKGROUND | GL2PS_OCCLUSION_CULL | GL2PS_BEST_ROOT/* | GL2PS_SIMPLE_LINE_OFFSET*/,
GL_RGBA, 0, NULL,
0, 0, 0, aBufferSize, aFileH, theFileName);
if (anErrCode != GL2PS_SUCCESS)
{
// initialization failed
if (aFileH != NULL)
fclose (aFileH);
break;
}
Redraw();
anErrCode = gl2psEndPage();
if (aFileH != NULL)
fclose (aFileH);
if (anErrCode == GL2PS_OVERFLOW)
aBufferSize *= 2;
else
break;
}
return anErrCode == GL2PS_SUCCESS;
}
#else
Standard_Boolean OpenGl_View::Export (const Standard_CString /*theFileName*/,
const Graphic3d_ExportFormat /*theFormat*/,
const Graphic3d_SortType /*theSortType*/)
{
return Standard_False;
}
#endif
//=======================================================================
//function : displayStructure
//purpose :
//=======================================================================
void OpenGl_View::displayStructure (const Handle(Graphic3d_CStructure)& theStructure,
const Standard_Integer thePriority)
{
const OpenGl_Structure* aStruct = reinterpret_cast<const OpenGl_Structure*> (theStructure.operator->());
const Graphic3d_ZLayerId aZLayer = aStruct->ZLayer();
myZLayers.AddStructure (aStruct, aZLayer, thePriority);
}
//=======================================================================
//function : eraseStructure
//purpose :
//=======================================================================
void OpenGl_View::eraseStructure (const Handle(Graphic3d_CStructure)& theStructure)
{
const OpenGl_Structure* aStruct = reinterpret_cast<const OpenGl_Structure*> (theStructure.operator->());
myZLayers.RemoveStructure (aStruct);
}
//=======================================================================
//function : changeZLayer
//purpose :
//=======================================================================
void OpenGl_View::changeZLayer (const Handle(Graphic3d_CStructure)& theStructure,
const Graphic3d_ZLayerId theNewLayerId)
{
const Graphic3d_ZLayerId anOldLayer = theStructure->ZLayer();
const OpenGl_Structure* aStruct = reinterpret_cast<const OpenGl_Structure*> (theStructure.operator->());
myZLayers.ChangeLayer (aStruct, anOldLayer, theNewLayerId);
}
//=======================================================================
//function : changePriority
//purpose :
//=======================================================================
void OpenGl_View::changePriority (const Handle(Graphic3d_CStructure)& theStructure,
const Standard_Integer theNewPriority)
{
const Graphic3d_ZLayerId aLayerId = theStructure->ZLayer();
const OpenGl_Structure* aStruct = reinterpret_cast<const OpenGl_Structure*> (theStructure.operator->());
myZLayers.ChangePriority (aStruct, aLayerId, theNewPriority);
}

639
src/OpenGl/OpenGl_View.hxx
View File

@ -29,25 +29,32 @@
#include <Aspect_TypeOfTriedronPosition.hxx>
#include <InterfaceGraphic_Graphic3d.hxx>
#include <InterfaceGraphic_Visual3d.hxx>
#include <Graphic3d_CView.hxx>
#include <Graphic3d_GraduatedTrihedron.hxx>
#include <Graphic3d_SequenceOfHClipPlane.hxx>
#include <Graphic3d_TypeOfShadingModel.hxx>
#include <Graphic3d_TypeOfSurfaceDetail.hxx>
#include <Graphic3d_WorldViewProjState.hxx>
#include <Graphic3d_ZLayerSettings.hxx>
#include <Visual3d_TypeOfSurfaceDetail.hxx>
#include <Visual3d_TypeOfModel.hxx>
#include <OpenGl_AspectFace.hxx>
#include <OpenGl_BackgroundArray.hxx>
#include <OpenGl_BVHTreeSelector.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_FrameBuffer.hxx>
#include <OpenGl_GraduatedTrihedron.hxx>
#include <OpenGl_LayerList.hxx>
#include <OpenGl_Light.hxx>
#include <OpenGl_LineAttributes.hxx>
#include <OpenGl_SceneGeometry.hxx>
#include <OpenGl_Structure.hxx>
#include <OpenGl_Trihedron.hxx>
#include <OpenGl_GraduatedTrihedron.hxx>
#include <OpenGl_Window.hxx>
#include <OpenGl_Workspace.hxx>
#include <map>
#include <set>
struct OPENGL_ZCLIP
{
@ -70,96 +77,370 @@ struct OPENGL_FOG
};
struct OpenGl_Matrix;
class OpenGl_Structure;
class Graphic3d_StructureManager;
class OpenGl_GraphicDriver;
class OpenGl_StateCounter;
class OpenGl_RaytraceMaterial;
class OpenGl_TriangleSet;
class OpenGl_Workspace;
class OpenGl_View;
DEFINE_STANDARD_HANDLE(OpenGl_View,MMgt_TShared)
DEFINE_STANDARD_HANDLE(OpenGl_View,Graphic3d_CView)
class OpenGl_View : public MMgt_TShared
//! Implementation of OpenGl view.
class OpenGl_View : public Graphic3d_CView
{
public:
Standard_EXPORT OpenGl_View (const CALL_DEF_VIEWCONTEXT &AContext, OpenGl_StateCounter* theCounter);
Standard_EXPORT virtual ~OpenGl_View ();
public:
//! Constructor.
Standard_EXPORT OpenGl_View (const Handle(Graphic3d_StructureManager)& theMgr,
const Handle(OpenGl_GraphicDriver)& theDriver,
const Handle(OpenGl_Caps)& theCaps,
Standard_Boolean& theDeviceLostFlag,
OpenGl_StateCounter* theCounter);
//! Default destructor.
Standard_EXPORT virtual ~OpenGl_View();
Standard_EXPORT void ReleaseGlResources (const Handle(OpenGl_Context)& theCtx);
void SetTextureEnv (const Handle(OpenGl_Context)& theCtx,
const Handle(Graphic3d_TextureEnv)& theTexture);
void SetSurfaceDetail (const Visual3d_TypeOfSurfaceDetail AMode);
void SetBackfacing (const Standard_Integer AMode);
void SetLights (const CALL_DEF_VIEWCONTEXT &AContext);
void SetAntiAliasing (const Standard_Boolean AMode) { myAntiAliasing = AMode; }
void SetClipPlanes (const Graphic3d_SequenceOfHClipPlane &thePlanes) { myClipPlanes = thePlanes; }
void SetVisualisation (const CALL_DEF_VIEWCONTEXT &AContext);
//! Deletes and erases the view.
Standard_EXPORT virtual void Remove() Standard_OVERRIDE;
const Handle(Graphic3d_Camera)& Camera() { return myCamera; }
void SetCamera (const Handle(Graphic3d_Camera)& theCamera) { myCamera = theCamera; }
//! @param theDrawToFrontBuffer Advanced option to modify rendering mode:
//! 1. TRUE. Drawing immediate mode structures directly to the front buffer over the scene image.
//! Fast, so preferred for interactive work (used by default).
//! However these extra drawings will be missed in image dump since it is performed from back buffer.
//! Notice that since no pre-buffering used the V-Sync will be ignored and rendering could be seen
//! in run-time (in case of slow hardware) and/or tearing may appear.
//! So this is strongly recommended to draw only simple (fast) structures.
//! 2. FALSE. Drawing immediate mode structures to the back buffer.
//! The complete scene is redrawn first, so this mode is slower if scene contains complex data and/or V-Sync
//! is turned on. But it works in any case and is especially useful for view dump because the dump image is read
//! from the back buffer.
//! @return previous mode.
Standard_EXPORT Standard_Boolean SetImmediateModeDrawToFront (const Standard_Boolean theDrawToFrontBuffer) Standard_OVERRIDE;
void SetClipLimit (const Graphic3d_CView& theCView);
//! Creates and maps rendering window to the view.
//! @param theView [in] the view to associate with the window.
//! @param theWindow [in] the window.
//! @param theContext [in] the rendering context. If NULL the context will be created internally.
//! @param theDisplayCB [in] the display callback function. If is not a NULL value, then the callback will be
//! invoked at the end of the OCC graphic traversal and just before the swap of buffers.
//! @param theClientData [in] the client data for the callback.
Standard_EXPORT virtual void SetWindow (const Handle(Aspect_Window)& theWindow,
const Aspect_RenderingContext theContext,
const Aspect_GraphicCallbackProc& theDisplayCB,
const Standard_Address theClientData) Standard_OVERRIDE;
void SetFog (const Graphic3d_CView& theCView, const Standard_Boolean theFlag);
//! Returns window associated with the view.
virtual Handle(Aspect_Window) Window() const Standard_OVERRIDE { return myWindow->PlatformWindow(); }
OpenGl_Trihedron& ChangeTrihedron() { return myTrihedron; }
void TriedronDisplay (const Aspect_TypeOfTriedronPosition thePosition,
const Quantity_NameOfColor theColor,
const Standard_Real theScale,
const Standard_Boolean theAsWireframe);
void TriedronErase (const Handle(OpenGl_Context)& theCtx);
//! Returns True if the window associated to the view is defined.
virtual Standard_Boolean IsDefined() const { return !myWindow.IsNull(); }
OpenGl_GraduatedTrihedron& ChangeGraduatedTrihedron() { return myGraduatedTrihedron; }
void GraduatedTrihedronDisplay (const Handle(OpenGl_Context)& theCtx,
const Graphic3d_GraduatedTrihedron& theCubic);
void GraduatedTrihedronErase (const Handle(OpenGl_Context)& theCtx);
//! Handle changing size of the rendering window.
Standard_EXPORT virtual void Resized() Standard_OVERRIDE;
Standard_Real Height () const { return myCamera->ViewDimensions().X(); }
Standard_Real Width () const { return myCamera->ViewDimensions().Y(); }
//! Redraw content of the view.
Standard_EXPORT virtual void Redraw() Standard_OVERRIDE;
Standard_Integer Backfacing () const { return myBackfacing; }
//! Redraw immediate content of the view.
Standard_EXPORT virtual void RedrawImmediate() Standard_OVERRIDE;
//! Add structure to display list with specified priority.
//! The structure will be added to associated with it z layer.
//! If the z layer is not presented in the view, the structure will
//! be displayed in default bottom-level z layer.
void DisplayStructure (const Handle(Graphic3d_Structure)& theStructure,
const Standard_Integer thePriority);
//! Marks BVH tree for given priority list as dirty and marks primitive set for rebuild.
Standard_EXPORT virtual void Invalidate() Standard_OVERRIDE;
//! Erase structure from display list.
void EraseStructure (const Handle(Graphic3d_Structure)& theStructure);
//! Return true if view content cache has been invalidated.
virtual Standard_Boolean IsInvalidated() Standard_OVERRIDE { return myBackBufferRestored; }
//! Insert a new top-level z layer with ID <theLayerId>
void AddZLayer (const Graphic3d_ZLayerId theLayerId);
//! Displays z-buffer trihedron.
Standard_EXPORT virtual void TriedronDisplay (const Aspect_TypeOfTriedronPosition thePosition = Aspect_TOTP_CENTER,
const Quantity_NameOfColor theColor = Quantity_NOC_WHITE,
const Standard_Real theScale = 0.02,
const Standard_Boolean theAsWireframe = Standard_True) Standard_OVERRIDE;
//! Remove a z layer with ID <theLayerId>
void RemoveZLayer (const Graphic3d_ZLayerId theLayerId);
//! Erases z-buffer trihedron.
Standard_EXPORT virtual void TriedronErase() Standard_OVERRIDE;
//! Display structure in z layer with ID <theNewLayerId>
//! If the layer with ID <theNewLayerId> is not presented in the view,
//! the structure will be displayed in default bottom-level layer.
void ChangeZLayer (const OpenGl_Structure* theStructure,
const Graphic3d_ZLayerId theNewLayerId);
//! Setup parameters of z-buffer trihedron.
Standard_EXPORT virtual void ZBufferTriedronSetup (const Quantity_NameOfColor theXColor = Quantity_NOC_RED,
const Quantity_NameOfColor theYColor = Quantity_NOC_GREEN,
const Quantity_NameOfColor theZColor = Quantity_NOC_BLUE1,
const Standard_Real theSizeRatio = 0.8,
const Standard_Real theAxisDiametr = 0.05,
const Standard_Integer theNbFacettes = 12) Standard_OVERRIDE;
//! Displays trihedron echo.
Standard_EXPORT virtual void TriedronEcho (const Aspect_TypeOfTriedronEcho theType = Aspect_TOTE_NONE) Standard_OVERRIDE;
//! Returns data of a graduated trihedron
const Graphic3d_GraduatedTrihedron& GetGraduatedTrihedron() { return myGTrihedronData; }
//! Displays Graduated Trihedron.
Standard_EXPORT virtual void GraduatedTrihedronDisplay (const Graphic3d_GraduatedTrihedron& theTrihedronData) Standard_OVERRIDE;
//! Erases Graduated Trihedron.
Standard_EXPORT virtual void GraduatedTrihedronErase() Standard_OVERRIDE;
//! Sets minimum and maximum points of scene bounding box for Graduated Trihedron stored in graphic view object.
//! @param theMin [in] the minimum point of scene.
//! @param theMax [in] the maximum point of scene.
Standard_EXPORT virtual void GraduatedTrihedronMinMaxValues (const Graphic3d_Vec3 theMin, const Graphic3d_Vec3 theMax) Standard_OVERRIDE;
//! Reads depths of shown pixels of the given rectangle.
Standard_EXPORT virtual void ReadDepths (const Standard_Integer theX,
const Standard_Integer theY,
const Standard_Integer theWidth,
const Standard_Integer theHeight,
const Standard_Address theBuffer) const Standard_OVERRIDE;
//! Dump active rendering buffer into specified memory buffer.
Standard_EXPORT virtual Standard_Boolean BufferDump (Image_PixMap& theImage,
const Graphic3d_BufferType& theBufferType) Standard_OVERRIDE;
//! Print the contents of the view to the printer.
//! @param thePrinterDC pass the PrinterDeviceContext (HDC)
//! @param theToShowBackground when set to FALSE then print the view without background
//! color (background is white) else set to TRUE for printing
//! with current background color
//! @param theFileName if != NULL, then the view will be printed to a file
//! @param thePrintAlgorithm select print algorithm: stretch, tile
//! @param theScaleFactor scaling coefficient, used internally to scale the printings
//! accordingly to the scale factor selected in the printer properties dialog
//! @return Standard_True if the data is passed to the printer, otherwise Standard_False if
//! the print operation failed due to the printer errors, or lack of system memory. This might be related
//! to insufficient memory or some internal errors.
//! All this errors are indicated by the message boxes (on level of OpenGl_GraphicDriver).
//! Warning: This function can reuse FBO assigned to the view, please take it into account
//! if you use it for your purposes.
Standard_EXPORT virtual Standard_Boolean Print (const Aspect_Handle thePrinterDC,
const Standard_Boolean theToShowBackground,
const Standard_CString theFileName,
const Aspect_PrintAlgo thePrintAlgorithm = Aspect_PA_STRETCH,
const Standard_Real theScaleFactor = 1.0) Standard_OVERRIDE;
//! Export scene into the one of the Vector graphics formats (SVG, PS, PDF...).
//! In contrast to Bitmaps, Vector graphics is scalable (so you may got quality benefits
//! on printing to laser printer). Notice however that results may differ a lot and
//! do not contain some elements.
Standard_EXPORT virtual Standard_Boolean Export (const Standard_CString theFileName,
const Graphic3d_ExportFormat theFormat,
const Graphic3d_SortType theSortType = Graphic3d_ST_BSP_Tree) Standard_OVERRIDE;
//! Marks BVH tree and the set of BVH primitives of correspondent priority list with id theLayerId as outdated.
Standard_EXPORT virtual void InvalidateBVHData (const Standard_Integer theLayerId) Standard_OVERRIDE;
//! Insert a new top-level z layer with the given ID.
Standard_EXPORT virtual void AddZLayer (const Graphic3d_ZLayerId theLayerId) Standard_OVERRIDE;
//! Remove a z layer with the given ID.
Standard_EXPORT virtual void RemoveZLayer (const Graphic3d_ZLayerId theLayerId) Standard_OVERRIDE;
//! Sets the settings for a single Z layer of specified view.
void SetZLayerSettings (const Graphic3d_ZLayerId theLayerId,
const Graphic3d_ZLayerSettings& theSettings);
Standard_EXPORT virtual void SetZLayerSettings (const Graphic3d_ZLayerId theLayerId,
const Graphic3d_ZLayerSettings& theSettings) Standard_OVERRIDE;
//! Changes the priority of a structure within its ZLayer
void ChangePriority (const OpenGl_Structure* theStructure,
const Standard_Integer theNewPriority);
//! Returns pointer to an assigned framebuffer object.
Standard_EXPORT virtual Graphic3d_PtrFrameBuffer FBO() const Standard_OVERRIDE;
void CreateBackgroundTexture (const Standard_CString AFileName,
const Aspect_FillMethod AFillStyle);
//! Sets framebuffer object for offscreen rendering.
Standard_EXPORT virtual void SetFBO (const Graphic3d_PtrFrameBuffer theFBO) Standard_OVERRIDE;
//! Generate offscreen FBO in the graphic library.
//! If not supported on hardware returns NULL.
Standard_EXPORT virtual Graphic3d_PtrFrameBuffer FBOCreate (const Standard_Integer theWidth,
const Standard_Integer theHeight) Standard_OVERRIDE;
//! Remove offscreen FBO from the graphic library
Standard_EXPORT virtual void FBORelease (Graphic3d_PtrFrameBuffer& theFBOPtr) Standard_OVERRIDE;
//! Read offscreen FBO configuration.
Standard_EXPORT virtual void FBOGetDimensions (const Graphic3d_PtrFrameBuffer theFBOPtr,
Standard_Integer& theWidth,
Standard_Integer& theHeight,
Standard_Integer& theWidthMax,
Standard_Integer& theHeightMax) Standard_OVERRIDE;
//! Change offscreen FBO viewport.
Standard_EXPORT virtual void FBOChangeViewport (Graphic3d_PtrFrameBuffer& theFBOPtr,
const Standard_Integer theWidth,
const Standard_Integer theHeight) Standard_OVERRIDE;
public:
//! Returns true if anti-aliasing is enabled for the view.
Standard_Boolean virtual IsAntialiasingEnabled() const Standard_OVERRIDE { return myAntiAliasing; }
//! Enable or disable anti-aliasing in the view.
virtual void SetAntialiasingEnabled (const Standard_Boolean theIsEnabled) Standard_OVERRIDE { myAntiAliasing = theIsEnabled; }
//! Returns background fill color.
Standard_EXPORT virtual Aspect_Background Background() const Standard_OVERRIDE;
//! Sets background fill color.
Standard_EXPORT virtual void SetBackground (const Aspect_Background& theBackground) Standard_OVERRIDE;
//! Returns gradient background fill colors.
Standard_EXPORT virtual Aspect_GradientBackground GradientBackground() const Standard_OVERRIDE;
//! Sets gradient background fill colors.
Standard_EXPORT virtual void SetGradientBackground (const Aspect_GradientBackground& theBackground) Standard_OVERRIDE;
//! Returns background image texture file path.
Standard_EXPORT virtual TCollection_AsciiString BackgroundImage() Standard_OVERRIDE { return myBackgroundImagePath; }
//! Sets background image texture file path.
Standard_EXPORT virtual void SetBackgroundImage (const TCollection_AsciiString& theFilePath) Standard_OVERRIDE;
//! Returns background image fill style.
Standard_EXPORT virtual Aspect_FillMethod BackgroundImageStyle() const Standard_OVERRIDE;
//! Sets background image fill style.
Standard_EXPORT virtual void SetBackgroundImageStyle (const Aspect_FillMethod theFillStyle) Standard_OVERRIDE;
//! Returns environment texture set for the view.
Standard_EXPORT virtual Handle(Graphic3d_TextureEnv) TextureEnv() const Standard_OVERRIDE { return myTextureEnvData; }
//! Sets environment texture for the view.
Standard_EXPORT virtual void SetTextureEnv (const Handle(Graphic3d_TextureEnv)& theTextureEnv) Standard_OVERRIDE;
//! Returns the state of frustum culling optimization.
virtual Standard_Boolean IsCullingEnabled() const Standard_OVERRIDE { return myCulling; }
//! Enables or disables frustum culling optimization.
virtual void SetCullingEnabled (const Standard_Boolean theIsEnabled) Standard_OVERRIDE { myCulling = theIsEnabled; }
//! Returns shading model of the view.
virtual Graphic3d_TypeOfShadingModel ShadingModel() const Standard_OVERRIDE { return myShadingModel; }
//! Sets shading model of the view.
virtual void SetShadingModel (const Graphic3d_TypeOfShadingModel theModel) Standard_OVERRIDE { myShadingModel = theModel; }
//! Returns surface detail type of the view.
virtual Graphic3d_TypeOfSurfaceDetail SurfaceDetailType() const Standard_OVERRIDE { return mySurfaceDetail; }
//! Sets surface detail type of the view.
virtual void SetSurfaceDetailType (const Graphic3d_TypeOfSurfaceDetail theType) Standard_OVERRIDE
{
mySurfaceDetail = theType;
myToUpdateEnvironmentMap = Standard_True;
}
//! Return backfacing model used for the view.
virtual Graphic3d_TypeOfBackfacingModel BackfacingModel() const Standard_OVERRIDE { return myBackfacing; }
//! Sets backfacing model for the view.
virtual void SetBackfacingModel (const Graphic3d_TypeOfBackfacingModel theModel) Standard_OVERRIDE { myBackfacing = theModel; }
//! Returns camera object of the view.
virtual const Handle(Graphic3d_Camera)& Camera() const Standard_OVERRIDE { return myCamera; }
//! Sets camera used by the view.
virtual void SetCamera (const Handle(Graphic3d_Camera)& theCamera) Standard_OVERRIDE { myCamera = theCamera; }
//! Returns the activity of back z-clipping plane.
virtual Standard_Boolean BackZClippingIsOn() const Standard_OVERRIDE { return myZClip.Back.IsOn; }
//! Activates the back Z-clipping plane.
virtual void SetBackZClippingOn (const Standard_Boolean theIsOn) Standard_OVERRIDE { myZClip.Back.IsOn = theIsOn; }
//! Returns the definition of the back Z-clipping plane.
virtual Standard_Real ZClippingBackPlane() const Standard_OVERRIDE { return myZClip.Back.Limit; }
//! Sets the definition of the back Z-clipping plane.
virtual void SetZClippingBackPlane (const Standard_Real theValue) Standard_OVERRIDE
{
myZClip.Back.Limit = static_cast<Standard_ShortReal> (theValue);
}
//! Returns the activity of front z-clipping plane.
virtual Standard_Boolean FrontZClippingIsOn() const Standard_OVERRIDE { return myZClip.Front.IsOn; }
//! Activates the front Z-clipping plane.
virtual void SetFrontZClippingOn (const Standard_Boolean theIsOn) Standard_OVERRIDE{ myZClip.Front.IsOn = theIsOn; }
//! Returns the definition of the front Z-clipping plane.
virtual Standard_Real ZClippingFrontPlane() const Standard_OVERRIDE { return myZClip.Front.Limit; }
//! Sets the definition of the front Z-clipping plane.
virtual void SetZClippingFrontPlane (const Standard_Real theValue) Standard_OVERRIDE
{
myZClip.Front.Limit = static_cast<Standard_ShortReal> (theValue);
}
//! Returns the activity of depth cueing.
virtual Standard_Boolean DepthCueingIsOn() const Standard_OVERRIDE { return myFog.IsOn; }
//! Sets the activity of depth cueing.
virtual void SetDepthCueingOn (const Standard_Boolean theIsOn) Standard_OVERRIDE { myFog.IsOn = theIsOn; }
//! Returns the back depth cueing plane.
virtual Standard_Real DepthCueingBackPlane() const Standard_OVERRIDE { return myFog.Back; }
//! Set the back depth cueing plane.
virtual void SetDepthCueingBackPlane (const Standard_Real theValue) Standard_OVERRIDE
{
myFog.Back = static_cast<Standard_ShortReal> (theValue);
}
//! Returns the front depth cueing plane.
virtual Standard_Real DepthCueingFrontPlane() const Standard_OVERRIDE { return myFog.Front; }
//! Set the front depth cueing plane.
virtual void SetDepthCueingFrontPlane (const Standard_Real theValue) Standard_OVERRIDE
{
myFog.Front = static_cast<Standard_ShortReal> (theValue);
}
//! Returns true if GL lighting is enabled.
virtual Standard_Boolean IsGLLightEnabled() const Standard_OVERRIDE { return myUseGLLight; }
//! Sets GL lighting enabled or disable state.
virtual void SetGLLightEnabled (const Standard_Boolean theIsEnabled) Standard_OVERRIDE { myUseGLLight = theIsEnabled; }
//! Returns list of lights of the view.
virtual const Graphic3d_ListOfCLight& Lights() const Standard_OVERRIDE { return myLights; }
//! Sets list of lights for the view.
virtual void SetLights (const Graphic3d_ListOfCLight& theLights) Standard_OVERRIDE
{
myLights = theLights;
myCurrLightSourceState = myStateCounter->Increment();
}
//! Returns list of clip planes set for the view.
virtual const Graphic3d_SequenceOfHClipPlane& ClipPlanes() const Standard_OVERRIDE { return myClipPlanes; }
//! Sets list of clip planes for the view.
virtual void SetClipPlanes (const Graphic3d_SequenceOfHClipPlane& thePlanes) Standard_OVERRIDE { myClipPlanes = thePlanes; }
public:
//! Returns background color.
const TEL_COLOUR& BackgroundColor() const { return myBgColor; }
//! Change trihedron.
OpenGl_Trihedron& ChangeTrihedron() { return myTrihedron; }
//! Change graduated trihedron.
OpenGl_GraduatedTrihedron& ChangeGraduatedTrihedron() { return myGraduatedTrihedron; }
void SetTextureEnv (const Handle(OpenGl_Context)& theCtx,
const Handle(Graphic3d_TextureEnv)& theTexture);
//! Returns height of view volume.
Standard_Real Height () const { return myCamera->ViewDimensions().X(); }
//! Returns width of view volume.
Standard_Real Width () const { return myCamera->ViewDimensions().Y(); }
void SetBackgroundTextureStyle (const Aspect_FillMethod FillStyle);
void SetBackgroundGradient (const Quantity_Color& AColor1, const Quantity_Color& AColor2, const Aspect_GradientFillMethod AType);
void SetBackgroundGradientType (const Aspect_GradientFillMethod AType);
void Render (const Handle(OpenGl_PrinterContext)& thePrintContext,
const Handle(OpenGl_Workspace)& theWorkspace,
OpenGl_FrameBuffer* theReadDrawFbo,
Graphic3d_Camera::Projection theProjection,
const Graphic3d_CView& theCView,
const Standard_Boolean theToDrawImmediate);
void SetBackgroundGradient (const Quantity_Color& AColor1, const Quantity_Color& AColor2, const Aspect_GradientFillMethod AType);
void SetBackgroundGradientType (const Aspect_GradientFillMethod AType);
void DrawBackground (const Handle(OpenGl_Workspace)& theWorkspace);
@ -169,82 +450,144 @@ class OpenGl_View : public MMgt_TShared
//! Returns list of openGL light sources.
const OpenGl_ListOfLight& LightList() const { return myLights; }
//! Returns OpenGL environment map.
const Handle(OpenGl_Texture)& TextureEnv() const { return myTextureEnv; }
//! Returns OpenGL window implementation.
const Handle(OpenGl_Window) GlWindow() const { return myWindow; }
//! Returns visualization mode for objects in the view.
Visual3d_TypeOfSurfaceDetail SurfaceDetail() const { return mySurfaceDetail; }
//! Returns OpenGL environment map.
const Handle(OpenGl_Texture)& GlTextureEnv() const { return myTextureEnv; }
//! Returns selector for BVH tree, providing a possibility to store information
//! about current view volume and to detect which objects are overlapping it.
OpenGl_BVHTreeSelector& BVHTreeSelector() { return myBVHSelector; }
//! Marks BVH tree for given priority list as dirty and
//! marks primitive set for rebuild.
void InvalidateBVHData (const Standard_Integer theLayerId);
//! Returns true if there are immediate structures to display
bool HasImmediateStructures() const
{
return myZLayers.NbImmediateStructures() != 0;
}
protected: //! @name Internal methods for managing GL resources
//! Initializes OpenGl resource for environment texture.
void initTextureEnv (const Handle(OpenGl_Context)& theContext);
protected: //! @name Internal redrawing sub-routines
//! Redraws view for the given monographic camera projection, or left/right eye.
void redraw (const Graphic3d_Camera::Projection theProjection, OpenGl_FrameBuffer* theReadDrawFbo);
//! Redraws view for the given monographic camera projection, or left/right eye.
//!
//! Method will blit snapshot containing main scene (myMainSceneFbos or BackBuffer)
//! into presentation buffer (myMainSceneFbos -> offscreen FBO or
//! myMainSceneFbos -> BackBuffer or BackBuffer -> FrontBuffer),
//! and redraw immediate structures on top.
//!
//! When scene caching is disabled (myTransientDrawToFront, no double buffer in window, etc.),
//! the first step (blitting) will be skipped.
//!
//! @return false if immediate structures has been rendered directly into FrontBuffer
//! and Buffer Swap should not be called.
bool redrawImmediate (const Graphic3d_Camera::Projection theProjection,
OpenGl_FrameBuffer* theReadFbo,
OpenGl_FrameBuffer* theDrawFbo,
const Standard_Boolean theIsPartialUpdate = Standard_False);
//! Copy content of Back buffer to the Front buffer.
void copyBackToFront();
//! Initialize blit quad.
OpenGl_VertexBuffer* initBlitQuad (const Standard_Boolean theToFlip);
//! Blit image from/to specified buffers.
bool blitBuffers (OpenGl_FrameBuffer* theReadFbo,
OpenGl_FrameBuffer* theDrawFbo,
const Standard_Boolean theToFlip = Standard_False);
//! Setup default FBO.
void bindDefaultFbo (OpenGl_FrameBuffer* theCustomFbo = NULL);
//! Blend together views pair into stereo image.
void drawStereoPair();
//! Invokes display callback.
void displayCallback (const Standard_Integer theReason);
protected: //! @name Rendering of GL graphics (with prepared drawing buffer).
//! Renders the graphical contents of the view into the preprepared window or framebuffer.
//! @param theProjection [in] the projection that should be used for rendering.
//! @param theReadDrawFbo [in] the framebuffer for rendering graphics.
//! @param theToDrawImmediate [in] the flag indicates whether the rendering performs in immediate mode.
void render (Graphic3d_Camera::Projection theProjection,
OpenGl_FrameBuffer* theReadDrawFbo,
const Standard_Boolean theToDrawImmediate);
//! Renders the graphical scene.
//! @param theReadDrawFbo [in] the framebuffer for rendering graphics.
//! @param theToDrawImmediate [in] the flag indicates whether the rendering performs in immediate mode.
void renderScene (OpenGl_FrameBuffer* theReadDrawFbo,
const Standard_Boolean theToDrawImmediate);
//! Render set of structures presented in the view.
//! @param theReadDrawFbo [in] the framebuffer for rendering graphics.
//! @param theToDrawImmediate [in] the flag indicates whether the rendering performs in immediate mode.
void renderStructs (OpenGl_FrameBuffer* theReadDrawFbo,
const Standard_Boolean theToDrawImmediate);
//! Renders trihedron.
void renderTrihedron (const Handle(OpenGl_Workspace) &theWorkspace);
private:
//! Adds the structure to display lists of the view.
Standard_EXPORT virtual void displayStructure (const Handle(Graphic3d_CStructure)& theStructure,
const Standard_Integer thePriority) Standard_OVERRIDE;
//! Erases the structure from display lists of the view.
Standard_EXPORT virtual void eraseStructure (const Handle(Graphic3d_CStructure)& theStructure) Standard_OVERRIDE;
//! Change Z layer of a structure already presented in view.
Standard_EXPORT virtual void changeZLayer (const Handle(Graphic3d_CStructure)& theCStructure,
const Graphic3d_ZLayerId theNewLayerId) Standard_OVERRIDE;
//! Changes the priority of a structure within its Z layer in the specified view.
Standard_EXPORT virtual void changePriority (const Handle(Graphic3d_CStructure)& theCStructure,
const Standard_Integer theNewPriority) Standard_OVERRIDE;
protected:
void RenderStructs (const Handle(OpenGl_Workspace)& theWorkspace,
OpenGl_FrameBuffer* theReadDrawFbo,
const Graphic3d_CView& theCView,
const Standard_Boolean theToDrawImmediate);
OpenGl_GraphicDriver* myDriver;
Handle(OpenGl_Window) myWindow;
Handle(OpenGl_Workspace) myWorkspace;
Handle(OpenGl_Caps) myCaps;
Standard_Boolean& myDeviceLostFlag;
Standard_Boolean myWasRedrawnGL;
void RedrawTrihedron (const Handle(OpenGl_Workspace) &theWorkspace);
Standard_Boolean myAntiAliasing;
Standard_Boolean myCulling;
Graphic3d_TypeOfShadingModel myShadingModel;
Graphic3d_TypeOfSurfaceDetail mySurfaceDetail;
Graphic3d_TypeOfBackfacingModel myBackfacing;
TEL_COLOUR myBgColor;
OPENGL_FOG myFog;
OPENGL_ZCLIP myZClip;
Graphic3d_SequenceOfHClipPlane myClipPlanes;
Handle(Graphic3d_Camera) myCamera;
OpenGl_FrameBuffer* myFBO;
Standard_Boolean myUseGLLight;
Standard_Boolean myToShowTrihedron;
Standard_Boolean myToShowGradTrihedron;
TCollection_AsciiString myBackgroundImagePath;
Handle(Graphic3d_TextureEnv) myTextureEnvData;
Graphic3d_GraduatedTrihedron myGTrihedronData;
//! Redraw contents of model scene: clipping planes,
//! lights, structures. The peculiar properties of "scene" is that
//! it requires empty Z-Buffer and uses projection and orientation
//! matrices supplied by 3d view.
void RedrawScene (const Handle(OpenGl_PrinterContext)& thePrintContext,
const Handle(OpenGl_Workspace)& theWorkspace,
OpenGl_FrameBuffer* theReadDrawFbo,
const Graphic3d_CView& theCView,
const Standard_Boolean theToDrawImmediate);
OpenGl_ListOfLight myLights;
OpenGl_LayerList myZLayers; //!< main list of displayed structure, sorted by layers
Handle(OpenGl_LineAttributes) myLineAttribs;
Handle(OpenGl_Texture) myTextureEnv;
Visual3d_TypeOfSurfaceDetail mySurfaceDetail;
Standard_Integer myBackfacing;
OPENGL_ZCLIP myZClip;
Graphic3d_SequenceOfHClipPlane myClipPlanes;
Handle(Graphic3d_Camera) myCamera;
OPENGL_FOG myFog;
OpenGl_Trihedron myTrihedron;
OpenGl_GraduatedTrihedron myGraduatedTrihedron;
bool myToShowTrihedron;
bool myToShowGradTrihedron;
//View_LABViewContext
int myVisualization;
Visual3d_TypeOfModel myShadingModel; //!< lighting shading model
//View_LABLight
OpenGl_ListOfLight myLights;
//View_LABPlane
//View_LABAliasing
Standard_Boolean myAntiAliasing;
//View_LABDepthCueing - fixed index used
OpenGl_LayerList myZLayers; //!< main list of displayed structure, sorted by layers
//! Modification state
Graphic3d_WorldViewProjState myWorldViewProjState;
OpenGl_StateCounter* myStateCounter;
Standard_Size myCurrLightSourceState;
Graphic3d_WorldViewProjState myWorldViewProjState; //!< camera modification state
OpenGl_StateCounter* myStateCounter;
Standard_Size myCurrLightSourceState;
typedef std::pair<Standard_Size, Standard_Size> StateInfo;
@ -255,6 +598,32 @@ protected:
//! Is needed for selection of overlapping objects and storage of the current view volume
OpenGl_BVHTreeSelector myBVHSelector;
OpenGl_Trihedron myTrihedron;
OpenGl_GraduatedTrihedron myGraduatedTrihedron;
Handle(OpenGl_Texture) myTextureEnv;
struct
{
Aspect_GraphicCallbackProc Func;
Standard_Address Data;
} myDisplayCallback;
protected: //! @name Rendering properties
//! Two framebuffers (left and right views) store cached main presentation
//! of the view (without presentation of immediate layers).
Handle(OpenGl_FrameBuffer) myMainSceneFbos[2];
Handle(OpenGl_FrameBuffer) myImmediateSceneFbos[2]; //!< Additional buffers for immediate layer in stereo mode.
OpenGl_VertexBuffer myFullScreenQuad; //!< Vertices for full-screen quad rendering.
OpenGl_VertexBuffer myFullScreenQuadFlip;
Standard_Boolean myToFlipOutput; //!< Flag to draw result image upside-down
unsigned int myFrameCounter; //!< redraw counter, for debugging
Standard_Boolean myHasFboBlit;
Standard_Boolean myTransientDrawToFront; //!< optimization flag for immediate mode (to render directly to the front buffer)
Standard_Boolean myBackBufferRestored;
Standard_Boolean myIsImmediateDrawn; //!< flag indicates that immediate mode buffer contains some data
protected: //! @name Background parameters
OpenGl_AspectFace* myTextureParams; //!< Stores texture and its parameters for textured background
@ -564,8 +933,7 @@ protected: //! @name methods related to ray-tracing
const Handle(OpenGl_ShaderObject)& theFragShader);
//! Initializes OpenGL/GLSL shader programs.
Standard_Boolean initRaytraceResources (const Graphic3d_CView& theCView,
const Handle(OpenGl_Context)& theGlContext);
Standard_Boolean initRaytraceResources (const Handle(OpenGl_Context)& theGlContext);
//! Releases OpenGL/GLSL shader programs.
void releaseRaytraceResources (const Handle(OpenGl_Context)& theGlContext);
@ -589,16 +957,14 @@ protected: //! @name methods related to ray-tracing
void unbindRaytraceTextures (const Handle(OpenGl_Context)& theGlContext);
//! Sets uniform state for the given ray-tracing shader program.
Standard_Boolean setUniformState (const Graphic3d_CView& theCView,
const OpenGl_Vec3* theOrigins,
Standard_Boolean setUniformState (const OpenGl_Vec3* theOrigins,
const OpenGl_Vec3* theDirects,
const OpenGl_Mat4& theUnviewMat,
const Standard_Integer theProgramId,
const Handle(OpenGl_Context)& theGlContext);
//! Runs ray-tracing shader programs.
Standard_Boolean runRaytraceShaders (const Graphic3d_CView& theCView,
const Standard_Integer theSizeX,
Standard_Boolean runRaytraceShaders (const Standard_Integer theSizeX,
const Standard_Integer theSizeY,
const OpenGl_Vec3* theOrigins,
const OpenGl_Vec3* theDirects,
@ -607,8 +973,7 @@ protected: //! @name methods related to ray-tracing
const Handle(OpenGl_Context)& theGlContext);
//! Redraws the window using OpenGL/GLSL ray-tracing.
Standard_Boolean raytrace (const Graphic3d_CView& theCView,
const Standard_Integer theSizeX,
Standard_Boolean raytrace (const Standard_Integer theSizeX,
const Standard_Integer theSizeY,
OpenGl_FrameBuffer* theReadDrawFbo,
const Handle(OpenGl_Context)& theGlContext);
@ -718,10 +1083,10 @@ protected: //! @name fields related to ray-tracing
public:
DEFINE_STANDARD_ALLOC
DEFINE_STANDARD_RTTI(OpenGl_View, MMgt_TShared) // Type definition
DEFINE_STANDARD_RTTI(OpenGl_View, Graphic3d_CView) // Type definition
friend class OpenGl_GraphicDriver;
friend class OpenGl_Workspace;
};
#endif // _OpenGl_View_Header

1001
src/OpenGl/OpenGl_View_2.cxx
View File

File diff suppressed because it is too large Load Diff

176
src/OpenGl/OpenGl_Workspace_2.cxx → src/OpenGl/OpenGl_View_Print.cxx
View File

@ -24,6 +24,8 @@
#include <OpenGl_Workspace.hxx>
#include <OpenGl_View.hxx>
#include <Standard_NotImplemented.hxx>
#if (defined(_WIN32) || defined(__WIN32__)) && defined(HAVE_FREEIMAGE)
#include <NCollection_Handle.hxx>
#include <FreeImagePlus.h>
@ -38,10 +40,10 @@
#ifndef HAVE_FREEIMAGE
// ---------------------------------------------------------------
// Function: initBitmapBuffer
// Purpose: init device independent bitmap to hold printing data
// ---------------------------------------------------------------
// =======================================================================
// function : initBitmapBuffer
// purpose : init device independent bitmap to hold printing data
// =======================================================================
static void initBitmapBuffer (const HDC theMemoryDC,
HBITMAP &theMemoryBmp,
const Standard_Integer theBmpWidth,
@ -70,10 +72,10 @@ static void initBitmapBuffer (const HDC theMemoryDC,
#else /* HAVE_FREEIMAGE */
// ---------------------------------------------------------------
// Function: imagePasteDC
// Purpose: copy the data from image buffer to the device context
// ---------------------------------------------------------------
// =======================================================================
// function : imagePasteDC
// purpose : copy the data from image buffer to the device context
// =======================================================================
static bool imagePasteDC(HDC theDstDC, FipHandle theImage, int theOffsetX,
int theOffsetY, int theWidth, int theHeight,
int theLeft = 0, int theTop = 0)
@ -133,10 +135,10 @@ static bool imagePasteDC(HDC theDstDC, FipHandle theImage, int theOffsetX,
return true;
}
// ---------------------------------------------------------------
// Function: imageStretchDC
// Purpose: copy pixels from image to dc by stretching them
// ---------------------------------------------------------------
// =======================================================================
// function : imageStretchDC
// purpose : copy pixels from image to dc by stretching them
// =======================================================================
static bool imageStretchDC(HDC theDstDC, FipHandle theImage, int theOffsetX,
int theOffsetY, int theWidth, int theHeight)
{
@ -165,10 +167,10 @@ static bool imageStretchDC(HDC theDstDC, FipHandle theImage, int theOffsetX,
#endif /* HAVE_FREEIMAGE */
// ---------------------------------------------------------------
// Function: getNearestPowOfTwo
// Purpose: get the nearest power of two for theNumber
// ---------------------------------------------------------------
// =======================================================================
// function : getNearestPowOfTwo
// purpose : get the nearest power of two for theNumber
// =======================================================================
static GLsizei getNearestPowOfTwo (const GLsizei theNumber)
{
GLsizei aLast = 1;
@ -176,10 +178,10 @@ static GLsizei getNearestPowOfTwo (const GLsizei theNumber)
return aLast;
}
// ---------------------------------------------------------------
// Function: getMaxFrameSize
// Purpose: get the maximum possible frame size
// ---------------------------------------------------------------
// =======================================================================
// function : getMaxFrameSize
// purpose : get the maximum possible frame size
// =======================================================================
static void getMaxFrameSize(Standard_Integer& theWidth,
Standard_Integer& theHeight)
{
@ -197,11 +199,11 @@ static void getMaxFrameSize(Standard_Integer& theWidth,
theHeight = (Standard_Integer)aMaxY;
}
// ---------------------------------------------------------------
// Function: fitDimensionsRatio
// Purpose: calculate correct width/height ratio for theWidth and
// theHeight parameters
// ---------------------------------------------------------------
// =======================================================================
// function : fitDimensionsRatio
// purpose : calculate correct width/height ratio for theWidth and
// theHeight parameters
// =======================================================================
static void fitDimensionsRatio (Standard_Integer& theWidth,
Standard_Integer& theHeight,
const Standard_Real theViewRatio)
@ -214,11 +216,11 @@ static void fitDimensionsRatio (Standard_Integer& theWidth,
theHeight = (Standard_Integer)(theWidth/theViewRatio);
}
// ---------------------------------------------------------------
// Function: initBufferStretch
// Purpose: calculate initialization sizes for frame buffer
// when the stretch algorithm is selected
// ---------------------------------------------------------------
// =======================================================================
// function : initBufferStretch
// purpose : calculate initialization sizes for frame buffer
// when the stretch algorithm is selected
// =======================================================================
static void initBufferStretch (Standard_Integer& theFrameWidth,
Standard_Integer& theFrameHeight,
const int theViewWidth,
@ -246,11 +248,12 @@ static void initBufferStretch (Standard_Integer& theFrameWidth,
theFrameHeight = (Standard_Integer)(theFrameHeight/aHeightRate);
}
}
// ---------------------------------------------------------------
// Function: initBufferTiling
// Purpose: calculate initialization sizes for frame buffer
// when the tile algorithm is selected
// ---------------------------------------------------------------
// =======================================================================
// function : initBufferTiling
// purpose : calculate initialization sizes for frame buffer
// when the tile algorithm is selected
// =======================================================================
static void initBufferTiling (Standard_Integer& theFrameWidth,
Standard_Integer &theFrameHeight,
const int theViewWidth,
@ -266,36 +269,28 @@ static void initBufferTiling (Standard_Integer& theFrameWidth,
#endif /* _WIN32 */
// ---------------------------------------------------------------
// ---------------------------------------------------------------
//call_togl_print
Standard_Boolean OpenGl_Workspace::Print
(const Handle(OpenGl_PrinterContext)& thePrintContext,
const Graphic3d_CView& ACView,
const Aspect_Handle hPrintDC,// const Aspect_Drawable hPrintDC,
const Standard_Boolean showBackground,
const Standard_CString filename,
const Aspect_PrintAlgo printAlgorithm,
const Standard_Real theScaleFactor)
// =======================================================================
// function : Print
// purpose :
// =======================================================================
Standard_Boolean OpenGl_View::Print (const Aspect_Handle thePrinterDC,
const Standard_Boolean theToShowBackground,
const Standard_CString theFileName,
const Aspect_PrintAlgo thePrintAlgorithm,
const Standard_Real theScaleFactor)
{
if (thePrintContext.IsNull())
{
return Standard_False;
}
#ifdef _WIN32
if (!Activate())
if (!myWorkspace->Activate())
{
//MessageBox (NULL, "Print failed: can't setup the view for printing.",
// "The operation couldn't be completed.", MB_OK);
return Standard_False;
}
Handle(OpenGl_Context) aCtx = myWorkspace->GetGlContext();
// printer page dimensions
HDC hPrnDC = (HDC) hPrintDC;
HDC hPrnDC = (HDC) thePrinterDC;
int devWidth = GetDeviceCaps (hPrnDC, HORZRES);
int devHeight = GetDeviceCaps (hPrnDC, VERTRES);
@ -318,8 +313,8 @@ Standard_Boolean OpenGl_Workspace::Print
Standard_Integer tempHeight = (Standard_Integer) devHeight;
// view dimensions
int viewWidth = myWidth;
int viewHeight = myHeight;
int viewWidth = myWindow->Width();
int viewHeight = myWindow->Height();
if (viewWidth == 0 || viewHeight == 0)
{
//MessageBox (NULL, "Print failed: can't setup the view for printing.",
@ -348,11 +343,11 @@ Standard_Boolean OpenGl_Workspace::Print
// Frame buffer initialization
OpenGl_FrameBuffer* aFrameBuffer = NULL;
OpenGl_FrameBuffer* aPrevBuffer = (OpenGl_FrameBuffer*) ACView.ptrFBO;
OpenGl_FrameBuffer* aPrevBuffer = (OpenGl_FrameBuffer*)myFBO;
Standard_Integer aFrameWidth (0), aFrameHeight (0),
aPrevBufferX (0), aPrevBufferY (0);
bool IsTiling = (printAlgorithm == 1);
bool IsTiling = (thePrintAlgorithm == Aspect_PA_TILE);
// try to use existing frame buffer
if (aPrevBuffer)
@ -384,7 +379,7 @@ Standard_Boolean OpenGl_Workspace::Print
fipImage* anImagePtr = new fipImage (FIT_BITMAP, aFrameWidth,
aFrameHeight, 24);
// if allocated succesfully
// if allocated successfully
if (anImagePtr->isValid())
{
aViewImage = anImagePtr;
@ -445,14 +440,14 @@ Standard_Boolean OpenGl_Workspace::Print
initBufferTiling (aFrameWidth, aFrameHeight, width, height);
// try to initialize framebuffer
if (aFrameBuffer->Init (GetGlContext(), aFrameWidth, aFrameHeight))
if (aFrameBuffer->Init (aCtx, aFrameWidth, aFrameHeight))
{
#ifdef HAVE_FREEIMAGE
// try to allocate fipImage and necessary resources
fipImage* anImagePtr = new fipImage (FIT_BITMAP, aFrameWidth,
aFrameHeight, 24);
// if allocated succesfully
// if allocated successfully
if (anImagePtr->isValid())
{
aViewImage = anImagePtr;
@ -463,7 +458,7 @@ Standard_Boolean OpenGl_Workspace::Print
if (!aViewBuffer)
{
aFrameBuffer->Release (GetGlContext().operator->());
aFrameBuffer->Release (aCtx.operator->());
aViewBuffer = NULL;
aViewImage = NULL;
}
@ -477,7 +472,7 @@ Standard_Boolean OpenGl_Workspace::Print
{
if (hViewBitmap)
DeleteObject (hViewBitmap);
aFrameBuffer->Release (GetGlContext().operator->());
aFrameBuffer->Release (aCtx.operator->());
hViewBitmap = NULL;
}
else
@ -497,7 +492,7 @@ Standard_Boolean OpenGl_Workspace::Print
if (aMaxWidth <= 1 || aMaxHeight <= 1)
{
MessageBox (NULL, "Print failed: can't allocate buffer for printing.",
"The operation couldn't be completed.", MB_OK);
"The operation couldn't be completed.", MB_OK);
if (aFrameBuffer)
delete aFrameBuffer;
@ -511,11 +506,10 @@ Standard_Boolean OpenGl_Workspace::Print
}
// setup printing context and viewport
myPrintContext = thePrintContext;
myWorkspace->PrinterContext() = new OpenGl_PrinterContext();
myWorkspace->PrinterContext()->SetLayerViewport ((GLsizei )aFrameWidth, (GLsizei )aFrameHeight);
GLint aViewPortBack[4];
GLint anAlignBack = 1;
myPrintContext->SetLayerViewport ((GLsizei )aFrameWidth,
(GLsizei )aFrameHeight);
glGetIntegerv (GL_VIEWPORT, aViewPortBack);
glGetIntegerv (GL_PACK_ALIGNMENT, &anAlignBack);
glPixelStorei (GL_PACK_ALIGNMENT, 4);
@ -525,10 +519,10 @@ Standard_Boolean OpenGl_Workspace::Print
DOCINFO di;
if (GetObjectType (hPrnDC) == OBJ_DC)
{
// Initalize printing procedure
// Initialize printing procedure
di.cbSize = sizeof(DOCINFO);
di.lpszDocName = "Open Cascade Document - print v3d view";
di.lpszOutput = filename;
di.lpszOutput = theFileName;
// if can't print the document
if (StartDoc (hPrnDC, &di) <= 0 || StartPage (hPrnDC) <= 0)
@ -544,7 +538,7 @@ Standard_Boolean OpenGl_Workspace::Print
DeleteDC (hMemDC);
#endif
myPrintContext.Nullify();
myWorkspace->PrinterContext().Nullify();
return Standard_False;
}
}
@ -557,24 +551,25 @@ Standard_Boolean OpenGl_Workspace::Print
bool isDone = true;
// Set up status for printing
if (!showBackground)
NamedStatus |= OPENGL_NS_WHITEBACK;
if (!theToShowBackground)
{
myWorkspace->NamedStatus |= OPENGL_NS_WHITEBACK;
}
// switch to mono camera for image dump
const Graphic3d_Camera::Projection aProjectType = myView->Camera()->ProjectionType() != Graphic3d_Camera::Projection_Stereo
? myView->Camera()->ProjectionType()
const Graphic3d_Camera::Projection aProjectType = myCamera->ProjectionType() != Graphic3d_Camera::Projection_Stereo
? myCamera->ProjectionType()
: Graphic3d_Camera::Projection_Perspective;
if (!IsTiling)
{
myPrintContext->SetScale ((GLfloat )aFrameWidth /viewWidth,
(GLfloat )aFrameHeight/viewHeight);
redraw1 (ACView, aFrameBuffer, aProjectType);
myWorkspace->PrinterContext()->SetScale ((GLfloat )aFrameWidth /viewWidth, (GLfloat )aFrameHeight/viewHeight);
redraw (aProjectType, aFrameBuffer);
if (!myTransientDrawToFront)
{
// render to FBO only if allowed to render to back buffer
myBackBufferRestored = Standard_True;
myIsImmediateDrawn = Standard_False;
redrawImmediate (ACView, NULL, aProjectType, aFrameBuffer);
redrawImmediate (aProjectType, NULL, aFrameBuffer);
myBackBufferRestored = Standard_False;
myIsImmediateDrawn = Standard_False;
}
@ -631,8 +626,7 @@ Standard_Boolean OpenGl_Workspace::Print
// calculate and set the text scaling factor for printing context
GLfloat aScaleRatex = (GLfloat)aFrameWidth /viewWidth;
GLfloat aScaleRatey = (GLfloat)aFrameHeight/viewHeight;
myPrintContext->SetScale (aScaleRatex * (GLfloat )aScalex,
aScaleRatey * (GLfloat )aScaley);
myWorkspace->PrinterContext()->SetScale (aScaleRatex * (GLfloat )aScalex, aScaleRatey * (GLfloat )aScaley);
// initialize projection matrix for printer context
TColStd_Array2OfReal aProj (0, 3, 0, 3);
@ -674,7 +668,7 @@ Standard_Boolean OpenGl_Workspace::Print
// set projection matrix
aProj(0,0) = aScalex;
aProj(1,1) = aScaley;
myPrintContext->SetProjTransformation (aProj);
myWorkspace->PrinterContext()->SetProjTransformation (aProj);
// calculate cropped frame rect
aTop = (j == 0) ? aPxCropy : 0;
@ -682,13 +676,13 @@ Standard_Boolean OpenGl_Workspace::Print
aFrameHeight;
// draw to the offscreen buffer and capture the result
redraw1 (ACView, aFrameBuffer, aProjectType);
redraw (aProjectType, aFrameBuffer);
if (!myTransientDrawToFront)
{
// render to FBO only if forces to render to back buffer
myBackBufferRestored = Standard_True;
myIsImmediateDrawn = Standard_False;
redrawImmediate (ACView, NULL, aProjectType, aFrameBuffer);
redrawImmediate (aProjectType, NULL, aFrameBuffer);
myBackBufferRestored = Standard_False;
myIsImmediateDrawn = Standard_False;
}
@ -738,7 +732,7 @@ Standard_Boolean OpenGl_Workspace::Print
// return OpenGl to the previous state
glPixelStorei (GL_PACK_ALIGNMENT, anAlignBack);
aFrameBuffer->UnbindBuffer (GetGlContext());
aFrameBuffer->UnbindBuffer (aCtx);
glViewport (aViewPortBack[0], aViewPortBack[1],
aViewPortBack[2], aViewPortBack[3]);
if (aPrevBuffer)
@ -747,7 +741,7 @@ Standard_Boolean OpenGl_Workspace::Print
}
else
{
aFrameBuffer->Release (GetGlContext().operator->());
aFrameBuffer->Release (aCtx.operator->());
delete aFrameBuffer;
}
@ -762,13 +756,13 @@ Standard_Boolean OpenGl_Workspace::Print
#endif
// Reset status after printing
NamedStatus &= ~OPENGL_NS_WHITEBACK;
myPrintContext.Nullify();
myWorkspace->NamedStatus &= ~OPENGL_NS_WHITEBACK;
myWorkspace->PrinterContext().Nullify();
return (Standard_Boolean) isDone;
#else // not _WIN32
myPrintContext.Nullify();
Standard_NotImplemented::Raise ("OpenGl_View::Print is implemented only on Windows");
myWorkspace->PrinterContext().Nullify();
return Standard_False;
#endif
}

72
src/OpenGl/OpenGl_View_Raytrace.cxx
View File

@ -13,14 +13,11 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Graphic3d_TextureParams.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_FrameBuffer.hxx>
#include <Graphic3d_TextureParams.hxx>
#include <OpenGl_PrimitiveArray.hxx>
#include <OpenGl_VertexBuffer.hxx>
#include <OpenGl_View.hxx>
#include <Graphic3d_GraphicDriver.hxx>
#include <OSD_Protection.hxx>
#include <OSD_File.hxx>
@ -1234,7 +1231,7 @@ Handle(OpenGl_ShaderProgram) OpenGl_View::initProgram (const Handle(OpenGl_Conte
// function : initRaytraceResources
// purpose : Initializes OpenGL/GLSL shader programs
// =======================================================================
Standard_Boolean OpenGl_View::initRaytraceResources (const Graphic3d_CView& theCView, const Handle(OpenGl_Context)& theGlContext)
Standard_Boolean OpenGl_View::initRaytraceResources (const Handle(OpenGl_Context)& theGlContext)
{
if (myRaytraceInitStatus == OpenGl_RT_FAIL)
{
@ -1269,9 +1266,9 @@ Standard_Boolean OpenGl_View::initRaytraceResources (const Graphic3d_CView& theC
}
}
if (theCView.RenderParams.RaytracingDepth != myRaytraceParameters.NbBounces)
if (myRenderParams.RaytracingDepth != myRaytraceParameters.NbBounces)
{
myRaytraceParameters.NbBounces = theCView.RenderParams.RaytracingDepth;
myRaytraceParameters.NbBounces = myRenderParams.RaytracingDepth;
aToRebuildShaders = Standard_True;
}
@ -1281,15 +1278,15 @@ Standard_Boolean OpenGl_View::initRaytraceResources (const Graphic3d_CView& theC
aToRebuildShaders = Standard_True;
}
if (theCView.RenderParams.IsTransparentShadowEnabled != myRaytraceParameters.TransparentShadows)
if (myRenderParams.IsTransparentShadowEnabled != myRaytraceParameters.TransparentShadows)
{
myRaytraceParameters.TransparentShadows = theCView.RenderParams.IsTransparentShadowEnabled;
myRaytraceParameters.TransparentShadows = myRenderParams.IsTransparentShadowEnabled;
aToRebuildShaders = Standard_True;
}
if (theCView.RenderParams.IsGlobalIlluminationEnabled != myRaytraceParameters.GlobalIllumination)
if (myRenderParams.IsGlobalIlluminationEnabled != myRaytraceParameters.GlobalIllumination)
{
myRaytraceParameters.GlobalIllumination = theCView.RenderParams.IsGlobalIlluminationEnabled;
myRaytraceParameters.GlobalIllumination = myRenderParams.IsGlobalIlluminationEnabled;
aToRebuildShaders = Standard_True;
}
@ -1347,7 +1344,7 @@ Standard_Boolean OpenGl_View::initRaytraceResources (const Graphic3d_CView& theC
return safeFailBack ("Ray-tracing requires EXT_framebuffer_blit extension", theGlContext);
}
myRaytraceParameters.NbBounces = theCView.RenderParams.RaytracingDepth;
myRaytraceParameters.NbBounces = myRenderParams.RaytracingDepth;
TCollection_AsciiString aFolder = Graphic3d_ShaderProgram::ShadersFolder();
@ -2071,11 +2068,12 @@ Standard_Boolean OpenGl_View::updateRaytraceLightSources (const OpenGl_Mat4& the
myRaytraceGeometry.Ambient = BVH_Vec4f (0.0f, 0.0f, 0.0f, 0.0f);
for (OpenGl_ListOfLight::Iterator aLightIter (myLights); aLightIter.More(); aLightIter.Next())
OpenGl_ListOfLight::Iterator aLightIter (myShadingModel == Graphic3d_TOSM_NONE ? OpenGl_NoShadingLight() : myLights);
for (; aLightIter.More(); aLightIter.Next())
{
const OpenGl_Light& aLight = aLightIter.Value();
if (aLight.Type == Visual3d_TOLS_AMBIENT)
if (aLight.Type == Graphic3d_TOLS_AMBIENT)
{
myRaytraceGeometry.Ambient += BVH_Vec4f (aLight.Color.r() * aLight.Intensity,
aLight.Color.g() * aLight.Intensity,
@ -2094,7 +2092,7 @@ Standard_Boolean OpenGl_View::updateRaytraceLightSources (const OpenGl_Mat4& the
-aLight.Direction.z(),
0.0f);
if (aLight.Type != Visual3d_TOLS_DIRECTIONAL)
if (aLight.Type != Graphic3d_TOLS_DIRECTIONAL)
{
aPosition = BVH_Vec4f (aLight.Position.x(),
aLight.Position.y(),
@ -2168,7 +2166,7 @@ Standard_Boolean OpenGl_View::updateRaytraceEnvironmentMap (const Handle(OpenGl_
{
aResult &= theGlContext->BindProgram (aProgram);
if (!myTextureEnv.IsNull() && mySurfaceDetail != Visual3d_TOD_NONE)
if (!myTextureEnv.IsNull() && mySurfaceDetail != Graphic3d_TOD_NONE)
{
myTextureEnv->Bind (theGlContext,
GL_TEXTURE0 + OpenGl_RT_EnvironmentMapTexture);
@ -2195,8 +2193,7 @@ Standard_Boolean OpenGl_View::updateRaytraceEnvironmentMap (const Handle(OpenGl_
// function : setUniformState
// purpose : Sets uniform state for the given ray-tracing shader program
// =======================================================================
Standard_Boolean OpenGl_View::setUniformState (const Graphic3d_CView& theCView,
const OpenGl_Vec3* theOrigins,
Standard_Boolean OpenGl_View::setUniformState (const OpenGl_Vec3* theOrigins,
const OpenGl_Vec3* theDirects,
const OpenGl_Mat4& theUnviewMat,
const Standard_Integer theProgramId,
@ -2245,14 +2242,14 @@ Standard_Boolean OpenGl_View::setUniformState (const Graphic3d_CView& the
// Set run-time rendering options
theProgram->SetUniform (theGlContext,
myUniformLocations[theProgramId][OpenGl_RT_uShadowsEnabled], theCView.RenderParams.IsShadowEnabled ? 1 : 0);
myUniformLocations[theProgramId][OpenGl_RT_uShadowsEnabled], myRenderParams.IsShadowEnabled ? 1 : 0);
theProgram->SetUniform (theGlContext,
myUniformLocations[theProgramId][OpenGl_RT_uReflectEnabled], theCView.RenderParams.IsReflectionEnabled ? 1 : 0);
myUniformLocations[theProgramId][OpenGl_RT_uReflectEnabled], myRenderParams.IsReflectionEnabled ? 1 : 0);
if (theCView.RenderParams.IsGlobalIlluminationEnabled)
if (myRenderParams.IsGlobalIlluminationEnabled)
{
theProgram->SetUniform (theGlContext,
myUniformLocations[theProgramId][OpenGl_RT_uBlockedRngEnabled], theCView.RenderParams.CoherentPathTracingMode ? 1 : 0);
myUniformLocations[theProgramId][OpenGl_RT_uBlockedRngEnabled], myRenderParams.CoherentPathTracingMode ? 1 : 0);
}
// Set array of 64-bit texture handles
@ -2275,9 +2272,9 @@ Standard_Boolean OpenGl_View::setUniformState (const Graphic3d_CView& the
}
else
{
const OpenGl_Vec4 aBackColor (theCView.DefWindow.Background.r,
theCView.DefWindow.Background.g,
theCView.DefWindow.Background.b,
const OpenGl_Vec4 aBackColor (myBgColor.rgb[0],
myBgColor.rgb[1],
myBgColor.rgb[2],
1.0f);
theProgram->SetUniform (theGlContext,
myUniformLocations[theProgramId][OpenGl_RT_uBackColorTop], aBackColor);
@ -2286,7 +2283,7 @@ Standard_Boolean OpenGl_View::setUniformState (const Graphic3d_CView& the
}
theProgram->SetUniform (theGlContext,
myUniformLocations[theProgramId][OpenGl_RT_uSphereMapForBack], theCView.RenderParams.UseEnvironmentMapBackground ? 1 : 0);
myUniformLocations[theProgramId][OpenGl_RT_uSphereMapForBack], myRenderParams.UseEnvironmentMapBackground ? 1 : 0);
return Standard_True;
}
@ -2345,8 +2342,7 @@ void OpenGl_View::unbindRaytraceTextures (const Handle(OpenGl_Context)& theGlCon
// function : runRaytraceShaders
// purpose : Runs ray-tracing shader programs
// =======================================================================
Standard_Boolean OpenGl_View::runRaytraceShaders (const Graphic3d_CView& theCView,
const Standard_Integer theSizeX,
Standard_Boolean OpenGl_View::runRaytraceShaders (const Standard_Integer theSizeX,
const Standard_Integer theSizeY,
const OpenGl_Vec3* theOrigins,
const OpenGl_Vec3* theDirects,
@ -2381,7 +2377,7 @@ Standard_Boolean OpenGl_View::runRaytraceShaders (const Graphic3d_CView&
aRenderFramebuffer->BindBuffer (theGlContext);
}
else if (theCView.RenderParams.IsAntialiasingEnabled) // if 2-pass ray-tracing is used
else if (myRenderParams.IsAntialiasingEnabled) // if 2-pass ray-tracing is used
{
myRaytraceFBO1->BindBuffer (theGlContext);
@ -2390,8 +2386,7 @@ Standard_Boolean OpenGl_View::runRaytraceShaders (const Graphic3d_CView&
Standard_Boolean aResult = theGlContext->BindProgram (myRaytraceProgram);
aResult &= setUniformState (theCView,
theOrigins,
aResult &= setUniformState (theOrigins,
theDirects,
theUnviewMat,
0, // ID of RT program
@ -2438,14 +2433,13 @@ Standard_Boolean OpenGl_View::runRaytraceShaders (const Graphic3d_CView&
++myAccumFrames;
}
else if (theCView.RenderParams.IsAntialiasingEnabled)
else if (myRenderParams.IsAntialiasingEnabled)
{
myRaytraceFBO1->ColorTexture()->Bind (theGlContext, GL_TEXTURE0 + OpenGl_RT_FsaaInputTexture);
aResult &= theGlContext->BindProgram (myPostFSAAProgram);
aResult &= setUniformState (theCView,
theOrigins,
aResult &= setUniformState (theOrigins,
theDirects,
theUnviewMat,
1, // ID of FSAA program
@ -2521,13 +2515,12 @@ Standard_Boolean OpenGl_View::runRaytraceShaders (const Graphic3d_CView&
// function : raytrace
// purpose : Redraws the window using OpenGL/GLSL ray-tracing
// =======================================================================
Standard_Boolean OpenGl_View::raytrace (const Graphic3d_CView& theCView,
const Standard_Integer theSizeX,
Standard_Boolean OpenGl_View::raytrace (const Standard_Integer theSizeX,
const Standard_Integer theSizeY,
OpenGl_FrameBuffer* theReadDrawFbo,
const Handle(OpenGl_Context)& theGlContext)
{
if (!initRaytraceResources (theCView, theGlContext))
if (!initRaytraceResources (theGlContext))
{
return Standard_False;
}
@ -2582,8 +2575,7 @@ Standard_Boolean OpenGl_View::raytrace (const Graphic3d_CView& theCView,
0, GL_DEBUG_SEVERITY_MEDIUM_ARB, "Error: Failed to acquire OpenGL image textures");
}
Standard_Boolean aResult = runRaytraceShaders (theCView,
theSizeX,
Standard_Boolean aResult = runRaytraceShaders (theSizeX,
theSizeY,
aOrigins,
aDirects,

1781
src/OpenGl/OpenGl_View_Redraw.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

139
src/OpenGl/OpenGl_Window.cxx
View File

@ -131,20 +131,16 @@ namespace
// purpose :
// =======================================================================
OpenGl_Window::OpenGl_Window (const Handle(OpenGl_GraphicDriver)& theDriver,
const CALL_DEF_WINDOW& theCWindow,
const Handle(Aspect_Window)& thePlatformWindow,
Aspect_RenderingContext theGContext,
const Handle(OpenGl_Caps)& theCaps,
const Handle(OpenGl_Context)& theShareCtx)
: myGlContext (new OpenGl_Context (theCaps)),
myOwnGContext (theGContext == 0),
myWidth (theCWindow.dx),
myHeight (theCWindow.dy),
myPlatformWindow (thePlatformWindow),
mySwapInterval (theCaps->swapInterval)
{
myBgColor.rgb[0] = theCWindow.Background.r;
myBgColor.rgb[1] = theCWindow.Background.g;
myBgColor.rgb[2] = theCWindow.Background.b;
myBgColor.rgb[3] = 1.0f;
myPlatformWindow->Size (myWidth, myHeight);
Standard_Boolean isCoreProfile = Standard_False;
@ -164,7 +160,10 @@ OpenGl_Window::OpenGl_Window (const Handle(OpenGl_GraphicDriver)& theDriver,
if (theGContext == (EGLContext )EGL_NO_CONTEXT)
{
// create new surface
anEglSurf = eglCreateWindowSurface (anEglDisplay, anEglConfig, (EGLNativeWindowType )theCWindow.XWindow, NULL);
anEglSurf = eglCreateWindowSurface (anEglDisplay,
anEglConfig,
(EGLNativeWindowType )myPlatformWindow->NativeHandle(),
NULL);
if (anEglSurf == EGL_NO_SURFACE)
{
Aspect_GraphicDeviceDefinitionError::Raise ("OpenGl_Window, EGL is unable to create surface for window!");
@ -189,7 +188,7 @@ OpenGl_Window::OpenGl_Window (const Handle(OpenGl_GraphicDriver)& theDriver,
myGlContext->Init ((Aspect_Drawable )anEglSurf, (Aspect_Display )anEglDisplay, (Aspect_RenderingContext )anEglContext, isCoreProfile);
#elif defined(_WIN32)
(void )theDriver;
HWND aWindow = (HWND )theCWindow.XWindow;
HWND aWindow = (HWND )myPlatformWindow->NativeHandle();
HDC aWindowDC = GetDC (aWindow);
HGLRC aGContext = (HGLRC )theGContext;
@ -438,7 +437,7 @@ OpenGl_Window::OpenGl_Window (const Handle(OpenGl_GraphicDriver)& theDriver,
myGlContext->Init ((Aspect_Handle )aWindow, (Aspect_Handle )aWindowDC, (Aspect_RenderingContext )aGContext, isCoreProfile);
#else
Window aParent = (Window )theCWindow.XWindow;
Window aParent = (Window )myPlatformWindow->NativeHandle();
Window aWindow = 0;
Display* aDisp = theDriver->GetDisplayConnection()->GetDisplay();
@ -634,10 +633,11 @@ OpenGl_Window::OpenGl_Window (const Handle(OpenGl_GraphicDriver)& theDriver,
Colormap cmap = XCreateColormap (aDisp, aParent, aVis->visual, AllocNone);
Quantity_Color aBgColor = myPlatformWindow->Background().Color();
XColor color;
color.red = (unsigned short) (myBgColor.rgb[0] * 0xFFFF);
color.green = (unsigned short) (myBgColor.rgb[1] * 0xFFFF);
color.blue = (unsigned short) (myBgColor.rgb[2] * 0xFFFF);
color.red = (unsigned short) (aBgColor.Red() * 0xFFFF);
color.green = (unsigned short) (aBgColor.Green() * 0xFFFF);
color.blue = (unsigned short) (aBgColor.Blue() * 0xFFFF);
color.flags = DoRed | DoGreen | DoBlue;
XAllocColor (aDisp, cmap, &color);
@ -751,7 +751,7 @@ Standard_Boolean OpenGl_Window::Activate()
// function : Resize
// purpose : call_subr_resize
// =======================================================================
void OpenGl_Window::Resize (const CALL_DEF_WINDOW& theCWindow)
void OpenGl_Window::Resize()
{
#if !defined(_WIN32) && !defined(HAVE_EGL) && !defined(__ANDROID__)
Display* aDisp = (Display* )myGlContext->myDisplay;
@ -759,12 +759,16 @@ void OpenGl_Window::Resize (const CALL_DEF_WINDOW& theCWindow)
return;
#endif
Standard_Integer aWidth = 0;
Standard_Integer aHeight = 0;
myPlatformWindow->Size (aWidth, aHeight);
// If the size is not changed - do nothing
if ((myWidth == theCWindow.dx) && (myHeight == theCWindow.dy))
if ((myWidth == aWidth) && (myHeight == aHeight))
return;
myWidth = theCWindow.dx;
myHeight = theCWindow.dy;
myWidth = aWidth;
myHeight = aHeight;
#if !defined(_WIN32) && !defined(HAVE_EGL) && !defined(__ANDROID__)
XResizeWindow (aDisp, myGlContext->myWindow, (unsigned int )myWidth, (unsigned int )myHeight);
@ -802,9 +806,9 @@ void OpenGl_Window::ReadDepths (const Standard_Integer theX, const Standard_
#if !defined(GL_ES_VERSION_2_0)
glRasterPos2i (theX, theY);
DisableFeatures();
myGlContext->DisableFeatures();
glReadPixels (theX, theY, theWidth, theHeight, GL_DEPTH_COMPONENT, GL_FLOAT, theDepths);
EnableFeatures();
myGlContext->EnableFeatures();
#endif
myGlContext->WorldViewState.Pop();
@ -813,19 +817,6 @@ void OpenGl_Window::ReadDepths (const Standard_Integer theX, const Standard_
myGlContext->ApplyProjectionMatrix();
}
// =======================================================================
// function : SetBackgroundColor
// purpose : call_subr_set_background
// =======================================================================
void OpenGl_Window::SetBackgroundColor (const Standard_ShortReal theR,
const Standard_ShortReal theG,
const Standard_ShortReal theB)
{
myBgColor.rgb[0] = theR;
myBgColor.rgb[1] = theG;
myBgColor.rgb[2] = theB;
}
#if !defined(__APPLE__) || defined(MACOSX_USE_GLX)
// =======================================================================
@ -866,87 +857,17 @@ void OpenGl_Window::Init()
#endif
}
#endif // !__APPLE__
// =======================================================================
// function : EnableFeatures
// function : SetSwapInterval
// purpose :
// =======================================================================
void OpenGl_Window::EnableFeatures() const
void OpenGl_Window::SetSwapInterval()
{
//
}
// =======================================================================
// function : DisableFeatures
// purpose :
// =======================================================================
void OpenGl_Window::DisableFeatures() const
{
#if !defined(GL_ES_VERSION_2_0)
glPixelTransferi (GL_MAP_COLOR, GL_FALSE);
#endif
/*
* Disable stuff that's likely to slow down glDrawPixels.
* (Omit as much of this as possible, when you know in advance
* that the OpenGL state will already be set correctly.)
*/
glDisable(GL_DITHER);
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glDisable(GL_TEXTURE_2D);
glDisable(GL_STENCIL_TEST);
#if !defined(GL_ES_VERSION_2_0)
glDisable(GL_LIGHTING);
glDisable(GL_ALPHA_TEST);
glDisable(GL_FOG);
glDisable(GL_LOGIC_OP);
glDisable(GL_TEXTURE_1D);
glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
glPixelTransferi(GL_RED_SCALE, 1);
glPixelTransferi(GL_RED_BIAS, 0);
glPixelTransferi(GL_GREEN_SCALE, 1);
glPixelTransferi(GL_GREEN_BIAS, 0);
glPixelTransferi(GL_BLUE_SCALE, 1);
glPixelTransferi(GL_BLUE_BIAS, 0);
glPixelTransferi(GL_ALPHA_SCALE, 1);
glPixelTransferi(GL_ALPHA_BIAS, 0);
/*
* Disable extensions that could slow down glDrawPixels.
* (Actually, you should check for the presence of the proper
* extension before making these calls. I've omitted that
* code for simplicity.)
*/
if ((myGlContext->myGlVerMajor >= 1) && (myGlContext->myGlVerMinor >= 2))
if (mySwapInterval != myGlContext->caps->swapInterval)
{
#ifdef GL_EXT_convolution
if (myGlContext->CheckExtension ("GL_CONVOLUTION_1D_EXT"))
glDisable(GL_CONVOLUTION_1D_EXT);
if (myGlContext->CheckExtension ("GL_CONVOLUTION_2D_EXT"))
glDisable(GL_CONVOLUTION_2D_EXT);
if (myGlContext->CheckExtension ("GL_SEPARABLE_2D_EXT"))
glDisable(GL_SEPARABLE_2D_EXT);
#endif
#ifdef GL_EXT_histogram
if (myGlContext->CheckExtension ("GL_SEPARABLE_2D_EXT"))
glDisable(GL_HISTOGRAM_EXT);
if (myGlContext->CheckExtension ("GL_MINMAX_EXT"))
glDisable(GL_MINMAX_EXT);
#endif
#ifdef GL_EXT_texture3D
if (myGlContext->CheckExtension ("GL_TEXTURE_3D_EXT"))
glDisable(GL_TEXTURE_3D_EXT);
#endif
mySwapInterval = myGlContext->caps->swapInterval;
myGlContext->SetSwapInterval (mySwapInterval);
}
#endif
}
#endif // !__APPLE__

21
src/OpenGl/OpenGl_Window.hxx
View File

@ -16,12 +16,12 @@
#ifndef _OpenGl_Window_Header
#define _OpenGl_Window_Header
#include <Aspect_RenderingContext.hxx>
#include <Aspect_Window.hxx>
#include <OpenGl_GlCore11.hxx>
#include <InterfaceGraphic_Aspect.hxx>
#include <OpenGl_Caps.hxx>
#include <MMgt_TShared.hxx>
#if defined(__APPLE__)
#import <TargetConditionals.h>
#endif
@ -48,7 +48,7 @@ public:
//! Main constructor - prepare GL context for specified window.
Standard_EXPORT OpenGl_Window (const Handle(OpenGl_GraphicDriver)& theDriver,
const CALL_DEF_WINDOW& theCWindow,
const Handle(Aspect_Window)& thePlatformWindow,
Aspect_RenderingContext theGContext,
const Handle(OpenGl_Caps)& theCaps,
const Handle(OpenGl_Context)& theShareCtx);
@ -57,38 +57,34 @@ public:
Standard_EXPORT virtual ~OpenGl_Window();
//! Resizes the window.
Standard_EXPORT virtual void Resize (const CALL_DEF_WINDOW& theCWindow);
Standard_EXPORT virtual void Resize();
//! Reads depth component for current scene into specified buffer.
void ReadDepths (const Standard_Integer theX, const Standard_Integer theY,
const Standard_Integer theWidth, const Standard_Integer theHeight,
float* theDepths);
Standard_EXPORT void SetBackgroundColor (const Standard_ShortReal theR,
const Standard_ShortReal theG,
const Standard_ShortReal theB);
Handle(Aspect_Window) PlatformWindow() { return myPlatformWindow; }
Standard_Integer Width() const { return myWidth; }
Standard_Integer Height() const { return myHeight; }
const TEL_COLOUR& BackgroundColor() const { return myBgColor; }
const Handle(OpenGl_Context)& GetGlContext() const { return myGlContext; }
protected:
//! Activates GL context and setup viewport.
Standard_EXPORT void Init();
//! Makes GL context for this window active in current thread
Standard_EXPORT virtual Standard_Boolean Activate();
Standard_EXPORT void EnableFeatures() const;
Standard_EXPORT void DisableFeatures() const;
//! Sets swap interval for this window according to the context's settings.
Standard_EXPORT void SetSwapInterval();
protected:
Handle(OpenGl_Context) myGlContext;
Standard_Boolean myOwnGContext; //!< set to TRUE if GL context was not created by this class
Handle(Aspect_Window) myPlatformWindow; //!< software platform window wrapper
#if defined(__APPLE__)
#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
UIView* myUIView;
@ -98,7 +94,6 @@ protected:
#endif
Standard_Integer myWidth; //!< window width in pixels
Standard_Integer myHeight; //!< window height in pixels
TEL_COLOUR myBgColor; //!< background color
Standard_Integer mySwapInterval;//!< last assigned swap interval (VSync) for this window

51
src/OpenGl/OpenGl_Window_1.mm
View File

@ -54,33 +54,30 @@
// purpose :
// =======================================================================
OpenGl_Window::OpenGl_Window (const Handle(OpenGl_GraphicDriver)& theDriver,
const CALL_DEF_WINDOW& theCWindow,
const Handle(Aspect_Window)& thePlatformWindow,
Aspect_RenderingContext theGContext,
const Handle(OpenGl_Caps)& theCaps,
const Handle(OpenGl_Context)& theShareCtx)
: myGlContext (new OpenGl_Context (theCaps)),
myOwnGContext (theGContext == 0),
#if defined(__APPLE__)
#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
myPlatformWindow (thePlatformWindow),
#if defined(__APPLE__) && defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
myUIView (NULL),
#endif
myWidthPt (theCWindow.dx),
myHeightPt (theCWindow.dy),
#endif
myWidth (theCWindow.dx),
myHeight (theCWindow.dy),
mySwapInterval (theCaps->swapInterval)
{
myBgColor.rgb[0] = theCWindow.Background.r;
myBgColor.rgb[1] = theCWindow.Background.g;
myBgColor.rgb[2] = theCWindow.Background.b;
myBgColor.rgb[3] = 1.0f;
myPlatformWindow->Size (myWidth, myHeight);
#if defined(__APPLE__)
myWidthPt = myWidth;
myHeightPt = myHeight;
#endif
#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE
EAGLContext* aGLContext = theGContext;
if (aGLContext == NULL)
{
void* aViewPtr = (void* )theCWindow.XWindow;
void* aViewPtr = (void* )myPlatformWindow->NativeHandle();
myUIView = (__bridge UIView* )aViewPtr;
CAEAGLLayer* anEaglLayer = (CAEAGLLayer* )myUIView.layer;
@ -204,7 +201,7 @@ OpenGl_Window::OpenGl_Window (const Handle(OpenGl_GraphicDriver)& theDriver,
myGlContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB, GL_DEBUG_TYPE_PORTABILITY_ARB, 0, GL_DEBUG_SEVERITY_LOW_ARB, aMsg);
}
NSView* aView = (NSView* )theCWindow.XWindow;
NSView* aView = (NSView* )myPlatformWindow->NativeHandle();
[aGLContext setView: aView];
isCore = (aTryCore == 1);
}
@ -248,17 +245,20 @@ OpenGl_Window::~OpenGl_Window()
// function : Resize
// purpose : call_subr_resize
// =======================================================================
void OpenGl_Window::Resize (const CALL_DEF_WINDOW& theCWindow)
void OpenGl_Window::Resize()
{
// If the size is not changed - do nothing
if (myWidthPt == theCWindow.dx
&& myHeightPt == theCWindow.dy)
Standard_Integer aWidthPt = 0;
Standard_Integer aHeightPt = 0;
myPlatformWindow->Size (aWidthPt, aHeightPt);
if (myWidthPt == aWidthPt
&& myHeightPt == aHeightPt)
{
return;
}
myWidthPt = theCWindow.dx;
myHeightPt = theCWindow.dy;
myWidthPt = aWidthPt;
myHeightPt = aHeightPt;
Init();
}
@ -354,4 +354,17 @@ void OpenGl_Window::Init()
#endif
}
// =======================================================================
// function : SetSwapInterval
// purpose :
// =======================================================================
void OpenGl_Window::SetSwapInterval()
{
if (mySwapInterval != myGlContext->caps->swapInterval)
{
mySwapInterval = myGlContext->caps->swapInterval;
myGlContext->SetSwapInterval (mySwapInterval);
}
}
#endif // __APPLE__

1608
src/OpenGl/OpenGl_Workspace.cxx
View File

File diff suppressed because it is too large Load Diff

193
src/OpenGl/OpenGl_Workspace.hxx
View File

@ -16,51 +16,29 @@
#ifndef _OpenGl_Workspace_Header
#define _OpenGl_Workspace_Header
#include <map>
#include <set>
#include <OpenGl_Window.hxx>
#include <TColStd_Array2OfReal.hxx>
#include <Quantity_Color.hxx>
#include <Graphic3d_CView.hxx>
#include <Graphic3d_TypeOfComposition.hxx>
#include <Graphic3d_TypeOfTexture.hxx>
#include <Graphic3d_PtrFrameBuffer.hxx>
#include <Graphic3d_BufferType.hxx>
#include <Aspect_Handle.hxx>
#include <Aspect_PrintAlgo.hxx>
#include <Aspect_PolygonOffsetMode.hxx>
#include <InterfaceGraphic_Graphic3d.hxx>
#include <InterfaceGraphic_Visual3d.hxx>
#include <NCollection_Sequence.hxx>
#include <OpenGl_AspectFace.hxx>
#include <OpenGl_CappingAlgo.hxx>
#include <OpenGl_FrameBuffer.hxx>
#include <OpenGl_LineAttributes.hxx>
#include <OpenGl_Matrix.hxx>
#include <OpenGl_NamedStatus.hxx>
#include <OpenGl_PrinterContext.hxx>
#include <OpenGl_SceneGeometry.hxx>
#include <OpenGl_TextParam.hxx>
#include <OpenGl_RenderFilter.hxx>
#include <OpenGl_Vec.hxx>
#include <OpenGl_LineAttributes.hxx>
#include <OpenGl_CappingAlgo.hxx>
#include <OpenGl_ShaderObject.hxx>
#include <OpenGl_ShaderProgram.hxx>
#include <OpenGl_TextParam.hxx>
#include <OpenGl_TextureBufferArb.hxx>
#include <OpenGl_Vec.hxx>
#include <OpenGl_Window.hxx>
class OpenGl_AspectLine;
class OpenGl_AspectMarker;
class OpenGl_AspectText;
class OpenGl_FrameBuffer;
class OpenGl_Structure;
class OpenGl_TriangleSet;
class OpenGl_Element;
class OpenGl_View;
class Image_PixMap;
@ -129,66 +107,39 @@ public:
};
class OpenGl_Workspace;
DEFINE_STANDARD_HANDLE(OpenGl_Workspace,OpenGl_Window)
DEFINE_STANDARD_HANDLE(OpenGl_Workspace,Standard_Transient)
//! Represents window with GL context.
//! Rendering workspace.
//! Provides methods to render primitives and maintain GL state.
class OpenGl_Workspace : public OpenGl_Window
class OpenGl_Workspace : public Standard_Transient
{
public:
//! Main constructor - prepare GL context for specified window.
Standard_EXPORT OpenGl_Workspace (const Handle(OpenGl_GraphicDriver)& theDriver,
const CALL_DEF_WINDOW& theCWindow,
Aspect_RenderingContext theGContext,
const Handle(OpenGl_Caps)& theCaps,
const Handle(OpenGl_Context)& theShareCtx);
//! Constructor of rendering workspace.
Standard_EXPORT OpenGl_Workspace (OpenGl_View* theView, const Handle(OpenGl_Window)& theWindow);
//! Destructor
Standard_EXPORT virtual ~OpenGl_Workspace();
Standard_EXPORT void SetActiveView (const Handle(OpenGl_View)& theView,
const Standard_Integer theViewId);
//! Activate rendering context.
Standard_EXPORT Standard_Boolean Activate();
const Handle(OpenGl_View)& ActiveView() const { return myView; }
OpenGl_View* View() const { return myView; }
Standard_Integer ActiveViewId() const { return myViewId; }
const Handle(OpenGl_Context)& GetGlContext() { return myGlContext; }
//! Redraw the window.
Standard_EXPORT virtual void Redraw (const Graphic3d_CView& theCView);
Standard_EXPORT Graphic3d_PtrFrameBuffer FBOCreate (const Standard_Integer theWidth, const Standard_Integer theHeight);
Standard_Boolean SetImmediateModeDrawToFront (const Standard_Boolean theDrawToFrontBuffer);
Standard_EXPORT virtual void RedrawImmediate (const Graphic3d_CView& theCView);
Standard_EXPORT void FBORelease (Graphic3d_PtrFrameBuffer theFBOPtr);
//! Mark cached view content invalid (e.g. complete view redraw should be performed on next frame).
void Invalidate() { myBackBufferRestored = Standard_False; }
//! Return true if view content cache has been invalidated.
Standard_Boolean IsInvalidated() const { return !myBackBufferRestored; }
//! Special method to perform printing.
//! System-specific and currently only Win platform implemented.
Standard_Boolean Print (const Handle(OpenGl_PrinterContext)& thePrintContext,
const Graphic3d_CView& theCView,
const Aspect_Handle theHPrintDC,
const Standard_Boolean theToShowBackground,
const Standard_CString theFileName,
const Aspect_PrintAlgo thePrintAlgorithm,
const Standard_Real theScaleFactor);
const Handle(OpenGl_PrinterContext)& PrinterContext() const
{
return myPrintContext;
}
void DisplayCallback (const Graphic3d_CView& theCView, int theReason);
Graphic3d_PtrFrameBuffer FBOCreate (const Standard_Integer theWidth, const Standard_Integer theHeight);
void FBORelease (Graphic3d_PtrFrameBuffer theFBOPtr);
Standard_Boolean BufferDump (OpenGl_FrameBuffer* theFBOPtr,
Image_PixMap& theImage,
const Graphic3d_BufferType& theBufferType);
Standard_EXPORT Standard_Integer Width() const;
Standard_EXPORT Standard_Integer Height() const;
//! Setup Z-buffer usage flag (without affecting GL state!).
//! Returns previously set flag.
Standard_Boolean SetUseZBuffer (const Standard_Boolean theToUse)
@ -198,16 +149,27 @@ public:
return wasUsed;
}
Standard_Boolean& UseZBuffer() { return myUseZBuffer; }
Standard_Boolean& UseDepthWrite() { return myUseDepthWrite; }
Standard_Boolean& UseGLLight() { return myUseGLLight; }
Handle(OpenGl_PrinterContext)& PrinterContext() { return myPrintContext; }
Standard_Integer AntiAliasingMode() const { return myAntiAliasingMode; }
//! @return true if usage of Z buffer is enabled.
Standard_Boolean& UseZBuffer() { return myUseZBuffer; }
//! @return true if depth writing is enabled.
Standard_Boolean& UseDepthWrite() { return myUseDepthWrite; }
//! @return true if usage of GL light is enabled.
Standard_EXPORT Standard_Boolean UseGLLight() const;
//! @return true if antialiasing is enabled.
Standard_EXPORT Standard_Integer AntiAliasingMode() const;
//! @return true if clipping algorithm enabled
Standard_EXPORT Standard_Boolean IsCullingEnabled() const;
Standard_Integer NamedStatus;
//// RELATED TO STATUS ////
Standard_Integer NamedStatus;
const TEL_COLOUR* HighlightColor;
const OpenGl_AspectLine* SetAspectLine (const OpenGl_AspectLine* theAspect);
@ -263,9 +225,6 @@ public:
//! Returns currently applied polygon offset params.
const TEL_POFFSET_PARAM& AppliedPolygonOffset() { return PolygonOffset_applied; }
//! @return true if clipping algorithm enabled
inline Standard_Boolean IsCullingEnabled() const { return myIsCullingEnabled; }
//! Returns capping algorithm rendering filter.
const Handle(OpenGl_CappingAlgoFilter)& DefaultCappingAlgoFilter() const
{
@ -286,43 +245,6 @@ public:
protected:
//! Copy content of Back buffer to the Front buffer
void copyBackToFront();
//! Initialize blit quad.
Standard_EXPORT OpenGl_VertexBuffer* initBlitQuad (const Standard_Boolean theToFlip);
//! Blit image from/to specified buffers.
Standard_EXPORT bool blitBuffers (OpenGl_FrameBuffer* theReadFbo,
OpenGl_FrameBuffer* theDrawFbo,
const Standard_Boolean theToFlip = Standard_False);
Standard_EXPORT virtual Standard_Boolean Activate();
void redraw1 (const Graphic3d_CView& theCView,
OpenGl_FrameBuffer* theReadDrawFbo,
const Graphic3d_Camera::Projection theProjection);
//! Setup default FBO.
void bindDefaultFbo (OpenGl_FrameBuffer* theCustomFbo = NULL);
//! Blend together views pair into stereo image.
void drawStereoPair (const Graphic3d_CView& theCView);
//! Blit snapshot containing main scene (myMainSceneFbos or BackBuffer)
//! into presentation buffer (myMainSceneFbos -> offscreen FBO or myMainSceneFbos -> BackBuffer or BackBuffer -> FrontBuffer),
//! and redraw immediate structures on top.
//!
//! When scene caching is disabled (myTransientDrawToFront, no double buffer in window, etc.),
//! the first step (blitting) will be skipped.
//!
//! @return false if immediate structures has been rendered directly into FrontBuffer and Buffer Swap should not be called.
bool redrawImmediate (const Graphic3d_CView& theCView,
OpenGl_FrameBuffer* theReadFbo,
const Graphic3d_Camera::Projection theProjection,
OpenGl_FrameBuffer* theDrawFbo,
const Standard_Boolean theIsPartialUpdate = Standard_False);
void updateMaterial (const int theFlag);
void setTextureParams (Handle(OpenGl_Texture)& theTexture,
@ -330,36 +252,15 @@ protected:
protected: //! @name protected fields
//! Two framebuffers (left and right views) store cached main presentation
//! of the view (without presentation of immediate layers).
Handle(OpenGl_FrameBuffer) myMainSceneFbos[2];
//! Additional buffers for immediate layer in stereo mode.
Handle(OpenGl_FrameBuffer) myImmediateSceneFbos[2];
//! Special flag which is invalidated when myMainSceneFbos can not be blitted for some reason (e.g. driver bugs).
Standard_Boolean myHasFboBlit;
//! Flag to draw result image upside-down
Standard_Boolean myToFlipOutput;
//! Vertices for full-screen quad rendering.
OpenGl_VertexBuffer myFullScreenQuad;
OpenGl_VertexBuffer myFullScreenQuadFlip;
Handle(OpenGl_PrinterContext) myPrintContext;
Handle(OpenGl_View) myView;
Handle(OpenGl_LineAttributes) myLineAttribs;
Standard_Integer myViewId;
Standard_Integer myAntiAliasingMode;
Standard_Boolean myTransientDrawToFront; //!< optimization flag for immediate mode (to render directly to the front buffer)
Standard_Boolean myBackBufferRestored;
Standard_Boolean myIsImmediateDrawn; //!< flag indicates that immediate mode buffer contains some data
Standard_Boolean myUseZBuffer;
Standard_Boolean myUseDepthWrite;
Standard_Boolean myUseGLLight;
Standard_Boolean myIsCullingEnabled; //!< frustum culling flag
unsigned int myFrameCounter; //!< redraw counter, for debugging
OpenGl_View* myView;
Handle(OpenGl_Window) myWindow;
Handle(OpenGl_Context) myGlContext;
Handle(OpenGl_PrinterContext) myPrintContext;
Handle(OpenGl_LineAttributes) myLineAttribs;
Standard_Integer myAntiAliasingMode;
Standard_Boolean myUseZBuffer;
Standard_Boolean myUseDepthWrite;
Standard_Boolean myUseGLLight;
Handle(OpenGl_CappingAlgoFilter) myDefaultCappingAlgoFilter;
OpenGl_AspectFace myNoneCulling;
OpenGl_AspectFace myFrontCulling;
@ -391,7 +292,7 @@ protected: //! @name fields related to status
public: //! @name type definition
DEFINE_STANDARD_RTTI(OpenGl_Workspace, OpenGl_Window)
DEFINE_STANDARD_RTTI(OpenGl_Workspace, Standard_Transient)
DEFINE_STANDARD_ALLOC
};

461
src/OpenGl/OpenGl_Workspace_5.cxx
View File

@ -1,461 +0,0 @@
// Created on: 2011-08-05
// Created by: Sergey ZERCHANINOV
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <OpenGl_GlCore11.hxx>
#include <OpenGl_Workspace.hxx>
#include <OpenGl_AspectLine.hxx>
#include <OpenGl_AspectFace.hxx>
#include <OpenGl_AspectMarker.hxx>
#include <OpenGl_AspectText.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_ShaderManager.hxx>
#include <OpenGl_telem_util.hxx>
#include <Graphic3d_GraphicDriver.hxx>
#include <Aspect_PolygonOffsetMode.hxx>
#include <OpenGl_View.hxx>
#ifdef HAVE_GL2PS
#include <gl2ps.h>
/* OCC22216 NOTE: linker dependency can be switched off by undefining macro.
Pragma comment for gl2ps.lib is defined only here. */
#ifdef _MSC_VER
#pragma comment( lib, "gl2ps.lib" )
#endif
#endif
/*----------------------------------------------------------------------*/
static void TelUpdatePolygonOffsets (const TEL_POFFSET_PARAM& theOffsetData)
{
if ((theOffsetData.mode & Aspect_POM_Fill) == Aspect_POM_Fill)
{
glEnable (GL_POLYGON_OFFSET_FILL);
}
else
{
glDisable (GL_POLYGON_OFFSET_FILL);
}
#if !defined(GL_ES_VERSION_2_0)
if ((theOffsetData.mode & Aspect_POM_Line) == Aspect_POM_Line)
{
glEnable (GL_POLYGON_OFFSET_LINE);
}
else
{
glDisable (GL_POLYGON_OFFSET_LINE);
}
if ((theOffsetData.mode & Aspect_POM_Point) == Aspect_POM_Point)
{
glEnable (GL_POLYGON_OFFSET_POINT);
}
else
{
glDisable (GL_POLYGON_OFFSET_POINT);
}
#endif
glPolygonOffset (theOffsetData.factor, theOffsetData.units);
}
/*----------------------------------------------------------------------*/
void OpenGl_Workspace::updateMaterial (const int theFlag)
{
// Case of hidden line
if (AspectFace_set->InteriorStyle() == Aspect_IS_HIDDENLINE)
{
myAspectFaceHl = *AspectFace_set; // copy all values including line edge aspect
myAspectFaceHl.ChangeIntFront().matcol = BackgroundColor();
myAspectFaceHl.ChangeIntFront().color_mask = 0;
myAspectFaceHl.ChangeIntFront().color_mask = 0;
AspectFace_set = &myAspectFaceHl;
return;
}
const OPENGL_SURF_PROP* aProps = &AspectFace_set->IntFront();
GLenum aFace = GL_FRONT_AND_BACK;
if (theFlag == TEL_BACK_MATERIAL)
{
aFace = GL_BACK;
aProps = &AspectFace_set->IntBack();
}
else if (AspectFace_set->DistinguishingMode() == TOn
&& !(NamedStatus & OPENGL_NS_RESMAT))
{
aFace = GL_FRONT;
}
myMatTmp.Init (*aProps);
// handling transparency
if (NamedStatus & OPENGL_NS_2NDPASSDO)
{
// second pass
myMatTmp.Diffuse.a() = aProps->env_reflexion;
}
else
{
if (aProps->env_reflexion != 0.0f)
{
// if the material reflects the environment scene, the second pass is needed
NamedStatus |= OPENGL_NS_2NDPASSNEED;
}
if (aProps->trans != 1.0f)
{
// render transparent
myMatTmp.Diffuse.a() = aProps->trans;
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable (GL_BLEND);
if (myUseDepthWrite)
{
glDepthMask (GL_FALSE);
}
}
else
{
// render opaque
if ((NamedStatus & OPENGL_NS_ANTIALIASING) == 0)
{
glBlendFunc (GL_ONE, GL_ZERO);
glDisable (GL_BLEND);
}
if (myUseDepthWrite)
{
glDepthMask (GL_TRUE);
}
}
}
// do not update material properties in case of zero reflection mode,
// because GL lighting will be disabled by OpenGl_PrimitiveArray::DrawArray() anyway.
if (aProps->color_mask == 0)
{
return;
}
// reset material
if (NamedStatus & OPENGL_NS_RESMAT)
{
#if !defined(GL_ES_VERSION_2_0)
if (myGlContext->core11 != NULL)
{
myGlContext->core11->glMaterialfv (aFace, GL_AMBIENT, myMatTmp.Ambient.GetData());
myGlContext->core11->glMaterialfv (aFace, GL_DIFFUSE, myMatTmp.Diffuse.GetData());
myGlContext->core11->glMaterialfv (aFace, GL_SPECULAR, myMatTmp.Specular.GetData());
myGlContext->core11->glMaterialfv (aFace, GL_EMISSION, myMatTmp.Emission.GetData());
myGlContext->core11->glMaterialf (aFace, GL_SHININESS, myMatTmp.Shine());
}
#endif
if (theFlag == TEL_FRONT_MATERIAL)
{
myMatFront = myMatTmp;
myMatBack = myMatTmp;
}
else
{
myMatBack = myMatTmp;
}
NamedStatus &= ~OPENGL_NS_RESMAT;
return;
}
// reduce updates
OpenGl_Material& anOld = (theFlag == TEL_FRONT_MATERIAL)
? myMatFront
: myMatBack;
#if !defined(GL_ES_VERSION_2_0)
if (myGlContext->core11 != NULL)
{
if (myMatTmp.Ambient.r() != anOld.Ambient.r()
|| myMatTmp.Ambient.g() != anOld.Ambient.g()
|| myMatTmp.Ambient.b() != anOld.Ambient.b())
{
myGlContext->core11->glMaterialfv (aFace, GL_AMBIENT, myMatTmp.Ambient.GetData());
}
if (myMatTmp.Diffuse.r() != anOld.Diffuse.r()
|| myMatTmp.Diffuse.g() != anOld.Diffuse.g()
|| myMatTmp.Diffuse.b() != anOld.Diffuse.b()
|| fabs (myMatTmp.Diffuse.a() - anOld.Diffuse.a()) > 0.01f)
{
myGlContext->core11->glMaterialfv (aFace, GL_DIFFUSE, myMatTmp.Diffuse.GetData());
}
if (myMatTmp.Specular.r() != anOld.Specular.r()
|| myMatTmp.Specular.g() != anOld.Specular.g()
|| myMatTmp.Specular.b() != anOld.Specular.b())
{
myGlContext->core11->glMaterialfv (aFace, GL_SPECULAR, myMatTmp.Specular.GetData());
}
if (myMatTmp.Emission.r() != anOld.Emission.r()
|| myMatTmp.Emission.g() != anOld.Emission.g()
|| myMatTmp.Emission.b() != anOld.Emission.b())
{
myGlContext->core11->glMaterialfv (aFace, GL_EMISSION, myMatTmp.Emission.GetData());
}
if (myMatTmp.Shine() != anOld.Shine())
{
myGlContext->core11->glMaterialf (aFace, GL_SHININESS, myMatTmp.Shine());
}
}
#endif
anOld = myMatTmp;
if (aFace == GL_FRONT_AND_BACK)
{
myMatBack = myMatTmp;
}
}
/*----------------------------------------------------------------------*/
const OpenGl_AspectLine * OpenGl_Workspace::SetAspectLine(const OpenGl_AspectLine *AnAspect)
{
const OpenGl_AspectLine *AspectLine_old = AspectLine_set;
AspectLine_set = AnAspect;
return AspectLine_old;
}
/*----------------------------------------------------------------------*/
const OpenGl_AspectFace * OpenGl_Workspace::SetAspectFace(const OpenGl_AspectFace *AnAspect)
{
const OpenGl_AspectFace *AspectFace_old = AspectFace_set;
AspectFace_set = AnAspect;
return AspectFace_old;
}
/*----------------------------------------------------------------------*/
const OpenGl_AspectMarker * OpenGl_Workspace::SetAspectMarker(const OpenGl_AspectMarker *AnAspect)
{
const OpenGl_AspectMarker *AspectMarker_old = AspectMarker_set;
AspectMarker_set = AnAspect;
return AspectMarker_old;
}
/*----------------------------------------------------------------------*/
const OpenGl_AspectText * OpenGl_Workspace::SetAspectText(const OpenGl_AspectText *AnAspect)
{
const OpenGl_AspectText *AspectText_old = AspectText_set;
AspectText_set = AnAspect;
return AspectText_old;
}
/*----------------------------------------------------------------------*/
const OpenGl_AspectLine * OpenGl_Workspace::AspectLine(const Standard_Boolean theWithApply)
{
if (theWithApply)
{
AspectLine_applied = AspectLine_set;
}
return AspectLine_set;
}
/*----------------------------------------------------------------------*/
const OpenGl_AspectFace* OpenGl_Workspace::AspectFace (const Standard_Boolean theToApply)
{
if (!theToApply)
{
return AspectFace_set;
}
if (!ActiveView()->Backfacing())
{
// manage back face culling mode, disable culling when clipping is enabled
TelCullMode aCullingMode = (myGlContext->Clipping().IsClippingOrCappingOn()
|| AspectFace_set->InteriorStyle() == Aspect_IS_HATCH)
? TelCullNone
: (TelCullMode )AspectFace_set->CullingMode();
if (aCullingMode != TelCullNone
&& !(NamedStatus & OPENGL_NS_2NDPASSDO))
{
// disable culling in case of translucent shading aspect
if (AspectFace_set->IntFront().trans != 1.0f)
{
aCullingMode = TelCullNone;
}
}
if (myCullingMode != aCullingMode)
{
myCullingMode = aCullingMode;
switch (myCullingMode)
{
case TelCullNone:
case TelCullUndefined:
{
glDisable (GL_CULL_FACE);
break;
}
case TelCullFront:
{
glCullFace (GL_FRONT);
glEnable (GL_CULL_FACE);
break;
}
case TelCullBack:
{
glCullFace (GL_BACK);
glEnable (GL_CULL_FACE);
break;
}
}
}
}
if (AspectFace_set == AspectFace_applied)
{
return AspectFace_set;
}
#if !defined(GL_ES_VERSION_2_0)
const Aspect_InteriorStyle anIntstyle = AspectFace_set->InteriorStyle();
if (AspectFace_applied == NULL || AspectFace_applied->InteriorStyle() != anIntstyle)
{
switch (anIntstyle)
{
case Aspect_IS_EMPTY:
case Aspect_IS_HOLLOW:
{
glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
break;
}
case Aspect_IS_HATCH:
{
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
myLineAttribs->SetTypeOfHatch (AspectFace_applied != NULL ? AspectFace_applied->Hatch() : TEL_HS_SOLID);
break;
}
case Aspect_IS_SOLID:
case Aspect_IS_HIDDENLINE:
{
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
if (myGlContext->core11 != NULL)
{
glDisable (GL_POLYGON_STIPPLE);
}
break;
}
case Aspect_IS_POINT:
{
glPolygonMode (GL_FRONT_AND_BACK, GL_POINT);
break;
}
}
}
if (anIntstyle == Aspect_IS_HATCH)
{
const Tint hatchstyle = AspectFace_set->Hatch();
if (AspectFace_applied == NULL || AspectFace_applied->Hatch() != hatchstyle)
{
myLineAttribs->SetTypeOfHatch (hatchstyle);
}
}
#endif
// Aspect_POM_None means: do not change current settings
if ((AspectFace_set->PolygonOffset().mode & Aspect_POM_None) != Aspect_POM_None)
{
if (PolygonOffset_applied.mode != AspectFace_set->PolygonOffset().mode
|| PolygonOffset_applied.factor != AspectFace_set->PolygonOffset().factor
|| PolygonOffset_applied.units != AspectFace_set->PolygonOffset().units)
{
SetPolygonOffset (AspectFace_set->PolygonOffset().mode,
AspectFace_set->PolygonOffset().factor,
AspectFace_set->PolygonOffset().units);
}
}
updateMaterial (TEL_FRONT_MATERIAL);
if (AspectFace_set->DistinguishingMode() == TOn)
{
updateMaterial (TEL_BACK_MATERIAL);
}
if ((NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0)
{
if (AspectFace_set->DoTextureMap())
{
EnableTexture (AspectFace_set->TextureRes (myGlContext),
AspectFace_set->TextureParams());
}
else
{
DisableTexture();
}
}
AspectFace_applied = AspectFace_set;
return AspectFace_set;
}
//=======================================================================
//function : SetPolygonOffset
//purpose :
//=======================================================================
void OpenGl_Workspace::SetPolygonOffset (int theMode,
Standard_ShortReal theFactor,
Standard_ShortReal theUnits)
{
PolygonOffset_applied.mode = theMode;
PolygonOffset_applied.factor = theFactor;
PolygonOffset_applied.units = theUnits;
TelUpdatePolygonOffsets (PolygonOffset_applied);
}
/*----------------------------------------------------------------------*/
const OpenGl_AspectMarker* OpenGl_Workspace::AspectMarker (const Standard_Boolean theToApply)
{
if (theToApply && (AspectMarker_set != AspectMarker_applied))
{
if (!AspectMarker_applied || (AspectMarker_set->Scale() != AspectMarker_applied->Scale()))
{
#if !defined(GL_ES_VERSION_2_0)
glPointSize (AspectMarker_set->Scale());
#ifdef HAVE_GL2PS
gl2psPointSize (AspectMarker_set->Scale());
#endif
#endif
}
AspectMarker_applied = AspectMarker_set;
}
return AspectMarker_set;
}
/*----------------------------------------------------------------------*/
const OpenGl_AspectText* OpenGl_Workspace::AspectText (const Standard_Boolean theWithApply)
{
if (theWithApply)
{
AspectText_applied = AspectText_set;
TextParam_applied = TextParam_set;
}
return AspectText_set;
}

1
src/OpenGl/OpenGl_telem_util.cxx
View File

@ -68,7 +68,6 @@ when a face has confused or aligned points.
#include <OpenGl_telem_util.hxx>
#include <InterfaceGraphic_Graphic3d.hxx>
#include <InterfaceGraphic_Visual3d.hxx>
#define GPRECIS 0.000001
Tint TelGetPolygonNormal(tel_point pnts, Tint* indexs, Tint npnt, Tfloat *norm ) {

3
src/PrsMgr/PrsMgr_Presentation.cxx
View File

@ -27,7 +27,6 @@
#include <PrsMgr_Prs.hxx>
#include <Quantity_Color.hxx>
#include <Standard_Type.hxx>
#include <Visual3d_View.hxx>
namespace
{
@ -374,7 +373,7 @@ void PrsMgr_Presentation::Compute (const Handle(Graphic3d_DataStructureManager)&
//=======================================================================
Handle(Prs3d_Projector) PrsMgr_Presentation::Projector (const Handle(Graphic3d_DataStructureManager)& theProjector)
{
Handle(Graphic3d_Camera) aCamera (Handle(Visual3d_View)::DownCast (theProjector)->Camera());
Handle(Graphic3d_Camera) aCamera = Handle(Graphic3d_CView)::DownCast (theProjector)->Camera();
const gp_Dir aDir = aCamera->Direction().Reversed();
const gp_Pnt anAt = aCamera->Center();
const gp_Dir anUp = aCamera->Up();

9
src/PrsMgr/PrsMgr_PresentationManager.cxx
View File

@ -15,7 +15,6 @@
#include <Geom_Transformation.hxx>
#include <Graphic3d_GraphicDriver.hxx>
#include <Graphic3d_StructureManager.hxx>
#include <Prs3d_Presentation.hxx>
#include <Prs3d_PresentationShadow.hxx>
#include <Prs3d_ShadingAspect.hxx>
@ -28,14 +27,12 @@
#include <Standard_Type.hxx>
#include <TColStd_ListIteratorOfListOfTransient.hxx>
#include <V3d_View.hxx>
#include <Visual3d_View.hxx>
#include <Visual3d_ViewManager.hxx>
// =======================================================================
// function : PrsMgr_PresentationManager
// purpose :
// =======================================================================
PrsMgr_PresentationManager::PrsMgr_PresentationManager (const Handle(Visual3d_ViewManager)& theStructureManager)
PrsMgr_PresentationManager::PrsMgr_PresentationManager (const Handle(Graphic3d_StructureManager)& theStructureManager)
: myStructureManager (theStructureManager),
myImmediateModeOn (0),
mySelectionColor (Quantity_NOC_GRAY99)
@ -346,7 +343,7 @@ void PrsMgr_PresentationManager::displayImmediate (const Handle(V3d_Viewer)& the
{
for (theViewer->InitActiveViews(); theViewer->MoreActiveViews(); theViewer->NextActiveViews())
{
const Handle(Visual3d_View)& aView = theViewer->ActiveView()->View();
const Handle(Graphic3d_CView)& aView = theViewer->ActiveView()->View();
for (PrsMgr_ListOfPresentations::Iterator anIter (myImmediateList); anIter.More(); anIter.Next())
{
const Handle(Prs3d_Presentation)& aPrs = anIter.Value();
@ -365,7 +362,7 @@ void PrsMgr_PresentationManager::displayImmediate (const Handle(V3d_Viewer)& the
aShadowPrs->Highlight (Aspect_TOHM_COLOR, aPrs->HighlightColor());
myViewDependentImmediateList.Append (aShadowPrs);
}
// handles custom highlight presentations which were defined in overriden
// handles custom highlight presentations which were defined in overridden
// HilightOwnerWithColor method of a custom AIS objects and maintain its
// visibility in different views on their own
else if (aShadowPrs.IsNull())

36
src/PrsMgr/PrsMgr_PresentationManager.hxx
View File

@ -17,27 +17,25 @@
#ifndef _PrsMgr_PresentationManager_HeaderFile
#define _PrsMgr_PresentationManager_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
#include <Graphic3d_NameOfMaterial.hxx>
#include <Graphic3d_StructureManager.hxx>
#include <Graphic3d_ZLayerId.hxx>
#include <MMgt_TShared.hxx>
#include <PrsMgr_ListOfPresentations.hxx>
#include <Quantity_Color.hxx>
#include <MMgt_TShared.hxx>
#include <Standard_Boolean.hxx>
#include <Quantity_NameOfColor.hxx>
#include <Graphic3d_NameOfMaterial.hxx>
#include <Graphic3d_ZLayerId.hxx>
class Visual3d_ViewManager;
class V3d_Viewer;
class Standard_NoSuchObject;
class PrsMgr_PresentableObject;
class Prs3d_Presentation;
class Geom_Transformation;
class Graphic3d_StructureManager;
class Prs3d_ShadingAspect;
class PrsMgr_Presentation;
#include <Standard.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Type.hxx>
class Geom_Transformation;
class Prs3d_Presentation;
class Prs3d_ShadingAspect;
class PrsMgr_PresentableObject;
class PrsMgr_Presentation;
class Standard_NoSuchObject;
class V3d_Viewer;
class PrsMgr_PresentationManager;
DEFINE_STANDARD_HANDLE(PrsMgr_PresentationManager, MMgt_TShared)
@ -54,7 +52,7 @@ public:
//! Creates a framework to manage displays and graphic entities with the 3D view theStructureManager.
Standard_EXPORT PrsMgr_PresentationManager(const Handle(Visual3d_ViewManager)& theStructureManager);
Standard_EXPORT PrsMgr_PresentationManager(const Handle(Graphic3d_StructureManager)& theStructureManager);
//! Displays the presentation of the object in the given Presentation manager with the given mode.
//! The mode should be enumerated by the object which inherits PresentableObject.
@ -175,7 +173,7 @@ protected:
//! Removes a presentation of the presentable object thePrsObject to this framework. thePrsObject has the display mode theMode.
Standard_EXPORT Standard_Boolean RemovePresentation (const Handle(PrsMgr_PresentableObject)& thePrsObject, const Standard_Integer theMode = 0);
Handle(Visual3d_ViewManager) myStructureManager;
Handle(Graphic3d_StructureManager) myStructureManager;
Standard_Integer myImmediateModeOn;
PrsMgr_ListOfPresentations myImmediateList;
PrsMgr_ListOfPresentations myViewDependentImmediateList;

2
src/PrsMgr/PrsMgr_PresentationManager.lxx
View File

@ -14,8 +14,6 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Visual3d_ViewManager.hxx>
inline Standard_Boolean PrsMgr_PresentationManager::IsImmediateModeOn() const
{
return myImmediateModeOn > 0;

1
src/QABugs/QABugs_8.cxx
View File

@ -26,7 +26,6 @@
#include <TColStd_Array2OfReal.hxx>
#include <V3d_View.hxx>
#include <Visual3d_View.hxx>
#include <BRepOffsetAPI_Sewing.hxx>

6
src/StdSelect/StdSelect_ViewerSelector3d.cxx
View File

@ -183,7 +183,7 @@ void StdSelect_ViewerSelector3d::DisplaySensitive (const Handle(V3d_View)& theVi
{
const Handle (SelectMgr_SelectableObject)& anObj = mySelectableObjects.GetObjectById (anObjectIdx);
Handle(Graphic3d_Structure) aStruct = new Graphic3d_Structure (theView->Viewer()->Viewer());
Handle(Graphic3d_Structure) aStruct = new Graphic3d_Structure (theView->Viewer()->StructureManager());
for (anObj->Init(); anObj->More(); anObj->Next())
{
@ -200,7 +200,7 @@ void StdSelect_ViewerSelector3d::DisplaySensitive (const Handle(V3d_View)& theVi
{
const Handle (SelectMgr_SelectableObject)& anObj = mySelectableObjectsTrsfPers.GetObjectById (anObjectIdx);
Handle(Graphic3d_Structure) aStruct = new Graphic3d_Structure (theView->Viewer()->Viewer());
Handle(Graphic3d_Structure) aStruct = new Graphic3d_Structure (theView->Viewer()->StructureManager());
if (!anObj->TransformPersistence().Flags || (anObj->TransformPersistence().Flags & Graphic3d_TMF_2d))
{
@ -261,7 +261,7 @@ void StdSelect_ViewerSelector3d::DisplaySensitive (const Handle(SelectMgr_Select
ClearSensitive (theView);
}
Handle(Graphic3d_Structure) aStruct = new Graphic3d_Structure (theView->Viewer()->Viewer());
Handle(Graphic3d_Structure) aStruct = new Graphic3d_Structure (theView->Viewer()->StructureManager());
ComputeSensitivePrs (aStruct, theSel, theTrsf, Graphic3d_TransformPers());

1
src/TKV3d/CMakeLists.txt
View File

@ -3,7 +3,6 @@ project(TKV3d)
set (TOOLKIT_MODULES
V3d
Graphic3d
Visual3d
Select3D
Prs3d
StdPrs

1
src/TKV3d/PACKAGES
View File

@ -1,6 +1,5 @@
V3d
Graphic3d
Visual3d
Select3D
Prs3d
StdPrs

4
src/V3d/V3d.cxx
View File

@ -35,8 +35,6 @@
#include <V3d.hxx>
#include <V3d_View.hxx>
#include <V3d_Viewer.hxx>
#include <Visual3d_View.hxx>
#include <Visual3d_ViewManager.hxx>
Graphic3d_Vector V3d::GetProjAxis(const V3d_TypeOfOrientation Orientation) {
Standard_Real Xpn=0,Ypn=0,Zpn=0 ;
@ -238,7 +236,7 @@ void V3d::DrawSphere(const Handle(V3d_Viewer)& aViewer,const Quantity_Length ray
{
const Standard_Boolean inf = ray < 0;
const Standard_Real aRadius = Standard_ShortReal(Abs(ray));
Handle(Graphic3d_Structure) Struct = new Graphic3d_Structure(aViewer->Viewer()) ;
Handle(Graphic3d_Structure) Struct = new Graphic3d_Structure(aViewer->StructureManager());
Handle(Graphic3d_Group) Group = Struct->NewGroup();
Handle(Graphic3d_AspectLine3d) LineAttrib = new Graphic3d_AspectLine3d() ;

5
src/V3d/V3d.hxx
View File

@ -32,7 +32,6 @@ class V3d_View;
class V3d_Viewer;
class V3d_Viewer;
class V3d_View;
class V3d_LayerMgr;
class V3d_Light;
class V3d_AmbientLight;
class V3d_PositionLight;
@ -47,8 +46,7 @@ class V3d_ColorScaleLayerItem;
//! This package contains the set of commands and services
//! of the 3D Viewer. It provides a set of high level commands
//! to control the views and viewing modes. This package is
//! complementary to the Visual3D graphic package.
//! to control the views and viewing modes.
class V3d
{
public:
@ -100,7 +98,6 @@ private:
friend class V3d_Viewer;
friend class V3d_View;
friend class V3d_LayerMgr;
friend class V3d_Light;
friend class V3d_AmbientLight;
friend class V3d_PositionLight;

20
src/V3d/V3d_AmbientLight.cxx
View File

@ -15,16 +15,16 @@
// Modified 30-03-98 : ZOV ; PRO6774 (reconstruction of the class hierarchy and suppressing useless methods)
#include <Standard_Type.hxx>
#include <V3d.hxx>
#include <V3d_AmbientLight.hxx>
#include <V3d_Viewer.hxx>
#include <Visual3d_Light.hxx>
V3d_AmbientLight::V3d_AmbientLight(const Handle(V3d_Viewer)& VM, const Quantity_NameOfColor Name):V3d_Light(VM) {
Quantity_Color C(Name) ;
MyType = V3d_AMBIENT ;
MyLight = new Visual3d_Light(C) ;
// =======================================================================
// function : V3d_AmbientLight
// purpose :
// =======================================================================
V3d_AmbientLight::V3d_AmbientLight (const Handle(V3d_Viewer)& theViewer,
const Quantity_NameOfColor theColor)
: V3d_Light (theViewer)
{
SetType (V3d_AMBIENT);
SetColor (theColor);
}

33
src/V3d/V3d_AmbientLight.hxx
View File

@ -17,14 +17,9 @@
#ifndef _V3d_AmbientLight_HeaderFile
#define _V3d_AmbientLight_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <V3d_Light.hxx>
#include <Quantity_NameOfColor.hxx>
class V3d_Viewer;
class V3d_AmbientLight;
DEFINE_STANDARD_HANDLE(V3d_AmbientLight, V3d_Light)
@ -34,32 +29,12 @@ class V3d_AmbientLight : public V3d_Light
public:
//! Constructs an ambient light source in the viewer VM.
//! Constructs an ambient light source in the viewer.
//! The default Color of this light source is WHITE.
Standard_EXPORT V3d_AmbientLight(const Handle(V3d_Viewer)& VM, const Quantity_NameOfColor Color = Quantity_NOC_WHITE);
Standard_EXPORT V3d_AmbientLight (const Handle(V3d_Viewer)& theViewer,
const Quantity_NameOfColor theColor = Quantity_NOC_WHITE);
DEFINE_STANDARD_RTTI(V3d_AmbientLight,V3d_Light)
protected:
private:
};
#endif // _V3d_AmbientLight_HeaderFile

3
src/V3d/V3d_CircularGrid.cxx
View File

@ -38,7 +38,6 @@
#include <TColStd_Array2OfReal.hxx>
#include <V3d_CircularGrid.hxx>
#include <V3d_Viewer.hxx>
#include <Visual3d_ViewManager.hxx>
/*----------------------------------------------------------------------*/
/*
@ -52,7 +51,7 @@
V3d_CircularGrid::V3d_CircularGrid (const V3d_ViewerPointer& aViewer, const Quantity_Color& aColor, const Quantity_Color& aTenthColor)
: Aspect_CircularGrid (1.,8),
myStructure (new Graphic3d_Structure (aViewer->Viewer ())),
myStructure (new Graphic3d_Structure (aViewer->StructureManager())),
myGroup (myStructure->NewGroup()),
myViewer (aViewer),
myCurAreDefined (Standard_False)

269
src/V3d/V3d_DirectionalLight.cxx
View File

@ -51,92 +51,149 @@
#include <V3d_DirectionalLight.hxx>
#include <V3d_View.hxx>
#include <V3d_Viewer.hxx>
#include <Visual3d_ContextPick.hxx>
#include <Visual3d_Light.hxx>
#include <Visual3d_ViewManager.hxx>
//-Constructors
V3d_DirectionalLight::V3d_DirectionalLight(const Handle(V3d_Viewer)& VM, const
V3d_TypeOfOrientation Direction,const Quantity_NameOfColor Name,const Standard_Boolean Headlight):V3d_PositionLight(VM) {
Quantity_Color C(Name) ;
Graphic3d_Vertex T(0.,0.,0.) ;
Graphic3d_Vertex P ;
Graphic3d_Vector V = V3d::GetProjAxis(Direction) ;
MyType = V3d_DIRECTIONAL ;
MyLight = new Visual3d_Light(C,V, Headlight) ;
// The initial target is chosen at random
MyTarget = T;
// Position is found
P.SetCoord(-V.X(),-V.Y(),-V.Z());
MyDisplayPosition = P;
// =======================================================================
// function : V3d_DirectionalLight
// purpose :
// =======================================================================
V3d_DirectionalLight::V3d_DirectionalLight (const Handle(V3d_Viewer)& theViewer,
const V3d_TypeOfOrientation theDirection,
const Quantity_NameOfColor theColor,
const Standard_Boolean theIsHeadlight)
: V3d_PositionLight (theViewer)
{
Graphic3d_Vector aV = V3d::GetProjAxis (theDirection);
SetType (V3d_DIRECTIONAL);
SetColor (theColor);
SetHeadlight (theIsHeadlight);
SetTarget (0., 0., 0.);
SetPosition (-aV.X(), -aV.Y(), -aV.Z());
}
V3d_DirectionalLight::V3d_DirectionalLight(const Handle(V3d_Viewer)& VM,const Standard_Real Xt,const Standard_Real Yt,const Standard_Real Zt,const Standard_Real Xp,const Standard_Real Yp,const Standard_Real Zp,const Quantity_NameOfColor Name,const Standard_Boolean Headlight):V3d_PositionLight(VM) {
Quantity_Color C(Name) ;
Graphic3d_Vertex T(Xt,Yt,Zt) ;
Graphic3d_Vertex P(Xp,Yp,Zp) ;
Graphic3d_Vector V(P,T);
MyType = V3d_DIRECTIONAL ;
V.Normalize();
MyLight = new Visual3d_Light(C,V, Headlight) ;
MyTarget = T;
MyDisplayPosition = P;
// =======================================================================
// function : V3d_DirectionalLight
// purpose :
// =======================================================================
V3d_DirectionalLight::V3d_DirectionalLight (const Handle(V3d_Viewer)& theViewer,
const Standard_Real theXt,
const Standard_Real theYt,
const Standard_Real theZt,
const Standard_Real theXp,
const Standard_Real theYp,
const Standard_Real theZp,
const Quantity_NameOfColor theColor,
const Standard_Boolean theIsHeadlight)
: V3d_PositionLight (theViewer)
{
SetType (V3d_DIRECTIONAL);
SetColor (theColor);
SetHeadlight (theIsHeadlight);
SetTarget (theXt, theYt, theZt);
SetPosition (theXp, theYp, theZp);
}
//-Methods, in order
// =======================================================================
// function : SetSmoothAngle
// purpose :
// =======================================================================
void V3d_DirectionalLight::SetSmoothAngle (const Standard_Real theValue)
{
MyLight->SetSmoothAngle (theValue);
V3d_BadValue_Raise_if (theValue < 0.0 || theValue > M_PI / 2.0,
"Bad value for smoothing angle");
myLight.Smoothness = static_cast<Standard_ShortReal> (theValue);
}
void V3d_DirectionalLight::SetDirection(const V3d_TypeOfOrientation Direction) {
Graphic3d_Vector V = V3d::GetProjAxis(Direction) ;
MyLight->SetDirection(V) ;
// =======================================================================
// function : SetDirection
// purpose :
// =======================================================================
void V3d_DirectionalLight::SetDirection (const V3d_TypeOfOrientation theDirection)
{
Graphic3d_Vector aV = V3d::GetProjAxis (theDirection);
SetDirection (aV.X(), aV.Y(), aV.Z());
}
void V3d_DirectionalLight::SetDirection(const Standard_Real Vx, const Standard_Real Vy, const Standard_Real Vz) {
// =======================================================================
// function : SetDirection
// purpose :
// =======================================================================
void V3d_DirectionalLight::SetDirection (const Standard_Real theVx,
const Standard_Real theVy,
const Standard_Real theVz)
{
V3d_BadValue_Raise_if (Sqrt (theVx * theVx + theVy * theVy + theVz * theVz) <= 0.,
"V3d_DirectionalLight::SetDirection, "
"null vector" );
V3d_BadValue_Raise_if( sqrt( Vx*Vx + Vy*Vy + Vz*Vz ) <= 0.,"V3d_DirectionalLight::SetDirection, null vector" );
Graphic3d_Vector aV (theVx, theVy, theVz);
aV.Normalize();
Graphic3d_Vector V(Vx,Vy,Vz) ;
V.Normalize() ;
MyLight->SetDirection(V) ;
myLight.Direction.x() = static_cast<Standard_ShortReal> (aV.X());
myLight.Direction.y() = static_cast<Standard_ShortReal> (aV.Y());
myLight.Direction.z() = static_cast<Standard_ShortReal> (aV.Z());
}
void V3d_DirectionalLight::SetDisplayPosition(const Standard_Real X, const Standard_Real Y, const Standard_Real Z) {
// =======================================================================
// function : SetDisplayPosition
// purpose :
// =======================================================================
void V3d_DirectionalLight::SetDisplayPosition (const Standard_Real theX,
const Standard_Real theY,
const Standard_Real theZ)
{
myDisplayPosition.SetCoord(theX, theY, theZ);
Standard_Real Xt,Yt,Zt;
Standard_Real aXt, aYt, aZt;
Target (aXt, aYt, aZt);
MyDisplayPosition.SetCoord(X,Y,Z) ;
MyTarget.Coord(Xt,Yt,Zt);
SetDirection(Xt-X,Yt-Y,Zt-Z);
Standard_Real aXd = aXt - theX;
Standard_Real aYd = aYt - theY;
Standard_Real aZd = aZt - theZ;
if (!Graphic3d_Vector (aXd, aYd, aZd).LengthZero())
{
SetDirection (aXd, aYd, aZd);
}
}
void V3d_DirectionalLight::SetPosition(const Standard_Real Xp, const Standard_Real Yp, const Standard_Real Zp) {
SetDisplayPosition (Xp,Yp,Zp);
// =======================================================================
// function : SetPosition
// purpose :
// =======================================================================
void V3d_DirectionalLight::SetPosition (const Standard_Real theXp,
const Standard_Real theYp,
const Standard_Real theZp)
{
SetDisplayPosition (theXp, theYp, theZp);
}
void V3d_DirectionalLight::Position(Standard_Real& Xp, Standard_Real& Yp, Standard_Real& Zp)const {
DisplayPosition (Xp,Yp,Zp) ;
// =======================================================================
// function : Position
// purpose :
// =======================================================================
void V3d_DirectionalLight::Position (Standard_Real& theXp,
Standard_Real& theYp,
Standard_Real& theZp) const
{
DisplayPosition (theXp, theYp, theZp) ;
}
void V3d_DirectionalLight::DisplayPosition(Standard_Real& Xp, Standard_Real& Yp, Standard_Real& Zp)const {
MyDisplayPosition.Coord(Xp,Yp,Zp) ;
// =======================================================================
// function : DisplayPosition
// purpose :
// =======================================================================
void V3d_DirectionalLight::DisplayPosition (Standard_Real& theXp,
Standard_Real& theYp,
Standard_Real& theZp) const
{
myDisplayPosition.Coord (theXp, theYp, theZp) ;
}
void V3d_DirectionalLight::Symbol (const Handle(Graphic3d_Group)& gsymbol, const Handle(V3d_View)& aView) const
// =======================================================================
// function : DisplayPosition
// purpose :
// =======================================================================
void V3d_DirectionalLight::Symbol (const Handle(Graphic3d_Group)& theSymbol, const Handle(V3d_View)& theView) const
{
Standard_Real Xi,Yi,Zi,Xf,Yf,Zf,Rayon,PXT,PYT,X,Y,Z,XT,YT,ZT;
Standard_Real A,B,C,Dist,Beta,CosBeta,SinBeta,Coef,X1,Y1,Z1;
@ -144,15 +201,15 @@ void V3d_DirectionalLight::Symbol (const Handle(Graphic3d_Group)& gsymbol, const
Standard_Integer IXP,IYP,j;
TColStd_Array2OfReal MatRot(0,2,0,2);
aView->Proj(VX,VY,VZ);
theView->Proj(VX,VY,VZ);
this->DisplayPosition(Xi,Yi,Zi);
Rayon = this->Radius();
aView->Project(Xi,Yi,Zi,PXT,PYT);
aView->Convert(PXT,PYT,IXP,IYP);
theView->Project(Xi,Yi,Zi,PXT,PYT);
theView->Convert(PXT,PYT,IXP,IYP);
// Coordinated 3d in the plane of projection of the source.
aView->Convert(IXP,IYP,XT,YT,ZT);
aView->Convert(PXT,PYT+Rayon,IXP,IYP);
aView->Convert(IXP,IYP,X,Y,Z);
theView->Convert(IXP,IYP,XT,YT,ZT);
theView->Convert(PXT,PYT+Rayon,IXP,IYP);
theView->Convert(IXP,IYP,X,Y,Z);
X = X+Xi-XT; Y = Y+Yi-YT; Z = Z+Zi-ZT;
Dist = Sqrt( Square(X-Xi) + Square(Y-Yi) + Square(Z-Zi) );
// Axis of rotation.
@ -161,7 +218,7 @@ void V3d_DirectionalLight::Symbol (const Handle(Graphic3d_Group)& gsymbol, const
C = (Z-Zi)/Dist;
// A sphere is drawn
V3d::CircleInPlane(gsymbol,Xi,Yi,Zi,VX,VY,VZ,Rayon/40.);
V3d::CircleInPlane(theSymbol,Xi,Yi,Zi,VX,VY,VZ,Rayon/40.);
for( j=1 ; j<=3 ; j++ ) {
Beta = j * M_PI / 4.;
CosBeta = Cos(Beta);
@ -184,7 +241,7 @@ void V3d_DirectionalLight::Symbol (const Handle(Graphic3d_Group)& gsymbol, const
Y1 = VX * MatRot(1,0) + VY * MatRot(1,1) + VZ * MatRot(1,2);
Z1 = VX * MatRot(2,0) + VY * MatRot(2,1) + VZ * MatRot(2,2);
VX = X1 + Xi - Xf ; VY = Y1 + Yi - Yf ; VZ = Z1 + Zi - Zf;
V3d::CircleInPlane(gsymbol,Xi,Yi,Zi,VX,VY,VZ,Rayon/40.);
V3d::CircleInPlane(theSymbol,Xi,Yi,Zi,VX,VY,VZ,Rayon/40.);
}
// The arrow is drawn
@ -195,14 +252,18 @@ void V3d_DirectionalLight::Symbol (const Handle(Graphic3d_Group)& gsymbol, const
Handle(Graphic3d_ArrayOfSegments) aPrims = new Graphic3d_ArrayOfSegments(2);
aPrims->AddVertex(Standard_ShortReal(Xi),Standard_ShortReal(Yi),Standard_ShortReal(Zi));
aPrims->AddVertex(Standard_ShortReal(X),Standard_ShortReal(Y),Standard_ShortReal(Z));
gsymbol->AddPrimitiveArray(aPrims);
theSymbol->AddPrimitiveArray(aPrims);
V3d::ArrowOfRadius(gsymbol, X, Y, Z, DX, DY, DZ, M_PI / 15., Rayon / 20.);
V3d::ArrowOfRadius(theSymbol, X, Y, Z, DX, DY, DZ, M_PI / 15., Rayon / 20.);
}
void V3d_DirectionalLight::Display( const Handle(V3d_View)& aView,
const V3d_TypeOfRepresentation TPres) {
// =======================================================================
// function : Display
// purpose :
// =======================================================================
void V3d_DirectionalLight::Display (const Handle(V3d_View)& theView,
const V3d_TypeOfRepresentation theTPres)
{
Standard_Real X,Y,Z,Rayon;
Standard_Real X0,Y0,Z0,VX,VY,VZ;
Standard_Real X1,Y1,Z1;
@ -216,37 +277,37 @@ void V3d_DirectionalLight::Display( const Handle(V3d_View)& aView,
// Creation of a structure of non-markable elements (target, meridian and
// parallel).
Pres = TPres;
Handle(V3d_Viewer) TheViewer = aView->Viewer();
Pres = theTPres;
Handle(V3d_Viewer) TheViewer = theView->Viewer();
UpdSov = TheViewer->UpdateMode();
TheViewer->SetUpdateMode(V3d_WAIT);
if (!MyGraphicStructure.IsNull()) {
MyGraphicStructure->Disconnect(MyGraphicStructure1);
MyGraphicStructure->Clear();
MyGraphicStructure1->Clear();
if (Pres == V3d_SAMELAST) Pres = MyTypeOfRepresentation;
if (!myGraphicStructure.IsNull()) {
myGraphicStructure->Disconnect(myGraphicStructure1);
myGraphicStructure->Clear();
myGraphicStructure1->Clear();
if (Pres == V3d_SAMELAST) Pres = myTypeOfRepresentation;
}
else {
if (Pres == V3d_SAMELAST) Pres = V3d_SIMPLE;
Handle(Graphic3d_Structure) slight = new Graphic3d_Structure(TheViewer->Viewer());
MyGraphicStructure = slight;
Handle(Graphic3d_Structure) snopick = new Graphic3d_Structure(TheViewer->Viewer());
MyGraphicStructure1 = snopick;
Handle(Graphic3d_Structure) slight = new Graphic3d_Structure(TheViewer->StructureManager());
myGraphicStructure = slight;
Handle(Graphic3d_Structure) snopick = new Graphic3d_Structure(TheViewer->StructureManager());
myGraphicStructure1 = snopick;
}
Handle(Graphic3d_Group) glight = MyGraphicStructure->NewGroup();
Handle(Graphic3d_Group) glight = myGraphicStructure->NewGroup();
Handle(Graphic3d_Group) gsphere;
if (Pres == V3d_COMPLETE
|| Pres == V3d_PARTIAL)
{
gsphere = MyGraphicStructure->NewGroup();
gsphere = myGraphicStructure->NewGroup();
}
Handle(Graphic3d_Group) gnopick = MyGraphicStructure1->NewGroup();
Handle(Graphic3d_Group) gnopick = myGraphicStructure1->NewGroup();
X0 = MyTarget.X();
Y0 = MyTarget.Y();
Z0 = MyTarget.Z();
X0 = myTarget.X();
Y0 = myTarget.Y();
Z0 = myTarget.Z();
//Display of the position of the light.
@ -255,14 +316,14 @@ void V3d_DirectionalLight::Display( const Handle(V3d_View)& aView,
Handle(Graphic3d_AspectLine3d) Asp1 = new Graphic3d_AspectLine3d();
Asp1->SetColor(Col1);
glight->SetPrimitivesAspect(Asp1);
this->Symbol(glight,aView);
this->Symbol(glight,theView);
// Display of the markable sphere (limit at the circle).
if (Pres == V3d_COMPLETE || Pres == V3d_PARTIAL) {
Rayon = this->Radius();
aView->Proj(VX,VY,VZ);
theView->Proj(VX,VY,VZ);
V3d::CircleInPlane(gsphere,X0,Y0,Z0,VX,VY,VZ,Rayon);
//Display of the meridian
@ -273,7 +334,7 @@ void V3d_DirectionalLight::Display( const Handle(V3d_View)& aView,
gnopick->SetPrimitivesAspect(Asp2);
// Definition of the axis of circle
aView->Up(DXRef,DYRef,DZRef);
theView->Up(DXRef,DYRef,DZRef);
this->DisplayPosition(X,Y,Z);
DXini = X-X0; DYini = Y-Y0; DZini = Z-Z0;
VX = DYRef*DZini - DZRef*DYini;
@ -285,8 +346,8 @@ void V3d_DirectionalLight::Display( const Handle(V3d_View)& aView,
// Display of the parallel
// Definition of the axis of circle
aView->Proj(VX,VY,VZ);
aView->Up(X1,Y1,Z1);
theView->Proj(VX,VY,VZ);
theView->Up(X1,Y1,Z1);
DXRef = VY * Z1 - VZ * Y1;
DYRef = VZ * X1 - VX * Z1;
DZRef = VX * Y1 - VY * X1;
@ -300,18 +361,22 @@ void V3d_DirectionalLight::Display( const Handle(V3d_View)& aView,
}
MyGraphicStructure->Connect(MyGraphicStructure1,Graphic3d_TOC_DESCENDANT);
myGraphicStructure->Connect(myGraphicStructure1,Graphic3d_TOC_DESCENDANT);
// cout << "MyGraphicStructure exploration \n" << flush; MyGraphicStructure->Exploration();
MyTypeOfRepresentation = Pres;
MyGraphicStructure->Display();
myTypeOfRepresentation = Pres;
myGraphicStructure->Display();
TheViewer->SetUpdateMode(UpdSov);
}
void V3d_DirectionalLight::Direction(Standard_Real& Vx, Standard_Real& Vy, Standard_Real& Vz)const {
Quantity_Color C ;
Graphic3d_Vector V ;
MyLight->Values(C,V) ;
V.Coord(Vx,Vy,Vz) ;
// =======================================================================
// function : Direction
// purpose :
// =======================================================================
void V3d_DirectionalLight::Direction (Standard_Real& theVx,
Standard_Real& theVy,
Standard_Real& theVz) const
{
theVx = myLight.Direction.x();
theVy = myLight.Direction.y();
theVz = myLight.Direction.z();
}

122
src/V3d/V3d_DirectionalLight.hxx
View File

@ -17,64 +17,62 @@
#ifndef _V3d_DirectionalLight_HeaderFile
#define _V3d_DirectionalLight_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Graphic3d_Vertex.hxx>
#include <V3d_PositionLight.hxx>
#include <V3d_TypeOfOrientation.hxx>
#include <Quantity_NameOfColor.hxx>
#include <Standard_Boolean.hxx>
#include <V3d_Coordinate.hxx>
#include <Quantity_Parameter.hxx>
#include <Standard_Real.hxx>
#include <V3d_TypeOfRepresentation.hxx>
class V3d_BadValue;
class V3d_Viewer;
class V3d_View;
class Graphic3d_Group;
class V3d_DirectionalLight;
DEFINE_STANDARD_HANDLE(V3d_DirectionalLight, V3d_PositionLight)
//! Create and modify a directional light source
//! in a viewer.
//! Directional light source for a viewer.
class V3d_DirectionalLight : public V3d_PositionLight
{
public:
//! Creates a directional light source in the viewer.
Standard_EXPORT V3d_DirectionalLight(const Handle(V3d_Viewer)& VM, const V3d_TypeOfOrientation Direction = V3d_XposYposZpos, const Quantity_NameOfColor Color = Quantity_NOC_WHITE, const Standard_Boolean Headlight = Standard_False);
Standard_EXPORT V3d_DirectionalLight (const Handle(V3d_Viewer)& theViewer,
const V3d_TypeOfOrientation theDirection = V3d_XposYposZpos,
const Quantity_NameOfColor theColor = Quantity_NOC_WHITE,
const Standard_Boolean theIsHeadlight = Standard_False);
//! Creates a directional light source in the viewer.
//! Xt,Yt,Zt : Coordinate of light source Target.
//! Xp,Yp,Zp : Coordinate of light source Position.
//! theXt, theYt, theZt : Coordinate of light source Target.
//! theXp, theYp, theZp : Coordinate of light source Position.
//! The others parameters describe before.
Standard_EXPORT V3d_DirectionalLight(const Handle(V3d_Viewer)& VM, const V3d_Coordinate Xt, const V3d_Coordinate Yt, const V3d_Coordinate Zt, const V3d_Coordinate Xp, const V3d_Coordinate Yp, const V3d_Coordinate Zp, const Quantity_NameOfColor Color = Quantity_NOC_WHITE, const Standard_Boolean Headlight = Standard_False);
//! Defines the direction of the light source
//! by a predefined orientation.
Standard_EXPORT void SetDirection (const V3d_TypeOfOrientation Direction);
//! Defines the direction of the light source by the predefined
//! vector Xm,Ym,Zm.
Standard_EXPORT V3d_DirectionalLight (const Handle(V3d_Viewer)& theViewer,
const V3d_Coordinate theXt,
const V3d_Coordinate theYt,
const V3d_Coordinate theZt,
const V3d_Coordinate theXp,
const V3d_Coordinate theYp,
const V3d_Coordinate theZp,
const Quantity_NameOfColor theColor = Quantity_NOC_WHITE,
const Standard_Boolean theIsHeadlight = Standard_False);
//! Defines the direction of the light source by a predefined orientation.
Standard_EXPORT void SetDirection (const V3d_TypeOfOrientation theDirection);
//! Defines the direction of the light source by the predefined vector theXm, theYm, theZm.
//! Warning: raises BadValue from V3d if the vector is null.
Standard_EXPORT void SetDirection (const Quantity_Parameter Xm, const Quantity_Parameter Ym, const Quantity_Parameter Zm);
Standard_EXPORT void SetDirection (const Quantity_Parameter theXm,
const Quantity_Parameter theYm,
const Quantity_Parameter theZm);
//! Defines the point of light source representation.
Standard_EXPORT void SetDisplayPosition (const V3d_Coordinate X, const V3d_Coordinate Y, const V3d_Coordinate Z);
Standard_EXPORT void SetDisplayPosition (const V3d_Coordinate theX,
const V3d_Coordinate theY,
const V3d_Coordinate theZ);
//! Calls SetDisplayPosition method.
Standard_EXPORT virtual void SetPosition (const V3d_Coordinate Xp, const V3d_Coordinate Yp, const V3d_Coordinate Zp) Standard_OVERRIDE;
Standard_EXPORT virtual void SetPosition (const V3d_Coordinate theXp,
const V3d_Coordinate theYp,
const V3d_Coordinate theZp) Standard_OVERRIDE;
//! Modifies the smoothing angle (in radians)
Standard_EXPORT void SetSmoothAngle (const Standard_Real theValue);
//! Display the graphic structure of light source
//! in the choosen view. We have three type of representation
//! in the chosen view. We have three type of representation
//! - SIMPLE : Only the light source is displayed.
//! - PARTIAL : The light source and the light space are
//! displayed.
@ -82,43 +80,35 @@ public:
//! We can choose the "SAMELAST" as parameter of representation
//! In this case the graphic structure representation will be
//! the last displayed.
Standard_EXPORT void Display (const Handle(V3d_View)& aView, const V3d_TypeOfRepresentation Representation) Standard_OVERRIDE;
Standard_EXPORT void Display (const Handle(V3d_View)& theView,
const V3d_TypeOfRepresentation theRepresentation) Standard_OVERRIDE;
//! Calls DisplayPosition method.
Standard_EXPORT virtual void Position (V3d_Coordinate& X, V3d_Coordinate& Y, V3d_Coordinate& Z) const Standard_OVERRIDE;
//! Returns the choosen position to represent the light
//! source.
Standard_EXPORT void DisplayPosition (V3d_Coordinate& X, V3d_Coordinate& Y, V3d_Coordinate& Z) const;
//! Returns the Vx,Vy,Vz direction of the light source.
Standard_EXPORT void Direction (Quantity_Parameter& Vx, Quantity_Parameter& Vy, Quantity_Parameter& Vz) const;
Standard_EXPORT virtual void Position (V3d_Coordinate& theX,
V3d_Coordinate& theY,
V3d_Coordinate& theZ) const Standard_OVERRIDE;
//! Returns the chosen position to represent the light source.
Standard_EXPORT void DisplayPosition (V3d_Coordinate& theX,
V3d_Coordinate& theY,
V3d_Coordinate& theZ) const;
//! Returns the theVx, theVy, theVz direction of the light source.
Standard_EXPORT void Direction (Quantity_Parameter& theVx,
Quantity_Parameter& theVy,
Quantity_Parameter& theVz) const;
DEFINE_STANDARD_RTTI(V3d_DirectionalLight,V3d_PositionLight)
protected:
private:
//! Defines the representation of the directional light source.
Standard_EXPORT void Symbol (const Handle(Graphic3d_Group)& theSymbol,
const Handle(V3d_View)& theView) const Standard_OVERRIDE;
private:
//! Defines the representation of the directional light source.
Standard_EXPORT void Symbol (const Handle(Graphic3d_Group)& gsymbol, const Handle(V3d_View)& aView) const Standard_OVERRIDE;
Graphic3d_Vertex MyDisplayPosition;
Graphic3d_Vertex myDisplayPosition;
};
#endif // _V3d_DirectionalLight_HeaderFile

171
src/V3d/V3d_Light.cxx
View File

@ -32,71 +32,102 @@
#include <V3d_Light.hxx>
#include <V3d_View.hxx>
#include <V3d_Viewer.hxx>
#include <Visual3d_Light.hxx>
//-Declarations
//-Aliases
//-Global data definitions
//-Local data definitions
//-Constructors
V3d_Light::V3d_Light(const Handle(V3d_Viewer)& VM) {
MyType = V3d_AMBIENT ;
VM->AddLight(this) ;
// =======================================================================
// function : V3d_Light
// purpose :
// =======================================================================
V3d_Light::V3d_Light (const Handle(V3d_Viewer)& theViewer)
{
SetType (V3d_AMBIENT);
theViewer->AddLight (this);
}
//-Methods, in order
Handle(Visual3d_Light) V3d_Light::Light() const {
return MyLight ;
// =======================================================================
// function : SetType
// purpose :
// =======================================================================
void V3d_Light::SetType (const V3d_TypeOfLight theType)
{
myLight.Type = (Graphic3d_TypeOfLightSource)theType;
}
void V3d_Light::SetColor(const Quantity_TypeOfColor Type, const Standard_Real v1, const Standard_Real v2, const Standard_Real v3) {
Standard_Real V1 = v1 ;
Standard_Real V2 = v2 ;
Standard_Real V3 = v3 ;
if( V1 < 0. ) V1 = 0. ; else if( V1 > 1. ) V1 = 1. ;
if( V2 < 0. ) V2 = 0. ; else if( V2 > 1. ) V2 = 1. ;
if( V3 < 0. ) V3 = 0. ; else if( V3 > 1. ) V3 = 1. ;
Quantity_Color C(V1,V2,V3,Type) ;
MyLight->SetColor(C) ;
// =======================================================================
// function : SetColor
// purpose :
// =======================================================================
void V3d_Light::SetColor (const Quantity_TypeOfColor theType,
const Standard_Real theValue1,
const Standard_Real theValue2,
const Standard_Real theValue3)
{
Standard_Real aValue1 = Max (0., Min (1., theValue1));
Standard_Real aValue2 = Max (0., Min (1., theValue2));
Standard_Real aValue3 = Max (0., Min (1., theValue3));
Quantity_Color aColor (aValue1, aValue2, aValue3, theType);
SetColor (aColor);
}
void V3d_Light::SetColor(const Quantity_NameOfColor Name) {
Quantity_Color C(Name) ;
MyLight->SetColor(C) ;
// =======================================================================
// function : SetColor
// purpose :
// =======================================================================
void V3d_Light::SetColor (const Quantity_NameOfColor theName)
{
SetColor (Quantity_Color (theName));
}
void V3d_Light::SetColor(const Quantity_Color& aColor) {
MyLight->SetColor(aColor) ;
// =======================================================================
// function : SetColor
// purpose :
// =======================================================================
void V3d_Light::SetColor (const Quantity_Color& theColor)
{
myLight.Color.r() = static_cast<Standard_ShortReal> (theColor.Red());
myLight.Color.g() = static_cast<Standard_ShortReal> (theColor.Green());
myLight.Color.b() = static_cast<Standard_ShortReal> (theColor.Blue());
}
void V3d_Light::Color(const Quantity_TypeOfColor Type, Standard_Real& V1, Standard_Real& V2, Standard_Real& V3) const {
Quantity_Color C ;
C = MyLight->Color() ;
C.Values(V1,V2,V3,Type) ;
// =======================================================================
// function : Color
// purpose :
// =======================================================================
void V3d_Light::Color (const Quantity_TypeOfColor theType,
Standard_Real& theValue1,
Standard_Real& theValue2,
Standard_Real& theValue3) const
{
Color().Values (theValue1, theValue2, theValue3, theType);
}
void V3d_Light::Color(Quantity_NameOfColor& Name) const{
Quantity_Color C ;
C = MyLight->Color() ;
Name = C.Name();
// =======================================================================
// function : Color
// purpose :
// =======================================================================
void V3d_Light::Color (Quantity_NameOfColor& theName) const
{
theName = Color().Name();
}
Quantity_Color V3d_Light::Color() const{
return MyLight->Color();
// =======================================================================
// function : Color
// purpose :
// =======================================================================
Quantity_Color V3d_Light::Color() const
{
return Quantity_Color (Standard_Real (myLight.Color.r()),
Standard_Real (myLight.Color.g()),
Standard_Real (myLight.Color.b()),
Quantity_TOC_RGB);
}
V3d_TypeOfLight V3d_Light::Type() const {
return MyType;
// =======================================================================
// function : Type
// purpose :
// =======================================================================
V3d_TypeOfLight V3d_Light::Type() const
{
return (V3d_TypeOfLight)myLight.Type;
}
// =======================================================================
@ -105,7 +136,11 @@ V3d_TypeOfLight V3d_Light::Type() const {
// =======================================================================
void V3d_Light::SetIntensity (const Standard_Real theValue)
{
MyLight->SetIntensity (theValue);
Standard_ASSERT_RAISE (theValue > 0.,
"V3d_Light::SetIntensity, "
"Negative value for intensity");
myLight.Intensity = static_cast<Standard_ShortReal> (theValue);
}
// =======================================================================
@ -114,7 +149,7 @@ void V3d_Light::SetIntensity (const Standard_Real theValue)
// =======================================================================
Standard_Real V3d_Light::Intensity() const
{
return MyLight->Intensity();
return myLight.Intensity;
}
// =======================================================================
@ -123,18 +158,31 @@ Standard_Real V3d_Light::Intensity() const
// =======================================================================
Standard_Real V3d_Light::Smoothness() const
{
return MyLight->Smoothness();
return myLight.Smoothness;
}
Standard_Boolean V3d_Light::Headlight() const {
return MyLight->Headlight();
// =======================================================================
// function : Headlight
// purpose :
// =======================================================================
Standard_Boolean V3d_Light::Headlight() const
{
return myLight.IsHeadlight;
}
// =======================================================================
// function : SetHeadlight
// purpose :
// =======================================================================
void V3d_Light::SetHeadlight (const Standard_Boolean theValue)
{
MyLight->SetHeadlight (theValue);
myLight.IsHeadlight = theValue;
}
// =======================================================================
// function : SymetricPointOnSphere
// purpose :
// =======================================================================
void V3d_Light::SymetricPointOnSphere (const Handle(V3d_View)& aView, const Graphic3d_Vertex &Center, const Graphic3d_Vertex &aPoint, const Standard_Real Rayon, Standard_Real& X, Standard_Real& Y, Standard_Real& Z, Standard_Real& VX, Standard_Real& VY, Standard_Real& VZ ) {
Standard_Real X0,Y0,Z0,XP,YP,ZP;
@ -176,7 +224,16 @@ void V3d_Light::SymetricPointOnSphere (const Handle(V3d_View)& aView, const Grap
}
}
Standard_Boolean V3d_Light::IsDisplayed() const {
if( MyGraphicStructure.IsNull() ) return Standard_False;
return MyGraphicStructure->IsDisplayed();
// =======================================================================
// function : IsDisplayed
// purpose :
// =======================================================================
Standard_Boolean V3d_Light::IsDisplayed() const
{
if (myGraphicStructure.IsNull())
{
return Standard_False;
}
return myGraphicStructure->IsDisplayed();
}

136
src/V3d/V3d_Light.hxx
View File

@ -17,26 +17,23 @@
#ifndef _V3d_Light_HeaderFile
#define _V3d_Light_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <V3d_TypeOfLight.hxx>
#include <Graphic3d_CLight.hxx>
#include <Graphic3d_Vertex.hxx>
#include <MMgt_TShared.hxx>
#include <V3d_View.hxx>
#include <Quantity_TypeOfColor.hxx>
#include <Quantity_Parameter.hxx>
#include <Quantity_NameOfColor.hxx>
#include <Quantity_Parameter.hxx>
#include <Quantity_TypeOfColor.hxx>
#include <Standard.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <Graphic3d_Vertex.hxx>
#include <Standard_Type.hxx>
#include <V3d_Coordinate.hxx>
class Visual3d_Light;
class Graphic3d_Structure;
class V3d_BadValue;
class V3d_Viewer;
class Quantity_Color;
class V3d_View;
#include <V3d_TypeOfLight.hxx>
#include <V3d_View.hxx>
class Graphic3d_Structure;
class Quantity_Color;
class V3d_Viewer;
class V3d_Light;
DEFINE_STANDARD_HANDLE(V3d_Light, MMgt_TShared)
@ -45,101 +42,84 @@ DEFINE_STANDARD_HANDLE(V3d_Light, MMgt_TShared)
//! (base class for AmbientLight and PositionLight)
class V3d_Light : public MMgt_TShared
{
public:
//! Defines the colour of a light source
//! according to the type of colour definition
//! and the three corresponding values.
Standard_EXPORT void SetColor (const Quantity_TypeOfColor Type, const Quantity_Parameter V1, const Quantity_Parameter V2, const Quantity_Parameter V3);
//! Defines the colour of a light source by giving
//! the name of the colour in the form Quantity_NOC_xxxx .
Standard_EXPORT void SetColor (const Quantity_NameOfColor Name);
//! Defines the colour of a light source by giving
//! the basic colour.
Standard_EXPORT void SetColor (const Quantity_Color& Name);
//! Returns the colour of the light source depending of
//! the color type.
Standard_EXPORT void Color (const Quantity_TypeOfColor Type, Quantity_Parameter& V1, Quantity_Parameter& V2, Quantity_Parameter& V3) const;
//! Returns the colour of the light source.
Standard_EXPORT void Color (Quantity_NameOfColor& Name) const;
//! Returns the colour of the light source.
//! Defines the color of a light source according to the type of color
//! definition and the three corresponding values.
Standard_EXPORT void SetColor (const Quantity_TypeOfColor theType,
const Quantity_Parameter theValue1,
const Quantity_Parameter theValue2,
const Quantity_Parameter theValue3);
//! Defines the color of a light source by giving
//! the name of the color in the form Quantity_NOC_xxxx.
Standard_EXPORT void SetColor (const Quantity_NameOfColor theName);
//! Defines the color of a light source by giving the basic color.
Standard_EXPORT void SetColor (const Quantity_Color& theColor);
//! Returns the color of the light source depending of the color type.
Standard_EXPORT void Color (const Quantity_TypeOfColor theType,
Quantity_Parameter& theValue1,
Quantity_Parameter& theValue2,
Quantity_Parameter& theValue3) const;
//! Returns the color of the light source.
Standard_EXPORT void Color (Quantity_NameOfColor& theName) const;
//! Returns the color of the light source.
Standard_EXPORT Quantity_Color Color() const;
//! Returns the Type of the Light
Standard_EXPORT V3d_TypeOfLight Type() const;
//! returns true if the light is a headlight
Standard_EXPORT Standard_Boolean Headlight() const;
//! Setup headlight flag.
Standard_EXPORT void SetHeadlight (const Standard_Boolean theValue);
//! Modifies the intensity of light source.
Standard_EXPORT void SetIntensity (const Standard_Real theValue);
//! returns the intensity of light source
Standard_EXPORT Standard_Real Intensity() const;
//! returns the smoothness of light source
Standard_EXPORT Standard_Real Smoothness() const;
//! Returns TRUE when a light representation is displayed
Standard_EXPORT Standard_Boolean IsDisplayed() const;
friend
//! Activates MyLight in the view.
Standard_EXPORT void V3d_View::SetLightOn (const Handle(V3d_Light)& MyLight);
friend
//! Activates all the lights defined in this view.
Standard_EXPORT void V3d_View::SetLightOn();
friend
//! Desactivate MyLight in this view.
Standard_EXPORT void V3d_View::SetLightOff (const Handle(V3d_Light)& MyLight);
friend
//! Deactivate all the Lights defined in this view.
Standard_EXPORT void V3d_View::SetLightOff();
friend
//! Updates the lights of the view. The view is redrawn.
Standard_EXPORT void V3d_View::UpdateLights() const;
DEFINE_STANDARD_RTTI(V3d_Light,MMgt_TShared)
protected:
Standard_EXPORT V3d_Light(const Handle(V3d_Viewer)& VM);
Standard_EXPORT V3d_Light (const Handle(V3d_Viewer)& theViewer);
//! Sets type of the light.
Standard_EXPORT void SetType (const V3d_TypeOfLight theType);
//! Returns the symetric point coordinates of "aPoint"
//! on the sphere of center "Center" and radius "Radius".
//! VX,VY,VZ is the project vector of view.
Standard_EXPORT static void SymetricPointOnSphere (const Handle(V3d_View)& aView, const Graphic3d_Vertex& Center, const Graphic3d_Vertex& aPoint, const Quantity_Parameter Radius, V3d_Coordinate& X, V3d_Coordinate& Y, V3d_Coordinate& Z, Quantity_Parameter& VX, Quantity_Parameter& VY, Quantity_Parameter& VZ);
V3d_TypeOfLight MyType;
Handle(Visual3d_Light) MyLight;
Handle(Graphic3d_Structure) MyGraphicStructure;
Handle(Graphic3d_Structure) MyGraphicStructure1;
private:
//! Returns the Light of the associated Visual3d.
Standard_EXPORT Handle(Visual3d_Light) Light() const;
protected:
//! Return light properties associated to this light source.
//! Hidden method exposed only to V3d_View.
Standard_EXPORT const Graphic3d_CLight& Light() const { return myLight; }
protected:
Graphic3d_CLight myLight;
Handle(Graphic3d_Structure) myGraphicStructure;
Handle(Graphic3d_Structure) myGraphicStructure1;
};
#endif // _V3d_Light_HeaderFile

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