15 # ifdef HPS_CORE_BUILD
16 # define HPS_API __declspec (dllexport)
17 # define EXPIMP_TEMPLATE
19 # define HPS_API __declspec (dllimport)
20 # define EXPIMP_TEMPLATE extern
22 # define HPS_TEMPLATE_API __declspec (dllexport)
32 # pragma warning(push)
33 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
39 # ifdef HPS_CORE_BUILD
40 # define HPS_API __attribute__ ((visibility ("default")))
41 # define EXPIMP_TEMPLATE
43 # define EXPIMP_TEMPLATE extern
45 # define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
52 #ifndef HPS_TEMPLATE_API
53 # define HPS_TEMPLATE_API
55 #ifndef EXPIMP_TEMPLATE
56 # define EXPIMP_TEMPLATE
59 # define ENUM_CLASS enum class
75 # if !defined(__APPLE__) && defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8))
79 # define OVERRIDE override
87 class EventDispatcherImpl;
252 GradientTopLeftToBottomRight,
253 GradientTopRightToBottomLeft,
254 GradientBottomLeftToTopRight,
255 GradientBottomRightToTopLeft,
364 FeatureSizePercentage
565 SubsegmentsAndIncludes
606 Everything = 0x00ffffff,
609 Include = 0x00000042,
610 Segment = 0x00000043,
612 Includer = 0x00000100,
615 Geometry = 0x10000000,
622 NURBSSurface = 0x1000002b,
625 Polygon = 0x1000002f,
628 CircularWedge = 0x10000032,
629 Ellipse = 0x10000033,
631 NURBSCurve = 0x10000037,
632 CircularArc = 0x10000038,
633 EllipticalArc = 0x10000039,
638 Reference = 0x10000040,
641 DistantLight = 0x10000100,
643 InfiniteRay = 0x10000102,
646 Attribute = 0x20000000,
648 Priority = 0x20000001,
653 ModellingMatrix = 0x20000010,
654 UserData = 0x20000021,
655 TextureMatrix = 0x20000023,
658 Culling = 0x20001000,
659 CullingBackFace = 0x20001001,
660 CullingExtent = 0x20001002,
661 CullingVector = 0x20001003,
662 CullingVectorTolerance = 0x20001004,
663 CullingFrustum = 0x20001005,
664 CullingDeferralExtent = 0x20001006,
666 CurveAttribute = 0x20002000,
667 CurveAttributeBudget = 0x20002001,
668 CurveAttributeContinuedBudget = 0x20002002,
669 CurveAttributeViewDependent = 0x20002003,
670 CurveAttributeMaximumDeviation = 0x20002004,
671 CurveAttributeMaximumAngle = 0x20002005,
672 CurveAttributeMaximumLength = 0x20002006,
674 CylinderAttribute = 0x20003000,
675 CylinderAttributeTessellation = 0x20003001,
676 CylinderAttributeOrientation = 0x20003002,
679 EdgeAttribute = 0x20004000,
680 EdgeAttributePattern = 0x20004015,
681 EdgeAttributeWeight = 0x20004016,
683 LightingAttribute = 0x20005000,
684 LightingAttributeInterpolation = 0x20005001,
687 LineAttribute = 0x20006000,
688 LineAttributePattern = 0x20006019,
689 LineAttributeWeight = 0x2000601a,
692 MarkerAttribute = 0x20007000,
693 MarkerAttributeSize = 0x2000701b,
694 MarkerAttributeSymbol = 0x2000701c,
696 SurfaceAttribute = 0x20008000,
697 SurfaceAttributeBudget = 0x20008001,
698 SurfaceAttributeMaximumFacetDeviation = 0x20008002,
699 SurfaceAttributeMaximumFacetAngle = 0x20008003,
700 SurfaceAttributeMaximumFacetWidth = 0x20008004,
701 SurfaceAttributeTrimCurveBudget = 0x20008005,
702 SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
705 SelectabilityWindows = 0x20009001,
706 SelectabilityEdges = 0x20009002,
707 SelectabilityFaces = 0x20009003,
708 SelectabilityLights = 0x20009004,
709 SelectabilityLines = 0x20009005,
710 SelectabilityMarkers = 0x20009006,
711 SelectabilityVertices = 0x20009007,
712 SelectabilityText = 0x20009008,
714 SphereAttribute = 0x2000a000,
715 SphereAttributeTessellation = 0x2000a001,
718 SubwindowEitherType = 0x2000b001,
719 SubwindowStandard = 0x2000b00d,
720 SubwindowLightweight = 0x2000b002,
721 SubwindowBackground = 0x2000b003,
722 SubwindowBorder = 0x2000b004,
723 SubwindowRenderingAlgorithm = 0x2000b005,
726 TextAttribute = 0x2000c000,
727 TextAttributeAlignment = 0x2000c01d,
728 TextAttributeBold = 0x2000c002,
729 TextAttributeItalic = 0x2000c003,
730 TextAttributeOverline = 0x2000c004,
731 TextAttributeStrikethrough = 0x2000c005,
732 TextAttributeUnderline = 0x2000c006,
733 TextAttributeSlant = 0x2000c007,
734 TextAttributeLineSpacing = 0x2000c008,
735 TextAttributeRotation = 0x2000c00a,
736 TextAttributeExtraSpace = 0x2000c00b,
737 TextAttributeGreeking = 0x2000c00c,
738 TextAttributeSizeTolerance = 0x2000c00d,
739 TextAttributeSize = 0x2000c00e,
740 TextAttributeFont = 0x2000c00f,
741 TextAttributeTransform = 0x2000c010,
742 TextAttributeRenderer = 0x2000c011,
743 TextAttributePreference = 0x2000c012,
744 TextAttributePath = 0x2000c01f,
745 TextAttributeSpacing = 0x2000c020,
748 TransparencyMethod = 0x2000d001,
749 TransparencyAlgorithm = 0x2000d002,
750 TransparencyDepthPeelingLayers = 0x2000d004,
751 TransparencyDepthPeelingMinimumArea = 0x2000d005,
752 TransparencyDepthWriting = 0x2000d006,
754 Visibility = 0x2000e000,
755 VisibilityCuttingSections = 0x2000e001,
756 VisibilityCutEdges = 0x2000e002,
757 VisibilityCutFaces = 0x2000e003,
758 VisibilityWindows = 0x2000e004,
759 VisibilityText = 0x2000e005,
760 VisibilityLines = 0x2000e006,
761 VisibilityEdgeLights = 0x2000e007,
762 VisibilityMarkerLights = 0x2000e008,
763 VisibilityFaceLights = 0x2000e009,
764 VisibilityGenericEdges = 0x2000e00a,
765 VisibilityHardEdges = 0x2000e00b,
766 VisibilityAdjacentEdges = 0x2000e00c,
767 VisibilityInteriorSilhouetteEdges = 0x2000e00d,
768 VisibilityShadowEmitting = 0x2000e00e,
769 VisibilityShadowReceiving = 0x2000e00f,
770 VisibilityShadowCasting = 0x2000e010,
771 VisibilityMarkers = 0x2000e011,
772 VisibilityVertices = 0x2000e012,
773 VisibilityFaces = 0x2000e013,
774 VisibilityPerimeterEdges = 0x2000e014,
775 VisibilityNonCulledEdges = 0x2000e015,
776 VisibilityMeshQuadEdges = 0x2000e016,
778 VisualEffects = 0x2000f000,
779 VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
780 VisualEffectsAntiAliasing = 0x2000f002,
781 VisualEffectsShadowMaps = 0x2000f003,
782 VisualEffectsSimpleShadow = 0x2000f004,
783 VisualEffectsSimpleShadowPlane = 0x2000f005,
784 VisualEffectsSimpleShadowLightDirection = 0x2000f006,
785 VisualEffectsSimpleShadowColor = 0x2000f007,
786 VisualEffectsSimpleReflection = 0x2000f008,
787 VisualEffectsSimpleReflectionPlane = 0x2000f009,
788 VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
791 PerformanceDisplayLists = 0x20010001,
792 PerformanceStaticModel = 0x20010002,
793 StaticModelSegment = 0x40000043,
796 DrawingAttribute = 0x20011000,
797 DrawingAttributePolygonHandedness = 0x20011001,
798 DrawingAttributeDepthRange = 0x20011002,
799 DrawingAttributeFaceDisplacement = 0x20011003,
800 DrawingAttributeGeneralDisplacement = 0x20011004,
801 DrawingAttributeVertexDisplacement = 0x20011005,
802 DrawingAttributeOverlay = 0x20011006,
803 DrawingAttributeDeferral = 0x20011007,
804 DrawingAttributeClipRegion = 0x20011012,
805 DrawingAttributeWorldHandedness = 0x20011018,
807 HiddenLineAttribute = 0x20012000,
808 HiddenLineAttributeColor = 0x20012001,
809 HiddenLineAttributeDimFactor = 0x20012002,
810 HiddenLineAttributeFaceDisplacement = 0x20012003,
811 HiddenLineAttributeLinePattern = 0x20012005,
812 HiddenLineAttributeRenderFaces = 0x20012006,
813 HiddenLineAttributeRenderText = 0x20012007,
814 HiddenLineAttributeAlgorithm = 0x20012008,
815 HiddenLineAttributeSilhouetteCleanup = 0x20012009,
816 HiddenLineAttributeVisibility = 0x2001200a,
817 HiddenLineAttributeWeight = 0x2001200b,
818 HiddenLineAttributeTransparencyCutoff = 0x2001200c,
820 SegmentStyle = 0x20013001,
821 NamedStyle = 0x20013002,
822 MaterialPalette = 0x20013003,
823 Portfolio = 0x20013004,
826 ContourLineVisibility = 0x20014001,
827 ContourLinePosition = 0x20014002,
828 ContourLineColor = 0x20014003,
829 ContourLinePattern = 0x20014004,
830 ContourLineWeight = 0x20014005,
831 ContourLineLighting = 0x20014006,
836 BoundingVolume = 0x20016001,
837 BoundingExclusion = 0x20016002,
840 AttributeLockSetting = 0x20017001,
841 AttributeLockSubsegmentOverride = 0x20017002,
843 TransformMask = 0x20018000,
844 TransformMaskCamera = 0x20018001,
845 TransformMaskCameraTranslation = 0x20018002,
846 TransformMaskCameraScale = 0x20018003,
847 TransformMaskCameraOffset = 0x20018004,
848 TransformMaskCameraRotation = 0x20018005,
849 TransformMaskCameraPerspectiveScale = 0x20018006,
850 TransformMaskCameraProjection = 0x20018007,
851 TransformMaskModellingMatrix = 0x20018008,
852 TransformMaskModellingMatrixTranslation = 0x20018009,
853 TransformMaskModellingMatrixScale = 0x20018010,
854 TransformMaskModellingMatrixOffset = 0x20018011,
855 TransformMaskModellingMatrixRotation = 0x20018012,
857 ColorInterpolation = 0x20019000,
858 ColorInterpolationFaceColor = 0x20019001,
859 ColorInterpolationEdgeColor = 0x20019002,
860 ColorInterpolationMarkerColor = 0x20019003,
861 ColorInterpolationFaceIndex = 0x20019004,
862 ColorInterpolationEdgeIndex = 0x20019005,
863 ColorInterpolationMarkerIndex = 0x20019006,
865 CuttingSectionAttribute = 0x2001a000,
866 CuttingSectionAttributeCuttingLevel = 0x2001a001,
867 CuttingSectionAttributeCappingLevel = 0x2001a002,
868 CuttingSectionAttributeMaterialPreference = 0x2001a003,
886 InvalidMaterialIndex = -1,
913 EnvironmentTexture = 8,
914 EnvironmentCubeMap = 9,
953 EnvironmentTexture = 8,
954 EnvironmentCubeMap = 9
1100 GeometryDisplayLists,
1119 AttributeStaticModel,
1120 AttributeSpatialStaticModel
1136 Everything = 0x01000000,
1138 Visibility = 0x02000000,
1140 VisibilityCuttingSections,
1146 VisibilityEdgeLights,
1147 VisibilityMarkerLights,
1148 VisibilityFaceLights,
1149 VisibilityGenericEdges,
1150 VisibilityHardEdges,
1151 VisibilityAdjacentEdges,
1152 VisibilityInteriorSilhouetteEdges,
1153 VisibilityShadowEmitting,
1154 VisibilityShadowReceiving,
1155 VisibilityShadowCasting,
1159 VisibilityPerimeterEdges,
1160 VisibilityNonCulledEdges,
1161 VisibilityMeshQuadEdges,
1162 VisibilityCutGeometry,
1171 MaterialCutGeometry,
1173 MaterialAmbientLightUpColor,
1174 MaterialAmbientLightDownColor,
1175 MaterialAmbientLightColor,
1177 MaterialWindowColor,
1178 MaterialWindowContrastColor,
1182 MaterialMarkerColor,
1184 MaterialCutEdgeColor,
1187 MaterialVertexDiffuse,
1188 MaterialVertexDiffuseColor,
1189 MaterialVertexDiffuseAlpha,
1190 MaterialVertexDiffuseTexture,
1191 MaterialVertexSpecular,
1192 MaterialVertexMirror,
1193 MaterialVertexTransmission,
1194 MaterialVertexEmission,
1195 MaterialVertexEnvironment,
1197 MaterialVertexGloss,
1200 MaterialEdgeDiffuse,
1201 MaterialEdgeDiffuseColor,
1202 MaterialEdgeDiffuseAlpha,
1203 MaterialEdgeDiffuseTexture,
1204 MaterialEdgeSpecular,
1206 MaterialEdgeTransmission,
1207 MaterialEdgeEmission,
1208 MaterialEdgeEnvironment,
1213 MaterialFaceDiffuse,
1214 MaterialFaceDiffuseColor,
1215 MaterialFaceDiffuseAlpha,
1216 MaterialFaceDiffuseTexture,
1217 MaterialFaceSpecular,
1219 MaterialFaceTransmission,
1220 MaterialFaceEmission,
1221 MaterialFaceEnvironment,
1226 MaterialBackFaceDiffuse,
1227 MaterialBackFaceDiffuseColor,
1228 MaterialBackFaceDiffuseAlpha,
1229 MaterialBackFaceDiffuseTexture,
1230 MaterialBackFaceSpecular,
1231 MaterialBackFaceMirror,
1232 MaterialBackFaceTransmission,
1233 MaterialBackFaceEmission,
1234 MaterialBackFaceEnvironment,
1235 MaterialBackFaceBump,
1236 MaterialBackFaceGloss,
1239 MaterialFrontFaceDiffuse,
1240 MaterialFrontFaceDiffuseColor,
1241 MaterialFrontFaceDiffuseAlpha,
1242 MaterialFrontFaceDiffuseTexture,
1243 MaterialFrontFaceSpecular,
1244 MaterialFrontFaceMirror,
1245 MaterialFrontFaceTransmission,
1246 MaterialFrontFaceEmission,
1247 MaterialFrontFaceEnvironment,
1248 MaterialFrontFaceBump,
1249 MaterialFrontFaceGloss,
1252 MaterialCutFaceDiffuse,
1253 MaterialCutFaceDiffuseColor,
1254 MaterialCutFaceDiffuseAlpha,
1255 MaterialCutFaceDiffuseTexture,
1256 MaterialCutFaceSpecular,
1257 MaterialCutFaceMirror,
1258 MaterialCutFaceTransmission,
1259 MaterialCutFaceEmission,
1260 MaterialCutFaceEnvironment,
1261 MaterialCutFaceBump,
1262 MaterialCutFaceGloss,
1580 CharacterPositionOnly,
1583 CharacterPositionAdjusted
1804 UnableToLoadLibraries,
1805 VersionIncompatibility,
1806 InitializationFailed,
1967 TriangleDownWithDot,
1970 TriangleRightWithDot,
1973 TriangleLeftWithDot,
1980 SolidTriangleRightV,
2055 SubsegmentsAndIncludes,
2058 enum class Expansion
2063 IncludesAndReferences,
2073 enum class Reorganization
2082 typedef double Time;
2086 # define HPS_INLINE __forceinline
2089 # define HPS_INLINE inline
2092 #ifndef HPS_UNREFERENCED
2093 #define HPS_UNREFERENCED(param) ((void)(param))
2097 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2099 template<
typename T>
2100 HPS_INLINE T Degrees_To_Radians(T
const & degrees)
2102 return degrees * (T)(PI / 180.0);
2105 template<
typename T>
2106 HPS_INLINE T Radians_To_Degrees(T
const & radians)
2108 return radians * (T)(180.0 / PI);
2111 template<
typename T>
2112 HPS_INLINE
void SinCos(T
const & angle, T & sine, T & cosine) {
2113 T a = Degrees_To_Radians(angle);
2118 template<
typename T>
2119 HPS_INLINE T Cos(T
const & angle) {
2120 return cos (Degrees_To_Radians(angle));
2123 template<
typename T>
2124 HPS_INLINE T Sin(T
const & angle) {
2125 return sin (Degrees_To_Radians(angle));
2128 template<
typename T>
2129 HPS_INLINE T ACos(T
const & x) {
2134 return Radians_To_Degrees(acos(x));
2137 template<
typename T>
2138 HPS_INLINE T ATan2(T
const & y, T
const & x) {
2139 if (x == 0 && y == 0)
2141 return Radians_To_Degrees(atan2(y, x));
2147 typedef double Alternative;
2148 static const int Type = 1;
2149 static float Epsilon () {
return 1.0e-30f; }
2152 typedef float Alternative;
2153 static const int Type = 2;
2154 static double Epsilon () {
return 1.0e-300; }
2163 # if HOOPS_BIGENDIAN
2171 static HPS_INLINE
bool is_infinite(int32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2172 static HPS_INLINE
bool is_infinite(uint32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2173 static HPS_INLINE
bool is_infinite(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2174 static HPS_INLINE
bool is_infinite(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2176 static HPS_INLINE
bool is_nan(int32_t
const & v) {
2177 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2178 return exp == 0x7F800000 && mantissa != 0;
2180 static HPS_INLINE
bool is_nan(uint32_t
const & v) {
2181 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2182 return exp == 0x7F800000 && mantissa != 0;
2184 static HPS_INLINE
bool is_nan(int32_t
const * v) {
2185 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2186 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2188 static HPS_INLINE
bool is_nan(uint32_t
const * v) {
2189 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2190 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2193 static HPS_INLINE
bool is_special(int32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2194 static HPS_INLINE
bool is_special(uint32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2195 static HPS_INLINE
bool is_special(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2196 static HPS_INLINE
bool is_special(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2205 static HPS_INLINE
bool IsInfinite(
float const & a) {
return is_infinite (extract_uint32_t(a)); }
2206 static HPS_INLINE
bool IsInfinite(
double const & a) {
2208 memcpy (v, &a,
sizeof(
double));
2209 return is_infinite (v);
2213 static HPS_INLINE
bool IsNAN(
float const & a) {
return is_nan (extract_uint32_t(a)); }
2214 static HPS_INLINE
bool IsNAN(
double const & a) {
2216 memcpy (v, &a,
sizeof(
double));
2221 static HPS_INLINE
bool IsAbnormal(
float const & a) {
return is_special (extract_uint32_t(a)); }
2222 static HPS_INLINE
bool IsAbnormal(
double const & a) {
2224 memcpy (v, &a,
sizeof(
double));
2225 return is_special (v);
2230 static HPS_INLINE
bool Equals(
float const & a,
float const & b,
int tolerance = 32);
2231 static HPS_INLINE
bool Equals(
double const & a,
double const & b,
int tolerance = 32);
2233 #ifndef HOOPS_DEFINED
2234 template <
typename Alloc>
2235 static HPS_INLINE
bool Equals(std::vector<float, Alloc>
const & a, std::vector<float, Alloc>
const & b,
int tolerance = 32)
2237 if (a.size() != b.size())
2240 auto it1 = a.begin();
2241 auto it2 = b.begin();
2242 auto const end = a.end();
2243 for ( ; it1 != end; ++it1, ++it2)
2245 if (!Equals(*it1, *it2, tolerance))
2252 static HPS_INLINE uint32_t extract_sign_bit(
float const & a) {
2253 return extract_uint32_t(a) & 0x80000000;
2255 static HPS_INLINE uint32_t extract_sign_bit(
double const & a) {
2257 memcpy (v, &a,
sizeof(
double));
2258 return v[High] & 0x80000000;
2261 static HPS_INLINE
void apply_sign_bit(
float & a, uint32_t
const & sign_bit) {
2262 uint32_t v = extract_uint32_t(a);
2265 inject_uint32_t(a, v);
2267 static HPS_INLINE
void apply_sign_bit(
double & a, uint32_t
const & sign_bit) {
2269 memcpy (v, &a,
sizeof(
double));
2270 v[High] &= 0x7FFFFFFF;
2271 v[High] |= sign_bit;
2272 memcpy (&a, v,
sizeof(
double));
2276 static HPS_INLINE
unsigned char unit_to_byte(
float const & a) {
2277 uint32_t v = extract_uint32_t(a);
2285 uint32_t exp = v >> 23;
2286 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2288 return (
unsigned char) (man >> (16 + 126 - exp));
2291 static HPS_INLINE
unsigned char unit_to_byte_scaled(
float const & a,
unsigned char mix) {
2292 uint32_t v = extract_uint32_t(a);
2300 uint32_t exp = v >> 23;
2301 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2303 uint32_t x = (man >> (16 + 126 - exp));
2305 return (
unsigned char) ((x * (mix+1)) >> 8);
2309 static HPS_INLINE
bool match(
float const & a,
float const & b) {
2310 uint32_t va = extract_uint32_t(a);
2311 uint32_t vb = extract_uint32_t(b);
2313 if (((va | vb) & 0x7FFFFFFF) == 0)
2318 static HPS_INLINE
bool match(
double const & a,
double const & b) {
2323 static HPS_INLINE
void replace_if_smaller(
float & a,
float const & b) {
2324 uint32_t va = extract_uint32_t(a);
2325 uint32_t vb = extract_uint32_t(b);
2327 uint32_t a_sign = va & 0x80000000;
2328 uint32_t b_sign = vb & 0x80000000;
2330 (int32_t&)a_sign >>= 31;
2331 (int32_t&)b_sign >>= 31;
2333 uint32_t mash = (a_sign&b_sign);
2338 if ((int32_t&)vb < (int32_t&)va)
2339 memcpy(&a, &b,
sizeof(
float));
2341 static HPS_INLINE
void replace_if_smaller(
double & a,
double const & b) {
2346 static HPS_INLINE
void replace_if_larger(
float & a,
float const & b) {
2347 uint32_t va = extract_uint32_t(a);
2348 uint32_t vb = extract_uint32_t(b);
2350 uint32_t a_sign = va & 0x80000000;
2351 uint32_t b_sign = vb & 0x80000000;
2353 (int32_t&)a_sign >>= 31;
2354 (int32_t&)b_sign >>= 31;
2356 uint32_t mash = (a_sign&b_sign);
2361 if ((int32_t&)vb > (int32_t&)va)
2362 memcpy(&a, &b,
sizeof(
float));
2364 static HPS_INLINE
void replace_if_larger(
double & a,
double const & b) {
2370 static HPS_INLINE uint32_t extract_uint32_t(
float const & a) {
2372 memcpy(&i, &a,
sizeof(
float));
2376 static HPS_INLINE
void inject_uint32_t(
float & a, uint32_t
const & i) {
2377 memcpy(&a, &i,
sizeof(
float));
2380 static HPS_INLINE
float C2F(
unsigned char x) {
2382 return char_to_float[x];
2387 static HPS_INLINE
void pack_4(
float const & f,
float * m) {
2388 memcpy(&m[0], &f,
sizeof(
float));
2389 memcpy(&m[1], &f,
sizeof(
float));
2390 memcpy(&m[2], &f,
sizeof(
float));
2391 memcpy(&m[3], &f,
sizeof(
float));
2394 static HPS_INLINE
void pack_4(
float const & f0,
float const & f1,
float const & f2,
float const & f3,
float * m) {
2395 memcpy(&m[0], &f0,
sizeof(
float));
2396 memcpy(&m[1], &f1,
sizeof(
float));
2397 memcpy(&m[2], &f2,
sizeof(
float));
2398 memcpy(&m[3], &f3,
sizeof(
float));
2401 static HPS_INLINE
void unpack_4(
float * f0,
float const *
const m) {
2402 memcpy(f0, m,
sizeof(
float)*4);
2405 static HPS_INLINE
void unpack_4(
float & f0,
float & f1,
float & f2,
float & f3,
float const *
const m) {
2406 memcpy(&f0, &m[0],
sizeof(
float));
2407 memcpy(&f1, &m[1],
sizeof(
float));
2408 memcpy(&f2, &m[2],
sizeof(
float));
2409 memcpy(&f3, &m[3],
sizeof(
float));
2413 static const float char_to_float[256];
2422 template <
typename T> HPS_INLINE T * Alter (T
const * a) {
return const_cast<T *
>(a); }
2423 template <
typename T> HPS_INLINE T & Alter (T
const & a) {
return const_cast<T &
>(a); }
2425 template <
typename T> HPS_INLINE T Abs (T
const & a) {
return a < 0 ? -a : a; }
2426 template <
typename T> HPS_INLINE
int Compare (T
const & a, T
const & b) {
return a == b ? 0 : a < b ? -1 : 1; }
2427 template <
typename T> HPS_INLINE
int Sign (T
const & a) {
return Compare(a,(T)0); }
2428 template <
typename T> HPS_INLINE
void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2429 template <
typename T> HPS_INLINE
int Floor(T
const & a) {
return ((a > 0 || (T)(
int)a == a) ? (
int)a : ((
int)a - 1)); }
2430 template <
typename T> HPS_INLINE
int Ceiling(T
const & a) {
return ((a < 0 || (T)(
int)a == a) ? (
int)a : ((
int)a + 1)); }
2432 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b) {
return a < b ? a : b; }
2433 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c) {
return Min(Min(a,b),c); }
2434 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); }
2435 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); }
2436 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); }
2438 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b) {
return a > b ? a : b; }
2439 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c) {
return Max(Max(a,b),c); }
2440 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); }
2441 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); }
2442 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); }
2444 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; }
2447 template <> HPS_INLINE
float Abs<float> (
float const & a) {
2448 uint32_t v = Float::extract_uint32_t(a);
2451 Float::inject_uint32_t(f,v);
2455 template <> HPS_INLINE
int Sign<float> (
float const & a) {
2456 uint32_t v = Float::extract_uint32_t(a);
2458 if ((v & 0x7FFFFFFF) == 0)
2461 return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2464 template <> HPS_INLINE
int Compare<float> (
float const & a,
float const & b) {
2465 int a_sign = Sign(a);
2466 int b_sign = Sign(b);
2468 if (a_sign != b_sign)
2469 return Compare(a_sign, b_sign);
2471 uint32_t v = Float::extract_uint32_t(a);
2472 uint32_t u = Float::extract_uint32_t(b);
2474 return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2477 template <> HPS_INLINE
float const & Min<float> (
float const & a,
float const & b) {
2483 template <> HPS_INLINE
float const & Max<float> (
float const & a,
float const & b) {
2492 HPS_INLINE
bool Float::Equals(
float const & a,
float const & b,
int tolerance) {
2493 int32_t va = Float::extract_uint32_t(a);
2494 int32_t vb = Float::extract_uint32_t(b);
2496 if (is_special(va) || is_special(vb)) {
2497 if (is_infinite(va) || is_infinite(vb))
2499 if (is_nan(va) || is_nan(vb))
2503 int const close_to_zero = 0x36A00000;
2504 if ((va & 0x7FFFFFFF) == 0)
2505 return (vb & 0x7FFFFFFF) < close_to_zero;
2506 else if ((vb & 0x7FFFFFFF) == 0)
2507 return (va & 0x7FFFFFFF) < close_to_zero;
2509 uint32_t sign_mask = va ^ vb;
2510 (int32_t &)sign_mask >>= 31;
2512 int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2513 int32_t v1 = tolerance + diff;
2514 int32_t v2 = tolerance - diff;
2515 return (v1|v2) >= 0;
2518 HPS_INLINE
bool Float::Equals(
double const & a,
double const & b,
int tolerance) {
2519 int32_t va[2], vb[2];
2520 memcpy (va, &a,
sizeof(
double));
2521 memcpy (vb, &b,
sizeof(
double));
2523 if (is_special(va) || is_special(vb)) {
2524 if (is_infinite(va) || is_infinite(vb))
2525 return va[High] == vb[High] && va[Low] == vb[Low];
2526 if (is_nan(va) || is_nan(vb))
2530 if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2531 return Abs(a - b) < 0.000000000000005;
2533 if (extract_sign_bit(a) != extract_sign_bit(b))
2536 if (va[High] != vb[High])
2539 return Abs(va[Low] - vb[Low]) <= tolerance;
2546 HPS_INLINE
bool Is_Abnormal (
double const & d) {
return Float::IsAbnormal (d); }
2548 template <
typename T>
2549 HPS_INLINE
bool Is_Abnormal (
size_t count, T
const * t) {
2551 if (Is_Abnormal (*t++))
2556 template <
typename T>
2557 HPS_INLINE
bool Is_Abnormal (
int count, T
const * t) {
2558 return count >= 0 && Is_Abnormal((
size_t)count, t);
2565 template <
typename F>
class HPS_TEMPLATE_API Vector_3D;
2566 template <
typename F>
class HPS_TEMPLATE_API Plane_3D;
2567 template <
typename F>
class HPS_TEMPLATE_API Vector_2D;
2568 template <
typename F>
class HPS_TEMPLATE_API Point_2D;
2571 template <
typename F>
2579 Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2581 template <
typename D>
2582 explicit Point_3D (
Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2590 bool operator== (
Point_3D const & p)
const {
return x == p.x && y == p.y && z == p.z; }
2591 bool operator!= (
Point_3D const & p)
const {
return !(*
this == p); }
2593 bool Equals(
Point_3D const & p,
int in_tolerance = 32)
const {
2600 Point_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2601 Point_3D & operator/= (F s) {
return operator*= ((F)1 / s); }
2602 Point_3D const operator* (F s)
const {
return Point_3D (x * s, y * s, z * s); }
2603 Point_3D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2605 F & operator[] (
size_t i) {
return (&x)[i]; }
2606 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2639 template <
typename F,
typename S>
2642 template <
typename F>
2643 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b) {
2644 return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2647 template <
typename F>
2648 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2649 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);
2652 template <
typename F>
2653 HPS_INLINE
bool Is_Abnormal (Point_3D<F>
const & p) {
2654 return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2658 template <
typename F>
2665 Point_2D (F v1, F v2) : x (v1), y (v2) {}
2667 template <
typename D>
2675 bool operator== (
Point_2D const & p)
const {
return x == p.x && y == p.y; }
2676 bool operator!= (
Point_2D const & p)
const {
return !(*
this == p); }
2678 bool Equals(
Point_2D const & p,
int in_tolerance = 32)
const {
2683 Point_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2684 Point_2D & operator/= (F s) {
return operator*= ((F)1 / s); }
2686 Point_2D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2688 F & operator[] (
size_t i) {
return (&x)[i]; }
2689 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2710 template <
typename F>
2713 template <
typename F,
typename S>
2714 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)); }
2716 template <
typename F>
2717 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b) {
2718 return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2721 template <
typename F>
2722 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b, Point_2D<F>
const & c) {
2723 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);
2726 template <
typename F>
2727 HPS_INLINE
bool Is_Abnormal (Point_2D<F>
const & p) {
2728 return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2732 template <
typename F>
2740 Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2741 template <
typename D>
2750 bool operator== (
Vector_3D const & v)
const {
2751 return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2753 bool operator!= (
Vector_3D const & v)
const {
return !(*
this == v); }
2755 bool Equals(
Vector_3D const & v,
int in_tolerance = 32)
const {
2761 Vector_3D & operator+= (
Vector_3D const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2762 Vector_3D & operator-= (
Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2766 Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2767 Vector_3D & operator/= (F s) {
return operator*= (1.0f / s); }
2769 Vector_3D const operator/ (F s)
const {
return operator* (1.0f / s); }
2771 F & operator[] (
size_t i) {
return (&x)[i]; }
2772 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2774 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2776 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y + (
double)z*(double)z; }
2778 HPS_INLINE
double Length2D ()
const {
return sqrt (LengthSquared2D()); }
2780 HPS_INLINE
double LengthSquared2D ()
const {
return (
double)x*(double)x + (
double)y*(double)y;}
2784 F range = Max (Abs (x), Abs (y), Abs (z));
2785 if (range > F(1.0e10))
2789 F len = (F)Length();
2796 HPS_INLINE
Vector_3D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2798 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y), Abs(z)); }
2799 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y)+Abs(z); }
2801 HPS_INLINE F Dot (
Vector_3D const & v)
const {
return x * v.x + y * v.y + z * v.z; }
2804 return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2809 return Vector_3D (x * v.x, y * v.y, z * v.z);
2823 template <
typename F,
typename S>
2826 template <
typename F>
2827 HPS_INLINE
bool Is_Abnormal (Vector_3D<F>
const & v) {
2828 return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2832 template <
typename F>
2833 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F>
const & v) : x(v.x), y(v.y), z(v.z) {}
2835 template <
typename F>
2836 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; }
2837 template <
typename F>
2838 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; }
2840 template <
typename F>
2841 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); }
2843 template <
typename F>
2844 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); }
2845 template <
typename F>
2846 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); }
2848 template <
typename F>
2849 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; }
2850 template <
typename F>
2851 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; }
2852 template <
typename F>
2853 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); }
2854 template <
typename F>
2855 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); }
2859 template <
typename F>
2860 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F>
const & a, Point_3D<F>
const & b,
float t) {
2861 return a + (b - a) * t;
2864 template <
typename F>
2865 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F>
const & a, Vector_3D<F>
const & b,
float t) {
2866 return Vector_3D<F>(a + (b - a) * t).Normalize();
2871 template <
typename F>
2872 HPS_INLINE
double PointToPointDistance(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2873 return (p2 - p1).Length();
2876 template <
typename F>
2877 HPS_INLINE
double PointToPointDistanceSquared(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2878 return (p2 - p1).LengthSquared();
2881 template <
typename F>
2882 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2883 F p =
static_cast<F
>((c - b).LengthSquared());
2884 F q =
static_cast<F
>((c - a).LengthSquared());
2885 F r =
static_cast<F
>((b - a).LengthSquared());
2888 (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2889 / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2894 template <
typename F>
2895 HPS_INLINE
bool Normalize(
size_t count, Vector_3D<F> * vectors) {
2896 bool success =
true;
2897 for (
size_t i = 0; i < count; ++i) {
2898 if (vectors->Normalize() == Vector_3D<F>::Zero())
2906 template <
typename F>
class HPS_TEMPLATE_API Plane_2D;
2908 template <
typename F>
2915 Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2916 template <
typename D>
2925 bool operator== (
Vector_2D const & v)
const {
2926 return Float::match(x, v.x) && Float::match(y, v.y);
2928 bool operator!= (
Vector_2D const & v)
const {
return !(*
this == v); }
2930 bool Equals(
Vector_2D const & v,
int in_tolerance = 32)
const {
2939 Vector_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2940 Vector_2D & operator/= (F s) {
return operator*= (1.0f / s); }
2942 Vector_2D const operator/ (F s)
const {
return operator* (1.0f / s); }
2944 F & operator[] (
size_t i) {
return (&x)[i]; }
2945 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2947 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2949 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y; }
2953 F range = Max (Abs (x), Abs (y));
2954 if (range > F(1.0e10))
2958 F len = (F)Length();
2965 HPS_INLINE
Vector_2D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2967 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y)); }
2968 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y); }
2970 HPS_INLINE F Dot (
Vector_2D const & v)
const {
return x * v.x + y * v.y; }
2973 HPS_INLINE
float Cross (
Vector_2D const & v)
const {
2974 return x * v.y - y * v.x;
2991 template <
typename F,
typename S>
2994 template <
typename F>
2995 HPS_INLINE
bool Is_Abnormal (Vector_2D<F>
const & v) {
2996 return Is_Abnormal (v.x) || Is_Abnormal (v.y);
3000 template <
typename F>
3001 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F>
const & that) : x (that.x), y (that.y), z(0) {}
3003 template <
typename F>
3004 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F>
const & v) : x(v.x), y(v.y), z(0) {}
3006 template <
typename F>
3007 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
3008 template <
typename F>
3009 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
3011 template <
typename F>
3012 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); }
3013 template <
typename F>
3014 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); }
3016 template <
typename F>
3017 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
3018 template <
typename F>
3019 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
3021 template <
typename F>
3022 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); }
3023 template <
typename F>
3024 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); }
3027 template <
typename F>
3028 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
3029 template <
typename F>
3030 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
3032 template <
typename F>
3033 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); }
3035 template <
typename F>
3036 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); }
3037 template <
typename F>
3038 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); }
3040 template <
typename F>
3041 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
3042 template <
typename F>
3043 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
3044 template <
typename F>
3045 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); }
3046 template <
typename F>
3047 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); }
3053 template <
typename F>
3062 Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3066 template <
typename D>
3067 explicit Plane_3D (
Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3083 for (
size_t i=0; i<count; ++i) {
3086 normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3087 normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3088 normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3098 double inv_count = 1.0 / (double)count;
3106 *
this = Plane_3D::Zero();
3112 bool operator== (
Plane_3D const & p)
const {
return a == p.a && b == p.b && c == p.c && d == p.d; }
3113 bool operator!= (
Plane_3D const & p)
const {
return !(*
this == p); }
3115 F & operator[] (
size_t i) {
return (&a)[i]; }
3116 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3118 HPS_INLINE
bool Equals(
Plane_3D const & p,
int in_tolerance = 32)
const {
3133 F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3134 F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3137 return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3138 ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3139 ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3146 F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3147 (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3149 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));
3152 static HPS_INLINE
Plane_3D Zero() {
return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3156 Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s;
return *
this; }
3157 Plane_3D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3158 Plane_3D const operator* (F s)
const {
return Plane_3D (a * s, b * s, c * s, d * s); }
3159 Plane_3D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3166 template <
typename F>
3167 HPS_INLINE
bool Is_Abnormal (
Plane_3D<F> const & p) {
3168 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3172 template <
typename F>
3173 HPS_INLINE F operator* (Plane_3D<F>
const & plane, Point_3D<F>
const & point) {
3174 return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3176 template <
typename F>
3177 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_3D<F>
const & plane) {
3178 return plane * point;
3181 template <
typename F>
3182 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F>
const & a, Plane_3D<F>
const & b,
float t) {
3183 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);
3186 template <
typename F>
3187 Vector_3D<F>::Vector_3D(Plane_3D<F>
const & p) : x(p.a), y(p.b), z(p.c) {}
3194 template <
typename F>
3202 Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3206 template <
typename D>
3207 explicit Plane_2D (
Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3211 bool operator== (
Plane_2D const & p)
const {
return a == p.a && b == p.b && c == p.c; }
3212 bool operator!= (
Plane_2D const & p)
const {
return !(*
this == p); }
3214 F & operator[] (
size_t i) {
return (&a)[i]; }
3215 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3217 HPS_INLINE
bool Equals(
Plane_2D const & p,
int in_tolerance = 32)
const {
3234 Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s;
return *
this; }
3235 Plane_2D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3236 Plane_2D const operator* (F s)
const {
return Plane_2D (a * s, b * s, c * s); }
3237 Plane_2D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3244 template <
typename F>
3245 HPS_INLINE
bool Is_Abnormal (
Plane_2D<F> const & p) {
3246 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3250 template <
typename F>
3251 HPS_INLINE F operator* (Plane_2D<F>
const & plane, Point_2D<F>
const & point) {
3252 return plane.a * point.x + plane.b * point.y + plane.c;
3254 template <
typename F>
3255 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_2D<F>
const & plane) {
3256 return plane * point;
3259 template <
typename F>
3260 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F>
const & a, Plane_2D<F>
const & b,
float t) {
3261 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);
3264 template <
typename F>
3265 Vector_2D<F>::Vector_2D(Plane_2D<F>
const & p) : x(p.a), y(p.b) {}
3279 : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3280 bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3282 IntRectangle(
int in_left,
int in_right,
int in_bottom,
int in_top)
3283 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3286 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3291 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3295 return !(*
this == rect);
3298 HPS_INLINE
int PixelWidth()
const {
3299 return right - left + 1;
3302 HPS_INLINE
int PixelHeight()
const {
3303 return top - bottom + 1;
3306 HPS_INLINE
int Width()
const {
3307 return right - left;
3310 HPS_INLINE
int Height()
const {
3311 return top - bottom;
3314 HPS_INLINE
int Area()
const {
3315 return Width() * Height();
3318 HPS_INLINE
Point2D Center()
const {
3319 return Point2D((
float)(left + right) * 0.5f, (
float)(bottom + top) * 0.5f);
3322 HPS_INLINE
bool Intersecting(
IntRectangle const & rect)
const {
3323 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3326 HPS_INLINE
bool Contains(
IntRectangle const & rect)
const {
3327 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3340 right += rect.right;
3341 bottom -= rect.bottom;
3356 right -= rect.right;
3357 bottom += rect.bottom;
3363 left = Max(left, rect.left);
3364 right = Min(right, rect.right);
3365 bottom = Max(bottom, rect.bottom);
3366 top = Min(top, rect.top);
3371 left = Min(left, rect.left);
3372 right = Max(right, rect.right);
3373 bottom = Min(bottom, rect.bottom);
3374 top = Max(top, rect.top);
3391 return temp.Expand(border);
3394 HPS_INLINE IntRectangle Expand(IntRectangle
const & a,
int border) {
3395 IntRectangle temp = a;
3396 return temp.Expand(border);
3399 HPS_INLINE IntRectangle Contract(IntRectangle
const & a,
int border) {
3400 IntRectangle temp = a;
3401 return temp.Contract(border);
3404 HPS_INLINE IntRectangle Contract(IntRectangle
const & a, IntRectangle
const & border) {
3405 IntRectangle temp = a;
3406 return temp.Contract(border);
3409 HPS_INLINE IntRectangle Intersect(IntRectangle
const & a, IntRectangle
const & b) {
3410 IntRectangle temp = a;
3411 return temp.Intersect(b);
3414 HPS_INLINE IntRectangle Union(IntRectangle
const & a, IntRectangle
const & b) {
3415 IntRectangle temp = a;
3416 return temp.Union(b);
3426 : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3427 bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3429 Rectangle(
float in_left,
float in_right,
float in_bottom,
float in_top)
3430 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3433 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3436 : left((
float)that.left), right((
float)that.right), bottom((
float)that.bottom), top((
float)that.top) {}
3446 Merge(count, points);
3458 Merge(count, points);
3462 HPS_INLINE
float Width()
const {
3463 return right - left;
3466 HPS_INLINE
float Height()
const {
3467 return top - bottom;
3470 HPS_INLINE
float Area()
const {
3471 return Width() * Height();
3474 HPS_INLINE
Point2D Center()
const {
3475 return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3478 HPS_INLINE
void Merge(
size_t count,
Point const * points) {
3481 if (Compare(points[0].x, points[1].x)>0) {
3482 Float::replace_if_smaller(left, points[1].x);
3483 Float::replace_if_larger(right, points[0].x);
3486 Float::replace_if_smaller(left, points[0].x);
3487 Float::replace_if_larger(right, points[1].x);
3490 if (Compare(points[0].y, points[1].y)>0) {
3491 Float::replace_if_smaller(bottom, points[1].y);
3492 Float::replace_if_larger(top, points[0].y);
3495 Float::replace_if_smaller(bottom, points[0].y);
3496 Float::replace_if_larger(top, points[1].y);
3507 HPS_INLINE
void Merge(
Point const & point) {
3508 Float::replace_if_smaller(left, point.x);
3509 Float::replace_if_smaller(bottom, point.y);
3510 Float::replace_if_larger(right, point.x);
3511 Float::replace_if_larger(top, point.y);
3514 HPS_INLINE
void Merge(
size_t count,
Point2D const * points) {
3517 if (Compare(points[0].x, points[1].x)>0) {
3518 Float::replace_if_smaller(left, points[1].x);
3519 Float::replace_if_larger(right, points[0].x);
3522 Float::replace_if_smaller(left, points[0].x);
3523 Float::replace_if_larger(right, points[1].x);
3526 if (Compare(points[0].y, points[1].y)>0) {
3527 Float::replace_if_smaller(bottom, points[1].y);
3528 Float::replace_if_larger(top, points[0].y);
3531 Float::replace_if_smaller(bottom, points[0].y);
3532 Float::replace_if_larger(top, points[1].y);
3543 HPS_INLINE
void Merge(
Point2D const & point) {
3544 Float::replace_if_smaller(left, point.x);
3545 Float::replace_if_smaller(bottom, point.y);
3546 Float::replace_if_larger(right, point.x);
3547 Float::replace_if_larger(top, point.y);
3550 bool operator==(
Rectangle const & rect)
const {
3551 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3554 bool operator!=(
Rectangle const & rect)
const {
3555 return !(*
this == rect);
3558 HPS_INLINE
bool Intersecting(
Rectangle const & rect)
const {
3559 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3562 HPS_INLINE
bool Contains(
Point const & contained)
const {
3563 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3566 HPS_INLINE
bool Contains(
Point2D const & contained)
const {
3567 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3570 HPS_INLINE
bool Contains(
Rectangle const & rect) {
3571 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3574 HPS_INLINE
bool Contains(
Rectangle const & rect,
float epsilon) {
3575 return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3576 bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3579 HPS_INLINE
Rectangle & Expand(
float border) {
3587 HPS_INLINE
Rectangle & Expand(
int border) {
3588 Expand((
float)border);
3594 right += rect.right;
3595 bottom -= rect.bottom;
3600 HPS_INLINE
Rectangle & Contract(
int border) {
3610 right -= rect.right;
3611 bottom += rect.bottom;
3617 left = Max(left, rect.left);
3618 right = Min(right, rect.right);
3619 bottom = Max(bottom, rect.bottom);
3620 top = Min(top, rect.top);
3625 left = Min(left, rect.left);
3626 right = Max(right, rect.right);
3627 bottom = Min(bottom, rect.bottom);
3628 top = Max(top, rect.top);
3633 float scale = (scope.right - scope.left) * 0.5f;
3634 float trans = (scope.right + scope.left) * 0.5f;
3636 left = left * scale + trans;
3637 right = right * scale + trans;
3639 scale = (scope.top - scope.bottom) * 0.5f;
3640 trans = (scope.top + scope.bottom) * 0.5f;
3642 bottom = bottom * scale + trans;
3643 top = top * scale + trans;
3648 float tmp = 2.0f/(scope.right - scope.left);
3649 right = (right - scope.left) * tmp - 1.0f;
3650 left = (left - scope.left) * tmp - 1.0f;
3652 tmp = 2.0f/(scope.top - scope.bottom);
3653 top = (top - scope.bottom) * tmp - 1.0f;
3654 bottom = (bottom - scope.bottom) * tmp - 1.0f;
3658 static HPS_INLINE
Rectangle FullScope() {
3659 return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3662 static HPS_INLINE
Rectangle InvalidScope() {
3663 return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3675 temp.left = Floor (a.left);
3676 temp.right = Floor (a.right);
3677 temp.bottom = Floor (a.bottom);
3678 temp.top = Floor (a.top);
3682 HPS_INLINE Rectangle Expand(Rectangle
const & a, Rectangle
const & border) {
3684 return temp.Expand(border);
3687 HPS_INLINE Rectangle Expand(Rectangle
const & a,
float border) {
3689 return temp.Expand(border);
3692 HPS_INLINE Rectangle Contract(Rectangle
const & a,
int border) {
3694 return temp.Contract(border);
3697 HPS_INLINE Rectangle Contract(Rectangle
const & a, Rectangle
const & border) {
3699 return temp.Contract(border);
3702 HPS_INLINE Rectangle Intersect(Rectangle
const & a, Rectangle
const & b) {
3704 return temp.Intersect(b);
3707 HPS_INLINE Rectangle Union(Rectangle
const & a, Rectangle
const & b) {
3709 return temp.Union(b);
3712 HPS_INLINE Rectangle Inscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3714 return temp.Inscribe_Scope(scope);
3717 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3719 return temp.Circumscribe_Scope(scope);
3722 HPS_INLINE IntRectangle::IntRectangle(Rectangle
const & that)
3723 : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3728 template <
typename F>
3731 template <
typename F>
3744 template <
typename D>
3773 min = Limit_Point();
3774 max = -Limit_Point();
3777 min = max = *points++;
3780 Merge(count, points);
3793 return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3810 HPS_INLINE
bool operator== (
Cuboid_3D const & cuboid)
const {
return (min == cuboid.
min && max == cuboid.
max); }
3816 HPS_INLINE
bool operator!= (
Cuboid_3D const & cuboid)
const {
return !(*
this == cuboid); }
3841 HPS_INLINE F
Volume ()
const {
return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3849 return max.x >= cuboid.
min.x && min.x <= cuboid.
max.x &&
3850 max.y >= cuboid.
min.y && min.y <= cuboid.
max.y &&
3851 max.z >= cuboid.
min.z && min.z <= cuboid.
max.z;
3860 return max.x + allowance >= cuboid.
min.x && min.x - allowance <= cuboid.
max.x &&
3861 max.y + allowance >= cuboid.
min.y && min.y - allowance <= cuboid.
max.y &&
3862 max.z + allowance >= cuboid.
min.z && min.z - allowance <= cuboid.
max.z;
3873 return max[dimension] >= cuboid.
min[dimension] && min[dimension] <= cuboid.
max[dimension];
3885 return max[dimension] + allowance >= cuboid.
min[dimension] && min[dimension] - allowance <= cuboid.
max[dimension];
3895 return LineIntersecting(start, direction,
true);
3906 return LineIntersecting(point1, direction,
false);
3915 Float::replace_if_smaller(min.x, cuboid.
min.x);
3916 Float::replace_if_smaller(min.y, cuboid.
min.y);
3917 Float::replace_if_smaller(min.z, cuboid.
min.z);
3918 Float::replace_if_larger(max.x, cuboid.
max.x);
3919 Float::replace_if_larger(max.y, cuboid.
max.y);
3920 Float::replace_if_larger(max.z, cuboid.
max.z);
3936 Float::replace_if_smaller(min.x, point.x);
3937 Float::replace_if_smaller(min.y, point.y);
3938 Float::replace_if_smaller(min.z, point.z);
3939 Float::replace_if_larger(max.x, point.x);
3940 Float::replace_if_larger(max.y, point.y);
3941 Float::replace_if_larger(max.z, point.z);
3952 if (Compare(points[0].x, points[1].x)>0) {
3953 Float::replace_if_smaller(min.x, points[1].x);
3954 Float::replace_if_larger(max.x, points[0].x);
3957 Float::replace_if_smaller(min.x, points[0].x);
3958 Float::replace_if_larger(max.x, points[1].x);
3961 if (Compare(points[0].y, points[1].y)>0) {
3962 Float::replace_if_smaller(min.y, points[1].y);
3963 Float::replace_if_larger(max.y, points[0].y);
3966 Float::replace_if_smaller(min.y, points[0].y);
3967 Float::replace_if_larger(max.y, points[1].y);
3970 if (Compare(points[0].z, points[1].z)>0) {
3971 Float::replace_if_smaller(min.z, points[1].z);
3972 Float::replace_if_larger(max.z, points[0].z);
3975 Float::replace_if_smaller(min.z, points[0].z);
3976 Float::replace_if_larger(max.z, points[1].z);
3993 return (contained.
min.x >= min.x &&
3994 contained.
min.y >= min.y &&
3995 contained.
min.z >= min.z &&
3996 contained.
max.x <= max.x &&
3997 contained.
max.y <= max.y &&
3998 contained.
max.z <= max.z);
4007 return (contained.x >= min.x &&
4008 contained.y >= min.y &&
4009 contained.z >= min.z &&
4010 contained.x <= max.x &&
4011 contained.y <= max.y &&
4012 contained.z <= max.z);
4022 return (contained.x >= min.x - epsilon &&
4023 contained.y >= min.y - epsilon &&
4024 contained.z >= min.z - epsilon &&
4025 contained.x <= max.x + epsilon &&
4026 contained.y <= max.y + epsilon &&
4027 contained.z <= max.z + epsilon);
4036 Float::replace_if_larger(min.x, cuboid.
min.x);
4037 Float::replace_if_larger(min.y, cuboid.
min.y);
4038 Float::replace_if_larger(min.z, cuboid.
min.z);
4039 Float::replace_if_smaller(max.x, cuboid.
max.x);
4040 Float::replace_if_smaller(max.y, cuboid.
max.y);
4041 Float::replace_if_smaller(max.z, cuboid.
max.z);
4051 Float::replace_if_smaller(min.x, cuboid.
min.x);
4052 Float::replace_if_smaller(min.y, cuboid.
min.y);
4053 Float::replace_if_smaller(min.z, cuboid.
min.z);
4054 Float::replace_if_larger(max.x, cuboid.
max.x);
4055 Float::replace_if_larger(max.y, cuboid.
max.y);
4056 Float::replace_if_larger(max.z, cuboid.
max.z);
4086 F
const limit = std::numeric_limits<F>::max();
4090 bool LineIntersecting (Point_3D<F>
const & start, Vector_3D<F>
const & direction,
bool is_ray)
const;
4093 typedef Cuboid_3D<float> SimpleCuboid;
4094 typedef Cuboid_3D<double> DSimpleCuboid;
4097 template <
typename F>
4098 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4099 Cuboid_3D<F> temp = a;
4100 return temp.Intersect(b);
4103 template <
typename F>
4104 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4105 Cuboid_3D<F> temp = a;
4106 return temp.Union(b);
4109 template <
typename F>
4110 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F>
const & a, F border) {
4111 Cuboid_3D<F> temp = a;
4112 return temp.Expand(border);
4115 template <
typename F>
4116 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F>
const & a, F border) {
4117 Cuboid_3D<F> temp = a;
4118 return temp.Contract(border);
4123 template <
typename F>
4124 struct HPS_TEMPLATE_API Sphere_3D {
4128 Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4130 template <
typename D>
4131 explicit Sphere_3D (Sphere_3D<D>
const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4133 Sphere_3D (Cuboid_3D<F>
const & cuboid) :
4134 center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4136 Sphere_3D (Point_3D<F>
const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4138 Sphere_3D (
size_t count, Point_3D<F>
const * points) : radius(0.0f) {
4139 Cuboid_3D<F> cuboid(count, points);
4140 center = Midpoint(cuboid.min, cuboid.max);
4141 Engulf (count, points);
4144 Sphere_3D (
size_t count, Point_3D<F>
const * points, Point_3D<F>
const & starting_center) : center(starting_center), radius(0) {
4145 Engulf (count, points);
4148 HPS_INLINE
bool IsValid()
const {
4152 static HPS_INLINE Sphere_3D Invalid() {
return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4154 void Invalidate() {radius = -1;}
4156 HPS_INLINE
bool operator== (Sphere_3D
const & sphere)
const {
return (center == sphere.center && radius == sphere.radius); }
4157 HPS_INLINE
bool operator!= (Sphere_3D
const & sphere)
const {
return !(*
this == sphere); }
4159 HPS_INLINE F Volume ()
const {
return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4161 HPS_INLINE
void Merge(Point_3D<F>
const & point) {
4162 Vector_3D<F> dir = point - center;
4163 F distance = (F)dir.Length();
4165 if (distance > radius) {
4166 F t = F(0.5) * (distance - radius);
4167 center += t * dir.Normalize();
4172 HPS_INLINE
void Merge(
size_t count, Point_3D<F>
const * points) {
4174 for (
size_t i = 0; i < count; ++i) {
4175 Vector_3D<F> dir = *points - center;
4176 F distance = (F)dir.Length();
4178 if (distance > radius) {
4179 F t = F(0.5) * (distance - radius);
4180 center += t * dir.Normalize();
4188 HPS_INLINE
void Merge (Sphere_3D
const & sphere) {
4189 Vector_3D<F> dir = sphere.center - center;
4190 F distance = (F)dir.Length();
4192 if (distance + sphere.radius > radius) {
4193 if (distance + radius > sphere.radius) {
4194 F t = F(0.5 * (sphere.radius + distance - radius));
4195 center += t * dir.Normalize();
4199 center = sphere.center;
4200 radius = sphere.radius;
4205 HPS_INLINE
void Merge (Cuboid_3D<F>
const & cuboid) { Merge (Sphere_3D (cuboid)); }
4209 HPS_INLINE
void Engulf (
size_t count, Point_3D<F>
const * points) {
4210 for (
size_t i = 0; i < count; ++i) {
4211 double dsq = (*points++ - center).LengthSquared();
4212 if ((F)dsq > radius * radius)
4213 radius = (F)sqrt(dsq);
4218 typedef Sphere_3D<float> SimpleSphere;
4219 typedef Sphere_3D<double> DSimpleSphere;
4222 template <
typename F>
4224 min =
Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4225 max =
Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4243 HPS_INLINE
RGBColor (
float r,
float g,
float b) : red (r), green (g), blue (b) {}
4244 explicit HPS_INLINE RGBColor (
RGB24Color const & c24);
4245 explicit HPS_INLINE RGBColor (
float gray) : red (gray), green (gray), blue (gray) {}
4246 explicit HPS_INLINE RGBColor (
RGBAS32Color const & c32);
4247 explicit HPS_INLINE RGBColor (
RGBA32Color const & c32);
4248 explicit HPS_INLINE RGBColor (
RGBAColor const & c);
4250 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4251 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4252 float Distance(RGBColor
const & other_color)
const;
4253 HPS_INLINE
bool IsValid()
const {
4254 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4257 HPS_INLINE
bool operator== (RGBColor
const & c)
const {
return red == c.red && green == c.green && blue == c.blue; }
4258 HPS_INLINE
bool operator!= (RGBColor
const & c)
const {
return !(*
this == c); }
4260 HPS_INLINE
bool Equals(RGBColor
const & c,
int in_tolerance = 32)
const
4263 HPS_INLINE RGBColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4264 HPS_INLINE RGBColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4265 HPS_INLINE RGBColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4266 HPS_INLINE RGBColor
const operator* (RGBColor
const & c)
const {
return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4267 HPS_INLINE RGBColor
const operator+ (RGBColor
const & c)
const {
return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4268 HPS_INLINE RGBColor
const operator- (RGBColor
const & c)
const {
return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4270 HPS_INLINE RGBColor & operator*= (
float s) { red *= s; green *= s; blue *= s;
return *
this; }
4271 HPS_INLINE RGBColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4272 HPS_INLINE RGBColor & operator+= (
float s) { red += s; green += s; blue += s;
return *
this; }
4273 HPS_INLINE RGBColor & operator-= (
float s) { red -= s; green -= s; blue -= s;
return *
this; }
4274 HPS_INLINE RGBColor
const operator* (
float s)
const {
return RGBColor (red * s, green * s, blue * s); }
4275 HPS_INLINE RGBColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4276 HPS_INLINE RGBColor
const operator+ (
float s)
const {
return RGBColor (red + s, green + s, blue + s); }
4277 HPS_INLINE RGBColor
const operator- (
float s)
const {
return RGBColor (red - s, green - s, blue - s); }
4279 static HPS_INLINE RGBColor Black() {
return RGBColor (0, 0, 0);};
4280 static HPS_INLINE RGBColor White() {
return RGBColor (1, 1, 1);};
4281 static HPS_INLINE RGBColor Invalid() {
return RGBColor (-1, -1, -1);};
4283 void ShowHLS(
float & out_hue,
float & out_lightness,
float & out_saturation)
const;
4284 void ShowHSV(
float & out_hue,
float & out_saturation,
float & out_value)
const;
4285 void ShowHIC(
float & out_hue,
float & out_intensity,
float & out_chromaticity)
const;
4287 static RGBColor HLS(
float in_hue,
float in_lightness,
float in_saturation);
4288 static RGBColor HSV(
float in_hue,
float in_saturation,
float in_value);
4289 static RGBColor HIC(
float in_hue,
float in_intensity,
float in_chromaticity);
4292 HPS_INLINE
RGBColor const operator* (
float s,
RGBColor const & v) {
return RGBColor (s * v.red, s * v.green, s * v.blue); }
4293 HPS_INLINE RGBColor
const operator+ (
float s, RGBColor
const & v) {
return RGBColor (s + v.red, s + v.green, s + v.blue); }
4294 HPS_INLINE RGBColor
const operator- (
float s, RGBColor
const & v) {
return RGBColor (s - v.red, s - v.green, s - v.blue); }
4306 explicit HPS_INLINE
RGBAColor (
float gray,
float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4307 HPS_INLINE RGBAColor (
float r,
float g,
float b,
float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4309 HPS_INLINE RGBAColor (RGBColor
const & c) {
4310 memcpy(
this, &c,
sizeof(RGBColor));
4312 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4314 HPS_INLINE RGBAColor (RGBColor
const & c,
float a) {
4315 memcpy(
this, &c,
sizeof(RGBColor));
4316 memcpy(&alpha, &a,
sizeof(
float));
4317 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4319 explicit HPS_INLINE RGBAColor (RGBA32Color
const & c32);
4320 explicit HPS_INLINE RGBAColor (RGBAS32Color
const & c32);
4322 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4323 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4324 HPS_INLINE
bool IsValid()
const {
4325 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4342 HPS_INLINE
bool operator!= (
RGBAColor const & c)
const {
return !(*
this == c); }
4344 HPS_INLINE
bool Equals(
RGBAColor const & c,
int in_tolerance = 32)
const {
4349 HPS_INLINE RGBAColor & operator*= (RGBAColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha;
return *
this; }
4350 HPS_INLINE RGBAColor & operator+= (RGBAColor
const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha;
return *
this; }
4351 HPS_INLINE RGBAColor & operator-= (RGBAColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha;
return *
this; }
4352 HPS_INLINE RGBAColor
const operator* (RGBAColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4353 HPS_INLINE RGBAColor
const operator+ (RGBAColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4354 HPS_INLINE RGBAColor
const operator- (RGBAColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4356 HPS_INLINE RGBAColor & operator*= (
float s) { red *= s; green *= s; blue *= s; alpha *= s;
return *
this; }
4357 HPS_INLINE RGBAColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4358 HPS_INLINE RGBAColor & operator+= (
float s) { red += s; green += s; blue += s; alpha += s;
return *
this; }
4359 HPS_INLINE RGBAColor & operator-= (
float s) { red -= s; green -= s; blue -= s; alpha -= s;
return *
this; }
4360 HPS_INLINE RGBAColor
const operator* (
float s)
const {
return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4361 HPS_INLINE RGBAColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4362 HPS_INLINE RGBAColor
const operator+ (
float s)
const {
return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4363 HPS_INLINE RGBAColor
const operator- (
float s)
const {
return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4365 HPS_INLINE RGBAColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4366 HPS_INLINE RGBAColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4367 HPS_INLINE RGBAColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4368 HPS_INLINE RGBAColor
const operator* (RGBColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4369 HPS_INLINE RGBAColor
const operator+ (RGBColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4370 HPS_INLINE RGBAColor
const operator- (RGBColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4372 static HPS_INLINE RGBAColor Black() {
return RGBAColor (0, 0, 0, 1);};
4373 static HPS_INLINE RGBAColor White() {
return RGBAColor (1, 1, 1, 1);};
4374 static HPS_INLINE RGBAColor Nothing() {
return RGBAColor (0, 0, 0, 0);};
4375 static HPS_INLINE RGBAColor Invalid() {
return RGBAColor (-1, -1, -1, -1);};
4389 HPS_INLINE
static Order Preferred_Order () {
return Order_BGRA;}
4390 unsigned char b, g, r, a;
4394 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4395 unsigned char r, g, b, a;
4399 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4400 unsigned char r, g, b, a;
4410 explicit HPS_INLINE
RGBAS32Color (
unsigned char gray,
unsigned char aa = 255) {
4416 HPS_INLINE
RGBAS32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255) {
4424 explicit HPS_INLINE RGBAS32Color (
RGBColor 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);
4432 HPS_INLINE RGBAS32Color (
RGB24Color const & c);
4436 HPS_INLINE RGBAS32Color (
RGBColor const & c,
float alpha)
4438 r = Float::unit_to_byte(c.red);
4439 g = Float::unit_to_byte(c.green);
4440 b = Float::unit_to_byte(c.blue);
4441 a = Float::unit_to_byte(alpha);
4443 HPS_INLINE RGBAS32Color (
RGBColor const & c,
unsigned char aa)
4445 r = Float::unit_to_byte(c.red);
4446 g = Float::unit_to_byte(c.green);
4447 b = Float::unit_to_byte(c.blue);
4450 explicit HPS_INLINE RGBAS32Color (
RGBAColor const & c)
4452 r = Float::unit_to_byte(c.
red);
4453 g = Float::unit_to_byte(c.
green);
4454 b = Float::unit_to_byte(c.
blue);
4455 a = Float::unit_to_byte(c.
alpha);
4457 HPS_INLINE RGBAS32Color (
RGBAColor const & c,
unsigned char mix)
4459 r = Float::unit_to_byte(c.
red);
4460 g = Float::unit_to_byte(c.
green);
4461 b = Float::unit_to_byte(c.
blue);
4462 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4465 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4466 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4467 HPS_INLINE
bool IsValid()
const {
return ((r | g | b | a) != 0); }
4469 HPS_INLINE
bool operator== (RGBAS32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4470 HPS_INLINE
bool operator!= (RGBAS32Color
const & c)
const {
return !(*
this == c); }
4472 static HPS_INLINE RGBAS32Color Black() {
return RGBAS32Color (0, 0, 0, 255);};
4473 static HPS_INLINE RGBAS32Color White() {
return RGBAS32Color (255, 255, 255, 255);};
4474 static HPS_INLINE RGBAS32Color Invalid() {
return RGBAS32Color (0, 0, 0, 0);};
4476 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4487 explicit HPS_INLINE
RGBA32Color (
unsigned char gray,
unsigned char aa = 255)
4488 : r (gray), g (gray), b (gray), a (aa) {}
4489 HPS_INLINE RGBA32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255)
4490 : r (rr), g (gg), b (bb), a (aa) {}
4492 : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4493 explicit HPS_INLINE RGBA32Color (
RGBColor const & c) {
4494 r = Float::unit_to_byte(c.red);
4495 g = Float::unit_to_byte(c.green);
4496 b = Float::unit_to_byte(c.blue);
4499 HPS_INLINE RGBA32Color (
RGBColor const & c,
float alpha) {
4500 r = Float::unit_to_byte(c.red);
4501 g = Float::unit_to_byte(c.green);
4502 b = Float::unit_to_byte(c.blue);
4503 a = Float::unit_to_byte(alpha);
4505 HPS_INLINE RGBA32Color (
RGBColor const & c,
unsigned char aa) {
4506 r = Float::unit_to_byte(c.red);
4507 g = Float::unit_to_byte(c.green);
4508 b = Float::unit_to_byte(c.blue);
4511 explicit HPS_INLINE RGBA32Color (
RGBAColor const & c) {
4512 r = Float::unit_to_byte(c.
red);
4513 g = Float::unit_to_byte(c.
green);
4514 b = Float::unit_to_byte(c.
blue);
4515 a = Float::unit_to_byte(c.
alpha);
4517 HPS_INLINE RGBA32Color (
RGBAColor const & c,
unsigned char mix) {
4518 r = Float::unit_to_byte(c.
red);
4519 g = Float::unit_to_byte(c.
green);
4520 b = Float::unit_to_byte(c.
blue);
4521 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4524 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4525 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4527 HPS_INLINE
bool operator== (RGBA32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4528 HPS_INLINE
bool operator!= (RGBA32Color
const & c)
const {
return !(*
this == c); }
4530 static HPS_INLINE RGBA32Color Black() {
return RGBA32Color (0, 0, 0, 255);};
4531 static HPS_INLINE RGBA32Color White() {
return RGBA32Color (255, 255, 255, 255);};
4533 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4545 explicit HPS_INLINE
RGB24Color (
unsigned char gray)
4546 : r (gray), g (gray), b (gray) {}
4547 HPS_INLINE RGB24Color (
unsigned char rr,
unsigned char gg,
unsigned char bb)
4548 : r (rr), g (gg), b (bb) {}
4549 explicit HPS_INLINE RGB24Color (
RGBColor const & c) {
4550 r = Float::unit_to_byte(c.red);
4551 g = Float::unit_to_byte(c.green);
4552 b = Float::unit_to_byte(c.blue);
4555 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4556 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4558 HPS_INLINE
bool operator== (RGB24Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b); }
4559 HPS_INLINE
bool operator!= (RGB24Color
const & c)
const {
return !(*
this == c); }
4562 HPS_INLINE RGBColor::RGBColor (
RGBAS32Color const & c32) {
4563 red = Float::C2F(c32.r);
4564 green = Float::C2F(c32.g);
4565 blue = Float::C2F(c32.b);
4568 HPS_INLINE RGBColor::RGBColor (RGBA32Color
const & c32) {
4569 red = Float::C2F(c32.r);
4570 green = Float::C2F(c32.g);
4571 blue = Float::C2F(c32.b);
4574 HPS_INLINE RGBColor::RGBColor (RGBAColor
const & c) {
4580 HPS_INLINE RGBColor::RGBColor (RGB24Color
const & c24) {
4581 red = Float::C2F(c24.r);
4582 green = Float::C2F(c24.g);
4583 blue = Float::C2F(c24.b);
4586 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color
const & c)
4594 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color
const & c)
4602 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color
const & c32) {
4603 red = Float::C2F(c32.r);
4604 green = Float::C2F(c32.g);
4605 blue = Float::C2F(c32.b);
4606 alpha = Float::C2F(c32.a);
4609 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color
const & c32) {
4610 red = Float::C2F(c32.r);
4611 green = Float::C2F(c32.g);
4612 blue = Float::C2F(c32.b);
4613 alpha = Float::C2F(c32.a);
4616 HPS_INLINE RGBColor Modulate(RGBColor
const & a, RGBColor
const & b) {
4617 return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4622 HPS_INLINE RGBColor Interpolate(RGBColor
const & a, RGBColor
const & b,
float t) {
4623 return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4626 HPS_INLINE RGBAColor Interpolate(RGBAColor
const & a, RGBAColor
const & b,
float t) {
4627 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);
4630 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color
const & a, RGBAS32Color
const & b,
float t) {
4631 return RGBAS32Color(
4632 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4633 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4634 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4635 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4638 HPS_INLINE RGBA32Color Interpolate(RGBA32Color
const & a, RGBA32Color
const & b,
float t) {
4640 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4641 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4642 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4643 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4646 HPS_INLINE RGB24Color Interpolate(RGB24Color
const & a, RGB24Color
const & b,
float t) {
4648 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4649 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4650 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t));
4662 Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4664 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) { }
4682 return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4683 y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4684 z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4685 x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4688 Quaternion operator* (
float in_right)
const {
4689 return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4693 return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4696 Quaternion operator/ (
float in_right)
const {
4697 return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4701 return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4705 return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4708 inline float Norm()
const {
4709 return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4715 float mag_q = Norm();
4716 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4718 ret.w =
static_cast<float>(log(mag_q));
4721 float scale =
static_cast<float>(acos(w / mag_q) / mag_V);
4728 ret.x = ret.y = ret.z = 0;
4735 float ea =
static_cast<float>(exp(w));
4736 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4737 float scale = ea * sin(mag_V) / mag_V;
4739 ret.w = ea * cos(mag_V);
4748 Quaternion ret = *
this + in_fraction * (in_right - *
this);
4749 return ret.Normalize();
4753 Quaternion Slerp(
Quaternion const & in_right,
float in_fraction,
bool in_shortest_path_only =
true)
const {
4755 float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4757 if (in_shortest_path_only && dot < 0) {
4764 if (dot > -0.95f && dot < 0.95f) {
4765 float angle =
static_cast<float>(acos(dot));
4766 float sina =
static_cast<float>(sin(angle));
4767 float sinat =
static_cast<float>(sin(angle*in_fraction));
4768 float sinaomt =
static_cast<float>(sin(angle*(1-in_fraction)));
4770 return (*
this * sinaomt + q3 * sinat) / sina;
4773 return Lerp(q3, in_fraction);
4786 Quaternion q1 = Slerp(in_right , in_fraction,
false);
4787 Quaternion q2 = in_control1.Slerp(in_control2, in_fraction,
false);
4789 return q1.Slerp(q2, 2*in_fraction*(1-in_fraction),
false);
4801 return *
this *
Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4832 typedef unsigned char byte;
4833 typedef signed char sbyte;
4834 typedef intptr_t WindowHandle;
4835 typedef int64_t TouchID;
4836 typedef intptr_t PlatformData;
4837 typedef intptr_t OpaqueHandle;
4870 class AttributesControl;
4886 class GeometryInsertControl;
4983 class ShaderDefinition;
5031 class FontInfoControl;
5098 enum class Type : uint32_t
5101 GenericMask = 0xffffff00,
5105 EventDispatcher = 0x00000003,
5106 EventHandler = 0x00000004,
5107 EventNotifier = 0x00000005,
5108 UpdateNotifier = 0x00000006,
5109 SearchResults = 0x00000008,
5110 FontSearchResults = 0x00000009,
5111 SearchResultsIterator = 0x0100000a,
5112 FontSearchResultsIterator = 0x0100000b,
5113 SelectionResults = 0x0000000c,
5114 SelectionResultsIterator = 0x0100000d,
5115 SelectionItem = 0x0000000e,
5116 TreeContext = 0x0000000f,
5117 StreamToolkit = 0x00000010,
5118 DriverEventHandler = 0x00000011,
5120 IONotifier = 0x04000100,
5121 StreamImportNotifier = 0x04000101,
5122 STLImportNotifier = 0x04000102,
5123 OBJImportNotifier = 0x04000103,
5124 ExchangeImportNotifier = 0x04000104,
5125 SketchupImportNotifier = 0x04000105,
5126 ParasolidImportNotifier = 0x04000106,
5127 ExchangeTranslationNotifier = 0x04000107,
5128 ExchangeExportNotifier = 0x04000108,
5129 StreamExportNotifier = 0x04000109,
5130 ExchangeReloadNotifier = 0x0400010a,
5131 DWGImportNotifier = 0x0400010b,
5134 MarkerKit = 0x01000010,
5135 SphereAttributeKit = 0x01000011,
5136 TextAttributeKit = 0x01000012,
5137 TransparencyKit = 0x01000013,
5138 VisibilityKit = 0x01000014,
5139 VisualEffectsKit = 0x01000015,
5140 CuttingSectionAttributeKit = 0x01000016,
5141 CircleKit = 0x01000017,
5142 CircularArcKit = 0x01000018,
5143 CircularWedgeKit = 0x01000019,
5144 CuttingSectionKit = 0x0100001a,
5145 CylinderKit = 0x0100001b,
5146 DistantLightKit = 0x0100001c,
5147 EllipseKit = 0x0100001d,
5148 EllipticalArcKit = 0x0100001e,
5149 InfiniteLineKit = 0x0100001f,
5150 LineKit = 0x01000020,
5151 NURBSCurveKit = 0x01000021,
5152 MeshKit = 0x01000022,
5153 NURBSSurfaceKit = 0x01000023,
5154 PolygonKit = 0x01000024,
5155 SphereKit = 0x01000025,
5156 SpotlightKit = 0x01000026,
5157 ShellKit = 0x01000027,
5158 TextKit = 0x01000028,
5159 MaterialKit = 0x01000029,
5160 TrimKit = 0x0100002a,
5161 TextureOptionsKit = 0x0100002c,
5162 LinePatternKit = 0x0100002d,
5163 GlyphKit = 0x0100002e,
5164 ImageKit = 0x0100002f,
5165 LinePatternOptionsKit = 0x01000030,
5166 CameraKit = 0x01000031,
5167 BoundingKit = 0x01000032,
5168 CullingKit = 0x01000033,
5169 CurveAttributeKit = 0x01000034,
5170 CylinderAttributeKit = 0x01000035,
5171 EdgeAttributeKit = 0x01000036,
5172 LightingAttributeKit = 0x01000037,
5173 LineAttributeKit = 0x01000038,
5174 MarkerAttributeKit = 0x01000039,
5175 MaterialMappingKit = 0x0100003a,
5176 MatrixKit = 0x0100003b,
5177 NURBSSurfaceAttributeKit = 0x0100003c,
5178 PostProcessEffectsKit = 0x0100003d,
5179 SelectabilityKit = 0x0100003e,
5180 SelectionOptionsKit = 0x0100003f,
5181 StandAloneWindowOptionsKit = 0x01000040,
5182 OffScreenWindowOptionsKit = 0x01000041,
5183 ApplicationWindowOptionsKit = 0x01000042,
5184 HighlightOptionsKit = 0x01000043,
5185 LinePatternParallelKit = 0x01000044,
5186 SubwindowKit = 0x01000045,
5187 PerformanceKit = 0x01000046,
5188 HiddenLineAttributeKit = 0x01000047,
5189 DrawingAttributeKit = 0x01000048,
5190 ShaderKit = 0x01000049,
5191 DebuggingKit = 0x0100004a,
5192 ContourLineKit = 0x0100004b,
5193 StreamImportOptionsKit = 0x0100004c,
5194 StreamImportResultsKit = 0x0100004d,
5195 StreamExportOptionsKit = 0x0100004e,
5196 StreamExportResultsKit = 0x0100004f,
5197 WindowInfoKit = 0x01000050,
5198 ImageImportOptionsKit = 0x01000051,
5199 SearchOptionsKit = 0x01000052,
5200 ShaderImportOptionsKit = 0x01000053,
5201 HardcopyExportOptionsKit = 0x01000055,
5202 AttributeLockKit = 0x01000056,
5203 TransformMaskKit = 0x01000057,
5204 ColorInterpolationKit = 0x01000058,
5205 UpdateOptionsKit = 0x01000059,
5206 ImageExportOptionsKit = 0x0100005a,
5207 OBJImportOptionsKit = 0x0100005b,
5208 OBJImportResultsKit = 0x0100005c,
5209 STLImportOptionsKit = 0x0100005d,
5210 STLImportResultsKit = 0x0100005e,
5211 ShellOptimizationOptionsKit = 0x0100005f,
5212 ShellRelationOptionsKit = 0x01000060,
5213 ShellRelationResultsKit = 0x01000061,
5214 GridKit = 0x01000062,
5215 CutGeometryGatheringOptionsKit = 0x01000063,
5216 SegmentOptimizationOptionsKit = 0x01000064,
5219 LinePatternElement = 0x03000000,
5220 SolidLinePatternElement = 0x03000001,
5221 BlankLinePatternElement = 0x03000002,
5222 GlyphLinePatternElement = 0x03000003,
5224 GlyphElement = 0x05000000,
5225 DotGlyphElement = 0x05000001,
5226 LineGlyphElement = 0x05000002,
5227 EllipseGlyphElement = 0x05000003,
5228 CircularArcGlyphElement = 0x05000004,
5229 InfiniteLineGlyphElement = 0x05000005,
5230 SphereGlyphElement = 0x05000006,
5232 TrimElement = 0x07000000,
5234 Condition = 0x09000000,
5235 NOTCondition = 0x09000001,
5236 ANDCondition = 0x09000002,
5237 ORCondition = 0x09000003,
5238 XORCondition = 0x09000004,
5239 EQCondition = 0x09000005,
5240 NEQCondition = 0x09000006,
5241 GTCondition = 0x09000007,
5242 LTCondition = 0x09000008,
5243 GTEQCondition = 0x09000009,
5244 LTEQCondition = 0x0900000A,
5246 MouseState = 0x01001001,
5247 TouchState = 0x01001002,
5248 KeyboardState = 0x01001003,
5249 FontInfoState = 0x01001004,
5251 KeyPath = 0x01000F01,
5254 IncludeKey = 0x10000001,
5255 PortfolioKey = 0x10000002,
5256 StyleKey = 0x10000003,
5258 SegmentKey = 0x10200000,
5259 WindowKey = 0x10600000,
5260 StandAloneWindowKey = 0x10600001,
5261 OffScreenWindowKey = 0x10600002,
5262 ApplicationWindowKey = 0x10600003,
5264 GeometryKey = 0x10100000,
5265 ReferenceKey = 0x10100001,
5266 CircleKey = 0x10100002,
5267 CircularArcKey = 0x10100003,
5268 CircularWedgeKey = 0x10100004,
5269 CuttingSectionKey = 0x10100005,
5270 CylinderKey = 0x10100006,
5271 EllipseKey = 0x10100007,
5272 EllipticalArcKey = 0x10100008,
5273 InfiniteLineKey = 0x10100009,
5274 LineKey = 0x1010000a,
5275 DistantLightKey = 0x1010000b,
5276 SpotlightKey = 0x1010000c,
5277 MarkerKey = 0x1010000d,
5278 MeshKey = 0x1010000e,
5279 NURBSCurveKey = 0x1010000f,
5280 NURBSSurfaceKey = 0x10100010,
5281 PolygonKey = 0x10100011,
5282 ShellKey = 0x10100012,
5283 SphereKey = 0x10100013,
5284 TextKey = 0x10100014,
5285 GridKey = 0x10100015,
5287 Definition = 0x20000000,
5288 NamedStyleDefinition = 0x20000001,
5289 TextureDefinition = 0x20000002,
5290 LinePatternDefinition = 0x20000003,
5291 GlyphDefinition = 0x20000004,
5292 CubeMapDefinition = 0x20000005,
5293 ImageDefinition = 0x20000006,
5294 MaterialPaletteDefinition = 0x20000007,
5295 ShaderDefinition = 0x20000008,
5297 Control = 0x50000000,
5298 CameraControl = 0x50000001,
5299 SelectabilityControl = 0x50000002,
5300 MarkerAttributeControl = 0x50000003,
5301 SphereAttributeControl = 0x50000004,
5302 LightingAttributeControl = 0x50000005,
5303 CylinderAttributeControl = 0x50000006,
5304 TextAttributeControl = 0x50000007,
5305 LineAttributeControl = 0x50000008,
5306 EdgeAttributeControl = 0x50000009,
5307 CurveAttributeControl = 0x5000000a,
5308 ModellingMatrixControl = 0x5000000b,
5309 TextureMatrixControl = 0x5000000c,
5310 CullingControl = 0x5000000d,
5311 TransparencyControl = 0x5000000e,
5312 MaterialMappingControl = 0x5000000f,
5313 NURBSSurfaceAttributeControl = 0x50000010,
5314 PostProcessEffectsControl = 0x50000011,
5315 BoundingControl = 0x50000012,
5316 VisualEffectsControl = 0x50000013,
5317 SelectionOptionsControl = 0x50000014,
5318 HighlightOptionsControl = 0x50000015,
5319 DefinitionControl = 0x50000016,
5320 SelectionControl = 0x50000017,
5321 HighlightControl = 0x50000018,
5322 StandAloneWindowOptionsControl = 0x50000019,
5323 OffScreenWindowOptionsControl = 0x5000001a,
5324 ApplicationWindowOptionsControl = 0x5000001b,
5325 VisibilityControl = 0x5000001c,
5326 SubwindowControl = 0x5000001d,
5327 PerformanceControl = 0x5000001e,
5328 HiddenLineAttributeControl = 0x5000001f,
5329 DrawingAttributeControl = 0x50000020,
5330 DebuggingControl = 0x50000021,
5331 ContourLineControl = 0x50000022,
5332 StyleControl = 0x50000023,
5333 ConditionControl = 0x50000024,
5334 PortfolioControl = 0x50000025,
5335 WindowInfoControl = 0x50000026,
5336 AttributeLockControl = 0x50000027,
5337 TransformMaskControl = 0x50000028,
5338 ColorInterpolationControl = 0x50000029,
5339 UpdateOptionsControl = 0x50000030,
5340 CuttingSectionAttributeControl = 0x50000031,
5342 LibraryMask = 0x80FF0000,
5344 Sprocket = 0x80000000,
5345 Canvas = 0x80000001,
5346 Layout = 0x80000002,
5349 Operator = 0x80000005,
5350 SprocketPath = 0x80000007,
5352 SprocketControl = 0xD0000000,
5353 OperatorControl = 0xD0000008,
5354 NavigationCubeControl = 0xD0000009,
5355 AxisTriadControl = 0xD000000A,
5357 Metadata = 0x80001000,
5358 IntegerMetadata = 0x80001001,
5359 UnsignedIntegerMetadata = 0x80001002,
5360 DoubleMetadata = 0x80001003,
5361 StringMetadata = 0x80001004,
5362 TimeMetadata = 0x80001005,
5363 BooleanMetadata = 0x80001006,
5365 Component = 0x80000200,
5366 Filter = 0x80000600,
5367 Capture = 0x80000a00,
5368 CADModel = 0x80000300,
5369 ComponentPath = 0x81001000,
5371 ExchangeMask = 0x80020000,
5372 ExchangeComponent = 0x80021200,
5373 ExchangeSheet = 0x80021201,
5374 ExchangeProductOccurrence = 0x80021202,
5375 ExchangeFilter = 0x80020601,
5376 ExchangeCapture = 0x80020a01,
5377 ExchangeCADModel = 0x80020301,
5378 ExchangeConfiguration = 0x81020001,
5379 ExchangeImportOptionsKit = 0x81020002,
5380 ExchangeExportACISOptionsKit = 0x81020003,
5381 ExchangeExportIGESOptionsKit = 0x81020004,
5382 ExchangeExportJTOptionsKit = 0x81020005,
5383 ExchangeExportParasolidOptionsKit = 0x81020006,
5384 ExchangeExportPRCOptionsKit = 0x81020007,
5385 ExchangeExportSTEPOptionsKit = 0x81020008,
5386 ExchangeExportSTLOptionsKit = 0x81020009,
5387 ExchangeExportU3DOptionsKit = 0x8102000a,
5388 ExchangeExportXMLOptionsKit = 0x8102000b,
5389 ExchangeTessellationOptionsKit = 0x8102000c,
5390 ExchangeModelFileImportOptionsKit = 0x8102000d,
5391 ExchangeTranslationOptionsKit = 0x8102000e,
5393 PublishMask = 0x80040000,
5394 PublishDocumentKit = 0x81040001,
5395 PublishPageKit = 0x81040002,
5396 PublishTemplateKit = 0x81040003,
5397 PublishAnnotationKit = 0x81040004,
5398 PublishArtworkKit = 0x81040005,
5399 PublishViewKit = 0x81040006,
5400 PublishTextKit = 0x81040007,
5401 PublishImageKit = 0x81040008,
5402 PublishTableKit = 0x81040009,
5403 PublishExportOptionsKit = 0x8104000a,
5404 PublishLinkKit = 0x8104000b,
5405 PublishButtonKit = 0x8104000c,
5406 PublishTextFieldKit = 0x8104000d,
5407 PublishSlideTableKit = 0x8104000e,
5408 PublishCheckBoxKit = 0x8104000f,
5409 PublishRadioButtonKit = 0x81040010,
5410 PublishListBoxKit = 0x81040011,
5411 PublishDropDownListKit = 0x81040012,
5412 PublishSignatureFieldKit = 0x81040013,
5414 PublishDocumentKey = 0x80040001,
5415 PublishPageControl = 0x80040002,
5417 SceneTree = 0x80008001,
5418 SceneTreeItem = 0x80008002,
5420 ComponentTree = 0x80008003,
5421 ComponentTreeItem = 0x80008004,
5423 SketchupMask = 0x80100000,
5424 SketchupImportOptionsKit = 0x81100001,
5425 SketchupImportResultsKit = 0x81100002,
5427 ParasolidMask = 0x80200000,
5428 ParasolidComponent = 0x80201201,
5429 ParasolidCADModel = 0x80200302,
5430 ParasolidImportOptionsKit = 0x81200003,
5431 ParasolidFacetTessellationKit = 0x81200004,
5432 ParasolidLineTessellationKit = 0x81200005,
5433 ParasolidExportOptionsKit = 0x81200006,
5435 DWGMask = 0x80400000,
5436 DWGComponent = 0x80401201,
5437 DWGLayer = 0x80401202,
5438 DWGLayout = 0x80400a03,
5439 DWGCADModel = 0x80400304,
5440 DWGImportOptionsKit = 0x81400005,
5442 IONotifierData = 0x84000200,
5443 StreamImportNotifierData = 0x84000201,
5444 STLImportNotifierData = 0x84000202,
5445 OBJImportNotifierData = 0x84000203,
5446 ExchangeImportNotifierData = 0x84020204,
5447 SketchupImportNotifierData = 0x84100205,
5448 ParasolidImportNotifierData = 0x84200206,
5449 ExchangeTranslationNotifierData = 0x84020207,
5450 ExchangeExportNotifierData = 0x84020208,
5451 StreamExportNotifierData = 0x84000209,
5452 DWGImportNotifierData = 0x8440020a,
5464 static void * Allocate(
size_t in_bytes,
bool in_clear_memory =
true);
5471 static void Free(
void * in_pointer);
5480 template <
typename T>
5481 class NO_HPS_API Allocator
5484 typedef T value_type;
5485 typedef value_type * pointer;
5486 typedef value_type
const * const_pointer;
5487 typedef value_type & reference;
5488 typedef value_type
const & const_reference;
5489 typedef size_t size_type;
5490 typedef ptrdiff_t difference_type;
5494 Allocator(Allocator<T>
const & in_that) { HPS_UNREFERENCED(in_that); }
5497 template <
typename U> Allocator(Allocator<U>
const &) {}
5499 template <
typename U>
5502 typedef Allocator<U> other;
5506 pointer address(reference x)
const {
return &x; }
5507 const_pointer address(const_reference x)
const {
return &x; }
5509 pointer allocate(size_type n,
void * v = 0) { HPS_UNREFERENCED(v);
return static_cast<pointer
>(
Memory::Allocate(n *
sizeof(T))); }
5510 void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n);
Memory::Free(p); }
5512 #if defined(_MSC_VER) || defined (__APPLE__)
5513 void construct(pointer p, const_reference x) {
new(p) T(x); }
5514 void construct(pointer p, value_type && x) {
new(p) T(std::move(x)); }
5516 template<
typename U,
typename... Args>
5517 void construct(U * p, Args&&... args) {
new(p) U(std::forward<Args>(args)...); }
5519 void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5521 size_type max_size()
const {
return static_cast<size_type
>(-1) /
sizeof(T); }
5524 template <
typename T,
typename U>
5525 bool operator==(
const Allocator<T> &,
const Allocator<U> &) {
return true; }
5527 template <
typename T,
typename U>
5528 bool operator!=(
const Allocator<T> &,
const Allocator<U> &) {
return false; }
5534 Exception(
char const * in_info) : std::runtime_error(in_info) { }
5542 InvalidObjectException(
char const * in_info =
"Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5552 IndexOutOfRangeException(
char const * in_info =
"Attempted to access an element outside the bounds of the array.") :
5624 HPS::Type Type()
const;
5633 virtual bool Empty()
const {
return (impl_ == 0);};
5636 virtual void Reset();
5641 bool HasType(HPS::Type in_mask)
const;
5645 intptr_t GetClassID()
const;
5650 intptr_t GetInstanceID()
const;
5654 template <
typename T>
5657 static const intptr_t ret = T().GetClassID();
5662 friend class HPSI::Impl;
5663 friend class HPSI::KeyImpl;
5664 friend class HPSI::TicketImpl;
5673 HPS::Type ObjectType()
const {
return HPS::Type::Control;}
5677 #if !defined(_MSC_VER) || _MSC_VER >= 1900
5694 this->Object::operator=(std::move(in_that));
6163 Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6168 intptr_t GetClassID()
const;
6172 virtual Event * Clone()
const=0;
6175 virtual bool Drop(
Event const * in_that_event)
const { HPS_UNREFERENCED(in_that_event);
return false; }
6190 static void *
operator new (
size_t in_size) {
return Memory::Allocate(in_size); }
6191 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
6198 friend class HPSI::EventDispatcherImpl;
6248 enum class KeyboardCode
6448 : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6455 return (ID == in_that.
ID && Location == in_that.
Location && TapCount == in_that.
TapCount);
6463 return !(*
this == in_that);
6472 typedef std::vector<Point, Allocator<Point> > PointArray;
6473 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6474 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6475 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6476 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6477 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6478 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6479 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6480 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6481 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6482 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6483 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6484 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6485 typedef std::vector<int, Allocator<int> > IntArray;
6486 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6487 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6488 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6489 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6490 typedef std::vector<float, Allocator<float> > FloatArray;
6491 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6492 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6493 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6494 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6495 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6496 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6497 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6498 typedef std::vector<bool, Allocator<bool> > BoolArray;
6499 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6500 typedef std::vector<Key, Allocator<Key> > KeyArray;
6501 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6502 typedef std::vector<char, Allocator<char> > CharArray;
6503 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6504 typedef std::vector<byte, Allocator<byte> > ByteArray;
6505 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6506 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6507 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6508 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6509 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6510 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6511 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6512 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6513 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6514 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6515 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6516 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6517 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6518 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6519 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6520 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6521 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6522 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6523 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6524 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6525 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6526 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6527 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6528 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6529 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6530 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6531 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6532 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6533 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6534 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6535 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6536 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6564 HPS::Type
ObjectType()
const {
return HPS::Type::SearchResultsIterator;}
6600 bool IsValid()
const;
6608 Key GetItem()
const;
6612 Key operator*()
const;
6616 SearchTypeArray GetResultTypes()
const;
6641 virtual void Reset();
6660 size_t GetCount()
const;
6699 HPS::Type
ObjectType()
const {
return HPS::Type::FontSearchResultsIterator;}
6730 bool IsValid()
const;
6769 virtual void Reset();
6774 HPS::Type
ObjectType()
const {
return HPS::Type::FontSearchResults;}
6789 size_t GetCount()
const;
6813 UTF8(
char const * in_string,
char const * in_locale = 0);
6817 UTF8(
wchar_t const * in_string);
6836 return Assign(std::move(in_utf8));
6843 size_t ToWStr(
wchar_t * out_wide_string)
const;
6848 size_t ToWStr(WCharArray & out_wide_string)
const;
6854 return (_length > 0);
6861 return (_length == 0);
6895 inline operator char const * ()
const
6902 char At(
size_t in_index)
const
6906 else if(in_index >= _length)
6909 return _text[in_index];
6915 UTF8 & Assign(
UTF8 const & in_utf8);
6922 return Assign(in_utf8);
6928 UTF8 & operator+= (
UTF8 const & in_utf8);
6933 UTF8 & operator+= (
char const * in_utf8);
6938 UTF8 operator+ (
UTF8 const & in_utf8)
const;
6943 UTF8 operator+ (
char const * in_utf8)
const;
6948 bool operator== (
UTF8 const & in_utf8)
const;
6953 bool operator!= (
UTF8 const & in_utf8)
const
6955 return !(*
this == in_utf8);
6961 bool operator== (
char const * in_utf8)
const;
6966 bool operator!= (
char const * in_utf8)
const
6968 return !(*
this == in_utf8);
6977 return in_right == in_left;
6986 return in_right != in_left;
6995 return in_right ==
UTF8(in_left);
7004 return in_right !=
UTF8(in_left);
7011 friend inline UTF8 operator+ (
char const * in_left,
UTF8 const & in_right)
7013 return UTF8(in_left) + in_right;
7020 friend inline UTF8 operator+ (
wchar_t const * in_left,
UTF8 const & in_right)
7022 return UTF8(in_left) + in_right;
7028 size_t GetHash()
const;
7032 size_t internal_encode(
wchar_t const * in_wide_string);
7033 size_t internal_decode(
wchar_t * out_wide_string)
const;
7037 mutable size_t _hash_key;
7038 static const size_t _buffer_size = 64 -
sizeof(
const char *) - 2 *
sizeof(
size_t);
7039 char _buffer[_buffer_size];
7044 inline size_t operator()(
const HPS::UTF8 & in_utf8)
const
7056 enum class Intrinsic
7075 Condition(HPS::Condition::Intrinsic in_special);
7096 bool ShowCondition(
UTF8 & out_condition)
const;
7101 bool ShowNumber(
float & out_number)
const;
7106 bool ShowIntrinsic(Condition::Intrinsic & out_special)
const;
7111 bool ShowOperands(ConditionArray & out_operands)
const;
7121 bool Equals(
Condition const & in_that)
const;
7126 bool operator==(
Condition const & in_that)
const;
7131 bool operator!=(
Condition const & in_that)
const;
7136 bool IsSatisfiedBy(UTF8Array
const & in_conditions)
const;
7141 bool IsSatisfiedBy(
char const * in_condition)
const;
7285 HPS_API Condition NOT(Condition
const & in_operand);
7291 HPS_API Condition OR(Condition
const & in_operand1, Condition
const & in_operand2);
7297 HPS_API Condition XOR(Condition
const & in_operand1, Condition
const & in_operand2);
7303 HPS_API Condition AND(Condition
const & in_operand1, Condition
const & in_operand2);
7309 HPS_API Condition EQ(Condition
const & in_operand1, Condition
const & in_operand2);
7315 HPS_API Condition NEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7321 HPS_API Condition GT(Condition
const & in_operand1, Condition
const & in_operand2);
7327 HPS_API Condition LT(Condition
const & in_operand1, Condition
const & in_operand2);
7333 HPS_API Condition GTEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7339 HPS_API Condition LTEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7354 Key(
Key const & in_that);
7367 Key & operator=(
Key && in_that);
7375 bool HasOwner()
const;
7387 void MoveTo(
SegmentKey const & in_new_owner);
7396 Key & operator=(
Key const & in_that);
7400 virtual void Assign(
Key const & in_that);
7403 bool Equals(
Key const & in_that)
const;
7406 bool operator!= (
Key const & in_that)
const;
7409 bool operator== (
Key const & in_that)
const;
7413 size_t GetHash()
const;
7418 inline size_t operator()(
const HPS::Key & in_key)
const
7466 SegmentKey Down(
char const * in_segment_name,
bool in_create_if_not_present =
false)
const;
7470 SegmentKey Subsegment(
char const * in_segment_name =
"",
bool in_create_if_not_present =
true)
const;
7528 size_t ShowSubsegments()
const;
7531 size_t ShowSubsegments(SegmentKeyArray & out_children)
const;
7536 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
7541 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
7546 size_t ShowStylers(SegmentKeyArray & out_segments)
const;
7551 size_t ShowStylers(StyleKeyArray & out_styles)
const;
7556 size_t ShowIncluders(SegmentKeyArray & out_segments)
const;
7561 size_t ShowIncluders(IncludeKeyArray & out_includes)
const;
7580 SegmentKey & SetCondition(
char const * in_condition);
7583 SegmentKey & SetConditions(UTF8Array
const & in_conditions);
7586 SegmentKey & SetConditions(
size_t in_count,
UTF8 const in_conditions []);
7592 bool ShowConditions(UTF8Array & out_conditions)
const;
7602 SegmentKey & SetMaterialPalette(
char const * in_name);
7608 bool ShowMaterialPalette(
UTF8 & out_name)
const;
7626 bool ShowPriority(
int & out_priority)
const;
7632 SegmentKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
7639 SegmentKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
7645 SegmentKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
7650 SegmentKey & UnsetUserData(intptr_t in_index);
7656 SegmentKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
7661 SegmentKey & UnsetUserData(HPS::IntPtrTArray
const & in_indices);
7668 size_t ShowUserDataCount()
const;
7674 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
7679 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
7685 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
7692 LineKey InsertLine(
size_t in_count,
Point const in_pts[]);
7695 LineKey InsertLine(PointArray
const & in_pts);
7771 PolygonKey InsertPolygon(PointArray
const & in_points);
7781 ShellKey InsertShell(PointArray
const & in_points, IntArray
const & in_facelist);
7784 ShellKey InsertShell(
size_t in_point_count,
Point const in_points [],
size_t in_facelist_count,
int const in_facelist []);
7787 ShellKey InsertShellByTristrips(PointArray
const & in_points, IntArray
const & in_tristrips);
7790 ShellKey InsertShellByTristrips(
size_t in_point_count,
Point const in_points [],
size_t in_tristrips_count,
int const in_tristrips []);
7796 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
7799 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns,
size_t in_point_count,
Point const in_points []);
7847 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);
7850 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);
7857 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);
7860 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[]);
7863 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);
7866 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[]);
7877 TextKey InsertText(
Point const & in_position,
char const * in_text);
7896 LineKey InsertLineFromGeometry(
CircleKey const & in_circle,
float in_deviation = -1.0f);
7923 LineKey InsertLineFromGeometry(
EllipseKey const & in_ellipse,
float in_deviation = -1.0f);
7941 LineKey InsertLineFromGeometry(
NURBSCurveKey const & in_nurbs_curve,
float in_deviation = -1.0f);
8023 bool ShowCamera(
CameraKit & out_kit)
const;
8072 bool ShowCulling(
CullingKit & out_kit)
const;
8101 SegmentKey & UnsetCuttingSectionAttributes();
8248 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
8368 bool ShowTextureMatrix(
MatrixKit & out_kit)
const;
8469 HPS::Type
ObjectType()
const {
return HPS::Type::SegmentOptimizationOptionsKit; }
8580 bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data)
const;
8582 bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix)
const;
8584 bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion)
const;
8586 bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope)
const;
8588 bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization)
const;
8590 bool ShowShellInstancing(
bool & out_shell_instancing)
const;
8592 bool ShowShellMerging(
bool & out_shell_merging)
const;
8594 bool ShowAttributeDelocalization(
bool & out_attribute_delocalization)
const;
8648 HPS::Type
ObjectType()
const {
return HPS::Type::UpdateNotifier;};
8674 intptr_t GetClassID()
const;
8709 void DrawTexturedBackground(OpaqueHandle in_texture,
MatrixKit const & in_matrix,
Rectangle const & in_extent)
const;
8713 mutable HPS::FloatArray matrix_elements;
8721 HPS::Type
ObjectType() const OVERRIDE {
return HPS::Type::DriverEventHandler; };
8734 HPS_UNREFERENCED(in_event);
8807 WindowKey & UnsetDriverEventHandler(intptr_t in_type);
8914 bool ShowSnapshot(
ImageKit & out_kit)
const;
8925 SegmentKey & UnsetCuttingSectionAttributes();
8948 void MoveTo(
SegmentKey const & in_new_owner);
8967 KeyPath(KeyArray
const & in_path);
8972 KeyPath(
size_t in_path_count,
Key const in_path []);
9005 KeyPath & operator+=(KeyArray
const & in_key_array);
9020 KeyPath & Append(KeyArray
const & in_key_array);
9030 KeyPath & operator=(KeyArray
const & in_path);
9034 void Set(
KeyPath const & in_that);
9039 bool Equals(
KeyPath const & in_that)
const;
9044 bool operator!= (
KeyPath const & in_that)
const;
9049 bool operator== (
KeyPath const & in_that)
const;
9055 KeyPath & SetKeys(KeyArray
const & in_keys);
9061 KeyPath & SetKeys(
size_t in_key_count,
Key const in_keys []);
9071 bool ShowKeys(KeyArray & out_keys)
const;
9095 bool ComputeTextExtent(
char const * in_text,
float & out_xfrac,
float & out_yfrac)
const;
9112 bool ShowNetBounding(
BoundingKit & out_kit)
const;
9116 bool ShowNetCamera(
CameraKit & out_kit)
const;
9180 bool ShowNetModellingMatrix(
MatrixKit & out_kit)
const;
9184 bool ShowNetTextureMatrix(
MatrixKit & out_kit)
const;
9188 bool ShowNetCulling(
CullingKit & out_kit)
const;
9220 bool ShowNetConditions(UTF8Array & out_conditions)
const;
9231 bool ShowNetMaterialPalette(
UTF8 & out_name)
const;
9243 bool ShowEffectiveGlyphDefinition(
char const * in_name,
GlyphDefinition & out_def)
const;
9249 bool ShowEffectiveLinePatternDefinition(
char const * in_name,
LinePatternDefinition & out_def)
const;
9255 bool ShowEffectiveShaderDefinition(
char const * in_name, ShaderDefinition & out_def)
const;
9261 bool ShowEffectiveTextureDefinition(
char const * in_name,
TextureDefinition & out_def)
const;
9267 bool ShowEffectiveImageDefinition(
char const * in_name,
ImageDefinition & out_def)
const;
9275 inline KeyPath operator+(Key
const & in_lhs, Key
const & in_rhs)
9284 inline KeyPath operator+(Key
const & in_lhs, KeyArray
const & in_rhs)
9293 inline KeyPath operator+(Key
const & in_lhs, KeyPath
const & in_rhs)
9302 inline KeyPath operator+(KeyArray
const & in_lhs, Key
const & in_rhs)
9311 inline KeyPath operator+(KeyArray
const & in_lhs, KeyArray
const & in_rhs)
9320 inline KeyPath operator+(KeyArray
const & in_lhs, KeyPath
const & in_rhs)
9329 inline KeyPath operator+(KeyPath
const & in_lhs, Key
const & in_rhs)
9338 inline KeyPath operator+(KeyPath
const & in_lhs, KeyArray
const & in_rhs)
9347 inline KeyPath operator+(KeyPath
const & in_lhs, KeyPath
const & in_rhs)
9414 bool operator==(
BoundingKit const & in_kit)
const;
9419 bool operator!=(
BoundingKit const & in_kit)
const;
9460 bool ShowExclusion(
bool & out_exclusion)
const;
9490 HPS::Type
ObjectType()
const {
return HPS::Type::BoundingControl;};
9541 bool ShowExclusion(
bool & out_exclusion)
const;
9876 bool ShowCuttingSections(
bool & out_state)
const;
9881 bool ShowCutEdges(
bool & out_state)
const;
9886 bool ShowCutFaces(
bool & out_state)
const;
9891 bool ShowWindows(
bool & out_state)
const;
9896 bool ShowText(
bool & out_state)
const;
9901 bool ShowLines(
bool & out_state)
const;
9906 bool ShowEdgeLights(
bool & out_state)
const;
9911 bool ShowMarkerLights(
bool & out_state)
const;
9916 bool ShowFaceLights(
bool & out_state)
const;
9921 bool ShowGenericEdges(
bool & out_state)
const;
9926 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
9931 bool ShowAdjacentEdges(
bool & out_state)
const;
9936 bool ShowHardEdges(
bool & out_state)
const;
9941 bool ShowMeshQuadEdges(
bool & out_state)
const;
9946 bool ShowNonCulledEdges(
bool & out_state)
const;
9951 bool ShowPerimeterEdges(
bool & out_state)
const;
9956 bool ShowFaces(
bool & out_state)
const;
9961 bool ShowVertices(
bool & out_state)
const;
9966 bool ShowMarkers(
bool & out_state)
const;
9971 bool ShowShadowCasting(
bool & out_state)
const;
9976 bool ShowShadowReceiving(
bool & out_state)
const;
9981 bool ShowShadowEmitting(
bool & out_state)
const;
10279 bool ShowCuttingSections(
bool & out_state)
const;
10284 bool ShowCutEdges(
bool & out_state)
const;
10289 bool ShowCutFaces(
bool & out_state)
const;
10294 bool ShowWindows(
bool & out_state)
const;
10299 bool ShowText(
bool & out_state)
const;
10304 bool ShowLines(
bool & out_state)
const;
10309 bool ShowEdgeLights(
bool & out_state)
const;
10314 bool ShowMarkerLights(
bool & out_state)
const;
10319 bool ShowFaceLights(
bool & out_state)
const;
10324 bool ShowGenericEdges(
bool & out_state)
const;
10329 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
10334 bool ShowAdjacentEdges(
bool & out_state)
const;
10339 bool ShowHardEdges(
bool & out_state)
const;
10344 bool ShowMeshQuadEdges(
bool & out_state)
const;
10349 bool ShowNonCulledEdges(
bool & out_state)
const;
10354 bool ShowPerimeterEdges(
bool & out_state)
const;
10359 bool ShowFaces(
bool & out_state)
const;
10364 bool ShowVertices(
bool & out_state)
const;
10369 bool ShowMarkers(
bool & out_state)
const;
10374 bool ShowShadowCasting(
bool & out_state)
const;
10379 bool ShowShadowReceiving(
bool & out_state)
const;
10384 bool ShowShadowEmitting(
bool & out_state)
const;
10441 bool Empty()
const;
10446 bool Equals(
CameraKit const & in_kit)
const;
10451 bool operator==(
CameraKit const & in_kit)
const;
10456 bool operator!=(
CameraKit const & in_kit)
const;
10486 CameraKit & SetField(
float in_width,
float in_height);
10497 CameraKit & SetNearLimit(
float const in_limit);
10531 bool ShowUpVector(
Vector & out_up_vector)
const;
10536 bool ShowPosition(
Point & out_position)
const;
10541 bool ShowTarget(
Point & out_target)
const;
10553 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_y_skew,
float & out_oblique_x_skew)
const;
10558 bool ShowWidth(
float & out_width)
const;
10563 bool ShowHeight(
float & out_height)
const;
10569 bool ShowField(
float & out_width,
float & out_height)
const;
10574 bool ShowNearLimit(
float & out_near_limit)
const;
10582 CameraKit & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10590 CameraKit & Orbit(
float in_theta,
float in_phi);
10598 CameraKit & Pan(
float in_theta,
float in_phi);
10701 bool ShowUpVector(
Vector & out_up_vector)
const;
10706 bool ShowPosition(
Point & out_position)
const;
10711 bool ShowTarget(
Point & out_target)
const;
10723 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_x_skew,
float & out_oblique_y_skew)
const;
10728 bool ShowWidth(
float & out_width)
const;
10733 bool ShowHeight(
float & out_height)
const;
10739 bool ShowField(
float & out_width,
float & out_height)
const;
10744 bool ShowNearLimit(
float & out_width)
const;
10752 CameraControl & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10838 bool Empty()
const;
11017 HPS::Type
ObjectType()
const {
return HPS::Type::SelectabilityControl;};
11209 bool Empty()
const;
11295 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
11306 bool ShowDepthWriting(
bool & out_state)
const;
11337 HPS::Type
ObjectType()
const {
return HPS::Type::TransparencyControl;};
11412 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
11423 bool ShowDepthWriting(
bool & out_state)
const;
11454 HPS::Type
ObjectType()
const {
return HPS::Type::ColorInterpolationKit;};
11468 bool Empty()
const;
11543 bool ShowFaceColor(
bool & out_state)
const;
11548 bool ShowEdgeColor(
bool & out_state)
const;
11553 bool ShowVertexColor(
bool & out_state)
const;
11558 bool ShowFaceIndex(
bool & out_state)
const;
11563 bool ShowEdgeIndex(
bool & out_state)
const;
11568 bool ShowVertexIndex(
bool & out_state)
const;
11598 HPS::Type
ObjectType()
const {
return HPS::Type::ColorInterpolationControl;};
11668 bool ShowFaceColor(
bool & out_state)
const;
11673 bool ShowEdgeColor(
bool & out_state)
const;
11678 bool ShowVertexColor(
bool & out_state)
const;
11683 bool ShowFaceIndex(
bool & out_state)
const;
11688 bool ShowEdgeIndex(
bool & out_state)
const;
11693 bool ShowVertexIndex(
bool & out_state)
const;
11748 bool Empty()
const;
11753 bool Equals(
CullingKit const & in_kit)
const;
11758 bool operator==(
CullingKit const & in_kit)
const;
11763 bool operator!=(
CullingKit const & in_kit)
const;
11769 CullingKit & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11775 CullingKit & SetDeferralExtent(
unsigned int in_pixels);
11781 CullingKit & SetExtent(
bool in_state,
unsigned int in_pixels);
11787 CullingKit & SetExtent(
unsigned int in_pixels);
11828 CullingKit & SetVectorTolerance(
float in_tolerance_degrees);
11867 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11873 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11878 bool ShowBackFace(
bool & out_state)
const;
11885 bool ShowVector(
bool & out_state,
HPS::Vector & out_vector)
const;
11890 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11895 bool ShowFrustum(
bool & out_state)
const;
11937 CullingControl & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11951 CullingControl & SetExtent(
bool in_state,
unsigned int in_pixels);
11999 CullingControl & SetVectorTolerance(
float in_tolerance_degrees);
12038 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
12044 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
12049 bool ShowBackFace(
bool & out_state)
const;
12056 bool ShowVector(
bool & out_state,
HPS::Vector & out_vector)
const;
12061 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
12066 bool ShowFrustum(
bool & out_state)
const;
12101 HPS::Type
ObjectType()
const {
return HPS::Type::MarkerAttributeKit;};
12123 bool Empty()
const;
12169 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
12206 HPS::Type
ObjectType()
const {
return HPS::Type::MarkerAttributeControl;};
12241 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
12280 HPS::Type
ObjectType()
const {
return HPS::Type::SphereAttributeKit;};
12302 bool Empty()
const;
12338 bool ShowTessellation(
size_t & out_facets)
const;
12367 HPS::Type
ObjectType()
const {
return HPS::Type::SphereAttributeControl;};
12393 bool ShowTessellation(
size_t & out_facets)
const;
12426 HPS::Type
ObjectType()
const {
return HPS::Type::LightingAttributeKit;};
12448 bool Empty()
const;
12517 HPS::Type
ObjectType()
const {
return HPS::Type::LightingAttributeControl;};
12576 HPS::Type
ObjectType()
const {
return HPS::Type::CylinderAttributeKit;};
12598 bool Empty()
const;
12644 bool ShowTessellation(
size_t & out_facets)
const;
12680 HPS::Type
ObjectType()
const {
return HPS::Type::CylinderAttributeControl;};
12715 bool ShowTessellation(
size_t & out_facets)
const;
12754 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionAttributeKit;};
12776 bool Empty()
const;
12871 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionAttributeControl;};
12980 bool Empty()
const;
13254 bool ShowBold(
bool & out_state)
const;
13259 bool ShowItalic(
bool & out_state)
const;
13264 bool ShowOverline(
bool & out_state)
const;
13269 bool ShowStrikethrough(
bool & out_state)
const;
13274 bool ShowUnderline(
bool & out_state)
const;
13279 bool ShowSlant(
float & out_angle)
const;
13284 bool ShowLineSpacing(
float & out_multiplier)
const;
13290 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13297 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13323 bool ShowFont(
UTF8 & out_name)
const;
13346 bool ShowPath(
Vector & out_path)
const;
13351 bool ShowSpacing(
float & out_multiplier)
const;
13382 HPS::Type
ObjectType()
const {
return HPS::Type::TextAttributeControl;};
13645 bool ShowBold(
bool & out_state)
const;
13650 bool ShowItalic(
bool & out_state)
const;
13655 bool ShowOverline(
bool & out_state)
const;
13660 bool ShowStrikethrough(
bool & out_state)
const;
13665 bool ShowUnderline(
bool & out_state)
const;
13670 bool ShowSlant(
float & out_angle)
const;
13675 bool ShowLineSpacing(
float & out_multiplier)
const;
13681 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13688 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13714 bool ShowFont(
UTF8 & out_name)
const;
13737 bool ShowPath(
Vector & out_path)
const;
13742 bool ShowSpacing(
float & out_multiplier)
const;
13800 bool Empty()
const;
13859 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13890 HPS::Type
ObjectType()
const {
return HPS::Type::LineAttributeControl;};
13938 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13994 bool Empty()
const;
14040 bool ShowPattern(
UTF8 & out_pattern_name)
const;
14046 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
14077 HPS::Type
ObjectType()
const {
return HPS::Type::EdgeAttributeControl;};
14112 bool ShowPattern(
UTF8 & out_pattern_name)
const;
14118 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
14173 bool Empty()
const;
14268 bool ShowBudget(
size_t & out_budget)
const;
14274 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
14279 bool ShowViewDependent(
bool & out_state)
const;
14285 bool ShowMaximumDeviation(
float & out_deviation)
const;
14291 bool ShowMaximumAngle(
float & out_degrees)
const;
14297 bool ShowMaximumLength(
float & out_length)
const;
14327 HPS::Type
ObjectType()
const {
return HPS::Type::CurveAttributeControl;};
14413 bool ShowBudget(
size_t & out_budget)
const;
14419 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
14424 bool ShowViewDependent(
bool & out_state)
const;
14430 bool ShowMaximumDeviation(
float & out_deviation)
const;
14436 bool ShowMaximumAngle(
float & out_degrees)
const;
14442 bool ShowMaximumLength(
float & out_length)
const;
14477 MatrixKit(FloatArray
const & in_matrix_source);
14482 MatrixKit(
float const in_matrix_source []);
14512 bool Empty()
const;
14517 bool Equals(
MatrixKit const & in_kit)
const;
14522 bool operator==(
MatrixKit const & in_kit)
const;
14527 bool operator!=(
MatrixKit const & in_kit)
const;
14534 MatrixKit & SetElement(
size_t in_row,
size_t in_column,
float in_value);
14540 MatrixKit & SetElement(
size_t in_ordinal_zero_to_fifteen,
float in_value);
14545 MatrixKit & SetElements(FloatArray
const & in_values);
14551 MatrixKit & SetElements(
size_t in_value_count,
float const in_values []);
14564 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14570 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14575 bool ShowElements(FloatArray & out_matrix)
const;
14580 bool ShowDeterminant(
float & out_determinant)
const;
14585 bool ShowInverse(
MatrixKit & out_matrix)
const;
14591 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14599 MatrixKit & Rotate(
float in_x,
float in_y,
float in_z);
14612 MatrixKit & Translate(
float in_x,
float in_y,
float in_z);
14619 MatrixKit & Scale(
float in_x,
float in_y,
float in_z);
14653 MatrixKit Multiply(
float in_scalar)
const;
14658 MatrixKit const & MultiplyAndAssign(
float in_scalar);
14673 MatrixKit operator*(
float in_scalar)
const;
14678 MatrixKit const & operator*=(
float in_scalar);
14684 Point Transform(
Point const & in_source)
const;
14689 PointArray Transform(PointArray
const & in_source)
const;
14695 PointArray Transform(
size_t in_count,
Point const in_source [])
const;
14705 VectorArray Transform(VectorArray
const & in_source)
const;
14711 VectorArray Transform(
size_t in_count,
Vector const in_source [])
const;
14716 Plane Transform(
Plane const & in_source)
const;
14721 PlaneArray Transform(PlaneArray
const & in_source)
const;
14727 PlaneArray Transform(
size_t in_count,
Plane const in_source [])
const;
14769 HPS::Type
ObjectType()
const {
return HPS::Type::ModellingMatrixControl;};
14811 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14817 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14822 bool ShowElements(FloatArray & out_matrix)
const;
14827 bool ShowDeterminant(
float & out_determinant)
const;
14832 bool ShowInverse(
MatrixKit & out_matrix)
const;
14838 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14915 HPS::Type
ObjectType()
const {
return HPS::Type::TextureMatrixControl;};
14957 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14963 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14968 bool ShowElements(FloatArray & out_matrix)
const;
14973 bool ShowDeterminant(
float & out_determinant)
const;
14978 bool ShowInverse(
MatrixKit & out_matrix)
const;
14984 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
15063 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialMappingKit;};
15085 bool Empty()
const;
15689 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15696 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15915 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15947 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialMappingControl;};
16542 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16550 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16768 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16799 HPS::Type
ObjectType()
const {
return HPS::Type::PortfolioControl; };
16807 size_t GetCount()
const;
16860 bool Show(PortfolioKeyArray & out_portfolios)
const;
16900 size_t GetCount()
const;
16903 StyleKey PushNamed(
char const * in_style_name);
16906 StyleKey PushNamed(
char const * in_style_name,
Condition const & in_condition);
16942 void Flush(
SegmentKey const & in_style_source);
16955 void Flush(
char const * in_style_name);
16963 void Flush(
char const * in_style_name,
Condition const & in_condition);
16968 StyleKey SetNamed(
char const * in_style_name);
16991 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names, ConditionArray
const & in_conditions);
16997 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names);
17013 void UnsetAllSegment();
17016 void UnsetAllNamed();
17019 void UnsetEverything();
17033 bool ShowTop(
StyleKey & out_style)
const;
17041 bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions)
const;
17046 bool Show(StyleKeyArray & out_styles)
const;
17052 bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionArray & out_conditions)
const;
17057 bool ShowAllSegment(StyleKeyArray & out_styles)
const;
17063 bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionArray & out_conditions)
const;
17068 bool ShowAllNamed(StyleKeyArray & out_styles)
const;
17100 HPS::Type
ObjectType()
const {
return HPS::Type::ConditionControl; };
17109 size_t GetCount()
const;
17147 bool ShowCondition(
char const * in_condition)
const;
17152 bool ShowConditions(UTF8Array & out_conditions)
const;
17203 bool Empty()
const;
17213 bool operator==(
MaterialKit const & in_kit)
const;
17218 bool operator!=(
MaterialKit const & in_kit)
const;
17255 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
size_t in_layer=0);
17264 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color,
size_t in_layer=0);
17270 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names);
17277 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names []);
17285 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names, RGBAColorArray
const & in_modulating_colors);
17294 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names [],
RGBAColor const in_modulating_colors []);
17300 MaterialKit & SetShader(
char const * in_shader_name);
17312 MaterialKit & SetSpecular(
char const * in_texture_name);
17318 MaterialKit & SetSpecular(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17330 MaterialKit & SetMirror(
char const * in_texture_name);
17343 MaterialKit & SetTransmission(
char const * in_texture_name);
17349 MaterialKit & SetTransmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17361 MaterialKit & SetEmission(
char const * in_texture_name);
17367 MaterialKit & SetEmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17374 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name);
17380 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17385 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name);
17391 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name,
RGBAColor const & in_modulating_color);
17401 MaterialKit & SetBump(
char const * in_texture_name);
17432 MaterialKit & UnsetDiffuseTexture(
size_t in_layer);
17473 bool ShowDiffuse()
const;
17478 bool ShowDiffuseColor(
RGBColor & out_rgb_color)
const;
17483 bool ShowDiffuseColor(
RGBAColor & out_rgba_color)
const;
17488 bool ShowDiffuseAlpha(
float & out_alpha)
const;
17513 bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names)
const;
17518 bool ShowShader(
UTF8 & out_shader_name)
const;
17578 bool ShowBump(
UTF8 & out_texture_name)
const;
17584 bool ShowGloss(
float & out_gloss)
const;
17613 HPS::Type
ObjectType()
const {
return HPS::Type::NURBSSurfaceAttributeKit;};
17635 bool Empty()
const;
17717 bool ShowBudget(
size_t & out_budget)
const;
17722 bool ShowMaximumDeviation(
float & out_deviation)
const;
17727 bool ShowMaximumAngle(
float & out_degrees)
const;
17732 bool ShowMaximumWidth(
float & out_width)
const;
17737 bool ShowTrimBudget(
size_t & out_budget)
const;
17742 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17773 HPS::Type
ObjectType()
const {
return HPS::Type::NURBSSurfaceAttributeControl;};
17845 bool ShowBudget(
size_t & out_budget)
const;
17850 bool ShowMaximumDeviation(
float & out_deviation)
const;
17855 bool ShowMaximumAngle(
float & out_degrees)
const;
17860 bool ShowMaximumWidth(
float & out_width)
const;
17865 bool ShowTrimBudget(
size_t & out_budget)
const;
17870 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17926 bool Empty()
const;
18008 HPS::Type
ObjectType()
const {
return HPS::Type::PerformanceControl;};
18082 HPS::Type
ObjectType()
const {
return HPS::Type::HiddenLineAttributeKit;};
18104 bool Empty()
const;
18244 bool ShowColor(
RGBAColor & out_color)
const;
18249 bool ShowDimFactor(
float & out_zero_to_one)
const;
18254 bool ShowFaceDisplacement(
float & out_buckets)
const;
18259 bool ShowLinePattern(
UTF8 & out_pattern)
const;
18264 bool ShowRenderFaces(
bool & out_state)
const;
18269 bool ShowRenderText(
bool & out_state)
const;
18279 bool ShowSilhouetteCleanup(
bool & out_state)
const;
18284 bool ShowVisibility(
bool & out_state)
const;
18290 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
18295 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
18327 HPS::Type
ObjectType()
const {
return HPS::Type::HiddenLineAttributeControl;};
18456 bool ShowColor(
RGBAColor & out_color)
const;
18461 bool ShowDimFactor(
float & out_zero_to_one)
const;
18466 bool ShowFaceDisplacement(
float & out_buckets)
const;
18471 bool ShowLinePattern(
UTF8 & out_pattern)
const;
18476 bool ShowRenderFaces(
bool & out_state)
const;
18481 bool ShowRenderText(
bool & out_state)
const;
18491 bool ShowSilhouetteCleanup(
bool & out_state)
const;
18496 bool ShowVisibility(
bool & out_state)
const;
18502 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
18507 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
18541 HPS::Type
ObjectType()
const {
return HPS::Type::DrawingAttributeKit;};
18563 bool Empty()
const;
18747 bool ShowDepthRange(
float & out_near,
float & out_far)
const;
18753 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18759 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18765 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18775 bool ShowDeferral(
int & out_defer_batch)
const;
18821 HPS::Type
ObjectType()
const {
return HPS::Type::DrawingAttributeControl;};
18989 bool ShowDepthRange(
float & out_x,
float & out_y)
const;
18995 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
19001 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
19007 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
19017 bool ShowDeferral(
int & out_defer_batch)
const;
19057 HPS::Type
ObjectType()
const {
return HPS::Type::PostProcessEffectsKit;};
19079 bool Empty()
const;
19142 PostProcessEffectsKit & SetDepthOfField(
float in_strength,
float in_near_distance,
float in_far_distance);
19151 PostProcessEffectsKit & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
19168 PostProcessEffectsKit & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
19176 PostProcessEffectsKit & SetEyeDomeLighting(
float in_exponent,
bool in_tolerance,
float in_strength);
19225 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
19234 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
19243 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
19273 HPS::Type
ObjectType()
const {
return HPS::Type::PostProcessEffectsControl;};
19334 PostProcessEffectsControl & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
19351 PostProcessEffectsControl & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
19409 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
19418 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
19427 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
19472 bool Empty()
const;
19616 bool ShowCameraRotation(
bool & out_state)
const;
19621 bool ShowCameraScale(
bool & out_state)
const;
19626 bool ShowCameraTranslation(
bool & out_state)
const;
19631 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19636 bool ShowCameraProjection(
bool & out_state)
const;
19641 bool ShowCameraOffset(
bool & out_state)
const;
19646 bool ShowCameraNearLimit(
bool & out_state)
const;
19651 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19656 bool ShowModellingMatrixScale(
bool & out_state)
const;
19661 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19666 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19697 HPS::Type
ObjectType()
const {
return HPS::Type::TransformMaskControl;};
19836 bool ShowCameraRotation(
bool & out_state)
const;
19841 bool ShowCameraScale(
bool & out_state)
const;
19846 bool ShowCameraTranslation(
bool & out_state)
const;
19851 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19856 bool ShowCameraProjection(
bool & out_state)
const;
19861 bool ShowCameraOffset(
bool & out_state)
const;
19866 bool ShowCameraNearLimit(
bool & out_state)
const;
19871 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19876 bool ShowModellingMatrixScale(
bool & out_state)
const;
19881 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19886 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19942 bool Empty()
const;
19978 VisualEffectsKit & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
19988 VisualEffectsKit & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
19996 VisualEffectsKit & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
20003 VisualEffectsKit & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
20030 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);
20041 VisualEffectsKit & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
20101 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
20106 bool ShowAntiAliasing(
bool & out_state)
const;
20115 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
20123 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
20128 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
20133 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
20138 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
20148 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;
20154 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
20159 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
20191 HPS::Type
ObjectType()
const {
return HPS::Type::VisualEffectsControl;};
20217 VisualEffectsControl & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
20227 VisualEffectsControl & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
20235 VisualEffectsControl & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
20242 VisualEffectsControl & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
20269 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);
20280 VisualEffectsControl & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
20341 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
20346 bool ShowAntiAliasing(
bool & out_state)
const;
20355 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
20363 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
20368 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
20373 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
20378 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
20388 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;
20393 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
20398 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
20454 bool Empty()
const;
20481 ContourLineKit & SetPositions(
float in_interval,
float in_offset);
20492 ContourLineKit & SetPositions(
size_t in_count,
float const in_positions[]);
20530 ContourLineKit & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20583 bool ShowVisibility(
bool & out_state)
const;
20590 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20595 bool ShowColors(RGBColorArray & out_colors)
const;
20600 bool ShowPatterns(UTF8Array & out_patterns)
const;
20606 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20611 bool ShowLighting(
bool & out_state)
const;
20640 HPS::Type
ObjectType()
const {
return HPS::Type::ContourLineControl; };
20705 ContourLineControl & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20758 bool ShowVisibility(
bool & out_state)
const;
20765 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20770 bool ShowColors(RGBColorArray & out_colors)
const;
20775 bool ShowPatterns(UTF8Array & out_patterns)
const;
20781 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20786 bool ShowLighting(
bool & out_state)
const;
20841 bool Empty()
const;
20954 bool ShowModelCompareMode(
bool & out_state,
SegmentKey & out_source1,
SegmentKey & out_source2)
const;
21092 bool ShowModelCompareMode(
bool & out_state,
SegmentKey & out_source1,
SegmentKey & out_source2)
const;
21147 bool Empty()
const;
21183 bool ShowResourceMonitor(
bool & out_display)
const;
21228 bool ShowResourceMonitor(
bool & out_display)
const;
21277 bool Empty()
const;
21299 WindowInfoKit & SetPhysicalPixels(
unsigned int in_width,
unsigned int in_height);
21305 WindowInfoKit & SetPhysicalSize(
float in_width,
float in_height);
21311 WindowInfoKit & SetWindowPixels(
unsigned int in_width,
unsigned int in_height);
21317 WindowInfoKit & SetWindowSize(
float in_width,
float in_height);
21345 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21351 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
21357 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21363 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
21370 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
21375 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
21380 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
21420 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21426 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
21432 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21438 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
21445 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
21450 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
21455 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
21461 bool ShowMaxTextureSize(
unsigned int & out_width,
unsigned int & out_height)
const;
21467 bool ShowLastUpdateTime(Time & out_time)
const;
21472 bool ShowDepthPeelingLayers(
size_t & out_layers)
const;
21477 bool ShowVideoMemory(
size_t & out_video_memory)
const;
21482 bool ShowDepthBufferSize(
size_t & out_bits)
const;
21487 bool ShowMaxLights(
size_t & out_lights)
const;
21492 bool ShowColorBitPlanes(
size_t & out_planes)
const;
21497 bool ShowLastUpdateInfo(
UpdateInfo & out_info)
const;
21549 bool Empty()
const;
21568 UTF8 GetName()
const;
21572 bool GetShellConvertibility()
const;
21625 bool Empty()
const;
21653 AttributeLockKit & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21667 AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21684 AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types);
21701 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21713 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21744 HPS::Type
ObjectType()
const {
return HPS::Type::AttributeLockControl;}
21762 AttributeLockControl & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21776 AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21810 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21822 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21871 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
21876 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
21895 bool ShowPriority(
int & out_priority)
const;
21903 GeometryKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21909 GeometryKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21915 GeometryKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21926 GeometryKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21931 GeometryKey & UnsetUserData(IntPtrTArray
const & in_indices);
21938 size_t ShowUserDataCount()
const;
21943 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21949 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21955 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21992 void Consume(
LineKit & in_kit);
21996 void Set(
LineKit const & in_kit);
22000 void Show(
LineKit & out_kit)
const;
22009 bool Empty()
const;
22014 bool Equals(
LineKit const & in_kit)
const;
22019 bool operator==(
LineKit const & in_kit)
const;
22024 bool operator!=(
LineKit const & in_kit)
const;
22028 size_t GetPointCount()
const;
22036 LineKit & SetPriority(
int in_priority);
22045 bool ShowPriority(
int & out_priority)
const;
22051 LineKit & SetPoints(PointArray
const & in_points);
22057 LineKit & SetPoints(
size_t in_count,
Point const in_points []);
22072 bool ShowPoints(PointArray & out_points)
const;
22079 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22085 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22092 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22100 LineKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22106 LineKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
22112 LineKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
22119 LineKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22126 LineKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
22133 LineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22139 LineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22145 LineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22150 LineKit & UnsetUserData(intptr_t in_index);
22156 LineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22161 LineKit & UnsetUserData(IntPtrTArray
const & in_indices);
22165 LineKit & UnsetAllUserData();
22168 size_t ShowUserDataCount()
const;
22173 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22179 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22185 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22226 void Consume(
LineKit & in_kit);
22230 void Set(
LineKit const & in_kit);
22234 void Show(
LineKit & out_kit)
const;
22238 size_t GetPointCount()
const;
22243 LineKey & SetPoints(PointArray
const & in_points);
22249 LineKey & SetPoints(
size_t in_count,
Point const in_points []);
22255 bool ShowPoints(PointArray & out_points)
const;
22262 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22268 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22275 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22283 LineKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22289 LineKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
22295 LineKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
22302 LineKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22309 LineKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
22358 bool Empty()
const;
22363 bool Equals(
MarkerKit const & in_kit)
const;
22368 bool operator==(
MarkerKit const & in_kit)
const;
22373 bool operator!=(
MarkerKit const & in_kit)
const;
22382 MarkerKit & SetPriority(
int in_priority);
22391 bool ShowPriority(
int & out_priority)
const;
22411 bool ShowPoint(
HPS::Point & out_point)
const;
22418 MarkerKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22424 MarkerKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22430 MarkerKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22435 MarkerKit & UnsetUserData(intptr_t in_index);
22441 MarkerKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22446 MarkerKit & UnsetUserData(IntPtrTArray
const & in_indices);
22453 size_t ShowUserDataCount()
const;
22458 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22464 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22470 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22530 bool ShowPoint(
Point & out_point)
const;
22579 bool Empty()
const;
22654 bool ShowPriority(
int & out_priority)
const;
22659 bool ShowDirection(
HPS::Vector & out_vector)
const;
22671 bool ShowCameraRelative(
bool & out_state)
const;
22678 DistantLightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22684 DistantLightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22690 DistantLightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22701 DistantLightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22713 size_t ShowUserDataCount()
const;
22718 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22724 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22730 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22813 bool ShowDirection(
HPS::Vector & out_vector)
const;
22825 bool ShowCameraRelative(
bool & out_state)
const;
22875 bool Empty()
const;
22885 bool operator==(
CylinderKit const & in_kit)
const;
22890 bool operator!=(
CylinderKit const & in_kit)
const;
22894 size_t GetPointCount()
const;
22911 bool ShowPriority(
int & out_priority)
const;
22917 CylinderKit & SetPoints(PointArray
const & in_points);
22928 CylinderKit & SetRadii(FloatArray
const & in_radii);
22934 CylinderKit & SetRadii(
size_t in_count,
float const in_radii []);
22962 bool ShowPoints(PointArray & out_points)
const;
22969 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22975 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22982 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22987 bool ShowRadii(FloatArray & out_radii)
const;
23113 CylinderKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
23118 CylinderKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
23151 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23165 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23172 CylinderKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23178 CylinderKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23184 CylinderKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23195 CylinderKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23200 CylinderKit & UnsetUserData(IntPtrTArray
const & in_indices);
23207 size_t ShowUserDataCount()
const;
23212 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23218 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23224 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23278 CylinderKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
23284 CylinderKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
23290 CylinderKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
23297 CylinderKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
23304 CylinderKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
23312 CylinderKey & EditRadiiByInsertion(
size_t in_offset,
size_t in_count,
float const in_radii[]);
23318 CylinderKey & EditRadiiByInsertion(
size_t in_offset, FloatArray
const & in_radii);
23324 CylinderKey & EditRadiiByDeletion(
size_t in_offset,
size_t in_count);
23331 CylinderKey & EditRadiiByReplacement(
size_t in_offset,
size_t in_count,
float const in_radii[]);
23338 CylinderKey & EditRadiiByReplacement(
size_t in_offset, FloatArray
const & in_radii);
23347 size_t GetPointCount()
const;
23352 bool ShowPoints(PointArray & out_points)
const;
23359 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
23365 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
23372 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
23377 bool ShowRadii(FloatArray & out_radii)
const;
23443 CylinderKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
23469 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23483 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_apply_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23533 bool Empty()
const;
23538 bool Equals(
SphereKit const & in_kit)
const;
23543 bool operator==(
SphereKit const & in_kit)
const;
23548 bool operator!=(
SphereKit const & in_kit)
const;
23556 SphereKit & SetPriority(
int in_priority);
23565 bool ShowPriority(
int & out_priority)
const;
23575 SphereKit & SetRadius(
float in_radius);
23604 bool ShowCenter(
Point & out_center)
const;
23609 bool ShowRadius(
float & out_radius)
const;
23615 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
23622 SphereKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23628 SphereKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23634 SphereKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23639 SphereKit & UnsetUserData(intptr_t in_index);
23645 SphereKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23650 SphereKit & UnsetUserData(IntPtrTArray
const & in_indices);
23657 size_t ShowUserDataCount()
const;
23662 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23668 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23674 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23733 SphereKey & SetRadius(
float in_radius);
23745 bool ShowCenter(
Point & out_center)
const;
23750 bool ShowRadius(
float & out_radius)
const;
23756 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
23806 bool Empty()
const;
23811 bool Equals(
CircleKit const & in_kit)
const;
23816 bool operator==(
CircleKit const & in_kit)
const;
23821 bool operator!=(
CircleKit const & in_kit)
const;
23829 CircleKit & SetPriority(
int const in_priority);
23838 bool ShowPriority(
int & out_priority)
const;
23850 CircleKit & SetRadius(
float in_radius);
23878 bool ShowCenter(
Point & out_center)
const;
23883 bool ShowRadius(
float & out_radius)
const;
23888 bool ShowNormal(
Vector & out_normal)
const;
23895 CircleKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23901 CircleKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23907 CircleKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23912 CircleKit & UnsetUserData(intptr_t in_index);
23918 CircleKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23923 CircleKit & UnsetUserData(IntPtrTArray
const & in_indices);
23930 size_t ShowUserDataCount()
const;
23935 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23941 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23947 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24009 CircleKey & SetRadius(
float in_radius);
24020 bool ShowCenter(
Point & out_center)
const;
24025 bool ShowRadius(
float & out_radius)
const;
24030 bool ShowNormal(
Vector & out_normal)
const;
24080 bool Empty()
const;
24112 bool ShowPriority(
int & out_priority)
const;
24151 bool ShowStart(
Point & out_start)
const;
24156 bool ShowMiddle(
Point & out_middle)
const;
24161 bool ShowEnd(
Point & out_end)
const;
24168 CircularArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24174 CircularArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24180 CircularArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24191 CircularArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24196 CircularArcKit & UnsetUserData(IntPtrTArray
const & in_indices);
24203 size_t ShowUserDataCount()
const;
24208 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24214 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24220 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24292 bool ShowStart(
Point & out_start)
const;
24297 bool ShowMiddle(
Point & out_middle)
const;
24302 bool ShowEnd(
Point & out_end)
const;
24330 HPS::Type
ObjectType()
const {
return HPS::Type::CircularWedgeKit; };
24351 bool Empty()
const;
24384 bool ShowPriority(
int & out_priority)
const;
24423 bool ShowStart(
Point & out_start)
const;
24428 bool ShowMiddle(
Point & out_middle)
const;
24433 bool ShowEnd(
Point & out_end)
const;
24440 CircularWedgeKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24446 CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24452 CircularWedgeKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24463 CircularWedgeKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24475 size_t ShowUserDataCount()
const;
24480 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24486 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24492 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24531 HPS::Type
ObjectType()
const {
return HPS::Type::CircularWedgeKey; };
24566 bool ShowStart(
Point & out_start)
const;
24571 bool ShowMiddle(
Point & out_middle)
const;
24576 bool ShowEnd(
Point & out_end)
const;
24604 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionKit; };
24625 bool Empty()
const;
24657 bool ShowPriority(
int & out_priority)
const;
24699 size_t GetPlaneCount()
const;
24704 bool ShowPlanes(HPS::PlaneArray & out_planes)
const;
24727 CuttingSectionKit & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24743 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24752 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24759 CuttingSectionKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24771 CuttingSectionKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24782 CuttingSectionKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24794 size_t ShowUserDataCount()
const;
24799 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24805 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24811 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24848 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionKey; };
24890 size_t GetPlaneCount()
const;
24895 bool ShowPlanes(HPS::PlaneArray & out_planes)
const;
24918 CuttingSectionKey & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24934 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24941 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24990 bool Empty()
const;
25022 bool ShowPriority(
int & out_priority)
const;
25061 bool ShowFirst(
Point & out_first)
const;
25066 bool ShowSecond(
Point & out_second)
const;
25078 InfiniteLineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25084 InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25090 InfiniteLineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25101 InfiniteLineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25113 size_t ShowUserDataCount()
const;
25118 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25124 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25130 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25201 bool ShowFirst(
Point & out_first)
const;
25206 bool ShowSecond(
Point & out_second)
const;
25267 bool Empty()
const;
25336 SpotlightKit & SetConcentration(
float in_concentration);
25386 bool ShowPriority(
int & out_priority)
const;
25391 bool ShowPosition(
HPS::Point & out_position)
const;
25396 bool ShowTarget(
HPS::Point & out_target)
const;
25420 bool ShowConcentration(
float & out_concentration)
const;
25425 bool ShowCameraRelative(
bool & out_state)
const;
25432 SpotlightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25438 SpotlightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25444 SpotlightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25455 SpotlightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25460 SpotlightKit & UnsetUserData(IntPtrTArray
const & in_indices);
25467 size_t ShowUserDataCount()
const;
25472 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25478 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25484 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25579 SpotlightKey & SetConcentration(
float in_concentration);
25597 bool ShowPosition(
HPS::Point & out_position)
const;
25602 bool ShowTarget(
HPS::Point & out_target)
const;
25626 bool ShowConcentration(
float & out_concentration)
const;
25631 bool ShowCameraRelative(
bool & out_state)
const;
25680 bool Empty()
const;
25699 size_t GetPointCount()
const;
25716 bool ShowPriority(
int & out_priority)
const;
25743 NURBSCurveKit & SetWeights(
size_t in_count,
float const in_weights []);
25754 NURBSCurveKit & SetKnots(
size_t in_count,
float const in_knots []);
25760 NURBSCurveKit & SetParameters(
float in_start,
float in_end);
25791 bool ShowDegree(
size_t & out_degree)
const;
25796 bool ShowPoints(PointArray & out_points)
const;
25803 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
25809 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
25816 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
25821 bool ShowWeights(FloatArray & out_weights)
const;
25826 bool ShowKnots(FloatArray & out_knots)
const;
25832 bool ShowParameters(
float & out_start,
float & out_end)
const;
25841 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25848 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
25856 NURBSCurveKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
25864 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25872 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25882 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25890 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
25899 NURBSCurveKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
25907 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25915 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25923 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25929 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
25936 NURBSCurveKit & EditKnotsByDeletion(
size_t in_offset,
size_t in_count);
25944 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25952 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25959 NURBSCurveKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25965 NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25971 NURBSCurveKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25982 NURBSCurveKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25987 NURBSCurveKit & UnsetUserData(IntPtrTArray
const & in_indices);
25994 size_t ShowUserDataCount()
const;
25999 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26005 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
26011 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
26064 size_t GetPointCount()
const;
26070 NURBSCurveKey & SetParameters(
float in_start,
float in_end);
26075 bool ShowDegree(
size_t & out_degree)
const;
26080 bool ShowPoints(PointArray & out_points)
const;
26087 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26093 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26100 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26105 bool ShowWeights(FloatArray & out_weights)
const;
26110 bool ShowKnots(FloatArray & out_knots)
const;
26116 bool ShowParameters(
float & out_start,
float & out_end)
const;
26126 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26134 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26145 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26154 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26164 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26172 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26221 bool Empty()
const;
26240 size_t GetPointCount()
const;
26257 bool ShowPriority(
int & out_priority)
const;
26301 NURBSSurfaceKit & SetWeights(
size_t in_count,
float const in_weights []);
26314 NURBSSurfaceKit & SetUKnots(
size_t in_count,
float const in_knots []);
26327 NURBSSurfaceKit & SetVKnots(
size_t in_count,
float const in_knots []);
26385 bool ShowUDegree(
size_t & out_degree)
const;
26390 bool ShowVDegree(
size_t & out_degree)
const;
26395 bool ShowUCount(
size_t & out_count)
const;
26400 bool ShowVCount(
size_t & out_count)
const;
26405 bool ShowPoints(PointArray & out_points)
const;
26412 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26418 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26425 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26430 bool ShowWeights(FloatArray & out_weights)
const;
26435 bool ShowUKnots(FloatArray & out_knots)
const;
26440 bool ShowVKnots(FloatArray & out_knots)
const;
26445 bool ShowTrims(TrimKitArray & out_trims)
const;
26454 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26461 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
26469 NURBSSurfaceKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
26477 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26485 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26495 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26503 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
26512 NURBSSurfaceKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
26520 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26528 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26537 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26544 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26552 NURBSSurfaceKit & EditUKnotsByDeletion(
size_t in_offset,
size_t in_count);
26560 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26568 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26577 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26584 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26592 NURBSSurfaceKit & EditVKnotsByDeletion(
size_t in_offset,
size_t in_count);
26600 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26608 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26615 NURBSSurfaceKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26621 NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26627 NURBSSurfaceKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26638 NURBSSurfaceKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26650 size_t ShowUserDataCount()
const;
26655 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26661 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
26667 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
26720 size_t GetPointCount()
const;
26742 bool ShowUDegree(
size_t & out_degree)
const;
26747 bool ShowVDegree(
size_t & out_degree)
const;
26752 bool ShowUCount(
size_t & out_count)
const;
26757 bool ShowVCount(
size_t & out_count)
const;
26762 bool ShowPoints(PointArray & out_points)
const;
26769 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26775 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26782 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26787 bool ShowWeights(FloatArray & out_weights)
const;
26792 bool ShowUKnots(FloatArray & out_knots)
const;
26797 bool ShowVKnots(FloatArray & out_knots)
const;
26802 bool ShowTrims(TrimKitArray & out_trims)
const;
26812 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26820 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26831 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26840 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26850 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26858 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26868 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26876 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26933 bool operator==(
TrimElement const & in_that)
const;
26938 bool operator!=(
TrimElement const & in_that)
const;
26944 void SetCurve(
LineKit const & in_line);
26988 void Set(
TrimKit const & in_kit);
26992 void Show(
TrimKit & out_kit)
const;
27001 bool Empty()
const;
27006 bool Equals(
TrimKit const & in_kit)
const;
27011 bool operator==(
TrimKit const & in_kit)
const;
27016 bool operator!=(
TrimKit const & in_kit)
const;
27028 TrimKit & SetShape(TrimElementArray
const & in_shape);
27052 bool ShowShape(TrimElementArray & out_shape)
const;
27106 bool Empty()
const;
27111 bool Equals(
EllipseKit const & in_kit)
const;
27116 bool operator==(
EllipseKit const & in_kit)
const;
27121 bool operator!=(
EllipseKit const & in_kit)
const;
27138 bool ShowPriority(
int & out_priority)
const;
27177 bool ShowCenter(
Point & out_center)
const;
27182 bool ShowMajor(
Point & out_major)
const;
27187 bool ShowMinor(
Point & out_minor)
const;
27194 EllipseKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27200 EllipseKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27206 EllipseKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
27211 EllipseKit & UnsetUserData(intptr_t in_index);
27217 EllipseKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
27222 EllipseKit & UnsetUserData(IntPtrTArray
const & in_indices);
27229 size_t ShowUserDataCount()
const;
27234 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27240 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27246 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27318 bool ShowCenter(
Point & out_center)
const;
27323 bool ShowMajor(
Point & out_major)
const;
27328 bool ShowMinor(
Point & out_minor)
const;
27356 HPS::Type
ObjectType()
const {
return HPS::Type::EllipticalArcKit; };
27377 bool Empty()
const;
27409 bool ShowPriority(
int & out_priority)
const;
27474 bool ShowCenter(
Point & out_center)
const;
27479 bool ShowMajor(
Point & out_major)
const;
27484 bool ShowMinor(
Point & out_minor)
const;
27489 bool ShowStart(
float & out_start)
const;
27494 bool ShowEnd(
float & out_end)
const;
27501 EllipticalArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27507 EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27513 EllipticalArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
27524 EllipticalArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
27536 size_t ShowUserDataCount()
const;
27541 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27547 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27553 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27590 HPS::Type
ObjectType()
const {
return HPS::Type::EllipticalArcKey; };
27643 bool ShowCenter(
Point & out_center)
const;
27648 bool ShowMajor(
Point & out_major)
const;
27653 bool ShowMinor(
Point & out_minor)
const;
27658 bool ShowStart(
float & out_start)
const;
27663 bool ShowEnd(
float & out_end)
const;
27695 void Consume(
TextKit & in_kit);
27699 void Set(
TextKit const & in_kit);
27703 void Show(
TextKit & out_kit)
const;
27712 bool Empty()
const;
27717 bool Equals(
TextKit const & in_kit)
const;
27722 bool operator==(
TextKit const & in_kit)
const;
27727 bool operator!=(
TextKit const & in_kit)
const;
27735 TextKit & SetPriority(
int in_priority);
27744 bool ShowPriority(
int & out_priority)
const;
27754 TextKit & SetText(
char const * in_string);
27764 TextKit & SetColorByIndex(
float in_index);
27781 TextKit & SetBold(
bool in_state);
27786 TextKit & SetItalic(
bool in_state);
27791 TextKit & SetOverline(
bool in_state);
27796 TextKit & SetStrikethrough(
bool in_state);
27801 TextKit & SetUnderline(
bool in_state);
27807 TextKit & SetSlant(
float in_angle);
27812 TextKit & SetLineSpacing(
float in_multiplier);
27824 TextKit & SetRotation(
float in_angle);
27884 TextKit & SetFont(
char const * in_name);
27919 TextKit & SetSpacing(
float in_multiplier);
27936 TextKit & UnsetModellingMatrix();
27956 TextKit & UnsetStrikethrough();
27968 TextKit & UnsetLineSpacing();
27984 TextKit & UnsetSizeTolerance();
28022 bool ShowPosition(
Point & out_position)
const;
28027 bool ShowText(
UTF8 & out_string)
const;
28039 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
28051 bool ShowBold(
bool & out_state)
const;
28056 bool ShowItalic(
bool & out_state)
const;
28061 bool ShowOverline(
bool & out_state)
const;
28066 bool ShowStrikethrough(
bool & out_state)
const;
28071 bool ShowUnderline(
bool & out_state)
const;
28076 bool ShowSlant(
float & out_angle)
const;
28081 bool ShowLineSpacing(
float & out_multiplier)
const;
28087 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
28094 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
28120 bool ShowFont(
UTF8 & out_name)
const;
28143 bool ShowPath(
Vector & out_path)
const;
28148 bool ShowSpacing(
float & out_multiplier)
const;
28158 TextKit & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28166 TextKit & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
28174 TextKit & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28184 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;
28198 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);
28213 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);
28220 TextKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
28230 TextKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
28236 TextKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
28241 TextKit & UnsetUserData(intptr_t in_index);
28247 TextKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
28252 TextKit & UnsetUserData(IntPtrTArray
const & in_indices);
28256 TextKit & UnsetAllUserData();
28259 size_t ShowUserDataCount()
const;
28264 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
28270 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
28276 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
28317 void Consume(
TextKit & in_kit);
28321 void Set(
TextKit const & in_kit);
28325 void Show(
TextKit & out_kit)
const;
28344 TextKey & SetText(
char const * in_string);
28354 TextKey & SetColorByIndex(
float in_index);
28371 TextKey & SetBold(
bool in_state);
28376 TextKey & SetItalic(
bool in_state);
28381 TextKey & SetOverline(
bool in_state);
28386 TextKey & SetStrikethrough(
bool in_state);
28391 TextKey & SetUnderline(
bool in_state);
28397 TextKey & SetSlant(
float in_angle);
28403 TextKey & SetLineSpacing(
float in_multiplier);
28415 TextKey & SetRotation(
float in_angle);
28475 TextKey & SetFont(
char const * in_name);
28512 TextKey & SetSpacing(
float in_multiplier);
28526 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);
28541 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);
28550 TextKey & UnsetModellingMatrix();
28570 TextKey & UnsetStrikethrough();
28582 TextKey & UnsetLineSpacing();
28598 TextKey & UnsetSizeTolerance();
28640 bool ShowPosition(
Point & out_position)
const;
28645 bool ShowText(
UTF8 & out_string)
const;
28657 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
28669 bool ShowBold(
bool & out_state)
const;
28674 bool ShowItalic(
bool & out_state)
const;
28679 bool ShowOverline(
bool & out_state)
const;
28684 bool ShowStrikethrough(
bool & out_state)
const;
28689 bool ShowUnderline(
bool & out_state)
const;
28694 bool ShowSlant(
float & out_angle)
const;
28699 bool ShowLineSpacing(
float & out_multiplier)
const;
28705 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
28712 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
28738 bool ShowFont(
UTF8 & out_name)
const;
28761 bool ShowPath(
Vector & out_path)
const;
28766 bool ShowSpacing(
float & out_multiplier)
const;
28776 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;
28786 TextKey & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28794 TextKey & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
28802 TextKey & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28824 HPS::Type
ObjectType()
const {
return HPS::Type::ShellOptimizationOptionsKit; };
28850 bool Empty()
const;
28921 bool ShowNormalTolerance(
float & out_normal_tolerance)
const;
28932 bool ShowOrphanElimination(
bool & out_orphan_elimination)
const;
28967 HPS::Type
ObjectType()
const {
return HPS::Type::ShellRelationOptionsKit; };
28993 bool Empty()
const;
29057 bool ShowTolerance(
float & out_tolerance)
const;
29067 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
29072 bool ShowNearestFaceCalculation(
bool & out_state)
const;
29098 HPS::Type
ObjectType()
const {
return HPS::Type::ShellRelationResultsKit; };
29119 bool Empty()
const;
29140 bool ShowRelations(ShellRelationArray & out_results)
const;
29145 bool ShowNearestFaces(SizeTArray & out_faces)
const;
29150 bool ShowDistances(FloatArray & out_distances)
const;
29185 void Set(
ShellKit const & in_kit);
29189 void Show(
ShellKit & out_kit)
const;
29193 size_t GetPointCount()
const;
29197 size_t GetFaceCount()
const;
29206 bool Empty()
const;
29211 bool Equals(
ShellKit const & in_kit)
const;
29216 bool operator==(
ShellKit const & in_kit)
const;
29221 bool operator!=(
ShellKit const & in_kit)
const;
29229 ShellKit & SetPriority(
int in_priority);
29238 bool ShowPriority(
int & out_priority)
const;
29245 ShellKit & SetPoints(PointArray
const & in_points);
29251 ShellKit & SetPoints(
size_t in_count,
Point const in_points []);
29256 ShellKit & SetFacelist(IntArray
const & in_facelist);
29262 ShellKit & SetFacelist(
size_t in_count,
int const in_facelist []);
29267 ShellKit & SetTristrips(IntArray
const & in_tristrips);
29273 ShellKit & SetTristrips(
size_t in_count,
int const in_tristrips []);
29294 bool ShowPoints(PointArray & out_points)
const;
29301 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
29307 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
29314 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
29319 bool ShowFacelist(IntArray & out_facelist)
const;
29324 bool ShowTristrips(IntArray & out_tristrips)
const;
29504 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29510 ShellKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29517 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29524 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
29530 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
29537 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
29543 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
29552 ShellKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29560 ShellKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
29570 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);
29579 ShellKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
29587 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29593 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29600 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29607 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
29613 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
29620 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
29626 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
29631 ShellKit & UnsetMaterialMapping();
29642 ShellKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
29647 ShellKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
29677 ShellKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
29682 ShellKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
29687 ShellKit & UnsetVertexParameters();
29693 ShellKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
29698 ShellKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
29703 ShellKit & UnsetVertexVisibilities();
29709 ShellKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
29714 ShellKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
29719 ShellKit & UnsetVertexEverything();
29741 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_apply_to, MaterialTypeArray & out_types,
29742 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29758 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_apply_to, MaterialTypeArray & out_types,
29759 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29770 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29780 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
29792 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
29803 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29814 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
29825 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29836 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29846 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29855 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
29861 ShellKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
29868 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
29875 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
29881 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
29888 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
29894 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
29902 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
29908 ShellKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
29915 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
29922 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
29928 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
29935 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
29941 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
29949 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29955 ShellKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29962 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29969 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
29975 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
29982 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
29988 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
29996 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30002 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30009 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30016 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
30022 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
30029 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
30035 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
30046 ShellKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
30051 ShellKit & UnsetFaceColorsByList(SizeTArray
const & in_faces);
30062 ShellKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
30067 ShellKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
30072 ShellKit & UnsetFaceVisibilities();
30078 ShellKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
30083 ShellKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
30100 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
30112 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
30123 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
30133 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
30144 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30154 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30163 ShellKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
30170 ShellKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
30177 ShellKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
30184 ShellKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
30191 ShellKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
30200 ShellKit & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30207 ShellKit & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
30214 ShellKit & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
30224 ShellKit & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30233 ShellKit & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
30262 ShellKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
30268 ShellKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
30274 ShellKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
30279 ShellKit & UnsetUserData(intptr_t in_index);
30285 ShellKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
30290 ShellKit & UnsetUserData(IntPtrTArray
const & in_indices);
30297 size_t ShowUserDataCount()
const;
30302 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
30308 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
30314 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
30361 void Set(
ShellKit const & in_kit);
30365 void Show(
ShellKit & out_kit)
const;
30369 size_t GetPointCount()
const;
30373 size_t GetFaceCount()
const;
30379 ShellKey & SetPoints(PointArray
const & in_points);
30385 ShellKey & SetPoints(
size_t in_count,
Point const in_points []);
30390 ShellKey & SetFacelist(IntArray
const & in_facelist);
30396 ShellKey & SetFacelist(
size_t in_count,
int const in_facelist []);
30401 ShellKey & SetTristrips(IntArray
const & in_tristrips);
30407 ShellKey & SetTristrips(
size_t in_count,
int const in_tristrips []);
30429 ShellKey & UnsetMaterialMapping();
30438 bool ShowPoints(PointArray & out_points)
const;
30445 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
30451 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
30458 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
30463 bool ShowFacelist(IntArray & out_facelist)
const;
30468 bool ShowTristrips(IntArray & out_tristrips)
const;
30649 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30656 ShellKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30663 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30670 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
30676 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
30683 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
30689 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
30699 ShellKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30707 ShellKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
30717 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);
30726 ShellKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
30734 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30741 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30748 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30755 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
30761 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
30768 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
30774 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
30785 ShellKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
30790 ShellKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
30820 ShellKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
30825 ShellKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
30830 ShellKey & UnsetVertexParameters();
30836 ShellKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
30841 ShellKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
30846 ShellKey & UnsetVertexVisibilities();
30852 ShellKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
30857 ShellKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
30862 ShellKey & UnsetVertexEverything();
30878 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_apply_to, MaterialTypeArray & out_types,
30879 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
30895 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_apply_to, MaterialTypeArray & out_types,
30896 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
30907 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
30917 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
30924 bool ShowNetVertexNormalsByRange(
size_t in_start,
size_t in_count, VectorArray & out_normals)
const;
30935 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
30946 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30957 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
30968 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30979 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30989 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30997 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
31004 ShellKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
31011 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
31018 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
31024 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
31031 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
31037 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
31045 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
31052 ShellKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
31059 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
31066 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
31072 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
31079 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
31085 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
31093 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31100 ShellKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
31107 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
31114 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
31120 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
31127 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
31133 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
31141 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31148 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31155 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31162 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
31168 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
31175 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
31181 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
31192 ShellKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
31197 ShellKey & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
31208 ShellKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
31213 ShellKey & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
31218 ShellKey & UnsetFaceVisibilities();
31224 ShellKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
31229 ShellKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
31246 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31258 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31269 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31279 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
31287 bool ShowNetFaceNormalsByRange(
size_t in_start,
size_t in_count, VectorArray & out_normals)
const;
31295 bool ShowNetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray & out_normals)
const;
31306 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31316 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31325 ShellKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
31332 ShellKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
31339 ShellKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
31346 ShellKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
31353 ShellKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
31362 ShellKey & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
31369 ShellKey & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
31376 ShellKey & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
31386 ShellKey & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
31395 ShellKey & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
31449 void Consume(
MeshKit & in_kit);
31453 void Set(
MeshKit const & in_kit);
31457 void Show(
MeshKit & out_kit)
const;
31466 bool Empty()
const;
31471 bool Equals(
MeshKit const & in_kit)
const;
31476 bool operator==(
MeshKit const & in_kit)
const;
31481 bool operator!=(
MeshKit const & in_kit)
const;
31485 size_t GetPointCount()
const;
31493 MeshKit & SetPriority(
int in_priority);
31502 bool ShowPriority(
int & out_priority)
const;
31507 MeshKit & SetPoints(PointArray
const & in_points);
31513 MeshKit & SetPoints(
size_t in_count,
Point const in_points []);
31520 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns, HPS::PointArray
const & in_points);
31528 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
31533 MeshKit & SetRows(
size_t in_rows);
31538 MeshKit & SetColumns(
size_t in_columns);
31559 bool ShowPoints(PointArray & out_points)
const;
31566 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
31572 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
31579 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
31586 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
31591 bool ShowRows(
size_t & out_rows)
const;
31596 bool ShowColumns(
size_t & out_columns)
const;
31776 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31782 MeshKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
31789 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
31796 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
31802 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
31809 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
31815 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
31824 MeshKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
31832 MeshKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
31842 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);
31851 MeshKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
31859 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31865 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31872 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31879 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
31885 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
31892 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
31898 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
31903 MeshKit & UnsetMaterialMapping();
31907 MeshKit & UnsetVertexColors();
31913 MeshKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
31918 MeshKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
31942 MeshKit & UnsetVertexNormals();
31948 MeshKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
31953 MeshKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
31958 MeshKit & UnsetVertexParameters();
31964 MeshKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
31969 MeshKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
31974 MeshKit & UnsetVertexVisibilities();
31980 MeshKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
31985 MeshKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
31990 MeshKit & UnsetVertexEverything();
32011 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_apply_to, MaterialTypeArray & out_types,
32012 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32028 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_apply_to, MaterialTypeArray & out_types,
32029 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32040 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32050 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
32062 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
32073 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32084 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
32095 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32106 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32116 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32124 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
32130 MeshKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
32137 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
32144 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
32150 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
32157 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
32163 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
32171 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
32177 MeshKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
32184 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
32191 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
32197 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
32204 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
32210 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
32218 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32224 MeshKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32231 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32238 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
32244 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
32251 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
32257 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
32265 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32271 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32278 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32285 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
32291 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
32298 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
32304 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
32315 MeshKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
32320 MeshKit & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
32325 MeshKit & UnsetFaceNormals();
32331 MeshKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
32336 MeshKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
32341 MeshKit & UnsetFaceVisibilities();
32347 MeshKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
32352 MeshKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
32357 MeshKit & UnsetFaceEverything();
32369 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32381 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32392 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32402 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
32413 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32423 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32430 MeshKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
32436 MeshKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
32442 MeshKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
32447 MeshKit & UnsetUserData(intptr_t in_index);
32453 MeshKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
32458 MeshKit & UnsetUserData(IntPtrTArray
const & in_indices);
32462 MeshKit & UnsetAllUserData();
32465 size_t ShowUserDataCount()
const;
32470 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
32476 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
32482 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
32526 void Consume(
MeshKit & in_kit);
32530 void Set(
MeshKit const & in_kit);
32534 void Show(
MeshKit & out_kit)
const;
32538 size_t GetPointCount()
const;
32545 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
32553 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
32558 bool ShowPoints(PointArray & out_points)
const;
32565 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
32571 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
32578 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
32585 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
32590 bool ShowRows(
size_t & out_rows)
const;
32595 bool ShowColumns(
size_t & out_columns)
const;
32606 MeshKey & UnsetMaterialMapping();
32787 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32794 MeshKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32801 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32808 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
32814 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
32821 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
32827 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
32837 MeshKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
32845 MeshKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
32855 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);
32864 MeshKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
32872 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32879 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32886 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32893 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
32899 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
32906 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
32912 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
32917 MeshKey & UnsetVertexColors();
32923 MeshKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
32928 MeshKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
32952 MeshKey & UnsetVertexNormals();
32958 MeshKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
32963 MeshKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
32968 MeshKey & UnsetVertexParameters();
32974 MeshKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
32979 MeshKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
32984 MeshKey & UnsetVertexVisibilities();
32990 MeshKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
32995 MeshKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
33000 MeshKey & UnsetVertexEverything();
33020 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_apply_to, MaterialTypeArray & out_types,
33021 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
33037 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_apply_to, MaterialTypeArray & out_types,
33038 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
33049 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
33059 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
33071 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
33082 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
33093 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
33104 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
33115 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33125 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33133 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
33140 MeshKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
33147 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
33154 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
33160 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
33167 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
33173 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
33181 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
33188 MeshKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
33195 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
33202 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
33208 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
33215 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
33221 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
33229 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
33236 MeshKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
33243 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
33250 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
33256 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
33263 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
33269 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
33277 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
33284 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
33291 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
33298 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
33304 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
33311 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
33317 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
33328 MeshKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
33333 MeshKey & UnsetFaceColorsByList(SizeTArray
const & in_faces);
33338 MeshKey & UnsetFaceNormals();
33344 MeshKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
33349 MeshKey & UnsetFaceNormalsByList(SizeTArray
const & in_faces);
33354 MeshKey & UnsetFaceVisibilities();
33360 MeshKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
33365 MeshKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_faces);
33370 MeshKey & UnsetFaceEverything();
33382 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33394 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33405 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
33415 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
33426 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33436 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33446 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[]);
33455 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);
33505 bool Empty()
const;
33510 bool Equals(
PolygonKit const & in_kit)
const;
33515 bool operator==(
PolygonKit const & in_kit)
const;
33520 bool operator!=(
PolygonKit const & in_kit)
const;
33524 size_t GetPointCount()
const;
33541 bool ShowPriority(
int & out_priority)
const;
33547 PolygonKit & SetPoints(PointArray
const & in_points);
33566 bool ShowPoints(PointArray & out_points)
const;
33573 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
33579 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
33586 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
33593 PolygonKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33599 PolygonKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
33605 PolygonKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
33612 PolygonKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33618 PolygonKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
33625 PolygonKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
33631 PolygonKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
33637 PolygonKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
33642 PolygonKit & UnsetUserData(intptr_t in_index);
33648 PolygonKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
33653 PolygonKit & UnsetUserData(IntPtrTArray
const & in_indices);
33660 size_t ShowUserDataCount()
const;
33665 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
33671 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
33677 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
33732 size_t GetPointCount()
const;
33737 PolygonKey & SetPoints(PointArray
const & in_points);
33748 bool ShowPoints(PointArray & out_points)
const;
33755 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
33761 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
33768 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
33775 PolygonKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33781 PolygonKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
33787 PolygonKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
33794 PolygonKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33800 PolygonKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
33827 void Consume(
GridKit & in_kit);
33831 void Set(
GridKit const & in_kit);
33835 void Show(
GridKit & out_kit)
const;
33849 bool Empty()
const;
33854 bool Equals(
GridKit const & in_kit)
const;
33859 bool operator==(
GridKit const & in_kit)
const;
33864 bool operator!=(
GridKit const & in_kit)
const;
33873 GridKit & SetPriority(
int in_priority);
33891 GridKit & SetFirstPoint(
Point const & in_first_point);
33900 GridKit & SetSecondPoint(
Point const & in_second_point);
33915 GridKit & SetFirstCount(
int in_first_count);
33927 GridKit & SetSecondCount(
int in_second_count);
33948 GridKit & UnsetSecondPoint();
33956 GridKit & UnsetSecondCount();
33966 bool ShowPriority(
int & out_priority)
const;
33976 bool ShowOrigin(
Point & out_origin)
const;
33981 bool ShowFirstPoint(
Point & out_first_point)
const;
33986 bool ShowSecondPoint(
Point & out_second_point)
const;
33991 bool ShowFirstCount(
int & out_first_count)
const;
33996 bool ShowSecondCount(
int & out_second_count)
const;
34003 GridKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
34009 GridKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
34015 GridKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
34020 GridKit & UnsetUserData(intptr_t in_index);
34026 GridKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
34031 GridKit & UnsetUserData(IntPtrTArray
const & in_indices);
34035 GridKit & UnsetAllUserData();
34038 size_t ShowUserDataCount()
const;
34043 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
34049 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
34055 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
34096 void Consume(
GridKit & in_kit);
34100 void Set(
GridKit const & in_kit);
34104 void Show(
GridKit & out_kit)
const;
34123 GridKey & SetFirstPoint(
Point const & in_first_point);
34132 GridKey & SetSecondPoint(
Point const & in_second_point);
34147 GridKey & SetFirstCount(
int in_first_count);
34159 GridKey & SetSecondCount(
int in_second_count);
34171 bool ShowOrigin(
Point & out_origin)
const;
34176 bool ShowFirstPoint(
Point & out_first_point)
const;
34181 bool ShowSecondPoint(
Point & out_second_point)
const;
34186 bool ShowFirstCount(
int & out_first_count)
const;
34191 bool ShowSecondCount(
int & out_second_count)
const;
34267 bool ShowPriority(
int & out_priority)
const;
34272 bool ShowCondition(
Condition & out_condition)
const;
34294 IncludeKey & SetFilter(AttributeLockTypeArray
const & in_types);
34316 IncludeKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
34323 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
34398 bool ShowCondition(
Condition & out_condition)
const;
34421 StyleKey & SetFilter(AttributeLockTypeArray
const & in_types);
34443 StyleKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
34450 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
34501 Key GetTarget()
const;
34506 size_t ShowTargets(
bool masked=
true)
const;
34512 size_t ShowTargets(KeyArray & out_keys,
bool masked=
true)
const;
34517 size_t ShowGeometryMask()
const;
34523 size_t ShowGeometryMask(SearchTypeArray & out_geometry_types)
const;
34528 ReferenceKey & SetGeometryMask(SearchTypeArray
const & in_geometry_types);
34536 void SetModellingMatrix(
MatrixKit const & in_kit);
34550 void UnsetModellingMatrix();
34560 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
34565 bool ShowCondition(
Condition & out_condition)
const;
34604 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowOptionsKit; };
34626 bool Empty()
const;
34712 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34717 bool ShowTitle(
UTF8 & out_window_name)
const;
34722 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
34732 bool ShowFullScreen(
bool & out_state)
const;
34766 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowOptionsControl; };
34798 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34803 bool ShowTitle(
UTF8 & out_window_name)
const;
34808 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
34818 bool ShowFullScreen(
bool & out_state)
const;
34823 bool ShowWindowHandle(WindowHandle & out_window_handle)
const;
34856 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowOptionsKit; };
34878 bool Empty()
const;
34962 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34967 bool ShowHardwareResident(
bool & out_state)
const;
34979 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
35007 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowOptionsKit; };
35029 bool Empty()
const;
35096 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
35101 bool ShowPlatformData(PlatformData & out_platform_data)
const;
35106 bool ShowFramebufferRetention(
bool & out_retain)
const;
35137 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowOptionsControl; };
35148 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
35158 bool ShowWindowHandle(WindowHandle & out_window_handle)
const;
35163 bool ShowPlatformData(PlatformData & out_platform_data)
const;
35168 bool ShowFramebufferRetention(
bool & out_retain)
const;
35219 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowKey; };
35270 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowKey; };
35347 void SetIndexedColor(byte in_index);
35350 void SetNormalColor();
35354 void SetExplicitColor(
RGBAColor const & in_color);
35408 HPS::Type
ObjectType()
const {
return HPS::Type::LineGlyphElement; };
35412 void SetPoints(GlyphPointArray
const & in_points);
35417 void SetPoints(
size_t in_count,
GlyphPoint const in_points[]);
35422 bool ShowPoints(GlyphPointArray & out_points)
const;
35467 bool ShowPoint(
GlyphPoint & out_point)
const;
35505 HPS::Type
ObjectType()
const {
return HPS::Type::EllipseGlyphElement; };
35509 void SetLowerLeft(
GlyphPoint const & in_point);
35513 void SetUpperRight(
GlyphPoint const & in_point);
35523 bool ShowLowerLeft(
GlyphPoint & out_point)
const;
35528 bool ShowUpperRight(
GlyphPoint & out_point)
const;
35560 HPS::Type
ObjectType()
const {
return HPS::Type::SphereGlyphElement; };
35599 HPS::Type
ObjectType()
const {
return HPS::Type::CircularArcGlyphElement; };
35603 void SetStartPoint(
GlyphPoint const & in_point);
35607 void SetIntermediatePoint(
GlyphPoint const & in_point);
35611 void SetEndPoint(
GlyphPoint const & in_point);
35622 bool ShowStartPoint(
GlyphPoint & out_point)
const;
35627 bool ShowIntermediatePoint(
GlyphPoint & out_point)
const;
35632 bool ShowEndPoint(
GlyphPoint & out_point)
const;
35672 HPS::Type
ObjectType()
const {
return HPS::Type::InfiniteLineGlyphElement; };
35676 void SetFirstPoint(
GlyphPoint const & in_point);
35680 void SetSecondPoint(
GlyphPoint const & in_point);
35694 bool ShowFirstPoint(
GlyphPoint & out_point)
const;
35699 bool ShowSecondPoint(
GlyphPoint & out_point)
const;
35741 void Set(
GlyphKit const & in_kit);
35745 void Show(
GlyphKit & out_kit)
const;
35754 bool Empty()
const;
35759 bool Equals(
GlyphKit const & in_kit)
const;
35764 bool operator==(
GlyphKit const & in_kit)
const;
35769 bool operator!=(
GlyphKit const & in_kit)
const;
35774 GlyphKit & SetRadius(sbyte in_radius);
35785 GlyphKit & SetElements(GlyphElementArray
const & in_def);
35812 bool ShowRadius(sbyte & out_radius)
const;
35817 bool ShowOffset(
GlyphPoint & out_point)
const;
35822 bool ShowElements(GlyphElementArray & out_def)
const;
35854 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternOptionsKit; };
35871 bool Empty()
const;
35997 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternElement; };
36069 HPS::Type
ObjectType()
const {
return HPS::Type::SolidLinePatternElement; };
36074 void SetColor(
RGBAColor const & in_color);
36079 void SetMaterialByIndex(
float in_material_index);
36124 HPS::Type
ObjectType()
const {
return HPS::Type::BlankLinePatternElement; };
36162 HPS::Type
ObjectType()
const {
return HPS::Type::GlyphLinePatternElement; };
36166 void SetSource(
char const * in_source);
36179 void SetMirror(
bool in_state);
36183 void SetFixed(
bool in_state);
36187 void SetRotation(
float in_degrees);
36192 bool ShowSource(
UTF8 & out_source)
const;
36208 bool ShowMirror(
bool & out_state)
const;
36213 bool ShowFixed(
bool & out_state)
const;
36218 bool ShowRotation(
float & out_degrees)
const;
36244 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternParallelKit; };
36261 bool Empty()
const;
36401 bool ShowBody(LinePatternElementArray & out_elements)
const;
36406 bool ShowAbsoluteLength(
bool & out_state)
const;
36411 bool ShowAbsoluteWeight(
bool & out_state)
const;
36435 bool ShowContinuous(
bool & out_state)
const;
36484 bool Empty()
const;
36504 LinePatternKit & SetParallels(LinePatternParallelKitArray
const & in_parallels);
36532 bool ShowParallels(LinePatternParallelKitArray & out_parallels)
const;
36590 virtual void Assign(
Definition const & in_that);
36595 bool Equals(
Definition const & in_that)
const;
36600 bool operator==(
Definition const & in_that)
const;
36605 bool operator!=(
Definition const & in_that)
const;
36751 ShaderDefinition DefineShader(
char const * in_name, ShaderKit
const & in_source);
36774 PortfolioKey & UndefineNamedStyle(
char const * in_name);
36779 PortfolioKey & UndefineMaterialPalette(
char const * in_name);
36789 PortfolioKey & UndefineLinePattern(
char const * in_name);
36902 ShaderDefinition ImportShader(ShaderDefinition
const & in_definition);
36907 size_t GetDefinitionCount()
const;
36910 size_t GetTextureDefinitionCount()
const;
36913 size_t GetCubeMapDefinitionCount()
const;
36916 size_t GetImageDefinitionCount()
const;
36919 size_t GetNamedStyleDefinitionCount()
const;
36922 size_t GetMaterialPaletteDefinitionCount()
const;
36925 size_t GetGlyphDefinitionCount()
const;
36928 size_t GetLinePatternDefinitionCount()
const;
36932 size_t GetShaderDefinitionCount()
const;
36938 bool ShowTextureDefinition(
char const * in_name,
TextureDefinition & out_found)
const;
36943 bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions)
const;
36949 bool ShowCubeMapDefinition(
char const * in_name,
CubeMapDefinition & out_found)
const;
36954 bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions)
const;
36960 bool ShowImageDefinition(
char const * in_name,
ImageDefinition & out_found)
const;
36965 bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions)
const;
36976 bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions)
const;
36987 bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions)
const;
36993 bool ShowGlyphDefinition(
char const * in_name,
GlyphDefinition & out_found)
const;
36998 bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions)
const;
37009 bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions)
const;
37015 bool ShowShaderDefinition(
char const * in_name, ShaderDefinition & out_found)
const;
37020 bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions)
const;
37024 void MoveTo(
SegmentKey const & in_new_owner);
37070 void Set(
GlyphKit const & in_kit);
37074 void Show(
GlyphKit & out_kit)
const;
37112 HPS::Type
ObjectType()
const {
return HPS::Type::TextureDefinition; };
37157 HPS::Type
ObjectType()
const {
return HPS::Type::TextureOptionsKit; };
37179 bool Empty()
const;
37285 bool ShowDecal(
bool & out_state)
const;
37290 bool ShowDownSampling(
bool & out_state)
const;
37295 bool ShowModulation(
bool & out_state)
const;
37300 bool ShowParameterOffset(
size_t & out_offset)
const;
37325 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
37374 HPS::Type
ObjectType()
const {
return HPS::Type::ImageExportOptionsKit; };
37396 bool Empty()
const;
37417 ExportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37441 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37472 HPS::Type
ObjectType()
const {
return HPS::Type::ImageImportOptionsKit; };
37489 bool Empty()
const;
37512 ImportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37555 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37565 bool ShowDownSampling(
bool & out_state)
const;
37570 bool ShowCompressionQuality(
float & out_quality)
const;
37599 static void Export(
char const * in_file_name,
HPS::WindowKey const & in_window,
unsigned int in_width,
unsigned int in_height,
Format in_format = Format::Png);
37605 static void Export(
char const * in_file_name,
HPS::ImageKit const & in_image_kit);
37651 void Set(
ImageKit const & in_kit);
37655 void Show(
ImageKit & out_kit)
const;
37664 bool Empty()
const;
37669 bool Equals(
ImageKit const & in_kit)
const;
37674 bool operator==(
ImageKit const & in_kit)
const;
37679 bool operator!=(
ImageKit const & in_kit)
const;
37694 ImageKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37699 ImageKit & SetData(ByteArray
const & in_image_data);
37705 ImageKit & SetData(
size_t in_byte_count, byte
const in_image_data []);
37715 ImageKit & SetDownSampling(
bool in_state);
37720 ImageKit & SetCompressionQuality(
float in_quality);
37740 ImageKit & UnsetCompressionQuality();
37750 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37755 bool ShowData(ByteArray & out_image_data)
const;
37765 bool ShowDownSampling(
bool & out_state)
const;
37770 bool ShowCompressionQuality(
float & out_quality)
const;
37802 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowOptionsControl; };
37830 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
37836 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37848 bool ShowImage(ByteArray & out_bytes)
const;
37853 bool ShowHardwareResident(
bool & out_state)
const;
37859 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
37904 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowKey; };
37961 void Set(
ImageKit const & in_kit);
37965 void Show(
ImageKit & out_kit)
const;
38002 HPS::Type
ObjectType()
const {
return HPS::Type::CubeMapDefinition; };
38029 void ShowSource(ImageDefinitionArray & out_image_sources)
const;
38075 HPS::Type
ObjectType()
const {
return HPS::Type::NamedStyleDefinition; };
38118 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialPaletteDefinition; };
38122 void Set(MaterialKitArray
const & in_source);
38127 void Set(
size_t in_count,
MaterialKit const in_source []);
38131 void Show(MaterialKitArray & out_source)
const;
38170 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternDefinition; };
38184 class HPS_API Shader
38189 enum class Parameterization
38194 PhysicalReflection,
38216 class HPS_API ImportOptionsKit :
public Object
38220 ImportOptionsKit();
38224 ImportOptionsKit(ImportOptionsKit
const & in_kit);
38229 ImportOptionsKit(ImportOptionsKit && in_that);
38234 ImportOptionsKit & operator=(ImportOptionsKit && in_that);
38236 virtual ~ImportOptionsKit();
38238 HPS::Type ObjectType()
const {
return HPS::Type::ShaderImportOptionsKit; };
38242 void Set(ImportOptionsKit
const & in_kit);
38246 void Show(ImportOptionsKit & out_kit)
const;
38251 ImportOptionsKit & operator=(ImportOptionsKit
const & in_kit);
38255 bool Empty()
const;
38260 bool Equals(ImportOptionsKit
const & in_kit)
const;
38265 bool operator==(ImportOptionsKit
const & in_kit)
const;
38270 bool operator!=(ImportOptionsKit
const & in_kit)
const;
38278 ImportOptionsKit & SetMultitexture(
bool in_state);
38283 ImportOptionsKit & SetParameterizationSource(Parameterization in_source);
38288 ImportOptionsKit & SetTransformMatrix(MatrixKit
const & in_transform);
38293 ImportOptionsKit & UnsetMultitexture();
38297 ImportOptionsKit & UnsetParameterizationSource();
38301 ImportOptionsKit & UnsetTransformMatrix();
38305 ImportOptionsKit & UnsetEverything();
38312 bool ShowMultitexture(
bool & out_state)
const;
38317 bool ShowParameterizationSource(Parameterization & out_source)
const;
38322 bool ShowTransformMatrix(MatrixKit & out_transform)
const;
38334 static ShaderKit Import(
char const * in_file_name, ImportOptionsKit
const & in_options);
38348 class HPS_API ShaderKit :
public Object
38356 ShaderKit(ShaderKit
const & in_kit);
38361 ShaderKit(ShaderKit && in_that);
38366 ShaderKit & operator=(ShaderKit && in_that);
38368 virtual ~ShaderKit();
38370 HPS::Type ObjectType()
const {
return HPS::Type::ShaderKit; };
38374 void Set(ShaderKit
const & in_kit);
38378 void Show(ShaderKit & out_kit)
const;
38383 ShaderKit & operator=(ShaderKit
const & in_kit);
38387 bool Empty()
const;
38392 bool Equals(ShaderKit
const & in_kit)
const;
38397 bool operator==(ShaderKit
const & in_kit)
const;
38402 bool operator!=(ShaderKit
const & in_kit)
const;
38407 ShaderKit & SetSource(
char const * in_source);
38415 ShaderKit & SetMultitexture(
bool in_state);
38420 ShaderKit & SetParameterizationSource(Shader::Parameterization in_source);
38425 ShaderKit & SetTransformMatrix(MatrixKit
const & in_transform);
38429 ShaderKit & UnsetSource();
38434 ShaderKit & UnsetMultitexture();
38438 ShaderKit & UnsetParameterizationSource();
38442 ShaderKit & UnsetTransformMatrix();
38446 ShaderKit & UnsetEverything();
38451 bool ShowSource(UTF8 & out_source)
const;
38458 bool ShowMultitexture(
bool & out_state)
const;
38463 bool ShowParameterizationSource(Shader::Parameterization & out_source)
const;
38468 bool ShowTransformMatrix(MatrixKit & out_transform)
const;
38473 class HPS_API ShaderDefinition :
public Definition
38477 ShaderDefinition();
38483 ShaderDefinition(Definition
const & in_that);
38487 ShaderDefinition(ShaderDefinition
const & in_that);
38492 ShaderDefinition & operator=(ShaderDefinition
const & in_that);
38497 ShaderDefinition(ShaderDefinition && in_that);
38502 ShaderDefinition & operator=(ShaderDefinition && in_that);
38504 ~ShaderDefinition();
38506 HPS::Type ObjectType()
const {
return HPS::Type::ShaderDefinition; };
38510 void Set(ShaderKit
const & in_kit);
38514 void Show(ShaderKit & out_kit)
const;
38546 HPS::Type
ObjectType()
const {
return HPS::Type::CutGeometryGatheringOptionsKit;};
38568 bool Empty()
const;
38627 bool ShowOffset(
size_t & out_offset)
const;
38680 bool Empty()
const;
38747 bool ShowCriteria(SearchTypeArray & out_types)
const;
38752 bool ShowSearchSpace(
Search::Space & out_search_space)
const;
38797 bool operator==(
TreeContext const & in_that)
const;
38802 bool operator!=(
TreeContext const & in_that)
const;
38829 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionOptionsKit;};
38851 bool Empty()
const;
39033 bool ShowProximity(
float & out_proximity)
const;
39043 bool ShowInternalLimit(
size_t & out_limit)
const;
39048 bool ShowRelatedLimit(
size_t & out_limit)
const;
39053 bool ShowSorting(
bool & out_sorted)
const;
39068 bool ShowScope(
KeyPath & out_start_path)
const;
39073 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
39078 bool ShowExtentCullingRespected(
bool & out_state)
const;
39083 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
39088 bool ShowFrustumCullingRespected(
bool & out_state)
const;
39093 bool ShowVectorCullingRespected(
bool & out_state)
const;
39124 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionOptionsControl;};
39223 bool ShowProximity(
float & out_proximity)
const;
39233 bool ShowInternalLimit(
size_t & out_limit)
const;
39238 bool ShowRelatedLimit(
size_t & out_limit)
const;
39243 bool ShowSorting(
bool & out_sorted)
const;
39258 bool ShowExtentCullingRespected(
bool & out_state)
const;
39263 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
39268 bool ShowFrustumCullingRespected(
bool & out_state)
const;
39273 bool ShowVectorCullingRespected(
bool & out_state)
const;
39339 bool ShowSelectedItem(
Key & out_selection)
const;
39344 bool ShowPath(
KeyPath & out_path)
const;
39349 bool ShowFaces(SizeTArray & out_faces)
const;
39354 bool ShowVertices(SizeTArray & out_vertices)
const;
39360 bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2)
const;
39365 bool ShowCharacters(SizeTArray & out_characters)
const;
39370 bool ShowSelectionPosition(
WindowPoint & out_location)
const;
39375 bool ShowSelectionPosition(
WorldPoint & out_location)
const;
39403 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionResultsIterator;}
39436 bool IsValid()
const;
39504 virtual void Reset();
39512 size_t GetCount()
const;
39618 size_t SelectByPolygon(PointArray
const & in_points,
SelectionResults & out_results)
const;
39633 size_t SelectByPolygon(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
39646 size_t SelectByLine(PointArray
const & in_points,
SelectionResults & out_results)
const;
39661 size_t SelectByLine(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
39763 HPS::Type
ObjectType()
const {
return HPS::Type::HighlightOptionsKit;};
39785 bool Empty()
const;
39853 bool ShowStyleName(
UTF8 & out_style_name)
const;
39858 bool ShowSecondaryStyleName(
UTF8 & out_style_name)
const;
39868 bool ShowNotification(
bool & out_state)
const;
40022 bool Empty()
const;
40070 bool ShowTimeLimit(HPS::Time & out_time_limit)
const;
40104 HPS::Type
ObjectType()
const {
return HPS::Type::UpdateOptionsControl;};
40141 bool ShowTimeLimit(HPS::Time & out_time_limit)
const;
40156 World(
char const * in_license);
40167 World & SetMaterialLibraryDirectory(
char const * in_directory);
40173 World & SetFontDirectory(
char const * in_directory);
40180 World & SetFontDirectories(
size_t in_count,
UTF8 const in_directories[]);
40186 World & SetFontDirectories(UTF8Array
const & in_directories);
40193 World & SetDriverConfigFile(
char const * in_filename);
40200 World & SetExchangeLibraryDirectory(
char const * in_directory);
40207 World & SetPublishResourceDirectory(
char const * in_directory);
40213 World & SetParasolidSchemaDirectory(
char const * in_directory);
40219 World & SetRealDWGDirectory(
char const * in_directory);
40226 World & SetRealDWGDirectory(
char const * in_directory, UTF8Array
const & in_object_enabler_directories);
40233 World & SetParasolidBodyshopDirectory(
char const * in_directory);
40237 World & UnsetMaterialLibraryDirectory();
40241 World & UnsetFontDirectories();
40245 World & UnsetDriverConfigFile();
40249 World & UnsetExchangeLibraryDirectory();
40253 World & UnsetPublishResourceDirectory();
40257 World & UnsetParasolidSchemaDirectory();
40261 World & UnsetRealDWGDirectory();
40265 World & UnsetParasolidBodyshopDirectory();
40270 bool ShowLicense(
UTF8 & out_license)
const;
40275 bool ShowMaterialLibraryDirectory(
UTF8 & out_directory)
const;
40280 bool ShowFontDirectories(UTF8Array & out_directories)
const;
40285 bool ShowDriverConfigFile(
UTF8 & out_filename)
const;
40290 bool ShowExchangeLibraryDirectory(
UTF8 & out_directory)
const;
40295 bool ShowPublishResourceDirectory(
UTF8 & out_directory)
const;
40300 bool ShowParasolidSchemaDirectory(
UTF8 & out_directory)
const;
40306 bool ShowRealDWGDirectory(
UTF8 & out_directory, UTF8Array & out_object_enabler_directories)
const;
40311 bool ShowParasolidBodyshopDirectory(
UTF8 & out_directory)
const;
40319 virtual void Reset() {}
40348 intptr_t GetClassID()
const;
40359 static void *
operator new (
size_t in_size){
return Memory::Allocate(in_size); }
40360 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
40373 static void Execute(
bool in_once=
true);
40377 static Time GetTime();
40380 static void Sleep(Time milliseconds);
40406 static void RelinquishMemory();
40434 static void ShowMemoryUsage(
size_t & out_allocated,
size_t & out_used);
40443 static void Reset();
40446 static void Synchronize();
40450 static WindowKeyArray GetWindowKeys();
40454 static SegmentKeyArray GetRootSegments();
40458 static PortfolioKeyArray GetPortfolios();
40464 static PortfolioKey const GetMaterialLibraryPortfolio();
40540 static size_t SelectByShell(
ShellKit const & in_shell,
40550 static size_t SelectByShell(
ShellKey const & in_shell,
40561 static size_t SelectByVolume(
SimpleCuboid const & in_volume,
40572 static size_t SelectByRay(
Point const & in_start_point,
Vector const & in_direction,
40600 static bool SetInformationEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40606 static bool SetWarningEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40612 static bool SetErrorEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40620 static void UnsetEmergencyHandler();
40624 static size_t GetSoftMemoryLimit();
40629 static size_t SetSoftMemoryLimit(
size_t in_limit_bytes);
40698 bool Subscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
40704 bool UnSubscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
40710 bool UnSubscribe(
EventHandler const & in_handler)
const;
40715 bool UnSubscribe(intptr_t in_type)
const;
40720 bool InjectEvent(
Event const & in_event)
const;
40730 void Shutdown()
const;
40734 bool IsShutdown()
const;
40739 void SetName(
char const * in_name)
const;
40743 void ShowName(
UTF8 & out_name)
const;
40747 virtual void Reset() {}
40786 bool Subscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
40792 bool UnSubscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
40800 void UnSubscribeEverything()
const;
40803 virtual void Reset() { UnSubscribeEverything(); }
40833 channel = GetClassID();
40834 consumable =
false;
40842 if(in_event.
GetChannel() != Object::ClassID<TimerTickEvent>())
40861 HPS_UNREFERENCED(in_that_event);
40866 return GetClassID();
40884 channel = GetClassID();
40885 consumable =
false;
40886 action = Action::None;
40890 :
Event(), action(in_action), results(in_results), options(in_options)
40892 channel = GetClassID();
40893 consumable =
false;
40900 if (in_event.
GetChannel() == Object::ClassID<HighlightEvent>())
40903 action = that.action;
40904 results = that.results;
40905 options = that.options;
40946 if (in_event.
GetChannel() == Object::ClassID<InformationEvent>())
40950 code =
event->code;
40973 return message == in_that.
message && code == in_that.
code;
40981 return Equals(in_that);
40989 return !Equals(in_that);
41006 WarningEvent(
char const * in_message) :
Event(), message(in_message), code(HPS::
Info::Code::Unknown) { channel = GetClassID(); }
41017 if(in_event.
GetChannel() == Object::ClassID<WarningEvent>())
41021 code =
event->code;
41044 return message == in_that.
message && code == in_that.
code;
41052 return Equals(in_that);
41060 return !Equals(in_that);
41077 ErrorEvent(
char const * in_message) :
Event(), message(in_message), code(HPS::
Info::Code::Unknown) { channel = GetClassID(); }
41088 if(in_event.
GetChannel() == Object::ClassID<ErrorEvent>())
41092 code =
event->code;
41115 return message == in_that.
message && code == in_that.
code;
41123 return Equals(in_that);
41131 return !Equals(in_that);
41166 if(in_event.
GetChannel() == Object::ClassID<StandAloneWindowEvent>())
41192 return action == in_that.
action;
41200 return Equals(in_that);
41208 return !Equals(in_that);
41221 { channel = GetClassID(); }
41249 if(in_event.
GetChannel() == Object::ClassID<UpdateCompletedEvent>())
41252 update_time =
event->update_time;
41280 , import_status_message(HPS::
UTF8())
41281 { channel = GetClassID(); }
41285 , import_status_message(in_message)
41286 { channel = GetClassID(); }
41292 if (in_event.
GetChannel() == Object::ClassID<ImportStatusEvent>())
41295 import_status_message =
event.import_status_message;
41326 return modifiers == in_that.modifiers;
41334 return Equals(in_that);
41342 return !Equals(in_that);
41347 bool None()
const {
return modifiers == _key_none; }
41351 bool Shift()
const {
return (modifiers & _key_shift) != 0; }
41355 bool Control()
const {
return (modifiers & _key_control) != 0; }
41359 bool Alt()
const {
return (modifiers & _key_alt) != 0; }
41363 bool Meta()
const {
return (modifiers & _key_meta) != 0; }
41369 bool HasAll(
ModifierKeys const & in_keys)
const {
return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
41379 void Shift(
bool in_state) {
if(in_state) modifiers |= _key_shift;
else modifiers &= ~(_key_shift); }
41383 void Control(
bool in_state) {
if(in_state) modifiers |= _key_control;
else modifiers &= ~(_key_control); }
41387 void Alt(
bool in_state) {
if(in_state) modifiers |= _key_alt;
else modifiers &= ~(_key_alt); }
41391 void Meta(
bool in_state) {
if(in_state) modifiers |= _key_meta;
else modifiers &= ~(_key_meta); }
41399 ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
41409 ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
41446 _key_none = 0x0000,
41447 _key_shift = 0x0001,
41448 _key_control = 0x0002,
41450 _key_meta = 0x0008,
41493 return Equals(in_that);
41501 return !Equals(in_that);
41508 return ModifierKeyState;
41535 :
InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
41543 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
41552 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
41559 if(in_event.
GetChannel() == Object::ClassID<TouchEvent>())
41562 channel = GetClassID();
41563 CurrentAction =
event->CurrentAction;
41564 Touches =
event->Touches;
41565 ModifierKeyState =
event->ModifierKeyState;
41595 return Equals(in_that);
41603 return !Equals(in_that);
41613 if (CurrentAction == that_touch_event->
CurrentAction && CurrentAction == Action::Move
41614 && Touches.size() == that_touch_event->
Touches.size() )
41616 TouchArray these_touches = Touches;
41617 TouchArray those_touches = that_touch_event->
Touches;
41619 std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
41620 std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
41622 for (
size_t i = 0 ; i < these_touches.size() ; i++)
41624 if (these_touches[i].ID != those_touches[i].ID)
41642 static bool sort_predicate(
Touch const & in_a,
Touch const & in_b)
41644 return static_cast<int>(in_a.
ID) < static_cast<int>(in_b.
ID);
41661 return buttons == in_that.buttons;
41669 return Equals(in_that);
41677 return !Equals(in_that);
41682 bool None()
const {
return buttons == _button_none; }
41686 bool Left()
const {
return (buttons & _button_left) != 0; }
41690 bool Right()
const {
return (buttons & _button_right) != 0; }
41694 bool Middle()
const {
return (buttons & _button_middle) != 0; }
41698 bool X1()
const {
return (buttons & _button_x1) != 0; }
41702 bool X2()
const {
return (buttons & _button_x2) != 0; }
41708 bool HasAll(
MouseButtons const & in_buttons)
const {
return (buttons & in_buttons.buttons) == in_buttons.buttons; }
41717 void Left(
bool in_state) {
if(in_state) buttons |= _button_left;
else buttons &= ~(_button_left); }
41721 void Right(
bool in_state) {
if(in_state) buttons |= _button_right;
else buttons &= ~(_button_right); }
41725 void Middle(
bool in_state) {
if(in_state) buttons |= _button_middle;
else buttons &= ~(_button_middle); }
41729 void X1(
bool in_state) {
if(in_state) buttons |= _button_x1;
else buttons &= ~(_button_x1); }
41733 void X2(
bool in_state) {
if(in_state) buttons |= _button_x2;
else buttons &= ~(_button_x2); }
41741 ret.buttons = buttons | in_buttons_to_merge.buttons;
41751 ret.buttons = buttons & ~in_buttons_to_remove.buttons;
41792 _button_none = 0x0000,
41793 _button_left = 0x0001,
41794 _button_right = 0x0002,
41795 _button_middle = 0x0004,
41796 _button_x1 = 0x0008,
41797 _button_x2 = 0x0010
41830 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
41840 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
41846 if(in_event.
GetChannel() == Object::ClassID<MouseEvent>())
41849 channel = GetClassID();
41850 CurrentAction =
event->CurrentAction;
41851 Location =
event->Location;
41852 CurrentButton =
event->CurrentButton;
41853 WheelDelta =
event->WheelDelta;
41854 ClickCount =
event->ClickCount;
41887 return Equals(in_that);
41895 return !Equals(in_that);
41906 (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
41915 if (CurrentAction == Action::Move)
41916 return GetClassID();
41949 :
InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
41957 :
InputEvent(in_modifiers), CurrentAction(in_action)
41959 channel = GetClassID();
41960 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41968 :
InputEvent(in_modifiers), CurrentAction(in_action)
41970 channel = GetClassID();
41971 KeyboardCodes = in_keyboardcodes;
41978 if(in_event.
GetChannel() == Object::ClassID<KeyboardEvent>())
41981 channel = GetClassID();
41982 KeyboardCodes =
event->KeyboardCodes;
41983 CurrentAction =
event->CurrentAction;
42014 return Equals(in_that);
42022 return !Equals(in_that);
42030 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
42037 KeyboardCodes = in_keyboardcodes;
42082 bool Equals(
MouseState const & in_that)
const;
42087 bool operator== (
MouseState const & in_that)
const;
42092 bool operator!= (
MouseState const & in_that)
const;
42120 HPS::KeyArray GetEventPath()
const;
42136 void SetActiveEvent(
MouseEvent const & in_event);
42140 void SetEventPath(KeyArray
const & in_path);
42194 bool Equals(
TouchState const & in_that)
const;
42199 bool operator== (
TouchState const & in_that)
const;
42204 bool operator!= (
TouchState const & in_that)
const;
42225 HPS::KeyArray GetEventPath()
const;
42229 size_t GetTouchCount()
const;
42233 HPS::TouchArray GetTouches()
const;
42241 void SetActiveEvent(
TouchEvent const & in_event);
42245 void SetEventPath(KeyArray
const & in_path);
42249 void SetTouches(TouchArray
const & in_touches);
42326 HPS::KeyArray GetEventPath()
const;
42330 size_t GetKeyboardCodeCount()
const;
42334 HPS::KeyboardCodeArray GetKeyboardCodes()
const;
42339 bool GetKeyState(HPS::KeyboardCode in_key_code)
const;
42351 void SetEventPath(KeyArray
const & in_path);
42355 void SetKeyboardCodes(KeyboardCodeArray
const & in_keyboard_codes);
42407 IOResult Status()
const;
42412 IOResult Status(
float & out_percent_complete)
const;
42456 virtual void Restart();
42463 static Toolkit CreateToolkit();
42477 intptr_t GetClassID()
const;
42501 GeometryExportEvent & operator=(GeometryExportEvent
const &);
42503 GeometryExportEvent();
42504 virtual ~GeometryExportEvent();
42505 GeometryExportEvent(
HPS::Key & in_key);
42515 SegmentExportEvent & operator=(SegmentExportEvent
const &);
42517 SegmentExportEvent();
42518 virtual ~SegmentExportEvent();
42535 intptr_t GetClassID()
const;
42561 AttributeLockImportEvent & operator=(AttributeLockImportEvent
const &);
42563 AttributeLockImportEvent();
42564 virtual ~AttributeLockImportEvent();
42574 BoundingImportEvent & operator=(BoundingImportEvent
const &);
42576 BoundingImportEvent();
42577 virtual ~BoundingImportEvent();
42587 CameraImportEvent & operator=(CameraImportEvent
const &);
42589 CameraImportEvent();
42590 virtual ~CameraImportEvent();
42600 CircleImportEvent & operator=(CircleImportEvent
const &);
42602 CircleImportEvent();
42603 virtual ~CircleImportEvent();
42613 CircularArcImportEvent & operator=(CircularArcImportEvent
const &);
42615 CircularArcImportEvent();
42616 virtual ~CircularArcImportEvent();
42626 CircularWedgeImportEvent & operator=(CircularWedgeImportEvent
const &);
42628 CircularWedgeImportEvent();
42629 virtual ~CircularWedgeImportEvent();
42639 ColorInterpolationImportEvent & operator=(ColorInterpolationImportEvent
const &);
42641 ColorInterpolationImportEvent();
42642 virtual ~ColorInterpolationImportEvent();
42652 CommentImportEvent & operator=(CommentImportEvent
const &);
42654 CommentImportEvent();
42655 virtual ~CommentImportEvent();
42656 CommentImportEvent(
HPS::SegmentKey & in_segment_key,
const char* in_comment);
42665 ConditionImportEvent & operator=(ConditionImportEvent
const &);
42667 ConditionImportEvent();
42668 virtual ~ConditionImportEvent();
42672 HPS::UTF8Array conditions;
42678 ContourLineImportEvent & operator=(ContourLineImportEvent
const &);
42680 ContourLineImportEvent();
42681 virtual ~ContourLineImportEvent();
42691 CuttingSectionImportEvent & operator=(CuttingSectionImportEvent
const &);
42693 CuttingSectionImportEvent();
42694 virtual ~CuttingSectionImportEvent();
42704 CuttingSectionAttributeImportEvent & operator=(CuttingSectionAttributeImportEvent
const &);
42706 CuttingSectionAttributeImportEvent();
42707 virtual ~CuttingSectionAttributeImportEvent();
42717 CubeMapDefinitionImportEvent & operator=(CubeMapDefinitionImportEvent
const &);
42719 CubeMapDefinitionImportEvent();
42720 virtual ~CubeMapDefinitionImportEvent();
42741 CullingImportEvent & operator=(CullingImportEvent
const &);
42743 CullingImportEvent();
42744 virtual ~CullingImportEvent();
42754 CurveAttributeImportEvent & operator=(CurveAttributeImportEvent
const &);
42756 CurveAttributeImportEvent();
42757 virtual ~CurveAttributeImportEvent();
42767 CylinderAttributeImportEvent & operator=(CylinderAttributeImportEvent
const &);
42769 CylinderAttributeImportEvent();
42770 virtual ~CylinderAttributeImportEvent();
42780 CylinderImportEvent & operator=(CylinderImportEvent
const &);
42782 CylinderImportEvent();
42783 virtual ~CylinderImportEvent();
42793 DistantLightPropertyImportEvent & operator=(DistantLightPropertyImportEvent
const &);
42795 DistantLightPropertyImportEvent();
42796 virtual ~DistantLightPropertyImportEvent();
42806 DistantLightImportEvent & operator=(DistantLightImportEvent
const &);
42808 DistantLightImportEvent();
42809 virtual ~DistantLightImportEvent();
42819 DrawingAttributeImportEvent & operator=(DrawingAttributeImportEvent
const &);
42821 DrawingAttributeImportEvent();
42822 virtual ~DrawingAttributeImportEvent();
42832 EdgeAttributeImportEvent & operator=(EdgeAttributeImportEvent
const &);
42834 EdgeAttributeImportEvent();
42835 virtual ~EdgeAttributeImportEvent();
42845 EllipseImportEvent & operator=(EllipseImportEvent
const &);
42847 EllipseImportEvent();
42848 virtual ~EllipseImportEvent();
42858 EllipticalArcImportEvent & operator=(EllipticalArcImportEvent
const &);
42860 EllipticalArcImportEvent();
42861 virtual ~EllipticalArcImportEvent();
42871 GlyphDefinitionImportEvent & operator=(GlyphDefinitionImportEvent
const &);
42873 GlyphDefinitionImportEvent();
42874 virtual ~GlyphDefinitionImportEvent();
42885 GridImportEvent & operator=(GridImportEvent
const &);
42888 virtual ~GridImportEvent();
42898 HiddenLineAttributeImportEvent & operator=(HiddenLineAttributeImportEvent
const &);
42900 HiddenLineAttributeImportEvent();
42901 virtual ~HiddenLineAttributeImportEvent();
42911 ImageDefinitionImportEvent & operator=(ImageDefinitionImportEvent
const &);
42913 ImageDefinitionImportEvent();
42914 virtual ~ImageDefinitionImportEvent();
42925 IncludeSegmentImportEvent & operator=(IncludeSegmentImportEvent
const &);
42927 IncludeSegmentImportEvent();
42928 virtual ~IncludeSegmentImportEvent();
42934 HPS::AttributeLockTypeArray filter_types;
42940 InfiniteLineImportEvent & operator=(InfiniteLineImportEvent
const &);
42942 InfiniteLineImportEvent();
42943 virtual ~InfiniteLineImportEvent();
42953 LightingAttributeImportEvent & operator=(LightingAttributeImportEvent
const &);
42955 LightingAttributeImportEvent();
42956 virtual ~LightingAttributeImportEvent();
42966 LineAttributeImportEvent & operator=(LineAttributeImportEvent
const &);
42968 LineAttributeImportEvent();
42969 virtual ~LineAttributeImportEvent();
42979 LineImportEvent & operator=(LineImportEvent
const &);
42982 virtual ~LineImportEvent();
42992 LinePatternDefinitionImportEvent & operator=(LinePatternDefinitionImportEvent
const &);
42994 LinePatternDefinitionImportEvent();
42995 virtual ~LinePatternDefinitionImportEvent();
43006 MarkerImportEvent & operator=(MarkerImportEvent
const &);
43008 MarkerImportEvent();
43009 virtual ~MarkerImportEvent();
43019 MarkerAttributeImportEvent & operator=(MarkerAttributeImportEvent
const &);
43021 MarkerAttributeImportEvent();
43022 virtual ~MarkerAttributeImportEvent();
43032 MaterialImportEvent & operator=(MaterialImportEvent
const &);
43034 MaterialImportEvent();
43035 virtual ~MaterialImportEvent();
43045 MaterialPaletteDefinitionImportEvent & operator=(MaterialPaletteDefinitionImportEvent
const &);
43047 MaterialPaletteDefinitionImportEvent();
43048 virtual ~MaterialPaletteDefinitionImportEvent();
43049 MaterialPaletteDefinitionImportEvent(
HPS::PortfolioKey & in_portfolio_key,
HPS::UTF8 && in_name, HPS::MaterialKitArray & in_material_mapping_kit_array);
43053 HPS::MaterialKitArray & material_mapping_kit_array;
43059 MaterialPaletteImportEvent & operator=(MaterialPaletteImportEvent
const &);
43061 MaterialPaletteImportEvent();
43062 virtual ~MaterialPaletteImportEvent();
43072 MatrixImportEvent & operator=(MatrixImportEvent
const &);
43074 MatrixImportEvent();
43075 virtual ~MatrixImportEvent();
43085 MeshImportEvent & operator=(MeshImportEvent
const &);
43088 virtual ~MeshImportEvent();
43098 MeshInstanceImportEvent & operator=(MeshInstanceImportEvent
const &);
43100 MeshInstanceImportEvent();
43101 virtual ~MeshInstanceImportEvent();
43112 NamedStyleDefinitionImportEvent & operator=(NamedStyleDefinitionImportEvent
const &);
43114 NamedStyleDefinitionImportEvent();
43115 virtual ~NamedStyleDefinitionImportEvent();
43126 NamedStyleImportEvent & operator=(NamedStyleImportEvent
const &);
43128 NamedStyleImportEvent();
43129 virtual ~NamedStyleImportEvent();
43135 HPS::AttributeLockTypeArray filter_types;
43141 NURBSCurveImportEvent & operator=(NURBSCurveImportEvent
const &);
43143 NURBSCurveImportEvent();
43144 virtual ~NURBSCurveImportEvent();
43154 NURBSSurfaceImportEvent & operator=(NURBSSurfaceImportEvent
const &);
43156 NURBSSurfaceImportEvent();
43157 virtual ~NURBSSurfaceImportEvent();
43167 NURBSSurfaceAttributeImportEvent & operator=(NURBSSurfaceAttributeImportEvent
const &);
43169 NURBSSurfaceAttributeImportEvent();
43170 virtual ~NURBSSurfaceAttributeImportEvent();
43180 PerformanceImportEvent & operator=(PerformanceImportEvent
const &);
43182 PerformanceImportEvent();
43183 virtual ~PerformanceImportEvent();
43193 PolygonImportEvent & operator=(PolygonImportEvent
const &);
43195 PolygonImportEvent();
43196 virtual ~PolygonImportEvent();
43206 PriorityImportEvent & operator=(PriorityImportEvent
const &);
43208 PriorityImportEvent();
43209 virtual ~PriorityImportEvent();
43210 PriorityImportEvent(
HPS::Key & in_key,
int in_priority);
43219 ReferenceGeometryImportEvent & operator=(ReferenceGeometryImportEvent
const &);
43221 ReferenceGeometryImportEvent();
43222 virtual ~ReferenceGeometryImportEvent();
43226 HPS::Key & reference_geometry_key;
43233 SegmentImportEvent & operator=(SegmentImportEvent
const &);
43235 SegmentImportEvent();
43236 virtual ~SegmentImportEvent();
43246 SelectabilityImportEvent & operator=(SelectabilityImportEvent
const &);
43248 SelectabilityImportEvent();
43249 virtual ~SelectabilityImportEvent();
43259 ShaderDefinitionImportEvent & operator=(ShaderDefinitionImportEvent
const &);
43261 ShaderDefinitionImportEvent();
43262 virtual ~ShaderDefinitionImportEvent();
43267 HPS::ShaderKit & shader_kit;
43273 ShellImportEvent & operator=(ShellImportEvent
const &);
43275 ShellImportEvent();
43276 virtual ~ShellImportEvent();
43286 ShellInstanceImportEvent & operator=(ShellInstanceImportEvent
const &);
43288 ShellInstanceImportEvent();
43289 virtual ~ShellInstanceImportEvent();
43300 SphereImportEvent & operator=(SphereImportEvent
const &);
43302 SphereImportEvent();
43303 virtual ~SphereImportEvent();
43313 SphereAttributeImportEvent & operator=(SphereAttributeImportEvent
const &);
43315 SphereAttributeImportEvent();
43316 virtual ~SphereAttributeImportEvent();
43326 SpotlightImportEvent & operator=(SpotlightImportEvent
const &);
43328 SpotlightImportEvent();
43329 virtual ~SpotlightImportEvent();
43339 StyleSegmentImportEvent & operator=(StyleSegmentImportEvent
const &);
43341 StyleSegmentImportEvent();
43342 virtual ~StyleSegmentImportEvent();
43348 HPS::AttributeLockTypeArray filter_types;
43354 TextImportEvent & operator=(TextImportEvent
const &);
43357 virtual ~TextImportEvent();
43367 TextAttributeImportEvent & operator=(TextAttributeImportEvent
const &);
43369 TextAttributeImportEvent();
43370 virtual ~TextAttributeImportEvent();
43381 TextureDefinitionImportEvent & operator=(TextureDefinitionImportEvent
const &);
43383 TextureDefinitionImportEvent();
43384 virtual ~TextureDefinitionImportEvent();
43397 TransformMaskImportEvent & operator=(TransformMaskImportEvent
const &);
43399 TransformMaskImportEvent();
43400 virtual ~TransformMaskImportEvent();
43410 TransparencyImportEvent & operator=(TransparencyImportEvent
const &);
43412 TransparencyImportEvent();
43413 virtual ~TransparencyImportEvent();
43423 SubwindowImportEvent & operator=(SubwindowImportEvent
const &);
43425 SubwindowImportEvent();
43426 virtual ~SubwindowImportEvent();
43437 NonDBUserDataImportEvent & operator=(NonDBUserDataImportEvent
const &);
43439 NonDBUserDataImportEvent() {}
43440 virtual ~NonDBUserDataImportEvent();
43441 NonDBUserDataImportEvent(
size_t in_count, HPS::byte
const in_data[]);
43451 UserDataImportEvent & operator=(UserDataImportEvent
const &);
43453 virtual ~UserDataImportEvent();
43454 UserDataImportEvent();
43455 UserDataImportEvent(
HPS::Key & in_key, intptr_t in_index,
size_t in_count, HPS::byte
const in_data[]);
43467 VisibilityImportEvent & operator=(VisibilityImportEvent
const &);
43469 VisibilityImportEvent();
43470 virtual ~VisibilityImportEvent();
43480 VisualEffectsImportEvent & operator=(VisualEffectsImportEvent
const &);
43482 VisualEffectsImportEvent();
43483 virtual ~VisualEffectsImportEvent();
43516 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportOptionsKit; };
43533 bool Empty()
const;
43576 bool ShowSegment(
SegmentKey & out_segment)
const;
43591 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
43606 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
43651 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportResultsKit; };
43668 bool Empty()
const;
43700 bool ShowSegment(
SegmentKey & out_segment)
const;
43718 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
43736 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
43752 bool ShowDefaultCamera(
CameraKit & out_camera)
const;
43760 ImportResultsKit & SetAlternateCameras(UTF8Array
const & in_names, CameraKitArray & in_cameras);
43771 bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras)
const;
43807 HPS::Type
ObjectType()
const {
return HPS::Type::StreamExportOptionsKit; };
43824 bool Empty()
const;
43852 ExportOptionsKit & SetVertexCompression(
bool in_state,
unsigned int in_bits_per_vertex = 24);
43861 ExportOptionsKit & SetNormalCompression(
bool in_state,
unsigned int in_bits_per_normal = 10);
43868 ExportOptionsKit & SetParameterCompression(
bool in_state,
unsigned int in_bits_per_parameter = 8);
43877 ExportOptionsKit & SetColorCompression(
bool in_state,
unsigned int in_bits_per_color = 24);
43886 ExportOptionsKit & SetIndexCompression(
bool in_state,
unsigned int in_bits_per_index = 8);
43910 ExportOptionsKit & SetImageCompression(
bool in_state,
float in_quality = 0.75f);
43961 bool ShowVertexCompression(
bool & out_state,
unsigned int & out_bits_per_vertex)
const;
43967 bool ShowNormalCompression(
bool & out_state,
unsigned int & out_bits_per_normal)
const;
43973 bool ShowParameterCompression(
bool & out_state,
unsigned int & out_bits_per_parameter)
const;
43979 bool ShowColorCompression(
bool & out_state,
unsigned int & out_bits_per_color)
const;
43985 bool ShowIndexCompression(
bool & out_state,
unsigned int & out_bits_per_index)
const;
43990 bool ShowConnectivityCompression(
bool & out_state)
const;
43996 bool ShowImageCompression(
bool & out_state,
float & out_quality)
const;
44001 bool ShowSerializeTristrips(
bool & out_state)
const;
44049 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportNotifier;};
44096 HPS::Type
ObjectType()
const {
return HPS::Type::StreamExportNotifier;};
44176 DotsPerCentimeter = DPCM,
44208 HPS::Type
ObjectType()
const {
return HPS::Type::HardcopyExportOptionsKit; };
44225 bool Empty()
const;
44250 bool ShowSize(
float & out_width,
float & out_height,
Hardcopy::SizeUnits & out_units)
const;
44290 bool ShowWYSIWYG(
bool & out_onoff)
const;
44333 static IOResult Export(
char const * in_filename, Driver in_driver_type,
HPS::WindowKey const & in_window, ExportOptionsKit
const & in_options);
44344 class HPS_API ExportOptionsKit :
public Object
44348 ExportOptionsKit();
44352 ExportOptionsKit(ExportOptionsKit
const & in_kit);
44357 ExportOptionsKit(ExportOptionsKit && in_that);
44362 ExportOptionsKit & operator=(ExportOptionsKit && in_that);
44364 virtual ~ExportOptionsKit();
44366 HPS::Type ObjectType()
const {
return HPS::Type::HardcopyExportOptionsKit; };
44370 void Set(ExportOptionsKit
const & in_kit);
44374 void Show(ExportOptionsKit & out_kit)
const;
44379 ExportOptionsKit & operator=(ExportOptionsKit
const & in_kit);
44383 bool Empty()
const;
44388 bool Equals(ExportOptionsKit
const & in_kit)
const;
44393 bool operator==(ExportOptionsKit
const & in_kit)
const;
44398 bool operator!=(ExportOptionsKit
const & in_kit)
const;
44406 bool ShowResolution(
float & out_resolution)
const;
44411 ExportOptionsKit & SetResolution(
float in_resolution);
44415 ExportOptionsKit & UnsetResolution();
44422 bool ShowWYSIWYG(
bool & out_onoff)
const;
44427 ExportOptionsKit & SetWYSIWYG(
bool in_onoff);
44431 ExportOptionsKit & UnsetWYSIWYG();
44436 ExportOptionsKit & UnsetEverything();
44445 static IOResult Export(intptr_t hdc, intptr_t attribdc,
HPS::WindowKey const & window, ExportOptionsKit
const & options);
44488 HPS::Type
ObjectType()
const {
return HPS::Type::OBJImportOptionsKit; };
44505 bool Empty()
const;
44535 bool ShowSegment(
SegmentKey & out_segment)
const;
44550 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
44596 HPS::Type
ObjectType()
const {
return HPS::Type::OBJImportResultsKit; };
44613 bool Empty()
const;
44645 bool ShowSegment(
SegmentKey & out_segment)
const;
44663 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
44787 HPS::Type
ObjectType()
const {
return HPS::Type::STLImportOptionsKit; };
44804 bool Empty()
const;
44866 bool ShowSegment(
SegmentKey & out_segment)
const;
44898 HPS::Type
ObjectType()
const {
return HPS::Type::STLImportResultsKit; };
44915 bool Empty()
const;
44947 bool ShowSegment(
SegmentKey & out_segment)
const;
45025 # pragma warning(pop)
HPS::Type ObjectType() const
Definition: hps.h:40161
Rotation
Definition: hps.h:1607
HPS::Type ObjectType() const
Definition: hps.h:27085
bool Empty() const
Definition: hps.h:6859
CameraPoint(Point const &in_point)
Definition: hps.h:5810
Alignment
Definition: hps.h:1540
Space
Definition: hps.h:561
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:41922
Channel
Definition: hps.h:945
HPS::Type ObjectType() const
Definition: hps.h:24257
Handedness
Definition: hps.h:1276
ColorSource
Definition: hps.h:1933
HPS::Type ObjectType() const
Definition: hps.h:17186
HPS::Type ObjectType() const
Definition: hps.h:36462
Event(intptr_t in_channel=0)
Definition: hps.h:6163
HPS::Type ObjectType() const
Definition: hps.h:44717
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3764
HPS::ByteArray user_data
Definition: hps.h:43444
float alpha
Definition: hps.h:4303
HPS::Type ObjectType() const
Definition: hps.h:36069
bool operator==(Touch const &in_that) const
Definition: hps.h:6453
Both cylinder ends will be capped.
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:41379
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:41135
size_t display_list_tristrip_count
Number of tristrips drawn from display lists during the last update.
Definition: hps.h:4821
HPS::Type ObjectType() const
Definition: hps.h:34496
HPS::Type ObjectType() const
Definition: hps.h:21988
HPS::Type ObjectType() const
Definition: hps.h:23785
size_t extent_culled_segment_count
Number of segments culled because of extent culling during the last update.
Definition: hps.h:4827
HPS::Type ObjectType() const
Definition: hps.h:24531
Action
Definition: hps.h:41520
Orientation
Definition: hps.h:537
Code
Definition: hps.h:134
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1331
Multiline strings will be left justfied.
HPS::Type ObjectType() const
Definition: hps.h:15063
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:41190
HPS::Type ObjectType() const
Definition: hps.h:8648
HPS::Type ObjectType() const
Definition: hps.h:28313
Event * Clone() const
Definition: hps.h:41033
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:41839
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:40821
ImportStatusEvent()
Definition: hps.h:41278
HPS::Type ObjectType() const
Definition: hps.h:21603
HPS::Type ObjectType() const
Definition: hps.h:36244
HPS::Type ObjectType() const
Definition: hps.h:26048
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:41585
size_t frustum_culled_segment_count
Number of segments culled because of frustum culling during the last update.
Definition: hps.h:4826
HPS::Type ObjectType() const
Definition: hps.h:30353
HPS::Type ObjectType() const
Definition: hps.h:25659
HPS::Type ObjectType() const
Definition: hps.h:11726
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, HPS::Info::Code in_code)
Definition: hps.h:41082
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:42028
HPS::Type ObjectType() const
Definition: hps.h:37957
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5707
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5955
Driver
Definition: hps.h:154
HPS::Type ObjectType() const
Definition: hps.h:42068
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2205
HPS::Type ObjectType() const
Definition: hps.h:39305
CappingLevel
Definition: hps.h:1739
virtual void Handle(DriverEvent const *in_event)
Definition: hps.h:8732
HPS::Type ObjectType() const
Definition: hps.h:23512
HPS::Type ObjectType() const
Definition: hps.h:35997
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:12871
size_t dot_3d_count
Number of 3D dots drawn during the last update.
Definition: hps.h:4809
HPS::Type ObjectType() const
Definition: hps.h:42180
HPS::Type ObjectType() const
Definition: hps.h:20640
HPS::Type ObjectType() const
Definition: hps.h:13890
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5558
HPS::Type ObjectType() const
Definition: hps.h:29098
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3871
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41967
static ModifierKeys KeyMeta()
Definition: hps.h:41438
HPS::Type ObjectType() const
Definition: hps.h:35732
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
HPS::Type ObjectType() const
Definition: hps.h:37112
HPS::Type ObjectType() const
Definition: hps.h:44096
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3750
HPS::Type ObjectType() const
Definition: hps.h:39477
HPS::Type ObjectType() const
Definition: hps.h:23710
HPS::Type ObjectType() const
Definition: hps.h:35270
HPS::Type ObjectType() const
Definition: hps.h:16892
HPS::Type ObjectType() const
Definition: hps.h:38546
Time GetTimeStamp() const
Definition: hps.h:6185
HPS::Type ObjectType() const
Definition: hps.h:22506
NormalizedPoint(Point const &in_point)
Definition: hps.h:5860
HPS::Type ObjectType() const
Definition: hps.h:24059
Event * Clone() const
Definition: hps.h:40850
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3799
Renderer
Definition: hps.h:1588
HPS::Type ObjectType() const
Definition: hps.h:34232
KeyboardEvent()
Definition: hps.h:41943
HPS::Type ObjectType() const
Definition: hps.h:7372
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3992
ObjectPoint(Point const &in_point)
Definition: hps.h:5710
HPS::Type ObjectType() const
Definition: hps.h:17773
Object space units ignoring any scaling components in modelling matrices.
Point_3D< F > min
Definition: hps.h:3734
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:41164
static ModifierKeys KeyAlt()
Definition: hps.h:41434
bool IsConsumable() const
Definition: hps.h:6188
HPS::ByteArray user_data
Definition: hps.h:43461
MaterialPreference
Definition: hps.h:1756
size_t line_dc_count
Number of DC lines drawn during the last update.
Definition: hps.h:4810
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41956
Mobility
Definition: hps.h:194
HPS::Type ObjectType() const
Definition: hps.h:13382
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5908
InterpolationAlgorithm
Definition: hps.h:1523
Fill
Definition: hps.h:1924
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3787
HPS::Type ObjectType() const
Definition: hps.h:27590
HPS::Type ObjectType() const
Definition: hps.h:19273
char At(size_t in_index) const
Definition: hps.h:6902
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:41374
HPS::Type ObjectType() const
Definition: hps.h:36124
ReferenceFrame
Definition: hps.h:1555
size_t polygon_dc_count
Number of DC polygons drawn during the last update.
Definition: hps.h:4814
HPS::Type ObjectType() const
Definition: hps.h:17100
GreekingUnits
Definition: hps.h:1642
HPS::Type ObjectType() const
Definition: hps.h:12280
InnerConeUnits
Definition: hps.h:486
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6004
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:3904
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:41240
OuterConeUnits
Definition: hps.h:472
HPS::Type ObjectType() const
Definition: hps.h:19057
HPS::Type ObjectType() const
Definition: hps.h:40672
size_t culled_display_list_tristrip_count
Number of tristrips from display lists culled during the last update.
Definition: hps.h:4823
HPS::Type ObjectType() const
Definition: hps.h:39574
HPS::Type ObjectType() const
Definition: hps.h:14491
HPS::Type ObjectType() const
Definition: hps.h:33715
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:42035
HPS::Type ObjectType() const
Definition: hps.h:26984
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41609
HPS::Type ObjectType() const
Definition: hps.h:12754
HPS::Type ObjectType() const
Definition: hps.h:25241
HPS::Type ObjectType() const
Definition: hps.h:36575
Channel
Definition: hps.h:904
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:41064
AreaUnits
Definition: hps.h:1469
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3841
HPS::Type ObjectType() const
Definition: hps.h:12101
HPS::Type ObjectType() const
Definition: hps.h:34856
Action
Definition: hps.h:41146
HPS::Type ObjectType() const
Definition: hps.h:14327
HPS::Type ObjectType() const
Definition: hps.h:43807
HPS::Type ObjectType() const
Definition: hps.h:27691
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6468
HPS::Type ObjectType() const
Definition: hps.h:38075
HPS::Type ObjectType() const
Definition: hps.h:34369
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41542
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3950
Border
Definition: hps.h:264
UpdateControl
Definition: hps.h:175
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:41369
Time update_time
Time taken by the last update.
Definition: hps.h:4829
size_t vector_culled_segment_count
Number of segments culled because of vector culling during the last update.
Definition: hps.h:4828
HPS::Type ObjectType() const
Definition: hps.h:23262
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:42004
HPS::Type ObjectType() const
Definition: hps.h:21528
WarningEvent(Event const &in_event)
Definition: hps.h:41015
HPS::Type ObjectType() const
Definition: hps.h:11598
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1943
static ModifierKeys KeyShift()
Definition: hps.h:41426
HPS::Type ObjectType() const
Definition: hps.h:28824
Shape
Definition: hps.h:1073
bool IsValid() const
Definition: hps.h:6852
Cuboid_3D()
Definition: hps.h:3742
ErrorEvent(Event const &in_event)
Definition: hps.h:41086
size_t GetWStrLength() const
Definition: hps.h:6881
Event * Clone() const
Definition: hps.h:40915
HPS::Type ObjectType() const
Definition: hps.h:11187
AppendMode
Definition: hps.h:332
static void Free(void *in_pointer)
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3935
void Meta(bool in_state)
Definition: hps.h:41391
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6103
HPS::Type ObjectType() const
Definition: hps.h:14769
UpdateStatus
Definition: hps.h:164
HPS_INLINE bool IsValid() const
Definition: hps.h:3792
HPS::Type ObjectType() const
Definition: hps.h:38658
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:41211
Quality
Definition: hps.h:1057
ResolutionUnits
Definition: hps.h:44172
TimerTickEvent(Event const &in_event)
Definition: hps.h:40840
Component
Definition: hps.h:352
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6054
HPS::Type ObjectType() const
Definition: hps.h:12367
Default
Definition: hps.h:1897
HPS::Type ObjectType() const
Definition: hps.h:10816
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5078
size_t triangle_3d_count
Number of 3D triangles drawn during the last update.
Definition: hps.h:4813
bool Shift() const
Definition: hps.h:41351
SizeToleranceUnits
Definition: hps.h:1629
HPS::Type ObjectType() const
Definition: hps.h:38782
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4021
Cap
Definition: hps.h:1848
Point_3D< F > max
Definition: hps.h:3736
HPS::Type ObjectType() const
Definition: hps.h:7455
HPS::Type ObjectType() const
Definition: hps.h:44488
HPS::Type ObjectType() const
Definition: hps.h:44596
MouseEvent()
Definition: hps.h:41821
HPS::Type ObjectType() const
Definition: hps.h:12206
HPS::Type ObjectType() const
Definition: hps.h:16799
HPS::Type ObjectType() const
Definition: hps.h:35315
Material Texture Channel.
static const float Infinity
Definition: hps.h:2200
InsetBehavior
Definition: hps.h:1829
HPS::Type ObjectType() const
Definition: hps.h:25167
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2213
HPS::Type ObjectType() const
Definition: hps.h:13778
HPS::Type ObjectType() const
Definition: hps.h:27284
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6467
HPS::Type ObjectType() const
Definition: hps.h:35505
HPS::Type ObjectType() const
Definition: hps.h:37802
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3914
Algorithm
Definition: hps.h:1457
Decimation
Definition: hps.h:1014
Granularity
Definition: hps.h:1378
Search the current segment only.
size_t display_list_line_3d_count
Number of lines drawn from display lists during the last update.
Definition: hps.h:4818
KeyboardEvent(Event const &in_event)
Definition: hps.h:41976
ClipOperation
Definition: hps.h:1305
HPS::Type ObjectType() const
Definition: hps.h:8990
Method
Definition: hps.h:1447
HPS::Type ObjectType() const
Definition: hps.h:26704
Parameterization
Definition: hps.h:959
FocusLostEvent()
Definition: hps.h:41219
CuttingLevel
Definition: hps.h:1748
Channel
Definition: hps.h:925
HandleResult
Definition: hps.h:40811
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5090
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:41134
Value
Definition: hps.h:1428
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2221
Code
Definition: hps.h:104
HPS::Type ObjectType() const
Definition: hps.h:26200
Event * Clone() const
Definition: hps.h:41227
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:41875
ErrorEvent()
Definition: hps.h:41073
Justification
Definition: hps.h:1563
The vertex colors applied to faces.
HPS::Type ObjectType() const
Definition: hps.h:14151
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5576
ErrorEvent(char const *in_message)
Definition: hps.h:41077
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:41247
FrameSize
Definition: hps.h:205
Justification
Definition: hps.h:1865
HPS::Type ObjectType() const
Definition: hps.h:11924
HPS::Type ObjectType() const
Definition: hps.h:19920
HPS::Type ObjectType() const
Definition: hps.h:22337
HPS::Type ObjectType() const
Definition: hps.h:8773
HPS::Type ObjectType() const
Definition: hps.h:37066
HPS::Type ObjectType() const
Definition: hps.h:35219
GreekingMode
Definition: hps.h:1654
HPS::Type ObjectType() const
Definition: hps.h:20432
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:42040
Operation
Definition: hps.h:455
HPS::Type ObjectType() const
Definition: hps.h:37647
Type
Definition: hps.h:2012
WorldPoint(Point const &in_point)
Definition: hps.h:5760
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:41634
HPS::Type ObjectType() const
Definition: hps.h:10013
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2492
HPS::Type ObjectType() const
Definition: hps.h:6699
TouchEvent(Event const &in_event)
Definition: hps.h:41557
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6984
Relation
Definition: hps.h:378
Action
Definition: hps.h:41935
ChannelMapping
Definition: hps.h:1028
HPS::Type ObjectType() const
Definition: hps.h:22854
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5593
HPS::Type ObjectType() const
Definition: hps.h:39124
HPS::Type ObjectType() const
Definition: hps.h:39763
bool Alt() const
Definition: hps.h:41359
ToleranceUnits
Definition: hps.h:361
HPS::Type ObjectType() const
Definition: hps.h:12680
SizeUnits
Definition: hps.h:1816
Type
Definition: hps.h:2029
The vertex colors applied to faces.
HPS::Type ObjectType() const
Definition: hps.h:35560
RelationTest
Definition: hps.h:388
Type
Definition: hps.h:323
HPS::Type ObjectType() const
Definition: hps.h:14915
Behavior
Definition: hps.h:570
Ambient Occulsion Quality.
HPS::Type ObjectType() const
Definition: hps.h:6774
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:42041
HPS::Type ObjectType() const
Definition: hps.h:18821
ImageFormat
Definition: hps.h:220
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5567
float blue
Definition: hps.h:4302
A grid of lines will be drawn in place of characters below the greeking limit.
Type
Definition: hps.h:428
HPS::Type ObjectType() const
Definition: hps.h:21260
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:7002
PixelPoint(Point const &in_point)
Definition: hps.h:6106
HPS::Type ObjectType() const
Definition: hps.h:6228
HPS::Type ObjectType() const
Definition: hps.h:7091
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41901
size_t non_display_list_tristrip_count
Number of tristrips drawn during the last update.
Definition: hps.h:4822
HPS::Type ObjectType() const
Definition: hps.h:21865
size_t display_list_vertex_3d_count
Number of vertices drawn from display lists during the last update.
Definition: hps.h:4820
HPS::Type ObjectType() const
Definition: hps.h:21744
Percentage of the requested font size defining the lower limit on the smallest font size that can be ...
HPS::Type ObjectType() const
Definition: hps.h:35458
HPS::Type ObjectType() const
Definition: hps.h:28967
HPS::Type ObjectType() const
Definition: hps.h:24330
HPS::Type ObjectType() const
Definition: hps.h:39403
HPS::Type ObjectType() const
Definition: hps.h:21125
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:41921
Event * Clone() const
Definition: hps.h:41305
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5084
HPS::Type ObjectType() const
Definition: hps.h:34766
HPS::Type ObjectType() const
Definition: hps.h:40780
Alignment and justification will be defined relative to a screen-facing box around the text...
HPS::Type ObjectType() const
Definition: hps.h:15947
Infinite line which extends infinitely in both directions along a vector.
size_t line_3d_count
Number of 3D lines drawn during the last update.
Definition: hps.h:4811
intptr_t GetChannel() const
Definition: hps.h:6182
HPS::Type ObjectType() const
Definition: hps.h:9382
Algorithm
Definition: hps.h:1358
HPS::Type ObjectType() const
Definition: hps.h:31445
HPS::Type ObjectType() const
Definition: hps.h:38118
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3859
Driver
Definition: hps.h:44322
SizeUnits
Definition: hps.h:1684
StandAloneWindowEvent()
Definition: hps.h:41155
HPS::Type ObjectType() const
Definition: hps.h:36644
HPS::Type ObjectType() const
Definition: hps.h:34604
HPS::Type ObjectType() const
Definition: hps.h:12517
HPS::Type ObjectType() const
Definition: hps.h:11337
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:41042
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41829
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5539
HPS::Type ObjectType() const
Definition: hps.h:17613
Level
Definition: hps.h:1349
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:41324
void Control(bool in_state)
Definition: hps.h:41383
HPS::Type ObjectType() const
Definition: hps.h:44049
HPS::Type ObjectType() const
Definition: hps.h:18327
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:4006
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:41063
The base class of all HPS exceptions.
Definition: hps.h:5531
RegionAlignment
Definition: hps.h:1663
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41551
Event * Clone() const
Definition: hps.h:41866
HPS::Type ObjectType() const
Definition: hps.h:21409
void Invalidate()
Definition: hps.h:3804
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4798
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5590
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:41243
HPS::Type ObjectType() const
Definition: hps.h:34092
HPS::Type ObjectType() const
Definition: hps.h:40000
HPS::ByteArray non_db_user_data
Definition: hps.h:42480
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6175
char const * GetBytes() const
Definition: hps.h:6888
virtual intptr_t Freshen() const
Definition: hps.h:41913
HPS::Type ObjectType() const
Definition: hps.h:35599
float green
Definition: hps.h:4301
Action
Definition: hps.h:41810
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1708
HPS::Type ObjectType() const
Definition: hps.h:10419
HPS::Type ObjectType() const
Definition: hps.h:27356
HPS::Type ObjectType() const
Definition: hps.h:24848
size_t triangle_dc_count
Number of DC triangles drawn during the last update.
Definition: hps.h:4812
HPS::Type ObjectType() const
Definition: hps.h:24604
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
HPS::Type ObjectType() const
Definition: hps.h:38170
HPS::Type ObjectType() const
Definition: hps.h:24969
InnerPixelPoint(Point const &in_point)
Definition: hps.h:6007
ImportStatusEvent(Event const &in_event)
Definition: hps.h:41290
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5857
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6447
static const float NegativeInfinity
Definition: hps.h:2202
HighlightEvent(Event const &in_event)
Definition: hps.h:40898
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6993
SizeUnits
Definition: hps.h:1489
HPS::Type ObjectType() const
Definition: hps.h:12958
HPS::Type ObjectType() const
Definition: hps.h:20819
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:41923
HPS::Type ObjectType() const
Definition: hps.h:10640
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5958
GatheringLevel
Definition: hps.h:1764
HPS::Type ObjectType() const
Definition: hps.h:29177
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3771
FrameOptions
Definition: hps.h:214
HPS::Type ObjectType() const
Definition: hps.h:35408
Space
Definition: hps.h:8606
void Alt(bool in_state)
Definition: hps.h:41387
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41948
HPS::Type ObjectType() const
Definition: hps.h:37374
Type
Definition: hps.h:258
bool operator!=(Touch const &in_that) const
Definition: hps.h:6461
Type
Definition: hps.h:446
HPS::Type ObjectType() const
Definition: hps.h:43516
HPS::Type ObjectType() const
Definition: hps.h:44898
HPS::Type ObjectType() const
Definition: hps.h:44787
HPS::Type ObjectType() const
Definition: hps.h:33823
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5757
HPS::Type ObjectType() const
Definition: hps.h:9574
HPS::Type ObjectType() const
Definition: hps.h:44984
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6975
HPS::SegmentKey & segment_key
Definition: hps.h:42522
Event * Clone() const
Definition: hps.h:41576
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:41113
Event * Clone() const
Definition: hps.h:41181
size_t GetLength() const
Definition: hps.h:6873
HPS::Type ObjectType() const
Definition: hps.h:21212
HPS::Type ObjectType() const
Definition: hps.h:26914
Type
Definition: hps.h:1134
HPS::Type ObjectType() const
Definition: hps.h:9490
bool None() const
Definition: hps.h:41347
size_t ClickCount
The number of clicks received.
Definition: hps.h:41925
virtual intptr_t Freshen() const
Definition: hps.h:6179
void Reset()
Definition: hps.h:6868
HPS::Type ObjectType() const
Definition: hps.h:37904
HPS::Type ObjectType() const
Definition: hps.h:23985
HPS::Type ObjectType() const
Definition: hps.h:40104
SizeUnits
Definition: hps.h:1617
Event * Clone() const
Definition: hps.h:41104
MouseEvent(Event const &in_event)
Definition: hps.h:41844
virtual bool Empty() const
Definition: hps.h:5633
Join
Definition: hps.h:1839
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3928
Modifier
Definition: hps.h:1876
size_t dot_dc_count
Number of DC dots drawn during the last update.
Definition: hps.h:4808
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41534
static intptr_t ClassID()
Definition: hps.h:5655
HighlightEvent()
Definition: hps.h:40882
virtual HPS::Type ObjectType() const
Definition: hps.h:5629
HPS::Type ObjectType() const
Definition: hps.h:13972
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:41633
Type
Definition: hps.h:581
virtual intptr_t Freshen() const
Definition: hps.h:40865
Background
Definition: hps.h:239
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3848
static ModifierKeys KeyControl()
Definition: hps.h:41430
HPS::Type ObjectType() const
Definition: hps.h:18541
HPS::Type ObjectType() const
Definition: hps.h:35854
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5905
HPS::Type ObjectType() const
Definition: hps.h:39896
StandAloneWindowEvent(Action in_action)
Definition: hps.h:41160
Mode
Definition: hps.h:1729
size_t segment_count
Number of segments traversed during the last update.
Definition: hps.h:4825
Event * Clone() const
Definition: hps.h:41264
size_t polygon_3d_count
Number of 3D polygons drawn during the last update.
Definition: hps.h:4815
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4065
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3883
size_t display_list_triangle_3d_count
Number of triangles drawn from display lists during the last update.
Definition: hps.h:4819
Type
Definition: hps.h:884
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3836
HPS::Type ObjectType() const
Definition: hps.h:12426
HPS::Type ObjectType() const
Definition: hps.h:32522
HPS::Type ObjectType() const
Definition: hps.h:38002
HPS::Type ObjectType() const
Definition: hps.h:43651
HPS::Type ObjectType() const
Definition: hps.h:42281
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3822
HPS::Type ObjectType() const
Definition: hps.h:37157
HPS::Type ObjectType() const
Definition: hps.h:12576
HPS::Type ObjectType() const
Definition: hps.h:18082
Mode
Definition: hps.h:1782
Event * Clone() const
Definition: hps.h:41995
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:3894
Tiling
Definition: hps.h:987
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4050
WindowPoint(Point const &in_point)
Definition: hps.h:6057
Transform
Definition: hps.h:1572
HPS::Type ObjectType() const
Definition: hps.h:37472
HPS::Key & key
Definition: hps.h:42508
A unitless linear scaling factor. A value of 2.0 will cause edges to be rendered twice as thick...
Grid composed of quadrilaterals.
HPS::Type ObjectType() const
Definition: hps.h:38829
ModifierKeys()
Definition: hps.h:41319
Preference
Definition: hps.h:1597
HPS::Type ObjectType() const
Definition: hps.h:25521
Capping
Definition: hps.h:526
HPS::Type ObjectType() const
Definition: hps.h:35672
TouchEvent()
Definition: hps.h:41528
Interpolation
Definition: hps.h:1003
HPS::Type ObjectType() const
Definition: hps.h:20191
WarningEvent(char const *in_message)
Definition: hps.h:41006
HPS::Type ObjectType() const
Definition: hps.h:20987
Modifiers
Definition: hps.h:41444
Component
Definition: hps.h:518
HPS::Type ObjectType() const
Definition: hps.h:36162
HPS::Type ObjectType() const
Definition: hps.h:6564
HPS::Type ObjectType() const
Definition: hps.h:22768
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4035
HPS::Type ObjectType() const
Definition: hps.h:44208
HPS::Type ObjectType() const
Definition: hps.h:22558
Format
Definition: hps.h:37335
WarningEvent()
Definition: hps.h:41002
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40859
Touch()
Definition: hps.h:6441
size_t polyhedron_count
Number of polyhedra drawn during the last update.
Definition: hps.h:4816
Component
Definition: hps.h:408
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
float red
Definition: hps.h:4300
ClipSpace
Definition: hps.h:1313
Control & operator=(Control &&in_that)
Definition: hps.h:5692
WarningEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:41011
HPS::Type ObjectType() const
Definition: hps.h:14077
SizeUnits
Definition: hps.h:44165
virtual void Reset()
Definition: hps.h:40803
HPS::Type ObjectType() const
Definition: hps.h:11454
bool Meta() const
Definition: hps.h:41363
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4077
TimerTickEvent()
Definition: hps.h:40831
HPS::Type ObjectType() const
Definition: hps.h:22221
RenderingAlgorithm
Definition: hps.h:275
EmergencyHandler()
Definition: hps.h:40343
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5807
TouchID ID
TouchID for this Touch.
Definition: hps.h:6466
HPS::Type ObjectType() const
Definition: hps.h:11017
HPS::Type ObjectType() const
Definition: hps.h:33484
HPS::Type ObjectType() const
Definition: hps.h:8469
HandednessOptimization
Definition: hps.h:369
size_t raster_count
Number of rasters drawn during the last update.
Definition: hps.h:4824
size_t deleted_display_list_count
Number of deleted display lists during the last update.
Definition: hps.h:4817
Projection
Definition: hps.h:1407
Control(Control &&in_that)
Definition: hps.h:5687
bool Control() const
Definition: hps.h:41355
HPS::Type ObjectType() const
Definition: hps.h:35007
HPS::Type ObjectType() const OVERRIDE
Definition: hps.h:8721
Overlay
Definition: hps.h:1285
Status
Definition: hps.h:6155
HPS::Type ObjectType() const
Definition: hps.h:35137
HPS::Type ObjectType() const
Definition: hps.h:6646
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:41924
HPS::Type ObjectType() const
Definition: hps.h:42391