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

0023710: Simplification of presentation managment classes

Browse Source 
Merge PrsMgr_Presentation3d into PrsMgr_Presentation
Cosmetics
This commit is contained in:
kgv 2014-04-03 15:33:26 +04:00 committed by apn
parent 4349c10e18
commit af324faa80
20 changed files with 746 additions and 899 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/AIS/AIS_ConnectedInteractive.cxx
View File

@ -22,7 +22,7 @@
#include <Geom_Transformation.hxx> #include <Geom_Transformation.hxx>
#include <PrsMgr_ModedPresentation.hxx> #include <PrsMgr_ModedPresentation.hxx>
#include <PrsMgr_Presentation3d.hxx> #include <PrsMgr_Presentation.hxx>
#include <OSD_Timer.hxx> #include <OSD_Timer.hxx>
@ -84,18 +84,19 @@ Connect(const Handle(AIS_InteractiveObject)& anotherIobj,
//======================================================================= //=======================================================================
//function : Disconnect //function : Disconnect
//purpose : //purpose :
//======================================================================= //=======================================================================
void AIS_ConnectedInteractive::Disconnect() void AIS_ConnectedInteractive::Disconnect()
{ {
for(Standard_Integer i =1;i<=myPresentations.Length();i++) for(Standard_Integer aPrsIter = 1; aPrsIter <= myPresentations.Length(); ++aPrsIter)
{
const Handle(PrsMgr_Presentation)& aPrs = myPresentations (aPrsIter).Presentation();
if (!aPrs.IsNull())
{ {
Handle(PrsMgr_Presentation3d) P = Handle(PrsMgr_Presentation3d)::DownCast(myPresentations(i).Presentation()); aPrs->Presentation()->DisconnectAll (Graphic3d_TOC_DESCENDANT);
if(!P.IsNull()) {
P->Presentation()->DisconnectAll(Graphic3d_TOC_DESCENDANT);
}
} }
}
} }
//======================================================================= //=======================================================================
//function : Compute //function : Compute

122
src/AIS/AIS_InteractiveObject.cxx
View File

@ -23,16 +23,9 @@
// instead a restricted object NameOfColor. // instead a restricted object NameOfColor.
// Add SetCurrentFacingModel() method // Add SetCurrentFacingModel() method
#define IMP020200 //GG Add SetTransformation() method
#define IMP140200 //GG Add HasPresentation() and Presentation() methods
// Add SetAspect() method.
#define BUC60632 //GG 15/03/00 Add protection on SetDisplayMode() #define BUC60632 //GG 15/03/00 Add protection on SetDisplayMode()
// method, compute only authorized presentation. // method, compute only authorized presentation.
#define IMP220501 //GG CADPAK_V2 Update selection properly
#define OCC708 //SAV unsetting transformation correctly #define OCC708 //SAV unsetting transformation correctly
#include <AIS_InteractiveObject.ixx> #include <AIS_InteractiveObject.ixx>
@ -550,33 +543,31 @@ void AIS_InteractiveObject::SetInfiniteState(const Standard_Boolean aFlag)
P->SetInfiniteState(myInfiniteState);} P->SetInfiniteState(myInfiniteState);}
} }
#ifdef IMP020200
//======================================================================= //=======================================================================
//function : SetTransformation //function : SetTransformation
//purpose : //purpose :
//======================================================================= //=======================================================================
void AIS_InteractiveObject::SetTransformation(const Handle(Geom_Transformation)& aTrsf, const Standard_Boolean postConcatenate, const Standard_Boolean updateSelection) { void AIS_InteractiveObject::SetTransformation (const Handle(Geom_Transformation)& theTrsf,
const Standard_Boolean theToPostConcatenate,
const Standard_Boolean theToUpdateSelection)
{
if (GetContext().IsNull())
{
return;
}
if(!GetContext().IsNull()){ const PrsMgr_Presentations& aPrsList = Presentations();
const PrsMgr_Presentations& prs = Presentations(); myHasTransformation = Standard_True;
Handle(Prs3d_Presentation) P; for (Standard_Integer aPrsIter = 1; aPrsIter <= aPrsList.Length(); ++aPrsIter)
Standard_Integer mode; {
myHasTransformation = Standard_True; const Standard_Integer aMode = aPrsList (aPrsIter).Mode();
for( Standard_Integer i=1 ; i<=prs.Length() ; i++ ) { Handle(Prs3d_Presentation) aPrs = GetContext()->MainPrsMgr()->Presentation (this, aMode)->Presentation();
mode = prs(i).Mode(); theToPostConcatenate ? aPrs->Multiply (theTrsf)
P = GetContext()->MainPrsMgr()->CastPresentation(this,mode)->Presentation(); : aPrs->Transform (theTrsf);
if( postConcatenate ) P->Multiply(aTrsf); if (theToUpdateSelection)
else P->Transform(aTrsf); {
if( updateSelection ) { myCTXPtr->ClearSelected (Standard_True);
#ifdef IMP220501 myCTXPtr->RecomputeSelectionOnly (this);
myCTXPtr->ClearSelected(Standard_True);
myCTXPtr->RecomputeSelectionOnly(this);
#else
if( HasSelection(mode) ) {
UpdateSelection(mode);
}
#endif
}
} }
} }
} }
@ -598,21 +589,22 @@ Handle(Geom_Transformation) trsf;
//======================================================================= //=======================================================================
//function : Transformation //function : Transformation
//purpose : //purpose :
//======================================================================= //=======================================================================
Handle(Geom_Transformation) AIS_InteractiveObject::Transformation() { Handle(Geom_Transformation) AIS_InteractiveObject::Transformation()
Handle(Geom_Transformation) trsf; {
if (GetContext().IsNull())
if(!GetContext().IsNull() ) { {
const PrsMgr_Presentations& prs = Presentations(); return Handle(Geom_Transformation)();
if( prs.Length() > 0 ) {
Handle(Prs3d_Presentation) P =
GetContext()->MainPrsMgr()->CastPresentation(this,1)->Presentation();
trsf = P->Transformation();
}
} }
return trsf; const PrsMgr_Presentations& aPrsList = Presentations();
if (aPrsList.Length() > 0)
{
Handle(Prs3d_Presentation) aPrs = GetContext()->MainPrsMgr()->Presentation (this, 1)->Presentation();
return aPrs->Transformation();
}
return Handle(Geom_Transformation)();
} }
//======================================================================= //=======================================================================
@ -623,36 +615,26 @@ Standard_Boolean AIS_InteractiveObject::HasTransformation() const {
return myHasTransformation; return myHasTransformation;
} }
#endif
#ifdef IMP140200
//======================================================================= //=======================================================================
//function : HasPresentation //function : HasPresentation
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean AIS_InteractiveObject::HasPresentation() const { Standard_Boolean AIS_InteractiveObject::HasPresentation() const
{
if( !GetContext().IsNull() && return !GetContext().IsNull()
GetContext()->MainPrsMgr()->HasPresentation(this,myDisplayMode) ) { && GetContext()->MainPrsMgr()->HasPresentation (this, myDisplayMode);
return Standard_True;
}
return Standard_False;
} }
//======================================================================= //=======================================================================
//function : Presentation //function : Presentation
//purpose : //purpose :
//======================================================================= //=======================================================================
Handle(Prs3d_Presentation) AIS_InteractiveObject::Presentation() const { Handle(Prs3d_Presentation) AIS_InteractiveObject::Presentation() const
Handle(Prs3d_Presentation) prs; {
return HasPresentation()
if( HasPresentation() ) { ? GetContext()->MainPrsMgr()->Presentation (this, myDisplayMode)->Presentation()
prs = GetContext()->MainPrsMgr()-> : Handle(Prs3d_Presentation)();
CastPresentation(this,myDisplayMode)->Presentation();
}
return prs;
} }
//======================================================================= //=======================================================================
@ -698,9 +680,6 @@ void AIS_InteractiveObject::SetAspect(const Handle(Prs3d_BasicAspect)& anAspect,
} }
} }
} }
#endif
// OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
//======================================================================= //=======================================================================
//function : SetPolygonOffsets //function : SetPolygonOffsets
@ -716,12 +695,11 @@ void AIS_InteractiveObject::SetPolygonOffsets(const Standard_Integer aMode,
myDrawer->ShadingAspect()->Aspect()->SetPolygonOffsets( aMode, aFactor, aUnits ); myDrawer->ShadingAspect()->Aspect()->SetPolygonOffsets( aMode, aFactor, aUnits );
// Modify existing presentations // Modify existing presentations
Handle(Graphic3d_Structure) aStruct; for (Standard_Integer aPrsIter = 1, n = myPresentations.Length(); aPrsIter <= n; ++aPrsIter)
for( Standard_Integer i = 1, n = myPresentations.Length(); i <= n; i++ ) { {
Handle(PrsMgr_Presentation3d) aPrs3d = const Handle(PrsMgr_Presentation)& aPrs3d = myPresentations (aPrsIter).Presentation();
Handle(PrsMgr_Presentation3d)::DownCast( myPresentations(i).Presentation() );
if ( !aPrs3d.IsNull() ) { if ( !aPrs3d.IsNull() ) {
aStruct = Handle(Graphic3d_Structure)::DownCast( aPrs3d->Presentation() ); const Handle(Graphic3d_Structure)& aStruct = aPrs3d->Presentation();
if( !aStruct.IsNull() ) { if( !aStruct.IsNull() ) {
aStruct->SetPrimitivesAspect( myDrawer->ShadingAspect()->Aspect() ); aStruct->SetPrimitivesAspect( myDrawer->ShadingAspect()->Aspect() );
// Workaround for issue 23115: Need to update also groups, because their // Workaround for issue 23115: Need to update also groups, because their
@ -750,7 +728,6 @@ void AIS_InteractiveObject::SetPolygonOffsets(const Standard_Integer aMode,
} }
} }
//======================================================================= //=======================================================================
//function : HasPolygonOffsets //function : HasPolygonOffsets
//purpose : //purpose :
@ -773,4 +750,3 @@ void AIS_InteractiveObject::PolygonOffsets(Standard_Integer& aMode,
if( HasPolygonOffsets() ) if( HasPolygonOffsets() )
myDrawer->ShadingAspect()->Aspect()->PolygonOffsets( aMode, aFactor, aUnits ); myDrawer->ShadingAspect()->Aspect()->PolygonOffsets( aMode, aFactor, aUnits );
} }
// OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets

2
src/AIS/AIS_LocalContext.cxx
View File

@ -1195,7 +1195,7 @@ Standard_Boolean AIS_LocalContext::ImmediateAdd (const Handle(AIS_InteractiveObj
return Standard_False; return Standard_False;
} }
myMainPM->AddToImmediateList (myMainPM->CastPresentation (theObj, theMode)->Presentation()); myMainPM->AddToImmediateList (myMainPM->Presentation (theObj, theMode)->Presentation());
return Standard_True; return Standard_True;
} }

11
src/AIS/AIS_MultipleConnectedInteractive.cxx
View File

@ -22,7 +22,7 @@
#include <AIS_MultipleConnectedInteractive.ixx> #include <AIS_MultipleConnectedInteractive.ixx>
#include <PrsMgr_ModedPresentation.hxx> #include <PrsMgr_ModedPresentation.hxx>
#include <PrsMgr_Presentation3d.hxx> #include <PrsMgr_Presentation.hxx>
static Standard_Boolean IsInSeq (const AIS_SequenceOfInteractive& theSeq, static Standard_Boolean IsInSeq (const AIS_SequenceOfInteractive& theSeq,
const Handle(AIS_InteractiveObject)& theItem) const Handle(AIS_InteractiveObject)& theItem)
@ -113,11 +113,12 @@ void AIS_MultipleConnectedInteractive::Disconnect(const Handle(AIS_InteractiveOb
void AIS_MultipleConnectedInteractive::DisconnectAll () void AIS_MultipleConnectedInteractive::DisconnectAll ()
{ {
/* for(Standard_Integer i =1;i<=myPresentations.Length();i++) /* for (Standard_Integer aPrsIter = 1; aPrsIter <= myPresentations.Length(); ++aPrsIter)
{ {
Handle(PrsMgr_Presentation3d) P = Handle(PrsMgr_Presentation3d)::DownCast(myPresentations(i).Presentation()); const Handle(PrsMgr_Presentation)& aPrs = myPresentations (aPrsIter).Presentation();
if(!P.IsNull()) { if (!aPrs.IsNull())
P->Presentation()->DisconnectAll(Graphic3d_TOC_DESCENDANT); {
aPrs->Presentation()->DisconnectAll (Graphic3d_TOC_DESCENDANT);
} }
}*/ }*/
myPreviousReferences = myReferences; // pour garder les poignees au chaud!!!! myPreviousReferences = myReferences; // pour garder les poignees au chaud!!!!

21
src/AIS/AIS_Shape.cxx
View File

@ -523,8 +523,7 @@ void AIS_Shape::SetColor(const Quantity_Color &aCol)
// fast shading modification... // fast shading modification...
if(!GetContext().IsNull()){ if(!GetContext().IsNull()){
if( GetContext()->MainPrsMgr()->HasPresentation(this,1)){ if( GetContext()->MainPrsMgr()->HasPresentation(this,1)){
Handle(Prs3d_Presentation) aPresentation = Handle(Prs3d_Presentation) aPresentation = GetContext()->MainPrsMgr()->Presentation (this, 1)->Presentation();
GetContext()->MainPrsMgr()->CastPresentation(this,1)->Presentation();
Handle(Graphic3d_Group) aCurGroup = Prs3d_Root::CurrentGroup(aPresentation); Handle(Graphic3d_Group) aCurGroup = Prs3d_Root::CurrentGroup(aPresentation);
Handle(Graphic3d_AspectFillArea3d) anAreaAspect = myDrawer->ShadingAspect()->Aspect(); Handle(Graphic3d_AspectFillArea3d) anAreaAspect = myDrawer->ShadingAspect()->Aspect();
Handle(Graphic3d_AspectLine3d) aLineAspect = myDrawer->LineAspect()->Aspect(); Handle(Graphic3d_AspectLine3d) aLineAspect = myDrawer->LineAspect()->Aspect();
@ -602,8 +601,7 @@ void AIS_Shape::UnsetColor()
if(!GetContext().IsNull()){ if(!GetContext().IsNull()){
if(GetContext()->MainPrsMgr()->HasPresentation(this,1)){ if(GetContext()->MainPrsMgr()->HasPresentation(this,1)){
Handle(Prs3d_Presentation) aPresentation = Handle(Prs3d_Presentation) aPresentation = GetContext()->MainPrsMgr()->Presentation (this, 1)->Presentation();
GetContext()->MainPrsMgr()->CastPresentation(this,1)->Presentation();
Handle(Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup(aPresentation); Handle(Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup(aPresentation);
Handle(Graphic3d_AspectFillArea3d) anAreaAsp = myDrawer->Link()->ShadingAspect()->Aspect(); Handle(Graphic3d_AspectFillArea3d) anAreaAsp = myDrawer->Link()->ShadingAspect()->Aspect();
@ -717,9 +715,9 @@ void AIS_Shape::SetMaterial(const Graphic3d_MaterialAspect& aMat)
myDrawer->ShadingAspect()->SetTransparency(myTransparency,myCurrentFacingModel); myDrawer->ShadingAspect()->SetTransparency(myTransparency,myCurrentFacingModel);
if(!GetContext().IsNull()){ if(!GetContext().IsNull()){
if(GetContext()->MainPrsMgr()->HasPresentation(this,1)){ if(GetContext()->MainPrsMgr()->HasPresentation(this,1))
Handle(Prs3d_Presentation) aPresentation = {
GetContext()->MainPrsMgr()->CastPresentation(this,1)->Presentation(); Handle(Prs3d_Presentation) aPresentation = GetContext()->MainPrsMgr()->Presentation (this, 1)->Presentation();
Handle(Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup(aPresentation); Handle(Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup(aPresentation);
Handle(Graphic3d_AspectFillArea3d) anAreaAsp = myDrawer->ShadingAspect()->Aspect(); Handle(Graphic3d_AspectFillArea3d) anAreaAsp = myDrawer->ShadingAspect()->Aspect();
@ -761,8 +759,7 @@ void AIS_Shape::UnsetMaterial()
hasOwnMaterial = Standard_False; hasOwnMaterial = Standard_False;
if(!GetContext().IsNull()){ if(!GetContext().IsNull()){
if(GetContext()->MainPrsMgr()->HasPresentation(this,1)){ if(GetContext()->MainPrsMgr()->HasPresentation(this,1)){
Handle(Prs3d_Presentation) aPresentation = Handle(Prs3d_Presentation) aPresentation = GetContext()->MainPrsMgr()->Presentation (this, 1)->Presentation();
GetContext()->MainPrsMgr()->CastPresentation(this,1)->Presentation();
Handle(Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup(aPresentation); Handle(Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup(aPresentation);
Handle(Graphic3d_AspectFillArea3d) anAreaAsp = myDrawer->ShadingAspect()->Aspect(); Handle(Graphic3d_AspectFillArea3d) anAreaAsp = myDrawer->ShadingAspect()->Aspect();
aPresentation->SetPrimitivesAspect(anAreaAsp); aPresentation->SetPrimitivesAspect(anAreaAsp);
@ -792,8 +789,7 @@ void AIS_Shape::SetTransparency(const Standard_Real AValue)
if(!GetContext().IsNull()){ if(!GetContext().IsNull()){
if(GetContext()->MainPrsMgr()->HasPresentation(this,1)){ if(GetContext()->MainPrsMgr()->HasPresentation(this,1)){
Handle(Prs3d_Presentation) aPresentation = Handle(Prs3d_Presentation) aPresentation = GetContext()->MainPrsMgr()->Presentation (this, 1)->Presentation();
GetContext()->MainPrsMgr()->CastPresentation(this,1)->Presentation();
Handle(Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup(aPresentation); Handle(Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup(aPresentation);
Handle(Graphic3d_AspectFillArea3d) anAreaAsp = myDrawer->ShadingAspect()->Aspect(); Handle(Graphic3d_AspectFillArea3d) anAreaAsp = myDrawer->ShadingAspect()->Aspect();
aPresentation->SetPrimitivesAspect(anAreaAsp); aPresentation->SetPrimitivesAspect(anAreaAsp);
@ -828,8 +824,7 @@ void AIS_Shape::UnsetTransparency()
if(!GetContext().IsNull()){ if(!GetContext().IsNull()){
if(GetContext()->MainPrsMgr()->HasPresentation(this,1)){ if(GetContext()->MainPrsMgr()->HasPresentation(this,1)){
Handle(Prs3d_Presentation) aPresentation = Handle(Prs3d_Presentation) aPresentation = GetContext()->MainPrsMgr()->Presentation (this, 1)->Presentation();
GetContext()->MainPrsMgr()->CastPresentation(this,1)->Presentation();
Handle(Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup(aPresentation); Handle(Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup(aPresentation);
Handle(Graphic3d_AspectFillArea3d) anAreaAsp = myDrawer->ShadingAspect()->Aspect(); Handle(Graphic3d_AspectFillArea3d) anAreaAsp = myDrawer->ShadingAspect()->Aspect();
aPresentation->SetPrimitivesAspect(anAreaAsp); aPresentation->SetPrimitivesAspect(anAreaAsp);

9
src/PrsMgr/PrsMgr.cdl
View File

@ -41,9 +41,6 @@ uses
is is
enumeration KindOfPrs is KOP_2D,KOP_3D
end KindOfPrs;
enumeration TypeOfPresentation3d is TOP_AllView, TOP_ProjectorDependant enumeration TypeOfPresentation3d is TOP_AllView, TOP_ProjectorDependant
end TypeOfPresentation3d; end TypeOfPresentation3d;
---Purpose: To declare the type of presentation as follows ---Purpose: To declare the type of presentation as follows
@ -55,17 +52,17 @@ is
class PresentationManager; class PresentationManager;
alias PresentationManager3d is PresentationManager; alias PresentationManager3d is PresentationManager;
deferred class Presentation; class Presentation;
alias Presentation3d is Presentation;
deferred class PresentableObject; deferred class PresentableObject;
imported ListOfPresentations; imported ListOfPresentations;
class Prs; class Prs;
class Presentation3d;
class ModedPresentation; class ModedPresentation;
class Presentations instantiates Sequence from TCollection class Presentations instantiates Sequence from TCollection
(ModedPresentation from PrsMgr); (ModedPresentation from PrsMgr);
pointer Presentation3dPointer to Presentation3d from PrsMgr; pointer PresentationPointer to Presentation from PrsMgr;
pointer PresentableObjectPointer to PresentableObject from PrsMgr; pointer PresentableObjectPointer to PresentableObject from PrsMgr;
end PrsMgr; end PrsMgr;

29
src/PrsMgr/PrsMgr_ModedPresentation.cdl
View File

@ -17,26 +17,27 @@
class ModedPresentation from PrsMgr class ModedPresentation from PrsMgr
uses uses
Presentation from PrsMgr
Presentation from PrsMgr
is is
Create
returns ModedPresentation from PrsMgr;
Create(aPresentation:Presentation from PrsMgr;
aMode: Integer from Standard)
returns ModedPresentation from PrsMgr;
Presentation(me) returns Presentation from PrsMgr
is static;
Mode(me) returns Integer from Standard; Create
returns ModedPresentation from PrsMgr;
Create (thePrs : Presentation from PrsMgr;
theMode : Integer from Standard)
returns ModedPresentation from PrsMgr;
Presentation (me) returns Presentation from PrsMgr
is static;
---C++: return const&
Mode (me) returns Integer from Standard;
fields fields
myPresentation: Presentation from PrsMgr; myPresentation: Presentation from PrsMgr;
myMode: Integer from Standard; myMode: Integer from Standard;
end ModedPresentation from PrsMgr; end ModedPresentation from PrsMgr;

18
src/PrsMgr/PrsMgr_ModedPresentation.cxx
View File

@ -14,17 +14,23 @@
#include <PrsMgr_ModedPresentation.ixx> #include <PrsMgr_ModedPresentation.ixx>
PrsMgr_ModedPresentation::PrsMgr_ModedPresentation() {} PrsMgr_ModedPresentation::PrsMgr_ModedPresentation()
: myMode (0) {}
PrsMgr_ModedPresentation::PrsMgr_ModedPresentation(const Handle(PrsMgr_Presentation)& aPresentation, const Standard_Integer aMode): myPresentation(aPresentation), myMode(aMode) { PrsMgr_ModedPresentation::PrsMgr_ModedPresentation (const Handle(PrsMgr_Presentation)& thePrs,
const Standard_Integer theMode)
: myPresentation (thePrs),
myMode (theMode)
{
//
} }
Handle(PrsMgr_Presentation) PrsMgr_ModedPresentation::Presentation () const { const Handle(PrsMgr_Presentation)& PrsMgr_ModedPresentation::Presentation() const
{
return myPresentation; return myPresentation;
} }
Standard_Integer PrsMgr_ModedPresentation::Mode () const { Standard_Integer PrsMgr_ModedPresentation::Mode() const
{
return myMode; return myMode;
} }

18
src/PrsMgr/PrsMgr_PresentableObject.cdl
View File

@ -291,14 +291,14 @@ fields
myTransformPersistence : CTransPersStruct from Graphic3d; myTransformPersistence : CTransPersStruct from Graphic3d;
friends friends
class Presentation3d from PrsMgr, class Presentation from PrsMgr,
class PresentationManager from PrsMgr, class PresentationManager from PrsMgr,
Compute from Presentation3d from PrsMgr(me : mutable; aProjector : DataStructureManager from Graphic3d), Compute from Presentation from PrsMgr(me : mutable; aProjector : DataStructureManager from Graphic3d),
Compute from Presentation3d from PrsMgr(me : mutable; aProjector : DataStructureManager from Graphic3d; Compute from Presentation from PrsMgr(me : mutable; aProjector : DataStructureManager from Graphic3d;
aGivenStruct : Structure from Graphic3d), aGivenStruct : Structure from Graphic3d),
Compute from Presentation3d from PrsMgr(me : mutable; aProjector : DataStructureManager from Graphic3d; Compute from Presentation from PrsMgr(me : mutable; aProjector : DataStructureManager from Graphic3d;
TheTrsf : Transformation from Geom), TheTrsf : Transformation from Geom),
Compute from Presentation3d from PrsMgr(me : mutable; aProjector : DataStructureManager from Graphic3d; Compute from Presentation from PrsMgr(me : mutable; aProjector : DataStructureManager from Graphic3d;
TheTrsf : Transformation from Geom; TheTrsf : Transformation from Geom;
aGivenStruct : Structure from Graphic3d) aGivenStruct : Structure from Graphic3d)
end PresentableObject from PrsMgr; end PresentableObject from PrsMgr;

138
src/PrsMgr/PrsMgr_PresentableObject.cxx
View File

@ -14,13 +14,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
// Modified by Rob
// 16-dec-1997 : Update Flag for Presentations.
#include <PrsMgr_PresentableObject.ixx> #include <PrsMgr_PresentableObject.ixx>
#include <PrsMgr_Presentation.hxx> #include <PrsMgr_Presentation.hxx>
#include <PrsMgr_Presentation3d.hxx>
#include <PrsMgr_ModedPresentation.hxx> #include <PrsMgr_ModedPresentation.hxx>
#include <PrsMgr_PresentationManager.hxx> #include <PrsMgr_PresentationManager.hxx>
#include <TColStd_ListIteratorOfListOfInteger.hxx> #include <TColStd_ListIteratorOfListOfInteger.hxx>
@ -45,32 +40,24 @@ PrsMgr_PresentableObject::PrsMgr_PresentableObject(const PrsMgr_TypeOfPresentati
//function : Fill //function : Fill
//purpose : //purpose :
//======================================================================= //=======================================================================
void PrsMgr_PresentableObject::Fill (const Handle(PrsMgr_PresentationManager)& aPresentationManager, void PrsMgr_PresentableObject::Fill (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
const Handle(PrsMgr_Presentation)& aPresentation, const Handle(PrsMgr_Presentation)& thePrs,
const Standard_Integer aMode) const Standard_Integer theMode)
{ {
if (aPresentation->DynamicType() == STANDARD_TYPE (PrsMgr_Presentation3d)) Handle(Prs3d_Presentation) aStruct3d = thePrs->Presentation();
{ Compute (thePrsMgr, aStruct3d, theMode);
Handle(PrsMgr_PresentationManager3d) aPrsMgr3d = UpdateLocation (aStruct3d);
(Handle(PrsMgr_PresentationManager3d)&)aPresentationManager; aStruct3d->SetClipPlanes (myClipPlanes);
Handle(PrsMgr_Presentation3d) aPrs3d = aStruct3d->SetTransformPersistence (GetTransformPersistenceMode(), GetTransformPersistencePoint());
(Handle(PrsMgr_Presentation3d)&)aPresentation;
Handle(Prs3d_Presentation) aStruct3d = aPrs3d->Presentation();
Compute (aPrsMgr3d, aStruct3d, aMode);
UpdateLocation (aStruct3d);
aStruct3d->SetClipPlanes (myClipPlanes);
aStruct3d->SetTransformPersistence (GetTransformPersistenceMode(), GetTransformPersistencePoint());
}
} }
//======================================================================= //=======================================================================
//function : Compute //function : Compute
//purpose : //purpose :
//======================================================================= //=======================================================================
void PrsMgr_PresentableObject::Compute(const Handle(PrsMgr_PresentationManager3d)& /*aPresentationManager*/, void PrsMgr_PresentableObject::Compute (const Handle(PrsMgr_PresentationManager)& /*aPresentationManager*/,
const Handle(Prs3d_Presentation)& /*aPresentation*/, const Handle(Prs3d_Presentation)& /*aPresentation*/,
const Standard_Integer /*aMode*/) const Standard_Integer /*aMode*/)
{ {
Standard_NotImplemented::Raise("cannot compute in a 3d visualizer"); Standard_NotImplemented::Raise("cannot compute in a 3d visualizer");
} }
@ -214,20 +201,17 @@ void PrsMgr_PresentableObject::ToBeUpdated(TColStd_ListOfInteger& OutList) const
//======================================================================= //=======================================================================
//function : SetTypeOfPresentation //function : SetTypeOfPresentation
//purpose : //purpose :
//======================================================================= //=======================================================================
void PrsMgr_PresentableObject::SetTypeOfPresentation(const PrsMgr_TypeOfPresentation3d aType) void PrsMgr_PresentableObject::SetTypeOfPresentation (const PrsMgr_TypeOfPresentation3d theType)
{ {
myTypeOfPresentation3d = aType; myTypeOfPresentation3d = theType;
for(Standard_Integer aPrsIter = 1; aPrsIter <= myPresentations.Length(); ++aPrsIter)
for(Standard_Integer IP =1; IP<=myPresentations.Length();IP++){ {
const Handle(PrsMgr_Presentation)& P = myPresentations(IP).Presentation(); const Handle(PrsMgr_Presentation)& aPrs = myPresentations (aPrsIter).Presentation();
if(P->KindOfPresentation()==PrsMgr_KOP_3D){ aPrs->Presentation()->SetVisual (myTypeOfPresentation3d == PrsMgr_TOP_ProjectorDependant
Graphic3d_TypeOfStructure Typ = ? Graphic3d_TOS_COMPUTED
(myTypeOfPresentation3d == PrsMgr_TOP_ProjectorDependant)? : Graphic3d_TOS_ALL);
Graphic3d_TOS_COMPUTED : Graphic3d_TOS_ALL;
(*(Handle(PrsMgr_Presentation3d)*)&P)->Presentation()->SetVisual(Typ);
}
} }
} }
@ -249,13 +233,10 @@ void PrsMgr_PresentableObject::SetLocation(const TopLoc_Location& aLoc)
void PrsMgr_PresentableObject::ResetLocation() void PrsMgr_PresentableObject::ResetLocation()
{ {
TopLoc_Location aLoc; TopLoc_Location aLoc;
Handle(Geom_Transformation) G = new Geom_Transformation(aLoc.Transformation()); Handle(Geom_Transformation) aTrsf = new Geom_Transformation (aLoc.Transformation());
for (Standard_Integer aPrsIter = 1; aPrsIter <= myPresentations.Length(); ++aPrsIter)
for(Standard_Integer i=1;i<=myPresentations.Length();i++){ {
const Handle(PrsMgr_Presentation)& P = myPresentations(i).Presentation(); myPresentations (aPrsIter).Presentation()->Transform (aTrsf);
if(P->KindOfPresentation()==PrsMgr_KOP_3D){
(*((Handle(PrsMgr_Presentation3d)*)&P))->Transform(G);
}
} }
myLocation = aLoc; myLocation = aLoc;
} }
@ -266,14 +247,20 @@ void PrsMgr_PresentableObject::ResetLocation()
//======================================================================= //=======================================================================
void PrsMgr_PresentableObject::UpdateLocation() void PrsMgr_PresentableObject::UpdateLocation()
{ {
if(!HasLocation()) return; if (!HasLocation())
Handle(Geom_Transformation) G = new Geom_Transformation(Location().Transformation()); {
if(G->Trsf().Form()==gp_Identity) return; return;
for (Standard_Integer i=1;i<=myPresentations.Length();i++){ }
const Handle(PrsMgr_Presentation)& P = myPresentations(i).Presentation();
if(P->KindOfPresentation()==PrsMgr_KOP_3D){ Handle(Geom_Transformation) aTrsf = new Geom_Transformation (Location().Transformation());
(*((Handle(PrsMgr_Presentation3d)*)&P))->Transform(G); if (aTrsf->Trsf().Form() == gp_Identity)
} {
return;
}
for (Standard_Integer aPrsIter = 1; aPrsIter <= myPresentations.Length(); ++aPrsIter)
{
myPresentations (aPrsIter).Presentation()->Transform (aTrsf);
} }
} }
@ -291,28 +278,24 @@ void PrsMgr_PresentableObject::UpdateLocation(const Handle(Prs3d_Presentation)&
//======================================================================= //=======================================================================
//function : SetTransformPersistence //function : SetTransformPersistence
//purpose : //purpose :
//======================================================================= //=======================================================================
void PrsMgr_PresentableObject::SetTransformPersistence( const Graphic3d_TransModeFlags& TheFlag, void PrsMgr_PresentableObject::SetTransformPersistence (const Graphic3d_TransModeFlags& theFlag,
const gp_Pnt& ThePoint ) const gp_Pnt& thePoint)
{ {
myTransformPersistence.Flag = TheFlag; myTransformPersistence.Flag = theFlag;
myTransformPersistence.Point.x = (Standard_ShortReal)ThePoint.X(); myTransformPersistence.Point.x = (Standard_ShortReal )thePoint.X();
myTransformPersistence.Point.y = (Standard_ShortReal)ThePoint.Y(); myTransformPersistence.Point.y = (Standard_ShortReal )thePoint.Y();
myTransformPersistence.Point.z = (Standard_ShortReal)ThePoint.Z(); myTransformPersistence.Point.z = (Standard_ShortReal )thePoint.Z();
for (Standard_Integer aPrsIter = 1; aPrsIter <= myPresentations.Length(); ++aPrsIter)
Handle(Graphic3d_Structure) aStruct; {
for( Standard_Integer i = 1, n = myPresentations.Length(); i <= n; i++ ) const Handle(PrsMgr_Presentation)& aPrs3d = myPresentations (aPrsIter).Presentation();
if (!aPrs3d.IsNull()
&& !aPrs3d->Presentation().IsNull())
{ {
Handle(PrsMgr_Presentation3d) aPrs3d = aPrs3d->Presentation()->SetTransformPersistence (theFlag, thePoint);
Handle(PrsMgr_Presentation3d)::DownCast( myPresentations(i).Presentation() );
if ( !aPrs3d.IsNull() )
{
aStruct = Handle(Graphic3d_Structure)::DownCast( aPrs3d->Presentation() );
if( !aStruct.IsNull() )
aStruct->SetTransformPersistence( TheFlag, ThePoint );
}
} }
}
} }
//======================================================================= //=======================================================================
@ -422,17 +405,12 @@ void PrsMgr_PresentableObject::UpdateClipping()
// pass over presentation manager 3d mechanism right to the structures - // pass over presentation manager 3d mechanism right to the structures -
// we do not interested in display mode collections. // we do not interested in display mode collections.
const PrsMgr_ModedPresentation& aModedPrs = myPresentations (aPrsIt); const PrsMgr_ModedPresentation& aModedPrs = myPresentations (aPrsIt);
if (aModedPrs.Presentation().IsNull()
Handle(PrsMgr_Presentation3d) aPrs = || aModedPrs.Presentation()->Presentation().IsNull())
Handle(PrsMgr_Presentation3d)::DownCast (aModedPrs.Presentation()); {
if (aPrs.IsNull())
continue; continue;
}
Handle(Prs3d_Presentation) aStruct3d = aPrs->Presentation(); aModedPrs.Presentation()->Presentation()->SetClipPlanes (myClipPlanes);
if (aStruct3d.IsNull())
continue;
aStruct3d->SetClipPlanes (myClipPlanes);
} }
} }

216
src/PrsMgr/PrsMgr_Presentation.cdl
View File

@ -14,90 +14,186 @@
-- Alternatively, this file may be used under the terms of Open CASCADE -- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement. -- commercial license or contractual agreement.
-- Modified by Rob : 20-feb-1997 class Presentation from PrsMgr
-- Modified by Rob : 16-dec-1997 : kind of presentation inherits TShared from MMgt
deferred class Presentation from PrsMgr
inherits TShared from MMgt
uses uses
PresentationManager from PrsMgr, PresentationManager from PrsMgr,
KindOfPrs from PrsMgr NameOfColor from Quantity,
Transformation from Geom,
Length from Quantity,
ShadingAspect from Prs3d,
TypeOfPresentation3d from PrsMgr,
DataStructureManager from Graphic3d,
Structure from Graphic3d,
PresentableObjectPointer from PrsMgr,PresentableObject from PrsMgr,
Prs from PrsMgr,
Projector from Prs3d,
Presentation from Prs3d
is is
Initialize(aPresentationManager: PresentationManager from PrsMgr) Create (thePresentationManager : PresentationManager from PrsMgr;
is protected; thePresentableObject : PresentableObject from PrsMgr)
returns mutable Presentation from PrsMgr
is private;
KindOfPresentation(me) returns KindOfPrs from PrsMgr is deferred; Destroy (me : mutable) is virtual;
---Purpose: 2D or 3D ---Level: Public
---Purpose: Destructor
Display(me: mutable) is deferred private; ---C++: alias ~
Erase(me: mutable) is deferred private;
SetVisible (me: mutable; theValue: Boolean from Standard) is deferred private; Display (me : mutable)
is virtual private;
Highlight(me: mutable) is deferred private; Display (me : mutable;
theIsHighlight : Boolean from Standard)
Unhighlight (me) is deferred private; is static private;
---Purpose: Displays myStructure and sets myDisplayReason to theIsHighlight value if
IsHighlighted(me) returns Boolean from Standard -- myStructure was not displayed or was invisible
is deferred private;
IsDisplayed(me) returns Boolean from Standard Erase (me : mutable)
is deferred private; is virtual private;
Destroy ( me : mutable ) SetVisible (me : mutable;
is virtual; theValue : Boolean from Standard)
---Level: Public is virtual private;
---Purpose: Destructor
---C++: alias ~
DisplayPriority(me) returns Integer from Standard Highlight (me : mutable) is virtual private;
is deferred private;
SetDisplayPriority(me:mutable;aNewPrior:Integer from Standard)
is deferred private;
SetZLayer ( me : mutable; Unhighlight (me) is virtual private;
theLayerId : Integer from Standard )
is deferred private;
---Purpose: Set Z layer ID for the presentation
GetZLayer ( me ) IsHighlighted (me) returns Boolean from Standard
returns Integer from Standard is deferred private; is virtual private;
---Purpose: Get Z layer ID for the presentation
IsDisplayed (me) returns Boolean from Standard
is virtual private;
DisplayPriority(me) returns Integer from Standard
is virtual private;
SetDisplayPriority(me:mutable;aNewPrior:Integer from Standard)
is virtual private;
SetZLayer (me : mutable;
theLayerId : Integer from Standard)
is virtual private;
---Purpose: Set Z layer ID for the presentation
GetZLayer (me) returns Integer from Standard
is virtual private;
---Purpose: Get Z layer ID for the presentation
Clear (me : mutable)
is virtual private;
---Purpose: removes the whole content of the presentation.
-- Does not remove the other connected presentations.
Color (me : mutable;
theColor : NameOfColor from Quantity)
is static private;
BoundBox (me)
is static private;
---Category: references to other presentation.
Connect (me;
theOther : Presentation from PrsMgr)
is static private;
---Category: Transformation methods.
Transform (me;
theTrsf : Transformation from Geom)
is static private;
Place (me;
theX, theY, theZ : Length from Quantity)
is static private;
Multiply (me;
theTrsf : Transformation from Geom)
is static private;
Move (me;
theX, theY, theZ : Length from Quantity)
is static private;
---Category: Global Aspect methods
SetShadingAspect (me;
theShadingAspect : ShadingAspect from Prs3d)
is static private;
Presentation (me) returns mutable Presentation from Prs3d
is static;
---C++: inline
---C++: return const&
---Category: Computed Structures
Compute (me : mutable;
theStructure : Structure from Graphic3d)
is static private;
Compute (me : mutable;
theProjector : DataStructureManager from Graphic3d)
returns Structure from Graphic3d
is static private;
Compute (me : mutable;
theProjector : DataStructureManager from Graphic3d;
theTrsf : Transformation from Geom)
returns Structure from Graphic3d
is static private;
Compute (me : mutable;
theProjector : DataStructureManager from Graphic3d;
theGivenStruct : Structure from Graphic3d)
is static private;
Compute (me : mutable;
theProjector : DataStructureManager from Graphic3d;
theTrsf : Transformation from Geom;
theGivenStruct : Structure from Graphic3d)
is static private;
Clear(me: mutable)
is deferred private;
---Category: Inquire Methods ---Category: Inquire Methods
--
PresentationManager(me) returns mutable PresentationManager
---Purpose: returns the PresentationManager in which the
-- presentation has been created.
is static;
---C++: inline
---C++: return const&
PresentationManager (me) returns mutable PresentationManager
---Purpose: returns the PresentationManager in which the presentation has been created.
is static;
---C++: inline
---C++: return const&
Projector (myclass;
theProjector : DataStructureManager from Graphic3d)
returns Projector from Prs3d
is private;
---Category: Internal Methods ---Category: Internal Methods
SetUpdateStatus(me:mutable; aStat : Boolean from Standard); SetUpdateStatus (me : mutable;
---C++: inline theStat : Boolean from Standard);
---C++: inline
MustBeUpdated(me) returns Boolean from Standard;
---C++: inline
MustBeUpdated (me) returns Boolean from Standard;
---C++: inline
fields fields
myPresentationManager: PresentationManager from PrsMgr is protected; myPresentationManager : PresentationManager from PrsMgr;
myMustBeUpdated : Boolean from Standard is protected; myStructure : Prs from PrsMgr;
myPresentableObject : PresentableObjectPointer from PrsMgr;
myMustBeUpdated : Boolean from Standard;
myDisplayReason : Boolean from Standard;
friends friends
class PresentationManager from PrsMgr
class PresentationManager from PrsMgr,
class PresentableObject from PrsMgr,
class Prs from PrsMgr
end Presentation from PrsMgr; end Presentation from PrsMgr;

385
src/PrsMgr/PrsMgr_Presentation.cxx
View File

@ -13,10 +13,387 @@
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <PrsMgr_Presentation.ixx> #include <PrsMgr_Presentation.ixx>
#include <PrsMgr_PresentationManager.hxx>
#include <PrsMgr_Prs.hxx>
#include <PrsMgr_ModedPresentation.hxx>
PrsMgr_Presentation::PrsMgr_Presentation #include <Graphic3d_Structure.hxx>
(const Handle(PrsMgr_PresentationManager)& aPresentationManager) #include <Visual3d_View.hxx>
:myPresentationManager(aPresentationManager),myMustBeUpdated(Standard_False) {} #include <Precision.hxx>
void PrsMgr_Presentation::Destroy () { //=======================================================================
//function : PrsMgr_Presentation
//purpose :
//=======================================================================
PrsMgr_Presentation::PrsMgr_Presentation (const Handle(PrsMgr_PresentationManager3d)& thePrsMgr,
const Handle(PrsMgr_PresentableObject)& thePrsObject)
: myPresentationManager (thePrsMgr),
myPresentableObject (thePrsObject.operator->()),
myMustBeUpdated (Standard_False),
myDisplayReason (Standard_False)
{
myStructure = new PrsMgr_Prs (thePrsMgr->StructureManager(),
this, thePrsObject->TypeOfPresentation3d());
myStructure->SetOwner (myPresentableObject);
}
//=======================================================================
//function : Display
//purpose :
//=======================================================================
void PrsMgr_Presentation::Display()
{
Display (Standard_False);
myDisplayReason = Standard_False;
}
//=======================================================================
//function : Display
//purpose :
//=======================================================================
void PrsMgr_Presentation::Display (const Standard_Boolean theIsHighlight)
{
if (!myStructure->IsDisplayed())
{
myStructure->Display();
myDisplayReason = theIsHighlight;
}
else if (!myStructure->IsVisible())
{
myStructure->SetVisible (Standard_True);
myDisplayReason = theIsHighlight;
}
}
//=======================================================================
//function : Erase
//purpose :
//=======================================================================
void PrsMgr_Presentation::Erase()
{
if (myStructure.IsNull())
{
return;
}
// Erase structure from structure manager
myStructure->Erase();
myStructure->Clear();
// Disconnect other structures
myStructure->DisconnectAll (Graphic3d_TOC_DESCENDANT);
// Clear groups and remove graphic structure
myStructure.Nullify();
}
//=======================================================================
//function : SetVisible
//purpose :
//=======================================================================
void PrsMgr_Presentation::SetVisible (const Standard_Boolean theValue)
{
myStructure->SetVisible (theValue);
}
//=======================================================================
//function : Highlight
//purpose :
//=======================================================================
void PrsMgr_Presentation::Highlight()
{
Display (Standard_True);
myStructure->Highlight();
}
//=======================================================================
//function : Unhighlight
//purpose :
//=======================================================================
void PrsMgr_Presentation::Unhighlight() const
{
myStructure->UnHighlight();
if (myDisplayReason)
{
myStructure->SetVisible (Standard_False);
}
}
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
void PrsMgr_Presentation::Clear()
{
// This modification remove the contain of the structure:
// Consequence:
// 1. The memory zone of the group is reused
// 2. The speed for animation is constant
//myPresentableObject = NULL;
SetUpdateStatus (Standard_True);
if (myStructure.IsNull())
{
return;
}
myStructure->Clear (Standard_True);
// myStructure->Clear(Standard_False);
myStructure->RemoveAll();
}
//=======================================================================
//function : Color
//purpose :
//=======================================================================
void PrsMgr_Presentation::Color (const Quantity_NameOfColor theColor)
{
Display (Standard_True);
myStructure->Color (theColor);
}
//=======================================================================
//function : BoundBox
//purpose :
//=======================================================================
void PrsMgr_Presentation::BoundBox() const
{
myStructure->BoundBox();
}
//=======================================================================
//function : IsDisplayed
//purpose :
//=======================================================================
Standard_Boolean PrsMgr_Presentation::IsDisplayed() const
{
return myStructure->IsDisplayed()
&& myStructure->IsVisible()
&& !myDisplayReason;
}
//=======================================================================
//function : IsHighlighted
//purpose :
//=======================================================================
Standard_Boolean PrsMgr_Presentation::IsHighlighted() const
{
return myStructure->IsHighlighted();
}
//=======================================================================
//function : DisplayPriority
//purpose :
//=======================================================================
Standard_Integer PrsMgr_Presentation::DisplayPriority() const
{
return myStructure->DisplayPriority();
}
//=======================================================================
//function : SetDisplayPriority
//purpose :
//=======================================================================
void PrsMgr_Presentation::SetDisplayPriority (const Standard_Integer theNewPrior)
{
myStructure->SetDisplayPriority (theNewPrior);
}
//=======================================================================
//function : Connect
//purpose :
//=======================================================================
void PrsMgr_Presentation::Connect (const Handle(PrsMgr_Presentation)& theOther) const
{
myStructure->Connect (theOther->Presentation());
}
//=======================================================================
//function : Transform
//purpose :
//=======================================================================
void PrsMgr_Presentation::Transform (const Handle(Geom_Transformation)& theTrsf) const
{
myStructure->Transform (theTrsf);
}
//=======================================================================
//function : Place
//purpose :
//=======================================================================
void PrsMgr_Presentation::Place (const Quantity_Length theX,
const Quantity_Length theY,
const Quantity_Length theZ) const
{
myStructure->Place (theX, theY, theZ);
}
//=======================================================================
//function : Multiply
//purpose :
//=======================================================================
void PrsMgr_Presentation::Multiply (const Handle(Geom_Transformation)& theTrsf) const
{
myStructure->Multiply (theTrsf);
}
//=======================================================================
//function : Move
//purpose :
//=======================================================================
void PrsMgr_Presentation::Move (const Quantity_Length theX,
const Quantity_Length theY,
const Quantity_Length theZ) const
{
myStructure->Move (theX, theY, theZ);
}
//=======================================================================
//function : SetShadingAspect
//purpose :
//=======================================================================
void PrsMgr_Presentation::SetShadingAspect (const Handle(Prs3d_ShadingAspect)& theShadingAspect) const
{
myStructure->SetShadingAspect (theShadingAspect);
}
//=======================================================================
//function : Compute
//purpose : Methods for hidden parts...
//=======================================================================
Handle(Graphic3d_Structure) PrsMgr_Presentation::Compute (const Handle(Graphic3d_DataStructureManager)& theProjector)
{
Handle(Prs3d_Presentation) aPrs = new Prs3d_Presentation (myPresentationManager->StructureManager());
myPresentableObject->Compute (Projector (theProjector), aPrs);
return aPrs;
}
//=======================================================================
//function : Compute
//purpose :
//=======================================================================
void PrsMgr_Presentation::Compute (const Handle(Graphic3d_Structure)& theStructure)
{
Standard_Integer aDispMode = 0;
Standard_Integer aPresentationsNumber = myPresentableObject->myPresentations.Length();
for (Standard_Integer anIter = 1; anIter <= aPresentationsNumber; ++anIter)
{
const PrsMgr_ModedPresentation& aModedPresentation = myPresentableObject->myPresentations.Value (anIter);
if (aModedPresentation.Presentation().operator->() == this)
{
aDispMode = aModedPresentation.Mode();
break;
}
}
Handle(Prs3d_Presentation) aPrs3d = Handle(Prs3d_Presentation)::DownCast (theStructure);
myPresentableObject->Compute (myPresentationManager, aPrs3d, aDispMode);
}
//=======================================================================
//function : Compute
//purpose :
//=======================================================================
void PrsMgr_Presentation::Compute (const Handle(Graphic3d_DataStructureManager)& theProjector,
const Handle(Graphic3d_Structure)& theStructToFill)
{
theStructToFill->Clear();
const Handle(Prs3d_Presentation)& aPrs = *((Handle(Prs3d_Presentation)* )&theStructToFill);
myPresentableObject->Compute (Projector (theProjector), aPrs);
}
//=======================================================================
//function : Compute
//purpose :
//=======================================================================
Handle(Graphic3d_Structure) PrsMgr_Presentation::Compute (const Handle(Graphic3d_DataStructureManager)& theProjector,
const Handle(Geom_Transformation)& theTrsf)
{
Handle(Prs3d_Presentation) aPrs3d = new Prs3d_Presentation (myPresentationManager->StructureManager());
if (theTrsf->Form() == gp_Translation)
{
myPresentableObject->Compute (Projector (theProjector), aPrs3d);
aPrs3d->Transform (theTrsf);
return aPrs3d;
}
// waiting that something is done in gp_Trsf...rob
for (Standard_Integer i = 1; i <= 3; ++i)
{
for (Standard_Integer j = 1; j <= 3; ++j)
{
if (i != j)
{
if (Abs (theTrsf->Value (i, j)) > Precision::Confusion())
{
myPresentableObject->Compute (Projector (theProjector), theTrsf, aPrs3d);
return aPrs3d;
}
}
}
}
myPresentableObject->Compute (Projector (theProjector), aPrs3d);
aPrs3d->Transform (theTrsf);
return aPrs3d;
}
//=======================================================================
//function : Compute
//purpose :
//=======================================================================
void PrsMgr_Presentation::Compute (const Handle(Graphic3d_DataStructureManager)& theProjector,
const Handle(Geom_Transformation)& theTrsf,
const Handle(Graphic3d_Structure)& theStructToFill)
{
// recompute HLR after transformation in all the case
Handle(Prs3d_Presentation) aPrs = *((Handle(Prs3d_Presentation)*)&theStructToFill);
theStructToFill->Clear();
myPresentableObject->Compute (Projector (theProjector), theTrsf, aPrs);
}
//=======================================================================
//function : Projector
//purpose :
//=======================================================================
Handle(Prs3d_Projector) PrsMgr_Presentation::Projector (const Handle(Graphic3d_DataStructureManager)& theProjector)
{
const Handle(Graphic3d_Camera)& aCamera = Handle(Visual3d_View)::DownCast (theProjector)->Camera();
const gp_Dir aDir = aCamera->Direction().Reversed();
const gp_Pnt anAt = aCamera->Center();
const gp_Dir anUp = aCamera->Up();
Handle(Prs3d_Projector) aProj = new Prs3d_Projector (!aCamera->IsOrthographic(),
aCamera->Scale(),
aDir.X(), aDir.Y(), aDir.Z(),
anAt.X(), anAt.Y(), anAt.Z(),
anUp.X(), anUp.Y(), anUp.Z());
return aProj;
}
//=======================================================================
//function : Destroy
//purpose :
//=======================================================================
void PrsMgr_Presentation::Destroy()
{
if (!myStructure.IsNull())
{
myStructure->Clear();
myStructure.Nullify();
}
}
//=======================================================================
//function : SetZLayer
//purpose :
//=======================================================================
void PrsMgr_Presentation::SetZLayer (Standard_Integer theLayerId)
{
myStructure->SetZLayer (theLayerId);
}
//=======================================================================
//function : GetZLayer
//purpose :
//=======================================================================
Standard_Integer PrsMgr_Presentation::GetZLayer() const
{
return myStructure->GetZLayer();
} }

21
src/PrsMgr/PrsMgr_Presentation.lxx
View File

@ -14,11 +14,22 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
inline void PrsMgr_Presentation::SetUpdateStatus(const Standard_Boolean TheUpdateStatus) inline void PrsMgr_Presentation::SetUpdateStatus (const Standard_Boolean theUpdateStatus)
{myMustBeUpdated = TheUpdateStatus ;} {
myMustBeUpdated = theUpdateStatus;
}
inline Standard_Boolean PrsMgr_Presentation::MustBeUpdated() const inline Standard_Boolean PrsMgr_Presentation::MustBeUpdated() const
{return myMustBeUpdated;} {
return myMustBeUpdated;
}
inline const Handle(PrsMgr_PresentationManager)& PrsMgr_Presentation::PresentationManager() const inline const Handle(PrsMgr_PresentationManager)& PrsMgr_Presentation::PresentationManager() const
{return myPresentationManager;} {
return myPresentationManager;
}
inline const Handle(Prs3d_Presentation)& PrsMgr_Presentation::Presentation() const
{
return myStructure;
}

173
src/PrsMgr/PrsMgr_Presentation3d.cdl
View File

@ -1,173 +0,0 @@
-- Created on: 1993-10-21
-- Created by: Jean-Louis FRENKEL
-- Copyright (c) 1993-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.
-- Modified by rob 09-oct-96
class Presentation3d from PrsMgr inherits Presentation from PrsMgr
uses
PresentationManager from PrsMgr,
Presentation from Prs3d,
NameOfColor from Quantity,
Transformation from Geom,
Length from Quantity,
ShadingAspect from Prs3d,
TypeOfPresentation3d from PrsMgr,
DataStructureManager from Graphic3d,
Structure from Graphic3d,
PresentableObjectPointer from PrsMgr,PresentableObject from PrsMgr,
Prs from PrsMgr,
Projector from Prs3d,
KindOfPrs from PrsMgr
is
Create(aPresentationManager: PresentationManager from PrsMgr;
aPresentableObject: PresentableObject from PrsMgr)
returns mutable Presentation3d from PrsMgr
is private;
KindOfPresentation(me) returns KindOfPrs from PrsMgr is redefined static;
Destroy(me: mutable) is redefined;
---Level: Public
---Purpose: Destructor
---C++: alias ~
Display(me: mutable)
is redefined static private;
Display (me: mutable;
theIsHighlight: Boolean from Standard)
is static private;
---Level: Private;
---Purpose: displays myStructure and sets myDisplayReason to theIsHighlight value if
-- myStructure was not displayed or was invisible
Erase(me: mutable) is redefined static private;
SetVisible (me: mutable; theValue: Boolean from Standard) is redefined static private;
Highlight(me: mutable) is redefined static private;
Unhighlight (me) is redefined static private;
IsDisplayed (me) returns Boolean from Standard
is redefined static private;
IsHighlighted (me) returns Boolean from Standard
is redefined static private;
DisplayPriority(me) returns Integer from Standard
is redefined static private;
SetDisplayPriority(me:mutable;aNewPrior:Integer from Standard)
is redefined static private;
SetZLayer ( me : mutable;
theLayerId : Integer from Standard )
is redefined static private;
---Purpose: Set Z layer ID for the presentation
GetZLayer ( me )
returns Integer from Standard is redefined static private;
---Purpose: Get Z layer ID for the presentation
Clear(me:mutable)
---Purpose: removes the whole content of the presentation.
-- Does not remove the other connected presentations.
--
is redefined static private;
Color(me:mutable; aColor: NameOfColor from Quantity)
is static private;
BoundBox(me)
is static private;
---Category: references to other presentation.
Connect(me; anOtherPresentation: Presentation3d from PrsMgr)
is static private;
---Category: Transformation methods.
Transform (me; aTransformation: Transformation from Geom)
is static private;
Place (me; X,Y,Z: Length from Quantity)
is static private;
Multiply (me; aTransformation: Transformation from Geom)
is static private;
Move (me; X,Y,Z: Length from Quantity)
is static private;
---Category: Global Aspect methods
SetShadingAspect(me;
aShadingAspect: ShadingAspect from Prs3d)
is static private;
Presentation (me) returns mutable Presentation from Prs3d
is static;
---Category: Computed Structures
Compute(me : mutable; theStructure: Structure from Graphic3d)
is static private;
Compute(me : mutable; aProjector: DataStructureManager from Graphic3d)
returns Structure from Graphic3d
is static private;
Compute(me : mutable;
aProjector : DataStructureManager from Graphic3d;
TheTrsf : Transformation from Geom)
returns Structure from Graphic3d
is static private;
Compute(me : mutable;
aProjector : DataStructureManager from Graphic3d;
aGivenStruct : Structure from Graphic3d)
is static private;
Compute(me : mutable;
aProjector : DataStructureManager from Graphic3d;
TheTrsf : Transformation from Geom;
aGivenStruct : Structure from Graphic3d)
is static private;
Projector(myclass; aProjector: DataStructureManager from Graphic3d)
returns Projector from Prs3d
is private;
fields
myStructure: Prs from PrsMgr;
myDisplayReason: Boolean from Standard;
myPresentableObject: PresentableObjectPointer from PrsMgr;
friends
class PresentationManager from PrsMgr,
class PresentableObject from PrsMgr,
class Prs from PrsMgr
end Presentation3d from PrsMgr;

401
src/PrsMgr/PrsMgr_Presentation3d.cxx
View File

@ -1,401 +0,0 @@
// Created on: 1993-10-21
// Created by: Jean-Louis FRENKEL
// Copyright (c) 1993-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.
// Modified by rob 09-oct-96
#define IMP040200 //GG Recompute HLR after transformation
// in all the case.
#include <PrsMgr_Presentation3d.ixx>
#include <PrsMgr_PresentationManager.hxx>
#include <PrsMgr_Prs.hxx>
#include <PrsMgr_ModedPresentation.hxx>
#include <Visual3d_View.hxx>
#include <Graphic3d_Structure.hxx>
#include <Precision.hxx>
PrsMgr_Presentation3d::PrsMgr_Presentation3d (const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
const Handle(PrsMgr_PresentableObject)& aPresentableObject)
: PrsMgr_Presentation(aPresentationManager),
myDisplayReason(Standard_False),
myPresentableObject (aPresentableObject.operator->())
{
myStructure = new PrsMgr_Prs(aPresentationManager->StructureManager(),
this, aPresentableObject->TypeOfPresentation3d());
myStructure->SetOwner(myPresentableObject);
}
PrsMgr_KindOfPrs PrsMgr_Presentation3d::KindOfPresentation() const
{return PrsMgr_KOP_3D;}
void PrsMgr_Presentation3d::Display()
{
Display (Standard_False);
myDisplayReason = Standard_False;
}
void PrsMgr_Presentation3d::Display(const Standard_Boolean theIsHighlight)
{
if (!myStructure->IsDisplayed())
{
myStructure->Display();
myDisplayReason = theIsHighlight;
}
else if (!myStructure->IsVisible())
{
myStructure->SetVisible (Standard_True);
myDisplayReason = theIsHighlight;
}
}
void PrsMgr_Presentation3d::Erase ()
{
if (myStructure.IsNull())
{
return;
}
// Erase structure from structure manager
myStructure->Erase();
myStructure->Clear();
// Disconnect other structures
myStructure->DisconnectAll (Graphic3d_TOC_DESCENDANT);
// Clear groups and remove graphic structure
myStructure.Nullify();
}
void PrsMgr_Presentation3d::SetVisible (const Standard_Boolean theValue)
{
myStructure->SetVisible (theValue);
}
void PrsMgr_Presentation3d::Highlight () {
Display (Standard_True);
myStructure->Highlight();}
void PrsMgr_Presentation3d::Unhighlight () const {
myStructure->UnHighlight();
if (myDisplayReason) myStructure->SetVisible (Standard_False);
}
void PrsMgr_Presentation3d::Clear() {
// This modification remove the contain of the structure:
// Consequence:
// 1. The memory zone of the group is reused
// 2. The speed for animation is constant
//myPresentableObject = NULL;
SetUpdateStatus(Standard_True);
if (myStructure.IsNull())
{
return;
}
myStructure->Clear(Standard_True);
// myStructure->Clear(Standard_False);
myStructure->RemoveAll();
}
void PrsMgr_Presentation3d::Color(const Quantity_NameOfColor aColor){
Display (Standard_True);
myStructure->Color(aColor);
}
void PrsMgr_Presentation3d::BoundBox() const {
myStructure->BoundBox();
}
Standard_Boolean PrsMgr_Presentation3d::IsDisplayed () const {
return myStructure->IsDisplayed() && myStructure->IsVisible() && !myDisplayReason;
}
Standard_Boolean PrsMgr_Presentation3d::IsHighlighted () const {
return myStructure->IsHighlighted();
}
Standard_Integer PrsMgr_Presentation3d::DisplayPriority() const {
return myStructure->DisplayPriority();
}
void PrsMgr_Presentation3d::SetDisplayPriority(const Standard_Integer TheNewPrior)
{
myStructure->SetDisplayPriority(TheNewPrior);
}
Handle(Prs3d_Presentation) PrsMgr_Presentation3d::Presentation() const {
return myStructure;
}
void PrsMgr_Presentation3d::Connect(const Handle(PrsMgr_Presentation3d)& anOtherPresentation) const {
myStructure->Connect(anOtherPresentation->Presentation());
}
void PrsMgr_Presentation3d::Transform (const Handle(Geom_Transformation)& aTransformation) const {
myStructure->Transform(aTransformation);
}
void PrsMgr_Presentation3d::Place (const Quantity_Length X,
const Quantity_Length Y,
const Quantity_Length Z) const {
myStructure->Place(X,Y,Z);
}
void PrsMgr_Presentation3d::Multiply (const Handle(Geom_Transformation)& aTransformation) const {
myStructure->Multiply(aTransformation);
}
void PrsMgr_Presentation3d::Move (const Quantity_Length X,
const Quantity_Length Y,
const Quantity_Length Z) const {
myStructure->Move(X,Y,Z);
}
void PrsMgr_Presentation3d::SetShadingAspect(const Handle(Prs3d_ShadingAspect)& aShadingAspect) const {
myStructure->SetShadingAspect(aShadingAspect);
}
//=======================================================================
//function : Compute
//purpose : Methods for hidden parts...
//=======================================================================
Handle(Graphic3d_Structure) PrsMgr_Presentation3d::
Compute(const Handle(Graphic3d_DataStructureManager)& aProjector)
{
#ifdef DEB
cout<<"passage in g = Compute(P) "<<endl;
#endif
Handle(Prs3d_Presentation) g = new Prs3d_Presentation(Handle(PrsMgr_PresentationManager3d)::DownCast(PresentationManager())->StructureManager());
myPresentableObject->Compute(Projector(aProjector),g);
return g;
}
//=======================================================================
//function : Compute
//purpose :
//=======================================================================
void PrsMgr_Presentation3d::Compute (const Handle(Graphic3d_Structure)& theStructure)
{
Standard_Integer aDispMode = 0;
Standard_Integer aPresentationsNumber = myPresentableObject->myPresentations.Length();
for (Standard_Integer anIter = 1; anIter <= aPresentationsNumber; anIter++)
{
const PrsMgr_ModedPresentation& aModedPresentation = myPresentableObject->myPresentations.Value (anIter);
Handle(PrsMgr_Presentation) aPresentation = aModedPresentation.Presentation();
PrsMgr_Presentation3d* aPresentation3d = (PrsMgr_Presentation3d* )aPresentation.operator->();
if (aPresentation3d == this)
{
aDispMode = aModedPresentation.Mode();
break;
}
}
Handle(Prs3d_Presentation) aPrs3d = Handle(Prs3d_Presentation)::DownCast (theStructure);
myPresentableObject->Compute(
Handle(PrsMgr_PresentationManager3d)::DownCast (PresentationManager()),
aPrs3d,
aDispMode);
}
//=======================================================================
//function : Compute
//purpose :
//=======================================================================
void PrsMgr_Presentation3d::Compute(const Handle(Graphic3d_DataStructureManager)& aProjector,
const Handle(Graphic3d_Structure)& TheStructToFill)
{
#ifdef DEB
cout<<"passage in Compute(P,Str)"<<endl;
#endif
TheStructToFill->Clear();
const Handle(Prs3d_Presentation)& P = *((Handle(Prs3d_Presentation)*) &TheStructToFill);
myPresentableObject->Compute(Projector(aProjector),P);
}
//=======================================================================
//function : Compute
//purpose :
//=======================================================================
Handle(Graphic3d_Structure) PrsMgr_Presentation3d::
Compute(const Handle(Graphic3d_DataStructureManager)& aProjector,
const Handle(Geom_Transformation)& TheTrsf)
{
#ifdef DEB
cout<<"passage in G = Compute(P,Trsf)"<<endl;
#endif
Handle(Prs3d_Presentation) g = new Prs3d_Presentation(Handle(PrsMgr_PresentationManager3d)::DownCast(PresentationManager())->StructureManager());
if(TheTrsf->Form()== gp_Translation){
#ifdef DEB
cout<<"\tla Trsf est une translation"<<endl;
#endif
myPresentableObject->Compute(Projector(aProjector),g);
g->Transform(TheTrsf);
}
else{
// waiting that something is done in gp_Trsf...rob
Standard_Boolean good (Standard_True);
for (Standard_Integer i=1;i<=3 && good ;i++){
for (Standard_Integer j=1;j<=3 && good ;j++){
if(i!=j){
if(Abs(TheTrsf->Value(i,j)) > Precision::Confusion())
good = Standard_False;
}
}
}
if(good){
#ifdef DEB
cout<<"\t it is checked if Trsf is a Translation"<<endl;
#endif
myPresentableObject->Compute(Projector(aProjector),g);
g->Transform(TheTrsf);
}
else{
#ifdef DEB
cout<<"\t Trsf is not only translation..."<<endl;
#endif
myPresentableObject->Compute(Projector(aProjector),TheTrsf,g);
}
}
return g;
}
//=======================================================================
//function : Compute
//purpose :
//=======================================================================
void PrsMgr_Presentation3d::Compute(const Handle(Graphic3d_DataStructureManager)& aProjector,
const Handle(Geom_Transformation)& TheTrsf,
const Handle(Graphic3d_Structure)& TheStructToFill)
{
#ifdef DEB
cout<<"passage in Compute(P,Trsf,Str)"<<endl;
#endif
Handle(Prs3d_Presentation) P = *((Handle(Prs3d_Presentation)*)&TheStructToFill);
#ifdef IMP040200
TheStructToFill->Clear();
myPresentableObject->Compute(Projector(aProjector),TheTrsf,P);
#else //Does not work properly, HLR seems deactivated for view rotation
if(TheTrsf->Form()== gp_Translation){
#ifdef DEB
cout<<"\t Trsf is a translation"<<endl;
#endif
// myPresentableObject->Compute(Projector(aProjector),P);
P->Transform(TheTrsf);
}
else{
// waiting that something is done in gp_Trsf...rob
Standard_Boolean good (Standard_True);
for (Standard_Integer i=1;i<=3 && good ;i++){
for (Standard_Integer j=1;j<=3 && good ;j++){
if(i!=j){
if(Abs(TheTrsf->Value(i,j)) > Precision::Confusion())
good = Standard_False;
}
}
}
if(good && !TheStructToFill->IsEmpty()){
#ifdef DEB
cout<<"\t it is checked if Trsf is a Translation"<<endl;
#endif
P->Transform(TheTrsf);
}
else{
TheStructToFill->Clear();
#ifdef DEB
cout<<"\t Trsf is not only translation..."<<endl;
#endif
myPresentableObject->Compute(Projector(aProjector),TheTrsf,P);
}
}
#endif
}
//=======================================================================
//function : Projector
//purpose :
//=======================================================================
Handle(Prs3d_Projector) PrsMgr_Presentation3d::Projector(const Handle(Graphic3d_DataStructureManager)& aProjector)
{
const Handle(Graphic3d_Camera)& aCamera = Handle(Visual3d_View)::DownCast (aProjector)->Camera();
Standard_Real DX, DY, DZ,XAt, YAt , ZAt,XUp, YUp, ZUp;
gp_Dir aDir = aCamera->Direction().Reversed();
DX = aDir.X(); DY = aDir.Y(); DZ = aDir.Z();
gp_Pnt anAt = aCamera->Center();
XAt = anAt.X(); YAt = anAt.Y(); ZAt = anAt.Z();
gp_Dir anUp = aCamera->Up();
XUp = anUp.X(); YUp = anUp.Y(); ZUp = anUp.Z();
Standard_Boolean pers = !aCamera->IsOrthographic();
Standard_Real focale = aCamera->Scale();
Handle(Prs3d_Projector) aProj =
new Prs3d_Projector(pers, focale, DX, DY, DZ, XAt, YAt, ZAt, XUp, YUp, ZUp);
return aProj;
}
void PrsMgr_Presentation3d::Destroy () {
if (!myStructure.IsNull())
myStructure->Clear();
myStructure.Nullify();
}
//=======================================================================
//function : SetZLayer
//purpose :
//=======================================================================
void PrsMgr_Presentation3d::SetZLayer (Standard_Integer theLayerId)
{
myStructure->SetZLayer (theLayerId);
}
//=======================================================================
//function : GetZLayer
//purpose :
//=======================================================================
Standard_Integer PrsMgr_Presentation3d::GetZLayer () const
{
return myStructure->GetZLayer ();
}

7
src/PrsMgr/PrsMgr_PresentationManager.cdl
View File

@ -31,7 +31,6 @@ uses
Transformation from Geom, Transformation from Geom,
NameOfMaterial from Graphic3d, NameOfMaterial from Graphic3d,
Presentation from PrsMgr, Presentation from PrsMgr,
Presentation3d from PrsMgr,
View from V3d, View from V3d,
ShadingAspect from Prs3d, ShadingAspect from Prs3d,
Presentation from Prs3d Presentation from Prs3d
@ -251,12 +250,6 @@ is
---Purpose: this method will change the color and the aspect of the presentations containing shaded structures. ---Purpose: this method will change the color and the aspect of the presentations containing shaded structures.
is static; is static;
CastPresentation (me;
thePrsObject : PresentableObject from PrsMgr;
theMode : Integer from Standard = 0)
returns mutable Presentation3d from PrsMgr
is static;
---Category: Private & deferred methods. ---Category: Private & deferred methods.
HasPresentation (me; HasPresentation (me;

32
src/PrsMgr/PrsMgr_PresentationManager.cxx
View File

@ -48,7 +48,7 @@ void PrsMgr_PresentationManager::Display (const Handle(PrsMgr_PresentableObject)
AddPresentation (thePrsObj, theMode); AddPresentation (thePrsObj, theMode);
} }
Handle(PrsMgr_Presentation3d) aPrs = CastPresentation (thePrsObj, theMode); Handle(PrsMgr_Presentation) aPrs = Presentation (thePrsObj, theMode);
if (aPrs->MustBeUpdated()) if (aPrs->MustBeUpdated())
{ {
Update (thePrsObj, theMode); Update (thePrsObj, theMode);
@ -114,7 +114,7 @@ void PrsMgr_PresentationManager::Highlight (const Handle(PrsMgr_PresentableObjec
AddPresentation (thePrsObj, theMode); AddPresentation (thePrsObj, theMode);
} }
Handle(PrsMgr_Presentation3d) aPrs = CastPresentation (thePrsObj, theMode); Handle(PrsMgr_Presentation) aPrs = Presentation (thePrsObj, theMode);
if (aPrs->MustBeUpdated()) if (aPrs->MustBeUpdated())
{ {
Update (thePrsObj, theMode); Update (thePrsObj, theMode);
@ -349,7 +349,7 @@ Handle(PrsMgr_Presentation) PrsMgr_PresentationManager::Presentation (const Hand
void PrsMgr_PresentationManager::AddPresentation (const Handle(PrsMgr_PresentableObject)& thePrsObj, void PrsMgr_PresentationManager::AddPresentation (const Handle(PrsMgr_PresentableObject)& thePrsObj,
const Standard_Integer theMode) const Standard_Integer theMode)
{ {
Handle(PrsMgr_Presentation) aPrs = new PrsMgr_Presentation3d (this, thePrsObj); Handle(PrsMgr_Presentation) aPrs = new PrsMgr_Presentation (this, thePrsObj);
thePrsObj->Presentations().Append (PrsMgr_ModedPresentation (aPrs, theMode)); thePrsObj->Presentations().Append (PrsMgr_ModedPresentation (aPrs, theMode));
thePrsObj->Fill (this, aPrs, theMode); thePrsObj->Fill (this, aPrs, theMode);
@ -434,7 +434,7 @@ void PrsMgr_PresentationManager::Connect (const Handle(PrsMgr_PresentableObject)
{ {
AddPresentation (theOtherObject, theOtherMode); AddPresentation (theOtherObject, theOtherMode);
} }
CastPresentation (thePrsObject, theMode)->Connect (CastPresentation (theOtherObject, theMode)); Presentation (thePrsObject, theMode)->Connect (Presentation (theOtherObject, theMode));
} }
// ======================================================================= // =======================================================================
@ -445,7 +445,7 @@ void PrsMgr_PresentationManager::Transform (const Handle(PrsMgr_PresentableObjec
const Handle(Geom_Transformation)& theTransformation, const Handle(Geom_Transformation)& theTransformation,
const Standard_Integer theMode) const Standard_Integer theMode)
{ {
CastPresentation (thePrsObj, theMode)->Transform (theTransformation); Presentation (thePrsObj, theMode)->Transform (theTransformation);
} }
// ======================================================================= // =======================================================================
@ -458,7 +458,7 @@ void PrsMgr_PresentationManager::Place (const Handle(PrsMgr_PresentableObject)&
const Quantity_Length theZ, const Quantity_Length theZ,
const Standard_Integer theMode) const Standard_Integer theMode)
{ {
CastPresentation (thePrsObj, theMode)->Place (theX, theY, theZ); Presentation (thePrsObj, theMode)->Place (theX, theY, theZ);
} }
// ======================================================================= // =======================================================================
@ -469,7 +469,7 @@ void PrsMgr_PresentationManager::Multiply (const Handle(PrsMgr_PresentableObject
const Handle(Geom_Transformation)& theTransformation, const Handle(Geom_Transformation)& theTransformation,
const Standard_Integer theMode) const Standard_Integer theMode)
{ {
CastPresentation (thePrsObj, theMode)->Multiply (theTransformation); Presentation (thePrsObj, theMode)->Multiply (theTransformation);
} }
// ======================================================================= // =======================================================================
@ -482,7 +482,7 @@ void PrsMgr_PresentationManager::Move (const Handle(PrsMgr_PresentableObject)& t
const Quantity_Length theZ, const Quantity_Length theZ,
const Standard_Integer theMode) const Standard_Integer theMode)
{ {
CastPresentation (thePrsObj, theMode)->Move (theX, theY, theZ); Presentation (thePrsObj, theMode)->Move (theX, theY, theZ);
} }
// ======================================================================= // =======================================================================
@ -498,7 +498,7 @@ void PrsMgr_PresentationManager::Color (const Handle(PrsMgr_PresentableObject)&
AddPresentation (thePrsObj, theMode); AddPresentation (thePrsObj, theMode);
} }
Handle(PrsMgr_Presentation3d) aPrs = CastPresentation (thePrsObj, theMode); Handle(PrsMgr_Presentation) aPrs = Presentation (thePrsObj, theMode);
if (aPrs->MustBeUpdated()) if (aPrs->MustBeUpdated())
{ {
Update (thePrsObj, theMode); Update (thePrsObj, theMode);
@ -531,7 +531,7 @@ void PrsMgr_PresentationManager::BoundBox (const Handle(PrsMgr_PresentableObject
{ {
Update (thePrsObject, theMode); Update (thePrsObject, theMode);
} }
CastPresentation (thePrsObject, theMode)->BoundBox(); Presentation (thePrsObject, theMode)->BoundBox();
} }
// ======================================================================= // =======================================================================
@ -559,16 +559,6 @@ void PrsMgr_PresentationManager::SetShadingAspect (const Handle(PrsMgr_Presentab
{ {
if (HasPresentation (thePrsObject, theMode)) if (HasPresentation (thePrsObject, theMode))
{ {
CastPresentation (thePrsObject, theMode)->SetShadingAspect (theShadingAspect); Presentation (thePrsObject, theMode)->SetShadingAspect (theShadingAspect);
} }
} }
// =======================================================================
// function : CastPresentation
// purpose :
// =======================================================================
Handle(PrsMgr_Presentation3d) PrsMgr_PresentationManager::CastPresentation (const Handle(PrsMgr_PresentableObject)& thePrsObject,
const Standard_Integer theMode) const
{
return Handle(PrsMgr_Presentation3d)::DownCast (Presentation (thePrsObject, theMode));
}

10
src/PrsMgr/PrsMgr_Prs.cdl
View File

@ -25,12 +25,12 @@ uses
Structure from Graphic3d, Structure from Graphic3d,
DataStructureManager from Graphic3d, DataStructureManager from Graphic3d,
TypeOfPresentation3d from PrsMgr, TypeOfPresentation3d from PrsMgr,
Presentation3dPointer from PrsMgr PresentationPointer from PrsMgr
is is
Create(aStructureManager : StructureManager from Graphic3d; Create (theStructManager : StructureManager from Graphic3d;
aPresentation : Presentation3dPointer from PrsMgr; thePresentation : PresentationPointer from PrsMgr;
aTypeOfPresentation3d : TypeOfPresentation3d from PrsMgr) theTypeOfPresentation3d : TypeOfPresentation3d from PrsMgr)
returns mutable Prs from PrsMgr; returns mutable Prs from PrsMgr;
Compute (me: mutable) Compute (me: mutable)
@ -74,5 +74,5 @@ is
fields fields
myPresentation3d: Presentation3dPointer from PrsMgr; myPresentation3d: PresentationPointer from PrsMgr;
end Prs from PrsMgr; end Prs from PrsMgr;

14
src/PrsMgr/PrsMgr_Prs.cxx
View File

@ -13,18 +13,18 @@
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <PrsMgr_Prs.ixx> #include <PrsMgr_Prs.ixx>
#include <PrsMgr_Presentation3d.hxx> #include <PrsMgr_Presentation.hxx>
#include <Precision.hxx> #include <Precision.hxx>
#include <gp_Trsf.hxx> #include <gp_Trsf.hxx>
#include <Geom_Transformation.hxx> #include <Geom_Transformation.hxx>
PrsMgr_Prs::PrsMgr_Prs (const Handle(Graphic3d_StructureManager)& aStructureManager, PrsMgr_Prs::PrsMgr_Prs (const Handle(Graphic3d_StructureManager)& theStructManager,
const PrsMgr_Presentation3dPointer& aPresentation3d, const PrsMgr_PresentationPointer& thePrs,
const PrsMgr_TypeOfPresentation3d aTypeOfPresentation) const PrsMgr_TypeOfPresentation3d theTypeOfPresentation)
:Prs3d_Presentation(aStructureManager),myPresentation3d(aPresentation3d) : Prs3d_Presentation (theStructManager),
myPresentation3d (thePrs)
{ {
if (theTypeOfPresentation == PrsMgr_TOP_ProjectorDependant)
if (aTypeOfPresentation == PrsMgr_TOP_ProjectorDependant)
SetVisual(Graphic3d_TOS_COMPUTED); SetVisual(Graphic3d_TOS_COMPUTED);
} }

3
src/TPrsStd/TPrsStd_NamedShapeDriver.cxx
View File

@ -28,8 +28,7 @@
#include <TColStd_ListIteratorOfListOfInteger.hxx> #include <TColStd_ListIteratorOfListOfInteger.hxx>
#include <PrsMgr_Presentation.hxx> #include <PrsMgr_Presentation.hxx>
#include <Prs3d_Presentation.hxx> #include <Prs3d_Presentation.hxx>
#include <PrsMgr_Presentation3d.hxx> #include <PrsMgr_PresentationManager.hxx>
#include <PrsMgr_PresentationManager3d.hxx>
#include <Geom_Transformation.hxx> #include <Geom_Transformation.hxx>
#undef OPTIM_UPDATE // If this variable is defined there will be done #undef OPTIM_UPDATE // If this variable is defined there will be done