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  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  class SPRK_OPS_API MarkupInsertedEvent : public HPS::Event
1434  {
1435  public:
1438  {
1439  channel = GetClassID();
1440  consumable = false;
1441  }
1442 
1443  MarkupInsertedEvent(HPS::Key const & in_markup_key, HPS::View const & in_view) : Event()
1444  {
1445  channel = GetClassID();
1446  consumable = false;
1447  markup_key = in_markup_key;
1448  view = in_view;
1449  }
1450 
1453  MarkupInsertedEvent(Event const & in_event) : Event(in_event)
1454  {
1455  if (in_event.GetChannel() == Object::ClassID<MarkupInsertedEvent>())
1456  {
1457  auto that = static_cast<MarkupInsertedEvent const &>(in_event);
1458  markup_key = that.markup_key;
1459  view = that.view;
1460  }
1461  else
1462  throw HPS::InvalidSpecificationException("Invalid Event Type to Cast From.");
1463  }
1464 
1466 
1469  Event * Clone() const
1470  {
1471  MarkupInsertedEvent * new_event = new MarkupInsertedEvent(*this);
1472  return new_event;
1473  }
1474 
1475  Key markup_key;
1476  View view;
1477  };
1478 
1479 private:
1480  struct Attributes
1481  {
1482  RGBColor color;
1483  LineAttributeKit line_attributes;
1484  TextAttributeKit text_attributes;
1485  };
1486 
1487  class KeyboardHiddenEventHandler : public EventHandler
1488  {
1489  public:
1490  KeyboardHiddenEventHandler()
1491  : EventHandler()
1492  { }
1493 
1494  virtual ~KeyboardHiddenEventHandler()
1495  { Shutdown(); }
1496 
1497  virtual HandleResult Handle(Event const * /*in_event*/)
1498  {
1499  markup_operator->keyboard_active = false;
1500 
1501  markup_operator->ResetCameras();
1502  return HandleResult::Handled;
1503  }
1504 
1505  void SetOperator(MarkupOperator * in_operator) { markup_operator = in_operator; }
1506 
1507  private:
1508  MarkupOperator * markup_operator;
1509  };
1510 
1511  std::unordered_multimap<RGBColor, SegmentKey> attribute_map;
1512 
1513  MarkupType markup_type;
1514  SegmentKey markup_segment;
1515  SegmentKey current_segment;
1516  Attributes current_attributes;
1517 
1518  static const RGBColor default_color;
1519  static const TextAttributeKit default_text_attributes;
1520  static const LineAttributeKit default_line_attributes;
1521 
1522  Point start_point;
1523  bool start_new_line;
1524  LineKey current_line;
1525  size_t current_line_size;
1526  CircleKey current_circle;
1527  LineKey current_circle_line;
1528  LineKey current_rectangle;
1529 
1530  bool start_new_note;
1531  bool keyboard_active;
1532  TextKey default_text;
1533  TextKey current_text;
1534  SizeTArray text_columns;
1535  size_t current_text_row;
1536 
1537  bool operator_active;
1538  TouchID tracked_touch_id;
1539  TouchID second_tracked_touch_id;
1540 
1541  CameraKit original_camera;
1542  CameraKit original_markup_camera;
1543 
1544  KeyboardHiddenEventHandler handler;
1545 
1546  bool SetupConstructionSegments();
1547  void LookupSegment();
1548  void CreateNewMarkupSegment();
1549  void DrawFreehand(Point const & location);
1550  void DrawText();
1551  void DrawCircle(Point const & location);
1552  void DrawCircleFromTwoPoints(Point const & point_one, Point const & point_two);
1553  void DrawRectangleFromTwoPoints(Point const & point_one, Point const & point_two);
1554  void DrawRectangle(Point const & location);
1555  void CenterCameras(Point const & main_camera_center, Point const & markup_camera_center);
1556  void ResetCameras();
1557  void EndTextNote();
1558 };
1559 
1560 
1561 }
1562 #endif
1563 
1564 
Definition: hps.h:6069
Handedness
Definition: hps.h:1257
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:509
MarkupInsertedEvent(Event const &in_event)
Definition: sprk_ops.h:1453
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:5578
SegmentKey GetSegmentKey()
Definition: sprk_ops.h:1428
static MouseButtons ButtonRight()
Definition: hps.h:42451
Definition: sprk_ops.h:983
Definition: sprk_ops.h:281
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:196
Definition: hps.h:34136
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:42938
Definition: hps.h:7441
Definition: sprk_ops.h:68
Definition: hps.h:3433
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:15148
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:1496
Definition: hps.h:8608
void SetLineAttribute(LineAttributeKit const &in_line_attributes)
Definition: sprk_ops.h:1423
Definition: sprk_ops.h:334
Definition: sprk_ops.h:1433
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:42837
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:338
Definition: sprk_ops.h:719
Definition: sprk_ops.h:445
Definition: hps.h:30554
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:4250
RGBColor GetColor()
Definition: sprk_ops.h:1406
Definition: hps.h:6817
Definition: hps.h:42329
Definition: hps.h:24962
Definition: hps.h:40019
Definition: hps.h:5773
Definition: hps.h:41383
Definition: hps.h:39316
Definition: hps.h:42725
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:376
Definition: sprk_ops.h:538
intptr_t GetChannel() const
Definition: hps.h:6202
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:1123
Definition: hps.h:13834
Definition: hps.h:40296
Definition: hps.h:41994
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:6169
void SetSelectionOptions(HPS::SelectionOptionsKit const &in_options)
Definition: sprk_ops.h:430
Definition: hps.h:13014
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:42447
static MouseButtons ButtonMiddle()
Definition: hps.h:42455
Definition: hps.h:8724
static ModifierKeys KeyControl()
Definition: hps.h:42109
MaterialMappingKit GetPlaneMaterial() const
Definition: sprk_ops.h:1192
Definition: hps.h:7360
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:73
Definition: hps.h:8938
void SetTextAttribute(TextAttributeKit const &in_text_attributes)
Definition: sprk_ops.h:1416
Definition: hps.h:22314
virtual HPS::UTF8 GetName() const
Definition: sprk_ops.h:724
Definition: hps.h:22599
Event * Clone() const
Definition: sprk_ops.h:1469
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:37080
MarkupInsertedEvent()
Definition: sprk_ops.h:1437
void SetHighlightOptions(HPS::HighlightOptionsKit const &in_options)
Definition: sprk_ops.h:555
Definition: sprk_ops.h:372