sprk_ops.h
1 // Copyright (c) Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 #ifndef SPRK_STD_OPERATORS_H
11 #define SPRK_STD_OPERATORS_H
12 
13 #include "sprk.h"
14 
15 #include <list>
16 #include <stack>
17 #include <unordered_map>
18 
19 namespace std
20 {
21  template<>
22  struct hash<HPS::RGBColor>
23  {
24  size_t operator()(HPS::RGBColor const & x) const
25  {
26  return (
27  (51 + std::hash<float>()(x.red)) * 51 + std::hash<float>()(x.green) * 51 + std::hash<float>()(x.blue));
28  }
29  };
30 }
31 
32 #ifdef _MSC_VER
33 #ifndef STATIC_APP
34 # ifdef SPRK_OPS
35 # define SPRK_OPS_API __declspec (dllexport)
36 # else
37 # define SPRK_OPS_API __declspec (dllimport)
38 # endif
39 #endif
40 #else
41 # include <stddef.h>
42 # if defined(LINUX_SYSTEM) && defined(SPRK_OPS)
43 # ifndef STATIC_APP
44 # define SPRK_OPS_API __attribute__ ((visibility ("default")))
45 # endif
46 # endif
47 #endif
48 
49 #ifndef SPRK_OPS_API
50 # define SPRK_OPS_API
51 #endif
52 
53 
54 namespace HPS
55 {
56 
68 class SPRK_OPS_API PanOrbitZoomOperator : public Operator
69 {
70 public:
71  PanOrbitZoomOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
73  virtual HPS::UTF8 GetName() const { return "HPS_PanOrbitZoomOperator"; }
74 
79  virtual bool OnMouseDown(MouseState const & in_state);
84  virtual bool OnMouseUp(MouseState const & in_state);
89  virtual bool OnMouseMove(MouseState const & in_state);
90 
95  virtual bool OnTouchDown(TouchState const & in_state);
100  virtual bool OnTouchUp(TouchState const & in_state);
105  virtual bool OnTouchMove(TouchState const & in_state);
106 
107 private:
108  HPS::WorldPoint start;
109 
110  HPS::WindowPoint start_point, new_point;
111  HPS::Vector start_sphere_pos, new_sphere_pos;
112 
113  bool operator_active;
114  float zoom_limit;
115  float focal_length;
116  HPS::WindowPoint last_zoom;
117  HPS::Vector last_relative;
118  float zoom_start_field_width;
119  float zoom_start_field_height;
120  HPS::Vector zoom_start_camera_look;
121  size_t current_touches;
122 
123  void ZoomStart();
124  void UpdateZoom(float zoom_factor);
125  void UpdateZoomLimit();
126  void UpdatePan(HPS::WorldPoint const & newLocation);
127  void UpdateRoll(HPS::Vector const & relative);
128 };
129 
137 class SPRK_OPS_API PanOperator : public Operator
138 {
139 public:
140  PanOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
142  virtual HPS::UTF8 GetName() const { return "HPS_PanOperator"; }
143 
148  virtual bool OnMouseDown(MouseState const & in_state);
153  virtual bool OnMouseUp(MouseState const & in_state);
158  virtual bool OnMouseMove(MouseState const & in_state);
159 
164  virtual bool OnTouchDown(TouchState const & in_state);
169  virtual bool OnTouchUp(TouchState const & in_state);
174  virtual bool OnTouchMove(TouchState const & in_state);
175 
176 private:
177  bool PanCommon(HPS::WindowPoint const & in_loc, HPS::KeyPath const & in_key_path);
178 
179  bool operator_active;
180  HPS::TouchID tracked_touch_ID;
181  HPS::WorldPoint start;
182 };
183 
191 class SPRK_OPS_API OrbitOperator : public Operator
192 {
193 public:
194  OrbitOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
196  virtual HPS::UTF8 GetName() const { return "HPS_OrbitOperator"; }
197 
202  virtual bool OnMouseDown(MouseState const & in_state);
207  virtual bool OnMouseUp(MouseState const & in_state);
212  virtual bool OnMouseMove(MouseState const & in_state);
213 
218  virtual bool OnTouchDown(TouchState const & in_state);
223  virtual bool OnTouchUp(TouchState const & in_state);
228  virtual bool OnTouchMove(TouchState const & in_state);
229 
230 private:
231  bool OrbitCommon(HPS::WindowPoint const & in_loc);
232 
233  bool operator_active;
234  HPS::TouchID tracked_touch_ID;
235  HPS::WindowPoint start_point, new_point;
236  HPS::Vector start_sphere_pos, new_sphere_pos;
237 };
238 
239 
240 class SPRK_OPS_API RelativeOrbitOperator : public Operator
241 {
242 
243 public:
250  RelativeOrbitOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonMiddle(), ModifierKeys in_modifier_trigger = ModifierKeys());
251  virtual HPS::UTF8 GetName() const { return "HPS_RelativeOrbitOperator"; }
252 
253  virtual bool OnMouseDown(MouseState const & in_state);
254  virtual bool OnMouseUp(MouseState const & in_state);
255  virtual bool OnMouseMove(MouseState const & in_state);
256 
257  virtual bool OnTouchDown(TouchState const & in_state);
258  virtual bool OnTouchUp(TouchState const & in_state);
259  virtual bool OnTouchMove(TouchState const & in_state);
260 
261 private:
262  bool OrbitCommon(HPS::WindowPoint const & in_loc);
263  bool RelativeOrbitCommon(HPS::WindowPoint const & in_loc, HPS::KeyPath & in_event_path);
264  void CalculateTarget(HPS::WindowKey const & in_window);
265 
266  HPS::Point faux_target;
267  bool operator_active;
268  HPS::TouchID tracked_touch_ID;
269  HPS::Vector start_sphere_pos, new_sphere_pos;
270  HPS::WindowPoint start_point, new_point;
271  HPS::SelectionOptionsKit selection_options;
272 };
273 
281 class SPRK_OPS_API ZoomOperator : public Operator
282 {
283 public:
284  ZoomOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
286  virtual HPS::UTF8 GetName() const { return "HPS_ZoomOperator"; }
287 
292  virtual bool OnMouseDown(MouseState const & in_state);
297  virtual bool OnMouseUp(MouseState const & in_state);
302  virtual bool OnMouseMove(MouseState const & in_state);
303 
308  virtual bool OnTouchDown(TouchState const & in_state);
313  virtual bool OnTouchMove(TouchState const & in_state);
314 
315 private:
316  bool operator_active;
317  HPS::TouchID tracked_touch_ID;
318  HPS::WindowPoint start_point;
319  float zoom_limit;
320  float focal_length;
321  HPS::WindowPoint last_zoom;
322  HPS::Vector last_relative;
323  float zoom_start_field_width;
324  float zoom_start_field_height;
325  HPS::Vector zoom_start_camera_look;
326  HPS::Point zoom_start_camera_target;
327 
328  void ZoomStart();
329  void UpdateZoom(float zoom_factor);
330  void UpdateZoomLimit();
331 };
332 
333 
334 class SPRK_OPS_API ConstructRectangleOperator : public Operator
335 {
336 public:
337  ConstructRectangleOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys(), bool draw_faces = false);
338  virtual HPS::UTF8 GetName() const { return "HPS_ConstructRectangleOperator"; }
339 
340  virtual void OnViewAttached();
341 
342  virtual bool OnMouseDown(MouseState const & in_state);
343  virtual bool OnMouseUp(MouseState const & in_state);
344  virtual bool OnMouseMove(MouseState const & in_state);
345 
346  virtual bool OnTouchDown(TouchState const & in_state);
347  virtual bool OnTouchUp(TouchState const & in_state);
348  virtual bool OnTouchMove(TouchState const & in_state);
349 
350  bool IsRectangleValid() const { return is_rect_valid; }
351 
353  HPS::Rectangle GetRectangle() const { return rect; }
354 
355 private:
356  bool ConstructRectCommon(WindowPoint const & in_loc);
357  void SetupConstructionSegment();
358 
359  bool draw_faces;
360  bool use_center_marker;
361  bool is_rect_valid;
362  bool operator_active;
363  HPS::WindowPoint start_point;
364  HPS::SegmentKey scratch_seg;
365  HPS::Rectangle rect;
366  HPS::LineKey temp_line_key;
367  HPS::PolygonKey temp_polygon_key;
368  HPS::MarkerKey temp_marker_key;
369  HPS::TouchID tracked_touch_ID;
370 };
371 
372 class SPRK_OPS_API ZoomBoxOperator : public ConstructRectangleOperator
373 {
374 public:
375  ZoomBoxOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
376  virtual HPS::UTF8 GetName() const { return "HPS_ZoomBoxOperator"; }
377 
378  virtual bool OnMouseUp(MouseState const & in_state);
379  virtual bool OnTouchUp(TouchState const & in_state);
380 
381 private:
382  bool ZoomCommon(HPS::WindowKey const & in_window, HPS::KeyPath const & in_event_path);
383 
384 };
385 
396 {
397 public:
410  SelectAreaOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
411 
412  virtual HPS::UTF8 GetName() const { return "HPS_SelectAreaOperator"; }
413 
414  virtual void OnViewAttached();
415 
416  virtual bool OnMouseUp(MouseState const & in_state);
417  virtual bool OnTouchUp(TouchState const & in_state);
418 
423  HPS::SelectionResults GetActiveSelection() const;
424 
430  void SetSelectionOptions(HPS::SelectionOptionsKit const & in_options) { selection_options = in_options; }
431 
435  HPS::SelectionOptionsKit GetSelectionOptions() const { return selection_options; }
436 
437 private:
438  bool SelectCommon(HPS::WindowKey & in_window, HPS::ModifierKeys in_modifiers = HPS::ModifierKeys());
439 
440  HPS::SelectionResults active_selection;
441  HPS::SelectionOptionsKit selection_options;
442 };
443 
444 
445 class SPRK_OPS_API HighlightAreaOperator : public SelectAreaOperator
446 {
447 public:
454  HighlightAreaOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
455 
456  virtual HPS::UTF8 GetName() const { return "HPS_HighlightAreaOperator"; }
457 
458  virtual void OnViewAttached();
459 
460  virtual bool OnMouseUp(MouseState const & in_state);
461  virtual bool OnTouchUp(TouchState const & in_state);
462 
468  void SetHighlightOptions(HPS::HighlightOptionsKit const & in_options) { highlight_options = in_options; }
469 
473  HPS::HighlightOptionsKit GetHighlightOptions() const { return highlight_options; }
474 
475 private:
476  bool HighlightCommon(WindowKey & in_window, ModifierKeys in_modifiers);
477 
478  HPS::HighlightOptionsKit highlight_options;
479 
480 };
481 
482 
492 class SPRK_OPS_API SelectOperator : public Operator
493 {
494 public:
507  SelectOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
508 
509  virtual HPS::UTF8 GetName() const { return "HPS_SelectOperator"; }
510 
511  virtual bool OnMouseDown(MouseState const & in_state);
512  virtual bool OnTouchDown(TouchState const & in_state);
513 
518  HPS::SelectionResults GetActiveSelection() const;
519 
523  void SetSelectionOptions(HPS::SelectionOptionsKit const & in_options) { selection_options = in_options; }
524 
528  HPS::SelectionOptionsKit GetSelectionOptions() const { return selection_options; }
529 
530 private:
531  bool SelectCommon(HPS::Point const & in_loc, HPS::WindowKey & in_window, HPS::ModifierKeys in_modifiers = HPS::ModifierKeys());
532 
533  HPS::SelectionResults active_selection;
534  HPS::SelectionOptionsKit selection_options;
535 };
536 
537 
538 class SPRK_OPS_API HighlightOperator : public SelectOperator
539 {
540 public:
545  HighlightOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
546 
547  virtual HPS::UTF8 GetName() const { return "HPS_HighlightOperator"; }
548 
549  virtual bool OnMouseDown(MouseState const & in_state);
550  virtual bool OnTouchDown(TouchState const & in_state);
551 
555  void SetHighlightOptions(HPS::HighlightOptionsKit const & in_options) { highlight_options = in_options; }
556 
560  HPS::HighlightOptionsKit GetHighlightOptions() const { return highlight_options; }
561 
562 private:
563  bool HighlightCommon(HPS::WindowKey & in_window, HPS::ModifierKeys in_modifiers);
564 
565  HPS::HighlightOptionsKit highlight_options;
566 };
567 
568 class SPRK_OPS_API MouseWheelOperator : public Operator
569 {
570 public:
571  enum class ZoomType
572  {
573  Fast,
574  Accurate,
575  };
576 
581  MouseWheelOperator(ZoomType in_default_type = ZoomType::Accurate, HPS::ModifierKeys in_alternate_type_modifiers = HPS::ModifierKeys::KeyControl());
582 
583  virtual HPS::UTF8 GetName() const { return "HPS_MouseWheelOperator"; }
584 
586  void UpdateZoomLimit();
587 
588  virtual bool OnMouseWheel(HPS::MouseState const & in_state);
589 
590  virtual void OnModelAttached();
591 
592  virtual void OnViewAttached();
593 
594 private:
595  float zoom_limit;
596  ZoomType zoom_type;
597  HPS::ModifierKeys zoom_modifier;
598 };
599 
611 class SPRK_OPS_API TurntableOperator : public Operator
612 {
613 public:
614  TurntableOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
616  virtual HPS::UTF8 GetName() const { return "HPS_TurntableOperator"; }
617 
623  virtual bool OnMouseDown(MouseState const & in_state);
628  virtual bool OnMouseUp(MouseState const & in_state);
633  virtual bool OnMouseMove(MouseState const & in_state);
638  virtual bool OnMouseWheel(MouseState const & in_state);
639 
645  virtual bool OnTouchDown(TouchState const & in_state);
650  virtual bool OnTouchUp(TouchState const & in_state);
656  virtual bool OnTouchMove(TouchState const & in_state);
657 
658 private:
659  void TurntableCommon(HPS::WindowPoint const & delta, HPS::Vector const & rotation_axis);
660  void CalculateCenterPoint(HPS::WindowKey const & window, HPS::Point const & location);
661 
662  bool operator_active;
663  bool center_point_set;
664  HPS::WorldPoint center_point;
665  HPS::TouchID tracked_touch_ID;
666  HPS::WindowPoint start_point;
667  HPS::SelectionOptionsKit selection_options;
668 };
669 
675 class SPRK_OPS_API ZoomFitTouchOperator : public Operator
676 {
677 public:
680  virtual HPS::UTF8 GetName() const { return "HPS_ZoomFitTouchOperator"; }
681 
686  virtual bool OnTouchDown(TouchState const & in_state);
691  virtual bool OnTouchUp(TouchState const & in_state);
692 
693 private:
694  HPS::TouchID tracked_touch_ID;
695 };
696 
719 class SPRK_OPS_API FlyOperator : public Operator
720 {
721 public:
722  FlyOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonRight(), ModifierKeys in_modifier_trigger = ModifierKeys());
724  virtual HPS::UTF8 GetName() const { return "HPS_FlyOperator"; }
725 
740  virtual bool OnKeyDown(KeyboardState const & in_state);
744  virtual bool OnKeyUp(KeyboardState const & in_state);
745 
750  virtual bool OnMouseDown(MouseState const & in_state);
754  virtual bool OnMouseUp(MouseState const & in_state);
759  virtual bool OnMouseMove(MouseState const & in_state);
765  virtual bool OnMouseWheel(MouseState const & in_state);
766 
771  virtual bool OnTouchDown(TouchState const & in_state);
775  virtual bool OnTouchUp(TouchState const & in_state);
780  virtual bool OnTouchMove(TouchState const & in_state);
781 
786  virtual bool OnTimerTick(HPS::TimerTickEvent const & in_event);
787 
788  virtual void OnModelAttached();
789  virtual void OnViewAttached();
790  virtual void OnViewDetached();
791 
792  /* getters/setters for inverting the X and Y axis */
793  void InvertXAxis() { invert_x_axis = !invert_x_axis;}
794  void InvertYAxis() { invert_y_axis = !invert_y_axis;}
795  bool IsXAxisInverted() { return invert_x_axis; }
796  bool IsYAxisInverted() { return invert_y_axis; }
797 
798  /* getters/setters for sensitivity */
799  /* Keyboard sensitivity affects the speed of movement of action triggered from the keyboard, such as walking forward by pressing W */
800  float GetKeyboardSensitivity() { return keyboard_sensitivity; }
801  void SetKeyboardSensitivity(float in_keyboard_sensitivity) { keyboard_sensitivity = in_keyboard_sensitivity; }
802 
803  /* Mouse sensitivity affects the speed of movement of action triggered from the mouse, such as rotating */
804  float GetMouseSensitivity() { return mouse_sensitivity; }
805  void SetMouseSensitivity(float in_mouse_sensitivity) { mouse_sensitivity = in_mouse_sensitivity; }
806 
807  /* Left Joystick sensitivity affects the speed of movement of action triggered from the left joystick on touch devices */
808  float GetLeftJoystickSensitivity() { return left_joystick_sensitivity; }
809  void SetLeftJoystickSensitivity(float in_left_joystick_sensitivity) { left_joystick_sensitivity = in_left_joystick_sensitivity; }
810 
811  /* Right Joystick sensitivity affects the speed of movement of action triggered from the right joystick on touch devices */
812  float GetRightJoystickSensitivity() { return right_joystick_sensitivity; }
813  void SetRightJoystickSensitivity(float in_right_joystick_sensitivity) { right_joystick_sensitivity = in_right_joystick_sensitivity; }
814 
815  /* getters/setters for joystick dead zone
816  The dead zone is an area around the initial touch down position where the user can move its finger
817  without triggering any movement.
818  The default value is 0.07. */
819  float GetJoystickDeadZone() { return joystick_dead_zone; }
820  void SetJoystickDeadZone(float in_dead_zone) { joystick_dead_zone = in_dead_zone; }
821 
822 protected:
823 
824  enum MovementFlags
825  {
826  no_movement = 0x0000,
827  moving_forward = 0x0001,
828  moving_back = 0x0002,
829  moving_left = 0x0004,
830  moving_right = 0x0008,
831  moving_up = 0x0010,
832  moving_down = 0x0020,
833  roll_left = 0x0040,
834  roll_right = 0x0080,
835  rotating = 0x0100,
836  move_with_touch = 0x0200,
837  rotate_with_touch = 0x0400
838  };
839 
840  unsigned int movement_flags;
841 
842  //movement functions
843  void MoveLeft(HPS::Point & position, HPS::Point & target, HPS::Vector & up);
844  void MoveRight(HPS::Point & position, HPS::Point & target, HPS::Vector & up);
845  void MoveUp(HPS::Point & position, HPS::Point & target, HPS::Vector & up);
846  void MoveDown(HPS::Point & position, HPS::Point & target, HPS::Vector & up);
847  void MoveForward(HPS::Point & position, HPS::Point & target, HPS::Vector const & direction);
848  void MoveBack(HPS::Point & position, HPS::Point & target, HPS::Vector const & direction);
849  void MoveWithTouch(HPS::Point & position, HPS::Point & target, HPS::Vector & up, HPS::Vector const & walking_direction);
850  void RotateScene(HPS::Point & position, HPS::Point & target);
851  void RotateWithTouch(HPS::Point & position, HPS::Point & target);
852  void RotateCommon(HPS::Point const & delta, HPS::Point & position, HPS::Point & target);
853 
854 private:
855 
856  enum class TouchPosition
857  {
858  Left,
859  Right,
860  None
861  };
862 
863  //touch IDs tracked by the operator
864  HPS::TouchID left_side_touch;
865  HPS::TouchID right_side_touch;
866  HPS::TouchID second_right_touch;
867 
868  //current and start location for touch operations
869  HPS::WindowPoint start_point;
870  HPS::WindowPoint left_start_point;
871  HPS::WindowPoint right_start_point;
872  HPS::WindowPoint current_right_touch_position;
873  HPS::WindowPoint second_right_start_point;
874  HPS::WindowPoint current_second_right_touch_position;
875  HPS::WindowPoint start_mid_point;
876 
877  //virtual joystick information
878  HPS::SegmentKey left_joystick_segment;
879  HPS::SegmentKey right_joystick_segment;
880  float joystick_dead_zone;
881 
882  //step length for left touch, right touch, and desktop operation
883  float keyboard_sensitivity;
884  float old_keyboard_sensitivity;
885  float left_joystick_sensitivity;
886  float old_left_joystick_sensitivity;
887  float right_joystick_sensitivity;
888  float old_right_joystick_sensitivity;
889  float mouse_sensitivity;
890 
891  //operator state flags
892  bool two_right_fingers_down;
893  bool invert_x_axis;
894  bool invert_y_axis;
895  Drawing::Handedness world_handedness;
896  bool shift_pressed;
897  bool ctrl_pressed;
898  HPS::KeyPath event_path;
899  HPS::WindowPoint rotation_location;
900  HPS::WindowPoint moving_position;
901 
902  //utility functions
903  void UpdateKeyboardState(KeyboardState const & in_state);
904  void ComputeReasonableStepLength();
905  void CreateJoystick(HPS::TouchState const & in_state, TouchPosition touch_position);
906 };
907 
939 class SPRK_OPS_API WalkOperator : public FlyOperator
940 {
941 public:
942  WalkOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonRight(), ModifierKeys in_modifier_trigger = ModifierKeys());
943 
945  virtual HPS::UTF8 GetName() const { return "HPS_WalkOperator"; }
946 
947  virtual void OnViewAttached();
948  virtual void OnModelAttached();
949 
954  virtual bool OnTimerTick(HPS::TimerTickEvent const & in_event);
955 
956  /* Getters / Setters for the plane the operator walks on. */
957  void SetGroundPlane(HPS::Plane const & in_plane) { ground = in_plane; }
958  HPS::Plane GetGroundPlane() { return ground; }
959 
960  /* Getters / Setters for camera vertical offset from the ground plane */
961  void SetWalkerHeight(float height) { height_off_ground = height; }
962  float GetWalkerHeight() { return height_off_ground; }
963 
964 private:
965  HPS::Plane ground;
966  HPS::Vector walking_direction;
967  float height_off_ground;
968 
969  void CalculateGroundPlane();
970  void SnapToPlane();
971  void AdjustWalkingDirection(HPS::Vector const & camera_direction, HPS::Vector const & camera_up);
972 };
973 
983 class SPRK_OPS_API SimpleWalkOperator : public WalkOperator
984 {
985 public:
986  SimpleWalkOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
987 
989  virtual HPS::UTF8 GetName() const { return "HPS_SimpleWalkOperator"; }
990 
994  virtual bool OnKeyDown(KeyboardState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
998  virtual bool OnKeyUp(KeyboardState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1003  virtual bool OnMouseWheel(MouseState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1004 
1009  virtual bool OnMouseDown(MouseState const & in_state);
1014  virtual bool OnMouseMove(MouseState const & in_state);
1018  virtual bool OnMouseUp(MouseState const & in_state);
1019 
1024  virtual bool OnTouchDown(TouchState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1029  virtual bool OnTouchMove(TouchState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1033  virtual bool OnTouchUp(TouchState const & in_state) { HPS_UNREFERENCED(in_state); return false; }
1034 
1039  virtual bool OnTimerTick(HPS::TimerTickEvent const & in_event);
1040 
1041 private:
1042  void MoveWithMouse(HPS::Point & position, HPS::Point & target);
1043 
1044  HPS::KeyPath event_path;
1045  HPS::WindowPoint rotation_location;
1046  HPS::WindowPoint start_point;
1047  bool moving;
1048 };
1049 
1050 
1108 class SPRK_OPS_API CuttingSectionOperator : public SelectOperator
1109 {
1110 private:
1111  enum class OpState
1112  {
1113  Uninitialized,
1114  Initialized,
1115  Translating,
1116  FacePicking,
1117  };
1118 
1119 public:
1120  CuttingSectionOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
1121 
1123  virtual HPS::UTF8 GetName() const { return "HPS_CuttingSectionOperator"; }
1124 
1125  virtual void OnModelAttached();
1126  virtual void OnViewAttached();
1127  virtual void OnViewDetached();
1128 
1129  /* This function programmatically assigns cutting planes to this operator from plane equations.
1130  * If this operator has already had cutting planes associated with it, the cutting planes set using
1131  * this function replace the previous cutting planes.
1132  * \param in_planes An array of Plane objects describing the cutting planes to be inserted. */
1133  void SetPlanes(PlaneArray const & in_planes);
1134 
1135  /* This function returns the planes associated with the active cutting sections
1136  * \return planes associated with the active cutting sections. */
1137  PlaneArray GetPlanes();
1138 
1144  virtual bool OnMouseDown(MouseState const & in_state);
1145 
1149  virtual bool OnMouseUp(MouseState const & in_state);
1150 
1156  virtual bool OnMouseMove(MouseState const & in_state);
1157 
1163  virtual bool OnTouchDown(TouchState const & in_state);
1164 
1168  virtual bool OnTouchUp(TouchState const & in_state);
1169 
1174  virtual bool OnTouchMove(TouchState const & in_state);
1175 
1180  virtual bool OnTimerTick(TimerTickEvent const & in_event);
1181 
1184  float GetIndicatorScale() const { return indicator_scale; }
1185 
1188  void SetIndicatorScale(float in_scale) { indicator_scale = in_scale; }
1189 
1192  MaterialMappingKit GetPlaneMaterial() const { return plane_material; }
1193 
1196  void SetPlaneMaterial(MaterialMappingKit const & in_plane_material);
1197 
1200  HighlightOptionsKit GetPlaneHighlightOptions() const { return highlight_options; }
1201 
1204  void SetPlaneHighlightOptions(HighlightOptionsKit const & in_highlight_options) { highlight_options = in_highlight_options; }
1205 
1208  bool GetMouseOverHighlighting() const { return enable_mouse_over_highlighting; }
1209 
1212  void SetMouseOverHighlighting(bool in_enable_mouse_over_highlighting) { enable_mouse_over_highlighting = in_enable_mouse_over_highlighting; }
1213 
1217  void SetSectioning(bool in_sectioning);
1218 
1221  bool GetSectioning() { return sectioning; }
1222 
1226  void SetIndicatorVisibility(bool in_use_indicator);
1227 
1230  bool GetIndicatorVisibility() { return (op_state == OpState::Uninitialized || op_state == OpState::FacePicking) ? true : false; }
1231 
1235  void SetPlaneVisibility(bool in_visibility);
1236 
1239  bool GetPlaneVisibility();
1240 
1241 private:
1242 
1243  void SetupOperatorSegment();
1244  void InsertNormalIndicator(float scale);
1245  ShellKey InsertCuttingPlaneGeometry();
1246  void MouseOverHighlighting(MouseState const & in_state);
1247  void TranslateCuttingPlane(KeyPath const & in_event_path, WindowPoint const & in_event_location);
1248  bool HandleMouseAndTouchDown(WindowKey const & in_event_source, int in_number_of_clicks,
1249  KeyPath const & in_event_path, WindowPoint const & in_event_location);
1250  void ViewAlignSectionPlanes(HPS::PlaneArray & in_out_planes) const;
1251  typedef std::pair<CuttingSectionKey, std::vector<ShellKey>> SectionInfo;
1252  typedef std::vector<SectionInfo> SectionArray;
1253  SectionArray sections;
1254 
1255  SegmentKey operator_root_segment;
1256  SegmentKey cutting_sections_segment;
1257  SegmentKey plane_representation_segment;
1258  bool sectioning;
1259 
1260  CuttingSectionKey translating_section;
1261  size_t translating_plane_offset;
1262  ShellKey translating_plane_representation;
1263 
1264  TouchID tracked_touch_ID;
1265  MaterialMappingKit plane_material;
1266  SegmentKey indicator_seg;
1267  OpState op_state;
1268  WorldPoint start_world_point;
1269  SelectionOptionsKit selection_options;
1270  SelectionOptionsKit mouse_over_selection_options;
1271  float indicator_scale;
1272  Vector plane_normal;
1273  bool plane_normal_valid;
1274  WorldPoint anchor_point;
1275  SimpleCuboid model_bounding;
1276 
1277  UpdateNotifier last_highlight_notifier;
1278  bool last_skipped_highlight_state_valid;
1279  MouseState last_skipped_highlight_state;
1280  bool is_plane_highlighted;
1281  PortfolioKey portfolio;
1282  SegmentKey style_segment;
1283  HighlightOptionsKit highlight_options;
1284  bool enable_mouse_over_highlighting;
1285  bool skip_mouse_overs;
1286 
1287  View attached_view;
1288  KeyArray navigation_keys;
1289 };
1290 
1326 class SPRK_OPS_API MarkupOperator : public Operator
1327 {
1328 public:
1329  enum class MarkupType
1330  {
1331  Freehand,
1332  Text,
1333  Circle,
1334  Rectangle,
1335  };
1336 
1337  MarkupOperator(MouseButtons in_mouse_trigger = MouseButtons::ButtonLeft(), ModifierKeys in_modifier_trigger = ModifierKeys());
1338 
1340  virtual HPS::UTF8 GetName() const OVERRIDE { return "HPS_MarkupOperator"; }
1341 
1342  virtual void OnViewAttached() OVERRIDE;
1343  virtual void OnViewDetached() OVERRIDE;
1344 
1349  virtual bool OnMouseDown(MouseState const & in_state) OVERRIDE;
1350 
1354  virtual bool OnMouseUp(MouseState const & in_state) OVERRIDE;
1355 
1362  virtual bool OnMouseMove(MouseState const & in_state) OVERRIDE;
1363 
1364 
1369  virtual bool OnTouchDown(TouchState const & in_state) OVERRIDE;
1370 
1374  virtual bool OnTouchUp(TouchState const & in_state) OVERRIDE;
1375 
1382  virtual bool OnTouchMove(TouchState const & in_state) OVERRIDE;
1383 
1389  virtual bool OnKeyDown(KeyboardState const & in_state) OVERRIDE;
1390 
1396  virtual bool OnTextInput(HPS::UTF8 const & in_text) OVERRIDE;
1397 
1399  MarkupType GetMarkupType() { return markup_type; }
1400 
1402  void SetMarkupType(MarkupType in_markup_type) { markup_type = in_markup_type; }
1403 
1406  RGBColor GetColor() { return current_attributes.color; }
1407 
1409  void SetColor(RGBColor const & in_color) { current_attributes.color = in_color; }
1410 
1413  TextAttributeKit GetTextAttributes() { return current_attributes.text_attributes; }
1414 
1416  void SetTextAttribute(TextAttributeKit const & in_text_attributes) { current_attributes.text_attributes = in_text_attributes; }
1417 
1420  LineAttributeKit GetLineAttributes() { return current_attributes.line_attributes; }
1421 
1423  void SetLineAttribute(LineAttributeKit const & in_line_attributes) {current_attributes.line_attributes = in_line_attributes; }
1424 
1428  SegmentKey GetSegmentKey() { return markup_segment; }
1429 
1431  void DeleteMarkups();
1432 
1433  /* Whether a markup is currently being inserted.
1434  * \return <span class='code'>true</span> if a markup is being inserted, <span class='code'>false</span> otherwise. */
1435  bool IsMarkupActive() { return operator_active; }
1436 
1437  class SPRK_OPS_API MarkupInsertedEvent : public HPS::Event
1438  {
1439  public:
1442  {
1443  channel = GetClassID();
1444  consumable = false;
1445  }
1446 
1447  MarkupInsertedEvent(HPS::Key const & in_markup_key, HPS::View const & in_view) : Event()
1448  {
1449  channel = GetClassID();
1450  consumable = false;
1451  markup_key = in_markup_key;
1452  view = in_view;
1453  }
1454 
1457  MarkupInsertedEvent(Event const & in_event) : Event(in_event)
1458  {
1459  if (in_event.GetChannel() == Object::ClassID<MarkupInsertedEvent>())
1460  {
1461  auto that = static_cast<MarkupInsertedEvent const &>(in_event);
1462  markup_key = that.markup_key;
1463  view = that.view;
1464  }
1465  else
1466  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
1467  }
1468 
1470 
1473  Event * Clone() const
1474  {
1475  MarkupInsertedEvent * new_event = new MarkupInsertedEvent(*this);
1476  return new_event;
1477  }
1478 
1479  Key markup_key;
1480  View view;
1481  };
1482 
1483 private:
1484  struct Attributes
1485  {
1486  RGBColor color;
1487  LineAttributeKit line_attributes;
1488  TextAttributeKit text_attributes;
1489  };
1490 
1491  class KeyboardHiddenEventHandler : public EventHandler
1492  {
1493  public:
1494  KeyboardHiddenEventHandler()
1495  : EventHandler()
1496  { }
1497 
1498  virtual ~KeyboardHiddenEventHandler()
1499  { Shutdown(); }
1500 
1501  virtual HandleResult Handle(Event const * /*in_event*/)
1502  {
1503  markup_operator->keyboard_active = false;
1504 
1505  markup_operator->ResetCameras();
1506  return HandleResult::Handled;
1507  }
1508 
1509  void SetOperator(MarkupOperator * in_operator) { markup_operator = in_operator; }
1510 
1511  private:
1512  MarkupOperator * markup_operator;
1513  };
1514 
1515  std::unordered_multimap<RGBColor, SegmentKey> attribute_map;
1516 
1517  MouseButtons mouse_trigger;
1518  ModifierKeys modifier_trigger;
1519 
1520  MarkupType markup_type;
1521  SegmentKey markup_segment;
1522  SegmentKey current_segment;
1523  Attributes current_attributes;
1524 
1525  static const RGBColor default_color;
1526  static const TextAttributeKit default_text_attributes;
1527  static const LineAttributeKit default_line_attributes;
1528 
1529  Point start_point;
1530  bool start_new_line;
1531  LineKey current_line;
1532  size_t current_line_size;
1533  CircleKey current_circle;
1534  LineKey current_circle_line;
1535  LineKey current_rectangle;
1536  View last_attached_view;
1537 
1538  bool start_new_note;
1539  bool keyboard_active;
1540  TextKey default_text;
1541  TextKey current_text;
1542  SizeTArray text_columns;
1543  size_t current_text_row;
1544 
1545  bool operator_active;
1546  TouchID tracked_touch_id;
1547  TouchID second_tracked_touch_id;
1548 
1549  CameraKit original_camera;
1550  CameraKit original_markup_camera;
1551 
1552  KeyboardHiddenEventHandler handler;
1553 
1554  bool SetupConstructionSegments();
1555  void LookupSegment();
1556  void CreateNewMarkupSegment();
1557  void DrawFreehand(Point const & location);
1558  void DrawText();
1559  void DrawCircle(Point const & location);
1560  void DrawCircleFromTwoPoints(Point const & point_one, Point const & point_two);
1561  void DrawRectangleFromTwoPoints(Point const & point_one, Point const & point_two);
1562  void DrawRectangle(Point const & location);
1563  void CenterCameras(Point const & main_camera_center, Point const & markup_camera_center);
1564  void ResetCameras();
1565  void EndTextNote();
1566 };
1567 
1568 
1569 }
1570 #endif
1571 
1572 
Definition: hps.h:6097
Handedness
Definition: hps.h:1261
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:509
MarkupInsertedEvent(Event const &in_event)
Definition: sprk_ops.h:1457
Definition: sprk.h:237
virtual bool OnMouseWheel(MouseState const &in_state)
Definition: sprk_ops.h:1003
bool GetSectioning()
Definition: sprk_ops.h:1221
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5606
SegmentKey GetSegmentKey()
Definition: sprk_ops.h:1428
static MouseButtons ButtonRight()
Definition: hps.h:42883
Definition: sprk_ops.h:983
Definition: sprk_ops.h:281
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:196
Definition: hps.h:34524
HPS::HighlightOptionsKit GetHighlightOptions() const
Definition: sprk_ops.h:473
Definition: sprk_ops.h:395
HPS::SelectionOptionsKit GetSelectionOptions() const
Definition: sprk_ops.h:528
void SetMarkupType(MarkupType in_markup_type)
Definition: sprk_ops.h:1402
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:989
Definition: hps.h:43370
Definition: hps.h:7473
Definition: sprk_ops.h:68
Definition: hps.h:3458
ZoomType
Definition: sprk_ops.h:571
void SetIndicatorScale(float in_scale)
Definition: sprk_ops.h:1188
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:251
Definition: hps.h:15390
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:456
HPS::SelectionOptionsKit GetSelectionOptions() const
Definition: sprk_ops.h:435
Definition: sprk_ops.h:611
virtual bool OnTouchDown(TouchState const &in_state)
Definition: sprk_ops.h:1024
void SetPlaneHighlightOptions(HighlightOptionsKit const &in_highlight_options)
Definition: sprk_ops.h:1204
Definition: sprk_ops.h:492
Definition: sprk_ops.h:191
TextAttributeKit GetTextAttributes()
Definition: sprk_ops.h:1413
Definition: hps.h:1500
Definition: hps.h:8640
void SetLineAttribute(LineAttributeKit const &in_line_attributes)
Definition: sprk_ops.h:1423
Definition: sprk_ops.h:334
Definition: sprk_ops.h:1437
Definition: sprk_ops.h:675
virtual bool OnTouchMove(TouchState const &in_state)
Definition: sprk_ops.h:1029
void SetSelectionOptions(HPS::SelectionOptionsKit const &in_options)
Definition: sprk_ops.h:523
Definition: sprk_ops.h:1108
Definition: hps.h:43269
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:338
Definition: sprk_ops.h:719
Definition: sprk_ops.h:445
Definition: hps.h:30942
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:412
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:583
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:945
Definition: sprk_ops.h:1326
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:142
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:680
bool GetIndicatorVisibility()
Definition: sprk_ops.h:1230
virtual bool OnTouchUp(TouchState const &in_state)
Definition: sprk_ops.h:1033
Definition: hps.h:4275
RGBColor GetColor()
Definition: sprk_ops.h:1406
Definition: hps.h:6846
Definition: hps.h:42761
Definition: hps.h:25204
Definition: hps.h:40448
Definition: hps.h:5801
Definition: hps.h:41814
Definition: hps.h:39745
Definition: hps.h:43157
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:376
Definition: sprk_ops.h:538
intptr_t GetChannel() const
Definition: hps.h:6230
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:1123
Definition: hps.h:14076
Definition: hps.h:40725
Definition: hps.h:42426
bool GetMouseOverHighlighting() const
Definition: sprk_ops.h:1208
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:547
HPS::Rectangle GetRectangle() const
Definition: sprk_ops.h:353
Definition: hps.h:6197
void SetSelectionOptions(HPS::SelectionOptionsKit const &in_options)
Definition: sprk_ops.h:430
Definition: hps.h:13110
virtual bool OnKeyDown(KeyboardState const &in_state)
Definition: sprk_ops.h:994
void SetMouseOverHighlighting(bool in_enable_mouse_over_highlighting)
Definition: sprk_ops.h:1212
Definition: sprk_ops.h:240
LineAttributeKit GetLineAttributes()
Definition: sprk_ops.h:1420
void SetHighlightOptions(HPS::HighlightOptionsKit const &in_options)
Definition: sprk_ops.h:468
float GetIndicatorScale() const
Definition: sprk_ops.h:1184
HPS::HighlightOptionsKit GetHighlightOptions() const
Definition: sprk_ops.h:560
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:286
Definition: sprk_ops.h:568
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:616
Definition: sprk_ops.h:939
static MouseButtons ButtonLeft()
Definition: hps.h:42879
static MouseButtons ButtonMiddle()
Definition: hps.h:42887
Definition: hps.h:8758
static ModifierKeys KeyControl()
Definition: hps.h:42541
MaterialMappingKit GetPlaneMaterial() const
Definition: sprk_ops.h:1192
Definition: hps.h:7392
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:73
Definition: hps.h:8972
void SetTextAttribute(TextAttributeKit const &in_text_attributes)
Definition: sprk_ops.h:1416
Definition: hps.h:22556
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:724
Definition: hps.h:22841
Event * Clone() const
Definition: sprk_ops.h:1473
void SetColor(RGBColor const &in_color)
Definition: sprk_ops.h:1409
Definition: sprk.h:1065
Definition: sprk_ops.h:137
virtual HPS::UTF8 GetName() const OVERRIDE
Definition: sprk_ops.h:1340
virtual bool OnKeyUp(KeyboardState const &in_state)
Definition: sprk_ops.h:998
HighlightOptionsKit GetPlaneHighlightOptions() const
Definition: sprk_ops.h:1200
Definition: hps.h:37490
MarkupInsertedEvent()
Definition: sprk_ops.h:1441
void SetHighlightOptions(HPS::HighlightOptionsKit const &in_options)
Definition: sprk_ops.h:555
Definition: sprk_ops.h:372