0030675: Visualization - remove redundant proxy classes in hierarchy of PrsMgr_Presen...
[occt.git] / src / Graphic3d / Graphic3d_CView.cxx
1 // Copyright (c) 2015 OPEN CASCADE SAS
2 //
3 // This file is part of Open CASCADE Technology software library.
4 //
5 // This library is free software; you can redistribute it and/or modify it under
6 // the terms of the GNU Lesser General Public License version 2.1 as published
7 // by the Free Software Foundation, with special exception defined in the file
8 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
9 // distribution for complete text of the license and disclaimer of any warranty.
10 //
11 // Alternatively, this file may be used under the terms of Open CASCADE
12 // commercial license or contractual agreement.
13
14 #include <Graphic3d_CView.hxx>
15 #include <Graphic3d_MapIteratorOfMapOfStructure.hxx>
16 #include <Graphic3d_StructureManager.hxx>
17
18 IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_CView,Graphic3d_DataStructureManager)
19
20 namespace
21 {
22   static const int THE_DEFAULT_LAYERS[] = { Graphic3d_ZLayerId_Top,
23                                             Graphic3d_ZLayerId_Topmost,
24                                             Graphic3d_ZLayerId_BotOSD,
25                                             Graphic3d_ZLayerId_TopOSD };
26
27   static const int THE_NB_DEFAULT_LAYERS = sizeof(THE_DEFAULT_LAYERS) / sizeof(*THE_DEFAULT_LAYERS);
28
29 }
30
31 //=======================================================================
32 //function : Constructor
33 //purpose  :
34 //=======================================================================
35 Graphic3d_CView::Graphic3d_CView (const Handle(Graphic3d_StructureManager)& theMgr)
36 : myBgColor                (Quantity_NOC_BLACK),
37   myStructureManager       (theMgr),
38   myCamera                 (new Graphic3d_Camera()),
39   myHiddenObjects          (new Graphic3d_NMapOfTransient()),
40   myIsInComputedMode       (Standard_False),
41   myIsActive               (Standard_False),
42   myIsRemoved              (Standard_False),
43   myShadingModel           (Graphic3d_TOSM_FRAGMENT),
44   myVisualization          (Graphic3d_TOV_WIREFRAME)
45 {
46   myId = myStructureManager->Identification (this);
47 }
48
49 //=======================================================================
50 //function : Destructor
51 //purpose  :
52 //=======================================================================
53 Graphic3d_CView::~Graphic3d_CView()
54 {
55   if (!IsRemoved())
56   {
57     myStructureManager->UnIdentification (this);
58   }
59 }
60
61 // =======================================================================
62 // function : Activate
63 // purpose  :
64 // =======================================================================
65 void Graphic3d_CView::Activate()
66 {
67   if (!IsActive())
68   {
69     myIsActive = Standard_True;
70
71     // Activation of a new view =>
72     // Display structures that can be displayed in this new view.
73     // All structures with status
74     // Displayed in ViewManager are returned and displayed in
75     // the view directly, if the structure is not already
76     // displayed and if the view accepts it in its context.
77     Graphic3d_MapOfStructure aDisplayedStructs;
78     myStructureManager->DisplayedStructures (aDisplayedStructs);
79     for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (aDisplayedStructs); aStructIter.More(); aStructIter.Next())
80     {
81       const Handle(Graphic3d_Structure)& aStruct = aStructIter.Key();
82       if (IsDisplayed (aStruct))
83       {
84         continue;
85       }
86
87       // If the structure can be displayed in the new context of the view, it is displayed.
88       const Graphic3d_TypeOfAnswer anAnswer = acceptDisplay (aStruct->Visual());
89       if (anAnswer == Graphic3d_TOA_YES
90        || anAnswer == Graphic3d_TOA_COMPUTE)
91       {
92         Display (aStruct);
93       }
94     }
95   }
96
97   Update();
98 }
99
100 // =======================================================================
101 // function : Deactivate
102 // purpose  :
103 // =======================================================================
104 void Graphic3d_CView::Deactivate()
105 {
106   if (IsActive())
107   {
108     // Deactivation of a view =>
109     // Removal of structures displayed in this view.
110     // All structures with status
111     // Displayed in ViewManager are returned and removed from
112     // the view directly, if the structure is not already
113     // displayed and if the view accepts it in its context.
114     Graphic3d_MapOfStructure aDisplayedStructs;
115     myStructureManager->DisplayedStructures (aDisplayedStructs);
116     for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (aDisplayedStructs); aStructIter.More(); aStructIter.Next())
117     {
118       const Handle(Graphic3d_Structure)& aStruct = aStructIter.Key();
119       if (!IsDisplayed (aStruct))
120       {
121         continue;
122       }
123
124       const Graphic3d_TypeOfAnswer anAnswer = acceptDisplay (aStruct->Visual());
125       if (anAnswer == Graphic3d_TOA_YES
126        || anAnswer == Graphic3d_TOA_COMPUTE)
127       {
128         Erase (aStruct);
129       }
130     }
131
132     Update();
133     myIsActive = Standard_False;
134   }
135 }
136
137 // ========================================================================
138 // function : Remove
139 // purpose  :
140 // ========================================================================
141 void Graphic3d_CView::Remove()
142 {
143   if (IsRemoved())
144   {
145     return;
146   }
147
148   Graphic3d_MapOfStructure aDisplayedStructs (myStructsDisplayed);
149
150   for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (aDisplayedStructs); aStructIter.More(); aStructIter.Next())
151   {
152     Erase (aStructIter.Value());
153   }
154
155   myStructsToCompute.Clear();
156   myStructsComputed .Clear();
157   myStructsDisplayed.Clear();
158
159   if (!myStructureManager.IsNull())
160   {
161     myStructureManager->UnIdentification (this);
162   }
163
164   myIsActive  = Standard_False;
165   myIsRemoved = Standard_True;
166 }
167
168 // ========================================================================
169 // function : SetComputedMode
170 // purpose  :
171 // ========================================================================
172 void Graphic3d_CView::SetComputedMode (const Standard_Boolean theMode)
173 {
174   if (( theMode &&  myIsInComputedMode)
175    || (!theMode && !myIsInComputedMode))
176   {
177     return;
178   }
179
180   myIsInComputedMode = theMode;
181   if (!myIsInComputedMode)
182   {
183     for (Graphic3d_MapOfStructure::Iterator aStructIter (myStructsDisplayed); aStructIter.More(); aStructIter.Next())
184     {
185       const Handle(Graphic3d_Structure)& aStruct  = aStructIter.Key();
186       const Graphic3d_TypeOfAnswer        anAnswer = acceptDisplay (aStruct->Visual());
187       if (anAnswer != Graphic3d_TOA_COMPUTE)
188       {
189         continue;
190       }
191
192       const Standard_Integer anIndex = IsComputed (aStruct);
193       if (anIndex != 0)
194       {
195         const Handle(Graphic3d_Structure)& aStructComp = myStructsComputed.Value (anIndex);
196         eraseStructure   (aStructComp->CStructure());
197         displayStructure (aStruct->CStructure(), aStruct->DisplayPriority());
198       }
199     }
200     return;
201   }
202
203   for (Graphic3d_MapOfStructure::Iterator aDispStructIter (myStructsDisplayed); aDispStructIter.More(); aDispStructIter.Next())
204   {
205     Handle(Graphic3d_Structure) aStruct  = aDispStructIter.Key();
206     const Graphic3d_TypeOfAnswer anAnswer = acceptDisplay (aStruct->Visual());
207     if (anAnswer != Graphic3d_TOA_COMPUTE)
208     {
209       continue;
210     }
211
212     const Standard_Integer anIndex = IsComputed (aStruct);
213     if (anIndex != 0)
214     {
215       eraseStructure   (aStruct->CStructure());
216       displayStructure (myStructsComputed.Value (anIndex)->CStructure(), aStruct->DisplayPriority());
217
218       Display (aStruct);
219       if (aStruct->IsHighlighted())
220       {
221         const Handle(Graphic3d_Structure)& aCompStruct = myStructsComputed.Value (anIndex);
222         if (!aCompStruct->IsHighlighted())
223         {
224           aCompStruct->Highlight (aStruct->HighlightStyle(), Standard_False);
225         }
226       }
227     }
228     else
229     {
230       Handle(Graphic3d_Structure) aCompStruct = aStruct->IsTransformed() ? aStruct->Compute (this, aStruct->Transformation()) : aStruct->Compute (this);
231       aCompStruct->SetHLRValidation (Standard_True);
232
233       const Standard_Boolean toComputeWireframe = myVisualization == Graphic3d_TOV_WIREFRAME
234                                                 && aStruct->ComputeVisual() != Graphic3d_TOS_SHADING;
235       const Standard_Boolean toComputeShading   = myVisualization == Graphic3d_TOV_SHADING
236                                                 && aStruct->ComputeVisual() != Graphic3d_TOS_WIREFRAME;
237       if (toComputeWireframe) aCompStruct->SetVisual (Graphic3d_TOS_WIREFRAME);
238       if (toComputeShading  ) aCompStruct->SetVisual (Graphic3d_TOS_SHADING);
239
240       if (aStruct->IsHighlighted())
241       {
242         aCompStruct->Highlight (aStruct->HighlightStyle(), Standard_False);
243       }
244
245       Standard_Boolean hasResult = Standard_False;
246       const Standard_Integer aNbToCompute = myStructsToCompute.Length();
247       const Standard_Integer aStructId    = aStruct->Identification();
248       for (Standard_Integer aToCompStructIter = 1; aToCompStructIter <= aNbToCompute; ++aToCompStructIter)
249       {
250         if (myStructsToCompute.Value (aToCompStructIter)->Identification() == aStructId)
251         {
252           hasResult = Standard_True;
253           myStructsComputed.ChangeValue (aToCompStructIter) = aCompStruct;
254           break;
255         }
256       }
257
258       if (!hasResult)
259       {
260         myStructsToCompute.Append (aStruct);
261         myStructsComputed .Append (aCompStruct);
262       }
263
264       aCompStruct->CalculateBoundBox();
265       eraseStructure   (aStruct->CStructure());
266       displayStructure (aCompStruct->CStructure(), aStruct->DisplayPriority());
267     }
268   }
269   Update();
270 }
271
272 // =======================================================================
273 // function : ReCompute
274 // purpose  :
275 // =======================================================================
276 void Graphic3d_CView::ReCompute (const Handle(Graphic3d_Structure)& theStruct)
277 {
278   theStruct->CalculateBoundBox();
279   if (!theStruct->IsMutable()
280    && !theStruct->CStructure()->IsForHighlight
281    && !theStruct->CStructure()->IsInfinite)
282   {
283     const Graphic3d_ZLayerId aLayerId = theStruct->GetZLayer();
284     InvalidateBVHData (aLayerId);
285   }
286
287   if (!ComputedMode()
288    || !IsActive()
289    || !theStruct->IsDisplayed())
290   {
291     return;
292   }
293
294   const Graphic3d_TypeOfAnswer anAnswer = acceptDisplay (theStruct->Visual());
295   if (anAnswer != Graphic3d_TOA_COMPUTE)
296   {
297     return;
298   }
299
300   const Standard_Integer anIndex = IsComputed (theStruct);
301   if (anIndex == 0)
302   {
303     return;
304   }
305
306   // compute + validation
307   Handle(Graphic3d_Structure) aCompStructOld = myStructsComputed.ChangeValue (anIndex);
308   Handle(Graphic3d_Structure) aCompStruct    = aCompStructOld;
309   aCompStruct->SetTransformation (Handle(Geom_Transformation)());
310   theStruct->IsTransformed() ? theStruct->Compute (this, theStruct->Transformation(), aCompStruct)
311                              : theStruct->Compute (this,                              aCompStruct);
312   aCompStruct->SetHLRValidation (Standard_True);
313   aCompStruct->CalculateBoundBox();
314
315   // of which type will be the computed?
316   const Standard_Boolean toComputeWireframe = myVisualization == Graphic3d_TOV_WIREFRAME
317                                            && theStruct->ComputeVisual() != Graphic3d_TOS_SHADING;
318   const Standard_Boolean toComputeShading   = myVisualization == Graphic3d_TOV_SHADING
319                                            && theStruct->ComputeVisual() != Graphic3d_TOS_WIREFRAME;
320   if (toComputeWireframe)
321   {
322     aCompStruct->SetVisual (Graphic3d_TOS_WIREFRAME);
323   }
324   else if (toComputeShading)
325   {
326     aCompStruct->SetVisual (Graphic3d_TOS_SHADING);
327   }
328
329   if (theStruct->IsHighlighted())
330   {
331     aCompStruct->Highlight (theStruct->HighlightStyle(), Standard_False);
332   }
333
334   // The previous calculation is removed and the new one is displayed
335   eraseStructure   (aCompStructOld->CStructure());
336   displayStructure (aCompStruct->CStructure(), theStruct->DisplayPriority());
337
338   // why not just replace existing items?
339   //myStructsToCompute.ChangeValue (anIndex) = theStruct;
340   //myStructsComputed .ChangeValue (anIndex) = aCompStruct;
341
342   // hlhsr and the new associated compute are added
343   myStructsToCompute.Append (theStruct);
344   myStructsComputed .Append (aCompStruct);
345
346   // hlhsr and the new associated compute are removed
347   myStructsToCompute.Remove (anIndex);
348   myStructsComputed .Remove (anIndex);
349 }
350
351 // =======================================================================
352 // function : Update
353 // purpose  :
354 // =======================================================================
355 void Graphic3d_CView::Update (const Graphic3d_ZLayerId theLayerId)
356 {
357   InvalidateZLayerBoundingBox (theLayerId);
358 }
359
360 // =======================================================================
361 // function : ContainsFacet
362 // purpose  :
363 // =======================================================================
364 Standard_Boolean Graphic3d_CView::ContainsFacet() const
365 {
366   for (Graphic3d_MapOfStructure::Iterator aStructIter (myStructsDisplayed); aStructIter.More(); aStructIter.Next())
367   {
368     if (aStructIter.Key()->ContainsFacet())
369     {
370       return Standard_True;
371     }
372   }
373   return Standard_False;
374 }
375
376 // =======================================================================
377 // function : ContainsFacet
378 // purpose  :
379 // =======================================================================
380 Standard_Boolean Graphic3d_CView::ContainsFacet (const Graphic3d_MapOfStructure& theSet) const
381 {
382   for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (theSet); aStructIter.More(); aStructIter.Next())
383   {
384     if (aStructIter.Key()->ContainsFacet())
385     {
386       return Standard_True;
387     }
388   }
389   return Standard_False;
390 }
391
392 // =======================================================================
393 // function : DisplayedStructures
394 // purpose  :
395 // =======================================================================
396 void Graphic3d_CView::DisplayedStructures (Graphic3d_MapOfStructure& theStructures) const
397 {
398   for (Graphic3d_MapOfStructure::Iterator aStructIter (myStructsDisplayed); aStructIter.More(); aStructIter.Next())
399   {
400     theStructures.Add (aStructIter.Key());
401   }
402 }
403
404 // =======================================================================
405 // function : MinMaxValues
406 // purpose  :
407 // =======================================================================
408 Bnd_Box Graphic3d_CView::MinMaxValues (const Standard_Boolean theToIncludeAuxiliary) const
409 {
410   Bnd_Box aResult;
411
412   if (!IsDefined())
413   {
414     return aResult;
415   }
416
417   Handle(Graphic3d_Camera) aCamera = Camera();
418   Standard_Integer aWinWidth  = 0;
419   Standard_Integer aWinHeight = 0;
420
421   Window()->Size (aWinWidth, aWinHeight);
422
423   for (Standard_Integer aLayer = 0; aLayer < THE_NB_DEFAULT_LAYERS; ++aLayer)
424   {
425     Bnd_Box aBox = ZLayerBoundingBox (THE_DEFAULT_LAYERS[aLayer],
426                                       aCamera,
427                                       aWinWidth,
428                                       aWinHeight,
429                                       theToIncludeAuxiliary);
430     aResult.Add (aBox);
431   }
432
433   Standard_Integer aMaxZLayer = ZLayerMax();
434   for (Standard_Integer aLayerId = Graphic3d_ZLayerId_Default; aLayerId <= aMaxZLayer; ++aLayerId)
435   {
436     Bnd_Box aBox = ZLayerBoundingBox (aLayerId,
437                                       aCamera,
438                                       aWinWidth,
439                                       aWinHeight,
440                                       theToIncludeAuxiliary);
441     aResult.Add(aBox);
442   }
443
444   return aResult;
445 }
446
447 // =======================================================================
448 // function : ConsiderZoomPersistenceObjects
449 // purpose  :
450 // =======================================================================
451 Standard_Real Graphic3d_CView::ConsiderZoomPersistenceObjects()
452 {
453   if (!IsDefined())
454   {
455     return 1.0;
456   }
457
458   Handle(Graphic3d_Camera) aCamera = Camera();
459   Standard_Integer aWinWidth  = 0;
460   Standard_Integer aWinHeight = 0;
461
462   Window()->Size (aWinWidth, aWinHeight);
463
464   Standard_Real aMaxCoef = 1.0;
465   for (Standard_Integer aLayer = 0; aLayer < THE_NB_DEFAULT_LAYERS; ++aLayer)
466   {
467     aMaxCoef = Max (aMaxCoef, considerZoomPersistenceObjects (THE_DEFAULT_LAYERS[aLayer], aCamera, aWinWidth, aWinHeight));
468   }
469
470   for (Standard_Integer aLayer = Graphic3d_ZLayerId_Default; aLayer <= ZLayerMax(); ++aLayer)
471   {
472     aMaxCoef = Max (aMaxCoef, considerZoomPersistenceObjects (aLayer, aCamera, aWinWidth, aWinHeight));
473   }
474
475   return aMaxCoef;
476 }
477
478 // =======================================================================
479 // function : MinMaxValues
480 // purpose  :
481 // =======================================================================
482 Bnd_Box Graphic3d_CView::MinMaxValues (const Graphic3d_MapOfStructure& theSet,
483                                        const Standard_Boolean theToIgnoreInfiniteFlag) const
484 {
485   Bnd_Box aResult;
486   const Standard_Integer aViewId = Identification();
487
488   Handle(Graphic3d_Camera) aCamera = Camera();
489   Standard_Integer aWinWidth  = 0;
490   Standard_Integer aWinHeight = 0;
491   if (IsDefined())
492   {
493     Window()->Size (aWinWidth, aWinHeight);
494   }
495
496   for (Graphic3d_MapIteratorOfMapOfStructure aStructIter (theSet); aStructIter.More(); aStructIter.Next())
497   {
498     const Handle(Graphic3d_Structure)& aStructure = aStructIter.Key();
499     if (aStructure->IsEmpty()
500     || !aStructure->CStructure()->IsVisible (aViewId))
501     {
502       continue;
503     }
504
505     // "FitAll" operation ignores object with transform persistence parameter
506     if (!aStructure->TransformPersistence().IsNull())
507     {
508       // Panning and 2d persistence apply changes to projection or/and its translation components.
509       // It makes them incompatible with z-fitting algorithm. Ignored by now.
510       if (!theToIgnoreInfiniteFlag
511        || aStructure->TransformPersistence()->IsTrihedronOr2d())
512       {
513         continue;
514       }
515     }
516
517     Bnd_Box aBox = aStructure->MinMaxValues (theToIgnoreInfiniteFlag);
518
519     if (aBox.IsWhole() || aBox.IsVoid())
520     {
521       continue;
522     }
523
524     if (!aStructure->TransformPersistence().IsNull())
525     {
526       const Graphic3d_Mat4d& aProjectionMat = aCamera->ProjectionMatrix();
527       const Graphic3d_Mat4d& aWorldViewMat  = aCamera->OrientationMatrix();
528       aStructure->TransformPersistence()->Apply (aCamera, aProjectionMat, aWorldViewMat, aWinWidth, aWinHeight, aBox);
529     }
530
531     // To prevent float overflow at camera parameters calculation and further
532     // rendering, bounding boxes with at least one vertex coordinate out of
533     // float range are skipped by view fit algorithms
534     if (Abs (aBox.CornerMax().X()) >= ShortRealLast() ||
535         Abs (aBox.CornerMax().Y()) >= ShortRealLast() ||
536         Abs (aBox.CornerMax().Z()) >= ShortRealLast() ||
537         Abs (aBox.CornerMin().X()) >= ShortRealLast() ||
538         Abs (aBox.CornerMin().Y()) >= ShortRealLast() ||
539         Abs (aBox.CornerMin().Z()) >= ShortRealLast())
540     {
541       continue;
542     }
543
544     aResult.Add (aBox);
545   }
546   return aResult;
547 }
548
549 // =======================================================================
550 // function : acceptDisplay
551 // purpose  :
552 // =======================================================================
553 Graphic3d_TypeOfAnswer Graphic3d_CView::acceptDisplay (const Graphic3d_TypeOfStructure theStructType) const
554 {
555   switch (theStructType)
556   {
557     case Graphic3d_TOS_ALL:
558     {
559       return Graphic3d_TOA_YES; // The structure accepts any type of view
560     }
561     case Graphic3d_TOS_SHADING:
562     {
563       return myVisualization == Graphic3d_TOV_SHADING
564            ? Graphic3d_TOA_YES
565            : Graphic3d_TOA_NO;
566     }
567     case Graphic3d_TOS_WIREFRAME:
568     {
569       return myVisualization == Graphic3d_TOV_WIREFRAME
570            ? Graphic3d_TOA_YES
571            : Graphic3d_TOA_NO;
572     }
573     case Graphic3d_TOS_COMPUTED:
574     {
575       return (myVisualization == Graphic3d_TOV_SHADING || myVisualization == Graphic3d_TOV_WIREFRAME)
576            ?  Graphic3d_TOA_COMPUTE
577            :  Graphic3d_TOA_NO;
578     }
579   }
580   return Graphic3d_TOA_NO;
581 }
582
583 // =======================================================================
584 // function : Compute
585 // purpose  :
586 // =======================================================================
587 void Graphic3d_CView::Compute()
588 {
589   // force HLRValidation to False on all structures calculated in the view
590   for (Graphic3d_SequenceOfStructure::Iterator aStructIter (myStructsComputed); aStructIter.More(); aStructIter.Next())
591   {
592     aStructIter.Value()->SetHLRValidation (Standard_False);
593   }
594
595   if (!ComputedMode())
596   {
597     return;
598   }
599
600   // Change of orientation or of projection type =>
601   // Remove structures that were calculated for the previous orientation.
602   // Recalculation of new structures.
603   NCollection_Sequence<Handle(Graphic3d_Structure)> aStructsSeq;
604   for (Graphic3d_MapOfStructure::Iterator aStructIter (myStructsDisplayed); aStructIter.More(); aStructIter.Next())
605   {
606     const Graphic3d_TypeOfAnswer anAnswer = acceptDisplay (aStructIter.Key()->Visual());
607     if (anAnswer == Graphic3d_TOA_COMPUTE)
608     {
609       aStructsSeq.Append (aStructIter.Key()); // if the structure was calculated, it is recalculated
610     }
611   }
612
613   for (NCollection_Sequence<Handle(Graphic3d_Structure)>::Iterator aStructIter (aStructsSeq); aStructIter.More(); aStructIter.Next())
614   {
615     Display (aStructIter.ChangeValue());
616   }
617 }
618
619 // =======================================================================
620 // function : Clear
621 // purpose  :
622 // =======================================================================
623 void Graphic3d_CView::Clear (Graphic3d_Structure* theStructure,
624                              const Standard_Boolean theWithDestruction)
625 {
626   const Standard_Integer anIndex = IsComputed (theStructure);
627   if (anIndex != 0)
628   {
629     const Handle(Graphic3d_Structure)& aCompStruct = myStructsComputed.Value (anIndex);
630     aCompStruct->GraphicClear (theWithDestruction);
631     aCompStruct->SetHLRValidation (Standard_False);
632   }
633 }
634
635 // =======================================================================
636 // function : Connect
637 // purpose  :
638 // =======================================================================
639 void Graphic3d_CView::Connect (const Graphic3d_Structure* theMother,
640                                const Graphic3d_Structure* theDaughter)
641 {
642   Standard_Integer anIndexM = IsComputed (theMother);
643   Standard_Integer anIndexD = IsComputed (theDaughter);
644   if (anIndexM != 0
645    && anIndexD != 0)
646   {
647     const Handle(Graphic3d_Structure)& aStructM = myStructsComputed.Value (anIndexM);
648     const Handle(Graphic3d_Structure)& aStructD = myStructsComputed.Value (anIndexD);
649     aStructM->GraphicConnect (aStructD);
650   }
651 }
652
653 // =======================================================================
654 // function : Disconnect
655 // purpose  :
656 // =======================================================================
657 void Graphic3d_CView::Disconnect (const Graphic3d_Structure* theMother,
658                                   const Graphic3d_Structure* theDaughter)
659 {
660   Standard_Integer anIndexM = IsComputed (theMother);
661   Standard_Integer anIndexD = IsComputed (theDaughter);
662   if (anIndexM != 0
663    && anIndexD != 0)
664   {
665     const Handle(Graphic3d_Structure)& aStructM = myStructsComputed.Value (anIndexM);
666     const Handle(Graphic3d_Structure)& aStructD = myStructsComputed.Value (anIndexD);
667     aStructM->GraphicDisconnect (aStructD);
668   }
669 }
670
671 // =======================================================================
672 // function : Display
673 // purpose  :
674 // =======================================================================
675 void Graphic3d_CView::Display (const Handle(Graphic3d_Structure)& theStructure)
676 {
677   if (!IsActive())
678   {
679     return;
680   }
681
682   // If Display on a structure present in the list of calculated structures while it is not
683   // or more, of calculated type =>
684   // - removes it as well as the associated old computed
685   // THis happens when hlhsr becomes again of type e non computed after SetVisual.
686   Standard_Integer anIndex = IsComputed (theStructure);
687   if (anIndex != 0
688    && theStructure->Visual() != Graphic3d_TOS_COMPUTED)
689   {
690     myStructsToCompute.Remove (anIndex);
691     myStructsComputed .Remove (anIndex);
692     anIndex = 0;
693   }
694
695   Graphic3d_TypeOfAnswer anAnswer = acceptDisplay (theStructure->Visual());
696   if (anAnswer == Graphic3d_TOA_NO)
697   {
698     return;
699   }
700
701   if (!ComputedMode())
702   {
703     anAnswer = Graphic3d_TOA_YES;
704   }
705
706   if (anAnswer == Graphic3d_TOA_YES)
707   {
708     if (!myStructsDisplayed.Add (theStructure))
709     {
710       return;
711     }
712
713     theStructure->CalculateBoundBox();
714     displayStructure (theStructure->CStructure(), theStructure->DisplayPriority());
715     Update (theStructure->GetZLayer());
716     return;
717   }
718   else if (anAnswer != Graphic3d_TOA_COMPUTE)
719   {
720     return;
721   }
722
723   if (anIndex != 0)
724   {
725     // Already computed, is COMPUTED still valid?
726     const Handle(Graphic3d_Structure)& anOldStruct = myStructsComputed.Value (anIndex);
727     if (anOldStruct->HLRValidation())
728     {
729       // Case COMPUTED valid, to be displayed
730       if (!myStructsDisplayed.Add (theStructure))
731       {
732         return;
733       }
734
735       displayStructure (anOldStruct->CStructure(), theStructure->DisplayPriority());
736       Update (anOldStruct->GetZLayer());
737       return;
738     }
739     else
740     {
741       // Case COMPUTED invalid
742       // Is there another valid representation?
743       // Find in the sequence of already calculated structures
744       // 1/ Structure having the same Owner as <AStructure>
745       // 2/ That is not <AStructure>
746       // 3/ The COMPUTED which of is valid
747       const Standard_Integer aNewIndex = HaveTheSameOwner (theStructure);
748       if (aNewIndex != 0)
749       {
750         // Case of COMPUTED invalid, WITH a valid of replacement; to be displayed
751         if (!myStructsDisplayed.Add (theStructure))
752         {
753           return;
754         }
755
756         const Handle(Graphic3d_Structure)& aNewStruct = myStructsComputed.Value (aNewIndex);
757         myStructsComputed.SetValue (anIndex, aNewStruct);
758         displayStructure (aNewStruct->CStructure(), theStructure->DisplayPriority());
759         Update (aNewStruct->GetZLayer());
760         return;
761       }
762       else
763       {
764         // Case COMPUTED invalid, WITHOUT a valid of replacement
765         // COMPUTED is removed if displayed
766         if (myStructsDisplayed.Contains (theStructure))
767         {
768           eraseStructure (anOldStruct->CStructure());
769         }
770       }
771     }
772   }
773
774   // Compute + Validation
775   Handle(Graphic3d_Structure) aStruct;
776   if (anIndex != 0)
777   {
778     aStruct = myStructsComputed.Value (anIndex);
779     aStruct->SetTransformation (Handle(Geom_Transformation)());
780     if (theStructure->IsTransformed())
781     {
782       theStructure->Compute (this, theStructure->Transformation(), aStruct);
783     }
784     else
785     {
786       theStructure->Compute (this, aStruct);
787     }
788   }
789   else
790   {
791     aStruct = theStructure->IsTransformed()
792             ? theStructure->Compute (this, theStructure->Transformation())
793             : theStructure->Compute (this);
794   }
795
796   aStruct->SetHLRValidation (Standard_True);
797
798   // TOCOMPUTE and COMPUTED associated to sequences are added
799   myStructsToCompute.Append (theStructure);
800   myStructsComputed .Append (aStruct);
801
802   // The previous are removed if necessary
803   if (anIndex != 0)
804   {
805     myStructsToCompute.Remove (anIndex);
806     myStructsComputed .Remove (anIndex);
807   }
808
809   // Of which type will be the computed?
810   const Standard_Boolean toComputeWireframe = myVisualization == Graphic3d_TOV_WIREFRAME
811                                            && theStructure->ComputeVisual() != Graphic3d_TOS_SHADING;
812   const Standard_Boolean toComputeShading   = myVisualization == Graphic3d_TOV_SHADING
813                                            && theStructure->ComputeVisual() != Graphic3d_TOS_WIREFRAME;
814   if (!toComputeShading && !toComputeWireframe)
815   {
816     anAnswer = Graphic3d_TOA_NO;
817   }
818   else
819   {
820     aStruct->SetVisual (toComputeWireframe ? Graphic3d_TOS_WIREFRAME : Graphic3d_TOS_SHADING);
821     anAnswer = acceptDisplay (aStruct->Visual());
822   }
823
824   if (theStructure->IsHighlighted())
825   {
826     aStruct->Highlight (theStructure->HighlightStyle(), Standard_False);
827   }
828
829   // It is displayed only if the calculated structure
830   // has a proper type corresponding to the one of the view.
831   if (anAnswer == Graphic3d_TOA_NO)
832   {
833     return;
834   }
835
836   myStructsDisplayed.Add (theStructure);
837   displayStructure (aStruct->CStructure(), theStructure->DisplayPriority());
838
839   Update (aStruct->GetZLayer());
840 }
841
842 // =======================================================================
843 // function : Erase
844 // purpose  :
845 // =======================================================================
846 void Graphic3d_CView::Erase (const Handle(Graphic3d_Structure)& theStructure)
847 {
848   if (!IsDisplayed (theStructure))
849   {
850     return;
851   }
852
853   const Graphic3d_TypeOfAnswer anAnswer = myIsInComputedMode ? acceptDisplay (theStructure->Visual()) : Graphic3d_TOA_YES;
854   if (anAnswer != Graphic3d_TOA_COMPUTE)
855   {
856     eraseStructure (theStructure->CStructure());
857   }
858
859   const Standard_Integer anIndex = !myStructsToCompute.IsEmpty() ? IsComputed (theStructure) : 0;
860   if (anIndex != 0)
861   {
862     if (anAnswer == Graphic3d_TOA_COMPUTE
863      && myIsInComputedMode)
864     {
865       const Handle(Graphic3d_Structure)& aCompStruct = myStructsComputed.ChangeValue (anIndex);
866       eraseStructure (aCompStruct->CStructure());
867     }
868     myStructsComputed .Remove (anIndex);
869     myStructsToCompute.Remove (anIndex);
870   }
871
872   myStructsDisplayed.Remove (theStructure);
873   Update (theStructure->GetZLayer());
874 }
875
876 // =======================================================================
877 // function : Highlight
878 // purpose  :
879 // =======================================================================
880 void Graphic3d_CView::Highlight (const Handle(Graphic3d_Structure)& theStructure)
881 {
882   const Standard_Integer anIndex = IsComputed (theStructure);
883   if (anIndex != 0)
884   {
885     const Handle(Graphic3d_Structure)& aCompStruct = myStructsComputed.ChangeValue (anIndex);
886     aCompStruct->Highlight (theStructure->HighlightStyle(), Standard_False);
887   }
888 }
889
890 // =======================================================================
891 // function : SetTransform
892 // purpose  :
893 // =======================================================================
894 void Graphic3d_CView::SetTransform (const Handle(Graphic3d_Structure)& theStructure,
895                                     const Handle(Geom_Transformation)& theTrsf)
896 {
897   const Standard_Integer anIndex = IsComputed (theStructure);
898   if (anIndex != 0)
899   {
900     // Test is somewhat light !
901     // trsf is transferred only if it is :
902     // a translation
903     // a scale
904     if (!theTrsf.IsNull()
905       && (theTrsf->Form() == gp_Translation
906        || theTrsf->Form() == gp_Scale
907        || theTrsf->Form() == gp_CompoundTrsf))
908     {
909       ReCompute (theStructure);
910     }
911     else
912     {
913       const Handle(Graphic3d_Structure)& aCompStruct = myStructsComputed.ChangeValue (anIndex);
914       aCompStruct->GraphicTransform (theTrsf);
915     }
916   }
917
918   theStructure->CalculateBoundBox();
919   if (!theStructure->IsMutable()
920    && !theStructure->CStructure()->IsForHighlight
921    && !theStructure->CStructure()->IsInfinite)
922   {
923     const Graphic3d_ZLayerId aLayerId = theStructure->GetZLayer();
924     InvalidateBVHData (aLayerId);
925   }
926 }
927
928 // =======================================================================
929 // function : UnHighlight
930 // purpose  :
931 // =======================================================================
932 void Graphic3d_CView::UnHighlight (const Handle(Graphic3d_Structure)& theStructure)
933 {
934   Standard_Integer anIndex = IsComputed (theStructure);
935   if (anIndex != 0)
936   {
937     const Handle(Graphic3d_Structure)& aCompStruct = myStructsComputed.ChangeValue (anIndex);
938     aCompStruct->CStructure()->GraphicUnhighlight();
939   }
940 }
941
942 // ========================================================================
943 // function : IsComputed
944 // purpose  :
945 // ========================================================================
946 Standard_Boolean Graphic3d_CView::IsComputed (const Standard_Integer theStructId,
947                                               Handle(Graphic3d_Structure)& theComputedStruct) const
948 {
949   theComputedStruct.Nullify();
950   if (!ComputedMode())
951     return Standard_False;
952
953   const Standard_Integer aNbStructs = myStructsToCompute.Length();
954   for (Standard_Integer aStructIter = 1; aStructIter <= aNbStructs; ++aStructIter)
955   {
956     if (myStructsToCompute.Value (aStructIter)->Identification() == theStructId)
957     {
958       theComputedStruct = myStructsComputed (aStructIter);
959       return Standard_True;
960     }
961   }
962   return Standard_False;
963 }
964
965 // =======================================================================
966 // function : IsComputed
967 // purpose  :
968 // =======================================================================
969 Standard_Integer Graphic3d_CView::IsComputed (const Graphic3d_Structure* theStructure) const
970 {
971   const Standard_Integer aStructId  = theStructure->Identification();
972   Standard_Integer aStructIndex = 1;
973   for (Graphic3d_SequenceOfStructure::Iterator aStructIter (myStructsToCompute); aStructIter.More(); aStructIter.Next(), ++aStructIndex)
974   {
975     const Handle(Graphic3d_Structure)& aStruct = aStructIter.Value();
976     if (aStruct->Identification() == aStructId)
977     {
978       return aStructIndex;
979     }
980   }
981   return 0;
982 }
983
984 // =======================================================================
985 // function : IsDisplayed
986 // purpose  :
987 // =======================================================================
988 Standard_Boolean Graphic3d_CView::IsDisplayed (const Handle(Graphic3d_Structure)& theStructure) const
989 {
990   return myStructsDisplayed.Contains (theStructure);
991 }
992
993 // =======================================================================
994 // function : ChangePriority
995 // purpose  :
996 // =======================================================================
997 void Graphic3d_CView::ChangePriority (const Handle(Graphic3d_Structure)& theStructure,
998                                       const Standard_Integer /*theOldPriority*/,
999                                       const Standard_Integer theNewPriority)
1000 {
1001   if (!IsActive()
1002   ||  !IsDisplayed (theStructure))
1003   {
1004     return;
1005   }
1006
1007   if (!myIsInComputedMode)
1008   {
1009     changePriority (theStructure->CStructure(), theNewPriority);
1010     return;
1011   }
1012
1013   const Standard_Integer              anIndex  = IsComputed (theStructure);
1014   const Handle(Graphic3d_CStructure)& aCStruct = anIndex != 0
1015                                                ? myStructsComputed.Value (anIndex)->CStructure()
1016                                                : theStructure->CStructure();
1017
1018   changePriority (aCStruct, theNewPriority);
1019 }
1020
1021 // =======================================================================
1022 // function : ChangeZLayer
1023 // purpose  :
1024 // =======================================================================
1025 void Graphic3d_CView::ChangeZLayer (const Handle(Graphic3d_Structure)& theStructure,
1026                                     const Graphic3d_ZLayerId theLayerId)
1027 {
1028   if (!IsActive()
1029   ||  !IsDisplayed (theStructure))
1030   {
1031     return;
1032   }
1033
1034   if (!myIsInComputedMode)
1035   {
1036     changeZLayer (theStructure->CStructure(), theLayerId);
1037     return;
1038   }
1039
1040   const Standard_Integer       anIndex  = IsComputed (theStructure);
1041   Handle(Graphic3d_CStructure) aCStruct = anIndex != 0
1042                                        ? myStructsComputed.Value (anIndex)->CStructure()
1043                                        : theStructure->CStructure();
1044
1045   changeZLayer (aCStruct, theLayerId);
1046 }
1047
1048 // =======================================================================
1049 // function : HaveTheSameOwner
1050 // purpose  :
1051 // =======================================================================
1052 Standard_Integer Graphic3d_CView::HaveTheSameOwner (const Handle(Graphic3d_Structure)& theStructure) const
1053 {
1054   // Find in the sequence of already calculated structures
1055   // 1/ Structure with the same Owner as <AStructure>
1056   // 2/ Which is not <AStructure>
1057   // 3/ COMPUTED which of is valid
1058   const Standard_Integer aNbToCompStructs = myStructsToCompute.Length();
1059   for (Standard_Integer aStructIter = 1; aStructIter <= aNbToCompStructs; ++aStructIter)
1060   {
1061     const Handle(Graphic3d_Structure)& aStructToComp = myStructsToCompute.Value (aStructIter);
1062     if (aStructToComp->Owner()          == theStructure->Owner()
1063      && aStructToComp->Identification() != theStructure->Identification())
1064     {
1065       const Handle(Graphic3d_Structure)& aStructComp = myStructsComputed.Value (aStructIter);
1066       if (aStructComp->HLRValidation())
1067       {
1068         return aStructIter;
1069       }
1070     }
1071   }
1072   return 0;
1073 }
1074
1075 // =======================================================================
1076 // function : CopySettings
1077 // purpose  :
1078 // =======================================================================
1079 void Graphic3d_CView::CopySettings (const Handle(Graphic3d_CView)& theOther)
1080 {
1081   ChangeRenderingParams() = theOther->RenderingParams();
1082   SetBackground            (theOther->Background());
1083   SetGradientBackground    (theOther->GradientBackground());
1084   SetBackgroundImage       (theOther->BackgroundImage());
1085   SetBackgroundImageStyle  (theOther->BackgroundImageStyle());
1086   SetTextureEnv            (theOther->TextureEnv());
1087   SetShadingModel          (theOther->ShadingModel());
1088   SetBackfacingModel       (theOther->BackfacingModel());
1089   SetCamera                (new Graphic3d_Camera (theOther->Camera()));
1090   SetLights                (theOther->Lights());
1091   SetClipPlanes            (theOther->ClipPlanes());
1092 }
1093
1094 // =======================================================================
1095 // function : SetShadingModel
1096 // purpose  :
1097 // =======================================================================
1098 void Graphic3d_CView::SetShadingModel (Graphic3d_TypeOfShadingModel theModel)
1099 {
1100   if (theModel == Graphic3d_TOSM_DEFAULT)
1101   {
1102     throw Standard_ProgramError ("Graphic3d_CView::SetShadingModel() - attempt to set invalid Shading Model!");
1103   }
1104
1105   myShadingModel = theModel;
1106 }