// Created by: NW,JPB,CAL // 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. // Modified 1/08/97 ; PCT : ajout texture mapping // 20/08/97 ; PCT : ajout transparence pour texture // 11/97 ; CAL : gestion du GraphicClear // 11/97 ; CAL : ajout pointer StructPtr // 11/97 ; CAL : amelioration de l'effacement SetManager // CAL : 15 janvier 1998 // Ajout de la methode IsTransformed dans une Structure. // (Permet la transmission de cette Trsf vers // la structure COMPUTED si necessaire) // Ajout de la methode IsRotated dans une Structure. // (Permet de connaitre le type de transformation // pour declencher le calcul des parties cachees // de maniere plus sioux) // Ajout de 3 nouvelles methodes Compute virtual dans Structure. // (Permet des Compute un peu plus specialises) // Ajout des 2 methodes sur Owner dans Structure. // (evite de calculer 2 fois les parties cachees // pour 2 representations differentes affichees // d'un meme Presentable Object (Owner)) // Ajout des 2 methodes sur HLRValidation dans Structure. // (permet de valider ou d'invalider le calcul des // parties cachees sur certaines representations) // Ajout de la transmission de la transformation d'une structure // vers sa COMPUTED. // 24/2/98 ; CAL : Modification de la gestion des champs // CAL : 26 mars 1998 // Patch, erreur dans la gestion du nombre de Group avec // facettes dans Graphic3d_Structure avec une operation // de Clear. (PRO12795) // FGU : 30 Avril 1998 // Ajout emission // CAL : 20 mai 1998 // Perfs. Connection entre structures COMPUTED. // 30/11/98 ; FMN : S4069. Textes always visible. // 22/03/04 ; SAN : OCC4895 High-level interface for controlling polygon offsets #define BUC60918 //GG 31/05/01 A transparente structure priority must have the // MAX_PRIORITY value so, the highlighted structure must have // MAX_PRIORITY-1 value. // Add ResetDisplayPriority() method. #define OCC1174 // SAV 08/01/03 Added back face interior color controling //-Version //-Design Declaration of variables specific to graphic structures //-Warning A structure is defined in a manager // This is a sequence of groups of primitives //-References //-Language C++ 2.0 //-Declarations // for the class #define XDOWNCAST #define XDESTROY #define XDEBUG #define XTRACE #define XTRACE_ISTRSF #include #include #include #include #include #include #include #include #include #include // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets #include // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets //-Aliases //-Global data definitions //-Constructors Graphic3d_Structure::Graphic3d_Structure (const Handle(Graphic3d_StructureManager)& AManager): MyAncestors (), MyDescendants (), MyGroups (), MyHighlightColor (Quantity_NOC_WHITE) { Standard_Integer i, j; MyOwner = NULL; Handle(Graphic3d_AspectLine3d) aAspectLine3d = new Graphic3d_AspectLine3d (); Handle(Graphic3d_AspectText3d) aAspectText3d = new Graphic3d_AspectText3d (); Handle(Graphic3d_AspectMarker3d) aAspectMarker3d = new Graphic3d_AspectMarker3d (); Handle(Graphic3d_AspectFillArea3d) aAspectFillArea3d = new Graphic3d_AspectFillArea3d (); // Return default values AManager->PrimitivesAspect (aAspectLine3d, aAspectText3d, aAspectMarker3d, aAspectFillArea3d); // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets // It is necessary to set default polygon offsets for a new presentation aAspectFillArea3d->SetPolygonOffsets( Aspect_POM_Fill, 1., 0. ); // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets // Update the associated CStructure UpdateStructure (aAspectLine3d, aAspectText3d, aAspectMarker3d, aAspectFillArea3d); MyFirstPtrStructureManager = MyPtrStructureManager = (void *) AManager.operator->(); MyCStructure.Id = int (AManager->NewIdentification ()); MyCStructure.IsOpen = 0; MyCStructure.IsDeleted = 0; MyCStructure.Composition = 0; /* Graphic3d_TOC_REPLACE */ for (i=0; i<=3; i++) for (j=0; j<=3; j++) if (i == j) MyCStructure.Transformation[i][j] = float (1.0); else MyCStructure.Transformation[i][j] = float (0.0); MyCStructure.Priority = int (Structure_MAX_PRIORITY / 2); MyCStructure.PreviousPriority = MyCStructure.Priority; MyCStructure.stick = 0, MyCStructure.highlight = 0, MyCStructure.visible = 1, MyCStructure.pick = 1; MyCStructure.ContainsFacet = 0, MyCStructure.IsInfinite = 0, MyCStructure.HLRValidation = 0; MyCStructure.ContextLine.IsDef = 1, MyCStructure.ContextFillArea.IsDef = 1, MyCStructure.ContextMarker.IsDef = 1, MyCStructure.ContextText.IsDef = 1; MyCStructure.ContextLine.IsSet = 0, MyCStructure.ContextFillArea.IsSet = 0, MyCStructure.ContextMarker.IsSet = 0, MyCStructure.ContextText.IsSet = 0; MyVisual = Graphic3d_TOS_ALL; MyComputeVisual = Graphic3d_TOS_ALL; /* ABD 29/10/04 Transform Persistence of Presentation( pan, zoom, rotate ) */ /*MyCStructure.TransformPersistence.IsDef = 1;*/ MyCStructure.TransformPersistence.IsSet = 0; MyCStructure.TransformPersistence.Flag = Graphic3d_TMF_None; MyCStructure.TransformPersistence.Point.x = 0.0; MyCStructure.TransformPersistence.Point.y = 0.0; MyCStructure.TransformPersistence.Point.z = 0.0; /* ABD 29/10/04 Transform Persistence of Presentation( pan, zoom, rotate ) */ MyGraphicDriver = AManager->GraphicDriver(); MyGraphicDriver->Structure (MyCStructure); #ifdef TRACE cout << "Graphic3d_Structure::Create (" << MyCStructure.Id << ")\n"; #endif } //-Destructors void Graphic3d_Structure::Destroy () { #ifdef DESTROY cout << "Graphic3d_Structure::Destroy (" << MyCStructure.Id << ")\n"; #endif // as MyFirstPtrStructureManager can be already destroyed, // avoid attempts to access it MyFirstPtrStructureManager = 0; Remove (); } //-Methods, in order void Graphic3d_Structure::Clear (const Standard_Boolean WithDestruction) { if (IsDeleted()) return; MyCStructure.ContainsFacet = 0; // clean groups in graphics driver at first GraphicClear (WithDestruction); // only then remove group references if (WithDestruction) MyGroups.Clear(); MyStructureManager->Clear (this, WithDestruction); Update(); } void Graphic3d_Structure::Remove () { if (IsDeleted ()) return; #ifdef DESTROY if (MyDescendants.Length () != 0) { cout << "The structure " << MyCStructure.Id << " have " << MyDescendants.Length () << " descendants.\n" << flush; } if (MyAncestors.Length () != 0) { cout << "The structure " << MyCStructure.Id << " have " << MyAncestors.Length () << " ancestors.\n" << flush; } #endif Standard_Integer i, Length; // clean groups in graphics driver at first; this is also should be done // to avoid unwanted group cleaning in group's destructor // Pass Standard_False to Clear(..) method to avoid updating in // structure manager, it isn't necessary, besides of it structure manager // could be already destroyed and invalid pointers used in structure; Length = MyGroups.Length(); for (Standard_Integer aGrId = 1; aGrId <= Length; ++aGrId) MyGroups.ChangeValue (aGrId)->Clear (Standard_False); // Standard_Address APtr = (void *) This ().operator->(); Standard_Address APtr = (void *) this; // It is necessary to remove the eventual pointer on the structure // that can be destroyed, in the list of descendants // of ancesters of this structure and in the list of ancesters // of descendants of the same structure. Length = MyDescendants.Length (); for (i=1; i<=Length; i++) ((Graphic3d_Structure *) (MyDescendants.Value (i)))->Remove (APtr, Graphic3d_TOC_ANCESTOR); Length = MyAncestors.Length (); for (i=1; i<=Length; i++) ((Graphic3d_Structure *) (MyAncestors.Value (i)))->Remove (APtr, Graphic3d_TOC_DESCENDANT); MyCStructure.ContainsFacet = 0; MyCStructure.IsDeleted = 1; // Destruction of me in the graphic library MyGraphicDriver->RemoveStructure (MyCStructure); // Liberation of the identification if the destroyed structure // in the first manager that performs creation of the structure. if ( MyFirstPtrStructureManager ) MyFirstStructureManager->Remove (Standard_Integer (MyCStructure.Id)); } void Graphic3d_Structure::Display () { if (IsDeleted ()) return; if (! MyCStructure.stick) { MyCStructure.stick = 1; MyStructureManager->Display (this); } MyCStructure.visible = 1; } void Graphic3d_Structure::Display (const Standard_Integer Priority) { if (IsDeleted ()) return; SetDisplayPriority (Priority); if (! MyCStructure.stick) { MyCStructure.stick = 1; MyStructureManager->Display (this); } MyCStructure.visible = 1; } void Graphic3d_Structure::SetDisplayPriority (const Standard_Integer Priority) { if (IsDeleted ()) return; #ifdef BUC60918 if( Priority == MyCStructure.Priority ) return; #endif MyCStructure.PreviousPriority = MyCStructure.Priority; MyCStructure.Priority = int (Priority); if (MyCStructure.Priority != MyCStructure.PreviousPriority) { if ( (MyCStructure.Priority > Structure_MAX_PRIORITY) || (MyCStructure.Priority < Structure_MIN_PRIORITY) ) Graphic3d_PriorityDefinitionError::Raise ("Bad value for StructurePriority"); if (MyCStructure.stick) MyStructureManager->ChangeDisplayPriority (this, Standard_Integer (MyCStructure.PreviousPriority), Standard_Integer (MyCStructure.Priority)); } } #ifdef BUC60918 void Graphic3d_Structure::ResetDisplayPriority () { if (IsDeleted ()) return; if (MyCStructure.Priority != MyCStructure.PreviousPriority) { Standard_Integer priority = MyCStructure.Priority; MyCStructure.Priority = MyCStructure.PreviousPriority; if (MyCStructure.stick) MyStructureManager->ChangeDisplayPriority (this, priority, Standard_Integer (MyCStructure.Priority)); } } #endif Standard_Integer Graphic3d_Structure::DisplayPriority () const { return Standard_Integer (MyCStructure.Priority); } void Graphic3d_Structure::Erase () { if (IsDeleted ()) return; if (MyCStructure.stick) { MyCStructure.stick = 0; MyStructureManager->Erase (this); } } void Graphic3d_Structure::Highlight (const Aspect_TypeOfHighlightMethod AMethod) { if (IsDeleted ()) return; // Highlight on already Highlighted structure. if (MyCStructure.highlight) { Aspect_TypeOfUpdate UpdateMode = MyStructureManager->UpdateMode (); if (UpdateMode == Aspect_TOU_WAIT) UnHighlight (); else { // To avoid call of method : Update () // Not useful and can be costly. MyStructureManager->SetUpdateMode (Aspect_TOU_WAIT); UnHighlight (); MyStructureManager->SetUpdateMode (UpdateMode); } } #ifdef BUC60918 SetDisplayPriority (Standard_Integer (Structure_MAX_PRIORITY)-1); #else SetDisplayPriority (Standard_Integer (Structure_MAX_PRIORITY)); #endif GraphicHighlight (AMethod); MyStructureManager->Highlight (this, AMethod); Update (); } void Graphic3d_Structure::SetHighlightColor (const Quantity_Color& AColor) { if (IsDeleted ()) return; if (! MyCStructure.highlight) MyHighlightColor = AColor; else { // Change highlight color on already Highlighted structure. Aspect_TypeOfUpdate UpdateMode = MyStructureManager->UpdateMode (); if (UpdateMode == Aspect_TOU_WAIT) UnHighlight (); else { // To avoid call of method : Update () // Not useful and can be costly. MyStructureManager->SetUpdateMode (Aspect_TOU_WAIT); UnHighlight (); MyStructureManager->SetUpdateMode (UpdateMode); } MyHighlightColor = AColor; Highlight (MyHighlightMethod); } } void Graphic3d_Structure::SetVisible (const Standard_Boolean AValue) { if (IsDeleted ()) return; MyCStructure.visible = AValue ? 1:0; MyGraphicDriver->NameSetStructure (MyCStructure); Update (); } void Graphic3d_Structure::SetPick (const Standard_Boolean AValue) { if (IsDeleted ()) return; MyCStructure.pick = AValue ? 1:0; MyGraphicDriver->NameSetStructure (MyCStructure); if (AValue) MyStructureManager->Detectable (this); else MyStructureManager->Undetectable (this); Update (); } void Graphic3d_Structure::UnHighlight () { if (IsDeleted ()) return; if (MyCStructure.highlight) { MyCStructure.highlight = 0; GraphicUnHighlight (); MyStructureManager->UnHighlight (this); #ifdef BUC60918 ResetDisplayPriority(); #else SetDisplayPriority (Standard_Integer (MyCStructure.PreviousPriority)); #endif Update (); } } Quantity_Color Graphic3d_Structure::HighlightColor () const { return (MyHighlightColor); } Standard_Boolean Graphic3d_Structure::IsDisplayed () const { if (MyCStructure.stick) return (Standard_True); else return (Standard_False); } Standard_Boolean Graphic3d_Structure::IsDeleted () const { if (MyCStructure.IsDeleted) return (Standard_True); else return (Standard_False); } Standard_Boolean Graphic3d_Structure::IsHighlighted () const { if (MyCStructure.highlight) return (Standard_True); else return (Standard_False); } Standard_Boolean Graphic3d_Structure::IsSelectable () const { if (MyCStructure.pick) return (Standard_True); else return (Standard_False); } Standard_Boolean Graphic3d_Structure::IsVisible () const { if (MyCStructure.visible) return (Standard_True); else return (Standard_False); } Standard_Boolean Graphic3d_Structure::IsRotated () const { // A somewhat light test ! return ( MyCStructure.Transformation[0][1] != 0. || MyCStructure.Transformation[0][2] != 0. || MyCStructure.Transformation[1][0] != 0. || MyCStructure.Transformation[1][2] != 0. || MyCStructure.Transformation[2][0] != 0. || MyCStructure.Transformation[2][1] != 0. ); } Standard_Boolean Graphic3d_Structure::IsTransformed () const { Standard_Boolean Result = Standard_False; Standard_Integer i, j; for (i=0; i<=3 && ! Result; i++) for (j=0; j<=3 && ! Result; j++) if (i == j) Result = MyCStructure.Transformation[i][j] != 1.; else Result = MyCStructure.Transformation[i][j] != 0.; #ifdef TRACE_ISTRSF cout << "Structure " << Identification (); if (Result) cout << " is transformed\n" << flush; else cout << " is not transformed\n" << flush; #endif return Result; } Standard_Boolean Graphic3d_Structure::ContainsFacet () const { if (IsDeleted ()) return (Standard_False); // A structure contains at least one facet : // if one of these groups contains at least one facet. Standard_Boolean Result1 = Standard_False; Standard_Boolean Result2 = Standard_False; Standard_Integer i, Length; Result1 = (MyCStructure.ContainsFacet > 0); // If one of groups contains at least one facet, the structure contains it too. if (Result1) return (Result1); Length = MyDescendants.Length (); // Stop at the first descendant containing at least one facet. for (i=1; i<=Length && ! Result2; i++) Result2 = ((Graphic3d_Structure *) (MyDescendants.Value (i)))->ContainsFacet (); return (Result2); } Standard_Boolean Graphic3d_Structure::IsEmpty () const { if (IsDeleted ()) return (Standard_True); // A structure is empty : // if all these groups are empty or if all // groups are empty and all their descendants // are empty or if all its descendants are empty. Standard_Boolean Result1 = Standard_True; Standard_Integer i, Length = MyGroups.Length (); // Stop at the first non-empty group for (i=1; i<=Length && Result1; i++) Result1 = (MyGroups.Value (i))->IsEmpty (); // If a group is non-empty the structure is also non-empty. if (! Result1) return (Standard_False); Standard_Boolean Result2 = Standard_True; Length = MyDescendants.Length (); // Stop at the first non-empty descendant for (i=1; i<=Length && Result2; i++) Result2 = ((Graphic3d_Structure *) (MyDescendants.Value (i)))->IsEmpty (); return (Result2); } void Graphic3d_Structure::PrimitivesAspect (Handle(Graphic3d_AspectLine3d)& CTXL, Handle(Graphic3d_AspectText3d)& CTXT, Handle(Graphic3d_AspectMarker3d)& CTXM, Handle(Graphic3d_AspectFillArea3d)& CTXF) const { CTXL = Line3dAspect (); CTXT = Text3dAspect (); CTXM = Marker3dAspect (); CTXF = FillArea3dAspect (); } void Graphic3d_Structure::GroupsWithFacet (const Standard_Integer ADelta) { MyCStructure.ContainsFacet = MyCStructure.ContainsFacet + ADelta; if (MyCStructure.ContainsFacet < 0) MyCStructure.ContainsFacet = 0; #ifdef DEBUG cout << "MyCStructure.ContainsFacet " << MyCStructure.ContainsFacet; cout << endl << flush; #endif } void Graphic3d_Structure::Compute() { // Implemented by Presentation } Handle(Graphic3d_Structure) Graphic3d_Structure::Compute (const Handle(Graphic3d_DataStructureManager)& ) { // Implemented by Presentation return this; } Handle(Graphic3d_Structure) Graphic3d_Structure::Compute (const Handle(Graphic3d_DataStructureManager)& , const TColStd_Array2OfReal& ) { // Implemented by Presentation return this; } void Graphic3d_Structure::Compute (const Handle(Graphic3d_DataStructureManager)& , Handle(Graphic3d_Structure)& ) { // Implemented by Presentation } void Graphic3d_Structure::Compute (const Handle(Graphic3d_DataStructureManager)& , const TColStd_Array2OfReal& , Handle(Graphic3d_Structure)& ) { // Implemented by Presentation } void Graphic3d_Structure::ReCompute () { MyStructureManager->ReCompute (this); } void Graphic3d_Structure::ReCompute (const Handle(Graphic3d_DataStructureManager)& aProjector) { MyStructureManager->ReCompute (this, aProjector); } //============================================================================= //function : SetInfiniteState //purpose : //============================================================================= void Graphic3d_Structure::SetInfiniteState (const Standard_Boolean theToSet) { MyCStructure.IsInfinite = theToSet ? 1 : 0; } Standard_Boolean Graphic3d_Structure::IsInfinite () const { if (IsDeleted ()) return (Standard_True); if (MyCStructure.IsInfinite) return (Standard_True); else return (Standard_False); } void Graphic3d_Structure::GraphicClear (const Standard_Boolean WithDestruction) { // clean and empty each group Standard_Integer Length = MyGroups.Length(); for (Standard_Integer aGrId = 1; aGrId <= Length; ++aGrId) { MyGroups.ChangeValue (aGrId)->Clear(); } if (WithDestruction) { while (!MyGroups.IsEmpty()) { Handle(Graphic3d_Group) aGroup = MyGroups.First(); aGroup->Remove(); } MyGraphicDriver->ClearStructure (MyCStructure); } } void Graphic3d_Structure::GraphicConnect (const Handle(Graphic3d_Structure)& theDaughter) { MyGraphicDriver->Connect (MyCStructure, theDaughter->MyCStructure); } void Graphic3d_Structure::GraphicDisconnect (const Handle(Graphic3d_Structure)& theDaughter) { MyGraphicDriver->Disconnect (MyCStructure, theDaughter->MyCStructure); } Handle(Graphic3d_AspectLine3d) Graphic3d_Structure::Line3dAspect () const { Standard_Real R, G, B; Standard_Real AWidth; Quantity_Color AColor; Aspect_TypeOfLine ALType; // ContextLine R = Standard_Real (MyCStructure.ContextLine.Color.r); G = Standard_Real (MyCStructure.ContextLine.Color.g); B = Standard_Real (MyCStructure.ContextLine.Color.b); AColor.SetValues (R, G, B, Quantity_TOC_RGB); ALType = Aspect_TypeOfLine (MyCStructure.ContextLine.LineType); AWidth = Standard_Real (MyCStructure.ContextLine.Width); Handle(Graphic3d_AspectLine3d) CTXL = new Graphic3d_AspectLine3d (AColor, ALType, AWidth); CTXL->SetShaderProgram (MyCStructure.ContextLine.ShaderProgram); return CTXL; } Handle(Graphic3d_AspectText3d) Graphic3d_Structure::Text3dAspect () const { Standard_Real R, G, B; Standard_CString AFont; Standard_Real ASpace; Standard_Real AnExpansion; Quantity_Color AColor; Aspect_TypeOfStyleText AStyle; Aspect_TypeOfDisplayText ADisplayType; // ContextText R = Standard_Real (MyCStructure.ContextText.Color.r); G = Standard_Real (MyCStructure.ContextText.Color.g); B = Standard_Real (MyCStructure.ContextText.Color.b); AColor.SetValues (R, G, B, Quantity_TOC_RGB); AFont = Standard_CString (MyCStructure.ContextText.Font); AnExpansion = Standard_Real (MyCStructure.ContextText.Expan); ASpace = Standard_Real (MyCStructure.ContextText.Space); AStyle = Aspect_TypeOfStyleText (MyCStructure.ContextText.Style); ADisplayType = Aspect_TypeOfDisplayText (MyCStructure.ContextText.DisplayType); Handle(Graphic3d_AspectText3d) CTXT = new Graphic3d_AspectText3d (AColor, AFont, AnExpansion, ASpace,AStyle,ADisplayType); CTXT->SetShaderProgram (MyCStructure.ContextText.ShaderProgram); return CTXT; } Handle(Graphic3d_AspectMarker3d) Graphic3d_Structure::Marker3dAspect () const { Standard_Real R, G, B; Standard_Real AScale; Quantity_Color AColor; Aspect_TypeOfMarker AMType; // ContextMarker R = Standard_Real (MyCStructure.ContextMarker.Color.r); G = Standard_Real (MyCStructure.ContextMarker.Color.g); B = Standard_Real (MyCStructure.ContextMarker.Color.b); AColor.SetValues (R, G, B, Quantity_TOC_RGB); AMType = MyCStructure.ContextMarker.MarkerType; AScale = Standard_Real (MyCStructure.ContextMarker.Scale); Handle(Graphic3d_AspectMarker3d) CTXM = new Graphic3d_AspectMarker3d (AMType, AColor, AScale); CTXM->SetShaderProgram (MyCStructure.ContextMarker.ShaderProgram); return CTXM; } Handle(Graphic3d_AspectFillArea3d) Graphic3d_Structure::FillArea3dAspect () const { Standard_Real R, G, B; Standard_Real AWidth; Quantity_Color AColor; Quantity_Color AnIntColor; Quantity_Color AnEdgeColor; Aspect_TypeOfLine ALType; Aspect_InteriorStyle AStyle; Standard_Boolean EdgeOn = Standard_False; Graphic3d_MaterialAspect Front; Graphic3d_MaterialAspect Back; // ContextFillArea AStyle = Aspect_InteriorStyle (MyCStructure.ContextFillArea.Style); R = Standard_Real (MyCStructure.ContextFillArea.IntColor.r); G = Standard_Real (MyCStructure.ContextFillArea.IntColor.g); B = Standard_Real (MyCStructure.ContextFillArea.IntColor.b); AnIntColor.SetValues (R, G, B, Quantity_TOC_RGB); // Edges if (MyCStructure.ContextFillArea.Edge == 1) EdgeOn = Standard_True; R = Standard_Real (MyCStructure.ContextFillArea.EdgeColor.r); G = Standard_Real (MyCStructure.ContextFillArea.EdgeColor.g); B = Standard_Real (MyCStructure.ContextFillArea.EdgeColor.b); AnEdgeColor.SetValues (R, G, B, Quantity_TOC_RGB); ALType = Aspect_TypeOfLine (MyCStructure.ContextFillArea.LineType); AWidth = Standard_Real (MyCStructure.ContextFillArea.Width); // Back Material Back.SetShininess ( Standard_Real (MyCStructure.ContextFillArea.Back.Shininess)); Back.SetAmbient ( Standard_Real (MyCStructure.ContextFillArea.Back.Ambient)); Back.SetDiffuse ( Standard_Real (MyCStructure.ContextFillArea.Back.Diffuse)); Back.SetSpecular ( Standard_Real (MyCStructure.ContextFillArea.Back.Specular)); Back.SetTransparency ( Standard_Real (MyCStructure.ContextFillArea.Back.Transparency)); Back.SetEmissive ( Standard_Real (MyCStructure.ContextFillArea.Back.Emission)); if (MyCStructure.ContextFillArea.Back.IsAmbient == 1) Back.SetReflectionModeOn (Graphic3d_TOR_AMBIENT); else Back.SetReflectionModeOff (Graphic3d_TOR_AMBIENT); if (MyCStructure.ContextFillArea.Back.IsDiffuse == 1) Back.SetReflectionModeOn (Graphic3d_TOR_DIFFUSE); else Back.SetReflectionModeOff (Graphic3d_TOR_DIFFUSE); if (MyCStructure.ContextFillArea.Back.IsSpecular == 1) Back.SetReflectionModeOn (Graphic3d_TOR_SPECULAR); else Back.SetReflectionModeOff (Graphic3d_TOR_SPECULAR); if (MyCStructure.ContextFillArea.Back.IsEmission == 1) Back.SetReflectionModeOn (Graphic3d_TOR_EMISSION); else Back.SetReflectionModeOff (Graphic3d_TOR_EMISSION); R = Standard_Real (MyCStructure.ContextFillArea.Back.ColorSpec.r); G = Standard_Real (MyCStructure.ContextFillArea.Back.ColorSpec.g); B = Standard_Real (MyCStructure.ContextFillArea.Back.ColorSpec.b); AColor.SetValues (R, G, B, Quantity_TOC_RGB); Back.SetSpecularColor (AColor); R = Standard_Real (MyCStructure.ContextFillArea.Back.ColorAmb.r); G = Standard_Real (MyCStructure.ContextFillArea.Back.ColorAmb.g); B = Standard_Real (MyCStructure.ContextFillArea.Back.ColorAmb.b); AColor.SetValues (R, G, B, Quantity_TOC_RGB); Back.SetAmbientColor (AColor); R = Standard_Real (MyCStructure.ContextFillArea.Back.ColorDif.r); G = Standard_Real (MyCStructure.ContextFillArea.Back.ColorDif.g); B = Standard_Real (MyCStructure.ContextFillArea.Back.ColorDif.b); AColor.SetValues (R, G, B, Quantity_TOC_RGB); Back.SetDiffuseColor (AColor); R = Standard_Real (MyCStructure.ContextFillArea.Back.ColorEms.r); G = Standard_Real (MyCStructure.ContextFillArea.Back.ColorEms.g); B = Standard_Real (MyCStructure.ContextFillArea.Back.ColorEms.b); AColor.SetValues (R, G, B, Quantity_TOC_RGB); Back.SetEmissiveColor (AColor); Back.SetEnvReflexion (MyCStructure.ContextFillArea.Back.EnvReflexion); Graphic3d_TypeOfMaterial mType = MyCStructure.ContextFillArea.Back.IsPhysic ? Graphic3d_MATERIAL_PHYSIC : Graphic3d_MATERIAL_ASPECT; Back.SetMaterialType(mType); // Front Material Front.SetShininess ( Standard_Real (MyCStructure.ContextFillArea.Front.Shininess)); Front.SetAmbient ( Standard_Real (MyCStructure.ContextFillArea.Front.Ambient)); Front.SetDiffuse ( Standard_Real (MyCStructure.ContextFillArea.Front.Diffuse)); Front.SetSpecular ( Standard_Real (MyCStructure.ContextFillArea.Front.Specular)); Front.SetTransparency ( Standard_Real (MyCStructure.ContextFillArea.Front.Transparency)); Front.SetEmissive ( Standard_Real (MyCStructure.ContextFillArea.Front.Emission)); if (MyCStructure.ContextFillArea.Front.IsAmbient == 1) Front.SetReflectionModeOn (Graphic3d_TOR_AMBIENT); else Front.SetReflectionModeOff (Graphic3d_TOR_AMBIENT); if (MyCStructure.ContextFillArea.Front.IsDiffuse == 1) Front.SetReflectionModeOn (Graphic3d_TOR_DIFFUSE); else Front.SetReflectionModeOff (Graphic3d_TOR_DIFFUSE); if (MyCStructure.ContextFillArea.Front.IsSpecular == 1) Front.SetReflectionModeOn (Graphic3d_TOR_SPECULAR); else Front.SetReflectionModeOff (Graphic3d_TOR_SPECULAR); if (MyCStructure.ContextFillArea.Front.Emission == 1) Front.SetReflectionModeOn (Graphic3d_TOR_EMISSION); else Front.SetReflectionModeOff (Graphic3d_TOR_EMISSION); R = Standard_Real (MyCStructure.ContextFillArea.Front.ColorSpec.r); G = Standard_Real (MyCStructure.ContextFillArea.Front.ColorSpec.g); B = Standard_Real (MyCStructure.ContextFillArea.Front.ColorSpec.b); AColor.SetValues (R, G, B, Quantity_TOC_RGB); Front.SetSpecularColor (AColor); R = Standard_Real (MyCStructure.ContextFillArea.Front.ColorAmb.r); G = Standard_Real (MyCStructure.ContextFillArea.Front.ColorAmb.g); B = Standard_Real (MyCStructure.ContextFillArea.Front.ColorAmb.b); AColor.SetValues (R, G, B, Quantity_TOC_RGB); Front.SetAmbientColor (AColor); R = Standard_Real (MyCStructure.ContextFillArea.Front.ColorDif.r); G = Standard_Real (MyCStructure.ContextFillArea.Front.ColorDif.g); B = Standard_Real (MyCStructure.ContextFillArea.Front.ColorDif.b); AColor.SetValues (R, G, B, Quantity_TOC_RGB); Front.SetDiffuseColor (AColor); R = Standard_Real (MyCStructure.ContextFillArea.Front.ColorEms.r); G = Standard_Real (MyCStructure.ContextFillArea.Front.ColorEms.g); B = Standard_Real (MyCStructure.ContextFillArea.Front.ColorEms.b); AColor.SetValues (R, G, B, Quantity_TOC_RGB); Front.SetEmissiveColor (AColor); Front.SetEnvReflexion (MyCStructure.ContextFillArea.Front.EnvReflexion); mType = MyCStructure.ContextFillArea.Front.IsPhysic ? Graphic3d_MATERIAL_PHYSIC : Graphic3d_MATERIAL_ASPECT; Front.SetMaterialType(mType); Handle(Graphic3d_AspectFillArea3d) CTXF = new Graphic3d_AspectFillArea3d (AStyle, AnIntColor, AnEdgeColor, ALType, AWidth, Front, Back); // Edges if (EdgeOn) CTXF->SetEdgeOn (); else CTXF->SetEdgeOff (); // Hatch CTXF->SetHatchStyle(Aspect_HatchStyle (MyCStructure.ContextFillArea.Hatch)); // Materials // Front and Back face if (MyCStructure.ContextFillArea.Distinguish == 1) CTXF->SetDistinguishOn (); else CTXF->SetDistinguishOff (); if (MyCStructure.ContextFillArea.BackFace == 1) CTXF->SuppressBackFace (); else CTXF->AllowBackFace (); // Texture CTXF->SetTextureMap (MyCStructure.ContextFillArea.Texture.TextureMap); if (MyCStructure.ContextFillArea.Texture.doTextureMap == 1) { CTXF->SetTextureMapOn(); } else { CTXF->SetTextureMapOff(); } CTXF->SetShaderProgram (MyCStructure.ContextFillArea.ShaderProgram); // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets CTXF->SetPolygonOffsets(MyCStructure.ContextFillArea.PolygonOffsetMode, MyCStructure.ContextFillArea.PolygonOffsetFactor, MyCStructure.ContextFillArea.PolygonOffsetUnits); // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets return CTXF; } const Graphic3d_SequenceOfGroup& Graphic3d_Structure::Groups() const { return MyGroups; } Standard_Integer Graphic3d_Structure::NumberOfGroups () const { return (MyGroups.Length ()); } void Graphic3d_Structure::SetPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& CTX) { if (IsDeleted ()) return; Standard_Real R, G, B; Standard_Real AWidth; Quantity_Color AColor; Aspect_TypeOfLine ALType; CTX->Values (AColor, ALType, AWidth); AColor.Values (R, G, B, Quantity_TOC_RGB); MyCStructure.ContextLine.Color.r = float (R); MyCStructure.ContextLine.Color.g = float (G); MyCStructure.ContextLine.Color.b = float (B); MyCStructure.ContextLine.LineType = int (ALType); MyCStructure.ContextLine.Width = float (AWidth); MyCStructure.ContextLine.ShaderProgram = CTX->ShaderProgram(); MyCStructure.ContextLine.IsDef = 1; MyGraphicDriver->ContextStructure (MyCStructure); // CAL 14/04/95 // Attributes are "IsSet" during the first update // of context (line, marker...) MyCStructure.ContextLine.IsSet = 1; MyCStructure.ContextFillArea.IsSet = 1; MyCStructure.ContextMarker.IsSet = 1; MyCStructure.ContextText.IsSet = 1; Update (); } void Graphic3d_Structure::SetPrimitivesAspect (const Handle(Graphic3d_AspectFillArea3d)& CTX) { if (IsDeleted ()) return; Standard_Real R, G, B; Standard_Real AWidth; Quantity_Color AnIntColor; Quantity_Color BackIntColor; Quantity_Color AnEdgeColor; Aspect_TypeOfLine ALType; Aspect_InteriorStyle AStyle; CTX->Values (AStyle, AnIntColor, BackIntColor, AnEdgeColor, ALType, AWidth); AnIntColor.Values (R, G, B, Quantity_TOC_RGB); MyCStructure.ContextFillArea.Style = int (AStyle); MyCStructure.ContextFillArea.IntColor.r = float (R); MyCStructure.ContextFillArea.IntColor.g = float (G); MyCStructure.ContextFillArea.IntColor.b = float (B); #ifdef OCC1174 if ( CTX->Distinguish() ) BackIntColor.Values( R, G, B, Quantity_TOC_RGB ); #endif MyCStructure.ContextFillArea.BackIntColor.r = float( R ); MyCStructure.ContextFillArea.BackIntColor.g = float( G ); MyCStructure.ContextFillArea.BackIntColor.b = float( B ); // Edges MyCStructure.ContextFillArea.Edge = CTX->Edge () ? 1:0; AnEdgeColor.Values (R, G, B, Quantity_TOC_RGB); MyCStructure.ContextFillArea.EdgeColor.r = float (R); MyCStructure.ContextFillArea.EdgeColor.g = float (G); MyCStructure.ContextFillArea.EdgeColor.b = float (B); MyCStructure.ContextFillArea.LineType = int (ALType); MyCStructure.ContextFillArea.Width = float (AWidth); MyCStructure.ContextFillArea.Hatch = int (CTX->HatchStyle ()); /*** Front and Back face ***/ MyCStructure.ContextFillArea.Distinguish = CTX->Distinguish () ? 1:0; MyCStructure.ContextFillArea.BackFace = CTX->BackFace () ? 1:0; /*** Back Material ***/ // Light specificity MyCStructure.ContextFillArea.Back.Shininess = float ((CTX->BackMaterial ()).Shininess ()); MyCStructure.ContextFillArea.Back.Ambient = float ((CTX->BackMaterial ()).Ambient ()); MyCStructure.ContextFillArea.Back.Diffuse = float ((CTX->BackMaterial ()).Diffuse ()); MyCStructure.ContextFillArea.Back.Specular = float ((CTX->BackMaterial ()).Specular ()); MyCStructure.ContextFillArea.Back.Transparency = float ((CTX->BackMaterial ()).Transparency ()); MyCStructure.ContextFillArea.Back.Emission = float ((CTX->BackMaterial ()).Emissive ()); // Reflection mode MyCStructure.ContextFillArea.Back.IsAmbient = ( (CTX->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 ); MyCStructure.ContextFillArea.Back.IsDiffuse = ( (CTX->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 ); MyCStructure.ContextFillArea.Back.IsSpecular = ( (CTX->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 ); MyCStructure.ContextFillArea.Back.IsEmission = ( (CTX->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 ); // Material type //JR/Hp const Graphic3d_MaterialAspect ama = CTX->BackMaterial () ; Standard_Boolean amt = ama.MaterialType(Graphic3d_MATERIAL_PHYSIC) ; MyCStructure.ContextFillArea.Back.IsPhysic = ( amt ? 1 : 0 ); // Specular Color MyCStructure.ContextFillArea.Back.ColorSpec.r = float (((CTX->BackMaterial ()).SpecularColor ()).Red ()); MyCStructure.ContextFillArea.Back.ColorSpec.g = float (((CTX->BackMaterial ()).SpecularColor ()).Green ()); MyCStructure.ContextFillArea.Back.ColorSpec.b = float (((CTX->BackMaterial ()).SpecularColor ()).Blue ()); // Ambient color MyCStructure.ContextFillArea.Back.ColorAmb.r = float (((CTX->BackMaterial ()).AmbientColor ()).Red ()); MyCStructure.ContextFillArea.Back.ColorAmb.g = float (((CTX->BackMaterial ()).AmbientColor ()).Green ()); MyCStructure.ContextFillArea.Back.ColorAmb.b = float (((CTX->BackMaterial ()).AmbientColor ()).Blue ()); // Diffuse color MyCStructure.ContextFillArea.Back.ColorDif.r = float (((CTX->BackMaterial ()).DiffuseColor ()).Red ()); MyCStructure.ContextFillArea.Back.ColorDif.g = float (((CTX->BackMaterial ()).DiffuseColor ()).Green ()); MyCStructure.ContextFillArea.Back.ColorDif.b = float (((CTX->BackMaterial ()).DiffuseColor ()).Blue ()); // Emissive color MyCStructure.ContextFillArea.Back.ColorEms.r = float (((CTX->BackMaterial ()).EmissiveColor ()).Red ()); MyCStructure.ContextFillArea.Back.ColorEms.g = float (((CTX->BackMaterial ()).EmissiveColor ()).Green ()); MyCStructure.ContextFillArea.Back.ColorEms.b = float (((CTX->BackMaterial ()).EmissiveColor ()).Blue ()); MyCStructure.ContextFillArea.Back.EnvReflexion = float ((CTX->BackMaterial ()).EnvReflexion()); /*** Front Material ***/ // Light specificity MyCStructure.ContextFillArea.Front.Shininess = float ((CTX->FrontMaterial ()).Shininess ()); MyCStructure.ContextFillArea.Front.Ambient = float ((CTX->FrontMaterial ()).Ambient ()); MyCStructure.ContextFillArea.Front.Diffuse = float ((CTX->FrontMaterial ()).Diffuse ()); MyCStructure.ContextFillArea.Front.Specular = float ((CTX->FrontMaterial ()).Specular ()); MyCStructure.ContextFillArea.Front.Transparency = float ((CTX->FrontMaterial ()).Transparency ()); MyCStructure.ContextFillArea.Front.Emission = float ((CTX->FrontMaterial ()).Emissive ()); // Reflection mode MyCStructure.ContextFillArea.Front.IsAmbient = ( (CTX->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 ); MyCStructure.ContextFillArea.Front.IsDiffuse = ( (CTX->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 ); MyCStructure.ContextFillArea.Front.IsSpecular = ( (CTX->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 ); MyCStructure.ContextFillArea.Front.IsEmission = ( (CTX->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 ); // Materail type //JR/Hp const Graphic3d_MaterialAspect amas = CTX->FrontMaterial () ; Standard_Boolean amty = amas.MaterialType(Graphic3d_MATERIAL_PHYSIC) ; MyCStructure.ContextFillArea.Front.IsPhysic = ( amty ? 1 : 0 ); // Specular Color MyCStructure.ContextFillArea.Front.ColorSpec.r = float (((CTX->FrontMaterial ()).SpecularColor ()).Red ()); MyCStructure.ContextFillArea.Front.ColorSpec.g = float (((CTX->FrontMaterial ()).SpecularColor ()).Green ()); MyCStructure.ContextFillArea.Front.ColorSpec.b = float (((CTX->FrontMaterial ()).SpecularColor ()).Blue ()); // Ambient color MyCStructure.ContextFillArea.Front.ColorAmb.r = float (((CTX->FrontMaterial ()).AmbientColor ()).Red ()); MyCStructure.ContextFillArea.Front.ColorAmb.g = float (((CTX->FrontMaterial ()).AmbientColor ()).Green ()); MyCStructure.ContextFillArea.Front.ColorAmb.b = float (((CTX->FrontMaterial ()).AmbientColor ()).Blue ()); // Diffuse color MyCStructure.ContextFillArea.Front.ColorDif.r = float (((CTX->FrontMaterial ()).DiffuseColor ()).Red ()); MyCStructure.ContextFillArea.Front.ColorDif.g = float (((CTX->FrontMaterial ()).DiffuseColor ()).Green ()); MyCStructure.ContextFillArea.Front.ColorDif.b = float (((CTX->FrontMaterial ()).DiffuseColor ()).Blue ()); // Emissive color MyCStructure.ContextFillArea.Front.ColorEms.r = float (((CTX->FrontMaterial ()).EmissiveColor ()).Red ()); MyCStructure.ContextFillArea.Front.ColorEms.g = float (((CTX->FrontMaterial ()).EmissiveColor ()).Green ()); MyCStructure.ContextFillArea.Front.ColorEms.b = float (((CTX->FrontMaterial ()).EmissiveColor ()).Blue ()); MyCStructure.ContextFillArea.Front.EnvReflexion = float ((CTX->FrontMaterial ()).EnvReflexion()); MyCStructure.ContextFillArea.IsDef = 1; // Definition material ok MyCStructure.ContextFillArea.Texture.TextureMap = CTX->TextureMap(); MyCStructure.ContextFillArea.Texture.doTextureMap = CTX->TextureMapState() ? 1 : 0; MyCStructure.ContextFillArea.ShaderProgram = CTX->ShaderProgram(); // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets Standard_Integer aPolyMode; Standard_ShortReal aPolyFactor, aPolyUnits; CTX->PolygonOffsets(aPolyMode, aPolyFactor, aPolyUnits); MyCStructure.ContextFillArea.PolygonOffsetMode = aPolyMode; MyCStructure.ContextFillArea.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor; MyCStructure.ContextFillArea.PolygonOffsetUnits = (Standard_ShortReal)aPolyUnits; // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets MyGraphicDriver->ContextStructure (MyCStructure); // CAL 14/04/95 // Attributes are "IsSet" during the first update // of context (line, marker...) MyCStructure.ContextLine.IsSet = 1; MyCStructure.ContextFillArea.IsSet = 1; MyCStructure.ContextMarker.IsSet = 1; MyCStructure.ContextText.IsSet = 1; Update (); } void Graphic3d_Structure::SetPrimitivesAspect (const Handle(Graphic3d_AspectText3d)& CTX) { if (IsDeleted ()) return; Standard_Real R, G, B; Standard_Real Rs, Gs, Bs; Standard_CString AFont; Standard_Real ASpace; Standard_Real AnExpansion; Quantity_Color AColor; Aspect_TypeOfStyleText AStyle; Aspect_TypeOfDisplayText ADisplayType; Quantity_Color AColorSubTitle; Standard_Boolean ATextZoomable; Standard_Real ATextAngle; Font_FontAspect ATextFontAspect; CTX->Values (AColor, AFont, AnExpansion, ASpace, AStyle, ADisplayType,AColorSubTitle,ATextZoomable,ATextAngle,ATextFontAspect); AColor.Values (R, G, B, Quantity_TOC_RGB); AColorSubTitle.Values (Rs, Gs, Bs, Quantity_TOC_RGB); MyCStructure.ContextText.Color.r = float (R); MyCStructure.ContextText.Color.g = float (G); MyCStructure.ContextText.Color.b = float (B); MyCStructure.ContextText.Font = (char*) (AFont); MyCStructure.ContextText.Expan = float (AnExpansion); MyCStructure.ContextText.Space = float (ASpace); MyCStructure.ContextText.Style = int (AStyle); MyCStructure.ContextText.DisplayType = int (ADisplayType); MyCStructure.ContextText.ColorSubTitle.r = float (Rs); MyCStructure.ContextText.ColorSubTitle.g = float (Gs); MyCStructure.ContextText.ColorSubTitle.b = float (Bs); MyCStructure.ContextText.TextZoomable = ATextZoomable; MyCStructure.ContextText.TextAngle = float (ATextAngle); MyCStructure.ContextText.TextFontAspect = int (ATextFontAspect); MyCStructure.ContextText.ShaderProgram = CTX->ShaderProgram(); MyCStructure.ContextText.IsDef = 1; MyGraphicDriver->ContextStructure (MyCStructure); // CAL 14/04/95 // Attributes are "IsSet" during the first update of a context (line, marker...) MyCStructure.ContextLine.IsSet = 1; MyCStructure.ContextFillArea.IsSet = 1; MyCStructure.ContextMarker.IsSet = 1; MyCStructure.ContextText.IsSet = 1; Update (); } void Graphic3d_Structure::SetPrimitivesAspect (const Handle(Graphic3d_AspectMarker3d)& CTX) { if (IsDeleted ()) return; Standard_Real R, G, B; Standard_Real AScale; Quantity_Color AColor; Aspect_TypeOfMarker AMType; CTX->Values (AColor, AMType, AScale); AColor.Values (R, G, B, Quantity_TOC_RGB); MyCStructure.ContextMarker.Color.r = float (R); MyCStructure.ContextMarker.Color.g = float (G); MyCStructure.ContextMarker.Color.b = float (B); MyCStructure.ContextMarker.MarkerType = AMType; MyCStructure.ContextMarker.Scale = float (AScale); MyCStructure.ContextMarker.ShaderProgram = CTX->ShaderProgram(); MyCStructure.ContextMarker.IsDef = 1; MyGraphicDriver->ContextStructure (MyCStructure); // Attributes are "IsSet" during the first update of a context (line, marker...) MyCStructure.ContextLine.IsSet = 1; MyCStructure.ContextFillArea.IsSet = 1; MyCStructure.ContextMarker.IsSet = 1; MyCStructure.ContextText.IsSet = 1; Update (); } void Graphic3d_Structure::SetVisual (const Graphic3d_TypeOfStructure AVisual) { if (IsDeleted ()) return; if (MyVisual == AVisual) return; if (! MyCStructure.stick) { MyVisual = AVisual; SetComputeVisual (AVisual); } else { Aspect_TypeOfUpdate UpdateMode = MyStructureManager->UpdateMode (); if (UpdateMode == Aspect_TOU_WAIT) { Erase (); MyVisual = AVisual; SetComputeVisual (AVisual); Display (); } else { // To avoid calling method : Update () // Not useful and can be costly. MyStructureManager->SetUpdateMode (Aspect_TOU_WAIT); Erase (); MyVisual = AVisual; SetComputeVisual (AVisual); MyStructureManager->SetUpdateMode (UpdateMode); Display (); } } } void Graphic3d_Structure::SetZoomLimit (const Standard_Real LimitInf, const Standard_Real LimitSup) { if (LimitInf <= 0.0) Graphic3d_StructureDefinitionError::Raise ("Bad value for ZoomLimit inf"); if (LimitSup <= 0.0) Graphic3d_StructureDefinitionError::Raise ("Bad value for ZoomLimit sup"); if (LimitSup < LimitInf) Graphic3d_StructureDefinitionError::Raise ("ZoomLimit sup < ZoomLimit inf"); } Graphic3d_TypeOfStructure Graphic3d_Structure::Visual () const { return (MyVisual); } Standard_Boolean Graphic3d_Structure::AcceptConnection (const Handle(Graphic3d_Structure)& AStructure1, const Handle(Graphic3d_Structure)& AStructure2, const Graphic3d_TypeOfConnection AType) { Graphic3d_MapOfStructure ASet; // cycle detection Graphic3d_Structure::Network (AStructure2, AType, ASet); return (! ASet.Contains (AStructure1)); } void Graphic3d_Structure::Ancestors (Graphic3d_MapOfStructure &SG) const { Standard_Integer i, Length = MyAncestors.Length (); for (i=1; i<=Length; i++) SG.Add ((Graphic3d_Structure *) (MyAncestors.Value (i))); } void Graphic3d_Structure::SetOwner (const Standard_Address Owner) { MyOwner = Owner; } Standard_Address Graphic3d_Structure::Owner () const { return MyOwner; } void Graphic3d_Structure::Descendants (Graphic3d_MapOfStructure& SG) const { Standard_Integer i, Length = MyDescendants.Length (); for (i=1; i<=Length; i++) SG.Add ((Graphic3d_Structure *) (MyDescendants.Value (i))); } void Graphic3d_Structure::Connect (const Handle(Graphic3d_Structure)& AStructure, const Graphic3d_TypeOfConnection AType, const Standard_Boolean WithCheck) { if (IsDeleted ()) return; if (WithCheck) // cycle detection if (! Graphic3d_Structure::AcceptConnection (this, AStructure, AType)) return; // connection Standard_Integer i; switch (AType) { case Graphic3d_TOC_DESCENDANT : { Standard_Integer indexD = 0; Standard_Integer LengthD = MyDescendants.Length (); for (i=1; i<=LengthD && indexD==0; i++) if ((void *) (MyDescendants.Value (i)) == (void *) (AStructure.operator->())) indexD = i; if (indexD == 0) { MyDescendants.Append ((void *) AStructure.operator->()); AStructure->Connect (this, Graphic3d_TOC_ANCESTOR); GraphicConnect (AStructure); MyStructureManager->Connect (this, AStructure); Update (); } } break; case Graphic3d_TOC_ANCESTOR : { Standard_Integer indexA = 0; Standard_Integer LengthA = MyAncestors.Length (); for (i=1; i<=LengthA && indexA==0; i++) if ((void *) (MyAncestors.Value (i)) == (void *) (AStructure.operator->())) indexA = i; if (indexA == 0) { MyAncestors.Append ((void *) AStructure.operator->()); AStructure->Connect (this, Graphic3d_TOC_DESCENDANT); // MyGraphicDriver->Connect is called in case // if connection between parent and child } } break; } } void Graphic3d_Structure::Disconnect (const Handle(Graphic3d_Structure)& AStructure) { if (IsDeleted ()) return; Standard_Integer i; Standard_Integer indexD = 0; Standard_Integer LengthD = MyDescendants.Length (); for (i=1; i<=LengthD && indexD==0; i++) if ((void *) (MyDescendants.Value (i)) == (void *) (AStructure.operator->())) indexD = i; // Search in the Descendants if (indexD != 0) { MyDescendants.Remove (indexD); AStructure->Disconnect (this); GraphicDisconnect (AStructure); MyStructureManager->Disconnect (this, AStructure); Update (); } else { Standard_Integer indexA = 0; Standard_Integer LengthA = MyAncestors.Length (); for (i=1; i<=LengthA && indexA==0; i++) if ((void *) (MyAncestors.Value (i)) == (void *) (AStructure.operator->())) indexA = i; // Search in the Ancestors if (indexA != 0) { MyAncestors.Remove (indexA); AStructure->Disconnect (this); // No call of MyGraphicDriver->Disconnect // in case of an ancestor } } } void Graphic3d_Structure::DisconnectAll (const Graphic3d_TypeOfConnection AType) { if (IsDeleted ()) return; Standard_Integer i, Length; // disconnection switch (AType) { case Graphic3d_TOC_DESCENDANT : Length = MyDescendants.Length (); for (i=1; i<=Length; i++) // Value (1) instead of Value (i) as MyDescendants // is modified by : // Graphic3d_Structure::Disconnect (AStructure) // that takes AStructure from MyDescendants ((Graphic3d_Structure *) (MyDescendants.Value (1)))->Disconnect (this); break; case Graphic3d_TOC_ANCESTOR : Length = MyAncestors.Length (); for (i=1; i<=Length; i++) // Value (1) instead of Value (i) as MyAncestors // is modified by : // Graphic3d_Structure::Disconnect (AStructure) // that takes AStructure from MyAncestors ((Graphic3d_Structure *) (MyAncestors.Value (1)))->Disconnect (this); break; } } Graphic3d_TypeOfComposition Graphic3d_Structure::Composition () const { if (MyCStructure.Composition) return (Graphic3d_TOC_POSTCONCATENATE); else return (Graphic3d_TOC_REPLACE); } void Graphic3d_Structure::SetTransform (const TColStd_Array2OfReal& AMatrix, const Graphic3d_TypeOfComposition AType) { if (IsDeleted ()) return; Standard_Integer lr, ur, lc, uc; Standard_Real valuetrsf; Standard_Real valueoldtrsf; Standard_Real valuenewtrsf; Standard_Integer i, j, k; TColStd_Array2OfReal TheTrsf (0, 3, 0, 3); TColStd_Array2OfReal NewTrsf (0, 3, 0, 3); TColStd_Array2OfReal AMatrix44 (0, 3, 0, 3); // Assign the new transformation in an array [0..3][0..3] // Avoid problemes if the user has defined matrice [1..4][1..4] // or [3..6][-1..2] !! lr = AMatrix.LowerRow (); ur = AMatrix.UpperRow (); lc = AMatrix.LowerCol (); uc = AMatrix.UpperCol (); if ( (ur - lr + 1 != 4) || (uc - lc + 1 != 4) ) Graphic3d_TransformError::Raise ("Transform : not a 4x4 matrix"); if (AType == Graphic3d_TOC_REPLACE) { MyCStructure.Composition = 0; // Update of CStructure for (i=0; i<=3; i++) for (j=0; j<=3; j++) { MyCStructure.Transformation[i][j] = float (AMatrix (lr + i, lc + j)); NewTrsf (i, j) = AMatrix (lr + i, lc + j); } } if (AType == Graphic3d_TOC_POSTCONCATENATE) { MyCStructure.Composition = 1; // To simplify management of indices for (i=0; i<=3; i++) for (j=0; j<=3; j++) AMatrix44 (i, j) = AMatrix (lr + i, lc + j); // Calculation of the product of matrices for (i=0; i<=3; i++) for (j=0; j<=3; j++) { NewTrsf (i, j) = 0.0; for (k=0; k<=3; k++) { valueoldtrsf = MyCStructure.Transformation[i][k]; valuetrsf = AMatrix44 (k, j); valuenewtrsf = NewTrsf (i, j) + valueoldtrsf * valuetrsf; NewTrsf (i, j) = valuenewtrsf; } } // Update of CStructure for (i=0; i<=3; i++) for (j=0; j<=3; j++) MyCStructure.Transformation[i][j] = float (NewTrsf (i, j)); } // If transformation, no validation of hidden already calculated parts. if (IsRotated ()) ReCompute (); GraphicTransform (NewTrsf); MyStructureManager->SetTransform (this, NewTrsf); Update (); } void Graphic3d_Structure::Transform (TColStd_Array2OfReal& AMatrix) const { Standard_Integer lr = AMatrix.LowerRow (); Standard_Integer ur = AMatrix.UpperRow (); Standard_Integer lc = AMatrix.LowerCol (); Standard_Integer uc = AMatrix.UpperCol (); if ( (ur - lr + 1 != 4) || (uc - lc + 1 != 4) ) Graphic3d_TransformError::Raise ("Transform : not a 4x4 matrix"); for (Standard_Integer i=0; i<=3; i++) for (Standard_Integer j=0; j<=3; j++) AMatrix (lr + i, lc + j) = MyCStructure.Transformation[i][j]; } //============================================================================= //function : MinMaxValues //purpose : //============================================================================= void Graphic3d_Structure::MinMaxValues (Standard_Real& theXMin, Standard_Real& theYMin, Standard_Real& theZMin, Standard_Real& theXMax, Standard_Real& theYMax, Standard_Real& theZMax, const Standard_Boolean theToIgnoreInfiniteFlag) const { if (IsEmpty()) { return; } Standard_Real aXMin, aYMin, aZMin, aXMax, aYMax, aZMax; MinMaxCoord (aXMin, aYMin, aZMin, aXMax, aYMax, aZMax); // Infinite boundaries corresponding to empty structure or // non-empty structure, without any primitives specified if (aXMin == RealFirst() && aYMin == RealFirst() && aZMin == RealFirst() && aXMax == RealLast() && aYMax == RealLast() && aZMax == RealLast()) { theXMin = RealFirst(); theYMin = RealFirst(); theZMin = RealFirst(); theXMax = RealLast(); theYMax = RealLast(); theZMax = RealLast(); return; } // Handle flag, which specifies that structure should be considered as infinite if (IsInfinite() && !theToIgnoreInfiniteFlag) { Graphic3d_Vertex aVertexMin (aXMin, aYMin, aZMin); Graphic3d_Vertex aVertexMax (aXMax, aYMax, aZMax); const Standard_Real aDistance = aVertexMin.Distance (aVertexMax); // Special case for infinite line: // Bounding borders of infinite line has been // calculated as own point in center of this line if (aDistance >= 500000.0) { theXMin = theXMax = 0.5 * (aXMin + aXMax); theYMin = theYMax = 0.5 * (aYMin + aYMax); theZMin = theZMax = 0.5 * (aZMin + aZMax); return; } theXMin = RealFirst(); theYMin = RealFirst(); theZMin = RealFirst(); theXMax = RealLast(); theYMax = RealLast(); theZMax = RealLast(); return; } // Min-Max values of the descendant structures Standard_Real aDescXMin = RealLast(); Standard_Real aDescYMin = RealLast(); Standard_Real aDescZMin = RealLast(); Standard_Real aDescXMax = RealFirst(); Standard_Real aDescYMax = RealFirst(); Standard_Real aDescZMax = RealFirst(); for (Standard_Integer aStructIt = 1; aStructIt <= MyDescendants.Length(); aStructIt++) { Graphic3d_Structure* aStructure = (Graphic3d_Structure*) MyDescendants.Value (aStructIt); aStructure->MinMaxValues (aXMin, aYMin, aZMin, aXMax, aYMax, aZMax); aDescXMin = Min (aXMin, aDescXMin); aDescYMin = Min (aYMin, aDescYMin); aDescZMin = Min (aZMin, aDescZMin); aDescXMax = Max (aXMax, aDescXMax); aDescYMax = Max (aYMax, aDescYMax); aDescZMax = Max (aZMax, aDescZMax); } if (aDescXMin != RealLast() || aDescYMin != RealLast() || aDescZMin != RealLast() || aDescXMax != RealFirst() || aDescYMax != RealFirst() || aDescZMax != RealFirst()) { aXMin = Min (aDescXMin, aXMin); aYMin = Min (aDescYMin, aYMin); aZMin = Min (aDescZMin, aZMin); aXMax = Max (aDescXMax, aXMax); aYMax = Max (aDescYMax, aYMax); aZMax = Max (aDescZMax, aZMax); } // Case impossible as it would mean that the structure is empty or infinite if (aXMin == RealFirst() && aYMin == RealFirst() && aZMin == RealFirst() && aXMax == RealLast() && aYMax == RealLast() && aZMax == RealLast()) { theXMin = RealFirst(); theYMin = RealFirst(); theZMin = RealFirst(); theXMax = RealLast(); theYMax = RealLast(); theZMax = RealLast(); return; } TColStd_Array2OfReal aTrsf(0, 3, 0, 3); Transform (aTrsf); TransformBoundaries (aTrsf, aXMin, aYMin, aZMin, aXMax, aYMax, aZMax); theXMin = aXMin; theYMin = aYMin; theZMin = aZMin; theXMax = aXMax; theYMax = aYMax; theZMax = aZMax; } Standard_Integer Graphic3d_Structure::Identification () const { Standard_Integer Result = MyCStructure.Id; return Result; } void Graphic3d_Structure::SetTransformPersistence( const Graphic3d_TransModeFlags& AFlag ) { SetTransformPersistence( AFlag, gp_Pnt( 0, 0, 0 ) ); } void Graphic3d_Structure::SetTransformPersistence( const Graphic3d_TransModeFlags& AFlag, const gp_Pnt& APoint ) { if (IsDeleted ()) return; MyCStructure.TransformPersistence.Flag = AFlag; MyCStructure.TransformPersistence.Point.x = float (APoint.X()); MyCStructure.TransformPersistence.Point.y = float (APoint.Y()); MyCStructure.TransformPersistence.Point.z = float (APoint.Z()); //MyStructureManager->Update (); //Update(); MyGraphicDriver->ContextStructure( MyCStructure ); MyCStructure.TransformPersistence.IsSet = 1; } Graphic3d_TransModeFlags Graphic3d_Structure::TransformPersistenceMode() const { return MyCStructure.TransformPersistence.Flag; } gp_Pnt Graphic3d_Structure::TransformPersistencePoint() const { gp_Pnt aPnt( 0., 0., 0. ); aPnt.SetX( MyCStructure.TransformPersistence.Point.x ); aPnt.SetY( MyCStructure.TransformPersistence.Point.y ); aPnt.SetZ( MyCStructure.TransformPersistence.Point.z ); return aPnt; } void Graphic3d_Structure::Add (const Handle(Graphic3d_Group)& AGroup) { // Method called only by the constructor of Graphic3d_Group // It is easy to check presence of // in sequence MyGroups. MyGroups.Append (AGroup); } void Graphic3d_Structure::Remove (const Standard_Address APtr, const Graphic3d_TypeOfConnection AType) { Standard_Integer i, index, length; switch (AType) { case Graphic3d_TOC_DESCENDANT : index = 0; length = MyDescendants.Length (); for (i=1; i<=length && index==0; i++) if ((void *) (MyDescendants.Value (i)) == APtr) index = i; if (index != 0) MyDescendants.Remove (index); #ifdef TRACE else cout << "Error, Graphic3d_Structure::Remove\n"; #endif break; case Graphic3d_TOC_ANCESTOR : index = 0; length = MyAncestors.Length (); for (i=1; i<=length && index==0; i++) if ((void *) (MyAncestors.Value (i)) == APtr) index = i; if (index != 0) MyAncestors.Remove (index); #ifdef TRACE else cout << "Error, Graphic3d_Structure::Remove\n"; #endif break; } } void Graphic3d_Structure::Remove (const Handle(Graphic3d_Group)& AGroup) { const Standard_Integer Length = MyGroups.Length (); // Search in Groups for (Standard_Integer i=1; i<=Length; i++) if (MyGroups.Value (i) == AGroup) { MyGroups.Remove (i); return; } } Handle(Graphic3d_StructureManager) Graphic3d_Structure::StructureManager () const { #ifdef DOWNCAST return (Handle(Graphic3d_StructureManager)::DownCast(Handle(Standard_Transient) ((Standard_Transient*) MyPtrStructureManager))); #else return MyStructureManager; #endif } //============================================================================= //function : MinMaxCoord //purpose : //============================================================================= void Graphic3d_Structure::MinMaxCoord (Standard_Real& theXMin, Standard_Real& theYMin, Standard_Real& theZMin, Standard_Real& theXMax, Standard_Real& theYMax, Standard_Real& theZMax) const { if (IsEmpty()) { theXMin = RealFirst(); theYMin = RealFirst(); theZMin = RealFirst(); theXMax = RealLast(); theYMax = RealLast(); theZMax = RealLast(); return; } Standard_Real aXMin = RealLast(); Standard_Real aYMin = RealLast(); Standard_Real aZMin = RealLast(); Standard_Real aXMax = RealFirst(); Standard_Real aYMax = RealFirst(); Standard_Real aZMax = RealFirst(); Standard_Real aGroupXMin, aGroupYMin, aGroupZMin, aGroupXMax, aGroupYMax, aGroupZMax; for (Standard_Integer aGroupIt = 1; aGroupIt <= MyGroups.Length(); aGroupIt++) { const Handle(Graphic3d_Group)& aGroup = MyGroups.Value (aGroupIt); if (aGroup->IsEmpty()) { continue; } aGroup->MinMaxValues (aGroupXMin, aGroupYMin, aGroupZMin, aGroupXMax, aGroupYMax, aGroupZMax); aXMin = Min (aXMin, aGroupXMin); aYMin = Min (aYMin, aGroupYMin); aZMin = Min (aZMin, aGroupZMin); aXMax = Max (aXMax, aGroupXMax); aYMax = Max (aYMax, aGroupYMax); aZMax = Max (aZMax, aGroupZMax); } // Case impossible as it would mean that the structure is empty if (aXMin == RealLast() && aYMin == RealLast() && aZMin == RealLast() && aXMax == RealFirst() && aYMax == RealFirst() && aZMax == RealFirst()) { theXMin = RealFirst(); theYMin = RealFirst(); theZMin = RealFirst(); theXMax = RealLast(); theYMax = RealLast(); theZMax = RealLast(); } theXMin = aXMin; theYMin = aYMin; theZMin = aZMin; theXMax = aXMax; theYMax = aYMax; theZMax = aZMax; } //============================================================================= //function : MinMaxCoordWithDescendants //purpose : //============================================================================= void Graphic3d_Structure::MinMaxCoordWithDescendants (Standard_Real& theXMin, Standard_Real& theYMin, Standard_Real& theZMin, Standard_Real& theXMax, Standard_Real& theYMax, Standard_Real& theZMax) const { if (IsEmpty()) { theXMin = RealFirst(); theYMin = RealFirst(); theZMin = RealFirst(); theXMax = RealLast(); theYMax = RealLast(); theZMax = RealLast(); return; } Standard_Real aXMin, aYMin, aZMin, aXMax, aYMax, aZMax; MinMaxCoord (aXMin, aYMin, aZMin, aXMax, aYMax, aZMax); // Min-Max of the descendant structures Standard_Real aDescXMin = RealLast(); Standard_Real aDescYMin = RealLast(); Standard_Real aDescZMin = RealLast(); Standard_Real aDescXMax = RealFirst(); Standard_Real aDescYMax = RealFirst(); Standard_Real aDescZMax = RealFirst(); for (Standard_Integer aStructIt = 1; aStructIt <= MyDescendants.Length(); aStructIt++) { Graphic3d_Structure* aStructure = (Graphic3d_Structure*) MyDescendants.Value (aStructIt); if (aStructure->IsEmpty()) { continue; } aStructure->MinMaxCoordWithDescendants (aXMin, aYMin, aZMin, aXMax, aYMax, aZMax); aDescXMin = Min (aXMin, aDescXMin); aDescYMin = Min (aYMin, aDescYMin); aDescZMin = Min (aZMin, aDescZMin); aDescXMax = Max (aXMax, aDescXMax); aDescYMax = Max (aYMax, aDescYMax); aDescZMax = Max (aZMax, aDescZMax); } if (aDescXMin != RealLast() || aDescYMin != RealLast() || aDescZMin != RealLast() || aDescXMax != RealFirst() || aDescYMax != RealFirst() || aDescZMax != RealFirst()) { TColStd_Array2OfReal aTrsf(0, 3, 0, 3); Transform (aTrsf); TransformBoundaries (aTrsf, aDescXMin, aDescYMin, aDescZMin, aDescXMax, aDescYMax, aDescZMax); aXMin = Min (aDescXMin, aXMin); aYMin = Min (aDescYMin, aYMin); aZMin = Min (aDescZMin, aZMin); aXMax = Max (aDescXMax, aXMax); aYMax = Max (aDescYMax, aYMax); aZMax = Max (aDescZMax, aZMax); } // Case impossible as it would mean that the structure is empty if (aXMin == RealLast() && aYMin == RealLast() && aZMin == RealLast() && aXMax == RealFirst() && aYMax == RealFirst() && aZMax == RealFirst()) { theXMin = RealFirst(); theYMin = RealFirst(); theZMin = RealFirst(); theXMax = RealLast(); theYMax = RealLast(); theZMax = RealLast(); } theXMin = aXMin; theYMin = aYMin; theZMin = aZMin; theXMax = aXMax; theYMax = aYMax; theZMax = aZMax; } void Graphic3d_Structure::Transforms (const TColStd_Array2OfReal& ATrsf, const Standard_Real X, const Standard_Real Y, const Standard_Real Z, Standard_Real& NewX, Standard_Real& NewY, Standard_Real& NewZ) { Standard_Real A, B, C, D; Standard_Real RL = RealLast (); Standard_Real RF = RealFirst (); if ((X == RF) || (Y == RF) || (Z == RF) || (X == RL) || (Y == RL) || (Z == RL)) { NewX = X; NewY = Y; NewZ = Z; } else { A = ATrsf (0, 0); B = ATrsf (0, 1); C = ATrsf (0, 2); D = ATrsf (0, 3); NewX = A * X + B * Y + C * Z + D; A = ATrsf (1, 0); B = ATrsf (1, 1); C = ATrsf (1, 2); D = ATrsf (1, 3); NewY = A * X + B * Y + C * Z + D; A = ATrsf (2, 0); B = ATrsf (2, 1); C = ATrsf (2, 2); D = ATrsf (2, 3); NewZ = A * X + B * Y + C * Z + D; } } Graphic3d_Vector Graphic3d_Structure::Transforms (const TColStd_Array2OfReal& ATrsf, const Graphic3d_Vector& Coord) { Standard_Real NewX, NewY, NewZ; Graphic3d_Vector Result; Graphic3d_Structure::Transforms (ATrsf, Coord.X (), Coord.Y (), Coord.Z (), NewX, NewY, NewZ); Result.SetCoord (NewX, NewY, NewZ); return (Result); } Graphic3d_Vertex Graphic3d_Structure::Transforms (const TColStd_Array2OfReal& ATrsf, const Graphic3d_Vertex& Coord) { Standard_Real NewX, NewY, NewZ; Graphic3d_Vertex Result; Graphic3d_Structure::Transforms (ATrsf, Coord.X (), Coord.Y (), Coord.Z (), NewX, NewY, NewZ); Result.SetCoord (NewX, NewY, NewZ); return (Result); } //============================================================================= //function : Transforms //purpose : //============================================================================= void Graphic3d_Structure::TransformBoundaries (const TColStd_Array2OfReal& theTrsf, Standard_Real& theXMin, Standard_Real& theYMin, Standard_Real& theZMin, Standard_Real& theXMax, Standard_Real& theYMax, Standard_Real& theZMax) { Standard_Real aXMin, aYMin, aZMin, aXMax, aYMax, aZMax, anU, aV, aW; Graphic3d_Structure::Transforms (theTrsf, theXMin, theYMin, theZMin, aXMin, aYMin, aZMin); Graphic3d_Structure::Transforms (theTrsf, theXMax, theYMax, theZMax, aXMax, aYMax, aZMax); Graphic3d_Structure::Transforms (theTrsf, theXMin, theYMin, theZMax, anU, aV, aW); aXMin = Min (anU, aXMin); aXMax = Max (anU, aXMax); aYMin = Min (aV, aYMin); aYMax = Max (aV, aYMax); aZMin = Min (aW, aZMin); aZMax = Max (aW, aZMax); Graphic3d_Structure::Transforms (theTrsf, theXMax, theYMin, theZMax, anU, aV, aW); aXMin = Min (anU, aXMin); aXMax = Max (anU, aXMax); aYMin = Min (aV, aYMin); aYMax = Max (aV, aYMax); aZMin = Min (aW, aZMin); aZMax = Max (aW, aZMax); Graphic3d_Structure::Transforms (theTrsf, theXMax, theYMin, theZMin, anU, aV, aW); aXMin = Min (anU, aXMin); aXMax = Max (anU, aXMax); aYMin = Min (aV, aYMin); aYMax = Max (aV, aYMax); aZMin = Min (aW, aZMin); aZMax = Max (aW, aZMax); Graphic3d_Structure::Transforms (theTrsf, theXMax, theYMax, theZMin, anU, aV, aW); aXMin = Min (anU, aXMin); aXMax = Max (anU, aXMax); aYMin = Min (aV, aYMin); aYMax = Max (aV, aYMax); aZMin = Min (aW, aZMin); aZMax = Max (aW, aZMax); Graphic3d_Structure::Transforms (theTrsf, theXMin, theYMax, theZMax, anU, aV, aW); aXMin = Min (anU, aXMin); aXMax = Max (anU, aXMax); aYMin = Min (aV, aYMin); aYMax = Max (aV, aYMax); aZMin = Min (aW, aZMin); aZMax = Max (aW, aZMax); Graphic3d_Structure::Transforms (theTrsf, theXMin, theYMax, theZMin, anU, aV, aW); aXMin = Min (anU, aXMin); aXMax = Max (anU, aXMax); aYMin = Min (aV, aYMin); aYMax = Max (aV, aYMax); aZMin = Min (aW, aZMin); aZMax = Max (aW, aZMax); theXMin = aXMin; theYMin = aYMin; theZMin = aZMin; theXMax = aXMax; theYMax = aYMax; theZMax = aZMax; } void Graphic3d_Structure::Network (const Handle(Graphic3d_Structure)& AStructure, const Graphic3d_TypeOfConnection AType, Graphic3d_MapOfStructure& ASet) { Graphic3d_MapOfStructure h1; Graphic3d_MapOfStructure h2; AStructure->Descendants (h1); AStructure->Ancestors (h2); Graphic3d_MapIteratorOfMapOfStructure IteratorD (h1); Graphic3d_MapIteratorOfMapOfStructure IteratorA (h2); ASet.Add (AStructure); // exploration switch (AType) { case Graphic3d_TOC_DESCENDANT : while (IteratorD.More ()) { Graphic3d_Structure::Network (IteratorD.Key (), AType, ASet); // IteratorD.Next () is located on the next structure IteratorD.Next (); } break; case Graphic3d_TOC_ANCESTOR : while (IteratorA.More ()) { Graphic3d_Structure::Network (IteratorA.Key (), AType, ASet); // IteratorA.Next () is located on the next structure IteratorA.Next (); } break; } } void Graphic3d_Structure::PrintNetwork (const Handle(Graphic3d_Structure)& AStructure, const Graphic3d_TypeOfConnection AType) { Graphic3d_MapOfStructure ASet; Graphic3d_MapIteratorOfMapOfStructure IteratorASet (ASet); Graphic3d_Structure::Network (AStructure, AType, ASet); while (IteratorASet.More ()) { cout << "\tIdent " << (IteratorASet.Key ())->Identification () << "\n"; IteratorASet.Next (); } cout << flush; } void Graphic3d_Structure::Update () const { if (IsDeleted ()) return; if (MyStructureManager->UpdateMode () == Aspect_TOU_ASAP) MyStructureManager->Update (); } void Graphic3d_Structure::UpdateStructure (const Handle(Graphic3d_AspectLine3d)& CTXL, const Handle(Graphic3d_AspectText3d)& CTXT, const Handle(Graphic3d_AspectMarker3d)& CTXM, const Handle(Graphic3d_AspectFillArea3d)& CTXF) { Standard_Real R, G, B; Standard_Real Rs, Gs, Bs; Standard_CString AFont; Standard_Real ASpace; Standard_Real AnExpansion; Standard_Real AWidth; Standard_Real AScale; Quantity_Color AColor; Quantity_Color AnIntColor; Quantity_Color BackIntColor; Quantity_Color AnEdgeColor; Aspect_TypeOfLine ALType; Aspect_TypeOfMarker AMType; Aspect_InteriorStyle AStyle; Aspect_TypeOfStyleText AStyleT; Aspect_TypeOfDisplayText ADisplayType; Quantity_Color AColorSubTitle; Standard_Boolean ATextZoomable; Standard_Real ATextAngle; Font_FontAspect ATextFontAspect; CTXL->Values (AColor, ALType, AWidth); AColor.Values (R, G, B, Quantity_TOC_RGB); MyCStructure.ContextLine.Color.r = float (R); MyCStructure.ContextLine.Color.g = float (G); MyCStructure.ContextLine.Color.b = float (B); MyCStructure.ContextLine.LineType = int (ALType); MyCStructure.ContextLine.Width = float (AWidth); MyCStructure.ContextLine.ShaderProgram = CTXL->ShaderProgram(); CTXM->Values (AColor, AMType, AScale); AColor.Values (R, G, B, Quantity_TOC_RGB); MyCStructure.ContextMarker.Color.r = float (R); MyCStructure.ContextMarker.Color.g = float (G); MyCStructure.ContextMarker.Color.b = float (B); MyCStructure.ContextMarker.MarkerType = AMType; MyCStructure.ContextMarker.Scale = float (AScale); MyCStructure.ContextMarker.ShaderProgram = CTXM->ShaderProgram(); CTXT->Values (AColor, AFont, AnExpansion, ASpace,AStyleT,ADisplayType,AColorSubTitle,ATextZoomable,ATextAngle,ATextFontAspect); AColor.Values (R, G, B, Quantity_TOC_RGB); AColorSubTitle.Values (Rs, Gs, Bs, Quantity_TOC_RGB); MyCStructure.ContextText.Color.r = float (R); MyCStructure.ContextText.Color.g = float (G); MyCStructure.ContextText.Color.b = float (B); MyCStructure.ContextText.Font = (char*) (AFont); MyCStructure.ContextText.Expan = float (AnExpansion); MyCStructure.ContextText.Style = int (AStyleT); MyCStructure.ContextText.DisplayType = int (ADisplayType); MyCStructure.ContextText.Space = float (ASpace); MyCStructure.ContextText.ColorSubTitle.r = float (Rs); MyCStructure.ContextText.ColorSubTitle.g = float (Gs); MyCStructure.ContextText.ColorSubTitle.b = float (Bs); MyCStructure.ContextText.TextZoomable = ATextZoomable; MyCStructure.ContextText.TextAngle = float (ATextAngle); MyCStructure.ContextText.TextFontAspect = int (ATextFontAspect); MyCStructure.ContextText.ShaderProgram = CTXT->ShaderProgram(); CTXF->Values (AStyle, AnIntColor, BackIntColor, AnEdgeColor, ALType, AWidth); AnIntColor.Values (R, G, B, Quantity_TOC_RGB); MyCStructure.ContextFillArea.Style = int (AStyle); MyCStructure.ContextFillArea.IntColor.r = float (R); MyCStructure.ContextFillArea.IntColor.g = float (G); MyCStructure.ContextFillArea.IntColor.b = float (B); #ifdef OCC1174 if ( CTXF->Distinguish() ) BackIntColor.Values( R, G, B, Quantity_TOC_RGB ); #endif MyCStructure.ContextFillArea.BackIntColor.r = float( R ); MyCStructure.ContextFillArea.BackIntColor.g = float( G ); MyCStructure.ContextFillArea.BackIntColor.b = float( B ); // Edges MyCStructure.ContextFillArea.Edge = CTXF->Edge () ? 1:0; AnEdgeColor.Values (R, G, B, Quantity_TOC_RGB); MyCStructure.ContextFillArea.EdgeColor.r = float (R); MyCStructure.ContextFillArea.EdgeColor.g = float (G); MyCStructure.ContextFillArea.EdgeColor.b = float (B); MyCStructure.ContextFillArea.LineType = int (ALType); MyCStructure.ContextFillArea.Width = float (AWidth); MyCStructure.ContextFillArea.Hatch = int (CTXF->HatchStyle ()); /*** Front and Back face ***/ MyCStructure.ContextFillArea.Distinguish = CTXF->Distinguish () ? 1:0; MyCStructure.ContextFillArea.BackFace = CTXF->BackFace () ? 1:0; /*** Back Material ***/ // Light specificity MyCStructure.ContextFillArea.Back.Shininess = float ((CTXF->BackMaterial ()).Shininess ()); MyCStructure.ContextFillArea.Back.Ambient = float ((CTXF->BackMaterial ()).Ambient ()); MyCStructure.ContextFillArea.Back.Diffuse = float ((CTXF->BackMaterial ()).Diffuse ()); MyCStructure.ContextFillArea.Back.Specular = float ((CTXF->BackMaterial ()).Specular ()); MyCStructure.ContextFillArea.Back.Transparency = float ((CTXF->BackMaterial ()).Transparency ()); MyCStructure.ContextFillArea.Back.Emission = float ((CTXF->BackMaterial ()).Emissive ()); // Reflection mode MyCStructure.ContextFillArea.Back.IsAmbient = ( (CTXF->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 ); MyCStructure.ContextFillArea.Back.IsDiffuse = ( (CTXF->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 ); MyCStructure.ContextFillArea.Back.IsSpecular = ( (CTXF->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 ); MyCStructure.ContextFillArea.Back.IsEmission = ( (CTXF->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 ); // Material type //JR/Hp const Graphic3d_MaterialAspect ama = CTXF->BackMaterial () ; Standard_Boolean amt = ama.MaterialType(Graphic3d_MATERIAL_PHYSIC) ; MyCStructure.ContextFillArea.Back.IsPhysic = ( amt ? 1 : 0 ); // Specular color MyCStructure.ContextFillArea.Back.ColorSpec.r = float (((CTXF->BackMaterial ()).SpecularColor ()).Red ()); MyCStructure.ContextFillArea.Back.ColorSpec.g = float (((CTXF->BackMaterial ()).SpecularColor ()).Green ()); MyCStructure.ContextFillArea.Back.ColorSpec.b = float (((CTXF->BackMaterial ()).SpecularColor ()).Blue ()); // Ambient color MyCStructure.ContextFillArea.Back.ColorAmb.r = float (((CTXF->BackMaterial ()).AmbientColor ()).Red ()); MyCStructure.ContextFillArea.Back.ColorAmb.g = float (((CTXF->BackMaterial ()).AmbientColor ()).Green ()); MyCStructure.ContextFillArea.Back.ColorAmb.b = float (((CTXF->BackMaterial ()).AmbientColor ()).Blue ()); // Diffuse color MyCStructure.ContextFillArea.Back.ColorDif.r = float (((CTXF->BackMaterial ()).DiffuseColor ()).Red ()); MyCStructure.ContextFillArea.Back.ColorDif.g = float (((CTXF->BackMaterial ()).DiffuseColor ()).Green ()); MyCStructure.ContextFillArea.Back.ColorDif.b = float (((CTXF->BackMaterial ()).DiffuseColor ()).Blue ()); // Emissive color MyCStructure.ContextFillArea.Back.ColorEms.r = float (((CTXF->BackMaterial ()).EmissiveColor ()).Red ()); MyCStructure.ContextFillArea.Back.ColorEms.g = float (((CTXF->BackMaterial ()).EmissiveColor ()).Green ()); MyCStructure.ContextFillArea.Back.ColorEms.b = float (((CTXF->BackMaterial ()).EmissiveColor ()).Blue ()); MyCStructure.ContextFillArea.Back.EnvReflexion = float ((CTXF->BackMaterial ()).EnvReflexion()); /*** Front Material ***/ // Light specificity MyCStructure.ContextFillArea.Front.Shininess = float ((CTXF->FrontMaterial ()).Shininess ()); MyCStructure.ContextFillArea.Front.Ambient = float ((CTXF->FrontMaterial ()).Ambient ()); MyCStructure.ContextFillArea.Front.Diffuse = float ((CTXF->FrontMaterial ()).Diffuse ()); MyCStructure.ContextFillArea.Front.Specular = float ((CTXF->FrontMaterial ()).Specular ()); MyCStructure.ContextFillArea.Front.Transparency = float ((CTXF->FrontMaterial ()).Transparency ()); MyCStructure.ContextFillArea.Front.Emission = float ((CTXF->FrontMaterial ()).Emissive ()); // Reflection mode MyCStructure.ContextFillArea.Front.IsAmbient = ( (CTXF->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 ); MyCStructure.ContextFillArea.Front.IsDiffuse = ( (CTXF->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 ); MyCStructure.ContextFillArea.Front.IsSpecular = ( (CTXF->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 ); MyCStructure.ContextFillArea.Front.IsEmission = ( (CTXF->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 ); // Material type //JR/Hp const Graphic3d_MaterialAspect amas = CTXF->FrontMaterial () ; Standard_Boolean amty = amas.MaterialType(Graphic3d_MATERIAL_PHYSIC) ; MyCStructure.ContextFillArea.Front.IsPhysic = ( amty ? 1 : 0 ); // Specular color MyCStructure.ContextFillArea.Front.ColorSpec.r = float (((CTXF->FrontMaterial ()).SpecularColor ()).Red ()); MyCStructure.ContextFillArea.Front.ColorSpec.g = float (((CTXF->FrontMaterial ()).SpecularColor ()).Green ()); MyCStructure.ContextFillArea.Front.ColorSpec.b = float (((CTXF->FrontMaterial ()).SpecularColor ()).Blue ()); // Ambient color MyCStructure.ContextFillArea.Front.ColorAmb.r = float (((CTXF->FrontMaterial ()).AmbientColor ()).Red ()); MyCStructure.ContextFillArea.Front.ColorAmb.g = float (((CTXF->FrontMaterial ()).AmbientColor ()).Green ()); MyCStructure.ContextFillArea.Front.ColorAmb.b = float (((CTXF->FrontMaterial ()).AmbientColor ()).Blue ()); // Diffuse color MyCStructure.ContextFillArea.Front.ColorDif.r = float (((CTXF->FrontMaterial ()).DiffuseColor ()).Red ()); MyCStructure.ContextFillArea.Front.ColorDif.g = float (((CTXF->FrontMaterial ()).DiffuseColor ()).Green ()); MyCStructure.ContextFillArea.Front.ColorDif.b = float (((CTXF->FrontMaterial ()).DiffuseColor ()).Blue ()); // Emissive color MyCStructure.ContextFillArea.Front.ColorEms.r = float (((CTXF->FrontMaterial ()).EmissiveColor ()).Red ()); MyCStructure.ContextFillArea.Front.ColorEms.g = float (((CTXF->FrontMaterial ()).EmissiveColor ()).Green ()); MyCStructure.ContextFillArea.Front.ColorEms.b = float (((CTXF->FrontMaterial ()).EmissiveColor ()).Blue ()); MyCStructure.ContextFillArea.Front.EnvReflexion = float ((CTXF->FrontMaterial ()).EnvReflexion()); MyCStructure.ContextFillArea.Texture.TextureMap = CTXF->TextureMap(); MyCStructure.ContextFillArea.Texture.doTextureMap = CTXF->TextureMapState() ? 1 : 0; MyCStructure.ContextFillArea.ShaderProgram = CTXF->ShaderProgram(); // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets Standard_Integer aPolyMode; Standard_ShortReal aPolyFactor, aPolyUnits; CTXF->PolygonOffsets(aPolyMode, aPolyFactor, aPolyUnits); MyCStructure.ContextFillArea.PolygonOffsetMode = aPolyMode; MyCStructure.ContextFillArea.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor; MyCStructure.ContextFillArea.PolygonOffsetUnits = (Standard_ShortReal)aPolyUnits; // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets } void Graphic3d_Structure::GraphicHighlight (const Aspect_TypeOfHighlightMethod AMethod) { Standard_Real XMin, YMin, ZMin, XMax, YMax, ZMax; Standard_Real R, G, B; MyCStructure.highlight = 1; MyHighlightMethod = AMethod; switch (AMethod) { case Aspect_TOHM_COLOR : MyHighlightColor.Values (R, G, B, Quantity_TOC_RGB); MyGraphicDriver->HighlightColor (MyCStructure, float (R), float (G), float (B) , Standard_True); MyGraphicDriver->NameSetStructure (MyCStructure); break; case Aspect_TOHM_BLINK : MyGraphicDriver->Blink (MyCStructure, Standard_True); MyGraphicDriver->NameSetStructure (MyCStructure); break; case Aspect_TOHM_BOUNDBOX : if (IsEmpty () || IsInfinite ()) { // Empty or infinite structure XMin = YMin = ZMin = 0.; XMax = YMax = ZMax = 0.; } else { MinMaxCoordWithDescendants (XMin, YMin, ZMin, XMax, YMax, ZMax); } MyCStructure.BoundBox.Pmin.x = float (XMin); MyCStructure.BoundBox.Pmin.y = float (YMin); MyCStructure.BoundBox.Pmin.z = float (ZMin); MyCStructure.BoundBox.Pmax.x = float (XMax); MyCStructure.BoundBox.Pmax.y = float (YMax); MyCStructure.BoundBox.Pmax.z = float (ZMax); MyHighlightColor.Values (R, G, B, Quantity_TOC_RGB); MyCStructure.BoundBox.Color.r = float (R); MyCStructure.BoundBox.Color.g = float (G); MyCStructure.BoundBox.Color.b = float (B); MyGraphicDriver->BoundaryBox (MyCStructure, Standard_True); break; } } void Graphic3d_Structure::GraphicTransform (const TColStd_Array2OfReal& AMatrix) { Standard_Integer i, j; for (i=0; i<=3; i++) for (j=0; j<=3; j++) MyCStructure.Transformation[i][j] = float (AMatrix (i, j)); MyGraphicDriver->TransformStructure (MyCStructure); } void Graphic3d_Structure::GraphicUnHighlight () { MyCStructure.highlight = 0; switch (MyHighlightMethod) { case Aspect_TOHM_COLOR : MyGraphicDriver->HighlightColor (MyCStructure, 0.0, 0.0, 0.0 , Standard_False); MyGraphicDriver->NameSetStructure (MyCStructure); break; case Aspect_TOHM_BLINK : MyGraphicDriver->Blink (MyCStructure, Standard_False); MyGraphicDriver->NameSetStructure (MyCStructure); break; case Aspect_TOHM_BOUNDBOX : MyGraphicDriver->BoundaryBox (MyCStructure, Standard_False); MyGraphicDriver->NameSetStructure (MyCStructure); break; } } Graphic3d_TypeOfStructure Graphic3d_Structure::ComputeVisual () const { return (MyComputeVisual); } void Graphic3d_Structure::SetComputeVisual (const Graphic3d_TypeOfStructure AVisual) { // The ComputeVisual is saved only if the structure is // declared TOS_ALL, TOS_WIREFRAME or TOS_SHADING. // This declaration permits to calculate // proper representation of the structure calculated by Compute // instead of passage to TOS_COMPUTED. if (AVisual != Graphic3d_TOS_COMPUTED) MyComputeVisual = AVisual; } void Graphic3d_Structure::Plot (const Handle(Graphic3d_Plotter)& ) { } void Graphic3d_Structure::SetManager (const Handle(Graphic3d_StructureManager)& AManager, const Standard_Boolean #ifdef IMPLEMENTED WithPropagation #endif ) { // All connected structures should follow ? #ifdef IMPLEMENTED if (WithPropagation) { Standard_Integer i, Length; Length = MyDescendants.Length (); for (i=1; i<=Length; i++) ((Graphic3d_Structure *) (MyDescendants.Value (i)))->SetStructureManager (AManager); Length = MyAncestors.Length (); for (i=1; i<=Length; i++) ((Graphic3d_Structure *) (MyAncestors.Value (i)))->SetStructureManager (AManager); } #endif // change of identification ? // MyStructureManager->Remove (Standard_Integer (MyCStructure.Id)); // AManager->NewIdentification (); // MyCStructure.Id = int (AManager->NewIdentification ()); Aspect_TypeOfUpdate UpdateMode = MyStructureManager->UpdateMode (); Aspect_TypeOfUpdate NewUpdateMode = AManager->UpdateMode (); MyStructureManager->SetUpdateMode (Aspect_TOU_WAIT); AManager->SetUpdateMode (Aspect_TOU_WAIT); if (MyCStructure.stick) { MyStructureManager->Erase (this); AManager->Display (this); } if (MyCStructure.highlight) { } if (MyCStructure.pick) { MyStructureManager->Undetectable (this); AManager->Detectable (this); } MyStructureManager->SetUpdateMode (UpdateMode); AManager->SetUpdateMode (NewUpdateMode); // New manager MyPtrStructureManager = (void *) AManager.operator->(); } void Graphic3d_Structure::SetHLRValidation (const Standard_Boolean AFlag) { MyCStructure.HLRValidation = AFlag ? 1:0; } Standard_Boolean Graphic3d_Structure::HLRValidation () const { // Hidden parts stored in are valid if : // 1/ the owner is defined. // 2/ they are not invalid. Standard_Boolean Result = MyOwner != NULL && MyCStructure.HLRValidation != 0; return Result; } //======================================================================= //function : CStructure //purpose : //======================================================================= Graphic3d_CStructure* Graphic3d_Structure::CStructure() { return &MyCStructure; } //======================================================================= //function : SetZLayer //purpose : //======================================================================= void Graphic3d_Structure::SetZLayer (const Standard_Integer theLayerId) { // if the structure is not displayed, unable to change its display layer if (IsDeleted ()) return; MyStructureManager->ChangeZLayer (this, theLayerId); } //======================================================================= //function : GetZLayer //purpose : //======================================================================= Standard_Integer Graphic3d_Structure::GetZLayer () const { return MyStructureManager->GetZLayer (this); } //======================================================================= //function : SetClipPlanes //purpose : //======================================================================= void Graphic3d_Structure::SetClipPlanes (const Graphic3d_SequenceOfHClipPlane& thePlanes) { MyCStructure.ClipPlanes = thePlanes; MyGraphicDriver->SetClipPlanes (MyCStructure); } //======================================================================= //function : GetClipPlanes //purpose : //======================================================================= const Graphic3d_SequenceOfHClipPlane& Graphic3d_Structure::GetClipPlanes() const { return MyCStructure.ClipPlanes; }