projects / occt.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Integration of OCCT 6.5.0 from SVN
[occt.git] / src / Visual3d / Visual3d_ViewManager.cxx
... / ...
CommitLineData
1
2/***********************************************************************
3
4 FONCTION :
5 ----------
6 Classe Visual3d_ViewManager.cxx :
7
8 Declaration des variables specifiques aux visualiseurs
9
10 HISTORIQUE DES MODIFICATIONS :
11 --------------------------------
12 Mars 1992 : NW,JPB,CAL ; Creation.
13 19-06-96 : FMN ; Suppression variables inutiles
14 04-02-97 : FMN ; Suppression de PSOutput, XWDOutput ...
15 06-05-97 : CAL ; Ajout du Clear sur les TOS_COMPUTED.
16 19-09-97 : CAL ; Remplacement de Window->Position par Window->Size;
17 24-10-97 : CAL ; Retrait de DownCast.
18 20-11-97 : CAL ; Disparition de la dependance avec math
19 01-12-97 : CAL ; Retrait du test IsActive sur l'Update et le Redraw
20 31-12-97 : CAL ; Disparition de MathGra
21 16-01-98 : CAL ; Ajout du SetTransform sur une TOS_COMPUTED
22 11-03-98 : CAL ; Visual3d_ViewManager::Remove ()
23 20-05-98 : CAL ; Perfs. Connection entre structures COMPUTED.
24 10-06-98 : CAL ; Modification des signatures de xxProjectRaster.
25 10-06-98 : CAL ; Modification de la signature de ViewExists.
26 01-12-98 : CAL ; S4062. Ajout des layers.
27 02-12-98 : CAL ; Remove () ne detruit plus les vues.
28
29************************************************************************/
30
31/*----------------------------------------------------------------------*/
32/*
33 * Constantes
34 */
35
36#define NO_DOWNCAST
37#define NO_DESTROY
38
39/*----------------------------------------------------------------------*/
40/*
41 * Includes
42 */
43
44// for the class
45#include <Visual3d_ViewManager.ixx>
46#include <Visual3d_ViewManager.pxx>
47
48#include <Standard_ErrorHandler.hxx>
49
50#include <Aspect.hxx>
51
52#include <Graphic3d_GraphicDriver.hxx>
53#include <Graphic3d_MapOfStructure.hxx>
54#include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
55
56#include <Visual3d_PickPath.hxx>
57#include <Visual3d_SetIteratorOfSetOfView.hxx>
58
59#ifndef WNT
60# include <Xw_Window.hxx>
61#else
62# include <WNT_Window.hxx>
63#endif // WNT
64
65//-Aliases
66
67//-Global data definitions
68
69// -- les vues definies
70// MyDefinedView : SetOfView;
71
72// -- le generateur d'identificateurs de vues
73// MyViewGenId : GenId;
74
75//-Constructors
76
77Visual3d_ViewManager::Visual3d_ViewManager (const Handle(Aspect_GraphicDevice)& aDevice):
78Graphic3d_StructureManager (aDevice),
79MyDefinedView (),
80MyViewGenId (View_IDMIN+((View_IDMIN+View_IDMAX)/(Visual3d_ViewManager::Limit ()))*(Visual3d_ViewManager::CurrentId ()-1),View_IDMIN+((View_IDMIN+View_IDMAX)/(Visual3d_ViewManager::Limit ()))*Visual3d_ViewManager::CurrentId ()-1),
81MyZBufferAuto (Standard_False),
82MyTransparency (Standard_False)
83{
84
85Handle(Aspect_GraphicDriver) agd = aDevice->GraphicDriver ();
86
87 MyGraphicDriver = *(Handle(Graphic3d_GraphicDriver) *) &agd;
88
89}
90
91//-Destructors
92
93void Visual3d_ViewManager::Destroy () {
94
95#ifdef DESTROY
96 cout << "Visual3d_ViewManager::Destroy (" << MyId << ")\n" << flush;
97#endif
98
99 Remove ();
100}
101
102//-Methods, in order
103
104void Visual3d_ViewManager::Remove () {
105
106#ifdef DESTROY
107 cout << "Visual3d_ViewManager::Remove (" << MyId << ")\n" << flush;
108#endif
109
110 //
111 // Destroy all defined views
112 //
113#ifdef DEB
114 Standard_Integer Length = MyDefinedView.Extent ();
115#else
116 MyDefinedView.Extent ();
117#endif
118
119#ifdef DESTROY
120 cout << "The Manager " << MyId << " have " << Length << " defined views\n";
121 cout << flush;
122#endif
123
124 MyDefinedView.Clear ();
125
126}
127
128void Visual3d_ViewManager::ChangeDisplayPriority (const Handle(Graphic3d_Structure)& AStructure, const Standard_Integer OldPriority, const Standard_Integer NewPriority) {
129
130#ifdef TRACE
131 cout << "Visual3d_ViewManager::ChangeDisplayPriority ("
132 << AStructure->Identification ()
133 << ", " << OldPriority << ", " << NewPriority << ")\n";
134 cout << flush;
135#endif
136
137 //
138 // Change structure priority in all defined views
139 //
140#ifdef DEB
141 Standard_Integer Length = MyDefinedView.Extent ();
142#else
143 MyDefinedView.Extent ();
144#endif
145 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
146
147 while (MyIterator.More ()) {
148 (MyIterator.Value ())->ChangeDisplayPriority
149 (AStructure, OldPriority, NewPriority);
150
151 // MyIterator.Next () se positionne sur la prochaine vue
152 MyIterator.Next ();
153 }
154
155}
156
157void Visual3d_ViewManager::ReCompute (const Handle(Graphic3d_Structure)& AStructure) {
158
159 //Standard_Integer LengthD = MyDisplayedStructure.Extent() ();
160
161 // Meme si physiquement la structure ne peut pas
162 // etre affichee (pb de type de visualisation)
163 // elle a le statut Displayed.
164
165 if (!MyDisplayedStructure.Contains(AStructure))
166 return;
167
168 //
169 // Recompute structure in all activated views
170 //
171 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
172
173 while (MyIterator.More ()) {
174 (MyIterator.Value ())->ReCompute (AStructure);
175
176 // MyIterator.Next () se positionne sur la prochaine vue
177 MyIterator.Next ();
178 }
179
180}
181
182void Visual3d_ViewManager::ReCompute (const Handle(Graphic3d_Structure)& AStructure,
183 const Handle(Graphic3d_DataStructureManager)& AProjector)
184{
185
186 if (! AProjector->IsKind (STANDARD_TYPE (Visual3d_View))) return;
187
188#ifdef DOWNCAST
189 Handle(Visual3d_View) theView = Handle(Visual3d_View)::DownCast (AProjector);
190#else
191 Handle(Visual3d_View) theView = *(Handle(Visual3d_View) *) &AProjector;
192#endif
193 Standard_Integer ViewId = theView->Identification ();
194
195 Standard_Integer indexD = 0;
196
197// Meme si physiquement la structure ne peut pas
198// etre affichee (pb de type de visualisation)
199// elle a le statut Displayed.
200 if (!MyDisplayedStructure.Contains(AStructure))
201 return;
202
203 //
204 // Recompute structure in one activated view
205 //
206 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
207
208 while (MyIterator.More ()) {
209 if ((MyIterator.Value ())->Identification () == ViewId)
210 theView->ReCompute (AStructure);
211
212 // MyIterator.Next () se positionne sur la prochaine vue
213 MyIterator.Next ();
214 }
215
216}
217
218void Visual3d_ViewManager::Clear (const Handle(Graphic3d_Structure)& AStructure, const Standard_Boolean WithDestruction) {
219
220#ifdef DEB
221 Standard_Integer Length = MyDefinedView.Extent ();
222#else
223 MyDefinedView.Extent ();
224#endif
225 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
226
227 while (MyIterator.More ()) {
228 (MyIterator.Value ())->Clear (AStructure, WithDestruction);
229
230 // MyIterator.Next () se positionne sur la prochaine vue
231 MyIterator.Next ();
232 }
233
234}
235
236void Visual3d_ViewManager::Connect (const Handle(Graphic3d_Structure)& AMother, const Handle(Graphic3d_Structure)& ADaughter) {
237
238#ifdef DEB
239 Standard_Integer Length = MyDefinedView.Extent ();
240#else
241 MyDefinedView.Extent ();
242#endif
243 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
244
245 while (MyIterator.More ()) {
246 (MyIterator.Value ())->Connect (AMother, ADaughter);
247
248 // MyIterator.Next () se positionne sur la prochaine vue
249 MyIterator.Next ();
250 }
251
252}
253
254void Visual3d_ViewManager::Disconnect (const Handle(Graphic3d_Structure)& AMother, const Handle(Graphic3d_Structure)& ADaughter) {
255
256#ifdef DEB
257 Standard_Integer Length = MyDefinedView.Extent ();
258#else
259 MyDefinedView.Extent ();
260#endif
261 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
262
263 while (MyIterator.More ()) {
264 (MyIterator.Value ())->Disconnect (AMother, ADaughter);
265
266 // MyIterator.Next () se positionne sur la prochaine vue
267 MyIterator.Next ();
268 }
269
270}
271
272void Visual3d_ViewManager::Display (const Handle(Graphic3d_Structure)& AStructure) {
273
274
275 // Meme si physiquement la structure ne peut pas
276 // etre affichee (pb de type de visualisation)
277 // elle a le statut Displayed.
278
279 MyDisplayedStructure.Add(AStructure);
280
281 //
282 // Display structure in all activated views
283 //
284 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
285
286 while (MyIterator.More ()) {
287 (MyIterator.Value ())->Display (AStructure);
288
289 // MyIterator.Next () se positionne sur la prochaine vue
290 MyIterator.Next ();
291 }
292
293}
294
295void Visual3d_ViewManager::Erase (const Handle(Graphic3d_Structure)& AStructure) {
296
297
298// Meme si physiquement la structure ne pouvait pas
299// etre affichee (pb de type de visualisation)
300// elle avait le statut Displayed.
301
302 MyDisplayedStructure.Remove(AStructure);
303
304
305
306 //
307 // Erase structure in all defined views
308 //
309#ifdef DEB
310 Standard_Integer Length = MyDefinedView.Extent ();
311#else
312 MyDefinedView.Extent ();
313#endif
314 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
315
316 while (MyIterator.More ()) {
317 (MyIterator.Value ())->Erase (AStructure);
318
319 // MyIterator.Next () se positionne sur la prochaine vue
320 MyIterator.Next ();
321 }
322
323 MyHighlightedStructure.Remove (AStructure);
324 MyVisibleStructure.Remove (AStructure);
325 MyPickStructure.Remove (AStructure);
326
327}
328
329void Visual3d_ViewManager::Erase () {
330
331 Graphic3d_MapIteratorOfMapOfStructure it( MyDisplayedStructure);
332
333 for (; it.More(); it.Next()) {
334 Handle(Graphic3d_Structure) SG = it.Key();
335 SG->Erase();
336 }
337
338}
339
340void Visual3d_ViewManager::Highlight (const Handle(Graphic3d_Structure)& AStructure, const Aspect_TypeOfHighlightMethod AMethod) {
341
342 MyHighlightedStructure.Add(AStructure);
343
344 //
345 // Highlight in all activated views
346 //
347#ifdef DEB
348 Standard_Integer Length = MyDefinedView.Extent ();
349#else
350 MyDefinedView.Extent ();
351#endif
352 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
353
354 while (MyIterator.More ()) {
355 (MyIterator.Value ())->Highlight (AStructure, AMethod);
356
357 // MyIterator.Next () se positionne sur la prochaine vue
358 MyIterator.Next ();
359 }
360
361}
362
363void Visual3d_ViewManager::SetTransform (const Handle(Graphic3d_Structure)& AStructure, const TColStd_Array2OfReal& ATrsf) {
364
365#ifdef DEB
366 Standard_Integer Length = MyDefinedView.Extent ();
367#else
368 MyDefinedView.Extent ();
369#endif
370 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
371
372 while (MyIterator.More ()) {
373 (MyIterator.Value ())->SetTransform (AStructure, ATrsf);
374
375 // MyIterator.Next () se positionne sur la prochaine vue
376 MyIterator.Next ();
377 }
378
379}
380
381void Visual3d_ViewManager::UnHighlight () {
382
383 Graphic3d_MapIteratorOfMapOfStructure it(MyHighlightedStructure);
384
385 for (; it.More(); it.Next()) {
386 Handle(Graphic3d_Structure) SG = it.Key();
387 SG->UnHighlight ();
388 }
389
390
391}
392
393void Visual3d_ViewManager::UnHighlight (const Handle(Graphic3d_Structure)& AStructure) {
394
395 MyHighlightedStructure.Remove(AStructure);
396
397
398 //
399 // UnHighlight in all activated views
400 //
401#ifdef DEB
402 Standard_Integer Length = MyDefinedView.Extent ();
403#else
404 MyDefinedView.Extent ();
405#endif
406 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
407
408 while (MyIterator.More ()) {
409 (MyIterator.Value ())->UnHighlight (AStructure);
410
411 // MyIterator.Next () se positionne sur la prochaine vue
412 MyIterator.Next ();
413 }
414
415}
416
417void Visual3d_ViewManager::Redraw () const {
418
419Standard_Integer MaxDx, MaxDy;
420Standard_Integer Dx, Dy;
421 MaxDx = MaxDy = IntegerFirst ();
422
423 //
424 // Redraw all activated views
425 //
426 Standard_Integer j = MyDefinedView.Extent ();
427 if (j == 0) return;
428 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
429
430 if (! MyUnderLayer.IsNull () || ! MyOverLayer.IsNull ()) {
431 while (MyIterator.More ()) {
432 (MyIterator.Value ())->Window ()->Size (Dx, Dy);
433 if (Dx > MaxDx) MaxDx = Dx;
434 if (Dy > MaxDy) MaxDy = Dy;
435
436 // MyIterator.Next () se positionne sur la prochaine vue
437 MyIterator.Next ();
438 }
439 if (! MyUnderLayer.IsNull ())
440 MyUnderLayer->SetViewport (MaxDx, MaxDy);
441 if (! MyOverLayer.IsNull ())
442 MyOverLayer->SetViewport (MaxDx, MaxDy);
443 }
444
445 if (! MyUnderLayer.IsNull () || ! MyOverLayer.IsNull ())
446 MyIterator.Initialize (MyDefinedView);
447 while (MyIterator.More ()) {
448 (MyIterator.Value ())->Redraw (MyUnderLayer, MyOverLayer);
449
450 // MyIterator.Next () se positionne sur la prochaine vue
451 MyIterator.Next ();
452 }
453
454}
455
456void Visual3d_ViewManager::Update () const {
457
458 //
459 // Update all activated views
460 //
461 Standard_Integer j = MyDefinedView.Extent ();
462 if (j == 0) return;
463 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
464
465 while (MyIterator.More ()) {
466 (MyIterator.Value ())->Update (MyUnderLayer, MyOverLayer);
467
468 // MyIterator.Next () se positionne sur la prochaine vue
469 MyIterator.Next ();
470 }
471
472}
473
474Handle(Visual3d_HSetOfView) Visual3d_ViewManager::ActivatedView () const {
475
476Handle (Visual3d_HSetOfView) SG = new Visual3d_HSetOfView ();
477
478#ifdef DEB
479 Standard_Integer Length = MyDefinedView.Extent ();
480#else
481 MyDefinedView.Extent ();
482#endif
483Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
484
485 while (MyIterator.More ()) {
486 if ((MyIterator.Value ())->IsActive ())
487 SG->Add (MyIterator.Value ());
488
489 // MyIterator.Next () se positionne sur la prochaine vue
490 MyIterator.Next ();
491 }
492
493 return (SG);
494
495}
496
497#ifdef IMPLEMENTED
498Standard_Boolean Visual3d_ViewManager::ContainsComputedStructure () const {
499
500Standard_Boolean Result = Standard_False;
501
502 //
503 // Check all activated views
504 //
505 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
506
507 Standard_Integer i = MyDefinedView.Extent ();
508
509 while ((! Result) && (MyIterator.More ())) {
510 if ((MyIterator.Value ())->IsActive ())
511 Result =
512 (MyIterator.Value ())->ContainsComputedStructure ();
513
514 // MyIterator.Next () se positionne
515 // sur la prochaine vue
516 MyIterator.Next ();
517 }
518
519 return Result;
520}
521#endif
522
523Handle(Visual3d_HSetOfView) Visual3d_ViewManager::DefinedView () const {
524
525Handle (Visual3d_HSetOfView) SG = new Visual3d_HSetOfView ();
526
527Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
528
529 while (MyIterator.More ()) {
530 SG->Add (MyIterator.Value ());
531
532 // MyIterator.Next () se positionne sur la prochaine vue
533 MyIterator.Next ();
534 }
535
536 return (SG);
537
538}
539
540void Visual3d_ViewManager::ConvertCoord (const Handle(Aspect_Window)& AWindow, const Graphic3d_Vertex& AVertex, Standard_Integer& AU, Standard_Integer& AV) const {
541
542// On convertit que si les donnees sont correctes
543Standard_Boolean Exist;
544Graphic3d_CView TheCView;
545//Graphic3d_Vertex Point;
546
547TColStd_Array2OfReal Ori_Matrix (0,3,0,3);
548TColStd_Array2OfReal Map_Matrix (0,3,0,3);
549
550Standard_Integer Width, Height;
551Standard_Real AX, AY, AZ;
552Standard_Real Dx, Dy, Ratio;
553
554 Exist = ViewExists (AWindow, TheCView);
555
556 if (! Exist) {
557 AU = AV = IntegerLast ();
558 }
559 else {
560 // NKV - 11.02.08 - Use graphic driver functions
561 Standard_Boolean Result;
562
563 AVertex.Coord (AX, AY, AZ);
564
565 Result = MyGraphicDriver->ProjectRaster (TheCView,
566 Standard_ShortReal (AX), Standard_ShortReal (AY), Standard_ShortReal (AZ),
567 AU, AV);
568
569 // the old code
570 if (!Result) {
571
572 Standard_Real PtX, PtY, PtZ, PtT;
573 Standard_Real APX, APY, APZ;
574 Standard_Real APT;
575
576 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
577#ifdef DEB
578 Standard_Integer Length = MyDefinedView.Extent ();
579#else
580 MyDefinedView.Extent ();
581#endif
582
583 Standard_Integer stop = 0;
584
585 while ((! stop) && (MyIterator.More ())) {
586 if (TheCView.ViewId ==
587 (MyIterator.Value ())->Identification ()) {
588 Ori_Matrix =
589 (MyIterator.Value ())->MatrixOfOrientation ();
590 Map_Matrix =
591 (MyIterator.Value ())->MatrixOfMapping ();
592 stop = 1;
593 }
594
595 // MyIterator.Next () se positionne
596 // sur la prochaine vue
597 MyIterator.Next ();
598 }
599
600
601 // WCS -> View Reference Coordinate Space
602 PtX = Ori_Matrix (0, 0) * AX
603 + Ori_Matrix (0, 1) * AY
604 + Ori_Matrix (0, 2) * AZ
605 + Ori_Matrix (0, 3);
606 PtY = Ori_Matrix (1, 0) * AX
607 + Ori_Matrix (1, 1) * AY
608 + Ori_Matrix (1, 2) * AZ
609 + Ori_Matrix (1, 3);
610 PtZ = Ori_Matrix (2, 0) * AX
611 + Ori_Matrix (2, 1) * AY
612 + Ori_Matrix (2, 2) * AZ
613 + Ori_Matrix (2, 3);
614 PtT = Ori_Matrix (3, 0) * AX
615 + Ori_Matrix (3, 1) * AY
616 + Ori_Matrix (3, 2) * AZ
617 + Ori_Matrix (3, 3);
618
619 // VRCS -> Normalized Projection Coordinate Space
620 APX = Map_Matrix (0, 0) * PtX
621 + Map_Matrix (0, 1) * PtY
622 + Map_Matrix (0, 2) * PtZ
623 + Map_Matrix (0, 3) * PtT;
624 APY = Map_Matrix (1, 0) * PtX
625 + Map_Matrix (1, 1) * PtY
626 + Map_Matrix (1, 2) * PtZ
627 + Map_Matrix (1, 3) * PtT;
628 APZ = Map_Matrix (2, 0) * PtX
629 + Map_Matrix (2, 1) * PtY
630 + Map_Matrix (2, 2) * PtZ
631 + Map_Matrix (2, 3) * PtT;
632 APT = Map_Matrix (3, 0) * PtX
633 + Map_Matrix (3, 1) * PtY
634 + Map_Matrix (3, 2) * PtZ
635 + Map_Matrix (3, 3) * PtT;
636
637 if (APT == 0. || stop == 0) {
638 AU = AV = IntegerLast ();
639 }
640 else {
641 APX /= APT;
642 APY /= APT;
643 APZ /= APT;
644
645 // NPCS -> Device Coordinate Space
646 AWindow->Size (Width, Height);
647 Dx = Standard_Real (Width);
648 Dy = Standard_Real (Height);
649 Ratio = Dx / Dy;
650 if (Ratio >= 1.) {
651 AU = Standard_Integer (APX * Dx);
652 AV = Standard_Integer (Dy - APY * Dy * Ratio);
653 }
654 else {
655 AU = Standard_Integer (APX * Dx / Ratio);
656 AV = Standard_Integer (Dy - APY * Dy);
657 }
658 }
659 }
660 }
661
662}
663
664Graphic3d_Vertex Visual3d_ViewManager::ConvertCoord (const Handle(Aspect_Window)& AWindow, const Standard_Integer AU, const Standard_Integer AV) const {
665
666// On convertit que si les donnees sont correctes
667Graphic3d_CView TheCView;
668Graphic3d_Vertex Point;
669
670 if (! ViewExists (AWindow, TheCView))
671 Point.SetCoord (RealLast (), RealLast (), RealLast ());
672 else {
673Standard_Integer Width, Height;
674Standard_ShortReal x, y, z;
675Standard_Boolean Result;
676
677 AWindow->Size (Width, Height);
678
679 Result = MyGraphicDriver->UnProjectRaster (TheCView,
680 0, 0, Width, Height,
681 AU, AV, x, y, z);
682
683 // Le unproject est realise par UnProjectRaster
684 if (Result) {
685 Point.SetCoord
686 (Standard_Real (x), Standard_Real (y), Standard_Real (z));
687 }
688 // Le unproject n'est pas realisable par UnProjectRaster
689 // Code a virer des que les drivers Phigs et Pex seront abandonnes.
690 else {
691
692Standard_Real NPCX, NPCY, NPCZ;
693Standard_Real VRCX, VRCY, VRCZ, VRCT;
694Standard_Real WCX, WCY, WCZ, WCT;
695
696TColStd_Array2OfReal TOri_Matrix (0,3,0,3);
697TColStd_Array2OfReal TMap_Matrix (0,3,0,3);
698TColStd_Array2OfReal TOri_Matrix_Inv (0,3,0,3);
699TColStd_Array2OfReal TMap_Matrix_Inv (0,3,0,3);
700
701Standard_Real Dx, Dy, Ratio;
702Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
703Standard_Integer j;
704
705Standard_Integer stop = 0;
706
707Standard_Boolean BResult;
708
709 j = MyDefinedView.Extent ();
710
711 while ((! stop) && (MyIterator.More ())) {
712 if (TheCView.ViewId ==
713 (MyIterator.Value ())->Identification ()) {
714 TOri_Matrix =
715 (MyIterator.Value ())->MatrixOfOrientation ();
716 TMap_Matrix =
717 (MyIterator.Value ())->MatrixOfMapping ();
718 stop = 1;
719 }
720
721 // MyIterator.Next () se positionne
722 // sur la prochaine vue
723 MyIterator.Next ();
724 }
725
726 // View Mapping Transformation and View Clip, inversion
727 BResult = Aspect::Inverse (TMap_Matrix, TMap_Matrix_Inv);
728
729 // View Orientation Transformation, inversion
730 BResult = Aspect::Inverse (TOri_Matrix, TOri_Matrix_Inv);
731
732 // (AU, AV) : Device Coordinate Space
733 // DCS -> NPCS Normalized Projection Coordinate Space
734 Dx = Standard_Real (Width);
735 Dy = Standard_Real (Height);
736 Ratio = Dx / Dy;
737
738 if (Ratio >= 1.) {
739 NPCX = Standard_Real (AU) / Dx;
740 NPCY = (Dy - Standard_Real (AV)) / Dx;
741 }
742 else {
743 NPCX = Standard_Real (AU) / Dy;
744 NPCY = (Dy - Standard_Real (AV)) / Dy;
745 }
746 NPCZ = 0.0;
747
748 // NPCS -> VRCS View Reference Coordinate Space
749 // PtVRC = Map_Matrix_Inv.Multiplied (PtNPC);
750
751 VRCX = TMap_Matrix_Inv (0, 0) * NPCX
752 + TMap_Matrix_Inv (0, 1) * NPCY
753 + TMap_Matrix_Inv (0, 2) * NPCZ
754 + TMap_Matrix_Inv (0, 3);
755 VRCY = TMap_Matrix_Inv (1, 0) * NPCX
756 + TMap_Matrix_Inv (1, 1) * NPCY
757 + TMap_Matrix_Inv (1, 2) * NPCZ
758 + TMap_Matrix_Inv (1, 3);
759 VRCZ = TMap_Matrix_Inv (2, 0) * NPCX
760 + TMap_Matrix_Inv (2, 1) * NPCY
761 + TMap_Matrix_Inv (2, 2) * NPCZ
762 + TMap_Matrix_Inv (2, 3);
763 VRCT = TMap_Matrix_Inv (3, 0) * NPCX
764 + TMap_Matrix_Inv (3, 1) * NPCY
765 + TMap_Matrix_Inv (3, 2) * NPCZ
766 + TMap_Matrix_Inv (3, 3);
767
768 // VRCS -> WCS World Coordinate Space
769 // PtWC = Ori_Matrix_Inv.Multiplied (PtVRC);
770
771 WCX = TOri_Matrix_Inv (0, 0) * VRCX
772 + TOri_Matrix_Inv (0, 1) * VRCY
773 + TOri_Matrix_Inv (0, 2) * VRCZ
774 + TOri_Matrix_Inv (0, 3) * VRCT;
775 WCY = TOri_Matrix_Inv (1, 0) * VRCX
776 + TOri_Matrix_Inv (1, 1) * VRCY
777 + TOri_Matrix_Inv (1, 2) * VRCZ
778 + TOri_Matrix_Inv (1, 3) * VRCT;
779 WCZ = TOri_Matrix_Inv (2, 0) * VRCX
780 + TOri_Matrix_Inv (2, 1) * VRCY
781 + TOri_Matrix_Inv (2, 2) * VRCZ
782 + TOri_Matrix_Inv (2, 3) * VRCT;
783 WCT = TOri_Matrix_Inv (3, 0) * VRCX
784 + TOri_Matrix_Inv (3, 1) * VRCY
785 + TOri_Matrix_Inv (3, 2) * VRCZ
786 + TOri_Matrix_Inv (3, 3) * VRCT;
787
788 if (WCT != 0.)
789 Point.SetCoord (WCX/WCT, WCY/WCT, WCZ/WCT);
790 else
791 Point.SetCoord (RealLast (), RealLast (), RealLast ());
792 }
793 }
794
795 return (Point);
796
797}
798
799void Visual3d_ViewManager::ConvertCoordWithProj (const Handle(Aspect_Window)& AWindow, const Standard_Integer AU, const Standard_Integer AV, Graphic3d_Vertex& Point, Graphic3d_Vector& Proj) const {
800
801// On convertit que si les donnees sont correctes
802Graphic3d_CView TheCView;
803
804 if (! ViewExists (AWindow, TheCView)) {
805 Point.SetCoord (RealLast (), RealLast (), RealLast ());
806 Proj.SetCoord (0., 0., 0.);
807 }
808 else {
809Standard_Integer Width, Height;
810Standard_ShortReal x, y, z;
811Standard_ShortReal dx, dy, dz;
812Standard_Boolean Result;
813
814 AWindow->Size (Width, Height);
815
816 Result = MyGraphicDriver->UnProjectRasterWithRay (TheCView,
817 0, 0, Width, Height,
818 AU, AV, x, y, z, dx, dy, dz);
819
820 // Le unproject est realise par UnProjectRaster
821 if (Result) {
822 Point.SetCoord
823 (Standard_Real (x), Standard_Real (y), Standard_Real (z));
824 Proj.SetCoord
825 (Standard_Real (dx), Standard_Real (dy), Standard_Real (dz));
826 Proj.Normalize();
827 }
828 // Le unproject n'est pas realisable par UnProjectRaster
829 // Code a virer des que les drivers Phigs et Pex seront abandonnes.
830 else {
831
832Standard_Real NPCX, NPCY, NPCZ;
833Standard_Real VRCX, VRCY, VRCZ, VRCT;
834Standard_Real WCX, WCY, WCZ, WCT;
835
836TColStd_Array2OfReal TOri_Matrix (0,3,0,3);
837TColStd_Array2OfReal TMap_Matrix (0,3,0,3);
838TColStd_Array2OfReal TOri_Matrix_Inv (0,3,0,3);
839TColStd_Array2OfReal TMap_Matrix_Inv (0,3,0,3);
840
841Standard_Real Dx, Dy, Ratio;
842Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
843Standard_Integer j;
844
845Standard_Integer stop = 0;
846
847Standard_Boolean BResult;
848
849 j = MyDefinedView.Extent ();
850
851 while ((! stop) && (MyIterator.More ())) {
852 if (TheCView.ViewId ==
853 (MyIterator.Value ())->Identification ()) {
854 TOri_Matrix =
855 (MyIterator.Value ())->MatrixOfOrientation ();
856 TMap_Matrix =
857 (MyIterator.Value ())->MatrixOfMapping ();
858 stop = 1;
859 }
860
861 // MyIterator.Next () se positionne
862 // sur la prochaine vue
863 MyIterator.Next ();
864 }
865
866 // View Mapping Transformation and View Clip, inversion
867 BResult = Aspect::Inverse (TMap_Matrix, TMap_Matrix_Inv);
868
869 // View Orientation Transformation, inversion
870 BResult = Aspect::Inverse (TOri_Matrix, TOri_Matrix_Inv);
871
872 // (AU, AV) : Device Coordinate Space
873 // DCS -> NPCS Normalized Projection Coordinate Space
874 Dx = Standard_Real (Width);
875 Dy = Standard_Real (Height);
876 Ratio = Dx / Dy;
877
878 if (Ratio >= 1.) {
879 NPCX = Standard_Real (AU) / Dx;
880 NPCY = (Dy - Standard_Real (AV)) / Dx;
881 }
882 else {
883 NPCX = Standard_Real (AU) / Dy;
884 NPCY = (Dy - Standard_Real (AV)) / Dy;
885 }
886 NPCZ = 0.0;
887
888 // NPCS -> VRCS View Reference Coordinate Space
889 // PtVRC = Map_Matrix_Inv.Multiplied (PtNPC);
890
891 VRCX = TMap_Matrix_Inv (0, 0) * NPCX
892 + TMap_Matrix_Inv (0, 1) * NPCY
893 + TMap_Matrix_Inv (0, 2) * NPCZ
894 + TMap_Matrix_Inv (0, 3);
895 VRCY = TMap_Matrix_Inv (1, 0) * NPCX
896 + TMap_Matrix_Inv (1, 1) * NPCY
897 + TMap_Matrix_Inv (1, 2) * NPCZ
898 + TMap_Matrix_Inv (1, 3);
899 VRCZ = TMap_Matrix_Inv (2, 0) * NPCX
900 + TMap_Matrix_Inv (2, 1) * NPCY
901 + TMap_Matrix_Inv (2, 2) * NPCZ
902 + TMap_Matrix_Inv (2, 3);
903 VRCT = TMap_Matrix_Inv (3, 0) * NPCX
904 + TMap_Matrix_Inv (3, 1) * NPCY
905 + TMap_Matrix_Inv (3, 2) * NPCZ
906 + TMap_Matrix_Inv (3, 3);
907
908 // VRCS -> WCS World Coordinate Space
909 // PtWC = Ori_Matrix_Inv.Multiplied (PtVRC);
910
911 WCX = TOri_Matrix_Inv (0, 0) * VRCX
912 + TOri_Matrix_Inv (0, 1) * VRCY
913 + TOri_Matrix_Inv (0, 2) * VRCZ
914 + TOri_Matrix_Inv (0, 3) * VRCT;
915 WCY = TOri_Matrix_Inv (1, 0) * VRCX
916 + TOri_Matrix_Inv (1, 1) * VRCY
917 + TOri_Matrix_Inv (1, 2) * VRCZ
918 + TOri_Matrix_Inv (1, 3) * VRCT;
919 WCZ = TOri_Matrix_Inv (2, 0) * VRCX
920 + TOri_Matrix_Inv (2, 1) * VRCY
921 + TOri_Matrix_Inv (2, 2) * VRCZ
922 + TOri_Matrix_Inv (2, 3) * VRCT;
923 WCT = TOri_Matrix_Inv (3, 0) * VRCX
924 + TOri_Matrix_Inv (3, 1) * VRCY
925 + TOri_Matrix_Inv (3, 2) * VRCZ
926 + TOri_Matrix_Inv (3, 3) * VRCT;
927
928 if (WCT != 0.)
929 Point.SetCoord (WCX/WCT, WCY/WCT, WCZ/WCT);
930 else
931 Point.SetCoord (RealLast (), RealLast (), RealLast ());
932
933 // Define projection ray
934 NPCZ = 10.0;
935
936 // NPCS -> VRCS View Reference Coordinate Space
937 // PtVRC = Map_Matrix_Inv.Multiplied (PtNPC);
938
939 VRCX = TMap_Matrix_Inv (0, 0) * NPCX
940 + TMap_Matrix_Inv (0, 1) * NPCY
941 + TMap_Matrix_Inv (0, 2) * NPCZ
942 + TMap_Matrix_Inv (0, 3);
943 VRCY = TMap_Matrix_Inv (1, 0) * NPCX
944 + TMap_Matrix_Inv (1, 1) * NPCY
945 + TMap_Matrix_Inv (1, 2) * NPCZ
946 + TMap_Matrix_Inv (1, 3);
947 VRCZ = TMap_Matrix_Inv (2, 0) * NPCX
948 + TMap_Matrix_Inv (2, 1) * NPCY
949 + TMap_Matrix_Inv (2, 2) * NPCZ
950 + TMap_Matrix_Inv (2, 3);
951 VRCT = TMap_Matrix_Inv (3, 0) * NPCX
952 + TMap_Matrix_Inv (3, 1) * NPCY
953 + TMap_Matrix_Inv (3, 2) * NPCZ
954 + TMap_Matrix_Inv (3, 3);
955
956 // VRCS -> WCS World Coordinate Space
957 // PtWC = Ori_Matrix_Inv.Multiplied (PtVRC);
958
959 WCX = TOri_Matrix_Inv (0, 0) * VRCX
960 + TOri_Matrix_Inv (0, 1) * VRCY
961 + TOri_Matrix_Inv (0, 2) * VRCZ
962 + TOri_Matrix_Inv (0, 3) * VRCT;
963 WCY = TOri_Matrix_Inv (1, 0) * VRCX
964 + TOri_Matrix_Inv (1, 1) * VRCY
965 + TOri_Matrix_Inv (1, 2) * VRCZ
966 + TOri_Matrix_Inv (1, 3) * VRCT;
967 WCZ = TOri_Matrix_Inv (2, 0) * VRCX
968 + TOri_Matrix_Inv (2, 1) * VRCY
969 + TOri_Matrix_Inv (2, 2) * VRCZ
970 + TOri_Matrix_Inv (2, 3) * VRCT;
971 WCT = TOri_Matrix_Inv (3, 0) * VRCX
972 + TOri_Matrix_Inv (3, 1) * VRCY
973 + TOri_Matrix_Inv (3, 2) * VRCZ
974 + TOri_Matrix_Inv (3, 3) * VRCT;
975
976 if (WCT != 0.) {
977 Proj.SetCoord (WCX/WCT, WCY/WCT, WCZ/WCT);
978 Proj.Normalize();
979 }
980 else
981 Proj.SetCoord (0., 0., 0.);
982 }
983 }
984
985}
986
987Visual3d_PickDescriptor Visual3d_ViewManager::Pick (const Visual3d_ContextPick& CTX, const Handle(Aspect_Window)& AWindow, const Standard_Integer AX, const Standard_Integer AY) {
988
989// On active le reperage que si les donnees sont correctes
990Standard_Boolean DoPick = Standard_False;
991
992CALL_DEF_PICK apick;
993Standard_Integer Width, Height;
994
995 // Parcours de la liste des vues pour rechercher
996 // une vue ayant pour fenetre celle specifiee
997 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
998 int TheWindowIdOfView;
999
1000#ifndef WNT
1001const Handle(Xw_Window) THEWindow = *(Handle(Xw_Window) *) &AWindow;
1002 int TheSpecifiedWindowId = int (THEWindow->XWindow ());
1003#else
1004const Handle(WNT_Window) THEWindow = *(Handle(WNT_Window) *) &AWindow;
1005 int TheSpecifiedWindowId = int (THEWindow->HWindow ());
1006#endif // WNT
1007
1008 while ((! DoPick) && (MyIterator.More ())) {
1009
1010 if ( ((MyIterator.Value ())->IsDefined ()) &&
1011 ((MyIterator.Value ())->IsActive ()) ) {
1012
1013const Handle(Aspect_Window) AspectWindow = (MyIterator.Value ())->Window ();
1014#ifndef WNT
1015const Handle(Xw_Window) theWindow = *(Handle(Xw_Window) *) &AspectWindow;
1016 TheWindowIdOfView = int (theWindow->XWindow ());
1017#else
1018const Handle(WNT_Window) theWindow = *(Handle(WNT_Window) *) &AspectWindow;
1019 TheWindowIdOfView = int (theWindow->HWindow ());
1020#endif // WNT
1021 // Comparaison sur les windows ids
1022 if (TheWindowIdOfView == TheSpecifiedWindowId) {
1023 DoPick = Standard_True;
1024
1025 // Mise a jour
1026 apick.WsId =
1027 int ((MyIterator.Value ())->Identification ());
1028
1029 apick.ViewId =
1030 int ((MyIterator.Value ())->Identification ());
1031#ifndef WNT
1032 apick.DefWindow.XWindow = TheSpecifiedWindowId;
1033#else
1034 apick.DefWindow.XWindow = (HWND) TheSpecifiedWindowId;
1035#endif
1036
1037 apick.x = int (AX);
1038 apick.y = int (AY);
1039
1040 theWindow->Size (Width, Height);
1041 apick.DefWindow.dx = float (Width);
1042 apick.DefWindow.dy = float (Height);
1043
1044 apick.Context.aperture = (float) CTX.Aperture ();
1045 apick.Context.order = int (CTX.Order ());
1046 apick.Context.depth = int (CTX.Depth ());
1047
1048 }
1049 } /* if ((MyIterator.Value ())->IsDefined ()) { */
1050
1051 // MyIterator.Next () se positionne
1052 // sur la prochaine vue
1053 MyIterator.Next ();
1054 }
1055
1056 if (DoPick)
1057 MyGraphicDriver->Pick (apick);
1058 else
1059 apick.Pick.depth = 0;
1060
1061 // Picking : le retour
1062Standard_Integer i, j=0;
1063Standard_Integer NbPick;
1064
1065Visual3d_PickDescriptor PDes (CTX);
1066Visual3d_PickPath PPat;
1067
1068 PDes.Clear ();
1069 NbPick = 0;
1070 // For i=0 it is not a graphic structure it is a view structure
1071 // For i=1 it is the displayed graphic structure
1072 // For i=2 to apick.Pick.depth-1 it is the connected graphic structures
1073 if (apick.Pick.depth != 0) {
1074 j = apick.Pick.listid[1];
1075 if ((Graphic3d_StructureManager::Identification (j))->
1076 IsSelectable ()) {
1077 // Maj element number
1078 PPat.SetElementNumber (apick.Pick.listelem[1]);
1079 // Maj pick identifier
1080 PPat.SetPickIdentifier (apick.Pick.listpickid[1]);
1081 // Maj structure
1082 PPat.SetStructIdentifier
1083 (Graphic3d_StructureManager::Identification (j));
1084 // Maj PickPath
1085 PDes.AddPickPath (PPat);
1086 NbPick++;
1087 }
1088 }
1089
1090 // Pas tres efficace, a revoir (CAL 22/09/95)
1091 if (apick.Pick.depth > 2) {
1092Handle(Graphic3d_Structure) StructCur =
1093 Graphic3d_StructureManager::Identification (j);
1094Standard_Boolean found;
1095Graphic3d_MapOfStructure Set;
1096
1097 for (i=2; i<apick.Pick.depth; i++) {
1098 found = Standard_False;
1099 j = apick.Pick.listid[i-1];
1100 Set.Clear ();
1101 StructCur->Descendants (Set);
1102Graphic3d_MapIteratorOfMapOfStructure IteratorD (Set);
1103
1104 j = apick.Pick.listid[i];
1105 while (IteratorD.More () && !found) {
1106 StructCur = IteratorD.Key ();
1107 if (StructCur->Identification () == j ) {
1108 found = Standard_True;
1109 // Maj element number
1110 PPat.SetElementNumber (apick.Pick.listelem[i]);
1111 // Maj pick identifier
1112 PPat.SetPickIdentifier (apick.Pick.listpickid[i]);
1113 // Maj structure
1114 PPat.SetStructIdentifier (StructCur);
1115 // Maj PickPath
1116 PDes.AddPickPath (PPat);
1117 NbPick++;
1118 }
1119 // IteratorD.Next () se positionne
1120 // sur la prochaine structure
1121 IteratorD.Next ();
1122 }
1123 }
1124 }
1125
1126 apick.Pick.depth = int (NbPick);
1127
1128 MyGraphicDriver->InitPick ();
1129
1130 return (PDes);
1131
1132}
1133
1134Standard_Boolean Visual3d_ViewManager::ViewExists (const Handle(Aspect_Window)& AWindow, Graphic3d_CView& TheCView) const {
1135
1136Standard_Boolean Exist = Standard_False;
1137
1138 // Parcours de la liste des vues pour rechercher
1139 // une vue ayant pour fenetre celle specifiee
1140 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
1141 int TheWindowIdOfView;
1142
1143#ifndef WNT
1144const Handle(Xw_Window) THEWindow = *(Handle(Xw_Window) *) &AWindow;
1145 int TheSpecifiedWindowId = int (THEWindow->XWindow ());
1146#else
1147const Handle(WNT_Window) THEWindow = *(Handle(WNT_Window) *) &AWindow;
1148 int TheSpecifiedWindowId = int (THEWindow->HWindow ());
1149#endif // WNT
1150
1151 while ((! Exist) && (MyIterator.More ())) {
1152
1153 if ( ((MyIterator.Value ())->IsDefined ()) &&
1154 ((MyIterator.Value ())->IsActive ()) ) {
1155
1156const Handle(Aspect_Window) AspectWindow = (MyIterator.Value ())->Window ();
1157#ifndef WNT
1158const Handle(Xw_Window) theWindow = *(Handle(Xw_Window) *) &AspectWindow;
1159 TheWindowIdOfView = int (theWindow->XWindow ());
1160#else
1161const Handle(WNT_Window) theWindow = *(Handle(WNT_Window) *) &AspectWindow;
1162 TheWindowIdOfView = int (theWindow->HWindow ());
1163#endif // WNT
1164 // Comparaison sur les windows ids
1165 if (TheWindowIdOfView == TheSpecifiedWindowId) {
1166 Exist = Standard_True;
1167 TheCView = *(CALL_DEF_VIEW *)(MyIterator.Value ())->CView ();
1168 }
1169 } /* if ((MyIterator.Value ())->IsDefined ()) */
1170
1171 // MyIterator.Next () se positionne
1172 // sur la prochaine vue
1173 MyIterator.Next ();
1174 }
1175
1176 return (Exist);
1177
1178}
1179
1180void Visual3d_ViewManager::Activate () {
1181
1182 //
1183 // Activates all deactivated views
1184 //
1185 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
1186
1187#ifdef DEB
1188 Standard_Integer Length = MyDefinedView.Extent ();
1189#else
1190 MyDefinedView.Extent ();
1191#endif
1192
1193 while (MyIterator.More ()) {
1194 if (! (MyIterator.Value ())->IsActive ())
1195 (MyIterator.Value ())->Activate ();
1196
1197 // MyIterator.Next () se positionne
1198 // sur la prochaine vue
1199 MyIterator.Next ();
1200 }
1201
1202}
1203
1204void Visual3d_ViewManager::Deactivate () {
1205
1206 //
1207 // Deactivates all activated views
1208 //
1209#ifdef DEB
1210 Standard_Integer Length = MyDefinedView.Extent ();
1211#else
1212 MyDefinedView.Extent ();
1213#endif
1214 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
1215
1216 while (MyIterator.More ()) {
1217 if ((MyIterator.Value ())->IsActive ())
1218 (MyIterator.Value ())->Deactivate ();
1219
1220 // MyIterator.Next () se positionne
1221 // sur la prochaine vue
1222 MyIterator.Next ();
1223 }
1224
1225}
1226
1227Standard_Integer Visual3d_ViewManager::MaxNumOfViews () const {
1228
1229 // on retourne le nombre theorique de vues definissables pour le
1230 // Visual3d_ViewManager courant.
1231 return
1232(Standard_Integer ((View_IDMAX-View_IDMIN+1)/Visual3d_ViewManager::Limit ()));
1233
1234}
1235
1236Handle(Graphic3d_Structure) Visual3d_ViewManager::Identification (const Standard_Integer AId) const {
1237
1238 return (Graphic3d_StructureManager::Identification (AId));
1239
1240}
1241
1242Standard_Integer Visual3d_ViewManager::Identification () const {
1243
1244 return (Graphic3d_StructureManager::Identification ());
1245
1246}
1247
1248Standard_Integer Visual3d_ViewManager::Identification (const Handle(Visual3d_View)& AView) {
1249
1250 MyDefinedView.Add (AView);
1251 return (MyViewGenId.Next ());
1252
1253}
1254
1255void Visual3d_ViewManager::UnIdentification (const Standard_Integer aViewId)
1256{
1257 MyViewGenId.Free(aViewId);
1258}
1259
1260void Visual3d_ViewManager::SetTransparency (const Standard_Boolean AFlag) {
1261
1262 if (MyTransparency && AFlag) return;
1263 if (! MyTransparency && ! AFlag) return;
1264
1265 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
1266 while (MyIterator.More ()) {
1267 (MyIterator.Value ())->SetTransparency (AFlag);
1268 // MyIterator.Next () se positionne sur la prochaine vue
1269 MyIterator.Next ();
1270 }
1271
1272 MyTransparency = AFlag;
1273
1274}
1275
1276Standard_Boolean Visual3d_ViewManager::Transparency () const {
1277
1278 return (MyTransparency);
1279
1280}
1281
1282void Visual3d_ViewManager::SetZBufferAuto (const Standard_Boolean AFlag) {
1283
1284 if (MyZBufferAuto && AFlag) return;
1285 if (! MyZBufferAuto && ! AFlag) return;
1286
1287 // si de False on passe a True :
1288 // pas de probleme, au prochain update de vue, celle-ci se
1289 // posera les bonnes questions pour reagir (SetVisualisation)
1290 // si de True on passe a False :
1291 // il faut modifier le ZBufferActivity de chaque vue pour que
1292 // le zbuffer ne soit actif que si le contexte le demande.
1293 // Dans ce cas on passe -1 pour que la vue se pose la question
1294 // Rappel : 0 on force la desactivation, 1 on force l'activation
1295 if (! AFlag) {
1296 Visual3d_SetIteratorOfSetOfView MyIterator(MyDefinedView);
1297 while (MyIterator.More ()) {
1298 (MyIterator.Value ())->SetZBufferActivity (-1);
1299 // MyIterator.Next () se positionne sur la prochaine vue
1300 MyIterator.Next ();
1301 }
1302 }
1303 MyZBufferAuto = AFlag;
1304
1305}
1306
1307Standard_Boolean Visual3d_ViewManager::ZBufferAuto () const {
1308
1309 return (MyZBufferAuto);
1310
1311}
1312
1313void Visual3d_ViewManager::SetLayer (const Handle(Visual3d_Layer)& ALayer) {
1314
1315#ifdef TRACE_LAYER
1316 cout << "Visual3d_ViewManager::SetLayer\n" << flush;
1317#endif
1318
1319 if (ALayer->Type () == Aspect_TOL_OVERLAY) {
1320#ifdef TRACE_LAYER
1321 if (MyOverLayer.IsNull ())
1322 cout << "MyOverLayer is defined" << endl;
1323 else
1324 cout << "MyOverLayer is redefined" << endl;
1325#endif
1326 MyOverLayer = ALayer;
1327 }
1328 else {
1329#ifdef TRACE_LAYER
1330 if (MyUnderLayer.IsNull ())
1331 cout << "MyUnderLayer is defined" << endl;
1332 else
1333 cout << "MyUnderLayer is redefined" << endl;
1334#endif
1335 MyUnderLayer = ALayer;
1336 }
1337
1338}
1339
1340const Handle(Visual3d_Layer)& Visual3d_ViewManager::UnderLayer () const {
1341
1342 return (MyUnderLayer);
1343
1344}
1345
1346const Handle(Visual3d_Layer)& Visual3d_ViewManager::OverLayer () const {
1347
1348 return (MyOverLayer);
1349
1350}
Open CASCADE Technology repository