< Home

< Table of Contents

REFERENCE MANUAL

hps.h
1 
2 // Copyright (c) 1998-2014 by Tech Soft 3D, Inc.
3 //
4 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
5 // and considered a trade secret as defined under civil and criminal statutes.
6 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
7 // unauthorized use or misappropriation of its trade secrets. Use of this information
8 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
9 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
10 
11 #ifndef HPS_H
12 #define HPS_H
13 
14 #ifdef _MSC_VER
15 # ifndef STATIC_APP
16 # ifdef HPS_CORE_BUILD
17 # define HPS_API __declspec (dllexport)
18 # define EXPIMP_TEMPLATE
19 # else
20 # define HPS_API __declspec (dllimport)
21 # define EXPIMP_TEMPLATE extern
22 # endif
23 # define HPS_TEMPLATE_API __declspec (dllexport)
24 # endif
25 # ifdef _WINDOWS_
26 # undef Ellipse
27 # undef Polyline
28 # undef Polygon
29 # undef Rectangle
30 # undef min
31 # undef max
32 # endif
33 # pragma warning(push)
34 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
35 #else
36 # include <limits.h>
37 # include <stddef.h>
38 # ifdef LINUX_SYSTEM
39 # ifndef STATIC_APP
40 # ifdef HPS_CORE_BUILD
41 # define HPS_API __attribute__ ((visibility ("default")))
42 # define EXPIMP_TEMPLATE
43 # else
44 # define EXPIMP_TEMPLATE extern
45 # endif
46 # define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
47 # endif
48 # endif
49 #endif
50 #ifndef HPS_API
51 # define HPS_API
52 #endif
53 #ifndef HPS_TEMPLATE_API
54 # define HPS_TEMPLATE_API
55 #endif
56 #ifndef EXPIMP_TEMPLATE
57 # define EXPIMP_TEMPLATE
58 #endif
59 #ifndef ENUM_CLASS
60 # define ENUM_CLASS enum class
61 #endif
62 
63 #define NO_HPS_API
64 
65 #include <stdint.h>
66 #include <memory>
67 #include <vector>
68 #include <math.h>
69 #include <float.h>
70 #include <limits>
71 #include <stdexcept>
72 #include <algorithm>
73 #include <cstring>
74 
75 
76 
77 namespace HPSI
78 {
79  class Impl;
80  class KeyImpl;
81  class TicketImpl;
82  class EventDispatcherImpl;
83  class AbstractImage;
84 };
85 
86 namespace HPS
87 {
88 
89  // unimplemented
90 
91 
92 //Begin Info
94 class HPS_API Info
95 {
96 public:
99  enum class Code {
100  Unknown,
101  Exchange,
102  Publish,
103  Data,
104  Key,
105  Geometry,
106  Database,
107  Driver,
108  Internal,
109  Memory,
110  System,
111  Unsupported,
112  };
113 
114 private:
116  Info();
117 };
118 
119 
120 //Begin Info
122 class HPS_API Emergency
123 {
124 public:
127  enum class Code {
128  Unknown,
129  Fatal,
130  SoftMemoryLimit,
131  HardMemoryLimit,
132  };
133 
134 private:
136  Emergency();
137 };
138 
139 
140 //Begin Window
142 class HPS_API Window
143 {
144 public:
147  enum class Driver {
148  Default3D,
149  OpenGL,
150  OpenGL2,
151  DirectX9,
152  DirectX11,
153  };
154 
157  enum class UpdateStatus {
158  InProgress,
159  Completed,
160  TimedOut,
161  Interrupted,
162  Failed
163  };
164 
168  enum class UpdateControl {
169  DefaultUpdate,
170 
174  CompleteUpdate,
175 
176  RefreshUpdate,
177 
178  CompileOnlyUpdate,
179 
183  ExhaustiveUpdate,
184  };
185 
188  enum class Mobility
189  {
190  Locked,
191  Floating,
192  FixedRatio,
193  Free
194  };
195 
199  enum class FrameSize
200  {
201  Single,
202  Double
203  };
204 
208  enum class FrameOptions
209  {
210  Inset,
211  Overlay
212  };
213 
214 private:
216  Window();
217 };
218 
219 //Begin Subwindow
221 class HPS_API Subwindow
222 {
223 public:
224  enum class Background
225  {
226  SolidColor,
227  Image,
228  Cubemap,
229  Blend,
230  Transparent,
231  Interactive,
232 
233  GradientTopToBottom,
234  GradientBottomToTop,
235  GradientLeftToRight,
236  GradientRightToLeft,
237  GradientTopLeftToBottomRight,
238  GradientTopRightToBottomLeft,
239  GradientBottomLeftToTopRight,
240  GradientBottomRightToTopLeft,
241  };
242 
243  enum class Type
244  {
245  Standard,
246  Lightweight
247  };
248 
249  enum class Border
250  {
251  None,
252  Inset,
253  InsetBold,
254  Overlay,
255  OverlayBold
256  };
257 
258 
261  {
264  ZBuffer,
265 
271  HiddenLine,
272 
278  FastHiddenLine,
279 
292  Priority
293  };
294 
295 private:
296  Subwindow();
297 };
298 //End Subwindow
299 
301 class HPS_API Style
302 {
303 public:
304 
308  enum class Type
309  {
310  Segment,
311  Named
312  };
313 
317  enum class AppendMode
318  {
319  None,
320  And,
321  Or
322  };
323 
324 private:
325  Style();
326 };
327 
328 
329 //Begin Shell Attributes
331 class HPS_API Shell
332 {
333 public:
334 
337  enum class Component
338  {
339  Faces,
340  Edges,
341  Vertices
342  };
343 
344  /* \enum ToleranceUnits
345  * Enumerates the Tolerance Units used to determine if points can be merged during shell optimization. */
346  enum class ToleranceUnits
347  {
348  ObjectSpace,
349  FeatureSizePercentage
350  };
351 
352  /* \enum HandednessOptimization
353  * Enumerates the shell optimization options with regards to handedness. */
355  {
356  None,
357  FixHandedness,
358  ReverseHandedness
359  };
360 
361  /* \enum RelationResults
362  * Enumerates the results of a shell relation computation. */
363  enum class Relation
364  {
365  On,
366  Off,
367  In,
368  Out
369  };
370 
371  /* \enum RelationTest
372  * Enumerates the test options for a shell relation computation. */
373  enum class RelationTest
374  {
375  Simple,
376  Enclosure,
377  Distance
378  };
379 
380 private:
382  Shell();
383 };
384 //End Shell Attributes
385 
386 //Begin Mesh Attributes
388 class HPS_API Mesh
389 {
390 public:
393  enum class Component
394  {
395  Faces,
396  Edges,
397  Vertices
398  };
399 
400 private:
402  Mesh();
403 };
404 //End Mesh Attributes
405 
406 //Begin InfiniteLine Attributes
408 class HPS_API InfiniteLine
409 {
410 public:
413  enum class Type
414  {
415  Line,
416  Ray
417  };
418 
419 private:
421  InfiniteLine();
422 };
423 //End InfiniteLine Attributes
424 
426 class HPS_API Trim
427 {
428 public:
431  enum class Type
432  {
433  Line,
434  Curve
435  };
436 
440  enum class Operation
441  {
442  Keep,
443  Remove
444  };
445 private:
447  Trim();
448 };
449 
450 //Begin Spotlight Attributes
452 class HPS_API Spotlight
453 {
454 public:
457  enum class OuterConeUnits
458  {
462  Degrees,
466  FieldRadius
467  };
468 
471  enum class InnerConeUnits
472  {
476  Degrees,
480  FieldRadius,
483  Percent
484  };
485 
486 
487 private:
489  Spotlight();
490 };
491 //End Spotlight Attributes
492 
493 
494 
495 
496 //Begin Cylinder Attributes
498 class HPS_API Cylinder
499 {
500 public:
503  enum class Component
504  {
505  Faces,
506  Edges,
507  };
508 
511  enum class Capping
512  {
513  None,
514  First,
515  Last,
516  Both
517  };
518 
522  enum class Orientation
523  {
524  Default,
525  DefaultRadii,
526  InvertRadii,
527  InvertRadiiOnly,
528  DefaultColors,
529  InvertColors,
530  InvertColorsOnly,
531  InvertAll
532  };
533 
534 private:
536  Cylinder();
537 };
538 
539 
541 class HPS_API Search
542 {
543 public:
546  enum class Space
547  {
548  SegmentOnly,
549  Subsegments,
550  SubsegmentsAndIncludes
551  };
552 
555  enum class Behavior
556  {
557  Exhaustive,
558  FirstMatch
559  };
560 
561 
562  // IMPORTANT: Remember to add compile time asserts in hpsi.cpp to keep these synchronized to 3DF HK types (if they map to HK types)
566  enum class Type : uint32_t {
567 
568  /* This enum classeration is divided into three parts.
569 
570  0xAABBBCCC
571 
572  The bits in A encode the most general category of the type (Geometry, Attribute).
573  The bits in B encode the subtype (Culling, TextAttribute). Attributes alone have these so far.
574  The bits in C encode the specific type (Shell, CullingVectorTolerance, TextAttributeSpacing).
575 
576  General category designators should have no bits in B or C.
577  Subtype category designators should have bits in A and B but not C.
578  Specific category designators should have bits in A and C and optionally B.
579 
580  Some types map to an HK type. To get the HK type you should mask out its subtype if it has one, else mask out its general type.
581  These types are kept in sync with the 3DF HK types by using Compile-time assets in hpsi.cpp.
582 
583  Geometry have no subtype. Most, 'Ordinary Geometry' map to a 3DF HK type.
584  The mutants or 'Special Geometry' (some lights and infinite ray) have no HK type to map to.
585 
586  Attributes come in a few forms.
587  The 'Simple Attributes' map to an HK type and have no subtypes -- they are what they are. ModellingMatrix, Camera, etc.
588  The 'Complex Attributes' have subtypes. A handful map to an HK type, but the majority are not.
589  */
590  None = 0x00000000,
591  Everything = 0x00ffffff,
592 
593  // Segment Stuff (Include & Segment map to HK types)
594  Include = 0x00000042,
595  Segment = 0x00000043,
596 
597  Includer = 0x00000100,
598 
599  // Geometry
600  Geometry = 0x10000000,
601 
602  // Ordinary Geometry (map to HK types) - (HK_* | Geometry)
603  CuttingSection = 0x10000026,
604  Shell = 0x10000028,
605  Mesh = 0x10000029,
606  Grid = 0x1000002a,
607  NURBSSurface = 0x1000002b,
608  Cylinder = 0x1000002d,
609  Sphere = 0x1000002e,
610  Polygon = 0x1000002f,
611  Circle = 0x10000030,
612  //unused = 0x10000031,
613  CircularWedge = 0x10000032,
614  Ellipse = 0x10000033,
615  Line = 0x10000034,
616  NURBSCurve = 0x10000037,
617  CircularArc = 0x10000038,
618  EllipticalArc = 0x10000039,
619  InfiniteLine = 0x1000003a,
620 // Image = 0x1000003b, N/A since images live in portfolios
621  Marker = 0x1000003c,
622  Text = 0x1000003e,
623  Reference = 0x10000040,
624 
625  // Special Geometry
626  DistantLight = 0x10000100,
627  Spotlight = 0x10000101,
628  InfiniteRay = 0x10000102,
629 
630  // Attributes
631  Attribute = 0x20000000,
632 
633  Priority = 0x20000001,
634 
635  // Simple Attributes (map to HK types)
636  Material = 0x2000000a,
637  Camera = 0x2000000e,
638  ModellingMatrix = 0x20000010,
639  UserData = 0x20000021,
640  TextureMatrix = 0x20000023,
641 
642  // Complex Attributes
643  Culling = 0x20001000,
644  CullingBackFace = 0x20001001,
645  CullingExtent = 0x20001002,
646  CullingVector = 0x20001003,
647  CullingVectorTolerance = 0x20001004,
648  CullingFrustum = 0x20001005,
649  CullingDeferralExtent = 0x20001006,
650 
651  CurveAttribute = 0x20002000,
652  CurveAttributeBudget = 0x20002001,
653  CurveAttributeContinuedBudget = 0x20002002,
654  CurveAttributeViewDependent = 0x20002003,
655  CurveAttributeMaximumDeviation = 0x20002004,
656  CurveAttributeMaximumAngle = 0x20002005,
657  CurveAttributeMaximumLength = 0x20002006,
658 
659  CylinderAttribute = 0x20003000,
660  CylinderAttributeTessellation = 0x20003001,
661  CylinderAttributeOrientation = 0x20003002,
662 
663  // EdgeAttributes map to HK types
664  EdgeAttribute = 0x20004000,
665  EdgeAttributePattern = 0x20004015,
666  EdgeAttributeWeight = 0x20004016,
667 
668  LightingAttribute = 0x20005000,
669  LightingAttributeInterpolation = 0x20005001,
670 
671  // LineAttributes map to HK types
672  LineAttribute = 0x20006000,
673  LineAttributePattern = 0x20006019,
674  LineAttributeWeight = 0x2000601a,
675 
676  // MarkerAttributes map to HK types
677  MarkerAttribute = 0x20007000,
678  MarkerAttributeSize = 0x2000701b,
679  MarkerAttributeSymbol = 0x2000701c,
680 
681  SurfaceAttribute = 0x20008000,
682  SurfaceAttributeBudget = 0x20008001,
683  SurfaceAttributeMaximumFacetDeviation = 0x20008002,
684  SurfaceAttributeMaximumFacetAngle = 0x20008003,
685  SurfaceAttributeMaximumFacetWidth = 0x20008004,
686  SurfaceAttributeTrimCurveBudget = 0x20008005,
687  SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
688 
689  Selectability = 0x20009000,
690  SelectabilityWindows = 0x20009001,
691  SelectabilityEdges = 0x20009002,
692  SelectabilityFaces = 0x20009003,
693  SelectabilityLights = 0x20009004,
694  SelectabilityLines = 0x20009005,
695  SelectabilityMarkers = 0x20009006,
696  SelectabilityVertices = 0x20009007,
697  SelectabilityText = 0x20009008,
698 
699  SphereAttribute = 0x2000a000,
700  SphereAttributeTessellation = 0x2000a001,
701 
702  Subwindow = 0x2000b000,
703  SubwindowEitherType = 0x2000b001,
704  SubwindowStandard = 0x2000b00d,
705  SubwindowLightweight = 0x2000b002,
706  SubwindowBackground = 0x2000b003,
707  SubwindowBorder = 0x2000b004,
708  SubwindowRenderingAlgorithm = 0x2000b005,
709 
710  // TextAttributeAlignment, Path, & Spacing map to HK types
711  TextAttribute = 0x2000c000,
712  TextAttributeAlignment = 0x2000c01d,
713  TextAttributeBold = 0x2000c002,
714  TextAttributeItalic = 0x2000c003,
715  TextAttributeOverline = 0x2000c004,
716  TextAttributeStrikethrough = 0x2000c005,
717  TextAttributeUnderline = 0x2000c006,
718  TextAttributeSlant = 0x2000c007,
719  TextAttributeLineSpacing = 0x2000c008,
720  TextAttributeRotation = 0x2000c00a,
721  TextAttributeExtraSpace = 0x2000c00b,
722  TextAttributeGreeking = 0x2000c00c,
723  TextAttributeSizeTolerance = 0x2000c00d,
724  TextAttributeSize = 0x2000c00e,
725  TextAttributeFont = 0x2000c00f,
726  TextAttributeTransform = 0x2000c010,
727  TextAttributeRenderer = 0x2000c011,
728  TextAttributePreference = 0x2000c012,
729  TextAttributePath = 0x2000c01f,
730  TextAttributeSpacing = 0x2000c020,
731 
732  Transparency = 0x2000d000,
733  TransparencyMethod = 0x2000d001,
734  TransparencyAlgorithm = 0x2000d002,
735  TransparencyDepthPeelingLayers = 0x2000d004,
736  TransparencyDepthPeelingMinimumArea = 0x2000d005,
737  TransparencyDepthWriting = 0x2000d006,
738 
739  Visibility = 0x2000e000,
740  VisibilityCuttingSections = 0x2000e001,
741  VisibilityCutEdges = 0x2000e002,
742  VisibilityCutFaces = 0x2000e003,
743  VisibilityWindows = 0x2000e004,
744  VisibilityText = 0x2000e005,
745  VisibilityLines = 0x2000e006,
746  VisibilityEdgeLights = 0x2000e007,
747  VisibilityMarkerLights = 0x2000e008,
748  VisibilityFaceLights = 0x2000e009,
749  VisibilityGenericEdges = 0x2000e00a,
750  VisibilityHardEdges = 0x2000e00b,
751  VisibilityAdjacentEdges = 0x2000e00c,
752  VisibilityInteriorSilhouetteEdges = 0x2000e00d,
753  VisibilityShadowEmitting = 0x2000e00e,
754  VisibilityShadowReceiving = 0x2000e00f,
755  VisibilityShadowCasting = 0x2000e010,
756  VisibilityMarkers = 0x2000e011,
757  VisibilityVertices = 0x2000e012,
758  VisibilityFaces = 0x2000e013,
759  VisibilityPerimeterEdges = 0x2000e014,
760  VisibilityNonCulledEdges = 0x2000e015,
761  VisibilityMeshQuadEdges = 0x2000e016,
762 
763  VisualEffects = 0x2000f000,
764  VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
765  VisualEffectsAntiAliasing = 0x2000f002,
766  VisualEffectsShadowMaps = 0x2000f003,
767  VisualEffectsSimpleShadow = 0x2000f004,
768  VisualEffectsSimpleShadowPlane = 0x2000f005,
769  VisualEffectsSimpleShadowLightDirection = 0x2000f006,
770  VisualEffectsSimpleShadowColor = 0x2000f007,
771  VisualEffectsSimpleReflection = 0x2000f008,
772  VisualEffectsSimpleReflectionPlane = 0x2000f009,
773  VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
774 
775  Performance = 0x20010000,
776  PerformanceDisplayLists = 0x20010001,
777  PerformanceStaticModel = 0x20010002,
778  StaticModelSegment = 0x40000043,
779 
780  // DrawingAttributeWorldHandedness map to HK types
781  DrawingAttribute = 0x20011000,
782  DrawingAttributePolygonHandedness = 0x20011001,
783  DrawingAttributeDepthRange = 0x20011002,
784  DrawingAttributeFaceDisplacement = 0x20011003,
785  DrawingAttributeGeneralDisplacement = 0x20011004,
786  DrawingAttributeVertexDisplacement = 0x20011005,
787  DrawingAttributeOverlay = 0x20011006,
788  DrawingAttributeDeferral = 0x20011007,
789  DrawingAttributeWorldHandedness = 0x20011018,
790  DrawingAttributeClipRegion = 0x20011019,
791 
792  HiddenLineAttribute = 0x20012000,
793  HiddenLineAttributeColor = 0x20012001,
794  HiddenLineAttributeDimFactor = 0x20012002,
795  HiddenLineAttributeFaceDisplacement = 0x20012003,
796  HiddenLineAttributeLinePattern = 0x20012005,
797  HiddenLineAttributeRenderFaces = 0x20012006,
798  HiddenLineAttributeRenderText = 0x20012007,
799  HiddenLineAttributeAlgorithm = 0x20012008,
800  HiddenLineAttributeSilhouetteCleanup = 0x20012009,
801  HiddenLineAttributeVisibility = 0x2001200a,
802  HiddenLineAttributeWeight = 0x2001200b,
803  HiddenLineAttributeTransparencyCutoff = 0x2001200c,
804 
805  SegmentStyle = 0x20013001,
806  NamedStyle = 0x20013002,
807  MaterialPalette = 0x20013003,
808  Portfolio = 0x20013004,
809 
810  ContourLine = 0x20014000,
811  ContourLineVisibility = 0x20014001,
812  ContourLinePosition = 0x20014002,
813  ContourLineColor = 0x20014003,
814  ContourLinePattern = 0x20014004,
815  ContourLineWeight = 0x20014005,
816  ContourLineLighting = 0x20014006,
817 
818  Condition = 0x20015000,
819 
820  Bounding = 0x20016000,
821  BoundingVolume = 0x20016001,
822  BoundingExclusion = 0x20016002,
823 
824  AttributeLock = 0x20017000,
825  AttributeLockSetting = 0x20017001,
826  AttributeLockSubsegmentOverride = 0x20017002,
827 
828  TransformMask = 0x20018000,
829  TransformMaskCamera = 0x20018001,
830  TransformMaskCameraTranslation = 0x20018002,
831  TransformMaskCameraScale = 0x20018003,
832  TransformMaskCameraOffset = 0x20018004,
833  TransformMaskCameraRotation = 0x20018005,
834  TransformMaskCameraPerspectiveScale = 0x20018006,
835  TransformMaskCameraProjection = 0x20018007,
836  TransformMaskModellingMatrix = 0x20018008,
837  TransformMaskModellingMatrixTranslation = 0x20018009,
838  TransformMaskModellingMatrixScale = 0x20018010,
839  TransformMaskModellingMatrixOffset = 0x20018011,
840  TransformMaskModellingMatrixRotation = 0x20018012,
841 
842  ColorInterpolation = 0x20019000,
843  ColorInterpolationFaceColor = 0x20019001,
844  ColorInterpolationEdgeColor = 0x20019002,
845  ColorInterpolationMarkerColor = 0x20019003,
846  ColorInterpolationFaceIndex = 0x20019004,
847  ColorInterpolationEdgeIndex = 0x20019005,
848  ColorInterpolationMarkerIndex = 0x20019006,
849 
850  CuttingSectionAttribute = 0x2001a000,
851  CuttingSectionAttributeCuttingLevel = 0x2001a001,
852  CuttingSectionAttributeCappingLevel = 0x2001a002,
853  CuttingSectionAttributeMaterialPreference = 0x2001a003,
854 
855  };
856  // IMPORTANT: Remember to add compile time asserts in hpsi.cpp to keep these synchronized to HK types (if they are map to HK types)
857 
858 private:
860  Search();
861 };
862 
864 class HPS_API Material
865 {
866 public:
869  enum class Type
870  {
871  InvalidMaterialIndex = -1,
872  Nothing = 0,
873  FullMaterial,
874  ExplicitRGBColor,
875  ExplicitRGBAColor,
876  MaterialIndex,
877  TextureName,
878  ModulatedTexture,
879  CubeMapName,
880  ModulatedCubeMap,
881  GlossValue,
882  DiffuseChannelAlpha
883 
884  };
885 
889  enum class Channel
890  {
891  DiffuseColor = 1,
892  DiffuseTexture = 2,
893  Specular = 3,
894  Emission = 4,
895  Transmission = 5,
896  Mirror = 6,
897  Bump = 7,
898  EnvironmentTexture = 8,
899  EnvironmentCubeMap = 9,
900  Gloss = 10
901  };
902 
904  class HPS_API Color
905  {
906  public:
910  enum class Channel
911  {
912  DiffuseColor = 1,
913  Specular = 3,
914  Emission = 4,
915  Mirror = 6
916  };
917 
918  private:
920  Color();
921  };
922 
924  class HPS_API Texture
925  {
926  public:
930  enum class Channel
931  {
932  DiffuseTexture = 2,
933  Specular = 3,
934  Emission = 4,
935  Transmission = 5,
936  Mirror = 6,
937  Bump = 7,
938  EnvironmentTexture = 8,
939  EnvironmentCubeMap = 9
940  };
941 
944  enum class Parameterization
945  {
947  Cylinder,
949  PhysicalReflection,
951  Object,
957  NaturalUV,
959  ReflectionVector,
961  SurfaceNormal,
963  Sphere,
965  UV,
967  World
968  };
969 
972  enum class Tiling
973  {
976  Clamp,
978  Repeat,
980  Reflect,
983  Trim
984  };
985 
988  enum class Interpolation
989  {
991  Bilinear,
992 
994  InterpolationOff
995  };
996 
999  enum class Decimation
1000  {
1003  Anisotropic,
1005  Mipmap,
1007  DecimationOff
1008  };
1009 
1013  enum class ChannelMapping
1014  {
1015  Red,
1016  Green,
1017  Blue,
1018  Alpha,
1019  Zero,
1020  One,
1021  Luminance
1022  };
1023 
1024  private:
1026  Texture();
1027  };
1028 private:
1030  Material();
1031 };
1032 
1033 class HPS_API PostProcessEffects
1034 {
1035 public:
1036  class HPS_API AmbientOcclusion
1037  {
1038  public:
1042  enum class Quality
1043  {
1044  Fastest,
1045  Nicest
1046  };
1047 
1048  private:
1049  AmbientOcclusion();
1050  };
1051 
1052  class HPS_API Bloom
1053  {
1054  public:
1058  enum class Shape
1059  {
1060  Star,
1061  Radial
1062  };
1063 
1064  private:
1065  Bloom();
1066  };
1067 
1068 private:
1069  PostProcessEffects() {}
1070 };
1071 
1072 class HPS_API Performance
1073 {
1074 public:
1078  enum class DisplayLists
1079  {
1081  NoDisplayLists,
1082 
1085  GeometryDisplayLists,
1086 
1089  SegmentDisplayLists
1090  };
1091 
1100  enum class StaticModel
1101  {
1102 
1103  NoStaticModel,
1104  AttributeStaticModel,
1105  AttributeSpatialStaticModel
1106  };
1107 
1108 
1109 private:
1110  Performance() {}
1111 };
1112 
1113 
1114 class HPS_API AttributeLock
1115 {
1116 public:
1117 
1119  enum class Type : uint32_t
1120  {
1121  Everything = 0x01000000,
1122 
1123  Visibility = 0x02000000,
1124 
1125  VisibilityCuttingSections,
1126  VisibilityCutEdges,
1127  VisibilityCutFaces,
1128  VisibilityWindows,
1129  VisibilityText,
1130  VisibilityLines,
1131  VisibilityEdgeLights,
1132  VisibilityMarkerLights,
1133  VisibilityFaceLights,
1134  VisibilityGenericEdges,
1135  VisibilityHardEdges,
1136  VisibilityAdjacentEdges,
1137  VisibilityInteriorSilhouetteEdges,
1138  VisibilityShadowEmitting,
1139  VisibilityShadowReceiving,
1140  VisibilityShadowCasting,
1141  VisibilityMarkers,
1142  VisibilityVertices,
1143  VisibilityFaces,
1144  VisibilityPerimeterEdges,
1145  VisibilityNonCulledEdges,
1146  VisibilityMeshQuadEdges,
1147  VisibilityCutGeometry,
1148  VisibilityEdges,
1149  VisibilityGeometry,
1150  VisibilityLights,
1151  VisibilityShadows,
1152 
1153  Material = 0x03000000,
1154 
1155  MaterialGeometry,
1156  MaterialCutGeometry,
1157 
1158  MaterialAmbientLightUpColor,
1159  MaterialAmbientLightDownColor,
1160  MaterialAmbientLightColor,
1161 
1162  MaterialWindowColor,
1163  MaterialWindowContrastColor,
1164 
1165  MaterialLightColor,
1166  MaterialLineColor,
1167  MaterialMarkerColor,
1168  MaterialTextColor,
1169  MaterialCutEdgeColor,
1170 
1171  MaterialVertex,
1172  MaterialVertexDiffuse,
1173  MaterialVertexDiffuseColor,
1174  MaterialVertexDiffuseAlpha,
1175  MaterialVertexDiffuseTexture,
1176  MaterialVertexSpecular,
1177  MaterialVertexMirror,
1178  MaterialVertexTransmission,
1179  MaterialVertexEmission,
1180  MaterialVertexEnvironment,
1181  MaterialVertexBump,
1182  MaterialVertexGloss,
1183 
1184  MaterialEdge,
1185  MaterialEdgeDiffuse,
1186  MaterialEdgeDiffuseColor,
1187  MaterialEdgeDiffuseAlpha,
1188  MaterialEdgeDiffuseTexture,
1189  MaterialEdgeSpecular,
1190  MaterialEdgeMirror,
1191  MaterialEdgeTransmission,
1192  MaterialEdgeEmission,
1193  MaterialEdgeEnvironment,
1194  MaterialEdgeBump,
1195  MaterialEdgeGloss,
1196 
1197  MaterialFace,
1198  MaterialFaceDiffuse,
1199  MaterialFaceDiffuseColor,
1200  MaterialFaceDiffuseAlpha,
1201  MaterialFaceDiffuseTexture,
1202  MaterialFaceSpecular,
1203  MaterialFaceMirror,
1204  MaterialFaceTransmission,
1205  MaterialFaceEmission,
1206  MaterialFaceEnvironment,
1207  MaterialFaceBump,
1208  MaterialFaceGloss,
1209 
1210  MaterialBackFace,
1211  MaterialBackFaceDiffuse,
1212  MaterialBackFaceDiffuseColor,
1213  MaterialBackFaceDiffuseAlpha,
1214  MaterialBackFaceDiffuseTexture,
1215  MaterialBackFaceSpecular,
1216  MaterialBackFaceMirror,
1217  MaterialBackFaceTransmission,
1218  MaterialBackFaceEmission,
1219  MaterialBackFaceEnvironment,
1220  MaterialBackFaceBump,
1221  MaterialBackFaceGloss,
1222 
1223  MaterialFrontFace,
1224  MaterialFrontFaceDiffuse,
1225  MaterialFrontFaceDiffuseColor,
1226  MaterialFrontFaceDiffuseAlpha,
1227  MaterialFrontFaceDiffuseTexture,
1228  MaterialFrontFaceSpecular,
1229  MaterialFrontFaceMirror,
1230  MaterialFrontFaceTransmission,
1231  MaterialFrontFaceEmission,
1232  MaterialFrontFaceEnvironment,
1233  MaterialFrontFaceBump,
1234  MaterialFrontFaceGloss,
1235 
1236  MaterialCutFace,
1237  MaterialCutFaceDiffuse,
1238  MaterialCutFaceDiffuseColor,
1239  MaterialCutFaceDiffuseAlpha,
1240  MaterialCutFaceDiffuseTexture,
1241  MaterialCutFaceSpecular,
1242  MaterialCutFaceMirror,
1243  MaterialCutFaceTransmission,
1244  MaterialCutFaceEmission,
1245  MaterialCutFaceEnvironment,
1246  MaterialCutFaceBump,
1247  MaterialCutFaceGloss,
1248 
1249  Camera = 0x04000000,
1250  };
1251 
1252 private:
1253  AttributeLock() {}
1254 };
1255 
1256 class HPS_API Drawing
1257 {
1258 public:
1261  enum class Handedness
1262  {
1263  NoHandedness,
1264  Left,
1265  Right
1266  };
1267 
1270  enum class Overlay
1271  {
1273  NoOverlay,
1276  NormalOverlay,
1279  OverlayWithZValues,
1280 
1285  InPlace,
1286  };
1287 
1290  enum class ClipOperation
1291  {
1292  Keep,
1293  Remove,
1294  };
1295 
1298  enum class ClipSpace
1299  {
1300  Window,
1301  World,
1302  Object,
1303  };
1304 
1305 private:
1306  Drawing() {}
1307 };
1308 
1309 
1310 class HPS_API HiddenLine
1311 {
1312 public:
1316  enum class Algorithm
1317  {
1318  None,
1319  ZBuffer,
1320  ZSort,
1321  };
1322 
1323 private:
1324  HiddenLine() {}
1325 };
1326 
1327 
1329 class HPS_API Selection
1330 {
1331 public:
1334  enum class Level
1335  {
1336  Segment,
1337  Entity,
1338  Subentity,
1339  };
1340 
1343  enum class Algorithm
1344  {
1345  Visual,
1346  Analytic
1347  };
1348 
1351  enum class Granularity
1352  {
1353  General,
1354  Detailed
1355  };
1356 
1357 private:
1359  Selection();
1360 };
1361 
1362 
1366 
1367 //Begin Camera
1369 class HPS_API Camera
1370 {
1371 public:
1380  enum class Projection {
1381  Default=1,
1382  Perspective,
1383  Orthographic,
1384  Stretched,
1385  };
1388 private:
1389  Camera();
1390 };
1391 
1392 
1393 //Begin Selectability
1395 class HPS_API Selectability
1396 {
1397 public:
1401  enum class Value
1402  {
1403  Off=0,
1404  On,
1405  ForcedOn
1406  };
1407 
1408 private:
1409  Selectability();
1410 };
1411 
1412 // Begin Transparency
1414 class HPS_API Transparency
1415 {
1416 public:
1420  enum class Method
1421  {
1422  Off,
1423  Blended,
1424  ScreenDoor
1425  };
1426 
1430  enum class Algorithm
1431  {
1432  NoSorting,
1433  Painters,
1434  ZSortNicest,
1435  ZSortFastest,
1436  DepthPeeling
1437  };
1438 
1442  enum class AreaUnits
1443  {
1444  Percent,
1445  Pixels
1446  };
1447 
1448 private:
1449  Transparency() {}
1450 };
1451 
1452 
1453 
1454 //Begin Marker Attributes
1456 class HPS_API Marker
1457 {
1458 public:
1462  enum class SizeUnits
1463  {
1464  ScaleFactor,
1465  ObjectSpace,
1466  SubscreenRelative,
1467  WindowRelative,
1468  WorldSpace,
1469  Points,
1470  Pixels
1471 
1472  };
1473 private:
1474  Marker();
1475 };
1476 
1477 //Begin Sphere Attributes
1479 class HPS_API Sphere
1480 {
1481 public:
1482 
1483 private:
1484  Sphere();
1485 };
1486 
1487 
1488 //Begin Lighting Attributes
1490 class HPS_API Lighting
1491 {
1492 public:
1497  {
1498  Phong,
1499  Gouraud,
1500  Flat
1501  };
1502 
1503 private:
1504  Lighting();
1505 };
1506 
1508 class HPS_API Text
1509 {
1510 public:
1513  enum class Alignment
1514  {
1515  TopLeft,
1516  CenterLeft,
1517  BottomLeft,
1518  TopCenter,
1519  Center,
1520  BottomCenter,
1521  TopRight,
1522  CenterRight,
1523  BottomRight
1524  };
1525 
1528  enum class ReferenceFrame
1529  {
1530  WorldAligned,
1531  PathAligned
1532  };
1533 
1536  enum class Justification
1537  {
1538  LeftJustified,
1539  RightJustified,
1540  CenterJustified
1541  };
1542 
1545  enum class Transform
1546  {
1548  Transformable,
1551  NonTransformable,
1553  CharacterPositionOnly,
1556  CharacterPositionAdjusted
1557  };
1558 
1561  enum class Renderer
1562  {
1563  DefaultRenderer,
1564  DriverRenderer,
1565  TruetypeRenderer,
1566  };
1567 
1570  enum class Preference
1571  {
1572  Default,
1573  Vector,
1574  Raster,
1575  Exterior
1576  };
1577 
1580  enum class Rotation
1581  {
1582  NoRotation,
1583  Rotate,
1584  FollowPath
1585  };
1586 
1587 
1590  enum class SizeUnits
1591  {
1592  ObjectSpace,
1593  SubscreenRelative,
1594  WindowRelative,
1595  WorldSpace,
1596  Points,
1597  Pixels
1598  };
1599 
1603  {
1604  ObjectSpace,
1605  SubscreenRelative,
1606  WindowRelative,
1607  WorldSpace,
1608  Points,
1609  Pixels,
1610  Percent
1611  };
1612 
1615  enum class GreekingUnits
1616  {
1617  ObjectSpace,
1618  SubscreenRelative,
1619  WindowRelative,
1620  WorldSpace,
1621  Points,
1622  Pixels
1623  };
1624 
1627  enum class GreekingMode
1628  {
1629  Nothing,
1630  Lines,
1631  Box
1632  };
1633 
1636  enum class RegionAlignment
1637  {
1638  RegionTop,
1639  RegionCenter,
1640  RegionBottom
1641  };
1642 
1643 private:
1645  Text();
1646 };
1647 
1648 // Begin Line Attributes
1649 
1651 class HPS_API Line
1652 {
1653 public:
1657  enum class SizeUnits
1658  {
1659  ScaleFactor,
1660  ObjectSpace,
1661  SubscreenRelative,
1662  WindowRelative,
1663  WorldSpace,
1664  Points,
1665  Pixels
1666  };
1667 private:
1668  Line();
1669 };
1670 
1671 
1672 // Begin Edge Attributes
1673 
1675 class HPS_API Edge
1676 {
1677 public:
1681  enum class SizeUnits
1682  {
1683  ScaleFactor,
1684  ObjectSpace,
1685  SubscreenRelative,
1686  WindowRelative,
1687  WorldSpace,
1688  Points,
1689  Pixels
1690  };
1691 private:
1692  Edge();
1693 };
1694 
1695 
1697 class HPS_API CuttingSection
1698 {
1699 public:
1702  enum class Mode
1703  {
1704  None,
1705  Round,
1706  Square,
1707  Plane
1708  };
1709 
1712  enum class CappingLevel
1713  {
1714  Entity,
1715  Segment,
1716  SegmentTree
1717  };
1718 
1721  enum class CuttingLevel
1722  {
1723  Global,
1724  Local,
1725  };
1726 
1730  {
1731  Explicit,
1732  Implicit,
1733  };
1734 
1737  enum class GatheringLevel
1738  {
1739  Segment,
1740  SegmentTree
1741  };
1742 
1743 private:
1745  CuttingSection();
1746 };
1747 
1749 class HPS_API ContourLine
1750 {
1751 public:
1755  enum class Mode
1756  {
1757  Repeating,
1758  Explicit,
1759  };
1760 
1761 private:
1762  ContourLine();
1763 };
1764 
1767 enum class IOResult
1768 {
1769  Success,
1770  Failure,
1771  FileNotFound,
1772  UnableToOpenFile,
1773  InvalidOptions,
1774  InvalidSegment,
1775  InProgress,
1776  Canceled,
1777  UnableToLoadLibraries,
1778  VersionIncompatibility,
1779  InitializationFailed,
1780  UnsupportedFormat,
1781 };
1782 
1784 class HPS_API LinePattern
1785 {
1786 public:
1789  enum class SizeUnits
1790  {
1791  ObjectSpace,
1792  SubscreenRelative,
1793  WindowRelative,
1794  WorldSpace,
1795  Points,
1796  Pixels,
1797  ScaleFactor
1798  };
1799 
1802  enum class InsetBehavior
1803  {
1804  Overlap,
1805  Trim,
1806  Inline
1807  };
1808 
1812  enum class Join
1813  {
1814  MitreJoin,
1815  RoundJoin,
1816  BevelJoin
1817  };
1818 
1821  enum class Cap
1822  {
1825  ButtCap,
1828  SquareCap,
1831  RoundCap,
1833  MitreCap
1834  };
1835 
1838  enum class Justification
1839  {
1842  Center,
1844  Stretch
1845  };
1846 
1849  enum class Modifier
1850  {
1851  GlyphName,
1852  Enumerated
1853  };
1854 
1855 
1870  enum class Default
1871  {
1872  Solid,
1873  DashDot,
1874  Dashed,
1875  Dotted,
1876  Dash2Dot,
1877  Dash3Dot,
1878  LongDash,
1879  LongDashShortDash,
1880  LongDash2ShortDash,
1881  FineDot,
1882  };
1883 
1884 private:
1886  LinePattern();
1887 };
1888 
1889 
1890 //Begin Glyphs
1892 class HPS_API Glyph
1893 {
1894 public:
1897  enum class Fill
1898  {
1899  Unfilled,
1900  ContinuousFill,
1901  NewFill
1902  };
1903 
1906  enum class ColorSource
1907  {
1908  Normal,
1909  Explicit,
1910  Indexed
1911  };
1912 
1916  enum class Default
1917  {
1918  Circle,
1919  CircleWithDot,
1920  CircleWithPlus,
1921  CircleWithTimes,
1922  CircleWithCircle,
1923  SolidCircle,
1924  Dot,
1925  Plus,
1926  Times,
1927  Splat,
1928  Box,
1929  BoxWithDot,
1930  BoxWithTimes,
1931  SolidBox,
1932  Diamond,
1933  DiamondWithDot,
1934  DiamondWithPlus,
1935  SolidDiamond,
1936  TriangleUp,
1937  TriangleUpWithDot,
1938  SolidTriangleUp,
1939  TriangleDown,
1940  TriangleDownWithDot,
1941  SolidTriangleDown,
1942  TriangleRight,
1943  TriangleRightWithDot,
1944  SolidTriangleRight,
1945  TriangleLeft,
1946  TriangleLeftWithDot,
1947  SolidTriangleLeft,
1948  TriangleUpV,
1949  SolidTriangleUpV,
1950  TriangleDownV,
1951  SolidTriangleDownV,
1952  TriangleRightV,
1953  SolidTriangleRightV,
1954  TriangleLeftV,
1955  SolidTriangleLeftV,
1956  LetterY,
1957  LetterZ,
1958  CircleLetterY,
1959  CircleLetterZ,
1960  VerticalBar,
1961  HorizontalBar,
1962  SlantLeft,
1963  SlantRight,
1964  WidePlus,
1965  SolidWidePlus,
1966  WideTimes,
1967  SolidWideTimes,
1968  Pound,
1969  };
1970 
1971 private:
1973  Glyph();
1974 };
1975 
1976 
1978 class HPS_API Bounding
1979 {
1980 public:
1984  enum class Type
1985  {
1986  None,
1987  Sphere,
1988  Cuboid
1989  };
1990 
1991 private:
1992  Bounding() {}
1993 };
1994 
1996 class HPS_API Grid
1997 {
1998 public:
2001  enum class Type
2002  {
2003  Quadrilateral,
2004  Radial
2005  };
2006 
2007 private:
2008  Grid();
2009 };
2010 
2011 
2012 
2013 #ifdef _MSC_VER
2014 # ifndef HPS_INLINE
2015 # define HPS_INLINE __forceinline
2016 # endif
2017 #else
2018 # define HPS_INLINE inline
2019 #endif
2020 
2021 #ifndef HPS_UNREFERENCED
2022 #define HPS_UNREFERENCED(param) ((void)(param))
2023 #endif
2024 
2025 
2026 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2027 
2028 template<typename T>
2029 HPS_INLINE T Degrees_To_Radians(T const & degrees)
2030 {
2031  return degrees * (T)(PI / 180.0);
2032 }
2033 
2034 template<typename T>
2035 HPS_INLINE T Radians_To_Degrees(T const & radians)
2036 {
2037  return radians * (T)(180.0 / PI);
2038 }
2039 
2040 template<typename T>
2041 HPS_INLINE void SinCos(T const & angle, T & sine, T & cosine) {
2042  T a = Degrees_To_Radians(angle);
2043  cosine = cos(a);
2044  sine = sin(a);
2045 }
2046 
2047 template<typename T>
2048 HPS_INLINE T Cos(T const & angle) {
2049  return cos (Degrees_To_Radians(angle));
2050 }
2051 
2052 template<typename T>
2053 HPS_INLINE T Sin(T const & angle) {
2054  return sin (Degrees_To_Radians(angle));
2055 }
2056 
2057 template<typename T>
2058 HPS_INLINE T ACos(T const & x) {
2059  if (x > 1)
2060  return 0;
2061  if (x < -1)
2062  return 180;
2063  return Radians_To_Degrees(acos(x));
2064 }
2065 
2066 template<typename T>
2067 HPS_INLINE T ATan2(T const & y, T const & x) {
2068  if (x == 0 && y == 0)
2069  return 0;
2070  return Radians_To_Degrees(atan2(y, x));
2071 }
2072 
2073 
2074 template <typename F> struct Float_Traits {};
2075 template <> struct Float_Traits<float> {
2076  typedef double Alternative;
2077  static const int Type = 1;
2078  static float Epsilon () { return 1.0e-30f; }
2079 };
2080 template <> struct Float_Traits<double> {
2081  typedef float Alternative;
2082  static const int Type = 2;
2083  static double Epsilon () { return 1.0e-300; }
2084 };
2085 
2086 
2087 
2089 class HPS_API Float {
2090 private:
2091  enum Parts {
2092 # if HOOPS_BIGENDIAN
2093  High, Low
2094 # else
2095  Low, High
2096 # endif
2097  };
2098 
2099  // & functions for a float represented in an int, * version for a double in an array of 2 ints
2100  static HPS_INLINE bool is_infinite(int32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2101  static HPS_INLINE bool is_infinite(uint32_t const & v) { return (v & 0x7FFFFFFF) == 0x7F800000; }
2102  static HPS_INLINE bool is_infinite(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2103  static HPS_INLINE bool is_infinite(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2104 
2105  static HPS_INLINE bool is_nan(int32_t const & v) {
2106  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2107  return exp == 0x7F800000 && mantissa != 0;
2108  }
2109  static HPS_INLINE bool is_nan(uint32_t const & v) {
2110  uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2111  return exp == 0x7F800000 && mantissa != 0;
2112  }
2113  static HPS_INLINE bool is_nan(int32_t const * v) {
2114  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2115  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2116  }
2117  static HPS_INLINE bool is_nan(uint32_t const * v) {
2118  uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2119  return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2120  }
2121 
2122  static HPS_INLINE bool is_special(int32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2123  static HPS_INLINE bool is_special(uint32_t const & v) { return (v & 0x7F800000) == 0x7F800000; }
2124  static HPS_INLINE bool is_special(int32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2125  static HPS_INLINE bool is_special(uint32_t const * v) { return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2126 public:
2127 
2129  static const float Infinity;
2131  static const float NegativeInfinity;
2132 
2134  static HPS_INLINE bool IsInfinite(float const & a) { return is_infinite (extract_uint32_t(a)); }
2135  static HPS_INLINE bool IsInfinite(double const & a) {
2136  uint32_t v[2];
2137  memcpy (v, &a, sizeof(double));
2138  return is_infinite (v);
2139  }
2140 
2142  static HPS_INLINE bool IsNAN(float const & a) { return is_nan (extract_uint32_t(a)); }
2143  static HPS_INLINE bool IsNAN(double const & a) {
2144  uint32_t v[2];
2145  memcpy (v, &a, sizeof(double));
2146  return is_nan (v);
2147  }
2148 
2150  static HPS_INLINE bool IsAbnormal(float const & a) { return is_special (extract_uint32_t(a)); }
2151  static HPS_INLINE bool IsAbnormal(double const & a) {
2152  uint32_t v[2];
2153  memcpy (v, &a, sizeof(double));
2154  return is_special (v);
2155  }
2156 
2159  static HPS_INLINE bool Equals(float const & a, float const & b, int tolerance = 32);
2160  static HPS_INLINE bool Equals(double const & a, double const & b, int tolerance = 32);
2161 
2162 #ifndef HOOPS_DEFINED
2163  template <typename Alloc>
2164  static HPS_INLINE bool Equals(std::vector<float, Alloc> const & a, std::vector<float, Alloc> const & b, int tolerance = 32)
2165  {
2166  if (a.size() != b.size())
2167  return false;
2168 
2169  auto it1 = a.begin();
2170  auto it2 = b.begin();
2171  auto const end = a.end();
2172  for ( ; it1 != end; ++it1, ++it2)
2173  {
2174  if (!Equals(*it1, *it2, tolerance))
2175  return false;
2176  }
2177  return true;
2178  }
2179 #endif
2180 
2181  static HPS_INLINE uint32_t extract_sign_bit(float const & a) {
2182  return extract_uint32_t(a) & 0x80000000;
2183  }
2184  static HPS_INLINE uint32_t extract_sign_bit(double const & a) {
2185  uint32_t v[2];
2186  memcpy (v, &a, sizeof(double));
2187  return v[High] & 0x80000000;
2188  }
2189 
2190  static HPS_INLINE void apply_sign_bit(float & a, uint32_t const & sign_bit) {
2191  uint32_t v = extract_uint32_t(a);
2192  v &= 0x7FFFFFFF;
2193  v |= sign_bit;
2194  inject_uint32_t(a, v);
2195  }
2196  static HPS_INLINE void apply_sign_bit(double & a, uint32_t const & sign_bit) {
2197  uint32_t v[2];
2198  memcpy (v, &a, sizeof(double));
2199  v[High] &= 0x7FFFFFFF;
2200  v[High] |= sign_bit;
2201  memcpy (&a, v, sizeof(double));
2202  }
2203 
2204 
2205  static HPS_INLINE unsigned char unit_to_byte(float const & a) {
2206  uint32_t v = extract_uint32_t(a);
2207 
2208  v &= 0x7FFFFFFF;
2209  if (v < 0x3B800000)
2210  return 0;
2211 
2212  v--;
2213 
2214  uint32_t exp = v >> 23;
2215  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2216 
2217  return (unsigned char) (man >> (16 + 126 - exp));
2218  }
2219 
2220  static HPS_INLINE unsigned char unit_to_byte_scaled(float const & a, unsigned char mix) {
2221  uint32_t v = extract_uint32_t(a);
2222 
2223  v &= 0x7FFFFFFF;
2224  if (v < 0x3B800000)
2225  return 0;
2226 
2227  v--;
2228 
2229  uint32_t exp = v >> 23;
2230  uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2231 
2232  uint32_t x = (man >> (16 + 126 - exp));
2233 
2234  return (unsigned char) ((x * (mix+1)) >> 8);
2235  }
2236 
2237 
2238  static HPS_INLINE bool match(float const & a, float const & b) {
2239  uint32_t va = extract_uint32_t(a);
2240  uint32_t vb = extract_uint32_t(b);
2241 
2242  if (((va | vb) & 0x7FFFFFFF) == 0)
2243  return true;
2244 
2245  return va == vb;
2246  }
2247  static HPS_INLINE bool match(double const & a, double const & b) {
2248  return a == b;
2249  }
2250 
2251 
2252  static HPS_INLINE void replace_if_smaller(float & a, float const & b) {
2253  uint32_t va = extract_uint32_t(a);
2254  uint32_t vb = extract_uint32_t(b);
2255 
2256  uint32_t a_sign = va & 0x80000000;
2257  uint32_t b_sign = vb & 0x80000000;
2258 
2259  (int32_t&)a_sign >>= 31;
2260  (int32_t&)b_sign >>= 31;
2261 
2262  uint32_t mash = (a_sign&b_sign);
2263 
2264  va ^= mash;
2265  vb ^= mash;
2266 
2267  if ((int32_t&)vb < (int32_t&)va)
2268  memcpy(&a, &b, sizeof(float));
2269  }
2270  static HPS_INLINE void replace_if_smaller(double & a, double const & b) {
2271  if (b < a)
2272  a = b;
2273  }
2274 
2275  static HPS_INLINE void replace_if_larger(float & a, float const & b) {
2276  uint32_t va = extract_uint32_t(a);
2277  uint32_t vb = extract_uint32_t(b);
2278 
2279  uint32_t a_sign = va & 0x80000000;
2280  uint32_t b_sign = vb & 0x80000000;
2281 
2282  (int32_t&)a_sign >>= 31;
2283  (int32_t&)b_sign >>= 31;
2284 
2285  uint32_t mash = (a_sign&b_sign);
2286 
2287  va ^= mash;
2288  vb ^= mash;
2289 
2290  if ((int32_t&)vb > (int32_t&)va)
2291  memcpy(&a, &b, sizeof(float));
2292  }
2293  static HPS_INLINE void replace_if_larger(double & a, double const & b) {
2294  if (b > a)
2295  a = b;
2296  }
2297 
2298 
2299  static HPS_INLINE uint32_t extract_uint32_t(float const & a) {
2300  uint32_t i;
2301  memcpy(&i, &a, sizeof(float));
2302  return i;
2303  }
2304 
2305  static HPS_INLINE void inject_uint32_t(float & a, uint32_t const & i) {
2306  memcpy(&a, &i, sizeof(float));
2307  }
2308 
2309  static HPS_INLINE float C2F(unsigned char x) {
2310  //return (float)x * (1.0f/255.0f);
2311  return char_to_float[x];
2312  }
2313 
2314 
2315  // SSE convenience functions
2316  static HPS_INLINE void pack_4(float const & f, float * m) {
2317  memcpy(&m[0], &f, sizeof(float));
2318  memcpy(&m[1], &f, sizeof(float));
2319  memcpy(&m[2], &f, sizeof(float));
2320  memcpy(&m[3], &f, sizeof(float));
2321  }
2322 
2323  static HPS_INLINE void pack_4(float const & f0, float const & f1, float const & f2, float const & f3, float * m) {
2324  memcpy(&m[0], &f0, sizeof(float));
2325  memcpy(&m[1], &f1, sizeof(float));
2326  memcpy(&m[2], &f2, sizeof(float));
2327  memcpy(&m[3], &f3, sizeof(float));
2328  }
2329 
2330  static HPS_INLINE void unpack_4(float * f0, float const * const m) {
2331  memcpy(f0, m, sizeof(float)*4);
2332  }
2333 
2334  static HPS_INLINE void unpack_4(float & f0, float & f1, float & f2, float & f3, float const * const m) {
2335  memcpy(&f0, &m[0], sizeof(float));
2336  memcpy(&f1, &m[1], sizeof(float));
2337  memcpy(&f2, &m[2], sizeof(float));
2338  memcpy(&f3, &m[3], sizeof(float));
2339  }
2340 
2341 private:
2342  static const float char_to_float[256];
2343 
2344  Float();
2345 };
2346 
2347 
2349 
2350 
2351 template <typename T> HPS_INLINE T * Alter (T const * a) { return const_cast<T *>(a); }
2352 template <typename T> HPS_INLINE T & Alter (T const & a) { return const_cast<T &>(a); }
2353 
2354 template <typename T> HPS_INLINE T Abs (T const & a) { return a < 0 ? -a : a; }
2355 template <typename T> HPS_INLINE int Compare (T const & a, T const & b) { return a == b ? 0 : a < b ? -1 : 1; }
2356 template <typename T> HPS_INLINE int Sign (T const & a) { return Compare(a,(T)0); }
2357 template <typename T> HPS_INLINE void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2358 template <typename T> HPS_INLINE int Floor(T const & a) { return ((a > 0 || (T)(int)a == a) ? (int)a : ((int)a - 1)); }
2359 template <typename T> HPS_INLINE int Ceiling(T const & a) { return ((a < 0 || (T)(int)a == a) ? (int)a : ((int)a + 1)); }
2360 
2361 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b) { return a < b ? a : b; }
2362 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c) { return Min(Min(a,b),c); }
2363 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c, T const & d) { return Min(Min(a, b, c),d); }
2364 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c, T const & d, T const & e) { return Min(Min(a,b,c,d),e); }
2365 template <typename T> HPS_INLINE T const & Min (T const & a, T const & b, T const & c, T const & d, T const & e, T const & f) { return Min(Min(a,b,c,d,e),f); }
2366 
2367 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b) { return a > b ? a : b; }
2368 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c) { return Max(Max(a,b),c); }
2369 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c, T const & d) { return Max(Max(a, b, c),d); }
2370 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c, T const & d, T const & e) { return Max(Max(a,b,c,d),e); }
2371 template <typename T> HPS_INLINE T const & Max (T const & a, T const & b, T const & c, T const & d, T const & e, T const & f) { return Max(Max(a,b,c,d,e),f); }
2372 
2373 template <typename T> HPS_INLINE T const & Clamp(T const & x, T const & min, T const & max) { return x < min ? min : x > max ? max : x; }
2374 
2375 
2376 template <> HPS_INLINE float Abs<float> (float const & a) {
2377  uint32_t v = Float::extract_uint32_t(a);
2378  v &= 0x7FFFFFFF;
2379  float f;
2380  Float::inject_uint32_t(f,v);
2381  return f;
2382 }
2383 
2384 template <> HPS_INLINE int Sign<float> (float const & a) {
2385  uint32_t v = Float::extract_uint32_t(a);
2386 
2387  if ((v & 0x7FFFFFFF) == 0)
2388  return 0;
2389 
2390  return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2391 }
2392 
2393 template <> HPS_INLINE int Compare<float> (float const & a, float const & b) {
2394  int a_sign = Sign(a);
2395  int b_sign = Sign(b);
2396 
2397  if (a_sign != b_sign)
2398  return Compare(a_sign, b_sign);
2399 
2400  uint32_t v = Float::extract_uint32_t(a);
2401  uint32_t u = Float::extract_uint32_t(b);
2402 
2403  return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2404 }
2405 
2406 template <> HPS_INLINE float const & Min<float> (float const & a, float const & b) {
2407  if (Compare(a,b)>0)
2408  return b;
2409  return a;
2410 }
2411 
2412 template <> HPS_INLINE float const & Max<float> (float const & a, float const & b) {
2413  if (Compare(a,b)>0)
2414  return a;
2415  return b;
2416 }
2417 
2418 
2420 
2421 HPS_INLINE bool Float::Equals(float const & a, float const & b, int tolerance) {
2422  int32_t va = Float::extract_uint32_t(a);
2423  int32_t vb = Float::extract_uint32_t(b);
2424 
2425  if (is_special(va) || is_special(vb)) {
2426  if (is_infinite(va) || is_infinite(vb))
2427  return va == vb; // final check is for sign bits same
2428  if (is_nan(va) || is_nan(vb))
2429  return false;
2430  }
2431 
2432  int const close_to_zero = 0x36A00000; // (approx) 5.0e-6f;
2433  if ((va & 0x7FFFFFFF) == 0)
2434  return (vb & 0x7FFFFFFF) < close_to_zero;
2435  else if ((vb & 0x7FFFFFFF) == 0)
2436  return (va & 0x7FFFFFFF) < close_to_zero;
2437 
2438  uint32_t sign_mask = va ^ vb;
2439  (int32_t &)sign_mask >>= 31;
2440 
2441  int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2442  int32_t v1 = tolerance + diff;
2443  int32_t v2 = tolerance - diff;
2444  return (v1|v2) >= 0;
2445 }
2446 
2447 HPS_INLINE bool Float::Equals(double const & a, double const & b, int tolerance) {
2448  int32_t va[2], vb[2];
2449  memcpy (va, &a, sizeof(double));
2450  memcpy (vb, &b, sizeof(double));
2451 
2452  if (is_special(va) || is_special(vb)) {
2453  if (is_infinite(va) || is_infinite(vb))
2454  return va[High] == vb[High] && va[Low] == vb[Low]; // final check is for sign bits same
2455  if (is_nan(va) || is_nan(vb))
2456  return false;
2457  }
2458 
2459  if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2460  return Abs(a - b) < 0.000000000000005;
2461 
2462  if (extract_sign_bit(a) != extract_sign_bit(b))
2463  return a == b;
2464 
2465  if (va[High] != vb[High])
2466  return false;
2467 
2468  return Abs(va[Low] - vb[Low]) <= tolerance;
2469 }
2470 
2472 
2473 
2474 HPS_INLINE bool Is_Abnormal (float const & f) { return Float::IsAbnormal (f); }
2475 HPS_INLINE bool Is_Abnormal (double const & d) { return Float::IsAbnormal (d); }
2476 
2477 template <typename T>
2478 HPS_INLINE bool Is_Abnormal (size_t count, T const * t) {
2479  while (count-- > 0)
2480  if (Is_Abnormal (*t++))
2481  return true;
2482  return false;
2483 }
2484 
2485 template <typename T>
2486 HPS_INLINE bool Is_Abnormal (int count, T const * t) {
2487  return count >= 0 && Is_Abnormal((size_t)count, t);
2488 }
2489 
2490 
2492 
2493 
2494 template <typename F> class HPS_TEMPLATE_API Vector_3D;
2495 template <typename F> class HPS_TEMPLATE_API Plane_3D;
2496 template <typename F> class HPS_TEMPLATE_API Vector_2D;
2497 template <typename F> class HPS_TEMPLATE_API Point_2D;
2498 
2499 
2500 template <typename F>
2501 class HPS_TEMPLATE_API Point_3D {
2502  public:
2503  F x;
2504  F y;
2505  F z;
2506 
2507  Point_3D () {}
2508  Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2509 
2510  template <typename D>
2511  explicit Point_3D (Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2512 
2513  explicit Point_3D (Vector_3D<F> const & v);
2514  explicit Point_3D (Vector_2D<F> const & v);
2515  explicit Point_3D (Point_2D<F> const & that);
2516 
2517  Point_3D const operator- () const { return Point_3D (-x, -y, -z); }
2518 
2519  bool operator== (Point_3D const & p) const { return x == p.x && y == p.y && z == p.z; }
2520  bool operator!= (Point_3D const & p) const { return !(*this == p); }
2521 
2522  bool Equals(Point_3D const & p, int in_tolerance = 32) const {
2523  return Float::Equals(x, p.x, in_tolerance) &&
2524  Float::Equals(y, p.y, in_tolerance) &&
2525  Float::Equals(z, p.z, in_tolerance);
2526  }
2527 
2528 
2529  Point_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2530  Point_3D & operator/= (F s) { return operator*= ((F)1 / s); }
2531  Point_3D const operator* (F s) const { return Point_3D (x * s, y * s, z * s); }
2532  Point_3D const operator/ (F s) const { return operator* ((F)1 / s); }
2533 
2534  F & operator[] (size_t i) { return (&x)[i]; }
2535  F const & operator[] (size_t i) const { return (&x)[i]; }
2536 
2537  Point_3D & operator+= (Vector_3D<F> const & v);
2538  Point_3D & operator-= (Vector_3D<F> const & v);
2539  Point_3D & operator*= (Vector_3D<F> const & v);
2540  Point_3D & operator/= (Vector_3D<F> const & v);
2541  Point_3D const operator* (Vector_3D<F> const & v) const;
2542  Point_3D const operator/ (Vector_3D<F> const & v) const;
2543 
2544  Point_3D & operator+= (Vector_2D<F> const & v);
2545  Point_3D & operator-= (Vector_2D<F> const & v);
2546  Point_3D & operator*= (Vector_2D<F> const & v);
2547  Point_3D & operator/= (Vector_2D<F> const & v);
2548  Point_3D const operator* (Vector_2D<F> const & v) const;
2549  Point_3D const operator/ (Vector_2D<F> const & v) const;
2550 
2551  Vector_3D<F> const operator- (Point_3D const & p) const;
2552 
2553  Point_3D const operator+ (Vector_3D<F> const & v) const;
2554  Point_3D const operator- (Vector_3D<F> const & v) const;
2555 
2556  Point_3D const operator+ (Vector_2D<F> const & v) const;
2557  Point_3D const operator- (Vector_2D<F> const & v) const;
2558 
2559  static HPS_INLINE Point_3D Origin() {return Point_3D (0, 0, 0);};
2560  static HPS_INLINE Point_3D Zero() {return Point_3D (0, 0, 0);}; //-V524
2561 };
2562 
2563 typedef Point_3D<float> Point;
2564 typedef Point_3D<double> DPoint;
2565 
2566 
2567 
2568 template <typename F, typename S>
2569 HPS_INLINE Point_3D<F> operator* (S s, Point_3D<F> const & a) { return Point_3D<F> (F(s * a.x), F(s * a.y), F(s * a.z)); }
2570 
2571 template <typename F>
2572 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b) {
2573  return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2574 }
2575 
2576 template <typename F>
2577 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2578  return Point_3D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2579 }
2580 
2581 template <typename F>
2582 HPS_INLINE bool Is_Abnormal (Point_3D<F> const & p) {
2583  return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2584 }
2585 
2586 
2587 template <typename F>
2588 class HPS_TEMPLATE_API Point_2D {
2589 public:
2590  F x;
2591  F y;
2592 
2593  Point_2D () {}
2594  Point_2D (F v1, F v2) : x (v1), y (v2) {}
2595 
2596  template <typename D>
2597  explicit Point_2D (Point_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2598 
2599  explicit Point_2D (Point_3D<F> const & that) : x ((F)that.x), y ((F)that.y) {}
2600  explicit Point_2D (Vector_2D<F> const & v);
2601 
2602  Point_2D const operator- () const { return Point_2D (-x, -y); }
2603 
2604  bool operator== (Point_2D const & p) const { return x == p.x && y == p.y; }
2605  bool operator!= (Point_2D const & p) const { return !(*this == p); }
2606 
2607  bool Equals(Point_2D const & p, int in_tolerance = 32) const {
2608  return Float::Equals(x, p.x, in_tolerance) && Float::Equals(y, p.y, in_tolerance);
2609  }
2610 
2611 
2612  Point_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2613  Point_2D & operator/= (F s) { return operator*= ((F)1 / s); }
2614  Point_2D const operator* (F s) const { return Point_2D (x * s, y * s); }
2615  Point_2D const operator/ (F s) const { return operator* ((F)1 / s); }
2616 
2617  F & operator[] (size_t i) { return (&x)[i]; }
2618  F const & operator[] (size_t i) const { return (&x)[i]; }
2619 
2620  Point_2D & operator+= (Vector_2D<F> const & v);
2621  Point_2D & operator-= (Vector_2D<F> const & v);
2622  Point_2D & operator*= (Vector_2D<F> const & v);
2623  Point_2D & operator/= (Vector_2D<F> const & v);
2624  Point_2D const operator* (Vector_2D<F> const & v) const;
2625  Point_2D const operator/ (Vector_2D<F> const & v) const;
2626 
2627  Vector_2D<F> const operator- (Point_2D const & p) const;
2628 
2629  Point_2D const operator+ (Vector_2D<F> const & v) const;
2630  Point_2D const operator- (Vector_2D<F> const & v) const;
2631 
2632  static HPS_INLINE Point_2D Origin() {return Point_2D (0, 0);};
2633  static HPS_INLINE Point_2D Zero() {return Point_2D (0, 0);}; //-V524
2634 };
2635 
2636 typedef Point_2D<float> Point2D;
2637 typedef Point_2D<double> DPoint2D;
2638 
2639 template <typename F>
2640 HPS_INLINE Point_3D<F>::Point_3D (Point_2D<F> const & that) : x (that.x), y (that.y), z (0) {}
2641 
2642 template <typename F, typename S>
2643 HPS_INLINE Point_2D<F> operator* (S s, Point_2D<F> const & a) { return Point_2D<F> (F(s * a.x), F(s * a.y)); }
2644 
2645 template <typename F>
2646 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b) {
2647  return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2648 }
2649 
2650 template <typename F>
2651 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F> const & a, Point_2D<F> const & b, Point_2D<F> const & c) {
2652  return Point_2D<F> (a.x + b.x + c.x, a.y + b.y + c.y, a.z + b.z + c.z) * (F)(1.0/3.0);
2653 }
2654 
2655 template <typename F>
2656 HPS_INLINE bool Is_Abnormal (Point_2D<F> const & p) {
2657  return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2658 }
2659 
2660 
2661 template <typename F>
2662 class HPS_TEMPLATE_API Vector_3D {
2663  public:
2664  F x;
2665  F y;
2666  F z;
2667 
2668  Vector_3D () {}
2669  Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2670  template <typename D>
2671  explicit Vector_3D (Vector_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2672  explicit Vector_3D(Point_3D<F> const & p) : x(p.x), y(p.y), z(p.z) {}
2673  explicit Vector_3D(Plane_3D<F> const & p);
2674 
2675  explicit Vector_3D (Vector_2D<F> const & that);
2676 
2677  Vector_3D const operator- () const { return Vector_3D (-x, -y, -z); }
2678 
2679  bool operator== (Vector_3D const & v) const {
2680  return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2681  }
2682  bool operator!= (Vector_3D const & v) const { return !(*this == v); }
2683 
2684  bool Equals(Vector_3D const & v, int in_tolerance = 32) const {
2685  return Float::Equals(x, v.x, in_tolerance) &&
2686  Float::Equals(y, v.y, in_tolerance) &&
2687  Float::Equals(z, v.z, in_tolerance);
2688  }
2689 
2690  Vector_3D & operator+= (Vector_3D const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2691  Vector_3D & operator-= (Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2692  Vector_3D const operator+ (Vector_3D const & v) const { return Vector_3D (x + v.x, y + v.y, z + v.z); }
2693  Vector_3D const operator- (Vector_3D const & v) const { return Vector_3D (x - v.x, y - v.y, z - v.z); }
2694 
2695  Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s; return *this; }
2696  Vector_3D & operator/= (F s) { return operator*= (1.0f / s); }
2697  Vector_3D const operator* (F s) const { return Vector_3D (x * s, y * s, z * s); }
2698  Vector_3D const operator/ (F s) const { return operator* (1.0f / s); }
2699 
2700  F & operator[] (size_t i) { return (&x)[i]; }
2701  F const & operator[] (size_t i) const { return (&x)[i]; }
2702 
2703  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2704 
2705  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y + (double)z*(double)z; }
2706 
2707  HPS_INLINE double Length2D () const { return sqrt (LengthSquared2D()); }
2708 
2709  HPS_INLINE double LengthSquared2D () const { return (double)x*(double)x + (double)y*(double)y;}
2710 
2711  HPS_INLINE Vector_3D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2712  if (check_range) {
2713  F range = Max (Abs (x), Abs (y), Abs (z));
2714  if (range > F(1.0e10))
2715  operator/= (range);
2716  }
2717 
2718  F len = (F)Length();
2719  if (len > epsilon)
2720  operator/= (len);
2721  else
2722  *this = Zero();
2723  return *this;
2724  }
2725  HPS_INLINE Vector_3D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2726 
2727  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y), Abs(z)); }
2728  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y)+Abs(z); }
2729 
2730  HPS_INLINE F Dot (Vector_3D const & v) const { return x * v.x + y * v.y + z * v.z; }
2731 
2732  HPS_INLINE Vector_3D Cross (Vector_3D const & v) const {
2733  return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2734  }
2735 
2736 
2737  HPS_INLINE Vector_3D Scale (Vector_3D const & v) const {
2738  return Vector_3D (x * v.x, y * v.y, z * v.z);
2739  }
2740 
2741  static HPS_INLINE Vector_3D XAxis() {return Vector_3D (1, 0, 0);};
2742  static HPS_INLINE Vector_3D YAxis() {return Vector_3D (0, 1, 0);};
2743  static HPS_INLINE Vector_3D ZAxis() {return Vector_3D (0, 0, 1);};
2744  static HPS_INLINE Vector_3D Zero() {return Vector_3D (0, 0, 0);};
2745  static HPS_INLINE Vector_3D Unit() {return Vector_3D (1, 1, 1);};
2746 };
2747 
2748 typedef Vector_3D<float> Vector;
2749 typedef Vector_3D<double> DVector;
2750 
2751 
2752 template <typename F, typename S>
2753 HPS_INLINE Vector_3D<F> operator* (S s, Vector_3D<F> const & v) {return Vector_3D<F> (F(s * v.x), F(s * v.y), F(s * v.z)); }
2754 
2755 template <typename F>
2756 HPS_INLINE bool Is_Abnormal (Vector_3D<F> const & v) {
2757  return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2758 }
2759 
2760 
2761 template <typename F>
2762 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F> const & v) : x(v.x), y(v.y), z(v.z) {}
2763 
2764 template <typename F>
2765 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_3D<F> const & v) { x += v.x; y += v.y; z += v.z; return *this; }
2766 template <typename F>
2767 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_3D<F> const & v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
2768 
2769 template <typename F>
2770 HPS_INLINE Vector_3D<F> const Point_3D<F>::operator- (Point_3D<F> const & p) const { return Vector_3D<F> (x - p.x, y - p.y, z - p.z); }
2771 
2772 template <typename F>
2773 HPS_INLINE Point_3D<F> const Point_3D<F>::operator+ (Vector_3D<F> const & v) const { return Point_3D<F> (x + v.x, y + v.y, z + v.z); }
2774 template <typename F>
2775 HPS_INLINE Point_3D<F> const Point_3D<F>::operator- (Vector_3D<F> const & v) const { return Point_3D<F> (x - v.x, y - v.y, z - v.z); }
2776 
2777 template <typename F>
2778 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_3D<F> const & v) { x *= v.x; y *= v.y; z *= v.z; return *this; }
2779 template <typename F>
2780 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_3D<F> const & v) { x /= v.x; y /= v.y; z /= v.z; return *this; }
2781 template <typename F>
2782 HPS_INLINE Point_3D<F> const Point_3D<F>::operator* (Vector_3D<F> const & v) const { return Point_3D<F> (x * v.x, y * v.y, z * v.z); }
2783 template <typename F>
2784 HPS_INLINE Point_3D<F> const Point_3D<F>::operator/ (Vector_3D<F> const & v) const { return Point_3D<F> (x / v.x, y / v.y, z / v.z); }
2785 
2786 
2787 
2788 template <typename F>
2789 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F> const & a, Point_3D<F> const & b, float t) {
2790  return a + (b - a) * t;
2791 }
2792 
2793 template <typename F>
2794 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F> const & a, Vector_3D<F> const & b, float t) {
2795  return Vector_3D<F>(a + (b - a) * t).Normalize();
2796 }
2797 
2798 
2799 
2800 template <typename F>
2801 HPS_INLINE double PointToPointDistance(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2802  return (p2 - p1).Length();
2803 }
2804 
2805 template <typename F>
2806 HPS_INLINE double PointToPointDistanceSquared(Point_3D<F> const & p1, Point_3D<F> const & p2) {
2807  return (p2 - p1).LengthSquared();
2808 }
2809 
2810 template <typename F>
2811 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F> const & a, Point_3D<F> const & b, Point_3D<F> const & c) {
2812  F p = static_cast<F>((c - b).LengthSquared());
2813  F q = static_cast<F>((c - a).LengthSquared());
2814  F r = static_cast<F>((b - a).LengthSquared());
2815 
2816  return Point_3D<F>(
2817  (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2818  / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2819 }
2820 
2821 
2822 
2823 template <typename F>
2824 HPS_INLINE bool Normalize(size_t count, Vector_3D<F> * vectors) {
2825  bool success = true;
2826  for (size_t i = 0; i < count; ++i) {
2827  if (vectors->Normalize() == Vector_3D<F>::Zero())
2828  success = false;
2829  vectors++;
2830  }
2831  return success;
2832 }
2833 
2834 
2835 template <typename F> class HPS_TEMPLATE_API Plane_2D;
2836 
2837 template <typename F>
2838 class HPS_TEMPLATE_API Vector_2D {
2839 public:
2840  F x;
2841  F y;
2842 
2843  Vector_2D () {}
2844  Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2845  template <typename D>
2846  explicit Vector_2D (Vector_2D<D> const & that) : x ((F)that.x), y ((F)that.y) {}
2847 
2848  explicit Vector_2D (Vector_3D<F> const & that) : x (that.x), y (that.y) {}
2849  explicit Vector_2D (Point_2D<F> const & p) : x(p.x), y(p.y) {}
2850  explicit Vector_2D (Plane_2D<F> const & p);
2851 
2852  Vector_2D const operator- () const { return Vector_2D (-x, -y); }
2853 
2854  bool operator== (Vector_2D const & v) const {
2855  return Float::match(x, v.x) && Float::match(y, v.y);
2856  }
2857  bool operator!= (Vector_2D const & v) const { return !(*this == v); }
2858 
2859  bool Equals(Vector_2D const & v, int in_tolerance = 32) const {
2860  return Float::Equals(x, v.x, in_tolerance) && Float::Equals(y, v.y, in_tolerance);
2861  }
2862 
2863  Vector_2D & operator+= (Vector_2D const & v) { x += v.x; y += v.y; return *this; }
2864  Vector_2D & operator-= (Vector_2D const & v) { x -= v.x; y -= v.y; return *this; }
2865  Vector_2D const operator+ (Vector_2D const & v) const { return Vector_2D (x + v.x, y + v.y); }
2866  Vector_2D const operator- (Vector_2D const & v) const { return Vector_2D (x - v.x, y - v.y); }
2867 
2868  Vector_2D & operator*= (F s) { x *= s; y *= s; return *this; }
2869  Vector_2D & operator/= (F s) { return operator*= (1.0f / s); }
2870  Vector_2D const operator* (F s) const { return Vector_2D (x * s, y * s); }
2871  Vector_2D const operator/ (F s) const { return operator* (1.0f / s); }
2872 
2873  F & operator[] (size_t i) { return (&x)[i]; }
2874  F const & operator[] (size_t i) const { return (&x)[i]; }
2875 
2876  HPS_INLINE double Length () const { return sqrt (LengthSquared()); }
2877 
2878  HPS_INLINE double LengthSquared () const { return (double)x*(double)x + (double)y*(double)y; }
2879 
2880  HPS_INLINE Vector_2D & Normalize (bool check_range = false, F epsilon = Float_Traits<F>::Epsilon()) {// not const &; allow V.normalize() *= S;
2881  if (check_range) {
2882  F range = Max (Abs (x), Abs (y));
2883  if (range > F(1.0e10))
2884  operator/= (range);
2885  }
2886 
2887  F len = (F)Length();
2888  if (len > epsilon)
2889  operator/= (len);
2890  else
2891  *this = Zero();
2892  return *this;
2893  }
2894  HPS_INLINE Vector_2D & Normalize (F epsilon) { return Normalize (false, epsilon); }
2895 
2896  HPS_INLINE F Magnitude () const { return Max (Abs(x), Abs(y)); }
2897  HPS_INLINE F Manhattan () const { return Abs(x)+Abs(y); }
2898 
2899  HPS_INLINE F Dot (Vector_2D const & v) const { return x * v.x + y * v.y; }
2900 
2901 
2902  HPS_INLINE float Cross (Vector_2D const & v) const {
2903  return x * v.y - y * v.x;
2904  }
2905 
2906  HPS_INLINE Vector_2D Scale (Vector_2D const & v) const {
2907  return Vector_2D (x * v.x, y * v.y);
2908  }
2909 
2910  static HPS_INLINE Vector_2D XAxis() {return Vector_2D (1, 0);};
2911  static HPS_INLINE Vector_2D YAxis() {return Vector_2D (0, 1);};
2912 
2913  static HPS_INLINE Vector_2D Zero() {return Vector_2D (0, 0);};
2914  static HPS_INLINE Vector_2D Unit() {return Vector_2D (1, 1);};
2915 };
2916 
2917 typedef Vector_2D<float> Vector2D;
2919 
2920 template <typename F, typename S>
2921 HPS_INLINE Vector_2D<F> operator* (S s, Vector_2D<F> const & v) {return Vector_2D<F> (F(s * v.x), F(s * v.y)); }
2922 
2923 template <typename F>
2924 HPS_INLINE bool Is_Abnormal (Vector_2D<F> const & v) {
2925  return Is_Abnormal (v.x) || Is_Abnormal (v.y);
2926 }
2927 
2928 
2929 template <typename F>
2930 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F> const & that) : x (that.x), y (that.y), z(0) {}
2931 
2932 template <typename F>
2933 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F> const & v) : x(v.x), y(v.y), z(0) {}
2934 
2935 template <typename F>
2936 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
2937 template <typename F>
2938 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
2939 
2940 template <typename F>
2941 HPS_INLINE Point_3D<F> const Point_3D<F>::operator+ (Vector_2D<F> const & v) const { return Point_3D<F> (x + v.x, y + v.y, z); }
2942 template <typename F>
2943 HPS_INLINE Point_3D<F> const Point_3D<F>::operator- (Vector_2D<F> const & v) const { return Point_3D<F> (x - v.x, y - v.y, z); }
2944 
2945 template <typename F>
2946 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
2947 template <typename F>
2948 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
2949 
2950 template <typename F>
2951 HPS_INLINE Point_3D<F> const Point_3D<F>::operator* (Vector_2D<F> const & v) const { return Point_3D<F> (x * v.x, y * v.y, z); }
2952 template <typename F>
2953 HPS_INLINE Point_3D<F> const Point_3D<F>::operator/ (Vector_2D<F> const & v) const { return Point_3D<F> (x / v.x, y / v.y, z); }
2954 
2955 
2956 template <typename F>
2957 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F> const & v) { x += v.x; y += v.y; return *this; }
2958 template <typename F>
2959 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F> const & v) { x -= v.x; y -= v.y; return *this; }
2960 
2961 template <typename F>
2962 HPS_INLINE Vector_2D<F> const Point_2D<F>::operator- (Point_2D<F> const & p) const { return Vector_2D<F> (x - p.x, y - p.y); }
2963 
2964 template <typename F>
2965 HPS_INLINE Point_2D<F> const Point_2D<F>::operator+ (Vector_2D<F> const & v) const { return Point_2D<F> (x + v.x, y + v.y); }
2966 template <typename F>
2967 HPS_INLINE Point_2D<F> const Point_2D<F>::operator- (Vector_2D<F> const & v) const { return Point_2D<F> (x - v.x, y - v.y); }
2968 
2969 template <typename F>
2970 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F> const & v) { x *= v.x; y *= v.y; return *this; }
2971 template <typename F>
2972 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F> const & v) { x /= v.x; y /= v.y; return *this; }
2973 template <typename F>
2974 HPS_INLINE Point_2D<F> const Point_2D<F>::operator* (Vector_2D<F> const & v) const { return Point_2D<F> (x * v.x, y * v.y); }
2975 template <typename F>
2976 HPS_INLINE Point_2D<F> const Point_2D<F>::operator/ (Vector_2D<F> const & v) const { return Point_2D<F> (x / v.x, y / v.y); }
2977 
2978 
2979 
2980 
2981 
2982 template <typename F>
2983 class HPS_TEMPLATE_API Plane_3D {
2984  public:
2985  F a;
2986  F b;
2987  F c;
2988  F d;
2989 
2990  Plane_3D () {}
2991  Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
2992  Plane_3D (Vector_3D<F> const & v, F f = 0) : a (v.x), b (v.y), c (v.z), d (f) {}
2993  Plane_3D (Vector_3D<F> const & v, Point_3D<F> const & p) : a (v.x), b (v.y), c (v.z), d (-(p.x * v.x + p.y * v.y + p.z * v.z)) {}
2994  Plane_3D (Point_3D<F> const & p, Vector_3D<F> const & v) : a (v.x), b (v.y), c (v.z), d (-(p.x * v.x + p.y * v.y + p.z * v.z)) {}
2995  template <typename D>
2996  explicit Plane_3D (Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
2997 
2998  Plane_3D (size_t count, Point_3D<F> const * points) {
2999  if (count >= 3) {
3000  // The 3 coefficients A, B, and C are proportional to the areas of the
3001  // projections of the polygon onto the yz, zx, and xy planes, respectively.
3002 
3003  // run around the polygon, collecting trapezoidal areas
3004  // a "center" point is also collected, to make the plane 'd' slightly more "valid" when the polygon is non-planar.
3005 
3006  // take care of the swing point first
3007  Point_3D<F> const * p0 = &points[count-1];
3008 
3010  Vector_3D<F> normal = Vector_3D<F>::Zero();
3011 
3012  for (size_t i=0; i<count; ++i) {
3013  Point_3D<F> const * p1 = &points[i];
3014 
3015  normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3016  normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3017  normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3018 
3019  ctr += Vector_3D<double>(Vector_3D<F>(points[i]));
3020 
3021  p0 = p1;
3022  }
3023 
3024  // ("should" always be != 0)
3025  if (normal.Normalize() != Vector_3D<F>::Zero()) {
3026  /* finish finding the average */
3027  double inv_count = 1.0 / (double)count;
3028  ctr *= inv_count;
3029 
3030  *this = Plane_3D(normal, Point_3D<F>(ctr));
3031  return;
3032  }
3033  }
3034 
3035  *this = Plane_3D::Zero();
3036  }
3037 
3038 
3039  Plane_3D const operator- () const { return Plane_3D (-a, -b, -c, -d); }
3040 
3041  bool operator== (Plane_3D const & p) const { return a == p.a && b == p.b && c == p.c && d == p.d; }
3042  bool operator!= (Plane_3D const & p) const { return !(*this == p); }
3043 
3044  F & operator[] (size_t i) { return (&a)[i]; }
3045  F const & operator[] (size_t i) const { return (&a)[i]; }
3046 
3047  HPS_INLINE bool Equals(Plane_3D const & p, int in_tolerance = 32) const {
3048  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) &&
3049  Float::Equals(c, p.c, in_tolerance) && Float::Equals(d, p.d, in_tolerance);
3050  }
3051 
3052  Plane_3D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.normalize() *= S;
3053  F len = (F)Vector_3D<F>(*this).Length();
3054  if (len > epsilon)
3055  operator/= (len);
3056  else
3057  *this = Zero();
3058  return *this;
3059  }
3060 
3061  Point_3D<F> IntersectLineSegment(Point_3D<F> const & p1, Point_3D<F> const & p2, float eps = 1e-5f) const {
3062  F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3063  F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3064 
3065  if (val1 >= eps) {
3066  return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3067  ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3068  ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3069  }
3070  else
3071  return p1;
3072  }
3073 
3074  Point_3D<F> IntersectLineSegment2(Point_3D<F> const & p1, Point_3D<F> const & p2) const {
3075  F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3076  (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3077 
3078  return Point_3D<F>(p1.x + u * (p2.x - p1.x), p1.y + u * (p2.y - p1.y), p1.z + u * (p2.z - p1.z));
3079  }
3080 
3081  static HPS_INLINE Plane_3D Zero() {return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3082 
3083 
3084  private:
3085  Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s; return *this; }
3086  Plane_3D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3087  Plane_3D const operator* (F s) const { return Plane_3D (a * s, b * s, c * s, d * s); }
3088  Plane_3D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3089 };
3090 
3091 typedef Plane_3D<float> Plane;
3092 typedef Plane_3D<double> DPlane;
3093 
3094 
3095 template <typename F>
3096 HPS_INLINE bool Is_Abnormal (Plane_3D<F> const & p) {
3097  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3098 }
3099 
3100 
3101 template <typename F>
3102 HPS_INLINE F operator* (Plane_3D<F> const & plane, Point_3D<F> const & point) {
3103  return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3104 }
3105 template <typename F>
3106 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_3D<F> const & plane) {
3107  return plane * point;
3108 }
3109 
3110 template <typename F>
3111 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F> const & a, Plane_3D<F> const & b, float t) {
3112  return Plane_3D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t, a.d + (b.d - a.d) * t);
3113 }
3114 
3115 template <typename F>
3116 Vector_3D<F>::Vector_3D(Plane_3D<F> const & p) : x(p.a), y(p.b), z(p.c) {}
3117 
3118 
3119 
3120 
3121 
3122 
3123 template <typename F>
3124 class HPS_TEMPLATE_API Plane_2D {
3125 public:
3126  F a;
3127  F b;
3128  F c;
3129 
3130  Plane_2D () {}
3131  Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3132  Plane_2D (Vector_2D<F> const & v, F f = 0) : a (v.x), b (v.y), c (f) {}
3133  Plane_2D (Vector_2D<F> const & v, Point_2D<F> const & p) : a (v.x), b (v.y), c (-(p.x * v.x + p.y * v.y)) {}
3134  Plane_2D (Point_2D<F> const & p, Vector_2D<F> const & v) : a (v.x), b (v.y), c (-(p.x * v.x + p.y * v.y)) {}
3135  template <typename D>
3136  explicit Plane_2D (Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3137 
3138  Plane_2D const operator- () const { return Plane_2D (-a, -b, -c); }
3139 
3140  bool operator== (Plane_2D const & p) const { return a == p.a && b == p.b && c == p.c; }
3141  bool operator!= (Plane_2D const & p) const { return !(*this == p); }
3142 
3143  F & operator[] (size_t i) { return (&a)[i]; }
3144  F const & operator[] (size_t i) const { return (&a)[i]; }
3145 
3146  HPS_INLINE bool Equals(Plane_2D const & p, int in_tolerance = 32) const {
3147  return Float::Equals(a, p.a, in_tolerance) && Float::Equals(b, p.b, in_tolerance) && Float::Equals(c, p.c, in_tolerance);
3148  }
3149 
3150  Plane_2D & Normalize (F epsilon = Float_Traits<F>::Epsilon()) { // not const &; allow V.Normalize() *= S;
3151  F len = (F)Vector_2D<F>(*this).Length();
3152  if (len > epsilon)
3153  operator/= (len);
3154  else
3155  *this = Zero();
3156  return *this;
3157  }
3158 
3159  static HPS_INLINE Plane_2D Zero() {return Plane_2D (0.0f, 0.0f, 0.0f);};
3160 
3161 
3162 private:
3163  Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s; return *this; }
3164  Plane_2D & operator/= (F s) { return operator*= ((F)1.0 / s); }
3165  Plane_2D const operator* (F s) const { return Plane_2D (a * s, b * s, c * s); }
3166  Plane_2D const operator/ (F s) const { return operator* ((F)1.0 / s); }
3167 };
3168 
3169 typedef Plane_2D<float> Plane2D;
3170 typedef Plane_2D<double> DPlane2D;
3171 
3172 
3173 template <typename F>
3174 HPS_INLINE bool Is_Abnormal (Plane_2D<F> const & p) {
3175  return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3176 }
3177 
3178 
3179 template <typename F>
3180 HPS_INLINE F operator* (Plane_2D<F> const & plane, Point_2D<F> const & point) {
3181  return plane.a * point.x + plane.b * point.y + plane.c;
3182 }
3183 template <typename F>
3184 HPS_INLINE F operator* (Point_3D<F> const & point, Plane_2D<F> const & plane) {
3185  return plane * point;
3186 }
3187 
3188 template <typename F>
3189 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F> const & a, Plane_2D<F> const & b, float t) {
3190  return Plane_2D<F>(a.a + (b.a - a.a) * t, a.b + (b.b - a.b) * t, a.c + (b.c - a.c) * t);
3191 }
3192 
3193 template <typename F>
3194 Vector_2D<F>::Vector_2D(Plane_2D<F> const & p) : x(p.a), y(p.b) {}
3195 
3196 
3197 
3198 
3199 struct Rectangle;
3200 
3201 struct HPS_API IntRectangle {
3202  int left;
3203  int right;
3204  int bottom;
3205  int top;
3206 
3207  IntRectangle()
3208  : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3209  bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3210 
3211  IntRectangle(int in_left, int in_right, int in_bottom, int in_top)
3212  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3213 
3214  IntRectangle(IntRectangle const & that)
3215  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3216 
3217  explicit IntRectangle(Rectangle const & that);
3218 
3219  bool operator==(IntRectangle const & rect) const {
3220  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3221  }
3222 
3223  bool operator!=(IntRectangle const & rect) const {
3224  return !(*this == rect);
3225  }
3226 
3227  HPS_INLINE int PixelWidth() const {
3228  return right - left + 1;
3229  }
3230 
3231  HPS_INLINE int PixelHeight() const {
3232  return top - bottom + 1;
3233  }
3234 
3235  HPS_INLINE int Width() const {
3236  return right - left;
3237  }
3238 
3239  HPS_INLINE int Height() const {
3240  return top - bottom;
3241  }
3242 
3243  HPS_INLINE int Area() const {
3244  return Width() * Height();
3245  }
3246 
3247  HPS_INLINE Point2D Center() const {
3248  return Point2D((float)(left + right) * 0.5f, (float)(bottom + top) * 0.5f);
3249  }
3250 
3251  HPS_INLINE bool Intersecting(IntRectangle const & rect) const {
3252  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3253  }
3254 
3255  HPS_INLINE bool Contains(IntRectangle const & rect) const {
3256  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3257  }
3258 
3259  HPS_INLINE IntRectangle & Expand(int border) {
3260  left -= border;
3261  right += border;
3262  bottom -= border;
3263  top += border;
3264  return *this;
3265  }
3266 
3267  HPS_INLINE IntRectangle & Expand(IntRectangle const & rect) {
3268  left -= rect.left;
3269  right += rect.right;
3270  bottom -= rect.bottom;
3271  top += rect.top;
3272  return *this;
3273  }
3274 
3275  HPS_INLINE IntRectangle & Contract(int border) {
3276  left += border;
3277  right -= border;
3278  bottom += border;
3279  top -= border;
3280  return *this;
3281  }
3282 
3283  HPS_INLINE IntRectangle & Contract(IntRectangle const & rect) {
3284  left += rect.left;
3285  right -= rect.right;
3286  bottom += rect.bottom;
3287  top -= rect.top;
3288  return *this;
3289  }
3290 
3291  HPS_INLINE IntRectangle & Intersect(IntRectangle const & rect) {
3292  left = Max(left, rect.left);
3293  right = Min(right, rect.right);
3294  bottom = Max(bottom, rect.bottom);
3295  top = Min(top, rect.top);
3296  return *this;
3297  }
3298 
3299  HPS_INLINE IntRectangle & Union(IntRectangle const & rect) {
3300  left = Min(left, rect.left);
3301  right = Max(right, rect.right);
3302  bottom = Min(bottom, rect.bottom);
3303  top = Max(top, rect.top);
3304  return *this;
3305  }
3306 
3307 
3308  static HPS_INLINE IntRectangle Invalid() {
3309  return IntRectangle();
3310  }
3311 
3312  static HPS_INLINE IntRectangle Zero() {
3313  return IntRectangle(0, 0, 0, 0);
3314  }
3315 
3316 };
3317 
3318 HPS_INLINE IntRectangle Expand(IntRectangle const & a, IntRectangle const & border) {
3319  IntRectangle temp = a;
3320  return temp.Expand(border);
3321 }
3322 
3323 HPS_INLINE IntRectangle Expand(IntRectangle const & a, int border) {
3324  IntRectangle temp = a;
3325  return temp.Expand(border);
3326 }
3327 
3328 HPS_INLINE IntRectangle Contract(IntRectangle const & a, int border) {
3329  IntRectangle temp = a;
3330  return temp.Contract(border);
3331 }
3332 
3333 HPS_INLINE IntRectangle Contract(IntRectangle const & a, IntRectangle const & border) {
3334  IntRectangle temp = a;
3335  return temp.Contract(border);
3336 }
3337 
3338 HPS_INLINE IntRectangle Intersect(IntRectangle const & a, IntRectangle const & b) {
3339  IntRectangle temp = a;
3340  return temp.Intersect(b);
3341 }
3342 
3343 HPS_INLINE IntRectangle Union(IntRectangle const & a, IntRectangle const & b) {
3344  IntRectangle temp = a;
3345  return temp.Union(b);
3346 }
3347 
3348 struct HPS_API Rectangle {
3349  float left;
3350  float right;
3351  float bottom;
3352  float top;
3353 
3354  Rectangle()
3355  : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3356  bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3357 
3358  Rectangle(float in_left, float in_right, float in_bottom, float in_top)
3359  : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3360 
3361  Rectangle(Rectangle const & that)
3362  : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3363 
3364  explicit Rectangle(IntRectangle const & that)
3365  : left((float)that.left), right((float)that.right), bottom((float)that.bottom), top((float)that.top) {}
3366 
3367  HPS_INLINE Rectangle(size_t count, Point const * points) {
3368  left = points->x;
3369  right = points->x;
3370  top = points->y;
3371  bottom = points->y;
3372  --count;
3373  if (count > 0) {
3374  ++points;
3375  Merge(count, points);
3376  }
3377  }
3378 
3379  HPS_INLINE Rectangle(size_t count, Point2D const * points) {
3380  left = points->x;
3381  right = points->x;
3382  top = points->y;
3383  bottom = points->y;
3384  --count;
3385  if (count > 0) {
3386  ++points;
3387  Merge(count, points);
3388  }
3389  }
3390 
3391  HPS_INLINE float Width() const {
3392  return right - left;
3393  }
3394 
3395  HPS_INLINE float Height() const {
3396  return top - bottom;
3397  }
3398 
3399  HPS_INLINE float Area() const {
3400  return Width() * Height();
3401  }
3402 
3403  HPS_INLINE Point2D Center() const {
3404  return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3405  }
3406 
3407  HPS_INLINE void Merge(size_t count, Point const * points) {
3408 
3409  while (count > 1) {
3410  if (Compare(points[0].x, points[1].x)>0) {
3411  Float::replace_if_smaller(left, points[1].x);
3412  Float::replace_if_larger(right, points[0].x);
3413  }
3414  else {
3415  Float::replace_if_smaller(left, points[0].x);
3416  Float::replace_if_larger(right, points[1].x);
3417  }
3418 
3419  if (Compare(points[0].y, points[1].y)>0) {
3420  Float::replace_if_smaller(bottom, points[1].y);
3421  Float::replace_if_larger(top, points[0].y);
3422  }
3423  else {
3424  Float::replace_if_smaller(bottom, points[0].y);
3425  Float::replace_if_larger(top, points[1].y);
3426  }
3427 
3428  points += 2;
3429  count -= 2;
3430  }
3431 
3432  if (count > 0)
3433  Merge(*points);
3434  }
3435 
3436  HPS_INLINE void Merge(Point const & point) {
3437  Float::replace_if_smaller(left, point.x);
3438  Float::replace_if_smaller(bottom, point.y);
3439  Float::replace_if_larger(right, point.x);
3440  Float::replace_if_larger(top, point.y);
3441  }
3442 
3443  HPS_INLINE void Merge(size_t count, Point2D const * points) {
3444 
3445  while (count > 1) {
3446  if (Compare(points[0].x, points[1].x)>0) {
3447  Float::replace_if_smaller(left, points[1].x);
3448  Float::replace_if_larger(right, points[0].x);
3449  }
3450  else {
3451  Float::replace_if_smaller(left, points[0].x);
3452  Float::replace_if_larger(right, points[1].x);
3453  }
3454 
3455  if (Compare(points[0].y, points[1].y)>0) {
3456  Float::replace_if_smaller(bottom, points[1].y);
3457  Float::replace_if_larger(top, points[0].y);
3458  }
3459  else {
3460  Float::replace_if_smaller(bottom, points[0].y);
3461  Float::replace_if_larger(top, points[1].y);
3462  }
3463 
3464  points += 2;
3465  count -= 2;
3466  }
3467 
3468  if (count > 0)
3469  Merge(*points);
3470  }
3471 
3472  HPS_INLINE void Merge(Point2D const & point) {
3473  Float::replace_if_smaller(left, point.x);
3474  Float::replace_if_smaller(bottom, point.y);
3475  Float::replace_if_larger(right, point.x);
3476  Float::replace_if_larger(top, point.y);
3477  }
3478 
3479  bool operator==(Rectangle const & rect) const {
3480  return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3481  }
3482 
3483  bool operator!=(Rectangle const & rect) const {
3484  return !(*this == rect);
3485  }
3486 
3487  HPS_INLINE bool Intersecting(Rectangle const & rect) const {
3488  return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3489  }
3490 
3491  HPS_INLINE bool Contains(Point const & contained) const {
3492  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3493  }
3494 
3495  HPS_INLINE bool Contains(Point2D const & contained) const {
3496  return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3497  }
3498 
3499  HPS_INLINE bool Contains(Rectangle const & rect) {
3500  return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3501  }
3502 
3503  HPS_INLINE bool Contains(Rectangle const & rect, float epsilon) {
3504  return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3505  bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3506  }
3507 
3508  HPS_INLINE Rectangle & Expand(float border) {
3509  left -= border;
3510  right += border;
3511  bottom -= border;
3512  top += border;
3513  return *this;
3514  }
3515 
3516  HPS_INLINE Rectangle & Expand(int border) {
3517  Expand((float)border);
3518  return *this;
3519  }
3520 
3521  HPS_INLINE Rectangle & Expand(Rectangle const & rect) {
3522  left -= rect.left;
3523  right += rect.right;
3524  bottom -= rect.bottom;
3525  top += rect.top;
3526  return *this;
3527  }
3528 
3529  HPS_INLINE Rectangle & Contract(int border) {
3530  left += border;
3531  right -= border;
3532  bottom += border;
3533  top -= border;
3534  return *this;
3535  }
3536 
3537  HPS_INLINE Rectangle & Contract(Rectangle const & rect) {
3538  left += rect.left;
3539  right -= rect.right;
3540  bottom += rect.bottom;
3541  top -= rect.top;
3542  return *this;
3543  }
3544 
3545  HPS_INLINE Rectangle & Intersect(Rectangle const & rect) {
3546  left = Max(left, rect.left);
3547  right = Min(right, rect.right);
3548  bottom = Max(bottom, rect.bottom);
3549  top = Min(top, rect.top);
3550  return *this;
3551  }
3552 
3553  HPS_INLINE Rectangle & Union(Rectangle const & rect) {
3554  left = Min(left, rect.left);
3555  right = Max(right, rect.right);
3556  bottom = Min(bottom, rect.bottom);
3557  top = Max(top, rect.top);
3558  return *this;
3559  }
3560 
3561  HPS_INLINE Rectangle & Inscribe_Scope(Rectangle const & scope) {
3562  float scale = (scope.right - scope.left) * 0.5f;
3563  float trans = (scope.right + scope.left) * 0.5f;
3564 
3565  left = left * scale + trans;
3566  right = right * scale + trans;
3567 
3568  scale = (scope.top - scope.bottom) * 0.5f;
3569  trans = (scope.top + scope.bottom) * 0.5f;
3570 
3571  bottom = bottom * scale + trans;
3572  top = top * scale + trans;
3573  return *this;
3574  }
3575 
3576  HPS_INLINE Rectangle & Circumscribe_Scope(Rectangle const & scope) {
3577  float tmp = 2.0f/(scope.right - scope.left);
3578  right = (right - scope.left) * tmp - 1.0f;
3579  left = (left - scope.left) * tmp - 1.0f;
3580 
3581  tmp = 2.0f/(scope.top - scope.bottom);
3582  top = (top - scope.bottom) * tmp - 1.0f;
3583  bottom = (bottom - scope.bottom) * tmp - 1.0f;
3584  return *this;
3585  }
3586 
3587  static HPS_INLINE Rectangle FullScope() {
3588  return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3589  }
3590 
3591  static HPS_INLINE Rectangle InvalidScope() {
3592  return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3593  }
3594 
3595  static HPS_INLINE Rectangle Zero() {
3596  return Rectangle(0, 0, 0, 0);
3597  }
3598 
3599 };
3600 
3601 
3602 HPS_INLINE IntRectangle Floor(Rectangle const & a) {
3603  IntRectangle temp;
3604  temp.left = Floor (a.left);
3605  temp.right = Floor (a.right);
3606  temp.bottom = Floor (a.bottom);
3607  temp.top = Floor (a.top);
3608  return temp;
3609 }
3610 
3611 HPS_INLINE Rectangle Expand(Rectangle const & a, Rectangle const & border) {
3612  Rectangle temp = a;
3613  return temp.Expand(border);
3614 }
3615 
3616 HPS_INLINE Rectangle Expand(Rectangle const & a, float border) {
3617  Rectangle temp = a;
3618  return temp.Expand(border);
3619 }
3620 
3621 HPS_INLINE Rectangle Contract(Rectangle const & a, int border) {
3622  Rectangle temp = a;
3623  return temp.Contract(border);
3624 }
3625 
3626 HPS_INLINE Rectangle Contract(Rectangle const & a, Rectangle const & border) {
3627  Rectangle temp = a;
3628  return temp.Contract(border);
3629 }
3630 
3631 HPS_INLINE Rectangle Intersect(Rectangle const & a, Rectangle const & b) {
3632  Rectangle temp = a;
3633  return temp.Intersect(b);
3634 }
3635 
3636 HPS_INLINE Rectangle Union(Rectangle const & a, Rectangle const & b) {
3637  Rectangle temp = a;
3638  return temp.Union(b);
3639 }
3640 
3641 HPS_INLINE Rectangle Inscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3642  Rectangle temp = a;
3643  return temp.Inscribe_Scope(scope);
3644 }
3645 
3646 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle const & a, Rectangle const & scope) {
3647  Rectangle temp = a;
3648  return temp.Circumscribe_Scope(scope);
3649 }
3650 
3651 HPS_INLINE IntRectangle::IntRectangle(Rectangle const & that)
3652  : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3653 
3654 
3655 
3656 
3657 template <typename F>
3658 struct Sphere_3D;
3659 
3660 template <typename F>
3661 struct HPS_TEMPLATE_API Cuboid_3D {
3666 
3667 
3671  Cuboid_3D () : min (Limit_Point()), max (-Limit_Point()) {}
3672 
3673  template <typename D>
3674 
3679  explicit Cuboid_3D (Cuboid_3D<D> const & that) : min (Point_3D<F>(that.min)), max (Point_3D<F>(that.max)) {}
3680 
3681 
3686  Cuboid_3D (Sphere_3D<F> const & that);
3687 
3693  Cuboid_3D (Point_3D<F> const & in_min, Point_3D<F> const & in_max) : min (in_min), max (in_max) {}
3694 
3700  Cuboid_3D (size_t count, Point_3D<F> const * points) {
3701  if (count == 0) {
3702  min = Limit_Point();
3703  max = -Limit_Point();
3704  return;
3705  }
3706  min = max = *points++;
3707  --count;
3708  if (count>0)
3709  Merge(count, points);
3710  }
3711 
3716  Cuboid_3D (Rectangle const & that) : min (Point_3D<F>(that.left, that.bottom, 0)), max (Point_3D<F>(that.right, that.top, 0)) {}
3717 
3721  HPS_INLINE bool IsValid() const {
3722  return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3723  }
3724 
3728  static HPS_INLINE Cuboid_3D Invalid() {return Cuboid_3D ();};
3729 
3733  void Invalidate() {min = Limit_Point(); max = -Limit_Point();}
3734 
3739  HPS_INLINE bool operator== (Cuboid_3D const & cuboid) const { return (min == cuboid.min && max == cuboid.max); }
3740 
3745  HPS_INLINE bool operator!= (Cuboid_3D const & cuboid) const { return !(*this == cuboid); }
3746 
3751  HPS_INLINE void Generate_Cuboid_Points (Point_3D<F> * points) const {
3752  points[0] = Point_3D<F> (min.x, min.y, min.z);
3753  points[1] = Point_3D<F> (min.x, min.y, max.z);
3754  points[2] = Point_3D<F> (min.x, max.y, min.z);
3755  points[3] = Point_3D<F> (min.x, max.y, max.z);
3756  points[4] = Point_3D<F> (max.x, min.y, min.z);
3757  points[5] = Point_3D<F> (max.x, min.y, max.z);
3758  points[6] = Point_3D<F> (max.x, max.y, min.z);
3759  points[7] = Point_3D<F> (max.x, max.y, max.z);
3760  }
3761 
3765  HPS_INLINE Vector_3D<F> Diagonal() const { return max - min; }
3766 
3770  HPS_INLINE F Volume () const { return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3771 
3777  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid) const {
3778  return max.x >= cuboid.min.x && min.x <= cuboid.max.x &&
3779  max.y >= cuboid.min.y && min.y <= cuboid.max.y &&
3780  max.z >= cuboid.min.z && min.z <= cuboid.max.z;
3781  }
3782 
3788  HPS_INLINE bool Intersecting (Cuboid_3D const & cuboid, F const allowance) const {
3789  return max.x + allowance >= cuboid.min.x && min.x - allowance <= cuboid.max.x &&
3790  max.y + allowance >= cuboid.min.y && min.y - allowance <= cuboid.max.y &&
3791  max.z + allowance >= cuboid.min.z && min.z - allowance <= cuboid.max.z;
3792  }
3793 
3800  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid) const {
3801  //ASSERT (0 <= dimension && dimension <= 2);
3802  return max[dimension] >= cuboid.min[dimension] && min[dimension] <= cuboid.max[dimension];
3803  }
3804 
3812  HPS_INLINE bool Intersecting (int dimension, Cuboid_3D const & cuboid, F const allowance) const {
3813  //ASSERT (0 <= dimension && dimension <= 2);
3814  return max[dimension] + allowance >= cuboid.min[dimension] && min[dimension] - allowance <= cuboid.max[dimension];
3815  }
3816 
3823  bool Intersecting (Point_3D<F> const & start, Vector_3D<F> const & direction) const;
3824 
3830  HPS_INLINE void Merge(Cuboid_3D const & cuboid) {
3831  Float::replace_if_smaller(min.x, cuboid.min.x);
3832  Float::replace_if_smaller(min.y, cuboid.min.y);
3833  Float::replace_if_smaller(min.z, cuboid.min.z);
3834  Float::replace_if_larger(max.x, cuboid.max.x);
3835  Float::replace_if_larger(max.y, cuboid.max.y);
3836  Float::replace_if_larger(max.z, cuboid.max.z);
3837  }
3838 
3844  HPS_INLINE void Merge(Sphere_3D<F> const & sphere) { Merge (Cuboid_3D (sphere)); }
3845 
3851  HPS_INLINE void Merge(Point_3D<F> const & point) {
3852  Float::replace_if_smaller(min.x, point.x);
3853  Float::replace_if_smaller(min.y, point.y);
3854  Float::replace_if_smaller(min.z, point.z);
3855  Float::replace_if_larger(max.x, point.x);
3856  Float::replace_if_larger(max.y, point.y);
3857  Float::replace_if_larger(max.z, point.z);
3858  }
3859 
3866  void Merge(size_t count, Point_3D<F> const * points) {
3867  while (count > 1) {
3868  if (Compare(points[0].x, points[1].x)>0) {
3869  Float::replace_if_smaller(min.x, points[1].x);
3870  Float::replace_if_larger(max.x, points[0].x);
3871  }
3872  else {
3873  Float::replace_if_smaller(min.x, points[0].x);
3874  Float::replace_if_larger(max.x, points[1].x);
3875  }
3876 
3877  if (Compare(points[0].y, points[1].y)>0) {
3878  Float::replace_if_smaller(min.y, points[1].y);
3879  Float::replace_if_larger(max.y, points[0].y);
3880  }
3881  else {
3882  Float::replace_if_smaller(min.y, points[0].y);
3883  Float::replace_if_larger(max.y, points[1].y);
3884  }
3885 
3886  if (Compare(points[0].z, points[1].z)>0) {
3887  Float::replace_if_smaller(min.z, points[1].z);
3888  Float::replace_if_larger(max.z, points[0].z);
3889  }
3890  else {
3891  Float::replace_if_smaller(min.z, points[0].z);
3892  Float::replace_if_larger(max.z, points[1].z);
3893  }
3894 
3895  points += 2;
3896  count -= 2;
3897  }
3898 
3899  if (count > 0)
3900  Merge(*points);
3901  }
3902 
3908  HPS_INLINE bool Contains(Cuboid_3D const & contained) const {
3909  return (contained.min.x >= min.x &&
3910  contained.min.y >= min.y &&
3911  contained.min.z >= min.z &&
3912  contained.max.x <= max.x &&
3913  contained.max.y <= max.y &&
3914  contained.max.z <= max.z);
3915  }
3916 
3922  HPS_INLINE bool Contains(Point_3D<F> const & contained) const {
3923  return (contained.x >= min.x &&
3924  contained.y >= min.y &&
3925  contained.z >= min.z &&
3926  contained.x <= max.x &&
3927  contained.y <= max.y &&
3928  contained.z <= max.z);
3929  }
3930 
3937  HPS_INLINE bool Contains(Point_3D<F> const & contained, F epsilon) const {
3938  return (contained.x >= min.x - epsilon &&
3939  contained.y >= min.y - epsilon &&
3940  contained.z >= min.z - epsilon &&
3941  contained.x <= max.x + epsilon &&
3942  contained.y <= max.y + epsilon &&
3943  contained.z <= max.z + epsilon);
3944  }
3945 
3951  HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const & cuboid) {
3952  Float::replace_if_larger(min.x, cuboid.min.x);
3953  Float::replace_if_larger(min.y, cuboid.min.y);
3954  Float::replace_if_larger(min.z, cuboid.min.z);
3955  Float::replace_if_smaller(max.x, cuboid.max.x);
3956  Float::replace_if_smaller(max.y, cuboid.max.y);
3957  Float::replace_if_smaller(max.z, cuboid.max.z);
3958  return *this;
3959  }
3960 
3966  HPS_INLINE Cuboid_3D & Union(Cuboid_3D const & cuboid) {
3967  Float::replace_if_smaller(min.x, cuboid.min.x);
3968  Float::replace_if_smaller(min.y, cuboid.min.y);
3969  Float::replace_if_smaller(min.z, cuboid.min.z);
3970  Float::replace_if_larger(max.x, cuboid.max.x);
3971  Float::replace_if_larger(max.y, cuboid.max.y);
3972  Float::replace_if_larger(max.z, cuboid.max.z);
3973  return *this;
3974  }
3975 
3981  HPS_INLINE Cuboid_3D & Expand(F border) {
3982  Vector_3D<F> delta (border, border, border);
3983  min -= delta;
3984  max += delta;
3985  return *this;
3986  }
3987 
3993  HPS_INLINE Cuboid_3D & Contract(F border) {
3994  Vector_3D<F> delta (border, border, border);
3995  min += delta;
3996  max -= delta;
3997  return *this;
3998  }
3999 
4000  private:
4001  HPS_INLINE static Point_3D<F> Limit_Point () {
4002  F const limit = std::numeric_limits<F>::max();
4003  return Point_3D<F> (limit, limit, limit);
4004  }
4005 };
4006 
4007 typedef Cuboid_3D<float> SimpleCuboid;
4008 typedef Cuboid_3D<double> DSimpleCuboid;
4009 
4010 
4011 template <typename F>
4012 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4013  Cuboid_3D<F> temp = a;
4014  return temp.Intersect(b);
4015 }
4016 
4017 template <typename F>
4018 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F> const & a, Cuboid_3D<F> const & b) {
4019  Cuboid_3D<F> temp = a;
4020  return temp.Union(b);
4021 }
4022 
4023 template <typename F>
4024 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F> const & a, F border) {
4025  Cuboid_3D<F> temp = a;
4026  return temp.Expand(border);
4027 }
4028 
4029 template <typename F>
4030 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F> const & a, F border) {
4031  Cuboid_3D<F> temp = a;
4032  return temp.Contract(border);
4033 }
4034 
4035 
4036 
4037 template <typename F>
4038 struct HPS_TEMPLATE_API Sphere_3D {
4039  Point_3D<F> center;
4040  F radius;
4041 
4042  Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4043 
4044  template <typename D>
4045  explicit Sphere_3D (Sphere_3D<D> const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4046 
4047  Sphere_3D (Cuboid_3D<F> const & cuboid) :
4048  center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4049 
4050  Sphere_3D (Point_3D<F> const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4051 
4052  Sphere_3D (size_t count, Point_3D<F> const * points) : radius(0.0f) {
4053  Cuboid_3D<F> cuboid(count, points);
4054  center = Midpoint(cuboid.min, cuboid.max);
4055  Engulf (count, points);
4056  }
4057 
4058  Sphere_3D (size_t count, Point_3D<F> const * points, Point_3D<F> const & starting_center) : center(starting_center), radius(0) {
4059  Engulf (count, points);
4060  }
4061 
4062  HPS_INLINE bool IsValid() const {
4063  return radius >= 0;
4064  }
4065 
4066  static HPS_INLINE Sphere_3D Invalid() {return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4067 
4068  void Invalidate() {radius = -1;}
4069 
4070  HPS_INLINE bool operator== (Sphere_3D const & sphere) const { return (center == sphere.center && radius == sphere.radius); }
4071  HPS_INLINE bool operator!= (Sphere_3D const & sphere) const { return !(*this == sphere); }
4072 
4073  HPS_INLINE F Volume () const { return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4074 
4075  HPS_INLINE void Merge(Point_3D<F> const & point) {
4076  Vector_3D<F> dir = point - center;
4077  F distance = (F)dir.Length();
4078 
4079  if (distance > radius) {
4080  F t = F(0.5) * (distance - radius);
4081  center += t * dir.Normalize();
4082  radius += t;
4083  }
4084  }
4085 
4086  HPS_INLINE void Merge(size_t count, Point_3D<F> const * points) {
4087 
4088  for (size_t i = 0; i < count; ++i) {
4089  Vector_3D<F> dir = *points - center;
4090  F distance = (F)dir.Length();
4091 
4092  if (distance > radius) {
4093  F t = F(0.5) * (distance - radius);
4094  center += t * dir.Normalize();
4095  radius += t;
4096  }
4097 
4098  ++points;
4099  }
4100  }
4101 
4102  HPS_INLINE void Merge (Sphere_3D const & sphere) {
4103  Vector_3D<F> dir = sphere.center - center;
4104  F distance = (F)dir.Length();
4105 
4106  if (distance + sphere.radius > radius) {
4107  if (distance + radius > sphere.radius) {
4108  F t = F(0.5 * (sphere.radius + distance - radius));
4109  center += t * dir.Normalize();
4110  radius += t;
4111  }
4112  else {
4113  center = sphere.center;
4114  radius = sphere.radius;
4115  }
4116  }
4117  }
4118 
4119  HPS_INLINE void Merge (Cuboid_3D<F> const & cuboid) { Merge (Sphere_3D (cuboid)); }
4120 
4121 private:
4122  // Engulf expands the sphere to include the points, but does not change the center as Merge does
4123  HPS_INLINE void Engulf (size_t count, Point_3D<F> const * points) {
4124  for (size_t i = 0; i < count; ++i) {
4125  double dsq = (*points++ - center).LengthSquared();
4126  if ((F)dsq > radius * radius)
4127  radius = (F)sqrt(dsq);
4128  }
4129  }
4130 };
4131 
4132 typedef Sphere_3D<float> SimpleSphere;
4133 typedef Sphere_3D<double> DSimpleSphere;
4134 
4135 
4136 template <typename F>
4137 HPS_INLINE Cuboid_3D<F>::Cuboid_3D(Sphere_3D<F> const & sphere) {
4138  min = Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4139  max = Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4140 }
4141 
4142 
4143 
4144 
4145 class RGB24Color;
4146 class RGBA32Color;
4147 class RGBAS32Color;
4148 class RGBAColor;
4149 
4150 class HPS_API RGBColor {
4151 public:
4152  float red;
4153  float green;
4154  float blue;
4155 
4156  HPS_INLINE RGBColor () {}
4157  HPS_INLINE RGBColor (float r, float g, float b) : red (r), green (g), blue (b) {}
4158  explicit HPS_INLINE RGBColor (RGB24Color const & c24);
4159  explicit HPS_INLINE RGBColor (float gray) : red (gray), green (gray), blue (gray) {}
4160  explicit HPS_INLINE RGBColor (RGBAS32Color const & c32);
4161  explicit HPS_INLINE RGBColor (RGBA32Color const & c32);
4162  explicit HPS_INLINE RGBColor (RGBAColor const & c);
4163 
4164  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4165  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4166  float Distance(RGBColor const & other_color) const;
4167  HPS_INLINE bool IsValid() const {
4168  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4169  }
4170 
4171  HPS_INLINE bool operator== (RGBColor const & c) const { return red == c.red && green == c.green && blue == c.blue; }
4172  HPS_INLINE bool operator!= (RGBColor const & c) const { return !(*this == c); }
4173 
4174  HPS_INLINE bool Equals(RGBColor const & c, int in_tolerance = 32) const
4175  { return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) && Float::Equals(blue, c.blue, in_tolerance); }
4176 
4177  HPS_INLINE RGBColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4178  HPS_INLINE RGBColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4179  HPS_INLINE RGBColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4180  HPS_INLINE RGBColor const operator* (RGBColor const & c) const { return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4181  HPS_INLINE RGBColor const operator+ (RGBColor const & c) const { return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4182  HPS_INLINE RGBColor const operator- (RGBColor const & c) const { return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4183 
4184  HPS_INLINE RGBColor & operator*= (float s) { red *= s; green *= s; blue *= s; return *this; }
4185  HPS_INLINE RGBColor & operator/= (float s) { return operator*= (1.0f / s); }
4186  HPS_INLINE RGBColor & operator+= (float s) { red += s; green += s; blue += s; return *this; }
4187  HPS_INLINE RGBColor & operator-= (float s) { red -= s; green -= s; blue -= s; return *this; }
4188  HPS_INLINE RGBColor const operator* (float s) const { return RGBColor (red * s, green * s, blue * s); }
4189  HPS_INLINE RGBColor const operator/ (float s) const { return operator* (1.0f / s); }
4190  HPS_INLINE RGBColor const operator+ (float s) const { return RGBColor (red + s, green + s, blue + s); }
4191  HPS_INLINE RGBColor const operator- (float s) const { return RGBColor (red - s, green - s, blue - s); }
4192 
4193  static HPS_INLINE RGBColor Black() {return RGBColor (0, 0, 0);};
4194  static HPS_INLINE RGBColor White() {return RGBColor (1, 1, 1);};
4195  static HPS_INLINE RGBColor Invalid() {return RGBColor (-1, -1, -1);};
4196 
4197  void ShowHLS(float & out_hue, float & out_lightness, float & out_saturation) const;
4198  void ShowHSV(float & out_hue, float & out_saturation, float & out_value) const;
4199  void ShowHIC(float & out_hue, float & out_intensity, float & out_chromaticity) const;
4200 
4201  static RGBColor HLS(float in_hue, float in_lightness, float in_saturation);
4202  static RGBColor HSV(float in_hue, float in_saturation, float in_value);
4203  static RGBColor HIC(float in_hue, float in_intensity, float in_chromaticity);
4204 };
4205 
4206 HPS_INLINE RGBColor const operator* (float s, RGBColor const & v) { return RGBColor (s * v.red, s * v.green, s * v.blue); }
4207 HPS_INLINE RGBColor const operator+ (float s, RGBColor const & v) { return RGBColor (s + v.red, s + v.green, s + v.blue); }
4208 HPS_INLINE RGBColor const operator- (float s, RGBColor const & v) { return RGBColor (s - v.red, s - v.green, s - v.blue); }
4209 
4210 
4211 class HPS_API RGBAColor {
4212 public:
4213 
4214  float red;
4215  float green;
4216  float blue;
4217  float alpha;
4219  HPS_INLINE RGBAColor () {}
4220  explicit HPS_INLINE RGBAColor (float gray, float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4221  HPS_INLINE RGBAColor (float r, float g, float b, float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4222 
4223  HPS_INLINE RGBAColor (RGBColor const & c) {
4224  memcpy(this, &c, sizeof(RGBColor)); //-V512
4225  alpha = 1.0f;
4226  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4227  }
4228  HPS_INLINE RGBAColor (RGBColor const & c, float a) {
4229  memcpy(this, &c, sizeof(RGBColor));
4230  memcpy(&alpha, &a, sizeof(float));
4231  Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4232  }
4233  explicit HPS_INLINE RGBAColor (RGBA32Color const & c32);
4234  explicit HPS_INLINE RGBAColor (RGBAS32Color const & c32);
4235 
4236  HPS_INLINE bool IsGray() const {return (red == green && green == blue);}
4237  HPS_INLINE float Gray() const { return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4238  HPS_INLINE bool IsValid() const {
4239  return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4240  }
4241 
4248  HPS_INLINE bool operator== (RGBAColor const & c) const { return red == c.red && green == c.green && blue == c.blue && alpha == c.alpha; }
4249 
4256  HPS_INLINE bool operator!= (RGBAColor const & c) const { return !(*this == c); }
4257 
4258  HPS_INLINE bool Equals(RGBAColor const & c, int in_tolerance = 32) const {
4259  return Float::Equals(red, c.red, in_tolerance) && Float::Equals(green, c.green, in_tolerance) &&
4260  Float::Equals(blue, c.blue, in_tolerance) && Float::Equals(alpha, c.alpha, in_tolerance);
4261  }
4262 
4263  HPS_INLINE RGBAColor & operator*= (RGBAColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha; return *this; }
4264  HPS_INLINE RGBAColor & operator+= (RGBAColor const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha; return *this; }
4265  HPS_INLINE RGBAColor & operator-= (RGBAColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha; return *this; }
4266  HPS_INLINE RGBAColor const operator* (RGBAColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4267  HPS_INLINE RGBAColor const operator+ (RGBAColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4268  HPS_INLINE RGBAColor const operator- (RGBAColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4269 
4270  HPS_INLINE RGBAColor & operator*= (float s) { red *= s; green *= s; blue *= s; alpha *= s; return *this; }
4271  HPS_INLINE RGBAColor & operator/= (float s) { return operator*= (1.0f / s); }
4272  HPS_INLINE RGBAColor & operator+= (float s) { red += s; green += s; blue += s; alpha += s; return *this; }
4273  HPS_INLINE RGBAColor & operator-= (float s) { red -= s; green -= s; blue -= s; alpha -= s; return *this; }
4274  HPS_INLINE RGBAColor const operator* (float s) const { return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4275  HPS_INLINE RGBAColor const operator/ (float s) const { return operator* (1.0f / s); }
4276  HPS_INLINE RGBAColor const operator+ (float s) const { return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4277  HPS_INLINE RGBAColor const operator- (float s) const { return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4278 
4279  HPS_INLINE RGBAColor & operator*= (RGBColor const & c) { red *= c.red; green *= c.green; blue *= c.blue; return *this; }
4280  HPS_INLINE RGBAColor & operator+= (RGBColor const & c) { red += c.red; green += c.green; blue += c.blue; return *this; }
4281  HPS_INLINE RGBAColor & operator-= (RGBColor const & c) { red -= c.red; green -= c.green; blue -= c.blue; return *this; }
4282  HPS_INLINE RGBAColor const operator* (RGBColor const & c) const { return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4283  HPS_INLINE RGBAColor const operator+ (RGBColor const & c) const { return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4284  HPS_INLINE RGBAColor const operator- (RGBColor const & c) const { return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4285 
4286  static HPS_INLINE RGBAColor Black() {return RGBAColor (0, 0, 0, 1);};
4287  static HPS_INLINE RGBAColor White() {return RGBAColor (1, 1, 1, 1);};
4288  static HPS_INLINE RGBAColor Nothing() {return RGBAColor (0, 0, 0, 0);};
4289  static HPS_INLINE RGBAColor Invalid() {return RGBAColor (-1, -1, -1, -1);};
4290 };
4291 
4292 
4293 
4295 public:
4296  enum Order {
4297  Order_ABGR,
4298  Order_RGBA,
4299  Order_BGRA
4300  };
4301 
4302 #ifdef _MSC_VER
4303  HPS_INLINE static Order Preferred_Order () {return Order_BGRA;}
4304  unsigned char b, g, r, a;
4305 #endif
4306 
4307 #ifdef __linux__
4308  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4309  unsigned char r, g, b, a;
4310 #endif
4311 
4312 #ifdef __APPLE_CC__
4313  HPS_INLINE static Order Preferred_Order () {return Order_RGBA;}
4314  unsigned char r, g, b, a;
4315 #endif
4316 };
4317 
4318 
4319 
4321 public:
4322 
4323  HPS_INLINE RGBAS32Color () /* : DirectRGBColor() */ {}
4324  explicit HPS_INLINE RGBAS32Color (unsigned char gray, unsigned char aa = 255) {
4325  r = gray;
4326  g = gray;
4327  b = gray;
4328  a = aa;
4329  }
4330  HPS_INLINE RGBAS32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255) {
4331  r = rr;
4332  g = gg;
4333  b = bb;
4334  a = aa;
4335  }
4336  HPS_INLINE RGBAS32Color (DirectRGBColor const & c) : DirectRGBColor(c) {};
4337 
4338  explicit HPS_INLINE RGBAS32Color (RGBColor const & c)
4339  {
4340  r = Float::unit_to_byte(c.red);
4341  g = Float::unit_to_byte(c.green);
4342  b = Float::unit_to_byte(c.blue);
4343  a = 255;
4344  }
4345 
4346  HPS_INLINE RGBAS32Color (RGB24Color const & c);
4347 
4348  HPS_INLINE RGBAS32Color (RGBA32Color const & c);
4349 
4350  HPS_INLINE RGBAS32Color (RGBColor const & c, float alpha)
4351  {
4352  r = Float::unit_to_byte(c.red);
4353  g = Float::unit_to_byte(c.green);
4354  b = Float::unit_to_byte(c.blue);
4355  a = Float::unit_to_byte(alpha);
4356  }
4357  HPS_INLINE RGBAS32Color (RGBColor const & c, unsigned char aa)
4358  {
4359  r = Float::unit_to_byte(c.red);
4360  g = Float::unit_to_byte(c.green);
4361  b = Float::unit_to_byte(c.blue);
4362  a = aa;
4363  }
4364  explicit HPS_INLINE RGBAS32Color (RGBAColor const & c)
4365  {
4366  r = Float::unit_to_byte(c.red);
4367  g = Float::unit_to_byte(c.green);
4368  b = Float::unit_to_byte(c.blue);
4369  a = Float::unit_to_byte(c.alpha);
4370  }
4371  HPS_INLINE RGBAS32Color (RGBAColor const & c, unsigned char mix)
4372  {
4373  r = Float::unit_to_byte(c.red);
4374  g = Float::unit_to_byte(c.green);
4375  b = Float::unit_to_byte(c.blue);
4376  a = Float::unit_to_byte_scaled(c.alpha, mix);
4377  }
4378 
4379  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4380  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4381  HPS_INLINE bool IsValid() const { return ((r | g | b | a) != 0); }
4382 
4383  HPS_INLINE bool operator== (RGBAS32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4384  HPS_INLINE bool operator!= (RGBAS32Color const & c) const { return !(*this == c); }
4385 
4386  static HPS_INLINE RGBAS32Color Black() {return RGBAS32Color (0, 0, 0, 255);};
4387  static HPS_INLINE RGBAS32Color White() {return RGBAS32Color (255, 255, 255, 255);};
4388  static HPS_INLINE RGBAS32Color Invalid() {return RGBAS32Color (0, 0, 0, 0);};
4389 
4390  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4391 };
4392 
4394 public:
4395  unsigned char r;
4396  unsigned char g;
4397  unsigned char b;
4398  unsigned char a;
4399 
4400  HPS_INLINE RGBA32Color () {}
4401  explicit HPS_INLINE RGBA32Color (unsigned char gray, unsigned char aa = 255)
4402  : r (gray), g (gray), b (gray), a (aa) {}
4403  HPS_INLINE RGBA32Color (unsigned char rr, unsigned char gg, unsigned char bb, unsigned char aa = 255)
4404  : r (rr), g (gg), b (bb), a (aa) {}
4405  HPS_INLINE RGBA32Color (RGBAS32Color const & c32)
4406  : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4407  explicit HPS_INLINE RGBA32Color (RGBColor const & c) {
4408  r = Float::unit_to_byte(c.red);
4409  g = Float::unit_to_byte(c.green);
4410  b = Float::unit_to_byte(c.blue);
4411  a = 255;
4412  }
4413  HPS_INLINE RGBA32Color (RGBColor const & c, float alpha) {
4414  r = Float::unit_to_byte(c.red);
4415  g = Float::unit_to_byte(c.green);
4416  b = Float::unit_to_byte(c.blue);
4417  a = Float::unit_to_byte(alpha);
4418  }
4419  HPS_INLINE RGBA32Color (RGBColor const & c, unsigned char aa) {
4420  r = Float::unit_to_byte(c.red);
4421  g = Float::unit_to_byte(c.green);
4422  b = Float::unit_to_byte(c.blue);
4423  a = aa;
4424  }
4425  explicit HPS_INLINE RGBA32Color (RGBAColor const & c) {
4426  r = Float::unit_to_byte(c.red);
4427  g = Float::unit_to_byte(c.green);
4428  b = Float::unit_to_byte(c.blue);
4429  a = Float::unit_to_byte(c.alpha);
4430  }
4431  HPS_INLINE RGBA32Color (RGBAColor const & c, unsigned char mix) {
4432  r = Float::unit_to_byte(c.red);
4433  g = Float::unit_to_byte(c.green);
4434  b = Float::unit_to_byte(c.blue);
4435  a = Float::unit_to_byte_scaled(c.alpha, mix);
4436  }
4437 
4438  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4439  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4440 
4441  HPS_INLINE bool operator== (RGBA32Color const & c) const { return (r == c.r && g == c.g && b == c.b && a == c.a); }
4442  HPS_INLINE bool operator!= (RGBA32Color const & c) const { return !(*this == c); }
4443 
4444  static HPS_INLINE RGBA32Color Black() {return RGBA32Color (0, 0, 0, 255);};
4445  static HPS_INLINE RGBA32Color White() {return RGBA32Color (255, 255, 255, 255);};
4446 
4447  static HPS_INLINE unsigned char Opaque_Alpha () {return 0xFF;}
4448 };
4449 
4450 
4452 {
4453 public:
4454  unsigned char r;
4455  unsigned char g;
4456  unsigned char b;
4457 
4458  HPS_INLINE RGB24Color () {}
4459  explicit HPS_INLINE RGB24Color (unsigned char gray)
4460  : r (gray), g (gray), b (gray) {}
4461  HPS_INLINE RGB24Color (unsigned char rr, unsigned char gg, unsigned char bb)
4462  : r (rr), g (gg), b (bb) {}
4463  explicit HPS_INLINE RGB24Color (RGBColor const & c) {
4464  r = Float::unit_to_byte(c.red);
4465  g = Float::unit_to_byte(c.green);
4466  b = Float::unit_to_byte(c.blue);
4467  }
4468 
4469  HPS_INLINE bool IsGray() const {return (r == g && g == b);}
4470  HPS_INLINE unsigned char Gray() const { return (unsigned char)(0.3125f * (float)r + 0.5000f * (float)g + 0.1875f * (float)b); }
4471 
4472  HPS_INLINE bool operator== (RGB24Color const & c) const { return (r == c.r && g == c.g && b == c.b); }
4473  HPS_INLINE bool operator!= (RGB24Color const & c) const { return !(*this == c); }
4474 };
4475 
4476 HPS_INLINE RGBColor::RGBColor (RGBAS32Color const & c32) {
4477  red = Float::C2F(c32.r);
4478  green = Float::C2F(c32.g);
4479  blue = Float::C2F(c32.b);
4480 }
4481 
4482 HPS_INLINE RGBColor::RGBColor (RGBA32Color const & c32) {
4483  red = Float::C2F(c32.r);
4484  green = Float::C2F(c32.g);
4485  blue = Float::C2F(c32.b);
4486 }
4487 
4488 HPS_INLINE RGBColor::RGBColor (RGBAColor const & c) {
4489  red = c.red;
4490  green = c.green;
4491  blue = c.blue;
4492 }
4493 
4494 HPS_INLINE RGBColor::RGBColor (RGB24Color const & c24) {
4495  red = Float::C2F(c24.r);
4496  green = Float::C2F(c24.g);
4497  blue = Float::C2F(c24.b);
4498 }
4499 
4500 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color const & c)
4501 {
4502  r = c.r;
4503  g = c.g;
4504  b = c.b;
4505  a = 255;
4506 }
4507 
4508 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color const & c)
4509 {
4510  r = c.r;
4511  g = c.g;
4512  b = c.b;
4513  a = c.a;
4514 }
4515 
4516 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color const & c32) {
4517  red = Float::C2F(c32.r);
4518  green = Float::C2F(c32.g);
4519  blue = Float::C2F(c32.b);
4520  alpha = Float::C2F(c32.a);
4521 }
4522 
4523 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color const & c32) {
4524  red = Float::C2F(c32.r);
4525  green = Float::C2F(c32.g);
4526  blue = Float::C2F(c32.b);
4527  alpha = Float::C2F(c32.a);
4528 }
4529 
4530 HPS_INLINE RGBColor Modulate(RGBColor const & a, RGBColor const & b) {
4531  return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4532 }
4533 
4534 
4535 
4536 HPS_INLINE RGBColor Interpolate(RGBColor const & a, RGBColor const & b, float t) {
4537  return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4538 }
4539 
4540 HPS_INLINE RGBAColor Interpolate(RGBAColor const & a, RGBAColor const & b, float t) {
4541  return RGBAColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t, a.alpha + (b.alpha - a.alpha) * t);
4542 }
4543 
4544 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color const & a, RGBAS32Color const & b, float t) {
4545  return RGBAS32Color(
4546  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4547  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4548  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4549  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4550 }
4551 
4552 HPS_INLINE RGBA32Color Interpolate(RGBA32Color const & a, RGBA32Color const & b, float t) {
4553  return RGBA32Color(
4554  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4555  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4556  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t),
4557  (unsigned char)(a.a + ((float)b.a - (float)a.a) * t));
4558 }
4559 
4560 HPS_INLINE RGB24Color Interpolate(RGB24Color const & a, RGB24Color const & b, float t) {
4561  return RGB24Color(
4562  (unsigned char)(a.r + ((float)b.r - (float)a.r) * t),
4563  (unsigned char)(a.g + ((float)b.g - (float)a.g) * t),
4564  (unsigned char)(a.b + ((float)b.b - (float)a.b) * t));
4565 }
4566 
4567 
4568 
4569 class HPS_API Quaternion {
4570 public:
4571  float w;
4572  float x;
4573  float y;
4574  float z;
4575 
4576  Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4577 
4578  Quaternion(float in_w, float in_x, float in_y, float in_z) : w(in_w), x(in_x), y(in_y), z(in_z) { }
4579 
4580  Quaternion(Quaternion const & that) : w(that.w), x(that.x), y(that.y), z(that.z) { }
4581 
4582  Quaternion const & Normalize() {
4583  float mag = Norm();
4584 
4585  if (mag > 0) {
4586  w /= mag;
4587  x /= mag;
4588  y /= mag;
4589  z /= mag;
4590  }
4591  return *this;
4592  }
4593 
4594 
4595  Quaternion operator* (Quaternion const & in_right) const {
4596  return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4597  y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4598  z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4599  x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4600  }
4601 
4602  Quaternion operator* (float in_right) const {
4603  return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4604  }
4605 
4606  friend Quaternion operator* (float in_left, Quaternion const & in_right) {
4607  return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4608  }
4609 
4610  Quaternion operator/ (float in_right) const {
4611  return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4612  }
4613 
4614  Quaternion operator- (Quaternion const & in_right) const {
4615  return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4616  }
4617 
4618  Quaternion operator+ (Quaternion const & in_right) const {
4619  return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4620  }
4621 
4622  inline float Norm() const {
4623  return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4624  }
4625 
4626 
4627  Quaternion Log() const {
4628  Quaternion ret;
4629  float mag_q = Norm();
4630  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4631 
4632  ret.w = static_cast<float>(log(mag_q));
4633 
4634  if (mag_V > 0) {
4635  float scale = static_cast<float>(acos(w / mag_q) / mag_V);
4636 
4637  ret.x = x * scale;
4638  ret.y = y * scale;
4639  ret.z = z * scale;
4640  }
4641  else
4642  ret.x = ret.y = ret.z = 0;
4643 
4644  return ret;
4645  }
4646 
4647  Quaternion Exp() const {
4648  Quaternion ret;
4649  float ea = static_cast<float>(exp(w));
4650  float mag_V = static_cast<float>(sqrt(x*x + y*y + z*z));
4651  float scale = ea * sin(mag_V) / mag_V;
4652 
4653  ret.w = ea * cos(mag_V);
4654  ret.x = scale * x;
4655  ret.y = scale * y;
4656  ret.z = scale * z;
4657 
4658  return ret;
4659  }
4660 
4661  Quaternion Lerp(Quaternion const & in_right, float in_fraction) const {
4662  Quaternion ret = *this + in_fraction * (in_right - *this);
4663  return ret.Normalize();
4664  }
4665 
4666 
4667  Quaternion Slerp(Quaternion const & in_right, float in_fraction, bool in_shortest_path_only = true) const {
4668  Quaternion q3;
4669  float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4670 
4671  if (in_shortest_path_only && dot < 0) {
4672  dot = -dot;
4673  q3 = -1 * in_right;
4674  }
4675  else
4676  q3 = in_right;
4677 
4678  if (dot > -0.95f && dot < 0.95f) {
4679  float angle = static_cast<float>(acos(dot));
4680  float sina = static_cast<float>(sin(angle));
4681  float sinat = static_cast<float>(sin(angle*in_fraction));
4682  float sinaomt = static_cast<float>(sin(angle*(1-in_fraction)));
4683 
4684  return (*this * sinaomt + q3 * sinat) / sina;
4685  }
4686  else //if the angle is small, we use linear interpolation
4687  return Lerp(q3, in_fraction);
4688  }
4689 
4690 
4691  /*
4692  Spherical cubic interpolation between two Quaternions
4693  \param in_right The Quaternion for interpolation.
4694  \param in_control1 The first control point.
4695  \param in_control2 The second control point.
4696  \param in_fraction Interpolation distance (0 - 1).
4697  \return Result of interpolation.
4698  */
4699  Quaternion Squad(Quaternion const & in_right, Quaternion const & in_control1, Quaternion const & in_control2, float in_fraction) const {
4700  Quaternion q1 = Slerp(in_right , in_fraction, false);
4701  Quaternion q2 = in_control1.Slerp(in_control2, in_fraction, false);
4702 
4703  return q1.Slerp(q2, 2*in_fraction*(1-in_fraction), false);
4704  }
4705 
4712  Quaternion Spline(Quaternion const & in_previous, Quaternion const & in_next) const {
4713  Quaternion qni(-x, -y, -z, w);
4714 
4715  return *this * Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4716  }
4717 
4718 };
4719 
4720 typedef unsigned char byte;
4721 typedef signed char sbyte;
4722 typedef intptr_t WindowHandle;
4723 typedef double Time;
4724 typedef int64_t TouchID;
4725 typedef intptr_t PlatformData;
4726 
4727 /*
4728 HPS Lexicon:
4729 
4730 Concept Class -- A class that contains only enums and possibly static functions. The
4731  constructor is usually private because they are not intended to be instantiated.
4732 
4733 Database -- (1) The internal space that stores and manages all HOOPS objects. Access to
4734  database objects is subject to locking to prevent threading deadlocks. (2) The class
4735  of the same name, offering static functions to initiate operations that take place
4736  within the database.
4737 
4738 Key -- A reference counted smart pointer to an object in the database. The
4739 
4740 Kit -- A user space object that carries a complete specification for a geometry, attribute,
4741  option group, or other type. Modifying a kit has no effect on the database unless
4742  and until it is applied. Kits should generally be passed by reference because they
4743  are potentially very large and copying them can be arduous.
4744 
4745 Smart Pointer -- An encapsulated, reference counted pointer to an internal object. Smart
4746  pointers should generally be passed by value to ensure the reference count is
4747  correct.
4748 
4749 User Space -- The external space occupied by all user code. User space objects are not
4750  in the database and are not subject to locking.
4751 
4752 */
4753 
4757 class SegmentKey;
4758 class AttributesControl;
4759 class LineKit;
4760 class LineKey;
4761 class TextKey;
4762 class TextKit;
4763 class Key;
4764 class VisibilityControl;
4765 class CameraControl;
4766 class SelectabilityControl;
4767 class TransparencyKit;
4768 class TransparencyControl;
4769 class CullingKit;
4770 class CullingControl;
4771 class GlyphKit;
4772 class MarkerAttributeControl;
4773 class GlyphDefinition;
4774 class GeometryInsertControl;
4775 class GlyphElement;
4776 class TextAttributeControl;
4777 class TextAttributeKit;
4778 class LineAttributeKit;
4779 class LineAttributeControl;
4780 class EdgeAttributeKit;
4781 class EdgeAttributeControl;
4782 class CurveAttributeKit;
4783 class CurveAttributeControl;
4784 class GlyphPoint;
4785 class MatrixKit;
4786 class ModellingMatrixControl;
4787 class TextureMatrixControl;
4788 class TextureDefinition;
4789 class MaterialMappingKit;
4790 class MaterialMappingControl;
4791 class MaterialKit;
4792 class MarkerKit;
4793 class MarkerKey;
4794 class DistantLightKit;
4795 class DistantLightKey;
4796 class CuttingSectionKit;
4797 class CuttingSectionKey;
4798 class CuttingSectionAttributeKit;
4799 class CuttingSectionAttributeControl;
4800 class CylinderAttributeKit;
4801 class CylinderAttributeControl;
4802 class Cylinder;
4803 class CylinderKey;
4804 class CylinderKit;
4805 class SphereKey;
4806 class SphereKit;
4807 class SphereAttributeKit;
4808 class SphereAttributeControl;
4809 class PolygonKit;
4810 class PolygonKey;
4811 class CircleKey;
4812 class CircleKit;
4813 class CircularArcKey;
4814 class CircularArcKit;
4815 class CircularWedgeKey;
4816 class CircularWedgeKit;
4817 class IncludeKey;
4818 class InfiniteLineKey;
4819 class InfiniteLineKit;
4820 class SpotlightKey;
4821 class SpotlightKit;
4822 class NURBSCurveKey;
4823 class NURBSCurveKit;
4824 class NURBSSurfaceKey;
4825 class NURBSSurfaceKit;
4826 class TrimKit;
4827 class TrimElement;
4828 class EllipseKey;
4829 class EllipseKit;
4830 class EllipticalArcKey;
4831 class EllipticalArcKit;
4832 class ShellKit;
4833 class ShellKey;
4834 class Shell;
4835 class MeshKit;
4836 class MeshKey;
4837 class WindowKey;
4838 class Database;
4839 class NURBSSurfaceAttributeKit;
4840 class NURBSSurfaceAttributeControl;
4841 class Driver;
4842 class Search;
4843 class PerformanceKit;
4844 class PerformanceControl;
4845 class HiddenLineAttributeKit;
4846 class HiddenLineAttributeControl;
4847 class DrawingAttributeKit;
4848 class DrawingAttributeControl;
4849 class PortfolioKey;
4850 class Selection;
4851 class SelectionOptionsKit;
4852 class SelectionResults;
4853 class SelectionItem;
4854 class SelectionControl;
4855 class HighlightControl;
4856 class HighlightOptionsKit;
4857 class ImageDefinition;
4858 class ImageKit;
4859 class TextureDefinition;
4860 class TextureOptionsKit;
4861 class NamedStyleDefinition;
4862 class MaterialPaletteDefinition;
4863 class GlyphDefinition;
4864 class LinePatternOptionsKit;
4865 class LinePatternDefinition;
4866 class LinePatternKit;
4867 class LinePatternElement;
4868 class LinePatternParallelKit;
4869 class CubeMapDefinition;
4870 class ShaderKit;
4871 class ShaderDefinition;
4872 class EmergencyHandler;
4873 class EventDispatcher;
4874 class EventHandler;
4875 class Event;
4876 class StandAloneWindowKey;
4877 class StandAloneWindowOptionsKit;
4878 class ApplicationWindowKey;
4879 class ApplicationWindowOptionsKit;
4880 class OffScreenWindowKey;
4881 class OffScreenWindowOptionsKit;
4882 class LightingAttributeControl;
4883 class VisualEffectsControl;
4884 class PostProcessEffectsControl;
4885 class SelectionOptionsControl;
4886 class ObjectPoint;
4887 class WorldPoint;
4888 class CameraPoint;
4889 class NormalizedPoint;
4890 class ScreenRangePoint;
4891 class InnerWindowPoint;
4892 class InnerPixelPoint;
4893 class WindowPoint;
4894 class PixelPoint;
4895 class VisibilityKit;
4896 class CameraKit;
4897 class SelectabilityKit;
4898 class MarkerAttributeKit;
4899 class LightingAttributeKit;
4900 class VisualEffectsKit;
4901 class PostProcessEffectsKit;
4902 class Portfolio;
4903 class SubwindowControl;
4904 class SubwindowKit;
4905 class World;
4906 class DebuggingControl;
4907 class DebuggingKit;
4908 class KeyPath;
4909 class ContourLineKit;
4910 class ContourLineControl;
4911 class UTF8;
4912 class StyleControl;
4913 class PortfolioControl;
4914 class Condition;
4915 class ConditionControl;
4916 class WindowInfoKit;
4917 class WindowInfoControl;
4918 class FontInfoState;
4919 class FontInfoControl;
4920 class SearchOptionsKit;
4921 class AttributeLockControl;
4922 class AttributeLockKit;
4923 class ReferenceKey;
4924 class StyleKey;
4925 class BoundingKit;
4926 class BoundingControl;
4927 class TransformMaskKit;
4928 class TransformMaskControl;
4929 class ColorInterpolationKit;
4930 class ColorInterpolationControl;
4931 class UpdateOptionsKit;
4932 class UpdateOptionsControl;
4933 class GeometryKey;
4934 class TreeContext;
4935 class ShellRelationOptionsKit;
4936 class ShellRelationResultsKit;
4937 class GridKit;
4938 class GridKey;
4939 class CutGeometryGatheringOptionsKit;
4940 
4944 
4945 
4948 class HPS_API GlyphPoint
4949 {
4950 public:
4951 
4953  GlyphPoint();
4954 
4959  GlyphPoint(sbyte in_x, sbyte in_y);
4960 
4965  bool Equals(GlyphPoint const & in_that) const { return (x==in_that.x && y==in_that.y); }
4966 
4971  bool operator==(GlyphPoint const & in_that) const { return Equals(in_that); }
4972 
4977  bool operator!=(GlyphPoint const & in_that) const { return !Equals(in_that); }
4978 
4979  sbyte x;
4980  sbyte y;
4981 };
4982 
4985 enum class Type : uint32_t
4986 {
4987  None = 0x00000000,
4988  GenericMask = 0xffffff00,
4989 
4990  World = 0x00000001,
4991  UTF8 = 0x00000002,
4992  EventDispatcher = 0x00000003,
4993  EventHandler = 0x00000004,
4994  EventNotifier = 0x00000005,
4995  UpdateNotifier = 0x00000006,
4996  SearchResults = 0x00000008,
4997  FontSearchResults = 0x00000009,
4998  SearchResultsIterator = 0x0100000a, // Using Kit bit. Change to special Iterator bit?
4999  FontSearchResultsIterator = 0x0100000b, // Using Kit bit. Change to special Iterator bit?
5000  SelectionResults = 0x0000000c,
5001  SelectionResultsIterator = 0x0100000d, // Using Kit bit. Change to special Iterator bit?
5002  SelectionItem = 0x0000000e,
5003  TreeContext = 0x0000000f,
5004 
5005  IONotifier = 0x04000100,
5006  StreamImportNotifier = 0x04000101,
5007  STLImportNotifier = 0x04000102,
5008  OBJImportNotifier = 0x04000103,
5009  ExchangeImportNotifier = 0x04000104,
5010  SketchupImportNotifier = 0x04000105,
5011  ParasolidImportNotifier = 0x04000106,
5012  ExchangeTranslationNotifier = 0x04000107,
5013  ExchangeExportNotifier = 0x04000108,
5014 
5015  Kit = 0x01000000,
5016  MarkerKit = 0x01000010,
5017  SphereAttributeKit = 0x01000011,
5018  TextAttributeKit = 0x01000012,
5019  TransparencyKit = 0x01000013,
5020  VisibilityKit = 0x01000014,
5021  VisualEffectsKit = 0x01000015,
5022  CuttingSectionAttributeKit = 0x01000016,
5023  CircleKit = 0x01000017,
5024  CircularArcKit = 0x01000018,
5025  CircularWedgeKit = 0x01000019,
5026  CuttingSectionKit = 0x0100001a,
5027  CylinderKit = 0x0100001b,
5028  DistantLightKit = 0x0100001c,
5029  EllipseKit = 0x0100001d,
5030  EllipticalArcKit = 0x0100001e,
5031  InfiniteLineKit = 0x0100001f,
5032  LineKit = 0x01000020,
5033  NURBSCurveKit = 0x01000021,
5034  MeshKit = 0x01000022,
5035  NURBSSurfaceKit = 0x01000023,
5036  PolygonKit = 0x01000024,
5037  SphereKit = 0x01000025,
5038  SpotlightKit = 0x01000026,
5039  ShellKit = 0x01000027,
5040  TextKit = 0x01000028,
5041  MaterialKit = 0x01000029,
5042  TrimKit = 0x0100002a,
5043  TextureOptionsKit = 0x0100002c,
5044  LinePatternKit = 0x0100002d,
5045  GlyphKit = 0x0100002e,
5046  ImageKit = 0x0100002f,
5047  LinePatternOptionsKit = 0x01000030,
5048  CameraKit = 0x01000031,
5049  BoundingKit = 0x01000032,
5050  CullingKit = 0x01000033,
5051  CurveAttributeKit = 0x01000034,
5052  CylinderAttributeKit = 0x01000035,
5053  EdgeAttributeKit = 0x01000036,
5054  LightingAttributeKit = 0x01000037,
5055  LineAttributeKit = 0x01000038,
5056  MarkerAttributeKit = 0x01000039,
5057  MaterialMappingKit = 0x0100003a,
5058  MatrixKit = 0x0100003b,
5059  NURBSSurfaceAttributeKit = 0x0100003c,
5060  PostProcessEffectsKit = 0x0100003d,
5061  SelectabilityKit = 0x0100003e,
5062  SelectionOptionsKit = 0x0100003f,
5063  StandAloneWindowOptionsKit = 0x01000040,
5064  OffScreenWindowOptionsKit = 0x01000041,
5065  ApplicationWindowOptionsKit = 0x01000042,
5066  HighlightOptionsKit = 0x01000043,
5067  LinePatternParallelKit = 0x01000044,
5068  SubwindowKit = 0x01000045,
5069  PerformanceKit = 0x01000046,
5070  HiddenLineAttributeKit = 0x01000047,
5071  DrawingAttributeKit = 0x01000048,
5072  ShaderKit = 0x01000049,
5073  DebuggingKit = 0x0100004a,
5074  ContourLineKit = 0x0100004b,
5075  StreamImportOptionsKit = 0x0100004c,
5076  StreamImportResultsKit = 0x0100004d,
5077  StreamExportOptionsKit = 0x0100004e,
5078  StreamExportResultsKit = 0x0100004f,
5079  WindowInfoKit = 0x01000050,
5080  ImageImportOptionsKit = 0x01000051,
5081  SearchOptionsKit = 0x01000052,
5082  ShaderImportOptionsKit = 0x01000053,
5083  HardcopyExportOptionsKit = 0x01000055,
5084  AttributeLockKit = 0x01000056,
5085  TransformMaskKit = 0x01000057,
5086  ColorInterpolationKit = 0x01000058,
5087  UpdateOptionsKit = 0x01000059,
5088  ImageExportOptionsKit = 0x0100005a,
5089  OBJImportOptionsKit = 0x0100005b,
5090  OBJImportResultsKit = 0x0100005c,
5091  STLImportOptionsKit = 0x0100005d,
5092  STLImportResultsKit = 0x0100005e,
5093  ShellOptimizationOptionsKit = 0x0100005f,
5094  ShellRelationOptionsKit = 0x01000060,
5095  ShellRelationResultsKit = 0x01000061,
5096  GridKit = 0x01000062,
5097  CutGeometryGatheringOptionsKit = 0x01000063,
5098 
5099 
5100  LinePatternElement = 0x03000000,
5101  SolidLinePatternElement = 0x03000001,
5102  BlankLinePatternElement = 0x03000002,
5103  GlyphLinePatternElement = 0x03000003,
5104 
5105  GlyphElement = 0x05000000,
5106  DotGlyphElement = 0x05000001,
5107  LineGlyphElement = 0x05000002,
5108  EllipseGlyphElement = 0x05000003,
5109  CircularArcGlyphElement = 0x05000004,
5110  InfiniteLineGlyphElement = 0x05000005,
5111 
5112  TrimElement = 0x07000000,
5113 
5114  Condition = 0x09000000,
5115  NOTCondition = 0x09000001,
5116  ANDCondition = 0x09000002,
5117  ORCondition = 0x09000003,
5118  XORCondition = 0x09000004,
5119 
5120  MouseState = 0x01001001,
5121  TouchState = 0x01001002,
5122  KeyboardState = 0x01001003,
5123  FontInfoState = 0x01001004,
5124 
5125  KeyPath = 0x01000F01,
5126 
5127  Key = 0x10000000,
5128  IncludeKey = 0x10000001,
5129  PortfolioKey = 0x10000002,
5130  StyleKey = 0x10000003,
5131 
5132  SegmentKey = 0x10200000,
5133  WindowKey = 0x10600000,
5134  StandAloneWindowKey = 0x10600001,
5135  OffScreenWindowKey = 0x10600002,
5136  ApplicationWindowKey = 0x10600003,
5137 
5138  GeometryKey = 0x10100000,
5139  ReferenceKey = 0x10100001,
5140  CircleKey = 0x10100002,
5141  CircularArcKey = 0x10100003,
5142  CircularWedgeKey = 0x10100004,
5143  CuttingSectionKey = 0x10100005,
5144  CylinderKey = 0x10100006,
5145  EllipseKey = 0x10100007,
5146  EllipticalArcKey = 0x10100008,
5147  InfiniteLineKey = 0x10100009,
5148  LineKey = 0x1010000a,
5149  DistantLightKey = 0x1010000b,
5150  SpotlightKey = 0x1010000c,
5151  MarkerKey = 0x1010000d,
5152  MeshKey = 0x1010000e,
5153  NURBSCurveKey = 0x1010000f,
5154  NURBSSurfaceKey = 0x10100010,
5155  PolygonKey = 0x10100011,
5156  ShellKey = 0x10100012,
5157  SphereKey = 0x10100013,
5158  TextKey = 0x10100014,
5159  GridKey = 0x10100015,
5160 
5161  Definition = 0x20000000,
5162  NamedStyleDefinition = 0x20000001,
5163  TextureDefinition = 0x20000002,
5164  LinePatternDefinition = 0x20000003,
5165  GlyphDefinition = 0x20000004,
5166  CubeMapDefinition = 0x20000005,
5167  ImageDefinition = 0x20000006,
5168  MaterialPaletteDefinition = 0x20000007,
5169  ShaderDefinition = 0x20000008,
5170 
5171  Control = 0x50000000,
5172  CameraControl = 0x50000001,
5173  SelectabilityControl = 0x50000002,
5174  MarkerAttributeControl = 0x50000003,
5175  SphereAttributeControl = 0x50000004,
5176  LightingAttributeControl = 0x50000005,
5177  CylinderAttributeControl = 0x50000006,
5178  TextAttributeControl = 0x50000007,
5179  LineAttributeControl = 0x50000008,
5180  EdgeAttributeControl = 0x50000009,
5181  CurveAttributeControl = 0x5000000a,
5182  ModellingMatrixControl = 0x5000000b,
5183  TextureMatrixControl = 0x5000000c,
5184  CullingControl = 0x5000000d,
5185  TransparencyControl = 0x5000000e,
5186  MaterialMappingControl = 0x5000000f,
5187  NURBSSurfaceAttributeControl = 0x50000010,
5188  PostProcessEffectsControl = 0x50000011,
5189  BoundingControl = 0x50000012,
5190  VisualEffectsControl = 0x50000013,
5191  SelectionOptionsControl = 0x50000014,
5192  HighlightOptionsControl = 0x50000015,
5193  DefinitionControl = 0x50000016,
5194  SelectionControl = 0x50000017,
5195  HighlightControl = 0x50000018,
5196  StandAloneWindowOptionsControl = 0x50000019,
5197  OffScreenWindowOptionsControl = 0x5000001a,
5198  ApplicationWindowOptionsControl = 0x5000001b,
5199  VisibilityControl = 0x5000001c,
5200  SubwindowControl = 0x5000001d,
5201  PerformanceControl = 0x5000001e,
5202  HiddenLineAttributeControl = 0x5000001f,
5203  DrawingAttributeControl = 0x50000020,
5204  DebuggingControl = 0x50000021,
5205  ContourLineControl = 0x50000022,
5206  StyleControl = 0x50000023,
5207  ConditionControl = 0x50000024,
5208  PortfolioControl = 0x50000025,
5209  WindowInfoControl = 0x50000026,
5210  AttributeLockControl = 0x50000027,
5211  TransformMaskControl = 0x50000028,
5212  ColorInterpolationControl = 0x50000029,
5213  UpdateOptionsControl = 0x50000030,
5214  CuttingSectionAttributeControl = 0x50000031,
5215 
5216  LibraryMask = 0x80FF0000,
5217 
5218  Sprocket = 0x80000000,
5219  Canvas = 0x80000001,
5220  Layout = 0x80000002,
5221  View = 0x80000003,
5222  Model = 0x80000004,
5223  Operator = 0x80000005,
5224  SprocketPath = 0x80000007,
5225 
5226  SprocketControl = 0xD0000000,
5227  OperatorControl = 0xD0000008,
5228  NavigationCubeControl = 0xD0000009,
5229  AxisTriadControl = 0xD000000A,
5230 
5231  Metadata = 0x80001000,
5232  IntegerMetadata = 0x80001001,
5233  UnsignedIntegerMetadata = 0x80001002,
5234  DoubleMetadata = 0x80001003,
5235  StringMetadata = 0x80001004,
5236  TimeMetadata = 0x80001005,
5237  BooleanMetadata = 0x80001006,
5238 
5239  Component = 0x80000200,
5240  Filter = 0x80000600,
5241  Capture = 0x80000a00,
5242  CADModel = 0x80000300,
5243  ComponentPath = 0x81001000,
5244 
5245  ExchangeMask = 0x80020000,
5246  ExchangeComponent = 0x80021200,
5247  ExchangeFilter = 0x80020601,
5248  ExchangeCapture = 0x80020a01,
5249  ExchangeCADModel = 0x80020301,
5250  ExchangeConfiguration = 0x81020001,
5251  ExchangeImportOptionsKit = 0x81020002,
5252  ExchangeExportACISOptionsKit = 0x81020003,
5253  ExchangeExportIGESOptionsKit = 0x81020004,
5254  ExchangeExportJTOptionsKit = 0x81020005,
5255  ExchangeExportParasolidOptionsKit = 0x81020006,
5256  ExchangeExportPRCOptionsKit = 0x81020007,
5257  ExchangeExportSTEPOptionsKit = 0x81020008,
5258  ExchangeExportSTLOptionsKit = 0x81020009,
5259  ExchangeExportU3DOptionsKit = 0x8102000a,
5260  ExchangeExportXMLOptionsKit = 0x8102000b,
5261  ExchangeTessellationOptionsKit = 0x8102000c,
5262  ExchangeSheet = 0x80021201,
5263  ExchangeModelFileImportOptionsKit = 0x8102000d,
5264 
5265  PublishMask = 0x80040000,
5266  PublishDocumentKit = 0x81040001,
5267  PublishPageKit = 0x81040002,
5268  PublishTemplateKit = 0x81040003,
5269  PublishAnnotationKit = 0x81040004,
5270  PublishArtworkKit = 0x81040005,
5271  PublishViewKit = 0x81040006,
5272  PublishTextKit = 0x81040007,
5273  PublishImageKit = 0x81040008,
5274  PublishTableKit = 0x81040009,
5275  PublishExportOptionsKit = 0x8104000a,
5276  PublishLinkKit = 0x8104000b,
5277  PublishButtonKit = 0x8104000c,
5278  PublishTextFieldKit = 0x8104000d,
5279  PublishSlideTableKit = 0x8104000e,
5280  PublishCheckBoxKit = 0x8104000f,
5281  PublishRadioButtonKit = 0x81040010,
5282  PublishListBoxKit = 0x81040011,
5283  PublishDropDownListKit = 0x81040012,
5284  PublishSignatureFieldKit = 0x81040013,
5285 
5286  PublishDocumentKey = 0x80040001,
5287  PublishPageControl = 0x80040002,
5288 
5289  SceneTree = 0x80008001,
5290  SceneTreeItem = 0x80008002,
5291 
5292  ComponentTree = 0x80008003,
5293  ComponentTreeItem = 0x80008004,
5294 
5295  SketchupMask = 0x80100000,
5296  SketchupImportOptionsKit = 0x81100001,
5297  SketchupImportResultsKit = 0x81100002,
5298 
5299  ParasolidMask = 0x80200000,
5300  ParasolidComponent = 0x80201201,
5301  ParasolidCADModel = 0x80200302,
5302  ParasolidImportOptionsKit = 0x81200003,
5303  ParasolidFacetTessellationKit = 0x81200004,
5304  ParasolidLineTessellationKit = 0x81200005,
5305  ParasolidExportOptionsKit = 0x81200006,
5306 
5307  IONotifierData = 0x84000200,
5308  StreamImportNotifierData = 0x84000201,
5309  STLImportNotifierData = 0x84000202,
5310  OBJImportNotifierData = 0x84000203,
5311  ExchangeImportNotifierData = 0x84020204,
5312  SketchupImportNotifierData = 0x84100205,
5313  ParasolidImportNotifierData = 0x84200206,
5314  ExchangeTranslationNotifierData = 0x84020207,
5315  ExchangeExportNotifierData = 0x84020208,
5316 };
5317 
5319 class HPS_API Memory
5320 {
5321 public:
5327  static void * Allocate(size_t in_bytes, bool in_clear_memory = true);
5328 
5329 
5334  static void Free(void * in_pointer);
5335 
5336 private:
5338  Memory();
5339 };
5340 
5341 
5343 template <typename T>
5344 class NO_HPS_API Allocator
5345 {
5346 public:
5347  typedef T value_type;
5348  typedef value_type * pointer;
5349  typedef value_type const * const_pointer;
5350  typedef value_type & reference;
5351  typedef value_type const & const_reference;
5352  typedef size_t size_type;
5353  typedef ptrdiff_t difference_type;
5354 
5355 
5356  Allocator() {}
5357  Allocator(Allocator<T> const & in_that) { HPS_UNREFERENCED(in_that); }
5358  ~Allocator() {}
5359 
5360  template <typename U> Allocator(Allocator<U> const &) {}
5361 
5362  template <typename U>
5363  struct rebind
5364  {
5365  typedef Allocator<U> other;
5366  };
5367 
5368 
5369  pointer address(reference x) const { return &x; }
5370  const_pointer address(const_reference x) const { return &x; }
5371 
5372  pointer allocate(size_type n, void * v = 0) { HPS_UNREFERENCED(v); return static_cast<pointer>(Memory::Allocate(n * sizeof(T))); }
5373  void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n); Memory::Free(p); }
5374 
5375 #if defined(_MSC_VER) || defined (__APPLE__)
5376  void construct(pointer p, const_reference x) { new(p) T(x); }
5377 #else
5378  template<typename U, typename... Args>
5379  void construct(U * p, Args&&... args) { new(p) U(std::forward<Args>(args)...); }
5380 #endif
5381  void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5382 
5383  size_type max_size() const { return static_cast<size_type>(-1) / sizeof(T); }
5384 };
5385 
5386 template <typename T, typename U>
5387 bool operator==(const Allocator<T> &, const Allocator<U> &) { return true; }
5388 
5389 template <typename T, typename U>
5390 bool operator!=(const Allocator<T> &, const Allocator<U> &) { return false; }
5391 
5393 class Exception : public std::runtime_error
5394 {
5395 public:
5396  Exception(char const * in_info) : std::runtime_error(in_info) { }
5397 };
5398 
5399 
5402 {
5403 public:
5404  InvalidObjectException(char const * in_info = "Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5405  Exception(in_info) {}
5406 };
5407 
5408 
5412 {
5413 public:
5414  IndexOutOfRangeException(char const * in_info = "Attempted to access an element outside the bounds of the array.") :
5415  Exception(in_info) {}
5416 };
5417 
5418 
5421 {
5422 public:
5423  InvalidSpecificationException(char const * in_info = "Missing or invalid specification.") :
5424  Exception(in_info) {}
5425 };
5426 
5427 
5430 {
5431 public:
5432  InvalidLicenseException(char const * in_info) :
5433  Exception(in_info) {}
5434 };
5435 
5436 
5439 {
5440 public:
5441  InvalidOperationException(char const * in_info = "Operation not supported on this platform.") :
5442  Exception(in_info) {}
5443 };
5444 
5446 class IOException : public Exception
5447 {
5448 public:
5452  IOException(char const * in_info, IOResult in_result)
5453  : Exception(in_info), result(in_result) {}
5454 
5455  IOResult result;
5456 };
5457 
5458 
5460 class HPS_API Object
5461 {
5462 public:
5463 
5464  Object();
5465 
5466  virtual ~Object();
5467 
5468  Object & operator=(Object const & other_object);
5469 
5473  Object(Object && in_that);
5474 
5475 
5479  Object & operator=(Object && in_that);
5480 
5484  Type Type() const;
5485 
5489  virtual Type ObjectType() const { return Type::None; }
5490 
5493  virtual bool Empty() const {return (impl_ == 0);};
5494 
5496  virtual void Reset();
5497 
5501  bool HasType(Type in_mask) const;
5502 
5505  intptr_t GetClassID() const;
5506 
5510  intptr_t GetInstanceID() const;
5511 
5512  template <typename T>
5513  static intptr_t ClassID()
5514  {
5515  static const intptr_t ret = T().GetClassID();
5516  return ret;
5517  }
5518 private:
5519 
5520  friend class HPSI::Impl;
5521  friend class HPSI::KeyImpl;
5522  friend class HPSI::TicketImpl;
5523 
5524  HPSI::Impl * impl_;
5525 };
5526 
5527 
5529 class HPS_API Control : public Object
5530 {
5531  Type ObjectType() const {return Type::Control;}
5532 
5533 
5534 
5535 protected:
5536  Control() {}
5537 
5541  Control(Control && in_that) : Object(std::move(in_that)) {}
5542 
5546  Control & operator=(Control && in_that)
5547  {
5548  this->Object::operator=(std::move(in_that));
5549  return *this;
5550  }
5551 };
5552 
5553 
5555 class HPS_API ObjectPoint : public Point
5556 {
5557 public:
5558 
5560  ObjectPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5561 
5563  ObjectPoint(Point const & in_point):Point(in_point){}
5564 
5566  ObjectPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5567 
5569  ObjectPoint(WindowKey const & in_window, WorldPoint const & in_point);
5570 
5572  ObjectPoint(WindowKey const & in_window, CameraPoint const & in_point);
5573 
5575  ObjectPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5576 
5578  ObjectPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5579 
5581  ObjectPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5582 
5584  ObjectPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5585 
5587  ObjectPoint(WindowKey const & in_window, WindowPoint const & in_point);
5588 
5590  ObjectPoint(WindowKey const & in_window, PixelPoint const & in_point);
5591 
5592 private:
5593 
5594  ObjectPoint(WorldPoint const & in_point); // Prevent implicit conversion to other types of points
5595  ObjectPoint(CameraPoint const & in_point); // Prevent implicit conversion to other types of points
5596  ObjectPoint(NormalizedPoint const & in_point); // Prevent implicit conversion to other types of points
5597  ObjectPoint(ScreenRangePoint const & in_point); // Prevent implicit conversion to other types of points
5598  ObjectPoint(InnerWindowPoint const & in_point); // Prevent implicit conversion to other types of points
5599  ObjectPoint(InnerPixelPoint const & in_point); // Prevent implicit conversion to other types of points
5600  ObjectPoint(WindowPoint const & in_point); // Prevent implicit conversion to other types of points
5601  ObjectPoint(PixelPoint const & in_point); // Prevent implicit conversion to other types of points
5602 
5603 };
5604 
5606 class HPS_API WorldPoint : public Point
5607 {
5608 public:
5610  WorldPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5611 
5613  WorldPoint(Point const & in_point):Point(in_point){}
5614 
5616  WorldPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5617 
5619  WorldPoint(WindowKey const & in_window, WorldPoint const & in_point);
5620 
5622  WorldPoint(WindowKey const & in_window, CameraPoint const & in_point);
5623 
5625  WorldPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5626 
5628  WorldPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5629 
5631  WorldPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5632 
5634  WorldPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5635 
5637  WorldPoint(WindowKey const & in_window, WindowPoint const & in_point);
5638 
5640  WorldPoint(WindowKey const & in_window, PixelPoint const & in_point);
5641 
5642 private:
5643 
5644  WorldPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5645  WorldPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5646  WorldPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5647  WorldPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5648  WorldPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5649  WorldPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5650  WorldPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5651  WorldPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5652 
5653 };
5654 
5656 class HPS_API CameraPoint : public Point
5657 {
5658 public:
5660  CameraPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5661 
5663  CameraPoint(Point const & in_point):Point(in_point){}
5664 
5666  CameraPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5667 
5669  CameraPoint(WindowKey const & in_window, WorldPoint const & in_point);
5670 
5672  CameraPoint(WindowKey const & in_window, CameraPoint const & in_point);
5673 
5675  CameraPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5676 
5678  CameraPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5679 
5681  CameraPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5682 
5684  CameraPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5685 
5687  CameraPoint(WindowKey const & in_window, WindowPoint const & in_point);
5688 
5690  CameraPoint(WindowKey const & in_window, PixelPoint const & in_point);
5691 
5692 private:
5693  CameraPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5694  CameraPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5695  CameraPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5696  CameraPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5697  CameraPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5698  CameraPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5699  CameraPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5700  CameraPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5701 
5702 };
5703 
5705 class HPS_API NormalizedPoint : public Point
5706 {
5707 public:
5708 
5710  NormalizedPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5711 
5713  NormalizedPoint(Point const & in_point):Point(in_point){}
5714 
5716  NormalizedPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5717 
5719  NormalizedPoint(WindowKey const & in_window, WorldPoint const & in_point);
5720 
5722  NormalizedPoint(WindowKey const & in_window, CameraPoint const & in_point);
5723 
5725  NormalizedPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5726 
5728  NormalizedPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5729 
5731  NormalizedPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5732 
5734  NormalizedPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5735 
5737  NormalizedPoint(WindowKey const & in_window, WindowPoint const & in_point);
5738 
5740  NormalizedPoint(WindowKey const & in_window, PixelPoint const & in_point);
5741 
5742 private:
5743  NormalizedPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5744  NormalizedPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5745  NormalizedPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5746  NormalizedPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5747  NormalizedPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5748  NormalizedPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5749  NormalizedPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5750  NormalizedPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5751 };
5752 
5754 class HPS_API ScreenRangePoint : public Point
5755 {
5756 public:
5758  ScreenRangePoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5759 
5761  ScreenRangePoint(Point const & in_point):Point(in_point){}
5762 
5764  ScreenRangePoint(WindowKey const & in_window, ObjectPoint const & in_point);
5765 
5767  ScreenRangePoint(WindowKey const & in_window, WorldPoint const & in_point);
5768 
5770  ScreenRangePoint(WindowKey const & in_window, CameraPoint const & in_point);
5771 
5773  ScreenRangePoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5774 
5776  ScreenRangePoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5777 
5779  ScreenRangePoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5780 
5782  ScreenRangePoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5783 
5785  ScreenRangePoint(WindowKey const & in_window, WindowPoint const & in_point);
5786 
5788  ScreenRangePoint(WindowKey const & in_window, PixelPoint const & in_point);
5789 
5790 private:
5791  ScreenRangePoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5792  ScreenRangePoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5793  ScreenRangePoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5794  ScreenRangePoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5795  ScreenRangePoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5796  ScreenRangePoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5797  ScreenRangePoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5798  ScreenRangePoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5799 
5800 };
5801 
5803 class HPS_API InnerWindowPoint : public Point
5804 {
5805 public:
5806 
5808  InnerWindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5809 
5811  InnerWindowPoint(Point const & in_point):Point(in_point){}
5812 
5814  InnerWindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5815 
5817  InnerWindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
5818 
5820  InnerWindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
5821 
5823  InnerWindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5824 
5826  InnerWindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5827 
5829  InnerWindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5830 
5832  InnerWindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5833 
5835  InnerWindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
5836 
5838  InnerWindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
5839 
5840 private:
5841  InnerWindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5842  InnerWindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5843  InnerWindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5844  InnerWindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5845  InnerWindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5846  InnerWindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5847  InnerWindowPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5848  InnerWindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5849 };
5850 
5852 class HPS_API InnerPixelPoint : public Point
5853 {
5854 public:
5855 
5857  InnerPixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5858 
5860  InnerPixelPoint(Point const & in_point):Point(in_point){}
5861 
5863  InnerPixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5864 
5866  InnerPixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
5867 
5869  InnerPixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
5870 
5872  InnerPixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5873 
5875  InnerPixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5876 
5878  InnerPixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5879 
5881  InnerPixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5882 
5884  InnerPixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
5885 
5887  InnerPixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
5888 
5889 private:
5890  InnerPixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5891  InnerPixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5892  InnerPixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5893  InnerPixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5894  InnerPixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5895  InnerPixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5896  InnerPixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5897  InnerPixelPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5898 
5899 };
5900 
5902 class HPS_API WindowPoint : public Point
5903 {
5904 public:
5905 
5907  WindowPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5908 
5910  WindowPoint(Point const & in_point):Point(in_point){}
5911 
5913  WindowPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5914 
5916  WindowPoint(WindowKey const & in_window, WorldPoint const & in_point);
5917 
5919  WindowPoint(WindowKey const & in_window, CameraPoint const & in_point);
5920 
5922  WindowPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5923 
5925  WindowPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5926 
5928  WindowPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5929 
5931  WindowPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5932 
5934  WindowPoint(WindowKey const & in_window, WindowPoint const & in_point);
5935 
5937  WindowPoint(WindowKey const & in_window, PixelPoint const & in_point);
5938 
5939 private:
5940  WindowPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5941  WindowPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5942  WindowPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5943  WindowPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5944  WindowPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5945  WindowPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5946  WindowPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5947  WindowPoint(PixelPoint const & in_point); // Prevents implicit conversion to other points
5948 };
5949 
5950 
5952 class HPS_API PixelPoint : public Point
5953 {
5954 public:
5956  PixelPoint(float px = 0.0f, float py = 0.0f, float pz = 0.0f) : Point(px, py, pz) {}
5957 
5959  PixelPoint(Point const & in_point):Point(in_point){}
5960 
5962  PixelPoint(WindowKey const & in_window, ObjectPoint const & in_point);
5963 
5965  PixelPoint(WindowKey const & in_window, WorldPoint const & in_point);
5966 
5968  PixelPoint(WindowKey const & in_window, CameraPoint const & in_point);
5969 
5971  PixelPoint(WindowKey const & in_window, NormalizedPoint const & in_point);
5972 
5974  PixelPoint(WindowKey const & in_window, ScreenRangePoint const & in_point);
5975 
5977  PixelPoint(WindowKey const & in_window, InnerWindowPoint const & in_point);
5978 
5980  PixelPoint(WindowKey const & in_window, InnerPixelPoint const & in_point);
5981 
5983  PixelPoint(WindowKey const & in_window, WindowPoint const & in_point);
5984 
5986  PixelPoint(WindowKey const & in_window, PixelPoint const & in_point);
5987 
5988 private:
5989  PixelPoint(ObjectPoint const & in_point); // Prevents implicit conversion to other points
5990  PixelPoint(WorldPoint const & in_point); // Prevents implicit conversion to other points
5991  PixelPoint(CameraPoint const & in_point); // Prevents implicit conversion to other points
5992  PixelPoint(NormalizedPoint const & in_point); // Prevents implicit conversion to other points
5993  PixelPoint(ScreenRangePoint const & in_point); // Prevents implicit conversion to other points
5994  PixelPoint(InnerWindowPoint const & in_point); // Prevents implicit conversion to other points
5995  PixelPoint(InnerPixelPoint const & in_point); // Prevents implicit conversion to other points
5996  PixelPoint(WindowPoint const & in_point); // Prevents implicit conversion to other points
5997 
5998 };
5999 
6002 class HPS_API Event
6003 {
6004 public:
6008  enum class Status
6009  {
6010  InProgress,
6011  Completed,
6012  Failed
6013  };
6014 
6016  Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6017 
6018  virtual ~Event();
6019 
6021  intptr_t GetClassID() const;
6022 
6025  virtual Event * Clone() const=0;
6026 
6028  virtual bool Drop(Event const * in_that_event) const { HPS_UNREFERENCED(in_that_event); return false; }
6029 
6032  virtual intptr_t Freshen() const { return 0; }
6033 
6035  intptr_t GetChannel() const { return channel; }
6036 
6038  Time GetTimeStamp() const { return time_stamp; }
6039 
6041  bool IsConsumable() const { return consumable; }
6042 
6043  static void * operator new (size_t in_size) { return Memory::Allocate(in_size); }
6044  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
6045 
6046 protected:
6047  intptr_t channel;
6048  bool consumable;
6049 
6050 private:
6051  friend class HPSI::EventDispatcherImpl;
6052  Time time_stamp;
6053 };
6054 
6055 
6058 class HPS_API EventNotifier : public Object
6059 {
6060 public:
6061 
6063  EventNotifier();
6064 
6067  EventNotifier(EventNotifier const & in_that);
6068 
6072  EventNotifier(EventNotifier && in_that);
6073 
6077  EventNotifier & operator=(EventNotifier && in_that);
6078 
6079  virtual ~EventNotifier();
6080 
6081  Type ObjectType() const {return Type::EventNotifier;};
6082 
6086  EventNotifier & operator=(EventNotifier const & in_that);
6087 
6090  virtual void Assign(EventNotifier const & in_that);
6091 
6093  void Wait() const;
6094 
6097  Event::Status Status() const;
6098 };
6099 
6101 enum class KeyboardCode
6102 {
6103  None = 0,
6104 
6105  Backspace = 8,
6106  Tab = 9,
6107  Clear = 11,
6108  Return = 13,
6109  Shift = 16,
6110  Control = 17,
6111  Alt = 18,
6112  Pause = 19,
6113  Escape = 27,
6114 
6115  Space = 32,
6116  ExclamationMark,
6117  DoubleQuote,
6118  Number,
6119  Dollar,
6120  Percent,
6121  Ampersand,
6122  SingleQuote,
6123  OpenParen,
6124  CloseParen,
6125 
6126  Asterisk,
6127  Plus,
6128  Comma,
6129  Hyphen,
6130  Period,
6131  Slash,
6132 
6133  D0,
6134  D1,
6135  D2,
6136  D3,
6137  D4,
6138  D5,
6139  D6,
6140  D7,
6141  D8,
6142  D9,
6143 
6144  Colon,
6145  Semicolon,
6146  LessThan,
6147  Equal,
6148  GreaterThan,
6149  QuestionMark,
6150  AtSymbol,
6151 
6152  A,
6153  B,
6154  C,
6155  D,
6156  E,
6157  F,
6158  G,
6159  H,
6160  I,
6161  J,
6162  K,
6163  L,
6164  M,
6165  N,
6166  O,
6167  P,
6168  Q,
6169  R,
6170  S,
6171  T,
6172  U,
6173  V,
6174  W,
6175  X,
6176  Y,
6177  Z,
6178 
6179  OpenBrackets,
6180  Backslash,
6181  CloseBrackets,
6182  Caret,
6183  Underscore,
6184  Backtick,
6185 
6186  a,
6187  b,
6188  c,
6189  d,
6190  e,
6191  f,
6192  g,
6193  h,
6194  i,
6195  j,
6196  k,
6197  l,
6198  m,
6199  n,
6200  o,
6201  p,
6202  q,
6203  r,
6204  s,
6205  t,
6206  u,
6207  v,
6208  w,
6209  x,
6210  y,
6211  z,
6212 
6213  OpenBrace,
6214  VerticalBar,
6215  ClosingBrace,
6216  Tilde,
6217  Delete,
6218 
6219  Insert=1024,
6220  Home,
6221  End,
6222  PageUp,
6223  PageDown,
6224 
6225  Help,
6226 
6227  Left,
6228  Up,
6229  Right,
6230  Down,
6231 
6232  NumPad0,
6233  NumPad1,
6234  NumPad2,
6235  NumPad3,
6236  NumPad4,
6237  NumPad5,
6238  NumPad6,
6239  NumPad7,
6240  NumPad8,
6241  NumPad9,
6242 
6243  F1,
6244  F2,
6245  F3,
6246  F4,
6247  F5,
6248  F6,
6249  F7,
6250  F8,
6251  F9,
6252  F10,
6253  F11,
6254  F12,
6255  F13,
6256  F14,
6257  F15,
6258  F16,
6259  F17,
6260  F18,
6261  F19,
6262  F20,
6263  F21,
6264  F22,
6265  F23,
6266  F24,
6267 
6268  // these are not implemented
6269 // CapsLock, //!< The Caps Lock key.
6270 //
6271 // NumLock, //!< The Num Lock key.
6272 // ScrollLock, //!< The Scroll Lock key.
6273 // LeftShift, //!< The left Shift key.
6274 // RightShift, //!< The right Shift key.
6275 // LeftCtrl, //!< The left CTRL key.
6276 // RightCtrl, //!< The right CTRL key.
6277 // LeftAlt, //!< The left ALT key.
6278 // RightAlt, //!< The right ALT key.
6279 //
6280 // Select, //!< The Select key.
6281 // Print, //!< The Print key.
6282 // Execute, //!< The Execute key.
6283 // PrintScreen, //!< The Print Screen key.
6284 };
6285 
6286 
6288 class NO_HPS_API Touch
6289 {
6290 public:
6291 
6294  Touch() : ID(0), Location(Point(0,0,0)), TapCount(0) {}
6295 
6300  Touch(TouchID in_id, WindowPoint const & in_location, size_t in_tap_count = 1)
6301  : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6302 
6306  inline bool operator==(Touch const & in_that) const
6307  {
6308  return (ID == in_that.ID && Location == in_that.Location && TapCount == in_that.TapCount);
6309  }
6310 
6314  inline bool operator!=(Touch const & in_that) const
6315  {
6316  return !(*this == in_that);
6317  }
6318 
6319  TouchID ID;
6321  size_t TapCount;
6322 };
6323 
6324 
6325 typedef std::vector<Point, Allocator<Point> > PointArray;
6326 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6327 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6328 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6329 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6330 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6331 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6332 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6333 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6334 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6335 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6336 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6337 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6338 typedef std::vector<int, Allocator<int> > IntArray;
6339 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6340 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6341 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6342 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6343 typedef std::vector<float, Allocator<float> > FloatArray;
6344 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6345 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6346 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6347 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6348 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6349 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6350 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6351 typedef std::vector<bool, Allocator<bool> > BoolArray;
6352 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6353 typedef std::vector<Key, Allocator<Key> > KeyArray;
6354 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6355 typedef std::vector<char, Allocator<char> > CharArray;
6356 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6357 typedef std::vector<byte, Allocator<byte> > ByteArray;
6358 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6359 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6360 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6361 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6362 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6363 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6364 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6365 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6366 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6367 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6368 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6369 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6370 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6371 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6372 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6373 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6374 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6375 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6376 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6377 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6378 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6379 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6380 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6381 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6382 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6383 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6384 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6385 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6386 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6387 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6388 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6389 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6390 
6391 
6393 class HPS_API SearchResultsIterator : public Object
6394 {
6395 public:
6396 
6399 
6403  SearchResultsIterator(SearchResultsIterator const & in_search_results_iterator);
6404 
6409 
6413  SearchResultsIterator & operator=(SearchResultsIterator && in_that);
6414 
6416 
6417  Type ObjectType() const {return Type::SearchResultsIterator;}
6418 
6423  SearchResultsIterator & operator=(SearchResultsIterator const & in_search_results_iterator);
6424 
6429  void Set(SearchResultsIterator const & in_search_results_iterator);
6430 
6432  void Next();
6433 
6436  SearchResultsIterator & operator++();
6437 
6440  SearchResultsIterator operator++(int in_val);
6441 
6444  bool operator==(SearchResultsIterator const & in_search_results_iterator);
6445 
6448  bool operator!=(SearchResultsIterator const & in_search_results_iterator);
6449 
6453  bool IsValid() const;
6454 
6456  void Reset();
6457 
6461  Key GetItem() const;
6462 
6465  Key operator*() const;
6466 
6469  SearchTypeArray GetResultTypes() const;
6470 };
6471 
6473 class HPS_API SearchResults : public Object
6474 {
6475 public:
6477  SearchResults();
6478 
6481  SearchResults(SearchResults const & in_search_results);
6482 
6486  SearchResults(SearchResults && in_that);
6487 
6491  SearchResults & operator=(SearchResults && in_that);
6492 
6494  virtual void Reset();
6495 
6497  ~SearchResults();
6498 
6499  Type ObjectType() const {return Type::SearchResults;}
6500 
6504  void Assign(SearchResults const & in_search_results);
6505 
6509  SearchResults & operator=(SearchResults const & in_search_results);
6510 
6513  size_t GetCount() const;
6514 
6517  SearchResultsIterator GetIterator() const;
6518 };
6519 
6521 class HPS_API FontSearchResultsIterator : public Object
6522 {
6523 public:
6524 
6527 
6531  FontSearchResultsIterator(FontSearchResultsIterator const & in_search_results_iterator);
6532 
6537 
6542  FontSearchResultsIterator & operator=(FontSearchResultsIterator const & in_search_results_iterator);
6543 
6544 
6548  FontSearchResultsIterator & operator=(FontSearchResultsIterator && in_that);
6549 
6551 
6552  Type ObjectType() const {return Type::FontSearchResultsIterator;}
6553 
6554 
6559  void Set(FontSearchResultsIterator const & in_search_results_iterator);
6560 
6562  void Next();
6563 
6566  FontSearchResultsIterator & operator++();
6567 
6570  FontSearchResultsIterator operator++(int in_val);
6571 
6574  bool operator==(FontSearchResultsIterator const & in_search_results_iterator);
6575 
6578  bool operator!=(FontSearchResultsIterator const & in_search_results_iterator);
6579 
6583  bool IsValid() const;
6584 
6586  void Reset();
6587 
6591  FontInfoState GetItem() const;
6592 
6595  FontInfoState operator*() const;
6596 
6597 };
6598 
6600 class HPS_API FontSearchResults : public Object
6601 {
6602 public:
6603 
6606 
6609  FontSearchResults(FontSearchResults const & in_search_results);
6610 
6615 
6619  FontSearchResults & operator=(FontSearchResults && in_that);
6620 
6622  virtual void Reset();
6623 
6625  ~FontSearchResults();
6626 
6627  Type ObjectType() const {return Type::FontSearchResults;}
6628 
6632  void Assign(FontSearchResults const & in_search_results);
6633 
6634 
6638  FontSearchResults & operator=(FontSearchResults const & in_search_results);
6639 
6642  size_t GetCount() const;
6643 
6646  FontSearchResultsIterator GetIterator() const;
6647 };
6648 
6650 class HPS_API UTF8
6651 {
6652 public:
6653 
6655  UTF8();
6656 
6658  ~UTF8();
6659 
6666  UTF8(char const * in_string, char const * in_locale = 0);
6667 
6670  UTF8(wchar_t const * in_string);
6671 
6674  UTF8(UTF8 const & in_that);
6675 
6678  UTF8(UTF8 && in_that);
6679 
6683  UTF8 & Assign(UTF8 && in_utf8);
6684 
6687  inline UTF8 & operator= (UTF8 && in_utf8)
6688  {
6689  return Assign(std::move(in_utf8));
6690  }
6691 
6696  size_t ToWStr(wchar_t * out_wide_string) const;
6697 
6701  size_t ToWStr(WCharArray & out_wide_string) const;
6702 
6705  inline bool IsValid() const
6706  {
6707  return (_length > 0);
6708  }
6709 
6712  inline bool Empty() const
6713  {
6714  return (_length == 0);
6715  }
6716 
6718  void Clear();
6719 
6721  void Reset() { Clear(); }
6722 
6726  inline size_t GetLength() const
6727  {
6728  return _length;
6729  }
6730 
6734  inline size_t GetWStrLength() const
6735  {
6736  return ToWStr(0);
6737  }
6738 
6741  inline char const * GetBytes() const
6742  {
6743  return _text;
6744  }
6745 
6748  inline operator char const * () const
6749  {
6750  return _text;
6751  }
6752 
6755  char At(size_t in_index) const
6756  {
6757  if(!IsValid())
6758  throw InvalidObjectException();
6759  else if(in_index >= _length)
6760  throw IndexOutOfRangeException();
6761  else
6762  return _text[in_index];
6763  }
6764 
6768  UTF8 & Assign(UTF8 const & in_utf8);
6769 
6773  inline UTF8 & operator= (UTF8 const & in_utf8)
6774  {
6775  return Assign(in_utf8);
6776  }
6777 
6781  UTF8 & operator+= (UTF8 const & in_utf8);
6782 
6786  UTF8 & operator+= (char const * in_utf8);
6787 
6791  UTF8 operator+ (UTF8 const & in_utf8) const;
6792 
6796  UTF8 operator+ (char const * in_utf8) const;
6797 
6801  bool operator== (UTF8 const & in_utf8) const;
6802 
6806  bool operator!= (UTF8 const & in_utf8) const
6807  {
6808  return !(*this == in_utf8);
6809  }
6810 
6814  bool operator== (char const * in_utf8) const;
6815 
6819  bool operator!= (char const * in_utf8) const
6820  {
6821  return !(*this == in_utf8);
6822  }
6823 
6828  friend inline bool operator==(char const * in_left, UTF8 const & in_right)
6829  {
6830  return in_right == in_left;
6831  }
6832 
6837  friend inline bool operator!=(char const * in_left, UTF8 const & in_right)
6838  {
6839  return in_right != in_left;
6840  }
6841 
6846  friend inline bool operator==(wchar_t const * in_left, UTF8 const & in_right)
6847  {
6848  return in_right == UTF8(in_left);
6849  }
6850 
6855  friend bool operator!=(wchar_t const * in_left, UTF8 const & in_right)
6856  {
6857  return in_right != UTF8(in_left);
6858  }
6859 
6864  friend inline UTF8 operator+ (char const * in_left, UTF8 const & in_right)
6865  {
6866  return UTF8(in_left) + in_right;
6867  }
6868 
6873  friend inline UTF8 operator+ (wchar_t const * in_left, UTF8 const & in_right)
6874  {
6875  return UTF8(in_left) + in_right;
6876  }
6877 
6878 
6881  size_t GetHash() const;
6882 
6883 private:
6884 
6885  size_t internal_encode(wchar_t const * in_wide_string);
6886  size_t internal_decode(wchar_t * out_wide_string) const;
6887 
6888  char * _text;
6889  size_t _length;
6890  mutable size_t _hash_key;
6891  static const size_t _buffer_size = 64 - sizeof(const char *) - 2 * sizeof(size_t);
6892  char _buffer[_buffer_size];
6893 };
6894 
6896 struct UTF8Hasher {
6897  inline size_t operator()(const UTF8 & in_utf8) const
6898  {
6899  return in_utf8.GetHash();
6900  }
6901 };
6902 
6905 class HPS_API Condition : public Object
6906 {
6907 public:
6908 
6910  Condition();
6911 
6914  Condition(char const * in_utf8);
6915 
6918  Condition(Condition const & in_that);
6919 
6923  Condition(Condition && in_that);
6924 
6928  Condition & operator=(Condition && in_that);
6929 
6930  Type ObjectType() const { return Type::Condition; }
6931 
6936  bool ShowCondition(UTF8 & out_condition) const;
6937 
6942  bool ShowOperands(ConditionArray & out_operands) const;
6943 
6947  Condition & operator=(Condition const & in_that);
6948 
6952  bool Equals(Condition const & in_that) const;
6953 
6957  bool operator==(Condition const & in_that) const;
6958 
6962  bool operator!=(Condition const & in_that) const;
6963 
6967  Condition OR(Condition const & in_operand2) const;
6968 
6972  Condition XOR(Condition const & in_operand2) const;
6973 
6977  Condition AND(Condition const & in_operand2) const;
6978 
6979 
6982  Condition operator !() const;
6983 
6987  Condition operator ||(Condition const & in_operand2) const;
6988 
6992  Condition operator ^(Condition const & in_operand2) const;
6993 
6997  Condition operator &&(Condition const & in_operand2) const;
6998 
6999 
7003  static Condition NOT(Condition const & in_operand);
7004 
7009  static Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7010 
7011 
7016  static Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7017 
7022  static Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7023 
7024  friend HPS_API Condition NOT(Condition const & in_operand);
7025  friend HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7026  friend HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7027  friend HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7028 };
7029 
7030 
7034 HPS_API Condition NOT(Condition const & in_operand);
7035 
7040 HPS_API Condition OR(Condition const & in_operand1, Condition const & in_operand2);
7041 
7046 HPS_API Condition XOR(Condition const & in_operand1, Condition const & in_operand2);
7047 
7052 HPS_API Condition AND(Condition const & in_operand1, Condition const & in_operand2);
7053 
7054 
7055 
7056 
7061 class HPS_API Key : public Object
7062 {
7063 public:
7064 
7066  Key();
7067 
7069  Key(Key const & in_that);
7070 
7072  explicit Key(Control const & in_control);
7073 
7077  Key(Key && in_that);
7078 
7082  Key & operator=(Key && in_that);
7083 
7085  virtual ~Key();
7086 
7087  Type ObjectType() const {return Type::Key;};
7088 
7090  bool HasOwner() const;
7091 
7093  SegmentKey Up() const;
7094 
7096  SegmentKey Owner() const;
7097 
7099  void Delete();
7100 
7102  void MoveTo(SegmentKey const & in_new_owner);
7103 
7106  Key CopyTo(SegmentKey const & in_destination) const;
7107 
7109  Key & operator=(Key const & in_that);
7110 
7112  virtual void Assign(Key const & in_that);
7113 
7115  bool Equals(Key const & in_that) const;
7116 
7118  bool operator!= (Key const & in_that) const;
7119 
7121  bool operator== (Key const & in_that) const;
7122 
7125  size_t GetHash() const;
7126 };
7127 
7129 struct KeyHasher {
7130  inline size_t operator()(const Key & in_key) const
7131  {
7132  return in_key.GetHash();
7133  }
7134 };
7135 
7136 
7139 class HPS_API SegmentKey : public Key
7140 {
7141 public:
7143  SegmentKey();
7144 
7146  SegmentKey(SegmentKey const & in_that);
7147 
7149  SegmentKey & operator=(SegmentKey const & other);
7150 
7154  SegmentKey(SegmentKey && in_that);
7155 
7159  SegmentKey & operator=(SegmentKey && in_that);
7160 
7162  explicit SegmentKey(Key const & in_that);
7163 
7165  ~SegmentKey();
7166 
7167  Type ObjectType() const {return Type::SegmentKey;};
7168 
7170  UTF8 Name() const;
7171 
7174  SegmentKey & SetName(char const * in_name);
7175 
7178  SegmentKey Down(char const * in_segment_name, bool in_create_if_not_present = false) const;
7179 
7182  SegmentKey Subsegment(char const * in_segment_name = "", bool in_create_if_not_present = true) const;
7183 
7185  void Flush(Search::Type in_type_to_remove = Search::Type::Everything, Search::Space in_search_space = Search::Space::SegmentOnly);
7186 
7188  void Flush(SearchTypeArray const & in_types_to_remove, Search::Space in_search_space = Search::Space::SegmentOnly);
7189 
7191  void Flush(size_t in_types_count, Search::Type const in_types_to_remove [], Search::Space in_search_space = Search::Space::SegmentOnly);
7192 
7193 
7194 
7196  size_t Find(Search::Type in_request, Search::Space in_search_space, SearchResults & out_results) const;
7197 
7199  size_t Find(SearchTypeArray const & in_requests, Search::Space in_search_space, SearchResults & out_results) const;
7200 
7202  size_t Find(size_t in_types_count, Search::Type const in_requests [], Search::Space in_search_space, SearchResults & out_results) const;
7203 
7204 
7206  size_t Find(SearchOptionsKit const & in_options, SearchResults & out_results) const;
7207 
7209  size_t Find(SearchOptionsKit const & in_options) const;
7210 
7211 
7214  IncludeKey IncludeSegment(SegmentKey const & in_seg);
7215 
7219  IncludeKey IncludeSegment(SegmentKey const & in_seg, Condition const & in_condition);
7220 
7221 
7227  ReferenceKey ReferenceGeometry(Key const & in_key);
7228 
7236  ReferenceKey ReferenceGeometry(Key const & in_key, Condition const & in_condition);
7237 
7238 
7240  size_t ShowSubsegments() const;
7241 
7243  size_t ShowSubsegments(SegmentKeyArray & out_children) const;
7244 
7248  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
7249 
7253  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
7254 
7258  size_t ShowStylers(SegmentKeyArray & out_segments) const;
7259 
7263  size_t ShowStylers(StyleKeyArray & out_styles) const;
7264 
7268  size_t ShowIncluders(SegmentKeyArray & out_segments) const;
7269 
7273  size_t ShowIncluders(IncludeKeyArray & out_includes) const;
7274 
7275 
7276 
7278  StyleControl GetStyleControl();
7279 
7281  StyleControl const GetStyleControl() const;
7282 
7283 
7285  PortfolioControl GetPortfolioControl();
7286 
7288  PortfolioControl const GetPortfolioControl() const;
7289 
7290 
7292  SegmentKey & SetCondition(char const * in_condition);
7293 
7295  SegmentKey & SetConditions(UTF8Array const & in_conditions);
7296 
7298  SegmentKey & SetConditions(size_t in_count, UTF8 const in_conditions []);
7299 
7301  SegmentKey & UnsetConditions();
7302 
7304  bool ShowConditions(UTF8Array & out_conditions) const;
7305 
7307  ConditionControl GetConditionControl();
7308 
7310  ConditionControl const GetConditionControl() const;
7311 
7312 
7314  SegmentKey & SetMaterialPalette(char const * in_name);
7315 
7317  SegmentKey & UnsetMaterialPalette();
7318 
7320  bool ShowMaterialPalette(UTF8 & out_name) const;
7321 
7322 
7329  SegmentKey & SetPriority(int in_priority);
7330 
7333  SegmentKey & UnsetPriority();
7334 
7338  bool ShowPriority(int & out_priority) const;
7339 
7340 
7346  SegmentKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
7347 
7352  SegmentKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
7353 
7357  SegmentKey & UnsetUserData(intptr_t in_index);
7358 
7363  SegmentKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
7364 
7368  SegmentKey & UnsetUserData(IntPtrTArray const & in_indices);
7369 
7372  SegmentKey & UnsetAllUserData();
7373 
7375  size_t ShowUserDataCount() const;
7376 
7380  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
7381 
7386  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
7387 
7388 
7390  LineKey InsertLine(LineKit const & in_kit);
7391 
7393  LineKey InsertLine(size_t in_count, Point const in_pts[]);
7394 
7396  LineKey InsertLine(PointArray const & in_pts);
7397 
7399  LineKey InsertLine(Point const & pt1, Point const & pt2);
7400 
7401 
7403  CylinderKey InsertCylinder(CylinderKit const & in_kit);
7404 
7406  CylinderKey InsertCylinder(size_t in_pcount, Point const in_points[], size_t in_rcount, float const in_radii [], Cylinder::Capping in_caps = Cylinder::Capping::Both);
7407 
7409  CylinderKey InsertCylinder(PointArray const & in_points, FloatArray const & in_radii, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7410 
7412  CylinderKey InsertCylinder(Point const & in_point1, Point const & in_point2, float in_radius, Cylinder::Capping in_caps = Cylinder::Capping::Both);
7413 
7414 
7419  SphereKey InsertSphere(SphereKit const & in_kit);
7420 
7428  SphereKey InsertSphere(Point const & in_center, float in_radius, Vector const & in_axis = Vector(0, 1, 0), Vector const & in_prime_meridian = Vector(1, 0, 0));
7429 
7431  CircleKey InsertCircle(CircleKit const & in_kit);
7432 
7434  CircleKey InsertCircle(Point const & in_start, Point const & in_middle, Point const & in_end);
7435 
7437  CircleKey InsertCircle(Point const & in_center, float in_radius, Vector const & in_normal);
7438 
7439 
7441  CircularArcKey InsertCircularArc(CircularArcKit const & in_kit);
7442 
7444  CircularArcKey InsertCircularArc(Point const & in_start, Point const & in_middle, Point const & in_end);
7445 
7446 
7448  CircularWedgeKey InsertCircularWedge(CircularWedgeKit const & in_kit);
7449 
7451  CircularWedgeKey InsertCircularWedge(Point const & in_start, Point const & in_middle, Point const & in_end);
7452 
7453 
7455  EllipseKey InsertEllipse(EllipseKit const & in_kit);
7456 
7458  EllipseKey InsertEllipse(Point const & in_center, Point const & in_major, Point const & in_minor);
7459 
7460 
7462  EllipticalArcKey InsertEllipticalArc(EllipticalArcKit const & in_kit);
7463 
7465  EllipticalArcKey InsertEllipticalArc(Point const & in_center, Point const & in_major, Point const & in_minor, float start, float end);
7466 
7467 
7469  PolygonKey InsertPolygon(PolygonKit const & in_kit);
7470 
7472  PolygonKey InsertPolygon(PointArray const & in_pts);
7473 
7475  PolygonKey InsertPolygon(size_t in_count, Point const in_points []);
7476 
7477 
7479  ShellKey InsertShell(ShellKit const & in_kit);
7480 
7482  ShellKey InsertShell(PointArray const & in_points, IntArray const & in_facelist);
7483 
7485  ShellKey InsertShell(size_t in_point_count, Point const in_points [], size_t in_facelist_count, int const in_facelist []);
7486 
7487 
7489  MeshKey InsertMesh(MeshKit const & in_kit);
7490 
7492  MeshKey InsertMesh(size_t in_rows, size_t in_columns, PointArray const & in_points);
7493 
7495  MeshKey InsertMesh(size_t in_rows, size_t in_columns, size_t in_point_count, Point const in_points []);
7496 
7497 
7499  MarkerKey InsertMarker(Point const & in_position);
7500 
7502  MarkerKey InsertMarker(MarkerKit const & in_kit);
7503 
7504 
7506  DistantLightKey InsertDistantLight(Vector const & in_direction);
7507 
7509  DistantLightKey InsertDistantLight(DistantLightKit const & in_kit);
7510 
7511 
7513  CuttingSectionKey InsertCuttingSection(Plane const & in_plane);
7514 
7516  CuttingSectionKey InsertCuttingSection(CuttingSectionKit const & in_kit);
7517 
7519  CuttingSectionKey InsertCuttingSection(PlaneArray const & in_planes);
7520 
7522  CuttingSectionKey InsertCuttingSection(size_t in_planes_count, Plane const in_planes []);
7523 
7524 
7526  InfiniteLineKey InsertInfiniteLine(InfiniteLineKit const & in_kit);
7527 
7529  InfiniteLineKey InsertInfiniteLine(Point const & in_first, Point const & in_second, InfiniteLine::Type in_type);
7530 
7531 
7533  SpotlightKey InsertSpotlight(Point const & in_position, Point const & in_target);
7534 
7536  SpotlightKey InsertSpotlight(SpotlightKit const & in_kit);
7537 
7538 
7540  NURBSCurveKey InsertNURBSCurve(NURBSCurveKit const & in_kit);
7541 
7543  NURBSCurveKey InsertNURBSCurve(size_t in_degree, PointArray const & in_points, FloatArray const & in_weights, FloatArray const & in_knots, float in_start_u, float in_end_u);
7544 
7546  NURBSCurveKey InsertNURBSCurve(size_t in_degree, size_t in_pcount, Point const in_points [], float const in_weights[], size_t in_knot_count, float const in_knots[], float in_start_u, float in_end_u);
7547 
7548 
7550  NURBSSurfaceKey InsertNURBSSurface(NURBSSurfaceKit const & in_kit);
7551 
7553  NURBSSurfaceKey InsertNURBSSurface(size_t in_udegree, size_t in_vdegree, size_t in_ucount, size_t in_vcount, PointArray const & in_points, FloatArray const & in_weights, FloatArray const & in_uknots, FloatArray const & in_vknots);
7554 
7556  NURBSSurfaceKey InsertNURBSSurface(size_t in_udegree, size_t in_vdegree, size_t in_ucount, size_t in_vcount, size_t in_point_count, Point const in_points[], float const in_weights[], size_t in_uknot_count, float const in_uknots[], size_t in_vknot_count, float const in_vknots[]);
7557 
7559  NURBSSurfaceKey InsertNURBSSurface(size_t in_udegree, size_t in_vdegree, size_t in_ucount, size_t in_vcount, PointArray const & in_points, FloatArray const & in_weights, FloatArray const & in_uknots, FloatArray const & in_vknots, TrimKitArray const & in_trims);
7560 
7562  NURBSSurfaceKey InsertNURBSSurface(size_t in_udegree, size_t in_vdegree, size_t in_ucount, size_t in_vcount, size_t in_point_count, Point const in_points[], float const in_weights[], size_t in_uknot_count, float const in_uknots[], size_t in_vknot_count, float const in_vknots[], size_t in_trim_count, TrimKit const in_trims[]);
7563 
7564 
7566  TextKey InsertText(TextKit const & in_kit);
7567 
7573  TextKey InsertText(Point const & in_position, char const * in_text);
7574 
7575 
7576 
7578  GridKey InsertGrid(GridKit const & in_kit);
7579 
7581  GridKey InsertGrid(Point const & in_origin, Point const & in_first_point = Point(1, 0, 0), Point const & in_second_point = Point(0, 1, 0), int in_first_count = 0, int in_second_count = 0, Grid::Type in_type = Grid::Type::Quadrilateral);
7582 
7583 
7584 
7592  LineKey InsertLineFromGeometry(CircleKey const & in_circle, float in_deviation = -1.0f);
7593 
7601  LineKey InsertLineFromGeometry(CircularArcKey const & in_circular_arc, float in_deviation = -1.0f);
7602 
7610  LineKey InsertLineFromGeometry(CircularWedgeKey const & in_circular_wedge, float in_deviation = -1.0f);
7611 
7619  LineKey InsertLineFromGeometry(EllipseKey const & in_ellipse, float in_deviation = -1.0f);
7620 
7628  LineKey InsertLineFromGeometry(EllipticalArcKey const & in_elliptical_arc, float in_deviation = -1.0f);
7629 
7637  LineKey InsertLineFromGeometry(NURBSCurveKey const & in_nurbs_curve, float in_deviation = -1.0f);
7638 
7643  ShellKey InsertShellFromGeometry(SphereKey const & in_sphere);
7644 
7649  ShellKey InsertShellFromGeometry(CylinderKey const & in_cylinder);
7650 
7655  ShellKey InsertShellFromGeometry(NURBSSurfaceKey const & in_nurbs_surface);
7656 
7661  ShellKey InsertShellFromGeometry(MeshKey const & in_mesh);
7662 
7667  ShellKey InsertShellFromGeometry(PolygonKey const & in_polygon);
7668 
7673  ShellKey InsertShellFromGeometry(TextKey const & in_text);
7674 
7675 
7677  SegmentKey & SetAttributeLocks(AttributeLockKit const & in_kit);
7678 
7680  SegmentKey & UnsetAttributeLocks();
7681 
7685  bool ShowAttributeLocks(AttributeLockKit & out_kit) const;
7686 
7688  AttributeLockControl GetAttributeLockControl();
7689 
7691  AttributeLockControl const GetAttributeLockControl() const;
7692 
7693 
7695  SegmentKey & SetBoundings(BoundingKit const & in_kit);
7696 
7698  SegmentKey & UnsetBoundings();
7699 
7703  bool ShowBoundings(BoundingKit & out_kit) const;
7704 
7706  BoundingControl GetBoundingControl();
7707 
7709  BoundingControl const GetBoundingControl() const;
7710 
7711 
7713  SegmentKey & SetCamera(CameraKit const & in_kit);
7714 
7716  SegmentKey & UnsetCamera();
7717 
7719  bool ShowCamera(CameraKit & out_kit) const;
7720 
7722  CameraControl GetCameraControl();
7723 
7725  CameraControl const GetCameraControl() const;
7726 
7728  SegmentKey & SetColorInterpolation(ColorInterpolationKit const & in_kit);
7729 
7731  SegmentKey & UnsetColorInterpolation();
7732 
7734  bool ShowColorInterpolation(ColorInterpolationKit & out_kit) const;
7735 
7737  ColorInterpolationControl GetColorInterpolationControl();
7738 
7740  ColorInterpolationControl const GetColorInterpolationControl() const;
7741 
7742 
7744  SegmentKey & SetContourLine(ContourLineKit const & in_kit);
7745 
7747  SegmentKey & UnsetContourLine();
7748 
7750  bool ShowContourLine(ContourLineKit & out_kit) const;
7751 
7753  ContourLineControl GetContourLineControl();
7754 
7756  ContourLineControl const GetContourLineControl() const;
7757 
7758 
7760  SegmentKey & SetCulling(CullingKit const & in_kit);
7761 
7763  SegmentKey & UnsetCulling();
7764 
7768  bool ShowCulling(CullingKit & out_kit) const;
7769 
7771  CullingControl GetCullingControl();
7772 
7774  CullingControl const GetCullingControl() const;
7775 
7776 
7778  SegmentKey & SetCurveAttributes(CurveAttributeKit const & in_kit);
7779 
7781  SegmentKey & UnsetCurveAttributes();
7782 
7784  bool ShowCurveAttributes(CurveAttributeKit & out_kit) const;
7785 
7787  CurveAttributeControl GetCurveAttributeControl();
7788 
7790  CurveAttributeControl const GetCurveAttributeControl() const;
7791 
7792 
7794  SegmentKey & SetCuttingSectionAttributes(CuttingSectionAttributeKit const & in_kit);
7795 
7797  SegmentKey & UnsetCuttingSectionAttributes();
7798 
7800  bool ShowCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
7801 
7803  CuttingSectionAttributeControl GetCuttingSectionAttributeControl();
7804 
7806  CuttingSectionAttributeControl const GetCuttingSectionAttributeControl() const;
7807 
7808 
7810  SegmentKey & SetCylinderAttributes(CylinderAttributeKit const & in_kit);
7811 
7813  SegmentKey & UnsetCylinderAttributes();
7814 
7816  bool ShowCylinderAttributes(CylinderAttributeKit & out_kit) const;
7817 
7819  CylinderAttributeControl GetCylinderAttributeControl();
7820 
7822  CylinderAttributeControl const GetCylinderAttributeControl() const;
7823 
7824 
7826  SegmentKey & SetDrawingAttribute(DrawingAttributeKit const & in_kit);
7827 
7829  SegmentKey & UnsetDrawingAttribute();
7830 
7832  bool ShowDrawingAttribute(DrawingAttributeKit & out_kit) const;
7833 
7835  DrawingAttributeControl GetDrawingAttributeControl();
7836 
7838  DrawingAttributeControl const GetDrawingAttributeControl() const;
7839 
7840 
7842  SegmentKey & SetEdgeAttributes(EdgeAttributeKit const & in_kit);
7843 
7845  SegmentKey & UnsetEdgeAttributes();
7846 
7848  bool ShowEdgeAttributes(EdgeAttributeKit & out_kit) const;
7849 
7851  EdgeAttributeControl GetEdgeAttributeControl();
7852 
7854  EdgeAttributeControl const GetEdgeAttributeControl() const;
7855 
7856 
7858  SegmentKey & SetHiddenLineAttribute(HiddenLineAttributeKit const & in_kit);
7859 
7861  SegmentKey & UnsetHiddenLineAttribute();
7862 
7864  bool ShowHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
7865 
7867  HiddenLineAttributeControl GetHiddenLineAttributeControl();
7868 
7870  HiddenLineAttributeControl const GetHiddenLineAttributeControl() const;
7871 
7872 
7874  SegmentKey & SetLightingAttributes(LightingAttributeKit const & in_kit);
7875 
7877  SegmentKey & UnsetLightingAttributes();
7878 
7880  bool ShowLightingAttributes(LightingAttributeKit & out_kit) const;
7881 
7883  LightingAttributeControl GetLightingAttributeControl();
7884 
7886  LightingAttributeControl const GetLightingAttributeControl() const;
7887 
7888 
7890  SegmentKey & SetLineAttributes(LineAttributeKit const & in_kit);
7891 
7893  SegmentKey & UnsetLineAttributes();
7894 
7896  bool ShowLineAttributes(LineAttributeKit & out_kit) const;
7897 
7899  LineAttributeControl GetLineAttributeControl();
7900 
7902  LineAttributeControl const GetLineAttributeControl() const;
7903 
7904 
7906  SegmentKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
7907 
7909  SegmentKey & UnsetMaterialMapping();
7910 
7912  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
7913 
7915  MaterialMappingControl GetMaterialMappingControl();
7916 
7918  MaterialMappingControl const GetMaterialMappingControl() const;
7919 
7920 
7922  SegmentKey & SetMarkerAttributes(MarkerAttributeKit const & in_kit);
7923 
7925  SegmentKey & UnsetMarkerAttributes();
7926 
7928  bool ShowMarkerAttributes(MarkerAttributeKit & out_kit) const;
7929 
7931  MarkerAttributeControl GetMarkerAttributeControl();
7932 
7934  MarkerAttributeControl const GetMarkerAttributeControl() const;
7935 
7936 
7938  SegmentKey & SetModellingMatrix(MatrixKit const & in_kit);
7939 
7941  SegmentKey & UnsetModellingMatrix();
7942 
7944  bool ShowModellingMatrix(MatrixKit & out_kit) const;
7945 
7947  ModellingMatrixControl GetModellingMatrixControl();
7948 
7950  ModellingMatrixControl const GetModellingMatrixControl() const;
7951 
7952 
7954  SegmentKey & SetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit const & in_kit);
7955 
7957  SegmentKey & UnsetNURBSSurfaceAttributes();
7958 
7960  bool ShowNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
7961 
7963  NURBSSurfaceAttributeControl GetNURBSSurfaceAttributeControl();
7964 
7966  NURBSSurfaceAttributeControl const GetNURBSSurfaceAttributeControl() const;
7967 
7968 
7970  SegmentKey & SetPerformance(PerformanceKit const & in_kit);
7971 
7973  SegmentKey & UnsetPerformance();
7974 
7976  bool ShowPerformance(PerformanceKit & out_kit) const;
7977 
7979  PerformanceControl GetPerformanceControl();
7980 
7982  PerformanceControl const GetPerformanceControl() const;
7983 
7984 
7986  SegmentKey & SetSelectability(SelectabilityKit const & in_kit);
7987 
7989  SegmentKey & UnsetSelectability();
7990 
7994  bool ShowSelectability(SelectabilityKit & out_kit) const;
7995 
7997  SelectabilityControl GetSelectabilityControl();
7998 
8000  SelectabilityControl const GetSelectabilityControl() const;
8001 
8002 
8004  SegmentKey & SetSphereAttributes(SphereAttributeKit const & in_kit);
8005 
8007  SegmentKey & UnsetSphereAttributes();
8008 
8012  bool ShowSphereAttributes(SphereAttributeKit & out_kit) const;
8013 
8015  SphereAttributeControl GetSphereAttributeControl();
8016 
8018  SphereAttributeControl const GetSphereAttributeControl() const;
8019 
8020 
8022  SegmentKey & SetSubwindow(SubwindowKit const & in_kit);
8023 
8025  SegmentKey & UnsetSubwindow();
8026 
8030  bool ShowSubwindow(SubwindowKit & out_kit) const;
8031 
8033  SubwindowControl GetSubwindowControl();
8034 
8036  SubwindowControl const GetSubwindowControl() const;
8037 
8038 
8040  SegmentKey & SetTextAttributes(TextAttributeKit const & in_kit);
8041 
8043  SegmentKey & UnsetTextAttributes();
8044 
8046  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
8047 
8049  TextAttributeControl GetTextAttributeControl();
8050 
8052  TextAttributeControl const GetTextAttributeControl() const;
8053 
8054 
8056  SegmentKey & SetTextureMatrix(MatrixKit const & in_kit);
8057 
8059  SegmentKey & UnsetTextureMatrix();
8060 
8064  bool ShowTextureMatrix(MatrixKit & out_kit) const;
8065 
8067  TextureMatrixControl GetTextureMatrixControl();
8068 
8070  TextureMatrixControl const GetTextureMatrixControl() const;
8071 
8073  SegmentKey & SetTransformMask(TransformMaskKit const & in_kit);
8074 
8076  SegmentKey & UnsetTransformMask();
8077 
8081  bool ShowTransformMask(TransformMaskKit & out_kit) const;
8082 
8084  TransformMaskControl GetTransformMaskControl();
8085 
8087  TransformMaskControl const GetTransformMaskControl() const;
8088 
8089 
8091  SegmentKey & SetTransparency(TransparencyKit const & in_kit);
8092 
8094  SegmentKey & UnsetTransparency();
8095 
8099  bool ShowTransparency(TransparencyKit & out_kit) const;
8100 
8102  TransparencyControl GetTransparencyControl();
8103 
8105  TransparencyControl const GetTransparencyControl() const;
8106 
8107 
8109  SegmentKey & SetVisibility(VisibilityKit const & in_kit);
8110 
8112  SegmentKey & UnsetVisibility();
8113 
8117  bool ShowVisibility(VisibilityKit & out_kit) const;
8118 
8120  VisibilityControl GetVisibilityControl();
8121 
8123  VisibilityControl const GetVisibilityControl() const;
8124 
8125 
8127  SegmentKey & SetVisualEffects(VisualEffectsKit const & in_kit);
8128 
8130  SegmentKey & UnsetVisualEffects();
8131 
8135  bool ShowVisualEffects(VisualEffectsKit & out_kit) const;
8136 
8138  VisualEffectsControl GetVisualEffectsControl();
8139 
8141  VisualEffectsControl const GetVisualEffectsControl() const;
8142 
8143 };
8144 
8145 
8147 class HPS_API Coordinate
8148 {
8149 public:
8150 
8154  enum class Space
8155  {
8156  Object,
8157  World,
8158  Camera,
8159  Normalized,
8160  ScreenRange,
8161  InnerWindow,
8162  InnerPixel,
8163  Window,
8164  Pixel,
8165  };
8166 
8167 private:
8168  Coordinate();
8169 };
8170 
8171 
8172 
8173 
8176 class HPS_API UpdateNotifier : public Object
8177 {
8178 public:
8179 
8180  UpdateNotifier();
8181 
8182  UpdateNotifier(UpdateNotifier const & in_that);
8183 
8187  UpdateNotifier(UpdateNotifier && in_that);
8188 
8192  UpdateNotifier & operator=(UpdateNotifier && in_that);
8193 
8194  virtual ~UpdateNotifier();
8195 
8196  Type ObjectType() const {return Type::UpdateNotifier;};
8197 
8199  UpdateNotifier & operator=(UpdateNotifier const & in_that);
8200 
8202  void Assign(UpdateNotifier const & in_that);
8203 
8204  void Wait() const;
8205 
8206  Window::UpdateStatus Status() const;
8207 
8208 };
8209 
8210 
8214 class HPS_API WindowKey : public SegmentKey
8215 {
8216 public:
8217 
8219  WindowKey();
8220 
8222  WindowKey(WindowKey const & in_window);
8223 
8225  WindowKey & operator=(WindowKey const & other);
8226 
8230  WindowKey(WindowKey && in_that);
8231 
8235  WindowKey & operator=(WindowKey && in_that);
8236 
8238  WindowKey(Key const & in_key);
8239 
8241  ~WindowKey();
8242 
8243  Type ObjectType() const {return Type::WindowKey;};
8244 
8246  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
8247 
8249  size_t FindFonts(FontSearchResults & out_results) const;
8250 
8252  WindowKey & SetPostProcessEffects(PostProcessEffectsKit const & in_kit);
8253 
8255  bool ShowPostProcessEffects(PostProcessEffectsKit & out_kit) const;
8256 
8258  PostProcessEffectsControl GetPostProcessEffectsControl();
8259 
8261  PostProcessEffectsControl const GetPostProcessEffectsControl() const;
8262 
8263 
8265  WindowKey & SetDebugging(DebuggingKit const & in_kit);
8266 
8270  bool ShowDebugging(DebuggingKit & out_kit) const;
8271 
8273  DebuggingControl GetDebuggingControl();
8274 
8276  DebuggingControl const GetDebuggingControl() const;
8277 
8279  WindowInfoControl const GetWindowInfoControl() const;
8280 
8281  bool ShowWindowInfo(WindowInfoKit & out_kit) const;
8282 
8284  WindowKey & SetSelectionOptions(SelectionOptionsKit const & in_kit);
8285 
8287  bool ShowSelectionOptions(SelectionOptionsKit & out_kit) const;
8288 
8290  WindowKey & SetUpdateOptions(UpdateOptionsKit const & in_kit);
8291 
8293  bool ShowUpdateOptions(UpdateOptionsKit & out_kit) const;
8294 
8295 
8297  SelectionOptionsControl GetSelectionOptionsControl();
8298 
8300  SelectionOptionsControl const GetSelectionOptionsControl() const;
8301 
8302 
8304  SelectionControl GetSelectionControl();
8305 
8307  SelectionControl const GetSelectionControl() const;
8308 
8310  HighlightControl GetHighlightControl();
8311 
8313  HighlightControl const GetHighlightControl() const;
8314 
8316  UpdateOptionsControl GetUpdateOptionsControl();
8317 
8319  UpdateOptionsControl const GetUpdateOptionsControl() const;
8320 
8322  void Update();
8323 
8328  void Update(UpdateOptionsKit const & in_kit);
8329 
8344  void Update(Window::UpdateControl in_control, Time in_time_limit=-1);
8345 
8349  UpdateNotifier UpdateWithNotifier();
8350 
8354  UpdateNotifier UpdateWithNotifier(UpdateOptionsKit const & in_kit);
8355 
8361  UpdateNotifier UpdateWithNotifier(Window::UpdateControl in_control, Time in_time_limit=-1);
8362 
8364  EventDispatcher & GetEventDispatcher();
8365 
8367  EventDispatcher const & GetEventDispatcher() const;
8368 
8372  bool ShowSnapshot(ImageKit & out_kit) const;
8373 
8374 private:
8375 
8377  SegmentKey & UnsetAttributeLocks();
8378  SegmentKey & UnsetCamera();
8379  SegmentKey & UnsetColorInterpolation();
8380  SegmentKey & UnsetContourLine();
8381  SegmentKey & UnsetCulling();
8382  SegmentKey & UnsetCurveAttributes();
8383  SegmentKey & UnsetCuttingSectionAttributes();
8384  SegmentKey & UnsetCylinderAttributes();
8385  SegmentKey & UnsetDrawingAttribute();
8386  SegmentKey & UnsetEdgeAttributes();
8387  SegmentKey & UnsetHiddenLineAttribute();
8388  SegmentKey & UnsetLightingAttributes();
8389  SegmentKey & UnsetLineAttributes();
8390  SegmentKey & UnsetMaterialMapping();
8391  SegmentKey & UnsetMarkerAttributes();
8392  SegmentKey & UnsetModellingMatrix();
8393  SegmentKey & UnsetNURBSSurfaceAttributes();
8394  SegmentKey & UnsetPerformance();
8395  SegmentKey & UnsetSelectability();
8396  SegmentKey & UnsetSphereAttributes();
8397  SegmentKey & UnsetSubwindow();
8398  SegmentKey & UnsetTextAttributes();
8399  SegmentKey & UnsetTextureMatrix();
8400  SegmentKey & UnsetTransformMask();
8401  SegmentKey & UnsetTransparency();
8402  SegmentKey & UnsetVisibility();
8403  SegmentKey & UnsetVisualEffects();
8404 
8406  void MoveTo(SegmentKey const & in_new_owner);
8407 
8409  Key CopyTo(SegmentKey const & in_destination) const;
8410 };
8411 
8412 
8413 
8416 class HPS_API KeyPath : public Object
8417 {
8418 public:
8419 
8421  KeyPath();
8422 
8425  KeyPath(KeyArray const & in_path);
8426 
8430  KeyPath(size_t in_path_count, Key const in_path []);
8431 
8433  KeyPath(KeyPath const & in_that);
8434 
8438  KeyPath(KeyPath && in_that);
8439 
8443  KeyPath & operator=(KeyPath && in_that);
8444 
8446  virtual ~KeyPath();
8447 
8448  Type ObjectType() const { return Type::KeyPath; }
8449 
8453  KeyPath & operator+=(Key const & in_key);
8454 
8458  KeyPath & operator+=(KeyPath const & in_key_path);
8459 
8463  KeyPath & operator+=(KeyArray const & in_key_array);
8464 
8468  KeyPath & Append(Key const & in_key);
8469 
8473  KeyPath & Append(KeyPath const & in_key_path);
8474 
8478  KeyPath & Append(KeyArray const & in_key_array);
8479 
8483  KeyPath & operator=(KeyPath const & in_that);
8484 
8488  KeyPath & operator=(KeyArray const & in_path);
8489 
8492  void Set(KeyPath const & in_that);
8493 
8497  bool Equals(KeyPath const & in_that) const;
8498 
8502  bool operator!= (KeyPath const & in_that) const;
8503 
8507  bool operator== (KeyPath const & in_that) const;
8508 
8509 
8513  KeyPath & SetKeys(KeyArray const & in_keys);
8514 
8519  KeyPath & SetKeys(size_t in_key_count, Key const in_keys []);
8520 
8521 
8524  KeyPath & UnsetKeys();
8525 
8526 
8529  bool ShowKeys(KeyArray & out_keys) const;
8530 
8531 
8538  bool ConvertCoordinate(Coordinate::Space in_space, Point const & in_point, Coordinate::Space in_output_space, Point & out_point) const;
8539 
8546  bool ConvertCoordinate(Coordinate::Space in_space, PointArray const & in_points, Coordinate::Space in_output_space, PointArray & out_points) const;
8547 
8553  bool ComputeTextExtent(const char* in_text, float & out_xfrac, float & out_yfrac) const;
8554 
8555 
8561  bool ComputeTransform(Coordinate::Space in_space, Coordinate::Space in_output_space, MatrixKit & out_matrix) const;
8562 
8563 
8566  bool ShowNetVisibility(VisibilityKit & out_kit) const;
8567 
8570  bool ShowNetBounding(BoundingKit & out_kit) const;
8571 
8574  bool ShowNetCamera(CameraKit & out_kit) const;
8575 
8578  bool ShowNetColorInterpolation(ColorInterpolationKit & out_kit) const;
8579 
8582  bool ShowNetContourLine(ContourLineKit & out_kit) const;
8583 
8586  bool ShowNetPerformance(PerformanceKit & out_kit) const;
8587 
8590  bool ShowNetHiddenLineAttribute(HiddenLineAttributeKit & out_kit) const;
8591 
8594  bool ShowNetDrawingAttribute(DrawingAttributeKit & out_kit) const;
8595 
8598  bool ShowNetSelectability(SelectabilityKit & out_kit) const;
8599 
8602  bool ShowNetMarkerAttributes(MarkerAttributeKit & out_kit) const;
8603 
8606  bool ShowNetSphereAttributes(SphereAttributeKit & out_kit) const;
8607 
8610  bool ShowNetLightingAttributes(LightingAttributeKit & out_kit) const;
8611 
8614  bool ShowNetCylinderAttributes(CylinderAttributeKit & out_kit) const;
8615 
8618  bool ShowNetCuttingSectionAttributes(CuttingSectionAttributeKit & out_kit) const;
8619 
8622  bool ShowNetTextAttributes(TextAttributeKit & out_kit) const;
8623 
8626  bool ShowNetLineAttributes(LineAttributeKit & out_kit) const;
8627 
8630  bool ShowNetEdgeAttributes(EdgeAttributeKit & out_kit) const;
8631 
8634  bool ShowNetCurveAttributes(CurveAttributeKit & out_kit) const;
8635 
8638  bool ShowNetModellingMatrix(MatrixKit & out_kit) const;
8639 
8642  bool ShowNetTextureMatrix(MatrixKit & out_kit) const;
8643 
8646  bool ShowNetCulling(CullingKit & out_kit) const;
8647 
8650  bool ShowNetTransparency(TransparencyKit & out_kit) const;
8651 
8654  bool ShowNetTransformMask(TransformMaskKit & out_kit) const;
8655 
8658  bool ShowNetMaterialMapping(MaterialMappingKit & out_kit) const;
8659 
8662  bool ShowNetNURBSSurfaceAttributes(NURBSSurfaceAttributeKit & out_kit) const;
8663 
8666  bool ShowNetVisualEffects(VisualEffectsKit & out_kit) const;
8667 
8670  bool ShowNetSubwindow(SubwindowKit & out_kit) const;
8671 
8674  bool ShowNetAttributeLocks(AttributeLockKit & out_kit) const;
8675 
8678  bool ShowNetConditions(UTF8Array & out_conditions) const;
8679 
8685  size_t GatherCutGeometry(SegmentKey const & in_destination, CutGeometryGatheringOptionsKit const & in_options) const;
8686 
8687 };
8688 
8689 
8694 inline KeyPath operator+(Key const & in_lhs, Key const & in_rhs)
8695 {
8696  return KeyPath().Append(in_lhs).Append(in_rhs);
8697 }
8698 
8703 inline KeyPath operator+(Key const & in_lhs, KeyArray const & in_rhs)
8704 {
8705  return KeyPath().Append(in_lhs).Append(in_rhs);
8706 }
8707 
8712 inline KeyPath operator+(Key const & in_lhs, KeyPath const & in_rhs)
8713 {
8714  return KeyPath().Append(in_lhs).Append(in_rhs);
8715 }
8716 
8721 inline KeyPath operator+(KeyArray const & in_lhs, Key const & in_rhs)
8722 {
8723  return KeyPath().Append(in_lhs).Append(in_rhs);
8724 }
8725 
8730 inline KeyPath operator+(KeyArray const & in_lhs, KeyArray const & in_rhs)
8731 {
8732  return KeyPath().Append(in_lhs).Append(in_rhs);
8733 }
8734 
8739 inline KeyPath operator+(KeyArray const & in_lhs, KeyPath const & in_rhs)
8740 {
8741  return KeyPath().Append(in_lhs).Append(in_rhs);
8742 }
8743 
8748 inline KeyPath operator+(KeyPath const & in_lhs, Key const & in_rhs)
8749 {
8750  return KeyPath().Append(in_lhs).Append(in_rhs);
8751 }
8752 
8757 inline KeyPath operator+(KeyPath const & in_lhs, KeyArray const & in_rhs)
8758 {
8759  return KeyPath().Append(in_lhs).Append(in_rhs);
8760 }
8761 
8766 inline KeyPath operator+(KeyPath const & in_lhs, KeyPath const & in_rhs)
8767 {
8768  return KeyPath().Append(in_lhs).Append(in_rhs);
8769 }
8770 
8771 
8775 
8777 class HPS_API BoundingKit : public Object
8778 {
8779 public:
8780 
8782  BoundingKit();
8783 
8786  BoundingKit(BoundingKit const & in_kit);
8787 
8791  BoundingKit(BoundingKit && in_that);
8792 
8796  BoundingKit & operator=(BoundingKit && in_that);
8797 
8799  virtual ~BoundingKit();
8800 
8801  Type ObjectType() const {return Type::BoundingKit;};
8802 
8806  static BoundingKit GetDefault();
8807 
8810  void Set(BoundingKit const & in_kit);
8811 
8814  void Show(BoundingKit & out_kit) const;
8815 
8819  BoundingKit & operator=(BoundingKit const & in_kit);
8820 
8823  bool Empty() const;
8824 
8828  bool Equals(BoundingKit const & in_kit) const;
8829 
8833  bool operator==(BoundingKit const & in_kit) const;
8834 
8838  bool operator!=(BoundingKit const & in_kit) const;
8839 
8840 
8844  BoundingKit & SetVolume(SimpleSphere const & in_sphere);
8845 
8849  BoundingKit & SetVolume(SimpleCuboid const & in_cuboid);
8850 
8854  BoundingKit & SetExclusion(bool in_exclude);
8855 
8856 
8859  BoundingKit & UnsetVolume();
8860 
8863  BoundingKit & UnsetExclusion();
8864 
8867  BoundingKit & UnsetEverything();
8868 
8869 
8874  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
8875 
8879  bool ShowExclusion(bool & out_exclusion) const;
8880 
8881 };
8882 
8883 
8886 class HPS_API BoundingControl : public Control
8887 {
8888 public:
8889 
8891  explicit BoundingControl(SegmentKey & in_seg);
8892 
8894  BoundingControl(BoundingControl const & in_that);
8895 
8899  BoundingControl(BoundingControl && in_that);
8900 
8904  BoundingControl & operator=(BoundingControl && in_that);
8905 
8907  ~BoundingControl();
8908 
8909  Type ObjectType() const {return Type::BoundingControl;};
8910 
8912  BoundingControl & operator=(BoundingControl const & in_that);
8913 
8918  BoundingControl & SetVolume(SimpleSphere const & in_sphere, SimpleCuboid const & in_cuboid);
8919 
8923  BoundingControl & SetVolume(SimpleSphere const & in_sphere);
8924 
8928  BoundingControl & SetVolume(SimpleCuboid const & in_cuboid);
8929 
8933  BoundingControl & SetExclusion(bool in_exclusion);
8934 
8935 
8938  BoundingControl & UnsetVolume();
8939 
8942  BoundingControl & UnsetExclusion();
8943 
8946  BoundingControl & UnsetEverything();
8947 
8948 
8953  bool ShowVolume(SimpleSphere & out_sphere, SimpleCuboid & out_cuboid) const;
8954 
8958  bool ShowExclusion(bool & out_exclusion) const;
8959 
8960 private:
8962  BoundingControl();
8963 };
8964 
8965 
8967 class HPS_API VisibilityKit : public Object
8968 {
8969 public:
8970 
8972  VisibilityKit();
8973 
8976  VisibilityKit(VisibilityKit const & in_kit);
8977 
8981  VisibilityKit(VisibilityKit && in_that);
8982 
8986  VisibilityKit & operator=(VisibilityKit && in_that);
8987 
8989  virtual ~VisibilityKit();
8990 
8991  Type ObjectType() const {return Type::VisibilityKit;};
8992 
8996  static VisibilityKit GetDefault();
8997 
9000  void Set(VisibilityKit const & in_kit);
9001 
9004  void Show(VisibilityKit & out_kit) const;
9005 
9009  VisibilityKit & operator=(VisibilityKit const & in_kit);
9010 
9013  bool Empty() const;
9014 
9018  bool Equals(VisibilityKit const & in_kit) const;
9019 
9023  bool operator==(VisibilityKit const & in_kit) const;
9024 
9028  bool operator!=(VisibilityKit const & in_kit) const;
9029 
9030 
9034  VisibilityKit & SetCuttingSections(bool in_state);
9035 
9039  VisibilityKit & SetCutEdges(bool in_state);
9040 
9044  VisibilityKit & SetCutFaces(bool in_state);
9045 
9049  VisibilityKit & SetWindows(bool in_state);
9050 
9054  VisibilityKit & SetText(bool in_state);
9055 
9059  VisibilityKit & SetLines(bool in_state);
9060 
9064  VisibilityKit & SetEdgeLights(bool in_state);
9065 
9069  VisibilityKit & SetMarkerLights(bool in_state);
9070 
9074  VisibilityKit & SetFaceLights(bool in_state);
9075 
9079  VisibilityKit & SetGenericEdges(bool in_state);
9080 
9084  VisibilityKit & SetInteriorSilhouetteEdges(bool in_state);
9085 
9089  VisibilityKit & SetAdjacentEdges(bool in_state);
9090 
9094  VisibilityKit & SetHardEdges(bool in_state);
9095 
9099  VisibilityKit & SetMeshQuadEdges(bool in_state);
9100 
9104  VisibilityKit & SetNonCulledEdges(bool in_state);
9105 
9109  VisibilityKit & SetPerimeterEdges(bool in_state);
9110 
9114  VisibilityKit & SetFaces(bool in_state);
9115 
9119  VisibilityKit & SetVertices(bool in_state);
9120 
9124  VisibilityKit & SetMarkers(bool in_state);
9125 
9129  VisibilityKit & SetShadowCasting(bool in_state);
9130 
9134  VisibilityKit & SetShadowReceiving(bool in_state);
9135 
9139  VisibilityKit & SetShadowEmitting(bool in_state);
9140 
9141 
9145  VisibilityKit & SetCutGeometry(bool in_state);
9146 
9150  VisibilityKit & SetEdges(bool in_state);
9151 
9155  VisibilityKit & SetGeometry(bool in_state);
9156 
9160  VisibilityKit & SetLights(bool in_state);
9161 
9165  VisibilityKit & SetShadows(bool in_state);
9166 
9170  VisibilityKit & SetEverything(bool in_state);
9171 
9172 
9175  VisibilityKit & UnsetCuttingSections();
9176 
9179  VisibilityKit & UnsetCutEdges();
9180 
9183  VisibilityKit & UnsetCutFaces();
9184 
9187  VisibilityKit & UnsetWindows();
9188 
9191  VisibilityKit & UnsetText();
9192 
9195  VisibilityKit & UnsetLines();
9196 
9199  VisibilityKit & UnsetEdgeLights();
9200 
9203  VisibilityKit & UnsetMarkerLights();
9204 
9207  VisibilityKit & UnsetFaceLights();
9208 
9211  VisibilityKit & UnsetGenericEdges();
9212 
9215  VisibilityKit & UnsetInteriorSilhouetteEdges();
9216 
9219  VisibilityKit & UnsetAdjacentEdges();
9220 
9223  VisibilityKit & UnsetHardEdges();
9224 
9227  VisibilityKit & UnsetMeshQuadEdges();
9228 
9231  VisibilityKit & UnsetNonCulledEdges();
9232 
9235  VisibilityKit & UnsetPerimeterEdges();
9236 
9239  VisibilityKit & UnsetFaces();
9240 
9243  VisibilityKit & UnsetVertices();
9244 
9247  VisibilityKit & UnsetMarkers();
9248 
9251  VisibilityKit & UnsetShadowCasting();
9252 
9255  VisibilityKit & UnsetShadowReceiving();
9256 
9259  VisibilityKit & UnsetShadowEmitting();
9260 
9261 
9264  VisibilityKit & UnsetCutGeometry();
9265 
9268  VisibilityKit & UnsetEdges();
9269 
9272  VisibilityKit & UnsetGeometry();
9273 
9276  VisibilityKit & UnsetLights();
9277 
9280  VisibilityKit & UnsetShadows();
9281 
9284  VisibilityKit & UnsetEverything();
9285 
9286 
9290  bool ShowCuttingSections(bool & out_state) const;
9291 
9295  bool ShowCutEdges(bool & out_state) const;
9296 
9300  bool ShowCutFaces(bool & out_state) const;
9301 
9305  bool ShowWindows(bool & out_state) const;
9306 
9310  bool ShowText(bool & out_state) const;
9311 
9315  bool ShowLines(bool & out_state) const;
9316 
9320  bool ShowEdgeLights(bool & out_state) const;
9321 
9325  bool ShowMarkerLights(bool & out_state) const;
9326 
9330  bool ShowFaceLights(bool & out_state) const;
9331 
9335  bool ShowGenericEdges(bool & out_state) const;
9336 
9340  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
9341 
9345  bool ShowAdjacentEdges(bool & out_state) const;
9346 
9350  bool ShowHardEdges(bool & out_state) const;
9351 
9355  bool ShowMeshQuadEdges(bool & out_state) const;
9356 
9360  bool ShowNonCulledEdges(bool & out_state) const;
9361 
9365  bool ShowPerimeterEdges(bool & out_state) const;
9366 
9370  bool ShowFaces(bool & out_state) const;
9371 
9375  bool ShowVertices(bool & out_state) const;
9376 
9380  bool ShowMarkers(bool & out_state) const;
9381 
9385  bool ShowShadowCasting(bool & out_state) const;
9386 
9390  bool ShowShadowReceiving(bool & out_state) const;
9391 
9395  bool ShowShadowEmitting(bool & out_state) const;
9396 };
9397 
9398 
9404 class HPS_API VisibilityControl : public Control
9405 {
9406 public:
9407 
9409  explicit VisibilityControl(SegmentKey & in_seg);
9410 
9412  VisibilityControl(VisibilityControl const & in_that);
9413 
9418 
9422  VisibilityControl & operator=(VisibilityControl && in_that);
9423 
9425  ~VisibilityControl();
9426 
9427  Type ObjectType() const {return Type::VisibilityControl;};
9428 
9430  VisibilityControl & operator=(VisibilityControl const & in_that);
9431 
9432 
9436  VisibilityControl & SetCuttingSections(bool in_state);
9437 
9441  VisibilityControl & SetCutEdges(bool in_state);
9442 
9446  VisibilityControl & SetCutFaces(bool in_state);
9447 
9451  VisibilityControl & SetWindows(bool in_state);
9452 
9456  VisibilityControl & SetText(bool in_state);
9457 
9461  VisibilityControl & SetLines(bool in_state);
9462 
9466  VisibilityControl & SetEdgeLights(bool in_state);
9467 
9471  VisibilityControl & SetMarkerLights(bool in_state);
9472 
9476  VisibilityControl & SetFaceLights(bool in_state);
9477 
9481  VisibilityControl & SetGenericEdges(bool in_state);
9482 
9486  VisibilityControl & SetInteriorSilhouetteEdges(bool in_state);
9487 
9491  VisibilityControl & SetAdjacentEdges(bool in_state);
9492 
9496  VisibilityControl & SetHardEdges(bool in_state);
9497 
9501  VisibilityControl & SetMeshQuadEdges(bool in_state);
9502 
9506  VisibilityControl & SetNonCulledEdges(bool in_state);
9507 
9511  VisibilityControl & SetPerimeterEdges(bool in_state);
9512 
9516  VisibilityControl & SetFaces(bool in_state);
9517 
9521  VisibilityControl & SetVertices(bool in_state);
9522 
9526  VisibilityControl & SetMarkers(bool in_state);
9527 
9531  VisibilityControl & SetShadowCasting(bool in_state);
9532 
9536  VisibilityControl & SetShadowReceiving(bool in_state);
9537 
9541  VisibilityControl & SetShadowEmitting(bool in_state);
9542 
9543 
9547  VisibilityControl & SetCutGeometry(bool in_state);
9548 
9552  VisibilityControl & SetEdges(bool in_state);
9553 
9557  VisibilityControl & SetGeometry(bool in_state);
9558 
9562  VisibilityControl & SetLights(bool in_state);
9563 
9567  VisibilityControl & SetShadows(bool in_state);
9568 
9572  VisibilityControl & SetEverything(bool in_state);
9573 
9574 
9577  VisibilityControl & UnsetCuttingSections();
9578 
9581  VisibilityControl & UnsetCutEdges();
9582 
9585  VisibilityControl & UnsetCutFaces();
9586 
9589  VisibilityControl & UnsetWindows();
9590 
9593  VisibilityControl & UnsetText();
9594 
9597  VisibilityControl & UnsetLines();
9598 
9601  VisibilityControl & UnsetEdgeLights();
9602 
9605  VisibilityControl & UnsetMarkerLights();
9606 
9609  VisibilityControl & UnsetFaceLights();
9610 
9613  VisibilityControl & UnsetGenericEdges();
9614 
9617  VisibilityControl & UnsetInteriorSilhouetteEdges();
9618 
9621  VisibilityControl & UnsetAdjacentEdges();
9622 
9625  VisibilityControl & UnsetHardEdges();
9626 
9629  VisibilityControl & UnsetMeshQuadEdges();
9630 
9633  VisibilityControl & UnsetNonCulledEdges();
9634 
9637  VisibilityControl & UnsetPerimeterEdges();
9638 
9641  VisibilityControl & UnsetFaces();
9642 
9645  VisibilityControl & UnsetVertices();
9646 
9649  VisibilityControl & UnsetMarkers();
9650 
9653  VisibilityControl & UnsetShadowCasting();
9654 
9657  VisibilityControl & UnsetShadowReceiving();
9658 
9661  VisibilityControl & UnsetShadowEmitting();
9662 
9663 
9666  VisibilityControl & UnsetCutGeometry();
9667 
9670  VisibilityControl & UnsetEdges();
9671 
9674  VisibilityControl & UnsetGeometry();
9675 
9678  VisibilityControl & UnsetLights();
9679 
9682  VisibilityControl & UnsetShadows();
9683 
9686  VisibilityControl & UnsetEverything();
9687 
9688 
9692  bool ShowCuttingSections(bool & out_state) const;
9693 
9697  bool ShowCutEdges(bool & out_state) const;
9698 
9702  bool ShowCutFaces(bool & out_state) const;
9703 
9707  bool ShowWindows(bool & out_state) const;
9708 
9712  bool ShowText(bool & out_state) const;
9713 
9717  bool ShowLines(bool & out_state) const;
9718 
9722  bool ShowEdgeLights(bool & out_state) const;
9723 
9727  bool ShowMarkerLights(bool & out_state) const;
9728 
9732  bool ShowFaceLights(bool & out_state) const;
9733 
9737  bool ShowGenericEdges(bool & out_state) const;
9738 
9742  bool ShowInteriorSilhouetteEdges(bool & out_state) const;
9743 
9747  bool ShowAdjacentEdges(bool & out_state) const;
9748 
9752  bool ShowHardEdges(bool & out_state) const;
9753 
9757  bool ShowMeshQuadEdges(bool & out_state) const;
9758 
9762  bool ShowNonCulledEdges(bool & out_state) const;
9763 
9767  bool ShowPerimeterEdges(bool & out_state) const;
9768 
9772  bool ShowFaces(bool & out_state) const;
9773 
9777  bool ShowVertices(bool & out_state) const;
9778 
9782  bool ShowMarkers(bool & out_state) const;
9783 
9787  bool ShowShadowCasting(bool & out_state) const;
9788 
9792  bool ShowShadowReceiving(bool & out_state) const;
9793 
9797  bool ShowShadowEmitting(bool & out_state) const;
9798 
9799 private:
9802 };
9803 
9804 
9805 
9808 class HPS_API CameraKit : public Object
9809 {
9810 public:
9811 
9813  CameraKit();
9814 
9817  CameraKit(const CameraKit & in_kit);
9818 
9822  CameraKit(CameraKit && in_that);
9823 
9827  CameraKit & operator=(CameraKit && in_that);
9828 
9830  virtual ~CameraKit();
9831 
9832  Type ObjectType() const {return Type::CameraKit;};
9833 
9837  static CameraKit GetDefault();
9838 
9841  void Set(CameraKit const & in_kit);
9842 
9845  void Show(CameraKit & out_kit) const;
9846 
9850  CameraKit & operator=(CameraKit const & in_kit);
9851 
9854  bool Empty() const;
9855 
9859  bool Equals(CameraKit const & in_kit) const;
9860 
9864  bool operator==(CameraKit const & in_kit) const;
9865 
9869  bool operator!=(CameraKit const & in_kit) const;
9870 
9874  CameraKit & SetUpVector(Vector const & in_up);
9875 
9879  CameraKit & SetPosition(Point const & in_position);
9880 
9884  CameraKit & SetTarget(Point const & in_target);
9885 
9892  CameraKit & SetProjection(Camera::Projection in_type, float in_oblique_y_skew = 0.0f, float in_oblique_x_skew = 0.0f);
9893 
9899  CameraKit & SetField(float in_width, float in_height);
9900 
9910  CameraKit & SetNearLimit(float const in_limit);
9911 
9914  CameraKit & UnsetUpVector();
9915 
9918  CameraKit & UnsetPosition();
9919 
9922  CameraKit & UnsetTarget();
9923 
9926  CameraKit & UnsetProjection();
9927 
9930  CameraKit & UnsetField();
9931 
9934  CameraKit & UnsetNearLimit();
9935 
9938  CameraKit & UnsetEverything();
9939 
9940 
9944  bool ShowUpVector(Vector & out_up) const;
9945 
9949  bool ShowPosition(Point & out_position) const;
9950 
9954  bool ShowTarget(Point & out_target) const;
9955 
9959  bool ShowProjection(Camera::Projection & out_type) const;
9960 
9966  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_y_skew, float & out_oblique_x_skew) const;
9967 
9971  bool ShowWidth(float & out_width) const;
9972 
9976  bool ShowHeight(float & out_height) const;
9977 
9982  bool ShowField(float & out_width, float & out_height) const;
9983 
9987  bool ShowNearLimit(float & out_near_limit) const;
9988 
9995  CameraKit & Dolly(float in_x_dir, float in_up, float in_forward);
9996 
10003  CameraKit & Orbit(float in_theta, float in_phi);
10004 
10011  CameraKit & Pan(float in_theta, float in_phi);
10012 
10018  CameraKit & Roll(float in_theta);
10019 
10025  CameraKit & Zoom(float in_zoom);
10026 };
10027 
10031 class HPS_API CameraControl : public Control
10032 {
10033 public:
10035  explicit CameraControl(SegmentKey & in_seg);
10036 
10038  CameraControl(CameraControl const & in_that);
10039 
10043  CameraControl(CameraControl && in_that);
10044 
10048  CameraControl & operator=(CameraControl && in_that);
10049 
10051  ~CameraControl();
10052 
10053  Type ObjectType() const {return Type::CameraControl;};
10054 
10056  CameraControl & operator=(CameraControl const & in_that);
10057 
10058 
10063  CameraControl & SetUpVector(Vector const & in_up);
10064 
10069  CameraControl & SetPosition(Point const & in_position);
10070 
10075  CameraControl & SetTarget(Point const & in_target);
10076 
10083  CameraControl & SetProjection(Camera::Projection in_type, float in_oblique_x_skew = 0.0f, float in_oblique_y_skew = 0.0f);
10084 
10090  CameraControl & SetField(float in_width, float in_height);
10091 
10102  CameraControl & SetNearLimit(float in_double);
10103 
10107  CameraControl & UnsetEverything();
10108 
10109 
10113  bool ShowUpVector(Vector & out_up) const;
10114 
10118  bool ShowPosition(Point & out_position) const;
10119 
10123  bool ShowTarget(Point & out_target) const;
10124 
10128  bool ShowProjection(Camera::Projection & out_type) const;
10129 
10135  bool ShowProjection(Camera::Projection & out_type, float & out_oblique_x_skew, float & out_oblique_y_skew) const;
10136 
10140  bool ShowWidth(float & out_width) const;
10141 
10145  bool ShowHeight(float & out_height) const;
10146 
10151  bool ShowField(float & out_width, float & out_height) const;
10152 
10156  bool ShowNearLimit(float & out_width) const;
10157 
10164  CameraControl & Dolly(float in_x_dir, float in_up, float in_forward);
10165 
10172  CameraControl & Orbit(float in_theta, float in_phi);
10173 
10180  CameraControl & Pan(float in_theta, float in_phi);
10181 
10187  CameraControl & Roll(float in_theta);
10188 
10194  CameraControl & Zoom(float in_zoom);
10195 
10196 private:
10198  CameraControl();
10199 };
10200 
10201 
10202 
10204 class HPS_API SelectabilityKit : public Object
10205 {
10206 public:
10207 
10209  SelectabilityKit();
10210 
10213  SelectabilityKit(SelectabilityKit const & in_kit);
10214 
10218  SelectabilityKit(SelectabilityKit && in_that);
10219 
10223  SelectabilityKit & operator=(SelectabilityKit && in_that);
10224 
10226  virtual ~SelectabilityKit();
10227 
10228  Type ObjectType() const {return Type::SelectabilityKit;};
10229 
10233  static SelectabilityKit GetDefault();
10234 
10237  void Set(SelectabilityKit const & in_kit);
10238 
10241  void Show(SelectabilityKit & out_kit) const;
10242 
10246  SelectabilityKit & operator=(SelectabilityKit const & in_kit);
10247 
10250  bool Empty() const;
10251 
10255  bool Equals(SelectabilityKit const & in_kit) const;
10256 
10260  bool operator==(SelectabilityKit const & in_kit) const;
10261 
10265  bool operator!=(SelectabilityKit const & in_kit) const;
10266 
10267 
10271  SelectabilityKit & SetWindows(Selectability::Value in_val);
10272 
10276  SelectabilityKit & SetEdges(Selectability::Value in_val);
10277 
10281  SelectabilityKit & SetFaces(Selectability::Value in_val);
10282 
10286  SelectabilityKit & SetLights(Selectability::Value in_val);
10287 
10291  SelectabilityKit & SetLines(Selectability::Value in_val);
10292 
10296  SelectabilityKit & SetMarkers(Selectability::Value in_val);
10297 
10301  SelectabilityKit & SetVertices(Selectability::Value in_val);
10302 
10306  SelectabilityKit & SetText(Selectability::Value in_val);
10307 
10311  SelectabilityKit & SetGeometry(Selectability::Value in_val);
10312 
10316  SelectabilityKit & SetEverything(Selectability::Value in_val);
10317 
10318 
10321  SelectabilityKit & UnsetWindows();
10322 
10325  SelectabilityKit & UnsetEdges();
10326 
10329  SelectabilityKit & UnsetFaces();
10330 
10333  SelectabilityKit & UnsetLights();
10334 
10337  SelectabilityKit & UnsetLines();
10338 
10341  SelectabilityKit & UnsetMarkers();
10342 
10345  SelectabilityKit & UnsetVertices();
10346 
10349  SelectabilityKit & UnsetText();
10350 
10353  SelectabilityKit & UnsetGeometry();
10354 
10357  SelectabilityKit & UnsetEverything();
10358 
10359 
10363  bool ShowWindows(Selectability::Value & out_val) const;
10364 
10368  bool ShowEdges(Selectability::Value & out_val) const;
10369 
10373  bool ShowFaces(Selectability::Value & out_val) const;
10374 
10378  bool ShowLights(Selectability::Value & out_val) const;
10379 
10383  bool ShowLines(Selectability::Value & out_val) const;
10384 
10388  bool ShowMarkers(Selectability::Value & out_val) const;
10389 
10393  bool ShowVertices(Selectability::Value & out_val) const;
10394 
10398  bool ShowText(Selectability::Value & out_val) const;
10399 };
10400 
10406 class HPS_API SelectabilityControl : public Control
10407 {
10408 public:
10409 
10411  explicit SelectabilityControl(SegmentKey & in_seg);
10412 
10414  SelectabilityControl(SelectabilityControl const & in_that);
10415 
10420 
10424  SelectabilityControl & operator=(SelectabilityControl && in_that);
10425 
10428 
10429  Type ObjectType() const {return Type::SelectabilityControl;};
10430 
10432  SelectabilityControl & operator=(SelectabilityControl const & in_that);
10433 
10434 
10438  SelectabilityControl & SetWindows(Selectability::Value in_val);
10439 
10443  SelectabilityControl & SetEdges(Selectability::Value in_val);
10444 
10448  SelectabilityControl & SetFaces(Selectability::Value in_val);
10449 
10453  SelectabilityControl & SetLights(Selectability::Value in_val);
10454 
10458  SelectabilityControl & SetLines(Selectability::Value in_val);
10459 
10463  SelectabilityControl & SetMarkers(Selectability::Value in_val);
10464 
10468  SelectabilityControl & SetVertices(Selectability::Value in_val);
10469 
10473  SelectabilityControl & SetText(Selectability::Value in_val);
10474 
10478  SelectabilityControl & SetGeometry(Selectability::Value in_val);
10479 
10483  SelectabilityControl & SetEverything(Selectability::Value in_val);
10484 
10485 
10488  SelectabilityControl & UnsetWindows();
10489 
10492  SelectabilityControl & UnsetEdges();
10493 
10496  SelectabilityControl & UnsetFaces();
10497 
10500  SelectabilityControl & UnsetLights();
10501 
10504  SelectabilityControl & UnsetLines();
10505 
10508  SelectabilityControl & UnsetMarkers();
10509 
10512  SelectabilityControl & UnsetVertices();
10513 
10516  SelectabilityControl & UnsetText();
10517 
10520  SelectabilityControl & UnsetGeometry();
10521 
10524  SelectabilityControl & UnsetEverything();
10525 
10526 
10530  bool ShowWindows(Selectability::Value & out_val) const;
10531 
10535  bool ShowEdges(Selectability::Value & out_val) const;
10536 
10540  bool ShowFaces(Selectability::Value & out_val) const;
10541 
10545  bool ShowLights(Selectability::Value & out_val) const;
10546 
10550  bool ShowLines(Selectability::Value & out_val) const;
10551 
10555  bool ShowMarkers(Selectability::Value & out_val) const;
10556 
10560  bool ShowVertices(Selectability::Value & out_val) const;
10561 
10565  bool ShowText(Selectability::Value & out_val) const;
10566 
10567 private:
10570 };
10571 
10572 
10574 class HPS_API TransparencyKit : public Object
10575 {
10576 public:
10577 
10579  TransparencyKit();
10580 
10583  TransparencyKit(TransparencyKit const & in_kit);
10584 
10588  TransparencyKit(TransparencyKit && in_that);
10589 
10593  TransparencyKit & operator=(TransparencyKit && in_that);
10594 
10596  virtual ~TransparencyKit();
10597 
10598  Type ObjectType() const {return Type::TransparencyKit;};
10599 
10603  static TransparencyKit GetDefault();
10604 
10607  void Set(TransparencyKit const & in_kit);
10608 
10611  void Show(TransparencyKit & out_kit) const;
10612 
10616  TransparencyKit & operator=(TransparencyKit const & in_kit);
10617 
10620  bool Empty() const;
10621 
10625  bool Equals(TransparencyKit const & in_kit) const;
10626 
10630  bool operator==(TransparencyKit const & in_kit) const;
10631 
10635  bool operator!=(TransparencyKit const & in_kit) const;
10636 
10637 
10641  TransparencyKit & SetMethod(Transparency::Method in_style);
10642 
10646  TransparencyKit & SetAlgorithm(Transparency::Algorithm in_algorithm);
10647 
10652  TransparencyKit & SetDepthPeelingLayers(unsigned int in_layers);
10653 
10659  TransparencyKit & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
10660 
10665  TransparencyKit & SetDepthWriting(bool in_state);
10666 
10667 
10670  TransparencyKit & UnsetMethod();
10671 
10674  TransparencyKit & UnsetAlgorithm();
10675 
10678  TransparencyKit & UnsetDepthPeelingLayers();
10679 
10682  TransparencyKit & UnsetDepthPeelingMinimumArea();
10683 
10686  TransparencyKit & UnsetDepthWriting();
10687 
10690  TransparencyKit & UnsetEverything();
10691 
10692 
10696  bool ShowMethod(Transparency::Method & out_style) const;
10697 
10701  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
10702 
10706  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
10707 
10712  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
10713 
10717  bool ShowDepthWriting(bool & out_state) const;
10718 };
10719 
10725 class HPS_API TransparencyControl : public Control
10726 {
10727 public:
10728 
10730  explicit TransparencyControl(SegmentKey & in_seg);
10731 
10733  TransparencyControl(TransparencyControl const & in_that);
10734 
10739 
10743  TransparencyControl & operator=(TransparencyControl && in_that);
10744 
10747 
10748  Type ObjectType() const {return Type::TransparencyControl;};
10749 
10751  TransparencyControl & operator=(TransparencyControl const & in_that);
10752 
10756  TransparencyControl & SetMethod(Transparency::Method in_style);
10757 
10761  TransparencyControl & SetAlgorithm(Transparency::Algorithm in_algorithm);
10762 
10767  TransparencyControl & SetDepthPeelingLayers(unsigned int in_layers);
10768 
10774  TransparencyControl & SetDepthPeelingMinimumArea(float in_area, Transparency::AreaUnits in_units);
10775 
10780  TransparencyControl & SetDepthWriting(bool in_state);
10781 
10782 
10785  TransparencyControl & UnsetMethod();
10786 
10789  TransparencyControl & UnsetAlgorithm();
10790 
10793  TransparencyControl & UnsetDepthPeelingLayers();
10794 
10797  TransparencyControl & UnsetDepthPeelingMinimumArea();
10798 
10801  TransparencyControl & UnsetDepthWriting();
10802 
10805  TransparencyControl & UnsetEverything();
10806 
10807 
10811  bool ShowMethod(Transparency::Method & out_style) const;
10812 
10816  bool ShowAlgorithm(Transparency::Algorithm & out_algorithm) const;
10817 
10821  bool ShowDepthPeelingLayers(unsigned int & out_layers) const;
10822 
10827  bool ShowDepthPeelingMinimumArea(float & out_area, Transparency::AreaUnits & out_units) const;
10828 
10832  bool ShowDepthWriting(bool & out_state) const;
10833 
10834 private:
10837 };
10838 
10840 class HPS_API ColorInterpolationKit : public Object
10841 {
10842 public:
10843 
10846 
10849 
10854 
10858  ColorInterpolationKit & operator=(ColorInterpolationKit && in_that);
10859 
10861  virtual ~ColorInterpolationKit();
10862 
10863  Type ObjectType() const {return Type::ColorInterpolationKit;};
10864 
10865  static ColorInterpolationKit GetDefault();
10866 
10868  void Set(ColorInterpolationKit const & in_kit);
10869 
10871  void Show(ColorInterpolationKit & out_kit) const;
10872 
10874  ColorInterpolationKit & operator=(ColorInterpolationKit const & in_kit);
10875 
10877  bool Empty() const;
10878 
10880  bool Equals(ColorInterpolationKit const & in_kit) const;
10881 
10883  bool operator==(ColorInterpolationKit const & in_kit) const;
10884 
10886  bool operator!=(ColorInterpolationKit const & in_kit) const;
10887 
10888 
10892  ColorInterpolationKit & SetFaceColor(bool in_state);
10893 
10897  ColorInterpolationKit & SetEdgeColor(bool in_state);
10898 
10902  ColorInterpolationKit & SetVertexColor(bool in_state);
10903 
10907  ColorInterpolationKit & SetFaceIndex(bool in_state);
10908 
10912  ColorInterpolationKit & SetEdgeIndex(bool in_state);
10913 
10917  ColorInterpolationKit & SetVertexIndex(bool in_state);
10918 
10919 
10922  ColorInterpolationKit & UnsetFaceColor();
10923 
10926  ColorInterpolationKit & UnsetEdgeColor();
10927 
10930  ColorInterpolationKit & UnsetVertexColor();
10931 
10934  ColorInterpolationKit & UnsetFaceIndex();
10935 
10938  ColorInterpolationKit & UnsetEdgeIndex();
10939 
10942  ColorInterpolationKit & UnsetVertexIndex();
10943 
10946  ColorInterpolationKit & UnsetEverything();
10947 
10948 
10952  bool ShowFaceColor(bool & out_state) const;
10953 
10957  bool ShowEdgeColor(bool & out_state) const;
10958 
10962  bool ShowVertexColor(bool & out_state) const;
10963 
10967  bool ShowFaceIndex(bool & out_state) const;
10968 
10972  bool ShowEdgeIndex(bool & out_state) const;
10973 
10977  bool ShowVertexIndex(bool & out_state) const;
10978 };
10979 
10980 
10984 class HPS_API ColorInterpolationControl : public Control
10985 {
10986 public:
10987 
10989  explicit ColorInterpolationControl(SegmentKey & in_seg);
10990 
10993 
10998 
11002  ColorInterpolationControl & operator=(ColorInterpolationControl && in_that);
11003 
11006 
11007  Type ObjectType() const {return Type::ColorInterpolationControl;};
11008 
11009 
11013  ColorInterpolationControl & SetFaceColor(bool in_state);
11014 
11018  ColorInterpolationControl & SetEdgeColor(bool in_state);
11019 
11023  ColorInterpolationControl & SetVertexColor(bool in_state);
11024 
11028  ColorInterpolationControl & SetFaceIndex(bool in_state);
11029 
11033  ColorInterpolationControl & SetEdgeIndex(bool in_state);
11034 
11038  ColorInterpolationControl & SetVertexIndex(bool in_state);
11039 
11040 
11043  ColorInterpolationControl & UnsetFaceColor();
11044 
11047  ColorInterpolationControl & UnsetEdgeColor();
11048 
11051  ColorInterpolationControl & UnsetVertexColor();
11052 
11055  ColorInterpolationControl & UnsetFaceIndex();
11056 
11059  ColorInterpolationControl & UnsetEdgeIndex();
11060 
11063  ColorInterpolationControl & UnsetVertexIndex();
11064 
11067  ColorInterpolationControl & UnsetEverything();
11068 
11069 
11073  bool ShowFaceColor(bool & out_state) const;
11074 
11078  bool ShowEdgeColor(bool & out_state) const;
11079 
11083  bool ShowVertexColor(bool & out_state) const;
11084 
11088  bool ShowFaceIndex(bool & out_state) const;
11089 
11093  bool ShowEdgeIndex(bool & out_state) const;
11094 
11098  bool ShowVertexIndex(bool & out_state) const;
11099 
11100 private:
11103 };
11104 
11105 
11107 class HPS_API CullingKit : public Object
11108 {
11109 public:
11110 
11112  CullingKit();
11113 
11116  CullingKit(CullingKit const & in_kit);
11117 
11121  CullingKit(CullingKit && in_that);
11122 
11126  CullingKit & operator=(CullingKit && in_that);
11127 
11129  virtual ~CullingKit();
11130 
11131  Type ObjectType() const {return Type::CullingKit;};
11132 
11136  static CullingKit GetDefault();
11137 
11140  void Set(CullingKit const & in_kit);
11141 
11144  void Show(CullingKit & out_kit) const;
11145 
11149  CullingKit & operator=(CullingKit const & in_kit);
11150 
11153  bool Empty() const;
11154 
11158  bool Equals(CullingKit const & in_kit) const;
11159 
11163  bool operator==(CullingKit const & in_kit) const;
11164 
11168  bool operator!=(CullingKit const & in_kit) const;
11169 
11174  CullingKit & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11175 
11180  CullingKit & SetDeferralExtent(unsigned int in_pixels);
11181 
11186  CullingKit & SetExtent(bool in_state, unsigned int in_pixels);
11187 
11192  CullingKit & SetExtent(unsigned int in_pixels);
11193 
11197  CullingKit & SetBackFace(bool in_state);
11198 
11205  CullingKit & SetVector(bool in_state, Vector const & in_vector, float in_tolerance_degrees);
11206 
11213  CullingKit & SetVector(Vector const & in_vector, float in_tolerance_degrees);
11214 
11221  CullingKit & SetVector(bool in_state, Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11222 
11228  CullingKit & SetVector(Vector const & in_vector);
11229 
11233  CullingKit & SetVectorTolerance(float in_tolerance_degrees);
11234 
11238  CullingKit & SetFrustum(bool in_state);
11239 
11242  CullingKit & UnsetDeferralExtent();
11243 
11246  CullingKit & UnsetExtent();
11247 
11250  CullingKit & UnsetBackFace();
11251 
11254  CullingKit & UnsetVector();
11255 
11258  CullingKit & UnsetVectorTolerance();
11259 
11262  CullingKit & UnsetFrustum();
11263 
11266  CullingKit & UnsetEverything();
11267 
11272  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11273 
11278  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11279 
11283  bool ShowBackFace(bool & out_state) const;
11284 
11290  bool ShowVector(bool & out_state, Vector & out_vector) const;
11291 
11295  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11296 
11300  bool ShowFrustum(bool & out_state) const;
11301 };
11302 
11306 class HPS_API CullingControl : public Control
11307 {
11308 public:
11309 
11311  explicit CullingControl(SegmentKey & in_seg);
11312 
11314  CullingControl(CullingControl const & in_that);
11315 
11317  ~CullingControl();
11318 
11322  CullingControl(CullingControl && in_that);
11323 
11327  CullingControl & operator=(CullingControl && in_that);
11328 
11329  Type ObjectType() const {return Type::CullingControl;};
11330 
11332  CullingControl & operator=(CullingControl const & in_that);
11333 
11340  CullingControl & SetDeferralExtent(bool in_state, unsigned int in_pixels);
11341 
11348  CullingControl & SetDeferralExtent(unsigned int in_pixels);
11349 
11354  CullingControl & SetExtent(bool in_state, unsigned int in_pixels);
11355 
11360  CullingControl & SetExtent(unsigned int in_pixels);
11361 
11366  CullingControl & SetBackFace(bool in_state);
11367 
11374  CullingControl & SetVector(bool in_state, Vector const & in_vector, float in_tolerance_degrees);
11375 
11382  CullingControl & SetVector(Vector const & in_vector, float in_tolerance_degrees);
11383 
11390  CullingControl & SetVector(bool in_state, Vector const & in_vector = Vector(0.0f, 0.0f, 1.0f));
11391 
11397  CullingControl & SetVector(Vector const & in_vector);
11398 
11402  CullingControl & SetVectorTolerance(float in_tolerance_degrees);
11403 
11407  CullingControl & SetFrustum(bool in_state);
11408 
11411  CullingControl & UnsetDeferralExtent();
11412 
11415  CullingControl & UnsetExtent();
11416 
11419  CullingControl & UnsetBackFace();
11420 
11423  CullingControl & UnsetVector();
11424 
11427  CullingControl & UnsetVectorTolerance();
11428 
11431  CullingControl & UnsetFrustum();
11432 
11435  CullingControl & UnsetEverything();
11436 
11441  bool ShowDeferralExtent(bool & out_state, unsigned int & out_pixels) const;
11442 
11447  bool ShowExtent(bool & out_state, unsigned int & out_pixels) const;
11448 
11452  bool ShowBackFace(bool & out_state) const;
11453 
11459  bool ShowVector(bool & out_state, Vector & out_vector) const;
11460 
11464  bool ShowVectorTolerance(float & out_tolerance_degrees) const;
11465 
11469  bool ShowFrustum(bool & out_state) const;
11470 
11471 private:
11473  CullingControl();
11474 };
11475 
11476 
11477 
11478 
11480 class HPS_API MarkerAttributeKit : public Object
11481 {
11482 public:
11483 
11486 
11489  MarkerAttributeKit(MarkerAttributeKit const & in_kit);
11490 
11495 
11499  MarkerAttributeKit & operator=(MarkerAttributeKit && in_that);
11500 
11502  virtual ~MarkerAttributeKit();
11503 
11504  Type ObjectType() const {return Type::MarkerAttributeKit;};
11505 
11509  static MarkerAttributeKit GetDefault();
11510 
11513  void Set(MarkerAttributeKit const & in_kit);
11514 
11517  void Show(MarkerAttributeKit & out_kit) const;
11518 
11522  MarkerAttributeKit & operator=(MarkerAttributeKit const & in_kit);
11523 
11526  bool Empty() const;
11527 
11531  bool Equals(MarkerAttributeKit const & in_kit) const;
11532 
11536  bool operator==(MarkerAttributeKit const & in_kit) const;
11537 
11541  bool operator!=(MarkerAttributeKit const & in_kit) const;
11542 
11543 
11547  MarkerAttributeKit & SetSymbol(char const * in_glyph_name);
11548 
11553  MarkerAttributeKit & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
11554 
11555 
11558  MarkerAttributeKit & UnsetSymbol();
11559 
11562  MarkerAttributeKit & UnsetSize();
11563 
11566  MarkerAttributeKit & UnsetEverything();
11567 
11568 
11572  bool ShowSymbol(UTF8 & out_glyph_name) const;
11573 
11578  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
11579 };
11580 
11586 class HPS_API MarkerAttributeControl : public Control
11587 {
11588 public:
11589 
11591  explicit MarkerAttributeControl(SegmentKey & in_seg);
11592 
11595 
11600 
11604  MarkerAttributeControl & operator=(MarkerAttributeControl && in_that);
11605 
11608 
11609  Type ObjectType() const {return Type::MarkerAttributeControl;};
11610 
11612  MarkerAttributeControl & operator=(MarkerAttributeControl const & in_that);
11613 
11617  MarkerAttributeControl & SetSymbol(char const * in_glyph_name);
11618 
11623  MarkerAttributeControl & SetSize(float in_size, Marker::SizeUnits in_units = Marker::SizeUnits::ScaleFactor);
11624 
11625 
11628  MarkerAttributeControl & UnsetSymbol();
11629 
11632  MarkerAttributeControl & UnsetSize();
11633 
11636  MarkerAttributeControl & UnsetEverything();
11637 
11638 
11642  bool ShowSymbol(UTF8 & out_glyph_name) const;
11643 
11648  bool ShowSize(float & out_size, Marker::SizeUnits & out_units) const;
11649 
11650 private:
11653 };
11654 
11655 
11657 class HPS_API SphereAttributeKit : public Object
11658 {
11659 public:
11660 
11663 
11666  SphereAttributeKit(SphereAttributeKit const & in_kit);
11667 
11672 
11676  SphereAttributeKit & operator=(SphereAttributeKit && in_that);
11677 
11679  virtual ~SphereAttributeKit();
11680 
11681  Type ObjectType() const {return Type::SphereAttributeKit;};
11682 
11686  static SphereAttributeKit GetDefault();
11687 
11690  void Set(SphereAttributeKit const & in_kit);
11691 
11694  void Show(SphereAttributeKit & out_kit) const;
11695 
11699  SphereAttributeKit & operator=(SphereAttributeKit const & in_kit);
11700 
11703  bool Empty() const;
11704 
11708  bool Equals(SphereAttributeKit const & in_kit) const;
11709 
11713  bool operator==(SphereAttributeKit const & in_kit) const;
11714 
11718  bool operator!=(SphereAttributeKit const & in_kit) const;
11719 
11720 
11724  SphereAttributeKit & SetTessellation(size_t in_facets);
11725 
11726 
11729  SphereAttributeKit & UnsetTessellation();
11730 
11733  SphereAttributeKit & UnsetEverything();
11734 
11735 
11739  bool ShowTessellation(size_t & out_facets) const;
11740 };
11741 
11742 
11745 class HPS_API SphereAttributeControl : public Control
11746 {
11747 public:
11748 
11750  explicit SphereAttributeControl(SegmentKey const & in_seg);
11751 
11754 
11759 
11763  SphereAttributeControl & operator=(SphereAttributeControl && in_that);
11764 
11767 
11768  Type ObjectType() const {return Type::SphereAttributeControl;};
11769 
11771  SphereAttributeControl & operator=(SphereAttributeControl const & in_that);
11772 
11773 
11778  SphereAttributeControl & SetTessellation(size_t in_facets);
11779 
11780 
11783  SphereAttributeControl & UnsetTessellation();
11784 
11787  SphereAttributeControl & UnsetEverything();
11788 
11789 
11793  bool ShowTessellation(size_t & out_facets) const;
11794 
11795 private:
11798 };
11799 
11800 
11802 class HPS_API LightingAttributeKit : public Object
11803 {
11804 public:
11805 
11808 
11812 
11817 
11821  LightingAttributeKit & operator=(LightingAttributeKit && in_that);
11822 
11824  virtual ~LightingAttributeKit();
11825 
11826  Type ObjectType() const {return Type::LightingAttributeKit;};
11827 
11831  static LightingAttributeKit GetDefault();
11832 
11835  void Set(LightingAttributeKit const & in_kit);
11836 
11839  void Show(LightingAttributeKit & out_kit) const;
11840 
11844  LightingAttributeKit & operator=(LightingAttributeKit const & in_kit);
11845 
11848  bool Empty() const;
11849 
11853  bool Equals(LightingAttributeKit const & in_kit) const;
11854 
11858  bool operator==(LightingAttributeKit const & in_kit) const;
11859 
11863  bool operator!=(LightingAttributeKit const & in_kit) const;
11864 
11865 
11869  LightingAttributeKit & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
11870 
11871 
11874  LightingAttributeKit & UnsetInterpolationAlgorithm();
11875 
11878  LightingAttributeKit & UnsetEverything();
11879 
11880 
11884  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
11885 };
11886 
11887 
11888 
11894 class HPS_API LightingAttributeControl : public Control
11895 {
11896 public:
11897 
11899  explicit LightingAttributeControl(SegmentKey & in_seg);
11900 
11903 
11908 
11912  LightingAttributeControl & operator=(LightingAttributeControl && in_that);
11913 
11916 
11917  Type ObjectType() const {return Type::LightingAttributeControl;};
11918 
11920  LightingAttributeControl & operator=(LightingAttributeControl const & in_that);
11921 
11922 
11926  LightingAttributeControl & SetInterpolationAlgorithm(Lighting::InterpolationAlgorithm in_interpolation);
11927 
11928 
11931  LightingAttributeControl & UnsetInterpolationAlgorithm();
11932 
11935  LightingAttributeControl & UnsetEverything();
11936 
11937 
11941  bool ShowInterpolationAlgorithm(Lighting::InterpolationAlgorithm & out_interpolation) const;
11942 
11943 private:
11946 };
11947 
11948 
11949 
11951 class HPS_API CylinderAttributeKit : public Object
11952 {
11953 public:
11954 
11957 
11961 
11966 
11970  CylinderAttributeKit & operator=(CylinderAttributeKit && in_that);
11971 
11973  virtual ~CylinderAttributeKit();
11974 
11975  Type ObjectType() const {return Type::CylinderAttributeKit;};
11976 
11980  static CylinderAttributeKit GetDefault();
11981 
11984  void Set(CylinderAttributeKit const & in_kit);
11985 
11988  void Show(CylinderAttributeKit & out_kit) const;
11989 
11993  CylinderAttributeKit & operator=(CylinderAttributeKit const & in_kit);
11994 
11997  bool Empty() const;
11998 
12002  bool Equals(CylinderAttributeKit const & in_kit) const;
12003 
12007  bool operator==(CylinderAttributeKit const & in_kit) const;
12008 
12012  bool operator!=(CylinderAttributeKit const & in_kit) const;
12013 
12014 
12018  CylinderAttributeKit & SetTessellation(size_t in_facets);
12019 
12024  CylinderAttributeKit & SetOrientation(Cylinder::Orientation in_adjust);
12025 
12026 
12029  CylinderAttributeKit & UnsetTessellation();
12030 
12033  CylinderAttributeKit & UnsetOrientation();
12034 
12037  CylinderAttributeKit & UnsetEverything();
12038 
12039 
12043  bool ShowTessellation(size_t & out_facets) const;
12044 
12048  bool ShowOrientation(Cylinder::Orientation & out_orientation) const;
12049 };
12050 
12051 
12052 
12056 class HPS_API CylinderAttributeControl : public Control
12057 {
12058 public:
12059 
12061  explicit CylinderAttributeControl(SegmentKey & in_seg);
12062 
12065 
12070 
12074  CylinderAttributeControl & operator=(CylinderAttributeControl && in_that);
12075 
12078 
12079  Type ObjectType() const {return Type::CylinderAttributeControl;};
12080 
12082  CylinderAttributeControl & operator=(CylinderAttributeControl const & in_that);
12083 
12084 
12088  CylinderAttributeControl & SetTessellation(size_t in_facets);
12089 
12094  CylinderAttributeControl & SetOrientation(Cylinder::Orientation in_orientation);
12095 
12096 
12099  CylinderAttributeControl & UnsetTessellation();
12100 
12103  CylinderAttributeControl & UnsetOrientation();
12104 
12107  CylinderAttributeControl & UnsetEverything();
12108 
12109 
12113  bool ShowTessellation(size_t & out_facets) const;
12114 
12118  bool ShowOrientation(Cylinder::Orientation & out_adjust) const;
12119 
12120 private:
12123 };
12124 
12125 
12126 
12128 class HPS_API CuttingSectionAttributeKit : public Object
12129 {
12130 public:
12131 
12134 
12138 
12143 
12148 
12150  virtual ~CuttingSectionAttributeKit();
12151 
12152  Type ObjectType() const {return Type::CuttingSectionAttributeKit;};
12153 
12157  static CuttingSectionAttributeKit GetDefault();
12158 
12161  void Set(CuttingSectionAttributeKit const & in_kit);
12162 
12165  void Show(CuttingSectionAttributeKit & out_kit) const;
12166 
12170  CuttingSectionAttributeKit & operator=(CuttingSectionAttributeKit const & in_kit);
12171 
12174  bool Empty() const;
12175 
12179  bool Equals(CuttingSectionAttributeKit const & in_kit) const;
12180 
12184  bool operator==(CuttingSectionAttributeKit const & in_kit) const;
12185 
12189  bool operator!=(CuttingSectionAttributeKit const & in_kit) const;
12190 
12191 
12195  CuttingSectionAttributeKit & SetCuttingLevel(CuttingSection::CuttingLevel in_level);
12196 
12200  CuttingSectionAttributeKit & SetCappingLevel(CuttingSection::CappingLevel in_level);
12201 
12205  CuttingSectionAttributeKit & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12206 
12207 
12210  CuttingSectionAttributeKit & UnsetCuttingLevel();
12211 
12214  CuttingSectionAttributeKit & UnsetCappingLevel();
12215 
12218  CuttingSectionAttributeKit & UnsetMaterialPreference();
12219 
12222  CuttingSectionAttributeKit & UnsetEverything();
12223 
12224 
12228  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12229 
12233  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12234 
12238  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12239 };
12240 
12241 
12242 
12247 {
12248 public:
12249 
12251  explicit CuttingSectionAttributeControl(SegmentKey & in_seg);
12252 
12255 
12260 
12265 
12268 
12269  Type ObjectType() const {return Type::CuttingSectionAttributeControl;};
12270 
12273 
12274 
12279 
12284 
12288  CuttingSectionAttributeControl & SetMaterialPreference(CuttingSection::MaterialPreference in_preference);
12289 
12290 
12293  CuttingSectionAttributeControl & UnsetCuttingLevel();
12294 
12297  CuttingSectionAttributeControl & UnsetCappingLevel();
12298 
12301  CuttingSectionAttributeControl & UnsetMaterialPreference();
12302 
12305  CuttingSectionAttributeControl & UnsetEverything();
12306 
12307 
12311  bool ShowCuttingLevel(CuttingSection::CuttingLevel & out_level) const;
12312 
12316  bool ShowCappingLevel(CuttingSection::CappingLevel & out_level) const;
12317 
12321  bool ShowMaterialPreference(CuttingSection::MaterialPreference & out_preference) const;
12322 
12323 private:
12326 };
12327 
12328 
12329 
12331 class HPS_API TextAttributeKit : public Object
12332 {
12333 public:
12334 
12336  TextAttributeKit();
12337 
12340  TextAttributeKit(TextAttributeKit const & in_kit);
12341 
12345  TextAttributeKit(TextAttributeKit && in_that);
12346 
12350  TextAttributeKit & operator=(TextAttributeKit && in_that);
12351 
12353  virtual ~TextAttributeKit();
12354 
12355  Type ObjectType() const {return Type::TextAttributeKit;};
12356 
12360  static TextAttributeKit GetDefault();
12361 
12364  void Set(TextAttributeKit const & in_kit);
12365 
12368  void Show(TextAttributeKit & out_kit) const;
12369 
12373  TextAttributeKit & operator=(TextAttributeKit const & in_kit);
12374 
12377  bool Empty() const;
12378 
12382  bool Equals(TextAttributeKit const & in_kit) const;
12383 
12387  bool operator==(TextAttributeKit const & in_kit) const;
12388 
12392  bool operator!=(TextAttributeKit const & in_kit) const;
12393 
12394 
12401 
12406  TextAttributeKit & SetBold(bool in_state);
12407 
12412  TextAttributeKit & SetItalic(bool in_state);
12413 
12417  TextAttributeKit & SetOverline(bool in_state);
12418 
12422  TextAttributeKit & SetStrikethrough(bool in_state);
12423 
12427  TextAttributeKit & SetUnderline(bool in_state);
12428 
12434  TextAttributeKit & SetSlant(float in_angle);
12435 
12440  TextAttributeKit & SetLineSpacing(float in_multiplier);
12441 
12446  TextAttributeKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
12447 
12452  TextAttributeKit & SetRotation(float in_angle);
12453 
12459  TextAttributeKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
12460 
12466  TextAttributeKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
12467 
12474  TextAttributeKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
12475 
12482 
12492  TextAttributeKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
12493 
12503  TextAttributeKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
12504 
12509  TextAttributeKit & SetSize(float in_size, Text::SizeUnits in_units);
12510 
12517  TextAttributeKit & SetFont(char const * in_name);
12518 
12522  TextAttributeKit & SetTransform(Text::Transform in_trans);
12523 
12527  TextAttributeKit & SetRenderer(Text::Renderer in_rend);
12528 
12533  TextAttributeKit & SetPreference(Text::Preference in_pref);
12534 
12542  TextAttributeKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
12543 
12548  TextAttributeKit & SetPath(Vector const & in_path);
12549 
12557  TextAttributeKit & SetSpacing(float in_multiplier);
12558 
12559 
12562  TextAttributeKit & UnsetAlignment();
12563 
12566  TextAttributeKit & UnsetBold();
12567 
12570  TextAttributeKit & UnsetItalic();
12571 
12574  TextAttributeKit & UnsetOverline();
12575 
12578  TextAttributeKit & UnsetStrikethrough();
12579 
12582  TextAttributeKit & UnsetUnderline();
12583 
12586  TextAttributeKit & UnsetSlant();
12587 
12590  TextAttributeKit & UnsetLineSpacing();
12591 
12594  TextAttributeKit & UnsetRotation();
12595 
12598  TextAttributeKit & UnsetExtraSpace();
12599 
12602  TextAttributeKit & UnsetGreeking();
12603 
12606  TextAttributeKit & UnsetSizeTolerance();
12607 
12610  TextAttributeKit & UnsetSize();
12611 
12614  TextAttributeKit & UnsetFont();
12615 
12618  TextAttributeKit & UnsetTransform();
12619 
12622  TextAttributeKit & UnsetRenderer();
12623 
12626  TextAttributeKit & UnsetPreference();
12627 
12630  TextAttributeKit & UnsetPath();
12631 
12634  TextAttributeKit & UnsetSpacing();
12635 
12638  TextAttributeKit & UnsetEverything();
12639 
12640 
12646  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
12647 
12651  bool ShowBold(bool & out_state) const;
12652 
12656  bool ShowItalic(bool & out_state) const;
12657 
12661  bool ShowOverline(bool & out_state) const;
12662 
12666  bool ShowStrikethrough(bool & out_state) const;
12667 
12671  bool ShowUnderline(bool & out_state) const;
12672 
12676  bool ShowSlant(float & out_angle) const;
12677 
12681  bool ShowLineSpacing(float & out_multiplier) const;
12682 
12687  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
12688 
12694  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
12695 
12702  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
12703 
12709  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
12710 
12715  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
12716 
12720  bool ShowFont(UTF8 & out_name) const;
12721 
12725  bool ShowTransform(Text::Transform & out_trans) const;
12726 
12730  bool ShowRenderer(Text::Renderer & out_rend) const;
12731 
12738  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
12739 
12743  bool ShowPath(Vector & out_path) const;
12744 
12748  bool ShowSpacing(float & out_multiplier) const;
12749 };
12750 
12756 class HPS_API TextAttributeControl : public Control
12757 {
12758 public:
12759 
12761  explicit TextAttributeControl(SegmentKey & in_seg);
12762 
12764  TextAttributeControl(TextAttributeControl const & in_that);
12765 
12770 
12774  TextAttributeControl & operator=(TextAttributeControl && in_that);
12775 
12778 
12779  Type ObjectType() const {return Type::TextAttributeControl;};
12780 
12782  TextAttributeControl & operator=(TextAttributeControl const & in_that);
12783 
12784 
12791 
12796  TextAttributeControl & SetBold(bool in_state);
12797 
12802  TextAttributeControl & SetItalic(bool in_state);
12803 
12807  TextAttributeControl & SetOverline(bool in_state);
12808 
12812  TextAttributeControl & SetStrikethrough(bool in_state);
12813 
12817  TextAttributeControl & SetUnderline(bool in_state);
12818 
12824  TextAttributeControl & SetSlant(float in_angle);
12825 
12830  TextAttributeControl & SetLineSpacing(float in_multiplier);
12831 
12836  TextAttributeControl & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
12837 
12842  TextAttributeControl & SetRotation(float in_angle);
12843 
12849  TextAttributeControl & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
12850 
12856  TextAttributeControl & SetExtraSpace(float in_size, Text::SizeUnits in_units);
12857 
12864  TextAttributeControl & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
12865 
12872 
12882  TextAttributeControl & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
12883 
12893  TextAttributeControl & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
12894 
12899  TextAttributeControl & SetSize(float in_size, Text::SizeUnits in_units);
12900 
12907  TextAttributeControl & SetFont(char const * in_name);
12908 
12912  TextAttributeControl & SetTransform(Text::Transform in_trans);
12913 
12917  TextAttributeControl & SetRenderer(Text::Renderer in_rend);
12918 
12923  TextAttributeControl & SetPreference(Text::Preference in_pref);
12924 
12932  TextAttributeControl & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
12933 
12938  TextAttributeControl & SetPath(Vector const & in_path);
12939 
12947  TextAttributeControl & SetSpacing(float in_multiplier);
12948 
12949 
12952  TextAttributeControl & UnsetAlignment();
12953 
12956  TextAttributeControl & UnsetBold();
12957 
12960  TextAttributeControl & UnsetItalic();
12961 
12964  TextAttributeControl & UnsetOverline();
12965 
12968  TextAttributeControl & UnsetStrikethrough();
12969 
12972  TextAttributeControl & UnsetUnderline();
12973 
12976  TextAttributeControl & UnsetSlant();
12977 
12980  TextAttributeControl & UnsetLineSpacing();
12981 
12984  TextAttributeControl & UnsetRotation();
12985 
12988  TextAttributeControl & UnsetExtraSpace();
12989 
12992  TextAttributeControl & UnsetGreeking();
12993 
12996  TextAttributeControl & UnsetSizeTolerance();
12997 
13000  TextAttributeControl & UnsetSize();
13001 
13004  TextAttributeControl & UnsetFont();
13005 
13008  TextAttributeControl & UnsetTransform();
13009 
13012  TextAttributeControl & UnsetRenderer();
13013 
13016  TextAttributeControl & UnsetPreference();
13017 
13020  TextAttributeControl & UnsetPath();
13021 
13024  TextAttributeControl & UnsetSpacing();
13025 
13028  TextAttributeControl & UnsetEverything();
13029 
13030 
13036  bool ShowAlignment(Text::Alignment & out_align, Text::ReferenceFrame & out_ref, Text::Justification & out_justify) const;
13037 
13041  bool ShowBold(bool & out_state) const;
13042 
13046  bool ShowItalic(bool & out_state) const;
13047 
13051  bool ShowOverline(bool & out_state) const;
13052 
13056  bool ShowStrikethrough(bool & out_state) const;
13057 
13061  bool ShowUnderline(bool & out_state) const;
13062 
13066  bool ShowSlant(float & out_angle) const;
13067 
13071  bool ShowLineSpacing(float & out_multiplier) const;
13072 
13077  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
13078 
13084  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
13085 
13092  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
13093 
13099  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
13100 
13105  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
13106 
13110  bool ShowFont(UTF8 & out_name) const;
13111 
13115  bool ShowTransform(Text::Transform & out_trans) const;
13116 
13120  bool ShowRenderer(Text::Renderer & out_rend) const;
13121 
13128  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
13129 
13133  bool ShowPath(Vector & out_path) const;
13134 
13138  bool ShowSpacing(float & out_multiplier) const;
13139 
13140 private:
13143 };
13144 
13145 
13146 
13147 
13148 
13150 class HPS_API LineAttributeKit : public Object
13151 {
13152 public:
13153 
13155  LineAttributeKit();
13156 
13159  LineAttributeKit(LineAttributeKit const & in_kit);
13160 
13164  LineAttributeKit(LineAttributeKit && in_that);
13165 
13169  LineAttributeKit & operator=(LineAttributeKit && in_that);
13170 
13172  virtual ~LineAttributeKit();
13173 
13174  Type ObjectType() const {return Type::LineAttributeKit;};
13175 
13179  static LineAttributeKit GetDefault();
13180 
13183  void Set(LineAttributeKit const & in_kit);
13184 
13187  void Show(LineAttributeKit & out_kit) const;
13188 
13192  LineAttributeKit & operator=(LineAttributeKit const & in_kit);
13193 
13196  bool Empty() const;
13197 
13201  bool Equals(LineAttributeKit const & in_kit) const;
13202 
13206  bool operator==(LineAttributeKit const & in_kit) const;
13207 
13211  bool operator!=(LineAttributeKit const & in_kit) const;
13212 
13213 
13217  LineAttributeKit & SetPattern(char const * in_name);
13218 
13223  LineAttributeKit & SetPattern(char const * in_name, LinePatternOptionsKit const & in_options);
13224 
13229  LineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13230 
13231 
13234  LineAttributeKit & UnsetPattern();
13235 
13238  LineAttributeKit & UnsetWeight();
13239 
13242  LineAttributeKit & UnsetEverything();
13243 
13244 
13249  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13250 
13255  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13256 };
13257 
13263 class HPS_API LineAttributeControl : public Control
13264 {
13265 public:
13266 
13268  explicit LineAttributeControl(SegmentKey & in_seg);
13269 
13271  LineAttributeControl(LineAttributeControl const & in_that);
13272 
13277 
13281  LineAttributeControl & operator=(LineAttributeControl && in_that);
13282 
13285 
13286  Type ObjectType() const {return Type::LineAttributeControl;};
13287 
13289  LineAttributeControl & operator=(LineAttributeControl const & in_that);
13290 
13291 
13295  LineAttributeControl & SetPattern(char const * in_pattern);
13296 
13301  LineAttributeControl & SetPattern(char const * in_pattern, LinePatternOptionsKit const & in_options);
13302 
13307  LineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
13308 
13309 
13312  LineAttributeControl & UnsetPattern();
13313 
13316  LineAttributeControl & UnsetWeight();
13317 
13320  LineAttributeControl & UnsetEverything();
13321 
13322 
13327  bool ShowPattern(UTF8 & out_pattern, LinePatternOptionsKit & out_options) const;
13328 
13333  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
13334 
13335 private:
13338 };
13339 
13340 
13341 
13343 class HPS_API EdgeAttributeKit : public Object
13344 {
13345 public:
13346 
13348  EdgeAttributeKit();
13349 
13352  EdgeAttributeKit(EdgeAttributeKit const & in_kit);
13353 
13357  EdgeAttributeKit(EdgeAttributeKit && in_that);
13358 
13362  EdgeAttributeKit & operator=(EdgeAttributeKit && in_that);
13363 
13365  virtual ~EdgeAttributeKit();
13366 
13367  Type ObjectType() const {return Type::EdgeAttributeKit;};
13368 
13372  static EdgeAttributeKit GetDefault();
13373 
13376  void Set(EdgeAttributeKit const & in_kit);
13377 
13380  void Show(EdgeAttributeKit & out_kit) const;
13381 
13385  EdgeAttributeKit & operator=(EdgeAttributeKit const & in_kit);
13386 
13389  bool Empty() const;
13390 
13394  bool Equals(EdgeAttributeKit const & in_kit) const;
13395 
13399  bool operator==(EdgeAttributeKit const & in_kit) const;
13400 
13404  bool operator!=(EdgeAttributeKit const & in_kit) const;
13405 
13406 
13410  EdgeAttributeKit & SetPattern(char const * in_pattern_name);
13411 
13416  EdgeAttributeKit & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
13417 
13418 
13421  EdgeAttributeKit & UnsetPattern();
13422 
13425  EdgeAttributeKit & UnsetWeight();
13426 
13429  EdgeAttributeKit & UnsetEverything();
13430 
13431 
13435  bool ShowPattern(UTF8 & out_pattern_name) const;
13436 
13441  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
13442 };
13443 
13449 class HPS_API EdgeAttributeControl : public Control
13450 {
13451 public:
13452 
13454  explicit EdgeAttributeControl(SegmentKey & in_seg);
13455 
13457  EdgeAttributeControl(EdgeAttributeControl const & in_that);
13458 
13463 
13467  EdgeAttributeControl & operator=(EdgeAttributeControl && in_that);
13468 
13471 
13472  Type ObjectType() const {return Type::EdgeAttributeControl;};
13473 
13475  EdgeAttributeControl & operator=(EdgeAttributeControl const & in_that);
13476 
13480  EdgeAttributeControl & SetPattern(char const * in_pattern_name);
13481 
13486  EdgeAttributeControl & SetWeight(float in_weight, Edge::SizeUnits in_units = Edge::SizeUnits::ScaleFactor);
13487 
13488 
13491  EdgeAttributeControl & UnsetPattern();
13492 
13495  EdgeAttributeControl & UnsetWeight();
13496 
13499  EdgeAttributeControl & UnsetEverything();
13500 
13501 
13505  bool ShowPattern(UTF8 & out_pattern_name) const;
13506 
13511  bool ShowWeight(float & out_weight, Edge::SizeUnits & out_units) const;
13512 
13513 private:
13516 };
13517 
13518 
13520 class HPS_API CurveAttributeKit : public Object
13521 {
13522 public:
13523 
13526 
13529  CurveAttributeKit(CurveAttributeKit const & in_kit);
13530 
13535 
13539  CurveAttributeKit & operator=(CurveAttributeKit && in_that);
13540 
13542  virtual ~CurveAttributeKit();
13543 
13544  Type ObjectType() const {return Type::CurveAttributeKit;};
13545 
13549  static CurveAttributeKit GetDefault();
13550 
13553  void Set(CurveAttributeKit const & in_kit);
13554 
13557  void Show(CurveAttributeKit & out_kit) const;
13558 
13562  CurveAttributeKit & operator=(CurveAttributeKit const & in_kit);
13563 
13566  bool Empty() const;
13567 
13571  bool Equals(CurveAttributeKit const & in_kit) const;
13572 
13576  bool operator==(CurveAttributeKit const & in_kit) const;
13577 
13581  bool operator!=(CurveAttributeKit const & in_kit) const;
13582 
13583  //Set
13584  CurveAttributeKit & SetBudget(size_t in_budget);
13585 
13592  CurveAttributeKit & SetContinuedBudget(bool in_state, size_t in_budget = 0);
13593 
13600  CurveAttributeKit & SetContinuedBudget(size_t in_budget);
13601 
13602 
13609  CurveAttributeKit & SetViewDependent(bool in_state);
13610 
13614  CurveAttributeKit & SetMaximumDeviation(float in_deviation);
13615 
13620  CurveAttributeKit & SetMaximumAngle(float in_degrees);
13621 
13626  CurveAttributeKit & SetMaximumLength(float in_length);
13627 
13628 
13631  CurveAttributeKit & UnsetBudget();
13632 
13635  CurveAttributeKit & UnsetContinuedBudget();
13636 
13639  CurveAttributeKit & UnsetViewDependent();
13640 
13643  CurveAttributeKit & UnsetMaximumDeviation();
13644 
13647  CurveAttributeKit & UnsetMaximumAngle();
13648 
13651  CurveAttributeKit & UnsetMaximumLength();
13652 
13655  CurveAttributeKit & UnsetEverything();
13656 
13657 
13661  bool ShowBudget(size_t & out_budget) const;
13662 
13667  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
13668 
13672  bool ShowViewDependent(bool & out_state) const;
13673 
13678  bool ShowMaximumDeviation(float & out_deviation) const;
13679 
13684  bool ShowMaximumAngle(float & out_degrees) const;
13685 
13690  bool ShowMaximumLength(float & out_length) const;
13691 };
13692 
13693 
13697 class HPS_API CurveAttributeControl : public Control
13698 {
13699 public:
13700 
13702  explicit CurveAttributeControl(SegmentKey & in_seg);
13703 
13706 
13711 
13715  CurveAttributeControl & operator=(CurveAttributeControl && in_that);
13716 
13719 
13720  Type ObjectType() const {return Type::CurveAttributeControl;};
13721 
13723  CurveAttributeControl & operator=(CurveAttributeControl const & in_that);
13724 
13728  CurveAttributeControl & SetBudget(size_t in_budget);
13729 
13736  CurveAttributeControl & SetContinuedBudget(bool in_state, size_t in_budget = 0);
13737 
13744  CurveAttributeControl & SetContinuedBudget(size_t in_budget);
13745 
13752  CurveAttributeControl & SetViewDependent(bool in_state);
13753 
13757  CurveAttributeControl & SetMaximumDeviation(float in_deviation);
13758 
13763  CurveAttributeControl & SetMaximumAngle(float in_degrees);
13764 
13769  CurveAttributeControl & SetMaximumLength(float in_length);
13770 
13771 
13774  CurveAttributeControl & UnsetBudget();
13775 
13778  CurveAttributeControl & UnsetContinuedBudget();
13779 
13782  CurveAttributeControl & UnsetViewDependent();
13783 
13786  CurveAttributeControl & UnsetMaximumDeviation();
13787 
13790  CurveAttributeControl & UnsetMaximumAngle();
13791 
13794  CurveAttributeControl & UnsetMaximumLength();
13795 
13798  CurveAttributeControl & UnsetEverything();
13799 
13800 
13804  bool ShowBudget(size_t & out_budget) const;
13805 
13810  bool ShowContinuedBudget(bool & out_state, size_t & out_budget) const;
13811 
13815  bool ShowViewDependent(bool & out_state) const;
13816 
13821  bool ShowMaximumDeviation(float & out_deviation) const;
13822 
13827  bool ShowMaximumAngle(float & out_degrees) const;
13828 
13833  bool ShowMaximumLength(float & out_length) const;
13834 
13835 private:
13838 };
13839 
13840 
13841 
13842 
13844 class HPS_API MatrixKit : public Object
13845 {
13846 public:
13847 
13849  MatrixKit();
13850 
13853  MatrixKit(MatrixKit const & in_kit);
13854 
13858  MatrixKit(MatrixKit && in_that);
13859 
13863  MatrixKit & operator=(MatrixKit && in_that);
13864 
13868  MatrixKit(FloatArray const & in_matrix_source);
13869 
13873  MatrixKit(float const in_matrix_source []);
13874 
13877  MatrixKit(Quaternion const & in_quaternion); //implicit conversion from quaternion
13878 
13880  virtual ~MatrixKit();
13881 
13882  Type ObjectType() const {return Type::MatrixKit;};
13883 
13886  static MatrixKit GetDefault();
13887 
13890  void Set(MatrixKit const & in_kit);
13891 
13894  void Show(MatrixKit & out_kit) const;
13895 
13899  MatrixKit & operator=(MatrixKit const & in_kit);
13900 
13903  bool Empty() const;
13904 
13908  bool Equals(MatrixKit const & in_kit) const;
13909 
13913  bool operator==(MatrixKit const & in_kit) const;
13914 
13918  bool operator!=(MatrixKit const & in_kit) const;
13919 
13925  MatrixKit & SetElement(size_t in_row, size_t in_column, float in_value);
13926 
13931  MatrixKit & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
13932 
13936  MatrixKit & SetElements(FloatArray const & in_matrix);
13937 
13942  MatrixKit & SetElements(size_t in_value_count, float const in_values []);
13943 
13944 
13947  MatrixKit & UnsetEverything();
13948 
13949 
13955  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
13956 
13961  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
13962 
13966  bool ShowElements(FloatArray & out_matrix) const;
13967 
13971  bool ShowDeterminant(float & out_determinant) const;
13972 
13976  bool ShowInverse(MatrixKit & out_matrix) const;
13977 
13982  bool ShowAdjoint(MatrixKit & out_matrix) const;
13983 
13984 
13990  MatrixKit & Rotate(float in_x, float in_y, float in_z);
13991 
13996  MatrixKit & RotateOffAxis(Vector const & in_vector, float in_theta);
13997 
14003  MatrixKit & Translate(float in_x, float in_y, float in_z);
14004 
14010  MatrixKit & Scale(float in_x, float in_y, float in_z);
14011 
14015  MatrixKit & Concatenate(MatrixKit const & in_kit);
14016 
14019  MatrixKit & Normalize();
14020 
14023  MatrixKit & Invert();
14024 
14028  MatrixKit & Adjoint();
14029 
14030 
14034  MatrixKit Multiply(MatrixKit const & in_right) const;
14035 
14039  MatrixKit const & MultiplyAndAssign(MatrixKit const & in_right);
14040 
14044  MatrixKit Multiply(float in_scalar) const;
14045 
14049  MatrixKit const & MultiplyAndAssign(float in_scalar);
14050 
14054  MatrixKit operator*(MatrixKit const & in_right) const;
14055 
14059  MatrixKit const & operator*=(MatrixKit const & in_right);
14060 
14064  MatrixKit operator*(float in_scalar) const;
14065 
14069  MatrixKit const & operator*=(float in_scalar);
14070 
14071 
14075  Point Transform(Point const & in_source) const;
14076 
14080  PointArray Transform(PointArray const & in_source) const;
14081 
14086  PointArray Transform(size_t in_count, Point const in_source []) const;
14087 
14091  Vector Transform(Vector const & in_source) const;
14092 
14096  VectorArray Transform(VectorArray const & in_source) const;
14097 
14102  VectorArray Transform(size_t in_count, Vector const in_source []) const;
14103 
14107  Plane Transform(Plane const & in_source) const;
14108 
14112  PlaneArray Transform(PlaneArray const & in_source) const;
14113 
14118  PlaneArray Transform(size_t in_count, Plane const in_source []) const;
14119 };
14120 
14124 class HPS_API ModellingMatrixControl : public Control
14125 {
14126 public:
14127 
14129  explicit ModellingMatrixControl(SegmentKey const & in_seg);
14130 
14132  explicit ModellingMatrixControl(ReferenceKey const & in_ref);
14133 
14136 
14141 
14145  ModellingMatrixControl & operator=(ModellingMatrixControl && in_that);
14146 
14149 
14150  Type ObjectType() const {return Type::ModellingMatrixControl;};
14151 
14153  ModellingMatrixControl & operator=(ModellingMatrixControl const & in_that);
14154 
14160  ModellingMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14161 
14166  ModellingMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14167 
14171  ModellingMatrixControl & SetElements(FloatArray const & in_matrix);
14172 
14177  ModellingMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14178 
14179 
14182  ModellingMatrixControl & UnsetEverything();
14183 
14184 
14190  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14191 
14196  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14197 
14201  bool ShowElements(FloatArray & out_matrix) const;
14202 
14206  bool ShowDeterminant(float & out_determinant) const;
14207 
14211  bool ShowInverse(MatrixKit & out_matrix) const;
14212 
14217  bool ShowAdjoint(MatrixKit & out_matrix) const;
14218 
14224  ModellingMatrixControl & Rotate(float in_x, float in_y, float in_z);
14225 
14230  ModellingMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14231 
14237  ModellingMatrixControl & Translate(float in_x, float in_y, float in_z);
14238 
14244  ModellingMatrixControl & Scale(float in_x, float in_y, float in_z);
14245 
14249  ModellingMatrixControl & Concatenate(MatrixKit const & in_kit);
14250 
14253  ModellingMatrixControl & Normalize();
14254 
14257  ModellingMatrixControl & Invert();
14258 
14262  ModellingMatrixControl & Adjoint();
14263 
14264 private:
14267 };
14268 
14271 class HPS_API TextureMatrixControl : public Control
14272 {
14273 public:
14274 
14276  explicit TextureMatrixControl(SegmentKey & in_seg);
14277 
14279  TextureMatrixControl(const TextureMatrixControl & in_that);
14280 
14285 
14289  TextureMatrixControl & operator=(TextureMatrixControl && in_that);
14290 
14293 
14294  Type ObjectType() const {return Type::TextureMatrixControl;};
14295 
14297  TextureMatrixControl & operator=(TextureMatrixControl const & in_that);
14298 
14299 
14305  TextureMatrixControl & SetElement(size_t in_row, size_t in_column, float in_value);
14306 
14311  TextureMatrixControl & SetElement(size_t in_ordinal_zero_to_fifteen, float in_value);
14312 
14316  TextureMatrixControl & SetElements(FloatArray const & in_matrix);
14317 
14322  TextureMatrixControl & SetElements(size_t in_value_count, float const in_values []);
14323 
14324 
14327  TextureMatrixControl & UnsetEverything();
14328 
14329 
14335  bool ShowElement(size_t in_row, size_t in_column, float & out_value) const;
14336 
14341  bool ShowElement(size_t in_ordinal_zero_to_fifteen, float & out_value) const;
14342 
14346  bool ShowElements(FloatArray & out_matrix) const;
14347 
14351  bool ShowDeterminant(float & out_determinant) const;
14352 
14356  bool ShowInverse(MatrixKit & out_matrix) const;
14357 
14362  bool ShowAdjoint(MatrixKit & out_matrix) const;
14363 
14369  TextureMatrixControl & Rotate(float in_x, float in_y, float in_z);
14370 
14375  TextureMatrixControl & RotateOffAxis(Vector const & in_vector, float in_theta);
14376 
14382  TextureMatrixControl & Translate(float in_x, float in_y, float in_z);
14383 
14389  TextureMatrixControl & Scale(float in_x, float in_y, float in_z);
14390 
14394  TextureMatrixControl & Concatenate(MatrixKit const & in_kit);
14395 
14398  TextureMatrixControl & Normalize();
14399 
14402  TextureMatrixControl & Invert();
14403 
14407  TextureMatrixControl & Adjoint();
14408 
14409 private:
14412 };
14413 
14414 
14417 class HPS_API MaterialMappingKit : public Object
14418 {
14419 public:
14420 
14423 
14426  MaterialMappingKit(MaterialMappingKit const & in_kit);
14427 
14432 
14436  MaterialMappingKit & operator=(MaterialMappingKit && in_that);
14437 
14439  ~MaterialMappingKit();
14440 
14441  Type ObjectType() const {return Type::MaterialMappingKit;};
14442 
14446  static MaterialMappingKit GetDefault();
14447 
14450  void Set(MaterialMappingKit const & in_kit);
14451 
14454  void Show(MaterialMappingKit & out_kit) const;
14455 
14459  MaterialMappingKit & operator=(MaterialMappingKit const & in_kit);
14460 
14463  bool Empty() const;
14464 
14468  bool Equals(MaterialMappingKit const & in_kit) const;
14469 
14473  bool operator==(MaterialMappingKit const & in_kit) const;
14474 
14478  bool operator!=(MaterialMappingKit const & in_kit) const;
14479 
14480  //Set
14481 
14485  MaterialMappingKit & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
14486 
14492  MaterialMappingKit & SetAmbientLightUpMaterialByIndex(float in_material_index);
14493 
14494 
14498  MaterialMappingKit & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
14499 
14505  MaterialMappingKit & SetAmbientLightDownMaterialByIndex(float in_material_index);
14506 
14512  MaterialMappingKit & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14513 
14518  MaterialMappingKit & SetBackFaceAlpha(float in_alpha);
14519 
14526  MaterialMappingKit & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14527 
14536  MaterialMappingKit & SetBackFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14537 
14541  MaterialMappingKit & SetBackFaceGloss(float in_value);
14542 
14546  MaterialMappingKit & SetBackFaceMaterial(MaterialKit const & in_material);
14547 
14552  MaterialMappingKit & SetBackFaceMaterialByIndex(float in_material_index);
14553 
14559  MaterialMappingKit & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14560 
14565  MaterialMappingKit & SetFrontFaceAlpha(float in_alpha);
14566 
14573  MaterialMappingKit & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14574 
14583  MaterialMappingKit & SetFrontFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14584 
14588  MaterialMappingKit & SetFrontFaceGloss(float in_value);
14589 
14593  MaterialMappingKit & SetFrontFaceMaterial(MaterialKit const & in_material);
14594 
14599  MaterialMappingKit & SetFrontFaceMaterialByIndex(float in_material_index);
14600 
14601 
14605  MaterialMappingKit & SetCutEdgeColor(RGBAColor const & in_rgba_color);
14606 
14612  MaterialMappingKit & SetCutEdgeMaterialByIndex(float in_material_index);
14613 
14619  MaterialMappingKit & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14620 
14625  MaterialMappingKit & SetCutFaceAlpha(float in_alpha);
14626 
14633  MaterialMappingKit & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14634 
14643  MaterialMappingKit & SetCutFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14644 
14648  MaterialMappingKit & SetCutFaceGloss(float in_value);
14649 
14653  MaterialMappingKit & SetCutFaceMaterial(MaterialKit const & in_material);
14654 
14659  MaterialMappingKit & SetCutFaceMaterialByIndex(float in_material_index);
14660 
14665  MaterialMappingKit & SetEdgeAlpha(float in_alpha);
14666 
14672  MaterialMappingKit & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14673 
14680  MaterialMappingKit & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14681 
14690  MaterialMappingKit & SetEdgeModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14691 
14695  MaterialMappingKit & SetEdgeGloss(float in_value);
14696 
14700  MaterialMappingKit & SetEdgeMaterial(MaterialKit const & in_material);
14701 
14706  MaterialMappingKit & SetEdgeMaterialByIndex(float in_material_index);
14707 
14712  MaterialMappingKit & SetFaceAlpha(float in_alpha);
14713 
14719  MaterialMappingKit & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14720 
14727  MaterialMappingKit & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14728 
14737  MaterialMappingKit & SetFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14738 
14742  MaterialMappingKit & SetFaceGloss(float in_value);
14743 
14747  MaterialMappingKit & SetFaceMaterial(MaterialKit const & in_material);
14748 
14753  MaterialMappingKit & SetFaceMaterialByIndex(float in_material_index);
14754 
14758  MaterialMappingKit & SetFaceShader(char const * in_shader_name);
14759 
14760 
14761 
14762 
14763 
14767  MaterialMappingKit & SetLightColor(RGBAColor const & in_rgba_color);
14768 
14774  MaterialMappingKit & SetLightMaterialByIndex(float in_material_index);
14775 
14776 
14780  MaterialMappingKit & SetLineColor(RGBAColor const & in_rgba_color);
14781 
14787  MaterialMappingKit & SetLineMaterialByIndex(float in_material_index);
14788 
14789 
14793  MaterialMappingKit & SetMarkerColor(RGBAColor const & in_rgba_color);
14794 
14800  MaterialMappingKit & SetMarkerMaterialByIndex(float in_material_index);
14801 
14802 
14806  MaterialMappingKit & SetTextColor(RGBAColor const & in_rgba_color);
14807 
14813  MaterialMappingKit & SetTextMaterialByIndex(float in_material_index);
14814 
14819  MaterialMappingKit & SetVertexAlpha(float in_alpha);
14820 
14826  MaterialMappingKit & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
14827 
14834  MaterialMappingKit & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14835 
14844  MaterialMappingKit & SetVertexModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
14845 
14849  MaterialMappingKit & SetVertexGloss(float in_value);
14850 
14854  MaterialMappingKit & SetVertexMaterial(MaterialKit const & in_material);
14855 
14860  MaterialMappingKit & SetVertexMaterialByIndex(float in_material_index);
14861 
14865  MaterialMappingKit & SetVertexShader(char const * in_shader_name);
14866 
14867 
14871  MaterialMappingKit & SetWindowColor(RGBAColor const & in_rgba_color);
14872 
14878  MaterialMappingKit & SetWindowMaterialByIndex(float in_material_index);
14879 
14880 
14884  MaterialMappingKit & SetWindowContrastColor(RGBAColor const & in_rgba_color);
14885 
14891  MaterialMappingKit & SetWindowContrastMaterialByIndex(float in_material_index);
14892 
14893  //Aggregate Sets
14894 
14898  MaterialMappingKit & SetCutGeometryColor(RGBAColor const & in_rgba_color);
14899 
14904  MaterialMappingKit & SetCutGeometryMaterialByIndex(float in_color_index);
14905 
14906 
14910  MaterialMappingKit & SetAmbientLightColor(RGBAColor const & in_rgba_color);
14911 
14917  MaterialMappingKit & SetAmbientLightMaterialByIndex(float in_material_index);
14918 
14919 
14920  //Unset
14921 
14924  MaterialMappingKit & UnsetAmbientLightUpColor();
14925 
14926 
14929  MaterialMappingKit & UnsetAmbientLightDownColor();
14930 
14931 
14934  MaterialMappingKit & UnsetBackFaceMaterial();
14935 
14938  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel);
14939 
14942  MaterialMappingKit & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
14943 
14946  MaterialMappingKit & UnsetFrontFaceMaterial();
14947 
14950  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel);
14951 
14954  MaterialMappingKit & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
14955 
14956 
14957 
14960  MaterialMappingKit & UnsetCutEdgeColor();
14961 
14962 
14965  MaterialMappingKit & UnsetCutFaceMaterial();
14966 
14969  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel);
14970 
14973  MaterialMappingKit & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
14974 
14975 
14978  MaterialMappingKit & UnsetEdgeMaterial();
14979 
14982  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel);
14983 
14986  MaterialMappingKit & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
14987 
14988 
14991  MaterialMappingKit & UnsetFaceMaterial();
14992 
14995  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel);
14996 
14999  MaterialMappingKit & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
15000 
15001 
15004  MaterialMappingKit & UnsetLightColor();
15005 
15006 
15009  MaterialMappingKit & UnsetLineColor();
15010 
15011 
15014  MaterialMappingKit & UnsetMarkerColor();
15015 
15016 
15019  MaterialMappingKit & UnsetTextColor();
15020 
15021 
15024  MaterialMappingKit & UnsetVertexMaterial();
15025 
15028  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel);
15029 
15032  MaterialMappingKit & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
15033 
15034 
15037  MaterialMappingKit & UnsetWindowColor();
15038 
15039 
15042  MaterialMappingKit & UnsetWindowContrastColor();
15043 
15044 
15045  //Aggregate Unsets
15046 
15049  MaterialMappingKit & UnsetCutGeometryColor();
15050 
15053  MaterialMappingKit & UnsetAmbientLightColor();
15054 
15057  MaterialMappingKit & UnsetEverything();
15058 
15059 
15060  //Show
15061 
15067  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15068 
15074  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15075 
15076 
15084  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15085 
15094  bool ShowBackFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15095 
15101  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15102 
15103 
15111  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15112 
15121  bool ShowFrontFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15122 
15128  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15129 
15130 
15131 
15137  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15138 
15139 
15147  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15148 
15157  bool ShowCutFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15158 
15164  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15165 
15166 
15174  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15175 
15184  bool ShowEdgeChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15185 
15191  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15192 
15193 
15201  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15202 
15211  bool ShowFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15212 
15218  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15219 
15220 
15226  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15227 
15228 
15234  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15235 
15236 
15242  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15243 
15244 
15250  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15251 
15252 
15260  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15261 
15270  bool ShowVertexChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15271 
15277  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15278 
15279 
15285  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15286 
15287 
15293  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15294 };
15295 
15296 
15302 class HPS_API MaterialMappingControl : public Control
15303 {
15304 public:
15305 
15307  explicit MaterialMappingControl(SegmentKey & in_seg);
15308 
15311 
15316 
15320  MaterialMappingControl & operator=(MaterialMappingControl && in_that);
15321 
15324 
15325  Type ObjectType() const {return Type::MaterialMappingControl;};
15326 
15328  MaterialMappingControl & operator=(MaterialMappingControl const & in_that);
15329 
15330  //Set
15331 
15335  MaterialMappingControl & SetAmbientLightUpColor(RGBAColor const & in_rgba_color);
15336 
15342  MaterialMappingControl & SetAmbientLightUpMaterialByIndex(float in_material_index);
15343 
15344 
15348  MaterialMappingControl & SetAmbientLightDownColor(RGBAColor const & in_rgba_color);
15349 
15355  MaterialMappingControl & SetAmbientLightDownMaterialByIndex(float in_material_index);
15356 
15361  MaterialMappingControl & SetBackFaceAlpha(float in_alpha);
15362 
15368  MaterialMappingControl & SetBackFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15369 
15376  MaterialMappingControl & SetBackFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15377 
15386  MaterialMappingControl & SetBackFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15387 
15391  MaterialMappingControl & SetBackFaceGloss(float in_value);
15392 
15396  MaterialMappingControl & SetBackFaceMaterial(MaterialKit const & in_material);
15397 
15402  MaterialMappingControl & SetBackFaceMaterialByIndex(float in_material_index);
15403 
15404 
15409  MaterialMappingControl & SetFrontFaceAlpha(float in_alpha);
15410 
15416  MaterialMappingControl & SetFrontFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15417 
15424  MaterialMappingControl & SetFrontFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15425 
15434  MaterialMappingControl & SetFrontFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15435 
15439  MaterialMappingControl & SetFrontFaceGloss(float in_value);
15440 
15444  MaterialMappingControl & SetFrontFaceMaterial(MaterialKit const & in_material);
15445 
15450  MaterialMappingControl & SetFrontFaceMaterialByIndex(float in_material_index);
15451 
15452 
15456  MaterialMappingControl & SetCutEdgeColor(RGBAColor const & in_rgba_color);
15457 
15463  MaterialMappingControl & SetCutEdgeMaterialByIndex(float in_material_index);
15464 
15469  MaterialMappingControl & SetCutFaceAlpha(float in_alpha);
15470 
15476  MaterialMappingControl & SetCutFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15477 
15484  MaterialMappingControl & SetCutFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15485 
15494  MaterialMappingControl & SetCutFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15495 
15499  MaterialMappingControl & SetCutFaceGloss(float in_value);
15500 
15504  MaterialMappingControl & SetCutFaceMaterial(MaterialKit const & in_material);
15505 
15510  MaterialMappingControl & SetCutFaceMaterialByIndex(float in_material_index);
15511 
15516  MaterialMappingControl & SetEdgeAlpha(float in_alpha);
15517 
15523  MaterialMappingControl & SetEdgeColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15524 
15531  MaterialMappingControl & SetEdgeTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15532 
15541  MaterialMappingControl & SetEdgeModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15542 
15546  MaterialMappingControl & SetEdgeGloss(float in_value);
15547 
15551  MaterialMappingControl & SetEdgeMaterial(MaterialKit const & in_material);
15552 
15557  MaterialMappingControl & SetEdgeMaterialByIndex(float in_material_index);
15558 
15564  MaterialMappingControl & SetFaceAlpha(float in_alpha);
15565 
15572  MaterialMappingControl & SetFaceColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15573 
15580  MaterialMappingControl & SetFaceTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15581 
15590  MaterialMappingControl & SetFaceModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15591 
15595  MaterialMappingControl & SetFaceGloss(float in_value);
15596 
15600  MaterialMappingControl & SetFaceMaterial(MaterialKit const & in_material);
15601 
15606  MaterialMappingControl & SetFaceMaterialByIndex(float in_material_index);
15607 
15611  MaterialMappingControl & SetFaceShader(char const * in_shader_name);
15612 
15613 
15617  MaterialMappingControl & SetLightColor(RGBAColor const & in_rgba_color);
15618 
15624  MaterialMappingControl & SetLightMaterialByIndex(float in_material_index);
15625 
15626 
15630  MaterialMappingControl & SetLineColor(RGBAColor const & in_rgba_color);
15631 
15637  MaterialMappingControl & SetLineMaterialByIndex(float in_material_index);
15638 
15639 
15643  MaterialMappingControl & SetMarkerColor(RGBAColor const & in_rgba_color);
15644 
15650  MaterialMappingControl & SetMarkerMaterialByIndex(float in_material_index);
15651 
15652 
15656  MaterialMappingControl & SetTextColor(RGBAColor const & in_rgba_color);
15657 
15663  MaterialMappingControl & SetTextMaterialByIndex(float in_material_index);
15664 
15665 
15670  MaterialMappingControl & SetVertexAlpha(float in_alpha);
15671 
15672 
15678  MaterialMappingControl & SetVertexColor(RGBAColor const & in_rgba_color, Material::Color::Channel in_channel = Material::Color::Channel::DiffuseColor);
15679 
15686  MaterialMappingControl & SetVertexTexture(char const * in_texture_name, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15687 
15696  MaterialMappingControl & SetVertexModulatedTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, Material::Texture::Channel in_channel = Material::Texture::Channel::DiffuseTexture, size_t in_layer = 0);
15697 
15701  MaterialMappingControl & SetVertexGloss(float in_value);
15702 
15706  MaterialMappingControl & SetVertexMaterial(MaterialKit const & in_material);
15707 
15712  MaterialMappingControl & SetVertexMaterialByIndex(float in_material_index);
15713 
15717  MaterialMappingControl & SetVertexShader(char const * in_shader_name);
15718 
15719 
15723  MaterialMappingControl & SetWindowColor(RGBAColor const & in_rgba_color);
15724 
15730  MaterialMappingControl & SetWindowMaterialByIndex(float in_material_index);
15731 
15732 
15736  MaterialMappingControl & SetWindowContrastColor(RGBAColor const & in_rgba_color);
15737 
15743  MaterialMappingControl & SetWindowContrastMaterialByIndex(float in_material_index);
15744 
15745  //Aggregate Sets
15746 
15750  MaterialMappingControl & SetCutGeometryColor(RGBAColor const & in_rgba_color);
15751 
15756  MaterialMappingControl & SetCutGeometryMaterialByIndex(float in_color_index);
15757 
15758 
15762  MaterialMappingControl & SetAmbientLightColor(RGBAColor const & in_rgba_color);
15763 
15769  MaterialMappingControl & SetAmbientLightMaterialByIndex(float in_material_index);
15770 
15771 
15772  //Unset
15773 
15776  MaterialMappingControl & UnsetAmbientLightUpColor();
15777 
15778 
15781  MaterialMappingControl & UnsetAmbientLightDownColor();
15782 
15783 
15786  MaterialMappingControl & UnsetFrontFaceMaterial();
15787 
15790  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel);
15791 
15794  MaterialMappingControl & UnsetFrontFaceChannel(Material::Channel in_channel, size_t in_layer);
15795 
15796 
15799  MaterialMappingControl & UnsetBackFaceMaterial();
15800 
15803  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel);
15804 
15807  MaterialMappingControl & UnsetBackFaceChannel(Material::Channel in_channel, size_t in_layer);
15808 
15809 
15812  MaterialMappingControl & UnsetCutEdgeColor();
15813 
15814 
15817  MaterialMappingControl & UnsetCutFaceMaterial();
15818 
15821  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel);
15822 
15825  MaterialMappingControl & UnsetCutFaceChannel(Material::Channel in_channel, size_t in_layer);
15826 
15827 
15830  MaterialMappingControl & UnsetEdgeMaterial();
15831 
15834  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel);
15835 
15838  MaterialMappingControl & UnsetEdgeChannel(Material::Channel in_channel, size_t in_layer);
15839 
15840 
15843  MaterialMappingControl & UnsetFaceMaterial();
15844 
15847  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel);
15848 
15851  MaterialMappingControl & UnsetFaceChannel(Material::Channel in_channel, size_t in_layer);
15852 
15853 
15856  MaterialMappingControl & UnsetLightColor();
15857 
15858 
15861  MaterialMappingControl & UnsetLineColor();
15862 
15863 
15866  MaterialMappingControl & UnsetMarkerColor();
15867 
15868 
15871  MaterialMappingControl & UnsetTextColor();
15872 
15873 
15876  MaterialMappingControl & UnsetVertexMaterial();
15877 
15880  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel);
15881 
15884  MaterialMappingControl & UnsetVertexChannel(Material::Channel in_channel, size_t in_layer);
15885 
15886 
15889  MaterialMappingControl & UnsetWindowColor();
15890 
15891 
15894  MaterialMappingControl & UnsetWindowContrastColor();
15895 
15896 
15897  //Aggregate Unsets
15898 
15901  MaterialMappingControl & UnsetCutGeometryColor();
15902 
15905  MaterialMappingControl & UnsetAmbientLightColor();
15906 
15909  MaterialMappingControl & UnsetEverything();
15910 
15911 
15912  //Show
15913 
15919  bool ShowAmbientLightUpColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15920 
15921 
15927  bool ShowAmbientLightDownColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15928 
15929 
15937  bool ShowBackFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15938 
15947  bool ShowBackFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15948 
15954  bool ShowBackFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15955 
15956 
15964  bool ShowFrontFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15965 
15974  bool ShowFrontFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
15975 
15981  bool ShowFrontFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
15982 
15983 
15989  bool ShowCutEdgeColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
15990 
15991 
15999  bool ShowCutFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16000 
16009  bool ShowCutFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16010 
16016  bool ShowCutFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16017 
16018 
16026  bool ShowEdgeChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16027 
16036  bool ShowEdgeChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16037 
16043  bool ShowEdgeMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16044 
16045 
16053  bool ShowFaceChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16054 
16063  bool ShowFaceChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16064 
16070  bool ShowFaceMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16071 
16072 
16078  bool ShowLightColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16079 
16080 
16086  bool ShowLineColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16087 
16088 
16094  bool ShowMarkerColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16095 
16096 
16102  bool ShowTextColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16103 
16104 
16112  bool ShowVertexChannel(Material::Channel in_channel, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16113 
16122  bool ShowVertexChannel(Material::Channel in_channel, size_t in_layer, Material::Type & out_type, RGBAColor & out_rgba_color, UTF8 & out_texture_name, float & out_value) const;
16123 
16129  bool ShowVertexMaterial(Material::Type & out_type, MaterialKit & out_kit, float & out_value) const;
16130 
16131 
16137  bool ShowWindowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16138 
16139 
16145  bool ShowWindowContrastColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_value) const;
16146 
16147 private:
16149 };
16150 
16151 
16154 class HPS_API PortfolioControl : public Control
16155 {
16156 public:
16158  explicit PortfolioControl(SegmentKey & in_seg);
16159 
16161  PortfolioControl(PortfolioControl const & in_that);
16162 
16166  PortfolioControl(PortfolioControl && in_that);
16167 
16171  PortfolioControl & operator=(PortfolioControl && in_that);
16172 
16174  ~PortfolioControl();
16175 
16176  Type ObjectType() const { return Type::PortfolioControl; };
16177 
16179  PortfolioControl & operator=(PortfolioControl const & in_that);
16180 
16182  size_t GetCount() const;
16183 
16184 
16189  PortfolioControl & Push(PortfolioKey const & in_portfolio);
16190 
16193  bool Pop();
16194 
16198  bool Pop(PortfolioKey & out_portfolio);
16199 
16200 
16204  PortfolioControl & Set(PortfolioKey const & in_portfolio);
16205 
16209  PortfolioControl & Set(PortfolioKeyArray const & in_portfolios);
16210 
16215  PortfolioControl & Set(size_t in_count, PortfolioKey const in_portfolios[]);
16216 
16217 
16220  PortfolioControl & UnsetTop();
16221 
16224  PortfolioControl & UnsetEverything();
16225 
16226 
16230  bool ShowTop(PortfolioKey & out_portfolio) const;
16231 
16235  bool Show(PortfolioKeyArray & out_portfolios) const;
16236 
16237 private:
16238  PortfolioControl();
16239 };
16240 
16241 
16242 
16245 class HPS_API StyleControl : public Control
16246 {
16247 public:
16249  explicit StyleControl(SegmentKey & in_seg);
16250 
16252  StyleControl(StyleControl const & in_that);
16253 
16257  StyleControl(StyleControl && in_that);
16258 
16262  StyleControl & operator=(StyleControl && in_that);
16263 
16265  ~StyleControl();
16266 
16267  Type ObjectType() const { return Type::StyleControl; };
16268 
16270  StyleControl & operator=(StyleControl const & in_that);
16271 
16273  size_t GetCount() const;
16274 
16275 
16277  StyleKey PushNamed(char const * in_style_name);
16278 
16280  StyleKey PushNamed(char const * in_style_name, Condition const & in_condition);
16281 
16283  StyleKey AppendNamed(char const * in_style_name, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16284 
16288  StyleKey PushSegment(SegmentKey const & in_style_source);
16289 
16293  StyleKey PushSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16294 
16297  StyleKey AppendSegment(SegmentKey const & in_style_source, Condition const & in_condition, Style::AppendMode mode = Style::AppendMode::Or);
16298 
16299 
16300 
16303  bool Pop();
16304 
16311  bool Pop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition);
16312 
16316  void Flush(SegmentKey const & in_style_source);
16317 
16324  void Flush(SegmentKey const & in_style_source, Condition const & in_condition);
16325 
16329  void Flush(char const * in_style_name);
16330 
16337  void Flush(char const * in_style_name, Condition const & in_condition);
16338 
16339 
16342  StyleKey SetNamed(char const * in_style_name);
16343 
16347  StyleKey SetNamed(char const * in_style_name, Condition const & in_condition);
16348 
16349 
16352  StyleKey SetSegment(SegmentKey const & in_style_source);
16353 
16357  StyleKey SetSegment(SegmentKey const & in_style_source, Condition const & in_condition);
16358 
16359 
16365  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names, ConditionArray const & in_conditions);
16366 
16371  void Set(StyleTypeArray const & in_types, SegmentKeyArray const & in_segment_sources, UTF8Array const & in_style_names);
16372 
16379  void Set(size_t in_count, Style::Type const in_types[], SegmentKey const in_segment_sources[], UTF8 const in_style_names[], Condition const in_conditions[]);
16380 
16381 
16382 
16384  void UnsetTop();
16385 
16387  void UnsetAllSegment();
16388 
16390  void UnsetAllNamed();
16391 
16393  void UnsetEverything();
16394 
16395 
16402  bool ShowTop(Style::Type & out_type, SegmentKey & out_segment_source, UTF8 & out_style_name, Condition & out_condition) const;
16403 
16407  bool ShowTop(StyleKey & out_style) const;
16408 
16415  bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions) const;
16416 
16420  bool Show(StyleKeyArray & out_styles) const;
16421 
16426  bool ShowAllSegment(SegmentKeyArray & out_segments, ConditionArray & out_conditions) const;
16427 
16431  bool ShowAllSegment(StyleKeyArray & out_styles) const;
16432 
16437  bool ShowAllNamed(UTF8Array & out_names, ConditionArray & out_conditions) const;
16438 
16442  bool ShowAllNamed(StyleKeyArray & out_styles) const;
16443 
16444 private:
16445  StyleControl();
16446 };
16447 
16448 
16451 class HPS_API ConditionControl : public Control
16452 {
16453 public:
16455  explicit ConditionControl(SegmentKey & in_seg);
16456 
16458  ConditionControl(ConditionControl const & in_that);
16459 
16463  ConditionControl(ConditionControl && in_that);
16464 
16468  ConditionControl & operator=(ConditionControl && in_that);
16469 
16471  ~ConditionControl();
16472 
16473 
16474  Type ObjectType() const { return Type::ConditionControl; };
16475 
16477  ConditionControl & operator=(ConditionControl const & in_that);
16478 
16481  size_t GetCount() const;
16482 
16486  ConditionControl & AddCondition(char const * in_condition);
16487 
16488 
16492  ConditionControl & SetCondition(char const * in_condition);
16493 
16497  ConditionControl & SetConditions(UTF8Array const & in_conditions);
16498 
16503  ConditionControl & SetConditions(size_t in_count, UTF8 const in_conditions []);
16504 
16505 
16509  ConditionControl & UnsetCondition(char const * in_condition);
16510 
16513  ConditionControl & UnsetEverything();
16514 
16515 
16519  bool ShowCondition(char const * in_condition) const;
16520 
16524  bool ShowConditions(UTF8Array & out_conditions) const;
16525 
16526 private:
16528  ConditionControl();
16529 };
16530 
16531 
16534 class HPS_API MaterialKit : public Object
16535 {
16536 public:
16537 
16539  MaterialKit();
16540 
16543  MaterialKit(MaterialKit const & in_kit);
16544 
16548  MaterialKit(MaterialKit && in_that);
16549 
16553  MaterialKit & operator=(MaterialKit && in_that);
16554 
16556  ~MaterialKit();
16557 
16558  Type ObjectType() const {return Type::MaterialKit;};
16559 
16562  void Set(MaterialKit const & in_kit);
16563 
16566  void Show(MaterialKit & out_kit) const;
16567 
16571  MaterialKit & operator=(MaterialKit const & in_kit);
16572 
16575  bool Empty() const;
16576 
16580  bool Equals(MaterialKit const & in_kit) const;
16581 
16585  bool operator==(MaterialKit const & in_kit) const;
16586 
16590  bool operator!=(MaterialKit const & in_kit) const;
16591 
16592 
16593  //Set
16594 
16598  MaterialKit & SetDiffuse(RGBColor const & in_color);
16599 
16603  MaterialKit & SetDiffuse(RGBAColor const & in_color);
16604 
16608  MaterialKit & SetDiffuseColor(RGBColor const & in_color);
16609 
16613  MaterialKit & SetDiffuseColor(RGBAColor const & in_color);
16614 
16619  MaterialKit & SetDiffuseAlpha(float in_alpha);
16620 
16627  MaterialKit & SetDiffuseTexture(char const * in_texture_name, size_t in_layer=0);
16628 
16636  MaterialKit & SetDiffuseTexture(char const * in_texture_name, RGBAColor const & in_modulating_color, size_t in_layer=0);
16637 
16642  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names);
16643 
16649  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names []);
16650 
16657  MaterialKit & SetDiffuseTexture(UTF8Array const & in_texture_names, RGBAColorArray const & in_modulating_colors);
16658 
16666  MaterialKit & SetDiffuseTexture(size_t in_count, UTF8 const in_texture_names [], RGBAColor const in_modulating_colors []);
16667 
16668 
16672  MaterialKit & SetShader(char const * in_shader_name);
16673 
16674 
16675 
16679  MaterialKit & SetSpecular(RGBAColor const & in_rgba_color);
16680 
16684  MaterialKit & SetSpecular(char const * in_texture_name);
16685 
16690  MaterialKit & SetSpecular(char const * in_texture_name, RGBAColor const & in_modulating_color);
16691 
16692 
16693 
16697  MaterialKit & SetMirror(RGBAColor const & in_rgba_color);
16698 
16702  MaterialKit & SetMirror(char const * in_texture_name);
16703 
16708  MaterialKit & SetMirror(char const * in_texture_name, RGBAColor const & in_modulating_color);
16709 
16710 
16711 
16715  MaterialKit & SetTransmission(char const * in_texture_name);
16716 
16721  MaterialKit & SetTransmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
16722 
16723 
16724 
16728  MaterialKit & SetEmission(RGBAColor const & in_rgba_color);
16729 
16733  MaterialKit & SetEmission(char const * in_texture_name);
16734 
16739  MaterialKit & SetEmission(char const * in_texture_name, RGBAColor const & in_modulating_color);
16740 
16741 
16742 
16746  MaterialKit & SetEnvironmentTexture(char const * in_texture_name);
16747 
16752  MaterialKit & SetEnvironmentTexture(char const * in_texture_name, RGBAColor const & in_modulating_color);
16753 
16757  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name);
16758 
16763  MaterialKit & SetEnvironmentCubeMap(char const * in_cubemap_name, RGBAColor const & in_modulating_color);
16764 
16767  MaterialKit & SetEnvironmentTexture();
16768 
16769 
16773  MaterialKit & SetBump(char const * in_texture_name);
16774 
16775 
16776 
16783  MaterialKit & SetGloss(float in_gloss);
16784 
16787  MaterialKit & UnsetDiffuseColorRGB();
16788 
16791  MaterialKit & UnsetDiffuseColor();
16792 
16795  MaterialKit & UnsetDiffuseAlpha();
16796 
16799  MaterialKit & UnsetDiffuseTexture();
16800 
16804  MaterialKit & UnsetDiffuseTexture(size_t in_layer);
16805 
16808  MaterialKit & UnsetShader();
16809 
16812  MaterialKit & UnsetSpecular();
16813 
16816  MaterialKit & UnsetMirror();
16817 
16820  MaterialKit & UnsetTransmission();
16821 
16824  MaterialKit & UnsetEmission();
16825 
16828  MaterialKit & UnsetEnvironment();
16829 
16832  MaterialKit & UnsetBump();
16833 
16836  MaterialKit & UnsetGloss();
16837 
16840  MaterialKit & UnsetEverything();
16841 
16842 
16845  bool ShowDiffuse() const;
16846 
16850  bool ShowDiffuseColor(RGBColor & out_rgb_color) const;
16851 
16855  bool ShowDiffuseColor(RGBAColor & out_rgba_color) const;
16856 
16860  bool ShowDiffuseAlpha(float & out_alpha) const;
16861 
16868  bool ShowDiffuseTexture(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16869 
16877  bool ShowDiffuseTexture(size_t in_layer, Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16878 
16885  bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names) const;
16886 
16890  bool ShowShader(UTF8 & out_shader_name) const;
16891 
16900  bool ShowSpecular(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16901 
16910  bool ShowMirror(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16911 
16912 
16913 
16922  bool ShowTransmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16923 
16924 
16933  bool ShowEmission(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16934 
16935 
16944  bool ShowEnvironment(Material::Type & out_type, RGBAColor & out_color, UTF8 & out_texture_name) const;
16945 
16946 
16950  bool ShowBump(UTF8 & out_texture_name) const;
16951 
16956  bool ShowGloss(float & out_gloss) const;
16957 };
16958 
16959 
16961 class HPS_API NURBSSurfaceAttributeKit : public Object
16962 {
16963 public:
16964 
16967 
16971 
16976 
16980  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit && in_that);
16981 
16983  virtual ~NURBSSurfaceAttributeKit();
16984 
16985  Type ObjectType() const {return Type::NURBSSurfaceAttributeKit;};
16986 
16990  static NURBSSurfaceAttributeKit GetDefault();
16991 
16994  void Set(NURBSSurfaceAttributeKit const & in_kit);
16995 
16998  void Show(NURBSSurfaceAttributeKit & out_kit) const;
16999 
17003  NURBSSurfaceAttributeKit & operator=(NURBSSurfaceAttributeKit const & in_kit);
17004 
17007  bool Empty() const;
17008 
17012  bool Equals(NURBSSurfaceAttributeKit const & in_kit) const;
17013 
17017  bool operator==(NURBSSurfaceAttributeKit const & in_kit) const;
17018 
17022  bool operator!=(NURBSSurfaceAttributeKit const & in_kit) const;
17023 
17024 
17028  NURBSSurfaceAttributeKit & SetBudget(size_t in_budget);
17029 
17034  NURBSSurfaceAttributeKit & SetMaximumDeviation(float in_deviation);
17035 
17039  NURBSSurfaceAttributeKit & SetMaximumAngle(float in_degrees);
17040 
17044  NURBSSurfaceAttributeKit & SetMaximumWidth(float in_width);
17045 
17049  NURBSSurfaceAttributeKit & SetTrimBudget(size_t in_budget);
17050 
17055  NURBSSurfaceAttributeKit & SetMaximumTrimDeviation(float in_deviation);
17056 
17057 
17060  NURBSSurfaceAttributeKit & UnsetBudget();
17061 
17064  NURBSSurfaceAttributeKit & UnsetMaximumDeviation();
17065 
17068  NURBSSurfaceAttributeKit & UnsetMaximumAngle();
17069 
17072  NURBSSurfaceAttributeKit & UnsetMaximumWidth();
17073 
17076  NURBSSurfaceAttributeKit & UnsetTrimBudget();
17077 
17080  NURBSSurfaceAttributeKit & UnsetMaximumTrimDeviation();
17081 
17084  NURBSSurfaceAttributeKit & UnsetEverything();
17085 
17089  bool ShowBudget(size_t & out_budget) const;
17090 
17094  bool ShowMaximumDeviation(float & out_deviation) const;
17095 
17099  bool ShowMaximumAngle(float & out_degrees) const;
17100 
17104  bool ShowMaximumWidth(float & out_width) const;
17105 
17109  bool ShowTrimBudget(size_t & out_budget) const;
17110 
17114  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17115 };
17116 
17123 {
17124 public:
17125 
17127  explicit NURBSSurfaceAttributeControl(SegmentKey & in_seg);
17128 
17131 
17136 
17141 
17144 
17145  Type ObjectType() const {return Type::NURBSSurfaceAttributeControl;};
17146 
17148  NURBSSurfaceAttributeControl & operator=(NURBSSurfaceAttributeControl const & in_that);
17149 
17153  NURBSSurfaceAttributeControl & SetBudget(size_t in_budget);
17154 
17159  NURBSSurfaceAttributeControl & SetMaximumDeviation(float in_deviation);
17160 
17164  NURBSSurfaceAttributeControl & SetMaximumAngle(float in_degrees);
17165 
17169  NURBSSurfaceAttributeControl & SetMaximumWidth(float in_width);
17170 
17174  NURBSSurfaceAttributeControl & SetTrimBudget(size_t in_budget);
17175 
17180  NURBSSurfaceAttributeControl & SetMaximumTrimDeviation(float in_deviation);
17181 
17182 
17185  NURBSSurfaceAttributeControl & UnsetBudget();
17186 
17189  NURBSSurfaceAttributeControl & UnsetMaximumDeviation();
17190 
17193  NURBSSurfaceAttributeControl & UnsetMaximumAngle();
17194 
17197  NURBSSurfaceAttributeControl & UnsetMaximumWidth();
17198 
17201  NURBSSurfaceAttributeControl & UnsetTrimBudget();
17202 
17205  NURBSSurfaceAttributeControl & UnsetMaximumTrimDeviation();
17206 
17209  NURBSSurfaceAttributeControl & UnsetEverything();
17210 
17211 
17215  bool ShowBudget(size_t & out_budget) const;
17216 
17220  bool ShowMaximumDeviation(float & out_deviation) const;
17221 
17225  bool ShowMaximumAngle(float & out_degrees) const;
17226 
17230  bool ShowMaximumWidth(float & out_width) const;
17231 
17235  bool ShowTrimBudget(size_t & out_budget) const;
17236 
17240  bool ShowMaximumTrimDeviation(float & out_deviation) const;
17241 
17242 private:
17245 };
17246 
17247 
17248 
17250 class HPS_API PerformanceKit : public Object
17251 {
17252 public:
17253 
17255  PerformanceKit();
17256 
17259  PerformanceKit(PerformanceKit const & in_kit);
17260 
17264  PerformanceKit(PerformanceKit && in_that);
17265 
17269  PerformanceKit & operator=(PerformanceKit && in_that);
17270 
17272  virtual ~PerformanceKit();
17273 
17274  Type ObjectType() const {return Type::PerformanceKit;};
17275 
17279  static PerformanceKit GetDefault();
17280 
17283  void Set(PerformanceKit const & in_kit);
17284 
17287  void Show(PerformanceKit & out_kit) const;
17288 
17292  PerformanceKit & operator=(PerformanceKit const & in_kit);
17293 
17296  bool Empty() const;
17297 
17301  bool Equals(PerformanceKit const & in_kit) const;
17302 
17306  bool operator==(PerformanceKit const & in_kit) const;
17307 
17311  bool operator!=(PerformanceKit const & in_kit) const;
17312 
17313 
17318 
17323  PerformanceKit & SetStaticModel(Performance::StaticModel in_model_type);
17324 
17325 
17328  PerformanceKit & UnsetDisplayLists();
17329 
17332  PerformanceKit & UnsetStaticModel();
17333 
17336  PerformanceKit & UnsetEverything();
17337 
17341  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17342 
17346  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17347 };
17348 
17349 
17355 class HPS_API PerformanceControl : public Control
17356 {
17357 public:
17358 
17360  explicit PerformanceControl(SegmentKey & in_seg);
17361 
17363  PerformanceControl(PerformanceControl const & in_that);
17364 
17369 
17373  PerformanceControl & operator=(PerformanceControl && in_that);
17374 
17376  ~PerformanceControl();
17377 
17378  Type ObjectType() const {return Type::PerformanceControl;};
17379 
17381  PerformanceControl & operator=(PerformanceControl const & in_that);
17382 
17383 
17388 
17393  PerformanceControl & SetStaticModel(Performance::StaticModel in_model_type);
17394 
17395 
17398  PerformanceControl & UnsetDisplayLists();
17399 
17402  PerformanceControl & UnsetStaticModel();
17403 
17406  PerformanceControl & UnsetEverything();
17407 
17408 
17412  bool ShowDisplayLists(Performance::DisplayLists & out_display_list) const;
17413 
17417  bool ShowStaticModel(Performance::StaticModel & out_model_type) const;
17418 
17419 private:
17422 };
17423 
17424 
17425 
17427 class HPS_API HiddenLineAttributeKit : public Object
17428 {
17429 public:
17430 
17433 
17437 
17442 
17446  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit && in_that);
17447 
17449  virtual ~HiddenLineAttributeKit();
17450 
17451  Type ObjectType() const {return Type::HiddenLineAttributeKit;};
17452 
17456  static HiddenLineAttributeKit GetDefault();
17457 
17460  void Set(HiddenLineAttributeKit const & in_kit);
17461 
17464  void Show(HiddenLineAttributeKit & out_kit) const;
17465 
17469  HiddenLineAttributeKit & operator=(HiddenLineAttributeKit const & in_kit);
17470 
17473  bool Empty() const;
17474 
17478  bool Equals(HiddenLineAttributeKit const & in_kit) const;
17479 
17483  bool operator==(HiddenLineAttributeKit const & in_kit) const;
17484 
17488  bool operator!=(HiddenLineAttributeKit const & in_kit) const;
17489 
17490 
17494  HiddenLineAttributeKit & SetColor(RGBAColor const & in_color);
17495 
17501  HiddenLineAttributeKit & SetDimFactor(float in_zero_to_one);
17502 
17512  HiddenLineAttributeKit & SetFaceDisplacement(float in_buckets);
17513 
17517  HiddenLineAttributeKit & SetLinePattern(char const * in_pattern);
17518 
17522  HiddenLineAttributeKit & SetRenderFaces(bool in_state);
17523 
17527  HiddenLineAttributeKit & SetRenderText(bool in_state);
17528 
17533  HiddenLineAttributeKit & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
17534 
17540  HiddenLineAttributeKit & SetSilhouetteCleanup(bool in_state);
17541 
17545  HiddenLineAttributeKit & SetVisibility(bool in_state);
17546 
17551  HiddenLineAttributeKit & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
17552 
17558  HiddenLineAttributeKit & SetTransparencyCutoff(float in_zero_to_one);
17559 
17560 
17563  HiddenLineAttributeKit & UnsetColor();
17564 
17567  HiddenLineAttributeKit & UnsetDimFactor();
17568 
17571  HiddenLineAttributeKit & UnsetFaceDisplacement();
17572 
17575  HiddenLineAttributeKit & UnsetLinePattern();
17576 
17579  HiddenLineAttributeKit & UnsetRenderFaces();
17580 
17583  HiddenLineAttributeKit & UnsetRenderText();
17584 
17587  HiddenLineAttributeKit & UnsetAlgorithm();
17588 
17591  HiddenLineAttributeKit & UnsetSilhouetteCleanup();
17592 
17595  HiddenLineAttributeKit & UnsetVisibility();
17596 
17599  HiddenLineAttributeKit & UnsetWeight();
17600 
17603  HiddenLineAttributeKit & UnsetTransparencyCutoff();
17604 
17607  HiddenLineAttributeKit & UnsetEverything();
17608 
17609 
17613  bool ShowColor(RGBAColor & out_color) const;
17614 
17618  bool ShowDimFactor(float & out_zero_to_one) const;
17619 
17623  bool ShowFaceDisplacement(float & out_buckets) const;
17624 
17628  bool ShowLinePattern(UTF8 & out_pattern) const;
17629 
17633  bool ShowRenderFaces(bool & out_state) const;
17634 
17638  bool ShowRenderText(bool & out_state) const;
17639 
17643  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
17644 
17648  bool ShowSilhouetteCleanup(bool & out_state) const;
17649 
17653  bool ShowVisibility(bool & out_state) const;
17654 
17659  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
17660 
17664  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
17665 };
17666 
17667 
17673 class HPS_API HiddenLineAttributeControl : public Control
17674 {
17675 public:
17676 
17678  explicit HiddenLineAttributeControl(SegmentKey & in_seg);
17679 
17682 
17687 
17692 
17695 
17696  Type ObjectType() const {return Type::HiddenLineAttributeControl;};
17697 
17699  HiddenLineAttributeControl & operator=(HiddenLineAttributeControl const & in_that);
17700 
17704  HiddenLineAttributeControl & SetColor(RGBAColor const & in_color);
17705 
17711  HiddenLineAttributeControl & SetDimFactor(float in_zero_to_one);
17712 
17722  HiddenLineAttributeControl & SetFaceDisplacement(float in_buckets);
17723 
17727  HiddenLineAttributeControl & SetLinePattern(char const * in_pattern);
17728 
17732  HiddenLineAttributeControl & SetRenderFaces(bool in_state);
17733 
17737  HiddenLineAttributeControl & SetRenderText(bool in_state);
17738 
17743  HiddenLineAttributeControl & SetAlgorithm(HiddenLine::Algorithm in_algorithm);
17744 
17750  HiddenLineAttributeControl & SetSilhouetteCleanup(bool in_state);
17751 
17755  HiddenLineAttributeControl & SetVisibility(bool in_state);
17756 
17761  HiddenLineAttributeControl & SetWeight(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
17762 
17768  HiddenLineAttributeControl & SetTransparencyCutoff(float in_zero_to_one);
17769 
17770 
17773  HiddenLineAttributeControl & UnsetColor();
17774 
17777  HiddenLineAttributeControl & UnsetDimFactor();
17778 
17781  HiddenLineAttributeControl & UnsetFaceDisplacement();
17782 
17785  HiddenLineAttributeControl & UnsetLinePattern();
17786 
17789  HiddenLineAttributeControl & UnsetRenderFaces();
17790 
17793  HiddenLineAttributeControl & UnsetRenderText();
17794 
17797  HiddenLineAttributeControl & UnsetAlgorithm();
17798 
17801  HiddenLineAttributeControl & UnsetSilhouetteCleanup();
17802 
17805  HiddenLineAttributeControl & UnsetVisibility();
17806 
17809  HiddenLineAttributeControl & UnsetWeight();
17810 
17813  HiddenLineAttributeControl & UnsetTransparencyCutoff();
17814 
17817  HiddenLineAttributeControl & UnsetEverything();
17818 
17819 
17823  bool ShowColor(RGBAColor & out_color) const;
17824 
17828  bool ShowDimFactor(float & out_zero_to_one) const;
17829 
17833  bool ShowFaceDisplacement(float & out_buckets) const;
17834 
17838  bool ShowLinePattern(UTF8 & out_pattern) const;
17839 
17843  bool ShowRenderFaces(bool & out_state) const;
17844 
17848  bool ShowRenderText(bool & out_state) const;
17849 
17853  bool ShowAlgorithm(HiddenLine::Algorithm & out_algorithm) const;
17854 
17858  bool ShowSilhouetteCleanup(bool & out_state) const;
17859 
17863  bool ShowVisibility(bool & out_state) const;
17864 
17869  bool ShowWeight(float & out_weight, Line::SizeUnits & out_units) const;
17870 
17874  bool ShowTransparencyCutoff(float & out_zero_to_one) const;
17875 
17876 private:
17879 };
17880 
17881 
17882 
17884 class HPS_API DrawingAttributeKit : public Object
17885 {
17886 public:
17887 
17890 
17893  DrawingAttributeKit(DrawingAttributeKit const & in_kit);
17894 
17899 
17903  DrawingAttributeKit & operator=(DrawingAttributeKit && in_that);
17904 
17906  virtual ~DrawingAttributeKit();
17907 
17908  Type ObjectType() const {return Type::DrawingAttributeKit;};
17909 
17913  static DrawingAttributeKit GetDefault();
17914 
17917  void Set(DrawingAttributeKit const & in_kit);
17918 
17921  void Show(DrawingAttributeKit & out_kit) const;
17922 
17926  DrawingAttributeKit & operator=(DrawingAttributeKit const & in_kit);
17927 
17930  bool Empty() const;
17931 
17935  bool Equals(DrawingAttributeKit const & in_kit) const;
17936 
17940  bool operator==(DrawingAttributeKit const & in_kit) const;
17941 
17945  bool operator!=(DrawingAttributeKit const & in_kit) const;
17946 
17962  DrawingAttributeKit & SetPolygonHandedness(Drawing::Handedness in_handedness);
17963 
17969  DrawingAttributeKit & SetWorldHandedness(Drawing::Handedness in_handedness);
17970 
17983  DrawingAttributeKit & SetDepthRange(float in_near, float in_far);
17984 
17991  DrawingAttributeKit & SetFaceDisplacement(bool in_state, int in_buckets=0);
17992 
17997  DrawingAttributeKit & SetFaceDisplacement(int in_buckets);
17998 
18005  DrawingAttributeKit & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18006 
18011  DrawingAttributeKit & SetGeneralDisplacement(int in_buckets);
18012 
18019  DrawingAttributeKit & SetVertexDisplacement(bool in_state, int in_buckets=0);
18020 
18025  DrawingAttributeKit & SetVertexDisplacement(int in_buckets);
18026 
18030  DrawingAttributeKit & SetOverlay(Drawing::Overlay in_overlay);
18031 
18036  DrawingAttributeKit & SetDeferral(int in_defer_batch);
18037 
18043  DrawingAttributeKit & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18044 
18051  DrawingAttributeKit & SetClipRegion(size_t in_number_of_points, Point const in_points [], Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18052 
18058  DrawingAttributeKit & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18059 
18062  DrawingAttributeKit & UnsetPolygonHandedness();
18063 
18066  DrawingAttributeKit & UnsetWorldHandedness();
18067 
18070  DrawingAttributeKit & UnsetDepthRange();
18071 
18074  DrawingAttributeKit & UnsetFaceDisplacement();
18075 
18078  DrawingAttributeKit & UnsetGeneralDisplacement();
18079 
18082  DrawingAttributeKit & UnsetVertexDisplacement();
18083 
18086  DrawingAttributeKit & UnsetOverlay();
18087 
18090  DrawingAttributeKit & UnsetDeferral();
18091 
18094  DrawingAttributeKit & UnsetClipRegion();
18095 
18098  DrawingAttributeKit & UnsetEverything();
18099 
18103  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18104 
18108  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18109 
18114  bool ShowDepthRange(float & out_near, float & out_far) const;
18115 
18120  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18121 
18126  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18127 
18132  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18133 
18137  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18138 
18142  bool ShowDeferral(int & out_defer_batch) const;
18143 
18149  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & out_operation) const;
18150 
18151 };
18152 
18153 
18165 class HPS_API DrawingAttributeControl : public Control
18166 {
18167 public:
18168 
18170  explicit DrawingAttributeControl(SegmentKey & in_seg);
18171 
18174 
18179 
18183  DrawingAttributeControl & operator=(DrawingAttributeControl && in_that);
18184 
18187 
18188  Type ObjectType() const {return Type::DrawingAttributeControl;};
18189 
18191  DrawingAttributeControl & operator=(DrawingAttributeControl const & in_that);
18192 
18202  DrawingAttributeControl & SetPolygonHandedness(Drawing::Handedness in_handedness);
18203 
18209  DrawingAttributeControl & SetWorldHandedness(Drawing::Handedness in_handedness);
18210 
18223  DrawingAttributeControl & SetDepthRange(float in_near, float in_far);
18224 
18231  DrawingAttributeControl & SetFaceDisplacement(bool in_state, int in_buckets=0);
18232 
18237  DrawingAttributeControl & SetFaceDisplacement(int in_buckets);
18238 
18245  DrawingAttributeControl & SetGeneralDisplacement(bool in_state, int in_buckets=0);
18246 
18251  DrawingAttributeControl & SetGeneralDisplacement(int in_buckets);
18252 
18259  DrawingAttributeControl & SetVertexDisplacement(bool in_state, int in_buckets=0);
18260 
18265  DrawingAttributeControl & SetVertexDisplacement(int in_buckets);
18266 
18270  DrawingAttributeControl & SetOverlay(Drawing::Overlay in_overlay);
18271 
18277  DrawingAttributeControl & SetClipRegion(PointArray const & in_points, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18278 
18285  DrawingAttributeControl & SetClipRegion(size_t in_number_of_points, Point const in_points [], Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18286 
18292  DrawingAttributeControl & SetClipRegion(PointArrayArray const & in_loops, Drawing::ClipSpace in_space = Drawing::ClipSpace::World, Drawing::ClipOperation in_operation = Drawing::ClipOperation::Keep);
18293 
18298  DrawingAttributeControl & SetDeferral(int in_deferral);
18301  DrawingAttributeControl & UnsetPolygonHandedness();
18302 
18305  DrawingAttributeControl & UnsetWorldHandedness();
18306 
18309  DrawingAttributeControl & UnsetDepthRange();
18310 
18313  DrawingAttributeControl & UnsetFaceDisplacement();
18314 
18317  DrawingAttributeControl & UnsetGeneralDisplacement();
18318 
18321  DrawingAttributeControl & UnsetVertexDisplacement();
18322 
18325  DrawingAttributeControl & UnsetOverlay();
18326 
18329  DrawingAttributeControl & UnsetDeferral();
18330 
18333  DrawingAttributeControl & UnsetClipRegion();
18334 
18337  DrawingAttributeControl & UnsetEverything();
18338 
18339 
18343  bool ShowPolygonHandedness(Drawing::Handedness & out_handedness) const;
18344 
18348  bool ShowWorldHandedness(Drawing::Handedness & out_handedness) const;
18349 
18354  bool ShowDepthRange(float & out_x, float & out_y) const;
18355 
18360  bool ShowFaceDisplacement(bool & out_state, int & out_buckets) const;
18361 
18366  bool ShowGeneralDisplacement(bool & out_state, int & out_buckets) const;
18367 
18372  bool ShowVertexDisplacement(bool & out_state, int & out_buckets) const;
18373 
18377  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
18378 
18382  bool ShowDeferral(int & out_defer_batch) const;
18383 
18389  bool ShowClipRegion(PointArrayArray & out_loops, Drawing::ClipSpace & out_space, Drawing::ClipOperation & ou_operation);
18390 
18391 private:
18394 };
18395 
18396 
18398 class HPS_API PostProcessEffectsKit : public Object
18399 {
18400 public:
18401 
18404 
18408 
18413 
18417  PostProcessEffectsKit & operator=(PostProcessEffectsKit && in_that);
18418 
18420  virtual ~PostProcessEffectsKit();
18421 
18422  Type ObjectType() const {return Type::PostProcessEffectsKit;};
18423 
18427  static PostProcessEffectsKit GetDefault();
18428 
18431  void Set(PostProcessEffectsKit const & in_kit);
18432 
18435  void Show(PostProcessEffectsKit & out_kit) const;
18436 
18440  PostProcessEffectsKit & operator=(PostProcessEffectsKit const & in_kit);
18441 
18444  bool Empty() const;
18445 
18449  bool Equals(PostProcessEffectsKit const & in_kit) const;
18450 
18454  bool operator==(PostProcessEffectsKit const & in_kit) const;
18455 
18459  bool operator!=(PostProcessEffectsKit const & in_kit) const;
18460 
18461 
18469  PostProcessEffectsKit & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
18470 
18477  PostProcessEffectsKit & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
18478 
18485  PostProcessEffectsKit & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
18486 
18492  PostProcessEffectsKit & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
18493 
18500  PostProcessEffectsKit & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
18501 
18507  PostProcessEffectsKit & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
18508 
18516  PostProcessEffectsKit & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
18517 
18524  PostProcessEffectsKit & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
18525 
18533  PostProcessEffectsKit & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
18534 
18541  PostProcessEffectsKit & SetEyeDomeLighting(float in_exponent, bool in_tolerance, float in_strength);
18542 
18545  PostProcessEffectsKit & UnsetAmbientOcclusion();
18546 
18549  PostProcessEffectsKit & UnsetBloom();
18550 
18553  PostProcessEffectsKit & UnsetDepthOfField();
18554 
18557  PostProcessEffectsKit & UnsetSilhouetteEdges();
18558 
18561  PostProcessEffectsKit & UnsetEyeDomeLighting();
18562 
18565  PostProcessEffectsKit & UnsetEverything();
18566 
18567 
18574  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
18575 
18582  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
18583 
18590  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
18591 
18599  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
18600 
18608  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
18609 };
18610 
18611 
18615 class HPS_API PostProcessEffectsControl : public Control
18616 {
18617 public:
18618 
18620  explicit PostProcessEffectsControl(WindowKey & in_seg);
18621 
18624 
18629 
18633  PostProcessEffectsControl & operator=(PostProcessEffectsControl && in_that);
18634 
18637 
18638  Type ObjectType() const {return Type::PostProcessEffectsControl;};
18639 
18641  PostProcessEffectsControl & operator=(PostProcessEffectsControl const & in_that);
18642 
18643 
18651  PostProcessEffectsControl & SetAmbientOcclusion(bool in_state, float in_strength = 1.0f, PostProcessEffects::AmbientOcclusion::Quality in_quality = PostProcessEffects::AmbientOcclusion::Quality::Fastest);
18652 
18659  PostProcessEffectsControl & SetAmbientOcclusion(float in_strength, PostProcessEffects::AmbientOcclusion::Quality in_quality);
18660 
18667  PostProcessEffectsControl & SetBloom(bool in_state, float in_strength = 1.0f, unsigned int in_blur = 5, PostProcessEffects::Bloom::Shape in_shape = PostProcessEffects::Bloom::Shape::Radial);
18668 
18674  PostProcessEffectsControl & SetBloom(float in_strength, unsigned int in_blur, PostProcessEffects::Bloom::Shape in_shape);
18675 
18682  PostProcessEffectsControl & SetDepthOfField(bool in_state, float in_strength = 1.0f, float in_near_distance = Float::NegativeInfinity, float in_far_distance = Float::Infinity);
18683 
18689  PostProcessEffectsControl & SetDepthOfField(float in_strength, float in_near_distance, float in_far_distance);
18690 
18698  PostProcessEffectsControl & SetSilhouetteEdges(bool in_state, float in_tolerance = 1.0f, bool in_heavy_exterior = false);
18699 
18706  PostProcessEffectsControl & SetSilhouetteEdges(float in_tolerance, bool in_heavy_exterior);
18707 
18714  PostProcessEffectsControl & SetEyeDomeLighting(bool in_state, float in_exponent = 50.0f, float in_tolerance = 1.0f, float in_strength = 1.0f);
18715 
18722  PostProcessEffectsControl & SetEyeDomeLighting(float in_exponent, float in_tolerance, float in_strength);
18723 
18724 
18727  PostProcessEffectsControl & UnsetAmbientOcclusion();
18728 
18731  PostProcessEffectsControl & UnsetBloom();
18732 
18735  PostProcessEffectsControl & UnsetDepthOfField();
18736 
18739  PostProcessEffectsControl & UnsetSilhouetteEdges();
18740 
18743  PostProcessEffectsControl & UnsetEyeDomeLighting();
18744 
18747  PostProcessEffectsControl & UnsetEverything();
18748 
18749 
18756  bool ShowAmbientOcclusion(bool & out_state, float & out_strength, PostProcessEffects::AmbientOcclusion::Quality & out_quality) const;
18757 
18764  bool ShowBloom(bool & out_state, float & out_strength, unsigned int & out_blur, PostProcessEffects::Bloom::Shape & out_shape) const;
18765 
18772  bool ShowDepthOfField(bool & out_state, float & out_strength, float & out_near_distance, float & out_far_distance) const;
18773 
18781  bool ShowSilhouetteEdges(bool & out_state, float & out_tolerance, bool & out_heavy_exterior) const;
18782 
18790  bool ShowEyeDomeLighting(bool & out_state, float & out_exponent, float & out_tolerance, float & out_strength) const;
18791 
18792 private:
18795 };
18796 
18798 class HPS_API TransformMaskKit : public Object
18799 {
18800 public:
18801 
18803  TransformMaskKit();
18804 
18806  TransformMaskKit(TransformMaskKit const & in_kit);
18807 
18811  TransformMaskKit(TransformMaskKit && in_that);
18812 
18816  TransformMaskKit & operator=(TransformMaskKit && in_that);
18817 
18819  virtual ~TransformMaskKit();
18820 
18821  Type ObjectType() const {return Type::TransformMaskKit;};
18822 
18823  static TransformMaskKit GetDefault();
18824 
18826  void Set(TransformMaskKit const & in_kit);
18827 
18829  void Show(TransformMaskKit & out_kit) const;
18830 
18832  TransformMaskKit & operator=(TransformMaskKit const & in_kit);
18833 
18835  bool Empty() const;
18836 
18838  bool Equals(TransformMaskKit const & in_kit) const;
18839 
18841  bool operator==(TransformMaskKit const & in_kit) const;
18842 
18844  bool operator!=(TransformMaskKit const & in_kit) const;
18845 
18846 
18850  TransformMaskKit & SetCameraRotation(bool in_state);
18851 
18855  TransformMaskKit & SetCameraScale(bool in_state);
18856 
18860  TransformMaskKit & SetCameraTranslation(bool in_state);
18861 
18865  TransformMaskKit & SetCameraPerspectiveScale(bool in_state);
18866 
18870  TransformMaskKit & SetCameraProjection(bool in_state);
18871 
18875  TransformMaskKit & SetCameraOffset(bool in_state);
18876 
18880  TransformMaskKit & SetCameraNearLimit(bool in_state);
18881 
18885  TransformMaskKit & SetModellingMatrixRotation(bool in_state);
18886 
18890  TransformMaskKit & SetModellingMatrixScale(bool in_state);
18891 
18895  TransformMaskKit & SetModellingMatrixTranslation(bool in_state);
18896 
18900  TransformMaskKit & SetModellingMatrixOffset(bool in_state);
18901 
18902 
18906  TransformMaskKit & SetCameraEverything(bool in_state);
18907 
18911  TransformMaskKit & SetModellingMatrixEverything(bool in_state);
18912 
18916  TransformMaskKit & SetEverything(bool in_state);
18917 
18918 
18921  TransformMaskKit & UnsetCameraRotation();
18922 
18925  TransformMaskKit & UnsetCameraScale();
18926 
18929  TransformMaskKit & UnsetCameraTranslation();
18930 
18933  TransformMaskKit & UnsetCameraPerspectiveScale();
18934 
18937  TransformMaskKit & UnsetCameraProjection();
18938 
18941  TransformMaskKit & UnsetCameraOffset();
18942 
18945  TransformMaskKit & UnsetCameraNearLimit();
18946 
18949  TransformMaskKit & UnsetCameraEverything();
18950 
18953  TransformMaskKit & UnsetModellingMatrixRotation();
18954 
18957  TransformMaskKit & UnsetModellingMatrixScale();
18958 
18961  TransformMaskKit & UnsetModellingMatrixTranslation();
18962 
18965  TransformMaskKit & UnsetModellingMatrixOffset();
18966 
18969  TransformMaskKit & UnsetModellingMatrixEverything();
18970 
18973  TransformMaskKit & UnsetEverything();
18974 
18975 
18979  bool ShowCameraRotation(bool & out_state) const;
18980 
18984  bool ShowCameraScale(bool & out_state) const;
18985 
18989  bool ShowCameraTranslation(bool & out_state) const;
18990 
18994  bool ShowCameraPerspectiveScale(bool & out_state) const;
18995 
18999  bool ShowCameraProjection(bool & out_state) const;
19000 
19004  bool ShowCameraOffset(bool & out_state) const;
19005 
19009  bool ShowCameraNearLimit(bool & out_state) const;
19010 
19014  bool ShowModellingMatrixRotation(bool & out_state) const;
19015 
19019  bool ShowModellingMatrixScale(bool & out_state) const;
19020 
19024  bool ShowModellingMatrixTranslation(bool & out_state) const;
19025 
19029  bool ShowModellingMatrixOffset(bool & out_state) const;
19030 };
19031 
19032 
19037 class HPS_API TransformMaskControl : public Control
19038 {
19039 public:
19040 
19042  explicit TransformMaskControl(SegmentKey & in_seg);
19043 
19045  TransformMaskControl(TransformMaskControl const & in_that);
19046 
19051 
19055  TransformMaskControl & operator=(TransformMaskControl && in_that);
19056 
19059 
19060  Type ObjectType() const {return Type::TransformMaskControl;};
19061 
19062 
19066  TransformMaskControl & SetCameraRotation(bool in_state);
19067 
19071  TransformMaskControl & SetCameraScale(bool in_state);
19072 
19076  TransformMaskControl & SetCameraTranslation(bool in_state);
19077 
19081  TransformMaskControl & SetCameraPerspectiveScale(bool in_state);
19082 
19086  TransformMaskControl & SetCameraProjection(bool in_state);
19087 
19091  TransformMaskControl & SetCameraOffset(bool in_state);
19092 
19096  TransformMaskControl & SetCameraNearLimit(bool in_state);
19097 
19101  TransformMaskControl & SetModellingMatrixRotation(bool in_state);
19102 
19106  TransformMaskControl & SetModellingMatrixScale(bool in_state);
19107 
19111  TransformMaskControl & SetModellingMatrixTranslation(bool in_state);
19112 
19116  TransformMaskControl & SetModellingMatrixOffset(bool in_state);
19117 
19118 
19122  TransformMaskControl & SetCameraEverything(bool in_state);
19123 
19127  TransformMaskControl & SetModellingMatrixEverything(bool in_state);
19128 
19132  TransformMaskControl & SetEverything(bool in_state);
19133 
19134 
19137  TransformMaskControl & UnsetCameraRotation();
19138 
19141  TransformMaskControl & UnsetCameraScale();
19142 
19145  TransformMaskControl & UnsetCameraTranslation();
19146 
19149  TransformMaskControl & UnsetCameraPerspectiveScale();
19150 
19153  TransformMaskControl & UnsetCameraProjection();
19154 
19157  TransformMaskControl & UnsetCameraOffset();
19158 
19161  TransformMaskControl & UnsetCameraNearLimit();
19162 
19165  TransformMaskControl & UnsetCameraEverything();
19166 
19169  TransformMaskControl & UnsetModellingMatrixRotation();
19170 
19173  TransformMaskControl & UnsetModellingMatrixScale();
19174 
19177  TransformMaskControl & UnsetModellingMatrixTranslation();
19178 
19181  TransformMaskControl & UnsetModellingMatrixOffset();
19182 
19185  TransformMaskControl & UnsetModellingMatrixEverything();
19186 
19189  TransformMaskControl & UnsetEverything();
19190 
19191 
19195  bool ShowCameraRotation(bool & out_state) const;
19196 
19200  bool ShowCameraScale(bool & out_state) const;
19201 
19205  bool ShowCameraTranslation(bool & out_state) const;
19206 
19210  bool ShowCameraPerspectiveScale(bool & out_state) const;
19211 
19215  bool ShowCameraProjection(bool & out_state) const;
19216 
19220  bool ShowCameraOffset(bool & out_state) const;
19221 
19225  bool ShowCameraNearLimit(bool & out_state) const;
19226 
19230  bool ShowModellingMatrixRotation(bool & out_state) const;
19231 
19235  bool ShowModellingMatrixScale(bool & out_state) const;
19236 
19240  bool ShowModellingMatrixTranslation(bool & out_state) const;
19241 
19245  bool ShowModellingMatrixOffset(bool & out_state) const;
19246 
19247 private:
19250 };
19251 
19252 
19253 
19255 class HPS_API VisualEffectsKit : public Object
19256 {
19257 public:
19258 
19260  VisualEffectsKit();
19261 
19264  VisualEffectsKit(VisualEffectsKit const & in_kit);
19265 
19269  VisualEffectsKit(VisualEffectsKit && in_that);
19270 
19274  VisualEffectsKit & operator=(VisualEffectsKit && in_that);
19275 
19277  virtual ~VisualEffectsKit();
19278 
19279  Type ObjectType() const {return Type::VisualEffectsKit;};
19280 
19284  static VisualEffectsKit GetDefault();
19285 
19288  void Set(VisualEffectsKit const & in_kit);
19289 
19292  void Show(VisualEffectsKit & out_kit) const;
19293 
19297  VisualEffectsKit & operator=(VisualEffectsKit const & in_kit);
19298 
19301  bool Empty() const;
19302 
19306  bool Equals(VisualEffectsKit const & in_kit) const;
19307 
19311  bool operator==(VisualEffectsKit const & in_kit) const;
19312 
19316  bool operator!=(VisualEffectsKit const & in_kit) const;
19317 
19321  VisualEffectsKit & SetPostProcessEffectsEnabled(bool in_state);
19322 
19326  VisualEffectsKit & SetAntiAliasing(bool in_state);
19327 
19337  VisualEffectsKit & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
19338 
19347  VisualEffectsKit & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
19348 
19355  VisualEffectsKit & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
19356 
19362  VisualEffectsKit & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
19363 
19367  VisualEffectsKit & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19368 
19372  VisualEffectsKit & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
19373 
19377  VisualEffectsKit & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
19378 
19389  VisualEffectsKit & SetSimpleReflection(bool in_state, float in_opacity = 0.5f, unsigned int in_blurring = 1, bool in_fading = false, float in_attenuation_near_distance = 0.0f, float in_attenuation_far_distance = Float::Infinity);
19390 
19400  VisualEffectsKit & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
19401 
19405  VisualEffectsKit & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19406 
19410  VisualEffectsKit & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
19411 
19412 
19415  VisualEffectsKit & UnsetPostProcessEffectsEnabled();
19416 
19419  VisualEffectsKit & UnsetAntiAliasing();
19420 
19423  VisualEffectsKit & UnsetShadowMaps();
19424 
19427  VisualEffectsKit & UnsetSimpleShadow();
19428 
19431  VisualEffectsKit & UnsetSimpleShadowPlane();
19432 
19435  VisualEffectsKit & UnsetSimpleShadowLightDirection();
19436 
19439  VisualEffectsKit & UnsetSimpleShadowColor();
19440 
19443  VisualEffectsKit & UnsetSimpleReflection();
19444 
19447  VisualEffectsKit & UnsetSimpleReflectionPlane();
19448 
19451  VisualEffectsKit & UnsetSimpleReflectionVisibility();
19452 
19455  VisualEffectsKit & UnsetEverything();
19456 
19460  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
19461 
19465  bool ShowAntiAliasing(bool & out_state) const;
19466 
19474  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
19475 
19482  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
19483 
19487  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
19488 
19492  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
19493 
19497  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
19498 
19507  bool ShowSimpleReflection(bool & out_state, float & out_opacity, unsigned int & out_blurring, bool & out_fading, float & out_attenuation_near_distance, float & out_attenuation_far_distance) const;
19508 
19509 
19513  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
19514 
19518  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
19519 };
19520 
19521 
19527 class HPS_API VisualEffectsControl : public Control
19528 {
19529 public:
19530 
19532  explicit VisualEffectsControl(SegmentKey & in_seg);
19533 
19535  VisualEffectsControl(VisualEffectsControl const & in_that);
19536 
19541 
19545  VisualEffectsControl & operator=(VisualEffectsControl && in_that);
19546 
19549 
19550  Type ObjectType() const {return Type::VisualEffectsControl;};
19551 
19553  VisualEffectsControl & operator=(VisualEffectsControl const & in_that);
19554 
19558  VisualEffectsControl & SetPostProcessEffectsEnabled(bool in_state);
19559 
19563  VisualEffectsControl & SetAntiAliasing(bool in_state);
19564 
19574  VisualEffectsControl & SetShadowMaps(bool in_state, unsigned int in_samples = 4, unsigned int in_resolution = 1024, bool in_view_dependent = true, bool in_jitter = true);
19575 
19584  VisualEffectsControl & SetShadowMaps(unsigned int in_samples, unsigned int in_resolution, bool in_view_dependent, bool in_jitter);
19585 
19592  VisualEffectsControl & SetSimpleShadow(bool in_state, unsigned int in_resolution = 256, unsigned int in_blurring = 1, bool in_ignore_transparency = false);
19593 
19599  VisualEffectsControl & SetSimpleShadow(unsigned int in_resolution, unsigned int in_blurring, bool in_ignore_transparency);
19600 
19604  VisualEffectsControl & SetSimpleShadowPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19605 
19609  VisualEffectsControl & SetSimpleShadowLightDirection(Vector const & in_direction = Vector(0.0f, 1.0f, 0.0f));
19610 
19614  VisualEffectsControl & SetSimpleShadowColor(RGBAColor const & in_color = RGBAColor(0.0f, 0.0f, 0.0f, 1.0f));
19615 
19626  VisualEffectsControl & SetSimpleReflection(bool in_state, float in_opacity = 0.5f, unsigned int in_blurring = 1, bool in_fading = false, float in_attenuation_near_distance = 0.0f, float in_attenuation_far_distance = Float::Infinity);
19627 
19637  VisualEffectsControl & SetSimpleReflection(float in_opacity, unsigned int in_blurring, bool in_fading, float in_attenuation_near_distance, float in_attenuation_far_distance);
19638 
19642  VisualEffectsControl & SetSimpleReflectionPlane(Plane const & in_projected_onto = Plane(0.0f, 1.0f, 0.0f, 1.0f));
19643 
19647  VisualEffectsControl & SetSimpleReflectionVisibility(VisibilityKit const & in_reflected_types);
19648 
19649 
19652  VisualEffectsControl & UnsetPostProcessEffectsEnabled();
19653 
19656  VisualEffectsControl & UnsetAntiAliasing();
19657 
19660  VisualEffectsControl & UnsetShadowMaps();
19661 
19664  VisualEffectsControl & UnsetSimpleShadow();
19665 
19668  VisualEffectsControl & UnsetSimpleShadowPlane();
19669 
19672  VisualEffectsControl & UnsetSimpleShadowLightDirection();
19673 
19676  VisualEffectsControl & UnsetSimpleShadowColor();
19677 
19680  VisualEffectsControl & UnsetSimpleReflection();
19681 
19684  VisualEffectsControl & UnsetSimpleReflectionPlane();
19685 
19688  VisualEffectsControl & UnsetSimpleReflectionVisibility();
19689 
19692  VisualEffectsControl & UnsetEverything();
19693 
19694 
19698  bool ShowPostProcessEffectsEnabled(bool & out_state) const;
19699 
19703  bool ShowAntiAliasing(bool & out_state) const;
19704 
19712  bool ShowShadowMaps(bool & out_state, unsigned int & out_samples, unsigned int & out_resolution, bool & out_view_dependent, bool & out_jitter) const;
19713 
19720  bool ShowSimpleShadow(bool & out_state, unsigned int & out_resolution, unsigned int & out_blurring, bool & out_ignore_transparency) const;
19721 
19725  bool ShowSimpleShadowPlane(Plane & out_projected_onto) const;
19726 
19730  bool ShowSimpleShadowLightDirection(Vector & out_direction) const;
19731 
19735  bool ShowSimpleShadowColor(RGBAColor & out_color) const;
19736 
19745  bool ShowSimpleReflection(bool & out_state, float & out_opacity, unsigned int & out_blurring, bool & out_fading, float & out_attenuation_near_distance, float & out_attenuation_far_distance) const;
19746 
19750  bool ShowSimpleReflectionPlane(Plane & out_projected_onto) const;
19751 
19755  bool ShowSimpleReflectionVisibility(VisibilityKit & out_reflected_types) const;
19756 
19757 private:
19760 };
19761 
19762 
19763 
19765 class HPS_API ContourLineKit : public Object
19766 {
19767 public:
19768 
19770  ContourLineKit();
19771 
19774  ContourLineKit(ContourLineKit const & in_kit);
19775 
19779  ContourLineKit(ContourLineKit && in_that);
19780 
19784  ContourLineKit & operator=(ContourLineKit && in_that);
19785 
19787  virtual ~ContourLineKit();
19788 
19789  Type ObjectType() const { return Type::ContourLineKit; };
19790 
19794  static ContourLineKit GetDefault();
19795 
19798  void Set(ContourLineKit const & in_kit);
19799 
19802  void Show(ContourLineKit & out_kit) const;
19803 
19807  ContourLineKit & operator=(ContourLineKit const & in_kit);
19808 
19811  bool Empty() const;
19812 
19816  bool Equals(ContourLineKit const & in_kit) const;
19817 
19821  bool operator==(ContourLineKit const & in_kit) const;
19822 
19826  bool operator!=(ContourLineKit const & in_kit) const;
19827 
19828 
19832  ContourLineKit & SetVisibility(bool in_state);
19833 
19838  ContourLineKit & SetPositions(float in_interval, float in_offset);
19839 
19843  ContourLineKit & SetPositions(FloatArray const & in_positions);
19844 
19849  ContourLineKit & SetPositions(size_t in_count, float const in_positions[]);
19850 
19854  ContourLineKit & SetColors(RGBColorArray const & in_colors);
19855 
19860  ContourLineKit & SetColors(size_t in_count, RGBColor const in_colors[]);
19861 
19865  ContourLineKit & SetColors(RGBColor const & in_color);
19866 
19870  ContourLineKit & SetPatterns(UTF8Array const & in_patterns);
19871 
19876  ContourLineKit & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
19877 
19881  ContourLineKit & SetPatterns(char const * in_pattern);
19882 
19887  ContourLineKit & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
19888 
19894  ContourLineKit & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
19895 
19900  ContourLineKit & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
19901 
19905  ContourLineKit & SetLighting(bool in_state);
19906 
19907 
19910  ContourLineKit & UnsetVisibility();
19911 
19914  ContourLineKit & UnsetPositions();
19915 
19918  ContourLineKit & UnsetColors();
19919 
19922  ContourLineKit & UnsetPatterns();
19923 
19926  ContourLineKit & UnsetWeights();
19927 
19930  ContourLineKit & UnsetLighting();
19931 
19934  ContourLineKit & UnsetEverything();
19935 
19936 
19940  bool ShowVisibility(bool & out_state) const;
19941 
19947  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
19948 
19952  bool ShowColors(RGBColorArray & out_colors) const;
19953 
19957  bool ShowPatterns(UTF8Array & out_patterns) const;
19958 
19963  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
19964 
19968  bool ShowLighting(bool & out_state) const;
19969 };
19970 
19974 class HPS_API ContourLineControl : public Control
19975 {
19976 public:
19977 
19979  explicit ContourLineControl(SegmentKey & in_seg);
19980 
19982  ContourLineControl(ContourLineControl const & in_that);
19983 
19988 
19992  ContourLineControl & operator=(ContourLineControl && in_that);
19993 
19995  ~ContourLineControl();
19996 
19997  Type ObjectType() const { return Type::ContourLineControl; };
19998 
20000  ContourLineControl & operator=(ContourLineControl const & in_that);
20001 
20002 
20006  ContourLineControl & SetVisibility(bool in_state);
20007 
20012  ContourLineControl & SetPositions(float in_interval, float in_offset);
20013 
20017  ContourLineControl & SetPositions(FloatArray const & in_positions);
20018 
20023  ContourLineControl & SetPositions(size_t in_count, float const in_positions[]);
20024 
20028  ContourLineControl & SetColors(RGBColorArray const & in_colors);
20029 
20034  ContourLineControl & SetColors(size_t in_count, RGBColor const in_rgb_colors[]);
20035 
20039  ContourLineControl & SetColors(RGBColor const & in_rgb_color);
20040 
20044  ContourLineControl & SetPatterns(UTF8Array const & in_patterns);
20045 
20050  ContourLineControl & SetPatterns(size_t in_count, UTF8 const in_patterns[]);
20051 
20055  ContourLineControl & SetPatterns(char const * in_pattern);
20056 
20061  ContourLineControl & SetWeights(FloatArray const & in_weights, LineSizeUnitsArray const & in_units);
20062 
20068  ContourLineControl & SetWeights(size_t in_count, float const in_weights[], Line::SizeUnits const in_units[]);
20069 
20074  ContourLineControl & SetWeights(float in_weight, Line::SizeUnits in_units = Line::SizeUnits::ScaleFactor);
20075 
20079  ContourLineControl & SetLighting(bool in_state);
20080 
20081 
20084  ContourLineControl & UnsetVisibility();
20085 
20088  ContourLineControl & UnsetPositions();
20089 
20092  ContourLineControl & UnsetColors();
20093 
20096  ContourLineControl & UnsetPatterns();
20097 
20100  ContourLineControl & UnsetWeights();
20101 
20104  ContourLineControl & UnsetLighting();
20105 
20108  ContourLineControl & UnsetEverything();
20109 
20110 
20114  bool ShowVisibility(bool & out_state) const;
20115 
20121  bool ShowPositions(ContourLine::Mode & out_mode, FloatArray & out_positions) const;
20122 
20126  bool ShowColors(RGBColorArray & out_colors) const;
20127 
20131  bool ShowPatterns(UTF8Array & out_patterns) const;
20132 
20137  bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units) const;
20138 
20142  bool ShowLighting(bool & out_state) const;
20143 
20144 private:
20147 };
20148 
20149 
20150 
20152 class HPS_API SubwindowKit : public Object
20153 {
20154 public:
20155 
20157  SubwindowKit();
20158 
20160  SubwindowKit(SubwindowKit const & in_kit);
20161 
20165  SubwindowKit(SubwindowKit && in_that);
20166 
20170  SubwindowKit & operator=(SubwindowKit && in_that);
20171 
20173  virtual ~SubwindowKit();
20174 
20175  Type ObjectType() const {return Type::SubwindowKit;}
20176 
20180  static SubwindowKit GetDefault();
20181 
20184  void Set(SubwindowKit const & in_kit);
20185 
20188  void Show(SubwindowKit & out_kit) const;
20189 
20193  SubwindowKit & operator=(SubwindowKit const & in_kit);
20194 
20197  bool Empty() const;
20198 
20202  bool Equals(SubwindowKit const & in_kit) const;
20203 
20207  bool operator==(SubwindowKit const & in_kit) const;
20208 
20212  bool operator!=(SubwindowKit const & in_kit) const;
20213 
20214 
20224  SubwindowKit & SetSubwindow(Rectangle const & in_subwindow_position, Subwindow::Type in_subwindow_type = Subwindow::Type::Standard);
20225 
20232  SubwindowKit & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20233 
20238  SubwindowKit & SetBorder(Subwindow::Border in_border_type);
20239 
20244  SubwindowKit & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20245 
20246 
20249  SubwindowKit & UnsetSubwindow();
20250 
20253  SubwindowKit & UnsetBackground();
20254 
20257  SubwindowKit & UnsetBorder();
20258 
20261  SubwindowKit & UnsetRenderingAlgorithm();
20262 
20265  SubwindowKit & UnsetEverything();
20266 
20267 
20272  bool ShowSubwindow(Rectangle & out_subwindow_position, Subwindow::Type & out_subwindow_type) const;
20273 
20278  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20279 
20283  bool ShowBorder(Subwindow::Border & out_border_type) const;
20284 
20288  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20289 };
20290 
20291 
20292 
20298 class HPS_API SubwindowControl : public Control
20299 {
20300 public:
20301 
20303  explicit SubwindowControl(SegmentKey & in_seg);
20304 
20306  SubwindowControl(SubwindowControl const & in_that);
20307 
20311  SubwindowControl(SubwindowControl && in_that);
20312 
20316  SubwindowControl & operator=(SubwindowControl && in_that);
20317 
20319  ~SubwindowControl();
20320 
20321  Type ObjectType() const {return Type::SubwindowControl;}
20322 
20324  SubwindowControl & operator=(SubwindowControl const & in_that);
20325 
20336  SubwindowControl & SetSubwindow(Rectangle const & in_window_position, Subwindow::Type in_type = Subwindow::Type::Standard);
20337 
20344  SubwindowControl & SetBackground(Subwindow::Background in_bg_type, char const * in_definition_name = "");
20345 
20350  SubwindowControl & SetBorder(Subwindow::Border in_border_type);
20351 
20357  SubwindowControl & SetRenderingAlgorithm(Subwindow::RenderingAlgorithm in_hsra);
20358 
20359 
20362  SubwindowControl & UnsetSubwindow();
20363 
20366  SubwindowControl & UnsetBackground();
20367 
20370  SubwindowControl & UnsetBorder();
20371 
20374  SubwindowControl & UnsetRenderingAlgorithm();
20375 
20378  SubwindowControl & UnsetEverything();
20379 
20380 
20385  bool ShowSubwindow(Rectangle & out_window_position, Subwindow::Type & out_subwindow_type) const;
20386 
20391  bool ShowBackground(Subwindow::Background & out_bg_type, UTF8 & out_definition_name) const;
20392 
20396  bool ShowBorder(Subwindow::Border & out_border_type) const;
20397 
20401  bool ShowRenderingAlgorithm(Subwindow::RenderingAlgorithm & out_hsra) const;
20402 
20403 private:
20405  SubwindowControl();
20406 };
20407 
20408 
20409 
20411 class HPS_API DebuggingKit : public Object
20412 {
20413 public:
20414 
20416  DebuggingKit();
20417 
20419  DebuggingKit(DebuggingKit const & in_kit);
20420 
20424  DebuggingKit(DebuggingKit && in_that);
20425 
20429  DebuggingKit & operator=(DebuggingKit && in_that);
20430 
20432  virtual ~DebuggingKit();
20433 
20434  Type ObjectType() const {return Type::DebuggingKit;}
20435 
20439  static DebuggingKit GetDefault();
20440 
20443  void Set(DebuggingKit const & in_kit);
20444 
20447  void Show(DebuggingKit & out_kit) const;
20448 
20452  DebuggingKit & operator=(DebuggingKit const & in_kit);
20453 
20456  bool Empty() const;
20457 
20461  bool Equals(DebuggingKit const & in_kit) const;
20462 
20466  bool operator==(DebuggingKit const & in_kit) const;
20467 
20471  bool operator!=(DebuggingKit const & in_kit) const;
20472 
20473 
20477  DebuggingKit & SetResourceMonitor(bool in_display);
20478 
20479 
20482  DebuggingKit & UnsetResourceMonitor();
20483 
20486  DebuggingKit & UnsetEverything();
20487 
20488 
20492  bool ShowResourceMonitor(bool & out_display) const;
20493 };
20494 
20495 
20498 class HPS_API DebuggingControl : public Control
20499 {
20500 public:
20501 
20503  explicit DebuggingControl(WindowKey & in_window);
20504 
20506  DebuggingControl(DebuggingControl const & in_that);
20507 
20511  DebuggingControl(DebuggingControl && in_that);
20512 
20516  DebuggingControl & operator=(DebuggingControl && in_that);
20517 
20519  ~DebuggingControl();
20520 
20521  Type ObjectType() const {return Type::DebuggingControl;}
20522 
20524  DebuggingControl & operator=(DebuggingControl const & in_that);
20525 
20530  DebuggingControl & SetResourceMonitor(bool in_display);
20531 
20532 
20536  bool ShowResourceMonitor(bool & out_display) const;
20537 
20538 private:
20540  DebuggingControl();
20541 };
20542 
20543 
20545 class HPS_API WindowInfoKit : public Object
20546 {
20547 public:
20548 
20550  WindowInfoKit();
20551 
20553  WindowInfoKit(WindowInfoKit const & in_kit);
20554 
20558  WindowInfoKit(WindowInfoKit && in_that);
20559 
20563  WindowInfoKit & operator=(WindowInfoKit && in_that);
20564 
20566  virtual ~WindowInfoKit();
20567 
20568  Type ObjectType() const {return Type::WindowInfoKit;}
20569 
20572  void Set(WindowInfoKit const & in_kit);
20573 
20576  void Show(WindowInfoKit & out_kit) const;
20577 
20581  WindowInfoKit & operator=(WindowInfoKit const & in_kit);
20582 
20585  bool Empty() const;
20586 
20590  bool Equals(WindowInfoKit const & in_kit) const;
20591 
20595  bool operator==(WindowInfoKit const & in_kit) const;
20596 
20600  bool operator!=(WindowInfoKit const & in_kit) const;
20601 
20602 
20607  WindowInfoKit & SetPhysicalPixels(unsigned int in_width, unsigned int in_height);
20608 
20613  WindowInfoKit & SetPhysicalSize(float in_width, float in_height);
20614 
20619  WindowInfoKit & SetWindowPixels(unsigned int in_width, unsigned int in_height);
20620 
20625  WindowInfoKit & SetWindowSize(float in_width, float in_height);
20626 
20627 
20630  WindowInfoKit & UnsetPhysicalPixels();
20631 
20634  WindowInfoKit & UnsetPhysicalSize();
20635 
20638  WindowInfoKit & UnsetWindowPixels();
20639 
20642  WindowInfoKit & UnsetWindowSize();
20643 
20646  WindowInfoKit & UnsetEverything();
20647 
20648 
20653  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
20654 
20659  bool ShowPhysicalSize(float & out_width, float & out_height) const;
20660 
20665  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
20666 
20671  bool ShowWindowSize(float & out_width, float & out_height) const;
20672 
20678  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
20679 
20683  bool ShowWindowAspectRatio(float & out_window_aspect) const;
20684 
20688  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
20689 };
20690 
20691 
20694 class HPS_API WindowInfoControl : public Control
20695 {
20696 public:
20697 
20699  explicit WindowInfoControl(WindowKey & in_window);
20700 
20702  WindowInfoControl(WindowInfoControl const & in_that);
20703 
20708 
20712  WindowInfoControl & operator=(WindowInfoControl && in_that);
20713 
20715  ~WindowInfoControl();
20716 
20717  Type ObjectType() const {return Type::WindowInfoControl;}
20718 
20720  WindowInfoControl & operator=(WindowInfoControl const & in_that);
20721 
20722 
20727  bool ShowPhysicalPixels(unsigned int & out_width, unsigned int & out_height) const;
20728 
20733  bool ShowPhysicalSize(float & out_width, float & out_height) const;
20734 
20739  bool ShowWindowPixels(unsigned int & out_width, unsigned int & out_height) const;
20740 
20745  bool ShowWindowSize(float & out_width, float & out_height) const;
20746 
20752  bool ShowResolution(float & out_horizontal, float & out_vertical) const;
20753 
20757  bool ShowWindowAspectRatio(float & out_window_aspect) const;
20758 
20762  bool ShowPixelAspectRatio(float & out_pixel_aspect) const;
20763 
20764 private:
20767 };
20768 
20770 class HPS_API FontInfoState : public Object
20771 {
20772 public:
20773 
20775  FontInfoState();
20776 
20778  FontInfoState(FontInfoState const & in_kit);
20779 
20783  FontInfoState(FontInfoState && in_that);
20784 
20788  FontInfoState & operator=(FontInfoState && in_that);
20789 
20791  virtual ~FontInfoState();
20792 
20793  Type ObjectType() const {return Type::FontInfoState;}
20794 
20797  void Assign(FontInfoState const & in_that);
20798 
20801  void Set(FontInfoState const & in_kit);
20802 
20805  void Show(FontInfoState & out_kit) const;
20806 
20810  FontInfoState & operator=(FontInfoState const & in_kit);
20811 
20814  bool Empty() const;
20815 
20819  bool Equals(FontInfoState const & in_kit) const;
20820 
20824  bool operator==(FontInfoState const & in_kit) const;
20825 
20829  bool operator!=(FontInfoState const & in_kit) const;
20830 
20833  UTF8 GetName() const;
20834 
20837  bool GetShellConvertibility() const;
20838 };
20839 
20840 
20845 class HPS_API AttributeLockKit : public Object
20846 {
20847 public:
20848 
20850  AttributeLockKit();
20851 
20853  AttributeLockKit(AttributeLockKit const & in_kit);
20854 
20858  AttributeLockKit(AttributeLockKit && in_that);
20859 
20863  AttributeLockKit & operator=(AttributeLockKit && in_that);
20864 
20866  virtual ~AttributeLockKit();
20867 
20868  Type ObjectType() const {return Type::AttributeLockKit;}
20869 
20873  static AttributeLockKit GetDefault();
20874 
20877  void Set(AttributeLockKit const & in_kit);
20878 
20881  void Show(AttributeLockKit & out_kit) const;
20882 
20886  AttributeLockKit & operator=(AttributeLockKit const & in_kit);
20887 
20890  bool Empty() const;
20891 
20895  bool Equals(AttributeLockKit const & in_kit) const;
20896 
20900  bool operator==(AttributeLockKit const & in_kit) const;
20901 
20905  bool operator!=(AttributeLockKit const & in_kit) const;
20906 
20912  AttributeLockKit & SetLock(AttributeLock::Type in_type, bool in_state = true);
20913 
20918  AttributeLockKit & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
20919 
20925  AttributeLockKit & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
20926 
20932  AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
20933 
20934 
20937  AttributeLockKit & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
20938 
20941  AttributeLockKit & UnsetLock(AttributeLockTypeArray const & in_types);
20942 
20945  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
20946 
20949  AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
20950 
20953  AttributeLockKit & UnsetEverything();
20954 
20955 
20960  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
20961 
20966  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
20967 
20972  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
20973 
20978  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
20979 };
20980 
20981 
20986 class HPS_API AttributeLockControl : public Control
20987 {
20988 public:
20989 
20991  explicit AttributeLockControl(SegmentKey & in_seg);
20992 
20997 
21001  AttributeLockControl & operator=(AttributeLockControl && in_that);
21002 
21004  AttributeLockControl(AttributeLockControl const & in_that);
21005 
21008 
21009  Type ObjectType() const {return Type::AttributeLockControl;}
21010 
21012  AttributeLockControl & operator=(AttributeLockControl const & in_that);
21013 
21014 
21020  AttributeLockControl & SetLock(AttributeLock::Type in_type, bool in_state = true);
21021 
21026  AttributeLockControl & SetLock(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21027 
21033  AttributeLockControl & SetSubsegmentLockOverride(AttributeLock::Type in_type, bool in_state = true);
21034 
21040  AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray const & in_types, BoolArray const & in_states);
21041 
21042 
21045  AttributeLockControl & UnsetLock(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21046 
21049  AttributeLockControl & UnsetLock(AttributeLockTypeArray const & in_types);
21050 
21053  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLock::Type in_type = AttributeLock::Type::Everything);
21054 
21057  AttributeLockControl & UnsetSubsegmentLockOverride(AttributeLockTypeArray const & in_types);
21058 
21061  AttributeLockControl & UnsetEverything();
21062 
21063 
21068  bool ShowLock(AttributeLock::Type in_type, bool & out_state) const;
21069 
21074  bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21075 
21080  bool ShowSubsegmentLockOverride(AttributeLock::Type in_type, bool & out_state) const;
21081 
21086  bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states) const;
21087 
21088 private:
21091 };
21092 
21096 
21097 class HPS_API GeometryKey : public Key
21098 {
21099 public:
21101  GeometryKey();
21102 
21106  explicit GeometryKey(Key const & in_that);
21107 
21110  GeometryKey(GeometryKey const & in_that);
21111 
21115  GeometryKey & operator=(GeometryKey const & in_that);
21116 
21120  GeometryKey(GeometryKey && in_that);
21121 
21125  GeometryKey & operator=(GeometryKey && in_that);
21126 
21127  ~GeometryKey();
21128 
21129  Type ObjectType() const { return Type::GeometryKey; };
21130 
21131 
21135  size_t ShowReferrers(SegmentKeyArray & out_segments) const;
21136 
21140  size_t ShowReferrers(ReferenceKeyArray & out_references) const;
21141 
21142 
21143 
21150  GeometryKey & SetPriority(int in_priority);
21151 
21154  GeometryKey & UnsetPriority();
21155 
21159  bool ShowPriority(int & out_priority) const;
21160 
21161 
21167  GeometryKey & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21168 
21173  GeometryKey & SetUserData(intptr_t in_index, ByteArray const & in_data);
21174 
21179  GeometryKey & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21180 
21184  GeometryKey & UnsetUserData(intptr_t in_index);
21185 
21190  GeometryKey & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21191 
21195  GeometryKey & UnsetUserData(IntPtrTArray const & in_indices);
21196 
21199  GeometryKey & UnsetAllUserData();
21200 
21202  size_t ShowUserDataCount() const;
21203 
21207  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21208 
21213  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21214 
21219  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21220 
21224  bool ShowBoundings(BoundingKit & out_kit) const;
21225 };
21226 
21227 
21229 class HPS_API LineKit : public Object
21230 {
21231 public:
21233  LineKit();
21234 
21237  LineKit(LineKit const & in_kit);
21238 
21242  LineKit(LineKit && in_that);
21243 
21247  LineKit & operator=(LineKit && in_that);
21248 
21249  virtual ~LineKit();
21250 
21251  Type ObjectType() const { return Type::LineKit; };
21252 
21255  void Consume(LineKit & in_kit);
21256 
21259  void Set(LineKit const & in_kit);
21260 
21263  void Show(LineKit & out_kit) const;
21264 
21268  LineKit & operator=(LineKit const & in_kit);
21269 
21272  bool Empty() const;
21273 
21277  bool Equals(LineKit const & in_kit) const;
21278 
21282  bool operator==(LineKit const & in_kit) const;
21283 
21287  bool operator!=(LineKit const & in_kit) const;
21288 
21291  size_t GetPointCount() const;
21292 
21299  LineKit & SetPriority(int in_priority);
21300 
21303  LineKit & UnsetPriority();
21304 
21308  bool ShowPriority(int & out_priority) const;
21309 
21310 
21314  LineKit & SetPoints(PointArray const & in_points);
21315 
21320  LineKit & SetPoints(size_t in_count, Point const in_points []);
21321 
21322 
21325  LineKit & UnsetPoints();
21326 
21329  LineKit & UnsetEverything();
21330 
21331 
21335  bool ShowPoints(PointArray & out_points) const;
21336 
21337 
21343  LineKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
21344 
21349  LineKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
21350 
21355  LineKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
21356 
21362  LineKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
21363 
21369  LineKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
21370 
21376  LineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21377 
21382  LineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
21383 
21388  LineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21389 
21393  LineKit & UnsetUserData(intptr_t in_index);
21394 
21399  LineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21400 
21404  LineKit & UnsetUserData(IntPtrTArray const & in_indices);
21405 
21408  LineKit & UnsetAllUserData();
21409 
21411  size_t ShowUserDataCount() const;
21412 
21416  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21417 
21422  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21423 
21428  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21429 };
21430 
21432 class HPS_API LineKey : public GeometryKey
21433 {
21434 public:
21436  LineKey();
21437 
21441  explicit LineKey(Key const & in_that);
21442 
21445  LineKey(LineKey const & in_that);
21446 
21450  LineKey & operator=(LineKey const & in_that);
21451 
21455  LineKey(LineKey && in_that);
21456 
21460  LineKey & operator=(LineKey && in_that);
21461 
21462  ~LineKey();
21463 
21464  Type ObjectType() const { return Type::LineKey; };
21465 
21466 
21469  void Consume(LineKit & in_kit);
21470 
21473  void Set(LineKit const & in_kit);
21474 
21477  void Show(LineKit & out_kit) const;
21478 
21481  size_t GetPointCount() const;
21482 
21486  LineKey & SetPoints(PointArray const & in_points);
21487 
21492  LineKey & SetPoints(size_t in_count, Point const in_points []);
21493 
21494 
21498  bool ShowPoints(PointArray & out_points) const;
21499 
21500 
21506  LineKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
21507 
21512  LineKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
21513 
21518  LineKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
21519 
21525  LineKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
21526 
21532  LineKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
21533 };
21534 
21535 
21536 
21538 class HPS_API MarkerKit : public Object
21539 {
21540 public:
21542  MarkerKit();
21543 
21546  MarkerKit(MarkerKit const & in_kit);
21547 
21551  MarkerKit(MarkerKit && in_that);
21552 
21556  MarkerKit & operator=(MarkerKit && in_that);
21557 
21558  virtual ~MarkerKit();
21559 
21560  Type ObjectType() const { return Type::MarkerKit; };
21561 
21564  void Consume(MarkerKit & in_kit);
21565 
21568  void Set(MarkerKit const & in_kit);
21569 
21572  void Show(MarkerKit & out_kit) const;
21573 
21577  MarkerKit & operator=(MarkerKit const & in_kit);
21578 
21581  bool Empty() const;
21582 
21586  bool Equals(MarkerKit const & in_kit) const;
21587 
21591  bool operator==(MarkerKit const & in_kit) const;
21592 
21596  bool operator!=(MarkerKit const & in_kit) const;
21597 
21598 
21605  MarkerKit & SetPriority(int in_priority);
21606 
21609  MarkerKit & UnsetPriority();
21610 
21614  bool ShowPriority(int & out_priority) const;
21615 
21619  MarkerKit & SetPoint(Point const & in_point);
21620 
21621 
21624  MarkerKit & UnsetPoint();
21625 
21628  MarkerKit & UnsetEverything();
21629 
21630 
21634  bool ShowPoint(Point & out_point) const;
21635 
21641  MarkerKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21642 
21647  MarkerKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
21648 
21653  MarkerKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21654 
21658  MarkerKit & UnsetUserData(intptr_t in_index);
21659 
21664  MarkerKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21665 
21669  MarkerKit & UnsetUserData(IntPtrTArray const & in_indices);
21670 
21673  MarkerKit & UnsetAllUserData();
21674 
21676  size_t ShowUserDataCount() const;
21677 
21681  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21682 
21687  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21688 
21693  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21694 };
21695 
21697 class HPS_API MarkerKey : public GeometryKey
21698 {
21699 public:
21701  MarkerKey();
21702 
21706  explicit MarkerKey(Key const & in_that);
21707 
21710  MarkerKey(MarkerKey const & in_that);
21711 
21715  MarkerKey & operator=(MarkerKey const & in_that);
21716 
21720  MarkerKey(MarkerKey && in_that);
21721 
21725  MarkerKey & operator=(MarkerKey && in_that);
21726 
21727  ~MarkerKey();
21728 
21729  Type ObjectType() const { return Type::MarkerKey; };
21730 
21731 
21734  void Consume(MarkerKit & in_kit);
21735 
21738  void Set(MarkerKit const & in_kit);
21739 
21742  void Show(MarkerKit & out_kit) const;
21743 
21744 
21748  MarkerKey & SetPoint(Point const & in_point);
21749 
21753  bool ShowPoint(Point & out_point) const;
21754 };
21755 
21756 
21757 
21759 class HPS_API DistantLightKit : public Object
21760 {
21761 public:
21763  DistantLightKit();
21764 
21767  DistantLightKit(DistantLightKit const & in_kit);
21768 
21772  DistantLightKit(DistantLightKit && in_that);
21773 
21777  DistantLightKit & operator=(DistantLightKit && in_that);
21778 
21779  virtual ~DistantLightKit();
21780 
21781  Type ObjectType() const { return Type::DistantLightKit; };
21782 
21785  void Consume(DistantLightKit & in_kit);
21786 
21789  void Set(DistantLightKit const & in_kit);
21790 
21793  void Show(DistantLightKit & out_kit) const;
21794 
21798  DistantLightKit & operator=(DistantLightKit const & in_kit);
21799 
21802  bool Empty() const;
21803 
21807  bool Equals(DistantLightKit const & in_kit) const;
21808 
21812  bool operator==(DistantLightKit const & in_kit) const;
21813 
21817  bool operator!=(DistantLightKit const & in_kit) const;
21818 
21819 
21826  DistantLightKit & SetPriority(int in_priority);
21827 
21833  DistantLightKit & SetDirection(Vector const & in_vector);
21834 
21838  DistantLightKit & SetColor(RGBAColor const & in_rgba_color);
21839 
21843  DistantLightKit & SetColorByIndex(float in_index);
21844 
21850  DistantLightKit & SetCameraRelative(bool in_state);
21851 
21852 
21855  DistantLightKit & UnsetPriority();
21856 
21859  DistantLightKit & UnsetDirection();
21860 
21863  DistantLightKit & UnsetColor();
21864 
21867  DistantLightKit & UnsetCameraRelative();
21868 
21871  DistantLightKit & UnsetEverything();
21872 
21873 
21877  bool ShowPriority(int & out_priority) const;
21878 
21882  bool ShowDirection(Vector & out_vector) const;
21883 
21889  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
21890 
21894  bool ShowCameraRelative(bool & out_state) const;
21895 
21901  DistantLightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
21902 
21907  DistantLightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
21908 
21913  DistantLightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
21914 
21918  DistantLightKit & UnsetUserData(intptr_t in_index);
21919 
21924  DistantLightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
21925 
21929  DistantLightKit & UnsetUserData(IntPtrTArray const & in_indices);
21930 
21933  DistantLightKit & UnsetAllUserData();
21934 
21936  size_t ShowUserDataCount() const;
21937 
21941  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
21942 
21947  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
21948 
21953  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
21954 };
21955 
21956 
21957 
21959 class HPS_API DistantLightKey : public GeometryKey
21960 {
21961 public:
21963  DistantLightKey();
21964 
21968  explicit DistantLightKey(Key const & in_that);
21969 
21972  DistantLightKey(DistantLightKey const & in_that);
21973 
21977  DistantLightKey & operator=(DistantLightKey const & in_that);
21978 
21982  DistantLightKey(DistantLightKey && in_that);
21983 
21987  DistantLightKey & operator=(DistantLightKey && in_that);
21988 
21989  ~DistantLightKey();
21990 
21991  Type ObjectType() const { return Type::DistantLightKey; };
21992 
21995  void Consume(DistantLightKit & in_kit);
21996 
21999  void Set(DistantLightKit const & in_kit);
22000 
22003  void Show(DistantLightKit & out_kit) const;
22004 
22005 
22010  DistantLightKey & SetDirection(Vector const & in_vector);
22011 
22015  DistantLightKey & SetColor(RGBAColor const & in_rgba_color);
22016 
22020  DistantLightKey & SetColorByIndex(float in_index);
22021 
22026  DistantLightKey & SetCameraRelative(bool in_state);
22027 
22028 
22031  DistantLightKey & UnsetColor();
22032 
22033 
22037  bool ShowDirection(Vector & out_vector) const;
22038 
22044  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
22045 
22049  bool ShowCameraRelative(bool & out_state) const;
22050 };
22051 
22052 
22053 
22054 
22056 class HPS_API CylinderKit : public Object
22057 {
22058 public:
22060  CylinderKit();
22061 
22064  CylinderKit(CylinderKit const & in_kit);
22065 
22069  CylinderKit(CylinderKit && in_that);
22070 
22074  CylinderKit & operator=(CylinderKit && in_that);
22075 
22076  virtual ~CylinderKit();
22077 
22078  Type ObjectType() const { return Type::CylinderKit; };
22079 
22082  void Consume(CylinderKit & in_kit);
22083 
22086  void Set(CylinderKit const & in_kit);
22087 
22090  void Show(CylinderKit & out_kit) const;
22091 
22095  CylinderKit & operator=(CylinderKit const & in_kit);
22096 
22099  bool Empty() const;
22100 
22104  bool Equals(CylinderKit const & in_kit) const;
22105 
22109  bool operator==(CylinderKit const & in_kit) const;
22110 
22114  bool operator!=(CylinderKit const & in_kit) const;
22115 
22118  size_t GetPointCount() const;
22119 
22126  CylinderKit & SetPriority(int in_priority);
22127 
22130  CylinderKit & UnsetPriority();
22131 
22135  bool ShowPriority(int & out_priority) const;
22136 
22137 
22141  CylinderKit & SetPoints(PointArray const & in_points);
22142 
22147  CylinderKit & SetPoints(size_t in_count, Point const in_points []);
22148 
22152  CylinderKit & SetRadii(FloatArray const & in_radii);
22153 
22158  CylinderKit & SetRadii(size_t in_count, float const in_radii []);
22159 
22163  CylinderKit & SetCaps(Cylinder::Capping in_capping);
22164 
22165 
22168  CylinderKit & UnsetPoints();
22169 
22172  CylinderKit & UnsetRadii();
22173 
22176  CylinderKit & UnsetCaps();
22177 
22180  CylinderKit & UnsetEverything();
22181 
22182 
22186  bool ShowPoints(PointArray & out_points) const;
22187 
22191  bool ShowRadii(FloatArray & out_radii) const;
22192 
22196  bool ShowCaps(Cylinder::Capping & out_caps) const;
22197 
22198 
22205  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22206 
22212  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22213 
22220  CylinderKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22221 
22228  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22229 
22236  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22237 
22244  CylinderKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22245 
22251  CylinderKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22252 
22253 
22260  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22261 
22267  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22268 
22275  CylinderKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22276 
22283  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22284 
22291  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22292 
22299  CylinderKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22300 
22306  CylinderKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22307 
22308 
22311  CylinderKit & UnsetVertexColors();
22312 
22317  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
22318 
22322  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
22323 
22324 
22328  CylinderKit & UnsetVertexColors(Cylinder::Component in_apply_to);
22329 
22335  CylinderKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
22336 
22341  CylinderKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_apply_to);
22342 
22343 
22355  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
22356 
22369  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
22370 
22376  CylinderKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22377 
22382  CylinderKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22383 
22388  CylinderKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22389 
22393  CylinderKit & UnsetUserData(intptr_t in_index);
22394 
22399  CylinderKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22400 
22404  CylinderKit & UnsetUserData(IntPtrTArray const & in_indices);
22405 
22408  CylinderKit & UnsetAllUserData();
22409 
22411  size_t ShowUserDataCount() const;
22412 
22416  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22417 
22422  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22423 
22428  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22429 };
22430 
22431 
22432 
22434 class HPS_API CylinderKey : public GeometryKey
22435 {
22436 public:
22438  CylinderKey();
22439 
22443  explicit CylinderKey(Key const & in_that);
22444 
22447  CylinderKey(CylinderKey const & in_that);
22448 
22452  CylinderKey & operator=(CylinderKey const & in_that);
22453 
22457  CylinderKey(CylinderKey && in_that);
22458 
22462  CylinderKey & operator=(CylinderKey && in_that);
22463 
22464  ~CylinderKey();
22465 
22466  Type ObjectType() const { return Type::CylinderKey; };
22467 
22470  void Consume(CylinderKit & in_kit);
22471 
22474  void Set(CylinderKit const & in_kit);
22475 
22476 
22482  CylinderKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
22483 
22488  CylinderKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
22489 
22494  CylinderKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
22495 
22501  CylinderKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
22502 
22508  CylinderKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
22509 
22510 
22516  CylinderKey & EditRadiiByInsertion(size_t in_offset, size_t in_count, float const in_radii[]);
22517 
22522  CylinderKey & EditRadiiByInsertion(size_t in_offset, FloatArray const & in_radii);
22523 
22528  CylinderKey & EditRadiiByDeletion(size_t in_offset, size_t in_count);
22529 
22535  CylinderKey & EditRadiiByReplacement(size_t in_offset, size_t in_count, float const in_radii[]);
22536 
22542  CylinderKey & EditRadiiByReplacement(size_t in_offset, FloatArray const & in_radii);
22543 
22544 
22547  void Show(CylinderKit & out_kit) const;
22548 
22551  size_t GetPointCount() const;
22552 
22556  bool ShowPoints(PointArray & out_points) const;
22557 
22561  bool ShowRadii(FloatArray & out_radii) const;
22562 
22566  bool ShowCaps(Cylinder::Capping & out_caps) const;
22567 
22568 
22575  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22576 
22583  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22584 
22591  CylinderKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22592 
22593 
22600  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22601 
22608  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22609 
22616  CylinderKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Cylinder::Component in_apply_to = Cylinder::Component::Faces);
22617 
22618 
22621  CylinderKey & UnsetVertexColors();
22622 
22627  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
22628 
22632  CylinderKey & UnsetVertexColors(Cylinder::Component in_apply_to);
22633 
22639  CylinderKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_apply_to);
22640 
22641 
22653  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
22654 
22667  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
22668 };
22669 
22670 
22671 
22672 
22674 class HPS_API SphereKit : public Object
22675 {
22676 public:
22678  SphereKit();
22679 
22682  SphereKit(SphereKit const & in_kit);
22683 
22687  SphereKit(SphereKit && in_that);
22688 
22692  SphereKit & operator=(SphereKit && in_that);
22693 
22694  virtual ~SphereKit();
22695 
22696  Type ObjectType() const { return Type::SphereKit; };
22697 
22700  void Consume(SphereKit & in_kit);
22701 
22704  void Set(SphereKit const & in_kit);
22705 
22708  void Show(SphereKit & out_kit) const;
22709 
22713  SphereKit & operator=(SphereKit const & in_kit);
22714 
22717  bool Empty() const;
22718 
22722  bool Equals(SphereKit const & in_kit) const;
22723 
22727  bool operator==(SphereKit const & in_kit) const;
22728 
22732  bool operator!=(SphereKit const & in_kit) const;
22733 
22740  SphereKit & SetPriority(int in_priority);
22741 
22744  SphereKit & UnsetPriority();
22745 
22749  bool ShowPriority(int & out_priority) const;
22750 
22754  SphereKit & SetCenter(Point const & in_center);
22755 
22759  SphereKit & SetRadius(float in_radius);
22760 
22765  SphereKit & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
22766 
22767 
22770  SphereKit & UnsetCenter();
22771 
22774  SphereKit & UnsetRadius();
22775 
22778  SphereKit & UnsetBasis();
22779 
22782  SphereKit & UnsetEverything();
22783 
22784 
22788  bool ShowCenter(Point & out_center) const;
22789 
22793  bool ShowRadius(float & out_radius) const;
22794 
22799  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
22800 
22806  SphereKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
22807 
22812  SphereKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
22813 
22818  SphereKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
22819 
22823  SphereKit & UnsetUserData(intptr_t in_index);
22824 
22829  SphereKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
22830 
22834  SphereKit & UnsetUserData(IntPtrTArray const & in_indices);
22835 
22838  SphereKit & UnsetAllUserData();
22839 
22841  size_t ShowUserDataCount() const;
22842 
22846  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
22847 
22852  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
22853 
22858  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
22859 };
22860 
22862 class HPS_API SphereKey : public GeometryKey
22863 {
22864 public:
22866  SphereKey();
22867 
22871  explicit SphereKey(Key const & in_that);
22872 
22875  SphereKey(SphereKey const & in_that);
22876 
22880  SphereKey & operator=(SphereKey const & in_that);
22881 
22885  SphereKey(SphereKey && in_that);
22886 
22890  SphereKey & operator=(SphereKey && in_that);
22891 
22892  ~SphereKey();
22893 
22894  Type ObjectType() const {return Type::SphereKey;};
22895 
22898  void Consume(SphereKit & in_kit);
22899 
22902  void Set(SphereKit const & in_kit);
22903 
22906  void Show(SphereKit & out_kit) const;
22907 
22908 
22912  SphereKey & SetCenter(Point const & in_center);
22913 
22917  SphereKey & SetRadius(float in_radius);
22918 
22923  SphereKey & SetBasis(Vector const & in_vertical, Vector const & in_horizontal);
22924 
22925 
22929  bool ShowCenter(Point & out_center) const;
22930 
22934  bool ShowRadius(float & out_radius) const;
22935 
22940  bool ShowBasis(Vector & out_vertical, Vector & out_horizontal) const;
22941 };
22942 
22943 
22944 
22945 
22947 class HPS_API CircleKit : public Object
22948 {
22949 public:
22951  CircleKit();
22952 
22955  CircleKit(CircleKit const & in_kit);
22956 
22960  CircleKit(CircleKit && in_that);
22961 
22965  CircleKit & operator=(CircleKit && in_that);
22966 
22967  virtual ~CircleKit();
22968 
22969  Type ObjectType() const { return Type::CircleKit; };
22970 
22973  void Consume(CircleKit & in_kit);
22974 
22977  void Set(CircleKit const & in_kit);
22978 
22981  void Show(CircleKit & out_kit) const;
22982 
22986  CircleKit & operator=(CircleKit const & in_kit);
22987 
22990  bool Empty() const;
22991 
22995  bool Equals(CircleKit const & in_kit) const;
22996 
23000  bool operator==(CircleKit const & in_kit) const;
23001 
23005  bool operator!=(CircleKit const & in_kit) const;
23006 
23013  CircleKit & SetPriority(int const in_priority);
23014 
23017  CircleKit & UnsetPriority();
23018 
23022  bool ShowPriority(int & out_priority) const;
23023 
23024 
23025 
23029  CircleKit & SetCenter(Point const & in_center);
23030 
23034  CircleKit & SetRadius(float in_radius);
23035 
23039  CircleKit & SetNormal(Vector const & in_normal);
23040 
23041 
23044  CircleKit & UnsetCenter();
23045 
23048  CircleKit & UnsetRadius();
23049 
23052  CircleKit & UnsetNormal();
23053 
23056  CircleKit & UnsetEverything();
23057 
23058 
23062  bool ShowCenter(Point & out_center) const;
23063 
23067  bool ShowRadius(float & out_radius) const;
23068 
23072  bool ShowNormal(Vector & out_normal) const;
23073 
23079  CircleKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23080 
23085  CircleKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23086 
23091  CircleKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23092 
23096  CircleKit & UnsetUserData(intptr_t in_index);
23097 
23102  CircleKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23103 
23107  CircleKit & UnsetUserData(IntPtrTArray const & in_indices);
23108 
23111  CircleKit & UnsetAllUserData();
23112 
23114  size_t ShowUserDataCount() const;
23115 
23119  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23120 
23125  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23126 
23131  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23132 };
23133 
23134 
23137 class HPS_API CircleKey : public GeometryKey
23138 {
23139 public:
23141  CircleKey();
23142 
23146  explicit CircleKey(Key const & in_that);
23147 
23150  CircleKey(CircleKey const & in_that);
23151 
23155  CircleKey & operator=(CircleKey const & in_that);
23156 
23160  CircleKey(CircleKey && in_that);
23161 
23165  CircleKey & operator=(CircleKey && in_that);
23166 
23167  ~CircleKey();
23168 
23169  Type ObjectType() const { return Type::CircleKey; };
23170 
23171 
23174  void Consume(CircleKit & in_kit);
23175 
23178  void Set(CircleKit const & in_kit);
23179 
23182  void Show(CircleKit & out_kit) const;
23183 
23184 
23188  CircleKey & SetCenter(Point const & in_center);
23189 
23193  CircleKey & SetRadius(float in_radius);
23194 
23198  CircleKey & SetNormal(Vector const & in_normal);
23199 
23200 
23204  bool ShowCenter(Point & out_center) const;
23205 
23209  bool ShowRadius(float & out_radius) const;
23210 
23214  bool ShowNormal(Vector & out_normal) const;
23215 };
23216 
23217 
23218 
23219 
23221 class HPS_API CircularArcKit : public Object
23222 {
23223 public:
23225  CircularArcKit();
23226 
23229  CircularArcKit(CircularArcKit const & in_kit);
23230 
23234  CircularArcKit(CircularArcKit && in_that);
23235 
23239  CircularArcKit & operator=(CircularArcKit && in_that);
23240 
23241  virtual ~CircularArcKit();
23242 
23243  Type ObjectType() const { return Type::CircularArcKit; };
23244 
23247  void Consume(CircularArcKit & in_kit);
23248 
23251  void Set(CircularArcKit const & in_kit);
23252 
23255  void Show(CircularArcKit & out_kit) const;
23256 
23260  CircularArcKit & operator=(CircularArcKit const & in_kit);
23261 
23264  bool Empty() const;
23265 
23269  bool Equals(CircularArcKit const & in_kit) const;
23270 
23274  bool operator==(CircularArcKit const & in_kit) const;
23275 
23279  bool operator!=(CircularArcKit const & in_kit) const;
23280 
23287  CircularArcKit & SetPriority(int in_priority);
23288 
23291  CircularArcKit & UnsetPriority();
23292 
23296  bool ShowPriority(int & out_priority) const;
23297 
23298 
23302  CircularArcKit & SetStart(Point const & in_start);
23303 
23307  CircularArcKit & SetMiddle(Point const & in_middle);
23308 
23312  CircularArcKit & SetEnd(Point const & in_end);
23313 
23314 
23317  CircularArcKit & UnsetStart();
23318 
23321  CircularArcKit & UnsetMiddle();
23322 
23325  CircularArcKit & UnsetEnd();
23326 
23329  CircularArcKit & UnsetEverything();
23330 
23331 
23335  bool ShowStart(Point & out_start) const;
23336 
23340  bool ShowMiddle(Point & out_middle) const;
23341 
23345  bool ShowEnd(Point & out_end) const;
23346 
23352  CircularArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23353 
23358  CircularArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23359 
23364  CircularArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23365 
23369  CircularArcKit & UnsetUserData(intptr_t in_index);
23370 
23375  CircularArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23376 
23380  CircularArcKit & UnsetUserData(IntPtrTArray const & in_indices);
23381 
23384  CircularArcKit & UnsetAllUserData();
23385 
23387  size_t ShowUserDataCount() const;
23388 
23392  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23393 
23398  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23399 
23404  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23405 };
23406 
23409 class HPS_API CircularArcKey : public GeometryKey
23410 {
23411 public:
23413  CircularArcKey();
23414 
23418  explicit CircularArcKey(Key const & in_that);
23419 
23422  CircularArcKey(CircularArcKey const & in_that);
23423 
23427  CircularArcKey & operator=(CircularArcKey const & in_that);
23428 
23432  CircularArcKey(CircularArcKey && in_that);
23433 
23437  CircularArcKey & operator=(CircularArcKey && in_that);
23438 
23439  ~CircularArcKey();
23440 
23441  Type ObjectType() const { return Type::CircularArcKey; };
23442 
23443 
23446  void Consume(CircularArcKit & in_kit);
23447 
23450  void Set(CircularArcKit const & in_kit);
23451 
23454  void Show(CircularArcKit & out_kit) const;
23455 
23456 
23460  CircularArcKey & SetStart(Point const & in_start);
23461 
23465  CircularArcKey & SetMiddle(Point const & in_middle);
23466 
23470  CircularArcKey & SetEnd(Point const & in_end);
23471 
23472 
23476  bool ShowStart(Point & out_start) const;
23477 
23481  bool ShowMiddle(Point & out_middle) const;
23482 
23486  bool ShowEnd(Point & out_end) const;
23487 };
23488 
23489 
23490 
23492 class HPS_API CircularWedgeKit : public Object
23493 {
23494 public:
23496  CircularWedgeKit();
23497 
23500  CircularWedgeKit(CircularWedgeKit const & in_kit);
23501 
23505  CircularWedgeKit(CircularWedgeKit && in_that);
23506 
23510  CircularWedgeKit & operator=(CircularWedgeKit && in_that);
23511 
23512  virtual ~CircularWedgeKit();
23513 
23514  Type ObjectType() const { return Type::CircularWedgeKit; };
23515 
23518  void Consume(CircularWedgeKit & in_kit);
23519 
23522  void Set(CircularWedgeKit const & in_kit);
23523 
23526  void Show(CircularWedgeKit & out_kit) const;
23527 
23531  CircularWedgeKit & operator=(CircularWedgeKit const & in_kit);
23532 
23535  bool Empty() const;
23536 
23540  bool Equals(CircularWedgeKit const & in_kit) const;
23541 
23545  bool operator==(CircularWedgeKit const & in_kit) const;
23546 
23550  bool operator!=(CircularWedgeKit const & in_kit) const;
23551 
23552 
23559  CircularWedgeKit & SetPriority(int in_priority);
23560 
23563  CircularWedgeKit & UnsetPriority();
23564 
23568  bool ShowPriority(int & out_priority) const;
23569 
23570 
23574  CircularWedgeKit & SetStart(Point const & in_start);
23575 
23579  CircularWedgeKit & SetMiddle(Point const & in_middle);
23580 
23584  CircularWedgeKit & SetEnd(Point const & in_end);
23585 
23586 
23589  CircularWedgeKit & UnsetStart();
23590 
23593  CircularWedgeKit & UnsetMiddle();
23594 
23597  CircularWedgeKit & UnsetEnd();
23598 
23601  CircularWedgeKit & UnsetEverything();
23602 
23603 
23607  bool ShowStart(Point & out_start) const;
23608 
23612  bool ShowMiddle(Point & out_middle) const;
23613 
23617  bool ShowEnd(Point & out_end) const;
23618 
23624  CircularWedgeKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23625 
23630  CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23631 
23636  CircularWedgeKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23637 
23641  CircularWedgeKit & UnsetUserData(intptr_t in_index);
23642 
23647  CircularWedgeKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23648 
23652  CircularWedgeKit & UnsetUserData(IntPtrTArray const & in_indices);
23653 
23656  CircularWedgeKit & UnsetAllUserData();
23657 
23659  size_t ShowUserDataCount() const;
23660 
23664  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23665 
23670  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23671 
23676  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23677 };
23678 
23679 
23683 class HPS_API CircularWedgeKey : public GeometryKey
23684 {
23685 public:
23687  CircularWedgeKey();
23688 
23692  explicit CircularWedgeKey(Key const & in_that);
23693 
23696  CircularWedgeKey(CircularWedgeKey const & in_that);
23697 
23701  CircularWedgeKey & operator=(CircularWedgeKey const & in_that);
23702 
23706  CircularWedgeKey(CircularWedgeKey && in_that);
23707 
23711  CircularWedgeKey & operator=(CircularWedgeKey && in_that);
23712 
23713  ~CircularWedgeKey();
23714 
23715  Type ObjectType() const { return Type::CircularWedgeKey; };
23716 
23717 
23720  void Consume(CircularWedgeKit & in_kit);
23721 
23724  void Set(CircularWedgeKit const & in_kit);
23725 
23728  void Show(CircularWedgeKit & out_kit) const;
23729 
23730 
23734  CircularWedgeKey & SetStart(Point const & in_start);
23735 
23739  CircularWedgeKey & SetMiddle(Point const & in_middle);
23740 
23744  CircularWedgeKey & SetEnd(Point const & in_end);
23745 
23746 
23750  bool ShowStart(Point & out_start) const;
23751 
23755  bool ShowMiddle(Point & out_middle) const;
23756 
23760  bool ShowEnd(Point & out_end) const;
23761 };
23762 
23763 
23764 
23766 class HPS_API CuttingSectionKit : public Object
23767 {
23768 public:
23771 
23774  CuttingSectionKit(CuttingSectionKit const & in_kit);
23775 
23780 
23784  CuttingSectionKit & operator=(CuttingSectionKit && in_that);
23785 
23786  virtual ~CuttingSectionKit();
23787 
23788  Type ObjectType() const { return Type::CuttingSectionKit; };
23789 
23792  void Consume(CuttingSectionKit & in_kit);
23793 
23796  void Set(CuttingSectionKit const & in_kit);
23797 
23800  void Show(CuttingSectionKit & out_kit) const;
23801 
23805  CuttingSectionKit & operator=(CuttingSectionKit const & in_kit);
23806 
23809  bool Empty() const;
23810 
23814  bool Equals(CuttingSectionKit const & in_kit) const;
23815 
23819  bool operator==(CuttingSectionKit const & in_kit) const;
23820 
23824  bool operator!=(CuttingSectionKit const & in_kit) const;
23825 
23832  CuttingSectionKit & SetPriority(int in_priority);
23833 
23836  CuttingSectionKit & UnsetPriority();
23837 
23841  bool ShowPriority(int & out_priority) const;
23842 
23843 
23847  CuttingSectionKit & SetPlanes(Plane const & in_plane);
23848 
23852  CuttingSectionKit & SetPlanes(PlaneArray const & in_planes);
23853 
23858  CuttingSectionKit & SetPlanes(size_t in_count, Plane const in_planes[]);
23859 
23865  CuttingSectionKit & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
23866 
23867 
23870  CuttingSectionKit & UnsetPlanes();
23871 
23874  CuttingSectionKit & UnsetVisualization();
23875 
23878  CuttingSectionKit & UnsetEverything();
23879 
23880 
23883  size_t GetPlaneCount() const;
23884 
23888  bool ShowPlanes(PlaneArray & out_planes) const;
23889 
23895  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
23896 
23897 
23904  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
23905 
23911  CuttingSectionKit & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
23912 
23919  CuttingSectionKit & EditPlanesByDeletion(size_t in_offset, size_t in_count);
23920 
23927  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
23928 
23936  CuttingSectionKit & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
23937 
23943  CuttingSectionKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
23944 
23949  CuttingSectionKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
23950 
23955  CuttingSectionKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
23956 
23960  CuttingSectionKit & UnsetUserData(intptr_t in_index);
23961 
23966  CuttingSectionKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
23967 
23971  CuttingSectionKit & UnsetUserData(IntPtrTArray const & in_indices);
23972 
23975  CuttingSectionKit & UnsetAllUserData();
23976 
23978  size_t ShowUserDataCount() const;
23979 
23983  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
23984 
23989  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
23990 
23995  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
23996 };
23997 
23998 
24000 class HPS_API CuttingSectionKey : public GeometryKey
24001 {
24002 public:
24005 
24009  explicit CuttingSectionKey(Key const & in_that);
24010 
24013  CuttingSectionKey(CuttingSectionKey const & in_that);
24014 
24018  CuttingSectionKey & operator=(CuttingSectionKey const & in_that);
24019 
24024 
24028  CuttingSectionKey & operator=(CuttingSectionKey && in_that);
24029 
24030  ~CuttingSectionKey();
24031 
24032  Type ObjectType() const { return Type::CuttingSectionKey; };
24033 
24034 
24037  void Consume(CuttingSectionKit & in_kit);
24038 
24041  void Set(CuttingSectionKit const & in_kit);
24042 
24045  void Show(CuttingSectionKit & out_kit) const;
24046 
24047 
24051  CuttingSectionKey & SetPlanes(Plane const & in_plane);
24052 
24056  CuttingSectionKey & SetPlanes(PlaneArray const & in_planes);
24057 
24062  CuttingSectionKey & SetPlanes(size_t in_count, Plane const in_planes[]);
24063 
24069  CuttingSectionKey & SetVisualization(CuttingSection::Mode in_mode, RGBAColor const & in_color, float in_scale = 1.0f);
24070 
24071 
24074  size_t GetPlaneCount() const;
24075 
24079  bool ShowPlanes(PlaneArray & out_planes) const;
24080 
24086  bool ShowVisualization(CuttingSection::Mode & out_mode, RGBAColor & out_color, float & out_scale) const;
24087 
24088 
24095  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, size_t in_count, Plane const in_planes[]);
24096 
24102  CuttingSectionKey & EditPlanesByInsertion(size_t in_offset, PlaneArray const & in_planes);
24103 
24110  CuttingSectionKey & EditPlanesByDeletion(size_t in_offset, size_t in_count);
24111 
24118  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, size_t in_count, Plane const in_planes[]);
24119 
24127  CuttingSectionKey & EditPlanesByReplacement(size_t in_offset, PlaneArray const & in_planes);
24128 };
24129 
24130 
24131 
24133 class HPS_API InfiniteLineKit : public Object
24134 {
24135 public:
24137  InfiniteLineKit();
24138 
24141  InfiniteLineKit(InfiniteLineKit const & in_kit);
24142 
24146  InfiniteLineKit(InfiniteLineKit && in_that);
24147 
24151  InfiniteLineKit & operator=(InfiniteLineKit && in_that);
24152 
24153  virtual ~InfiniteLineKit();
24154 
24155  Type ObjectType() const { return Type::InfiniteLineKit; };
24156 
24159  void Consume(InfiniteLineKit & in_kit);
24160 
24163  void Set(InfiniteLineKit const & in_kit);
24164 
24167  void Show(InfiniteLineKit & out_kit) const;
24168 
24172  InfiniteLineKit & operator=(InfiniteLineKit const & in_kit);
24173 
24176  bool Empty() const;
24177 
24181  bool Equals(InfiniteLineKit const & in_kit) const;
24182 
24186  bool operator==(InfiniteLineKit const & in_kit) const;
24187 
24191  bool operator!=(InfiniteLineKit const & in_kit) const;
24192 
24199  InfiniteLineKit & SetPriority(int in_priority);
24200 
24203  InfiniteLineKit & UnsetPriority();
24204 
24208  bool ShowPriority(int & out_priority) const;
24209 
24210 
24214  InfiniteLineKit & SetFirst(Point const & in_first);
24215 
24219  InfiniteLineKit & SetSecond(Point const & in_second);
24220 
24224  InfiniteLineKit & SetType(InfiniteLine::Type in_type);
24225 
24226 
24229  InfiniteLineKit & UnsetFirst();
24230 
24233  InfiniteLineKit & UnsetSecond();
24234 
24237  InfiniteLineKit & UnsetType();
24238 
24241  InfiniteLineKit & UnsetEverything();
24242 
24243 
24247  bool ShowFirst(Point & out_first) const;
24248 
24252  bool ShowSecond(Point & out_second) const;
24253 
24257  bool ShowType(InfiniteLine::Type & out_type) const;
24258 
24264  InfiniteLineKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24265 
24270  InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24271 
24276  InfiniteLineKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24277 
24281  InfiniteLineKit & UnsetUserData(intptr_t in_index);
24282 
24287  InfiniteLineKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24288 
24292  InfiniteLineKit & UnsetUserData(IntPtrTArray const & in_indices);
24293 
24296  InfiniteLineKit & UnsetAllUserData();
24297 
24299  size_t ShowUserDataCount() const;
24300 
24304  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24305 
24310  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24311 
24316  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24317 };
24318 
24319 
24321 class HPS_API InfiniteLineKey : public GeometryKey
24322 {
24323 public:
24325  InfiniteLineKey();
24326 
24330  explicit InfiniteLineKey(Key const & in_that);
24331 
24334  InfiniteLineKey(InfiniteLineKey const & in_that);
24335 
24339  InfiniteLineKey & operator=(InfiniteLineKey const & in_that);
24340 
24344  InfiniteLineKey(InfiniteLineKey && in_that);
24345 
24349  InfiniteLineKey & operator=(InfiniteLineKey && in_that);
24350 
24351  ~InfiniteLineKey();
24352 
24353  Type ObjectType() const { return Type::InfiniteLineKey; };
24354 
24357  void Consume(InfiniteLineKit & in_kit);
24358 
24361  void Set(InfiniteLineKit const & in_kit);
24362 
24365  void Show(InfiniteLineKit & out_kit) const;
24366 
24367 
24371  InfiniteLineKey & SetFirst(Point const & in_first);
24372 
24376  InfiniteLineKey & SetSecond(Point const & in_second);
24377 
24381  InfiniteLineKey & SetType(InfiniteLine::Type in_type);
24382 
24383 
24387  bool ShowFirst(Point & out_first) const;
24388 
24392  bool ShowSecond(Point & out_second) const;
24393 
24397  bool ShowType(InfiniteLine::Type & out_type) const;
24398 };
24399 
24400 
24401 
24405 class HPS_API SpotlightKit : public Object
24406 {
24407 public:
24409  SpotlightKit();
24410 
24413  SpotlightKit(SpotlightKit const & in_kit);
24414 
24418  SpotlightKit(SpotlightKit && in_that);
24419 
24423  SpotlightKit & operator=(SpotlightKit && in_that);
24424 
24425  virtual ~SpotlightKit();
24426 
24427  Type ObjectType() const { return Type::SpotlightKit; };
24428 
24432  static SpotlightKit GetDefault();
24433 
24436  void Consume(SpotlightKit & in_kit);
24437 
24440  void Set(SpotlightKit const & in_kit);
24441 
24444  void Show(SpotlightKit & out_kit) const;
24445 
24449  SpotlightKit & operator=(SpotlightKit const & in_kit);
24450 
24453  bool Empty() const;
24454 
24458  bool Equals(SpotlightKit const & in_kit) const;
24459 
24463  bool operator==(SpotlightKit const & in_kit) const;
24464 
24468  bool operator!=(SpotlightKit const & in_kit) const;
24469 
24470 
24477  SpotlightKit & SetPriority(int in_priority);
24478 
24484  SpotlightKit & SetPosition(Point const & in_position);
24485 
24491  SpotlightKit & SetTarget(Point const & in_target);
24492 
24496  SpotlightKit & SetColor(RGBAColor const & in_rgba_color);
24497 
24501  SpotlightKit & SetColorByIndex(float in_index);
24502 
24508  SpotlightKit & SetOuterCone(float in_size, Spotlight::OuterConeUnits in_units = Spotlight::OuterConeUnits::Degrees);
24509 
24515  SpotlightKit & SetInnerCone(float in_size, Spotlight::InnerConeUnits in_units = Spotlight::InnerConeUnits::Percent);
24516 
24522  SpotlightKit & SetConcentration(float in_concentration);
24523 
24529  SpotlightKit & SetCameraRelative(bool in_state);
24530 
24531 
24534  SpotlightKit & UnsetPriority();
24535 
24538  SpotlightKit & UnsetPosition();
24539 
24542  SpotlightKit & UnsetTarget();
24543 
24546  SpotlightKit & UnsetColor();
24547 
24550  SpotlightKit & UnsetOuterCone();
24551 
24554  SpotlightKit & UnsetInnerCone();
24555 
24558  SpotlightKit & UnsetConcentration();
24559 
24562  SpotlightKit & UnsetCameraRelative();
24563 
24566  SpotlightKit & UnsetEverything();
24567 
24568 
24572  bool ShowPriority(int & out_priority) const;
24573 
24577  bool ShowPosition(Point & out_position) const;
24578 
24582  bool ShowTarget(Point & out_target) const;
24583 
24589  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
24590 
24595  bool ShowOuterCone(float & out_size, Spotlight::OuterConeUnits & out_units) const;
24596 
24601  bool ShowInnerCone(float & out_size, Spotlight::InnerConeUnits & out_units) const;
24602 
24606  bool ShowConcentration(float & out_concentration) const;
24607 
24611  bool ShowCameraRelative(bool & out_state) const;
24612 
24618  SpotlightKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
24619 
24624  SpotlightKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
24625 
24630  SpotlightKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
24631 
24635  SpotlightKit & UnsetUserData(intptr_t in_index);
24636 
24641  SpotlightKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
24642 
24646  SpotlightKit & UnsetUserData(IntPtrTArray const & in_indices);
24647 
24650  SpotlightKit & UnsetAllUserData();
24651 
24653  size_t ShowUserDataCount() const;
24654 
24658  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
24659 
24664  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
24665 
24670  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
24671 };
24672 
24673 
24675 class HPS_API SpotlightKey : public GeometryKey
24676 {
24677 public:
24679  SpotlightKey();
24680 
24684  explicit SpotlightKey(Key const & in_that);
24685 
24688  SpotlightKey(SpotlightKey const & in_that);
24689 
24693  SpotlightKey & operator=(SpotlightKey const & in_that);
24694 
24698  SpotlightKey(SpotlightKey && in_that);
24699 
24703  SpotlightKey & operator=(SpotlightKey && in_that);
24704 
24705  ~SpotlightKey();
24706 
24707  Type ObjectType() const { return Type::SpotlightKey; };
24708 
24711  void Consume(SpotlightKit & in_kit);
24712 
24715  void Set(SpotlightKit const & in_kit);
24716 
24719  void Show(SpotlightKit & out_kit) const;
24720 
24721 
24727  SpotlightKey & SetPosition(Point const & in_position);
24728 
24734  SpotlightKey & SetTarget(Point const & in_target);
24735 
24739  SpotlightKey & SetColor(RGBAColor const & in_rgba_color);
24740 
24744  SpotlightKey & SetColorByIndex(float in_index);
24745 
24751  SpotlightKey & SetOuterCone(float in_size, Spotlight::OuterConeUnits in_units = Spotlight::OuterConeUnits::Degrees);
24752 
24758  SpotlightKey & SetInnerCone(float in_size, Spotlight::InnerConeUnits in_units = Spotlight::InnerConeUnits::Percent);
24759 
24765  SpotlightKey & SetConcentration(float in_concentration);
24766 
24772  SpotlightKey & SetCameraRelative(bool in_state);
24773 
24774 
24777  SpotlightKey & UnsetColor();
24778 
24779 
24783  bool ShowPosition(Point & out_position) const;
24784 
24788  bool ShowTarget(Point & out_target) const;
24789 
24795  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
24796 
24801  bool ShowOuterCone(float & out_size, Spotlight::OuterConeUnits & out_units) const;
24802 
24807  bool ShowInnerCone(float & out_size, Spotlight::InnerConeUnits & out_units) const;
24808 
24812  bool ShowConcentration(float & out_concentration) const;
24813 
24817  bool ShowCameraRelative(bool & out_state) const;
24818 };
24819 
24820 
24821 
24823 class HPS_API NURBSCurveKit : public Object
24824 {
24825 public:
24827  NURBSCurveKit();
24828 
24831  NURBSCurveKit(NURBSCurveKit const & in_kit);
24832 
24836  NURBSCurveKit(NURBSCurveKit && in_that);
24837 
24841  NURBSCurveKit & operator=(NURBSCurveKit && in_that);
24842 
24843  virtual ~NURBSCurveKit();
24844 
24845  Type ObjectType() const { return Type::NURBSCurveKit; };
24846 
24849  void Consume(NURBSCurveKit & in_kit);
24850 
24853  void Set(NURBSCurveKit const & in_kit);
24854 
24857  void Show(NURBSCurveKit & out_kit) const;
24858 
24862  NURBSCurveKit & operator=(NURBSCurveKit const & in_kit);
24863 
24866  bool Empty() const;
24867 
24871  bool Equals(NURBSCurveKit const & in_kit) const;
24872 
24876  bool operator==(NURBSCurveKit const & in_kit) const;
24877 
24881  bool operator!=(NURBSCurveKit const & in_kit) const;
24882 
24885  size_t GetPointCount() const;
24886 
24893  NURBSCurveKit & SetPriority(int in_priority);
24894 
24897  NURBSCurveKit & UnsetPriority();
24898 
24902  bool ShowPriority(int & out_priority) const;
24903 
24907  NURBSCurveKit & SetDegree(size_t in_degree);
24908 
24912  NURBSCurveKit & SetPoints(PointArray const & in_points);
24913 
24918  NURBSCurveKit & SetPoints(size_t in_count, Point const in_points []);
24919 
24923  NURBSCurveKit & SetWeights(FloatArray const & in_weights);
24924 
24929  NURBSCurveKit & SetWeights(size_t in_count, float const in_weights []);
24930 
24934  NURBSCurveKit & SetKnots(FloatArray const & in_knots);
24935 
24940  NURBSCurveKit & SetKnots(size_t in_count, float const in_knots []);
24941 
24946  NURBSCurveKit & SetParameters(float in_start, float in_end);
24947 
24948 
24951  NURBSCurveKit & UnsetDegree();
24952 
24955  NURBSCurveKit & UnsetPoints();
24956 
24959  NURBSCurveKit & UnsetWeights();
24960 
24963  NURBSCurveKit & UnsetKnots();
24964 
24967  NURBSCurveKit & UnsetParameters();
24968 
24971  NURBSCurveKit & UnsetEverything();
24972 
24973 
24977  bool ShowDegree(size_t & out_degree) const;
24978 
24982  bool ShowPoints(PointArray & out_points) const;
24983 
24987  bool ShowWeights(FloatArray & out_weights) const;
24988 
24992  bool ShowKnots(FloatArray & out_knots) const;
24993 
24998  bool ShowParameters(float & out_start, float & out_end) const;
24999 
25000 
25007  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
25008 
25014  NURBSCurveKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
25015 
25022  NURBSCurveKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
25023 
25030  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25031 
25038  NURBSCurveKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25039 
25040 
25048  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
25049 
25056  NURBSCurveKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
25057 
25065  NURBSCurveKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
25066 
25073  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25074 
25081  NURBSCurveKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25082 
25083 
25089  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
25090 
25095  NURBSCurveKit & EditKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
25096 
25102  NURBSCurveKit & EditKnotsByDeletion(size_t in_offset, size_t in_count);
25103 
25110  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25111 
25118  NURBSCurveKit & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25119 
25125  NURBSCurveKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25126 
25131  NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25132 
25137  NURBSCurveKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25138 
25142  NURBSCurveKit & UnsetUserData(intptr_t in_index);
25143 
25148  NURBSCurveKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25149 
25153  NURBSCurveKit & UnsetUserData(IntPtrTArray const & in_indices);
25154 
25157  NURBSCurveKit & UnsetAllUserData();
25158 
25160  size_t ShowUserDataCount() const;
25161 
25165  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25166 
25171  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25172 
25177  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25178 };
25179 
25180 
25182 class HPS_API NURBSCurveKey : public GeometryKey
25183 {
25184 public:
25186  NURBSCurveKey();
25187 
25191  explicit NURBSCurveKey(Key const & in_that);
25192 
25195  NURBSCurveKey(NURBSCurveKey const & in_that);
25196 
25200  NURBSCurveKey & operator=(NURBSCurveKey const & in_that);
25201 
25205  NURBSCurveKey(NURBSCurveKey && in_that);
25206 
25210  NURBSCurveKey & operator=(NURBSCurveKey && in_that);
25211 
25212  ~NURBSCurveKey();
25213 
25214  Type ObjectType() const {return Type::NURBSCurveKey;};
25215 
25218  void Consume(NURBSCurveKit & in_kit);
25219 
25222  void Set(NURBSCurveKit const & in_kit);
25223 
25226  void Show(NURBSCurveKit & out_kit) const;
25227 
25230  size_t GetPointCount() const;
25231 
25236  NURBSCurveKey & SetParameters(float in_start, float in_end);
25237 
25241  bool ShowDegree(size_t & out_degree) const;
25242 
25246  bool ShowPoints(PointArray & out_points) const;
25247 
25251  bool ShowWeights(FloatArray & out_weights) const;
25252 
25256  bool ShowKnots(FloatArray & out_knots) const;
25257 
25262  bool ShowParameters(float & out_start, float & out_end) const;
25263 
25264 
25272  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25273 
25280  NURBSCurveKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25281 
25282 
25291  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25292 
25300  NURBSCurveKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25301 
25302 
25310  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25311 
25318  NURBSCurveKey & EditKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25319 };
25320 
25321 
25322 
25324 class HPS_API NURBSSurfaceKit : public Object
25325 {
25326 public:
25328  NURBSSurfaceKit();
25329 
25332  NURBSSurfaceKit(NURBSSurfaceKit const & in_kit);
25333 
25337  NURBSSurfaceKit(NURBSSurfaceKit && in_that);
25338 
25342  NURBSSurfaceKit & operator=(NURBSSurfaceKit && in_that);
25343 
25344  virtual ~NURBSSurfaceKit();
25345 
25346  Type ObjectType() const { return Type::NURBSSurfaceKit; };
25347 
25350  void Consume(NURBSSurfaceKit & in_kit);
25351 
25354  void Set(NURBSSurfaceKit const & in_kit);
25355 
25358  void Show(NURBSSurfaceKit & out_kit) const;
25359 
25363  NURBSSurfaceKit & operator=(NURBSSurfaceKit const & in_kit);
25364 
25367  bool Empty() const;
25368 
25372  bool Equals(NURBSSurfaceKit const & in_kit) const;
25373 
25377  bool operator==(NURBSSurfaceKit const & in_kit) const;
25378 
25382  bool operator!=(NURBSSurfaceKit const & in_kit) const;
25383 
25386  size_t GetPointCount() const;
25387 
25394  NURBSSurfaceKit & SetPriority(int in_priority);
25395 
25398  NURBSSurfaceKit & UnsetPriority();
25399 
25403  bool ShowPriority(int & out_priority) const;
25404 
25408  NURBSSurfaceKit & SetUDegree(size_t in_degree);
25409 
25413  NURBSSurfaceKit & SetVDegree(size_t in_degree);
25414 
25418  NURBSSurfaceKit & SetUCount(size_t in_count);
25419 
25423  NURBSSurfaceKit & SetVCount(size_t in_count);
25424 
25428  NURBSSurfaceKit & SetPoints(PointArray const & in_points);
25429 
25434  NURBSSurfaceKit & SetPoints(size_t in_count, Point const in_points []);
25435 
25440  NURBSSurfaceKit & SetWeights(FloatArray const & in_weights);
25441 
25447  NURBSSurfaceKit & SetWeights(size_t in_count, float const in_weights []);
25448 
25453  NURBSSurfaceKit & SetUKnots(FloatArray const & in_knots);
25454 
25460  NURBSSurfaceKit & SetUKnots(size_t in_count, float const in_knots []);
25461 
25466  NURBSSurfaceKit & SetVKnots(FloatArray const & in_knots);
25467 
25473  NURBSSurfaceKit & SetVKnots(size_t in_count, float const in_knots []);
25474 
25478  NURBSSurfaceKit & SetTrims(TrimKitArray const & in_trims);
25479 
25484  NURBSSurfaceKit & SetTrims(size_t in_count, TrimKit const in_trims []);
25485 
25486 
25489  NURBSSurfaceKit & UnsetUDegree();
25490 
25493  NURBSSurfaceKit & UnsetVDegree();
25494 
25497  NURBSSurfaceKit & UnsetUCount();
25498 
25501  NURBSSurfaceKit & UnsetVCount();
25502 
25505  NURBSSurfaceKit & UnsetPoints();
25506 
25509  NURBSSurfaceKit & UnsetWeights();
25510 
25513  NURBSSurfaceKit & UnsetUKnots();
25514 
25517  NURBSSurfaceKit & UnsetVKnots();
25518 
25521  NURBSSurfaceKit & UnsetTrims();
25522 
25525  NURBSSurfaceKit & UnsetEverything();
25526 
25527 
25531  bool ShowUDegree(size_t & out_degree) const;
25532 
25536  bool ShowVDegree(size_t & out_degree) const;
25537 
25541  bool ShowUCount(size_t & out_count) const;
25542 
25546  bool ShowVCount(size_t & out_count) const;
25547 
25551  bool ShowPoints(PointArray & out_points) const;
25552 
25556  bool ShowWeights(FloatArray & out_weights) const;
25557 
25561  bool ShowUKnots(FloatArray & out_knots) const;
25562 
25566  bool ShowVKnots(FloatArray & out_knots) const;
25567 
25571  bool ShowTrims(TrimKitArray & out_trims) const;
25572 
25573 
25580  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
25581 
25587  NURBSSurfaceKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
25588 
25595  NURBSSurfaceKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
25596 
25603  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25604 
25611  NURBSSurfaceKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25612 
25613 
25621  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, size_t in_count, float const in_weights[]);
25622 
25629  NURBSSurfaceKit & EditWeightsByInsertion(size_t in_offset, FloatArray const & in_weights);
25630 
25638  NURBSSurfaceKit & EditWeightsByDeletion(size_t in_offset, size_t in_count);
25639 
25646  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25647 
25654  NURBSSurfaceKit & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25655 
25656 
25663  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
25664 
25670  NURBSSurfaceKit & EditUKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
25671 
25678  NURBSSurfaceKit & EditUKnotsByDeletion(size_t in_offset, size_t in_count);
25679 
25686  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25687 
25694  NURBSSurfaceKit & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25695 
25696 
25703  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, size_t in_count, float const in_knots[]);
25704 
25710  NURBSSurfaceKit & EditVKnotsByInsertion(size_t in_offset, FloatArray const & in_knots);
25711 
25718  NURBSSurfaceKit & EditVKnotsByDeletion(size_t in_offset, size_t in_count);
25719 
25726  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25727 
25734  NURBSSurfaceKit & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25735 
25741  NURBSSurfaceKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
25742 
25747  NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
25748 
25753  NURBSSurfaceKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
25754 
25758  NURBSSurfaceKit & UnsetUserData(intptr_t in_index);
25759 
25764  NURBSSurfaceKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
25765 
25769  NURBSSurfaceKit & UnsetUserData(IntPtrTArray const & in_indices);
25770 
25773  NURBSSurfaceKit & UnsetAllUserData();
25774 
25776  size_t ShowUserDataCount() const;
25777 
25781  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
25782 
25787  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
25788 
25793  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
25794 };
25795 
25796 
25798 class HPS_API NURBSSurfaceKey : public GeometryKey
25799 {
25800 public:
25802  NURBSSurfaceKey();
25803 
25807  explicit NURBSSurfaceKey(Key const & in_that);
25808 
25811  NURBSSurfaceKey(NURBSSurfaceKey const & in_that);
25812 
25816  NURBSSurfaceKey & operator=(NURBSSurfaceKey const & in_that);
25817 
25821  NURBSSurfaceKey(NURBSSurfaceKey && in_that);
25822 
25826  NURBSSurfaceKey & operator=(NURBSSurfaceKey && in_that);
25827 
25828  ~NURBSSurfaceKey();
25829 
25830  Type ObjectType() const { return Type::NURBSSurfaceKey; };
25831 
25834  void Consume(NURBSSurfaceKit & in_kit);
25835 
25838  void Set(NURBSSurfaceKit const & in_kit);
25839 
25842  void Show(NURBSSurfaceKit & out_kit) const;
25843 
25846  size_t GetPointCount() const;
25847 
25852  NURBSSurfaceKey & SetTrims(size_t in_count, TrimKit const in_trims []);
25853 
25857  NURBSSurfaceKey & SetTrims(TrimKitArray const & in_trims);
25858 
25859 
25862  NURBSSurfaceKey & UnsetTrims();
25863 
25864 
25868  bool ShowUDegree(size_t & out_degree) const;
25869 
25873  bool ShowVDegree(size_t & out_degree) const;
25874 
25878  bool ShowUCount(size_t & out_count) const;
25879 
25883  bool ShowVCount(size_t & out_count) const;
25884 
25888  bool ShowPoints(PointArray & out_points) const;
25889 
25893  bool ShowWeights(FloatArray & out_weights) const;
25894 
25898  bool ShowUKnots(FloatArray & out_knots) const;
25899 
25903  bool ShowVKnots(FloatArray & out_knots) const;
25904 
25908  bool ShowTrims(TrimKitArray & out_trims) const;
25909 
25910 
25918  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
25919 
25926  NURBSSurfaceKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
25927 
25928 
25937  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, size_t in_count, float const in_weights[]);
25938 
25946  NURBSSurfaceKey & EditWeightsByReplacement(size_t in_offset, FloatArray const & in_weights);
25947 
25948 
25956  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25957 
25964  NURBSSurfaceKey & EditUKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25965 
25966 
25974  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, size_t in_count, float const in_knots[]);
25975 
25982  NURBSSurfaceKey & EditVKnotsByReplacement(size_t in_offset, FloatArray const & in_knots);
25983 };
25984 
25985 
25986 
25988 class HPS_API TrimElement : public Object
25989 {
25990 public:
25992  TrimElement();
25993 
25996  TrimElement(TrimElement const & in_that);
25997 
26001  TrimElement(LineKit const & in_line);
26002 
26006  TrimElement(NURBSCurveKit const & in_curve);
26007 
26011  TrimElement(TrimElement && in_that);
26012 
26016  TrimElement & operator=(TrimElement && in_that);
26017 
26018  ~TrimElement();
26019 
26020  Type ObjectType() const { return Type::TrimElement; };
26021 
26024  void Set(TrimElement const & in_that);
26025 
26029  TrimElement & operator=(TrimElement const & in_that);
26030 
26034  bool Equals(TrimElement const & in_that) const;
26035 
26039  bool operator==(TrimElement const & in_that) const;
26040 
26044  bool operator!=(TrimElement const & in_that) const;
26045 
26046 
26050  void SetCurve(LineKit const & in_line);
26051 
26055  void SetCurve(NURBSCurveKit const & in_curve);
26056 
26062  bool ShowCurve(Trim::Type & out_type, LineKit & out_line, NURBSCurveKit & out_curve) const;
26063 };
26064 
26065 
26066 
26068 class HPS_API TrimKit : public Object
26069 {
26070 public:
26072  TrimKit();
26073 
26076  TrimKit(TrimKit const & in_kit);
26077 
26081  TrimKit(TrimKit && in_that);
26082 
26086  TrimKit & operator=(TrimKit && in_that);
26087 
26088  virtual ~TrimKit();
26089 
26090  Type ObjectType() const { return Type::TrimKit; };
26091 
26094  void Set(TrimKit const & in_kit);
26095 
26098  void Show(TrimKit & out_kit) const;
26099 
26103  TrimKit & operator=(TrimKit const & in_kit);
26104 
26107  bool Empty() const;
26108 
26112  bool Equals(TrimKit const & in_kit) const;
26113 
26117  bool operator==(TrimKit const & in_kit) const;
26118 
26122  bool operator!=(TrimKit const & in_kit) const;
26123 
26124 
26129  TrimKit & SetShape(size_t in_count, TrimElement const in_shape[]);
26130 
26134  TrimKit & SetShape(TrimElementArray const & in_shape);
26135 
26139  TrimKit & SetOperation(Trim::Operation in_operation);
26140 
26141 
26144  TrimKit & UnsetShape();
26145 
26148  TrimKit & UnsetOperation();
26149 
26152  TrimKit & UnsetEverything();
26153 
26154 
26158  bool ShowShape(TrimElementArray & out_shape) const;
26159 
26163  bool ShowOperation(Trim::Operation & out_operation) const;
26164 };
26165 
26166 
26167 
26169 class HPS_API EllipseKit : public Object
26170 {
26171 public:
26173  EllipseKit();
26174 
26177  EllipseKit(EllipseKit const & in_kit);
26178 
26182  EllipseKit(EllipseKit && in_that);
26183 
26187  EllipseKit & operator=(EllipseKit && in_that);
26188 
26189  virtual ~EllipseKit();
26190 
26191  Type ObjectType() const { return Type::EllipseKit; };
26192 
26195  void Consume(EllipseKit & in_kit);
26196 
26199  void Set(EllipseKit const & in_kit);
26200 
26203  void Show(EllipseKit & out_kit) const;
26204 
26208  EllipseKit & operator=(EllipseKit const & in_kit);
26209 
26212  bool Empty() const;
26213 
26217  bool Equals(EllipseKit const & in_kit) const;
26218 
26222  bool operator==(EllipseKit const & in_kit) const;
26223 
26227  bool operator!=(EllipseKit const & in_kit) const;
26228 
26235  EllipseKit & SetPriority(int in_priority);
26236 
26239  EllipseKit & UnsetPriority();
26240 
26244  bool ShowPriority(int & out_priority) const;
26245 
26246 
26250  EllipseKit & SetCenter(Point const & in_center);
26251 
26255  EllipseKit & SetMajor(Point const & in_major);
26256 
26260  EllipseKit & SetMinor(Point const & in_minor);
26261 
26262 
26265  EllipseKit & UnsetCenter();
26266 
26269  EllipseKit & UnsetMajor();
26270 
26273  EllipseKit & UnsetMinor();
26274 
26277  EllipseKit & UnsetEverything();
26278 
26279 
26283  bool ShowCenter(Point & out_center) const;
26284 
26288  bool ShowMajor(Point & out_major) const;
26289 
26293  bool ShowMinor(Point & out_minor) const;
26294 
26300  EllipseKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26301 
26306  EllipseKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26307 
26312  EllipseKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26313 
26317  EllipseKit & UnsetUserData(intptr_t in_index);
26318 
26323  EllipseKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26324 
26328  EllipseKit & UnsetUserData(IntPtrTArray const & in_indices);
26329 
26332  EllipseKit & UnsetAllUserData();
26333 
26335  size_t ShowUserDataCount() const;
26336 
26340  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26341 
26346  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26347 
26352  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26353 };
26354 
26355 
26356 
26358 class HPS_API EllipseKey : public GeometryKey
26359 {
26360 public:
26362  EllipseKey();
26363 
26367  explicit EllipseKey(Key const & in_that);
26368 
26371  EllipseKey(EllipseKey const & in_that);
26372 
26376  EllipseKey & operator=(EllipseKey const & other);
26377 
26381  EllipseKey(EllipseKey && in_that);
26382 
26386  EllipseKey & operator=(EllipseKey && in_that);
26387 
26388  ~EllipseKey();
26389 
26390  Type ObjectType() const { return Type::EllipseKey; };
26391 
26394  void Consume(EllipseKit & in_kit);
26395 
26398  void Set(EllipseKit const & in_kit);
26399 
26402  void Show(EllipseKit & out_kit) const;
26403 
26404 
26408  EllipseKey & SetCenter(Point const & in_center);
26409 
26413  EllipseKey & SetMajor(Point const & in_major);
26414 
26418  EllipseKey & SetMinor(Point const & in_minor);
26419 
26420 
26424  bool ShowCenter(Point & out_center) const;
26425 
26429  bool ShowMajor(Point & out_major) const;
26430 
26434  bool ShowMinor(Point & out_minor) const;
26435 };
26436 
26437 
26438 
26440 class HPS_API EllipticalArcKit : public Object
26441 {
26442 public:
26444  EllipticalArcKit();
26445 
26448  EllipticalArcKit(EllipticalArcKit const & in_kit);
26449 
26453  EllipticalArcKit(EllipticalArcKit && in_that);
26454 
26458  EllipticalArcKit & operator=(EllipticalArcKit && in_that);
26459 
26460  virtual ~EllipticalArcKit();
26461 
26462  Type ObjectType() const { return Type::EllipticalArcKit; };
26463 
26466  void Consume(EllipticalArcKit & in_kit);
26467 
26470  void Set(EllipticalArcKit const & in_kit);
26471 
26474  void Show(EllipticalArcKit & out_kit) const;
26475 
26479  EllipticalArcKit & operator=(EllipticalArcKit const & in_kit);
26480 
26483  bool Empty() const;
26484 
26488  bool Equals(EllipticalArcKit const & in_kit) const;
26489 
26493  bool operator==(EllipticalArcKit const & in_kit) const;
26494 
26498  bool operator!=(EllipticalArcKit const & in_kit) const;
26499 
26506  EllipticalArcKit & SetPriority(int in_priority);
26507 
26510  EllipticalArcKit & UnsetPriority();
26511 
26515  bool ShowPriority(int & out_priority) const;
26516 
26517 
26521  EllipticalArcKit & SetCenter(Point const & in_center);
26522 
26526  EllipticalArcKit & SetMajor(Point const & in_major);
26527 
26531  EllipticalArcKit & SetMinor(Point const & in_minor);
26532 
26540  EllipticalArcKit & SetStart(float in_start);
26541 
26549  EllipticalArcKit & SetEnd(float in_end);
26550 
26551 
26554  EllipticalArcKit & UnsetCenter();
26555 
26558  EllipticalArcKit & UnsetMajor();
26559 
26562  EllipticalArcKit & UnsetMinor();
26563 
26566  EllipticalArcKit & UnsetStart();
26567 
26570  EllipticalArcKit & UnsetEnd();
26571 
26574  EllipticalArcKit & UnsetEverything();
26575 
26576 
26580  bool ShowCenter(Point & out_center) const;
26581 
26585  bool ShowMajor(Point & out_major) const;
26586 
26590  bool ShowMinor(Point & out_minor) const;
26591 
26595  bool ShowStart(float & out_start) const;
26596 
26600  bool ShowEnd(float & out_end) const;
26601 
26607  EllipticalArcKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
26608 
26613  EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
26614 
26619  EllipticalArcKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
26620 
26624  EllipticalArcKit & UnsetUserData(intptr_t in_index);
26625 
26630  EllipticalArcKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
26631 
26635  EllipticalArcKit & UnsetUserData(IntPtrTArray const & in_indices);
26636 
26639  EllipticalArcKit & UnsetAllUserData();
26640 
26642  size_t ShowUserDataCount() const;
26643 
26647  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
26648 
26653  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
26654 
26659  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
26660 };
26661 
26662 
26664 class HPS_API EllipticalArcKey : public GeometryKey
26665 {
26666 public:
26668  EllipticalArcKey();
26669 
26673  explicit EllipticalArcKey(Key const & in_that);
26674 
26677  EllipticalArcKey(EllipticalArcKey const & in_that);
26678 
26682  EllipticalArcKey & operator=(EllipticalArcKey const & other);
26683 
26687  EllipticalArcKey(EllipticalArcKey && in_that);
26688 
26692  EllipticalArcKey & operator=(EllipticalArcKey && in_that);
26693 
26694  ~EllipticalArcKey();
26695 
26696  Type ObjectType() const { return Type::EllipticalArcKey; };
26697 
26698 
26701  void Consume(EllipticalArcKit & in_kit);
26702 
26705  void Set(EllipticalArcKit const & in_kit);
26706 
26709  void Show(EllipticalArcKit & out_kit) const;
26710 
26711 
26715  EllipticalArcKey & SetCenter(Point const & in_center);
26716 
26720  EllipticalArcKey & SetMajor(Point const & in_major);
26721 
26725  EllipticalArcKey & SetMinor(Point const & in_minor);
26726 
26734  EllipticalArcKey & SetStart(float in_start);
26735 
26743  EllipticalArcKey & SetEnd(float in_end);
26744 
26745 
26749  bool ShowCenter(Point & out_center) const;
26750 
26754  bool ShowMajor(Point & out_major) const;
26755 
26759  bool ShowMinor(Point & out_minor) const;
26760 
26764  bool ShowStart(float & out_start) const;
26765 
26769  bool ShowEnd(float & out_end) const;
26770 };
26771 
26772 
26773 
26775 class HPS_API TextKit : public Object
26776 {
26777 public:
26779  TextKit();
26780 
26783  TextKit(TextKit const & in_kit);
26784 
26788  TextKit(TextKit && in_that);
26789 
26793  TextKit & operator=(TextKit && in_that);
26794 
26795  virtual ~TextKit();
26796 
26797  Type ObjectType() const { return Type::TextKit; };
26798 
26801  void Consume(TextKit & in_kit);
26802 
26805  void Set(TextKit const & in_kit);
26806 
26809  void Show(TextKit & out_kit) const;
26810 
26814  TextKit & operator=(TextKit const & in_kit);
26815 
26818  bool Empty() const;
26819 
26823  bool Equals(TextKit const & in_kit) const;
26824 
26828  bool operator==(TextKit const & in_kit) const;
26829 
26833  bool operator!=(TextKit const & in_kit) const;
26834 
26841  TextKit & SetPriority(int in_priority);
26842 
26845  TextKit & UnsetPriority();
26846 
26850  bool ShowPriority(int & out_priority) const;
26851 
26855  TextKit & SetPosition(Point const & in_position);
26856 
26860  TextKit & SetText(char const * in_string);
26861 
26865  TextKit & SetColor(RGBAColor const & in_rgba_color);
26866 
26870  TextKit & SetColorByIndex(float in_index);
26871 
26875  TextKit & SetModellingMatrix(MatrixKit const & in_matrix);
26876 
26883 
26887  TextKit & SetBold(bool in_state);
26888 
26892  TextKit & SetItalic(bool in_state);
26893 
26897  TextKit & SetOverline(bool in_state);
26898 
26902  TextKit & SetStrikethrough(bool in_state);
26903 
26907  TextKit & SetUnderline(bool in_state);
26908 
26913  TextKit & SetSlant(float in_angle);
26914 
26918  TextKit & SetLineSpacing(float in_multiplier);
26919 
26925  TextKit & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
26926 
26930  TextKit & SetRotation(float in_angle);
26931 
26937  TextKit & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
26938 
26943  TextKit & SetExtraSpace(float in_size, Text::SizeUnits in_units);
26944 
26951  TextKit & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
26952 
26958  TextKit & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
26959 
26968  TextKit & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
26969 
26977  TextKit & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
26978 
26983  TextKit & SetSize(float in_size, Text::SizeUnits in_units);
26984 
26990  TextKit & SetFont(char const * in_name);
26991 
26995  TextKit & SetTransform(Text::Transform in_trans);
26996 
27000  TextKit & SetRenderer(Text::Renderer in_rend);
27001 
27005  TextKit & SetPreference(Text::Preference in_pref);
27006 
27013  TextKit & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
27014 
27018  TextKit & SetPath(Vector const & in_path);
27019 
27025  TextKit & SetSpacing(float in_multiplier);
27026 
27027 
27030  TextKit & UnsetPosition();
27031 
27034  TextKit & UnsetText();
27035 
27038  TextKit & UnsetColor();
27039 
27042  TextKit & UnsetModellingMatrix();
27043 
27046  TextKit & UnsetAlignment();
27047 
27050  TextKit & UnsetBold();
27051 
27054  TextKit & UnsetItalic();
27055 
27058  TextKit & UnsetOverline();
27059 
27062  TextKit & UnsetStrikethrough();
27063 
27066  TextKit & UnsetUnderline();
27067 
27070  TextKit & UnsetSlant();
27071 
27074  TextKit & UnsetLineSpacing();
27075 
27078  TextKit & UnsetRotation();
27079 
27082  TextKit & UnsetExtraSpace();
27083 
27086  TextKit & UnsetGreeking();
27087 
27090  TextKit & UnsetSizeTolerance();
27091 
27094  TextKit & UnsetSize();
27095 
27098  TextKit & UnsetFont();
27099 
27102  TextKit & UnsetTransform();
27103 
27106  TextKit & UnsetRenderer();
27107 
27110  TextKit & UnsetPreference();
27111 
27114  TextKit & UnsetPath();
27115 
27118  TextKit & UnsetSpacing();
27119 
27122  TextKit & UnsetEverything();
27123 
27124 
27128  bool ShowPosition(Point & out_position) const;
27129 
27133  bool ShowText(UTF8 & out_string) const;
27134 
27140  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
27141 
27145  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
27146 
27152  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
27153 
27157  bool ShowBold(bool & out_state) const;
27158 
27162  bool ShowItalic(bool & out_state) const;
27163 
27167  bool ShowOverline(bool & out_state) const;
27168 
27172  bool ShowStrikethrough(bool & out_state) const;
27173 
27177  bool ShowUnderline(bool & out_state) const;
27178 
27182  bool ShowSlant(float & out_angle) const;
27183 
27187  bool ShowLineSpacing(float & out_multiplier) const;
27188 
27193  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
27194 
27200  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
27201 
27208  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
27209 
27215  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
27216 
27221  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
27222 
27226  bool ShowFont(UTF8 & out_name) const;
27227 
27231  bool ShowTransform(Text::Transform & out_trans) const;
27232 
27236  bool ShowRenderer(Text::Renderer & out_renderer) const;
27237 
27244  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
27245 
27249  bool ShowPath(Vector & out_path) const;
27250 
27254  bool ShowSpacing(float & out_multiplier) const;
27255 
27256 
27264  TextKit & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
27265 
27272  TextKit & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
27273 
27280  TextKit & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
27281 
27290  bool ShowRegion(PointArray & out_region, Text::RegionAlignment & out_region_alignment, bool & out_region_fitting, bool & out_region_adjust_direction, bool & out_region_relative_coordinates, bool & out_region_window_space) const;
27291 
27304  TextKit & SetRegion(PointArray & in_region, Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
27305 
27319  TextKit & SetRegion(size_t in_region_count, Point const in_region [], Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
27320 
27326  TextKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
27327 
27330  TextKit & UnsetRegion();
27331 
27336  TextKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
27337 
27342  TextKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
27343 
27347  TextKit & UnsetUserData(intptr_t in_index);
27348 
27353  TextKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
27354 
27358  TextKit & UnsetUserData(IntPtrTArray const & in_indices);
27359 
27362  TextKit & UnsetAllUserData();
27363 
27365  size_t ShowUserDataCount() const;
27366 
27370  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
27371 
27376  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
27377 
27382  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
27383 };
27384 
27385 
27387 class HPS_API TextKey : public GeometryKey
27388 {
27389 public:
27391  TextKey();
27392 
27396  explicit TextKey(Key const & in_that);
27397 
27400  TextKey(TextKey const & in_that);
27401 
27405  TextKey & operator=(TextKey const & other);
27406 
27410  TextKey(TextKey && in_that);
27411 
27415  TextKey & operator=(TextKey && in_that);
27416 
27417  ~TextKey();
27418 
27419  Type ObjectType() const {return Type::TextKey;};
27420 
27423  void Consume(TextKit & in_kit);
27424 
27427  void Set(TextKit const & in_kit);
27428 
27431  void Show(TextKit & out_kit) const;
27432 
27435  TextKey & SetTextAttributes(TextAttributeKit const & in_kit);
27436 
27440  bool ShowTextAttributes(TextAttributeKit & out_kit) const;
27441 
27445  TextKey & SetPosition(Point const & in_position);
27446 
27450  TextKey & SetText(char const * in_string);
27451 
27455  TextKey & SetColor(RGBAColor const & in_rgba_color);
27456 
27460  TextKey & SetColorByIndex(float in_index);
27461 
27465  TextKey & SetModellingMatrix(MatrixKit const & in_matrix);
27466 
27473 
27477  TextKey & SetBold(bool in_state);
27478 
27482  TextKey & SetItalic(bool in_state);
27483 
27487  TextKey & SetOverline(bool in_state);
27488 
27492  TextKey & SetStrikethrough(bool in_state);
27493 
27497  TextKey & SetUnderline(bool in_state);
27498 
27503  TextKey & SetSlant(float in_angle);
27504 
27509  TextKey & SetLineSpacing(float in_multiplier);
27510 
27516  TextKey & SetRotation(Text::Rotation in_state, float in_angle = 0.0f);
27517 
27521  TextKey & SetRotation(float in_angle);
27522 
27528  TextKey & SetExtraSpace(bool in_state, float in_size = 0.0f, Text::SizeUnits in_units = Text::SizeUnits::ObjectSpace);
27529 
27534  TextKey & SetExtraSpace(float in_size, Text::SizeUnits in_units);
27535 
27542  TextKey & SetGreeking(bool in_state, float in_size = 0.0f, Text::GreekingUnits in_units = Text::GreekingUnits::ObjectSpace, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27543 
27549  TextKey & SetGreeking(float in_size, Text::GreekingUnits in_units, Text::GreekingMode in_mode = Text::GreekingMode::Lines);
27550 
27559  TextKey & SetSizeTolerance(bool in_state, float in_size = 50.0f, Text::SizeToleranceUnits in_units = Text::SizeToleranceUnits::Percent);
27560 
27568  TextKey & SetSizeTolerance(float in_size, Text::SizeToleranceUnits in_units);
27569 
27574  TextKey & SetSize(float in_size, Text::SizeUnits in_units);
27575 
27581  TextKey & SetFont(char const * in_name);
27582 
27586  TextKey & SetTransform(Text::Transform in_transform);
27587 
27591  TextKey & SetRenderer(Text::Renderer in_renderer);
27592 
27596  TextKey & SetPreference(Text::Preference in_preference);
27597 
27605  TextKey & SetPreference(float in_cutoff, Text::SizeUnits in_units, Text::Preference in_smaller, Text::Preference in_larger);
27606 
27611  TextKey & SetPath(Vector const & in_path);
27612 
27618  TextKey & SetSpacing(float in_multiplier);
27619 
27632  TextKey & SetRegion(PointArray & in_region, Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
27633 
27647  TextKey & SetRegion(size_t in_region_count, Point const in_region [], Text::RegionAlignment in_region_alignment, bool in_region_fitting, bool in_region_adjust_direction, bool in_region_relative_coordinates, bool in_region_window_space);
27648 
27649 
27652  TextKey & UnsetColor();
27653 
27656  TextKey & UnsetModellingMatrix();
27657 
27660  TextKey & UnsetAlignment();
27661 
27664  TextKey & UnsetBold();
27665 
27668  TextKey & UnsetItalic();
27669 
27672  TextKey & UnsetOverline();
27673 
27676  TextKey & UnsetStrikethrough();
27677 
27680  TextKey & UnsetUnderline();
27681 
27684  TextKey & UnsetSlant();
27685 
27688  TextKey & UnsetLineSpacing();
27689 
27692  TextKey & UnsetRotation();
27693 
27696  TextKey & UnsetExtraSpace();
27697 
27700  TextKey & UnsetGreeking();
27701 
27704  TextKey & UnsetSizeTolerance();
27705 
27708  TextKey & UnsetSize();
27709 
27712  TextKey & UnsetFont();
27713 
27716  TextKey & UnsetTransform();
27717 
27720  TextKey & UnsetRenderer();
27721 
27724  TextKey & UnsetPreference();
27725 
27728  TextKey & UnsetPath();
27729 
27732  TextKey & UnsetSpacing();
27733 
27736  TextKey & UnsetRegion();
27737 
27740  TextKey & UnsetEverything();
27741 
27742 
27746  bool ShowPosition(Point & out_position) const;
27747 
27751  bool ShowText(UTF8 & out_string) const;
27752 
27758  bool ShowColor(Material::Type & out_type, RGBAColor & out_rgba_color, float & out_index) const;
27759 
27763  bool ShowModellingMatrix(MatrixKit & out_matrix) const;
27764 
27770  bool ShowAlignment(Text::Alignment & out_alignment, Text::ReferenceFrame & out_reference_frame, Text::Justification & out_justification) const;
27771 
27775  bool ShowBold(bool & out_state) const;
27776 
27780  bool ShowItalic(bool & out_state) const;
27781 
27785  bool ShowOverline(bool & out_state) const;
27786 
27790  bool ShowStrikethrough(bool & out_state) const;
27791 
27795  bool ShowUnderline(bool & out_state) const;
27796 
27800  bool ShowSlant(float & out_angle) const;
27801 
27805  bool ShowLineSpacing(float & out_multiplier) const;
27806 
27811  bool ShowRotation(Text::Rotation & out_rot, float & out_angle) const;
27812 
27818  bool ShowExtraSpace(bool & out_state, float & out_size, Text::SizeUnits & out_units) const;
27819 
27826  bool ShowGreeking(bool & out_state, float & out_size, Text::GreekingUnits & out_units, Text::GreekingMode & out_mode) const;
27827 
27833  bool ShowSizeTolerance(bool & out_state, float & out_size, Text::SizeToleranceUnits & out_units) const;
27834 
27839  bool ShowSize(float & out_size, Text::SizeUnits & out_units) const;
27840 
27844  bool ShowFont(UTF8 & out_name) const;
27845 
27849  bool ShowTransform(Text::Transform & out_trans) const;
27850 
27854  bool ShowRenderer(Text::Renderer & out_renderer) const;
27855 
27862  bool ShowPreference(float & out_cutoff, Text::SizeUnits & out_units, Text::Preference & out_smaller, Text::Preference & out_larger) const;
27863 
27867  bool ShowPath(Vector & out_path) const;
27868 
27872  bool ShowSpacing(float & out_multiplier) const;
27873 
27882  bool ShowRegion(PointArray & out_region, Text::RegionAlignment & out_region_alignment, bool & out_region_fitting, bool & out_region_adjust_direction, bool & out_region_relative_coordinates, bool & out_region_window_space) const;
27883 
27884 
27892  TextKey & EditTextByInsertion(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
27893 
27900  TextKey & EditTextByDeletion(size_t in_row, size_t in_column, size_t in_count);
27901 
27908  TextKey & EditTextByReplacement(size_t in_row, size_t in_column, size_t in_count, char const * in_text);
27909 };
27910 
27911 
27913 class HPS_API ShellOptimizationOptionsKit : public Object
27914 {
27915 public:
27918 
27922 
27927 
27928  virtual ~ShellOptimizationOptionsKit();
27929 
27930  Type ObjectType() const { return Type::ShellOptimizationOptionsKit; };
27931 
27934  void Consume(ShellOptimizationOptionsKit & in_kit);
27935 
27938  void Set(ShellOptimizationOptionsKit const & in_kit);
27939 
27942  void Show(ShellOptimizationOptionsKit & out_kit) const;
27943 
27947  ShellOptimizationOptionsKit & operator=(ShellOptimizationOptionsKit const & in_kit);
27948 
27953 
27956  bool Empty() const;
27957 
27961  bool Equals(ShellOptimizationOptionsKit const & in_kit) const;
27962 
27966  bool operator==(ShellOptimizationOptionsKit const & in_kit) const;
27967 
27971  bool operator!=(ShellOptimizationOptionsKit const & in_kit) const;
27972 
27976  static ShellOptimizationOptionsKit GetDefault();
27977 
27978 
27982  ShellOptimizationOptionsKit & SetNormalTolerance(float in_normal_tolerance);
27983 
27988  ShellOptimizationOptionsKit & SetTolerance(float in_tolerance, Shell::ToleranceUnits in_tolerance_units);
27989 
27994  ShellOptimizationOptionsKit & SetOrphanElimination(bool in_orphan_elimination);
27995 
28000  ShellOptimizationOptionsKit & SetHandednessOptimization(Shell::HandednessOptimization in_handedness_option);
28001 
28002 
28005  ShellOptimizationOptionsKit & UnsetNormalTolerance();
28006 
28009  ShellOptimizationOptionsKit & UnsetTolerance();
28010 
28013  ShellOptimizationOptionsKit & UnsetOrphanElimination();
28014 
28017  ShellOptimizationOptionsKit & UnsetHandednessOptimization();
28018 
28021  ShellOptimizationOptionsKit & UnsetEverything();
28022 
28023 
28027  bool ShowNormalTolerance(float & out_normal_tolerance) const;
28028 
28033  bool ShowTolerance(float & out_tolerance, Shell::ToleranceUnits & out_tolerance_units) const;
28034 
28038  bool ShowOrphanElimination(bool & out_orphan_elimination) const;
28039 
28044  bool ShowHandednessOptimization(Shell::HandednessOptimization & out_handedness_option) const;
28045 };
28046 
28047 
28051 class HPS_API ShellRelationOptionsKit : public Object
28052 {
28053 public:
28056 
28060 
28065 
28069  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit && in_that);
28070 
28071  virtual ~ShellRelationOptionsKit();
28072 
28073  Type ObjectType() const { return Type::ShellRelationOptionsKit; };
28074 
28078  static ShellRelationOptionsKit GetDefault();
28079 
28082  void Consume(ShellRelationOptionsKit & in_kit);
28083 
28086  void Set(ShellRelationOptionsKit const & in_kit);
28087 
28090  void Show(ShellRelationOptionsKit & out_kit) const;
28091 
28095  ShellRelationOptionsKit & operator=(ShellRelationOptionsKit const & in_kit);
28096 
28099  bool Empty() const;
28100 
28104  bool Equals(ShellRelationOptionsKit const & in_kit) const;
28105 
28109  bool operator==(ShellRelationOptionsKit const & in_kit) const;
28110 
28114  bool operator!=(ShellRelationOptionsKit const & in_kit) const;
28115 
28116 
28120  ShellRelationOptionsKit & SetTolerance(float in_tolerance);
28121 
28125  ShellRelationOptionsKit & SetTest(Shell::RelationTest in_test);
28126 
28131  ShellRelationOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
28132 
28136  ShellRelationOptionsKit & SetNearestFaceCalculation(bool in_state);
28137 
28138 
28141  ShellRelationOptionsKit & UnsetTolerance();
28142 
28145  ShellRelationOptionsKit & UnsetTest();
28146 
28149  ShellRelationOptionsKit & UnsetTreeContext();
28150 
28153  ShellRelationOptionsKit & UnsetNearestFaceCalculation();
28154 
28157  ShellRelationOptionsKit & UnsetEverything();
28158 
28159 
28163  bool ShowTolerance(float & out_tolerance) const;
28164 
28168  bool ShowTest(Shell::RelationTest & out_test) const;
28169 
28173  bool ShowTreeContext(TreeContext & out_tree_context) const;
28174 
28178  bool ShowNearestFaceCalculation(bool & out_state) const;
28179 };
28180 
28182 class HPS_API ShellRelationResultsKit : public Object
28183 {
28184 public:
28187 
28191 
28196 
28200  ShellRelationResultsKit & operator=(ShellRelationResultsKit && in_that);
28201 
28202  virtual ~ShellRelationResultsKit();
28203 
28204  Type ObjectType() const { return Type::ShellRelationResultsKit; };
28205 
28208  void Consume(ShellRelationResultsKit & in_kit);
28209 
28212  void Set(ShellRelationResultsKit const & in_kit);
28213 
28216  void Show(ShellRelationResultsKit & out_kit) const;
28217 
28221  ShellRelationResultsKit & operator=(ShellRelationResultsKit const & in_kit);
28222 
28225  bool Empty() const;
28226 
28230  bool Equals(ShellRelationResultsKit const & in_kit) const;
28231 
28235  bool operator==(ShellRelationResultsKit const & in_kit) const;
28236 
28240  bool operator!=(ShellRelationResultsKit const & in_kit) const;
28241 
28242 
28246  bool ShowRelations(ShellRelationArray & out_results) const;
28247 
28251  bool ShowNearestFaces(SizeTArray & out_faces) const;
28252 
28256  bool ShowDistances(FloatArray & out_distances) const;
28257 };
28258 
28259 
28261 class HPS_API ShellKit : public Object
28262 {
28263 public:
28265  ShellKit();
28266 
28269  ShellKit(ShellKit const & in_kit);
28270 
28274  ShellKit(ShellKit && in_that);
28275 
28279  ShellKit & operator=(ShellKit && in_that);
28280 
28281  virtual ~ShellKit();
28282 
28283  Type ObjectType() const { return Type::ShellKit; };
28284 
28287  void Consume(ShellKit & in_kit);
28288 
28291  void Set(ShellKit const & in_kit);
28292 
28295  void Show(ShellKit & out_kit) const;
28296 
28299  size_t GetPointCount() const;
28300 
28303  size_t GetFaceCount() const;
28304 
28308  ShellKit & operator=(ShellKit const & in_kit);
28309 
28312  bool Empty() const;
28313 
28317  bool Equals(ShellKit const & in_kit) const;
28318 
28322  bool operator==(ShellKit const & in_kit) const;
28323 
28327  bool operator!=(ShellKit const & in_kit) const;
28328 
28335  ShellKit & SetPriority(int in_priority);
28336 
28339  ShellKit & UnsetPriority();
28340 
28344  bool ShowPriority(int & out_priority) const;
28345 
28346 
28347 
28351  ShellKit & SetPoints(PointArray const & in_points);
28352 
28357  ShellKit & SetPoints(size_t in_count, Point const in_points []);
28358 
28362  ShellKit & SetFacelist(IntArray const & in_facelist);
28363 
28368  ShellKit & SetFacelist(size_t in_count, int const in_facelist []);
28369 
28372  ShellKit & UnsetPoints();
28373 
28376  ShellKit & UnsetFacelist();
28377 
28380  ShellKit & UnsetEverything();
28381 
28385  bool ShowPoints(PointArray & out_points) const;
28386 
28390  bool ShowFacelist(IntArray & out_facelist) const;
28391 
28392 
28398  ShellKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
28399 
28400 
28407  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
28408 
28414  ShellKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
28415 
28422  ShellKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
28423 
28430  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
28431 
28438  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
28439 
28446  ShellKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
28447 
28453  ShellKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
28454 
28455 
28462  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
28463 
28469  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
28470 
28477  ShellKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
28478 
28485  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
28486 
28493  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
28494 
28501  ShellKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
28502 
28508  ShellKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
28509 
28510 
28517  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
28518 
28524  ShellKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
28525 
28532  ShellKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
28533 
28540  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
28541 
28548  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
28549 
28556  ShellKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
28557 
28563  ShellKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
28564 
28565 
28571  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
28572 
28577  ShellKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
28578 
28584  ShellKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
28585 
28591  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
28592 
28597  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
28598 
28604  ShellKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
28605 
28610  ShellKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
28611 
28612 
28619  ShellKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
28620 
28627  ShellKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
28628 
28637  ShellKit & SetVertexParametersByList(size_t in_vertex_count, size_t const in_vertices[], size_t in_param_count, float const in_params[], size_t in_param_width=2);
28638 
28646  ShellKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
28647 
28648 
28654  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
28655 
28660  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
28661 
28667  ShellKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
28668 
28674  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
28675 
28680  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
28681 
28687  ShellKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
28688 
28693  ShellKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
28694 
28695 
28698  ShellKit & UnsetMaterialMapping();
28699 
28700 
28703  ShellKit & UnsetVertexColors();
28704 
28709  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
28710 
28714  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
28715 
28716 
28720  ShellKit & UnsetVertexColors(Shell::Component in_apply_to);
28721 
28727  ShellKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
28728 
28733  ShellKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
28734 
28735 
28738  ShellKit & UnsetVertexNormals();
28739 
28744  ShellKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
28745 
28749  ShellKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
28750 
28751 
28754  ShellKit & UnsetVertexParameters();
28755 
28760  ShellKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
28761 
28765  ShellKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
28766 
28767 
28770  ShellKit & UnsetVertexVisibilities();
28771 
28776  ShellKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
28777 
28781  ShellKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
28782 
28783 
28786  ShellKit & UnsetVertexEverything();
28787 
28788 
28792  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
28793 
28794 
28808  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_applied_to, MaterialTypeArray & out_types,
28809  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
28810 
28825  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_applied_to, MaterialTypeArray & out_types,
28826  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
28827 
28828 
28837  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
28838 
28847  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
28848 
28849 
28859  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
28860 
28870  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
28871 
28881  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
28882 
28892  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
28893 
28894 
28903  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
28904 
28913  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
28914 
28915 
28916 
28922  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
28923 
28928  ShellKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
28929 
28935  ShellKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
28936 
28942  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
28943 
28948  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
28949 
28955  ShellKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
28956 
28961  ShellKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
28962 
28963 
28969  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
28970 
28975  ShellKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
28976 
28982  ShellKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
28983 
28989  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
28990 
28995  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
28996 
29002  ShellKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
29003 
29008  ShellKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
29009 
29010 
29016  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29017 
29022  ShellKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
29023 
29029  ShellKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29030 
29036  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
29037 
29042  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
29043 
29049  ShellKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
29050 
29055  ShellKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
29056 
29057 
29063  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29064 
29069  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29070 
29076  ShellKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29077 
29083  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
29084 
29089  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
29090 
29096  ShellKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
29097 
29102  ShellKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
29103 
29104 
29107  ShellKit & UnsetFaceColors();
29108 
29113  ShellKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
29114 
29118  ShellKit & UnsetFaceColorsByList(SizeTArray const & in_faces);
29119 
29120 
29123  ShellKit & UnsetFaceNormals();
29124 
29129  ShellKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
29130 
29134  ShellKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
29135 
29136 
29139  ShellKit & UnsetFaceVisibilities();
29140 
29145  ShellKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
29146 
29150  ShellKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
29151 
29152 
29155  ShellKit & UnsetFaceEverything();
29156 
29157 
29167  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
29168 
29179  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
29180 
29181 
29190  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29191 
29200  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
29201 
29202 
29211  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
29212 
29221  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
29222 
29223 
29230  ShellKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
29231 
29237  ShellKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
29238 
29244  ShellKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
29245 
29251  ShellKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
29252 
29258  ShellKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
29259 
29260 
29267  ShellKit & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
29268 
29274  ShellKit & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
29275 
29281  ShellKit & EditFacelistByDeletion(size_t in_offset, size_t in_count);
29282 
29291  ShellKit & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
29292 
29300  ShellKit & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
29301 
29304  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
29305 
29310  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
29311 
29316  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
29317 
29322  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
29323 
29329  ShellKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
29330 
29335  ShellKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
29336 
29341  ShellKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
29342 
29346  ShellKit & UnsetUserData(intptr_t in_index);
29347 
29352  ShellKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
29353 
29357  ShellKit & UnsetUserData(IntPtrTArray const & in_indices);
29358 
29361  ShellKit & UnsetAllUserData();
29362 
29364  size_t ShowUserDataCount() const;
29365 
29369  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
29370 
29375  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
29376 
29381  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
29382 };
29383 
29384 
29385 
29387 class HPS_API ShellKey : public GeometryKey
29388 {
29389 public:
29391  ShellKey();
29392 
29397  explicit ShellKey(Key const & in_that);
29398 
29401  ShellKey(ShellKey const & in_that);
29402 
29406  ShellKey & operator=(ShellKey const & other);
29407 
29411  ShellKey(ShellKey && in_that);
29412 
29416  ShellKey & operator=(ShellKey && in_that);
29417 
29418  ~ShellKey();
29419 
29420  Type ObjectType() const { return Type::ShellKey; };
29421 
29424  void Consume(ShellKit & in_kit);
29425 
29428  void Set(ShellKit const & in_kit);
29429 
29432  void Show(ShellKit & out_kit) const;
29433 
29436  size_t GetPointCount() const;
29437 
29440  size_t GetFaceCount() const;
29441 
29442 
29446  ShellKey & SetPoints(PointArray const & in_points);
29447 
29452  ShellKey & SetPoints(size_t in_count, Point const in_points []);
29453 
29457  ShellKey & SetFacelist(IntArray const & in_facelist);
29458 
29463  ShellKey & SetFacelist(size_t in_count, int const in_facelist []);
29464 
29469  ShellKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
29470 
29473  ShellKey & UnsetPoints();
29474 
29477  ShellKey & UnsetFacelist();
29478 
29481  ShellKey & UnsetMaterialMapping();
29482 
29485  ShellKey & UnsetEverything();
29486 
29490  bool ShowPoints(PointArray & out_points) const;
29491 
29495  bool ShowFacelist(IntArray & out_facelist) const;
29496 
29500  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
29501 
29502 
29509  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29510 
29517  ShellKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29518 
29525  ShellKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29526 
29533  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29534 
29541  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29542 
29549  ShellKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29550 
29556  ShellKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Shell::Component in_apply_to = Shell::Component::Faces);
29557 
29558 
29565  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29566 
29573  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29574 
29581  ShellKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29582 
29589  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Shell::Component in_apply_to = Shell::Component::Faces);
29590 
29597  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Shell::Component in_apply_to = Shell::Component::Faces);
29598 
29605  ShellKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29606 
29612  ShellKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Shell::Component in_apply_to = Shell::Component::Faces);
29613 
29614 
29621  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29622 
29629  ShellKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29630 
29637  ShellKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29638 
29645  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Shell::Component in_apply_to = Shell::Component::Faces);
29646 
29653  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Shell::Component in_apply_to = Shell::Component::Faces);
29654 
29661  ShellKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29662 
29668  ShellKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Shell::Component in_apply_to = Shell::Component::Faces);
29669 
29670 
29676  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
29677 
29683  ShellKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
29684 
29690  ShellKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
29691 
29697  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
29698 
29703  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
29704 
29710  ShellKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
29711 
29716  ShellKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
29717 
29718 
29726  ShellKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
29727 
29734  ShellKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
29735 
29744  ShellKey & SetVertexParametersByList(size_t in_vertex_count, size_t const in_vertices[], size_t in_param_count, float const in_params[], size_t in_param_width=2);
29745 
29753  ShellKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
29754 
29755 
29761  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
29762 
29768  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
29769 
29775  ShellKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
29776 
29782  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
29783 
29788  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
29789 
29795  ShellKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
29796 
29801  ShellKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
29802 
29803 
29806  ShellKey & UnsetVertexColors();
29807 
29812  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
29813 
29817  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
29818 
29819 
29823  ShellKey & UnsetVertexColors(Shell::Component in_apply_to);
29824 
29830  ShellKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_apply_to);
29831 
29836  ShellKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_apply_to);
29837 
29838 
29841  ShellKey & UnsetVertexNormals();
29842 
29847  ShellKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
29848 
29852  ShellKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
29853 
29854 
29857  ShellKey & UnsetVertexParameters();
29858 
29863  ShellKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
29864 
29868  ShellKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
29869 
29870 
29873  ShellKey & UnsetVertexVisibilities();
29874 
29879  ShellKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
29880 
29884  ShellKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
29885 
29886 
29889  ShellKey & UnsetVertexEverything();
29890 
29891 
29905  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Shell::Component in_applied_to, MaterialTypeArray & out_types,
29906  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29907 
29922  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Shell::Component in_applied_to, MaterialTypeArray & out_types,
29923  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
29924 
29925 
29934  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
29935 
29944  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
29945 
29946 
29956  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
29957 
29967  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29968 
29978  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
29979 
29989  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
29990 
29991 
30000  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30001 
30010  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
30011 
30012 
30018  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
30019 
30025  ShellKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
30026 
30032  ShellKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
30033 
30039  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
30040 
30045  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
30046 
30052  ShellKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
30053 
30058  ShellKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
30059 
30060 
30066  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
30067 
30073  ShellKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
30074 
30080  ShellKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
30081 
30087  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
30088 
30093  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
30094 
30100  ShellKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
30101 
30106  ShellKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
30107 
30108 
30114  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30115 
30121  ShellKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
30122 
30128  ShellKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30129 
30135  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
30136 
30141  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
30142 
30148  ShellKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
30149 
30154  ShellKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
30155 
30156 
30162  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30163 
30169  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30170 
30176  ShellKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30177 
30183  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
30184 
30189  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
30190 
30196  ShellKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
30197 
30202  ShellKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
30203 
30204 
30207  ShellKey & UnsetFaceColors();
30208 
30213  ShellKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
30214 
30218  ShellKey & UnsetFaceColorsByList(SizeTArray const & in_vertices);
30219 
30220 
30223  ShellKey & UnsetFaceNormals();
30224 
30229  ShellKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
30230 
30234  ShellKey & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
30235 
30236 
30239  ShellKey & UnsetFaceVisibilities();
30240 
30245  ShellKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
30246 
30250  ShellKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
30251 
30252 
30255  ShellKey & UnsetFaceEverything();
30256 
30257 
30267  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
30268 
30279  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
30280 
30281 
30290  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
30291 
30300  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
30301 
30302 
30308  bool ShowNetFaceNormalsByRange(size_t in_start, size_t in_count, VectorArray & out_normals) const;
30309 
30316  bool ShowNetFaceNormalsByList(SizeTArray const & in_faces, VectorArray & out_normals) const;
30317 
30318 
30327  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
30328 
30337  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
30338 
30339 
30346  ShellKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
30347 
30353  ShellKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
30354 
30360  ShellKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
30361 
30367  ShellKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
30368 
30374  ShellKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
30375 
30376 
30383  ShellKey & EditFacelistByInsertion(size_t in_offset, size_t in_count, int const in_facelist[]);
30384 
30390  ShellKey & EditFacelistByInsertion(size_t in_offset, IntArray const & in_facelist);
30391 
30397  ShellKey & EditFacelistByDeletion(size_t in_offset, size_t in_count);
30398 
30407  ShellKey & EditFacelistByReplacement(size_t in_offset, size_t in_count, int const in_facelist[]);
30408 
30416  ShellKey & EditFacelistByReplacement(size_t in_offset, IntArray const & in_facelist);
30417 
30420  void Optimize(ShellOptimizationOptionsKit const & in_shell_optimization_kit);
30421 
30426  void ComputeRelation(PointArray const & in_points, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30427 
30432  void ComputeRelation(ShellKey const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30433 
30438  void ComputeRelation(ShellKit const & in_points_source, ShellRelationOptionsKit const & in_options, ShellRelationResultsKit & out_results) const;
30439 };
30440 
30441 
30442 
30444 class HPS_API MeshKit : public Object
30445 {
30446 public:
30448  MeshKit();
30449 
30452  MeshKit(MeshKit const & in_kit);
30453 
30457  MeshKit(MeshKit && in_that);
30458 
30462  MeshKit & operator=(MeshKit && in_that);
30463 
30464  virtual ~MeshKit();
30465 
30466  Type ObjectType() const { return Type::MeshKit; };
30467 
30470  void Consume(MeshKit & in_kit);
30471 
30474  void Set(MeshKit const & in_kit);
30475 
30478  void Show(MeshKit & out_kit) const;
30479 
30483  MeshKit & operator=(MeshKit const & in_kit);
30484 
30487  bool Empty() const;
30488 
30492  bool Equals(MeshKit const & in_kit) const;
30493 
30497  bool operator==(MeshKit const & in_kit) const;
30498 
30502  bool operator!=(MeshKit const & in_kit) const;
30503 
30506  size_t GetPointCount() const;
30507 
30514  MeshKit & SetPriority(int in_priority);
30515 
30518  MeshKit & UnsetPriority();
30519 
30523  bool ShowPriority(int & out_priority) const;
30524 
30528  MeshKit & SetPoints(PointArray const & in_points);
30529 
30534  MeshKit & SetPoints(size_t in_count, Point const in_points []);
30535 
30541  MeshKit & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
30542 
30549  MeshKit & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
30550 
30554  MeshKit & SetRows(size_t in_rows);
30555 
30559  MeshKit & SetColumns(size_t in_columns);
30560 
30563  MeshKit & UnsetPoints();
30564 
30567  MeshKit & UnsetRows();
30568 
30571  MeshKit & UnsetColumns();
30572 
30575  MeshKit & UnsetEverything();
30576 
30580  bool ShowPoints(PointArray & out_points) const;
30581 
30587  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
30588 
30592  bool ShowRows(size_t & out_rows) const;
30593 
30597  bool ShowColumns(size_t & out_columns) const;
30598 
30599 
30605  MeshKit & SetMaterialMapping(MaterialMappingKit const & in_kit);
30606 
30613  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
30614 
30620  MeshKit & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
30621 
30628  MeshKit & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
30629 
30636  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
30637 
30644  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
30645 
30652  MeshKit & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
30653 
30659  MeshKit & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
30660 
30661 
30668  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
30669 
30675  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
30676 
30683  MeshKit & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
30684 
30691  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
30692 
30699  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
30700 
30707  MeshKit & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
30708 
30714  MeshKit & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
30715 
30716 
30723  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
30724 
30730  MeshKit & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
30731 
30738  MeshKit & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
30739 
30746  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
30747 
30754  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
30755 
30762  MeshKit & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
30763 
30769  MeshKit & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
30770 
30771 
30777  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
30778 
30783  MeshKit & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
30784 
30790  MeshKit & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
30791 
30797  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
30798 
30803  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
30804 
30810  MeshKit & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
30811 
30816  MeshKit & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
30817 
30818 
30825  MeshKit & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
30826 
30833  MeshKit & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
30834 
30843  MeshKit & SetVertexParametersByList(size_t in_vertex_count, size_t const in_vertices[], size_t in_param_count, float const in_params[], size_t in_param_width=2);
30844 
30852  MeshKit & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
30853 
30854 
30860  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
30861 
30866  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
30867 
30873  MeshKit & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
30874 
30880  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
30881 
30886  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
30887 
30893  MeshKit & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
30894 
30899  MeshKit & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
30900 
30901 
30904  MeshKit & UnsetMaterialMapping();
30905 
30908  MeshKit & UnsetVertexColors();
30909 
30914  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
30915 
30919  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices);
30920 
30921 
30925  MeshKit & UnsetVertexColors(Mesh::Component in_apply_to);
30926 
30932  MeshKit & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
30933 
30938  MeshKit & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
30939 
30940 
30943  MeshKit & UnsetVertexNormals();
30944 
30949  MeshKit & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
30950 
30954  MeshKit & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
30955 
30956 
30959  MeshKit & UnsetVertexParameters();
30960 
30965  MeshKit & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
30966 
30970  MeshKit & UnsetVertexParametersByList(SizeTArray const & in_vertices);
30971 
30972 
30975  MeshKit & UnsetVertexVisibilities();
30976 
30981  MeshKit & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
30982 
30986  MeshKit & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
30987 
30988 
30991  MeshKit & UnsetVertexEverything();
30992 
30993 
30997  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
30998 
31012  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31013  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31014 
31029  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31030  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
31031 
31032 
31041  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31042 
31051  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
31052 
31053 
31063  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
31064 
31074  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31075 
31085  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
31086 
31096  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
31097 
31098 
31107  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31108 
31117  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
31118 
31119 
31125  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
31126 
31131  MeshKit & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
31132 
31138  MeshKit & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
31139 
31145  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
31146 
31151  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
31152 
31158  MeshKit & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
31159 
31164  MeshKit & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
31165 
31166 
31172  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
31173 
31178  MeshKit & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
31179 
31185  MeshKit & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
31186 
31192  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
31193 
31198  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
31199 
31205  MeshKit & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
31206 
31211  MeshKit & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
31212 
31213 
31219  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31220 
31225  MeshKit & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
31226 
31232  MeshKit & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31233 
31239  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
31240 
31245  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
31246 
31252  MeshKit & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
31253 
31258  MeshKit & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
31259 
31260 
31266  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31267 
31272  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31273 
31279  MeshKit & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31280 
31286  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
31287 
31292  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
31293 
31299  MeshKit & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
31300 
31305  MeshKit & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
31306 
31307 
31310  MeshKit & UnsetFaceColors();
31311 
31316  MeshKit & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
31317 
31321  MeshKit & UnsetFaceColorsByList(SizeTArray const & in_vertices);
31322 
31323 
31326  MeshKit & UnsetFaceNormals();
31327 
31332  MeshKit & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
31333 
31337  MeshKit & UnsetFaceNormalsByList(SizeTArray const & in_vertices);
31338 
31339 
31342  MeshKit & UnsetFaceVisibilities();
31343 
31348  MeshKit & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
31349 
31353  MeshKit & UnsetFaceVisibilitiesByList(SizeTArray const & in_vertices);
31354 
31355 
31358  MeshKit & UnsetFaceEverything();
31359 
31360 
31370  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31371 
31382  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
31383 
31384 
31393  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
31394 
31403  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
31404 
31405 
31414  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
31415 
31424  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
31425 
31431  MeshKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
31432 
31437  MeshKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
31438 
31443  MeshKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
31444 
31448  MeshKit & UnsetUserData(intptr_t in_index);
31449 
31454  MeshKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
31455 
31459  MeshKit & UnsetUserData(IntPtrTArray const & in_indices);
31460 
31463  MeshKit & UnsetAllUserData();
31464 
31466  size_t ShowUserDataCount() const;
31467 
31471  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
31472 
31477  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
31478 
31483  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
31484 
31485 };
31486 
31487 
31488 
31490 class HPS_API MeshKey : public GeometryKey
31491 {
31492 public:
31494  MeshKey();
31495 
31500  explicit MeshKey(Key const & in_that);
31501 
31504  MeshKey(MeshKey const & in_that);
31505 
31509  MeshKey & operator=(MeshKey const & in_that);
31510 
31514  MeshKey(MeshKey && in_that);
31515 
31519  MeshKey & operator=(MeshKey && in_that);
31520 
31521  ~MeshKey();
31522 
31523  Type ObjectType() const { return Type::MeshKey; };
31524 
31527  void Consume(MeshKit & in_kit);
31528 
31531  void Set(MeshKit const & in_kit);
31532 
31535  void Show(MeshKit & out_kit) const;
31536 
31539  size_t GetPointCount() const;
31540 
31546  MeshKey & SetPoints(size_t in_rows, size_t in_columns, PointArray const & in_points);
31547 
31554  MeshKey & SetPoints(size_t in_rows, size_t in_columns, size_t in_count, Point const in_points []);
31555 
31559  bool ShowPoints(PointArray & out_points) const;
31560 
31566  bool ShowPoints(size_t & out_rows, size_t & out_columns, PointArray & out_points) const;
31567 
31571  bool ShowRows(size_t & out_rows) const;
31572 
31576  bool ShowColumns(size_t & out_columns) const;
31577 
31578 
31583  MeshKey & SetMaterialMapping(MaterialMappingKit const & in_kit);
31584 
31587  MeshKey & UnsetMaterialMapping();
31588 
31592  bool ShowMaterialMapping(MaterialMappingKit & out_kit) const;
31593 
31594 
31601  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31602 
31609  MeshKey & SetVertexRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31610 
31617  MeshKey & SetVertexRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31618 
31625  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const in_rgb_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31626 
31633  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColorArray const & in_rgb_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31634 
31641  MeshKey & SetVertexRGBColorsByList(size_t in_count, size_t const in_vertices[], RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31642 
31648  MeshKey & SetVertexRGBColorsByList(SizeTArray const & in_vertices, RGBColor const & in_rgb_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31649 
31650 
31657  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31658 
31665  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31666 
31673  MeshKey & SetVertexRGBAColorsByRange(size_t in_start, size_t in_count, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31674 
31681  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const in_rgba_colors[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31682 
31689  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColorArray const & in_rgba_colors, Mesh::Component in_apply_to = Mesh::Component::Faces);
31690 
31697  MeshKey & SetVertexRGBAColorsByList(size_t in_count, size_t const in_vertices[], RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31698 
31704  MeshKey & SetVertexRGBAColorsByList(SizeTArray const & in_vertices, RGBAColor const & in_rgba_color, Mesh::Component in_apply_to = Mesh::Component::Faces);
31705 
31706 
31713  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31714 
31721  MeshKey & SetVertexIndexColorsByRange(size_t in_start, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31722 
31729  MeshKey & SetVertexIndexColorsByRange(size_t in_start, size_t in_count, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31730 
31737  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float const in_indices[], Mesh::Component in_apply_to = Mesh::Component::Faces);
31738 
31745  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, FloatArray const & in_indices, Mesh::Component in_apply_to = Mesh::Component::Faces);
31746 
31753  MeshKey & SetVertexIndexColorsByList(size_t in_count, size_t const in_vertices[], float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31754 
31760  MeshKey & SetVertexIndexColorsByList(SizeTArray const & in_vertices, float in_index, Mesh::Component in_apply_to = Mesh::Component::Faces);
31761 
31762 
31768  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
31769 
31775  MeshKey & SetVertexNormalsByRange(size_t in_start, VectorArray const & in_normals);
31776 
31782  MeshKey & SetVertexNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
31783 
31789  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const in_normals[]);
31790 
31795  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, VectorArray const & in_normals);
31796 
31802  MeshKey & SetVertexNormalsByList(size_t in_count, size_t const in_vertices[], Vector const & in_normal);
31803 
31808  MeshKey & SetVertexNormalsByList(SizeTArray const & in_vertices, Vector const & in_normal);
31809 
31810 
31818  MeshKey & SetVertexParametersByRange(size_t in_start, size_t in_param_count, float const in_params[], size_t in_param_width=2);
31819 
31826  MeshKey & SetVertexParametersByRange(size_t in_start, FloatArray const & in_params, size_t in_param_width=2);
31827 
31836  MeshKey & SetVertexParametersByList(size_t in_vertex_count, size_t const in_vertices[], size_t in_param_count, float const in_params[], size_t in_param_width=2);
31837 
31845  MeshKey & SetVertexParametersByList(SizeTArray const & in_vertices, FloatArray const & in_params, size_t in_param_width=2);
31846 
31847 
31853  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
31854 
31860  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
31861 
31867  MeshKey & SetVertexVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
31868 
31874  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool const in_visibilities[]);
31875 
31880  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray const & in_visibilities);
31881 
31887  MeshKey & SetVertexVisibilitiesByList(size_t in_count, size_t const in_vertices[], bool in_visibility);
31888 
31893  MeshKey & SetVertexVisibilitiesByList(SizeTArray const & in_vertices, bool in_visibility);
31894 
31895 
31898  MeshKey & UnsetVertexColors();
31899 
31904  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count);
31905 
31909  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices);
31910 
31911 
31915  MeshKey & UnsetVertexColors(Mesh::Component in_apply_to);
31916 
31922  MeshKey & UnsetVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_apply_to);
31923 
31928  MeshKey & UnsetVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_apply_to);
31929 
31930 
31933  MeshKey & UnsetVertexNormals();
31934 
31939  MeshKey & UnsetVertexNormalsByRange(size_t in_start, size_t in_count);
31940 
31944  MeshKey & UnsetVertexNormalsByList(SizeTArray const & in_vertices);
31945 
31946 
31949  MeshKey & UnsetVertexParameters();
31950 
31955  MeshKey & UnsetVertexParametersByRange(size_t in_start, size_t in_count);
31956 
31960  MeshKey & UnsetVertexParametersByList(SizeTArray const & in_vertices);
31961 
31962 
31965  MeshKey & UnsetVertexVisibilities();
31966 
31971  MeshKey & UnsetVertexVisibilitiesByRange(size_t in_start, size_t in_count);
31972 
31976  MeshKey & UnsetVertexVisibilitiesByList(SizeTArray const & in_vertices);
31977 
31978 
31981  MeshKey & UnsetVertexEverything();
31982 
31985  MeshKey & UnsetEverything();
31986 
31987 
32001  bool ShowVertexColorsByRange(size_t in_start, size_t in_count, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32002  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32003 
32018  bool ShowVertexColorsByList(SizeTArray const & in_vertices, Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32019  RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices) const;
32020 
32021 
32030  bool ShowVertexNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32031 
32040  bool ShowVertexNormalsByList(SizeTArray const & in_vertices, BoolArray & out_validities, VectorArray & out_normals) const;
32041 
32042 
32052  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params) const;
32053 
32063  bool ShowVertexParametersByRange(size_t in_start, size_t in_count, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32064 
32074  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params) const;
32075 
32085  bool ShowVertexParametersByList(SizeTArray const & in_vertices, BoolArray & out_validities, FloatArray & out_params, size_t & out_param_width) const;
32086 
32087 
32096  bool ShowVertexVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32097 
32106  bool ShowVertexVisibilitiesByList(SizeTArray const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities) const;
32107 
32108 
32114  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const in_rgb_colors[]);
32115 
32121  MeshKey & SetFaceRGBColorsByRange(size_t in_start, RGBColorArray const & in_rgb_colors);
32122 
32128  MeshKey & SetFaceRGBColorsByRange(size_t in_start, size_t in_count, RGBColor const & in_rgb_color);
32129 
32135  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const in_rgb_colors[]);
32136 
32141  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColorArray const & in_rgb_colors);
32142 
32148  MeshKey & SetFaceRGBColorsByList(size_t in_count, size_t const in_faces[], RGBColor const & in_rgb_color);
32149 
32154  MeshKey & SetFaceRGBColorsByList(SizeTArray const & in_faces, RGBColor const & in_rgb_color);
32155 
32156 
32162  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float const in_indices[]);
32163 
32169  MeshKey & SetFaceIndexColorsByRange(size_t in_start, FloatArray const & in_indices);
32170 
32176  MeshKey & SetFaceIndexColorsByRange(size_t in_start, size_t in_count, float in_index);
32177 
32183  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float const in_indices[]);
32184 
32189  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, FloatArray const & in_indices);
32190 
32196  MeshKey & SetFaceIndexColorsByList(size_t in_count, size_t const in_faces[], float in_index);
32197 
32202  MeshKey & SetFaceIndexColorsByList(SizeTArray const & in_faces, float in_index);
32203 
32204 
32210  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const in_normals[]);
32211 
32217  MeshKey & SetFaceNormalsByRange(size_t in_start, VectorArray const & in_normals);
32218 
32224  MeshKey & SetFaceNormalsByRange(size_t in_start, size_t in_count, Vector const & in_normal);
32225 
32231  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const in_normals[]);
32232 
32237  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, VectorArray const & in_normals);
32238 
32244  MeshKey & SetFaceNormalsByList(size_t in_count, size_t const in_faces[], Vector const & in_normal);
32245 
32250  MeshKey & SetFaceNormalsByList(SizeTArray const & in_faces, Vector const & in_normal);
32251 
32252 
32258  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool const in_visibilities[]);
32259 
32265  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, BoolArray const & in_visibilities);
32266 
32272  MeshKey & SetFaceVisibilitiesByRange(size_t in_start, size_t in_count, bool in_visibility);
32273 
32279  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool const in_visibilities[]);
32280 
32285  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray const & in_visibilities);
32286 
32292  MeshKey & SetFaceVisibilitiesByList(size_t in_count, size_t const in_faces[], bool in_visibility);
32293 
32298  MeshKey & SetFaceVisibilitiesByList(SizeTArray const & in_faces, bool in_visibility);
32299 
32300 
32303  MeshKey & UnsetFaceColors();
32304 
32309  MeshKey & UnsetFaceColorsByRange(size_t in_start, size_t in_count);
32310 
32314  MeshKey & UnsetFaceColorsByList(SizeTArray const & in_faces);
32315 
32316 
32319  MeshKey & UnsetFaceNormals();
32320 
32325  MeshKey & UnsetFaceNormalsByRange(size_t in_start, size_t in_count);
32326 
32330  MeshKey & UnsetFaceNormalsByList(SizeTArray const & in_faces);
32331 
32332 
32335  MeshKey & UnsetFaceVisibilities();
32336 
32341  MeshKey & UnsetFaceVisibilitiesByRange(size_t in_start, size_t in_count);
32342 
32346  MeshKey & UnsetFaceVisibilitiesByList(SizeTArray const & in_faces);
32347 
32348 
32351  MeshKey & UnsetFaceEverything();
32352 
32353 
32363  bool ShowFaceColorsByRange(size_t in_start, size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32364 
32375  bool ShowFaceColorsByList(SizeTArray const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices) const;
32376 
32377 
32386  bool ShowFaceNormalsByRange(size_t in_start, size_t in_count, BoolArray & out_validities, VectorArray & out_normals) const;
32387 
32396  bool ShowFaceNormalsByList(SizeTArray const & in_faces, BoolArray & out_validities, VectorArray & out_normals) const;
32397 
32398 
32407  bool ShowFaceVisibilitiesByRange(size_t in_start, size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities) const;
32408 
32417  bool ShowFaceVisibilitiesByList(SizeTArray const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities) const;
32418 
32427  MeshKey & EditMeshByReplacement(size_t in_row_offset, size_t in_column_offset, size_t in_row_count, size_t in_column_count, size_t in_point_count, Point const in_points[]);
32428 
32436  MeshKey & EditMeshByReplacement(size_t in_row_offset, size_t in_column_offset, size_t in_row_count, size_t in_column_count, PointArray const & in_points);
32437 };
32438 
32439 
32440 
32441 
32443 class HPS_API PolygonKit : public Object
32444 {
32445 public:
32447  PolygonKit();
32448 
32451  PolygonKit(PolygonKit const & in_kit);
32452 
32456  PolygonKit(PolygonKit && in_that);
32457 
32461  PolygonKit & operator=(PolygonKit && in_that);
32462 
32463  virtual ~PolygonKit();
32464 
32465  Type ObjectType() const { return Type::PolygonKit; };
32466 
32469  void Consume(PolygonKit & in_kit);
32470 
32473  void Set(PolygonKit const & in_kit);
32474 
32477  void Show(PolygonKit & out_kit) const;
32478 
32482  PolygonKit & operator=(PolygonKit const & in_kit);
32483 
32486  bool Empty() const;
32487 
32491  bool Equals(PolygonKit const & in_kit) const;
32492 
32496  bool operator==(PolygonKit const & in_kit) const;
32497 
32501  bool operator!=(PolygonKit const & in_kit) const;
32502 
32505  size_t GetPointCount() const;
32506 
32513  PolygonKit & SetPriority(int in_priority);
32514 
32517  PolygonKit & UnsetPriority();
32518 
32522  bool ShowPriority(int & out_priority) const;
32523 
32524 
32528  PolygonKit & SetPoints(PointArray const & in_points);
32529 
32534  PolygonKit & SetPoints(size_t in_count, Point const in_points []);
32535 
32538  PolygonKit & UnsetPoints();
32539 
32542  PolygonKit & UnsetEverything();
32543 
32547  bool ShowPoints(PointArray & out_points) const;
32548 
32554  PolygonKit & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
32555 
32560  PolygonKit & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
32561 
32566  PolygonKit & EditPointsByDeletion(size_t in_offset, size_t in_count);
32567 
32573  PolygonKit & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
32574 
32579  PolygonKit & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
32580 
32586  PolygonKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
32587 
32592  PolygonKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
32593 
32598  PolygonKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
32599 
32603  PolygonKit & UnsetUserData(intptr_t in_index);
32604 
32609  PolygonKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
32610 
32614  PolygonKit & UnsetUserData(IntPtrTArray const & in_indices);
32615 
32618  PolygonKit & UnsetAllUserData();
32619 
32621  size_t ShowUserDataCount() const;
32622 
32626  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
32627 
32632  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
32633 
32638  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
32639 };
32640 
32641 
32643 class HPS_API PolygonKey : public GeometryKey
32644 {
32645 public:
32647  PolygonKey();
32648 
32653  explicit PolygonKey(Key const & in_that);
32654 
32657  PolygonKey(PolygonKey const & in_that);
32658 
32662  PolygonKey & operator=(PolygonKey const & in_that);
32663 
32667  PolygonKey(PolygonKey && in_that);
32668 
32672  PolygonKey & operator=(PolygonKey && in_that);
32673 
32674  ~PolygonKey();
32675 
32676  Type ObjectType() const { return Type::PolygonKey; };
32677 
32678 
32681  void Consume(PolygonKit & in_kit);
32682 
32685  void Set(PolygonKit const & in_kit);
32686 
32689  void Show(PolygonKit & out_kit) const;
32690 
32693  size_t GetPointCount() const;
32694 
32698  PolygonKey & SetPoints(PointArray const & in_points);
32699 
32704  PolygonKey & SetPoints(size_t in_count, Point const in_points []);
32705 
32709  bool ShowPoints(PointArray & out_points) const;
32710 
32716  PolygonKey & EditPointsByInsertion(size_t in_offset, size_t in_count, Point const in_points[]);
32717 
32722  PolygonKey & EditPointsByInsertion(size_t in_offset, PointArray const & in_points);
32723 
32728  PolygonKey & EditPointsByDeletion(size_t in_offset, size_t in_count);
32729 
32735  PolygonKey & EditPointsByReplacement(size_t in_offset, size_t in_count, Point const in_points[]);
32736 
32741  PolygonKey & EditPointsByReplacement(size_t in_offset, PointArray const & in_points);
32742 };
32743 
32744 
32745 
32746 
32748 class HPS_API GridKit : public Object
32749 {
32750 public:
32752  GridKit();
32753 
32756  GridKit(GridKit const & in_kit);
32757 
32760  GridKit(GridKit && in_that);
32761 
32762  virtual ~GridKit();
32763 
32764  Type ObjectType() const { return Type::GridKit; };
32765 
32768  void Consume(GridKit & in_kit);
32769 
32772  void Set(GridKit const & in_kit);
32773 
32776  void Show(GridKit & out_kit) const;
32777 
32781  GridKit & operator=(GridKit const & in_kit);
32782 
32786  GridKit & operator=(GridKit && in_that);
32787 
32790  bool Empty() const;
32791 
32795  bool Equals(GridKit const & in_kit) const;
32796 
32800  bool operator==(GridKit const & in_kit) const;
32801 
32805  bool operator!=(GridKit const & in_kit) const;
32806 
32807 
32814  GridKit & SetPriority(int in_priority);
32815 
32819  GridKit & SetType(Grid::Type in_type);
32820 
32824  GridKit & SetOrigin(Point const & in_origin);
32825 
32832  GridKit & SetFirstPoint(Point const & in_first_point);
32833 
32841  GridKit & SetSecondPoint(Point const & in_second_point);
32842 
32856  GridKit & SetFirstCount(int in_first_count);
32857 
32868  GridKit & SetSecondCount(int in_second_count);
32869 
32870 
32873  GridKit & UnsetPriority();
32874 
32877  GridKit & UnsetType();
32878 
32881  GridKit & UnsetOrigin();
32882 
32885  GridKit & UnsetFirstPoint();
32886 
32889  GridKit & UnsetSecondPoint();
32890 
32893  GridKit & UnsetFirstCount();
32894 
32897  GridKit & UnsetSecondCount();
32898 
32901  GridKit & UnsetEverything();
32902 
32903 
32907  bool ShowPriority(int & out_priority) const;
32908 
32912  bool ShowType(Grid::Type & out_type) const;
32913 
32917  bool ShowOrigin(Point & out_origin) const;
32918 
32922  bool ShowFirstPoint(Point & out_first_point) const;
32923 
32927  bool ShowSecondPoint(Point & out_second_point) const;
32928 
32932  bool ShowFirstCount(int & out_first_count) const;
32933 
32937  bool ShowSecondCount(int & out_second_count) const;
32938 
32944  GridKit & SetUserData(intptr_t in_index, size_t in_bytes, byte const in_data[]);
32945 
32950  GridKit & SetUserData(intptr_t in_index, ByteArray const & in_data);
32951 
32956  GridKit & SetUserData(IntPtrTArray const & in_indices, ByteArrayArray const & in_data);
32957 
32961  GridKit & UnsetUserData(intptr_t in_index);
32962 
32967  GridKit & UnsetUserData(size_t in_count, intptr_t const in_indices[]);
32968 
32972  GridKit & UnsetUserData(IntPtrTArray const & in_indices);
32973 
32976  GridKit & UnsetAllUserData();
32977 
32979  size_t ShowUserDataCount() const;
32980 
32984  bool ShowUserDataIndices(IntPtrTArray & out_indices) const;
32985 
32990  bool ShowUserData(intptr_t in_index, ByteArray & out_data) const;
32991 
32996  bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data) const;
32997 };
32998 
32999 
33001 class HPS_API GridKey : public GeometryKey
33002 {
33003 public:
33005  GridKey();
33006 
33011  explicit GridKey(Key const & in_that);
33012 
33015  GridKey(GridKey const & in_that);
33016 
33019  GridKey(GridKey && in_that);
33020 
33024  GridKey & operator=(GridKey const & in_that);
33025 
33029  GridKey & operator=(GridKey && in_that);
33030 
33031  ~GridKey();
33032 
33033  Type ObjectType() const { return Type::GridKey; };
33034 
33037  void Consume(GridKit & in_kit);
33038 
33041  void Set(GridKit const & in_kit);
33042 
33045  void Show(GridKit & out_kit) const;
33046 
33047 
33051  GridKey & SetType(Grid::Type in_type);
33052 
33056  GridKey & SetOrigin(Point const & in_origin);
33057 
33064  GridKey & SetFirstPoint(Point const & in_first_point);
33065 
33073  GridKey & SetSecondPoint(Point const & in_second_point);
33074 
33088  GridKey & SetFirstCount(int in_first_count);
33089 
33100  GridKey & SetSecondCount(int in_second_count);
33101 
33102 
33103 
33107  bool ShowType(Grid::Type & out_type) const;
33108 
33112  bool ShowOrigin(Point & out_origin) const;
33113 
33117  bool ShowFirstPoint(Point & out_first_point) const;
33118 
33122  bool ShowSecondPoint(Point & out_second_point) const;
33123 
33127  bool ShowFirstCount(int & out_first_count) const;
33128 
33132  bool ShowSecondCount(int & out_second_count) const;
33133 };
33134 
33135 
33136 
33137 
33139 class HPS_API IncludeKey : public Key
33140 {
33141 public:
33143  IncludeKey();
33144 
33149  explicit IncludeKey(Key const & in_that);
33150 
33153  IncludeKey(IncludeKey const & in_that);
33154 
33158  IncludeKey & operator=(IncludeKey const & in_that);
33159 
33163  IncludeKey(IncludeKey && in_that);
33164 
33168  IncludeKey & operator=(IncludeKey && in_that);
33169 
33170  ~IncludeKey();
33171 
33172 
33173  Type ObjectType() const { return Type::IncludeKey; };
33174 
33177  SegmentKey GetTarget() const;
33178 
33179 
33184  IncludeKey & SetPriority(int in_priority);
33185 
33193  IncludeKey & SetCondition(Condition const & in_condition);
33194 
33195 
33198  IncludeKey & UnsetPriority();
33199 
33202  IncludeKey & UnsetCondition();
33203 
33204 
33208  bool ShowPriority(int & out_priority) const;
33209 
33213  bool ShowCondition(Condition & out_condition) const;
33214 
33220  IncludeKey & SetFilter(AttributeLock::Type in_type);
33221 
33228  IncludeKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
33229 
33235  IncludeKey & SetFilter(AttributeLockTypeArray const & in_types);
33236 
33242  IncludeKey & UnsetFilter(AttributeLock::Type in_type);
33243 
33250  IncludeKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
33251 
33257  IncludeKey & UnsetFilter(AttributeLockTypeArray const & in_types);
33258 
33264  bool ShowFilter(AttributeLockTypeArray & out_types) const;
33265 
33271  bool ShowFilter(AttributeLock::Type in_type) const;
33272 };
33273 
33274 
33275 
33277 class HPS_API StyleKey : public Key
33278 {
33279 public:
33281  StyleKey();
33282 
33287  explicit StyleKey(Key const & in_that);
33288 
33291  StyleKey(StyleKey const & in_that);
33292 
33296  StyleKey & operator=(StyleKey const & other);
33297 
33301  StyleKey(StyleKey && in_that);
33302 
33306  StyleKey & operator=(StyleKey && in_that);
33307 
33308  ~StyleKey();
33309 
33310  Type ObjectType() const { return Type::StyleKey; };
33311 
33312 
33318  bool ShowSource(Style::Type & out_type, SegmentKey & out_segment, UTF8 & out_name) const;
33319 
33320 
33328  StyleKey & SetCondition(Condition const & in_condition);
33329 
33330 
33333  StyleKey & UnsetCondition();
33334 
33335 
33339  bool ShowCondition(Condition & out_condition) const;
33340 
33341 
33347  StyleKey & SetFilter(AttributeLock::Type in_type);
33348 
33355  StyleKey & SetFilter(size_t in_count, AttributeLock::Type const in_types[]);
33356 
33362  StyleKey & SetFilter(AttributeLockTypeArray const & in_types);
33363 
33369  StyleKey & UnsetFilter(AttributeLock::Type in_type);
33370 
33377  StyleKey & UnsetFilter(size_t in_count, AttributeLock::Type const in_types[]);
33378 
33384  StyleKey & UnsetFilter(AttributeLockTypeArray const & in_types);
33385 
33391  bool ShowFilter(AttributeLockTypeArray & out_types) const;
33392 
33398  bool ShowFilter(AttributeLock::Type in_type) const;
33399 };
33400 
33401 
33402 
33404 class HPS_API ReferenceKey : public GeometryKey
33405 {
33406 public:
33408  ReferenceKey();
33409 
33414  explicit ReferenceKey(Key const & in_that);
33415 
33418  ReferenceKey(ReferenceKey const & in_that);
33419 
33423  ReferenceKey & operator=(ReferenceKey const & in_that);
33424 
33428  ReferenceKey(ReferenceKey && in_that);
33429 
33433  ReferenceKey & operator=(ReferenceKey && in_that);
33434 
33435  ~ReferenceKey();
33436 
33437  Type ObjectType() const { return Type::ReferenceKey; };
33438 
33442  Key GetTarget() const;
33443 
33447  size_t ShowTargets(bool masked=true) const;
33448 
33453  size_t ShowTargets(KeyArray & out_keys, bool masked=true) const;
33454 
33458  size_t ShowGeometryMask() const;
33459 
33464  size_t ShowGeometryMask(SearchTypeArray & out_geometry_types) const;
33465 
33469  ReferenceKey & SetGeometryMask(SearchTypeArray const & in_geometry_types);
33470 
33473  ReferenceKey & UnsetGeometryMask();
33474 
33477  void SetModellingMatrix(MatrixKit const & in_kit);
33478 
33487  ReferenceKey & SetCondition(Condition const & in_condition);
33488 
33489 
33491  void UnsetModellingMatrix();
33492 
33495  ReferenceKey & UnsetCondition();
33496 
33497 
33501  bool ShowModellingMatrix(MatrixKit & out_kit) const;
33502 
33506  bool ShowCondition(Condition & out_condition) const;
33507 
33508 
33511  ModellingMatrixControl GetModellingMatrixControl();
33512 
33515  ModellingMatrixControl const GetModellingMatrixControl() const;
33516 };
33517 
33518 
33519 
33523 class HPS_API StandAloneWindowOptionsKit : public Object
33524 {
33525 public:
33528 
33532 
33537 
33542 
33543  virtual ~StandAloneWindowOptionsKit();
33544 
33545  Type ObjectType() const { return Type::StandAloneWindowOptionsKit; };
33546 
33550  static StandAloneWindowOptionsKit GetDefault();
33551 
33554  void Set(StandAloneWindowOptionsKit const & in_kit);
33555 
33558  void Show(StandAloneWindowOptionsKit & out_kit) const;
33559 
33563  StandAloneWindowOptionsKit & operator=(StandAloneWindowOptionsKit const & in_kit);
33564 
33567  bool Empty() const;
33568 
33572  bool Equals(StandAloneWindowOptionsKit const & in_kit) const;
33573 
33577  bool operator==(StandAloneWindowOptionsKit const & in_kit) const;
33578 
33582  bool operator!=(StandAloneWindowOptionsKit const & in_kit) const;
33583 
33587  StandAloneWindowOptionsKit & SetDriver(Window::Driver in_driver);
33588 
33593  StandAloneWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
33594 
33598  StandAloneWindowOptionsKit & SetTitle(char const * in_window_name);
33599 
33604  StandAloneWindowOptionsKit & SetSubscreen(Rectangle const & in_subscreen);
33605 
33609  StandAloneWindowOptionsKit & SetMobility(Window::Mobility in_mobility);
33610 
33614  StandAloneWindowOptionsKit & SetFullScreen(bool in_state);
33615 
33618  StandAloneWindowOptionsKit & UnsetDriver();
33619 
33622  StandAloneWindowOptionsKit & UnsetAntiAliasCapable();
33623 
33626  StandAloneWindowOptionsKit & UnsetTitle();
33627 
33630  StandAloneWindowOptionsKit & UnsetSubscreen();
33631 
33634  StandAloneWindowOptionsKit & UnsetMobility();
33635 
33638  StandAloneWindowOptionsKit & UnsetFullScreen();
33639 
33642  StandAloneWindowOptionsKit & UnsetEverything();
33643 
33647  bool ShowDriver(Window::Driver & out_driver) const;
33648 
33653  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
33654 
33658  bool ShowTitle(UTF8 & out_window_name) const;
33659 
33663  bool ShowSubscreen(Rectangle & out_subscreen) const;
33664 
33668  bool ShowMobility(Window::Mobility & out_mobility) const;
33669 
33673  bool ShowFullScreen(bool & out_state) const;
33674 };
33675 
33676 
33677 
33684 {
33685 public:
33689 
33693 
33698 
33703 
33706 
33707  Type ObjectType() const { return Type::StandAloneWindowOptionsControl; };
33708 
33713 
33718  StandAloneWindowOptionsControl & SetSubscreen(Rectangle const & in_subscreen);
33719 
33723  StandAloneWindowOptionsControl & SetMobility(Window::Mobility in_mobility);
33724 
33728  StandAloneWindowOptionsControl & SetFullScreen(bool in_state);
33729 
33733  bool ShowDriver(Window::Driver & out_driver) const;
33734 
33739  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
33740 
33744  bool ShowTitle(UTF8 & out_window_name) const;
33745 
33749  bool ShowSubscreen(Rectangle & out_subscreen) const;
33750 
33754  bool ShowMobility(Window::Mobility & out_mobility) const;
33755 
33759  bool ShowFullScreen(bool & out_state) const;
33760 
33761 private:
33764 };
33765 
33766 
33767 
33771 class HPS_API OffScreenWindowOptionsKit : public Object
33772 {
33773 public:
33776 
33780 
33785 
33789  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit && in_that);
33790 
33791  virtual ~OffScreenWindowOptionsKit();
33792 
33793  Type ObjectType() const { return Type::OffScreenWindowOptionsKit; };
33794 
33798  static OffScreenWindowOptionsKit GetDefault();
33799 
33802  void Set(OffScreenWindowOptionsKit const & in_kit);
33803 
33806  void Show(OffScreenWindowOptionsKit & out_kit) const;
33807 
33811  OffScreenWindowOptionsKit & operator=(OffScreenWindowOptionsKit const & in_kit);
33812 
33815  bool Empty() const;
33816 
33820  bool Equals(OffScreenWindowOptionsKit const & in_kit) const;
33821 
33825  bool operator==(OffScreenWindowOptionsKit const & in_kit) const;
33826 
33830  bool operator!=(OffScreenWindowOptionsKit const & in_kit) const;
33831 
33835  OffScreenWindowOptionsKit & SetDriver(Window::Driver in_driver);
33836 
33841  OffScreenWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
33842 
33847  OffScreenWindowOptionsKit & SetHardwareResident(bool in_state);
33848 
33853  OffScreenWindowOptionsKit & SetOpacity(bool in_state, float in_opacity = 1.0f);
33854 
33858  OffScreenWindowOptionsKit & SetOpacity(float in_opacity);
33859 
33862  OffScreenWindowOptionsKit & UnsetDriver();
33863 
33866  OffScreenWindowOptionsKit & UnsetAntiAliasCapable();
33867 
33870  OffScreenWindowOptionsKit & UnsetHardwareResident();
33871 
33874  OffScreenWindowOptionsKit & UnsetOpacity();
33875 
33878  OffScreenWindowOptionsKit & UnsetEverything();
33879 
33883  bool ShowDriver(Window::Driver & out_driver) const;
33884 
33889  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
33890 
33894  bool ShowHardwareResident(bool & out_state) const;
33895 
33900  bool ShowOpacity(bool & out_state, float & out_opacity) const;
33901 };
33902 
33906 class HPS_API ApplicationWindowOptionsKit : public Object
33907 {
33908 public:
33911 
33915 
33920 
33925 
33926  virtual ~ApplicationWindowOptionsKit();
33927 
33928  Type ObjectType() const { return Type::ApplicationWindowOptionsKit; };
33929 
33933  static ApplicationWindowOptionsKit GetDefault();
33934 
33937  void Set(ApplicationWindowOptionsKit const & in_kit);
33938 
33941  void Show(ApplicationWindowOptionsKit & out_kit) const;
33942 
33946  ApplicationWindowOptionsKit & operator=(ApplicationWindowOptionsKit const & in_kit);
33947 
33950  bool Empty() const;
33951 
33955  bool Equals(ApplicationWindowOptionsKit const & in_kit) const;
33956 
33960  bool operator==(ApplicationWindowOptionsKit const & in_kit) const;
33961 
33965  bool operator!=(ApplicationWindowOptionsKit const & in_kit) const;
33966 
33970  ApplicationWindowOptionsKit & SetDriver(Window::Driver in_driver);
33971 
33976  ApplicationWindowOptionsKit & SetAntiAliasCapable(bool in_state, unsigned int in_samples = 4);
33977 
33981  ApplicationWindowOptionsKit & SetPlatformData(PlatformData in_platform_data);
33982 
33986  ApplicationWindowOptionsKit & SetFramebufferRetention(bool in_retain);
33987 
33990  ApplicationWindowOptionsKit & UnsetDriver();
33991 
33994  ApplicationWindowOptionsKit & UnsetAntiAliasCapable();
33995 
33998  ApplicationWindowOptionsKit & UnsetPlatformData();
33999 
34002  ApplicationWindowOptionsKit & UnsetFramebufferRetention();
34003 
34006  ApplicationWindowOptionsKit & UnsetEverything();
34007 
34011  bool ShowDriver(Window::Driver & out_driver) const;
34012 
34017  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34018 
34022  bool ShowPlatformData(PlatformData & out_platform_data) const;
34023 
34027  bool ShowFramebufferRetention(bool & out_retain) const;
34028 
34029 };
34030 
34031 
34032 
34035 {
34036 public:
34040 
34044 
34049 
34054 
34057 
34058  Type ObjectType() const { return Type::ApplicationWindowOptionsControl; };
34059 
34064 
34069  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
34070 
34074  bool ShowDriver(Window::Driver & out_driver) const;
34075 
34079  bool ShowWindowHandle(WindowHandle & out_window_handle) const;
34080 
34084  bool ShowPlatformData(PlatformData & out_platform_data) const;
34085 
34089  bool ShowFramebufferRetention(bool & out_retain) const;
34090 
34094  ApplicationWindowOptionsControl & SetWindowHandle(WindowHandle in_window_handle);
34095 
34099  ApplicationWindowOptionsControl & SetPlatformData(PlatformData in_platform_data);
34100 
34101 private:
34104 };
34105 
34106 
34107 
34112 class HPS_API StandAloneWindowKey : public WindowKey
34113 {
34114 public:
34117 
34122  StandAloneWindowKey(Key const & in_key);
34123 
34126  StandAloneWindowKey(StandAloneWindowKey const & in_that);
34127 
34132 
34136  StandAloneWindowKey & operator=(StandAloneWindowKey && in_that);
34137 
34139 
34140  Type ObjectType() const { return Type::StandAloneWindowKey; };
34141 
34144  StandAloneWindowOptionsControl const GetWindowOptionsControl() const;
34145 
34148  StandAloneWindowOptionsControl GetWindowOptionsControl();
34149 
34153  bool ShowWindowOptions(StandAloneWindowOptionsKit & out_kit) const;
34154 
34157  Window::UpdateStatus Pause();
34158 };
34159 
34160 
34161 
34163 class HPS_API ApplicationWindowKey : public WindowKey
34164 {
34165 public:
34168 
34173  ApplicationWindowKey(Key const & in_key);
34174 
34177  ApplicationWindowKey(ApplicationWindowKey const & in_that);
34178 
34183 
34187  ApplicationWindowKey & operator=(ApplicationWindowKey && in_that);
34188 
34190 
34191  Type ObjectType() const { return Type::ApplicationWindowKey; };
34192 
34195  ApplicationWindowOptionsControl const GetWindowOptionsControl() const;
34196 
34199  ApplicationWindowOptionsControl GetWindowOptionsControl();
34200 
34204  bool ShowWindowOptions(ApplicationWindowOptionsKit & out_kit) const;
34205 };
34206 
34210 
34211 
34212 
34214 class HPS_API GlyphElement : public Object
34215 {
34216 public:
34218  GlyphElement();
34219 
34222  GlyphElement(GlyphElement const & in_that);
34223 
34227  GlyphElement(GlyphElement && in_that);
34228 
34232  GlyphElement & operator=(GlyphElement && in_that);
34233 
34234  virtual ~GlyphElement();
34235 
34236  Type ObjectType() const { return Type::GlyphElement; };
34237 
34240  void Set(GlyphElement const & in_that);
34241 
34245  GlyphElement & operator=(GlyphElement const & in_that);
34246 
34250  bool Equals(GlyphElement const & in_that) const;
34251 
34255  bool operator==(GlyphElement const & in_that) const;
34256 
34260  bool operator!=(GlyphElement const & in_that) const;
34261 
34264  void SetFill(Glyph::Fill in_fill);
34265 
34268  void SetIndexedColor(byte in_index);
34269 
34271  void SetNormalColor();
34272 
34275  void SetExplicitColor(RGBAColor const & in_color);
34276 
34280  bool ShowFill(Glyph::Fill & out_fill) const;
34281 
34287  bool ShowColor(Glyph::ColorSource & out_source, byte & out_index, RGBAColor & out_color) const;
34288 };
34289 
34290 
34292 class HPS_API LineGlyphElement : public GlyphElement
34293 {
34294 public:
34296  LineGlyphElement();
34297 
34302  LineGlyphElement(GlyphElement const & in_that);
34303 
34306  LineGlyphElement(LineGlyphElement const & in_that);
34307 
34310  explicit LineGlyphElement(GlyphPointArray const & in_points);
34311 
34315  LineGlyphElement(size_t in_count, GlyphPoint const in_points[]);
34316 
34320  LineGlyphElement(LineGlyphElement && in_that);
34321 
34325  LineGlyphElement & operator=(LineGlyphElement && in_that);
34326 
34327  ~LineGlyphElement();
34328 
34329  Type ObjectType() const { return Type::LineGlyphElement; };
34330 
34333  void SetPoints(GlyphPointArray const & in_points);
34334 
34338  void SetPoints(size_t in_count, GlyphPoint const in_points[]);
34339 
34343  bool ShowPoints(GlyphPointArray & out_points) const;
34344 };
34345 
34347 class HPS_API DotGlyphElement : public GlyphElement
34348 {
34349 public:
34351  DotGlyphElement();
34352 
34357  DotGlyphElement(GlyphElement const & in_that);
34358 
34361  DotGlyphElement(DotGlyphElement const & in_that);
34362 
34365  explicit DotGlyphElement(GlyphPoint const & in_point);
34366 
34370  DotGlyphElement(DotGlyphElement && in_that);
34371 
34375  DotGlyphElement & operator=(DotGlyphElement && in_that);
34376 
34377  ~DotGlyphElement();
34378 
34379  Type ObjectType() const { return Type::DotGlyphElement; };
34380 
34383  void SetPoint(GlyphPoint const & in_point);
34384 
34388  bool ShowPoint(GlyphPoint & out_point) const;
34389 };
34390 
34391 
34393 class HPS_API EllipseGlyphElement : public GlyphElement
34394 {
34395 public:
34398 
34403  EllipseGlyphElement(GlyphElement const & in_that);
34404 
34407  EllipseGlyphElement(EllipseGlyphElement const & in_that);
34408 
34412  EllipseGlyphElement(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
34413 
34418 
34422  EllipseGlyphElement & operator=(EllipseGlyphElement && in_that);
34423 
34425 
34426  Type ObjectType() const { return Type::EllipseGlyphElement; };
34427 
34430  void SetLowerLeft(GlyphPoint const & in_point);
34431 
34434  void SetUpperRight(GlyphPoint const & in_point);
34435 
34439  void SetPoints(GlyphPoint const & in_lower_left, GlyphPoint const & in_upper_right);
34440 
34444  bool ShowLowerLeft(GlyphPoint & out_point) const;
34445 
34449  bool ShowUpperRight(GlyphPoint & out_point) const;
34450 };
34451 
34452 
34455 {
34456 public:
34459 
34464  CircularArcGlyphElement(GlyphElement const & in_that);
34465 
34469 
34474  CircularArcGlyphElement(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
34475 
34480 
34484  CircularArcGlyphElement & operator=(CircularArcGlyphElement && in_that);
34485 
34487 
34488  Type ObjectType() const { return Type::CircularArcGlyphElement; };
34489 
34492  void SetStartPoint(GlyphPoint const & in_point);
34493 
34496  void SetIntermediatePoint(GlyphPoint const & in_point);
34497 
34500  void SetEndPoint(GlyphPoint const & in_point);
34501 
34506  void SetPoints(GlyphPoint const & in_start, GlyphPoint const & in_intermediate, GlyphPoint const & in_end);
34507 
34511  bool ShowStartPoint(GlyphPoint & out_point) const;
34512 
34516  bool ShowIntermediatePoint(GlyphPoint & out_point) const;
34517 
34521  bool ShowEndPoint(GlyphPoint & out_point) const;
34522 };
34523 
34524 
34525 
34528 {
34529 public:
34532 
34537  InfiniteLineGlyphElement(GlyphElement const & in_that);
34538 
34542 
34546  InfiniteLineGlyphElement(GlyphPoint const & in_first, GlyphPoint const & in_second, InfiniteLine::Type in_type = InfiniteLine::Type::Line);
34547 
34552 
34556  InfiniteLineGlyphElement & operator=(InfiniteLineGlyphElement && in_that);
34557 
34559 
34560  Type ObjectType() const { return Type::InfiniteLineGlyphElement; };
34561 
34564  void SetFirstPoint(GlyphPoint const & in_point);
34565 
34568  void SetSecondPoint(GlyphPoint const & in_point);
34569 
34573  void SetPoints(GlyphPoint const & in_first, GlyphPoint const & in_second);
34574 
34577  void SetInfiniteType(InfiniteLine::Type in_type);
34578 
34582  bool ShowFirstPoint(GlyphPoint & out_point) const;
34583 
34587  bool ShowSecondPoint(GlyphPoint & out_point) const;
34588 
34592  bool ShowInfiniteType(InfiniteLine::Type & out_type) const;
34593 };
34594 
34595 
34596 
34598 class HPS_API GlyphKit : public Object
34599 {
34600 public:
34602  GlyphKit();
34603 
34606  GlyphKit(GlyphKit const & in_kit);
34607 
34611  GlyphKit(GlyphKit && in_that);
34612 
34616  GlyphKit & operator=(GlyphKit && in_that);
34617 
34618  virtual ~GlyphKit();
34619 
34620  Type ObjectType() const { return Type::GlyphKit; };
34621 
34625  static GlyphKit GetDefault(Glyph::Default in_default_glyph);
34626 
34629  void Set(GlyphKit const & in_kit);
34630 
34633  void Show(GlyphKit & out_kit) const;
34634 
34638  GlyphKit & operator=(GlyphKit const & in_kit);
34639 
34642  bool Empty() const;
34643 
34647  bool Equals(GlyphKit const & in_kit) const;
34648 
34652  bool operator==(GlyphKit const & in_kit) const;
34653 
34657  bool operator!=(GlyphKit const & in_kit) const;
34658 
34662  GlyphKit & SetRadius(sbyte in_radius);
34663 
34668  GlyphKit & SetOffset(GlyphPoint const & in_point);
34669 
34673  GlyphKit & SetElements(GlyphElementArray const & in_def);
34674 
34679  GlyphKit & SetElements(size_t in_count, GlyphElement const in_def []);
34680 
34683  GlyphKit & UnsetRadius();
34684 
34687  GlyphKit & UnsetOffset();
34688 
34691  GlyphKit & UnsetElements();
34692 
34695  GlyphKit & UnsetEverything();
34696 
34700  bool ShowRadius(sbyte & out_radius) const;
34701 
34705  bool ShowOffset(GlyphPoint & out_point) const;
34706 
34710  bool ShowElements(GlyphElementArray & out_def) const;
34711 };
34712 
34716 
34717 
34720 class HPS_API LinePatternOptionsKit : public Object
34721 {
34722 public:
34725 
34729 
34734 
34738  LinePatternOptionsKit & operator=(LinePatternOptionsKit && in_that);
34739 
34740  virtual ~LinePatternOptionsKit();
34741 
34742  Type ObjectType() const { return Type::LinePatternOptionsKit; };
34743 
34746  void Set(LinePatternOptionsKit const & in_kit);
34747 
34750  void Show(LinePatternOptionsKit & out_kit) const;
34751 
34755  LinePatternOptionsKit & operator=(LinePatternOptionsKit const & in_kit);
34756 
34759  bool Empty() const;
34760 
34764  bool Equals(LinePatternOptionsKit const & in_kit) const;
34765 
34769  bool operator==(LinePatternOptionsKit const & in_kit) const;
34770 
34774  bool operator!=(LinePatternOptionsKit const & in_kit) const;
34775 
34779  LinePatternOptionsKit & SetStartCap(char const * in_glyph);
34780 
34784  LinePatternOptionsKit & SetStartCap(LinePattern::Cap in_type);
34785 
34789  LinePatternOptionsKit & SetEndCap(char const * in_glyph);
34790 
34794  LinePatternOptionsKit & SetEndCap(LinePattern::Cap in_type);
34795 
34799  LinePatternOptionsKit & SetInnerCap(LinePattern::Cap in_type);
34800 
34804  LinePatternOptionsKit & SetJoin(char const * in_glyph);
34805 
34809  LinePatternOptionsKit & SetJoin(LinePattern::Join in_type);
34810 
34814  LinePatternOptionsKit & UnsetStartCap();
34815 
34819  LinePatternOptionsKit & UnsetEndCap();
34820 
34823  LinePatternOptionsKit & UnsetInnerCap();
34824 
34828  LinePatternOptionsKit & UnsetJoin();
34829 
34832  LinePatternOptionsKit & UnsetEverything();
34833 
34839  bool ShowStartCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
34840 
34846  bool ShowEndCap(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Cap & out_type) const;
34847 
34851  bool ShowInnerCap(LinePattern::Cap & out_type) const;
34852 
34858  bool ShowJoin(LinePattern::Modifier & out_modifier, UTF8 & out_glyph, LinePattern::Join & out_type) const;
34859 };
34860 
34863 class HPS_API LinePatternElement : public Object
34864 {
34865 public:
34868 
34871  LinePatternElement(LinePatternElement const & in_that);
34872 
34877 
34881  LinePatternElement & operator=(LinePatternElement && in_that);
34882 
34883  ~LinePatternElement();
34884 
34885  Type ObjectType() const { return Type::LinePatternElement; };
34886 
34889  void Set(LinePatternElement const & in_that);
34890 
34894  LinePatternElement & operator=(LinePatternElement const & in_that);
34895 
34899  bool Equals(LinePatternElement const & in_that) const;
34900 
34904  bool operator==(LinePatternElement const & in_that) const;
34905 
34909  bool operator!=(LinePatternElement const & in_that) const;
34910 
34914  void SetSize(float in_size, LinePattern::SizeUnits in_units);
34915 
34920  bool ShowSize(float & out_size, LinePattern::SizeUnits & out_units) const;
34921 };
34922 
34925 {
34926 public:
34929 
34935 
34939 
34943  SolidLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
34944 
34949 
34953  SolidLinePatternElement & operator=(SolidLinePatternElement && in_that);
34954 
34956 
34957  Type ObjectType() const { return Type::SolidLinePatternElement; };
34958 
34962  void SetColor(RGBAColor const & in_color);
34963 
34967  void SetMaterialByIndex(float in_material_index);
34968 
34974  bool ShowColor(Material::Type & out_type, RGBAColor & out_color, float & out_index) const;
34975 };
34976 
34977 
34980 {
34981 public:
34984 
34990 
34994 
34998  BlankLinePatternElement(float in_size, LinePattern::SizeUnits in_units);
34999 
35004 
35008  BlankLinePatternElement & operator=(BlankLinePatternElement && in_that);
35009 
35011 
35012  Type ObjectType() const { return Type::BlankLinePatternElement; };
35013 };
35014 
35015 
35018 {
35019 public:
35022 
35028 
35032 
35036  GlyphLinePatternElement & operator=(GlyphLinePatternElement const & in_that);
35037 
35042 
35046  GlyphLinePatternElement & operator=(GlyphLinePatternElement && in_that);
35047 
35049 
35050  Type ObjectType() const { return Type::GlyphLinePatternElement; };
35051 
35054  void SetSource(char const * in_source);
35055 
35059  void SetWeight(float in_weight, LinePattern::SizeUnits in_units);
35060 
35063  void SetInsetBehavior(LinePattern::InsetBehavior in_behavior);
35064 
35067  void SetMirror(bool in_state);
35068 
35071  void SetFixed(bool in_state);
35072 
35075  void SetRotation(float in_degrees);
35076 
35080  bool ShowSource(UTF8 & out_source) const;
35081 
35086  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units) const;
35087 
35091  bool ShowInsetBehavior(LinePattern::InsetBehavior & out_behavior) const;
35092 
35096  bool ShowMirror(bool & out_state) const;
35097 
35101  bool ShowFixed(bool & out_state) const;
35102 
35106  bool ShowRotation(float & out_degrees) const;
35107 };
35108 
35110 class HPS_API LinePatternParallelKit : public Object
35111 {
35112 public:
35115 
35119 
35124 
35128  LinePatternParallelKit & operator=(LinePatternParallelKit && in_that);
35129 
35130  virtual ~LinePatternParallelKit();
35131 
35132  Type ObjectType() const { return Type::LinePatternParallelKit; };
35133 
35136  void Set(LinePatternParallelKit const & in_kit);
35137 
35140  void Show(LinePatternParallelKit & out_kit) const;
35141 
35145  LinePatternParallelKit & operator=(LinePatternParallelKit const & in_kit);
35146 
35149  bool Empty() const;
35150 
35154  bool Equals(LinePatternParallelKit const & in_kit) const;
35155 
35159  bool operator==(LinePatternParallelKit const & in_kit) const;
35160 
35164  bool operator!=(LinePatternParallelKit const & in_kit) const;
35165 
35169  LinePatternParallelKit & SetStartCap(GlyphLinePatternElement const & in_start);
35170 
35174  LinePatternParallelKit & SetEndCap(GlyphLinePatternElement const & in_end);
35175 
35179  LinePatternParallelKit & SetJoin(GlyphLinePatternElement const & in_join);
35180 
35184  LinePatternParallelKit & SetBody(LinePatternElementArray const & in_elements);
35185 
35190  LinePatternParallelKit & SetBody(size_t in_count, LinePatternElement const in_elements []);
35191 
35195  LinePatternParallelKit & SetAbsoluteLength(bool in_state);
35196 
35200  LinePatternParallelKit & SetAbsoluteWeight(bool in_state);
35201 
35205  LinePatternParallelKit & SetJustification(LinePattern::Justification in_type);
35206 
35213  LinePatternParallelKit & SetOffset(float in_offset, LinePattern::SizeUnits in_units, bool in_fixed = false);
35214 
35220  LinePatternParallelKit & SetWeight(float in_weight, LinePattern::SizeUnits in_units, bool in_fixed = false);
35221 
35225  LinePatternParallelKit & SetContinuous(bool in_state);
35226 
35229  LinePatternParallelKit & UnsetStartCap();
35230 
35233  LinePatternParallelKit & UnsetEndCap();
35234 
35237  LinePatternParallelKit & UnsetJoin();
35238 
35241  LinePatternParallelKit & UnsetBody();
35242 
35245  LinePatternParallelKit & UnsetAbsoluteLength();
35246 
35249  LinePatternParallelKit & UnsetAbsoluteWeight();
35250 
35253  LinePatternParallelKit & UnsetJustification();
35254 
35257  LinePatternParallelKit & UnsetOffset();
35258 
35261  LinePatternParallelKit & UnsetWeight();
35262 
35265  LinePatternParallelKit & UnsetContinuous();
35266 
35269  LinePatternParallelKit & UnsetEverything();
35270 
35274  bool ShowStartCap(GlyphLinePatternElement & out_start) const;
35275 
35279  bool ShowEndCap(GlyphLinePatternElement & out_end) const;
35280 
35284  bool ShowJoin(GlyphLinePatternElement & out_join) const;
35285 
35289  bool ShowBody(LinePatternElementArray & out_elements) const;
35290 
35294  bool ShowAbsoluteLength(bool & out_state) const;
35295 
35299  bool ShowAbsoluteWeight(bool & out_state) const;
35300 
35304  bool ShowJustification(LinePattern::Justification & out_type) const;
35305 
35311  bool ShowOffset(float & out_offset, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
35312 
35318  bool ShowWeight(float & out_weight, LinePattern::SizeUnits & out_units, bool & out_fixed) const;
35319 
35323  bool ShowContinuous(bool & out_state) const;
35324 };
35325 
35326 
35328 class HPS_API LinePatternKit : public Object
35329 {
35330 public:
35332  LinePatternKit();
35333 
35336  LinePatternKit(LinePatternKit const & in_kit);
35337 
35341  LinePatternKit(LinePatternKit && in_that);
35342 
35346  LinePatternKit & operator=(LinePatternKit && in_that);
35347 
35348  virtual ~LinePatternKit();
35349 
35350  Type ObjectType() const { return Type::LinePatternKit; };
35351 
35355  static LinePatternKit GetDefault(LinePattern::Default in_default_line_pattern);
35356 
35359  void Set(LinePatternKit const & in_kit);
35360 
35363  void Show(LinePatternKit & out_kit) const;
35364 
35368  LinePatternKit & operator=(LinePatternKit const & in_kit);
35369 
35372  bool Empty() const;
35373 
35377  bool Equals(LinePatternKit const & in_kit) const;
35378 
35382  bool operator==(LinePatternKit const & in_kit) const;
35383 
35387  bool operator!=(LinePatternKit const & in_kit) const;
35388 
35392  LinePatternKit & SetParallels(LinePatternParallelKitArray const & in_parallels);
35393 
35398  LinePatternKit & SetParallels(size_t in_count, LinePatternParallelKit const in_parallels []);
35399 
35403  LinePatternKit & SetJoin(LinePattern::Join in_type);
35404 
35407  LinePatternKit & UnsetParallels();
35408 
35411  LinePatternKit & UnsetJoin();
35412 
35415  LinePatternKit & UnsetEverything();
35416 
35420  bool ShowParallels(LinePatternParallelKitArray & out_parallels) const;
35421 
35425  bool ShowJoin(LinePattern::Join & out_type) const;
35426 };
35427 
35428 
35429 
35433 
35434 
35436 class HPS_API Definition : public Object
35437 {
35438 public:
35440  Definition();
35441 
35444  Definition(Definition const & in_that);
35445 
35449  Definition & operator=(Definition const & in_that);
35450 
35454  Definition(Definition && in_that);
35455 
35459  Definition & operator=(Definition && in_that);
35460 
35461  virtual ~Definition();
35462 
35463  Type ObjectType() const { return Type::Definition; };
35464 
35466  void Undefine();
35467 
35470  PortfolioKey Owner() const;
35471 
35474  UTF8 Name() const;
35475 
35478  virtual void Assign(Definition const & in_that);
35479 
35483  bool Equals(Definition const & in_that) const;
35484 
35488  bool operator==(Definition const & in_that) const;
35489 
35493  bool operator!=(Definition const & in_that) const;
35494 };
35495 
35496 
35499 class HPS_API PortfolioKey : public Key
35500 {
35501 public:
35503  PortfolioKey();
35504 
35509  explicit PortfolioKey(Key const & in_that);
35510 
35513  PortfolioKey(PortfolioKey const & in_that);
35514 
35518  PortfolioKey & operator=(PortfolioKey const & in_that);
35519 
35523  PortfolioKey(PortfolioKey && in_that);
35524 
35528  PortfolioKey & operator=(PortfolioKey && in_that);
35529 
35530  ~PortfolioKey();
35531 
35532  Type ObjectType() const { return Type::PortfolioKey; };
35533 
35534  // Define
35535 
35542  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source);
35543 
35551  TextureDefinition DefineTexture(char const * in_name, ImageDefinition const & in_source, TextureOptionsKit const & in_options);
35552 
35553 
35565  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
35566  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
35567  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
35568 
35581  CubeMapDefinition DefineCubeMap(char const * in_name, ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
35582  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
35583  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y, TextureOptionsKit const & in_options);
35584 
35585 
35591  ImageDefinition DefineImage(char const * in_name, ImageKit const & in_source);
35592 
35593 
35599  NamedStyleDefinition DefineNamedStyle(char const * in_name, SegmentKey const & in_style_source);
35600 
35601 
35607  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, MaterialKitArray const & in_source);
35608 
35615  MaterialPaletteDefinition DefineMaterialPalette(char const * in_name, size_t in_count, MaterialKit const in_source []);
35616 
35617 
35623  GlyphDefinition DefineGlyph(char const * in_name, GlyphKit const & in_source);
35624 
35625 
35631  LinePatternDefinition DefineLinePattern(char const * in_name, LinePatternKit const & in_source);
35632 
35633 
35639  ShaderDefinition DefineShader(char const * in_name, ShaderKit const & in_source);
35640 
35641 
35642  // UnDefine
35643 
35647  PortfolioKey & UndefineTexture(char const * in_name);
35648 
35652  PortfolioKey & UndefineCubeMap(char const * in_name);
35653 
35657  PortfolioKey & UndefineImage(char const * in_name);
35658 
35662  PortfolioKey & UndefineNamedStyle(char const * in_name);
35663 
35667  PortfolioKey & UndefineMaterialPalette(char const * in_name);
35668 
35672  PortfolioKey & UndefineGlyph(char const * in_name);
35673 
35677  PortfolioKey & UndefineLinePattern(char const * in_name);
35678 
35682  PortfolioKey & UndefineShader(char const * in_name);
35683 
35684 
35685  // Import collections
35691  PortfolioKey & ImportPortfolio(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35692 
35693 
35699  PortfolioKey & ImportAllTextures(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35700 
35706  PortfolioKey & ImportAllCubeMaps(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35707 
35713  PortfolioKey & ImportAllImages(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35714 
35720  PortfolioKey & ImportAllNamedStyles(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35721 
35727  PortfolioKey & ImportAllMaterialPalettes(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35728 
35734  PortfolioKey & ImportAllGlyphs(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35735 
35741  PortfolioKey & ImportAllLinePatterns(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35742 
35748  PortfolioKey & ImportAllShaders(PortfolioKey const & in_portfolio, bool in_replace_existing = true);
35749 
35750 
35751  // Import individual definitions
35755  TextureDefinition ImportTexture(TextureDefinition const & in_definition);
35756 
35760  CubeMapDefinition ImportCubeMap(CubeMapDefinition const & in_definition);
35761 
35765  ImageDefinition ImportImage(ImageDefinition const & in_definition);
35766 
35770  NamedStyleDefinition ImportNamedStyle(NamedStyleDefinition const & in_definition);
35771 
35775  MaterialPaletteDefinition ImportMaterialPalette(MaterialPaletteDefinition const & in_definition);
35776 
35780  GlyphDefinition ImportGlyph(GlyphDefinition const & in_definition);
35781 
35785  LinePatternDefinition ImportLinePattern(LinePatternDefinition const & in_definition);
35786 
35790  ShaderDefinition ImportShader(ShaderDefinition const & in_definition);
35791 
35792 
35793  // Show
35795  size_t GetDefinitionCount() const;
35796 
35798  size_t GetTextureDefinitionCount() const;
35799 
35801  size_t GetCubeMapDefinitionCount() const;
35802 
35804  size_t GetImageDefinitionCount() const;
35805 
35807  size_t GetNamedStyleDefinitionCount() const;
35808 
35810  size_t GetMaterialPaletteDefinitionCount() const;
35811 
35813  size_t GetGlyphDefinitionCount() const;
35814 
35816  size_t GetLinePatternDefinitionCount() const;
35817 
35819  size_t GetShaderDefinitionCount() const;
35820 
35825  bool ShowTextureDefinition(char const * in_name, TextureDefinition & out_found) const;
35826 
35830  bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions) const;
35831 
35836  bool ShowCubeMapDefinition(char const * in_name, CubeMapDefinition & out_found) const;
35837 
35841  bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions) const;
35842 
35847  bool ShowImageDefinition(char const * in_name, ImageDefinition & out_found) const;
35848 
35852  bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions) const;
35853 
35858  bool ShowNamedStyleDefinition(char const * in_name, NamedStyleDefinition & out_found) const;
35859 
35863  bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions) const;
35864 
35869  bool ShowMaterialPaletteDefinition(char const * in_name, MaterialPaletteDefinition & out_found) const;
35870 
35874  bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions) const;
35875 
35880  bool ShowGlyphDefinition(char const * in_name, GlyphDefinition & out_found) const;
35881 
35885  bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions) const;
35886 
35891  bool ShowLinePatternDefinition(char const * in_name, LinePatternDefinition & out_found) const;
35892 
35896  bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions) const;
35897 
35902  bool ShowShaderDefinition(char const * in_name, ShaderDefinition & out_found) const;
35903 
35907  bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions) const;
35908 
35909 private:
35911  void MoveTo(SegmentKey const & in_new_owner);
35912 
35914  Key CopyTo(SegmentKey const & in_destination) const;
35915 };
35916 
35917 
35918 
35920 class HPS_API GlyphDefinition : public Definition
35921 {
35922 public:
35924  GlyphDefinition();
35925 
35930  GlyphDefinition(Definition const & in_that);
35931 
35934  GlyphDefinition(GlyphDefinition const & in_that);
35935 
35939  GlyphDefinition & operator=(GlyphDefinition const & in_that);
35940 
35944  GlyphDefinition(GlyphDefinition && in_that);
35945 
35949  GlyphDefinition & operator=(GlyphDefinition && in_that);
35950 
35951  ~GlyphDefinition();
35952 
35953  Type ObjectType() const { return Type::GlyphDefinition; };
35954 
35957  void Set(GlyphKit const & in_kit);
35958 
35961  void Show(GlyphKit & out_kit) const;
35962 };
35963 
35964 
35966 class HPS_API TextureDefinition : public Definition
35967 {
35968 public:
35971 
35976  TextureDefinition(Definition const & in_that);
35977 
35980  TextureDefinition(TextureDefinition const & in_that);
35981 
35985  TextureDefinition & operator=(TextureDefinition const & in_that);
35986 
35991 
35995  TextureDefinition & operator=(TextureDefinition && in_that);
35996 
35997  ~TextureDefinition();
35998 
35999  Type ObjectType() const { return Type::TextureDefinition; };
36000 
36003  void SetSource(ImageDefinition const & in_source);
36004 
36007  void ShowSource(ImageDefinition & out_source) const;
36008 
36011  void SetOptions(TextureOptionsKit const & in_options);
36012 
36015  void ShowOptions(TextureOptionsKit & out_options) const;
36016 
36017 };
36018 
36022 class HPS_API TextureOptionsKit : public Object
36023 {
36024 public:
36027 
36030  TextureOptionsKit(TextureOptionsKit const & in_kit);
36031 
36036 
36040  TextureOptionsKit & operator=(TextureOptionsKit && in_that);
36041 
36042  virtual ~TextureOptionsKit();
36043 
36044  Type ObjectType() const { return Type::TextureOptionsKit; };
36045 
36049  static TextureOptionsKit GetDefault();
36050 
36053  void Set(TextureOptionsKit const & in_kit);
36054 
36057  void Show(TextureOptionsKit & out_kit) const;
36058 
36062  TextureOptionsKit & operator=(TextureOptionsKit const & in_kit);
36063 
36066  bool Empty() const;
36067 
36071  bool Equals(TextureOptionsKit const & in_kit) const;
36072 
36076  bool operator==(TextureOptionsKit const & in_kit) const;
36077 
36081  bool operator!=(TextureOptionsKit const & in_kit) const;
36082 
36087  TextureOptionsKit & SetDecal(bool in_state);
36088 
36092  TextureOptionsKit & SetDownSampling(bool in_state);
36093 
36097  TextureOptionsKit & SetModulation(bool in_state);
36098 
36102  TextureOptionsKit & SetParameterOffset(size_t in_offset);
36103 
36107  TextureOptionsKit & SetParameterizationSource(Material::Texture::Parameterization in_source);
36108 
36112  TextureOptionsKit & SetTiling(Material::Texture::Tiling in_tiling);
36113 
36117  TextureOptionsKit & SetInterpolationFilter(Material::Texture::Interpolation in_filter);
36118 
36122  TextureOptionsKit & SetDecimationFilter(Material::Texture::Decimation in_filter);
36123 
36127  TextureOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
36128 
36131  TextureOptionsKit & UnsetDecal();
36132 
36135  TextureOptionsKit & UnsetDownSampling();
36136 
36139  TextureOptionsKit & UnsetModulation();
36140 
36143  TextureOptionsKit & UnsetParameterOffset();
36144 
36147  TextureOptionsKit & UnsetParameterizationSource();
36148 
36151  TextureOptionsKit & UnsetTiling();
36152 
36155  TextureOptionsKit & UnsetInterpolationFilter();
36156 
36159  TextureOptionsKit & UnsetDecimationFilter();
36160 
36163  TextureOptionsKit & UnsetTransformMatrix();
36164 
36167  TextureOptionsKit & UnsetEverything();
36168 
36172  bool ShowDecal(bool & out_state) const;
36173 
36177  bool ShowDownSampling(bool & out_state) const;
36178 
36182  bool ShowModulation(bool & out_state) const;
36183 
36187  bool ShowParameterOffset(size_t & out_offset) const;
36188 
36192  bool ShowParameterizationSource(Material::Texture::Parameterization & out_source) const;
36193 
36197  bool ShowTiling(Material::Texture::Tiling & out_tiling) const;
36198 
36202  bool ShowInterpolationFilter(Material::Texture::Interpolation & out_filter) const;
36203 
36207  bool ShowDecimationFilter(Material::Texture::Decimation & out_filter) const;
36208 
36212  bool ShowTransformMatrix(MatrixKit & out_transform) const;
36213 };
36214 
36215 
36217 class HPS_API Image
36218 {
36219 public:
36222  enum class Format
36223  {
36224  RGB,
36225  RGBA,
36226  ARGB,
36227  Mapped8,
36228  Grayscale,
36229  Jpeg,
36230  Png,
36231  Targa,
36232  DXT1,
36233  DXT3,
36234  DXT5
36235  };
36236 
36238  class HPS_API ExportOptionsKit : public Object
36239  {
36240  public:
36242  ExportOptionsKit();
36243 
36246  ExportOptionsKit(ExportOptionsKit const & in_kit);
36247 
36251  ExportOptionsKit(ExportOptionsKit && in_that);
36252 
36256  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
36257 
36258  virtual ~ExportOptionsKit();
36259 
36260  Type ObjectType() const { return Type::ImageExportOptionsKit; };
36261 
36265  static ExportOptionsKit GetDefault();
36266 
36269  void Set(ExportOptionsKit const & in_kit);
36270 
36273  void Show(ExportOptionsKit & out_kit) const;
36274 
36278  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
36279 
36282  bool Empty() const;
36283 
36287  bool Equals(ExportOptionsKit const & in_kit) const;
36288 
36292  bool operator==(ExportOptionsKit const & in_kit) const;
36293 
36297  bool operator!=(ExportOptionsKit const & in_kit) const;
36298 
36303  ExportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
36304 
36309  ExportOptionsKit & SetFormat(Image::Format in_format);
36310 
36313  ExportOptionsKit & UnsetSize();
36314 
36317  ExportOptionsKit & UnsetFormat();
36318 
36321  ExportOptionsKit & UnsetEverything();
36322 
36327  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
36328 
36332  bool ShowFormat(Image::Format & out_format) const;
36333  };
36334 
36336  class HPS_API ImportOptionsKit : public Object
36337  {
36338  public:
36340  ImportOptionsKit();
36341 
36344  ImportOptionsKit(ImportOptionsKit const & in_kit);
36345 
36349  ImportOptionsKit(ImportOptionsKit && in_that);
36350 
36354  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
36355 
36356  virtual ~ImportOptionsKit();
36357 
36358  Type ObjectType() const { return Type::ImageImportOptionsKit; };
36359 
36362  void Set(ImportOptionsKit const & in_kit);
36363 
36366  void Show(ImportOptionsKit & out_kit) const;
36367 
36371  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
36372 
36375  bool Empty() const;
36376 
36380  bool Equals(ImportOptionsKit const & in_kit) const;
36381 
36385  bool operator==(ImportOptionsKit const & in_kit) const;
36386 
36390  bool operator!=(ImportOptionsKit const & in_kit) const;
36391 
36398  ImportOptionsKit & SetSize(unsigned int in_width, unsigned int in_height);
36399 
36403  ImportOptionsKit & SetFormat(Image::Format in_format);
36404 
36409  ImportOptionsKit & SetDownSampling(bool in_state);
36410 
36415  ImportOptionsKit & SetCompressionQuality(float in_quality);
36416 
36419  ImportOptionsKit & UnsetSize();
36420 
36423  ImportOptionsKit & UnsetFormat();
36424 
36427  ImportOptionsKit & UnsetDownSampling();
36428 
36431  ImportOptionsKit & UnsetCompressionQuality();
36432 
36435  ImportOptionsKit & UnsetEverything();
36436 
36441  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
36442 
36446  bool ShowFormat(Image::Format & out_format) const;
36447 
36451  bool ShowDownSampling(bool & out_state) const;
36452 
36456  bool ShowCompressionQuality(float & out_quality) const;
36457  };
36458 
36460  class HPS_API File
36461  {
36462  public:
36468  static ImageKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
36469 
36476  static void Export(char const * in_file_name, WindowKey const & in_window, ExportOptionsKit const & in_options);
36477 
36485  static void Export(char const * in_file_name, WindowKey const & in_window, unsigned int in_width, unsigned int in_height, Format in_format = Format::Png);
36486 
36491  static void Export(char const * in_file_name, ImageKit const & in_image_kit);
36492 
36493  private:
36495  File();
36496  };
36497 
36498 private:
36500  Image();
36501 };
36502 
36503 
36505 class HPS_API ImageKit : public Object
36506 {
36507 public:
36509  ImageKit();
36510 
36513  ImageKit(ImageKit const & in_kit);
36514 
36519  ImageKit(ImageKit const & in_kit, Image::Format in_format);
36520 
36524  ImageKit(ImageKit && in_that);
36525 
36529  ImageKit & operator=(ImageKit && in_that);
36530 
36531  virtual ~ImageKit();
36532 
36533  Type ObjectType() const { return Type::ImageKit; };
36534 
36537  void Set(ImageKit const & in_kit);
36538 
36541  void Show(ImageKit & out_kit) const;
36542 
36546  ImageKit & operator=(ImageKit const & in_kit);
36547 
36550  bool Empty() const;
36551 
36555  bool Equals(ImageKit const & in_kit) const;
36556 
36560  bool operator==(ImageKit const & in_kit) const;
36561 
36565  bool operator!=(ImageKit const & in_kit) const;
36566 
36570  void Convert(ImageKit const & in_kit, Image::Format in_format);
36571 
36574  void Convert(Image::Format in_format);
36575 
36580  ImageKit & SetSize(unsigned int in_width, unsigned int in_height);
36581 
36585  ImageKit & SetData(ByteArray const & in_image_data);
36586 
36591  ImageKit & SetData(size_t in_byte_count, byte const in_image_data []);
36592 
36596  ImageKit & SetFormat(Image::Format in_format);
36597 
36601  ImageKit & SetDownSampling(bool in_state);
36602 
36606  ImageKit & SetCompressionQuality(float in_quality);
36607 
36610  ImageKit & UnsetSize();
36611 
36614  ImageKit & UnsetData();
36615 
36618  ImageKit & UnsetFormat();
36619 
36622  ImageKit & UnsetDownSampling();
36623 
36626  ImageKit & UnsetCompressionQuality();
36627 
36630  ImageKit & UnsetEverything();
36631 
36636  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
36637 
36641  bool ShowData(ByteArray & out_image_data) const;
36642 
36646  bool ShowFormat(Image::Format & out_format) const;
36647 
36651  bool ShowDownSampling(bool & out_state) const;
36652 
36656  bool ShowCompressionQuality(float & out_quality) const;
36657 };
36658 
36659 
36665 {
36666 public:
36670 
36675 
36680 
36685 
36687 
36688  Type ObjectType() const { return Type::OffScreenWindowOptionsControl; };
36689 
36693  OffScreenWindowOptionsControl & operator=(OffScreenWindowOptionsControl const & in_that);
36694 
36699  OffScreenWindowOptionsControl & SetSize(unsigned int in_width, unsigned int in_height);
36700 
36704  bool ShowDriver(Window::Driver & out_driver) const;
36705 
36710  bool ShowAntiAliasCapable(bool & out_state, unsigned int & out_samples) const;
36711 
36716  bool ShowSize(unsigned int & out_width, unsigned int & out_height) const;
36717 
36722  bool ShowImage(Image::Format in_format, ImageKit & out_image) const;
36723 
36727  bool ShowHardwareResident(bool & out_state) const;
36728 
36733  bool ShowOpacity(bool & out_state, float & out_opacity) const;
36734 
36735 private:
36738 };
36739 
36740 
36743 class HPS_API OffScreenWindowKey : public WindowKey
36744 {
36745 public:
36748 
36753  OffScreenWindowKey(Key const & in_key);
36754 
36757  OffScreenWindowKey(OffScreenWindowKey const & in_that);
36758 
36763 
36767  OffScreenWindowKey & operator=(OffScreenWindowKey && in_that);
36768 
36769  ~OffScreenWindowKey();
36770 
36771  Type ObjectType() const { return Type::OffScreenWindowKey; };
36772 
36775  OffScreenWindowOptionsControl const GetWindowOptionsControl() const;
36776 
36779  OffScreenWindowOptionsControl GetWindowOptionsControl();
36780 
36784  bool ShowWindowOptions(OffScreenWindowOptionsKit & out_kit) const;
36785 };
36786 
36787 
36788 
36789 
36791 class HPS_API ImageDefinition : public Definition
36792 {
36793 public:
36795  ImageDefinition();
36796 
36801  ImageDefinition(Definition const & in_that);
36802 
36805  ImageDefinition(ImageDefinition const & in_that);
36806 
36810  ImageDefinition & operator=(ImageDefinition const & in_that);
36811 
36815  ImageDefinition(ImageDefinition && in_that);
36816 
36820  ImageDefinition & operator=(ImageDefinition && in_that);
36821 
36822  ~ImageDefinition();
36823 
36824  Type ObjectType() const { return Type::ImageDefinition; };
36825 
36828  void Set(ImageKit const & in_kit);
36829 
36832  void Show(ImageKit & out_kit) const;
36833 };
36834 
36836 class HPS_API CubeMapDefinition : public Definition
36837 {
36838 public:
36841 
36846  CubeMapDefinition(Definition const & in_that);
36847 
36850  CubeMapDefinition(CubeMapDefinition const & in_that);
36851 
36855  CubeMapDefinition & operator=(CubeMapDefinition const & in_that);
36856 
36861 
36865  CubeMapDefinition & operator=(CubeMapDefinition && in_that);
36866 
36867  ~CubeMapDefinition();
36868 
36869  Type ObjectType() const { return Type::CubeMapDefinition; };
36870 
36878  void SetSource(ImageDefinition const & in_negative_z, ImageDefinition const & in_positive_z,
36879  ImageDefinition const & in_negative_x, ImageDefinition const & in_positive_x,
36880  ImageDefinition const & in_negative_y, ImageDefinition const & in_positive_y);
36881 
36889  void ShowSource(ImageDefinition & out_negative_z, ImageDefinition & out_positive_z,
36890  ImageDefinition & out_negative_x, ImageDefinition & out_positive_x,
36891  ImageDefinition & out_negative_y, ImageDefinition & out_positive_y) const;
36892 
36896  void ShowSource(ImageDefinitionArray & out_image_sources) const;
36897 
36900  void SetOptions(TextureOptionsKit const & in_options);
36901 
36904  void ShowOptions(TextureOptionsKit & out_options) const;
36905 };
36906 
36907 
36909 class HPS_API NamedStyleDefinition : public Definition
36910 {
36911 public:
36914 
36919  NamedStyleDefinition(Definition const & in_that);
36920 
36923  NamedStyleDefinition(NamedStyleDefinition const & in_that);
36924 
36928  NamedStyleDefinition & operator=(NamedStyleDefinition const & in_that);
36929 
36934 
36938  NamedStyleDefinition & operator=(NamedStyleDefinition && in_that);
36939 
36941 
36942  Type ObjectType() const { return Type::NamedStyleDefinition; };
36943 
36947  SegmentKey GetSource() const;
36948 };
36949 
36950 
36953 {
36954 public:
36957 
36962  MaterialPaletteDefinition(Definition const & in_that);
36963 
36967 
36971  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition const & in_that);
36972 
36977 
36981  MaterialPaletteDefinition & operator=(MaterialPaletteDefinition && in_that);
36982 
36984 
36985  Type ObjectType() const { return Type::MaterialPaletteDefinition; };
36986 
36989  void Set(MaterialKitArray const & in_source);
36990 
36994  void Set(size_t in_count, MaterialKit const in_source []);
36995 
36998  void Show(MaterialKitArray & out_source) const;
36999 };
37000 
37001 
37002 
37004 class HPS_API LinePatternDefinition : public Definition
37005 {
37006 public:
37009 
37014  LinePatternDefinition(Definition const & in_that);
37015 
37019 
37023  LinePatternDefinition & operator=(LinePatternDefinition const & in_that);
37024 
37029 
37033  LinePatternDefinition & operator=(LinePatternDefinition && in_that);
37034 
37036 
37037  Type ObjectType() const { return Type::LinePatternDefinition; };
37038 
37041  void Set(LinePatternKit const & in_kit);
37042 
37045  void Show(LinePatternKit & out_kit) const;
37046 };
37047 
37048 
37049 
37051 class HPS_API Shader
37052 {
37053 public:
37056  enum class Parameterization
37057  {
37059  Cylinder,
37061  PhysicalReflection,
37063  Object,
37069  NaturalUV,
37071  ReflectionVector,
37073  SurfaceNormal,
37075  Sphere,
37077  UV,
37079  World
37080  };
37081 
37083  class HPS_API ImportOptionsKit : public Object
37084  {
37085  public:
37087  ImportOptionsKit();
37088 
37091  ImportOptionsKit(ImportOptionsKit const & in_kit);
37092 
37096  ImportOptionsKit(ImportOptionsKit && in_that);
37097 
37101  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
37102 
37103  virtual ~ImportOptionsKit();
37104 
37105  Type ObjectType() const { return Type::ShaderImportOptionsKit; };
37106 
37109  void Set(ImportOptionsKit const & in_kit);
37110 
37113  void Show(ImportOptionsKit & out_kit) const;
37114 
37118  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
37119 
37122  bool Empty() const;
37123 
37127  bool Equals(ImportOptionsKit const & in_kit) const;
37128 
37132  bool operator==(ImportOptionsKit const & in_kit) const;
37133 
37137  bool operator!=(ImportOptionsKit const & in_kit) const;
37138 
37145  ImportOptionsKit & SetMultitexture(bool in_state);
37146 
37150  ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
37151 
37155  ImportOptionsKit & SetTransformMatrix(MatrixKit const & in_transform);
37156 
37160  ImportOptionsKit & UnsetMultitexture();
37161 
37164  ImportOptionsKit & UnsetParameterizationSource();
37165 
37168  ImportOptionsKit & UnsetTransformMatrix();
37169 
37172  ImportOptionsKit & UnsetEverything();
37173 
37179  bool ShowMultitexture(bool & out_state) const;
37180 
37184  bool ShowParameterizationSource(Parameterization & out_source) const;
37185 
37189  bool ShowTransformMatrix(MatrixKit & out_transform) const;
37190  };
37191 
37193  class HPS_API File
37194  {
37195  public:
37201  static ShaderKit Import(char const * in_file_name, ImportOptionsKit const & in_options);
37202 
37203  private:
37205  File();
37206  };
37207 
37208 private:
37210  Shader();
37211 };
37212 
37213 
37215 class HPS_API ShaderKit : public Object
37216 {
37217 public:
37219  ShaderKit();
37220 
37223  ShaderKit(ShaderKit const & in_kit);
37224 
37228  ShaderKit(ShaderKit && in_that);
37229 
37233  ShaderKit & operator=(ShaderKit && in_that);
37234 
37235  virtual ~ShaderKit();
37236 
37237  Type ObjectType() const { return Type::ShaderKit; };
37238 
37241  void Set(ShaderKit const & in_kit);
37242 
37245  void Show(ShaderKit & out_kit) const;
37246 
37250  ShaderKit & operator=(ShaderKit const & in_kit);
37251 
37254  bool Empty() const;
37255 
37259  bool Equals(ShaderKit const & in_kit) const;
37260 
37264  bool operator==(ShaderKit const & in_kit) const;
37265 
37269  bool operator!=(ShaderKit const & in_kit) const;
37270 
37274  ShaderKit & SetSource(char const * in_source);
37275 
37282  ShaderKit & SetMultitexture(bool in_state);
37283 
37287  ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
37288 
37292  ShaderKit & SetTransformMatrix(MatrixKit const & in_transform);
37293 
37296  ShaderKit & UnsetSource();
37297 
37301  ShaderKit & UnsetMultitexture();
37302 
37305  ShaderKit & UnsetParameterizationSource();
37306 
37309  ShaderKit & UnsetTransformMatrix();
37310 
37313  ShaderKit & UnsetEverything();
37314 
37318  bool ShowSource(UTF8 & out_source) const;
37319 
37325  bool ShowMultitexture(bool & out_state) const;
37326 
37330  bool ShowParameterizationSource(Shader::Parameterization & out_source) const;
37331 
37335  bool ShowTransformMatrix(MatrixKit & out_transform) const;
37336 };
37337 
37338 
37340 class HPS_API ShaderDefinition : public Definition
37341 {
37342 public:
37344  ShaderDefinition();
37345 
37350  ShaderDefinition(Definition const & in_that);
37351 
37354  ShaderDefinition(ShaderDefinition const & in_that);
37355 
37359  ShaderDefinition & operator=(ShaderDefinition const & in_that);
37360 
37364  ShaderDefinition(ShaderDefinition && in_that);
37365 
37369  ShaderDefinition & operator=(ShaderDefinition && in_that);
37370 
37371  ~ShaderDefinition();
37372 
37373  Type ObjectType() const { return Type::ShaderDefinition; };
37374 
37377  void Set(ShaderKit const & in_kit);
37378 
37381  void Show(ShaderKit & out_kit) const;
37382 };
37383 
37384 
37385 
37386 
37390 
37392 {
37393 public:
37396 
37400 
37405 
37410 
37411  virtual ~CutGeometryGatheringOptionsKit();
37412 
37413  Type ObjectType() const {return Type::CutGeometryGatheringOptionsKit;};
37414 
37418  static CutGeometryGatheringOptionsKit GetDefault();
37419 
37422  void Set(CutGeometryGatheringOptionsKit const & in_kit);
37423 
37426  void Show(CutGeometryGatheringOptionsKit & out_kit) const;
37427 
37432 
37435  bool Empty() const;
37436 
37440  bool Equals(CutGeometryGatheringOptionsKit const & in_kit) const;
37441 
37445  bool operator==(CutGeometryGatheringOptionsKit const & in_kit) const;
37446 
37450  bool operator!=(CutGeometryGatheringOptionsKit const & in_kit) const;
37451 
37452 
37456  CutGeometryGatheringOptionsKit & SetCuttingSection(CuttingSectionKey const & in_cutter);
37457 
37461  CutGeometryGatheringOptionsKit & SetOffset(size_t in_offset);
37462 
37467 
37468 
37471  CutGeometryGatheringOptionsKit & UnsetCuttingSection();
37472 
37475  CutGeometryGatheringOptionsKit & UnsetOffset();
37476 
37479  CutGeometryGatheringOptionsKit & UnsetLevel();
37480 
37483  CutGeometryGatheringOptionsKit & UnsetEverything();
37484 
37485 
37489  bool ShowCuttingSection(CuttingSectionKey & out_cutter) const;
37490 
37494  bool ShowOffset(size_t & out_offset) const;
37495 
37499  bool ShowLevel(CuttingSection::GatheringLevel & out_level) const;
37500 };
37501 
37503 class HPS_API SearchOptionsKit : public Object
37504 {
37505 public:
37507  SearchOptionsKit();
37508 
37511  SearchOptionsKit(SearchOptionsKit const & in_kit);
37512 
37516  SearchOptionsKit(SearchOptionsKit && in_that);
37517 
37521  SearchOptionsKit & operator=(SearchOptionsKit && in_that);
37522 
37523  virtual ~SearchOptionsKit();
37524 
37525  Type ObjectType() const {return Type::SearchOptionsKit;};
37526 
37530  static SearchOptionsKit GetDefault();
37531 
37534  void Set(SearchOptionsKit const & in_kit);
37535 
37538  void Show(SearchOptionsKit & out_kit) const;
37539 
37543  SearchOptionsKit & operator=(SearchOptionsKit const & in_kit);
37544 
37547  bool Empty() const;
37548 
37552  bool Equals(SearchOptionsKit const & in_kit) const;
37553 
37557  bool operator==(SearchOptionsKit const & in_kit) const;
37558 
37562  bool operator!=(SearchOptionsKit const & in_kit) const;
37563 
37567  SearchOptionsKit & SetCriteria(Search::Type in_request);
37568 
37572  SearchOptionsKit & SetBehavior(Search::Behavior in_behavior);
37573 
37577  SearchOptionsKit & SetCriteria(SearchTypeArray const & in_requests);
37578 
37583  SearchOptionsKit & SetCriteria(size_t in_count, Search::Type const in_requests []);
37584 
37588  SearchOptionsKit & SetSearchSpace(Search::Space in_search_space);
37589 
37592  SearchOptionsKit & UnsetBehavior();
37593 
37596  SearchOptionsKit & UnsetCriteria();
37597 
37600  SearchOptionsKit & UnsetSearchSpace();
37601 
37604  SearchOptionsKit & UnsetEverything();
37605 
37609  bool ShowBehavior(Search::Behavior & out_behavior) const;
37610 
37614  bool ShowCriteria(SearchTypeArray & out_types) const;
37615 
37619  bool ShowSearchSpace(Search::Space & out_search_space) const;
37620 };
37621 
37625 class HPS_API TreeContext : public Object
37626 {
37627 public:
37630  TreeContext(bool in_create = true);
37631 
37634  TreeContext(TreeContext const & in_that);
37635 
37639  TreeContext(TreeContext && in_that);
37640 
37644  TreeContext & operator=(TreeContext && in_that);
37645 
37647  virtual ~TreeContext();
37648 
37649  Type ObjectType() const {return Type::TreeContext;};
37650 
37654  TreeContext & operator=(TreeContext const & in_that);
37655 
37659  bool Equals(TreeContext const & in_that) const;
37660 
37664  bool operator==(TreeContext const & in_that) const;
37665 
37669  bool operator!=(TreeContext const & in_that) const;
37670 
37671 };
37672 
37674 class HPS_API SelectionOptionsKit : public Object
37675 {
37676 public:
37679 
37682  SelectionOptionsKit(SelectionOptionsKit const & in_kit);
37683 
37688 
37692  SelectionOptionsKit & operator=(SelectionOptionsKit && in_that);
37693 
37694  virtual ~SelectionOptionsKit();
37695 
37696  Type ObjectType() const {return Type::SelectionOptionsKit;};
37697 
37701  static SelectionOptionsKit GetDefault();
37702 
37705  void Set(SelectionOptionsKit const & in_kit);
37706 
37709  void Show(SelectionOptionsKit & out_kit) const;
37710 
37714  SelectionOptionsKit & operator=(SelectionOptionsKit const & in_kit);
37715 
37718  bool Empty() const;
37719 
37723  bool Equals(SelectionOptionsKit const & in_kit) const;
37724 
37728  bool operator==(SelectionOptionsKit const & in_kit) const;
37729 
37733  bool operator!=(SelectionOptionsKit const & in_kit) const;
37734 
37742  SelectionOptionsKit & SetProximity(float in_proximity);
37743 
37749  SelectionOptionsKit & SetLevel(Selection::Level in_level);
37750 
37755  SelectionOptionsKit & SetInternalLimit(size_t in_limit);
37756 
37765  SelectionOptionsKit & SetRelatedLimit(size_t in_limit);
37766 
37774  SelectionOptionsKit & SetSorting(bool in_sorted);
37775 
37781  SelectionOptionsKit & SetAlgorithm(Selection::Algorithm in_algorithm);
37782 
37788  SelectionOptionsKit & SetGranularity(Selection::Granularity in_granularity);
37789 
37794  SelectionOptionsKit & SetScope(SegmentKey const & in_start_segment);
37795 
37800  SelectionOptionsKit & SetScope(KeyPath const & in_start_path);
37801 
37806  SelectionOptionsKit & SetTreeContext(TreeContext const & in_tree_context);
37807 
37814  SelectionOptionsKit & SetExtentCullingRespected(bool in_state);
37815 
37822  SelectionOptionsKit & SetDeferralExtentCullingRespected(bool in_state);
37823 
37830  SelectionOptionsKit & SetFrustumCullingRespected(bool in_state);
37831 
37838  SelectionOptionsKit & SetVectorCullingRespected(bool in_state);
37839 
37842  SelectionOptionsKit & UnsetProximity();
37843 
37846  SelectionOptionsKit & UnsetLevel();
37847 
37850  SelectionOptionsKit & UnsetInternalLimit();
37851 
37854  SelectionOptionsKit & UnsetRelatedLimit();
37855 
37858  SelectionOptionsKit & UnsetSorting();
37859 
37862  SelectionOptionsKit & UnsetAlgorithm();
37863 
37866  SelectionOptionsKit & UnsetGranularity();
37867 
37870  SelectionOptionsKit & UnsetScope();
37871 
37874  SelectionOptionsKit & UnsetTreeContext();
37875 
37878  SelectionOptionsKit & UnsetExtentCullingRespected();
37879 
37882  SelectionOptionsKit & UnsetDeferralExtentCullingRespected();
37883 
37886  SelectionOptionsKit & UnsetFrustumCullingRespected();
37887 
37890  SelectionOptionsKit & UnsetVectorCullingRespected();
37891 
37892 
37895  SelectionOptionsKit & UnsetEverything();
37896 
37900  bool ShowProximity(float & out_proximity) const;
37901 
37905  bool ShowLevel(Selection::Level & out_level) const;
37906 
37910  bool ShowInternalLimit(size_t & out_limit) const;
37911 
37915  bool ShowRelatedLimit(size_t & out_limit) const;
37916 
37920  bool ShowSorting(bool & out_sorted) const;
37921 
37925  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
37926 
37930  bool ShowGranularity(Selection::Granularity & out_granularity) const;
37931 
37935  bool ShowScope(KeyPath & out_start_path) const;
37936 
37940  bool ShowTreeContext(TreeContext & out_tree_context) const;
37941 
37945  bool ShowExtentCullingRespected(bool & out_state) const;
37946 
37950  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
37951 
37955  bool ShowFrustumCullingRespected(bool & out_state) const;
37956 
37960  bool ShowVectorCullingRespected(bool & out_state) const;
37961 };
37962 
37963 
37964 
37968 class HPS_API SelectionOptionsControl : public Control
37969 {
37970 public:
37973  explicit SelectionOptionsControl(WindowKey const & in_window);
37974 
37978 
37983 
37987  SelectionOptionsControl & operator=(SelectionOptionsControl && in_that);
37988 
37990 
37991  Type ObjectType() const {return Type::SelectionOptionsControl;};
37992 
37996  SelectionOptionsControl & operator=(SelectionOptionsControl const & in_that);
37997 
38003  SelectionOptionsControl & SetProximity(float in_proximity);
38004 
38010  SelectionOptionsControl & SetLevel(Selection::Level in_level);
38011 
38018  SelectionOptionsControl & SetInternalLimit(size_t in_limit);
38019 
38028  SelectionOptionsControl & SetRelatedLimit(size_t in_limit);
38029 
38037  SelectionOptionsControl & SetSorting(bool in_sorted);
38038 
38044  SelectionOptionsControl & SetAlgorithm(Selection::Algorithm in_algorithm);
38045 
38051  SelectionOptionsControl & SetGranularity(Selection::Granularity in_granularity);
38052 
38059  SelectionOptionsControl & SetExtentCullingRespected(bool in_state);
38060 
38067  SelectionOptionsControl & SetDeferralExtentCullingRespected(bool in_state);
38068 
38075  SelectionOptionsControl & SetFrustumCullingRespected(bool in_state);
38076 
38083  SelectionOptionsControl & SetVectorCullingRespected(bool in_state);
38084 
38085  // there is no way to unset default values, intentionally
38086 
38090  bool ShowProximity(float & out_proximity) const;
38091 
38095  bool ShowLevel(Selection::Level & out_level) const;
38096 
38100  bool ShowInternalLimit(size_t & out_limit) const;
38101 
38105  bool ShowRelatedLimit(size_t & out_limit) const;
38106 
38110  bool ShowSorting(bool & out_sorted) const;
38111 
38115  bool ShowAlgorithm(Selection::Algorithm & out_algorithm) const;
38116 
38120  bool ShowGranularity(Selection::Granularity & out_granularity) const;
38121 
38125  bool ShowExtentCullingRespected(bool & out_state) const;
38126 
38130  bool ShowDeferralExtentCullingRespected(bool & out_state) const;
38131 
38135  bool ShowFrustumCullingRespected(bool & out_state) const;
38136 
38140  bool ShowVectorCullingRespected(bool & out_state) const;
38141 
38142 private:
38145 };
38146 
38147 
38148 
38150 class HPS_API SelectionItem : public Object
38151 {
38152 public:
38154  SelectionItem();
38155 
38158  SelectionItem(SelectionItem const & in_that);
38159 
38163  SelectionItem(SelectionItem && in_that);
38164 
38168  SelectionItem & operator=(SelectionItem && in_that);
38169 
38170  virtual ~SelectionItem();
38171 
38172  Type ObjectType() const {return Type::SelectionItem;};
38173 
38176  void Set(SelectionItem const & in_that);
38177 
38181  SelectionItem & operator=(SelectionItem const & in_that);
38182 
38186  bool Equals(SelectionItem const & in_that) const;
38187 
38191  bool operator==(SelectionItem const & in_that) const;
38192 
38196  bool operator!=(SelectionItem const & in_that) const;
38197 
38201  bool ShowSelectionLevel(Selection::Level & out_level) const;
38202 
38206  bool ShowSelectedItem(Key & out_selection) const;
38207 
38211  bool ShowPath(KeyPath & out_path) const;
38212 
38216  bool ShowFaces(SizeTArray & out_faces) const;
38217 
38221  bool ShowVertices(SizeTArray & out_vertices) const;
38222 
38227  bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2) const;
38228 
38232  bool ShowCharacters(SizeTArray & out_characters) const;
38233 
38237  bool ShowSelectionPosition(WindowPoint & out_location) const;
38238 
38242  bool ShowSelectionPosition(WorldPoint & out_location) const;
38243 
38244 };
38245 
38247 class HPS_API SelectionResultsIterator : public Object
38248 {
38249 public:
38252 
38257 
38262 
38266  SelectionResultsIterator & operator=(SelectionResultsIterator && in_that);
38267 
38269 
38270  Type ObjectType() const {return Type::SelectionResultsIterator;}
38271 
38275  SelectionResultsIterator & operator=(SelectionResultsIterator const & in_that);
38276 
38279  void Set(SelectionResultsIterator const & in_that);
38280 
38282  void Next();
38283 
38286  SelectionResultsIterator & operator++();
38287 
38290  SelectionResultsIterator operator++(int in_val);
38291 
38294  bool operator==(SelectionResultsIterator const & in_search_results_iterator);
38295 
38298  bool operator!=(SelectionResultsIterator const & in_search_results_iterator);
38299 
38300 
38303  bool IsValid() const;
38304 
38306  void Reset();
38307 
38310  SelectionItem GetItem() const;
38311 
38314  SelectionItem operator*() const;
38315 
38316 
38317 };
38318 
38322 class HPS_API SelectionResults : public Object
38323 {
38324 public:
38326  SelectionResults();
38327 
38330  SelectionResults(SelectionResults const & in_that);
38331 
38335  SelectionResults(SelectionResults && in_that);
38336 
38340  SelectionResults & operator=(SelectionResults && in_that);
38341 
38342  ~SelectionResults();
38343 
38344  Type ObjectType() const {return Type::SelectionResults;}
38345 
38348  void Assign(SelectionResults const & in_that);
38349 
38353  SelectionResults & operator=(SelectionResults const & in_that);
38354 
38358  bool Equals(SelectionResults const & in_that) const;
38359 
38363  bool operator==(SelectionResults const & in_that) const;
38364 
38368  bool operator!=(SelectionResults const & in_that) const;
38369 
38371  virtual void Reset();
38372 
38375  Selection::Level GetSelectionLevel() const;
38376 
38379  size_t GetCount() const;
38380 
38383  SelectionResultsIterator GetIterator() const;
38384 
38390  bool Union(SelectionResults const & in_that);
38391 
38396  bool Intersect(SelectionResults const & in_that);
38397 
38403  bool SymmetricDifference(SelectionResults const & in_that);
38404 
38409  bool Difference(SelectionResults const & in_that);
38410 
38413  void Copy(SelectionResults const & in_that);
38414 };
38415 
38418 class HPS_API SelectionControl : public Object
38419 {
38420 public:
38423  explicit SelectionControl(WindowKey const & in_window);
38424 
38427  SelectionControl(SelectionControl const & in_that);
38428 
38432  SelectionControl(SelectionControl && in_that);
38433 
38437  SelectionControl & operator=(SelectionControl && in_that);
38438 
38439  ~SelectionControl();
38440 
38441  Type ObjectType() const {return Type::SelectionControl;};
38442 
38446  SelectionControl & operator=(SelectionControl const & in_that);
38447 
38453  size_t SelectByPoint(Point const & in_location, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
38454 
38459  size_t SelectByPoint(Point const & in_location, SelectionResults & out_results) const;
38460 
38466  size_t SelectByArea(Rectangle const & in_area, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
38467 
38472  size_t SelectByArea(Rectangle const & in_area, SelectionResults & out_results) const;
38473 
38479  size_t SelectByPolygon(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
38480 
38485  size_t SelectByPolygon(PointArray const & in_points, SelectionResults & out_results) const;
38486 
38493  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
38494 
38500  size_t SelectByPolygon(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
38501 
38507  size_t SelectByLine(PointArray const & in_points, SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
38508 
38513  size_t SelectByLine(PointArray const & in_points, SelectionResults & out_results) const;
38514 
38521  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionOptionsKit const & in_options, SelectionResults & out_results) const;
38522 
38528  size_t SelectByLine(size_t in_point_count, Point const in_points [], SelectionResults & out_results) const;
38529 
38530 
38531  //Object space selections
38532 
38538  size_t SelectByShell(ShellKit const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
38539 
38544  size_t SelectByShell(ShellKit const & in_shell, SelectionResults & out_results);
38545 
38551  size_t SelectByShell(ShellKey const & in_shell, SelectionOptionsKit const & in_options, SelectionResults & out_results);
38552 
38557  size_t SelectByShell(ShellKey const & in_shell, SelectionResults & out_results);
38558 
38559 
38566  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionOptionsKit const & in_options, SelectionResults & out_results);
38567 
38573  size_t SelectByVolume(SimpleCuboid const & in_volume, SelectionResults & out_results);
38574 
38575 
38582  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionOptionsKit const & in_options, SelectionResults & out_results);
38583 
38589  size_t SelectByRay(Point const & in_start_point, Vector const & in_direction, SelectionResults & out_results);
38590 
38591 private:
38593  SelectionControl();
38594 };
38595 
38596 
38597 
38599 class HPS_API HighlightOptionsKit : public Object
38600 {
38601 public:
38604 
38607  HighlightOptionsKit(char const * in_style_name);
38608 
38612  HighlightOptionsKit(char const * in_style_name, char const * in_secondary_style_name);
38613 
38616  HighlightOptionsKit(HighlightOptionsKit const & in_kit);
38617 
38622 
38626  HighlightOptionsKit & operator=(HighlightOptionsKit && in_that);
38627 
38628  virtual ~HighlightOptionsKit();
38629 
38630  Type ObjectType() const {return Type::HighlightOptionsKit;};
38631 
38635  static HighlightOptionsKit GetDefault();
38636 
38639  void Set(HighlightOptionsKit const & in_kit);
38640 
38643  void Show(HighlightOptionsKit & out_kit) const;
38644 
38648  HighlightOptionsKit & operator=(HighlightOptionsKit const & in_kit);
38649 
38652  bool Empty() const;
38653 
38657  bool Equals(HighlightOptionsKit const & in_kit) const;
38658 
38662  bool operator==(HighlightOptionsKit const & in_kit) const;
38663 
38667  bool operator!=(HighlightOptionsKit const & in_kit) const;
38668 
38669 
38673  HighlightOptionsKit & SetStyleName(char const * in_style_name);
38674 
38678  HighlightOptionsKit & SetSecondaryStyleName(char const * in_style_name);
38679 
38686  HighlightOptionsKit & SetOverlay(Drawing::Overlay in_overlay);
38687 
38693  HighlightOptionsKit & SetNotification(bool in_state);
38694 
38695 
38698  HighlightOptionsKit & UnsetStyleName();
38699 
38702  HighlightOptionsKit & UnsetSecondaryStyleName();
38703 
38706  HighlightOptionsKit & UnsetOverlay();
38707 
38710  HighlightOptionsKit & UnsetNotification();
38711 
38714  HighlightOptionsKit & UnsetEverything();
38715 
38716 
38720  bool ShowStyleName(UTF8 & out_style_name) const;
38721 
38725  bool ShowSecondaryStyleName(UTF8 & out_style_name) const;
38726 
38730  bool ShowOverlay(Drawing::Overlay & out_overlay) const;
38731 
38735  bool ShowNotification(bool & out_state) const;
38736 };
38737 
38740 class HPS_API HighlightControl : public Control
38741 {
38742 public:
38745  explicit HighlightControl(WindowKey const & in_window);
38746 
38749  HighlightControl(HighlightControl const & in_that);
38750 
38754  HighlightControl(HighlightControl && in_that);
38755 
38759  HighlightControl & operator=(HighlightControl && in_that);
38760 
38761  ~HighlightControl();
38762 
38763  Type ObjectType() const {return Type::HighlightControl;};
38764 
38768  HighlightControl & operator=(HighlightControl const & in_that);
38769 
38774  HighlightControl & Highlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options);
38775 
38780  HighlightControl & Highlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options);
38781 
38786  HighlightControl & Highlight(SearchResults const & in_items, HighlightOptionsKit const & in_options);
38787 
38792  HighlightControl & Highlight(KeyPath const & in_item, HighlightOptionsKit const & in_options);
38793 
38798  HighlightControl & Highlight(Key const & in_item, HighlightOptionsKit const & in_options);
38799 
38804  HighlightControl & Unhighlight(SelectionResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
38805 
38810  HighlightControl & Unhighlight(SelectionItem const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
38811 
38816  HighlightControl & Unhighlight(SearchResults const & in_items, HighlightOptionsKit const & in_options = HighlightOptionsKit());
38817 
38822  HighlightControl & Unhighlight(KeyPath const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
38823 
38828  HighlightControl & Unhighlight(Key const & in_item, HighlightOptionsKit const & in_options = HighlightOptionsKit());
38829 
38833  HighlightControl & Unhighlight(HighlightOptionsKit const & in_options);
38834 
38837  HighlightControl & UnhighlightEverything();
38838 
38839 private:
38841  HighlightControl();
38842 };
38843 
38845 class HPS_API UpdateOptionsKit : public Object
38846 {
38847 public:
38849  UpdateOptionsKit();
38850 
38853  UpdateOptionsKit(UpdateOptionsKit const & in_kit);
38854 
38858  UpdateOptionsKit(UpdateOptionsKit && in_that);
38859 
38863  UpdateOptionsKit & operator=(UpdateOptionsKit && in_that);
38864 
38865  virtual ~UpdateOptionsKit();
38866 
38867  Type ObjectType() const {return Type::UpdateOptionsKit;};
38868 
38872  static UpdateOptionsKit GetDefault();
38873 
38876  void Set(UpdateOptionsKit const & in_kit);
38877 
38880  void Show(UpdateOptionsKit & out_kit) const;
38881 
38885  UpdateOptionsKit & operator=(UpdateOptionsKit const & in_kit);
38886 
38889  bool Empty() const;
38890 
38894  bool Equals(UpdateOptionsKit const & in_kit) const;
38895 
38899  bool operator==(UpdateOptionsKit const & in_kit) const;
38900 
38904  bool operator!=(UpdateOptionsKit const & in_kit) const;
38905 
38909  UpdateOptionsKit & SetUpdateControl(Window::UpdateControl in_control);
38910 
38914  UpdateOptionsKit & SetTimeLimit(Time in_time_limit);
38915 
38918  UpdateOptionsKit & UnsetUpdateControl();
38919 
38922  UpdateOptionsKit & UnsetTimeLimit();
38923 
38926  UpdateOptionsKit & UnsetEverything();
38927 
38928 
38932  bool ShowUpdateControl(Window::UpdateControl & out_control) const;
38933 
38937  bool ShowTimeLimit(Time & out_time_limit) const;
38938 
38939 };
38940 
38941 
38942 
38948 class HPS_API UpdateOptionsControl : public Control
38949 {
38950 public:
38953  explicit UpdateOptionsControl(WindowKey const & in_window);
38954 
38957  UpdateOptionsControl(UpdateOptionsControl const & in_that);
38958 
38963 
38967  UpdateOptionsControl & operator=(UpdateOptionsControl && in_that);
38968 
38970 
38971  Type ObjectType() const {return Type::UpdateOptionsControl;};
38972 
38976  UpdateOptionsControl & operator=(UpdateOptionsControl const & in_that);
38977 
38981  UpdateOptionsControl & SetUpdateControl(Window::UpdateControl in_control);
38982 
38986  UpdateOptionsControl & SetTimeLimit(Time in_time_limit);
38987 
38990  UpdateOptionsControl & UnsetUpdateControl();
38991 
38994  UpdateOptionsControl & UnsetTimeLimit();
38995 
38998  UpdateOptionsControl & UnsetEverything();
38999 
39003  bool ShowUpdateControl(Window::UpdateControl & out_control) const;
39004 
39008  bool ShowTimeLimit(Time & out_time_limit) const;
39009 
39010 private:
39013 };
39014 
39017 class HPS_API World : public Object
39018 {
39019 public:
39023  World(char const * in_license);
39024 
39026  ~World();
39027 
39028  Type ObjectType() const {return Type::World;};
39029 
39034  World & SetMaterialLibraryDirectory(char const * in_directory);
39035 
39040  World & SetFontDirectory(char const * in_directory);
39041 
39047  World & SetFontDirectories(size_t in_count, UTF8 const in_directories[]);
39048 
39053  World & SetFontDirectories(UTF8Array const & in_directories);
39054 
39060  World & SetDriverConfigFile(char const * in_filename);
39061 
39067  World & SetExchangeLibraryDirectory(char const * in_directory);
39068 
39074  World & SetPublishResourceDirectory(char const * in_directory);
39075 
39080  World & SetParasolidSchemaDirectory(char const * in_directory);
39081 
39084  World & UnsetMaterialLibraryDirectory();
39085 
39088  World & UnsetFontDirectories();
39089 
39092  World & UnsetDriverConfigFile();
39093 
39096  World & UnsetExchangeLibraryDirectory();
39097 
39100  World & UnsetPublishResourceDirectory();
39101 
39104  World & UnsetParasolidSchemaDirectory();
39105 
39109  bool ShowLicense(UTF8 & out_license) const;
39110 
39114  bool ShowMaterialLibraryDirectory(UTF8 & out_directory) const;
39115 
39119  bool ShowFontDirectories(UTF8Array & out_directories) const;
39120 
39124  bool ShowDriverConfigFile(UTF8 & out_filename) const;
39125 
39129  bool ShowExchangeLibraryDirectory(UTF8 & out_directory) const;
39130 
39134  bool ShowPublishResourceDirectory(UTF8 & out_directory) const;
39135 
39139  bool ShowParasolidSchemaDirectory(UTF8 & out_directory) const;
39140 
39141 
39142 private:
39144  World();
39145 
39147  virtual void Reset() {}
39148 };
39149 
39150 
39166 class HPS_API EmergencyHandler
39167 {
39168 public:
39169 
39172 
39173  virtual ~EmergencyHandler();
39174 
39176  intptr_t GetClassID() const;
39177 
39180  virtual EmergencyHandler * Clone() const = 0;
39181 
39185  virtual void Handle(const char * message, Emergency::Code code) const = 0;
39186 
39187  static void * operator new (size_t in_size){ return Memory::Allocate(in_size); }
39188  static void operator delete (void * in_ptr, size_t in_size) throw () { HPS_UNREFERENCED(in_size); Memory::Free(in_ptr); }
39189 };
39190 
39191 
39194 class HPS_API Database
39195 {
39196 public:
39201  static void Execute(bool in_once=true);
39202 
39205  static Time GetTime();
39206 
39208  static void Sleep(Time milliseconds);
39209 
39234  static void RelinquishMemory();
39235 
39236 
39262  static void ShowMemoryUsage(size_t & out_allocated, size_t & out_used);
39263 
39271  static void Reset();
39272 
39274  static void Synchronize();
39275 
39278  static WindowKeyArray GetWindowKeys();
39279 
39282  static SegmentKeyArray GetRootSegments();
39283 
39286  static PortfolioKeyArray GetPortfolios();
39287 
39292  static PortfolioKey const GetMaterialLibraryPortfolio();
39293 
39299  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, Window::Driver in_driver = Window::Driver::Default3D);
39300 
39305  static ApplicationWindowKey CreateApplicationWindow(WindowHandle in_window_handle, ApplicationWindowOptionsKit const & in_options);
39306 
39310  static StandAloneWindowKey CreateStandAloneWindow(Window::Driver in_driver = Window::Driver::Default3D);
39311 
39315  static StandAloneWindowKey CreateStandAloneWindow(StandAloneWindowOptionsKit const & in_options);
39316 
39323  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, Window::Driver in_driver = Window::Driver::Default3D);
39324 
39330  static OffScreenWindowKey CreateOffScreenWindow(unsigned int in_width, unsigned int in_height, OffScreenWindowOptionsKit const & in_options);
39331 
39337  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, Window::Driver in_driver = Window::Driver::Default3D);
39338 
39343  static OffScreenWindowKey CreateOffScreenWindow(ImageDefinition const & in_destination_image, OffScreenWindowOptionsKit const & in_options);
39344 
39347  static SegmentKey CreateRootSegment();
39348 
39351  static PortfolioKey CreatePortfolio();
39352 
39355  static EventDispatcher CreateEventDispatcher();
39356 
39360  static EventDispatcher CreateEventDispatcher(char const * in_name);
39361 
39367  static size_t SelectByShell(ShellKit const & in_shell,
39368  SelectionOptionsKit const & in_options,
39369  SelectionResults & out_results);
39370 
39376  static size_t SelectByShell(ShellKey const & in_shell,
39377  SelectionOptionsKit const & in_options,
39378  SelectionResults & out_results);
39379 
39386  static size_t SelectByVolume(SimpleCuboid const & in_volume,
39387  SelectionOptionsKit const & in_options,
39388  SelectionResults & out_results);
39389 
39396  static size_t SelectByRay(Point const & in_start_point, Vector const & in_direction,
39397  SelectionOptionsKit const & in_options,
39398  SelectionResults & out_results);
39399 
39402  static EventDispatcher const & GetEventDispatcher();
39403 
39404 
39408  static bool GetInformationEventFilter(Info::Code in_code);
39409 
39413  static bool GetWarningEventFilter(Info::Code in_code);
39414 
39418  static bool GetErrorEventFilter(Info::Code in_code);
39419 
39424  static bool SetInformationEventFilter(Info::Code in_code, bool in_filtered);
39425 
39430  static bool SetWarningEventFilter(Info::Code in_code, bool in_filtered);
39431 
39436  static bool SetErrorEventFilter(Info::Code in_code, bool in_filtered);
39437 
39438 
39441  static void SetEmergencyHandler(EmergencyHandler const & in_emergency_handler);
39442 
39444  static void UnsetEmergencyHandler();
39445 
39448  static size_t GetSoftMemoryLimit();
39449 
39453  static size_t SetSoftMemoryLimit(size_t in_limit_bytes);
39454 
39458  static bool IsDriverAvailable(Window::Driver in_driver);
39459 
39460 private:
39462  Database();
39463 };
39464 
39465 
39469 
39470 
39471 
39473 class HPS_API EventDispatcher : public Object
39474 {
39475 public:
39478  EventDispatcher();
39479 
39482  EventDispatcher(EventDispatcher const & in_that);
39483 
39487  EventDispatcher(EventDispatcher && in_that);
39488 
39492  EventDispatcher & operator=(EventDispatcher && in_that);
39493 
39494  virtual ~EventDispatcher();
39495 
39496  Type ObjectType() const {return Type::EventDispatcher;};
39497 
39501  EventDispatcher & operator=(EventDispatcher const & in_that);
39502 
39506  bool Equals(EventDispatcher const & in_that) const;
39507 
39511  bool operator==(EventDispatcher const & in_that) const;
39512 
39516  bool operator!=(EventDispatcher const & in_that) const;
39517 
39522  bool Subscribe(EventHandler const & in_handler, intptr_t in_type) const;
39523 
39528  bool UnSubscribe(EventHandler const & in_handler, intptr_t in_type) const;
39529 
39534  bool UnSubscribe(EventHandler const & in_handler) const;
39535 
39540  bool UnSubscribe(intptr_t in_type) const;
39541 
39545  bool InjectEvent(Event const & in_event) const;
39546 
39551  EventNotifier InjectEventWithNotifier(Event const & in_event) const;
39552 
39555  void Shutdown() const;
39556 
39559  bool IsShutdown() const;
39560 
39561 
39564  void SetName(char const * in_name) const;
39565 
39568  void ShowName(UTF8 & out_name) const;
39569 
39570 private:
39572  virtual void Reset() {}
39573 };
39574 
39575 
39578 class HPS_API EventHandler : public Object
39579 {
39580 public:
39582  EventHandler();
39583 
39586  EventHandler(EventHandler const & in_that);
39587 
39591  EventHandler(EventHandler && in_that);
39592 
39596  EventHandler & operator=(EventHandler && in_that);
39597 
39601  EventHandler & operator=(EventHandler const & in_that);
39602 
39603  virtual ~EventHandler();
39604 
39605  Type ObjectType() const {return Type::EventHandler;};
39606 
39611  bool Subscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
39612 
39617  bool UnSubscribe(EventDispatcher const & in_dispatcher, intptr_t in_type) const;
39618 
39622  bool UnSubscribe(EventDispatcher const & in_dispatcher) const;
39623 
39625  void UnSubscribeEverything() const;
39626 
39628  virtual void Reset() { UnSubscribeEverything(); }
39629 
39632  void Shutdown();
39633 
39636  enum class HandleResult
39637  {
39638  Handled,
39639  NotHandled
39640  };
39641 
39646  virtual HandleResult Handle(Event const * in_event) { HPS_UNREFERENCED(in_event); return HandleResult::NotHandled;};
39647 };
39648 
39649 
39650 
39652 class HPS_API TimerTickEvent : public Event
39653 {
39654 public:
39657  {
39658  channel = GetClassID();
39659  consumable = false;
39660  }
39661 
39662 
39665  TimerTickEvent(Event const & in_event) : Event(in_event)
39666  {
39667  if(in_event.GetChannel() != Object::ClassID<TimerTickEvent>())
39668  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
39669  }
39670 
39671  ~TimerTickEvent();
39672 
39675  Event * Clone() const
39676  {
39677  TimerTickEvent * new_event = new TimerTickEvent(*this);
39678  return new_event;
39679  }
39680 
39684  virtual bool Drop(Event const * in_that_event) const
39685  {
39686  HPS_UNREFERENCED(in_that_event);
39687  return true;
39688  }
39689 
39690  virtual intptr_t Freshen() const {
39691  return GetClassID();
39692  }
39693 };
39694 
39696 class HPS_API HighlightEvent : public Event
39697 {
39698 public:
39699  enum class Action
39700  {
39701  None = 0,
39702  Highlight,
39703  Unhighlight,
39704  };
39705 
39708  {
39709  channel = GetClassID();
39710  consumable = false;
39711  action = Action::None;
39712  }
39713 
39714  HighlightEvent(Action in_action, SelectionResults const & in_results = SelectionResults(), HighlightOptionsKit const & in_options = HighlightOptionsKit())
39715  : Event(), action(in_action), results(in_results), options(in_options)
39716  {
39717  channel = GetClassID();
39718  consumable = false;
39719  }
39720 
39723  HighlightEvent(Event const & in_event) : Event(in_event)
39724  {
39725  if (in_event.GetChannel() == Object::ClassID<HighlightEvent>())
39726  {
39727  auto that = static_cast<HighlightEvent const &>(in_event);
39728  action = that.action;
39729  results = that.results;
39730  options = that.options;
39731  }
39732  else
39733  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
39734  }
39735 
39736  ~HighlightEvent();
39737 
39740  Event * Clone() const
39741  {
39742  HighlightEvent * new_event = new HighlightEvent(*this);
39743  return new_event;
39744  }
39745 
39746  Action action;
39747  SelectionResults results;
39748  HighlightOptionsKit options;
39749 };
39750 
39752 class HPS_API InformationEvent : public Event
39753 {
39754 public:
39756  InformationEvent() : Event(), code(Info::Code::Unknown) { channel = GetClassID(); }
39757 
39760  InformationEvent(char const * in_message) : Event(), message(in_message), code(Info::Code::Unknown) { channel = GetClassID(); }
39761 
39765  InformationEvent(char const * in_message, Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
39766 
39769  InformationEvent(Event const & in_event) : Event(in_event)
39770  {
39771  if (in_event.GetChannel() == Object::ClassID<InformationEvent>())
39772  {
39773  InformationEvent const * event = static_cast<InformationEvent const *>(&in_event);
39774  message = event->message;
39775  code = event->code;
39776  }
39777  else
39778  {
39779  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
39780  }
39781  }
39782 
39783  ~InformationEvent();
39784 
39787  Event * Clone() const
39788  {
39789  InformationEvent * new_event = new InformationEvent(*this);
39790  return new_event;
39791  }
39792 
39796  virtual bool Equals(InformationEvent const & in_that) const
39797  {
39798  return message == in_that.message && code == in_that.code;
39799  }
39800 
39804  virtual bool operator== (InformationEvent const & in_that) const
39805  {
39806  return Equals(in_that);
39807  }
39808 
39812  virtual bool operator!= (InformationEvent const & in_that) const
39813  {
39814  return !Equals(in_that);
39815  }
39816 
39819 };
39820 
39821 
39823 class HPS_API WarningEvent : public Event
39824 {
39825 public:
39827  WarningEvent() : Event(), code(Info::Code::Unknown) { channel = GetClassID(); }
39828 
39831  WarningEvent(char const * in_message) : Event(), message(in_message), code(Info::Code::Unknown) { channel = GetClassID(); }
39832 
39836  WarningEvent(char const * in_message, Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
39837 
39840  WarningEvent(Event const & in_event) : Event(in_event)
39841  {
39842  if(in_event.GetChannel() == Object::ClassID<WarningEvent>())
39843  {
39844  WarningEvent const * event = static_cast<WarningEvent const *>(&in_event);
39845  message = event->message;
39846  code = event->code;
39847  }
39848  else
39849  {
39850  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
39851  }
39852  }
39853 
39854  ~WarningEvent();
39855 
39858  Event * Clone() const
39859  {
39860  WarningEvent * new_event = new WarningEvent(*this);
39861  return new_event;
39862  }
39863 
39867  virtual bool Equals(WarningEvent const & in_that) const
39868  {
39869  return message == in_that.message && code == in_that.code;
39870  }
39871 
39875  virtual bool operator== (WarningEvent const & in_that) const
39876  {
39877  return Equals(in_that);
39878  }
39879 
39883  virtual bool operator!= (WarningEvent const & in_that) const
39884  {
39885  return !Equals(in_that);
39886  }
39887 
39890 };
39891 
39892 
39894 class HPS_API ErrorEvent : public Event
39895 {
39896 public:
39898  ErrorEvent() : Event(), code(Info::Code::Unknown) { channel = GetClassID(); }
39899 
39902  ErrorEvent(char const * in_message) : Event(), message(in_message), code(Info::Code::Unknown) { channel = GetClassID(); }
39903 
39907  ErrorEvent(char const * in_message, Info::Code in_code) : Event(), message(in_message), code(in_code) { channel = GetClassID(); }
39908 
39911  ErrorEvent(Event const & in_event) : Event(in_event)
39912  {
39913  if(in_event.GetChannel() == Object::ClassID<ErrorEvent>())
39914  {
39915  ErrorEvent const * event = static_cast<ErrorEvent const *>(&in_event);
39916  message = event->message;
39917  code = event->code;
39918  }
39919  else
39920  {
39921  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
39922  }
39923  }
39924 
39925  ~ErrorEvent();
39926 
39929  Event * Clone() const
39930  {
39931  ErrorEvent * new_event = new ErrorEvent(*this);
39932  return new_event;
39933  }
39934 
39938  virtual bool Equals(ErrorEvent const & in_that) const
39939  {
39940  return message == in_that.message && code == in_that.code;
39941  }
39942 
39946  virtual bool operator== (ErrorEvent const & in_that) const
39947  {
39948  return Equals(in_that);
39949  }
39950 
39954  virtual bool operator!= (ErrorEvent const & in_that) const
39955  {
39956  return !Equals(in_that);
39957  }
39958 
39961 };
39962 
39963 
39965 class HPS_API StandAloneWindowEvent : public Event
39966 {
39967 public:
39968 
39971  enum class Action
39972  {
39973  Unknown,
39974  Close,
39975  FocusIn,
39976  FocusOut,
39977  };
39978 
39980  StandAloneWindowEvent() : Event(), action(Action::Unknown) { channel = GetClassID(); }
39981 
39982 
39985  StandAloneWindowEvent(Action in_action) : Event(), action(in_action) { channel = GetClassID(); }
39986 
39989  StandAloneWindowEvent(Event const & in_event) : Event(in_event)
39990  {
39991  if(in_event.GetChannel() == Object::ClassID<StandAloneWindowEvent>())
39992  {
39993  StandAloneWindowEvent const * event = static_cast<StandAloneWindowEvent const *>(&in_event);
39994  action = event->action;
39995  }
39996  else
39997  {
39998  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
39999  }
40000  }
40001 
40003 
40006  Event * Clone() const
40007  {
40008  StandAloneWindowEvent * new_event = new StandAloneWindowEvent(*this);
40009  return new_event;
40010  }
40011 
40015  virtual bool Equals(StandAloneWindowEvent const & in_that) const
40016  {
40017  return action == in_that.action;
40018  }
40019 
40023  virtual bool operator== (StandAloneWindowEvent const & in_that) const
40024  {
40025  return Equals(in_that);
40026  }
40027 
40031  virtual bool operator!= (StandAloneWindowEvent const & in_that) const
40032  {
40033  return !Equals(in_that);
40034  }
40035 
40037 };
40038 
40040 class HPS_API FocusLostEvent : public Event
40041 {
40042 public:
40045  Event()
40046  { channel = GetClassID(); }
40047 
40048  ~FocusLostEvent() {};
40049 
40052  Event * Clone() const
40053  {
40054  FocusLostEvent * new_event = new FocusLostEvent(*this);
40055  return new_event;
40056  }
40057 };
40058 
40059 
40061 class HPS_API UpdateCompletedEvent : public Event
40062 {
40063 public:
40065  UpdateCompletedEvent() : Event(), update_time(-1) { channel = GetClassID(); }
40066 
40068  UpdateCompletedEvent(Time in_update_time) : Event(), update_time(in_update_time) { channel = GetClassID(); }
40069 
40070  virtual ~UpdateCompletedEvent();
40071 
40074  Event * Clone() const
40075  {
40076  UpdateCompletedEvent * new_event = new UpdateCompletedEvent(*this);
40077  return new_event;
40078  }
40079 
40080  Time update_time;
40081 };
40082 
40084 class HPS_API ImportStatusEvent : public Event
40085 {
40086 public:
40089  : Event()
40090  , import_status_message(UTF8())
40091  { channel = GetClassID(); }
40092 
40093  ImportStatusEvent(char const * in_message)
40094  : Event()
40095  , import_status_message(in_message)
40096  { channel = GetClassID(); }
40097 
40098  ~ImportStatusEvent() {};
40099 
40102  Event * Clone() const
40103  {
40104  ImportStatusEvent * new_event = new ImportStatusEvent(*this);
40105  return new_event;
40106  }
40107 
40108  UTF8 import_status_message;
40109 };
40110 
40112 class HPS_API ModifierKeys
40113 {
40114 public:
40116  ModifierKeys() : modifiers(_key_none) {}
40117 
40121  bool Equals(ModifierKeys const & in_that) const
40122  {
40123  return modifiers == in_that.modifiers;
40124  }
40125 
40129  bool operator== (ModifierKeys const & in_that) const
40130  {
40131  return Equals(in_that);
40132  }
40133 
40137  bool operator!= (ModifierKeys const & in_that) const
40138  {
40139  return !Equals(in_that);
40140  }
40141 
40144  bool None() const { return modifiers == _key_none; }
40145 
40148  bool Shift() const { return (modifiers & _key_shift) != 0; }
40149 
40152  bool Control() const { return (modifiers & _key_control) != 0; }
40153 
40156  bool Alt() const { return (modifiers & _key_alt) != 0; }
40157 
40160  bool Meta() const { return (modifiers & _key_meta) != 0; }
40161 
40162 
40166  bool HasAll(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
40167 
40171  bool HasAny(ModifierKeys const & in_keys) const { return (modifiers & in_keys.modifiers) != 0; }
40172 
40173 
40176  void Shift(bool in_state) { if(in_state) modifiers |= _key_shift; else modifiers &= ~(_key_shift); }
40177 
40180  void Control(bool in_state) { if(in_state) modifiers |= _key_control; else modifiers &= ~(_key_control); }
40181 
40184  void Alt(bool in_state) { if(in_state) modifiers |= _key_alt; else modifiers &= ~(_key_alt); }
40185 
40188  void Meta(bool in_state) { if(in_state) modifiers |= _key_meta; else modifiers &= ~(_key_meta); }
40189 
40193  ModifierKeys operator+ (ModifierKeys const & in_modifiers_to_merge)
40194  {
40195  ModifierKeys ret;
40196  ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
40197  return ret;
40198  }
40199 
40203  ModifierKeys operator- (ModifierKeys const & in_modifiers_to_remove)
40204  {
40205  ModifierKeys ret;
40206  ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
40207  return ret;
40208  }
40209 
40213  ModifierKeys & operator+= (ModifierKeys const & in_modifiers_to_merge) { *this = *this + in_modifiers_to_merge; return *this; }
40214 
40218  ModifierKeys & operator-= (ModifierKeys const & in_modifiers_to_remove) { *this = *this - in_modifiers_to_remove; return *this; }
40219 
40220 
40223  static ModifierKeys KeyShift() { ModifierKeys ret; ret.Shift(true); return ret; }
40224 
40227  static ModifierKeys KeyControl() { ModifierKeys ret; ret.Control(true); return ret; }
40228 
40231  static ModifierKeys KeyAlt() { ModifierKeys ret; ret.Alt(true); return ret; }
40232 
40235  static ModifierKeys KeyMeta() { ModifierKeys ret; ret.Meta(true); return ret; }
40236 
40237 protected:
40238 
40242  {
40243  _key_none = 0x0000,
40244  _key_shift = 0x0001,
40245  _key_control = 0x0002,
40246  _key_alt = 0x0004,
40247  _key_meta = 0x0008,
40248  };
40249 
40250  int modifiers;
40251 };
40252 
40253 
40256 class HPS_API InputEvent : public Event
40257 {
40258 public:
40259 
40261  InputEvent() : Event() { channel = GetClassID(); }
40262 
40265  InputEvent(ModifierKeys const & in_modifiers) : Event(), ModifierKeyState(in_modifiers) { channel = GetClassID(); }
40266 
40267  ~InputEvent();
40268 
40271  Event * Clone() const
40272  {
40273  InputEvent * new_event = new InputEvent(*this);
40274  return new_event;
40275  }
40276 
40280  virtual bool Equals(InputEvent const & in_that) const
40281  {
40282  return ModifierKeyState == in_that.ModifierKeyState;
40283  }
40284 
40288  virtual bool operator== (InputEvent const & in_that) const
40289  {
40290  return Equals(in_that);
40291  }
40292 
40296  virtual bool operator!= (InputEvent const & in_that) const
40297  {
40298  return !Equals(in_that);
40299  }
40300 
40305  {
40306  return ModifierKeyState;
40307  }
40308 
40310 };
40311 
40313 class HPS_API TouchEvent : public InputEvent
40314 {
40315 public:
40318  enum class Action
40319  {
40320  TouchDown,
40321  TouchUp,
40322  Move,
40323  };
40324 
40326  TouchEvent() : InputEvent() { channel = GetClassID(); }
40327 
40332  TouchEvent(Action in_action, ModifierKeys in_modifier = ModifierKeys())
40333  : InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
40334 
40340  TouchEvent(Action in_action, TouchArray const & in_touches, ModifierKeys in_modifier = ModifierKeys())
40341  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
40342 
40349  TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier = ModifierKeys())
40350  : InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
40351 
40352 
40355  TouchEvent(Event const & in_event) : InputEvent()
40356  {
40357  if(in_event.GetChannel() == Object::ClassID<TouchEvent>())
40358  {
40359  TouchEvent const * event = static_cast<TouchEvent const *>(&in_event);
40360  channel = GetClassID();
40361  CurrentAction = event->CurrentAction;
40362  Touches = event->Touches;
40363  ModifierKeyState = event->ModifierKeyState;
40364  }
40365  else
40366  throw InvalidSpecificationException("Invalid Event type to cast from.");
40367  }
40368 
40369  ~TouchEvent();
40370 
40371 
40374  Event * Clone() const
40375  {
40376  TouchEvent * new_event = new TouchEvent(*this);
40377  return new_event;
40378  }
40379 
40383  virtual bool Equals(TouchEvent const & in_that) const
40384  {
40385  return InputEvent::Equals(in_that) && Touches == in_that.Touches && CurrentAction == in_that.CurrentAction;
40386  }
40387 
40391  virtual bool operator== (TouchEvent const & in_that) const
40392  {
40393  return Equals(in_that);
40394  }
40395 
40399  virtual bool operator!= (TouchEvent const & in_that) const
40400  {
40401  return !Equals(in_that);
40402  }
40403 
40407  virtual bool Drop(Event const * in_that_event) const
40408  {
40409  TouchEvent const * that_touch_event = static_cast<TouchEvent const *>(in_that_event);
40410 
40411  if (CurrentAction == that_touch_event->CurrentAction && CurrentAction == Action::Move
40412  && Touches.size() == that_touch_event->Touches.size() )
40413  {
40414  TouchArray these_touches = Touches;
40415  TouchArray those_touches = that_touch_event->Touches;
40416 
40417  std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
40418  std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
40419 
40420  for (size_t i = 0 ; i < these_touches.size() ; i++)
40421  {
40422  if (these_touches[i].ID != those_touches[i].ID)
40423  return false;
40424  }
40425  return true;
40426  }
40427 
40428  return false;
40429  }
40430 
40434  void SetTouches(size_t in_touch_count, Touch const in_touches[])
40435  {
40436  Touches.assign(in_touches, in_touches + in_touch_count);
40437  }
40438 
40441  void SetTouches(TouchArray const & in_touches)
40442  {
40443  Touches = in_touches;
40444  }
40445 
40447  TouchArray Touches;
40448 
40449 private:
40455  static bool sort_predicate(Touch const & in_a, Touch const & in_b)
40456  {
40457  return static_cast<int>(in_a.ID) < static_cast<int>(in_b.ID);
40458  }
40459 };
40460 
40461 
40463 class HPS_API MouseButtons
40464 {
40465 public:
40467  MouseButtons() : buttons(_button_none) {}
40468 
40472  bool Equals(MouseButtons const & in_that) const
40473  {
40474  return buttons == in_that.buttons;
40475  }
40476 
40480  bool operator== (MouseButtons const & in_that) const
40481  {
40482  return Equals(in_that);
40483  }
40484 
40488  bool operator!= (MouseButtons const & in_that) const
40489  {
40490  return !Equals(in_that);
40491  }
40492 
40495  bool None() const { return buttons == _button_none; }
40496 
40499  bool Left() const { return (buttons & _button_left) != 0; }
40500 
40503  bool Right() const { return (buttons & _button_right) != 0; }
40504 
40507  bool Middle() const { return (buttons & _button_middle) != 0; }
40508 
40511  bool X1() const { return (buttons & _button_x1) != 0; }
40512 
40515  bool X2() const { return (buttons & _button_x2) != 0; }
40516 
40517 
40521  bool HasAll(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) == in_buttons.buttons; }
40522 
40526  bool HasAny(MouseButtons const & in_buttons) const { return (buttons & in_buttons.buttons) != 0; }
40527 
40530  void Left(bool in_state) { if(in_state) buttons |= _button_left; else buttons &= ~(_button_left); }
40531 
40534  void Right(bool in_state) { if(in_state) buttons |= _button_right; else buttons &= ~(_button_right); }
40535 
40538  void Middle(bool in_state) { if(in_state) buttons |= _button_middle; else buttons &= ~(_button_middle); }
40539 
40542  void X1(bool in_state) { if(in_state) buttons |= _button_x1; else buttons &= ~(_button_x1); }
40543 
40546  void X2(bool in_state) { if(in_state) buttons |= _button_x2; else buttons &= ~(_button_x2); }
40547 
40551  MouseButtons operator+ (MouseButtons const & in_buttons_to_merge)
40552  {
40553  MouseButtons ret;
40554  ret.buttons = buttons | in_buttons_to_merge.buttons;
40555  return ret;
40556  }
40557 
40561  MouseButtons operator- (MouseButtons const & in_buttons_to_remove)
40562  {
40563  MouseButtons ret;
40564  ret.buttons = buttons & ~in_buttons_to_remove.buttons;
40565  return ret;
40566  }
40567 
40571  MouseButtons & operator+= (MouseButtons const & in_buttons_to_merge) { *this = *this + in_buttons_to_merge; return *this; }
40572 
40576  MouseButtons & operator-= (MouseButtons const & in_buttons_to_remove) { *this = *this - in_buttons_to_remove; return *this; }
40577 
40578 
40581  static MouseButtons ButtonLeft() { MouseButtons ret; ret.Left(true); return ret; }
40582 
40585  static MouseButtons ButtonRight() { MouseButtons ret; ret.Right(true); return ret; }
40586 
40589  static MouseButtons ButtonMiddle() { MouseButtons ret; ret.Middle(true); return ret; }
40590 
40593  static MouseButtons ButtonX1() { MouseButtons ret; ret.X1(true); return ret; }
40594 
40597  static MouseButtons ButtonX2() { MouseButtons ret; ret.X2(true); return ret; }
40598 
40599 protected:
40600 
40603  enum Buttons
40604  {
40605  _button_none = 0x0000,
40606  _button_left = 0x0001,
40607  _button_right = 0x0002,
40608  _button_middle = 0x0004,
40609  _button_x1 = 0x0008,
40610  _button_x2 = 0x0010
40611  };
40612 
40613  int buttons;
40614 };
40615 
40617 class HPS_API MouseEvent : public InputEvent
40618 {
40619 public:
40620 
40623  enum class Action
40624  {
40625  ButtonUp,
40626  ButtonDown,
40627  Move,
40628  Scroll,
40629  Enter,
40630  Leave
40631  };
40632 
40634  MouseEvent() : InputEvent() { channel = GetClassID(); }
40635 
40642  MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button = MouseButtons(), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
40643  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
40644 
40652  MouseEvent(Action in_action, float in_wheel_delta, WindowPoint in_location = WindowPoint(0,0,0), ModifierKeys in_modifier = ModifierKeys(), size_t in_click_count = 0)
40653  : InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
40654 
40657  MouseEvent(Event const & in_event) : InputEvent()
40658  {
40659  if(in_event.GetChannel() == Object::ClassID<MouseEvent>())
40660  {
40661  MouseEvent const * event = static_cast<MouseEvent const *>(&in_event);
40662  channel = GetClassID();
40663  CurrentAction = event->CurrentAction;
40664  Location = event->Location;
40665  CurrentButton = event->CurrentButton;
40666  WheelDelta = event->WheelDelta;
40667  ClickCount = event->ClickCount;
40668  }
40669  else
40670  {
40671  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
40672  }
40673  }
40674 
40675  ~MouseEvent();
40676 
40679  Event * Clone() const
40680  {
40681  MouseEvent * new_event = new MouseEvent(*this);
40682  return new_event;
40683  }
40684 
40688  virtual bool Equals(MouseEvent const & in_that) const
40689  {
40690  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction
40691  && CurrentButton == in_that.CurrentButton && WheelDelta == in_that.WheelDelta
40692  && Location == in_that.Location && ClickCount == in_that.ClickCount;
40693  }
40694 
40698  virtual bool operator== (MouseEvent const & in_that) const
40699  {
40700  return Equals(in_that);
40701  }
40702 
40706  virtual bool operator!= (MouseEvent const & in_that) const
40707  {
40708  return !Equals(in_that);
40709  }
40710 
40714  virtual bool Drop(Event const * in_that_event) const
40715  {
40716  MouseEvent const * that_mouse_event = static_cast<MouseEvent const *>(in_that_event);
40717 
40718  if (CurrentAction == that_mouse_event->CurrentAction &&
40719  (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
40720  CurrentButton == that_mouse_event->CurrentButton)
40721  return true;
40722 
40723  return false;
40724  }
40725 
40726  virtual intptr_t Freshen() const {
40727 
40728  if (CurrentAction == Action::Move)
40729  return GetClassID();
40730 
40731  return 0;
40732  }
40733 
40737  float WheelDelta;
40738  size_t ClickCount;
40739 };
40740 
40741 
40743 class HPS_API KeyboardEvent : public InputEvent
40744 {
40745 public:
40748  enum class Action
40749  {
40750  None,
40751  KeyDown,
40752  KeyUp
40753  };
40754 
40756  KeyboardEvent() : InputEvent(), CurrentAction(Action::None) { channel = GetClassID(); }
40757 
40762  : InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
40763 
40769  KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers = ModifierKeys())
40770  : InputEvent(in_modifiers), CurrentAction(in_action)
40771  {
40772  channel = GetClassID();
40773  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
40774  }
40775 
40780  KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const & in_keyboardcodes, ModifierKeys in_modifiers = ModifierKeys())
40781  : InputEvent(in_modifiers), CurrentAction(in_action)
40782  {
40783  channel = GetClassID();
40784  KeyboardCodes = in_keyboardcodes;
40785  }
40786 
40789  KeyboardEvent(Event const & in_event) : InputEvent()
40790  {
40791  if(in_event.GetChannel() == Object::ClassID<KeyboardEvent>())
40792  {
40793  KeyboardEvent const * event = static_cast<KeyboardEvent const *>(&in_event);
40794  channel = GetClassID();
40795  KeyboardCodes = event->KeyboardCodes;
40796  CurrentAction = event->CurrentAction;
40797  }
40798  else
40799  {
40800  throw InvalidSpecificationException("Invalid Event Type to Cast From.");
40801  }
40802  }
40803 
40804  ~KeyboardEvent();
40805 
40808  Event * Clone() const
40809  {
40810  KeyboardEvent * new_event = new KeyboardEvent(*this);
40811  return new_event;
40812  }
40813 
40817  virtual bool Equals(KeyboardEvent const & in_that) const
40818  {
40819  return InputEvent::Equals(in_that) && CurrentAction == in_that.CurrentAction && KeyboardCodes == in_that.KeyboardCodes;
40820  }
40821 
40825  virtual bool operator== (KeyboardEvent const & in_that) const
40826  {
40827  return Equals(in_that);
40828  }
40829 
40833  virtual bool operator!= (KeyboardEvent const & in_that) const
40834  {
40835  return !Equals(in_that);
40836  }
40837 
40841  void SetKeyboardCodes(size_t in_keyboardcode_count, KeyboardCode const in_keyboardcodes[])
40842  {
40843  KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
40844  }
40845 
40848  void SetKeyboardCodes(KeyboardCodeArray const & in_keyboardcodes)
40849  {
40850  KeyboardCodes = in_keyboardcodes;
40851  }
40852 
40853  KeyboardCodeArray KeyboardCodes;
40855 };
40856 
40857 
40859 class HPS_API MouseState : public Object
40860 {
40861 public:
40863  MouseState();
40864 
40867  MouseState(MouseState const & in_that);
40868 
40872  MouseState(MouseState && in_that);
40873 
40877  MouseState & operator=(MouseState && in_that);
40878 
40879  ~MouseState();
40880 
40881  Type ObjectType() const {return Type::MouseState;};
40882 
40885  void Assign(MouseState const & in_that);
40886 
40890  MouseState & operator=(MouseState const & in_that);
40891 
40895  bool Equals(MouseState const & in_that) const;
40896 
40900  bool operator== (MouseState const & in_that) const;
40901 
40905  bool operator!= (MouseState const & in_that) const;
40906 
40909  MouseEvent GetActiveEvent() const;
40910 
40914  WindowKey GetEventSource() const;
40915 
40919  KeyArray GetEventPath() const;
40920 
40923  MouseButtons GetButtons() const;
40924 
40927  WindowPoint GetLocation() const;
40928 
40931  ModifierKeys GetModifierKeys() const;
40932 };
40933 
40934 
40935 
40937 class HPS_API TouchState : public Object
40938 {
40939 public:
40941  TouchState();
40942 
40945  TouchState(TouchState const & in_that);
40946 
40950  TouchState(TouchState && in_that);
40951 
40955  TouchState & operator=(TouchState && in_that);
40956 
40957  ~TouchState();
40958 
40959  Type ObjectType() const {return Type::TouchState;};
40960 
40963  void Assign(TouchState const & in_that);
40964 
40968  TouchState & operator=(TouchState const & in_that);
40969 
40973  bool Equals(TouchState const & in_that) const;
40974 
40978  bool operator== (TouchState const & in_that) const;
40979 
40983  bool operator!= (TouchState const & in_that) const;
40984 
40987  TouchEvent GetActiveEvent() const;
40988 
40992  WindowKey GetEventSource() const;
40993 
40997  KeyArray GetEventPath() const;
40998 
41001  size_t GetTouchCount() const;
41002 
41005  TouchArray GetTouches() const;
41006 
41009  ModifierKeys GetModifierKeys() const;
41010 };
41011 
41012 
41013 
41015 class HPS_API KeyboardState : public Object
41016 {
41017 public:
41019  KeyboardState();
41020 
41023  KeyboardState(KeyboardState const & in_that);
41024 
41028  KeyboardState(KeyboardState && in_that);
41029 
41033  KeyboardState & operator=(KeyboardState && in_that);
41034 
41035  ~KeyboardState();
41036 
41037  Type ObjectType() const {return Type::KeyboardState;};
41038 
41041  void Assign(KeyboardState const & in_that);
41042 
41046  KeyboardState & operator=(KeyboardState const & in_that);
41047 
41051  bool Equals(KeyboardState const & in_that) const;
41052 
41056  bool operator== (KeyboardState const & in_that) const;
41057 
41061  bool operator!= (KeyboardState const & in_that) const;
41062 
41065  KeyboardEvent GetActiveEvent() const;
41066 
41070  WindowKey GetEventSource() const;
41071 
41075  KeyArray GetEventPath() const;
41076 
41079  size_t GetKeyboardCodeCount() const;
41080 
41083  KeyboardCodeArray GetKeyboardCodes() const;
41084 
41088  bool GetKeyState(KeyboardCode in_key_code) const;
41089 
41092  ModifierKeys GetModifierKeys() const;
41093 };
41094 
41095 
41099 
41102 class HPS_API IONotifier : public Object
41103 {
41104 public:
41106  IONotifier();
41107 
41110  IONotifier(IONotifier const & in_that);
41111 
41115  IONotifier(IONotifier && in_that);
41116 
41120  IONotifier & operator=(IONotifier && in_that);
41121 
41122  virtual ~IONotifier();
41123 
41124  Type ObjectType() const {return Type::IONotifier;};
41125 
41129  IONotifier & operator=(IONotifier const & in_that);
41130 
41133  void Assign(IONotifier const & in_that);
41134 
41136  void Wait();
41137 
41140  IOResult Status() const;
41141 
41145  IOResult Status(float & out_percent_complete) const;
41146 
41150  void Cancel();
41151 };
41152 
41154 class HPS_API Stream
41155 {
41156 public:
41157 
41159  class HPS_API ImportOptionsKit : public Object
41160  {
41161  public:
41163  ImportOptionsKit();
41164 
41167  ImportOptionsKit(ImportOptionsKit const & in_kit);
41168 
41172  ImportOptionsKit(ImportOptionsKit && in_that);
41173 
41177  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
41178 
41179  virtual ~ImportOptionsKit();
41180 
41181  Type ObjectType() const { return Type::StreamImportOptionsKit; };
41182 
41185  void Set(ImportOptionsKit const & in_kit);
41186 
41189  void Show(ImportOptionsKit & out_kit) const;
41190 
41194  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
41195 
41198  bool Empty() const;
41199 
41203  bool Equals(ImportOptionsKit const & in_kit) const;
41204 
41208  bool operator==(ImportOptionsKit const & in_kit) const;
41209 
41213  bool operator!=(ImportOptionsKit const & in_kit) const;
41214 
41219  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
41220 
41223  ImportOptionsKit & UnsetSegment();
41224 
41228  bool ShowSegment(SegmentKey & out_segment) const;
41229 
41234  ImportOptionsKit & SetAlternateRoot(SegmentKey const & in_segment);
41235 
41238  ImportOptionsKit & UnsetAlternateRoot();
41239 
41243  bool ShowAlternateRoot(SegmentKey & out_segment) const;
41244 
41249  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
41250 
41253  ImportOptionsKit & UnsetPortfolio();
41254 
41258  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
41259 
41262  ImportOptionsKit & UnsetEverything();
41263  };
41264 
41266  class HPS_API ImportResultsKit : public Object
41267  {
41268  public:
41270  ImportResultsKit();
41271 
41274  ImportResultsKit(ImportResultsKit const & in_kit);
41275 
41279  ImportResultsKit(ImportResultsKit && in_that);
41280 
41284  ImportResultsKit & operator=(ImportResultsKit && in_that);
41285 
41286  virtual ~ImportResultsKit();
41287 
41288  Type ObjectType() const { return Type::StreamImportResultsKit; };
41289 
41292  void Set(ImportResultsKit const & in_kit);
41293 
41296  void Show(ImportResultsKit & out_kit) const;
41297 
41301  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
41302 
41305  bool Empty() const;
41306 
41310  bool Equals(ImportResultsKit const & in_kit) const;
41311 
41315  bool operator==(ImportResultsKit const & in_kit) const;
41316 
41320  bool operator!=(ImportResultsKit const & in_kit) const;
41321 
41326  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
41327 
41331  ImportResultsKit & UnsetSegment();
41332 
41337  bool ShowSegment(SegmentKey & out_segment) const;
41338 
41343  ImportResultsKit & SetAlternateRoot(SegmentKey const & in_segment);
41344 
41348  ImportResultsKit & UnsetAlternateRoot();
41349 
41355  bool ShowAlternateRoot(SegmentKey & out_segment) const;
41356 
41361  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
41362 
41366  ImportResultsKit & UnsetPortfolio();
41367 
41373  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
41374 
41379  ImportResultsKit & SetDefaultCamera(CameraKit const & in_camera);
41380 
41384  ImportResultsKit & UnsetDefaultCamera();
41385 
41389  bool ShowDefaultCamera(CameraKit & out_camera) const;
41390 
41391 
41397  ImportResultsKit & SetAlternateCameras(UTF8Array const & in_names, CameraKitArray & in_cameras);
41398 
41402  ImportResultsKit & UnsetAlternateCameras();
41403 
41408  bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras) const;
41409 
41410 
41413  ImportResultsKit & UnsetEverything();
41414  };
41415 
41417  class HPS_API ExportOptionsKit : public Object
41418  {
41419  public:
41421  ExportOptionsKit();
41422 
41425  ExportOptionsKit(ExportOptionsKit const & in_kit);
41426 
41430  ExportOptionsKit(ExportOptionsKit && in_that);
41431 
41435  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
41436 
41440  static ExportOptionsKit GetDefault();
41441 
41442  virtual ~ExportOptionsKit();
41443 
41444  Type ObjectType() const { return Type::StreamExportOptionsKit; };
41445 
41448  void Set(ExportOptionsKit const & in_kit);
41449 
41452  void Show(ExportOptionsKit & out_kit) const;
41453 
41457  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
41458 
41461  bool Empty() const;
41462 
41466  bool Equals(ExportOptionsKit const & in_kit) const;
41467 
41471  bool operator==(ExportOptionsKit const & in_kit) const;
41472 
41476  bool operator!=(ExportOptionsKit const & in_kit) const;
41477 
41485  ExportOptionsKit & SetVertexCompression(bool in_state, unsigned int in_bits_per_vertex = 24);
41486 
41494  ExportOptionsKit & SetNormalCompression(bool in_state, unsigned int in_bits_per_normal = 10);
41495 
41501  ExportOptionsKit & SetParameterCompression(bool in_state, unsigned int in_bits_per_parameter = 8);
41502 
41510  ExportOptionsKit & SetColorCompression(bool in_state, unsigned int in_bits_per_color = 24);
41511 
41519  ExportOptionsKit & SetIndexCompression(bool in_state, unsigned int in_bits_per_index = 8);
41520 
41526  ExportOptionsKit & SetConnectivityCompression(bool in_state);
41527 
41536  ExportOptionsKit & SetImageCompression(bool in_state, float in_quality = 0.75f);
41537 
41540  ExportOptionsKit & UnsetVertexCompression();
41541 
41544  ExportOptionsKit & UnsetNormalCompression();
41545 
41548  ExportOptionsKit & UnsetParameterCompression();
41549 
41552  ExportOptionsKit & UnsetColorCompression();
41553 
41556  ExportOptionsKit & UnsetIndexCompression();
41557 
41560  ExportOptionsKit & UnsetConnectivityCompression();
41561 
41564  ExportOptionsKit & UnsetImageCompression();
41565 
41568  ExportOptionsKit & UnsetEverything();
41569 
41574  bool ShowVertexCompression(bool & out_state, unsigned int & out_bits_per_vertex) const;
41575 
41580  bool ShowNormalCompression(bool & out_state, unsigned int & out_bits_per_normal) const;
41581 
41586  bool ShowParameterCompression(bool & out_state, unsigned int & out_bits_per_parameter) const;
41587 
41592  bool ShowColorCompression(bool & out_state, unsigned int & out_bits_per_color) const;
41593 
41598  bool ShowIndexCompression(bool & out_state, unsigned int & out_bits_per_index) const;
41599 
41603  bool ShowConnectivityCompression(bool & out_state) const;
41604 
41609  bool ShowImageCompression(bool & out_state, float & out_quality) const;
41610  };
41611 
41614  class HPS_API ImportNotifier : public IONotifier
41615  {
41616  public:
41618  ImportNotifier();
41619 
41622  ImportNotifier(ImportNotifier const & in_that);
41623 
41628  ImportNotifier(IONotifier const & in_that);
41629 
41633  ImportNotifier(ImportNotifier && in_that);
41634 
41638  ImportNotifier & operator=(ImportNotifier && in_that);
41639 
41640  virtual ~ImportNotifier();
41641 
41642  Type ObjectType() const {return Type::StreamImportNotifier;};
41643 
41647  ImportNotifier & operator=(ImportNotifier const & in_that);
41648 
41651  void Assign(ImportNotifier const & in_that);
41652 
41656  ImportResultsKit GetResults() const;
41657  };
41658 
41659 
41661  class HPS_API File
41662  {
41663  public:
41669  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
41670 
41676  static void Export(const char * in_file_name, SegmentKey const & in_segment, ExportOptionsKit const & in_options);
41677 
41683  static void Export(SegmentKey const & in_segment, ExportOptionsKit const & in_options, ByteArrayArray & out_hsf_buffers);
41684 
41685  private:
41687  File();
41688  };
41689 private:
41691  Stream();
41692 };
41693 
41697 
41702 class HPS_API Hardcopy
41703 {
41704 public:
41705 
41707  enum class SizeUnits
41708  {
41709  Centimeters,
41710  Inches,
41711  };
41712 
41714  enum class ResolutionUnits
41715  {
41716  DPCM,
41717  DPI,
41718  DotsPerCentimeter = DPCM,
41719  DotsPerInch = DPI,
41720  };
41721 
41723  class HPS_API File
41724  {
41725  public:
41726 
41728  class HPS_API ExportOptionsKit : public Object
41729  {
41730  public:
41732  ExportOptionsKit();
41733 
41736  ExportOptionsKit(ExportOptionsKit const & in_kit);
41737 
41741  ExportOptionsKit(ExportOptionsKit && in_that);
41742 
41746  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
41747 
41748  virtual ~ExportOptionsKit();
41749 
41750  Type ObjectType() const { return Type::HardcopyExportOptionsKit; };
41751 
41754  void Set(ExportOptionsKit const & in_kit);
41755 
41758  void Show(ExportOptionsKit & out_kit) const;
41759 
41763  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
41764 
41767  bool Empty() const;
41768 
41772  bool Equals(ExportOptionsKit const & in_kit) const;
41773 
41777  bool operator==(ExportOptionsKit const & in_kit) const;
41778 
41782  bool operator!=(ExportOptionsKit const & in_kit) const;
41783 
41784 
41785 
41786 
41792  bool ShowSize(float & out_width, float & out_height, Hardcopy::SizeUnits & out_units) const;
41793 
41801  ExportOptionsKit & SetSize(float in_width, float in_height, Hardcopy::SizeUnits in_units = Hardcopy::SizeUnits::Inches);
41802 
41805  ExportOptionsKit & UnsetSize();
41806 
41807 
41808 
41814  bool ShowResolution(float & out_resolution, Hardcopy::ResolutionUnits & out_units) const;
41815 
41822  ExportOptionsKit & SetResolution(float in_resolution, Hardcopy::ResolutionUnits in_units = Hardcopy::ResolutionUnits::DPI);
41823 
41826  ExportOptionsKit & UnsetResolution();
41827 
41828 
41829 
41832  bool ShowWYSIWYG(bool & out_onoff) const;
41833 
41839  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
41840 
41843  ExportOptionsKit & UnsetWYSIWYG();
41844 
41845 
41848  ExportOptionsKit & UnsetEverything();
41849 
41850 
41854  static ExportOptionsKit GetDefault();
41855  };
41856 
41858  enum class Driver
41859  {
41860  PDF,
41861  Postscript
41862  };
41863 
41869  static IOResult Export(char const * in_filename, Driver in_driver_type, WindowKey const & in_window, ExportOptionsKit const & in_options);
41870  private:
41871  File();
41872  };
41873 
41874 #ifdef _MSC_VER
41875  class HPS_API GDI
41876  {
41877  public:
41878 
41880  class HPS_API ExportOptionsKit : public Object
41881  {
41882  public:
41884  ExportOptionsKit();
41885 
41888  ExportOptionsKit(ExportOptionsKit const & in_kit);
41889 
41893  ExportOptionsKit(ExportOptionsKit && in_that);
41894 
41898  ExportOptionsKit & operator=(ExportOptionsKit && in_that);
41899 
41900  virtual ~ExportOptionsKit();
41901 
41902  Type ObjectType() const { return Type::HardcopyExportOptionsKit; };
41903 
41906  void Set(ExportOptionsKit const & in_kit);
41907 
41910  void Show(ExportOptionsKit & out_kit) const;
41911 
41915  ExportOptionsKit & operator=(ExportOptionsKit const & in_kit);
41916 
41919  bool Empty() const;
41920 
41924  bool Equals(ExportOptionsKit const & in_kit) const;
41925 
41929  bool operator==(ExportOptionsKit const & in_kit) const;
41930 
41934  bool operator!=(ExportOptionsKit const & in_kit) const;
41935 
41936 
41937 
41938 
41942  bool ShowResolution(float & out_resolution) const;
41943 
41947  ExportOptionsKit & SetResolution(float in_resolution);
41948 
41951  ExportOptionsKit & UnsetResolution();
41952 
41953 
41954 
41955 
41958  bool ShowWYSIWYG(bool & out_onoff) const;
41959 
41963  ExportOptionsKit & SetWYSIWYG(bool in_onoff);
41964 
41967  ExportOptionsKit & UnsetWYSIWYG();
41968 
41969 
41972  ExportOptionsKit & UnsetEverything();
41973  };
41974 
41981  static IOResult Export(intptr_t hdc, intptr_t attribdc, WindowKey const & window, ExportOptionsKit const & options);
41982 
41983  private:
41984  GDI();
41985  };
41986 #endif
41987 
41988 private:
41989  Hardcopy();
41990 };
41991 
41995 
41997 class HPS_API OBJ
41998 {
41999 public:
42000 
42002  class HPS_API ImportOptionsKit : public Object
42003  {
42004  public:
42006  ImportOptionsKit();
42007 
42010  ImportOptionsKit(ImportOptionsKit const & in_kit);
42011 
42015  ImportOptionsKit(ImportOptionsKit && in_that);
42016 
42020  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
42021 
42022  virtual ~ImportOptionsKit();
42023 
42024  Type ObjectType() const { return Type::OBJImportOptionsKit; };
42025 
42028  void Set(ImportOptionsKit const & in_kit);
42029 
42032  void Show(ImportOptionsKit & out_kit) const;
42033 
42037  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
42038 
42041  bool Empty() const;
42042 
42046  bool Equals(ImportOptionsKit const & in_kit) const;
42047 
42051  bool operator==(ImportOptionsKit const & in_kit) const;
42052 
42056  bool operator!=(ImportOptionsKit const & in_kit) const;
42057 
42062  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
42063 
42066  ImportOptionsKit & UnsetSegment();
42067 
42071  bool ShowSegment(SegmentKey & out_segment) const;
42072 
42077  ImportOptionsKit & SetPortfolio(PortfolioKey const & in_portfolio);
42078 
42081  ImportOptionsKit & UnsetPortfolio();
42082 
42086  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
42087 
42093  ImportOptionsKit & SetHandedness(Drawing::Handedness const & in_handedness);
42094 
42097  ImportOptionsKit & UnsetHandedness();
42098 
42102  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
42103 
42106  ImportOptionsKit & UnsetEverything();
42107  };
42108 
42110  class HPS_API ImportResultsKit : public Object
42111  {
42112  public:
42114  ImportResultsKit();
42115 
42118  ImportResultsKit(ImportResultsKit const & in_kit);
42119 
42123  ImportResultsKit(ImportResultsKit && in_that);
42124 
42128  ImportResultsKit & operator=(ImportResultsKit && in_that);
42129 
42130  virtual ~ImportResultsKit();
42131 
42132  Type ObjectType() const { return Type::OBJImportResultsKit; };
42133 
42136  void Set(ImportResultsKit const & in_kit);
42137 
42140  void Show(ImportResultsKit & out_kit) const;
42141 
42145  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
42146 
42149  bool Empty() const;
42150 
42154  bool Equals(ImportResultsKit const & in_kit) const;
42155 
42159  bool operator==(ImportResultsKit const & in_kit) const;
42160 
42164  bool operator!=(ImportResultsKit const & in_kit) const;
42165 
42170  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
42171 
42175  ImportResultsKit & UnsetSegment();
42176 
42181  bool ShowSegment(SegmentKey & out_segment) const;
42182 
42187  ImportResultsKit & SetPortfolio(PortfolioKey const & in_portfolio);
42188 
42192  ImportResultsKit & UnsetPortfolio();
42193 
42199  bool ShowPortfolio(PortfolioKey & out_portfolio) const;
42200 
42205  ImportResultsKit & SetHandedness(Drawing::Handedness const & in_handedness);
42206 
42210  ImportResultsKit & UnsetHandedness();
42211 
42216  bool ShowHandedness(Drawing::Handedness & out_handedness) const;
42217 
42220  ImportResultsKit & UnsetEverything();
42221  };
42222 
42225  class HPS_API ImportNotifier : public IONotifier
42226  {
42227  public:
42229  ImportNotifier();
42230 
42233  ImportNotifier(ImportNotifier const & in_that);
42234 
42239  ImportNotifier(IONotifier const & in_that);
42240 
42244  ImportNotifier(ImportNotifier && in_that);
42245 
42249  ImportNotifier & operator=(ImportNotifier && in_that);
42250 
42251  virtual ~ImportNotifier();
42252 
42253  Type ObjectType() const {return Type::OBJImportNotifier;};
42254 
42258  ImportNotifier & operator=(ImportNotifier const & in_that);
42259 
42262  void Assign(ImportNotifier const & in_that);
42263 
42267  ImportResultsKit GetResults() const;
42268  };
42269 
42270 
42272  class HPS_API File
42273  {
42274  public:
42280  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
42281 
42282  private:
42284  File();
42285  };
42286 private:
42288  OBJ();
42289 };
42290 
42294 
42296 class HPS_API STL
42297 {
42298 public:
42299 
42301  class HPS_API ImportOptionsKit : public Object
42302  {
42303  public:
42305  ImportOptionsKit();
42306 
42309  ImportOptionsKit(ImportOptionsKit const & in_kit);
42310 
42314  ImportOptionsKit(ImportOptionsKit && in_that);
42315 
42319  ImportOptionsKit & operator=(ImportOptionsKit && in_that);
42320 
42321  virtual ~ImportOptionsKit();
42322 
42323  Type ObjectType() const { return Type::STLImportOptionsKit; };
42324 
42327  void Set(ImportOptionsKit const & in_kit);
42328 
42331  void Show(ImportOptionsKit & out_kit) const;
42332 
42336  ImportOptionsKit & operator=(ImportOptionsKit const & in_kit);
42337 
42340  bool Empty() const;
42341 
42345  bool Equals(ImportOptionsKit const & in_kit) const;
42346 
42350  bool operator==(ImportOptionsKit const & in_kit) const;
42351 
42355  bool operator!=(ImportOptionsKit const & in_kit) const;
42356 
42360  static ImportOptionsKit GetDefault();
42361 
42366  ImportOptionsKit & SetSegment(SegmentKey const & in_segment);
42367 
42375  ImportOptionsKit & SetOptimization(bool in_state, ShellOptimizationOptionsKit const & in_optimization_kit);
42376 
42383  ImportOptionsKit & SetOptimization(ShellOptimizationOptionsKit const & in_optimization_kit);
42384 
42385 
42388  ImportOptionsKit & UnsetSegment();
42389 
42392  ImportOptionsKit & UnsetOptimization();
42393 
42396  ImportOptionsKit & UnsetEverything();
42397 
42398 
42402  bool ShowSegment(SegmentKey & out_segment) const;
42403 
42408  bool ShowOptimization(bool & out_state, ShellOptimizationOptionsKit & out_optimization_options) const;
42409  };
42410 
42412  class HPS_API ImportResultsKit : public Object
42413  {
42414  public:
42416  ImportResultsKit();
42417 
42420  ImportResultsKit(ImportResultsKit const & in_kit);
42421 
42425  ImportResultsKit(ImportResultsKit && in_that);
42426 
42430  ImportResultsKit & operator=(ImportResultsKit && in_that);
42431 
42432  virtual ~ImportResultsKit();
42433 
42434  Type ObjectType() const { return Type::STLImportResultsKit; };
42435 
42438  void Set(ImportResultsKit const & in_kit);
42439 
42442  void Show(ImportResultsKit & out_kit) const;
42443 
42447  ImportResultsKit & operator=(ImportResultsKit const & in_kit);
42448 
42451  bool Empty() const;
42452 
42456  bool Equals(ImportResultsKit const & in_kit) const;
42457 
42461  bool operator==(ImportResultsKit const & in_kit) const;
42462 
42466  bool operator!=(ImportResultsKit const & in_kit) const;
42467 
42472  ImportResultsKit & SetSegment(SegmentKey const & in_segment);
42473 
42477  ImportResultsKit & UnsetSegment();
42478 
42483  bool ShowSegment(SegmentKey & out_segment) const;
42484 
42487  ImportResultsKit & UnsetEverything();
42488  };
42489 
42492  class HPS_API ImportNotifier : public IONotifier
42493  {
42494  public:
42496  ImportNotifier();
42497 
42500  ImportNotifier(ImportNotifier const & in_that);
42501 
42506  ImportNotifier(IONotifier const & in_that);
42507 
42511  ImportNotifier(ImportNotifier && in_that);
42512 
42516  ImportNotifier & operator=(ImportNotifier && in_that);
42517 
42518  virtual ~ImportNotifier();
42519 
42520  Type ObjectType() const {return Type::STLImportNotifier;};
42521 
42525  ImportNotifier & operator=(ImportNotifier const & in_that);
42526 
42529  void Assign(ImportNotifier const & in_that);
42530 
42534  ImportResultsKit GetResults() const;
42535  };
42536 
42537 
42539  class HPS_API File
42540  {
42541  public:
42547  static ImportNotifier Import(char const * in_file_name, ImportOptionsKit const & in_options);
42548 
42549  private:
42551  File();
42552  };
42553 private:
42555  STL();
42556 };
42557 
42558 }
42559 
42560 #ifdef _MSC_VER
42561 # pragma warning(pop)
42562 #endif
42563 
42564 #endif
42565 
42566 
Type ObjectType() const
Definition: hps.h:39028
Rotation
Definition: hps.h:1580
Type ObjectType() const
Definition: hps.h:26191
bool Empty() const
Definition: hps.h:6712
CameraPoint(Point const &in_point)
Definition: hps.h:5663
Alignment
Definition: hps.h:1513
Type ObjectType() const
Definition: hps.h:18821
Space
Definition: hps.h:546
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:40735
Definition: hps.h:3201
Definition: hps.h:5902
Channel
Definition: hps.h:930
Type ObjectType() const
Definition: hps.h:23441
Handedness
Definition: hps.h:1261
Definition: hps.h:13697
Definition: hps.h:1036
Definition: hps.h:11480
ColorSource
Definition: hps.h:1906
Type ObjectType() const
Definition: hps.h:16558
bool HasAll(MouseButtons const &in_buttons) const
Definition: hps.h:40521
Type ObjectType() const
Definition: hps.h:35350
Event(intptr_t in_channel=0)
Definition: hps.h:6016
Definition: hps.h:17673
Type ObjectType() const
Definition: hps.h:42253
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3693
float alpha
Definition: hps.h:4217
Definition: hps.h:33771
Type ObjectType() const
Definition: hps.h:34957
bool operator==(Touch const &in_that) const
Definition: hps.h:6306
Both cylinder ends will be capped.
void X1(bool in_state)
Definition: hps.h:40542
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:40176
Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:39960
InformationEvent(char const *in_message)
Definition: hps.h:39760
Type ObjectType() const
Definition: hps.h:37373
Type ObjectType() const
Definition: hps.h:33437
Type ObjectType() const
Definition: hps.h:21251
Type ObjectType() const
Definition: hps.h:22969
Type ObjectType() const
Definition: hps.h:23715
Action
Definition: hps.h:40318
Orientation
Definition: hps.h:522
Definition: hps.h:20152
Code
Definition: hps.h:127
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1316
Multiline strings will be left justfied.
Definition: hps.h:38845
Type ObjectType() const
Definition: hps.h:14441
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:40015
Type ObjectType() const
Definition: hps.h:8196
Type ObjectType() const
Definition: hps.h:27419
Event * Clone() const
Definition: hps.h:39858
Definition: hps.h:12756
MouseEvent(Action in_action, float in_wheel_delta, WindowPoint in_location=WindowPoint(0, 0, 0), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:40652
Definition: hps.h:41997
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:39646
ImportStatusEvent()
Definition: hps.h:40088
Type ObjectType() const
Definition: hps.h:20868
Type ObjectType() const
Definition: hps.h:35132
Definition: hps.h:13263
Type ObjectType() const
Definition: hps.h:25214
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:40383
Type ObjectType() const
Definition: hps.h:29420
Type ObjectType() const
Definition: hps.h:24845
Type ObjectType() const
Definition: hps.h:11131
static MouseButtons ButtonX2()
Definition: hps.h:40597
Definition: hps.h:19255
A unitless linear scaling factor. A value of 2.0 will cause markers to be rendered twice as large...
The clip region is specified in world coordinated.
ErrorEvent(char const *in_message, Info::Code in_code)
Definition: hps.h:39907
void SetKeyboardCodes(size_t in_keyboardcode_count, KeyboardCode const in_keyboardcodes[])
Definition: hps.h:40841
Definition: hps.h:42412
Definition: hps.h:37004
Definition: hps.h:18615
Type ObjectType() const
Definition: hps.h:36824
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5560
Definition: hps.h:1479
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5808
bool Middle() const
Definition: hps.h:40507
Definition: hps.h:452
Driver
Definition: hps.h:147
Type ObjectType() const
Definition: hps.h:40881
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2134
Definition: hps.h:34454
Type ObjectType() const
Definition: hps.h:38172
CappingLevel
Definition: hps.h:1712
Definition: hps.h:40743
Type ObjectType() const
Definition: hps.h:22696
Type ObjectType() const
Definition: hps.h:34885
Definition: hps.h:8886
Object space units ignoring any scaling components in modelling matrices.
Type ObjectType() const
Definition: hps.h:12269
Type ObjectType() const
Definition: hps.h:40959
Type ObjectType() const
Definition: hps.h:19997
Definition: hps.h:25798
Type ObjectType() const
Definition: hps.h:13286
InputEvent()
Definition: hps.h:40261
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5420
static MouseButtons ButtonRight()
Definition: hps.h:40585
Type ObjectType() const
Definition: hps.h:28204
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3800
Definition: hps.h:5460
Definition: hps.h:34720
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:40780
static ModifierKeys KeyMeta()
Definition: hps.h:40235
Type ObjectType() const
Definition: hps.h:34620
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
Definition: hps.h:1490
Definition: hps.h:22862
Type ObjectType() const
Definition: hps.h:35999
Definition: hps.h:16154
bool Equals(MouseButtons const &in_that) const
Definition: hps.h:40472
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3679
Definition: hps.h:34112
Type ObjectType() const
Definition: hps.h:19060
Type ObjectType() const
Definition: hps.h:38344
Type ObjectType() const
Definition: hps.h:22894
Type ObjectType() const
Definition: hps.h:34191
Definition: hps.h:21759
Type ObjectType() const
Definition: hps.h:16267
MouseButtons()
Definition: hps.h:40467
Type ObjectType() const
Definition: hps.h:37413
Definition: hps.h:19765
Time GetTimeStamp() const
Definition: hps.h:6038
Definition: hps.h:42539
void Left(bool in_state)
Definition: hps.h:40530
Type ObjectType() const
Definition: hps.h:21729
NormalizedPoint(Point const &in_point)
Definition: hps.h:5713
Type ObjectType() const
Definition: hps.h:23243
Event * Clone() const
Definition: hps.h:39675
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3728
bool HasAny(MouseButtons const &in_buttons) const
Definition: hps.h:40526
Renderer
Definition: hps.h:1561
Type ObjectType() const
Definition: hps.h:33173
Definition: hps.h:39166
KeyboardEvent()
Definition: hps.h:40756
Type ObjectType() const
Definition: hps.h:7087
Definition: hps.h:36791
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3908
ObjectPoint(Point const &in_point)
Definition: hps.h:5563
Type ObjectType() const
Definition: hps.h:17145
Definition: hps.h:32643
Object space units ignoring any scaling components in modelling matrices.
Definition: hps.h:38948
Definition: hps.h:4294
Definition: hps.h:6521
Definition: hps.h:1310
Definition: hps.h:39696
Definition: hps.h:23683
Point_3D< F > min
Definition: hps.h:3663
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:39989
static ModifierKeys KeyAlt()
Definition: hps.h:40231
bool IsConsumable() const
Definition: hps.h:6041
Definition: hps.h:1033
size_t GetHash() const
Definition: hps.h:1651
MaterialPreference
Definition: hps.h:1729
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:40769
Mobility
Definition: hps.h:188
Type ObjectType() const
Definition: hps.h:12779
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5761
Definition: hps.h:14124
InterpolationAlgorithm
Definition: hps.h:1496
Fill
Definition: hps.h:1897
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3716
Definition: hps.h:23137
Definition: hps.h:18798
Type ObjectType() const
Definition: hps.h:26696
Type ObjectType() const
Definition: hps.h:18638
char At(size_t in_index) const
Definition: hps.h:6755
Definition: hps.h:39017
Definition: hps.h:4320
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:40171
Type ObjectType() const
Definition: hps.h:35012
Definition: hps.h:122
ReferenceFrame
Definition: hps.h:1528
Definition: hps.h:25182
Bloom Shape.
Definition: hps.h:41015
Definition: hps.h:37391
Definition: hps.h:3661
Definition: hps.h:3658
Type ObjectType() const
Definition: hps.h:16474
GreekingUnits
Definition: hps.h:1615
Definition: hps.h:18165
Definition: hps.h:7139
Type ObjectType() const
Definition: hps.h:11681
InnerConeUnits
Definition: hps.h:471
Definition: hps.h:25988
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5857
static MouseButtons ButtonX1()
Definition: hps.h:40593
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:40065
Definition: hps.h:17884
Definition: hps.h:3348
OuterConeUnits
Definition: hps.h:457
Definition: hps.h:6288
void X2(bool in_state)
Definition: hps.h:40546
Type ObjectType() const
Definition: hps.h:18422
Type ObjectType() const
Definition: hps.h:39496
Type ObjectType() const
Definition: hps.h:38441
Type ObjectType() const
Definition: hps.h:13882
Definition: hps.h:14417
Definition: hps.h:1978
Type ObjectType() const
Definition: hps.h:32676
void SetKeyboardCodes(KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:40848
Type ObjectType() const
Definition: hps.h:26090
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40407
Type ObjectType() const
Definition: hps.h:12152
Type ObjectType() const
Definition: hps.h:24427
Definition: hps.h:426
Type ObjectType() const
Definition: hps.h:35463
Definition: hps.h:21229
Channel
Definition: hps.h:889
Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:39889
AreaUnits
Definition: hps.h:1442
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3770
Definition: hps.h:37193
Type ObjectType() const
Definition: hps.h:11504
Definition: hps.h:8147
Definition: hps.h:26068
Definition: hps.h:19037
Type ObjectType() const
Definition: hps.h:33793
Action
Definition: hps.h:39971
Event * Clone() const
Definition: hps.h:39787
Type ObjectType() const
Definition: hps.h:13720
Definition: hps.h:4569
Type ObjectType() const
Definition: hps.h:41444
Type ObjectType() const
Definition: hps.h:26797
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6321
Definition: hps.h:20694
Definition: hps.h:4451
Type ObjectType() const
Definition: hps.h:36942
Type ObjectType() const
Definition: hps.h:33310
Definition: hps.h:1369
Definition: hps.h:17355
Definition: hps.h:864
Definition: hps.h:5446
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:40340
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3866
Border
Definition: hps.h:249
UpdateControl
Definition: hps.h:168
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:40166
Definition: hps.h:36909
Definition: hps.h:35110
Definition: hps.h:7129
Type ObjectType() const
Definition: hps.h:22466
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:40817
Type ObjectType() const
Definition: hps.h:20793
WarningEvent(Event const &in_event)
Definition: hps.h:39840
Definition: hps.h:36022
Type ObjectType() const
Definition: hps.h:11007
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1916
Definition: hps.h:1697
static ModifierKeys KeyShift()
Definition: hps.h:40223
Definition: hps.h:142
Type ObjectType() const
Definition: hps.h:27930
Shape
Definition: hps.h:1058
bool IsValid() const
Definition: hps.h:6705
Definition: hps.h:19974
Definition: hps.h:1508
Cuboid_3D()
Definition: hps.h:3671
ErrorEvent(Event const &in_event)
Definition: hps.h:39911
size_t GetWStrLength() const
Definition: hps.h:6734
Event * Clone() const
Definition: hps.h:39740
Type ObjectType() const
Definition: hps.h:10598
AppendMode
Definition: hps.h:317
Definition: hps.h:8176
Definition: hps.h:24675
static void Free(void *in_pointer)
bool X1() const
Definition: hps.h:40511
Definition: hps.h:221
Definition: hps.h:40084
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3851
void Meta(bool in_state)
Definition: hps.h:40188
Definition: hps.h:6473
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5956
Definition: hps.h:26169
Type ObjectType() const
Definition: hps.h:14150
UpdateStatus
Definition: hps.h:157
HPS_INLINE bool IsValid() const
Definition: hps.h:3721
Type ObjectType() const
Definition: hps.h:37525
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:40036
Definition: hps.h:20498
Quality
Definition: hps.h:1042
ResolutionUnits
Definition: hps.h:41714
Event * Clone() const
Definition: hps.h:40271
ModifierKeys ModifierKeyState
The modifier keys which are active for this InputEvent.
Definition: hps.h:40309
Definition: hps.h:4393
TimerTickEvent(Event const &in_event)
Definition: hps.h:39665
Component
Definition: hps.h:337
Definition: hps.h:42110
Definition: hps.h:5555
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5907
Type ObjectType() const
Definition: hps.h:11768
Definition: hps.h:11894
Default
Definition: hps.h:1870
Type ObjectType() const
Definition: hps.h:10228
Definition: hps.h:16451
Definition: hps.h:2074
Definition: hps.h:24133
InformationEvent()
Definition: hps.h:39756
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:4965
Definition: hps.h:36743
Definition: hps.h:11107
Definition: hps.h:13343
Definition: hps.h:10574
Definition: hps.h:42492
bool Shift() const
Definition: hps.h:40148
SizeToleranceUnits
Definition: hps.h:1602
Type ObjectType() const
Definition: hps.h:37649
Definition: hps.h:1749
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:3937
Cap
Definition: hps.h:1821
Point_3D< F > max
Definition: hps.h:3665
Type ObjectType() const
Definition: hps.h:7167
Definition: hps.h:10840
Definition: hps.h:20298
Definition: hps.h:13449
Type ObjectType() const
Definition: hps.h:42024
Type ObjectType() const
Definition: hps.h:42132
MouseEvent()
Definition: hps.h:40634
Definition: hps.h:13520
Type ObjectType() const
Definition: hps.h:11609
Definition: hps.h:19527
Definition: hps.h:26440
Definition: hps.h:1052
Type ObjectType() const
Definition: hps.h:16176
Definition: hps.h:11802
Definition: hps.h:31490
Type ObjectType() const
Definition: hps.h:34236
Definition: hps.h:12128
static const float Infinity
Definition: hps.h:2129
InsetBehavior
Definition: hps.h:1802
Type ObjectType() const
Definition: hps.h:24353
Definition: hps.h:5529
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2142
Type ObjectType() const
Definition: hps.h:13174
Type ObjectType() const
Definition: hps.h:26390
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6320
Type ObjectType() const
Definition: hps.h:34426
Type ObjectType() const
Definition: hps.h:36688
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3830
Algorithm
Definition: hps.h:1430
Definition: hps.h:40937
Decimation
Definition: hps.h:999
StaticModel
Definition: hps.h:1100
Definition: hps.h:37625
Granularity
Definition: hps.h:1351
Parameterization
Definition: hps.h:37056
Definition: hps.h:35920
DisplayLists
Definition: hps.h:1078
Definition: hps.h:10406
Search the current segment only.
Definition: hps.h:2588
Definition: hps.h:41417
Definition: hps.h:541
KeyboardEvent(Event const &in_event)
Definition: hps.h:40789
Definition: hps.h:20545
Definition: hps.h:34163
Definition: hps.h:33683
ClipOperation
Definition: hps.h:1290
Type ObjectType() const
Definition: hps.h:8448
Definition: hps.h:2501
Definition: hps.h:29387
Method
Definition: hps.h:1420
Definition: hps.h:35966
Type ObjectType() const
Definition: hps.h:25830
Definition: hps.h:41661
Parameterization
Definition: hps.h:944
Definition: hps.h:4211
Definition: hps.h:36217
Definition: hps.h:35436
FocusLostEvent()
Definition: hps.h:40044
CuttingLevel
Definition: hps.h:1721
Channel
Definition: hps.h:910
Definition: hps.h:8967
Definition: hps.h:42301
HandleResult
Definition: hps.h:39636
Definition: hps.h:38150
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:4977
Definition: hps.h:5803
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:39959
Value
Definition: hps.h:1401
Definition: hps.h:1072
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2150
Code
Definition: hps.h:99
Type ObjectType() const
Definition: hps.h:25346
Event * Clone() const
Definition: hps.h:40052
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:40688
Definition: hps.h:40617
ErrorEvent()
Definition: hps.h:39898
Definition: hps.h:39965
Justification
Definition: hps.h:1536
The vertex colors applied to faces.
Definition: hps.h:6393
Type ObjectType() const
Definition: hps.h:13544
Definition: hps.h:34292
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5438
ErrorEvent(char const *in_message)
Definition: hps.h:39902
Definition: hps.h:40313
FrameSize
Definition: hps.h:199
Definition: hps.h:2089
Definition: hps.h:8777
Definition: hps.h:22947
Definition: hps.h:11586
Justification
Definition: hps.h:1838
Definition: hps.h:20986
Type ObjectType() const
Definition: hps.h:11329
Definition: hps.h:39473
Definition: hps.h:36952
Type ObjectType() const
Definition: hps.h:19279
Definition: hps.h:1675
Definition: hps.h:1456
Type ObjectType() const
Definition: hps.h:21560
bool None() const
Definition: hps.h:40495
Definition: hps.h:301
Definition: hps.h:1395
Type ObjectType() const
Definition: hps.h:8243
Type ObjectType() const
Definition: hps.h:35953
Type ObjectType() const
Definition: hps.h:34140
Definition: hps.h:17122
GreekingMode
Definition: hps.h:1627
Type ObjectType() const
Definition: hps.h:19789
Definition: hps.h:35328
KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:40853
Operation
Definition: hps.h:440
Definition: hps.h:1414
Type ObjectType() const
Definition: hps.h:36533
Type
Definition: hps.h:1984
WorldPoint(Point const &in_point)
Definition: hps.h:5613
TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:40447
Definition: hps.h:42272
Type ObjectType() const
Definition: hps.h:9427
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2421
Definition: hps.h:21959
Definition: hps.h:33906
Type ObjectType() const
Definition: hps.h:6552
Definition: hps.h:17427
TouchEvent(Event const &in_event)
Definition: hps.h:40355
void SetTouches(TouchArray const &in_touches)
Definition: hps.h:40441
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6837
Definition: hps.h:4948
Definition: hps.h:38418
Definition: hps.h:42296
Definition: hps.h:34393
Definition: hps.h:4150
Relation
Definition: hps.h:363
Action
Definition: hps.h:40748
ChannelMapping
Definition: hps.h:1013
Type ObjectType() const
Definition: hps.h:22078
Definition: hps.h:6650
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5455
Type ObjectType() const
Definition: hps.h:37991
Type ObjectType() const
Definition: hps.h:38630
Definition: hps.h:23221
Definition: hps.h:5656
bool Alt() const
Definition: hps.h:40156
Definition: hps.h:40463
ToleranceUnits
Definition: hps.h:346
Definition: hps.h:24000
Definition: hps.h:26664
Definition: hps.h:37051
Type ObjectType() const
Definition: hps.h:12079
SizeUnits
Definition: hps.h:1789
Type
Definition: hps.h:2001
Type ObjectType() const
Definition: hps.h:17274
The vertex colors applied to faces.
RelationTest
Definition: hps.h:373
Definition: hps.h:38322
Type
Definition: hps.h:308
Type ObjectType() const
Definition: hps.h:14294
Behavior
Definition: hps.h:555
Definition: hps.h:5606
Ambient Occulsion Quality.
Type ObjectType() const
Definition: hps.h:6627
KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:40854
Definition: hps.h:39652
Type ObjectType() const
Definition: hps.h:18188
Style Append Mode.
Definition: hps.h:37674
Definition: hps.h:24823
Definition: hps.h:40859
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5429
float blue
Definition: hps.h:4216
A grid of lines will be drawn in place of characters below the greeking limit.
Definition: hps.h:40040
Type
Definition: hps.h:413
Type ObjectType() const
Definition: hps.h:20568
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6855
PixelPoint(Point const &in_point)
Definition: hps.h:5959
Type ObjectType() const
Definition: hps.h:6081
Type ObjectType() const
Definition: hps.h:6930
Definition: hps.h:17250
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40714
Definition: hps.h:20411
Definition: hps.h:41614
Type ObjectType() const
Definition: hps.h:21129
Type ObjectType() const
Definition: hps.h:21009
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
Type ObjectType() const
Definition: hps.h:34379
Type ObjectType() const
Definition: hps.h:28073
Type ObjectType() const
Definition: hps.h:23514
Type ObjectType() const
Definition: hps.h:38270
Type ObjectType() const
Definition: hps.h:20434
MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:40734
Event * Clone() const
Definition: hps.h:40102
Definition: hps.h:13844
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:4971
Definition: hps.h:34979
Definition: hps.h:40061
Type ObjectType() const
Definition: hps.h:33707
Type ObjectType() const
Definition: hps.h:39605
Alignment and justification will be defined relative to a screen-facing box around the text...
Definition: hps.h:41266
Type ObjectType() const
Definition: hps.h:15325
Definition: hps.h:1892
Definition: hps.h:30444
Infinite line which extends infinitely in both directions along a vector.
InformationEvent(char const *in_message, Info::Code in_code)
Definition: hps.h:39765
intptr_t GetChannel() const
Definition: hps.h:6035
Type ObjectType() const
Definition: hps.h:8801
Definition: hps.h:1329
Definition: hps.h:13150
Algorithm
Definition: hps.h:1343
Type ObjectType() const
Definition: hps.h:30466
Type ObjectType() const
Definition: hps.h:36985
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3788
Definition: hps.h:12056
Definition: hps.h:10204
Driver
Definition: hps.h:41858
Definition: hps.h:6896
Definition: hps.h:41102
SizeUnits
Definition: hps.h:1657
StandAloneWindowEvent()
Definition: hps.h:39980
Type ObjectType() const
Definition: hps.h:35532
Type ObjectType() const
Definition: hps.h:33545
ModifierKeys GetModifierKeys() const
Definition: hps.h:40304
Definition: hps.h:40112
Definition: hps.h:38599
Definition: hps.h:39823
Type ObjectType() const
Definition: hps.h:11917
Type ObjectType() const
Definition: hps.h:10748
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:39867
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:40642
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5401
Type ObjectType() const
Definition: hps.h:16985
Definition: hps.h:37340
Level
Definition: hps.h:1334
virtual bool Equals(InformationEvent const &in_that) const
Definition: hps.h:39796
bool X2() const
Definition: hps.h:40515
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:40121
Definition: hps.h:33523
Definition: hps.h:42225
bool Left() const
Definition: hps.h:40499
void Control(bool in_state)
Definition: hps.h:40180
Definition: hps.h:21097
Definition: hps.h:41875
Definition: hps.h:2838
Definition: hps.h:16534
Definition: hps.h:40256
Type ObjectType() const
Definition: hps.h:41642
Type ObjectType() const
Definition: hps.h:17696
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:3922
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:39888
The base class of all HPS exceptions.
Definition: hps.h:5393
RegionAlignment
Definition: hps.h:1636
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:40349
Event * Clone() const
Definition: hps.h:40679
Definition: hps.h:6002
Type ObjectType() const
Definition: hps.h:20717
Definition: hps.h:36460
InformationEvent(Event const &in_event)
Definition: hps.h:39769
Definition: hps.h:12331
void Invalidate()
Definition: hps.h:3733
Definition: hps.h:22434
Definition: hps.h:37968
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4712
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5452
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:40068
Type ObjectType() const
Definition: hps.h:33033
Definition: hps.h:5952
Type ObjectType() const
Definition: hps.h:38867
Definition: hps.h:41728
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6028
Definition: hps.h:388
char const * GetBytes() const
Definition: hps.h:6741
Definition: hps.h:37215
virtual intptr_t Freshen() const
Definition: hps.h:40726
Definition: hps.h:33404
Type ObjectType() const
Definition: hps.h:34488
InputEvent(ModifierKeys const &in_modifiers)
Definition: hps.h:40265
float green
Definition: hps.h:4215
Action
Definition: hps.h:40623
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1681
Type ObjectType() const
Definition: hps.h:9832
Type ObjectType() const
Definition: hps.h:26462
Type ObjectType() const
Definition: hps.h:24032
Type ObjectType() const
Definition: hps.h:23788
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
Definition: hps.h:10031
Type ObjectType() const
Definition: hps.h:37037
Type ObjectType() const
Definition: hps.h:24155
InnerPixelPoint(Point const &in_point)
Definition: hps.h:5860
Type ObjectType() const
Definition: hps.h:41902
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5710
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6300
static const float NegativeInfinity
Definition: hps.h:2131
HighlightEvent(Event const &in_event)
Definition: hps.h:39723
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6846
SizeUnits
Definition: hps.h:1462
Type ObjectType() const
Definition: hps.h:12355
Type ObjectType() const
Definition: hps.h:20175
Definition: hps.h:20770
MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:40736
Type ObjectType() const
Definition: hps.h:10053
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5811
GatheringLevel
Definition: hps.h:1737
Type ObjectType() const
Definition: hps.h:28283
Info::Code code
The warning code for this InformationEvent.
Definition: hps.h:39818
Definition: hps.h:39578
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3700
Definition: hps.h:11951
FrameOptions
Definition: hps.h:208
Type ObjectType() const
Definition: hps.h:34329
Space
Definition: hps.h:8154
void Alt(bool in_state)
Definition: hps.h:40184
Definition: hps.h:6905
Buttons
Definition: hps.h:40603
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:40761
Type ObjectType() const
Definition: hps.h:36260
Type
Definition: hps.h:243
bool operator!=(Touch const &in_that) const
Definition: hps.h:6314
Definition: hps.h:39194
Definition: hps.h:23409
Definition: hps.h:94
Type
Definition: hps.h:431
Type ObjectType() const
Definition: hps.h:41181
Definition: hps.h:12246
Type ObjectType() const
Definition: hps.h:42434
Type ObjectType() const
Definition: hps.h:37237
Type ObjectType() const
Definition: hps.h:42323
Type ObjectType() const
Definition: hps.h:32764
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5610
Type ObjectType() const
Definition: hps.h:8991
Type ObjectType() const
Definition: hps.h:42520
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6828
Definition: hps.h:22674
void SetTouches(size_t in_touch_count, Touch const in_touches[])
Definition: hps.h:40434
Definition: hps.h:34214
Definition: hps.h:1256
Event * Clone() const
Definition: hps.h:40374
void Middle(bool in_state)
Definition: hps.h:40538
Definition: hps.h:28261
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:39938
Event * Clone() const
Definition: hps.h:40006
size_t GetLength() const
Definition: hps.h:6726
Type ObjectType() const
Definition: hps.h:20521
Type ObjectType() const
Definition: hps.h:26020
Type
Definition: hps.h:1119
Definition: hps.h:408
Type ObjectType() const
Definition: hps.h:8909
bool None() const
Definition: hps.h:40144
size_t ClickCount
The number of clicks received.
Definition: hps.h:40738
virtual intptr_t Freshen() const
Definition: hps.h:6032
void Reset()
Definition: hps.h:6721
Type ObjectType() const
Definition: hps.h:36771
Type ObjectType() const
Definition: hps.h:23169
Definition: hps.h:33277
Type ObjectType() const
Definition: hps.h:38971
Definition: hps.h:38247
SizeUnits
Definition: hps.h:1590
Event * Clone() const
Definition: hps.h:39929
MouseEvent(Event const &in_event)
Definition: hps.h:40657
bool Right() const
Definition: hps.h:40503
Definition: hps.h:1996
virtual bool Empty() const
Definition: hps.h:5493
Join
Definition: hps.h:1812
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3844
Modifier
Definition: hps.h:1849
static MouseButtons ButtonLeft()
Definition: hps.h:40581
static MouseButtons ButtonMiddle()
Definition: hps.h:40589
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:40332
HighlightEvent()
Definition: hps.h:39707
virtual Type ObjectType() const
Definition: hps.h:5489
Definition: hps.h:18398
Type ObjectType() const
Definition: hps.h:13367
Definition: hps.h:27913
Definition: hps.h:16245
Definition: hps.h:5705
TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:40446
Definition: hps.h:8214
Type
Definition: hps.h:566
virtual intptr_t Freshen() const
Definition: hps.h:39690
Background
Definition: hps.h:224
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3777
Definition: hps.h:41723
static ModifierKeys KeyControl()
Definition: hps.h:40227
Type ObjectType() const
Definition: hps.h:17908
Definition: hps.h:5411
Type ObjectType() const
Definition: hps.h:34742
Definition: hps.h:7061
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5758
Type ObjectType() const
Definition: hps.h:38763
StandAloneWindowEvent(Action in_action)
Definition: hps.h:39985
Mode
Definition: hps.h:1702
Definition: hps.h:32443
Definition: hps.h:10725
UTF8 message
The warning information for this WarningEvent.
Definition: hps.h:39817
Event * Clone() const
Definition: hps.h:40074
Definition: hps.h:33139
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:3981
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3812
Definition: hps.h:33001
Type
Definition: hps.h:869
Definition: hps.h:331
Definition: hps.h:14271
Definition: hps.h:20845
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3765
Definition: hps.h:904
Type ObjectType() const
Definition: hps.h:11826
Definition: hps.h:34924
Type ObjectType() const
Definition: hps.h:31523
Type ObjectType() const
Definition: hps.h:17378
Definition: hps.h:41154
Type ObjectType() const
Definition: hps.h:36869
Definition: hps.h:41880
Definition: hps.h:34598
Type ObjectType() const
Definition: hps.h:41288
Definition: hps.h:5754
Definition: hps.h:37083
Type ObjectType() const
Definition: hps.h:41037
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3751
Type ObjectType() const
Definition: hps.h:36044
Definition: hps.h:34863
Type ObjectType() const
Definition: hps.h:11975
Type ObjectType() const
Definition: hps.h:17451
Definition: hps.h:23492
Mode
Definition: hps.h:1755
Definition: hps.h:8416
Event * Clone() const
Definition: hps.h:40808
Definition: hps.h:9808
Tiling
Definition: hps.h:972
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:3966
WindowPoint(Point const &in_point)
Definition: hps.h:5910
Transform
Definition: hps.h:1545
Type ObjectType() const
Definition: hps.h:36358
Definition: hps.h:10984
Definition: hps.h:39752
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Definition: hps.h:21432
Definition: hps.h:34347
Definition: hps.h:26775
Definition: hps.h:21697
Grid composed of quadrilaterals.
Type ObjectType() const
Definition: hps.h:37696
Definition: hps.h:25324
Definition: hps.h:924
ModifierKeys()
Definition: hps.h:40116
Definition: hps.h:24405
Definition: hps.h:1784
Definition: hps.h:22056
Definition: hps.h:27387
Preference
Definition: hps.h:1570
Type ObjectType() const
Definition: hps.h:24707
Capping
Definition: hps.h:511
Definition: hps.h:39894
Type ObjectType() const
Definition: hps.h:34560
TouchEvent()
Definition: hps.h:40326
Interpolation
Definition: hps.h:988
Type ObjectType() const
Definition: hps.h:19550
virtual bool Equals(InputEvent const &in_that) const
Definition: hps.h:40280
WarningEvent(char const *in_message)
Definition: hps.h:39831
Type ObjectType() const
Definition: hps.h:20321
Modifiers
Definition: hps.h:40241
Component
Definition: hps.h:503
Definition: hps.h:498
Definition: hps.h:9404
Definition: hps.h:36664
Type ObjectType() const
Definition: hps.h:35050
Type ObjectType() const
Definition: hps.h:6417
Type ObjectType() const
Definition: hps.h:21991
Definition: hps.h:16961
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:3951
Type ObjectType() const
Definition: hps.h:41750
Type ObjectType() const
Definition: hps.h:21781
Definition: hps.h:3124
Format
Definition: hps.h:36222
WarningEvent()
Definition: hps.h:39827
Definition: hps.h:24321
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:39684
Touch()
Definition: hps.h:6294
Definition: hps.h:11745
Definition: hps.h:35017
Component
Definition: hps.h:393
Definition: hps.h:32748
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
Definition: hps.h:38740
Definition: hps.h:1114
float red
Definition: hps.h:4214
ClipSpace
Definition: hps.h:1298
Definition: hps.h:11657
Definition: hps.h:36836
Definition: hps.h:15302
Control & operator=(Control &&in_that)
Definition: hps.h:5546
WarningEvent(char const *in_message, Info::Code in_code)
Definition: hps.h:39836
Type ObjectType() const
Definition: hps.h:13472
Definition: hps.h:28182
SizeUnits
Definition: hps.h:41707
void Right(bool in_state)
Definition: hps.h:40534
virtual void Reset()
Definition: hps.h:39628
Definition: hps.h:11306
Type ObjectType() const
Definition: hps.h:10863
bool Meta() const
Definition: hps.h:40160
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:3993
Definition: hps.h:34527
TimerTickEvent()
Definition: hps.h:39656
Definition: hps.h:37503
Definition: hps.h:36238
Type ObjectType() const
Definition: hps.h:21464
RenderingAlgorithm
Definition: hps.h:260
EmergencyHandler()
Definition: hps.h:39171
Definition: hps.h:34034
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5660
TouchID ID
TouchID for this Touch.
Definition: hps.h:6319
Definition: hps.h:35499
Type ObjectType() const
Definition: hps.h:10429
Type ObjectType() const
Definition: hps.h:32465
Definition: hps.h:41702
Definition: hps.h:6058
Definition: hps.h:23766
HandednessOptimization
Definition: hps.h:354
Definition: hps.h:6600
Projection
Definition: hps.h:1380
Control(Control &&in_that)
Definition: hps.h:5541
bool Control() const
Definition: hps.h:40152
Definition: hps.h:5319
Type ObjectType() const
Definition: hps.h:33928
Overlay
Definition: hps.h:1270
Definition: hps.h:28051
Definition: hps.h:5852
Definition: hps.h:36336
Definition: hps.h:42002
Type ObjectType() const
Definition: hps.h:37105
size_t GetHash() const
Status
Definition: hps.h:6008
Definition: hps.h:21538
Type ObjectType() const
Definition: hps.h:34058
Type ObjectType() const
Definition: hps.h:6499
float WheelDelta
If the action involves the mouse wheel, this is the amount the wheel moved. It is positive if the mou...
Definition: hps.h:40737
Definition: hps.h:36505
Definition: hps.h:41159
Definition: hps.h:26358
Type ObjectType() const
Definition: hps.h:41124