0024070: OpenGL capped object-level clipping planes
[occt.git] / src / Graphic3d / Graphic3d_Structure.cxx
CommitLineData
b311480e 1// Created by: NW,JPB,CAL
2// Copyright (c) 1991-1999 Matra Datavision
3// Copyright (c) 1999-2012 OPEN CASCADE SAS
4//
5// The content of this file is subject to the Open CASCADE Technology Public
6// License Version 6.5 (the "License"). You may not use the content of this file
7// except in compliance with the License. Please obtain a copy of the License
8// at http://www.opencascade.org and read it completely before using this file.
9//
10// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12//
13// The Original Code and all software distributed under the License is
14// distributed on an "AS IS" basis, without warranty of any kind, and the
15// Initial Developer hereby disclaims all such warranties, including without
16// limitation, any warranties of merchantability, fitness for a particular
17// purpose or non-infringement. Please see the License for the specific terms
18// and conditions governing the rights and limitations under the License.
19
7fd59977 20// Modified 1/08/97 ; PCT : ajout texture mapping
21// 20/08/97 ; PCT : ajout transparence pour texture
22// 11/97 ; CAL : gestion du GraphicClear
23// 11/97 ; CAL : ajout pointer StructPtr
24// 11/97 ; CAL : amelioration de l'effacement SetManager
25// CAL : 15 janvier 1998
26// Ajout de la methode IsTransformed dans une Structure.
27// (Permet la transmission de cette Trsf vers
28// la structure COMPUTED si necessaire)
7fd59977 29// Ajout de la methode IsRotated dans une Structure.
30// (Permet de connaitre le type de transformation
31// pour declencher le calcul des parties cachees
32// de maniere plus sioux)
7fd59977 33// Ajout de 3 nouvelles methodes Compute virtual dans Structure.
34// (Permet des Compute un peu plus specialises)
7fd59977 35// Ajout des 2 methodes sur Owner dans Structure.
36// (evite de calculer 2 fois les parties cachees
37// pour 2 representations differentes affichees
38// d'un meme Presentable Object (Owner))
7fd59977 39// Ajout des 2 methodes sur HLRValidation dans Structure.
40// (permet de valider ou d'invalider le calcul des
41// parties cachees sur certaines representations)
7fd59977 42// Ajout de la transmission de la transformation d'une structure
43// vers sa COMPUTED.
44// 24/2/98 ; CAL : Modification de la gestion des champs
45// CAL : 26 mars 1998
46// Patch, erreur dans la gestion du nombre de Group avec
47// facettes dans Graphic3d_Structure avec une operation
48// de Clear. (PRO12795)
49// FGU : 30 Avril 1998
50// Ajout emission
51// CAL : 20 mai 1998
52// Perfs. Connection entre structures COMPUTED.
bbf32d01
K
53// 30/11/98 ; FMN : S4069. Textes always visible.
54// 22/03/04 ; SAN : OCC4895 High-level interface for controlling polygon offsets
7fd59977 55
bbf32d01 56#define BUC60918 //GG 31/05/01 A transparente structure priority must have the
7fd59977 57// MAX_PRIORITY value so, the highlighted structure must have
bbf32d01 58// MAX_PRIORITY-1 value.
7fd59977 59// Add ResetDisplayPriority() method.
60
61#define OCC1174 // SAV 08/01/03 Added back face interior color controling
62
63
7fd59977 64
bbf32d01 65//-Version
7fd59977 66
81bba717 67//-Design Declaration of variables specific to graphic structures
7fd59977 68
81bba717 69//-Warning A structure is defined in a manager
70// This is a sequence of groups of primitives
7fd59977 71
bbf32d01 72//-References
7fd59977 73
74//-Language C++ 2.0
75
76//-Declarations
77
78// for the class
79
80#define XDOWNCAST
81#define XDESTROY
82#define XDEBUG
83#define XTRACE
84#define XTRACE_ISTRSF
85
86#include <stdio.h>
87
88#include <Graphic3d_Structure.ixx>
89#include <Graphic3d_Structure.pxx>
90
7fd59977 91#include <Graphic3d_GraphicDriver.hxx>
92#include <Graphic3d_MaterialAspect.hxx>
93
94#include <Graphic3d_MapOfStructure.hxx>
95#include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
96
97#include <Quantity_Color.hxx>
98#include <TColStd_Array2OfReal.hxx>
99#include <Graphic3d_TextureMap.hxx>
100
bbf32d01 101// OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
7fd59977 102#include <Aspect_PolygonOffsetMode.hxx>
bbf32d01 103// OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
7fd59977 104
105//-Aliases
106
107//-Global data definitions
108
109//-Constructors
110
111Graphic3d_Structure::Graphic3d_Structure (const Handle(Graphic3d_StructureManager)& AManager):
7fd59977 112MyAncestors (),
113MyDescendants (),
114MyGroups (),
115MyHighlightColor (Quantity_NOC_WHITE)
116{
117
118 Standard_Integer i, j;
119
120 MyOwner = NULL;
121
122 Handle(Graphic3d_AspectLine3d) aAspectLine3d =
123 new Graphic3d_AspectLine3d ();
124 Handle(Graphic3d_AspectText3d) aAspectText3d =
125 new Graphic3d_AspectText3d ();
126 Handle(Graphic3d_AspectMarker3d) aAspectMarker3d =
127 new Graphic3d_AspectMarker3d ();
128 Handle(Graphic3d_AspectFillArea3d) aAspectFillArea3d =
129 new Graphic3d_AspectFillArea3d ();
130
81bba717 131 // Return default values
7fd59977 132 AManager->PrimitivesAspect (aAspectLine3d, aAspectText3d,
133 aAspectMarker3d, aAspectFillArea3d);
134
bbf32d01 135 // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
7fd59977 136 // It is necessary to set default polygon offsets for a new presentation
137 aAspectFillArea3d->SetPolygonOffsets( Aspect_POM_Fill, 1., 0. );
bbf32d01 138 // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
7fd59977 139
81bba717 140 // Update the associated CStructure
7fd59977 141 UpdateStructure (aAspectLine3d, aAspectText3d,
142 aAspectMarker3d, aAspectFillArea3d);
143
144 MyFirstPtrStructureManager = MyPtrStructureManager =
145 (void *) AManager.operator->();
146 MyCStructure.Id = int (AManager->NewIdentification ());
147
148 MyCStructure.IsOpen = 0;
149 MyCStructure.IsDeleted = 0;
150
151 MyCStructure.Composition = 0; /* Graphic3d_TOC_REPLACE */
152
153 for (i=0; i<=3; i++)
154 for (j=0; j<=3; j++)
155 if (i == j)
156 MyCStructure.Transformation[i][j] = float (1.0);
157 else
158 MyCStructure.Transformation[i][j] = float (0.0);
159
160 MyCStructure.Priority = int (Structure_MAX_PRIORITY / 2);
161 MyCStructure.PreviousPriority = MyCStructure.Priority;
162 MyCStructure.stick = 0,
163 MyCStructure.highlight = 0,
164 MyCStructure.visible = 1,
165 MyCStructure.pick = 1;
166 MyCStructure.ContainsFacet = 0,
167 MyCStructure.IsInfinite = 0,
168 MyCStructure.HLRValidation = 0;
169
7fd59977 170 MyCStructure.ContextLine.IsDef = 1,
171 MyCStructure.ContextFillArea.IsDef = 1,
172 MyCStructure.ContextMarker.IsDef = 1,
173 MyCStructure.ContextText.IsDef = 1;
174
175 MyCStructure.ContextLine.IsSet = 0,
176 MyCStructure.ContextFillArea.IsSet = 0,
177 MyCStructure.ContextMarker.IsSet = 0,
178 MyCStructure.ContextText.IsSet = 0;
179
180 MyVisual = Graphic3d_TOS_ALL;
181 MyComputeVisual = Graphic3d_TOS_ALL;
182
183 /* ABD 29/10/04 Transform Persistence of Presentation( pan, zoom, rotate ) */
184 /*MyCStructure.TransformPersistence.IsDef = 1;*/
185 MyCStructure.TransformPersistence.IsSet = 0;
186 MyCStructure.TransformPersistence.Flag = Graphic3d_TMF_None;
187 MyCStructure.TransformPersistence.Point.x = 0.0;
188 MyCStructure.TransformPersistence.Point.y = 0.0;
189 MyCStructure.TransformPersistence.Point.z = 0.0;
190 /* ABD 29/10/04 Transform Persistence of Presentation( pan, zoom, rotate ) */
7fd59977 191
dc3fe572 192 MyGraphicDriver = AManager->GraphicDriver();
7fd59977 193 MyGraphicDriver->Structure (MyCStructure);
194
195#ifdef TRACE
196 cout << "Graphic3d_Structure::Create (" << MyCStructure.Id << ")\n";
197#endif
198
199}
200
201//-Destructors
202
203void Graphic3d_Structure::Destroy () {
204
205#ifdef DESTROY
206 cout << "Graphic3d_Structure::Destroy (" << MyCStructure.Id << ")\n";
207#endif
208
209 // as MyFirstPtrStructureManager can be already destroyed,
bbf32d01 210 // avoid attempts to access it
7fd59977 211 MyFirstPtrStructureManager = 0;
212 Remove ();
213
214}
215
216//-Methods, in order
217
98178592
A
218void Graphic3d_Structure::Clear (const Standard_Boolean WithDestruction)
219{
220 if (IsDeleted()) return;
7fd59977 221
98178592 222 MyCStructure.ContainsFacet = 0;
7fd59977 223
98178592 224 // clean groups in graphics driver at first
98178592 225 GraphicClear (WithDestruction);
7fd59977 226
98178592
A
227 // only then remove group references
228 if (WithDestruction)
98178592 229 MyGroups.Clear();
7fd59977 230
7fd59977 231 MyStructureManager->Clear (this, WithDestruction);
232
98178592 233 Update();
7fd59977 234}
235
236void Graphic3d_Structure::Remove () {
237
238 if (IsDeleted ()) return;
239
240#ifdef DESTROY
241 if (MyDescendants.Length () != 0) {
242 cout << "The structure " << MyCStructure.Id << " have "
243 << MyDescendants.Length () << " descendants.\n" << flush;
244 }
245 if (MyAncestors.Length () != 0) {
246 cout << "The structure " << MyCStructure.Id << " have "
247 << MyAncestors.Length () << " ancestors.\n" << flush;
248 }
249#endif
250
251 Standard_Integer i, Length;
98178592 252
6c8126b5
A
253 // clean groups in graphics driver at first; this is also should be done
254 // to avoid unwanted group cleaning in group's destructor
255 // Pass Standard_False to Clear(..) method to avoid updating in
256 // structure manager, it isn't necessary, besides of it structure manager
257 // could be already destroyed and invalid pointers used in structure;
98178592
A
258 Length = MyGroups.Length();
259 for (Standard_Integer aGrId = 1; aGrId <= Length; ++aGrId)
6c8126b5 260 MyGroups.ChangeValue (aGrId)->Clear (Standard_False);
98178592 261
7fd59977 262 // Standard_Address APtr = (void *) This ().operator->();
263 Standard_Address APtr = (void *) this;
81bba717 264 // It is necessary to remove the eventual pointer on the structure
265 // that can be destroyed, in the list of descendants
266 // of ancesters of this structure and in the list of ancesters
267 // of descendants of the same structure.
7fd59977 268
269 Length = MyDescendants.Length ();
270 for (i=1; i<=Length; i++)
271 ((Graphic3d_Structure *)
272 (MyDescendants.Value (i)))->Remove (APtr, Graphic3d_TOC_ANCESTOR);
273
274 Length = MyAncestors.Length ();
275 for (i=1; i<=Length; i++)
276 ((Graphic3d_Structure *)
277 (MyAncestors.Value (i)))->Remove (APtr, Graphic3d_TOC_DESCENDANT);
278
279 MyCStructure.ContainsFacet = 0;
280 MyCStructure.IsDeleted = 1;
281
81bba717 282 // Destruction of me in the graphic library
7fd59977 283 MyGraphicDriver->RemoveStructure (MyCStructure);
284
bbf32d01 285 // Liberation of the identification if the destroyed structure
81bba717 286 // in the first manager that performs creation of the structure.
7fd59977 287 if ( MyFirstPtrStructureManager )
288 MyFirstStructureManager->Remove (Standard_Integer (MyCStructure.Id));
289
290}
291
292void Graphic3d_Structure::Display () {
293
294 if (IsDeleted ()) return;
295
296 if (! MyCStructure.stick) {
297 MyCStructure.stick = 1;
298 MyStructureManager->Display (this);
299 }
300
301}
302
303void Graphic3d_Structure::Display (const Standard_Integer Priority) {
304
305 if (IsDeleted ()) return;
306
307 SetDisplayPriority (Priority);
308
309 if (! MyCStructure.stick) {
310 MyCStructure.stick = 1;
311 MyStructureManager->Display (this);
312 }
313
314}
315
316void Graphic3d_Structure::SetDisplayPriority (const Standard_Integer Priority) {
317
318 if (IsDeleted ()) return;
319
320#ifdef BUC60918
321 if( Priority == MyCStructure.Priority ) return;
322#endif
323
324 MyCStructure.PreviousPriority = MyCStructure.Priority;
325 MyCStructure.Priority = int (Priority);
326
327 if (MyCStructure.Priority != MyCStructure.PreviousPriority) {
328 if ( (MyCStructure.Priority > Structure_MAX_PRIORITY) ||
329 (MyCStructure.Priority < Structure_MIN_PRIORITY) )
330 Graphic3d_PriorityDefinitionError::Raise
331 ("Bad value for StructurePriority");
332
333 if (MyCStructure.stick)
334 MyStructureManager->ChangeDisplayPriority (this,
335 Standard_Integer (MyCStructure.PreviousPriority),
336 Standard_Integer (MyCStructure.Priority));
337 }
338
339}
340
341#ifdef BUC60918
342void Graphic3d_Structure::ResetDisplayPriority () {
343
344 if (IsDeleted ()) return;
345
346 if (MyCStructure.Priority != MyCStructure.PreviousPriority) {
347 Standard_Integer priority = MyCStructure.Priority;
348 MyCStructure.Priority = MyCStructure.PreviousPriority;
349
350 if (MyCStructure.stick)
351 MyStructureManager->ChangeDisplayPriority (this,
352 priority,
353 Standard_Integer (MyCStructure.Priority));
354 }
355
356}
357#endif
358
359Standard_Integer Graphic3d_Structure::DisplayPriority () const {
360
361 return Standard_Integer (MyCStructure.Priority);
362
363}
364
365void Graphic3d_Structure::Erase () {
366
367 if (IsDeleted ()) return;
368
369 if (MyCStructure.stick) {
370 MyCStructure.stick = 0;
371 MyStructureManager->Erase (this);
372 }
373
374}
375
376void Graphic3d_Structure::Highlight (const Aspect_TypeOfHighlightMethod AMethod) {
377
378 if (IsDeleted ()) return;
379
81bba717 380 // Highlight on already Highlighted structure.
7fd59977 381 if (MyCStructure.highlight) {
382
383 Aspect_TypeOfUpdate UpdateMode = MyStructureManager->UpdateMode ();
384 if (UpdateMode == Aspect_TOU_WAIT)
385 UnHighlight ();
386 else {
81bba717 387 // To avoid call of method : Update ()
388 // Not useful and can be costly.
7fd59977 389 MyStructureManager->SetUpdateMode (Aspect_TOU_WAIT);
390 UnHighlight ();
391 MyStructureManager->SetUpdateMode (UpdateMode);
392 }
393 }
394
395#ifdef BUC60918
396 SetDisplayPriority (Standard_Integer (Structure_MAX_PRIORITY)-1);
397#else
398 SetDisplayPriority (Standard_Integer (Structure_MAX_PRIORITY));
399#endif
400
401 GraphicHighlight (AMethod);
402 MyStructureManager->Highlight (this, AMethod);
403
404 Update ();
405
406}
407
408void Graphic3d_Structure::SetHighlightColor (const Quantity_Color& AColor) {
409
410 if (IsDeleted ()) return;
411
412 if (! MyCStructure.highlight)
413 MyHighlightColor = AColor;
414 else {
81bba717 415 // Change highlight color on already Highlighted structure.
7fd59977 416
417 Aspect_TypeOfUpdate UpdateMode = MyStructureManager->UpdateMode ();
418 if (UpdateMode == Aspect_TOU_WAIT)
419 UnHighlight ();
420 else {
81bba717 421 // To avoid call of method : Update ()
422 // Not useful and can be costly.
7fd59977 423 MyStructureManager->SetUpdateMode (Aspect_TOU_WAIT);
424 UnHighlight ();
425 MyStructureManager->SetUpdateMode (UpdateMode);
426 }
427 MyHighlightColor = AColor;
428 Highlight (MyHighlightMethod);
429 }
430
431}
432
433void Graphic3d_Structure::SetVisible (const Standard_Boolean AValue) {
434
435 if (IsDeleted ()) return;
436
437 MyCStructure.visible = AValue ? 1:0;
438
439 MyGraphicDriver->NameSetStructure (MyCStructure);
440
441 if (AValue)
442 MyStructureManager->Visible (this);
443 else
444 MyStructureManager->Invisible (this);
445
446 Update ();
447
448}
449
450void Graphic3d_Structure::SetPick (const Standard_Boolean AValue) {
451
452 if (IsDeleted ()) return;
453
454 MyCStructure.pick = AValue ? 1:0;
455
456 MyGraphicDriver->NameSetStructure (MyCStructure);
457
458 if (AValue)
459 MyStructureManager->Detectable (this);
460 else
461 MyStructureManager->Undetectable (this);
462
463 Update ();
464
465}
466
467void Graphic3d_Structure::UnHighlight () {
468
469 if (IsDeleted ()) return;
470
471 if (MyCStructure.highlight) {
472 MyCStructure.highlight = 0;
473
474 GraphicUnHighlight ();
475 MyStructureManager->UnHighlight (this);
476#ifdef BUC60918
477 ResetDisplayPriority();
478#else
479 SetDisplayPriority
480 (Standard_Integer (MyCStructure.PreviousPriority));
481#endif
482 Update ();
483 }
484
485}
486
487Quantity_Color Graphic3d_Structure::HighlightColor () const {
488
489 return (MyHighlightColor);
490
491}
492
493Standard_Boolean Graphic3d_Structure::IsDisplayed () const {
494
495 if (MyCStructure.stick)
496 return (Standard_True);
497 else
498 return (Standard_False);
499
500}
501
502Standard_Boolean Graphic3d_Structure::IsDeleted () const {
503
504 if (MyCStructure.IsDeleted)
505 return (Standard_True);
506 else
507 return (Standard_False);
508
509}
510
511Standard_Boolean Graphic3d_Structure::IsHighlighted () const {
512
513 if (MyCStructure.highlight)
514 return (Standard_True);
515 else
516 return (Standard_False);
517
518}
519
520Standard_Boolean Graphic3d_Structure::IsSelectable () const {
521
522 if (MyCStructure.pick)
523 return (Standard_True);
524 else
525 return (Standard_False);
526
527}
528
529Standard_Boolean Graphic3d_Structure::IsVisible () const {
530
531 if (MyCStructure.visible)
532 return (Standard_True);
533 else
534 return (Standard_False);
535
536}
537
538Standard_Boolean Graphic3d_Structure::IsRotated () const {
539
81bba717 540 // A somewhat light test !
7fd59977 541 return ( MyCStructure.Transformation[0][1] != 0.
542 || MyCStructure.Transformation[0][2] != 0.
543 || MyCStructure.Transformation[1][0] != 0.
544 || MyCStructure.Transformation[1][2] != 0.
545 || MyCStructure.Transformation[2][0] != 0.
546 || MyCStructure.Transformation[2][1] != 0. );
547
548}
549
550Standard_Boolean Graphic3d_Structure::IsTransformed () const {
551
552 Standard_Boolean Result = Standard_False;
553 Standard_Integer i, j;
554
555 for (i=0; i<=3 && ! Result; i++)
556 for (j=0; j<=3 && ! Result; j++)
557 if (i == j)
558 Result = MyCStructure.Transformation[i][j] != 1.;
559 else
560 Result = MyCStructure.Transformation[i][j] != 0.;
561
562#ifdef TRACE_ISTRSF
81bba717 563 cout << "Structure " << Identification ();
7fd59977 564 if (Result)
81bba717 565 cout << " is transformed\n" << flush;
7fd59977 566 else
81bba717 567 cout << " is not transformed\n" << flush;
7fd59977 568#endif
569
570 return Result;
571
572}
573
574Standard_Boolean Graphic3d_Structure::ContainsFacet () const {
575
576 if (IsDeleted ()) return (Standard_False);
577
81bba717 578 // A structure contains at least one facet :
579 // if one of these groups contains at least one facet.
7fd59977 580
581 Standard_Boolean Result1 = Standard_False;
582 Standard_Boolean Result2 = Standard_False;
583 Standard_Integer i, Length;
584
585 Result1 = (MyCStructure.ContainsFacet > 0);
586
81bba717 587 // If one of groups contains at least one facet, the structure contains it too.
7fd59977 588 if (Result1) return (Result1);
589
590 Length = MyDescendants.Length ();
591
81bba717 592 // Stop at the first descendant containing at least one facet.
7fd59977 593 for (i=1; i<=Length && ! Result2; i++)
594 Result2 = ((Graphic3d_Structure *)
595 (MyDescendants.Value (i)))->ContainsFacet ();
596
597 return (Result2);
598
599}
600
601Standard_Boolean Graphic3d_Structure::IsEmpty () const {
602
603 if (IsDeleted ()) return (Standard_True);
604
81bba717 605 // A structure is empty :
bbf32d01 606 // if all these groups are empty or if all
81bba717 607 // groups are empty and all their descendants
608 // are empty or if all its descendants are empty.
7fd59977 609
610 Standard_Boolean Result1 = Standard_True;
611 Standard_Integer i, Length = MyGroups.Length ();
612
81bba717 613 // Stop at the first non-empty group
7fd59977 614 for (i=1; i<=Length && Result1; i++)
615 Result1 = (MyGroups.Value (i))->IsEmpty ();
616
81bba717 617 // If a group is non-empty the structure is also non-empty.
7fd59977 618 if (! Result1) return (Standard_False);
619
620 Standard_Boolean Result2 = Standard_True;
621
622 Length = MyDescendants.Length ();
623
bbf32d01 624 // Stop at the first non-empty descendant
7fd59977 625 for (i=1; i<=Length && Result2; i++)
626 Result2 = ((Graphic3d_Structure *)
627 (MyDescendants.Value (i)))->IsEmpty ();
628
629 return (Result2);
630
631}
632
633void Graphic3d_Structure::PrimitivesAspect (Handle(Graphic3d_AspectLine3d)& CTXL, Handle(Graphic3d_AspectText3d)& CTXT, Handle(Graphic3d_AspectMarker3d)& CTXM, Handle(Graphic3d_AspectFillArea3d)& CTXF) const {
634
635 CTXL = Line3dAspect ();
636 CTXT = Text3dAspect ();
637 CTXM = Marker3dAspect ();
638 CTXF = FillArea3dAspect ();
639
640}
641
642void Graphic3d_Structure::GroupsWithFacet (const Standard_Integer ADelta) {
643
644 MyCStructure.ContainsFacet = MyCStructure.ContainsFacet + ADelta;
645 if (MyCStructure.ContainsFacet < 0) MyCStructure.ContainsFacet = 0;
646
647#ifdef DEBUG
648 cout << "MyCStructure.ContainsFacet " << MyCStructure.ContainsFacet;
649 cout << endl << flush;
650#endif
651
652}
653
654Handle(Graphic3d_Structure) Graphic3d_Structure::Compute (const Handle(Graphic3d_DataStructureManager)& ) {
655
656 // Implemented by Presentation
657 return this;
658}
659
660Handle(Graphic3d_Structure) Graphic3d_Structure::Compute (const Handle(Graphic3d_DataStructureManager)& , const TColStd_Array2OfReal& ) {
661
662 // Implemented by Presentation
663 return this;
664}
665
666void Graphic3d_Structure::Compute (const Handle(Graphic3d_DataStructureManager)& , Handle(Graphic3d_Structure)& ) {
667
668 // Implemented by Presentation
669}
670
671void Graphic3d_Structure::Compute (const Handle(Graphic3d_DataStructureManager)& , const TColStd_Array2OfReal& , Handle(Graphic3d_Structure)& ) {
672
673 // Implemented by Presentation
674}
675
676void Graphic3d_Structure::ReCompute () {
677
678 MyStructureManager->ReCompute (this);
679
680}
681
682void Graphic3d_Structure::ReCompute (const Handle(Graphic3d_DataStructureManager)& aProjector) {
683
684 MyStructureManager->ReCompute (this, aProjector);
685
686}
687
688void Graphic3d_Structure::SetInfiniteState (const Standard_Boolean AValue) {
689
690 MyCStructure.IsInfinite = AValue ? 1:0;
691
692}
693
694Standard_Boolean Graphic3d_Structure::IsInfinite () const {
695
696 if (IsDeleted ()) return (Standard_True);
697
698 if (MyCStructure.IsInfinite)
699 return (Standard_True);
700 else
701 return (Standard_False);
702
703}
704
5e27df78 705void Graphic3d_Structure::GraphicClear (const Standard_Boolean WithDestruction)
706{
707 // clean and empty each group
708 Standard_Integer Length = MyGroups.Length();
709 for (Standard_Integer aGrId = 1; aGrId <= Length; ++aGrId)
710 {
711 MyGroups.ChangeValue (aGrId)->Clear();
712 }
7fd59977 713
714 if (WithDestruction)
5e27df78 715 {
5e27df78 716 while (!MyGroups.IsEmpty())
717 {
718 Handle(Graphic3d_Group) aGroup = MyGroups.First();
719 aGroup->Remove();
720 }
7fd59977 721
5e27df78 722 MyGraphicDriver->ClearStructure (MyCStructure);
7fd59977 723 }
7fd59977 724}
725
bf75be98 726void Graphic3d_Structure::GraphicConnect (const Handle(Graphic3d_Structure)& theDaughter)
727{
728 MyGraphicDriver->Connect (MyCStructure, theDaughter->MyCStructure);
7fd59977 729}
730
bf75be98 731void Graphic3d_Structure::GraphicDisconnect (const Handle(Graphic3d_Structure)& theDaughter)
732{
733 MyGraphicDriver->Disconnect (MyCStructure, theDaughter->MyCStructure);
7fd59977 734}
735
736Handle(Graphic3d_AspectLine3d) Graphic3d_Structure::Line3dAspect () const {
737
738 Standard_Real R, G, B;
739 Standard_Real AWidth;
740 Quantity_Color AColor;
741 Aspect_TypeOfLine ALType;
742
743 // ContextLine
744 R = Standard_Real (MyCStructure.ContextLine.Color.r);
745 G = Standard_Real (MyCStructure.ContextLine.Color.g);
746 B = Standard_Real (MyCStructure.ContextLine.Color.b);
747 AColor.SetValues (R, G, B, Quantity_TOC_RGB);
748 ALType = Aspect_TypeOfLine (MyCStructure.ContextLine.LineType);
749 AWidth = Standard_Real (MyCStructure.ContextLine.Width);
750
751 Handle(Graphic3d_AspectLine3d) CTXL =
752 new Graphic3d_AspectLine3d (AColor, ALType, AWidth);
753
754 return CTXL;
755
756}
757
758Handle(Graphic3d_AspectText3d) Graphic3d_Structure::Text3dAspect () const {
759
760 Standard_Real R, G, B;
761 Standard_CString AFont;
762 Standard_Real ASpace;
763 Standard_Real AnExpansion;
764 Quantity_Color AColor;
765 Aspect_TypeOfStyleText AStyle;
766 Aspect_TypeOfDisplayText ADisplayType;
767
768 // ContextText
769 R = Standard_Real (MyCStructure.ContextText.Color.r);
770 G = Standard_Real (MyCStructure.ContextText.Color.g);
771 B = Standard_Real (MyCStructure.ContextText.Color.b);
772 AColor.SetValues (R, G, B, Quantity_TOC_RGB);
773 AFont = Standard_CString (MyCStructure.ContextText.Font);
774 AnExpansion = Standard_Real (MyCStructure.ContextText.Expan);
775 ASpace = Standard_Real (MyCStructure.ContextText.Space);
776 AStyle = Aspect_TypeOfStyleText (MyCStructure.ContextText.Style);
777 ADisplayType = Aspect_TypeOfDisplayText (MyCStructure.ContextText.DisplayType);
778
779 Handle(Graphic3d_AspectText3d) CTXT =
780 new Graphic3d_AspectText3d (AColor, AFont, AnExpansion, ASpace,AStyle,ADisplayType);
781
782 return CTXT;
783
784}
785
786Handle(Graphic3d_AspectMarker3d) Graphic3d_Structure::Marker3dAspect () const {
787
788 Standard_Real R, G, B;
789 Standard_Real AScale;
790 Quantity_Color AColor;
791 Aspect_TypeOfMarker AMType;
792
793 // ContextMarker
794 R = Standard_Real (MyCStructure.ContextMarker.Color.r);
795 G = Standard_Real (MyCStructure.ContextMarker.Color.g);
796 B = Standard_Real (MyCStructure.ContextMarker.Color.b);
797 AColor.SetValues (R, G, B, Quantity_TOC_RGB);
a577aaab 798 AMType = MyCStructure.ContextMarker.MarkerType;
7fd59977 799 AScale = Standard_Real (MyCStructure.ContextMarker.Scale);
800
801 Handle(Graphic3d_AspectMarker3d) CTXM =
802 new Graphic3d_AspectMarker3d (AMType, AColor, AScale);
803
804 return CTXM;
805
806}
807
808Handle(Graphic3d_AspectFillArea3d) Graphic3d_Structure::FillArea3dAspect () const {
809
810 Standard_Real R, G, B;
811 Standard_Real AWidth;
812 Quantity_Color AColor;
813 Quantity_Color AnIntColor;
814 Quantity_Color AnEdgeColor;
815 Aspect_TypeOfLine ALType;
816 Aspect_InteriorStyle AStyle;
817 Standard_Boolean EdgeOn = Standard_False;
818 Graphic3d_MaterialAspect Front;
819 Graphic3d_MaterialAspect Back;
820
821 // ContextFillArea
822 AStyle = Aspect_InteriorStyle (MyCStructure.ContextFillArea.Style);
823 R = Standard_Real (MyCStructure.ContextFillArea.IntColor.r);
824 G = Standard_Real (MyCStructure.ContextFillArea.IntColor.g);
825 B = Standard_Real (MyCStructure.ContextFillArea.IntColor.b);
826 AnIntColor.SetValues (R, G, B, Quantity_TOC_RGB);
827 // Edges
828 if (MyCStructure.ContextFillArea.Edge == 1) EdgeOn = Standard_True;
829 R = Standard_Real (MyCStructure.ContextFillArea.EdgeColor.r);
830 G = Standard_Real (MyCStructure.ContextFillArea.EdgeColor.g);
831 B = Standard_Real (MyCStructure.ContextFillArea.EdgeColor.b);
832 AnEdgeColor.SetValues (R, G, B, Quantity_TOC_RGB);
833 ALType = Aspect_TypeOfLine (MyCStructure.ContextFillArea.LineType);
834 AWidth = Standard_Real (MyCStructure.ContextFillArea.Width);
835 // Back Material
836 Back.SetShininess (
837 Standard_Real (MyCStructure.ContextFillArea.Back.Shininess));
838 Back.SetAmbient (
839 Standard_Real (MyCStructure.ContextFillArea.Back.Ambient));
840 Back.SetDiffuse (
841 Standard_Real (MyCStructure.ContextFillArea.Back.Diffuse));
842 Back.SetSpecular (
843 Standard_Real (MyCStructure.ContextFillArea.Back.Specular));
844 Back.SetTransparency (
845 Standard_Real (MyCStructure.ContextFillArea.Back.Transparency));
846 Back.SetEmissive (
847 Standard_Real (MyCStructure.ContextFillArea.Back.Emission));
848 if (MyCStructure.ContextFillArea.Back.IsAmbient == 1)
849 Back.SetReflectionModeOn (Graphic3d_TOR_AMBIENT);
850 else
851 Back.SetReflectionModeOff (Graphic3d_TOR_AMBIENT);
852 if (MyCStructure.ContextFillArea.Back.IsDiffuse == 1)
853 Back.SetReflectionModeOn (Graphic3d_TOR_DIFFUSE);
854 else
855 Back.SetReflectionModeOff (Graphic3d_TOR_DIFFUSE);
856 if (MyCStructure.ContextFillArea.Back.IsSpecular == 1)
857 Back.SetReflectionModeOn (Graphic3d_TOR_SPECULAR);
858 else
859 Back.SetReflectionModeOff (Graphic3d_TOR_SPECULAR);
860 if (MyCStructure.ContextFillArea.Back.IsEmission == 1)
861 Back.SetReflectionModeOn (Graphic3d_TOR_EMISSION);
862 else
863 Back.SetReflectionModeOff (Graphic3d_TOR_EMISSION);
864
865 R = Standard_Real (MyCStructure.ContextFillArea.Back.ColorSpec.r);
866 G = Standard_Real (MyCStructure.ContextFillArea.Back.ColorSpec.g);
867 B = Standard_Real (MyCStructure.ContextFillArea.Back.ColorSpec.b);
868 AColor.SetValues (R, G, B, Quantity_TOC_RGB);
869 Back.SetSpecularColor (AColor);
870
871 R = Standard_Real (MyCStructure.ContextFillArea.Back.ColorAmb.r);
872 G = Standard_Real (MyCStructure.ContextFillArea.Back.ColorAmb.g);
873 B = Standard_Real (MyCStructure.ContextFillArea.Back.ColorAmb.b);
874 AColor.SetValues (R, G, B, Quantity_TOC_RGB);
875 Back.SetAmbientColor (AColor);
876
877 R = Standard_Real (MyCStructure.ContextFillArea.Back.ColorDif.r);
878 G = Standard_Real (MyCStructure.ContextFillArea.Back.ColorDif.g);
879 B = Standard_Real (MyCStructure.ContextFillArea.Back.ColorDif.b);
880 AColor.SetValues (R, G, B, Quantity_TOC_RGB);
881 Back.SetDiffuseColor (AColor);
882
883 R = Standard_Real (MyCStructure.ContextFillArea.Back.ColorEms.r);
884 G = Standard_Real (MyCStructure.ContextFillArea.Back.ColorEms.g);
885 B = Standard_Real (MyCStructure.ContextFillArea.Back.ColorEms.b);
886 AColor.SetValues (R, G, B, Quantity_TOC_RGB);
887 Back.SetEmissiveColor (AColor);
888
889 Back.SetEnvReflexion (MyCStructure.ContextFillArea.Back.EnvReflexion);
890
bbf32d01
K
891 Graphic3d_TypeOfMaterial mType =
892 MyCStructure.ContextFillArea.Back.IsPhysic ?
7fd59977 893Graphic3d_MATERIAL_PHYSIC : Graphic3d_MATERIAL_ASPECT;
894 Back.SetMaterialType(mType);
895
896 // Front Material
897 Front.SetShininess (
898 Standard_Real (MyCStructure.ContextFillArea.Front.Shininess));
899 Front.SetAmbient (
900 Standard_Real (MyCStructure.ContextFillArea.Front.Ambient));
901 Front.SetDiffuse (
902 Standard_Real (MyCStructure.ContextFillArea.Front.Diffuse));
903 Front.SetSpecular (
904 Standard_Real (MyCStructure.ContextFillArea.Front.Specular));
905 Front.SetTransparency (
906 Standard_Real (MyCStructure.ContextFillArea.Front.Transparency));
907 Front.SetEmissive (
908 Standard_Real (MyCStructure.ContextFillArea.Front.Emission));
909 if (MyCStructure.ContextFillArea.Front.IsAmbient == 1)
910 Front.SetReflectionModeOn (Graphic3d_TOR_AMBIENT);
911 else
912 Front.SetReflectionModeOff (Graphic3d_TOR_AMBIENT);
913 if (MyCStructure.ContextFillArea.Front.IsDiffuse == 1)
914 Front.SetReflectionModeOn (Graphic3d_TOR_DIFFUSE);
915 else
916 Front.SetReflectionModeOff (Graphic3d_TOR_DIFFUSE);
917 if (MyCStructure.ContextFillArea.Front.IsSpecular == 1)
918 Front.SetReflectionModeOn (Graphic3d_TOR_SPECULAR);
919 else
920 Front.SetReflectionModeOff (Graphic3d_TOR_SPECULAR);
921 if (MyCStructure.ContextFillArea.Front.Emission == 1)
922 Front.SetReflectionModeOn (Graphic3d_TOR_EMISSION);
923 else
924 Front.SetReflectionModeOff (Graphic3d_TOR_EMISSION);
925
926 R = Standard_Real (MyCStructure.ContextFillArea.Front.ColorSpec.r);
927 G = Standard_Real (MyCStructure.ContextFillArea.Front.ColorSpec.g);
928 B = Standard_Real (MyCStructure.ContextFillArea.Front.ColorSpec.b);
929 AColor.SetValues (R, G, B, Quantity_TOC_RGB);
930 Front.SetSpecularColor (AColor);
931
932 R = Standard_Real (MyCStructure.ContextFillArea.Front.ColorAmb.r);
933 G = Standard_Real (MyCStructure.ContextFillArea.Front.ColorAmb.g);
934 B = Standard_Real (MyCStructure.ContextFillArea.Front.ColorAmb.b);
935 AColor.SetValues (R, G, B, Quantity_TOC_RGB);
936 Front.SetAmbientColor (AColor);
937
938 R = Standard_Real (MyCStructure.ContextFillArea.Front.ColorDif.r);
939 G = Standard_Real (MyCStructure.ContextFillArea.Front.ColorDif.g);
940 B = Standard_Real (MyCStructure.ContextFillArea.Front.ColorDif.b);
941 AColor.SetValues (R, G, B, Quantity_TOC_RGB);
942 Front.SetDiffuseColor (AColor);
943
944 R = Standard_Real (MyCStructure.ContextFillArea.Front.ColorEms.r);
945 G = Standard_Real (MyCStructure.ContextFillArea.Front.ColorEms.g);
946 B = Standard_Real (MyCStructure.ContextFillArea.Front.ColorEms.b);
947 AColor.SetValues (R, G, B, Quantity_TOC_RGB);
948 Front.SetEmissiveColor (AColor);
949
950 Front.SetEnvReflexion (MyCStructure.ContextFillArea.Front.EnvReflexion);
951
952 mType = MyCStructure.ContextFillArea.Front.IsPhysic ? Graphic3d_MATERIAL_PHYSIC : Graphic3d_MATERIAL_ASPECT;
953 Front.SetMaterialType(mType);
954
955 Handle(Graphic3d_AspectFillArea3d) CTXF =
956 new Graphic3d_AspectFillArea3d (AStyle, AnIntColor, AnEdgeColor, ALType, AWidth, Front, Back);
957
958 // Edges
959 if (EdgeOn)
960 CTXF->SetEdgeOn ();
961 else
962 CTXF->SetEdgeOff ();
963 // Hatch
964 CTXF->SetHatchStyle(Aspect_HatchStyle (MyCStructure.ContextFillArea.Hatch));
965 // Materials
966 // Front and Back face
967 if (MyCStructure.ContextFillArea.Distinguish == 1)
968 CTXF->SetDistinguishOn ();
969 else
970 CTXF->SetDistinguishOff ();
971 if (MyCStructure.ContextFillArea.BackFace == 1)
972 CTXF->SuppressBackFace ();
973 else
974 CTXF->AllowBackFace ();
975 // Texture
bf75be98 976 CTXF->SetTextureMap (MyCStructure.ContextFillArea.Texture.TextureMap);
7fd59977 977 if (MyCStructure.ContextFillArea.Texture.doTextureMap == 1)
bf75be98 978 {
979 CTXF->SetTextureMapOn();
980 }
7fd59977 981 else
bf75be98 982 {
983 CTXF->SetTextureMapOff();
984 }
7fd59977 985
bbf32d01
K
986 // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
987 CTXF->SetPolygonOffsets(MyCStructure.ContextFillArea.PolygonOffsetMode,
7fd59977 988 MyCStructure.ContextFillArea.PolygonOffsetFactor,
989 MyCStructure.ContextFillArea.PolygonOffsetUnits);
bbf32d01 990 // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
7fd59977 991
992 return CTXF;
993
994}
995
bbf32d01
K
996const Graphic3d_SequenceOfGroup& Graphic3d_Structure::Groups() const {
997 return MyGroups;
7fd59977 998}
999
1000Standard_Integer Graphic3d_Structure::NumberOfGroups () const {
7fd59977 1001 return (MyGroups.Length ());
7fd59977 1002}
1003
1004void Graphic3d_Structure::SetPrimitivesAspect (const Handle(Graphic3d_AspectLine3d)& CTX) {
1005
1006 if (IsDeleted ()) return;
1007
1008 Standard_Real R, G, B;
1009 Standard_Real AWidth;
1010 Quantity_Color AColor;
1011 Aspect_TypeOfLine ALType;
1012
1013 CTX->Values (AColor, ALType, AWidth);
1014 AColor.Values (R, G, B, Quantity_TOC_RGB);
1015
1016 MyCStructure.ContextLine.Color.r = float (R);
1017 MyCStructure.ContextLine.Color.g = float (G);
1018 MyCStructure.ContextLine.Color.b = float (B);
1019 MyCStructure.ContextLine.LineType = int (ALType);
1020 MyCStructure.ContextLine.Width = float (AWidth);
1021 MyCStructure.ContextLine.IsDef = 1;
1022
1023 MyGraphicDriver->ContextStructure (MyCStructure);
1024
1025 // CAL 14/04/95
bbf32d01
K
1026 // Attributes are "IsSet" during the first update
1027 // of context (line, marker...)
7fd59977 1028 MyCStructure.ContextLine.IsSet = 1;
1029 MyCStructure.ContextFillArea.IsSet = 1;
1030 MyCStructure.ContextMarker.IsSet = 1;
1031 MyCStructure.ContextText.IsSet = 1;
1032
1033 Update ();
1034
1035}
1036
1037void Graphic3d_Structure::SetPrimitivesAspect (const Handle(Graphic3d_AspectFillArea3d)& CTX) {
1038
1039 if (IsDeleted ()) return;
1040
1041 Standard_Real R, G, B;
1042 Standard_Real AWidth;
1043 Quantity_Color AnIntColor;
1044 Quantity_Color BackIntColor;
1045 Quantity_Color AnEdgeColor;
1046 Aspect_TypeOfLine ALType;
1047 Aspect_InteriorStyle AStyle;
1048
1049 CTX->Values (AStyle, AnIntColor, BackIntColor, AnEdgeColor, ALType, AWidth);
1050 AnIntColor.Values (R, G, B, Quantity_TOC_RGB);
1051
1052 MyCStructure.ContextFillArea.Style = int (AStyle);
1053 MyCStructure.ContextFillArea.IntColor.r = float (R);
1054 MyCStructure.ContextFillArea.IntColor.g = float (G);
1055 MyCStructure.ContextFillArea.IntColor.b = float (B);
1056
1057#ifdef OCC1174
1058 if ( CTX->Distinguish() )
1059 BackIntColor.Values( R, G, B, Quantity_TOC_RGB );
1060#endif
1061 MyCStructure.ContextFillArea.BackIntColor.r = float( R );
1062 MyCStructure.ContextFillArea.BackIntColor.g = float( G );
1063 MyCStructure.ContextFillArea.BackIntColor.b = float( B );
1064
1065
1066 // Edges
1067 MyCStructure.ContextFillArea.Edge = CTX->Edge () ? 1:0;
1068 AnEdgeColor.Values (R, G, B, Quantity_TOC_RGB);
1069 MyCStructure.ContextFillArea.EdgeColor.r = float (R);
1070 MyCStructure.ContextFillArea.EdgeColor.g = float (G);
1071 MyCStructure.ContextFillArea.EdgeColor.b = float (B);
1072 MyCStructure.ContextFillArea.LineType = int (ALType);
1073 MyCStructure.ContextFillArea.Width = float (AWidth);
1074 MyCStructure.ContextFillArea.Hatch = int (CTX->HatchStyle ());
7fd59977 1075
1076 /*** Front and Back face ***/
1077 MyCStructure.ContextFillArea.Distinguish = CTX->Distinguish () ? 1:0;
1078 MyCStructure.ContextFillArea.BackFace = CTX->BackFace () ? 1:0;
1079
1080 /*** Back Material ***/
1081 // Light specificity
1082 MyCStructure.ContextFillArea.Back.Shininess =
1083 float ((CTX->BackMaterial ()).Shininess ());
1084 MyCStructure.ContextFillArea.Back.Ambient =
1085 float ((CTX->BackMaterial ()).Ambient ());
1086 MyCStructure.ContextFillArea.Back.Diffuse =
1087 float ((CTX->BackMaterial ()).Diffuse ());
1088 MyCStructure.ContextFillArea.Back.Specular =
1089 float ((CTX->BackMaterial ()).Specular ());
1090 MyCStructure.ContextFillArea.Back.Transparency =
1091 float ((CTX->BackMaterial ()).Transparency ());
1092 MyCStructure.ContextFillArea.Back.Emission =
1093 float ((CTX->BackMaterial ()).Emissive ());
1094
1095 // Reflection mode
1096 MyCStructure.ContextFillArea.Back.IsAmbient =
1097 ( (CTX->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
1098 MyCStructure.ContextFillArea.Back.IsDiffuse =
1099 ( (CTX->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
1100 MyCStructure.ContextFillArea.Back.IsSpecular =
1101 ( (CTX->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
1102 MyCStructure.ContextFillArea.Back.IsEmission =
1103 ( (CTX->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
1104
1105 // Material type
1106 //JR/Hp
1107 const Graphic3d_MaterialAspect ama = CTX->BackMaterial () ;
1108 Standard_Boolean amt = ama.MaterialType(Graphic3d_MATERIAL_PHYSIC) ;
1109 MyCStructure.ContextFillArea.Back.IsPhysic = ( amt ? 1 : 0 );
1110
bbf32d01 1111 // Specular Color
7fd59977 1112 MyCStructure.ContextFillArea.Back.ColorSpec.r =
1113 float (((CTX->BackMaterial ()).SpecularColor ()).Red ());
1114 MyCStructure.ContextFillArea.Back.ColorSpec.g =
1115 float (((CTX->BackMaterial ()).SpecularColor ()).Green ());
1116 MyCStructure.ContextFillArea.Back.ColorSpec.b =
1117 float (((CTX->BackMaterial ()).SpecularColor ()).Blue ());
1118
1119 // Ambient color
1120 MyCStructure.ContextFillArea.Back.ColorAmb.r =
1121 float (((CTX->BackMaterial ()).AmbientColor ()).Red ());
1122 MyCStructure.ContextFillArea.Back.ColorAmb.g =
1123 float (((CTX->BackMaterial ()).AmbientColor ()).Green ());
1124 MyCStructure.ContextFillArea.Back.ColorAmb.b =
1125 float (((CTX->BackMaterial ()).AmbientColor ()).Blue ());
1126
1127 // Diffuse color
1128 MyCStructure.ContextFillArea.Back.ColorDif.r =
1129 float (((CTX->BackMaterial ()).DiffuseColor ()).Red ());
1130 MyCStructure.ContextFillArea.Back.ColorDif.g =
1131 float (((CTX->BackMaterial ()).DiffuseColor ()).Green ());
1132 MyCStructure.ContextFillArea.Back.ColorDif.b =
1133 float (((CTX->BackMaterial ()).DiffuseColor ()).Blue ());
1134
1135 // Emissive color
1136 MyCStructure.ContextFillArea.Back.ColorEms.r =
1137 float (((CTX->BackMaterial ()).EmissiveColor ()).Red ());
1138 MyCStructure.ContextFillArea.Back.ColorEms.g =
1139 float (((CTX->BackMaterial ()).EmissiveColor ()).Green ());
1140 MyCStructure.ContextFillArea.Back.ColorEms.b =
1141 float (((CTX->BackMaterial ()).EmissiveColor ()).Blue ());
1142
bbf32d01 1143 MyCStructure.ContextFillArea.Back.EnvReflexion =
7fd59977 1144 float ((CTX->BackMaterial ()).EnvReflexion());
1145
1146 /*** Front Material ***/
1147 // Light specificity
1148 MyCStructure.ContextFillArea.Front.Shininess =
1149 float ((CTX->FrontMaterial ()).Shininess ());
1150 MyCStructure.ContextFillArea.Front.Ambient =
1151 float ((CTX->FrontMaterial ()).Ambient ());
1152 MyCStructure.ContextFillArea.Front.Diffuse =
1153 float ((CTX->FrontMaterial ()).Diffuse ());
1154 MyCStructure.ContextFillArea.Front.Specular =
1155 float ((CTX->FrontMaterial ()).Specular ());
1156 MyCStructure.ContextFillArea.Front.Transparency =
1157 float ((CTX->FrontMaterial ()).Transparency ());
1158 MyCStructure.ContextFillArea.Front.Emission =
1159 float ((CTX->FrontMaterial ()).Emissive ());
1160
1161 // Reflection mode
1162 MyCStructure.ContextFillArea.Front.IsAmbient =
1163 ( (CTX->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
1164 MyCStructure.ContextFillArea.Front.IsDiffuse =
1165 ( (CTX->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
1166 MyCStructure.ContextFillArea.Front.IsSpecular =
1167 ( (CTX->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
1168 MyCStructure.ContextFillArea.Front.IsEmission =
1169 ( (CTX->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
1170
1171 // Materail type
1172 //JR/Hp
1173 const Graphic3d_MaterialAspect amas = CTX->FrontMaterial () ;
1174 Standard_Boolean amty = amas.MaterialType(Graphic3d_MATERIAL_PHYSIC) ;
1175 MyCStructure.ContextFillArea.Front.IsPhysic = ( amty ? 1 : 0 );
1176
1177 // Specular Color
1178 MyCStructure.ContextFillArea.Front.ColorSpec.r =
1179 float (((CTX->FrontMaterial ()).SpecularColor ()).Red ());
1180 MyCStructure.ContextFillArea.Front.ColorSpec.g =
1181 float (((CTX->FrontMaterial ()).SpecularColor ()).Green ());
1182 MyCStructure.ContextFillArea.Front.ColorSpec.b =
1183 float (((CTX->FrontMaterial ()).SpecularColor ()).Blue ());
1184
1185 // Ambient color
1186 MyCStructure.ContextFillArea.Front.ColorAmb.r =
1187 float (((CTX->FrontMaterial ()).AmbientColor ()).Red ());
1188 MyCStructure.ContextFillArea.Front.ColorAmb.g =
1189 float (((CTX->FrontMaterial ()).AmbientColor ()).Green ());
1190 MyCStructure.ContextFillArea.Front.ColorAmb.b =
1191 float (((CTX->FrontMaterial ()).AmbientColor ()).Blue ());
1192
1193 // Diffuse color
1194 MyCStructure.ContextFillArea.Front.ColorDif.r =
1195 float (((CTX->FrontMaterial ()).DiffuseColor ()).Red ());
1196 MyCStructure.ContextFillArea.Front.ColorDif.g =
1197 float (((CTX->FrontMaterial ()).DiffuseColor ()).Green ());
1198 MyCStructure.ContextFillArea.Front.ColorDif.b =
1199 float (((CTX->FrontMaterial ()).DiffuseColor ()).Blue ());
1200
1201 // Emissive color
1202 MyCStructure.ContextFillArea.Front.ColorEms.r =
1203 float (((CTX->FrontMaterial ()).EmissiveColor ()).Red ());
1204 MyCStructure.ContextFillArea.Front.ColorEms.g =
1205 float (((CTX->FrontMaterial ()).EmissiveColor ()).Green ());
1206 MyCStructure.ContextFillArea.Front.ColorEms.b =
1207 float (((CTX->FrontMaterial ()).EmissiveColor ()).Blue ());
1208
bbf32d01 1209 MyCStructure.ContextFillArea.Front.EnvReflexion =
7fd59977 1210 float ((CTX->FrontMaterial ()).EnvReflexion());
1211
1212 MyCStructure.ContextFillArea.IsDef = 1; // Definition material ok
1213
bf75be98 1214 MyCStructure.ContextFillArea.Texture.TextureMap = CTX->TextureMap();
1215 MyCStructure.ContextFillArea.Texture.doTextureMap = CTX->TextureMapState() ? 1 : 0;
7fd59977 1216
bbf32d01 1217 // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
7fd59977 1218 Standard_Integer aPolyMode;
60be1f9b 1219 Standard_ShortReal aPolyFactor, aPolyUnits;
7fd59977 1220 CTX->PolygonOffsets(aPolyMode, aPolyFactor, aPolyUnits);
1221 MyCStructure.ContextFillArea.PolygonOffsetMode = aPolyMode;
b8ddfc2f 1222 MyCStructure.ContextFillArea.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor;
1223 MyCStructure.ContextFillArea.PolygonOffsetUnits = (Standard_ShortReal)aPolyUnits;
bbf32d01 1224 // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
7fd59977 1225
1226 MyGraphicDriver->ContextStructure (MyCStructure);
7fd59977 1227
1228 // CAL 14/04/95
81bba717 1229 // Attributes are "IsSet" during the first update
1230 // of context (line, marker...)
7fd59977 1231 MyCStructure.ContextLine.IsSet = 1;
1232 MyCStructure.ContextFillArea.IsSet = 1;
1233 MyCStructure.ContextMarker.IsSet = 1;
1234 MyCStructure.ContextText.IsSet = 1;
1235
1236 Update ();
1237
1238}
1239
1240void Graphic3d_Structure::SetPrimitivesAspect (const Handle(Graphic3d_AspectText3d)& CTX) {
1241
1242 if (IsDeleted ()) return;
1243
1244 Standard_Real R, G, B;
1245 Standard_Real Rs, Gs, Bs;
1246 Standard_CString AFont;
1247 Standard_Real ASpace;
1248 Standard_Real AnExpansion;
1249 Quantity_Color AColor;
1250 Aspect_TypeOfStyleText AStyle;
1251 Aspect_TypeOfDisplayText ADisplayType;
1252 Quantity_Color AColorSubTitle;
1253 Standard_Boolean ATextZoomable;
1254 Standard_Real ATextAngle;
eeaaaefb 1255 Font_FontAspect ATextFontAspect;
7fd59977 1256
1257 CTX->Values (AColor, AFont, AnExpansion, ASpace, AStyle, ADisplayType,AColorSubTitle,ATextZoomable,ATextAngle,ATextFontAspect);
1258 AColor.Values (R, G, B, Quantity_TOC_RGB);
1259 AColorSubTitle.Values (Rs, Gs, Bs, Quantity_TOC_RGB);
1260
1261 MyCStructure.ContextText.Color.r = float (R);
1262 MyCStructure.ContextText.Color.g = float (G);
1263 MyCStructure.ContextText.Color.b = float (B);
1264 MyCStructure.ContextText.Font = (char*) (AFont);
1265 MyCStructure.ContextText.Expan = float (AnExpansion);
1266 MyCStructure.ContextText.Space = float (ASpace);
1267 MyCStructure.ContextText.Style = int (AStyle);
1268 MyCStructure.ContextText.DisplayType = int (ADisplayType);
1269 MyCStructure.ContextText.ColorSubTitle.r = float (Rs);
1270 MyCStructure.ContextText.ColorSubTitle.g = float (Gs);
1271 MyCStructure.ContextText.ColorSubTitle.b = float (Bs);
bbf32d01 1272 MyCStructure.ContextText.TextZoomable = ATextZoomable;
60be1f9b 1273 MyCStructure.ContextText.TextAngle = float (ATextAngle);
b8ddfc2f 1274 MyCStructure.ContextText.TextFontAspect = int (ATextFontAspect);
7fd59977 1275
1276 MyCStructure.ContextText.IsDef = 1;
1277
1278 MyGraphicDriver->ContextStructure (MyCStructure);
1279
1280 // CAL 14/04/95
81bba717 1281 // Attributes are "IsSet" during the first update of a context (line, marker...)
7fd59977 1282 MyCStructure.ContextLine.IsSet = 1;
1283 MyCStructure.ContextFillArea.IsSet = 1;
1284 MyCStructure.ContextMarker.IsSet = 1;
1285 MyCStructure.ContextText.IsSet = 1;
1286
1287 Update ();
1288
1289}
1290
1291void Graphic3d_Structure::SetPrimitivesAspect (const Handle(Graphic3d_AspectMarker3d)& CTX) {
1292
1293 if (IsDeleted ()) return;
1294
1295 Standard_Real R, G, B;
1296 Standard_Real AScale;
1297 Quantity_Color AColor;
1298 Aspect_TypeOfMarker AMType;
1299
1300 CTX->Values (AColor, AMType, AScale);
1301 AColor.Values (R, G, B, Quantity_TOC_RGB);
1302
1303 MyCStructure.ContextMarker.Color.r = float (R);
1304 MyCStructure.ContextMarker.Color.g = float (G);
1305 MyCStructure.ContextMarker.Color.b = float (B);
a577aaab 1306 MyCStructure.ContextMarker.MarkerType = AMType;
7fd59977 1307 MyCStructure.ContextMarker.Scale = float (AScale);
1308 MyCStructure.ContextMarker.IsDef = 1;
1309
1310 MyGraphicDriver->ContextStructure (MyCStructure);
1311
81bba717 1312 // Attributes are "IsSet" during the first update of a context (line, marker...)
7fd59977 1313 MyCStructure.ContextLine.IsSet = 1;
1314 MyCStructure.ContextFillArea.IsSet = 1;
1315 MyCStructure.ContextMarker.IsSet = 1;
1316 MyCStructure.ContextText.IsSet = 1;
1317
1318 Update ();
1319
1320}
1321
1322void Graphic3d_Structure::SetVisual (const Graphic3d_TypeOfStructure AVisual) {
1323
1324 if (IsDeleted ()) return;
1325 if (MyVisual == AVisual) return;
1326
1327 if (! MyCStructure.stick) {
1328 MyVisual = AVisual;
1329 SetComputeVisual (AVisual);
1330 }
1331 else {
1332
1333 Aspect_TypeOfUpdate UpdateMode = MyStructureManager->UpdateMode ();
1334 if (UpdateMode == Aspect_TOU_WAIT) {
1335 Erase ();
1336 MyVisual = AVisual;
1337 SetComputeVisual (AVisual);
1338 Display ();
1339 }
1340 else {
81bba717 1341 // To avoid calling method : Update ()
1342 // Not useful and can be costly.
7fd59977 1343 MyStructureManager->SetUpdateMode (Aspect_TOU_WAIT);
1344 Erase ();
1345 MyVisual = AVisual;
1346 SetComputeVisual (AVisual);
1347 MyStructureManager->SetUpdateMode (UpdateMode);
1348 Display ();
1349 }
1350 }
1351
1352}
1353
1354void Graphic3d_Structure::SetZoomLimit (const Standard_Real LimitInf, const Standard_Real LimitSup) {
1355
1356 if (LimitInf <= 0.0)
1357 Graphic3d_StructureDefinitionError::Raise
1358 ("Bad value for ZoomLimit inf");
1359
1360 if (LimitSup <= 0.0)
1361 Graphic3d_StructureDefinitionError::Raise
1362 ("Bad value for ZoomLimit sup");
1363
1364 if (LimitSup < LimitInf)
1365 Graphic3d_StructureDefinitionError::Raise
1366 ("ZoomLimit sup < ZoomLimit inf");
1367
1368}
1369
1370Graphic3d_TypeOfStructure Graphic3d_Structure::Visual () const {
1371
1372 return (MyVisual);
1373
1374}
1375
1376Standard_Boolean Graphic3d_Structure::AcceptConnection (const Handle(Graphic3d_Structure)& AStructure1, const Handle(Graphic3d_Structure)& AStructure2, const Graphic3d_TypeOfConnection AType) {
1377
1378 Graphic3d_MapOfStructure ASet;
1379
1380 // cycle detection
1381 Graphic3d_Structure::Network (AStructure2, AType, ASet);
1382
1383 return (! ASet.Contains (AStructure1));
1384
1385}
1386
1387void Graphic3d_Structure::Ancestors (Graphic3d_MapOfStructure &SG) const {
1388
1389 Standard_Integer i, Length = MyAncestors.Length ();
1390
1391 for (i=1; i<=Length; i++)
1392 SG.Add ((Graphic3d_Structure *) (MyAncestors.Value (i)));
1393
1394
1395}
1396
1397void Graphic3d_Structure::SetOwner (const Standard_Address Owner) {
1398
1399 MyOwner = Owner;
1400
1401}
1402
1403Standard_Address Graphic3d_Structure::Owner () const {
1404
1405 return MyOwner;
1406
1407}
1408
1409void Graphic3d_Structure::Descendants (Graphic3d_MapOfStructure& SG) const {
1410
1411 Standard_Integer i, Length = MyDescendants.Length ();
1412
1413 for (i=1; i<=Length; i++)
1414 SG.Add ((Graphic3d_Structure *) (MyDescendants.Value (i)));
1415
1416}
1417
1418void Graphic3d_Structure::Connect (const Handle(Graphic3d_Structure)& AStructure, const Graphic3d_TypeOfConnection AType, const Standard_Boolean WithCheck) {
1419
1420 if (IsDeleted ()) return;
1421
1422 if (WithCheck)
1423 // cycle detection
1424 if (! Graphic3d_Structure::AcceptConnection
1425 (this, AStructure, AType))
1426 return;
1427
1428 // connection
1429 Standard_Integer i;
bbf32d01 1430 switch (AType)
7fd59977 1431 {
1432
bbf32d01 1433 case Graphic3d_TOC_DESCENDANT :
7fd59977 1434 {
1435 Standard_Integer indexD = 0;
1436 Standard_Integer LengthD = MyDescendants.Length ();
1437 for (i=1; i<=LengthD && indexD==0; i++)
1438 if ((void *) (MyDescendants.Value (i)) ==
1439 (void *) (AStructure.operator->())) indexD = i;
1440
1441 if (indexD == 0) {
1442 MyDescendants.Append ((void *) AStructure.operator->());
1443 AStructure->Connect (this, Graphic3d_TOC_ANCESTOR);
1444
1445 GraphicConnect (AStructure);
1446 MyStructureManager->Connect (this, AStructure);
1447
1448 Update ();
1449 }
1450 }
1451 break;
1452
bbf32d01 1453 case Graphic3d_TOC_ANCESTOR :
7fd59977 1454 {
1455 Standard_Integer indexA = 0;
1456 Standard_Integer LengthA = MyAncestors.Length ();
1457 for (i=1; i<=LengthA && indexA==0; i++)
1458 if ((void *) (MyAncestors.Value (i)) ==
1459 (void *) (AStructure.operator->())) indexA = i;
1460
1461 if (indexA == 0) {
1462 MyAncestors.Append ((void *) AStructure.operator->());
1463 AStructure->Connect (this, Graphic3d_TOC_DESCENDANT);
1464
81bba717 1465 // MyGraphicDriver->Connect is called in case
1466 // if connection between parent and child
7fd59977 1467 }
1468 }
1469 break;
1470 }
1471
1472}
1473
1474void Graphic3d_Structure::Disconnect (const Handle(Graphic3d_Structure)& AStructure) {
1475
1476 if (IsDeleted ()) return;
1477
1478 Standard_Integer i;
1479
1480 Standard_Integer indexD = 0;
1481 Standard_Integer LengthD = MyDescendants.Length ();
1482 for (i=1; i<=LengthD && indexD==0; i++)
1483 if ((void *) (MyDescendants.Value (i)) ==
1484 (void *) (AStructure.operator->())) indexD = i;
1485
81bba717 1486 // Search in the Descendants
7fd59977 1487 if (indexD != 0) {
1488 MyDescendants.Remove (indexD);
1489 AStructure->Disconnect (this);
1490
1491 GraphicDisconnect (AStructure);
1492 MyStructureManager->Disconnect (this, AStructure);
1493
1494 Update ();
1495 }
1496 else {
1497 Standard_Integer indexA = 0;
1498 Standard_Integer LengthA = MyAncestors.Length ();
1499 for (i=1; i<=LengthA && indexA==0; i++)
1500 if ((void *) (MyAncestors.Value (i)) ==
1501 (void *) (AStructure.operator->())) indexA = i;
1502
81bba717 1503 // Search in the Ancestors
7fd59977 1504 if (indexA != 0) {
1505 MyAncestors.Remove (indexA);
1506 AStructure->Disconnect (this);
1507
81bba717 1508 // No call of MyGraphicDriver->Disconnect
1509 // in case of an ancestor
7fd59977 1510 }
1511 }
1512
1513}
1514
1515void Graphic3d_Structure::DisconnectAll (const Graphic3d_TypeOfConnection AType) {
1516
1517 if (IsDeleted ()) return;
1518
1519 Standard_Integer i, Length;
1520
1521 // disconnection
bbf32d01 1522 switch (AType)
7fd59977 1523 {
1524 case Graphic3d_TOC_DESCENDANT :
1525 Length = MyDescendants.Length ();
1526 for (i=1; i<=Length; i++)
81bba717 1527 // Value (1) instead of Value (i) as MyDescendants
1528 // is modified by :
7fd59977 1529 // Graphic3d_Structure::Disconnect (AStructure)
81bba717 1530 // that takes AStructure from MyDescendants
7fd59977 1531 ((Graphic3d_Structure *)
1532 (MyDescendants.Value (1)))->Disconnect (this);
1533 break;
1534 case Graphic3d_TOC_ANCESTOR :
1535 Length = MyAncestors.Length ();
1536 for (i=1; i<=Length; i++)
bbf32d01 1537 // Value (1) instead of Value (i) as MyAncestors
81bba717 1538 // is modified by :
7fd59977 1539 // Graphic3d_Structure::Disconnect (AStructure)
81bba717 1540 // that takes AStructure from MyAncestors
7fd59977 1541 ((Graphic3d_Structure *)
1542 (MyAncestors.Value (1)))->Disconnect (this);
1543 break;
1544 }
1545
1546}
1547
1548Graphic3d_TypeOfComposition Graphic3d_Structure::Composition () const {
1549
1550 if (MyCStructure.Composition)
1551 return (Graphic3d_TOC_POSTCONCATENATE);
1552 else
1553 return (Graphic3d_TOC_REPLACE);
1554
1555}
1556
1557void Graphic3d_Structure::SetTransform (const TColStd_Array2OfReal& AMatrix, const Graphic3d_TypeOfComposition AType) {
1558
1559 if (IsDeleted ()) return;
1560
1561 Standard_Integer lr, ur, lc, uc;
1562 Standard_Real valuetrsf;
1563 Standard_Real valueoldtrsf;
1564 Standard_Real valuenewtrsf;
1565 Standard_Integer i, j, k;
1566 TColStd_Array2OfReal TheTrsf (0, 3, 0, 3);
1567 TColStd_Array2OfReal NewTrsf (0, 3, 0, 3);
1568 TColStd_Array2OfReal AMatrix44 (0, 3, 0, 3);
1569
1570 // Assign the new transformation in an array [0..3][0..3]
81bba717 1571 // Avoid problemes if the user has defined matrice [1..4][1..4]
bbf32d01 1572 // or [3..6][-1..2] !!
7fd59977 1573 lr = AMatrix.LowerRow ();
1574 ur = AMatrix.UpperRow ();
1575 lc = AMatrix.LowerCol ();
1576 uc = AMatrix.UpperCol ();
1577
1578 if ( (ur - lr + 1 != 4) || (uc - lc + 1 != 4) )
1579 Graphic3d_TransformError::Raise
1580 ("Transform : not a 4x4 matrix");
1581
1582 if (AType == Graphic3d_TOC_REPLACE) {
1583 MyCStructure.Composition = 0;
81bba717 1584 // Update of CStructure
7fd59977 1585 for (i=0; i<=3; i++)
1586 for (j=0; j<=3; j++) {
1587 MyCStructure.Transformation[i][j] =
1588 float (AMatrix (lr + i, lc + j));
1589 NewTrsf (i, j) = AMatrix (lr + i, lc + j);
1590 }
1591 }
1592
1593 if (AType == Graphic3d_TOC_POSTCONCATENATE) {
1594 MyCStructure.Composition = 1;
81bba717 1595 // To simplify management of indices
7fd59977 1596 for (i=0; i<=3; i++)
1597 for (j=0; j<=3; j++)
1598 AMatrix44 (i, j) = AMatrix (lr + i, lc + j);
81bba717 1599 // Calculation of the product of matrices
7fd59977 1600 for (i=0; i<=3; i++)
1601 for (j=0; j<=3; j++) {
1602 NewTrsf (i, j) = 0.0;
1603 for (k=0; k<=3; k++) {
1604 valueoldtrsf = MyCStructure.Transformation[i][k];
1605 valuetrsf = AMatrix44 (k, j);
1606 valuenewtrsf = NewTrsf (i, j) +
1607 valueoldtrsf * valuetrsf;
1608 NewTrsf (i, j) = valuenewtrsf;
1609 }
1610 }
81bba717 1611 // Update of CStructure
7fd59977 1612 for (i=0; i<=3; i++)
1613 for (j=0; j<=3; j++)
1614 MyCStructure.Transformation[i][j] = float (NewTrsf (i, j));
1615 }
1616
81bba717 1617 // If transformation, no validation of hidden already calculated parts.
7fd59977 1618 if (IsRotated ())
1619 ReCompute ();
1620
1621 GraphicTransform (NewTrsf);
1622 MyStructureManager->SetTransform (this, NewTrsf);
1623
1624 Update ();
1625
1626}
1627
1628void Graphic3d_Structure::Transform (TColStd_Array2OfReal& AMatrix) const {
1629
1630 Standard_Integer lr = AMatrix.LowerRow ();
1631 Standard_Integer ur = AMatrix.UpperRow ();
1632 Standard_Integer lc = AMatrix.LowerCol ();
1633 Standard_Integer uc = AMatrix.UpperCol ();
1634
1635 if ( (ur - lr + 1 != 4) || (uc - lc + 1 != 4) )
1636 Graphic3d_TransformError::Raise
1637 ("Transform : not a 4x4 matrix");
1638
1639 for (Standard_Integer i=0; i<=3; i++)
1640 for (Standard_Integer j=0; j<=3; j++)
1641 AMatrix (lr + i, lc + j) = MyCStructure.Transformation[i][j];
1642
1643}
1644
1645void Graphic3d_Structure::MinMaxValues (Standard_Real& XMin, Standard_Real& YMin, Standard_Real& ZMin, Standard_Real& XMax, Standard_Real& YMax, Standard_Real& ZMax) const {
1646
1647 Standard_Real RL = RealLast ();
1648 Standard_Real RF = RealFirst ();
1649
1650 Standard_Real XTMin, YTMin, ZTMin, XTMax, YTMax, ZTMax, U, V, W;
1651
1652 MinMaxCoord (XTMin, YTMin, ZTMin, XTMax, YTMax, ZTMax);
1653 if ((XTMin == RF) && (YTMin == RF) &&
1654 (ZTMin == RF) && (XTMax == RL) &&
1655 (YTMax == RL) && (ZTMax == RL)) {
bbf32d01 1656 // Case impossible as it would mean that
81bba717 1657 // the structure is empty
bbf32d01
K
1658 XMin = RF;
1659 YMin = RF;
7fd59977 1660 ZMin = RF;
bbf32d01 1661
7fd59977 1662 XMax = RL;
1663 YMax = RL;
1664 ZMax = RL;
1665 }
1666 else {
1667 Standard_Integer i, j;
1668 TColStd_Array2OfReal TheTrsf (0, 3, 0, 3);
1669
1670 for (i=0; i<=3; i++)
1671 for (j=0; j<=3; j++)
1672 TheTrsf (i, j) = MyCStructure.Transformation[i][j];
1673
1674 Graphic3d_Structure::Transforms
1675 (TheTrsf, XTMin, YTMin, ZTMin, XMin, YMin, ZMin);
1676 Graphic3d_Structure::Transforms
1677 (TheTrsf, XTMax, YTMax, ZTMax, XMax, YMax, ZMax);
1678 Graphic3d_Structure::Transforms
1679 (TheTrsf, XTMin, YTMin, ZTMax, U, V, W);
1680 XMin = Min(U,XMin) ; XMax = Max(U,XMax) ;
1681 YMin = Min(V,YMin) ; YMax = Max(V,YMax) ;
1682 ZMin = Min(W,ZMin) ; ZMax = Max(W,ZMax) ;
1683 Graphic3d_Structure::Transforms
1684 (TheTrsf, XTMax, YTMin, ZTMax, U, V, W);
1685 XMin = Min(U,XMin) ; XMax = Max(U,XMax) ;
1686 YMin = Min(V,YMin) ; YMax = Max(V,YMax) ;
1687 ZMin = Min(W,ZMin) ; ZMax = Max(W,ZMax) ;
1688 Graphic3d_Structure::Transforms
1689 (TheTrsf, XTMax, YTMin, ZTMin, U, V, W);
1690 XMin = Min(U,XMin) ; XMax = Max(U,XMax) ;
1691 YMin = Min(V,YMin) ; YMax = Max(V,YMax) ;
1692 ZMin = Min(W,ZMin) ; ZMax = Max(W,ZMax) ;
1693 Graphic3d_Structure::Transforms
1694 (TheTrsf, XTMax, YTMax, ZTMin, U, V, W);
1695 XMin = Min(U,XMin) ; XMax = Max(U,XMax) ;
1696 YMin = Min(V,YMin) ; YMax = Max(V,YMax) ;
1697 ZMin = Min(W,ZMin) ; ZMax = Max(W,ZMax) ;
1698 Graphic3d_Structure::Transforms
1699 (TheTrsf, XTMin, YTMax, ZTMax, U, V, W);
1700 XMin = Min(U,XMin) ; XMax = Max(U,XMax) ;
1701 YMin = Min(V,YMin) ; YMax = Max(V,YMax) ;
1702 ZMin = Min(W,ZMin) ; ZMax = Max(W,ZMax) ;
1703 Graphic3d_Structure::Transforms
1704 (TheTrsf, XTMin, YTMax, ZTMin, U, V, W);
1705 XMin = Min(U,XMin) ; XMax = Max(U,XMax) ;
1706 YMin = Min(V,YMin) ; YMax = Max(V,YMax) ;
1707 ZMin = Min(W,ZMin) ; ZMax = Max(W,ZMax) ;
1708 }
1709}
1710
7fd59977 1711Standard_Integer Graphic3d_Structure::Identification () const {
1712
1713 Standard_Integer Result = MyCStructure.Id;
1714
1715 return Result;
1716
1717}
1718
1719void Graphic3d_Structure::SetTransformPersistence( const Graphic3d_TransModeFlags& AFlag )
1720{
1721 SetTransformPersistence( AFlag, gp_Pnt( 0, 0, 0 ) );
1722}
1723
1724void Graphic3d_Structure::SetTransformPersistence( const Graphic3d_TransModeFlags& AFlag,
1725 const gp_Pnt& APoint )
1726{
bbf32d01 1727 if (IsDeleted ()) return;
7fd59977 1728
1729 MyCStructure.TransformPersistence.Flag = AFlag;
60be1f9b 1730 MyCStructure.TransformPersistence.Point.x = float (APoint.X());
1731 MyCStructure.TransformPersistence.Point.y = float (APoint.Y());
1732 MyCStructure.TransformPersistence.Point.z = float (APoint.Z());
7fd59977 1733 //MyStructureManager->Update ();
1734 //Update();
1735 MyGraphicDriver->ContextStructure( MyCStructure );
1736
1737 MyCStructure.TransformPersistence.IsSet = 1;
1738}
1739
1740Graphic3d_TransModeFlags Graphic3d_Structure::TransformPersistenceMode() const
1741{
1742 return MyCStructure.TransformPersistence.Flag;
1743}
1744
1745gp_Pnt Graphic3d_Structure::TransformPersistencePoint() const
1746{
1747 gp_Pnt aPnt( 0., 0., 0. );
1748 aPnt.SetX( MyCStructure.TransformPersistence.Point.x );
1749 aPnt.SetY( MyCStructure.TransformPersistence.Point.y );
1750 aPnt.SetZ( MyCStructure.TransformPersistence.Point.z );
1751
1752 return aPnt;
1753}
1754
1755void Graphic3d_Structure::Add (const Handle(Graphic3d_Group)& AGroup) {
1756
81bba717 1757 // Method called only by the constructor of Graphic3d_Group
1758 // It is easy to check presence of <AGroup>
1759 // in sequence MyGroups.
7fd59977 1760 MyGroups.Append (AGroup);
1761
1762}
1763
1764void Graphic3d_Structure::Remove (const Standard_Address APtr, const Graphic3d_TypeOfConnection AType) {
1765
1766 Standard_Integer i, index, length;
1767
bbf32d01 1768 switch (AType)
7fd59977 1769 {
1770 case Graphic3d_TOC_DESCENDANT :
1771 index = 0;
1772 length = MyDescendants.Length ();
1773 for (i=1; i<=length && index==0; i++)
1774 if ((void *) (MyDescendants.Value (i)) == APtr)
1775 index = i;
1776 if (index != 0)
1777 MyDescendants.Remove (index);
1778#ifdef TRACE
1779 else
1780 cout << "Error, Graphic3d_Structure::Remove\n";
1781#endif
1782 break;
1783
1784 case Graphic3d_TOC_ANCESTOR :
1785 index = 0;
1786 length = MyAncestors.Length ();
1787 for (i=1; i<=length && index==0; i++)
1788 if ((void *) (MyAncestors.Value (i)) == APtr)
1789 index = i;
1790 if (index != 0)
1791 MyAncestors.Remove (index);
1792#ifdef TRACE
1793 else
1794 cout << "Error, Graphic3d_Structure::Remove\n";
1795#endif
1796 break;
1797 }
1798
1799}
1800
1801void Graphic3d_Structure::Remove (const Handle(Graphic3d_Group)& AGroup) {
1802
b8ddfc2f 1803 const Standard_Integer Length = MyGroups.Length ();
81bba717 1804 // Search in Groups
b8ddfc2f 1805 for (Standard_Integer i=1; i<=Length; i++)
1806 if (MyGroups.Value (i) == AGroup)
1807 {
1808 MyGroups.Remove (i);
1809 return;
1810 }
7fd59977 1811}
1812
1813Handle(Graphic3d_StructureManager) Graphic3d_Structure::StructureManager () const {
1814
1815#ifdef DOWNCAST
1816 return
1817 (Handle(Graphic3d_StructureManager)::DownCast(Handle(Standard_Transient)
1818 ((Standard_Transient*) MyPtrStructureManager)));
1819#else
1820 return MyStructureManager;
1821#endif
1822
1823}
1824
7fd59977 1825
1826void Graphic3d_Structure::MinMaxCoord (Standard_Real& XMin, Standard_Real& YMin, Standard_Real& ZMin, Standard_Real& XMax, Standard_Real& YMax, Standard_Real& ZMax) const {
1827
1828 Standard_Real RL = RealLast ();
1829 Standard_Real RF = RealFirst ();
1830
1831 Standard_Real Xm, Ym, Zm, XM, YM, ZM;
1832
1833 //Bounding borders of infinite line has been calculated as own point
1834 //in center of this line
1835 if (IsEmpty () || IsInfinite ()) {
1836 if( IsInfinite ()){
1837 for (int i=1; i<=MyGroups.Length (); i++)
1838 if (! (MyGroups.Value (i))->IsEmpty () ) {
1839 (MyGroups.Value (i))->MinMaxValues(Xm, Ym, Zm, XM, YM, ZM);
1840 Graphic3d_Vertex vertex1(Xm, Ym, Zm);
1841 Graphic3d_Vertex vertex2(XM, YM, ZM);
b8ddfc2f 1842 const Standard_Real distance = vertex1.Distance( vertex2 );
7fd59977 1843 if( distance >= 500000.0){
b8ddfc2f 1844 XMin = XMax = 0.5*(Xm+ XM);
1845 YMin = YMax = 0.5*(Ym+ YM);
1846 ZMin = ZMax = 0.5*(Zm+ ZM);
7fd59977 1847 return;
bbf32d01 1848 }
7fd59977 1849 }
1850 }
1851 XMin = RF;
1852 YMin = RF;
1853 ZMin = RF;
1854
1855 XMax = RL;
1856 YMax = RL;
1857 ZMax = RL;
1858 }
1859 else {
1860 XMin = RL;
1861 YMin = RL;
1862 ZMin = RL;
1863
1864 XMax = RF;
1865 YMax = RF;
1866 ZMax = RF;
1867 Standard_Integer i, Length;
1868
1869 Length = MyGroups.Length ();
1870 for (i=1; i<=Length; i++)
1871 if (! (MyGroups.Value (i))->IsEmpty () ) {
1872 (MyGroups.Value (i))->MinMaxValues(Xm, Ym, Zm, XM, YM, ZM);
1873 if (Xm < XMin) XMin = Xm;
1874 if (Ym < YMin) YMin = Ym;
1875 if (Zm < ZMin) ZMin = Zm;
1876 if (XM > XMax) XMax = XM;
1877 if (YM > YMax) YMax = YM;
1878 if (ZM > ZMax) ZMax = ZM;
1879 }
1880
1881 Length = MyDescendants.Length ();
1882 for (i=1; i<=Length; i++)
1883 if (! ((Graphic3d_Structure *)
1884 (MyDescendants.Value (i)))->IsEmpty () ) {
1885 ((Graphic3d_Structure *)
1886 (MyDescendants.Value (i)))->MinMaxValues (Xm, Ym, Zm, XM, YM, ZM);
1887
1888 if (Xm < XMin) XMin = Xm;
1889 if (Ym < YMin) YMin = Ym;
1890 if (Zm < ZMin) ZMin = Zm;
1891 if (XM > XMax) XMax = XM;
1892 if (YM > YMax) YMax = YM;
1893 if (ZM > ZMax) ZMax = ZM;
1894 }
1895
1896 if ((XMin == RL) && (YMin == RL) &&
1897 (ZMin == RL) && (XMax == RF) &&
1898 (YMax == RF) && (ZMax == RF)) {
bbf32d01 1899 // Case impossible as it would mean
81bba717 1900 // that the structure is empty
7fd59977 1901 XMin = RF;
1902 YMin = RF;
1903 ZMin = RF;
1904
1905 XMax = RL;
1906 YMax = RL;
1907 ZMax = RL;
1908 }
1909
1910 }
1911
1912}
1913
1914void 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) {
1915
1916 Standard_Real A, B, C, D;
1917
1918 Standard_Real RL = RealLast ();
1919 Standard_Real RF = RealFirst ();
1920
1921 if ((X == RF) || (Y == RF) || (Z == RF) ||
1922 (X == RL) || (Y == RL) || (Z == RL)) {
1923 NewX = X;
1924 NewY = Y;
1925 NewZ = Z;
1926 }
1927 else {
1928 A = ATrsf (0, 0);
1929 B = ATrsf (0, 1);
1930 C = ATrsf (0, 2);
1931 D = ATrsf (0, 3);
1932 NewX = A * X + B * Y + C * Z + D;
1933 A = ATrsf (1, 0);
1934 B = ATrsf (1, 1);
1935 C = ATrsf (1, 2);
1936 D = ATrsf (1, 3);
1937 NewY = A * X + B * Y + C * Z + D;
1938 A = ATrsf (2, 0);
1939 B = ATrsf (2, 1);
1940 C = ATrsf (2, 2);
1941 D = ATrsf (2, 3);
1942 NewZ = A * X + B * Y + C * Z + D;
1943 }
1944
1945}
1946
1947Graphic3d_Vector Graphic3d_Structure::Transforms (const TColStd_Array2OfReal& ATrsf, const Graphic3d_Vector& Coord) {
1948
1949 Standard_Real NewX, NewY, NewZ;
1950 Graphic3d_Vector Result;
1951
1952 Graphic3d_Structure::Transforms
1953 (ATrsf, Coord.X (), Coord.Y (), Coord.Z (), NewX, NewY, NewZ);
1954 Result.SetCoord (NewX, NewY, NewZ);
1955
1956 return (Result);
1957
1958}
1959
1960Graphic3d_Vertex Graphic3d_Structure::Transforms (const TColStd_Array2OfReal& ATrsf, const Graphic3d_Vertex& Coord) {
1961
1962 Standard_Real NewX, NewY, NewZ;
1963 Graphic3d_Vertex Result;
1964
1965 Graphic3d_Structure::Transforms
1966 (ATrsf, Coord.X (), Coord.Y (), Coord.Z (), NewX, NewY, NewZ);
1967 Result.SetCoord (NewX, NewY, NewZ);
1968
1969 return (Result);
1970
1971}
1972
1973void Graphic3d_Structure::Network (const Handle(Graphic3d_Structure)& AStructure, const Graphic3d_TypeOfConnection AType, Graphic3d_MapOfStructure& ASet) {
1974
1975
1976 Graphic3d_MapOfStructure h1;
1977 Graphic3d_MapOfStructure h2;
1978 AStructure->Descendants (h1);
1979 AStructure->Ancestors (h2);
1980
1981 Graphic3d_MapIteratorOfMapOfStructure IteratorD (h1);
1982 Graphic3d_MapIteratorOfMapOfStructure IteratorA (h2);
1983
1984 ASet.Add (AStructure);
1985
1986 // exploration
bbf32d01 1987 switch (AType)
7fd59977 1988 {
1989
1990 case Graphic3d_TOC_DESCENDANT :
1991 while (IteratorD.More ()) {
1992 Graphic3d_Structure::Network
1993 (IteratorD.Key (), AType, ASet);
81bba717 1994 // IteratorD.Next () is located on the next structure
7fd59977 1995 IteratorD.Next ();
1996 }
1997 break;
1998
1999 case Graphic3d_TOC_ANCESTOR :
2000 while (IteratorA.More ()) {
2001 Graphic3d_Structure::Network
2002 (IteratorA.Key (), AType, ASet);
bbf32d01
K
2003 // IteratorA.Next () is located on the next structure
2004 IteratorA.Next ();
7fd59977 2005 }
2006 break;
2007 }
2008
2009}
2010
bbf32d01 2011void Graphic3d_Structure::PrintNetwork (const Handle(Graphic3d_Structure)& AStructure, const Graphic3d_TypeOfConnection AType)
7fd59977 2012{
2013
2014 Graphic3d_MapOfStructure ASet;
2015
2016 Graphic3d_MapIteratorOfMapOfStructure IteratorASet (ASet);
2017
2018 Graphic3d_Structure::Network (AStructure, AType, ASet);
2019
2020 while (IteratorASet.More ()) {
2021 cout << "\tIdent "
2022 << (IteratorASet.Key ())->Identification () << "\n";
2023 IteratorASet.Next ();
2024 }
2025 cout << flush;
2026
2027}
2028
bbf32d01 2029void Graphic3d_Structure::Update () const
7fd59977 2030{
2031
2032 if (IsDeleted ()) return;
2033
2034 if (MyStructureManager->UpdateMode () == Aspect_TOU_ASAP)
2035 MyStructureManager->Update ();
2036
2037}
2038
bbf32d01 2039void Graphic3d_Structure::UpdateStructure (const Handle(Graphic3d_AspectLine3d)& CTXL, const Handle(Graphic3d_AspectText3d)& CTXT, const Handle(Graphic3d_AspectMarker3d)& CTXM, const Handle(Graphic3d_AspectFillArea3d)& CTXF)
7fd59977 2040{
2041
2042 Standard_Real R, G, B;
2043 Standard_Real Rs, Gs, Bs;
2044 Standard_CString AFont;
2045 Standard_Real ASpace;
2046 Standard_Real AnExpansion;
2047 Standard_Real AWidth;
2048 Standard_Real AScale;
2049 Quantity_Color AColor;
2050 Quantity_Color AnIntColor;
2051 Quantity_Color BackIntColor;
2052 Quantity_Color AnEdgeColor;
2053 Aspect_TypeOfLine ALType;
2054 Aspect_TypeOfMarker AMType;
2055 Aspect_InteriorStyle AStyle;
2056 Aspect_TypeOfStyleText AStyleT;
2057 Aspect_TypeOfDisplayText ADisplayType;
bbf32d01 2058 Quantity_Color AColorSubTitle;
7fd59977 2059 Standard_Boolean ATextZoomable;
2060 Standard_Real ATextAngle;
eeaaaefb 2061 Font_FontAspect ATextFontAspect;
7fd59977 2062
2063
2064 CTXL->Values (AColor, ALType, AWidth);
2065 AColor.Values (R, G, B, Quantity_TOC_RGB);
2066
2067 MyCStructure.ContextLine.Color.r = float (R);
2068 MyCStructure.ContextLine.Color.g = float (G);
2069 MyCStructure.ContextLine.Color.b = float (B);
2070 MyCStructure.ContextLine.LineType = int (ALType);
2071 MyCStructure.ContextLine.Width = float (AWidth);
2072
2073 CTXM->Values (AColor, AMType, AScale);
2074 AColor.Values (R, G, B, Quantity_TOC_RGB);
2075
2076 MyCStructure.ContextMarker.Color.r = float (R);
2077 MyCStructure.ContextMarker.Color.g = float (G);
2078 MyCStructure.ContextMarker.Color.b = float (B);
a577aaab 2079 MyCStructure.ContextMarker.MarkerType = AMType;
7fd59977 2080 MyCStructure.ContextMarker.Scale = float (AScale);
2081
2082 CTXT->Values (AColor, AFont, AnExpansion, ASpace,AStyleT,ADisplayType,AColorSubTitle,ATextZoomable,ATextAngle,ATextFontAspect);
2083 AColor.Values (R, G, B, Quantity_TOC_RGB);
2084 AColorSubTitle.Values (Rs, Gs, Bs, Quantity_TOC_RGB);
2085
2086 MyCStructure.ContextText.Color.r = float (R);
2087 MyCStructure.ContextText.Color.g = float (G);
2088 MyCStructure.ContextText.Color.b = float (B);
2089 MyCStructure.ContextText.Font = (char*) (AFont);
2090 MyCStructure.ContextText.Expan = float (AnExpansion);
2091 MyCStructure.ContextText.Style = int (AStyleT);
2092 MyCStructure.ContextText.DisplayType = int (ADisplayType);
2093 MyCStructure.ContextText.Space = float (ASpace);
2094 MyCStructure.ContextText.ColorSubTitle.r = float (Rs);
2095 MyCStructure.ContextText.ColorSubTitle.g = float (Gs);
2096 MyCStructure.ContextText.ColorSubTitle.b = float (Bs);
2097 MyCStructure.ContextText.TextZoomable = ATextZoomable;
60be1f9b 2098 MyCStructure.ContextText.TextAngle = float (ATextAngle);
b8ddfc2f 2099 MyCStructure.ContextText.TextFontAspect = int (ATextFontAspect);
7fd59977 2100
2101
2102
2103 CTXF->Values (AStyle, AnIntColor, BackIntColor, AnEdgeColor, ALType, AWidth);
2104 AnIntColor.Values (R, G, B, Quantity_TOC_RGB);
2105
2106 MyCStructure.ContextFillArea.Style = int (AStyle);
2107 MyCStructure.ContextFillArea.IntColor.r = float (R);
2108 MyCStructure.ContextFillArea.IntColor.g = float (G);
2109 MyCStructure.ContextFillArea.IntColor.b = float (B);
2110#ifdef OCC1174
2111 if ( CTXF->Distinguish() )
2112 BackIntColor.Values( R, G, B, Quantity_TOC_RGB );
2113#endif
2114 MyCStructure.ContextFillArea.BackIntColor.r = float( R );
2115 MyCStructure.ContextFillArea.BackIntColor.g = float( G );
2116 MyCStructure.ContextFillArea.BackIntColor.b = float( B );
2117
2118 // Edges
2119 MyCStructure.ContextFillArea.Edge = CTXF->Edge () ? 1:0;
2120 AnEdgeColor.Values (R, G, B, Quantity_TOC_RGB);
2121 MyCStructure.ContextFillArea.EdgeColor.r = float (R);
2122 MyCStructure.ContextFillArea.EdgeColor.g = float (G);
2123 MyCStructure.ContextFillArea.EdgeColor.b = float (B);
2124 MyCStructure.ContextFillArea.LineType = int (ALType);
2125 MyCStructure.ContextFillArea.Width = float (AWidth);
2126 MyCStructure.ContextFillArea.Hatch = int (CTXF->HatchStyle ());
7fd59977 2127
2128 /*** Front and Back face ***/
2129 MyCStructure.ContextFillArea.Distinguish = CTXF->Distinguish () ? 1:0;
2130 MyCStructure.ContextFillArea.BackFace = CTXF->BackFace () ? 1:0;
2131 /*** Back Material ***/
2132 // Light specificity
2133 MyCStructure.ContextFillArea.Back.Shininess =
2134 float ((CTXF->BackMaterial ()).Shininess ());
2135 MyCStructure.ContextFillArea.Back.Ambient =
2136 float ((CTXF->BackMaterial ()).Ambient ());
2137 MyCStructure.ContextFillArea.Back.Diffuse =
2138 float ((CTXF->BackMaterial ()).Diffuse ());
2139 MyCStructure.ContextFillArea.Back.Specular =
2140 float ((CTXF->BackMaterial ()).Specular ());
2141 MyCStructure.ContextFillArea.Back.Transparency =
2142 float ((CTXF->BackMaterial ()).Transparency ());
2143 MyCStructure.ContextFillArea.Back.Emission =
2144 float ((CTXF->BackMaterial ()).Emissive ());
2145
2146 // Reflection mode
2147 MyCStructure.ContextFillArea.Back.IsAmbient =
2148 ( (CTXF->BackMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
2149 MyCStructure.ContextFillArea.Back.IsDiffuse =
2150 ( (CTXF->BackMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
2151 MyCStructure.ContextFillArea.Back.IsSpecular =
2152 ( (CTXF->BackMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
2153 MyCStructure.ContextFillArea.Back.IsEmission =
2154 ( (CTXF->BackMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
2155
2156 // Material type
2157 //JR/Hp
2158 const Graphic3d_MaterialAspect ama = CTXF->BackMaterial () ;
2159 Standard_Boolean amt = ama.MaterialType(Graphic3d_MATERIAL_PHYSIC) ;
2160 MyCStructure.ContextFillArea.Back.IsPhysic = ( amt ? 1 : 0 );
2161
2162 // Specular color
2163 MyCStructure.ContextFillArea.Back.ColorSpec.r =
2164 float (((CTXF->BackMaterial ()).SpecularColor ()).Red ());
2165 MyCStructure.ContextFillArea.Back.ColorSpec.g =
2166 float (((CTXF->BackMaterial ()).SpecularColor ()).Green ());
2167 MyCStructure.ContextFillArea.Back.ColorSpec.b =
2168 float (((CTXF->BackMaterial ()).SpecularColor ()).Blue ());
2169
2170 // Ambient color
2171 MyCStructure.ContextFillArea.Back.ColorAmb.r =
2172 float (((CTXF->BackMaterial ()).AmbientColor ()).Red ());
2173 MyCStructure.ContextFillArea.Back.ColorAmb.g =
2174 float (((CTXF->BackMaterial ()).AmbientColor ()).Green ());
2175 MyCStructure.ContextFillArea.Back.ColorAmb.b =
2176 float (((CTXF->BackMaterial ()).AmbientColor ()).Blue ());
2177
2178 // Diffuse color
2179 MyCStructure.ContextFillArea.Back.ColorDif.r =
2180 float (((CTXF->BackMaterial ()).DiffuseColor ()).Red ());
2181 MyCStructure.ContextFillArea.Back.ColorDif.g =
2182 float (((CTXF->BackMaterial ()).DiffuseColor ()).Green ());
2183 MyCStructure.ContextFillArea.Back.ColorDif.b =
2184 float (((CTXF->BackMaterial ()).DiffuseColor ()).Blue ());
2185
2186 // Emissive color
2187 MyCStructure.ContextFillArea.Back.ColorEms.r =
2188 float (((CTXF->BackMaterial ()).EmissiveColor ()).Red ());
2189 MyCStructure.ContextFillArea.Back.ColorEms.g =
2190 float (((CTXF->BackMaterial ()).EmissiveColor ()).Green ());
2191 MyCStructure.ContextFillArea.Back.ColorEms.b =
2192 float (((CTXF->BackMaterial ()).EmissiveColor ()).Blue ());
2193
bbf32d01 2194 MyCStructure.ContextFillArea.Back.EnvReflexion =
7fd59977 2195 float ((CTXF->BackMaterial ()).EnvReflexion());
2196
2197 /*** Front Material ***/
2198 // Light specificity
2199 MyCStructure.ContextFillArea.Front.Shininess =
2200 float ((CTXF->FrontMaterial ()).Shininess ());
2201 MyCStructure.ContextFillArea.Front.Ambient =
2202 float ((CTXF->FrontMaterial ()).Ambient ());
2203 MyCStructure.ContextFillArea.Front.Diffuse =
2204 float ((CTXF->FrontMaterial ()).Diffuse ());
2205 MyCStructure.ContextFillArea.Front.Specular =
2206 float ((CTXF->FrontMaterial ()).Specular ());
2207 MyCStructure.ContextFillArea.Front.Transparency =
2208 float ((CTXF->FrontMaterial ()).Transparency ());
2209 MyCStructure.ContextFillArea.Front.Emission =
2210 float ((CTXF->FrontMaterial ()).Emissive ());
2211
2212 // Reflection mode
2213 MyCStructure.ContextFillArea.Front.IsAmbient =
2214 ( (CTXF->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_AMBIENT) ? 1 : 0 );
2215 MyCStructure.ContextFillArea.Front.IsDiffuse =
2216 ( (CTXF->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_DIFFUSE) ? 1 : 0 );
2217 MyCStructure.ContextFillArea.Front.IsSpecular =
2218 ( (CTXF->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_SPECULAR) ? 1 : 0 );
2219 MyCStructure.ContextFillArea.Front.IsEmission =
2220 ( (CTXF->FrontMaterial ()).ReflectionMode (Graphic3d_TOR_EMISSION) ? 1 : 0 );
2221
2222 // Material type
2223 //JR/Hp
2224 const Graphic3d_MaterialAspect amas = CTXF->FrontMaterial () ;
2225 Standard_Boolean amty = amas.MaterialType(Graphic3d_MATERIAL_PHYSIC) ;
2226 MyCStructure.ContextFillArea.Front.IsPhysic = ( amty ? 1 : 0 );
2227
2228 // Specular color
2229 MyCStructure.ContextFillArea.Front.ColorSpec.r =
2230 float (((CTXF->FrontMaterial ()).SpecularColor ()).Red ());
2231 MyCStructure.ContextFillArea.Front.ColorSpec.g =
2232 float (((CTXF->FrontMaterial ()).SpecularColor ()).Green ());
2233 MyCStructure.ContextFillArea.Front.ColorSpec.b =
2234 float (((CTXF->FrontMaterial ()).SpecularColor ()).Blue ());
2235
2236 // Ambient color
2237 MyCStructure.ContextFillArea.Front.ColorAmb.r =
2238 float (((CTXF->FrontMaterial ()).AmbientColor ()).Red ());
2239 MyCStructure.ContextFillArea.Front.ColorAmb.g =
2240 float (((CTXF->FrontMaterial ()).AmbientColor ()).Green ());
2241 MyCStructure.ContextFillArea.Front.ColorAmb.b =
2242 float (((CTXF->FrontMaterial ()).AmbientColor ()).Blue ());
2243
2244 // Diffuse color
2245 MyCStructure.ContextFillArea.Front.ColorDif.r =
2246 float (((CTXF->FrontMaterial ()).DiffuseColor ()).Red ());
2247 MyCStructure.ContextFillArea.Front.ColorDif.g =
2248 float (((CTXF->FrontMaterial ()).DiffuseColor ()).Green ());
2249 MyCStructure.ContextFillArea.Front.ColorDif.b =
2250 float (((CTXF->FrontMaterial ()).DiffuseColor ()).Blue ());
2251
2252 // Emissive color
2253 MyCStructure.ContextFillArea.Front.ColorEms.r =
2254 float (((CTXF->FrontMaterial ()).EmissiveColor ()).Red ());
2255 MyCStructure.ContextFillArea.Front.ColorEms.g =
2256 float (((CTXF->FrontMaterial ()).EmissiveColor ()).Green ());
2257 MyCStructure.ContextFillArea.Front.ColorEms.b =
2258 float (((CTXF->FrontMaterial ()).EmissiveColor ()).Blue ());
2259
bbf32d01 2260 MyCStructure.ContextFillArea.Front.EnvReflexion =
7fd59977 2261 float ((CTXF->FrontMaterial ()).EnvReflexion());
2262
bf75be98 2263 MyCStructure.ContextFillArea.Texture.TextureMap = CTXF->TextureMap();
2264 MyCStructure.ContextFillArea.Texture.doTextureMap = CTXF->TextureMapState() ? 1 : 0;
7fd59977 2265
bbf32d01 2266 // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
7fd59977 2267 Standard_Integer aPolyMode;
60be1f9b 2268 Standard_ShortReal aPolyFactor, aPolyUnits;
7fd59977 2269 CTXF->PolygonOffsets(aPolyMode, aPolyFactor, aPolyUnits);
2270 MyCStructure.ContextFillArea.PolygonOffsetMode = aPolyMode;
b8ddfc2f 2271 MyCStructure.ContextFillArea.PolygonOffsetFactor = (Standard_ShortReal)aPolyFactor;
2272 MyCStructure.ContextFillArea.PolygonOffsetUnits = (Standard_ShortReal)aPolyUnits;
bbf32d01 2273 // OCC4895 SAN 22/03/04 High-level interface for controlling polygon offsets
7fd59977 2274}
2275
2276void Graphic3d_Structure::GraphicHighlight (const Aspect_TypeOfHighlightMethod AMethod) {
2277
2278 Standard_Real XMin, YMin, ZMin, XMax, YMax, ZMax;
2279 Standard_Real R, G, B;
2280
2281 MyCStructure.highlight = 1;
2282 MyHighlightMethod = AMethod;
2283
bbf32d01 2284 switch (AMethod)
7fd59977 2285 {
2286 case Aspect_TOHM_COLOR :
2287 MyHighlightColor.Values (R, G, B, Quantity_TOC_RGB);
2288 MyGraphicDriver->HighlightColor
2289 (MyCStructure, float (R), float (G),
2290 float (B) , Standard_True);
2291 MyGraphicDriver->NameSetStructure (MyCStructure);
2292 break;
2293 case Aspect_TOHM_BLINK :
2294 MyGraphicDriver->Blink (MyCStructure, Standard_True);
2295 MyGraphicDriver->NameSetStructure (MyCStructure);
2296 break;
2297 case Aspect_TOHM_BOUNDBOX :
2298 if (IsEmpty () || IsInfinite ()) {
81bba717 2299 // Empty or infinite structure
7fd59977 2300 XMin = YMin = ZMin = 0.;
2301 XMax = YMax = ZMax = 0.;
2302 }
2303 else {
2304 MinMaxCoord
2305 (XMin, YMin, ZMin, XMax, YMax, ZMax);
2306 }
2307 MyCStructure.BoundBox.Pmin.x = float (XMin);
2308 MyCStructure.BoundBox.Pmin.y = float (YMin);
2309 MyCStructure.BoundBox.Pmin.z = float (ZMin);
2310 MyCStructure.BoundBox.Pmax.x = float (XMax);
2311 MyCStructure.BoundBox.Pmax.y = float (YMax);
2312 MyCStructure.BoundBox.Pmax.z = float (ZMax);
2313 MyHighlightColor.Values (R, G, B, Quantity_TOC_RGB);
2314 MyCStructure.BoundBox.Color.r = float (R);
2315 MyCStructure.BoundBox.Color.g = float (G);
2316 MyCStructure.BoundBox.Color.b = float (B);
2317 MyGraphicDriver->BoundaryBox (MyCStructure, Standard_True);
2318 break;
2319 }
2320
2321}
2322
2323void Graphic3d_Structure::GraphicTransform (const TColStd_Array2OfReal& AMatrix) {
2324
2325 Standard_Integer i, j;
2326
2327 for (i=0; i<=3; i++)
2328 for (j=0; j<=3; j++)
2329 MyCStructure.Transformation[i][j] = float (AMatrix (i, j));
2330
2331 MyGraphicDriver->TransformStructure (MyCStructure);
2332
2333}
2334
2335void Graphic3d_Structure::GraphicUnHighlight () {
2336
2337 MyCStructure.highlight = 0;
2338
bbf32d01 2339 switch (MyHighlightMethod)
7fd59977 2340 {
2341 case Aspect_TOHM_COLOR :
2342 MyGraphicDriver->HighlightColor
2343 (MyCStructure, 0.0, 0.0, 0.0 , Standard_False);
2344 MyGraphicDriver->NameSetStructure (MyCStructure);
2345 break;
2346 case Aspect_TOHM_BLINK :
2347 MyGraphicDriver->Blink (MyCStructure, Standard_False);
2348 MyGraphicDriver->NameSetStructure (MyCStructure);
2349 break;
2350 case Aspect_TOHM_BOUNDBOX :
2351 MyGraphicDriver->BoundaryBox
2352 (MyCStructure, Standard_False);
2353 MyGraphicDriver->NameSetStructure (MyCStructure);
2354 break;
2355 }
2356
2357}
2358
2359Graphic3d_TypeOfStructure Graphic3d_Structure::ComputeVisual () const {
2360
2361 return (MyComputeVisual);
2362
2363}
2364
2365void Graphic3d_Structure::SetComputeVisual (const Graphic3d_TypeOfStructure AVisual) {
2366
81bba717 2367 // The ComputeVisual is saved only if the structure is
2368 // declared TOS_ALL, TOS_WIREFRAME or TOS_SHADING.
2369 // This declaration permits to calculate
2370 // proper representation of the structure calculated by Compute
2371 // instead of passage to TOS_COMPUTED.
7fd59977 2372 if (AVisual != Graphic3d_TOS_COMPUTED)
2373 MyComputeVisual = AVisual;
2374
2375}
2376
2377void Graphic3d_Structure::Plot (const Handle(Graphic3d_Plotter)& ) {
2378
2379}
2380
35e08fe8 2381void Graphic3d_Structure::SetManager (const Handle(Graphic3d_StructureManager)& AManager,
2382 const Standard_Boolean
2383 #ifdef IMPLEMENTED
2384 WithPropagation
2385 #endif
2386 )
7fd59977 2387
35e08fe8 2388{
81bba717 2389 // All connected structures should follow ?
7fd59977 2390#ifdef IMPLEMENTED
2391 if (WithPropagation) {
2392 Standard_Integer i, Length;
2393 Length = MyDescendants.Length ();
2394 for (i=1; i<=Length; i++)
2395 ((Graphic3d_Structure *)
2396 (MyDescendants.Value (i)))->SetStructureManager (AManager);
2397
2398 Length = MyAncestors.Length ();
2399 for (i=1; i<=Length; i++)
2400 ((Graphic3d_Structure *)
2401 (MyAncestors.Value (i)))->SetStructureManager (AManager);
2402 }
2403#endif
2404
81bba717 2405 // change of identification ?
7fd59977 2406 // MyStructureManager->Remove (Standard_Integer (MyCStructure.Id));
2407 // AManager->NewIdentification ();
2408 // MyCStructure.Id = int (AManager->NewIdentification ());
2409
2410 Aspect_TypeOfUpdate UpdateMode = MyStructureManager->UpdateMode ();
2411 Aspect_TypeOfUpdate NewUpdateMode = AManager->UpdateMode ();
2412 MyStructureManager->SetUpdateMode (Aspect_TOU_WAIT);
2413 AManager->SetUpdateMode (Aspect_TOU_WAIT);
2414
2415 if (MyCStructure.stick) {
2416 MyStructureManager->Erase (this);
2417 AManager->Display (this);
2418 }
2419
2420 if (MyCStructure.highlight) {
2421 }
2422
2423 if (MyCStructure.visible) {
2424 MyStructureManager->Invisible (this);
2425 AManager->Visible (this);
2426 }
2427
2428 if (MyCStructure.pick) {
2429 MyStructureManager->Undetectable (this);
2430 AManager->Detectable (this);
2431 }
2432
2433 MyStructureManager->SetUpdateMode (UpdateMode);
2434 AManager->SetUpdateMode (NewUpdateMode);
2435
81bba717 2436 // New manager
7fd59977 2437 MyPtrStructureManager = (void *) AManager.operator->();
2438
2439}
2440
2441void Graphic3d_Structure::SetHLRValidation (const Standard_Boolean AFlag) {
2442
2443 MyCStructure.HLRValidation = AFlag ? 1:0;
2444
2445}
2446
2447Standard_Boolean Graphic3d_Structure::HLRValidation () const {
2448
81bba717 2449 // Hidden parts stored in <me> are valid if :
2450 // 1/ the owner is defined.
2451 // 2/ they are not invalid.
7fd59977 2452
2453 Standard_Boolean Result = MyOwner != NULL && MyCStructure.HLRValidation != 0;
2454
2455 return Result;
2456
2457}
2458
bf75be98 2459//=======================================================================
2460//function : CStructure
2461//purpose :
2462//=======================================================================
bf75be98 2463Graphic3d_CStructure* Graphic3d_Structure::CStructure()
2464{
2465 return &MyCStructure;
7fd59977 2466}
59f45b7c 2467
2468//=======================================================================
2469//function : SetZLayer
2470//purpose :
2471//=======================================================================
59f45b7c 2472void Graphic3d_Structure::SetZLayer (const Standard_Integer theLayerId)
2473{
2474 // if the structure is not displayed, unable to change its display layer
2475 if (IsDeleted ())
2476 return;
2477
2478 MyStructureManager->ChangeZLayer (this, theLayerId);
2479}
2480
2481//=======================================================================
2482//function : GetZLayer
2483//purpose :
2484//=======================================================================
59f45b7c 2485Standard_Integer Graphic3d_Structure::GetZLayer () const
2486{
2487 return MyStructureManager->GetZLayer (this);
2488}
4269bd1b 2489
2490//=======================================================================
2491//function : SetClipPlanes
2492//purpose :
2493//=======================================================================
2494void Graphic3d_Structure::SetClipPlanes (const Graphic3d_SetOfHClipPlane& thePlanes)
2495{
2496 MyCStructure.ClipPlanes = thePlanes;
2497 MyGraphicDriver->SetClipPlanes (MyCStructure);
2498}
2499
2500//=======================================================================
2501//function : GetClipPlanes
2502//purpose :
2503//=======================================================================
2504const Graphic3d_SetOfHClipPlane& Graphic3d_Structure::GetClipPlanes() const
2505{
2506 return MyCStructure.ClipPlanes;
2507}