0029372: Graphic3d_TransformPers - improve description of Local Coordinate system...
[occt.git] / src / Graphic3d / Graphic3d_TransformPers.hxx
1 // Created on: 2015-06-18
2 // Created by: Anton POLETAEV
3 // Copyright (c) 2015 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #ifndef _Graphic3d_TransformPers_HeaderFile
17 #define _Graphic3d_TransformPers_HeaderFile
18
19 #include <Aspect_TypeOfTriedronPosition.hxx>
20 #include <Bnd_Box.hxx>
21 #include <BVH_Box.hxx>
22 #include <Graphic3d_Camera.hxx>
23 #include <Graphic3d_TransformUtils.hxx>
24 #include <Graphic3d_TransModeFlags.hxx>
25 #include <Graphic3d_Vec.hxx>
26 #include <NCollection_Mat4.hxx>
27
28 DEFINE_STANDARD_HANDLE(Graphic3d_TransformPers, Standard_Transient)
29
30 //! Transformation Persistence definition.
31 //!
32 //! Transformation Persistence defines a mutable Local Coordinate system which depends on camera position,
33 //! so that visual appearance of the object becomes partially immutable while camera moves.
34 //! Object visually preserves particular property such as size, placement, rotation or their combination.
35 //!
36 //! Graphic3d_TMF_ZoomPers, Graphic3d_TMF_RotatePers and Graphic3d_TMF_ZoomRotatePers define Local Coordinate system
37 //! having origin in specified anchor point defined in World Coordinate system,
38 //! while Graphic3d_TMF_TriedronPers and Graphic3d_TMF_2d define origin as 2D offset from screen corner in pixels.
39 //!
40 //! Graphic3d_TMF_2d, Graphic3d_TMF_TriedronPers and Graphic3d_TMF_ZoomPers defines Local Coordinate system where length units are pixels.
41 //! Beware that Graphic3d_RenderingParams::ResolutionRatio() will be ignored!
42 //! For other Persistence flags, normal (world) length units will apply.
43 //!
44 //! WARNING: Graphic3d_TMF_None is not permitted for defining instance of this class - NULL handle should be used for this purpose!
45 class Graphic3d_TransformPers : public Standard_Transient
46 {
47   DEFINE_STANDARD_RTTIEXT(Graphic3d_TransformPers, Standard_Transient)
48 public:
49
50   //! Return true if specified mode is zoom/rotate transformation persistence.
51   static Standard_Boolean IsZoomOrRotate (Graphic3d_TransModeFlags theMode)
52   {
53     return (theMode & (Graphic3d_TMF_ZoomPers | Graphic3d_TMF_RotatePers)) != 0;
54   }
55
56   //! Return true if specified mode is 2d/trihedron transformation persistence.
57   static Standard_Boolean IsTrihedronOr2d (Graphic3d_TransModeFlags theMode)
58   {
59     return (theMode & (Graphic3d_TMF_TriedronPers | Graphic3d_TMF_2d)) != 0;
60   }
61
62   //! Create Graphic3d_TransformPers instance from deprecated parameters set
63   //! decoding 2D corner + offset parameters from 3D point.
64   Standard_EXPORT static Handle(Graphic3d_TransformPers) FromDeprecatedParams (Graphic3d_TransModeFlags theFlag,
65                                                                                const gp_Pnt&            thePoint);
66
67 public:
68
69   //! Set transformation persistence.
70   Graphic3d_TransformPers (const Graphic3d_TransModeFlags theMode)
71   : myMode (theMode)
72   {
73     if (IsZoomOrRotate (theMode))
74     {
75       SetPersistence (theMode, gp_Pnt(0.0, 0.0, 0.0));
76     }
77     else if (IsTrihedronOr2d (theMode))
78     {
79       SetPersistence (theMode, Aspect_TOTP_LEFT_LOWER, Graphic3d_Vec2i (0, 0));
80     }
81     else
82     {
83       throw Standard_ProgramError("Graphic3d_TransformPers::SetPersistence(), wrong persistence mode.");
84     }
85   }
86
87   //! Set Zoom/Rotate transformation persistence with an anchor 3D point.
88   //! Anchor point defines the origin of Local Coordinate system within World Coordinate system.
89   //! Throws an exception if persistence mode is not Graphic3d_TMF_ZoomPers, Graphic3d_TMF_ZoomRotatePers or Graphic3d_TMF_RotatePers.
90   Graphic3d_TransformPers (const Graphic3d_TransModeFlags theMode,
91                            const gp_Pnt& thePnt)
92   : myMode (Graphic3d_TMF_None)
93   {
94     SetPersistence (theMode, thePnt);
95   }
96
97   //! Set 2d/trihedron transformation persistence with a corner and 2D offset.
98   //! 2D offset defines the origin of Local Coordinate system as projection of 2D point on screen plane into World Coordinate system.
99   //! Throws an exception if persistence mode is not Graphic3d_TMF_TriedronPers or Graphic3d_TMF_2d.
100   //! The offset is a positive displacement from the view corner in pixels.
101   Graphic3d_TransformPers (const Graphic3d_TransModeFlags theMode,
102                            const Aspect_TypeOfTriedronPosition theCorner,
103                            const Graphic3d_Vec2i& theOffset = Graphic3d_Vec2i (0, 0))
104   : myMode (Graphic3d_TMF_None)
105   {
106     SetPersistence (theMode, theCorner, theOffset);
107   }
108
109   //! Return true for Graphic3d_TMF_ZoomPers, Graphic3d_TMF_ZoomRotatePers or Graphic3d_TMF_RotatePers modes.
110   Standard_Boolean IsZoomOrRotate() const { return IsZoomOrRotate (myMode); }
111
112   //! Return true for Graphic3d_TMF_TriedronPers and Graphic3d_TMF_2d modes.
113   Standard_Boolean IsTrihedronOr2d() const { return IsTrihedronOr2d (myMode); }
114
115   //! Transformation persistence mode flags.
116   Graphic3d_TransModeFlags Mode() const { return myMode; }
117
118   //! Transformation persistence mode flags.
119   Graphic3d_TransModeFlags Flags() const { return myMode; }
120
121   //! Set Zoom/Rotate transformation persistence with an anchor 3D point.
122   //! Throws an exception if persistence mode is not Graphic3d_TMF_ZoomPers, Graphic3d_TMF_ZoomRotatePers or Graphic3d_TMF_RotatePers.
123   void SetPersistence (const Graphic3d_TransModeFlags theMode,
124                        const gp_Pnt& thePnt)
125   {
126     if (!IsZoomOrRotate (theMode))
127     {
128       throw Standard_ProgramError("Graphic3d_TransformPers::SetPersistence(), wrong persistence mode.");
129     }
130
131     myMode = theMode;
132     myParams.Params3d.PntX = thePnt.X();
133     myParams.Params3d.PntY = thePnt.Y();
134     myParams.Params3d.PntZ = thePnt.Z();
135   }
136
137   //! Set 2d/trihedron transformation persistence with a corner and 2D offset.
138   //! Throws an exception if persistence mode is not Graphic3d_TMF_TriedronPers or Graphic3d_TMF_2d.
139   void SetPersistence (const Graphic3d_TransModeFlags theMode,
140                        const Aspect_TypeOfTriedronPosition theCorner,
141                        const Graphic3d_Vec2i& theOffset)
142   {
143     if (!IsTrihedronOr2d (theMode))
144     {
145       throw Standard_ProgramError("Graphic3d_TransformPers::SetPersistence(), wrong persistence mode.");
146     }
147
148     myMode = theMode;
149     myParams.Params2d.Corner  = theCorner;
150     myParams.Params2d.OffsetX = theOffset.x();
151     myParams.Params2d.OffsetY = theOffset.y();
152   }
153
154 public:
155
156   //! Return the anchor point for zoom/rotate transformation persistence.
157   gp_Pnt AnchorPoint() const
158   {
159     if (!IsZoomOrRotate())
160     {
161       throw Standard_ProgramError("Graphic3d_TransformPers::AnchorPoint(), wrong persistence mode.");
162     }
163
164     return gp_Pnt (myParams.Params3d.PntX, myParams.Params3d.PntY, myParams.Params3d.PntZ);
165   }
166
167   //! Set the anchor point for zoom/rotate transformation persistence.
168   void SetAnchorPoint (const gp_Pnt& thePnt)
169   {
170     if (!IsZoomOrRotate())
171     {
172       throw Standard_ProgramError("Graphic3d_TransformPers::SetAnchorPoint(), wrong persistence mode.");
173     }
174
175     myParams.Params3d.PntX = thePnt.X();
176     myParams.Params3d.PntY = thePnt.Y();
177     myParams.Params3d.PntZ = thePnt.Z();
178   }
179
180   //! Return the corner for 2d/trihedron transformation persistence.
181   Aspect_TypeOfTriedronPosition Corner2d() const
182   {
183     if (!IsTrihedronOr2d())
184     {
185       throw Standard_ProgramError("Graphic3d_TransformPers::Corner2d(), wrong persistence mode.");
186     }
187
188     return myParams.Params2d.Corner;
189   }
190
191   //! Set the corner for 2d/trihedron transformation persistence.
192   void SetCorner2d (const Aspect_TypeOfTriedronPosition thePos)
193   {
194     if (!IsTrihedronOr2d())
195     {
196       throw Standard_ProgramError("Graphic3d_TransformPers::SetCorner2d(), wrong persistence mode.");
197     }
198
199     myParams.Params2d.Corner = thePos;
200   }
201
202   //! Return the offset from the corner for 2d/trihedron transformation persistence.
203   Graphic3d_Vec2i Offset2d() const
204   {
205     if (!IsTrihedronOr2d())
206     {
207       throw Standard_ProgramError("Graphic3d_TransformPers::Offset2d(), wrong persistence mode.");
208     }
209
210     return Graphic3d_Vec2i (myParams.Params2d.OffsetX, myParams.Params2d.OffsetY);
211   }
212
213   //! Set the offset from the corner for 2d/trihedron transformation persistence.
214   void SetOffset2d (const Graphic3d_Vec2i& theOffset)
215   {
216     if (!IsTrihedronOr2d())
217     {
218       throw Standard_ProgramError("Graphic3d_TransformPers::SetOffset2d(), wrong persistence mode.");
219     }
220
221     myParams.Params2d.OffsetX = theOffset.x();
222     myParams.Params2d.OffsetY = theOffset.y();
223   }
224
225 public:
226
227   //! Apply transformation to bounding box of presentation.
228   //! @param theCamera [in] camera definition
229   //! @param theProjection [in] the projection transformation matrix.
230   //! @param theWorldView [in] the world view transformation matrix.
231   //! @param theViewportWidth [in] the width of viewport (for 2d persistence).
232   //! @param theViewportHeight [in] the height of viewport (for 2d persistence).
233   //! @param theBoundingBox [in/out] the bounding box to transform.
234   template<class T>
235   void Apply (const Handle(Graphic3d_Camera)& theCamera,
236               const NCollection_Mat4<T>& theProjection,
237               const NCollection_Mat4<T>& theWorldView,
238               const Standard_Integer theViewportWidth,
239               const Standard_Integer theViewportHeight,
240               Bnd_Box& theBoundingBox) const;
241
242   //! Apply transformation to bounding box of presentation
243   //! @param theCamera [in] camera definition
244   //! @param theProjection [in] the projection transformation matrix.
245   //! @param theWorldView [in] the world view transformation matrix.
246   //! @param theViewportWidth [in] the width of viewport (for 2d persistence).
247   //! @param theViewportHeight [in] the height of viewport (for 2d persistence).
248   //! @param theBoundingBox [in/out] the bounding box to transform.
249   template<class T>
250   void Apply (const Handle(Graphic3d_Camera)& theCamera,
251               const NCollection_Mat4<T>& theProjection,
252               const NCollection_Mat4<T>& theWorldView,
253               const Standard_Integer theViewportWidth,
254               const Standard_Integer theViewportHeight,
255               BVH_Box<T, 3>& theBoundingBox) const;
256
257   //! Compute transformation.
258   //! Computed matrix can be applied to model world transformation
259   //! of an object to implement effect of transformation persistence.
260   //! @param theCamera [in] camera definition
261   //! @param theProjection [in] the projection transformation matrix.
262   //! @param theWorldView [in] the world view transformation matrix.
263   //! @param theViewportWidth [in] the width of viewport (for 2d persistence).
264   //! @param theViewportHeight [in] the height of viewport (for 2d persistence).
265   //! @return transformation matrix to be applied to model world transformation of an object.
266   template<class T>
267   NCollection_Mat4<T> Compute (const Handle(Graphic3d_Camera)& theCamera,
268                                const NCollection_Mat4<T>& theProjection,
269                                const NCollection_Mat4<T>& theWorldView,
270                                const Standard_Integer theViewportWidth,
271                                const Standard_Integer theViewportHeight) const;
272
273   //! Apply transformation persistence on specified matrices.
274   //! @param theCamera camera definition
275   //! @param theProjection projection matrix to modify
276   //! @param theWorldView  world-view matrix to modify
277   //! @param theViewportWidth  viewport width
278   //! @param theViewportHeight viewport height
279   template<class T>
280   void Apply (const Handle(Graphic3d_Camera)& theCamera,
281               const NCollection_Mat4<T>& theProjection,
282               NCollection_Mat4<T>& theWorldView,
283               const Standard_Integer theViewportWidth,
284               const Standard_Integer theViewportHeight) const;
285
286 private:
287
288   //! 3D anchor point for zoom/rotate transformation persistence.
289   struct PersParams3d
290   {
291     Standard_Real PntX;
292     Standard_Real PntY;
293     Standard_Real PntZ;
294   };
295
296   //! 2d/trihedron transformation persistence parameters.
297   struct PersParams2d
298   {
299     Standard_Integer OffsetX;
300     Standard_Integer OffsetY;
301     Aspect_TypeOfTriedronPosition Corner;
302   };
303
304 private:
305
306   Graphic3d_TransModeFlags myMode;  //!< Transformation persistence mode flags
307   union
308   {
309     PersParams3d Params3d;
310     PersParams2d Params2d;
311   } myParams;
312
313 };
314
315 // =======================================================================
316 // function : Apply
317 // purpose  : Apply transformation to world view and projection matrices.
318 // =======================================================================
319 template<class T>
320 void Graphic3d_TransformPers::Apply (const Handle(Graphic3d_Camera)& theCamera,
321                                      const NCollection_Mat4<T>& theProjection,
322                                      NCollection_Mat4<T>& theWorldView,
323                                      const Standard_Integer theViewportWidth,
324                                      const Standard_Integer theViewportHeight) const
325 {
326   (void )theViewportWidth;
327   (void )theProjection;
328   if (myMode == Graphic3d_TMF_None
329    || theViewportHeight == 0)
330   {
331     return;
332   }
333
334   // use total size when tiling is active
335   const Standard_Integer aVPSizeY = theCamera->Tile().IsValid() ? theCamera->Tile().TotalSize.y() : theViewportHeight;
336
337   // a small enough jitter compensation offset
338   // to avoid image dragging within single pixel in corner cases
339   const Standard_Real aJitterComp = 0.001;
340   if (myMode == Graphic3d_TMF_TriedronPers)
341   {
342     // reset Z focus for trihedron persistence
343     const Standard_Real aFocus = theCamera->IsOrthographic()
344                                ? theCamera->Distance()
345                                : (theCamera->ZFocusType() == Graphic3d_Camera::FocusType_Relative
346                                 ? Standard_Real(theCamera->ZFocus() * theCamera->Distance())
347                                 : Standard_Real(theCamera->ZFocus()));
348
349     // scale factor to pixels
350     const gp_XYZ aViewDim = theCamera->ViewDimensions (aFocus);
351     const Standard_Real aScale = Abs(aViewDim.Y()) / Standard_Real(aVPSizeY);
352     const gp_Dir aForward (theCamera->Center().XYZ() - theCamera->Eye().XYZ());
353     gp_XYZ aCenter = theCamera->Center().XYZ() + aForward.XYZ() * (aFocus - theCamera->Distance());
354     if ((myParams.Params2d.Corner & (Aspect_TOTP_LEFT | Aspect_TOTP_RIGHT)) != 0)
355     {
356       const Standard_Real anOffsetX = (Standard_Real(myParams.Params2d.OffsetX) + aJitterComp) * aScale;
357       const gp_Dir aSide   = aForward.Crossed (theCamera->Up());
358       const gp_XYZ aDeltaX = aSide.XYZ() * (Abs(aViewDim.X()) * 0.5 - anOffsetX);
359       if ((myParams.Params2d.Corner & Aspect_TOTP_RIGHT) != 0)
360       {
361         aCenter += aDeltaX;
362       }
363       else
364       {
365         aCenter -= aDeltaX;
366       }
367     }
368     if ((myParams.Params2d.Corner & (Aspect_TOTP_TOP | Aspect_TOTP_BOTTOM)) != 0)
369     {
370       const Standard_Real anOffsetY = (Standard_Real(myParams.Params2d.OffsetY) + aJitterComp) * aScale;
371       const gp_XYZ aDeltaY = theCamera->Up().XYZ() * (Abs(aViewDim.Y()) * 0.5 - anOffsetY);
372       if ((myParams.Params2d.Corner & Aspect_TOTP_TOP) != 0)
373       {
374         aCenter += aDeltaY;
375       }
376       else
377       {
378         aCenter -= aDeltaY;
379       }
380     }
381
382     NCollection_Mat4<Standard_Real> aWorldView = theCamera->OrientationMatrix();
383     Graphic3d_TransformUtils::Translate (aWorldView, aCenter.X(), aCenter.Y(), aCenter.Z());
384     Graphic3d_TransformUtils::Scale     (aWorldView, aScale,      aScale,      aScale);
385     theWorldView.ConvertFrom (aWorldView);
386     return;
387   }
388   else if (myMode == Graphic3d_TMF_2d)
389   {
390     const Standard_Real aFocus = theCamera->IsOrthographic()
391                                ? theCamera->Distance()
392                                : (theCamera->ZFocusType() == Graphic3d_Camera::FocusType_Relative
393                                 ? Standard_Real(theCamera->ZFocus() * theCamera->Distance())
394                                 : Standard_Real(theCamera->ZFocus()));
395
396     // scale factor to pixels
397     const gp_XYZ        aViewDim = theCamera->ViewDimensions (aFocus);
398     const Standard_Real aScale   = Abs(aViewDim.Y()) / Standard_Real(aVPSizeY);
399     gp_XYZ aCenter (0.0, 0.0, -aFocus);
400     if ((myParams.Params2d.Corner & (Aspect_TOTP_LEFT | Aspect_TOTP_RIGHT)) != 0)
401     {
402       aCenter.SetX (-aViewDim.X() * 0.5 + (Standard_Real(myParams.Params2d.OffsetX) + aJitterComp) * aScale);
403       if ((myParams.Params2d.Corner & Aspect_TOTP_RIGHT) != 0)
404       {
405         aCenter.SetX (-aCenter.X());
406       }
407     }
408     if ((myParams.Params2d.Corner & (Aspect_TOTP_TOP | Aspect_TOTP_BOTTOM)) != 0)
409     {
410       aCenter.SetY (-aViewDim.Y() * 0.5 + (Standard_Real(myParams.Params2d.OffsetY) + aJitterComp) * aScale);
411       if ((myParams.Params2d.Corner & Aspect_TOTP_TOP) != 0)
412       {
413         aCenter.SetY (-aCenter.Y());
414       }
415     }
416
417     theWorldView.InitIdentity();
418     Graphic3d_TransformUtils::Translate (theWorldView, T(aCenter.X()), T(aCenter.Y()), T(aCenter.Z()));
419     Graphic3d_TransformUtils::Scale     (theWorldView, T(aScale),      T(aScale),      T(aScale));
420     return;
421   }
422   else
423   {
424     // Compute reference point for transformation in untransformed projection space.
425     NCollection_Mat4<Standard_Real> aWorldView = theCamera->OrientationMatrix();
426     Graphic3d_TransformUtils::Translate (aWorldView, myParams.Params3d.PntX, myParams.Params3d.PntY, myParams.Params3d.PntZ);
427     if ((myMode & Graphic3d_TMF_RotatePers) != 0)
428     {
429       // lock rotation by nullifying rotation component
430       aWorldView.SetValue (0, 0, 1.0);
431       aWorldView.SetValue (1, 0, 0.0);
432       aWorldView.SetValue (2, 0, 0.0);
433
434       aWorldView.SetValue (0, 1, 0.0);
435       aWorldView.SetValue (1, 1, 1.0);
436       aWorldView.SetValue (2, 1, 0.0);
437
438       aWorldView.SetValue (0, 2, 0.0);
439       aWorldView.SetValue (1, 2, 0.0);
440       aWorldView.SetValue (2, 2, 1.0);
441     }
442
443     if ((myMode & Graphic3d_TMF_ZoomPers) != 0)
444     {
445       // lock zooming
446       gp_Vec aVecToEye (theCamera->Direction());
447       gp_Vec aVecToObj (theCamera->Eye(), gp_Pnt (myParams.Params3d.PntX, myParams.Params3d.PntY, myParams.Params3d.PntZ));
448       const Standard_Real aFocus = aVecToObj.Dot (aVecToEye);
449       const gp_XYZ aViewDim = theCamera->ViewDimensions (aFocus);
450       const Standard_Real aScale = Abs(aViewDim.Y()) / Standard_Real(aVPSizeY);
451       Graphic3d_TransformUtils::Scale (aWorldView, aScale, aScale, aScale);
452     }
453     theWorldView.ConvertFrom (aWorldView);
454     return;
455   }
456 }
457
458 // =======================================================================
459 // function : Apply
460 // purpose  : Apply transformation to bounding box of presentation.
461 // =======================================================================
462 template<class T>
463 void Graphic3d_TransformPers::Apply (const Handle(Graphic3d_Camera)& theCamera,
464                                      const NCollection_Mat4<T>& theProjection,
465                                      const NCollection_Mat4<T>& theWorldView,
466                                      const Standard_Integer theViewportWidth,
467                                      const Standard_Integer theViewportHeight,
468                                      Bnd_Box& theBoundingBox) const
469 {
470   if (theBoundingBox.IsVoid())
471   {
472     return;
473   }
474
475   T aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
476
477   theBoundingBox.Get (aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
478
479   typename BVH_Box<T, 3>::BVH_VecNt aMin (aXmin, aYmin, aZmin);
480   typename BVH_Box<T, 3>::BVH_VecNt aMax (aXmax, aYmax, aZmax);
481   BVH_Box<T, 3> aBBox (aMin, aMax);
482
483   Apply (theCamera, theProjection, theWorldView, theViewportWidth, theViewportHeight, aBBox);
484
485   theBoundingBox = Bnd_Box();
486   theBoundingBox.Update (aBBox.CornerMin().x(), aBBox.CornerMin().y(), aBBox.CornerMin().z(),
487                          aBBox.CornerMax().x(), aBBox.CornerMax().y(), aBBox.CornerMax().z());
488 }
489
490 // =======================================================================
491 // function : Apply
492 // purpose  : Apply transformation to bounding box of presentation.
493 // =======================================================================
494 template<class T>
495 void Graphic3d_TransformPers::Apply (const Handle(Graphic3d_Camera)& theCamera,
496                                      const NCollection_Mat4<T>& theProjection,
497                                      const NCollection_Mat4<T>& theWorldView,
498                                      const Standard_Integer theViewportWidth,
499                                      const Standard_Integer theViewportHeight,
500                                      BVH_Box<T, 3>& theBoundingBox) const
501 {
502   NCollection_Mat4<T> aTPers = Compute (theCamera, theProjection, theWorldView, theViewportWidth, theViewportHeight);
503   if (aTPers.IsIdentity()
504   || !theBoundingBox.IsValid())
505   {
506     return;
507   }
508
509   const typename BVH_Box<T, 3>::BVH_VecNt& aMin = theBoundingBox.CornerMin();
510   const typename BVH_Box<T, 3>::BVH_VecNt& aMax = theBoundingBox.CornerMax();
511
512   typename BVH_Box<T, 4>::BVH_VecNt anArrayOfCorners[8];
513   anArrayOfCorners[0] = typename BVH_Box<T, 4>::BVH_VecNt (aMin.x(), aMin.y(), aMin.z(), static_cast<T> (1.0));
514   anArrayOfCorners[1] = typename BVH_Box<T, 4>::BVH_VecNt (aMin.x(), aMin.y(), aMax.z(), static_cast<T> (1.0));
515   anArrayOfCorners[2] = typename BVH_Box<T, 4>::BVH_VecNt (aMin.x(), aMax.y(), aMin.z(), static_cast<T> (1.0));
516   anArrayOfCorners[3] = typename BVH_Box<T, 4>::BVH_VecNt (aMin.x(), aMax.y(), aMax.z(), static_cast<T> (1.0));
517   anArrayOfCorners[4] = typename BVH_Box<T, 4>::BVH_VecNt (aMax.x(), aMin.y(), aMin.z(), static_cast<T> (1.0));
518   anArrayOfCorners[5] = typename BVH_Box<T, 4>::BVH_VecNt (aMax.x(), aMin.y(), aMax.z(), static_cast<T> (1.0));
519   anArrayOfCorners[6] = typename BVH_Box<T, 4>::BVH_VecNt (aMax.x(), aMax.y(), aMin.z(), static_cast<T> (1.0));
520   anArrayOfCorners[7] = typename BVH_Box<T, 4>::BVH_VecNt (aMax.x(), aMax.y(), aMax.z(), static_cast<T> (1.0));
521
522   theBoundingBox.Clear();
523   for (Standard_Integer anIt = 0; anIt < 8; ++anIt)
524   {
525     typename BVH_Box<T, 4>::BVH_VecNt& aCorner = anArrayOfCorners[anIt];
526     aCorner  = aTPers * aCorner;
527     aCorner = aCorner / aCorner.w();
528     theBoundingBox.Add (typename BVH_Box<T, 3>::BVH_VecNt (aCorner.x(), aCorner.y(), aCorner.z()));
529   }
530 }
531
532 // =======================================================================
533 // function : Compute
534 // purpose  : Compute transformation.
535 // =======================================================================
536 template<class T>
537 NCollection_Mat4<T> Graphic3d_TransformPers::Compute (const Handle(Graphic3d_Camera)& theCamera,
538                                                       const NCollection_Mat4<T>& theProjection,
539                                                       const NCollection_Mat4<T>& theWorldView,
540                                                       const Standard_Integer theViewportWidth,
541                                                       const Standard_Integer theViewportHeight) const
542 {
543   if (myMode == Graphic3d_TMF_None)
544   {
545     return NCollection_Mat4<T>();
546   }
547
548   NCollection_Mat4<T> aWorldView (theWorldView);
549   NCollection_Mat4<T> anUnviewMat;
550   if (!theWorldView.Inverted (anUnviewMat))
551   {
552     return NCollection_Mat4<T>();
553   }
554
555   // compute only world-view matrix difference to avoid floating point instability
556   // caused by projection matrix modifications outside of this algorithm (e.g. by Z-fit)
557   Apply (theCamera, theProjection, aWorldView, theViewportWidth, theViewportHeight);
558   return anUnviewMat * aWorldView;
559 }
560
561 #endif // _Graphic3d_TransformPers_HeaderFile