Overview

Sample Code

Programming Guide

API Reference

Support

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 
1348  virtual bool OnMouseDown(MouseState const & in_state) OVERRIDE;
1349 
1353  virtual bool OnMouseUp(MouseState const & in_state) OVERRIDE;
1354 
1361  virtual bool OnMouseMove(MouseState const & in_state) OVERRIDE;
1362 
1363 
1368  virtual bool OnTouchDown(TouchState const & in_state) OVERRIDE;
1369 
1373  virtual bool OnTouchUp(TouchState const & in_state) OVERRIDE;
1374 
1381  virtual bool OnTouchMove(TouchState const & in_state) OVERRIDE;
1382 
1388  virtual bool OnKeyDown(KeyboardState const & in_state) OVERRIDE;
1389 
1395  virtual bool OnTextInput(HPS::UTF8 const & in_text) OVERRIDE;
1396 
1398  MarkupType GetMarkupType() { return markup_type; }
1399 
1401  void SetMarkupType(MarkupType in_markup_type) { markup_type = in_markup_type; }
1402 
1405  RGBColor GetColor() { return current_attributes.color; }
1406 
1408  void SetColor(RGBColor const & in_color) { current_attributes.color = in_color; }
1409 
1412  TextAttributeKit GetTextAttributes() { return current_attributes.text_attributes; }
1413 
1415  void SetTextAttribute(TextAttributeKit const & in_text_attributes) { current_attributes.text_attributes = in_text_attributes; }
1416 
1419  LineAttributeKit GetLineAttributes() { return current_attributes.line_attributes; }
1420 
1422  void SetLineAttribute(LineAttributeKit const & in_line_attributes) {current_attributes.line_attributes = in_line_attributes; }
1423 
1427  SegmentKey GetSegmentKey() { return markup_segment; }
1428 
1430  void DeleteMarkups();
1431 
1432  class SPRK_OPS_API MarkupInsertedEvent : public HPS::Event
1433  {
1434  public:
1437  {
1438  channel = GetClassID();
1439  consumable = false;
1440  }
1441 
1442  MarkupInsertedEvent(HPS::Key const & in_markup_key) : Event()
1443  {
1444  channel = GetClassID();
1445  consumable = false;
1446  markup_key = in_markup_key;
1447  }
1448 
1451  MarkupInsertedEvent(Event const & in_event) : Event(in_event)
1452  {
1453  if (in_event.GetChannel() == Object::ClassID<MarkupInsertedEvent>())
1454  {
1455  auto that = static_cast<MarkupInsertedEvent const &>(in_event);
1456  markup_key = that.markup_key;
1457  }
1458  else
1459  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
1460  }
1461 
1463 
1466  Event * Clone() const
1467  {
1468  MarkupInsertedEvent * new_event = new MarkupInsertedEvent(*this);
1469  return new_event;
1470  }
1471 
1472  Key markup_key;
1473  };
1474 
1475 private:
1476  struct Attributes
1477  {
1478  RGBColor color;
1479  LineAttributeKit line_attributes;
1480  TextAttributeKit text_attributes;
1481  };
1482 
1483  class KeyboardHiddenEventHandler : public EventHandler
1484  {
1485  public:
1486  KeyboardHiddenEventHandler()
1487  : EventHandler()
1488  { }
1489 
1490  virtual ~KeyboardHiddenEventHandler()
1491  { Shutdown(); }
1492 
1493  virtual HandleResult Handle(Event const * /*in_event*/)
1494  {
1495  markup_operator->keyboard_active = false;
1496 
1497  markup_operator->ResetCameras();
1498  return HandleResult::Handled;
1499  }
1500 
1501  void SetOperator(MarkupOperator * in_operator) { markup_operator = in_operator; }
1502 
1503  private:
1504  MarkupOperator * markup_operator;
1505  };
1506 
1507  std::unordered_multimap<RGBColor, SegmentKey> attribute_map;
1508 
1509  MarkupType markup_type;
1510  SegmentKey markup_segment;
1511  SegmentKey current_segment;
1512  Attributes current_attributes;
1513 
1514  static const RGBColor default_color;
1515  static const TextAttributeKit default_text_attributes;
1516  static const LineAttributeKit default_line_attributes;
1517 
1518  Point start_point;
1519  bool start_new_line;
1520  LineKey current_line;
1521  size_t current_line_size;
1522  CircleKey current_circle;
1523  LineKey current_circle_line;
1524  LineKey current_rectangle;
1525 
1526  bool start_new_note;
1527  bool typing;
1528  bool keyboard_active;
1529  TextKey default_text;
1530  TextKey current_text;
1531  SizeTArray text_columns;
1532  size_t current_text_row;
1533 
1534  bool operator_active;
1535  TouchID tracked_touch_id;
1536  TouchID second_tracked_touch_id;
1537 
1538  CameraKit original_camera;
1539  CameraKit original_markup_camera;
1540 
1541  KeyboardHiddenEventHandler handler;
1542 
1543  bool SetupConstructionSegments();
1544  void LookupSegment();
1545  void CreateNewMarkupSegment();
1546  void DrawFreehand(Point const & location);
1547  void DrawText();
1548  void DrawCircle(Point const & location);
1549  void DrawCircleFromTwoPoints(Point const & point_one, Point const & point_two);
1550  void DrawRectangleFromTwoPoints(Point const & point_one, Point const & point_two);
1551  void DrawRectangle(Point const & location);
1552  void CenterCameras(Point const & main_camera_center, Point const & markup_camera_center);
1553  void ResetCameras();
1554  void EndTextNote();
1555 };
1556 
1557 
1558 }
1559 #endif
1560 
1561 
Definition: hps.h:6070
Handedness
Definition: hps.h:1258
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:509
MarkupInsertedEvent(Event const &in_event)
Definition: sprk_ops.h:1451
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:5579
SegmentKey GetSegmentKey()
Definition: sprk_ops.h:1427
static MouseButtons ButtonRight()
Definition: hps.h:42455
Definition: sprk_ops.h:983
Definition: sprk_ops.h:281
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:196
Definition: hps.h:34140
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:1401
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:989
Definition: hps.h:42942
Definition: hps.h:7445
Definition: sprk_ops.h:68
Definition: hps.h:3434
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:15152
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:1412
Definition: hps.h:1497
Definition: hps.h:8612
void SetLineAttribute(LineAttributeKit const &in_line_attributes)
Definition: sprk_ops.h:1422
Definition: sprk_ops.h:334
Definition: sprk_ops.h:1432
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:42841
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:338
Definition: sprk_ops.h:719
Definition: sprk_ops.h:445
Definition: hps.h:30558
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:4251
RGBColor GetColor()
Definition: sprk_ops.h:1405
Definition: hps.h:6818
Definition: hps.h:42333
Definition: hps.h:24966
Definition: hps.h:40023
Definition: hps.h:5774
Definition: hps.h:41387
Definition: hps.h:39320
Definition: hps.h:42729
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:376
Definition: sprk_ops.h:538
intptr_t GetChannel() const
Definition: hps.h:6203
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:1123
Definition: hps.h:13838
Definition: hps.h:40300
Definition: hps.h:41998
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:6170
void SetSelectionOptions(HPS::SelectionOptionsKit const &in_options)
Definition: sprk_ops.h:430
Definition: hps.h:13018
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:1419
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:42451
static MouseButtons ButtonMiddle()
Definition: hps.h:42459
Definition: hps.h:8728
static ModifierKeys KeyControl()
Definition: hps.h:42113
MaterialMappingKit GetPlaneMaterial() const
Definition: sprk_ops.h:1192
Definition: hps.h:7364
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:73
Definition: hps.h:8942
void SetTextAttribute(TextAttributeKit const &in_text_attributes)
Definition: sprk_ops.h:1415
Definition: hps.h:22318
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:724
Definition: hps.h:22603
Event * Clone() const
Definition: sprk_ops.h:1466
void SetColor(RGBColor const &in_color)
Definition: sprk_ops.h:1408
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:37084
MarkupInsertedEvent()
Definition: sprk_ops.h:1436
void SetHighlightOptions(HPS::HighlightOptionsKit const &in_options)
Definition: sprk_ops.h:555
Definition: sprk_ops.h:372