0032183: Visualization - implement AIS_LightSource::ProcessDragging() for rotating...
[occt.git] / src / AIS / AIS_LightSource.hxx
1 // Created on: 2020-09-07
2 // Created by: Maria KRYLOVA
3 // Copyright (c) 2020 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 _AIS_LightSource_HeaderFile
17 #define _AIS_LightSource_HeaderFile
18
19 #include <AIS_InteractiveObject.hxx>
20 #include <Graphic3d_CLight.hxx>
21 #include <SelectMgr_EntityOwner.hxx>
22
23 class Prs3d_ShadingAspect;
24 class Select3D_SensitiveSphere;
25
26 //! Interactive object for a light source.
27 //! Each type of light source has it's own presentation:
28 //! - Ambient light is displayed as a sphere at view corner;
29 //! - Positional light is represented by a sphere or marker;
30 //! - Spot light is represented by a cone;
31 //! - Directional light is represented by a set of arrows at the corner of view.
32 //! In addition, light source name could be displayed, and clicking on presentation will enable/disable light.
33 class AIS_LightSource : public AIS_InteractiveObject
34 {
35   friend class AIS_LightSourceOwner;
36   DEFINE_STANDARD_RTTIEXT(AIS_LightSource, AIS_InteractiveObject)
37 public:
38
39   //! Initializes the light source by copying Graphic3d_CLight settings.
40   Standard_EXPORT AIS_LightSource (const Handle(Graphic3d_CLight)& theLightSource);
41
42   //! Returns the light.
43   const Handle(Graphic3d_CLight)& Light() const { return myLightSource; }
44
45   //! Set the light.
46   void SetLight (const Handle(Graphic3d_CLight)& theLight)
47   {
48     myLightSource = theLight;
49     SetToUpdate();
50   }
51
52 public: //! @name Light properties
53
54   //! Returns TRUE if the light source name should be displayed; TRUE by default.
55   Standard_Boolean ToDisplayName() const { return myToDisplayName; }
56
57   //! Show/hide light source name.
58   void SetDisplayName(Standard_Boolean theToDisplay)
59   {
60     if (myToDisplayName != theToDisplay)
61     {
62       myToDisplayName = theToDisplay;
63       SetToUpdate();
64     }
65   }
66
67   //! Returns TRUE to display light source range as sphere (positional light) or cone (spot light); TRUE by default.
68   //! Has no effect for non-zoomable presentation.
69   Standard_Boolean ToDisplayRange() const { return myToDisplayRange; }
70
71   //! Show/hide light source range shaded presentation.
72   void SetDisplayRange (Standard_Boolean theToDisplay)
73   {
74     if (myToDisplayRange != theToDisplay)
75     {
76       myToDisplayRange = theToDisplay;
77       SetToUpdate();
78     }
79   }
80
81   //! Returns the size of presentation; 50 by default.
82   Standard_Real Size() const { return mySize; }
83
84   //! Sets the size of presentation.
85   void SetSize (Standard_Real theSize)
86   {
87     if (mySize != theSize)
88     {
89       mySize = theSize;
90       SetToUpdate();
91     }
92   }
93
94   //! Returns Sensitive sphere arc size in pixels; 20 by default.
95   Standard_Integer ArcSize() const { return mySensSphereArcSize; }
96
97   //! Sets the size of sensitive sphere arc.
98   void SetArcSize (Standard_Integer theSize)
99   {
100     if (mySensSphereArcSize != theSize)
101     {
102       mySensSphereArcSize = theSize;
103       SetToUpdate();
104     }
105   }
106
107   //! Returns TRUE if transform-persistence is allowed;
108   //! TRUE by default for Ambient and Directional lights
109   //! and FALSE by default for Positional and Spot lights.
110   bool IsZoomable() const { return myIsZoomable; }
111
112   //! Sets if transform-persistence is allowed.
113   void SetZoomable (bool theIsZoomable)
114   {
115     if (myIsZoomable != theIsZoomable)
116     {
117       myIsZoomable = theIsZoomable;
118       SetToUpdate();
119     }
120   }
121
122   //! Sets if dragging is allowed.
123   void SetDraggable (bool theIsDraggable)
124   {
125     if (myIsDraggable != theIsDraggable)
126     {
127       myIsDraggable = theIsDraggable;
128     }
129   }
130
131   //! Returns TRUE if mouse click will turn light on/off; TRUE by default.
132   bool ToSwitchOnClick() const { return myToSwitchOnClick; }
133
134   //! Sets if mouse click should turn light on/off.
135   void SetSwitchOnClick (bool theToHandle) { myToSwitchOnClick = theToHandle; }
136
137   //! Returns a number of directional light arrows to display; 5 by default.
138   Standard_Integer NbArrows() const { return myNbArrows; }
139
140   //! Returns a number of directional light arrows to display (supported values: 1, 3, 5, 9).
141   void SetNbArrows (Standard_Integer theNbArrows)
142   {
143     if (myNbArrows != theNbArrows)
144     {
145       myNbArrows = theNbArrows;
146       SetToUpdate();
147     }
148   }
149
150   //! Returns light source icon.
151   //! @param theIsEnabled [in] marker index for enabled/disabled light source states
152   const Handle(Graphic3d_MarkerImage)& MarkerImage (bool theIsEnabled) const { return myMarkerImages[theIsEnabled ? 1 : 0]; }
153
154   //! Returns light source icon.
155   //! @param theIsEnabled [in] marker index for enabled/disabled light source states
156   Aspect_TypeOfMarker MarkerType (bool theIsEnabled) const { return myMarkerTypes[theIsEnabled ? 1 : 0]; }
157
158   //! Sets custom icon to light source.
159   void SetMarkerImage (const Handle(Graphic3d_MarkerImage)& theImage,
160                        bool theIsEnabled)
161   {
162     myMarkerImages[theIsEnabled ? 1 : 0] = theImage;
163     myMarkerTypes [theIsEnabled ? 1 : 0] = !theImage.IsNull()
164                                          ? Aspect_TOM_USERDEFINED
165                                          : (theIsEnabled ? Aspect_TOM_O_POINT : Aspect_TOM_O_X);
166   }
167
168   //! Sets standard icon to light source.
169   void SetMarkerType (Aspect_TypeOfMarker theType,
170                       bool theIsEnabled)
171   {
172     myMarkerTypes[theIsEnabled ? 1 : 0] = theType;
173   }
174
175   //! Returns tessellation level for quadric surfaces; 30 by default.
176   Standard_Integer NbSplitsQuadric() const { return myNbSplitsQuadric; }
177
178   //! Sets tessellation level for quadric surfaces.
179   void SetNbSplitsQuadric (Standard_Integer theNbSplits) { myNbSplitsQuadric = theNbSplits; }
180
181   //! Returns tessellation level for arrows; 20 by default.
182   Standard_Integer NbSplitsArrow() const { return myNbSplitsArrow; }
183
184   //! Sets tessellation level for arrows.
185   void SetNbSplitsArrow (Standard_Integer theNbSplits) { myNbSplitsArrow = theNbSplits; }
186
187   //! Returns kind of the object.
188   virtual AIS_KindOfInteractive Type() const Standard_OVERRIDE { return AIS_KindOfInteractive_LightSource; }
189
190 protected:
191
192   //! Return true if specified display mode is supported: 0 for main presentation and 1 for highlight.
193   virtual Standard_Boolean AcceptDisplayMode (const Standard_Integer theMode) const Standard_OVERRIDE
194   {
195     return theMode == 0
196         || theMode == 1;
197   }
198
199   //! Computes selection sensitive zones(triangulation) for light source presentation.
200   Standard_EXPORT virtual void Compute (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
201                                         const Handle(Prs3d_Presentation)& thePrs,
202                                         const Standard_Integer theMode) Standard_OVERRIDE;
203
204   //! Fills presentation.
205   Standard_EXPORT virtual void ComputeSelection (const Handle(SelectMgr_Selection)& theSel,
206                                                  const Standard_Integer theMode) Standard_OVERRIDE;
207
208   //! Drag object in the viewer.
209   //! @param[in] theCtx      interactive context
210   //! @param[in] theView     active View
211   //! @param[in] theOwner    the owner of detected entity
212   //! @param[in] theDragFrom drag start point
213   //! @param[in] theDragTo   drag end point
214   //! @param[in] theAction   drag action
215   //! @return FALSE if object rejects dragging action (e.g. AIS_DragAction_Start)
216   Standard_EXPORT virtual Standard_Boolean ProcessDragging (const Handle(AIS_InteractiveContext)& theCtx,
217                                                             const Handle(V3d_View)& theView,
218                                                             const Handle(SelectMgr_EntityOwner)& theOwner,
219                                                             const Graphic3d_Vec2i& theDragFrom,
220                                                             const Graphic3d_Vec2i& theDragTo,
221                                                             const AIS_DragAction theAction) Standard_OVERRIDE;
222
223   //! Sets new local transformation, which is propagated to Graphic3d_CLight instance.
224   Standard_EXPORT virtual void setLocalTransformation (const Handle(TopLoc_Datum3D)& theTrsf) Standard_OVERRIDE;
225
226   //! Updates local transformation basing on a type of light source.
227   Standard_EXPORT virtual void updateLightLocalTransformation();
228
229   //! Updates transform persistence basing on a type of light source.
230   Standard_EXPORT virtual void updateLightTransformPersistence();
231
232   //! Sets color of light.
233   Standard_EXPORT virtual void updateLightAspects();
234
235   //! Compute ambient light source presentation as a sphere at view corner.
236   Standard_EXPORT virtual void computeAmbient (const Handle(Prs3d_Presentation)& thePrs,
237                                                const Standard_Integer theMode);
238
239   //! Compute directional light source presentation as a set of arrows at view corner.
240   Standard_EXPORT virtual void computeDirectional (const Handle(Prs3d_Presentation)& thePrs,
241                                                    const Standard_Integer theMode);
242
243   //! Compute positional light source presentation as a sphere of either fixed size (no range) or of size representing a maximum range.
244   Standard_EXPORT virtual void computePositional (const Handle(Prs3d_Presentation)& thePrs,
245                                                   const Standard_Integer theMode);
246
247   //! Compute spot light source presentation as a cone.
248   Standard_EXPORT virtual void computeSpot (const Handle(Prs3d_Presentation)& thePrs,
249                                             const Standard_Integer theMode);
250
251 protected:
252
253   Handle(Graphic3d_CLight)         myLightSource;           //!< displayed light source
254
255   Handle(Graphic3d_AspectMarker3d) myDisabledMarkerAspect;  //!< disabled light source marker style
256   Handle(Graphic3d_AspectLine3d)   myArrowLineAspectShadow; //!< arrow shadow style
257   Handle(Graphic3d_MarkerImage)    myMarkerImages[2];       //!< icon of disabled (0) and enabled (1) light
258   Handle(Select3D_SensitiveSphere) mySensSphere;            //!< sensitive sphere of directional light source
259   Aspect_TypeOfMarker              myMarkerTypes[2];        //!< icon of disabled (0) and enabled (1) light
260   Aspect_TypeOfMarker              myCodirMarkerType;       //!< icon of arrow co-directional to camera direction (look from)
261   Aspect_TypeOfMarker              myOpposMarkerType;       //!< icon of arrow opposite to camera direction (look at)
262
263   Graphic3d_Vec2i  myStartTransform;    //!< position of starting transformation
264   gp_Trsf          myLocTrsfStart;      //!< object transformation before transformation
265   Standard_Real    mySize;              //!< presentation size
266   Standard_Integer myNbArrows;          //!< number of directional light arrows
267   Standard_Integer myNbSplitsQuadric;   //!< tessellation level for quadric surfaces
268   Standard_Integer myNbSplitsArrow;     //!< tessellation level for arrows
269   Standard_Integer mySensSphereArcSize; //! sensitive sphere arc size in pixels
270   Standard_Boolean myIsZoomable;        //!< flag to allow/disallow transform-persistence when possible
271   Standard_Boolean myIsDraggable;       //!< flag to allow/disallow rotate directional light source by dragging
272   Standard_Boolean myToDisplayName;     //!< flag to show/hide name
273   Standard_Boolean myToDisplayRange;    //!< flag to show/hide range of positional/spot light
274   Standard_Boolean myToSwitchOnClick;   //!< flag to handle mouse click to turn light on/off
275
276 };
277
278 //! Owner of AIS_LightSource presentation.
279 class AIS_LightSourceOwner : public SelectMgr_EntityOwner
280 {
281   DEFINE_STANDARD_RTTIEXT(AIS_LightSourceOwner, SelectMgr_EntityOwner)
282 public:
283
284   //! Main constructor.
285   Standard_EXPORT AIS_LightSourceOwner (const Handle(AIS_LightSource)& theObject,
286                                         Standard_Integer thePriority = 5);
287
288   //! Handle mouse button click event.
289   Standard_EXPORT virtual Standard_Boolean HandleMouseClick (const Graphic3d_Vec2i& thePoint,
290                                                              Aspect_VKeyMouse theButton,
291                                                              Aspect_VKeyFlags theModifiers,
292                                                              bool theIsDoubleClick) Standard_OVERRIDE;
293
294   //! Highlights selectable object's presentation with display mode in presentation manager with given highlight style.
295   //! Also a check for auto-highlight is performed - if selectable object manages highlighting on its own,
296   //! execution will be passed to SelectMgr_SelectableObject::HilightOwnerWithColor method.
297   Standard_EXPORT virtual void HilightWithColor (const Handle(PrsMgr_PresentationManager)& thePrsMgr,
298                                                  const Handle(Prs3d_Drawer)& theStyle,
299                                                  const Standard_Integer theMode) Standard_OVERRIDE;
300
301   //! Always update dynamic highlighting.
302   Standard_EXPORT virtual Standard_Boolean IsForcedHilight() const Standard_OVERRIDE;
303
304 };
305
306 #endif // _AIS_LightSource_HeaderFile