16 # ifdef HPS_CORE_BUILD
17 # define HPS_API __declspec (dllexport)
18 # define EXPIMP_TEMPLATE
20 # define HPS_API __declspec (dllimport)
21 # define EXPIMP_TEMPLATE extern
23 # define HPS_TEMPLATE_API __declspec (dllexport)
33 # pragma warning(push)
34 # pragma warning(disable: 4251) //Not an issue as long as debug and release libraries aren't mixed
40 # ifdef HPS_CORE_BUILD
41 # define HPS_API __attribute__ ((visibility ("default")))
42 # define EXPIMP_TEMPLATE
44 # define EXPIMP_TEMPLATE extern
46 # define HPS_TEMPLATE_API __attribute__ ((visibility ("default")))
53 #ifndef HPS_TEMPLATE_API
54 # define HPS_TEMPLATE_API
56 #ifndef EXPIMP_TEMPLATE
57 # define EXPIMP_TEMPLATE
60 # define ENUM_CLASS enum class
82 class EventDispatcherImpl;
245 GradientTopLeftToBottomRight,
246 GradientTopRightToBottomLeft,
247 GradientBottomLeftToTopRight,
248 GradientBottomRightToTopLeft,
357 FeatureSizePercentage
558 SubsegmentsAndIncludes
599 Everything = 0x00ffffff,
602 Include = 0x00000042,
603 Segment = 0x00000043,
605 Includer = 0x00000100,
608 Geometry = 0x10000000,
615 NURBSSurface = 0x1000002b,
618 Polygon = 0x1000002f,
621 CircularWedge = 0x10000032,
622 Ellipse = 0x10000033,
624 NURBSCurve = 0x10000037,
625 CircularArc = 0x10000038,
626 EllipticalArc = 0x10000039,
631 Reference = 0x10000040,
634 DistantLight = 0x10000100,
636 InfiniteRay = 0x10000102,
639 Attribute = 0x20000000,
641 Priority = 0x20000001,
646 ModellingMatrix = 0x20000010,
647 UserData = 0x20000021,
648 TextureMatrix = 0x20000023,
651 Culling = 0x20001000,
652 CullingBackFace = 0x20001001,
653 CullingExtent = 0x20001002,
654 CullingVector = 0x20001003,
655 CullingVectorTolerance = 0x20001004,
656 CullingFrustum = 0x20001005,
657 CullingDeferralExtent = 0x20001006,
659 CurveAttribute = 0x20002000,
660 CurveAttributeBudget = 0x20002001,
661 CurveAttributeContinuedBudget = 0x20002002,
662 CurveAttributeViewDependent = 0x20002003,
663 CurveAttributeMaximumDeviation = 0x20002004,
664 CurveAttributeMaximumAngle = 0x20002005,
665 CurveAttributeMaximumLength = 0x20002006,
667 CylinderAttribute = 0x20003000,
668 CylinderAttributeTessellation = 0x20003001,
669 CylinderAttributeOrientation = 0x20003002,
672 EdgeAttribute = 0x20004000,
673 EdgeAttributePattern = 0x20004015,
674 EdgeAttributeWeight = 0x20004016,
676 LightingAttribute = 0x20005000,
677 LightingAttributeInterpolation = 0x20005001,
680 LineAttribute = 0x20006000,
681 LineAttributePattern = 0x20006019,
682 LineAttributeWeight = 0x2000601a,
685 MarkerAttribute = 0x20007000,
686 MarkerAttributeSize = 0x2000701b,
687 MarkerAttributeSymbol = 0x2000701c,
689 SurfaceAttribute = 0x20008000,
690 SurfaceAttributeBudget = 0x20008001,
691 SurfaceAttributeMaximumFacetDeviation = 0x20008002,
692 SurfaceAttributeMaximumFacetAngle = 0x20008003,
693 SurfaceAttributeMaximumFacetWidth = 0x20008004,
694 SurfaceAttributeTrimCurveBudget = 0x20008005,
695 SurfaceAttributeMaximumTrimCurveDeviation = 0x20008006,
698 SelectabilityWindows = 0x20009001,
699 SelectabilityEdges = 0x20009002,
700 SelectabilityFaces = 0x20009003,
701 SelectabilityLights = 0x20009004,
702 SelectabilityLines = 0x20009005,
703 SelectabilityMarkers = 0x20009006,
704 SelectabilityVertices = 0x20009007,
705 SelectabilityText = 0x20009008,
707 SphereAttribute = 0x2000a000,
708 SphereAttributeTessellation = 0x2000a001,
711 SubwindowEitherType = 0x2000b001,
712 SubwindowStandard = 0x2000b00d,
713 SubwindowLightweight = 0x2000b002,
714 SubwindowBackground = 0x2000b003,
715 SubwindowBorder = 0x2000b004,
716 SubwindowRenderingAlgorithm = 0x2000b005,
719 TextAttribute = 0x2000c000,
720 TextAttributeAlignment = 0x2000c01d,
721 TextAttributeBold = 0x2000c002,
722 TextAttributeItalic = 0x2000c003,
723 TextAttributeOverline = 0x2000c004,
724 TextAttributeStrikethrough = 0x2000c005,
725 TextAttributeUnderline = 0x2000c006,
726 TextAttributeSlant = 0x2000c007,
727 TextAttributeLineSpacing = 0x2000c008,
728 TextAttributeRotation = 0x2000c00a,
729 TextAttributeExtraSpace = 0x2000c00b,
730 TextAttributeGreeking = 0x2000c00c,
731 TextAttributeSizeTolerance = 0x2000c00d,
732 TextAttributeSize = 0x2000c00e,
733 TextAttributeFont = 0x2000c00f,
734 TextAttributeTransform = 0x2000c010,
735 TextAttributeRenderer = 0x2000c011,
736 TextAttributePreference = 0x2000c012,
737 TextAttributePath = 0x2000c01f,
738 TextAttributeSpacing = 0x2000c020,
741 TransparencyMethod = 0x2000d001,
742 TransparencyAlgorithm = 0x2000d002,
743 TransparencyDepthPeelingLayers = 0x2000d004,
744 TransparencyDepthPeelingMinimumArea = 0x2000d005,
745 TransparencyDepthWriting = 0x2000d006,
747 Visibility = 0x2000e000,
748 VisibilityCuttingSections = 0x2000e001,
749 VisibilityCutEdges = 0x2000e002,
750 VisibilityCutFaces = 0x2000e003,
751 VisibilityWindows = 0x2000e004,
752 VisibilityText = 0x2000e005,
753 VisibilityLines = 0x2000e006,
754 VisibilityEdgeLights = 0x2000e007,
755 VisibilityMarkerLights = 0x2000e008,
756 VisibilityFaceLights = 0x2000e009,
757 VisibilityGenericEdges = 0x2000e00a,
758 VisibilityHardEdges = 0x2000e00b,
759 VisibilityAdjacentEdges = 0x2000e00c,
760 VisibilityInteriorSilhouetteEdges = 0x2000e00d,
761 VisibilityShadowEmitting = 0x2000e00e,
762 VisibilityShadowReceiving = 0x2000e00f,
763 VisibilityShadowCasting = 0x2000e010,
764 VisibilityMarkers = 0x2000e011,
765 VisibilityVertices = 0x2000e012,
766 VisibilityFaces = 0x2000e013,
767 VisibilityPerimeterEdges = 0x2000e014,
768 VisibilityNonCulledEdges = 0x2000e015,
769 VisibilityMeshQuadEdges = 0x2000e016,
771 VisualEffects = 0x2000f000,
772 VisualEffectsPostProcessEffectsEnabled = 0x2000f001,
773 VisualEffectsAntiAliasing = 0x2000f002,
774 VisualEffectsShadowMaps = 0x2000f003,
775 VisualEffectsSimpleShadow = 0x2000f004,
776 VisualEffectsSimpleShadowPlane = 0x2000f005,
777 VisualEffectsSimpleShadowLightDirection = 0x2000f006,
778 VisualEffectsSimpleShadowColor = 0x2000f007,
779 VisualEffectsSimpleReflection = 0x2000f008,
780 VisualEffectsSimpleReflectionPlane = 0x2000f009,
781 VisualEffectsSimpleReflectionVisibility = 0x2000f00a,
784 PerformanceDisplayLists = 0x20010001,
785 PerformanceStaticModel = 0x20010002,
786 StaticModelSegment = 0x40000043,
789 DrawingAttribute = 0x20011000,
790 DrawingAttributePolygonHandedness = 0x20011001,
791 DrawingAttributeDepthRange = 0x20011002,
792 DrawingAttributeFaceDisplacement = 0x20011003,
793 DrawingAttributeGeneralDisplacement = 0x20011004,
794 DrawingAttributeVertexDisplacement = 0x20011005,
795 DrawingAttributeOverlay = 0x20011006,
796 DrawingAttributeDeferral = 0x20011007,
797 DrawingAttributeClipRegion = 0x20011012,
798 DrawingAttributeWorldHandedness = 0x20011018,
800 HiddenLineAttribute = 0x20012000,
801 HiddenLineAttributeColor = 0x20012001,
802 HiddenLineAttributeDimFactor = 0x20012002,
803 HiddenLineAttributeFaceDisplacement = 0x20012003,
804 HiddenLineAttributeLinePattern = 0x20012005,
805 HiddenLineAttributeRenderFaces = 0x20012006,
806 HiddenLineAttributeRenderText = 0x20012007,
807 HiddenLineAttributeAlgorithm = 0x20012008,
808 HiddenLineAttributeSilhouetteCleanup = 0x20012009,
809 HiddenLineAttributeVisibility = 0x2001200a,
810 HiddenLineAttributeWeight = 0x2001200b,
811 HiddenLineAttributeTransparencyCutoff = 0x2001200c,
813 SegmentStyle = 0x20013001,
814 NamedStyle = 0x20013002,
815 MaterialPalette = 0x20013003,
816 Portfolio = 0x20013004,
819 ContourLineVisibility = 0x20014001,
820 ContourLinePosition = 0x20014002,
821 ContourLineColor = 0x20014003,
822 ContourLinePattern = 0x20014004,
823 ContourLineWeight = 0x20014005,
824 ContourLineLighting = 0x20014006,
829 BoundingVolume = 0x20016001,
830 BoundingExclusion = 0x20016002,
833 AttributeLockSetting = 0x20017001,
834 AttributeLockSubsegmentOverride = 0x20017002,
836 TransformMask = 0x20018000,
837 TransformMaskCamera = 0x20018001,
838 TransformMaskCameraTranslation = 0x20018002,
839 TransformMaskCameraScale = 0x20018003,
840 TransformMaskCameraOffset = 0x20018004,
841 TransformMaskCameraRotation = 0x20018005,
842 TransformMaskCameraPerspectiveScale = 0x20018006,
843 TransformMaskCameraProjection = 0x20018007,
844 TransformMaskModellingMatrix = 0x20018008,
845 TransformMaskModellingMatrixTranslation = 0x20018009,
846 TransformMaskModellingMatrixScale = 0x20018010,
847 TransformMaskModellingMatrixOffset = 0x20018011,
848 TransformMaskModellingMatrixRotation = 0x20018012,
850 ColorInterpolation = 0x20019000,
851 ColorInterpolationFaceColor = 0x20019001,
852 ColorInterpolationEdgeColor = 0x20019002,
853 ColorInterpolationMarkerColor = 0x20019003,
854 ColorInterpolationFaceIndex = 0x20019004,
855 ColorInterpolationEdgeIndex = 0x20019005,
856 ColorInterpolationMarkerIndex = 0x20019006,
858 CuttingSectionAttribute = 0x2001a000,
859 CuttingSectionAttributeCuttingLevel = 0x2001a001,
860 CuttingSectionAttributeCappingLevel = 0x2001a002,
861 CuttingSectionAttributeMaterialPreference = 0x2001a003,
879 InvalidMaterialIndex = -1,
906 EnvironmentTexture = 8,
907 EnvironmentCubeMap = 9,
946 EnvironmentTexture = 8,
947 EnvironmentCubeMap = 9
1093 GeometryDisplayLists,
1112 AttributeStaticModel,
1113 AttributeSpatialStaticModel
1129 Everything = 0x01000000,
1131 Visibility = 0x02000000,
1133 VisibilityCuttingSections,
1139 VisibilityEdgeLights,
1140 VisibilityMarkerLights,
1141 VisibilityFaceLights,
1142 VisibilityGenericEdges,
1143 VisibilityHardEdges,
1144 VisibilityAdjacentEdges,
1145 VisibilityInteriorSilhouetteEdges,
1146 VisibilityShadowEmitting,
1147 VisibilityShadowReceiving,
1148 VisibilityShadowCasting,
1152 VisibilityPerimeterEdges,
1153 VisibilityNonCulledEdges,
1154 VisibilityMeshQuadEdges,
1155 VisibilityCutGeometry,
1164 MaterialCutGeometry,
1166 MaterialAmbientLightUpColor,
1167 MaterialAmbientLightDownColor,
1168 MaterialAmbientLightColor,
1170 MaterialWindowColor,
1171 MaterialWindowContrastColor,
1175 MaterialMarkerColor,
1177 MaterialCutEdgeColor,
1180 MaterialVertexDiffuse,
1181 MaterialVertexDiffuseColor,
1182 MaterialVertexDiffuseAlpha,
1183 MaterialVertexDiffuseTexture,
1184 MaterialVertexSpecular,
1185 MaterialVertexMirror,
1186 MaterialVertexTransmission,
1187 MaterialVertexEmission,
1188 MaterialVertexEnvironment,
1190 MaterialVertexGloss,
1193 MaterialEdgeDiffuse,
1194 MaterialEdgeDiffuseColor,
1195 MaterialEdgeDiffuseAlpha,
1196 MaterialEdgeDiffuseTexture,
1197 MaterialEdgeSpecular,
1199 MaterialEdgeTransmission,
1200 MaterialEdgeEmission,
1201 MaterialEdgeEnvironment,
1206 MaterialFaceDiffuse,
1207 MaterialFaceDiffuseColor,
1208 MaterialFaceDiffuseAlpha,
1209 MaterialFaceDiffuseTexture,
1210 MaterialFaceSpecular,
1212 MaterialFaceTransmission,
1213 MaterialFaceEmission,
1214 MaterialFaceEnvironment,
1219 MaterialBackFaceDiffuse,
1220 MaterialBackFaceDiffuseColor,
1221 MaterialBackFaceDiffuseAlpha,
1222 MaterialBackFaceDiffuseTexture,
1223 MaterialBackFaceSpecular,
1224 MaterialBackFaceMirror,
1225 MaterialBackFaceTransmission,
1226 MaterialBackFaceEmission,
1227 MaterialBackFaceEnvironment,
1228 MaterialBackFaceBump,
1229 MaterialBackFaceGloss,
1232 MaterialFrontFaceDiffuse,
1233 MaterialFrontFaceDiffuseColor,
1234 MaterialFrontFaceDiffuseAlpha,
1235 MaterialFrontFaceDiffuseTexture,
1236 MaterialFrontFaceSpecular,
1237 MaterialFrontFaceMirror,
1238 MaterialFrontFaceTransmission,
1239 MaterialFrontFaceEmission,
1240 MaterialFrontFaceEnvironment,
1241 MaterialFrontFaceBump,
1242 MaterialFrontFaceGloss,
1245 MaterialCutFaceDiffuse,
1246 MaterialCutFaceDiffuseColor,
1247 MaterialCutFaceDiffuseAlpha,
1248 MaterialCutFaceDiffuseTexture,
1249 MaterialCutFaceSpecular,
1250 MaterialCutFaceMirror,
1251 MaterialCutFaceTransmission,
1252 MaterialCutFaceEmission,
1253 MaterialCutFaceEnvironment,
1254 MaterialCutFaceBump,
1255 MaterialCutFaceGloss,
1561 CharacterPositionOnly,
1564 CharacterPositionAdjusted
1785 UnableToLoadLibraries,
1786 VersionIncompatibility,
1787 InitializationFailed,
1948 TriangleDownWithDot,
1951 TriangleRightWithDot,
1954 TriangleLeftWithDot,
1961 SolidTriangleRightV,
2035 SubsegmentsAndIncludes,
2038 enum class Expansion
2043 IncludesAndReferences,
2053 enum class Reorganization
2062 typedef double Time;
2066 # define HPS_INLINE __forceinline
2069 # define HPS_INLINE inline
2072 #ifndef HPS_UNREFERENCED
2073 #define HPS_UNREFERENCED(param) ((void)(param))
2077 const double PI = 3.141592653589793238462643383279502884197169399375105820974944592308;
2079 template<
typename T>
2080 HPS_INLINE T Degrees_To_Radians(T
const & degrees)
2082 return degrees * (T)(PI / 180.0);
2085 template<
typename T>
2086 HPS_INLINE T Radians_To_Degrees(T
const & radians)
2088 return radians * (T)(180.0 / PI);
2091 template<
typename T>
2092 HPS_INLINE
void SinCos(T
const & angle, T & sine, T & cosine) {
2093 T a = Degrees_To_Radians(angle);
2098 template<
typename T>
2099 HPS_INLINE T Cos(T
const & angle) {
2100 return cos (Degrees_To_Radians(angle));
2103 template<
typename T>
2104 HPS_INLINE T Sin(T
const & angle) {
2105 return sin (Degrees_To_Radians(angle));
2108 template<
typename T>
2109 HPS_INLINE T ACos(T
const & x) {
2114 return Radians_To_Degrees(acos(x));
2117 template<
typename T>
2118 HPS_INLINE T ATan2(T
const & y, T
const & x) {
2119 if (x == 0 && y == 0)
2121 return Radians_To_Degrees(atan2(y, x));
2127 typedef double Alternative;
2128 static const int Type = 1;
2129 static float Epsilon () {
return 1.0e-30f; }
2132 typedef float Alternative;
2133 static const int Type = 2;
2134 static double Epsilon () {
return 1.0e-300; }
2143 # if HOOPS_BIGENDIAN
2151 static HPS_INLINE
bool is_infinite(int32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2152 static HPS_INLINE
bool is_infinite(uint32_t
const & v) {
return (v & 0x7FFFFFFF) == 0x7F800000; }
2153 static HPS_INLINE
bool is_infinite(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2154 static HPS_INLINE
bool is_infinite(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000 && v[Low] == 0; }
2156 static HPS_INLINE
bool is_nan(int32_t
const & v) {
2157 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2158 return exp == 0x7F800000 && mantissa != 0;
2160 static HPS_INLINE
bool is_nan(uint32_t
const & v) {
2161 uint32_t exp = v & 0x7F800000, mantissa = v & 0x007FFFFF;
2162 return exp == 0x7F800000 && mantissa != 0;
2164 static HPS_INLINE
bool is_nan(int32_t
const * v) {
2165 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2166 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2168 static HPS_INLINE
bool is_nan(uint32_t
const * v) {
2169 uint32_t exp = v[High] & 0x7FF00000, mantissa_high = v[High] & 0x000FFFFF;
2170 return exp == 0x7FF00000 && (mantissa_high | v[Low]) != 0;
2173 static HPS_INLINE
bool is_special(int32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2174 static HPS_INLINE
bool is_special(uint32_t
const & v) {
return (v & 0x7F800000) == 0x7F800000; }
2175 static HPS_INLINE
bool is_special(int32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2176 static HPS_INLINE
bool is_special(uint32_t
const * v) {
return (v[High] & 0x7FFFFFFF) == 0x7FF00000; }
2185 static HPS_INLINE
bool IsInfinite(
float const & a) {
return is_infinite (extract_uint32_t(a)); }
2186 static HPS_INLINE
bool IsInfinite(
double const & a) {
2188 memcpy (v, &a,
sizeof(
double));
2189 return is_infinite (v);
2193 static HPS_INLINE
bool IsNAN(
float const & a) {
return is_nan (extract_uint32_t(a)); }
2194 static HPS_INLINE
bool IsNAN(
double const & a) {
2196 memcpy (v, &a,
sizeof(
double));
2201 static HPS_INLINE
bool IsAbnormal(
float const & a) {
return is_special (extract_uint32_t(a)); }
2202 static HPS_INLINE
bool IsAbnormal(
double const & a) {
2204 memcpy (v, &a,
sizeof(
double));
2205 return is_special (v);
2210 static HPS_INLINE
bool Equals(
float const & a,
float const & b,
int tolerance = 32);
2211 static HPS_INLINE
bool Equals(
double const & a,
double const & b,
int tolerance = 32);
2213 #ifndef HOOPS_DEFINED
2214 template <
typename Alloc>
2215 static HPS_INLINE
bool Equals(std::vector<float, Alloc>
const & a, std::vector<float, Alloc>
const & b,
int tolerance = 32)
2217 if (a.size() != b.size())
2220 auto it1 = a.begin();
2221 auto it2 = b.begin();
2222 auto const end = a.end();
2223 for ( ; it1 != end; ++it1, ++it2)
2225 if (!Equals(*it1, *it2, tolerance))
2232 static HPS_INLINE uint32_t extract_sign_bit(
float const & a) {
2233 return extract_uint32_t(a) & 0x80000000;
2235 static HPS_INLINE uint32_t extract_sign_bit(
double const & a) {
2237 memcpy (v, &a,
sizeof(
double));
2238 return v[High] & 0x80000000;
2241 static HPS_INLINE
void apply_sign_bit(
float & a, uint32_t
const & sign_bit) {
2242 uint32_t v = extract_uint32_t(a);
2245 inject_uint32_t(a, v);
2247 static HPS_INLINE
void apply_sign_bit(
double & a, uint32_t
const & sign_bit) {
2249 memcpy (v, &a,
sizeof(
double));
2250 v[High] &= 0x7FFFFFFF;
2251 v[High] |= sign_bit;
2252 memcpy (&a, v,
sizeof(
double));
2256 static HPS_INLINE
unsigned char unit_to_byte(
float const & a) {
2257 uint32_t v = extract_uint32_t(a);
2265 uint32_t exp = v >> 23;
2266 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2268 return (
unsigned char) (man >> (16 + 126 - exp));
2271 static HPS_INLINE
unsigned char unit_to_byte_scaled(
float const & a,
unsigned char mix) {
2272 uint32_t v = extract_uint32_t(a);
2280 uint32_t exp = v >> 23;
2281 uint32_t man = (v & 0x007FFFFF) | 0x00800000;
2283 uint32_t x = (man >> (16 + 126 - exp));
2285 return (
unsigned char) ((x * (mix+1)) >> 8);
2289 static HPS_INLINE
bool match(
float const & a,
float const & b) {
2290 uint32_t va = extract_uint32_t(a);
2291 uint32_t vb = extract_uint32_t(b);
2293 if (((va | vb) & 0x7FFFFFFF) == 0)
2298 static HPS_INLINE
bool match(
double const & a,
double const & b) {
2303 static HPS_INLINE
void replace_if_smaller(
float & a,
float const & b) {
2304 uint32_t va = extract_uint32_t(a);
2305 uint32_t vb = extract_uint32_t(b);
2307 uint32_t a_sign = va & 0x80000000;
2308 uint32_t b_sign = vb & 0x80000000;
2310 (int32_t&)a_sign >>= 31;
2311 (int32_t&)b_sign >>= 31;
2313 uint32_t mash = (a_sign&b_sign);
2318 if ((int32_t&)vb < (int32_t&)va)
2319 memcpy(&a, &b,
sizeof(
float));
2321 static HPS_INLINE
void replace_if_smaller(
double & a,
double const & b) {
2326 static HPS_INLINE
void replace_if_larger(
float & a,
float const & b) {
2327 uint32_t va = extract_uint32_t(a);
2328 uint32_t vb = extract_uint32_t(b);
2330 uint32_t a_sign = va & 0x80000000;
2331 uint32_t b_sign = vb & 0x80000000;
2333 (int32_t&)a_sign >>= 31;
2334 (int32_t&)b_sign >>= 31;
2336 uint32_t mash = (a_sign&b_sign);
2341 if ((int32_t&)vb > (int32_t&)va)
2342 memcpy(&a, &b,
sizeof(
float));
2344 static HPS_INLINE
void replace_if_larger(
double & a,
double const & b) {
2350 static HPS_INLINE uint32_t extract_uint32_t(
float const & a) {
2352 memcpy(&i, &a,
sizeof(
float));
2356 static HPS_INLINE
void inject_uint32_t(
float & a, uint32_t
const & i) {
2357 memcpy(&a, &i,
sizeof(
float));
2360 static HPS_INLINE
float C2F(
unsigned char x) {
2362 return char_to_float[x];
2367 static HPS_INLINE
void pack_4(
float const & f,
float * m) {
2368 memcpy(&m[0], &f,
sizeof(
float));
2369 memcpy(&m[1], &f,
sizeof(
float));
2370 memcpy(&m[2], &f,
sizeof(
float));
2371 memcpy(&m[3], &f,
sizeof(
float));
2374 static HPS_INLINE
void pack_4(
float const & f0,
float const & f1,
float const & f2,
float const & f3,
float * m) {
2375 memcpy(&m[0], &f0,
sizeof(
float));
2376 memcpy(&m[1], &f1,
sizeof(
float));
2377 memcpy(&m[2], &f2,
sizeof(
float));
2378 memcpy(&m[3], &f3,
sizeof(
float));
2381 static HPS_INLINE
void unpack_4(
float * f0,
float const *
const m) {
2382 memcpy(f0, m,
sizeof(
float)*4);
2385 static HPS_INLINE
void unpack_4(
float & f0,
float & f1,
float & f2,
float & f3,
float const *
const m) {
2386 memcpy(&f0, &m[0],
sizeof(
float));
2387 memcpy(&f1, &m[1],
sizeof(
float));
2388 memcpy(&f2, &m[2],
sizeof(
float));
2389 memcpy(&f3, &m[3],
sizeof(
float));
2393 static const float char_to_float[256];
2402 template <
typename T> HPS_INLINE T * Alter (T
const * a) {
return const_cast<T *
>(a); }
2403 template <
typename T> HPS_INLINE T & Alter (T
const & a) {
return const_cast<T &
>(a); }
2405 template <
typename T> HPS_INLINE T Abs (T
const & a) {
return a < 0 ? -a : a; }
2406 template <
typename T> HPS_INLINE
int Compare (T
const & a, T
const & b) {
return a == b ? 0 : a < b ? -1 : 1; }
2407 template <
typename T> HPS_INLINE
int Sign (T
const & a) {
return Compare(a,(T)0); }
2408 template <
typename T> HPS_INLINE
void Swap (T & a, T & b) { T temp = a; a = b; b = temp; }
2409 template <
typename T> HPS_INLINE
int Floor(T
const & a) {
return ((a > 0 || (T)(
int)a == a) ? (
int)a : ((
int)a - 1)); }
2410 template <
typename T> HPS_INLINE
int Ceiling(T
const & a) {
return ((a < 0 || (T)(
int)a == a) ? (
int)a : ((
int)a + 1)); }
2412 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b) {
return a < b ? a : b; }
2413 template <
typename T> HPS_INLINE T
const & Min (T
const & a, T
const & b, T
const & c) {
return Min(Min(a,b),c); }
2414 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); }
2415 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); }
2416 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); }
2418 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b) {
return a > b ? a : b; }
2419 template <
typename T> HPS_INLINE T
const & Max (T
const & a, T
const & b, T
const & c) {
return Max(Max(a,b),c); }
2420 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); }
2421 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); }
2422 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); }
2424 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; }
2427 template <> HPS_INLINE
float Abs<float> (
float const & a) {
2428 uint32_t v = Float::extract_uint32_t(a);
2431 Float::inject_uint32_t(f,v);
2435 template <> HPS_INLINE
int Sign<float> (
float const & a) {
2436 uint32_t v = Float::extract_uint32_t(a);
2438 if ((v & 0x7FFFFFFF) == 0)
2441 return ((int32_t)(v & 0x80000000)>>31) | 0x01;
2444 template <> HPS_INLINE
int Compare<float> (
float const & a,
float const & b) {
2445 int a_sign = Sign(a);
2446 int b_sign = Sign(b);
2448 if (a_sign != b_sign)
2449 return Compare(a_sign, b_sign);
2451 uint32_t v = Float::extract_uint32_t(a);
2452 uint32_t u = Float::extract_uint32_t(b);
2454 return Compare((v & 0x7FFFFFFF), (u & 0x7FFFFFFF)) * a_sign;
2457 template <> HPS_INLINE
float const & Min<float> (
float const & a,
float const & b) {
2463 template <> HPS_INLINE
float const & Max<float> (
float const & a,
float const & b) {
2472 HPS_INLINE
bool Float::Equals(
float const & a,
float const & b,
int tolerance) {
2473 int32_t va = Float::extract_uint32_t(a);
2474 int32_t vb = Float::extract_uint32_t(b);
2476 if (is_special(va) || is_special(vb)) {
2477 if (is_infinite(va) || is_infinite(vb))
2479 if (is_nan(va) || is_nan(vb))
2483 int const close_to_zero = 0x36A00000;
2484 if ((va & 0x7FFFFFFF) == 0)
2485 return (vb & 0x7FFFFFFF) < close_to_zero;
2486 else if ((vb & 0x7FFFFFFF) == 0)
2487 return (va & 0x7FFFFFFF) < close_to_zero;
2489 uint32_t sign_mask = va ^ vb;
2490 (int32_t &)sign_mask >>= 31;
2492 int32_t diff = ((va + sign_mask) ^ (sign_mask & 0x7FFFFFFF)) -vb;
2493 int32_t v1 = tolerance + diff;
2494 int32_t v2 = tolerance - diff;
2495 return (v1|v2) >= 0;
2498 HPS_INLINE
bool Float::Equals(
double const & a,
double const & b,
int tolerance) {
2499 int32_t va[2], vb[2];
2500 memcpy (va, &a,
sizeof(
double));
2501 memcpy (vb, &b,
sizeof(
double));
2503 if (is_special(va) || is_special(vb)) {
2504 if (is_infinite(va) || is_infinite(vb))
2505 return va[High] == vb[High] && va[Low] == vb[Low];
2506 if (is_nan(va) || is_nan(vb))
2510 if ((va[High] == 0 && va[Low] == 0) || (vb[High] == 0 && vb[Low] == 0))
2511 return Abs(a - b) < 0.000000000000005;
2513 if (extract_sign_bit(a) != extract_sign_bit(b))
2516 if (va[High] != vb[High])
2519 return Abs(va[Low] - vb[Low]) <= tolerance;
2526 HPS_INLINE
bool Is_Abnormal (
double const & d) {
return Float::IsAbnormal (d); }
2528 template <
typename T>
2529 HPS_INLINE
bool Is_Abnormal (
size_t count, T
const * t) {
2531 if (Is_Abnormal (*t++))
2536 template <
typename T>
2537 HPS_INLINE
bool Is_Abnormal (
int count, T
const * t) {
2538 return count >= 0 && Is_Abnormal((
size_t)count, t);
2545 template <
typename F>
class HPS_TEMPLATE_API Vector_3D;
2546 template <
typename F>
class HPS_TEMPLATE_API Plane_3D;
2547 template <
typename F>
class HPS_TEMPLATE_API Vector_2D;
2548 template <
typename F>
class HPS_TEMPLATE_API Point_2D;
2551 template <
typename F>
2559 Point_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2561 template <
typename D>
2562 explicit Point_3D (
Point_3D<D> const & that) : x ((F)that.x), y ((F)that.y), z ((F)that.z) {}
2570 bool operator== (
Point_3D const & p)
const {
return x == p.x && y == p.y && z == p.z; }
2571 bool operator!= (
Point_3D const & p)
const {
return !(*
this == p); }
2573 bool Equals(
Point_3D const & p,
int in_tolerance = 32)
const {
2580 Point_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2581 Point_3D & operator/= (F s) {
return operator*= ((F)1 / s); }
2582 Point_3D const operator* (F s)
const {
return Point_3D (x * s, y * s, z * s); }
2583 Point_3D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2585 F & operator[] (
size_t i) {
return (&x)[i]; }
2586 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2619 template <
typename F,
typename S>
2622 template <
typename F>
2623 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b) {
2624 return Point_3D<F> (a.x + b.x, a.y + b.y, a.z + b.z) * 0.5f;
2627 template <
typename F>
2628 HPS_INLINE Point_3D<F> Midpoint (Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2629 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);
2632 template <
typename F>
2633 HPS_INLINE
bool Is_Abnormal (Point_3D<F>
const & p) {
2634 return Is_Abnormal (p.x) || Is_Abnormal (p.y) || Is_Abnormal (p.z);
2638 template <
typename F>
2645 Point_2D (F v1, F v2) : x (v1), y (v2) {}
2647 template <
typename D>
2655 bool operator== (
Point_2D const & p)
const {
return x == p.x && y == p.y; }
2656 bool operator!= (
Point_2D const & p)
const {
return !(*
this == p); }
2658 bool Equals(
Point_2D const & p,
int in_tolerance = 32)
const {
2663 Point_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2664 Point_2D & operator/= (F s) {
return operator*= ((F)1 / s); }
2666 Point_2D const operator/ (F s)
const {
return operator* ((F)1 / s); }
2668 F & operator[] (
size_t i) {
return (&x)[i]; }
2669 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2690 template <
typename F>
2693 template <
typename F,
typename S>
2694 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)); }
2696 template <
typename F>
2697 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b) {
2698 return Point_2D<F> (a.x + b.x, a.y + b.y) * 0.5f;
2701 template <
typename F>
2702 HPS_INLINE Point_2D<F> Midpoint (Point_2D<F>
const & a, Point_2D<F>
const & b, Point_2D<F>
const & c) {
2703 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);
2706 template <
typename F>
2707 HPS_INLINE
bool Is_Abnormal (Point_2D<F>
const & p) {
2708 return Is_Abnormal (p.x) || Is_Abnormal (p.y);
2712 template <
typename F>
2720 Vector_3D (F v1, F v2, F v3) : x (v1), y (v2), z (v3) {}
2721 template <
typename D>
2730 bool operator== (
Vector_3D const & v)
const {
2731 return Float::match(x, v.x) && Float::match(y, v.y) && Float::match(z, v.z);
2733 bool operator!= (
Vector_3D const & v)
const {
return !(*
this == v); }
2735 bool Equals(
Vector_3D const & v,
int in_tolerance = 32)
const {
2741 Vector_3D & operator+= (
Vector_3D const & v) { x += v.x; y += v.y; z += v.z;
return *
this; }
2742 Vector_3D & operator-= (
Vector_3D const & v) { x -= v.x; y -= v.y; z -= v.z;
return *
this; }
2746 Vector_3D & operator*= (F s) { x *= s; y *= s; z *= s;
return *
this; }
2747 Vector_3D & operator/= (F s) {
return operator*= (1.0f / s); }
2749 Vector_3D const operator/ (F s)
const {
return operator* (1.0f / s); }
2751 F & operator[] (
size_t i) {
return (&x)[i]; }
2752 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2754 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2756 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y + (
double)z*(double)z; }
2758 HPS_INLINE
double Length2D ()
const {
return sqrt (LengthSquared2D()); }
2760 HPS_INLINE
double LengthSquared2D ()
const {
return (
double)x*(double)x + (
double)y*(double)y;}
2764 F range = Max (Abs (x), Abs (y), Abs (z));
2765 if (range > F(1.0e10))
2769 F len = (F)Length();
2776 HPS_INLINE
Vector_3D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2778 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y), Abs(z)); }
2779 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y)+Abs(z); }
2781 HPS_INLINE F Dot (
Vector_3D const & v)
const {
return x * v.x + y * v.y + z * v.z; }
2784 return Vector_3D (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
2789 return Vector_3D (x * v.x, y * v.y, z * v.z);
2803 template <
typename F,
typename S>
2806 template <
typename F>
2807 HPS_INLINE
bool Is_Abnormal (Vector_3D<F>
const & v) {
2808 return Is_Abnormal (v.x) || Is_Abnormal (v.y) || Is_Abnormal (v.z);
2812 template <
typename F>
2813 HPS_INLINE Point_3D<F>::Point_3D(Vector_3D<F>
const & v) : x(v.x), y(v.y), z(v.z) {}
2815 template <
typename F>
2816 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; }
2817 template <
typename F>
2818 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; }
2820 template <
typename F>
2821 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); }
2823 template <
typename F>
2824 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); }
2825 template <
typename F>
2826 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); }
2828 template <
typename F>
2829 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; }
2830 template <
typename F>
2831 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; }
2832 template <
typename F>
2833 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); }
2834 template <
typename F>
2835 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); }
2839 template <
typename F>
2840 HPS_INLINE Point_3D<F> Interpolate(Point_3D<F>
const & a, Point_3D<F>
const & b,
float t) {
2841 return a + (b - a) * t;
2844 template <
typename F>
2845 HPS_INLINE Vector_3D<F> Interpolate(Vector_3D<F>
const & a, Vector_3D<F>
const & b,
float t) {
2846 return Vector_3D<F>(a + (b - a) * t).Normalize();
2851 template <
typename F>
2852 HPS_INLINE
double PointToPointDistance(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2853 return (p2 - p1).Length();
2856 template <
typename F>
2857 HPS_INLINE
double PointToPointDistanceSquared(Point_3D<F>
const & p1, Point_3D<F>
const & p2) {
2858 return (p2 - p1).LengthSquared();
2861 template <
typename F>
2862 HPS_INLINE Point_3D<F> Circumcenter(Point_3D<F>
const & a, Point_3D<F>
const & b, Point_3D<F>
const & c) {
2863 F p =
static_cast<F
>((c - b).LengthSquared());
2864 F q =
static_cast<F
>((c - a).LengthSquared());
2865 F r =
static_cast<F
>((b - a).LengthSquared());
2868 (a * (p*(q+r-p)) + (Vector_3D<F>)b * (q*(r+p-q)) + (Vector_3D<F>)c * (r*(p+q-r)))
2869 / (2 * (p*q + p*r + q*r) - (p*p + q*q + r*r)) );
2874 template <
typename F>
2875 HPS_INLINE
bool Normalize(
size_t count, Vector_3D<F> * vectors) {
2876 bool success =
true;
2877 for (
size_t i = 0; i < count; ++i) {
2878 if (vectors->Normalize() == Vector_3D<F>::Zero())
2886 template <
typename F>
class HPS_TEMPLATE_API Plane_2D;
2888 template <
typename F>
2895 Vector_2D (F v1, F v2) : x (v1), y (v2) {}
2896 template <
typename D>
2905 bool operator== (
Vector_2D const & v)
const {
2906 return Float::match(x, v.x) && Float::match(y, v.y);
2908 bool operator!= (
Vector_2D const & v)
const {
return !(*
this == v); }
2910 bool Equals(
Vector_2D const & v,
int in_tolerance = 32)
const {
2919 Vector_2D & operator*= (F s) { x *= s; y *= s;
return *
this; }
2920 Vector_2D & operator/= (F s) {
return operator*= (1.0f / s); }
2922 Vector_2D const operator/ (F s)
const {
return operator* (1.0f / s); }
2924 F & operator[] (
size_t i) {
return (&x)[i]; }
2925 F
const & operator[] (
size_t i)
const {
return (&x)[i]; }
2927 HPS_INLINE
double Length ()
const {
return sqrt (LengthSquared()); }
2929 HPS_INLINE
double LengthSquared ()
const {
return (
double)x*(double)x + (
double)y*(double)y; }
2933 F range = Max (Abs (x), Abs (y));
2934 if (range > F(1.0e10))
2938 F len = (F)Length();
2945 HPS_INLINE
Vector_2D & Normalize (F epsilon) {
return Normalize (
false, epsilon); }
2947 HPS_INLINE F Magnitude ()
const {
return Max (Abs(x), Abs(y)); }
2948 HPS_INLINE F Manhattan ()
const {
return Abs(x)+Abs(y); }
2950 HPS_INLINE F Dot (
Vector_2D const & v)
const {
return x * v.x + y * v.y; }
2953 HPS_INLINE
float Cross (
Vector_2D const & v)
const {
2954 return x * v.y - y * v.x;
2971 template <
typename F,
typename S>
2974 template <
typename F>
2975 HPS_INLINE
bool Is_Abnormal (Vector_2D<F>
const & v) {
2976 return Is_Abnormal (v.x) || Is_Abnormal (v.y);
2980 template <
typename F>
2981 HPS_INLINE Vector_3D<F>::Vector_3D (Vector_2D<F>
const & that) : x (that.x), y (that.y), z(0) {}
2983 template <
typename F>
2984 HPS_INLINE Point_3D<F>::Point_3D(Vector_2D<F>
const & v) : x(v.x), y(v.y), z(0) {}
2986 template <
typename F>
2987 HPS_INLINE Point_3D<F> & Point_3D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
2988 template <
typename F>
2989 HPS_INLINE Point_3D<F> & Point_3D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
2991 template <
typename F>
2992 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); }
2993 template <
typename F>
2994 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); }
2996 template <
typename F>
2997 HPS_INLINE Point_3D<F> & Point_3D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
2998 template <
typename F>
2999 HPS_INLINE Point_3D<F> & Point_3D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
3001 template <
typename F>
3002 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); }
3003 template <
typename F>
3004 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); }
3007 template <
typename F>
3008 HPS_INLINE Point_2D<F> & Point_2D<F>::operator+= (Vector_2D<F>
const & v) { x += v.x; y += v.y;
return *
this; }
3009 template <
typename F>
3010 HPS_INLINE Point_2D<F> & Point_2D<F>::operator-= (Vector_2D<F>
const & v) { x -= v.x; y -= v.y;
return *
this; }
3012 template <
typename F>
3013 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); }
3015 template <
typename F>
3016 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); }
3017 template <
typename F>
3018 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); }
3020 template <
typename F>
3021 HPS_INLINE Point_2D<F> & Point_2D<F>::operator*= (Vector_2D<F>
const & v) { x *= v.x; y *= v.y;
return *
this; }
3022 template <
typename F>
3023 HPS_INLINE Point_2D<F> & Point_2D<F>::operator/= (Vector_2D<F>
const & v) { x /= v.x; y /= v.y;
return *
this; }
3024 template <
typename F>
3025 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); }
3026 template <
typename F>
3027 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); }
3033 template <
typename F>
3042 Plane_3D (F v1, F v2, F v3, F v4) : a (v1), b (v2), c (v3), d (v4) {}
3046 template <
typename D>
3047 explicit Plane_3D (
Plane_3D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c), d ((F)that.d) {}
3063 for (
size_t i=0; i<count; ++i) {
3066 normal.x += (p0->y + p1->y) * (p1->z - p0->z);
3067 normal.y += (p0->z + p1->z) * (p1->x - p0->x);
3068 normal.z += (p0->x + p1->x) * (p1->y - p0->y);
3078 double inv_count = 1.0 / (double)count;
3086 *
this = Plane_3D::Zero();
3092 bool operator== (
Plane_3D const & p)
const {
return a == p.a && b == p.b && c == p.c && d == p.d; }
3093 bool operator!= (
Plane_3D const & p)
const {
return !(*
this == p); }
3095 F & operator[] (
size_t i) {
return (&a)[i]; }
3096 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3098 HPS_INLINE
bool Equals(
Plane_3D const & p,
int in_tolerance = 32)
const {
3113 F val1 = Abs (a * p1.x + b * p1.y + c * p1.z + d);
3114 F val2 = Abs (a * p2.x + b * p2.y + c * p2.z + d);
3117 return Point_3D<F> (((val1 * p2.x) + (val2 * p1.x)) / (val1 + val2),
3118 ((val1 * p2.y) + (val2 * p1.y)) / (val1 + val2),
3119 ((val1 * p2.z) + (val2 * p1.z)) / (val1 + val2));
3126 F u = (a * p1.x + b * p1.y + c * p1.z + d) /
3127 (a * (p1.x - p2.x) + b * (p1.y - p2.y) + c * (p1.z - p2.z));
3129 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));
3132 static HPS_INLINE
Plane_3D Zero() {
return Plane_3D (0.0f, 0.0f, 0.0f, 0.0f);};
3136 Plane_3D & operator*= (F s) { a *= s; b *= s; c *= s; d *= s;
return *
this; }
3137 Plane_3D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3138 Plane_3D const operator* (F s)
const {
return Plane_3D (a * s, b * s, c * s, d * s); }
3139 Plane_3D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3146 template <
typename F>
3147 HPS_INLINE
bool Is_Abnormal (
Plane_3D<F> const & p) {
3148 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c) || Is_Abnormal (p.d);
3152 template <
typename F>
3153 HPS_INLINE F operator* (Plane_3D<F>
const & plane, Point_3D<F>
const & point) {
3154 return plane.a * point.x + plane.b * point.y + plane.c * point.z + plane.d;
3156 template <
typename F>
3157 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_3D<F>
const & plane) {
3158 return plane * point;
3161 template <
typename F>
3162 HPS_INLINE Plane_3D<F> Interpolate(Plane_3D<F>
const & a, Plane_3D<F>
const & b,
float t) {
3163 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);
3166 template <
typename F>
3167 Vector_3D<F>::Vector_3D(Plane_3D<F>
const & p) : x(p.a), y(p.b), z(p.c) {}
3174 template <
typename F>
3182 Plane_2D (F v1, F v2, F v3) : a (v1), b (v2), c (v3) {}
3186 template <
typename D>
3187 explicit Plane_2D (
Plane_2D<D> const & that) : a ((F)that.a), b ((F)that.b), c ((F)that.c) {}
3191 bool operator== (
Plane_2D const & p)
const {
return a == p.a && b == p.b && c == p.c; }
3192 bool operator!= (
Plane_2D const & p)
const {
return !(*
this == p); }
3194 F & operator[] (
size_t i) {
return (&a)[i]; }
3195 F
const & operator[] (
size_t i)
const {
return (&a)[i]; }
3197 HPS_INLINE
bool Equals(
Plane_2D const & p,
int in_tolerance = 32)
const {
3214 Plane_2D & operator*= (F s) { a *= s; b *= s; c *= s;
return *
this; }
3215 Plane_2D & operator/= (F s) {
return operator*= ((F)1.0 / s); }
3216 Plane_2D const operator* (F s)
const {
return Plane_2D (a * s, b * s, c * s); }
3217 Plane_2D const operator/ (F s)
const {
return operator* ((F)1.0 / s); }
3224 template <
typename F>
3225 HPS_INLINE
bool Is_Abnormal (
Plane_2D<F> const & p) {
3226 return Is_Abnormal (p.a) || Is_Abnormal (p.b) || Is_Abnormal (p.c);
3230 template <
typename F>
3231 HPS_INLINE F operator* (Plane_2D<F>
const & plane, Point_2D<F>
const & point) {
3232 return plane.a * point.x + plane.b * point.y + plane.c;
3234 template <
typename F>
3235 HPS_INLINE F operator* (Point_3D<F>
const & point, Plane_2D<F>
const & plane) {
3236 return plane * point;
3239 template <
typename F>
3240 HPS_INLINE Plane_2D<F> Interpolate(Plane_2D<F>
const & a, Plane_2D<F>
const & b,
float t) {
3241 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);
3244 template <
typename F>
3245 Vector_2D<F>::Vector_2D(Plane_2D<F>
const & p) : x(p.a), y(p.b) {}
3259 : left(std::numeric_limits<int>::max()), right(std::numeric_limits<int>::min()),
3260 bottom(std::numeric_limits<int>::max()), top(std::numeric_limits<int>::min()) {}
3262 IntRectangle(
int in_left,
int in_right,
int in_bottom,
int in_top)
3263 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3266 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3271 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3275 return !(*
this == rect);
3278 HPS_INLINE
int PixelWidth()
const {
3279 return right - left + 1;
3282 HPS_INLINE
int PixelHeight()
const {
3283 return top - bottom + 1;
3286 HPS_INLINE
int Width()
const {
3287 return right - left;
3290 HPS_INLINE
int Height()
const {
3291 return top - bottom;
3294 HPS_INLINE
int Area()
const {
3295 return Width() * Height();
3298 HPS_INLINE
Point2D Center()
const {
3299 return Point2D((
float)(left + right) * 0.5f, (
float)(bottom + top) * 0.5f);
3302 HPS_INLINE
bool Intersecting(
IntRectangle const & rect)
const {
3303 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3306 HPS_INLINE
bool Contains(
IntRectangle const & rect)
const {
3307 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3320 right += rect.right;
3321 bottom -= rect.bottom;
3336 right -= rect.right;
3337 bottom += rect.bottom;
3343 left = Max(left, rect.left);
3344 right = Min(right, rect.right);
3345 bottom = Max(bottom, rect.bottom);
3346 top = Min(top, rect.top);
3351 left = Min(left, rect.left);
3352 right = Max(right, rect.right);
3353 bottom = Min(bottom, rect.bottom);
3354 top = Max(top, rect.top);
3371 return temp.Expand(border);
3374 HPS_INLINE IntRectangle Expand(IntRectangle
const & a,
int border) {
3375 IntRectangle temp = a;
3376 return temp.Expand(border);
3379 HPS_INLINE IntRectangle Contract(IntRectangle
const & a,
int border) {
3380 IntRectangle temp = a;
3381 return temp.Contract(border);
3384 HPS_INLINE IntRectangle Contract(IntRectangle
const & a, IntRectangle
const & border) {
3385 IntRectangle temp = a;
3386 return temp.Contract(border);
3389 HPS_INLINE IntRectangle Intersect(IntRectangle
const & a, IntRectangle
const & b) {
3390 IntRectangle temp = a;
3391 return temp.Intersect(b);
3394 HPS_INLINE IntRectangle Union(IntRectangle
const & a, IntRectangle
const & b) {
3395 IntRectangle temp = a;
3396 return temp.Union(b);
3406 : left(std::numeric_limits<float>::max()), right(std::numeric_limits<float>::min()),
3407 bottom(std::numeric_limits<float>::max()), top(std::numeric_limits<float>::min()) {}
3409 Rectangle(
float in_left,
float in_right,
float in_bottom,
float in_top)
3410 : left(in_left), right(in_right), bottom(in_bottom), top(in_top) {}
3413 : left(that.left), right(that.right), bottom(that.bottom), top(that.top) {}
3416 : left((
float)that.left), right((
float)that.right), bottom((
float)that.bottom), top((
float)that.top) {}
3426 Merge(count, points);
3438 Merge(count, points);
3442 HPS_INLINE
float Width()
const {
3443 return right - left;
3446 HPS_INLINE
float Height()
const {
3447 return top - bottom;
3450 HPS_INLINE
float Area()
const {
3451 return Width() * Height();
3454 HPS_INLINE
Point2D Center()
const {
3455 return Point2D((left + right) * 0.5f, (bottom + top) * 0.5f);
3458 HPS_INLINE
void Merge(
size_t count,
Point const * points) {
3461 if (Compare(points[0].x, points[1].x)>0) {
3462 Float::replace_if_smaller(left, points[1].x);
3463 Float::replace_if_larger(right, points[0].x);
3466 Float::replace_if_smaller(left, points[0].x);
3467 Float::replace_if_larger(right, points[1].x);
3470 if (Compare(points[0].y, points[1].y)>0) {
3471 Float::replace_if_smaller(bottom, points[1].y);
3472 Float::replace_if_larger(top, points[0].y);
3475 Float::replace_if_smaller(bottom, points[0].y);
3476 Float::replace_if_larger(top, points[1].y);
3487 HPS_INLINE
void Merge(
Point const & point) {
3488 Float::replace_if_smaller(left, point.x);
3489 Float::replace_if_smaller(bottom, point.y);
3490 Float::replace_if_larger(right, point.x);
3491 Float::replace_if_larger(top, point.y);
3494 HPS_INLINE
void Merge(
size_t count,
Point2D const * points) {
3497 if (Compare(points[0].x, points[1].x)>0) {
3498 Float::replace_if_smaller(left, points[1].x);
3499 Float::replace_if_larger(right, points[0].x);
3502 Float::replace_if_smaller(left, points[0].x);
3503 Float::replace_if_larger(right, points[1].x);
3506 if (Compare(points[0].y, points[1].y)>0) {
3507 Float::replace_if_smaller(bottom, points[1].y);
3508 Float::replace_if_larger(top, points[0].y);
3511 Float::replace_if_smaller(bottom, points[0].y);
3512 Float::replace_if_larger(top, points[1].y);
3523 HPS_INLINE
void Merge(
Point2D const & point) {
3524 Float::replace_if_smaller(left, point.x);
3525 Float::replace_if_smaller(bottom, point.y);
3526 Float::replace_if_larger(right, point.x);
3527 Float::replace_if_larger(top, point.y);
3530 bool operator==(
Rectangle const & rect)
const {
3531 return (left == rect.left && right == rect.right && bottom == rect.bottom && top == rect.top);
3534 bool operator!=(
Rectangle const & rect)
const {
3535 return !(*
this == rect);
3538 HPS_INLINE
bool Intersecting(
Rectangle const & rect)
const {
3539 return right >= rect.left && left <= rect.right && top >= rect.bottom && bottom <= rect.top;
3542 HPS_INLINE
bool Contains(
Point const & contained)
const {
3543 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3546 HPS_INLINE
bool Contains(
Point2D const & contained)
const {
3547 return !(contained.x < left || contained.x > right || contained.y < bottom || contained.y > top);
3550 HPS_INLINE
bool Contains(
Rectangle const & rect) {
3551 return (left <= rect.left && right >= rect.right && bottom <= rect.bottom && top >= rect.top);
3554 HPS_INLINE
bool Contains(
Rectangle const & rect,
float epsilon) {
3555 return (left <= rect.left + epsilon && right >= rect.right - epsilon &&
3556 bottom <= rect.bottom + epsilon && top >= rect.top - epsilon);
3559 HPS_INLINE
Rectangle & Expand(
float border) {
3567 HPS_INLINE
Rectangle & Expand(
int border) {
3568 Expand((
float)border);
3574 right += rect.right;
3575 bottom -= rect.bottom;
3580 HPS_INLINE
Rectangle & Contract(
int border) {
3590 right -= rect.right;
3591 bottom += rect.bottom;
3597 left = Max(left, rect.left);
3598 right = Min(right, rect.right);
3599 bottom = Max(bottom, rect.bottom);
3600 top = Min(top, rect.top);
3605 left = Min(left, rect.left);
3606 right = Max(right, rect.right);
3607 bottom = Min(bottom, rect.bottom);
3608 top = Max(top, rect.top);
3613 float scale = (scope.right - scope.left) * 0.5f;
3614 float trans = (scope.right + scope.left) * 0.5f;
3616 left = left * scale + trans;
3617 right = right * scale + trans;
3619 scale = (scope.top - scope.bottom) * 0.5f;
3620 trans = (scope.top + scope.bottom) * 0.5f;
3622 bottom = bottom * scale + trans;
3623 top = top * scale + trans;
3628 float tmp = 2.0f/(scope.right - scope.left);
3629 right = (right - scope.left) * tmp - 1.0f;
3630 left = (left - scope.left) * tmp - 1.0f;
3632 tmp = 2.0f/(scope.top - scope.bottom);
3633 top = (top - scope.bottom) * tmp - 1.0f;
3634 bottom = (bottom - scope.bottom) * tmp - 1.0f;
3638 static HPS_INLINE
Rectangle FullScope() {
3639 return Rectangle(-1.0f, 1.0f, -1.0f, 1.0f);
3642 static HPS_INLINE
Rectangle InvalidScope() {
3643 return Rectangle(1.0f, -1.0f, 1.0f, -1.0f);
3655 temp.left = Floor (a.left);
3656 temp.right = Floor (a.right);
3657 temp.bottom = Floor (a.bottom);
3658 temp.top = Floor (a.top);
3662 HPS_INLINE Rectangle Expand(Rectangle
const & a, Rectangle
const & border) {
3664 return temp.Expand(border);
3667 HPS_INLINE Rectangle Expand(Rectangle
const & a,
float border) {
3669 return temp.Expand(border);
3672 HPS_INLINE Rectangle Contract(Rectangle
const & a,
int border) {
3674 return temp.Contract(border);
3677 HPS_INLINE Rectangle Contract(Rectangle
const & a, Rectangle
const & border) {
3679 return temp.Contract(border);
3682 HPS_INLINE Rectangle Intersect(Rectangle
const & a, Rectangle
const & b) {
3684 return temp.Intersect(b);
3687 HPS_INLINE Rectangle Union(Rectangle
const & a, Rectangle
const & b) {
3689 return temp.Union(b);
3692 HPS_INLINE Rectangle Inscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3694 return temp.Inscribe_Scope(scope);
3697 HPS_INLINE Rectangle Circumscribe_Scope(Rectangle
const & a, Rectangle
const & scope) {
3699 return temp.Circumscribe_Scope(scope);
3702 HPS_INLINE IntRectangle::IntRectangle(Rectangle
const & that)
3703 : left ((int)that.left), right ((int)that.right), bottom ((int)that.bottom), top ((int)that.top) {}
3708 template <
typename F>
3711 template <
typename F>
3724 template <
typename D>
3753 min = Limit_Point();
3754 max = -Limit_Point();
3757 min = max = *points++;
3760 Merge(count, points);
3773 return min.x <= max.x && min.y <= max.y && min.z <= max.z;
3790 HPS_INLINE
bool operator== (
Cuboid_3D const & cuboid)
const {
return (min == cuboid.
min && max == cuboid.
max); }
3796 HPS_INLINE
bool operator!= (
Cuboid_3D const & cuboid)
const {
return !(*
this == cuboid); }
3821 HPS_INLINE F
Volume ()
const {
return (max.x - min.x) * (max.y - min.y) * (max.z - min.z); }
3829 return max.x >= cuboid.
min.x && min.x <= cuboid.
max.x &&
3830 max.y >= cuboid.
min.y && min.y <= cuboid.
max.y &&
3831 max.z >= cuboid.
min.z && min.z <= cuboid.
max.z;
3840 return max.x + allowance >= cuboid.
min.x && min.x - allowance <= cuboid.
max.x &&
3841 max.y + allowance >= cuboid.
min.y && min.y - allowance <= cuboid.
max.y &&
3842 max.z + allowance >= cuboid.
min.z && min.z - allowance <= cuboid.
max.z;
3853 return max[dimension] >= cuboid.
min[dimension] && min[dimension] <= cuboid.
max[dimension];
3865 return max[dimension] + allowance >= cuboid.
min[dimension] && min[dimension] - allowance <= cuboid.
max[dimension];
3875 return LineIntersecting(start, direction,
true);
3886 return LineIntersecting(point1, direction,
false);
3895 Float::replace_if_smaller(min.x, cuboid.
min.x);
3896 Float::replace_if_smaller(min.y, cuboid.
min.y);
3897 Float::replace_if_smaller(min.z, cuboid.
min.z);
3898 Float::replace_if_larger(max.x, cuboid.
max.x);
3899 Float::replace_if_larger(max.y, cuboid.
max.y);
3900 Float::replace_if_larger(max.z, cuboid.
max.z);
3916 Float::replace_if_smaller(min.x, point.x);
3917 Float::replace_if_smaller(min.y, point.y);
3918 Float::replace_if_smaller(min.z, point.z);
3919 Float::replace_if_larger(max.x, point.x);
3920 Float::replace_if_larger(max.y, point.y);
3921 Float::replace_if_larger(max.z, point.z);
3932 if (Compare(points[0].x, points[1].x)>0) {
3933 Float::replace_if_smaller(min.x, points[1].x);
3934 Float::replace_if_larger(max.x, points[0].x);
3937 Float::replace_if_smaller(min.x, points[0].x);
3938 Float::replace_if_larger(max.x, points[1].x);
3941 if (Compare(points[0].y, points[1].y)>0) {
3942 Float::replace_if_smaller(min.y, points[1].y);
3943 Float::replace_if_larger(max.y, points[0].y);
3946 Float::replace_if_smaller(min.y, points[0].y);
3947 Float::replace_if_larger(max.y, points[1].y);
3950 if (Compare(points[0].z, points[1].z)>0) {
3951 Float::replace_if_smaller(min.z, points[1].z);
3952 Float::replace_if_larger(max.z, points[0].z);
3955 Float::replace_if_smaller(min.z, points[0].z);
3956 Float::replace_if_larger(max.z, points[1].z);
3973 return (contained.
min.x >= min.x &&
3974 contained.
min.y >= min.y &&
3975 contained.
min.z >= min.z &&
3976 contained.
max.x <= max.x &&
3977 contained.
max.y <= max.y &&
3978 contained.
max.z <= max.z);
3987 return (contained.x >= min.x &&
3988 contained.y >= min.y &&
3989 contained.z >= min.z &&
3990 contained.x <= max.x &&
3991 contained.y <= max.y &&
3992 contained.z <= max.z);
4002 return (contained.x >= min.x - epsilon &&
4003 contained.y >= min.y - epsilon &&
4004 contained.z >= min.z - epsilon &&
4005 contained.x <= max.x + epsilon &&
4006 contained.y <= max.y + epsilon &&
4007 contained.z <= max.z + epsilon);
4016 Float::replace_if_larger(min.x, cuboid.
min.x);
4017 Float::replace_if_larger(min.y, cuboid.
min.y);
4018 Float::replace_if_larger(min.z, cuboid.
min.z);
4019 Float::replace_if_smaller(max.x, cuboid.
max.x);
4020 Float::replace_if_smaller(max.y, cuboid.
max.y);
4021 Float::replace_if_smaller(max.z, cuboid.
max.z);
4031 Float::replace_if_smaller(min.x, cuboid.
min.x);
4032 Float::replace_if_smaller(min.y, cuboid.
min.y);
4033 Float::replace_if_smaller(min.z, cuboid.
min.z);
4034 Float::replace_if_larger(max.x, cuboid.
max.x);
4035 Float::replace_if_larger(max.y, cuboid.
max.y);
4036 Float::replace_if_larger(max.z, cuboid.
max.z);
4066 F
const limit = std::numeric_limits<F>::max();
4070 bool LineIntersecting (Point_3D<F>
const & start, Vector_3D<F>
const & direction,
bool is_ray)
const;
4073 typedef Cuboid_3D<float> SimpleCuboid;
4074 typedef Cuboid_3D<double> DSimpleCuboid;
4077 template <
typename F>
4078 HPS_INLINE Cuboid_3D<F> Intersect(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4079 Cuboid_3D<F> temp = a;
4080 return temp.Intersect(b);
4083 template <
typename F>
4084 HPS_INLINE Cuboid_3D<F> Union(Cuboid_3D<F>
const & a, Cuboid_3D<F>
const & b) {
4085 Cuboid_3D<F> temp = a;
4086 return temp.Union(b);
4089 template <
typename F>
4090 HPS_INLINE Cuboid_3D<F> Expand(Cuboid_3D<F>
const & a, F border) {
4091 Cuboid_3D<F> temp = a;
4092 return temp.Expand(border);
4095 template <
typename F>
4096 HPS_INLINE Cuboid_3D<F> Contract(Cuboid_3D<F>
const & a, F border) {
4097 Cuboid_3D<F> temp = a;
4098 return temp.Contract(border);
4103 template <
typename F>
4104 struct HPS_TEMPLATE_API Sphere_3D {
4108 Sphere_3D () : center(Point_3D<F>(0, 0, 0)), radius(0) {}
4110 template <
typename D>
4111 explicit Sphere_3D (Sphere_3D<D>
const & that) : center(Point_3D<F>(that.center)), radius(F(that.radius)) {}
4113 Sphere_3D (Cuboid_3D<F>
const & cuboid) :
4114 center (Midpoint(cuboid.min, cuboid.max)), radius (F(0.5 * cuboid.Diagonal().Length())) {}
4116 Sphere_3D (Point_3D<F>
const & starting_center, F in_radius = 0) : center(starting_center), radius(in_radius) {}
4118 Sphere_3D (
size_t count, Point_3D<F>
const * points) : radius(0.0f) {
4119 Cuboid_3D<F> cuboid(count, points);
4120 center = Midpoint(cuboid.min, cuboid.max);
4121 Engulf (count, points);
4124 Sphere_3D (
size_t count, Point_3D<F>
const * points, Point_3D<F>
const & starting_center) : center(starting_center), radius(0) {
4125 Engulf (count, points);
4128 HPS_INLINE
bool IsValid()
const {
4132 static HPS_INLINE Sphere_3D Invalid() {
return Sphere_3D(Point_3D<F>(0,0,0), -1);};
4134 void Invalidate() {radius = -1;}
4136 HPS_INLINE
bool operator== (Sphere_3D
const & sphere)
const {
return (center == sphere.center && radius == sphere.radius); }
4137 HPS_INLINE
bool operator!= (Sphere_3D
const & sphere)
const {
return !(*
this == sphere); }
4139 HPS_INLINE F Volume ()
const {
return F((4.0 / 3.0 * PI) * radius * radius * radius); }
4141 HPS_INLINE
void Merge(Point_3D<F>
const & point) {
4142 Vector_3D<F> dir = point - center;
4143 F distance = (F)dir.Length();
4145 if (distance > radius) {
4146 F t = F(0.5) * (distance - radius);
4147 center += t * dir.Normalize();
4152 HPS_INLINE
void Merge(
size_t count, Point_3D<F>
const * points) {
4154 for (
size_t i = 0; i < count; ++i) {
4155 Vector_3D<F> dir = *points - center;
4156 F distance = (F)dir.Length();
4158 if (distance > radius) {
4159 F t = F(0.5) * (distance - radius);
4160 center += t * dir.Normalize();
4168 HPS_INLINE
void Merge (Sphere_3D
const & sphere) {
4169 Vector_3D<F> dir = sphere.center - center;
4170 F distance = (F)dir.Length();
4172 if (distance + sphere.radius > radius) {
4173 if (distance + radius > sphere.radius) {
4174 F t = F(0.5 * (sphere.radius + distance - radius));
4175 center += t * dir.Normalize();
4179 center = sphere.center;
4180 radius = sphere.radius;
4185 HPS_INLINE
void Merge (Cuboid_3D<F>
const & cuboid) { Merge (Sphere_3D (cuboid)); }
4189 HPS_INLINE
void Engulf (
size_t count, Point_3D<F>
const * points) {
4190 for (
size_t i = 0; i < count; ++i) {
4191 double dsq = (*points++ - center).LengthSquared();
4192 if ((F)dsq > radius * radius)
4193 radius = (F)sqrt(dsq);
4198 typedef Sphere_3D<float> SimpleSphere;
4199 typedef Sphere_3D<double> DSimpleSphere;
4202 template <
typename F>
4204 min =
Point_3D<F>(sphere.center.x - sphere.radius, sphere.center.y - sphere.radius, sphere.center.z - sphere.radius);
4205 max =
Point_3D<F>(sphere.center.x + sphere.radius, sphere.center.y + sphere.radius, sphere.center.z + sphere.radius);
4223 HPS_INLINE
RGBColor (
float r,
float g,
float b) : red (r), green (g), blue (b) {}
4224 explicit HPS_INLINE RGBColor (
RGB24Color const & c24);
4225 explicit HPS_INLINE RGBColor (
float gray) : red (gray), green (gray), blue (gray) {}
4226 explicit HPS_INLINE RGBColor (
RGBAS32Color const & c32);
4227 explicit HPS_INLINE RGBColor (
RGBA32Color const & c32);
4228 explicit HPS_INLINE RGBColor (
RGBAColor const & c);
4230 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4231 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4232 float Distance(RGBColor
const & other_color)
const;
4233 HPS_INLINE
bool IsValid()
const {
4234 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue)) == 0;
4237 HPS_INLINE
bool operator== (RGBColor
const & c)
const {
return red == c.red && green == c.green && blue == c.blue; }
4238 HPS_INLINE
bool operator!= (RGBColor
const & c)
const {
return !(*
this == c); }
4240 HPS_INLINE
bool Equals(RGBColor
const & c,
int in_tolerance = 32)
const
4243 HPS_INLINE RGBColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4244 HPS_INLINE RGBColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4245 HPS_INLINE RGBColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4246 HPS_INLINE RGBColor
const operator* (RGBColor
const & c)
const {
return RGBColor (red * c.red, green * c.green, blue * c.blue); }
4247 HPS_INLINE RGBColor
const operator+ (RGBColor
const & c)
const {
return RGBColor (red + c.red, green + c.green, blue + c.blue); }
4248 HPS_INLINE RGBColor
const operator- (RGBColor
const & c)
const {
return RGBColor (red - c.red, green - c.green, blue - c.blue); }
4250 HPS_INLINE RGBColor & operator*= (
float s) { red *= s; green *= s; blue *= s;
return *
this; }
4251 HPS_INLINE RGBColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4252 HPS_INLINE RGBColor & operator+= (
float s) { red += s; green += s; blue += s;
return *
this; }
4253 HPS_INLINE RGBColor & operator-= (
float s) { red -= s; green -= s; blue -= s;
return *
this; }
4254 HPS_INLINE RGBColor
const operator* (
float s)
const {
return RGBColor (red * s, green * s, blue * s); }
4255 HPS_INLINE RGBColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4256 HPS_INLINE RGBColor
const operator+ (
float s)
const {
return RGBColor (red + s, green + s, blue + s); }
4257 HPS_INLINE RGBColor
const operator- (
float s)
const {
return RGBColor (red - s, green - s, blue - s); }
4259 static HPS_INLINE RGBColor Black() {
return RGBColor (0, 0, 0);};
4260 static HPS_INLINE RGBColor White() {
return RGBColor (1, 1, 1);};
4261 static HPS_INLINE RGBColor Invalid() {
return RGBColor (-1, -1, -1);};
4263 void ShowHLS(
float & out_hue,
float & out_lightness,
float & out_saturation)
const;
4264 void ShowHSV(
float & out_hue,
float & out_saturation,
float & out_value)
const;
4265 void ShowHIC(
float & out_hue,
float & out_intensity,
float & out_chromaticity)
const;
4267 static RGBColor HLS(
float in_hue,
float in_lightness,
float in_saturation);
4268 static RGBColor HSV(
float in_hue,
float in_saturation,
float in_value);
4269 static RGBColor HIC(
float in_hue,
float in_intensity,
float in_chromaticity);
4272 HPS_INLINE
RGBColor const operator* (
float s,
RGBColor const & v) {
return RGBColor (s * v.red, s * v.green, s * v.blue); }
4273 HPS_INLINE RGBColor
const operator+ (
float s, RGBColor
const & v) {
return RGBColor (s + v.red, s + v.green, s + v.blue); }
4274 HPS_INLINE RGBColor
const operator- (
float s, RGBColor
const & v) {
return RGBColor (s - v.red, s - v.green, s - v.blue); }
4286 explicit HPS_INLINE
RGBAColor (
float gray,
float a = 1) : red (gray), green (gray), blue (gray), alpha (a) {}
4287 HPS_INLINE RGBAColor (
float r,
float g,
float b,
float a = 1) : red (r), green (g), blue (b), alpha (a) {}
4289 HPS_INLINE RGBAColor (RGBColor
const & c) {
4290 memcpy(
this, &c,
sizeof(RGBColor));
4292 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4294 HPS_INLINE RGBAColor (RGBColor
const & c,
float a) {
4295 memcpy(
this, &c,
sizeof(RGBColor));
4296 memcpy(&alpha, &a,
sizeof(
float));
4297 Float::apply_sign_bit(alpha, Float::extract_sign_bit(c.red) | Float::extract_sign_bit(c.green) | Float::extract_sign_bit(c.blue));
4299 explicit HPS_INLINE RGBAColor (RGBA32Color
const & c32);
4300 explicit HPS_INLINE RGBAColor (RGBAS32Color
const & c32);
4302 HPS_INLINE
bool IsGray()
const {
return (red == green && green == blue);}
4303 HPS_INLINE
float Gray()
const {
return 0.3125f * red + 0.5000f * green + 0.1875f * blue; }
4304 HPS_INLINE
bool IsValid()
const {
4305 return (Float::extract_sign_bit(red) | Float::extract_sign_bit(green) | Float::extract_sign_bit(blue) | Float::extract_sign_bit(alpha)) == 0;
4322 HPS_INLINE
bool operator!= (
RGBAColor const & c)
const {
return !(*
this == c); }
4324 HPS_INLINE
bool Equals(
RGBAColor const & c,
int in_tolerance = 32)
const {
4329 HPS_INLINE RGBAColor & operator*= (RGBAColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue; alpha *= c.alpha;
return *
this; }
4330 HPS_INLINE RGBAColor & operator+= (RGBAColor
const & c) { red += c.red; green += c.green; blue += c.blue; alpha += c.alpha;
return *
this; }
4331 HPS_INLINE RGBAColor & operator-= (RGBAColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue; alpha -= c.alpha;
return *
this; }
4332 HPS_INLINE RGBAColor
const operator* (RGBAColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha * c.alpha); }
4333 HPS_INLINE RGBAColor
const operator+ (RGBAColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha + c.alpha); }
4334 HPS_INLINE RGBAColor
const operator- (RGBAColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha - c.alpha); }
4336 HPS_INLINE RGBAColor & operator*= (
float s) { red *= s; green *= s; blue *= s; alpha *= s;
return *
this; }
4337 HPS_INLINE RGBAColor & operator/= (
float s) {
return operator*= (1.0f / s); }
4338 HPS_INLINE RGBAColor & operator+= (
float s) { red += s; green += s; blue += s; alpha += s;
return *
this; }
4339 HPS_INLINE RGBAColor & operator-= (
float s) { red -= s; green -= s; blue -= s; alpha -= s;
return *
this; }
4340 HPS_INLINE RGBAColor
const operator* (
float s)
const {
return RGBAColor (red * s, green * s, blue * s, alpha * s); }
4341 HPS_INLINE RGBAColor
const operator/ (
float s)
const {
return operator* (1.0f / s); }
4342 HPS_INLINE RGBAColor
const operator+ (
float s)
const {
return RGBAColor (red + s, green + s, blue + s, alpha + s); }
4343 HPS_INLINE RGBAColor
const operator- (
float s)
const {
return RGBAColor (red - s, green - s, blue - s, alpha - s); }
4345 HPS_INLINE RGBAColor & operator*= (RGBColor
const & c) { red *= c.red; green *= c.green; blue *= c.blue;
return *
this; }
4346 HPS_INLINE RGBAColor & operator+= (RGBColor
const & c) { red += c.red; green += c.green; blue += c.blue;
return *
this; }
4347 HPS_INLINE RGBAColor & operator-= (RGBColor
const & c) { red -= c.red; green -= c.green; blue -= c.blue;
return *
this; }
4348 HPS_INLINE RGBAColor
const operator* (RGBColor
const & c)
const {
return RGBAColor (red * c.red, green * c.green, blue * c.blue, alpha); }
4349 HPS_INLINE RGBAColor
const operator+ (RGBColor
const & c)
const {
return RGBAColor (red + c.red, green + c.green, blue + c.blue, alpha); }
4350 HPS_INLINE RGBAColor
const operator- (RGBColor
const & c)
const {
return RGBAColor (red - c.red, green - c.green, blue - c.blue, alpha); }
4352 static HPS_INLINE RGBAColor Black() {
return RGBAColor (0, 0, 0, 1);};
4353 static HPS_INLINE RGBAColor White() {
return RGBAColor (1, 1, 1, 1);};
4354 static HPS_INLINE RGBAColor Nothing() {
return RGBAColor (0, 0, 0, 0);};
4355 static HPS_INLINE RGBAColor Invalid() {
return RGBAColor (-1, -1, -1, -1);};
4369 HPS_INLINE
static Order Preferred_Order () {
return Order_BGRA;}
4370 unsigned char b, g, r, a;
4374 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4375 unsigned char r, g, b, a;
4379 HPS_INLINE
static Order Preferred_Order () {
return Order_RGBA;}
4380 unsigned char r, g, b, a;
4390 explicit HPS_INLINE
RGBAS32Color (
unsigned char gray,
unsigned char aa = 255) {
4396 HPS_INLINE
RGBAS32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255) {
4404 explicit HPS_INLINE RGBAS32Color (
RGBColor const & c)
4406 r = Float::unit_to_byte(c.red);
4407 g = Float::unit_to_byte(c.green);
4408 b = Float::unit_to_byte(c.blue);
4412 HPS_INLINE RGBAS32Color (
RGB24Color const & c);
4416 HPS_INLINE RGBAS32Color (
RGBColor const & c,
float alpha)
4418 r = Float::unit_to_byte(c.red);
4419 g = Float::unit_to_byte(c.green);
4420 b = Float::unit_to_byte(c.blue);
4421 a = Float::unit_to_byte(alpha);
4423 HPS_INLINE RGBAS32Color (
RGBColor const & c,
unsigned char aa)
4425 r = Float::unit_to_byte(c.red);
4426 g = Float::unit_to_byte(c.green);
4427 b = Float::unit_to_byte(c.blue);
4430 explicit HPS_INLINE RGBAS32Color (
RGBAColor const & c)
4432 r = Float::unit_to_byte(c.
red);
4433 g = Float::unit_to_byte(c.
green);
4434 b = Float::unit_to_byte(c.
blue);
4435 a = Float::unit_to_byte(c.
alpha);
4437 HPS_INLINE RGBAS32Color (
RGBAColor const & c,
unsigned char mix)
4439 r = Float::unit_to_byte(c.
red);
4440 g = Float::unit_to_byte(c.
green);
4441 b = Float::unit_to_byte(c.
blue);
4442 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4445 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4446 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4447 HPS_INLINE
bool IsValid()
const {
return ((r | g | b | a) != 0); }
4449 HPS_INLINE
bool operator== (RGBAS32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4450 HPS_INLINE
bool operator!= (RGBAS32Color
const & c)
const {
return !(*
this == c); }
4452 static HPS_INLINE RGBAS32Color Black() {
return RGBAS32Color (0, 0, 0, 255);};
4453 static HPS_INLINE RGBAS32Color White() {
return RGBAS32Color (255, 255, 255, 255);};
4454 static HPS_INLINE RGBAS32Color Invalid() {
return RGBAS32Color (0, 0, 0, 0);};
4456 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4467 explicit HPS_INLINE
RGBA32Color (
unsigned char gray,
unsigned char aa = 255)
4468 : r (gray), g (gray), b (gray), a (aa) {}
4469 HPS_INLINE RGBA32Color (
unsigned char rr,
unsigned char gg,
unsigned char bb,
unsigned char aa = 255)
4470 : r (rr), g (gg), b (bb), a (aa) {}
4472 : r (c32.r), g (c32.g), b (c32.b), a (c32.a) {}
4473 explicit HPS_INLINE RGBA32Color (
RGBColor const & c) {
4474 r = Float::unit_to_byte(c.red);
4475 g = Float::unit_to_byte(c.green);
4476 b = Float::unit_to_byte(c.blue);
4479 HPS_INLINE RGBA32Color (
RGBColor const & c,
float alpha) {
4480 r = Float::unit_to_byte(c.red);
4481 g = Float::unit_to_byte(c.green);
4482 b = Float::unit_to_byte(c.blue);
4483 a = Float::unit_to_byte(alpha);
4485 HPS_INLINE RGBA32Color (
RGBColor const & c,
unsigned char aa) {
4486 r = Float::unit_to_byte(c.red);
4487 g = Float::unit_to_byte(c.green);
4488 b = Float::unit_to_byte(c.blue);
4491 explicit HPS_INLINE RGBA32Color (
RGBAColor const & c) {
4492 r = Float::unit_to_byte(c.
red);
4493 g = Float::unit_to_byte(c.
green);
4494 b = Float::unit_to_byte(c.
blue);
4495 a = Float::unit_to_byte(c.
alpha);
4497 HPS_INLINE RGBA32Color (
RGBAColor const & c,
unsigned char mix) {
4498 r = Float::unit_to_byte(c.
red);
4499 g = Float::unit_to_byte(c.
green);
4500 b = Float::unit_to_byte(c.
blue);
4501 a = Float::unit_to_byte_scaled(c.
alpha, mix);
4504 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4505 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4507 HPS_INLINE
bool operator== (RGBA32Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b && a == c.a); }
4508 HPS_INLINE
bool operator!= (RGBA32Color
const & c)
const {
return !(*
this == c); }
4510 static HPS_INLINE RGBA32Color Black() {
return RGBA32Color (0, 0, 0, 255);};
4511 static HPS_INLINE RGBA32Color White() {
return RGBA32Color (255, 255, 255, 255);};
4513 static HPS_INLINE
unsigned char Opaque_Alpha () {
return 0xFF;}
4525 explicit HPS_INLINE
RGB24Color (
unsigned char gray)
4526 : r (gray), g (gray), b (gray) {}
4527 HPS_INLINE RGB24Color (
unsigned char rr,
unsigned char gg,
unsigned char bb)
4528 : r (rr), g (gg), b (bb) {}
4529 explicit HPS_INLINE RGB24Color (
RGBColor const & c) {
4530 r = Float::unit_to_byte(c.red);
4531 g = Float::unit_to_byte(c.green);
4532 b = Float::unit_to_byte(c.blue);
4535 HPS_INLINE
bool IsGray()
const {
return (r == g && g == b);}
4536 HPS_INLINE
unsigned char Gray()
const {
return (
unsigned char)(0.3125f * (float)r + 0.5000f * (
float)g + 0.1875f * (float)b); }
4538 HPS_INLINE
bool operator== (RGB24Color
const & c)
const {
return (r == c.r && g == c.g && b == c.b); }
4539 HPS_INLINE
bool operator!= (RGB24Color
const & c)
const {
return !(*
this == c); }
4542 HPS_INLINE RGBColor::RGBColor (
RGBAS32Color const & c32) {
4543 red = Float::C2F(c32.r);
4544 green = Float::C2F(c32.g);
4545 blue = Float::C2F(c32.b);
4548 HPS_INLINE RGBColor::RGBColor (RGBA32Color
const & c32) {
4549 red = Float::C2F(c32.r);
4550 green = Float::C2F(c32.g);
4551 blue = Float::C2F(c32.b);
4554 HPS_INLINE RGBColor::RGBColor (RGBAColor
const & c) {
4560 HPS_INLINE RGBColor::RGBColor (RGB24Color
const & c24) {
4561 red = Float::C2F(c24.r);
4562 green = Float::C2F(c24.g);
4563 blue = Float::C2F(c24.b);
4566 HPS_INLINE RGBAS32Color::RGBAS32Color (RGB24Color
const & c)
4574 HPS_INLINE RGBAS32Color::RGBAS32Color (RGBA32Color
const & c)
4582 HPS_INLINE RGBAColor::RGBAColor (RGBAS32Color
const & c32) {
4583 red = Float::C2F(c32.r);
4584 green = Float::C2F(c32.g);
4585 blue = Float::C2F(c32.b);
4586 alpha = Float::C2F(c32.a);
4589 HPS_INLINE RGBAColor::RGBAColor (RGBA32Color
const & c32) {
4590 red = Float::C2F(c32.r);
4591 green = Float::C2F(c32.g);
4592 blue = Float::C2F(c32.b);
4593 alpha = Float::C2F(c32.a);
4596 HPS_INLINE RGBColor Modulate(RGBColor
const & a, RGBColor
const & b) {
4597 return RGBColor(a.red * b.red, a.green * b.green, a.blue * b.blue);
4602 HPS_INLINE RGBColor Interpolate(RGBColor
const & a, RGBColor
const & b,
float t) {
4603 return RGBColor(a.red + (b.red - a.red) * t, a.green + (b.green - a.green) * t, a.blue + (b.blue - a.blue) * t);
4606 HPS_INLINE RGBAColor Interpolate(RGBAColor
const & a, RGBAColor
const & b,
float t) {
4607 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);
4610 HPS_INLINE RGBAS32Color Interpolate(RGBAS32Color
const & a, RGBAS32Color
const & b,
float t) {
4611 return RGBAS32Color(
4612 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4613 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4614 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4615 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4618 HPS_INLINE RGBA32Color Interpolate(RGBA32Color
const & a, RGBA32Color
const & b,
float t) {
4620 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4621 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4622 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t),
4623 (
unsigned char)(a.a + ((
float)b.a - (
float)a.a) * t));
4626 HPS_INLINE RGB24Color Interpolate(RGB24Color
const & a, RGB24Color
const & b,
float t) {
4628 (
unsigned char)(a.r + ((
float)b.r - (
float)a.r) * t),
4629 (
unsigned char)(a.g + ((
float)b.g - (
float)a.g) * t),
4630 (
unsigned char)(a.b + ((
float)b.b - (
float)a.b) * t));
4642 Quaternion() : w(0.0f), x(0.0f), y(0.0f), z(0.0f) { }
4644 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) { }
4662 return Quaternion(w*in_right.w - x*in_right.x - y*in_right.y - z*in_right.z,
4663 y*in_right.z - z*in_right.y + w*in_right.x + x*in_right.w,
4664 z*in_right.x - x*in_right.z + w*in_right.y + y*in_right.w,
4665 x*in_right.y - y*in_right.x + w*in_right.z + z*in_right.w);
4668 Quaternion operator* (
float in_right)
const {
4669 return Quaternion(w*in_right, x*in_right, y*in_right, z*in_right);
4673 return Quaternion(in_left*in_right.w, in_left*in_right.x, in_left*in_right.y, in_left*in_right.z);
4676 Quaternion operator/ (
float in_right)
const {
4677 return Quaternion(w/in_right, x/in_right, y/in_right, z/in_right);
4681 return Quaternion(w-in_right.w, x-in_right.x, y-in_right.y, z-in_right.z);
4685 return Quaternion(w+in_right.w, x+in_right.x, y+in_right.y, z+in_right.z);
4688 inline float Norm()
const {
4689 return static_cast<float>(sqrt(w*w + x*x + y*y + z*z));
4695 float mag_q = Norm();
4696 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4698 ret.w =
static_cast<float>(log(mag_q));
4701 float scale =
static_cast<float>(acos(w / mag_q) / mag_V);
4708 ret.x = ret.y = ret.z = 0;
4715 float ea =
static_cast<float>(exp(w));
4716 float mag_V =
static_cast<float>(sqrt(x*x + y*y + z*z));
4717 float scale = ea * sin(mag_V) / mag_V;
4719 ret.w = ea * cos(mag_V);
4728 Quaternion ret = *
this + in_fraction * (in_right - *
this);
4729 return ret.Normalize();
4733 Quaternion Slerp(
Quaternion const & in_right,
float in_fraction,
bool in_shortest_path_only =
true)
const {
4735 float dot = x*in_right.x + y*in_right.y + z*in_right.z + w*in_right.w;
4737 if (in_shortest_path_only && dot < 0) {
4744 if (dot > -0.95f && dot < 0.95f) {
4745 float angle =
static_cast<float>(acos(dot));
4746 float sina =
static_cast<float>(sin(angle));
4747 float sinat =
static_cast<float>(sin(angle*in_fraction));
4748 float sinaomt =
static_cast<float>(sin(angle*(1-in_fraction)));
4750 return (*
this * sinaomt + q3 * sinat) / sina;
4753 return Lerp(q3, in_fraction);
4766 Quaternion q1 = Slerp(in_right , in_fraction,
false);
4767 Quaternion q2 = in_control1.Slerp(in_control2, in_fraction,
false);
4769 return q1.Slerp(q2, 2*in_fraction*(1-in_fraction),
false);
4781 return *
this *
Quaternion(((qni*in_previous).Log() + (qni*in_next).Log()) / -4).Exp();
4788 size_t dot_dc_count;
4789 size_t dot_3d_count;
4790 size_t line_dc_count;
4791 size_t line_3d_count;
4792 size_t triangle_dc_count;
4793 size_t triangle_3d_count;
4794 size_t polygon_dc_count;
4795 size_t polygon_3d_count;
4796 size_t polyhedron_count;
4797 size_t deleted_display_list_count;
4798 size_t display_list_line_3d_count;
4799 size_t display_list_triangle_3d_count;
4800 size_t display_list_vertex_3d_count;
4801 size_t display_list_tristrip_count;
4802 size_t non_display_list_tristrip_count;
4803 size_t culled_display_list_tristrip_count;
4804 size_t raster_count;
4805 size_t segment_count;
4806 size_t frustum_culled_segment_count;
4807 size_t extent_culled_segment_count;
4808 size_t vector_culled_segment_count;
4812 typedef unsigned char byte;
4813 typedef signed char sbyte;
4814 typedef intptr_t WindowHandle;
4815 typedef int64_t TouchID;
4816 typedef intptr_t PlatformData;
4849 class AttributesControl;
4865 class GeometryInsertControl;
5010 class FontInfoControl;
5077 enum class Type : uint32_t
5080 GenericMask = 0xffffff00,
5084 EventDispatcher = 0x00000003,
5085 EventHandler = 0x00000004,
5086 EventNotifier = 0x00000005,
5087 UpdateNotifier = 0x00000006,
5088 SearchResults = 0x00000008,
5089 FontSearchResults = 0x00000009,
5090 SearchResultsIterator = 0x0100000a,
5091 FontSearchResultsIterator = 0x0100000b,
5092 SelectionResults = 0x0000000c,
5093 SelectionResultsIterator = 0x0100000d,
5094 SelectionItem = 0x0000000e,
5095 TreeContext = 0x0000000f,
5096 StreamToolkit = 0x00000010,
5098 IONotifier = 0x04000100,
5099 StreamImportNotifier = 0x04000101,
5100 STLImportNotifier = 0x04000102,
5101 OBJImportNotifier = 0x04000103,
5102 ExchangeImportNotifier = 0x04000104,
5103 SketchupImportNotifier = 0x04000105,
5104 ParasolidImportNotifier = 0x04000106,
5105 ExchangeTranslationNotifier = 0x04000107,
5106 ExchangeExportNotifier = 0x04000108,
5107 StreamExportNotifier = 0x04000109,
5108 ExchangeReloadNotifier = 0x0400010a,
5109 DWGImportNotifier = 0x0400010b,
5112 MarkerKit = 0x01000010,
5113 SphereAttributeKit = 0x01000011,
5114 TextAttributeKit = 0x01000012,
5115 TransparencyKit = 0x01000013,
5116 VisibilityKit = 0x01000014,
5117 VisualEffectsKit = 0x01000015,
5118 CuttingSectionAttributeKit = 0x01000016,
5119 CircleKit = 0x01000017,
5120 CircularArcKit = 0x01000018,
5121 CircularWedgeKit = 0x01000019,
5122 CuttingSectionKit = 0x0100001a,
5123 CylinderKit = 0x0100001b,
5124 DistantLightKit = 0x0100001c,
5125 EllipseKit = 0x0100001d,
5126 EllipticalArcKit = 0x0100001e,
5127 InfiniteLineKit = 0x0100001f,
5128 LineKit = 0x01000020,
5129 NURBSCurveKit = 0x01000021,
5130 MeshKit = 0x01000022,
5131 NURBSSurfaceKit = 0x01000023,
5132 PolygonKit = 0x01000024,
5133 SphereKit = 0x01000025,
5134 SpotlightKit = 0x01000026,
5135 ShellKit = 0x01000027,
5136 TextKit = 0x01000028,
5137 MaterialKit = 0x01000029,
5138 TrimKit = 0x0100002a,
5139 TextureOptionsKit = 0x0100002c,
5140 LinePatternKit = 0x0100002d,
5141 GlyphKit = 0x0100002e,
5142 ImageKit = 0x0100002f,
5143 LinePatternOptionsKit = 0x01000030,
5144 CameraKit = 0x01000031,
5145 BoundingKit = 0x01000032,
5146 CullingKit = 0x01000033,
5147 CurveAttributeKit = 0x01000034,
5148 CylinderAttributeKit = 0x01000035,
5149 EdgeAttributeKit = 0x01000036,
5150 LightingAttributeKit = 0x01000037,
5151 LineAttributeKit = 0x01000038,
5152 MarkerAttributeKit = 0x01000039,
5153 MaterialMappingKit = 0x0100003a,
5154 MatrixKit = 0x0100003b,
5155 NURBSSurfaceAttributeKit = 0x0100003c,
5156 PostProcessEffectsKit = 0x0100003d,
5157 SelectabilityKit = 0x0100003e,
5158 SelectionOptionsKit = 0x0100003f,
5159 StandAloneWindowOptionsKit = 0x01000040,
5160 OffScreenWindowOptionsKit = 0x01000041,
5161 ApplicationWindowOptionsKit = 0x01000042,
5162 HighlightOptionsKit = 0x01000043,
5163 LinePatternParallelKit = 0x01000044,
5164 SubwindowKit = 0x01000045,
5165 PerformanceKit = 0x01000046,
5166 HiddenLineAttributeKit = 0x01000047,
5167 DrawingAttributeKit = 0x01000048,
5168 ShaderKit = 0x01000049,
5169 DebuggingKit = 0x0100004a,
5170 ContourLineKit = 0x0100004b,
5171 StreamImportOptionsKit = 0x0100004c,
5172 StreamImportResultsKit = 0x0100004d,
5173 StreamExportOptionsKit = 0x0100004e,
5174 StreamExportResultsKit = 0x0100004f,
5175 WindowInfoKit = 0x01000050,
5176 ImageImportOptionsKit = 0x01000051,
5177 SearchOptionsKit = 0x01000052,
5178 ShaderImportOptionsKit = 0x01000053,
5179 HardcopyExportOptionsKit = 0x01000055,
5180 AttributeLockKit = 0x01000056,
5181 TransformMaskKit = 0x01000057,
5182 ColorInterpolationKit = 0x01000058,
5183 UpdateOptionsKit = 0x01000059,
5184 ImageExportOptionsKit = 0x0100005a,
5185 OBJImportOptionsKit = 0x0100005b,
5186 OBJImportResultsKit = 0x0100005c,
5187 STLImportOptionsKit = 0x0100005d,
5188 STLImportResultsKit = 0x0100005e,
5189 ShellOptimizationOptionsKit = 0x0100005f,
5190 ShellRelationOptionsKit = 0x01000060,
5191 ShellRelationResultsKit = 0x01000061,
5192 GridKit = 0x01000062,
5193 CutGeometryGatheringOptionsKit = 0x01000063,
5194 SegmentOptimizationOptionsKit = 0x01000064,
5197 LinePatternElement = 0x03000000,
5198 SolidLinePatternElement = 0x03000001,
5199 BlankLinePatternElement = 0x03000002,
5200 GlyphLinePatternElement = 0x03000003,
5202 GlyphElement = 0x05000000,
5203 DotGlyphElement = 0x05000001,
5204 LineGlyphElement = 0x05000002,
5205 EllipseGlyphElement = 0x05000003,
5206 CircularArcGlyphElement = 0x05000004,
5207 InfiniteLineGlyphElement = 0x05000005,
5209 TrimElement = 0x07000000,
5211 Condition = 0x09000000,
5212 NOTCondition = 0x09000001,
5213 ANDCondition = 0x09000002,
5214 ORCondition = 0x09000003,
5215 XORCondition = 0x09000004,
5216 EQCondition = 0x09000005,
5217 NEQCondition = 0x09000006,
5218 GTCondition = 0x09000007,
5219 LTCondition = 0x09000008,
5220 GTEQCondition = 0x09000009,
5221 LTEQCondition = 0x0900000A,
5223 MouseState = 0x01001001,
5224 TouchState = 0x01001002,
5225 KeyboardState = 0x01001003,
5226 FontInfoState = 0x01001004,
5228 KeyPath = 0x01000F01,
5231 IncludeKey = 0x10000001,
5232 PortfolioKey = 0x10000002,
5233 StyleKey = 0x10000003,
5235 SegmentKey = 0x10200000,
5236 WindowKey = 0x10600000,
5237 StandAloneWindowKey = 0x10600001,
5238 OffScreenWindowKey = 0x10600002,
5239 ApplicationWindowKey = 0x10600003,
5241 GeometryKey = 0x10100000,
5242 ReferenceKey = 0x10100001,
5243 CircleKey = 0x10100002,
5244 CircularArcKey = 0x10100003,
5245 CircularWedgeKey = 0x10100004,
5246 CuttingSectionKey = 0x10100005,
5247 CylinderKey = 0x10100006,
5248 EllipseKey = 0x10100007,
5249 EllipticalArcKey = 0x10100008,
5250 InfiniteLineKey = 0x10100009,
5251 LineKey = 0x1010000a,
5252 DistantLightKey = 0x1010000b,
5253 SpotlightKey = 0x1010000c,
5254 MarkerKey = 0x1010000d,
5255 MeshKey = 0x1010000e,
5256 NURBSCurveKey = 0x1010000f,
5257 NURBSSurfaceKey = 0x10100010,
5258 PolygonKey = 0x10100011,
5259 ShellKey = 0x10100012,
5260 SphereKey = 0x10100013,
5261 TextKey = 0x10100014,
5262 GridKey = 0x10100015,
5264 Definition = 0x20000000,
5265 NamedStyleDefinition = 0x20000001,
5266 TextureDefinition = 0x20000002,
5267 LinePatternDefinition = 0x20000003,
5268 GlyphDefinition = 0x20000004,
5269 CubeMapDefinition = 0x20000005,
5270 ImageDefinition = 0x20000006,
5271 MaterialPaletteDefinition = 0x20000007,
5272 ShaderDefinition = 0x20000008,
5274 Control = 0x50000000,
5275 CameraControl = 0x50000001,
5276 SelectabilityControl = 0x50000002,
5277 MarkerAttributeControl = 0x50000003,
5278 SphereAttributeControl = 0x50000004,
5279 LightingAttributeControl = 0x50000005,
5280 CylinderAttributeControl = 0x50000006,
5281 TextAttributeControl = 0x50000007,
5282 LineAttributeControl = 0x50000008,
5283 EdgeAttributeControl = 0x50000009,
5284 CurveAttributeControl = 0x5000000a,
5285 ModellingMatrixControl = 0x5000000b,
5286 TextureMatrixControl = 0x5000000c,
5287 CullingControl = 0x5000000d,
5288 TransparencyControl = 0x5000000e,
5289 MaterialMappingControl = 0x5000000f,
5290 NURBSSurfaceAttributeControl = 0x50000010,
5291 PostProcessEffectsControl = 0x50000011,
5292 BoundingControl = 0x50000012,
5293 VisualEffectsControl = 0x50000013,
5294 SelectionOptionsControl = 0x50000014,
5295 HighlightOptionsControl = 0x50000015,
5296 DefinitionControl = 0x50000016,
5297 SelectionControl = 0x50000017,
5298 HighlightControl = 0x50000018,
5299 StandAloneWindowOptionsControl = 0x50000019,
5300 OffScreenWindowOptionsControl = 0x5000001a,
5301 ApplicationWindowOptionsControl = 0x5000001b,
5302 VisibilityControl = 0x5000001c,
5303 SubwindowControl = 0x5000001d,
5304 PerformanceControl = 0x5000001e,
5305 HiddenLineAttributeControl = 0x5000001f,
5306 DrawingAttributeControl = 0x50000020,
5307 DebuggingControl = 0x50000021,
5308 ContourLineControl = 0x50000022,
5309 StyleControl = 0x50000023,
5310 ConditionControl = 0x50000024,
5311 PortfolioControl = 0x50000025,
5312 WindowInfoControl = 0x50000026,
5313 AttributeLockControl = 0x50000027,
5314 TransformMaskControl = 0x50000028,
5315 ColorInterpolationControl = 0x50000029,
5316 UpdateOptionsControl = 0x50000030,
5317 CuttingSectionAttributeControl = 0x50000031,
5319 LibraryMask = 0x80FF0000,
5321 Sprocket = 0x80000000,
5322 Canvas = 0x80000001,
5323 Layout = 0x80000002,
5326 Operator = 0x80000005,
5327 SprocketPath = 0x80000007,
5329 SprocketControl = 0xD0000000,
5330 OperatorControl = 0xD0000008,
5331 NavigationCubeControl = 0xD0000009,
5332 AxisTriadControl = 0xD000000A,
5334 Metadata = 0x80001000,
5335 IntegerMetadata = 0x80001001,
5336 UnsignedIntegerMetadata = 0x80001002,
5337 DoubleMetadata = 0x80001003,
5338 StringMetadata = 0x80001004,
5339 TimeMetadata = 0x80001005,
5340 BooleanMetadata = 0x80001006,
5342 Component = 0x80000200,
5343 Filter = 0x80000600,
5344 Capture = 0x80000a00,
5345 CADModel = 0x80000300,
5346 ComponentPath = 0x81001000,
5348 ExchangeMask = 0x80020000,
5349 ExchangeComponent = 0x80021200,
5350 ExchangeFilter = 0x80020601,
5351 ExchangeCapture = 0x80020a01,
5352 ExchangeCADModel = 0x80020301,
5353 ExchangeConfiguration = 0x81020001,
5354 ExchangeImportOptionsKit = 0x81020002,
5355 ExchangeExportACISOptionsKit = 0x81020003,
5356 ExchangeExportIGESOptionsKit = 0x81020004,
5357 ExchangeExportJTOptionsKit = 0x81020005,
5358 ExchangeExportParasolidOptionsKit = 0x81020006,
5359 ExchangeExportPRCOptionsKit = 0x81020007,
5360 ExchangeExportSTEPOptionsKit = 0x81020008,
5361 ExchangeExportSTLOptionsKit = 0x81020009,
5362 ExchangeExportU3DOptionsKit = 0x8102000a,
5363 ExchangeExportXMLOptionsKit = 0x8102000b,
5364 ExchangeTessellationOptionsKit = 0x8102000c,
5365 ExchangeSheet = 0x80021201,
5366 ExchangeModelFileImportOptionsKit = 0x8102000d,
5368 PublishMask = 0x80040000,
5369 PublishDocumentKit = 0x81040001,
5370 PublishPageKit = 0x81040002,
5371 PublishTemplateKit = 0x81040003,
5372 PublishAnnotationKit = 0x81040004,
5373 PublishArtworkKit = 0x81040005,
5374 PublishViewKit = 0x81040006,
5375 PublishTextKit = 0x81040007,
5376 PublishImageKit = 0x81040008,
5377 PublishTableKit = 0x81040009,
5378 PublishExportOptionsKit = 0x8104000a,
5379 PublishLinkKit = 0x8104000b,
5380 PublishButtonKit = 0x8104000c,
5381 PublishTextFieldKit = 0x8104000d,
5382 PublishSlideTableKit = 0x8104000e,
5383 PublishCheckBoxKit = 0x8104000f,
5384 PublishRadioButtonKit = 0x81040010,
5385 PublishListBoxKit = 0x81040011,
5386 PublishDropDownListKit = 0x81040012,
5387 PublishSignatureFieldKit = 0x81040013,
5389 PublishDocumentKey = 0x80040001,
5390 PublishPageControl = 0x80040002,
5392 SceneTree = 0x80008001,
5393 SceneTreeItem = 0x80008002,
5395 ComponentTree = 0x80008003,
5396 ComponentTreeItem = 0x80008004,
5398 SketchupMask = 0x80100000,
5399 SketchupImportOptionsKit = 0x81100001,
5400 SketchupImportResultsKit = 0x81100002,
5402 ParasolidMask = 0x80200000,
5403 ParasolidComponent = 0x80201201,
5404 ParasolidCADModel = 0x80200302,
5405 ParasolidImportOptionsKit = 0x81200003,
5406 ParasolidFacetTessellationKit = 0x81200004,
5407 ParasolidLineTessellationKit = 0x81200005,
5408 ParasolidExportOptionsKit = 0x81200006,
5410 DWGMask = 0x80400000,
5411 DWGComponent = 0x80401200,
5412 DWGCADModel = 0x80400301,
5413 DWGImportOptionsKit = 0x81400002,
5415 IONotifierData = 0x84000200,
5416 StreamImportNotifierData = 0x84000201,
5417 STLImportNotifierData = 0x84000202,
5418 OBJImportNotifierData = 0x84000203,
5419 ExchangeImportNotifierData = 0x84020204,
5420 SketchupImportNotifierData = 0x84100205,
5421 ParasolidImportNotifierData = 0x84200206,
5422 ExchangeTranslationNotifierData = 0x84020207,
5423 ExchangeExportNotifierData = 0x84020208,
5424 StreamExportNotifierData = 0x84000209,
5425 DWGImportNotifierData = 0x8440020a,
5437 static void * Allocate(
size_t in_bytes,
bool in_clear_memory =
true);
5444 static void Free(
void * in_pointer);
5453 template <
typename T>
5454 class NO_HPS_API Allocator
5457 typedef T value_type;
5458 typedef value_type * pointer;
5459 typedef value_type
const * const_pointer;
5460 typedef value_type & reference;
5461 typedef value_type
const & const_reference;
5462 typedef size_t size_type;
5463 typedef ptrdiff_t difference_type;
5467 Allocator(Allocator<T>
const & in_that) { HPS_UNREFERENCED(in_that); }
5470 template <
typename U> Allocator(Allocator<U>
const &) {}
5472 template <
typename U>
5475 typedef Allocator<U> other;
5479 pointer address(reference x)
const {
return &x; }
5480 const_pointer address(const_reference x)
const {
return &x; }
5482 pointer allocate(size_type n,
void * v = 0) { HPS_UNREFERENCED(v);
return static_cast<pointer
>(
Memory::Allocate(n *
sizeof(T))); }
5483 void deallocate(pointer p, size_type n) { HPS_UNREFERENCED(n);
Memory::Free(p); }
5485 #if defined(_MSC_VER) || defined (__APPLE__)
5486 void construct(pointer p, const_reference x) {
new(p) T(x); }
5488 template<
typename U,
typename... Args>
5489 void construct(U * p, Args&&... args) {
new(p) U(std::forward<Args>(args)...); }
5491 void destroy(pointer p) { HPS_UNREFERENCED(p); p->~T(); }
5493 size_type max_size()
const {
return static_cast<size_type
>(-1) /
sizeof(T); }
5496 template <
typename T,
typename U>
5497 bool operator==(
const Allocator<T> &,
const Allocator<U> &) {
return true; }
5499 template <
typename T,
typename U>
5500 bool operator!=(
const Allocator<T> &,
const Allocator<U> &) {
return false; }
5506 Exception(
char const * in_info) : std::runtime_error(in_info) { }
5514 InvalidObjectException(
char const * in_info =
"Attempted to use a deleted, uninitialized, or otherwise invalid object.") :
5524 IndexOutOfRangeException(
char const * in_info =
"Attempted to access an element outside the bounds of the array.") :
5594 HPS::Type Type()
const;
5603 virtual bool Empty()
const {
return (impl_ == 0);};
5606 virtual void Reset();
5611 bool HasType(HPS::Type in_mask)
const;
5615 intptr_t GetClassID()
const;
5620 intptr_t GetInstanceID()
const;
5622 template <
typename T>
5623 static intptr_t ClassID()
5625 static const intptr_t ret = T().GetClassID();
5630 friend class HPSI::Impl;
5631 friend class HPSI::KeyImpl;
5632 friend class HPSI::TicketImpl;
5641 HPS::Type ObjectType()
const {
return HPS::Type::Control;}
5658 this->Object::operator=(std::move(in_that));
6126 Event(intptr_t in_channel = 0): channel(in_channel), consumable(true), time_stamp(0) {}
6131 intptr_t GetClassID()
const;
6135 virtual Event * Clone()
const=0;
6138 virtual bool Drop(
Event const * in_that_event)
const { HPS_UNREFERENCED(in_that_event);
return false; }
6153 static void *
operator new (
size_t in_size) {
return Memory::Allocate(in_size); }
6154 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
6161 friend class HPSI::EventDispatcherImpl;
6211 enum class KeyboardCode
6411 : ID(in_id), Location(in_location), TapCount(in_tap_count) {}
6418 return (ID == in_that.
ID && Location == in_that.
Location && TapCount == in_that.
TapCount);
6426 return !(*
this == in_that);
6435 typedef std::vector<Point, Allocator<Point> > PointArray;
6436 typedef std::vector<ObjectPoint, Allocator<ObjectPoint> > ObjectPointArray;
6437 typedef std::vector<WorldPoint, Allocator<WorldPoint> > WorldPointArray;
6438 typedef std::vector<CameraPoint, Allocator<CameraPoint> > CameraPointArray;
6439 typedef std::vector<NormalizedPoint, Allocator<NormalizedPoint> > NormalizedPointArray;
6440 typedef std::vector<ScreenRangePoint, Allocator<ScreenRangePoint> > ScreenRangePointArray;
6441 typedef std::vector<InnerWindowPoint, Allocator<InnerWindowPoint> > InnerWindowPointArray;
6442 typedef std::vector<InnerPixelPoint, Allocator<InnerPixelPoint> > InnerPixelPointArray;
6443 typedef std::vector<WindowPoint, Allocator<WindowPoint> > WindowPointArray;
6444 typedef std::vector<PixelPoint, Allocator<PixelPoint> > PixelPointArray;
6445 typedef std::vector<Vector, Allocator<Vector> > VectorArray;
6446 typedef std::vector<DVector, Allocator<DVector> > DVectorArray;
6447 typedef std::vector<Plane, Allocator<Plane> > PlaneArray;
6448 typedef std::vector<int, Allocator<int> > IntArray;
6449 typedef std::vector<RGBColor, Allocator<RGBColor> > RGBColorArray;
6450 typedef std::vector<RGBAColor, Allocator<RGBAColor> > RGBAColorArray;
6451 typedef std::vector<unsigned int, Allocator<unsigned int> > UnsignedIntArray;
6452 typedef std::vector<size_t, Allocator<size_t> > SizeTArray;
6453 typedef std::vector<float, Allocator<float> > FloatArray;
6454 typedef std::vector<SegmentKey, Allocator<SegmentKey> > SegmentKeyArray;
6455 typedef std::vector<WindowKey, Allocator<WindowKey> > WindowKeyArray;
6456 typedef std::vector<EventHandler, Allocator<EventHandler> > EventHandlerArray;
6457 typedef std::vector<GlyphElement, Allocator<GlyphElement> > GlyphElementArray;
6458 typedef std::vector<GlyphPoint, Allocator<GlyphPoint> > GlyphPointArray;
6459 typedef std::vector<UTF8, Allocator<UTF8> > UTF8Array;
6460 typedef std::vector<UTF8Array, Allocator<UTF8Array> > UTF8ArrayArray;
6461 typedef std::vector<bool, Allocator<bool> > BoolArray;
6462 typedef std::vector<TrimKit, Allocator<TrimKit> > TrimKitArray;
6463 typedef std::vector<Key, Allocator<Key> > KeyArray;
6464 typedef std::vector<PortfolioKey, Allocator<PortfolioKey> > PortfolioKeyArray;
6465 typedef std::vector<char, Allocator<char> > CharArray;
6466 typedef std::vector<wchar_t, Allocator<wchar_t> > WCharArray;
6467 typedef std::vector<byte, Allocator<byte> > ByteArray;
6468 typedef std::vector<ByteArray, Allocator<ByteArray> > ByteArrayArray;
6469 typedef std::vector<sbyte, Allocator<sbyte> > SByteArray;
6470 typedef std::vector<MaterialKit, Allocator<MaterialKit> > MaterialKitArray;
6471 typedef std::vector<LinePatternElement, Allocator<LinePatternElement> > LinePatternElementArray;
6472 typedef std::vector<LinePatternParallelKit, Allocator<LinePatternParallelKit> > LinePatternParallelKitArray;
6473 typedef std::vector<Material::Type, Allocator<Material::Type> > MaterialTypeArray;
6474 typedef std::vector<Search::Type, Allocator<Search::Type> > SearchTypeArray;
6475 typedef std::vector<Line::SizeUnits, Allocator<Line::SizeUnits> > LineSizeUnitsArray;
6476 typedef std::vector<CameraKit, Allocator<CameraKit> > CameraKitArray;
6477 typedef std::vector<Condition, Allocator<Condition> > ConditionArray;
6478 typedef std::vector<TextureDefinition, Allocator<TextureDefinition> > TextureDefinitionArray;
6479 typedef std::vector<CubeMapDefinition, Allocator<CubeMapDefinition> > CubeMapDefinitionArray;
6480 typedef std::vector<ImageDefinition, Allocator<ImageDefinition> > ImageDefinitionArray;
6481 typedef std::vector<NamedStyleDefinition, Allocator<NamedStyleDefinition> > NamedStyleDefinitionArray;
6482 typedef std::vector<MaterialPaletteDefinition, Allocator<MaterialPaletteDefinition> > MaterialPaletteDefinitionArray;
6483 typedef std::vector<GlyphDefinition, Allocator<GlyphDefinition> > GlyphDefinitionArray;
6484 typedef std::vector<LinePatternDefinition, Allocator<LinePatternDefinition> > LinePatternDefinitionArray;
6485 typedef std::vector<ShaderDefinition, Allocator<ShaderDefinition> > ShaderDefinitionArray;
6486 typedef std::vector<IntRectangle, Allocator<IntRectangle> > IntRectangleArray;
6487 typedef std::vector<AttributeLock::Type, Allocator<AttributeLock::Type> > AttributeLockTypeArray;
6488 typedef std::vector<Style::Type, Allocator<Style::Type> > StyleTypeArray;
6489 typedef std::vector<TrimElement, Allocator<TrimElement> > TrimElementArray;
6490 typedef std::vector<KeyPath, Allocator<KeyPath> > KeyPathArray;
6491 typedef std::vector<IncludeKey, Allocator<IncludeKey> > IncludeKeyArray;
6492 typedef std::vector<KeyboardCode, Allocator<KeyboardCode> > KeyboardCodeArray;
6493 typedef std::vector<Touch, Allocator<Touch> > TouchArray;
6494 typedef std::vector<ReferenceKey, Allocator<ReferenceKey> > ReferenceKeyArray;
6495 typedef std::vector<intptr_t, Allocator<intptr_t> > IntPtrTArray;
6496 typedef std::vector<GeometryKey, Allocator<GeometryKey> > GeometryKeyArray;
6497 typedef std::vector<Shell::Relation, Allocator<Shell::Relation> > ShellRelationArray;
6498 typedef std::vector<StyleKey, Allocator<StyleKey> > StyleKeyArray;
6499 typedef std::vector<PointArray, Allocator<PointArray> > PointArrayArray;
6527 HPS::Type
ObjectType()
const {
return HPS::Type::SearchResultsIterator;}
6563 bool IsValid()
const;
6571 Key GetItem()
const;
6575 Key operator*()
const;
6579 SearchTypeArray GetResultTypes()
const;
6604 virtual void Reset();
6623 size_t GetCount()
const;
6662 HPS::Type
ObjectType()
const {
return HPS::Type::FontSearchResultsIterator;}
6693 bool IsValid()
const;
6732 virtual void Reset();
6737 HPS::Type
ObjectType()
const {
return HPS::Type::FontSearchResults;}
6752 size_t GetCount()
const;
6776 UTF8(
char const * in_string,
char const * in_locale = 0);
6780 UTF8(
wchar_t const * in_string);
6799 return Assign(std::move(in_utf8));
6806 size_t ToWStr(
wchar_t * out_wide_string)
const;
6811 size_t ToWStr(WCharArray & out_wide_string)
const;
6817 return (_length > 0);
6824 return (_length == 0);
6858 inline operator char const * ()
const
6865 char At(
size_t in_index)
const
6869 else if(in_index >= _length)
6872 return _text[in_index];
6878 UTF8 & Assign(
UTF8 const & in_utf8);
6885 return Assign(in_utf8);
6891 UTF8 & operator+= (
UTF8 const & in_utf8);
6896 UTF8 & operator+= (
char const * in_utf8);
6901 UTF8 operator+ (
UTF8 const & in_utf8)
const;
6906 UTF8 operator+ (
char const * in_utf8)
const;
6911 bool operator== (
UTF8 const & in_utf8)
const;
6916 bool operator!= (
UTF8 const & in_utf8)
const
6918 return !(*
this == in_utf8);
6924 bool operator== (
char const * in_utf8)
const;
6929 bool operator!= (
char const * in_utf8)
const
6931 return !(*
this == in_utf8);
6940 return in_right == in_left;
6949 return in_right != in_left;
6958 return in_right ==
UTF8(in_left);
6967 return in_right !=
UTF8(in_left);
6974 friend inline UTF8 operator+ (
char const * in_left,
UTF8 const & in_right)
6976 return UTF8(in_left) + in_right;
6983 friend inline UTF8 operator+ (
wchar_t const * in_left,
UTF8 const & in_right)
6985 return UTF8(in_left) + in_right;
6991 size_t GetHash()
const;
6995 size_t internal_encode(
wchar_t const * in_wide_string);
6996 size_t internal_decode(
wchar_t * out_wide_string)
const;
7000 mutable size_t _hash_key;
7001 static const size_t _buffer_size = 64 -
sizeof(
const char *) - 2 *
sizeof(
size_t);
7002 char _buffer[_buffer_size];
7007 inline size_t operator()(
const HPS::UTF8 & in_utf8)
const
7019 enum class Intrinsic
7038 Condition(HPS::Condition::Intrinsic in_special);
7059 bool ShowCondition(
UTF8 & out_condition)
const;
7064 bool ShowNumber(
float & out_number)
const;
7069 bool ShowIntrinsic(Condition::Intrinsic & out_special)
const;
7074 bool ShowOperands(ConditionArray & out_operands)
const;
7084 bool Equals(
Condition const & in_that)
const;
7089 bool operator==(
Condition const & in_that)
const;
7094 bool operator!=(
Condition const & in_that)
const;
7099 bool IsSatisfiedBy(UTF8Array
const & in_conditions)
const;
7104 bool IsSatisfiedBy(
char const * in_condition)
const;
7248 HPS_API Condition NOT(Condition
const & in_operand);
7254 HPS_API Condition OR(Condition
const & in_operand1, Condition
const & in_operand2);
7260 HPS_API Condition XOR(Condition
const & in_operand1, Condition
const & in_operand2);
7266 HPS_API Condition AND(Condition
const & in_operand1, Condition
const & in_operand2);
7272 HPS_API Condition EQ(Condition
const & in_operand1, Condition
const & in_operand2);
7278 HPS_API Condition NEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7284 HPS_API Condition GT(Condition
const & in_operand1, Condition
const & in_operand2);
7290 HPS_API Condition LT(Condition
const & in_operand1, Condition
const & in_operand2);
7296 HPS_API Condition GTEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7302 HPS_API Condition LTEQ(Condition
const & in_operand1, Condition
const & in_operand2);
7317 Key(
Key const & in_that);
7330 Key & operator=(
Key && in_that);
7338 bool HasOwner()
const;
7350 void MoveTo(
SegmentKey const & in_new_owner);
7357 Key & operator=(
Key const & in_that);
7360 virtual void Assign(
Key const & in_that);
7363 bool Equals(
Key const & in_that)
const;
7366 bool operator!= (
Key const & in_that)
const;
7369 bool operator== (
Key const & in_that)
const;
7373 size_t GetHash()
const;
7378 inline size_t operator()(
const HPS::Key & in_key)
const
7426 SegmentKey Down(
char const * in_segment_name,
bool in_create_if_not_present =
false)
const;
7430 SegmentKey Subsegment(
char const * in_segment_name =
"",
bool in_create_if_not_present =
true)
const;
7488 size_t ShowSubsegments()
const;
7491 size_t ShowSubsegments(SegmentKeyArray & out_children)
const;
7496 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
7501 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
7506 size_t ShowStylers(SegmentKeyArray & out_segments)
const;
7511 size_t ShowStylers(StyleKeyArray & out_styles)
const;
7516 size_t ShowIncluders(SegmentKeyArray & out_segments)
const;
7521 size_t ShowIncluders(IncludeKeyArray & out_includes)
const;
7540 SegmentKey & SetCondition(
char const * in_condition);
7543 SegmentKey & SetConditions(UTF8Array
const & in_conditions);
7546 SegmentKey & SetConditions(
size_t in_count,
UTF8 const in_conditions []);
7552 bool ShowConditions(UTF8Array & out_conditions)
const;
7562 SegmentKey & SetMaterialPalette(
char const * in_name);
7568 bool ShowMaterialPalette(
UTF8 & out_name)
const;
7586 bool ShowPriority(
int & out_priority)
const;
7592 SegmentKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
7599 SegmentKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
7605 SegmentKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
7610 SegmentKey & UnsetUserData(intptr_t in_index);
7616 SegmentKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
7621 SegmentKey & UnsetUserData(HPS::IntPtrTArray
const & in_indices);
7628 size_t ShowUserDataCount()
const;
7634 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
7639 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
7645 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
7652 LineKey InsertLine(
size_t in_count,
Point const in_pts[]);
7655 LineKey InsertLine(PointArray
const & in_pts);
7731 PolygonKey InsertPolygon(PointArray
const & in_pts);
7741 ShellKey InsertShell(PointArray
const & in_points, IntArray
const & in_facelist);
7744 ShellKey InsertShell(
size_t in_point_count,
Point const in_points [],
size_t in_facelist_count,
int const in_facelist []);
7747 ShellKey InsertShellByTristrips(PointArray
const & in_points, IntArray
const & in_tristrips);
7750 ShellKey InsertShellByTristrips(
size_t in_point_count,
Point const in_points [],
size_t in_tristrips_count,
int const in_tristrips []);
7756 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
7759 MeshKey InsertMesh(
size_t in_rows,
size_t in_columns,
size_t in_point_count,
Point const in_points []);
7807 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);
7810 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);
7817 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);
7820 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[]);
7823 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);
7826 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[]);
7837 TextKey InsertText(
Point const & in_position,
char const * in_text);
7856 LineKey InsertLineFromGeometry(
CircleKey const & in_circle,
float in_deviation = -1.0f);
7883 LineKey InsertLineFromGeometry(
EllipseKey const & in_ellipse,
float in_deviation = -1.0f);
7901 LineKey InsertLineFromGeometry(
NURBSCurveKey const & in_nurbs_curve,
float in_deviation = -1.0f);
7983 bool ShowCamera(
CameraKit & out_kit)
const;
8032 bool ShowCulling(
CullingKit & out_kit)
const;
8061 SegmentKey & UnsetCuttingSectionAttributes();
8208 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
8328 bool ShowTextureMatrix(
MatrixKit & out_kit)
const;
8429 HPS::Type
ObjectType()
const {
return HPS::Type::SegmentOptimizationOptionsKit; }
8540 bool ShowUserData(HPS::SegmentOptimizationOptions::UserData & out_user_data)
const;
8542 bool ShowMatrix(HPS::SegmentOptimizationOptions::Matrix & out_matrix)
const;
8544 bool ShowExpansion(HPS::SegmentOptimizationOptions::Expansion & out_expansion)
const;
8546 bool ShowScope(HPS::SegmentOptimizationOptions::Scope & out_scope)
const;
8548 bool ShowReorganization(HPS::SegmentOptimizationOptions::Reorganization & out_reorganization)
const;
8550 bool ShowShellInstancing(
bool & out_shell_instancing)
const;
8552 bool ShowShellMerging(
bool & out_shell_merging)
const;
8554 bool ShowAttributeDelocalization(
bool & out_attribute_delocalization)
const;
8608 HPS::Type
ObjectType()
const {
return HPS::Type::UpdateNotifier;};
8784 bool ShowSnapshot(
ImageKit & out_kit)
const;
8795 SegmentKey & UnsetCuttingSectionAttributes();
8818 void MoveTo(
SegmentKey const & in_new_owner);
8837 KeyPath(KeyArray
const & in_path);
8842 KeyPath(
size_t in_path_count,
Key const in_path []);
8875 KeyPath & operator+=(KeyArray
const & in_key_array);
8890 KeyPath & Append(KeyArray
const & in_key_array);
8900 KeyPath & operator=(KeyArray
const & in_path);
8904 void Set(
KeyPath const & in_that);
8909 bool Equals(
KeyPath const & in_that)
const;
8914 bool operator!= (
KeyPath const & in_that)
const;
8919 bool operator== (
KeyPath const & in_that)
const;
8925 KeyPath & SetKeys(KeyArray
const & in_keys);
8931 KeyPath & SetKeys(
size_t in_key_count,
Key const in_keys []);
8941 bool ShowKeys(KeyArray & out_keys)
const;
8965 bool ComputeTextExtent(
const char* in_text,
float & out_xfrac,
float & out_yfrac)
const;
8982 bool ShowNetBounding(
BoundingKit & out_kit)
const;
8986 bool ShowNetCamera(
CameraKit & out_kit)
const;
9050 bool ShowNetModellingMatrix(
MatrixKit & out_kit)
const;
9054 bool ShowNetTextureMatrix(
MatrixKit & out_kit)
const;
9058 bool ShowNetCulling(
CullingKit & out_kit)
const;
9090 bool ShowNetConditions(UTF8Array & out_conditions)
const;
9106 inline KeyPath operator+(Key
const & in_lhs, Key
const & in_rhs)
9115 inline KeyPath operator+(Key
const & in_lhs, KeyArray
const & in_rhs)
9124 inline KeyPath operator+(Key
const & in_lhs, KeyPath
const & in_rhs)
9133 inline KeyPath operator+(KeyArray
const & in_lhs, Key
const & in_rhs)
9142 inline KeyPath operator+(KeyArray
const & in_lhs, KeyArray
const & in_rhs)
9151 inline KeyPath operator+(KeyArray
const & in_lhs, KeyPath
const & in_rhs)
9160 inline KeyPath operator+(KeyPath
const & in_lhs, Key
const & in_rhs)
9169 inline KeyPath operator+(KeyPath
const & in_lhs, KeyArray
const & in_rhs)
9178 inline KeyPath operator+(KeyPath
const & in_lhs, KeyPath
const & in_rhs)
9245 bool operator==(
BoundingKit const & in_kit)
const;
9250 bool operator!=(
BoundingKit const & in_kit)
const;
9291 bool ShowExclusion(
bool & out_exclusion)
const;
9321 HPS::Type
ObjectType()
const {
return HPS::Type::BoundingControl;};
9370 bool ShowExclusion(
bool & out_exclusion)
const;
9705 bool ShowCuttingSections(
bool & out_state)
const;
9710 bool ShowCutEdges(
bool & out_state)
const;
9715 bool ShowCutFaces(
bool & out_state)
const;
9720 bool ShowWindows(
bool & out_state)
const;
9725 bool ShowText(
bool & out_state)
const;
9730 bool ShowLines(
bool & out_state)
const;
9735 bool ShowEdgeLights(
bool & out_state)
const;
9740 bool ShowMarkerLights(
bool & out_state)
const;
9745 bool ShowFaceLights(
bool & out_state)
const;
9750 bool ShowGenericEdges(
bool & out_state)
const;
9755 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
9760 bool ShowAdjacentEdges(
bool & out_state)
const;
9765 bool ShowHardEdges(
bool & out_state)
const;
9770 bool ShowMeshQuadEdges(
bool & out_state)
const;
9775 bool ShowNonCulledEdges(
bool & out_state)
const;
9780 bool ShowPerimeterEdges(
bool & out_state)
const;
9785 bool ShowFaces(
bool & out_state)
const;
9790 bool ShowVertices(
bool & out_state)
const;
9795 bool ShowMarkers(
bool & out_state)
const;
9800 bool ShowShadowCasting(
bool & out_state)
const;
9805 bool ShowShadowReceiving(
bool & out_state)
const;
9810 bool ShowShadowEmitting(
bool & out_state)
const;
9842 HPS::Type
ObjectType()
const {
return HPS::Type::VisibilityControl;};
10107 bool ShowCuttingSections(
bool & out_state)
const;
10112 bool ShowCutEdges(
bool & out_state)
const;
10117 bool ShowCutFaces(
bool & out_state)
const;
10122 bool ShowWindows(
bool & out_state)
const;
10127 bool ShowText(
bool & out_state)
const;
10132 bool ShowLines(
bool & out_state)
const;
10137 bool ShowEdgeLights(
bool & out_state)
const;
10142 bool ShowMarkerLights(
bool & out_state)
const;
10147 bool ShowFaceLights(
bool & out_state)
const;
10152 bool ShowGenericEdges(
bool & out_state)
const;
10157 bool ShowInteriorSilhouetteEdges(
bool & out_state)
const;
10162 bool ShowAdjacentEdges(
bool & out_state)
const;
10167 bool ShowHardEdges(
bool & out_state)
const;
10172 bool ShowMeshQuadEdges(
bool & out_state)
const;
10177 bool ShowNonCulledEdges(
bool & out_state)
const;
10182 bool ShowPerimeterEdges(
bool & out_state)
const;
10187 bool ShowFaces(
bool & out_state)
const;
10192 bool ShowVertices(
bool & out_state)
const;
10197 bool ShowMarkers(
bool & out_state)
const;
10202 bool ShowShadowCasting(
bool & out_state)
const;
10207 bool ShowShadowReceiving(
bool & out_state)
const;
10212 bool ShowShadowEmitting(
bool & out_state)
const;
10269 bool Empty()
const;
10274 bool Equals(
CameraKit const & in_kit)
const;
10279 bool operator==(
CameraKit const & in_kit)
const;
10284 bool operator!=(
CameraKit const & in_kit)
const;
10314 CameraKit & SetField(
float in_width,
float in_height);
10325 CameraKit & SetNearLimit(
float const in_limit);
10359 bool ShowUpVector(
Vector & out_up_vector)
const;
10364 bool ShowPosition(
Point & out_position)
const;
10369 bool ShowTarget(
Point & out_target)
const;
10381 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_y_skew,
float & out_oblique_x_skew)
const;
10386 bool ShowWidth(
float & out_width)
const;
10391 bool ShowHeight(
float & out_height)
const;
10397 bool ShowField(
float & out_width,
float & out_height)
const;
10402 bool ShowNearLimit(
float & out_near_limit)
const;
10410 CameraKit & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10418 CameraKit & Orbit(
float in_theta,
float in_phi);
10426 CameraKit & Pan(
float in_theta,
float in_phi);
10528 bool ShowUpVector(
Vector & out_up_vector)
const;
10533 bool ShowPosition(
Point & out_position)
const;
10538 bool ShowTarget(
Point & out_target)
const;
10550 bool ShowProjection(
Camera::Projection & out_type,
float & out_oblique_x_skew,
float & out_oblique_y_skew)
const;
10555 bool ShowWidth(
float & out_width)
const;
10560 bool ShowHeight(
float & out_height)
const;
10566 bool ShowField(
float & out_width,
float & out_height)
const;
10571 bool ShowNearLimit(
float & out_width)
const;
10579 CameraControl & Dolly(
float in_x_dir,
float in_up,
float in_forward);
10665 bool Empty()
const;
10844 HPS::Type
ObjectType()
const {
return HPS::Type::SelectabilityControl;};
11035 bool Empty()
const;
11121 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
11132 bool ShowDepthWriting(
bool & out_state)
const;
11163 HPS::Type
ObjectType()
const {
return HPS::Type::TransparencyControl;};
11236 bool ShowDepthPeelingLayers(
unsigned int & out_layers)
const;
11247 bool ShowDepthWriting(
bool & out_state)
const;
11278 HPS::Type
ObjectType()
const {
return HPS::Type::ColorInterpolationKit;};
11292 bool Empty()
const;
11367 bool ShowFaceColor(
bool & out_state)
const;
11372 bool ShowEdgeColor(
bool & out_state)
const;
11377 bool ShowVertexColor(
bool & out_state)
const;
11382 bool ShowFaceIndex(
bool & out_state)
const;
11387 bool ShowEdgeIndex(
bool & out_state)
const;
11392 bool ShowVertexIndex(
bool & out_state)
const;
11422 HPS::Type
ObjectType()
const {
return HPS::Type::ColorInterpolationControl;};
11488 bool ShowFaceColor(
bool & out_state)
const;
11493 bool ShowEdgeColor(
bool & out_state)
const;
11498 bool ShowVertexColor(
bool & out_state)
const;
11503 bool ShowFaceIndex(
bool & out_state)
const;
11508 bool ShowEdgeIndex(
bool & out_state)
const;
11513 bool ShowVertexIndex(
bool & out_state)
const;
11568 bool Empty()
const;
11573 bool Equals(
CullingKit const & in_kit)
const;
11578 bool operator==(
CullingKit const & in_kit)
const;
11583 bool operator!=(
CullingKit const & in_kit)
const;
11589 CullingKit & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11595 CullingKit & SetDeferralExtent(
unsigned int in_pixels);
11601 CullingKit & SetExtent(
bool in_state,
unsigned int in_pixels);
11607 CullingKit & SetExtent(
unsigned int in_pixels);
11648 CullingKit & SetVectorTolerance(
float in_tolerance_degrees);
11687 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11693 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11698 bool ShowBackFace(
bool & out_state)
const;
11705 bool ShowVector(
bool & out_state,
HPS::Vector & out_vector)
const;
11710 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11715 bool ShowFrustum(
bool & out_state)
const;
11755 CullingControl & SetDeferralExtent(
bool in_state,
unsigned int in_pixels);
11769 CullingControl & SetExtent(
bool in_state,
unsigned int in_pixels);
11817 CullingControl & SetVectorTolerance(
float in_tolerance_degrees);
11856 bool ShowDeferralExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11862 bool ShowExtent(
bool & out_state,
unsigned int & out_pixels)
const;
11867 bool ShowBackFace(
bool & out_state)
const;
11874 bool ShowVector(
bool & out_state,
HPS::Vector & out_vector)
const;
11879 bool ShowVectorTolerance(
float & out_tolerance_degrees)
const;
11884 bool ShowFrustum(
bool & out_state)
const;
11919 HPS::Type
ObjectType()
const {
return HPS::Type::MarkerAttributeKit;};
11941 bool Empty()
const;
11987 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
12024 HPS::Type
ObjectType()
const {
return HPS::Type::MarkerAttributeControl;};
12057 bool ShowSymbol(
UTF8 & out_glyph_name)
const;
12096 HPS::Type
ObjectType()
const {
return HPS::Type::SphereAttributeKit;};
12118 bool Empty()
const;
12154 bool ShowTessellation(
size_t & out_facets)
const;
12183 HPS::Type
ObjectType()
const {
return HPS::Type::SphereAttributeControl;};
12208 bool ShowTessellation(
size_t & out_facets)
const;
12241 HPS::Type
ObjectType()
const {
return HPS::Type::LightingAttributeKit;};
12263 bool Empty()
const;
12332 HPS::Type
ObjectType()
const {
return HPS::Type::LightingAttributeControl;};
12390 HPS::Type
ObjectType()
const {
return HPS::Type::CylinderAttributeKit;};
12412 bool Empty()
const;
12458 bool ShowTessellation(
size_t & out_facets)
const;
12494 HPS::Type
ObjectType()
const {
return HPS::Type::CylinderAttributeControl;};
12528 bool ShowTessellation(
size_t & out_facets)
const;
12567 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionAttributeKit;};
12589 bool Empty()
const;
12684 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionAttributeControl;};
12792 bool Empty()
const;
13066 bool ShowBold(
bool & out_state)
const;
13071 bool ShowItalic(
bool & out_state)
const;
13076 bool ShowOverline(
bool & out_state)
const;
13081 bool ShowStrikethrough(
bool & out_state)
const;
13086 bool ShowUnderline(
bool & out_state)
const;
13091 bool ShowSlant(
float & out_angle)
const;
13096 bool ShowLineSpacing(
float & out_multiplier)
const;
13102 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13109 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13135 bool ShowFont(
UTF8 & out_name)
const;
13158 bool ShowPath(
Vector & out_path)
const;
13163 bool ShowSpacing(
float & out_multiplier)
const;
13194 HPS::Type
ObjectType()
const {
return HPS::Type::TextAttributeControl;};
13456 bool ShowBold(
bool & out_state)
const;
13461 bool ShowItalic(
bool & out_state)
const;
13466 bool ShowOverline(
bool & out_state)
const;
13471 bool ShowStrikethrough(
bool & out_state)
const;
13476 bool ShowUnderline(
bool & out_state)
const;
13481 bool ShowSlant(
float & out_angle)
const;
13486 bool ShowLineSpacing(
float & out_multiplier)
const;
13492 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
13499 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
13525 bool ShowFont(
UTF8 & out_name)
const;
13548 bool ShowPath(
Vector & out_path)
const;
13553 bool ShowSpacing(
float & out_multiplier)
const;
13611 bool Empty()
const;
13670 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13701 HPS::Type
ObjectType()
const {
return HPS::Type::LineAttributeControl;};
13748 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
13804 bool Empty()
const;
13850 bool ShowPattern(
UTF8 & out_pattern_name)
const;
13856 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
13887 HPS::Type
ObjectType()
const {
return HPS::Type::EdgeAttributeControl;};
13920 bool ShowPattern(
UTF8 & out_pattern_name)
const;
13926 bool ShowWeight(
float & out_weight,
Edge::SizeUnits & out_units)
const;
13981 bool Empty()
const;
14076 bool ShowBudget(
size_t & out_budget)
const;
14082 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
14087 bool ShowViewDependent(
bool & out_state)
const;
14093 bool ShowMaximumDeviation(
float & out_deviation)
const;
14099 bool ShowMaximumAngle(
float & out_degrees)
const;
14105 bool ShowMaximumLength(
float & out_length)
const;
14135 HPS::Type
ObjectType()
const {
return HPS::Type::CurveAttributeControl;};
14219 bool ShowBudget(
size_t & out_budget)
const;
14225 bool ShowContinuedBudget(
bool & out_state,
size_t & out_budget)
const;
14230 bool ShowViewDependent(
bool & out_state)
const;
14236 bool ShowMaximumDeviation(
float & out_deviation)
const;
14242 bool ShowMaximumAngle(
float & out_degrees)
const;
14248 bool ShowMaximumLength(
float & out_length)
const;
14283 MatrixKit(FloatArray
const & in_matrix_source);
14288 MatrixKit(
float const in_matrix_source []);
14318 bool Empty()
const;
14323 bool Equals(
MatrixKit const & in_kit)
const;
14328 bool operator==(
MatrixKit const & in_kit)
const;
14333 bool operator!=(
MatrixKit const & in_kit)
const;
14340 MatrixKit & SetElement(
size_t in_row,
size_t in_column,
float in_value);
14346 MatrixKit & SetElement(
size_t in_ordinal_zero_to_fifteen,
float in_value);
14351 MatrixKit & SetElements(FloatArray
const & in_matrix);
14357 MatrixKit & SetElements(
size_t in_value_count,
float const in_values []);
14370 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14376 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14381 bool ShowElements(FloatArray & out_matrix)
const;
14386 bool ShowDeterminant(
float & out_determinant)
const;
14391 bool ShowInverse(
MatrixKit & out_matrix)
const;
14397 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14405 MatrixKit & Rotate(
float in_x,
float in_y,
float in_z);
14418 MatrixKit & Translate(
float in_x,
float in_y,
float in_z);
14425 MatrixKit & Scale(
float in_x,
float in_y,
float in_z);
14459 MatrixKit Multiply(
float in_scalar)
const;
14464 MatrixKit const & MultiplyAndAssign(
float in_scalar);
14479 MatrixKit operator*(
float in_scalar)
const;
14484 MatrixKit const & operator*=(
float in_scalar);
14490 Point Transform(
Point const & in_source)
const;
14495 PointArray Transform(PointArray
const & in_source)
const;
14501 PointArray Transform(
size_t in_count,
Point const in_source [])
const;
14511 VectorArray Transform(VectorArray
const & in_source)
const;
14517 VectorArray Transform(
size_t in_count,
Vector const in_source [])
const;
14522 Plane Transform(
Plane const & in_source)
const;
14527 PlaneArray Transform(PlaneArray
const & in_source)
const;
14533 PlaneArray Transform(
size_t in_count,
Plane const in_source [])
const;
14575 HPS::Type
ObjectType()
const {
return HPS::Type::ModellingMatrixControl;};
14615 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14621 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14626 bool ShowElements(FloatArray & out_matrix)
const;
14631 bool ShowDeterminant(
float & out_determinant)
const;
14636 bool ShowInverse(
MatrixKit & out_matrix)
const;
14642 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14719 HPS::Type
ObjectType()
const {
return HPS::Type::TextureMatrixControl;};
14760 bool ShowElement(
size_t in_row,
size_t in_column,
float & out_value)
const;
14766 bool ShowElement(
size_t in_ordinal_zero_to_fifteen,
float & out_value)
const;
14771 bool ShowElements(FloatArray & out_matrix)
const;
14776 bool ShowDeterminant(
float & out_determinant)
const;
14781 bool ShowInverse(
MatrixKit & out_matrix)
const;
14787 bool ShowAdjoint(
MatrixKit & out_matrix)
const;
14866 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialMappingKit;};
14888 bool Empty()
const;
15492 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15499 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15718 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
15750 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialMappingControl;};
16344 bool ShowAmbientLightUpColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16352 bool ShowAmbientLightDownColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16570 bool ShowWindowContrastColor(
Material::Type & out_type,
RGBAColor & out_rgba_color,
float & out_value)
const;
16601 HPS::Type
ObjectType()
const {
return HPS::Type::PortfolioControl; };
16607 size_t GetCount()
const;
16660 bool Show(PortfolioKeyArray & out_portfolios)
const;
16698 size_t GetCount()
const;
16702 StyleKey PushNamed(
char const * in_style_name);
16705 StyleKey PushNamed(
char const * in_style_name,
Condition const & in_condition);
16741 void Flush(
SegmentKey const & in_style_source);
16754 void Flush(
char const * in_style_name);
16762 void Flush(
char const * in_style_name,
Condition const & in_condition);
16767 StyleKey SetNamed(
char const * in_style_name);
16790 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names, ConditionArray
const & in_conditions);
16796 void Set(StyleTypeArray
const & in_types, SegmentKeyArray
const & in_segment_sources, UTF8Array
const & in_style_names);
16812 void UnsetAllSegment();
16815 void UnsetAllNamed();
16818 void UnsetEverything();
16832 bool ShowTop(
StyleKey & out_style)
const;
16840 bool Show(StyleTypeArray & out_types, SegmentKeyArray & out_segment_sources, UTF8Array & out_style_names, ConditionArray & out_conditions)
const;
16845 bool Show(StyleKeyArray & out_styles)
const;
16851 bool ShowAllSegment(SegmentKeyArray & out_segments, HPS::ConditionArray & out_conditions)
const;
16856 bool ShowAllSegment(StyleKeyArray & out_styles)
const;
16862 bool ShowAllNamed(UTF8Array & out_names, HPS::ConditionArray & out_conditions)
const;
16867 bool ShowAllNamed(StyleKeyArray & out_styles)
const;
16899 HPS::Type
ObjectType()
const {
return HPS::Type::ConditionControl; };
16906 size_t GetCount()
const;
16944 bool ShowCondition(
char const * in_condition)
const;
16949 bool ShowConditions(UTF8Array & out_conditions)
const;
17000 bool Empty()
const;
17010 bool operator==(
MaterialKit const & in_kit)
const;
17015 bool operator!=(
MaterialKit const & in_kit)
const;
17052 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
size_t in_layer=0);
17061 MaterialKit & SetDiffuseTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color,
size_t in_layer=0);
17067 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names);
17074 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names []);
17082 MaterialKit & SetDiffuseTexture(UTF8Array
const & in_texture_names, RGBAColorArray
const & in_modulating_colors);
17091 MaterialKit & SetDiffuseTexture(
size_t in_count,
UTF8 const in_texture_names [],
RGBAColor const in_modulating_colors []);
17097 MaterialKit & SetShader(
char const * in_shader_name);
17109 MaterialKit & SetSpecular(
char const * in_texture_name);
17115 MaterialKit & SetSpecular(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17127 MaterialKit & SetMirror(
char const * in_texture_name);
17140 MaterialKit & SetTransmission(
char const * in_texture_name);
17146 MaterialKit & SetTransmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17158 MaterialKit & SetEmission(
char const * in_texture_name);
17164 MaterialKit & SetEmission(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17171 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name);
17177 MaterialKit & SetEnvironmentTexture(
char const * in_texture_name,
RGBAColor const & in_modulating_color);
17182 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name);
17188 MaterialKit & SetEnvironmentCubeMap(
char const * in_cubemap_name,
RGBAColor const & in_modulating_color);
17198 MaterialKit & SetBump(
char const * in_texture_name);
17229 MaterialKit & UnsetDiffuseTexture(
size_t in_layer);
17270 bool ShowDiffuse()
const;
17275 bool ShowDiffuseColor(
RGBColor & out_rgb_color)
const;
17280 bool ShowDiffuseColor(
RGBAColor & out_rgba_color)
const;
17285 bool ShowDiffuseAlpha(
float & out_alpha)
const;
17310 bool ShowDiffuseTexture(MaterialTypeArray & out_types, RGBAColorArray & out_colors, UTF8Array & out_texture_names)
const;
17315 bool ShowShader(
UTF8 & out_shader_name)
const;
17375 bool ShowBump(
UTF8 & out_texture_name)
const;
17381 bool ShowGloss(
float & out_gloss)
const;
17410 HPS::Type
ObjectType()
const {
return HPS::Type::NURBSSurfaceAttributeKit;};
17432 bool Empty()
const;
17514 bool ShowBudget(
size_t & out_budget)
const;
17519 bool ShowMaximumDeviation(
float & out_deviation)
const;
17524 bool ShowMaximumAngle(
float & out_degrees)
const;
17529 bool ShowMaximumWidth(
float & out_width)
const;
17534 bool ShowTrimBudget(
size_t & out_budget)
const;
17539 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17570 HPS::Type
ObjectType()
const {
return HPS::Type::NURBSSurfaceAttributeControl;};
17640 bool ShowBudget(
size_t & out_budget)
const;
17645 bool ShowMaximumDeviation(
float & out_deviation)
const;
17650 bool ShowMaximumAngle(
float & out_degrees)
const;
17655 bool ShowMaximumWidth(
float & out_width)
const;
17660 bool ShowTrimBudget(
size_t & out_budget)
const;
17665 bool ShowMaximumTrimDeviation(
float & out_deviation)
const;
17721 bool Empty()
const;
17803 HPS::Type
ObjectType()
const {
return HPS::Type::PerformanceControl;};
17876 HPS::Type
ObjectType()
const {
return HPS::Type::HiddenLineAttributeKit;};
17898 bool Empty()
const;
18038 bool ShowColor(
RGBAColor & out_color)
const;
18043 bool ShowDimFactor(
float & out_zero_to_one)
const;
18048 bool ShowFaceDisplacement(
float & out_buckets)
const;
18053 bool ShowLinePattern(
UTF8 & out_pattern)
const;
18058 bool ShowRenderFaces(
bool & out_state)
const;
18063 bool ShowRenderText(
bool & out_state)
const;
18073 bool ShowSilhouetteCleanup(
bool & out_state)
const;
18078 bool ShowVisibility(
bool & out_state)
const;
18084 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
18089 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
18121 HPS::Type
ObjectType()
const {
return HPS::Type::HiddenLineAttributeControl;};
18248 bool ShowColor(
RGBAColor & out_color)
const;
18253 bool ShowDimFactor(
float & out_zero_to_one)
const;
18258 bool ShowFaceDisplacement(
float & out_buckets)
const;
18263 bool ShowLinePattern(
UTF8 & out_pattern)
const;
18268 bool ShowRenderFaces(
bool & out_state)
const;
18273 bool ShowRenderText(
bool & out_state)
const;
18283 bool ShowSilhouetteCleanup(
bool & out_state)
const;
18288 bool ShowVisibility(
bool & out_state)
const;
18294 bool ShowWeight(
float & out_weight,
Line::SizeUnits & out_units)
const;
18299 bool ShowTransparencyCutoff(
float & out_zero_to_one)
const;
18333 HPS::Type
ObjectType()
const {
return HPS::Type::DrawingAttributeKit;};
18355 bool Empty()
const;
18539 bool ShowDepthRange(
float & out_near,
float & out_far)
const;
18545 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18551 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18557 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18567 bool ShowDeferral(
int & out_defer_batch)
const;
18613 HPS::Type
ObjectType()
const {
return HPS::Type::DrawingAttributeControl;};
18779 bool ShowDepthRange(
float & out_x,
float & out_y)
const;
18785 bool ShowFaceDisplacement(
bool & out_state,
int & out_buckets)
const;
18791 bool ShowGeneralDisplacement(
bool & out_state,
int & out_buckets)
const;
18797 bool ShowVertexDisplacement(
bool & out_state,
int & out_buckets)
const;
18807 bool ShowDeferral(
int & out_defer_batch)
const;
18847 HPS::Type
ObjectType()
const {
return HPS::Type::PostProcessEffectsKit;};
18869 bool Empty()
const;
18932 PostProcessEffectsKit & SetDepthOfField(
float in_strength,
float in_near_distance,
float in_far_distance);
18941 PostProcessEffectsKit & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
18958 PostProcessEffectsKit & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
18966 PostProcessEffectsKit & SetEyeDomeLighting(
float in_exponent,
bool in_tolerance,
float in_strength);
19015 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
19024 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
19033 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
19063 HPS::Type
ObjectType()
const {
return HPS::Type::PostProcessEffectsControl;};
19123 PostProcessEffectsControl & SetSilhouetteEdges(
bool in_state,
float in_tolerance = 1.0f,
bool in_heavy_exterior =
false);
19139 PostProcessEffectsControl & SetEyeDomeLighting(
bool in_state,
float in_exponent = 50.0f,
float in_tolerance = 1.0f,
float in_strength = 1.0f);
19197 bool ShowDepthOfField(
bool & out_state,
float & out_strength,
float & out_near_distance,
float & out_far_distance)
const;
19206 bool ShowSilhouetteEdges(
bool & out_state,
float & out_tolerance,
bool & out_heavy_exterior)
const;
19215 bool ShowEyeDomeLighting(
bool & out_state,
float & out_exponent,
float & out_tolerance,
float & out_strength)
const;
19260 bool Empty()
const;
19404 bool ShowCameraRotation(
bool & out_state)
const;
19409 bool ShowCameraScale(
bool & out_state)
const;
19414 bool ShowCameraTranslation(
bool & out_state)
const;
19419 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19424 bool ShowCameraProjection(
bool & out_state)
const;
19429 bool ShowCameraOffset(
bool & out_state)
const;
19434 bool ShowCameraNearLimit(
bool & out_state)
const;
19439 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19444 bool ShowModellingMatrixScale(
bool & out_state)
const;
19449 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19454 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19485 HPS::Type
ObjectType()
const {
return HPS::Type::TransformMaskControl;};
19620 bool ShowCameraRotation(
bool & out_state)
const;
19625 bool ShowCameraScale(
bool & out_state)
const;
19630 bool ShowCameraTranslation(
bool & out_state)
const;
19635 bool ShowCameraPerspectiveScale(
bool & out_state)
const;
19640 bool ShowCameraProjection(
bool & out_state)
const;
19645 bool ShowCameraOffset(
bool & out_state)
const;
19650 bool ShowCameraNearLimit(
bool & out_state)
const;
19655 bool ShowModellingMatrixRotation(
bool & out_state)
const;
19660 bool ShowModellingMatrixScale(
bool & out_state)
const;
19665 bool ShowModellingMatrixTranslation(
bool & out_state)
const;
19670 bool ShowModellingMatrixOffset(
bool & out_state)
const;
19726 bool Empty()
const;
19762 VisualEffectsKit & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
19772 VisualEffectsKit & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
19780 VisualEffectsKit & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
19787 VisualEffectsKit & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
19814 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);
19825 VisualEffectsKit & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
19885 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
19890 bool ShowAntiAliasing(
bool & out_state)
const;
19899 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
19907 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
19912 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
19917 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
19922 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
19932 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;
19938 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
19943 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
19975 HPS::Type
ObjectType()
const {
return HPS::Type::VisualEffectsControl;};
19999 VisualEffectsControl & SetShadowMaps(
bool in_state,
unsigned int in_samples = 4,
unsigned int in_resolution = 1024,
bool in_view_dependent =
true,
bool in_jitter =
true);
20009 VisualEffectsControl & SetShadowMaps(
unsigned int in_samples,
unsigned int in_resolution,
bool in_view_dependent,
bool in_jitter);
20017 VisualEffectsControl & SetSimpleShadow(
bool in_state,
unsigned int in_resolution = 256,
unsigned int in_blurring = 1,
bool in_ignore_transparency =
false);
20024 VisualEffectsControl & SetSimpleShadow(
unsigned int in_resolution,
unsigned int in_blurring,
bool in_ignore_transparency);
20051 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);
20062 VisualEffectsControl & SetSimpleReflection(
float in_opacity,
unsigned int in_blurring,
bool in_fading,
float in_attenuation_near_distance,
float in_attenuation_far_distance);
20123 bool ShowPostProcessEffectsEnabled(
bool & out_state)
const;
20128 bool ShowAntiAliasing(
bool & out_state)
const;
20137 bool ShowShadowMaps(
bool & out_state,
unsigned int & out_samples,
unsigned int & out_resolution,
bool & out_view_dependent,
bool & out_jitter)
const;
20145 bool ShowSimpleShadow(
bool & out_state,
unsigned int & out_resolution,
unsigned int & out_blurring,
bool & out_ignore_transparency)
const;
20150 bool ShowSimpleShadowPlane(
Plane & out_projected_onto)
const;
20155 bool ShowSimpleShadowLightDirection(
Vector & out_direction)
const;
20160 bool ShowSimpleShadowColor(
RGBAColor & out_color)
const;
20170 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;
20175 bool ShowSimpleReflectionPlane(
Plane & out_projected_onto)
const;
20180 bool ShowSimpleReflectionVisibility(
VisibilityKit & out_reflected_types)
const;
20236 bool Empty()
const;
20263 ContourLineKit & SetPositions(
float in_interval,
float in_offset);
20274 ContourLineKit & SetPositions(
size_t in_count,
float const in_positions[]);
20312 ContourLineKit & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20365 bool ShowVisibility(
bool & out_state)
const;
20372 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20377 bool ShowColors(RGBColorArray & out_colors)
const;
20382 bool ShowPatterns(UTF8Array & out_patterns)
const;
20388 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20393 bool ShowLighting(
bool & out_state)
const;
20422 HPS::Type
ObjectType()
const {
return HPS::Type::ContourLineControl; };
20486 ContourLineControl & SetWeights(FloatArray
const & in_weights, LineSizeUnitsArray
const & in_units);
20539 bool ShowVisibility(
bool & out_state)
const;
20546 bool ShowPositions(
ContourLine::Mode & out_mode, FloatArray & out_positions)
const;
20551 bool ShowColors(RGBColorArray & out_colors)
const;
20556 bool ShowPatterns(UTF8Array & out_patterns)
const;
20562 bool ShowWeights(FloatArray & out_weights, LineSizeUnitsArray & out_units)
const;
20567 bool ShowLighting(
bool & out_state)
const;
20622 bool Empty()
const;
20735 bool ShowModelCompareMode(
bool & out_state,
SegmentKey & out_source1,
SegmentKey & out_source2)
const;
20871 bool ShowModelCompareMode(
bool & out_state,
SegmentKey & out_source1,
SegmentKey & out_source2)
const;
20926 bool Empty()
const;
20962 bool ShowResourceMonitor(
bool & out_display)
const;
21005 bool ShowResourceMonitor(
bool & out_display)
const;
21010 bool ShowLastUpdateInfo(
UpdateInfo & out_info);
21059 bool Empty()
const;
21081 WindowInfoKit & SetPhysicalPixels(
unsigned int in_width,
unsigned int in_height);
21087 WindowInfoKit & SetPhysicalSize(
float in_width,
float in_height);
21093 WindowInfoKit & SetWindowPixels(
unsigned int in_width,
unsigned int in_height);
21099 WindowInfoKit & SetWindowSize(
float in_width,
float in_height);
21127 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21133 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
21139 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21145 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
21152 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
21157 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
21162 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
21200 bool ShowPhysicalPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21206 bool ShowPhysicalSize(
float & out_width,
float & out_height)
const;
21212 bool ShowWindowPixels(
unsigned int & out_width,
unsigned int & out_height)
const;
21218 bool ShowWindowSize(
float & out_width,
float & out_height)
const;
21225 bool ShowResolution(
float & out_horizontal,
float & out_vertical)
const;
21230 bool ShowWindowAspectRatio(
float & out_window_aspect)
const;
21235 bool ShowPixelAspectRatio(
float & out_pixel_aspect)
const;
21241 bool ShowMaxTextureSize(
unsigned int & out_width,
unsigned int & out_height)
const;
21247 bool ShowLastUpdateTime(Time & out_time)
const;
21252 bool ShowDepthPeelingLayers(
size_t & out_layers)
const;
21257 bool ShowVideoMemory(
size_t & out_video_memory)
const;
21262 bool ShowDepthBufferSize(
size_t & out_bits)
const;
21267 bool ShowMaxLights(
size_t & out_lights)
const;
21272 bool ShowColorBitPlanes(
size_t & out_planes)
const;
21324 bool Empty()
const;
21343 UTF8 GetName()
const;
21347 bool GetShellConvertibility()
const;
21400 bool Empty()
const;
21428 AttributeLockKit & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21442 AttributeLockKit & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21459 AttributeLockKit & UnsetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types);
21476 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21488 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21519 HPS::Type
ObjectType()
const {
return HPS::Type::AttributeLockControl;}
21536 AttributeLockControl & SetLock(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21550 AttributeLockControl & SetSubsegmentLockOverride(AttributeLockTypeArray
const & in_types, BoolArray
const & in_states);
21584 bool ShowLock(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21596 bool ShowSubsegmentLockOverride(AttributeLockTypeArray & out_types, BoolArray & out_states)
const;
21645 size_t ShowReferrers(SegmentKeyArray & out_segments)
const;
21650 size_t ShowReferrers(ReferenceKeyArray & out_references)
const;
21669 bool ShowPriority(
int & out_priority)
const;
21677 GeometryKey & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21683 GeometryKey & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21689 GeometryKey & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21700 GeometryKey & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21705 GeometryKey & UnsetUserData(IntPtrTArray
const & in_indices);
21712 size_t ShowUserDataCount()
const;
21717 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21723 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21729 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21765 void Consume(
LineKit & in_kit);
21769 void Set(
LineKit const & in_kit);
21773 void Show(
LineKit & out_kit)
const;
21782 bool Empty()
const;
21787 bool Equals(
LineKit const & in_kit)
const;
21792 bool operator==(
LineKit const & in_kit)
const;
21797 bool operator!=(
LineKit const & in_kit)
const;
21801 size_t GetPointCount()
const;
21809 LineKit & SetPriority(
int in_priority);
21818 bool ShowPriority(
int & out_priority)
const;
21824 LineKit & SetPoints(PointArray
const & in_points);
21830 LineKit & SetPoints(
size_t in_count,
Point const in_points []);
21845 bool ShowPoints(PointArray & out_points)
const;
21852 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
21858 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
21865 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
21873 LineKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21879 LineKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
21885 LineKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
21892 LineKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
21899 LineKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
21906 LineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
21912 LineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
21918 LineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
21923 LineKit & UnsetUserData(intptr_t in_index);
21929 LineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
21934 LineKit & UnsetUserData(IntPtrTArray
const & in_indices);
21938 LineKit & UnsetAllUserData();
21941 size_t ShowUserDataCount()
const;
21946 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
21952 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
21958 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
21999 void Consume(
LineKit & in_kit);
22003 void Set(
LineKit const & in_kit);
22007 void Show(
LineKit & out_kit)
const;
22011 size_t GetPointCount()
const;
22016 LineKey & SetPoints(PointArray
const & in_points);
22022 LineKey & SetPoints(
size_t in_count,
Point const in_points []);
22028 bool ShowPoints(PointArray & out_points)
const;
22035 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22041 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22048 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22056 LineKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22062 LineKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
22068 LineKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
22075 LineKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
22082 LineKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
22131 bool Empty()
const;
22136 bool Equals(
MarkerKit const & in_kit)
const;
22141 bool operator==(
MarkerKit const & in_kit)
const;
22146 bool operator!=(
MarkerKit const & in_kit)
const;
22155 MarkerKit & SetPriority(
int in_priority);
22164 bool ShowPriority(
int & out_priority)
const;
22184 bool ShowPoint(
HPS::Point & out_point)
const;
22191 MarkerKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22197 MarkerKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22203 MarkerKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22208 MarkerKit & UnsetUserData(intptr_t in_index);
22214 MarkerKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22219 MarkerKit & UnsetUserData(IntPtrTArray
const & in_indices);
22226 size_t ShowUserDataCount()
const;
22231 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22237 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22243 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22303 bool ShowPoint(
Point & out_point)
const;
22352 bool Empty()
const;
22427 bool ShowPriority(
int & out_priority)
const;
22432 bool ShowDirection(
HPS::Vector & out_vector)
const;
22444 bool ShowCameraRelative(
bool & out_state)
const;
22451 DistantLightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22457 DistantLightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22463 DistantLightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22474 DistantLightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22486 size_t ShowUserDataCount()
const;
22491 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22497 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22503 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
22587 bool ShowDirection(
HPS::Vector & out_vector)
const;
22599 bool ShowCameraRelative(
bool & out_state)
const;
22649 bool Empty()
const;
22659 bool operator==(
CylinderKit const & in_kit)
const;
22664 bool operator!=(
CylinderKit const & in_kit)
const;
22668 size_t GetPointCount()
const;
22685 bool ShowPriority(
int & out_priority)
const;
22691 CylinderKit & SetPoints(PointArray
const & in_points);
22702 CylinderKit & SetRadii(FloatArray
const & in_radii);
22708 CylinderKit & SetRadii(
size_t in_count,
float const in_radii []);
22736 bool ShowPoints(PointArray & out_points)
const;
22743 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
22749 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
22756 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
22761 bool ShowRadii(FloatArray & out_radii)
const;
22887 CylinderKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
22892 CylinderKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
22925 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
22939 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
22946 CylinderKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
22952 CylinderKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
22958 CylinderKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
22969 CylinderKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
22974 CylinderKit & UnsetUserData(IntPtrTArray
const & in_indices);
22981 size_t ShowUserDataCount()
const;
22986 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
22992 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
22998 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23052 CylinderKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
23058 CylinderKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
23064 CylinderKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
23071 CylinderKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
23078 CylinderKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
23086 CylinderKey & EditRadiiByInsertion(
size_t in_offset,
size_t in_count,
float const in_radii[]);
23092 CylinderKey & EditRadiiByInsertion(
size_t in_offset, FloatArray
const & in_radii);
23098 CylinderKey & EditRadiiByDeletion(
size_t in_offset,
size_t in_count);
23105 CylinderKey & EditRadiiByReplacement(
size_t in_offset,
size_t in_count,
float const in_radii[]);
23112 CylinderKey & EditRadiiByReplacement(
size_t in_offset, FloatArray
const & in_radii);
23121 size_t GetPointCount()
const;
23126 bool ShowPoints(PointArray & out_points)
const;
23133 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
23139 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
23146 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
23151 bool ShowRadii(FloatArray & out_radii)
const;
23217 CylinderKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
23243 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23257 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Cylinder::Component in_applied_to, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
23307 bool Empty()
const;
23312 bool Equals(
SphereKit const & in_kit)
const;
23317 bool operator==(
SphereKit const & in_kit)
const;
23322 bool operator!=(
SphereKit const & in_kit)
const;
23330 SphereKit & SetPriority(
int in_priority);
23339 bool ShowPriority(
int & out_priority)
const;
23349 SphereKit & SetRadius(
float in_radius);
23378 bool ShowCenter(
Point & out_center)
const;
23383 bool ShowRadius(
float & out_radius)
const;
23389 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
23396 SphereKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23402 SphereKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23408 SphereKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23413 SphereKit & UnsetUserData(intptr_t in_index);
23419 SphereKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23424 SphereKit & UnsetUserData(IntPtrTArray
const & in_indices);
23431 size_t ShowUserDataCount()
const;
23436 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23442 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23448 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23507 SphereKey & SetRadius(
float in_radius);
23519 bool ShowCenter(
Point & out_center)
const;
23524 bool ShowRadius(
float & out_radius)
const;
23530 bool ShowBasis(
Vector & out_vertical,
Vector & out_horizontal)
const;
23580 bool Empty()
const;
23585 bool Equals(
CircleKit const & in_kit)
const;
23590 bool operator==(
CircleKit const & in_kit)
const;
23595 bool operator!=(
CircleKit const & in_kit)
const;
23603 CircleKit & SetPriority(
int const in_priority);
23612 bool ShowPriority(
int & out_priority)
const;
23624 CircleKit & SetRadius(
float in_radius);
23652 bool ShowCenter(
Point & out_center)
const;
23657 bool ShowRadius(
float & out_radius)
const;
23662 bool ShowNormal(
Vector & out_normal)
const;
23669 CircleKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23675 CircleKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23681 CircleKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23686 CircleKit & UnsetUserData(intptr_t in_index);
23692 CircleKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23697 CircleKit & UnsetUserData(IntPtrTArray
const & in_indices);
23704 size_t ShowUserDataCount()
const;
23709 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23715 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23721 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
23783 CircleKey & SetRadius(
float in_radius);
23794 bool ShowCenter(
Point & out_center)
const;
23799 bool ShowRadius(
float & out_radius)
const;
23804 bool ShowNormal(
Vector & out_normal)
const;
23854 bool Empty()
const;
23886 bool ShowPriority(
int & out_priority)
const;
23925 bool ShowStart(
Point & out_start)
const;
23930 bool ShowMiddle(
Point & out_middle)
const;
23935 bool ShowEnd(
Point & out_end)
const;
23942 CircularArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
23948 CircularArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
23954 CircularArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
23965 CircularArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
23970 CircularArcKit & UnsetUserData(IntPtrTArray
const & in_indices);
23977 size_t ShowUserDataCount()
const;
23982 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
23988 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
23994 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24066 bool ShowStart(
Point & out_start)
const;
24071 bool ShowMiddle(
Point & out_middle)
const;
24076 bool ShowEnd(
Point & out_end)
const;
24104 HPS::Type
ObjectType()
const {
return HPS::Type::CircularWedgeKit; };
24125 bool Empty()
const;
24158 bool ShowPriority(
int & out_priority)
const;
24197 bool ShowStart(
Point & out_start)
const;
24202 bool ShowMiddle(
Point & out_middle)
const;
24207 bool ShowEnd(
Point & out_end)
const;
24214 CircularWedgeKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24220 CircularWedgeKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24226 CircularWedgeKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24237 CircularWedgeKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24249 size_t ShowUserDataCount()
const;
24254 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24260 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24266 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24305 HPS::Type
ObjectType()
const {
return HPS::Type::CircularWedgeKey; };
24340 bool ShowStart(
Point & out_start)
const;
24345 bool ShowMiddle(
Point & out_middle)
const;
24350 bool ShowEnd(
Point & out_end)
const;
24378 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionKit; };
24399 bool Empty()
const;
24431 bool ShowPriority(
int & out_priority)
const;
24473 size_t GetPlaneCount()
const;
24478 bool ShowPlanes(HPS::PlaneArray & out_planes)
const;
24501 CuttingSectionKit & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24517 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24526 CuttingSectionKit & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24533 CuttingSectionKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24545 CuttingSectionKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24556 CuttingSectionKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24568 size_t ShowUserDataCount()
const;
24573 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24579 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24585 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24622 HPS::Type
ObjectType()
const {
return HPS::Type::CuttingSectionKey; };
24664 size_t GetPlaneCount()
const;
24669 bool ShowPlanes(HPS::PlaneArray & out_planes)
const;
24692 CuttingSectionKey & EditPlanesByInsertion(
size_t in_offset, PlaneArray
const & in_planes);
24708 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset,
size_t in_count,
Plane const in_planes[]);
24717 CuttingSectionKey & EditPlanesByReplacement(
size_t in_offset, PlaneArray
const & in_planes);
24766 bool Empty()
const;
24798 bool ShowPriority(
int & out_priority)
const;
24837 bool ShowFirst(
Point & out_first)
const;
24842 bool ShowSecond(
Point & out_second)
const;
24854 InfiniteLineKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
24860 InfiniteLineKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
24866 InfiniteLineKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
24877 InfiniteLineKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
24889 size_t ShowUserDataCount()
const;
24894 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
24900 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
24906 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
24977 bool ShowFirst(
Point & out_first)
const;
24982 bool ShowSecond(
Point & out_second)
const;
25043 bool Empty()
const;
25112 SpotlightKit & SetConcentration(
float in_concentration);
25162 bool ShowPriority(
int & out_priority)
const;
25167 bool ShowPosition(
HPS::Point & out_position)
const;
25172 bool ShowTarget(
HPS::Point & out_target)
const;
25196 bool ShowConcentration(
float & out_concentration)
const;
25201 bool ShowCameraRelative(
bool & out_state)
const;
25208 SpotlightKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25214 SpotlightKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25220 SpotlightKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25231 SpotlightKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25236 SpotlightKit & UnsetUserData(IntPtrTArray
const & in_indices);
25243 size_t ShowUserDataCount()
const;
25248 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25254 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25260 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25355 SpotlightKey & SetConcentration(
float in_concentration);
25373 bool ShowPosition(
HPS::Point & out_position)
const;
25378 bool ShowTarget(
HPS::Point & out_target)
const;
25402 bool ShowConcentration(
float & out_concentration)
const;
25407 bool ShowCameraRelative(
bool & out_state)
const;
25456 bool Empty()
const;
25475 size_t GetPointCount()
const;
25492 bool ShowPriority(
int & out_priority)
const;
25519 NURBSCurveKit & SetWeights(
size_t in_count,
float const in_weights []);
25530 NURBSCurveKit & SetKnots(
size_t in_count,
float const in_knots []);
25536 NURBSCurveKit & SetParameters(
float in_start,
float in_end);
25567 bool ShowDegree(
size_t & out_degree)
const;
25572 bool ShowPoints(PointArray & out_points)
const;
25579 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
25585 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
25592 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
25597 bool ShowWeights(FloatArray & out_weights)
const;
25602 bool ShowKnots(FloatArray & out_knots)
const;
25608 bool ShowParameters(
float & out_start,
float & out_end)
const;
25617 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25624 NURBSCurveKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
25632 NURBSCurveKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
25640 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25648 NURBSCurveKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25658 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25666 NURBSCurveKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
25675 NURBSCurveKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
25683 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25691 NURBSCurveKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25699 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25705 NURBSCurveKit & EditKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
25712 NURBSCurveKit & EditKnotsByDeletion(
size_t in_offset,
size_t in_count);
25720 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25728 NURBSCurveKit & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25735 NURBSCurveKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
25741 NURBSCurveKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
25747 NURBSCurveKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
25758 NURBSCurveKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
25763 NURBSCurveKit & UnsetUserData(IntPtrTArray
const & in_indices);
25770 size_t ShowUserDataCount()
const;
25775 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
25781 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
25787 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
25840 size_t GetPointCount()
const;
25846 NURBSCurveKey & SetParameters(
float in_start,
float in_end);
25851 bool ShowDegree(
size_t & out_degree)
const;
25856 bool ShowPoints(PointArray & out_points)
const;
25863 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
25869 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
25876 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
25881 bool ShowWeights(FloatArray & out_weights)
const;
25886 bool ShowKnots(FloatArray & out_knots)
const;
25892 bool ShowParameters(
float & out_start,
float & out_end)
const;
25902 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
25910 NURBSCurveKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
25921 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
25930 NURBSCurveKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
25940 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
25948 NURBSCurveKey & EditKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
25997 bool Empty()
const;
26016 size_t GetPointCount()
const;
26033 bool ShowPriority(
int & out_priority)
const;
26077 NURBSSurfaceKit & SetWeights(
size_t in_count,
float const in_weights []);
26090 NURBSSurfaceKit & SetUKnots(
size_t in_count,
float const in_knots []);
26103 NURBSSurfaceKit & SetVKnots(
size_t in_count,
float const in_knots []);
26161 bool ShowUDegree(
size_t & out_degree)
const;
26166 bool ShowVDegree(
size_t & out_degree)
const;
26171 bool ShowUCount(
size_t & out_count)
const;
26176 bool ShowVCount(
size_t & out_count)
const;
26181 bool ShowPoints(PointArray & out_points)
const;
26188 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26194 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26201 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26206 bool ShowWeights(FloatArray & out_weights)
const;
26211 bool ShowUKnots(FloatArray & out_knots)
const;
26216 bool ShowVKnots(FloatArray & out_knots)
const;
26221 bool ShowTrims(TrimKitArray & out_trims)
const;
26230 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26237 NURBSSurfaceKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
26245 NURBSSurfaceKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
26253 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26261 NURBSSurfaceKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26271 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26279 NURBSSurfaceKit & EditWeightsByInsertion(
size_t in_offset, FloatArray
const & in_weights);
26288 NURBSSurfaceKit & EditWeightsByDeletion(
size_t in_offset,
size_t in_count);
26296 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26304 NURBSSurfaceKit & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26313 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26320 NURBSSurfaceKit & EditUKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26328 NURBSSurfaceKit & EditUKnotsByDeletion(
size_t in_offset,
size_t in_count);
26336 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26344 NURBSSurfaceKit & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26353 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26360 NURBSSurfaceKit & EditVKnotsByInsertion(
size_t in_offset, FloatArray
const & in_knots);
26368 NURBSSurfaceKit & EditVKnotsByDeletion(
size_t in_offset,
size_t in_count);
26376 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26384 NURBSSurfaceKit & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26391 NURBSSurfaceKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26397 NURBSSurfaceKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26403 NURBSSurfaceKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26414 NURBSSurfaceKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26426 size_t ShowUserDataCount()
const;
26431 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
26437 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
26443 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
26496 size_t GetPointCount()
const;
26518 bool ShowUDegree(
size_t & out_degree)
const;
26523 bool ShowVDegree(
size_t & out_degree)
const;
26528 bool ShowUCount(
size_t & out_count)
const;
26533 bool ShowVCount(
size_t & out_count)
const;
26538 bool ShowPoints(PointArray & out_points)
const;
26545 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
26551 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
26558 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
26563 bool ShowWeights(FloatArray & out_weights)
const;
26568 bool ShowUKnots(FloatArray & out_knots)
const;
26573 bool ShowVKnots(FloatArray & out_knots)
const;
26578 bool ShowTrims(TrimKitArray & out_trims)
const;
26588 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
26596 NURBSSurfaceKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
26607 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset,
size_t in_count,
float const in_weights[]);
26616 NURBSSurfaceKey & EditWeightsByReplacement(
size_t in_offset, FloatArray
const & in_weights);
26626 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26634 NURBSSurfaceKey & EditUKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26644 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset,
size_t in_count,
float const in_knots[]);
26652 NURBSSurfaceKey & EditVKnotsByReplacement(
size_t in_offset, FloatArray
const & in_knots);
26709 bool operator==(
TrimElement const & in_that)
const;
26714 bool operator!=(
TrimElement const & in_that)
const;
26720 void SetCurve(
LineKit const & in_line);
26764 void Set(
TrimKit const & in_kit);
26768 void Show(
TrimKit & out_kit)
const;
26777 bool Empty()
const;
26782 bool Equals(
TrimKit const & in_kit)
const;
26787 bool operator==(
TrimKit const & in_kit)
const;
26792 bool operator!=(
TrimKit const & in_kit)
const;
26804 TrimKit & SetShape(TrimElementArray
const & in_shape);
26828 bool ShowShape(TrimElementArray & out_shape)
const;
26882 bool Empty()
const;
26887 bool Equals(
EllipseKit const & in_kit)
const;
26892 bool operator==(
EllipseKit const & in_kit)
const;
26897 bool operator!=(
EllipseKit const & in_kit)
const;
26914 bool ShowPriority(
int & out_priority)
const;
26953 bool ShowCenter(
Point & out_center)
const;
26958 bool ShowMajor(
Point & out_major)
const;
26963 bool ShowMinor(
Point & out_minor)
const;
26970 EllipseKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
26976 EllipseKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
26982 EllipseKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
26987 EllipseKit & UnsetUserData(intptr_t in_index);
26993 EllipseKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
26998 EllipseKit & UnsetUserData(IntPtrTArray
const & in_indices);
27005 size_t ShowUserDataCount()
const;
27010 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27016 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27022 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27094 bool ShowCenter(
Point & out_center)
const;
27099 bool ShowMajor(
Point & out_major)
const;
27104 bool ShowMinor(
Point & out_minor)
const;
27132 HPS::Type
ObjectType()
const {
return HPS::Type::EllipticalArcKit; };
27153 bool Empty()
const;
27185 bool ShowPriority(
int & out_priority)
const;
27250 bool ShowCenter(
Point & out_center)
const;
27255 bool ShowMajor(
Point & out_major)
const;
27260 bool ShowMinor(
Point & out_minor)
const;
27265 bool ShowStart(
float & out_start)
const;
27270 bool ShowEnd(
float & out_end)
const;
27277 EllipticalArcKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
27283 EllipticalArcKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
27289 EllipticalArcKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
27300 EllipticalArcKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
27312 size_t ShowUserDataCount()
const;
27317 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
27323 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
27329 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
27366 HPS::Type
ObjectType()
const {
return HPS::Type::EllipticalArcKey; };
27419 bool ShowCenter(
Point & out_center)
const;
27424 bool ShowMajor(
Point & out_major)
const;
27429 bool ShowMinor(
Point & out_minor)
const;
27434 bool ShowStart(
float & out_start)
const;
27439 bool ShowEnd(
float & out_end)
const;
27471 void Consume(
TextKit & in_kit);
27475 void Set(
TextKit const & in_kit);
27479 void Show(
TextKit & out_kit)
const;
27488 bool Empty()
const;
27493 bool Equals(
TextKit const & in_kit)
const;
27498 bool operator==(
TextKit const & in_kit)
const;
27503 bool operator!=(
TextKit const & in_kit)
const;
27511 TextKit & SetPriority(
int in_priority);
27520 bool ShowPriority(
int & out_priority)
const;
27530 TextKit & SetText(
char const * in_string);
27540 TextKit & SetColorByIndex(
float in_index);
27557 TextKit & SetBold(
bool in_state);
27562 TextKit & SetItalic(
bool in_state);
27567 TextKit & SetOverline(
bool in_state);
27572 TextKit & SetStrikethrough(
bool in_state);
27577 TextKit & SetUnderline(
bool in_state);
27583 TextKit & SetSlant(
float in_angle);
27588 TextKit & SetLineSpacing(
float in_multiplier);
27600 TextKit & SetRotation(
float in_angle);
27660 TextKit & SetFont(
char const * in_name);
27695 TextKit & SetSpacing(
float in_multiplier);
27712 TextKit & UnsetModellingMatrix();
27732 TextKit & UnsetStrikethrough();
27744 TextKit & UnsetLineSpacing();
27760 TextKit & UnsetSizeTolerance();
27798 bool ShowPosition(
Point & out_position)
const;
27803 bool ShowText(
UTF8 & out_string)
const;
27815 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
27827 bool ShowBold(
bool & out_state)
const;
27832 bool ShowItalic(
bool & out_state)
const;
27837 bool ShowOverline(
bool & out_state)
const;
27842 bool ShowStrikethrough(
bool & out_state)
const;
27847 bool ShowUnderline(
bool & out_state)
const;
27852 bool ShowSlant(
float & out_angle)
const;
27857 bool ShowLineSpacing(
float & out_multiplier)
const;
27863 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
27870 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
27896 bool ShowFont(
UTF8 & out_name)
const;
27919 bool ShowPath(
Vector & out_path)
const;
27924 bool ShowSpacing(
float & out_multiplier)
const;
27934 TextKit & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
27942 TextKit & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
27950 TextKit & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
27960 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;
27974 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);
27989 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);
27996 TextKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
28006 TextKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
28012 TextKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
28017 TextKit & UnsetUserData(intptr_t in_index);
28023 TextKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
28028 TextKit & UnsetUserData(IntPtrTArray
const & in_indices);
28032 TextKit & UnsetAllUserData();
28035 size_t ShowUserDataCount()
const;
28040 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
28046 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
28052 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
28093 void Consume(
TextKit & in_kit);
28097 void Set(
TextKit const & in_kit);
28101 void Show(
TextKit & out_kit)
const;
28120 TextKey & SetText(
char const * in_string);
28130 TextKey & SetColorByIndex(
float in_index);
28147 TextKey & SetBold(
bool in_state);
28152 TextKey & SetItalic(
bool in_state);
28157 TextKey & SetOverline(
bool in_state);
28162 TextKey & SetStrikethrough(
bool in_state);
28167 TextKey & SetUnderline(
bool in_state);
28173 TextKey & SetSlant(
float in_angle);
28179 TextKey & SetLineSpacing(
float in_multiplier);
28191 TextKey & SetRotation(
float in_angle);
28251 TextKey & SetFont(
char const * in_name);
28288 TextKey & SetSpacing(
float in_multiplier);
28302 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);
28317 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);
28326 TextKey & UnsetModellingMatrix();
28346 TextKey & UnsetStrikethrough();
28358 TextKey & UnsetLineSpacing();
28374 TextKey & UnsetSizeTolerance();
28416 bool ShowPosition(
Point & out_position)
const;
28421 bool ShowText(
UTF8 & out_string)
const;
28433 bool ShowModellingMatrix(
MatrixKit & out_matrix)
const;
28445 bool ShowBold(
bool & out_state)
const;
28450 bool ShowItalic(
bool & out_state)
const;
28455 bool ShowOverline(
bool & out_state)
const;
28460 bool ShowStrikethrough(
bool & out_state)
const;
28465 bool ShowUnderline(
bool & out_state)
const;
28470 bool ShowSlant(
float & out_angle)
const;
28475 bool ShowLineSpacing(
float & out_multiplier)
const;
28481 bool ShowRotation(
Text::Rotation & out_rot,
float & out_angle)
const;
28488 bool ShowExtraSpace(
bool & out_state,
float & out_size,
Text::SizeUnits & out_units)
const;
28514 bool ShowFont(
UTF8 & out_name)
const;
28537 bool ShowPath(
Vector & out_path)
const;
28542 bool ShowSpacing(
float & out_multiplier)
const;
28552 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;
28562 TextKey & EditTextByInsertion(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28570 TextKey & EditTextByDeletion(
size_t in_row,
size_t in_column,
size_t in_count);
28578 TextKey & EditTextByReplacement(
size_t in_row,
size_t in_column,
size_t in_count,
char const * in_text);
28600 HPS::Type
ObjectType()
const {
return HPS::Type::ShellOptimizationOptionsKit; };
28626 bool Empty()
const;
28697 bool ShowNormalTolerance(
float & out_normal_tolerance)
const;
28708 bool ShowOrphanElimination(
bool & out_orphan_elimination)
const;
28743 HPS::Type
ObjectType()
const {
return HPS::Type::ShellRelationOptionsKit; };
28769 bool Empty()
const;
28833 bool ShowTolerance(
float & out_tolerance)
const;
28843 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
28848 bool ShowNearestFaceCalculation(
bool & out_state)
const;
28874 HPS::Type
ObjectType()
const {
return HPS::Type::ShellRelationResultsKit; };
28895 bool Empty()
const;
28916 bool ShowRelations(ShellRelationArray & out_results)
const;
28921 bool ShowNearestFaces(SizeTArray & out_faces)
const;
28926 bool ShowDistances(FloatArray & out_distances)
const;
28961 void Set(
ShellKit const & in_kit);
28965 void Show(
ShellKit & out_kit)
const;
28969 size_t GetPointCount()
const;
28973 size_t GetFaceCount()
const;
28982 bool Empty()
const;
28987 bool Equals(
ShellKit const & in_kit)
const;
28992 bool operator==(
ShellKit const & in_kit)
const;
28997 bool operator!=(
ShellKit const & in_kit)
const;
29005 ShellKit & SetPriority(
int in_priority);
29014 bool ShowPriority(
int & out_priority)
const;
29021 ShellKit & SetPoints(PointArray
const & in_points);
29027 ShellKit & SetPoints(
size_t in_count,
Point const in_points []);
29032 ShellKit & SetFacelist(IntArray
const & in_facelist);
29038 ShellKit & SetFacelist(
size_t in_count,
int const in_facelist []);
29043 ShellKit & SetTristrips(IntArray
const & in_tristrips);
29049 ShellKit & SetTristrips(
size_t in_count,
int const in_tristrips []);
29070 bool ShowPoints(PointArray & out_points)
const;
29077 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
29083 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
29090 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
29095 bool ShowFacelist(IntArray & out_facelist)
const;
29100 bool ShowTristrips(IntArray & out_tristrips)
const;
29280 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29286 ShellKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29293 ShellKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29300 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
29306 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
29313 ShellKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
29319 ShellKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
29328 ShellKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
29336 ShellKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
29346 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);
29355 ShellKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
29363 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29369 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29376 ShellKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29383 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
29389 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
29396 ShellKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
29402 ShellKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
29407 ShellKit & UnsetMaterialMapping();
29418 ShellKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
29423 ShellKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
29453 ShellKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
29458 ShellKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
29463 ShellKit & UnsetVertexParameters();
29469 ShellKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
29474 ShellKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
29479 ShellKit & UnsetVertexVisibilities();
29485 ShellKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
29490 ShellKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
29495 ShellKit & UnsetVertexEverything();
29517 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
29518 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29534 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
29535 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
29546 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29556 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
29568 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
29579 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29590 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
29601 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
29612 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29622 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29631 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
29637 ShellKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
29644 ShellKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
29651 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
29657 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
29664 ShellKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
29670 ShellKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
29678 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
29684 ShellKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
29691 ShellKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
29698 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
29704 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
29711 ShellKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
29717 ShellKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
29725 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
29731 ShellKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
29738 ShellKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
29745 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
29751 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
29758 ShellKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
29764 ShellKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
29772 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
29778 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
29785 ShellKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
29792 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
29798 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
29805 ShellKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
29811 ShellKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
29822 ShellKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
29827 ShellKit & UnsetFaceColorsByList(SizeTArray
const & in_faces);
29838 ShellKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
29843 ShellKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
29848 ShellKit & UnsetFaceVisibilities();
29854 ShellKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
29859 ShellKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
29876 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
29888 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
29899 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
29909 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
29920 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29930 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
29939 ShellKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
29946 ShellKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
29953 ShellKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
29960 ShellKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
29967 ShellKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
29976 ShellKit & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
29983 ShellKit & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
29990 ShellKit & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
30000 ShellKit & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
30009 ShellKit & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
30038 ShellKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
30044 ShellKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
30050 ShellKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
30055 ShellKit & UnsetUserData(intptr_t in_index);
30061 ShellKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
30066 ShellKit & UnsetUserData(IntPtrTArray
const & in_indices);
30073 size_t ShowUserDataCount()
const;
30078 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
30084 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
30090 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
30137 void Set(
ShellKit const & in_kit);
30141 void Show(
ShellKit & out_kit)
const;
30145 size_t GetPointCount()
const;
30149 size_t GetFaceCount()
const;
30155 ShellKey & SetPoints(PointArray
const & in_points);
30161 ShellKey & SetPoints(
size_t in_count,
Point const in_points []);
30166 ShellKey & SetFacelist(IntArray
const & in_facelist);
30172 ShellKey & SetFacelist(
size_t in_count,
int const in_facelist []);
30177 ShellKey & SetTristrips(IntArray
const & in_tristrips);
30183 ShellKey & SetTristrips(
size_t in_count,
int const in_tristrips []);
30205 ShellKey & UnsetMaterialMapping();
30214 bool ShowPoints(PointArray & out_points)
const;
30221 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
30227 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
30234 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
30239 bool ShowFacelist(IntArray & out_facelist)
const;
30244 bool ShowTristrips(IntArray & out_tristrips)
const;
30425 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30432 ShellKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30439 ShellKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30446 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
30452 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
30459 ShellKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
30465 ShellKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
30475 ShellKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
30483 ShellKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
30493 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);
30502 ShellKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
30510 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30517 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30524 ShellKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30531 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
30537 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
30544 ShellKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
30550 ShellKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
30561 ShellKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
30566 ShellKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
30596 ShellKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
30601 ShellKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
30606 ShellKey & UnsetVertexParameters();
30612 ShellKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
30617 ShellKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
30622 ShellKey & UnsetVertexVisibilities();
30628 ShellKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
30633 ShellKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
30638 ShellKey & UnsetVertexEverything();
30654 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
30655 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
30671 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Shell::Component in_applied_to, MaterialTypeArray & out_types,
30672 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
30683 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
30693 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
30705 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
30716 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30727 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
30738 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
30749 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30759 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
30767 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
30774 ShellKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
30781 ShellKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
30788 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
30794 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
30801 ShellKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
30807 ShellKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
30815 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
30822 ShellKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
30829 ShellKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
30836 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
30842 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
30849 ShellKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
30855 ShellKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
30863 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
30870 ShellKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
30877 ShellKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
30884 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
30890 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
30897 ShellKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
30903 ShellKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
30911 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
30918 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
30925 ShellKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
30932 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
30938 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
30945 ShellKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
30951 ShellKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
30962 ShellKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
30967 ShellKey & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
30978 ShellKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
30983 ShellKey & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
30988 ShellKey & UnsetFaceVisibilities();
30994 ShellKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
30999 ShellKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
31016 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31028 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
31039 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31049 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
31057 bool ShowNetFaceNormalsByRange(
size_t in_start,
size_t in_count, VectorArray & out_normals)
const;
31065 bool ShowNetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray & out_normals)
const;
31076 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31086 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31095 ShellKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
31102 ShellKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
31109 ShellKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
31116 ShellKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
31123 ShellKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
31132 ShellKey & EditFacelistByInsertion(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
31139 ShellKey & EditFacelistByInsertion(
size_t in_offset, IntArray
const & in_facelist);
31146 ShellKey & EditFacelistByDeletion(
size_t in_offset,
size_t in_count);
31156 ShellKey & EditFacelistByReplacement(
size_t in_offset,
size_t in_count,
int const in_facelist[]);
31165 ShellKey & EditFacelistByReplacement(
size_t in_offset, IntArray
const & in_facelist);
31219 void Consume(
MeshKit & in_kit);
31223 void Set(
MeshKit const & in_kit);
31227 void Show(
MeshKit & out_kit)
const;
31236 bool Empty()
const;
31241 bool Equals(
MeshKit const & in_kit)
const;
31246 bool operator==(
MeshKit const & in_kit)
const;
31251 bool operator!=(
MeshKit const & in_kit)
const;
31255 size_t GetPointCount()
const;
31263 MeshKit & SetPriority(
int in_priority);
31272 bool ShowPriority(
int & out_priority)
const;
31277 MeshKit & SetPoints(PointArray
const & in_points);
31283 MeshKit & SetPoints(
size_t in_count,
Point const in_points []);
31290 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns, HPS::PointArray
const & in_points);
31298 MeshKit & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
31303 MeshKit & SetRows(
size_t in_rows);
31308 MeshKit & SetColumns(
size_t in_columns);
31329 bool ShowPoints(PointArray & out_points)
const;
31336 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
31342 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
31349 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
31356 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
31361 bool ShowRows(
size_t & out_rows)
const;
31366 bool ShowColumns(
size_t & out_columns)
const;
31546 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31552 MeshKit & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
31559 MeshKit & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
31566 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
31572 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
31579 MeshKit & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
31585 MeshKit & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
31594 MeshKit & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
31602 MeshKit & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
31612 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);
31621 MeshKit & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
31629 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
31635 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
31642 MeshKit & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
31649 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
31655 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
31662 MeshKit & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
31668 MeshKit & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
31673 MeshKit & UnsetMaterialMapping();
31677 MeshKit & UnsetVertexColors();
31683 MeshKit & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
31688 MeshKit & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
31712 MeshKit & UnsetVertexNormals();
31718 MeshKit & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
31723 MeshKit & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
31728 MeshKit & UnsetVertexParameters();
31734 MeshKit & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
31739 MeshKit & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
31744 MeshKit & UnsetVertexVisibilities();
31750 MeshKit & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
31755 MeshKit & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
31760 MeshKit & UnsetVertexEverything();
31781 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31782 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31798 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
31799 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
31810 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
31820 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
31832 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
31843 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31854 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
31865 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
31876 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31886 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
31894 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
31900 MeshKit & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
31907 MeshKit & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
31914 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
31920 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
31927 MeshKit & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
31933 MeshKit & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
31941 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
31947 MeshKit & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
31954 MeshKit & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
31961 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
31967 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
31974 MeshKit & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
31980 MeshKit & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
31988 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
31994 MeshKit & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32001 MeshKit & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32008 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
32014 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
32021 MeshKit & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
32027 MeshKit & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
32035 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32041 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32048 MeshKit & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32055 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
32061 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
32068 MeshKit & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
32074 MeshKit & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
32085 MeshKit & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
32090 MeshKit & UnsetFaceColorsByList(SizeTArray
const & in_vertices);
32095 MeshKit & UnsetFaceNormals();
32101 MeshKit & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
32106 MeshKit & UnsetFaceNormalsByList(SizeTArray
const & in_vertices);
32111 MeshKit & UnsetFaceVisibilities();
32117 MeshKit & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
32122 MeshKit & UnsetFaceVisibilitiesByList(SizeTArray
const & in_vertices);
32127 MeshKit & UnsetFaceEverything();
32139 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32151 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
32162 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32172 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
32183 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32193 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32200 MeshKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
32206 MeshKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
32212 MeshKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
32217 MeshKit & UnsetUserData(intptr_t in_index);
32223 MeshKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
32228 MeshKit & UnsetUserData(IntPtrTArray
const & in_indices);
32232 MeshKit & UnsetAllUserData();
32235 size_t ShowUserDataCount()
const;
32240 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
32246 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
32252 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
32296 void Consume(
MeshKit & in_kit);
32300 void Set(
MeshKit const & in_kit);
32304 void Show(
MeshKit & out_kit)
const;
32308 size_t GetPointCount()
const;
32315 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns, PointArray
const & in_points);
32323 MeshKey & SetPoints(
size_t in_rows,
size_t in_columns,
size_t in_count,
Point const in_points []);
32328 bool ShowPoints(PointArray & out_points)
const;
32335 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
32341 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
32348 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
32355 bool ShowPoints(
size_t & out_rows,
size_t & out_columns, PointArray & out_points)
const;
32360 bool ShowRows(
size_t & out_rows)
const;
32365 bool ShowColumns(
size_t & out_columns)
const;
32376 MeshKey & UnsetMaterialMapping();
32557 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
32564 MeshKey & SetVertexNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
32571 MeshKey & SetVertexNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
32578 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const in_normals[]);
32584 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices, VectorArray
const & in_normals);
32591 MeshKey & SetVertexNormalsByList(
size_t in_count,
size_t const in_vertices[],
Vector const & in_normal);
32597 MeshKey & SetVertexNormalsByList(SizeTArray
const & in_vertices,
Vector const & in_normal);
32607 MeshKey & SetVertexParametersByRange(
size_t in_start,
size_t in_param_count,
float const in_params[],
size_t in_param_width=2);
32615 MeshKey & SetVertexParametersByRange(
size_t in_start, FloatArray
const & in_params,
size_t in_param_width=2);
32625 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);
32634 MeshKey & SetVertexParametersByList(SizeTArray
const & in_vertices, FloatArray
const & in_params,
size_t in_param_width=2);
32642 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
32649 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
32656 MeshKey & SetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
32663 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool const in_visibilities[]);
32669 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray
const & in_visibilities);
32676 MeshKey & SetVertexVisibilitiesByList(
size_t in_count,
size_t const in_vertices[],
bool in_visibility);
32682 MeshKey & SetVertexVisibilitiesByList(SizeTArray
const & in_vertices,
bool in_visibility);
32687 MeshKey & UnsetVertexColors();
32693 MeshKey & UnsetVertexColorsByRange(
size_t in_start,
size_t in_count);
32698 MeshKey & UnsetVertexColorsByList(SizeTArray
const & in_vertices);
32722 MeshKey & UnsetVertexNormals();
32728 MeshKey & UnsetVertexNormalsByRange(
size_t in_start,
size_t in_count);
32733 MeshKey & UnsetVertexNormalsByList(SizeTArray
const & in_vertices);
32738 MeshKey & UnsetVertexParameters();
32744 MeshKey & UnsetVertexParametersByRange(
size_t in_start,
size_t in_count);
32749 MeshKey & UnsetVertexParametersByList(SizeTArray
const & in_vertices);
32754 MeshKey & UnsetVertexVisibilities();
32760 MeshKey & UnsetVertexVisibilitiesByRange(
size_t in_start,
size_t in_count);
32765 MeshKey & UnsetVertexVisibilitiesByList(SizeTArray
const & in_vertices);
32770 MeshKey & UnsetVertexEverything();
32790 bool ShowVertexColorsByRange(
size_t in_start,
size_t in_count,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32791 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32807 bool ShowVertexColorsByList(SizeTArray
const & in_vertices,
Mesh::Component in_applied_to, MaterialTypeArray & out_types,
32808 RGBColorArray & out_rgb_colors, RGBAColorArray & out_rgba_colors, FloatArray & out_indices)
const;
32819 bool ShowVertexNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
32829 bool ShowVertexNormalsByList(SizeTArray
const & in_vertices, BoolArray & out_validities, VectorArray & out_normals)
const;
32841 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params)
const;
32852 bool ShowVertexParametersByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32863 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params)
const;
32874 bool ShowVertexParametersByList(SizeTArray
const & in_vertices, BoolArray & out_validities, FloatArray & out_params,
size_t & out_param_width)
const;
32885 bool ShowVertexVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32895 bool ShowVertexVisibilitiesByList(SizeTArray
const & in_vertices, BoolArray & out_validities, BoolArray & out_visibilities)
const;
32903 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const in_rgb_colors[]);
32910 MeshKey & SetFaceRGBColorsByRange(
size_t in_start, RGBColorArray
const & in_rgb_colors);
32917 MeshKey & SetFaceRGBColorsByRange(
size_t in_start,
size_t in_count,
RGBColor const & in_rgb_color);
32924 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const in_rgb_colors[]);
32930 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces, RGBColorArray
const & in_rgb_colors);
32937 MeshKey & SetFaceRGBColorsByList(
size_t in_count,
size_t const in_faces[],
RGBColor const & in_rgb_color);
32943 MeshKey & SetFaceRGBColorsByList(SizeTArray
const & in_faces,
RGBColor const & in_rgb_color);
32951 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float const in_indices[]);
32958 MeshKey & SetFaceIndexColorsByRange(
size_t in_start, FloatArray
const & in_indices);
32965 MeshKey & SetFaceIndexColorsByRange(
size_t in_start,
size_t in_count,
float in_index);
32972 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float const in_indices[]);
32978 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces, FloatArray
const & in_indices);
32985 MeshKey & SetFaceIndexColorsByList(
size_t in_count,
size_t const in_faces[],
float in_index);
32991 MeshKey & SetFaceIndexColorsByList(SizeTArray
const & in_faces,
float in_index);
32999 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const in_normals[]);
33006 MeshKey & SetFaceNormalsByRange(
size_t in_start, VectorArray
const & in_normals);
33013 MeshKey & SetFaceNormalsByRange(
size_t in_start,
size_t in_count,
Vector const & in_normal);
33020 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const in_normals[]);
33026 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces, VectorArray
const & in_normals);
33033 MeshKey & SetFaceNormalsByList(
size_t in_count,
size_t const in_faces[],
Vector const & in_normal);
33039 MeshKey & SetFaceNormalsByList(SizeTArray
const & in_faces,
Vector const & in_normal);
33047 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool const in_visibilities[]);
33054 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start, BoolArray
const & in_visibilities);
33061 MeshKey & SetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count,
bool in_visibility);
33068 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool const in_visibilities[]);
33074 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray
const & in_visibilities);
33081 MeshKey & SetFaceVisibilitiesByList(
size_t in_count,
size_t const in_faces[],
bool in_visibility);
33087 MeshKey & SetFaceVisibilitiesByList(SizeTArray
const & in_faces,
bool in_visibility);
33098 MeshKey & UnsetFaceColorsByRange(
size_t in_start,
size_t in_count);
33103 MeshKey & UnsetFaceColorsByList(SizeTArray
const & in_faces);
33108 MeshKey & UnsetFaceNormals();
33114 MeshKey & UnsetFaceNormalsByRange(
size_t in_start,
size_t in_count);
33119 MeshKey & UnsetFaceNormalsByList(SizeTArray
const & in_faces);
33124 MeshKey & UnsetFaceVisibilities();
33130 MeshKey & UnsetFaceVisibilitiesByRange(
size_t in_start,
size_t in_count);
33135 MeshKey & UnsetFaceVisibilitiesByList(SizeTArray
const & in_faces);
33140 MeshKey & UnsetFaceEverything();
33152 bool ShowFaceColorsByRange(
size_t in_start,
size_t in_count, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33164 bool ShowFaceColorsByList(SizeTArray
const & in_faces, MaterialTypeArray & out_types, RGBColorArray & out_rgb_colors, FloatArray & out_indices)
const;
33175 bool ShowFaceNormalsByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, VectorArray & out_normals)
const;
33185 bool ShowFaceNormalsByList(SizeTArray
const & in_faces, BoolArray & out_validities, VectorArray & out_normals)
const;
33196 bool ShowFaceVisibilitiesByRange(
size_t in_start,
size_t in_count, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33206 bool ShowFaceVisibilitiesByList(SizeTArray
const & in_faces, BoolArray & out_validities, BoolArray & out_visibilities)
const;
33216 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[]);
33225 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);
33275 bool Empty()
const;
33280 bool Equals(
PolygonKit const & in_kit)
const;
33285 bool operator==(
PolygonKit const & in_kit)
const;
33290 bool operator!=(
PolygonKit const & in_kit)
const;
33294 size_t GetPointCount()
const;
33311 bool ShowPriority(
int & out_priority)
const;
33317 PolygonKit & SetPoints(PointArray
const & in_points);
33336 bool ShowPoints(PointArray & out_points)
const;
33343 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
33349 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
33356 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
33363 PolygonKit & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33369 PolygonKit & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
33375 PolygonKit & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
33382 PolygonKit & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33388 PolygonKit & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
33395 PolygonKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
33401 PolygonKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
33407 PolygonKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
33412 PolygonKit & UnsetUserData(intptr_t in_index);
33418 PolygonKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
33423 PolygonKit & UnsetUserData(IntPtrTArray
const & in_indices);
33430 size_t ShowUserDataCount()
const;
33435 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
33441 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
33447 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
33502 size_t GetPointCount()
const;
33507 PolygonKey & SetPoints(PointArray
const & in_points);
33518 bool ShowPoints(PointArray & out_points)
const;
33525 bool ShowPointsByRange(
size_t in_start_index,
size_t in_count, PointArray & out_points)
const;
33531 bool ShowPointsByList(SizeTArray
const & in_indices, PointArray & out_points)
const;
33538 bool ShowPointsByList(
size_t in_count,
size_t const in_indices[], PointArray & out_points)
const;
33545 PolygonKey & EditPointsByInsertion(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33551 PolygonKey & EditPointsByInsertion(
size_t in_offset, PointArray
const & in_points);
33557 PolygonKey & EditPointsByDeletion(
size_t in_offset,
size_t in_count);
33564 PolygonKey & EditPointsByReplacement(
size_t in_offset,
size_t in_count,
Point const in_points[]);
33570 PolygonKey & EditPointsByReplacement(
size_t in_offset, PointArray
const & in_points);
33597 void Consume(
GridKit & in_kit);
33601 void Set(
GridKit const & in_kit);
33605 void Show(
GridKit & out_kit)
const;
33619 bool Empty()
const;
33624 bool Equals(
GridKit const & in_kit)
const;
33629 bool operator==(
GridKit const & in_kit)
const;
33634 bool operator!=(
GridKit const & in_kit)
const;
33643 GridKit & SetPriority(
int in_priority);
33661 GridKit & SetFirstPoint(
Point const & in_first_point);
33670 GridKit & SetSecondPoint(
Point const & in_second_point);
33685 GridKit & SetFirstCount(
int in_first_count);
33697 GridKit & SetSecondCount(
int in_second_count);
33718 GridKit & UnsetSecondPoint();
33726 GridKit & UnsetSecondCount();
33736 bool ShowPriority(
int & out_priority)
const;
33746 bool ShowOrigin(
Point & out_origin)
const;
33751 bool ShowFirstPoint(
Point & out_first_point)
const;
33756 bool ShowSecondPoint(
Point & out_second_point)
const;
33761 bool ShowFirstCount(
int & out_first_count)
const;
33766 bool ShowSecondCount(
int & out_second_count)
const;
33773 GridKit & SetUserData(intptr_t in_index,
size_t in_bytes, byte
const in_data[]);
33779 GridKit & SetUserData(intptr_t in_index, ByteArray
const & in_data);
33785 GridKit & SetUserData(IntPtrTArray
const & in_indices, ByteArrayArray
const & in_data);
33790 GridKit & UnsetUserData(intptr_t in_index);
33796 GridKit & UnsetUserData(
size_t in_count, intptr_t
const in_indices[]);
33801 GridKit & UnsetUserData(IntPtrTArray
const & in_indices);
33805 GridKit & UnsetAllUserData();
33808 size_t ShowUserDataCount()
const;
33813 bool ShowUserDataIndices(IntPtrTArray & out_indices)
const;
33819 bool ShowUserData(intptr_t in_index, ByteArray & out_data)
const;
33825 bool ShowUserData(IntPtrTArray & out_indices, ByteArrayArray & out_data)
const;
33866 void Consume(
GridKit & in_kit);
33870 void Set(
GridKit const & in_kit);
33874 void Show(
GridKit & out_kit)
const;
33893 GridKey & SetFirstPoint(
Point const & in_first_point);
33902 GridKey & SetSecondPoint(
Point const & in_second_point);
33917 GridKey & SetFirstCount(
int in_first_count);
33929 GridKey & SetSecondCount(
int in_second_count);
33941 bool ShowOrigin(
Point & out_origin)
const;
33946 bool ShowFirstPoint(
Point & out_first_point)
const;
33951 bool ShowSecondPoint(
Point & out_second_point)
const;
33956 bool ShowFirstCount(
int & out_first_count)
const;
33961 bool ShowSecondCount(
int & out_second_count)
const;
34037 bool ShowPriority(
int & out_priority)
const;
34042 bool ShowCondition(
Condition & out_condition)
const;
34064 IncludeKey & SetFilter(AttributeLockTypeArray
const & in_types);
34086 IncludeKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
34093 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
34168 bool ShowCondition(
Condition & out_condition)
const;
34191 StyleKey & SetFilter(AttributeLockTypeArray
const & in_types);
34213 StyleKey & UnsetFilter(AttributeLockTypeArray
const & in_types);
34220 bool ShowFilter(AttributeLockTypeArray & out_types)
const;
34271 Key GetTarget()
const;
34276 size_t ShowTargets(
bool masked=
true)
const;
34282 size_t ShowTargets(KeyArray & out_keys,
bool masked=
true)
const;
34287 size_t ShowGeometryMask()
const;
34293 size_t ShowGeometryMask(SearchTypeArray & out_geometry_types)
const;
34298 ReferenceKey & SetGeometryMask(SearchTypeArray
const & in_geometry_types);
34306 void SetModellingMatrix(
MatrixKit const & in_kit);
34320 void UnsetModellingMatrix();
34330 bool ShowModellingMatrix(
MatrixKit & out_kit)
const;
34335 bool ShowCondition(
Condition & out_condition)
const;
34374 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowOptionsKit; };
34396 bool Empty()
const;
34482 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34487 bool ShowTitle(
UTF8 & out_window_name)
const;
34492 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
34502 bool ShowFullScreen(
bool & out_state)
const;
34536 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowOptionsControl; };
34568 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34573 bool ShowTitle(
UTF8 & out_window_name)
const;
34578 bool ShowSubscreen(
Rectangle & out_subscreen)
const;
34588 bool ShowFullScreen(
bool & out_state)
const;
34622 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowOptionsKit; };
34644 bool Empty()
const;
34728 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34733 bool ShowHardwareResident(
bool & out_state)
const;
34745 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
34773 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowOptionsKit; };
34795 bool Empty()
const;
34862 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34867 bool ShowPlatformData(PlatformData & out_platform_data)
const;
34872 bool ShowFramebufferRetention(
bool & out_retain)
const;
34903 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowOptionsControl; };
34914 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
34924 bool ShowWindowHandle(WindowHandle & out_window_handle)
const;
34929 bool ShowPlatformData(PlatformData & out_platform_data)
const;
34934 bool ShowFramebufferRetention(
bool & out_retain)
const;
34985 HPS::Type
ObjectType()
const {
return HPS::Type::StandAloneWindowKey; };
35036 HPS::Type
ObjectType()
const {
return HPS::Type::ApplicationWindowKey; };
35113 void SetIndexedColor(byte in_index);
35116 void SetNormalColor();
35120 void SetExplicitColor(
RGBAColor const & in_color);
35174 HPS::Type
ObjectType()
const {
return HPS::Type::LineGlyphElement; };
35178 void SetPoints(GlyphPointArray
const & in_points);
35183 void SetPoints(
size_t in_count,
GlyphPoint const in_points[]);
35188 bool ShowPoints(GlyphPointArray & out_points)
const;
35233 bool ShowPoint(
GlyphPoint & out_point)
const;
35271 HPS::Type
ObjectType()
const {
return HPS::Type::EllipseGlyphElement; };
35275 void SetLowerLeft(
GlyphPoint const & in_point);
35279 void SetUpperRight(
GlyphPoint const & in_point);
35289 bool ShowLowerLeft(
GlyphPoint & out_point)
const;
35294 bool ShowUpperRight(
GlyphPoint & out_point)
const;
35333 HPS::Type
ObjectType()
const {
return HPS::Type::CircularArcGlyphElement; };
35337 void SetStartPoint(
GlyphPoint const & in_point);
35341 void SetIntermediatePoint(
GlyphPoint const & in_point);
35345 void SetEndPoint(
GlyphPoint const & in_point);
35356 bool ShowStartPoint(
GlyphPoint & out_point)
const;
35361 bool ShowIntermediatePoint(
GlyphPoint & out_point)
const;
35366 bool ShowEndPoint(
GlyphPoint & out_point)
const;
35405 HPS::Type
ObjectType()
const {
return HPS::Type::InfiniteLineGlyphElement; };
35409 void SetFirstPoint(
GlyphPoint const & in_point);
35413 void SetSecondPoint(
GlyphPoint const & in_point);
35427 bool ShowFirstPoint(
GlyphPoint & out_point)
const;
35432 bool ShowSecondPoint(
GlyphPoint & out_point)
const;
35474 void Set(
GlyphKit const & in_kit);
35478 void Show(
GlyphKit & out_kit)
const;
35487 bool Empty()
const;
35492 bool Equals(
GlyphKit const & in_kit)
const;
35497 bool operator==(
GlyphKit const & in_kit)
const;
35502 bool operator!=(
GlyphKit const & in_kit)
const;
35507 GlyphKit & SetRadius(sbyte in_radius);
35518 GlyphKit & SetElements(GlyphElementArray
const & in_def);
35545 bool ShowRadius(sbyte & out_radius)
const;
35550 bool ShowOffset(
GlyphPoint & out_point)
const;
35555 bool ShowElements(GlyphElementArray & out_def)
const;
35587 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternOptionsKit; };
35604 bool Empty()
const;
35730 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternElement; };
35802 HPS::Type
ObjectType()
const {
return HPS::Type::SolidLinePatternElement; };
35807 void SetColor(
RGBAColor const & in_color);
35812 void SetMaterialByIndex(
float in_material_index);
35857 HPS::Type
ObjectType()
const {
return HPS::Type::BlankLinePatternElement; };
35895 HPS::Type
ObjectType()
const {
return HPS::Type::GlyphLinePatternElement; };
35899 void SetSource(
char const * in_source);
35912 void SetMirror(
bool in_state);
35916 void SetFixed(
bool in_state);
35920 void SetRotation(
float in_degrees);
35925 bool ShowSource(
UTF8 & out_source)
const;
35941 bool ShowMirror(
bool & out_state)
const;
35946 bool ShowFixed(
bool & out_state)
const;
35951 bool ShowRotation(
float & out_degrees)
const;
35977 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternParallelKit; };
35994 bool Empty()
const;
36134 bool ShowBody(LinePatternElementArray & out_elements)
const;
36139 bool ShowAbsoluteLength(
bool & out_state)
const;
36144 bool ShowAbsoluteWeight(
bool & out_state)
const;
36168 bool ShowContinuous(
bool & out_state)
const;
36217 bool Empty()
const;
36237 LinePatternKit & SetParallels(LinePatternParallelKitArray
const & in_parallels);
36265 bool ShowParallels(LinePatternParallelKitArray & out_parallels)
const;
36323 virtual void Assign(
Definition const & in_that);
36328 bool Equals(
Definition const & in_that)
const;
36333 bool operator==(
Definition const & in_that)
const;
36338 bool operator!=(
Definition const & in_that)
const;
36507 PortfolioKey & UndefineNamedStyle(
char const * in_name);
36512 PortfolioKey & UndefineMaterialPalette(
char const * in_name);
36522 PortfolioKey & UndefineLinePattern(
char const * in_name);
36640 size_t GetDefinitionCount()
const;
36643 size_t GetTextureDefinitionCount()
const;
36646 size_t GetCubeMapDefinitionCount()
const;
36649 size_t GetImageDefinitionCount()
const;
36652 size_t GetNamedStyleDefinitionCount()
const;
36655 size_t GetMaterialPaletteDefinitionCount()
const;
36658 size_t GetGlyphDefinitionCount()
const;
36661 size_t GetLinePatternDefinitionCount()
const;
36664 size_t GetShaderDefinitionCount()
const;
36670 bool ShowTextureDefinition(
char const * in_name,
TextureDefinition & out_found)
const;
36675 bool ShowAllTextureDefinitions(TextureDefinitionArray & out_definitions)
const;
36681 bool ShowCubeMapDefinition(
char const * in_name,
CubeMapDefinition & out_found)
const;
36686 bool ShowAllCubeMapDefinitions(CubeMapDefinitionArray & out_definitions)
const;
36692 bool ShowImageDefinition(
char const * in_name,
ImageDefinition & out_found)
const;
36697 bool ShowAllImageDefinitions(ImageDefinitionArray & out_definitions)
const;
36708 bool ShowAllNamedStyleDefinitions(NamedStyleDefinitionArray & out_definitions)
const;
36719 bool ShowAllMaterialPaletteDefinitions(MaterialPaletteDefinitionArray & out_definitions)
const;
36725 bool ShowGlyphDefinition(
char const * in_name,
GlyphDefinition & out_found)
const;
36730 bool ShowAllGlyphDefinitions(GlyphDefinitionArray & out_definitions)
const;
36741 bool ShowAllLinePatternDefinitions(LinePatternDefinitionArray & out_definitions)
const;
36747 bool ShowShaderDefinition(
char const * in_name,
ShaderDefinition & out_found)
const;
36752 bool ShowAllShaderDefinitions(ShaderDefinitionArray & out_definitions)
const;
36756 void MoveTo(
SegmentKey const & in_new_owner);
36802 void Set(
GlyphKit const & in_kit);
36806 void Show(
GlyphKit & out_kit)
const;
36844 HPS::Type
ObjectType()
const {
return HPS::Type::TextureDefinition; };
36889 HPS::Type
ObjectType()
const {
return HPS::Type::TextureOptionsKit; };
36911 bool Empty()
const;
37017 bool ShowDecal(
bool & out_state)
const;
37022 bool ShowDownSampling(
bool & out_state)
const;
37027 bool ShowModulation(
bool & out_state)
const;
37032 bool ShowParameterOffset(
size_t & out_offset)
const;
37057 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
37106 HPS::Type
ObjectType()
const {
return HPS::Type::ImageExportOptionsKit; };
37128 bool Empty()
const;
37149 ExportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37173 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37204 HPS::Type
ObjectType()
const {
return HPS::Type::ImageImportOptionsKit; };
37221 bool Empty()
const;
37244 ImportOptionsKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37287 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37297 bool ShowDownSampling(
bool & out_state)
const;
37302 bool ShowCompressionQuality(
float & out_quality)
const;
37331 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);
37337 static void Export(
char const * in_file_name,
HPS::ImageKit const & in_image_kit);
37383 void Set(
ImageKit const & in_kit);
37387 void Show(
ImageKit & out_kit)
const;
37396 bool Empty()
const;
37401 bool Equals(
ImageKit const & in_kit)
const;
37406 bool operator==(
ImageKit const & in_kit)
const;
37411 bool operator!=(
ImageKit const & in_kit)
const;
37426 ImageKit & SetSize(
unsigned int in_width,
unsigned int in_height);
37431 ImageKit & SetData(ByteArray
const & in_image_data);
37437 ImageKit & SetData(
size_t in_byte_count, byte
const in_image_data []);
37447 ImageKit & SetDownSampling(
bool in_state);
37452 ImageKit & SetCompressionQuality(
float in_quality);
37472 ImageKit & UnsetCompressionQuality();
37482 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37487 bool ShowData(ByteArray & out_image_data)
const;
37497 bool ShowDownSampling(
bool & out_state)
const;
37502 bool ShowCompressionQuality(
float & out_quality)
const;
37534 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowOptionsControl; };
37562 bool ShowAntiAliasCapable(
bool & out_state,
unsigned int & out_samples)
const;
37568 bool ShowSize(
unsigned int & out_width,
unsigned int & out_height)
const;
37580 bool ShowImage(ByteArray & out_bytes)
const;
37585 bool ShowHardwareResident(
bool & out_state)
const;
37591 bool ShowOpacity(
bool & out_state,
float & out_opacity)
const;
37636 HPS::Type
ObjectType()
const {
return HPS::Type::OffScreenWindowKey; };
37693 void Set(
ImageKit const & in_kit);
37697 void Show(
ImageKit & out_kit)
const;
37734 HPS::Type
ObjectType()
const {
return HPS::Type::CubeMapDefinition; };
37761 void ShowSource(ImageDefinitionArray & out_image_sources)
const;
37807 HPS::Type
ObjectType()
const {
return HPS::Type::NamedStyleDefinition; };
37850 HPS::Type
ObjectType()
const {
return HPS::Type::MaterialPaletteDefinition; };
37854 void Set(MaterialKitArray
const & in_source);
37859 void Set(
size_t in_count,
MaterialKit const in_source []);
37863 void Show(MaterialKitArray & out_source)
const;
37902 HPS::Type
ObjectType()
const {
return HPS::Type::LinePatternDefinition; };
37926 PhysicalReflection,
37970 HPS::Type
ObjectType()
const {
return HPS::Type::ShaderImportOptionsKit; };
37987 bool Empty()
const;
38044 bool ShowMultitexture(
bool & out_state)
const;
38054 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
38119 bool Empty()
const;
38124 bool Equals(
ShaderKit const & in_kit)
const;
38129 bool operator==(
ShaderKit const & in_kit)
const;
38134 bool operator!=(
ShaderKit const & in_kit)
const;
38139 ShaderKit & SetSource(
char const * in_source);
38147 ShaderKit & SetMultitexture(
bool in_state);
38170 ShaderKit & UnsetParameterizationSource();
38183 bool ShowSource(
UTF8 & out_source)
const;
38190 bool ShowMultitexture(
bool & out_state)
const;
38200 bool ShowTransformMatrix(
MatrixKit & out_transform)
const;
38238 HPS::Type
ObjectType()
const {
return HPS::Type::ShaderDefinition; };
38278 HPS::Type
ObjectType()
const {
return HPS::Type::CutGeometryGatheringOptionsKit;};
38300 bool Empty()
const;
38359 bool ShowOffset(
size_t & out_offset)
const;
38412 bool Empty()
const;
38479 bool ShowCriteria(SearchTypeArray & out_types)
const;
38484 bool ShowSearchSpace(
Search::Space & out_search_space)
const;
38529 bool operator==(
TreeContext const & in_that)
const;
38534 bool operator!=(
TreeContext const & in_that)
const;
38561 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionOptionsKit;};
38583 bool Empty()
const;
38765 bool ShowProximity(
float & out_proximity)
const;
38775 bool ShowInternalLimit(
size_t & out_limit)
const;
38780 bool ShowRelatedLimit(
size_t & out_limit)
const;
38785 bool ShowSorting(
bool & out_sorted)
const;
38800 bool ShowScope(
KeyPath & out_start_path)
const;
38805 bool ShowTreeContext(
TreeContext & out_tree_context)
const;
38810 bool ShowExtentCullingRespected(
bool & out_state)
const;
38815 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
38820 bool ShowFrustumCullingRespected(
bool & out_state)
const;
38825 bool ShowVectorCullingRespected(
bool & out_state)
const;
38856 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionOptionsControl;};
38955 bool ShowProximity(
float & out_proximity)
const;
38965 bool ShowInternalLimit(
size_t & out_limit)
const;
38970 bool ShowRelatedLimit(
size_t & out_limit)
const;
38975 bool ShowSorting(
bool & out_sorted)
const;
38990 bool ShowExtentCullingRespected(
bool & out_state)
const;
38995 bool ShowDeferralExtentCullingRespected(
bool & out_state)
const;
39000 bool ShowFrustumCullingRespected(
bool & out_state)
const;
39005 bool ShowVectorCullingRespected(
bool & out_state)
const;
39071 bool ShowSelectedItem(
Key & out_selection)
const;
39076 bool ShowPath(
KeyPath & out_path)
const;
39081 bool ShowFaces(SizeTArray & out_faces)
const;
39086 bool ShowVertices(SizeTArray & out_vertices)
const;
39092 bool ShowEdges(SizeTArray & out_vertices1, SizeTArray & out_vertices2)
const;
39097 bool ShowCharacters(SizeTArray & out_characters)
const;
39102 bool ShowSelectionPosition(
WindowPoint & out_location)
const;
39107 bool ShowSelectionPosition(
WorldPoint & out_location)
const;
39135 HPS::Type
ObjectType()
const {
return HPS::Type::SelectionResultsIterator;}
39168 bool IsValid()
const;
39236 virtual void Reset();
39244 size_t GetCount()
const;
39350 size_t SelectByPolygon(PointArray
const & in_points,
SelectionResults & out_results)
const;
39365 size_t SelectByPolygon(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
39378 size_t SelectByLine(PointArray
const & in_points,
SelectionResults & out_results)
const;
39393 size_t SelectByLine(
size_t in_point_count,
Point const in_points [],
SelectionResults & out_results)
const;
39495 HPS::Type
ObjectType()
const {
return HPS::Type::HighlightOptionsKit;};
39517 bool Empty()
const;
39585 bool ShowStyleName(
UTF8 & out_style_name)
const;
39590 bool ShowSecondaryStyleName(
UTF8 & out_style_name)
const;
39600 bool ShowNotification(
bool & out_state)
const;
39754 bool Empty()
const;
39802 bool ShowTimeLimit(HPS::Time & out_time_limit)
const;
39836 HPS::Type
ObjectType()
const {
return HPS::Type::UpdateOptionsControl;};
39873 bool ShowTimeLimit(HPS::Time & out_time_limit)
const;
39888 World(
char const * in_license);
39899 World & SetMaterialLibraryDirectory(
char const * in_directory);
39905 World & SetFontDirectory(
char const * in_directory);
39912 World & SetFontDirectories(
size_t in_count,
UTF8 const in_directories[]);
39918 World & SetFontDirectories(UTF8Array
const & in_directories);
39925 World & SetDriverConfigFile(
char const * in_filename);
39932 World & SetExchangeLibraryDirectory(
char const * in_directory);
39939 World & SetPublishResourceDirectory(
char const * in_directory);
39945 World & SetParasolidSchemaDirectory(
char const * in_directory);
39951 World & SetRealDWGDirectory(
char const * in_directory);
39955 World & UnsetMaterialLibraryDirectory();
39959 World & UnsetFontDirectories();
39963 World & UnsetDriverConfigFile();
39967 World & UnsetExchangeLibraryDirectory();
39971 World & UnsetPublishResourceDirectory();
39975 World & UnsetParasolidSchemaDirectory();
39979 World & UnsetRealDWGDirectory();
39984 bool ShowLicense(
UTF8 & out_license)
const;
39989 bool ShowMaterialLibraryDirectory(
UTF8 & out_directory)
const;
39994 bool ShowFontDirectories(UTF8Array & out_directories)
const;
39999 bool ShowDriverConfigFile(
UTF8 & out_filename)
const;
40004 bool ShowExchangeLibraryDirectory(
UTF8 & out_directory)
const;
40009 bool ShowPublishResourceDirectory(
UTF8 & out_directory)
const;
40014 bool ShowParasolidSchemaDirectory(
UTF8 & out_directory)
const;
40019 bool ShowRealDWGDirectory(
UTF8 & out_directory)
const;
40027 virtual void Reset() {}
40056 intptr_t GetClassID()
const;
40067 static void *
operator new (
size_t in_size){
return Memory::Allocate(in_size); }
40068 static void operator delete (
void * in_ptr,
size_t in_size)
throw () { HPS_UNREFERENCED(in_size);
Memory::Free(in_ptr); }
40081 static void Execute(
bool in_once=
true);
40085 static Time GetTime();
40088 static void Sleep(Time milliseconds);
40114 static void RelinquishMemory();
40142 static void ShowMemoryUsage(
size_t & out_allocated,
size_t & out_used);
40151 static void Reset();
40154 static void Synchronize();
40158 static WindowKeyArray GetWindowKeys();
40162 static SegmentKeyArray GetRootSegments();
40166 static PortfolioKeyArray GetPortfolios();
40172 static PortfolioKey const GetMaterialLibraryPortfolio();
40247 static size_t SelectByShell(
ShellKit const & in_shell,
40256 static size_t SelectByShell(
ShellKey const & in_shell,
40266 static size_t SelectByVolume(
SimpleCuboid const & in_volume,
40276 static size_t SelectByRay(
Point const & in_start_point,
Vector const & in_direction,
40304 static bool SetInformationEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40310 static bool SetWarningEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40316 static bool SetErrorEventFilter(
HPS::Info::Code in_code,
bool in_filtered);
40324 static void UnsetEmergencyHandler();
40328 static size_t GetSoftMemoryLimit();
40333 static size_t SetSoftMemoryLimit(
size_t in_limit_bytes);
40402 bool Subscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
40408 bool UnSubscribe(
EventHandler const & in_handler, intptr_t in_type)
const;
40414 bool UnSubscribe(
EventHandler const & in_handler)
const;
40420 bool UnSubscribe(intptr_t in_type)
const;
40425 bool InjectEvent(
Event const & in_event)
const;
40435 void Shutdown()
const;
40439 bool IsShutdown()
const;
40444 void SetName(
char const * in_name)
const;
40448 void ShowName(
UTF8 & out_name)
const;
40452 virtual void Reset() {}
40491 bool Subscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
40497 bool UnSubscribe(
EventDispatcher const & in_dispatcher, intptr_t in_type)
const;
40505 void UnSubscribeEverything()
const;
40508 virtual void Reset() { UnSubscribeEverything(); }
40538 channel = GetClassID();
40539 consumable =
false;
40547 if(in_event.
GetChannel() != Object::ClassID<TimerTickEvent>())
40566 HPS_UNREFERENCED(in_that_event);
40571 return GetClassID();
40589 channel = GetClassID();
40590 consumable =
false;
40591 action = Action::None;
40595 :
Event(), action(in_action), results(in_results), options(in_options)
40597 channel = GetClassID();
40598 consumable =
false;
40605 if (in_event.
GetChannel() == Object::ClassID<HighlightEvent>())
40608 action = that.action;
40609 results = that.results;
40610 options = that.options;
40651 if (in_event.
GetChannel() == Object::ClassID<InformationEvent>())
40655 code =
event->code;
40678 return message == in_that.
message && code == in_that.
code;
40686 return Equals(in_that);
40694 return !Equals(in_that);
40711 WarningEvent(
char const * in_message) :
Event(), message(in_message), code(HPS::
Info::Code::Unknown) { channel = GetClassID(); }
40722 if(in_event.
GetChannel() == Object::ClassID<WarningEvent>())
40726 code =
event->code;
40749 return message == in_that.
message && code == in_that.
code;
40757 return Equals(in_that);
40765 return !Equals(in_that);
40782 ErrorEvent(
char const * in_message) :
Event(), message(in_message), code(HPS::
Info::Code::Unknown) { channel = GetClassID(); }
40793 if(in_event.
GetChannel() == Object::ClassID<ErrorEvent>())
40797 code =
event->code;
40820 return message == in_that.
message && code == in_that.
code;
40828 return Equals(in_that);
40836 return !Equals(in_that);
40871 if(in_event.
GetChannel() == Object::ClassID<StandAloneWindowEvent>())
40897 return action == in_that.
action;
40905 return Equals(in_that);
40913 return !Equals(in_that);
40926 { channel = GetClassID(); }
40954 if(in_event.
GetChannel() == Object::ClassID<UpdateCompletedEvent>())
40957 update_time =
event->update_time;
40985 , import_status_message(HPS::
UTF8())
40986 { channel = GetClassID(); }
40990 , import_status_message(in_message)
40991 { channel = GetClassID(); }
40997 if (in_event.
GetChannel() == Object::ClassID<ImportStatusEvent>())
41000 import_status_message =
event.import_status_message;
41031 return modifiers == in_that.modifiers;
41039 return Equals(in_that);
41047 return !Equals(in_that);
41052 bool None()
const {
return modifiers == _key_none; }
41056 bool Shift()
const {
return (modifiers & _key_shift) != 0; }
41060 bool Control()
const {
return (modifiers & _key_control) != 0; }
41064 bool Alt()
const {
return (modifiers & _key_alt) != 0; }
41068 bool Meta()
const {
return (modifiers & _key_meta) != 0; }
41074 bool HasAll(
ModifierKeys const & in_keys)
const {
return (modifiers & in_keys.modifiers) == in_keys.modifiers; }
41084 void Shift(
bool in_state) {
if(in_state) modifiers |= _key_shift;
else modifiers &= ~(_key_shift); }
41088 void Control(
bool in_state) {
if(in_state) modifiers |= _key_control;
else modifiers &= ~(_key_control); }
41092 void Alt(
bool in_state) {
if(in_state) modifiers |= _key_alt;
else modifiers &= ~(_key_alt); }
41096 void Meta(
bool in_state) {
if(in_state) modifiers |= _key_meta;
else modifiers &= ~(_key_meta); }
41104 ret.modifiers = modifiers | in_modifiers_to_merge.modifiers;
41114 ret.modifiers = modifiers & ~in_modifiers_to_remove.modifiers;
41151 _key_none = 0x0000,
41152 _key_shift = 0x0001,
41153 _key_control = 0x0002,
41155 _key_meta = 0x0008,
41198 return Equals(in_that);
41206 return !Equals(in_that);
41214 return ModifierKeyState;
41241 :
InputEvent(in_modifier), CurrentAction(in_action) { channel = GetClassID(); }
41249 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches) { channel = GetClassID(); }
41258 :
InputEvent(in_modifier), CurrentAction(in_action), Touches(in_touches, in_touches + in_touch_count) { channel = GetClassID(); }
41265 if(in_event.
GetChannel() == Object::ClassID<TouchEvent>())
41268 channel = GetClassID();
41269 CurrentAction =
event->CurrentAction;
41270 Touches =
event->Touches;
41271 ModifierKeyState =
event->ModifierKeyState;
41301 return Equals(in_that);
41309 return !Equals(in_that);
41319 if (CurrentAction == that_touch_event->
CurrentAction && CurrentAction == Action::Move
41320 && Touches.size() == that_touch_event->
Touches.size() )
41322 TouchArray these_touches = Touches;
41323 TouchArray those_touches = that_touch_event->
Touches;
41325 std::sort(those_touches.begin(), those_touches.end(), sort_predicate);
41326 std::sort(these_touches.begin(), these_touches.end(), sort_predicate);
41328 for (
size_t i = 0 ; i < these_touches.size() ; i++)
41330 if (these_touches[i].ID != those_touches[i].ID)
41344 Touches.assign(in_touches, in_touches + in_touch_count);
41351 Touches = in_touches;
41363 static bool sort_predicate(
Touch const & in_a,
Touch const & in_b)
41365 return static_cast<int>(in_a.
ID) < static_cast<int>(in_b.
ID);
41382 return buttons == in_that.buttons;
41390 return Equals(in_that);
41398 return !Equals(in_that);
41403 bool None()
const {
return buttons == _button_none; }
41407 bool Left()
const {
return (buttons & _button_left) != 0; }
41411 bool Right()
const {
return (buttons & _button_right) != 0; }
41415 bool Middle()
const {
return (buttons & _button_middle) != 0; }
41419 bool X1()
const {
return (buttons & _button_x1) != 0; }
41423 bool X2()
const {
return (buttons & _button_x2) != 0; }
41429 bool HasAll(
MouseButtons const & in_buttons)
const {
return (buttons & in_buttons.buttons) == in_buttons.buttons; }
41438 void Left(
bool in_state) {
if(in_state) buttons |= _button_left;
else buttons &= ~(_button_left); }
41442 void Right(
bool in_state) {
if(in_state) buttons |= _button_right;
else buttons &= ~(_button_right); }
41446 void Middle(
bool in_state) {
if(in_state) buttons |= _button_middle;
else buttons &= ~(_button_middle); }
41450 void X1(
bool in_state) {
if(in_state) buttons |= _button_x1;
else buttons &= ~(_button_x1); }
41454 void X2(
bool in_state) {
if(in_state) buttons |= _button_x2;
else buttons &= ~(_button_x2); }
41462 ret.buttons = buttons | in_buttons_to_merge.buttons;
41472 ret.buttons = buttons & ~in_buttons_to_remove.buttons;
41513 _button_none = 0x0000,
41514 _button_left = 0x0001,
41515 _button_right = 0x0002,
41516 _button_middle = 0x0004,
41517 _button_x1 = 0x0008,
41518 _button_x2 = 0x0010
41551 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), CurrentButton(in_button), WheelDelta(0), ClickCount(in_click_count) { channel = GetClassID(); }
41561 :
InputEvent(in_modifier), CurrentAction(in_action), Location(in_location), WheelDelta(in_wheel_delta), ClickCount(in_click_count) { channel = GetClassID(); }
41567 if(in_event.
GetChannel() == Object::ClassID<MouseEvent>())
41570 channel = GetClassID();
41571 CurrentAction =
event->CurrentAction;
41572 Location =
event->Location;
41573 CurrentButton =
event->CurrentButton;
41574 WheelDelta =
event->WheelDelta;
41575 ClickCount =
event->ClickCount;
41608 return Equals(in_that);
41616 return !Equals(in_that);
41627 (CurrentAction == Action::ButtonDown || CurrentAction == Action::ButtonUp || CurrentAction == Action::Move) &&
41636 if (CurrentAction == Action::Move)
41637 return GetClassID();
41670 :
InputEvent(in_modifiers), CurrentAction(in_action) { channel = GetClassID(); }
41678 :
InputEvent(in_modifiers), CurrentAction(in_action)
41680 channel = GetClassID();
41681 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41689 :
InputEvent(in_modifiers), CurrentAction(in_action)
41691 channel = GetClassID();
41692 KeyboardCodes = in_keyboardcodes;
41699 if(in_event.
GetChannel() == Object::ClassID<KeyboardEvent>())
41702 channel = GetClassID();
41703 KeyboardCodes =
event->KeyboardCodes;
41704 CurrentAction =
event->CurrentAction;
41735 return Equals(in_that);
41743 return !Equals(in_that);
41751 KeyboardCodes.assign(in_keyboardcodes, in_keyboardcodes + in_keyboardcode_count);
41758 KeyboardCodes = in_keyboardcodes;
41803 bool Equals(
MouseState const & in_that)
const;
41808 bool operator== (
MouseState const & in_that)
const;
41813 bool operator!= (
MouseState const & in_that)
const;
41841 HPS::KeyArray GetEventPath()
const;
41857 void SetActiveEvent(
MouseEvent const & in_event);
41861 void SetEventPath(KeyArray
const & in_path);
41915 bool Equals(
TouchState const & in_that)
const;
41920 bool operator== (
TouchState const & in_that)
const;
41925 bool operator!= (
TouchState const & in_that)
const;
41946 HPS::KeyArray GetEventPath()
const;
41950 size_t GetTouchCount()
const;
41954 HPS::TouchArray GetTouches()
const;
41962 void SetActiveEvent(
TouchEvent const & in_event);
41966 void SetEventPath(KeyArray
const & in_path);
41970 void SetTouches(TouchArray
const & in_touches);
42047 HPS::KeyArray GetEventPath()
const;
42051 size_t GetKeyboardCodeCount()
const;
42055 HPS::KeyboardCodeArray GetKeyboardCodes()
const;
42060 bool GetKeyState(HPS::KeyboardCode in_key_code)
const;
42072 void SetEventPath(KeyArray
const & in_path);
42076 void SetKeyboardCodes(KeyboardCodeArray
const & in_keyboard_codes);
42128 IOResult Status()
const;
42133 IOResult Status(
float & out_percent_complete)
const;
42174 virtual void Restart();
42179 static Toolkit CreateToolkit();
42204 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportOptionsKit; };
42221 bool Empty()
const;
42264 bool ShowSegment(
SegmentKey & out_segment)
const;
42279 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
42294 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
42324 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportResultsKit; };
42341 bool Empty()
const;
42373 bool ShowSegment(
SegmentKey & out_segment)
const;
42391 bool ShowAlternateRoot(
SegmentKey & out_segment)
const;
42409 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
42425 bool ShowDefaultCamera(
CameraKit & out_camera)
const;
42433 ImportResultsKit & SetAlternateCameras(UTF8Array
const & in_names, CameraKitArray & in_cameras);
42444 bool ShowAlternateCameras(UTF8Array & out_names, CameraKitArray & out_cameras)
const;
42480 HPS::Type
ObjectType()
const {
return HPS::Type::StreamExportOptionsKit; };
42497 bool Empty()
const;
42525 ExportOptionsKit & SetVertexCompression(
bool in_state,
unsigned int in_bits_per_vertex = 24);
42534 ExportOptionsKit & SetNormalCompression(
bool in_state,
unsigned int in_bits_per_normal = 10);
42541 ExportOptionsKit & SetParameterCompression(
bool in_state,
unsigned int in_bits_per_parameter = 8);
42550 ExportOptionsKit & SetColorCompression(
bool in_state,
unsigned int in_bits_per_color = 24);
42559 ExportOptionsKit & SetIndexCompression(
bool in_state,
unsigned int in_bits_per_index = 8);
42583 ExportOptionsKit & SetImageCompression(
bool in_state,
float in_quality = 0.75f);
42634 bool ShowVertexCompression(
bool & out_state,
unsigned int & out_bits_per_vertex)
const;
42640 bool ShowNormalCompression(
bool & out_state,
unsigned int & out_bits_per_normal)
const;
42646 bool ShowParameterCompression(
bool & out_state,
unsigned int & out_bits_per_parameter)
const;
42652 bool ShowColorCompression(
bool & out_state,
unsigned int & out_bits_per_color)
const;
42658 bool ShowIndexCompression(
bool & out_state,
unsigned int & out_bits_per_index)
const;
42663 bool ShowConnectivityCompression(
bool & out_state)
const;
42669 bool ShowImageCompression(
bool & out_state,
float & out_quality)
const;
42674 bool ShowSerializeTristrips(
bool & out_state)
const;
42707 HPS::Type
ObjectType()
const {
return HPS::Type::StreamImportNotifier;};
42754 HPS::Type
ObjectType()
const {
return HPS::Type::StreamExportNotifier;};
42827 DotsPerCentimeter = DPCM,
42859 HPS::Type
ObjectType()
const {
return HPS::Type::HardcopyExportOptionsKit; };
42876 bool Empty()
const;
42901 bool ShowSize(
float & out_width,
float & out_height,
Hardcopy::SizeUnits & out_units)
const;
42941 bool ShowWYSIWYG(
bool & out_onoff)
const;
42984 static IOResult Export(
char const * in_filename, Driver in_driver_type,
HPS::WindowKey const & in_window, ExportOptionsKit
const & in_options);
42995 class HPS_API ExportOptionsKit :
public Object
42999 ExportOptionsKit();
43003 ExportOptionsKit(ExportOptionsKit
const & in_kit);
43008 ExportOptionsKit(ExportOptionsKit && in_that);
43013 ExportOptionsKit & operator=(ExportOptionsKit && in_that);
43015 virtual ~ExportOptionsKit();
43017 HPS::Type ObjectType()
const {
return HPS::Type::HardcopyExportOptionsKit; };
43021 void Set(ExportOptionsKit
const & in_kit);
43025 void Show(ExportOptionsKit & out_kit)
const;
43030 ExportOptionsKit & operator=(ExportOptionsKit
const & in_kit);
43034 bool Empty()
const;
43039 bool Equals(ExportOptionsKit
const & in_kit)
const;
43044 bool operator==(ExportOptionsKit
const & in_kit)
const;
43049 bool operator!=(ExportOptionsKit
const & in_kit)
const;
43057 bool ShowResolution(
float & out_resolution)
const;
43062 ExportOptionsKit & SetResolution(
float in_resolution);
43066 ExportOptionsKit & UnsetResolution();
43073 bool ShowWYSIWYG(
bool & out_onoff)
const;
43078 ExportOptionsKit & SetWYSIWYG(
bool in_onoff);
43082 ExportOptionsKit & UnsetWYSIWYG();
43087 ExportOptionsKit & UnsetEverything();
43096 static IOResult Export(intptr_t hdc, intptr_t attribdc,
HPS::WindowKey const & window, ExportOptionsKit
const & options);
43139 HPS::Type
ObjectType()
const {
return HPS::Type::OBJImportOptionsKit; };
43156 bool Empty()
const;
43186 bool ShowSegment(
SegmentKey & out_segment)
const;
43201 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
43247 HPS::Type
ObjectType()
const {
return HPS::Type::OBJImportResultsKit; };
43264 bool Empty()
const;
43296 bool ShowSegment(
SegmentKey & out_segment)
const;
43314 bool ShowPortfolio(
PortfolioKey & out_portfolio)
const;
43438 HPS::Type
ObjectType()
const {
return HPS::Type::STLImportOptionsKit; };
43455 bool Empty()
const;
43517 bool ShowSegment(
SegmentKey & out_segment)
const;
43549 HPS::Type
ObjectType()
const {
return HPS::Type::STLImportResultsKit; };
43566 bool Empty()
const;
43598 bool ShowSegment(
SegmentKey & out_segment)
const;
43676 # pragma warning(pop)
HPS::Type ObjectType() const
Definition: hps.h:39893
Rotation
Definition: hps.h:1588
HPS::Type ObjectType() const
Definition: hps.h:26861
bool Empty() const
Definition: hps.h:6822
CameraPoint(Point const &in_point)
Definition: hps.h:5773
Alignment
Definition: hps.h:1521
Space
Definition: hps.h:554
WindowPoint Location
Location in window space of the mouse cursor.
Definition: hps.h:41643
Channel
Definition: hps.h:938
HPS::Type ObjectType() const
Definition: hps.h:24031
Handedness
Definition: hps.h:1269
ColorSource
Definition: hps.h:1914
HPS::Type ObjectType() const
Definition: hps.h:16983
HPS::Type ObjectType() const
Definition: hps.h:36195
Event(intptr_t in_channel=0)
Definition: hps.h:6126
HPS::Type ObjectType() const
Definition: hps.h:43368
Cuboid_3D(Point_3D< F > const &in_min, Point_3D< F > const &in_max)
Definition: hps.h:3744
float alpha
Definition: hps.h:4283
HPS::Type ObjectType() const
Definition: hps.h:35802
bool operator==(Touch const &in_that) const
Definition: hps.h:6416
Both cylinder ends will be capped.
Search for all attributes, geometry, segments, includes and includers.
void Shift(bool in_state)
Definition: hps.h:41084
HPS::Info::Code code
The error code for this ErrorEvent.
Definition: hps.h:40840
HPS::Type ObjectType() const
Definition: hps.h:38238
HPS::Type ObjectType() const
Definition: hps.h:34266
HPS::Type ObjectType() const
Definition: hps.h:21761
HPS::Type ObjectType() const
Definition: hps.h:23559
HPS::Type ObjectType() const
Definition: hps.h:24305
Action
Definition: hps.h:41226
Orientation
Definition: hps.h:530
Code
Definition: hps.h:127
Definition: sprk_exchange.h:43
Algorithm
Definition: hps.h:1324
Multiline strings will be left justfied.
HPS::Type ObjectType() const
Definition: hps.h:14866
virtual bool Equals(StandAloneWindowEvent const &in_that) const
Definition: hps.h:40895
HPS::Type ObjectType() const
Definition: hps.h:8608
HPS::Type ObjectType() const
Definition: hps.h:28089
Event * Clone() const
Definition: hps.h:40738
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:41560
virtual HandleResult Handle(Event const *in_event)
Definition: hps.h:40526
ImportStatusEvent()
Definition: hps.h:40983
HPS::Type ObjectType() const
Definition: hps.h:21378
HPS::Type ObjectType() const
Definition: hps.h:35977
HPS::Type ObjectType() const
Definition: hps.h:25824
virtual bool Equals(TouchEvent const &in_that) const
Definition: hps.h:41291
HPS::Type ObjectType() const
Definition: hps.h:30129
HPS::Type ObjectType() const
Definition: hps.h:25435
HPS::Type ObjectType() const
Definition: hps.h:11546
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:40787
void SetKeyboardCodes(size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[])
Definition: hps.h:41749
HPS::Type ObjectType() const
Definition: hps.h:37689
ObjectPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5670
InnerWindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5918
Driver
Definition: hps.h:147
HPS::Type ObjectType() const
Definition: hps.h:41789
static HPS_INLINE bool IsInfinite(float const &a)
Definition: hps.h:2185
HPS::Type ObjectType() const
Definition: hps.h:39037
CappingLevel
Definition: hps.h:1720
HPS::Type ObjectType() const
Definition: hps.h:23286
HPS::Type ObjectType() const
Definition: hps.h:35730
Object space units ignoring any scaling components in modelling matrices.
HPS::Type ObjectType() const
Definition: hps.h:12684
HPS::Type ObjectType() const
Definition: hps.h:41901
HPS::Type ObjectType() const
Definition: hps.h:20422
HPS::Type ObjectType() const
Definition: hps.h:13701
An InvalidSpecificationException is thrown when a method is called with non-sensical or contradictory...
Definition: hps.h:5530
HPS::Type ObjectType() const
Definition: hps.h:28874
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid) const
Definition: hps.h:3851
KeyboardEvent(KeyboardEvent::Action in_action, KeyboardCodeArray const &in_keyboardcodes, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41688
static ModifierKeys KeyMeta()
Definition: hps.h:41143
HPS::Type ObjectType() const
Definition: hps.h:35465
Visualize will perform runtime query of the 3D capabilities of the Operating System and graphics card...
HPS::Type ObjectType() const
Definition: hps.h:36844
HPS::Type ObjectType() const
Definition: hps.h:42754
Cuboid_3D(Cuboid_3D< D > const &that)
Definition: hps.h:3730
HPS::Type ObjectType() const
Definition: hps.h:39209
HPS::Type ObjectType() const
Definition: hps.h:23484
HPS::Type ObjectType() const
Definition: hps.h:35036
HPS::Type ObjectType() const
Definition: hps.h:16692
HPS::Type ObjectType() const
Definition: hps.h:38278
Time GetTimeStamp() const
Definition: hps.h:6148
HPS::Type ObjectType() const
Definition: hps.h:22279
NormalizedPoint(Point const &in_point)
Definition: hps.h:5823
HPS::Type ObjectType() const
Definition: hps.h:23833
Event * Clone() const
Definition: hps.h:40555
static HPS_INLINE Cuboid_3D Invalid()
Definition: hps.h:3779
Renderer
Definition: hps.h:1569
HPS::Type ObjectType() const
Definition: hps.h:34002
KeyboardEvent()
Definition: hps.h:41664
HPS::Type ObjectType() const
Definition: hps.h:7335
HPS_INLINE bool Contains(Cuboid_3D const &contained) const
Definition: hps.h:3972
ObjectPoint(Point const &in_point)
Definition: hps.h:5673
HPS::Type ObjectType() const
Definition: hps.h:17570
Object space units ignoring any scaling components in modelling matrices.
Point_3D< F > min
Definition: hps.h:3714
StandAloneWindowEvent(Event const &in_event)
Definition: hps.h:40869
static ModifierKeys KeyAlt()
Definition: hps.h:41139
bool IsConsumable() const
Definition: hps.h:6151
MaterialPreference
Definition: hps.h:1737
KeyboardEvent(KeyboardEvent::Action in_action, size_t in_keyboardcode_count, HPS::KeyboardCode const in_keyboardcodes[], ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41677
Mobility
Definition: hps.h:187
HPS::Type ObjectType() const
Definition: hps.h:13194
ScreenRangePoint(Point const &in_point)
Definition: hps.h:5871
InterpolationAlgorithm
Definition: hps.h:1504
Fill
Definition: hps.h:1905
Cuboid_3D(Rectangle const &that)
Definition: hps.h:3767
HPS::Type ObjectType() const
Definition: hps.h:27366
HPS::Type ObjectType() const
Definition: hps.h:19063
char At(size_t in_index) const
Definition: hps.h:6865
bool HasAny(ModifierKeys const &in_keys) const
Definition: hps.h:41079
HPS::Type ObjectType() const
Definition: hps.h:35857
ReferenceFrame
Definition: hps.h:1536
HPS::Type ObjectType() const
Definition: hps.h:16899
GreekingUnits
Definition: hps.h:1623
HPS::Type ObjectType() const
Definition: hps.h:12096
InnerConeUnits
Definition: hps.h:479
InnerPixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5967
HPS_INLINE bool Intersecting(Point_3D< F > const &point1, Point_3D< F > const &point2) const
Definition: hps.h:3884
KeyPath & Append(Key const &in_key)
UpdateCompletedEvent()
Definition: hps.h:40945
OuterConeUnits
Definition: hps.h:465
HPS::Type ObjectType() const
Definition: hps.h:18847
HPS::Type ObjectType() const
Definition: hps.h:40376
HPS::Type ObjectType() const
Definition: hps.h:39306
HPS::Type ObjectType() const
Definition: hps.h:14297
HPS::Type ObjectType() const
Definition: hps.h:33485
void SetKeyboardCodes(HPS::KeyboardCodeArray const &in_keyboardcodes)
Definition: hps.h:41756
HPS::Type ObjectType() const
Definition: hps.h:26760
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41315
HPS::Type ObjectType() const
Definition: hps.h:12567
HPS::Type ObjectType() const
Definition: hps.h:25017
HPS::Type ObjectType() const
Definition: hps.h:36308
Channel
Definition: hps.h:897
HPS::Info::Code code
The warning code for this WarningEvent.
Definition: hps.h:40769
AreaUnits
Definition: hps.h:1450
Definition: sprk_publish.h:42
HPS_INLINE F Volume() const
Definition: hps.h:3821
HPS::Type ObjectType() const
Definition: hps.h:11919
HPS::Type ObjectType() const
Definition: hps.h:34622
Action
Definition: hps.h:40851
HPS::Type ObjectType() const
Definition: hps.h:14135
HPS::Type ObjectType() const
Definition: hps.h:42480
HPS::Type ObjectType() const
Definition: hps.h:27467
size_t TapCount
Number of taps for this Touch.
Definition: hps.h:6431
HPS::Type ObjectType() const
Definition: hps.h:37807
HPS::Type ObjectType() const
Definition: hps.h:34139
TouchEvent(Action in_action, TouchArray const &in_touches, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41248
void Merge(size_t count, Point_3D< F > const *points)
Definition: hps.h:3930
Border
Definition: hps.h:257
UpdateControl
Definition: hps.h:168
bool HasAll(ModifierKeys const &in_keys) const
Definition: hps.h:41074
HPS::Type ObjectType() const
Definition: hps.h:23036
virtual bool Equals(KeyboardEvent const &in_that) const
Definition: hps.h:41725
HPS::Type ObjectType() const
Definition: hps.h:21303
WarningEvent(Event const &in_event)
Definition: hps.h:40720
HPS::Type ObjectType() const
Definition: hps.h:11422
The geometry inside the clip region is drawn. Everything outside of it is clipped.
Default
Definition: hps.h:1924
static ModifierKeys KeyShift()
Definition: hps.h:41131
HPS::Type ObjectType() const
Definition: hps.h:28600
Shape
Definition: hps.h:1066
bool IsValid() const
Definition: hps.h:6815
Cuboid_3D()
Definition: hps.h:3722
ErrorEvent(Event const &in_event)
Definition: hps.h:40791
size_t GetWStrLength() const
Definition: hps.h:6844
Event * Clone() const
Definition: hps.h:40620
HPS::Type ObjectType() const
Definition: hps.h:11013
AppendMode
Definition: hps.h:325
static void Free(void *in_pointer)
HPS_INLINE void Merge(Point_3D< F > const &point)
Definition: hps.h:3915
void Meta(bool in_state)
Definition: hps.h:41096
PixelPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6066
HPS::Type ObjectType() const
Definition: hps.h:14575
UpdateStatus
Definition: hps.h:157
HPS_INLINE bool IsValid() const
Definition: hps.h:3772
HPS::Type ObjectType() const
Definition: hps.h:38390
Action action
The action for this StandAloneWindowEvent.
Definition: hps.h:40916
Quality
Definition: hps.h:1050
ResolutionUnits
Definition: hps.h:42823
TimerTickEvent(Event const &in_event)
Definition: hps.h:40545
Component
Definition: hps.h:345
WindowPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:6017
HPS::Type ObjectType() const
Definition: hps.h:12183
Default
Definition: hps.h:1878
HPS::Type ObjectType() const
Definition: hps.h:10643
bool Equals(GlyphPoint const &in_that) const
Definition: hps.h:5057
bool Shift() const
Definition: hps.h:41056
SizeToleranceUnits
Definition: hps.h:1610
HPS::Type ObjectType() const
Definition: hps.h:38514
HPS_INLINE bool Contains(Point_3D< F > const &contained, F epsilon) const
Definition: hps.h:4001
Cap
Definition: hps.h:1829
Point_3D< F > max
Definition: hps.h:3716
HPS::Type ObjectType() const
Definition: hps.h:7415
HPS::Type ObjectType() const
Definition: hps.h:43139
HPS::Type ObjectType() const
Definition: hps.h:43247
MouseEvent()
Definition: hps.h:41542
HPS::Type ObjectType() const
Definition: hps.h:12024
HPS::Type ObjectType() const
Definition: hps.h:16601
HPS::Type ObjectType() const
Definition: hps.h:35081
Material Texture Channel.
static const float Infinity
Definition: hps.h:2180
InsetBehavior
Definition: hps.h:1810
HPS::Type ObjectType() const
Definition: hps.h:24943
static HPS_INLINE bool IsNAN(float const &a)
Definition: hps.h:2193
HPS::Type ObjectType() const
Definition: hps.h:13589
HPS::Type ObjectType() const
Definition: hps.h:27060
WindowPoint Location
Location in window space for this Touch.
Definition: hps.h:6430
HPS::Type ObjectType() const
Definition: hps.h:35271
HPS::Type ObjectType() const
Definition: hps.h:37534
HPS_INLINE void Merge(Cuboid_3D const &cuboid)
Definition: hps.h:3894
Algorithm
Definition: hps.h:1438
Decimation
Definition: hps.h:1007
Granularity
Definition: hps.h:1359
Parameterization
Definition: hps.h:37921
Search the current segment only.
KeyboardEvent(Event const &in_event)
Definition: hps.h:41697
ClipOperation
Definition: hps.h:1298
HPS::Type ObjectType() const
Definition: hps.h:8860
Method
Definition: hps.h:1428
HPS::Type ObjectType() const
Definition: hps.h:26480
Parameterization
Definition: hps.h:952
FocusLostEvent()
Definition: hps.h:40924
CuttingLevel
Definition: hps.h:1729
Channel
Definition: hps.h:918
HandleResult
Definition: hps.h:40516
bool operator!=(GlyphPoint const &in_that) const
Definition: hps.h:5069
UTF8 message
The error message for this ErrorEvent.
Definition: hps.h:40839
Value
Definition: hps.h:1409
static HPS_INLINE bool IsAbnormal(float const &a)
Definition: hps.h:2201
HPS::Type ObjectType() const
Definition: hps.h:25976
Event * Clone() const
Definition: hps.h:40932
virtual bool Equals(MouseEvent const &in_that) const
Definition: hps.h:41596
ErrorEvent()
Definition: hps.h:40778
Justification
Definition: hps.h:1544
The vertex colors applied to faces.
HPS::Type ObjectType() const
Definition: hps.h:13959
An InvalidOperationException is thrown when an operation is not supported on the current platform...
Definition: hps.h:5548
ErrorEvent(char const *in_message)
Definition: hps.h:40782
UpdateCompletedEvent(Event const &in_event)
Definition: hps.h:40952
FrameSize
Definition: hps.h:198
Justification
Definition: hps.h:1846
HPS::Type ObjectType() const
Definition: hps.h:11744
HPS::Type ObjectType() const
Definition: hps.h:19704
HPS::Type ObjectType() const
Definition: hps.h:22110
HPS::Type ObjectType() const
Definition: hps.h:8655
HPS::Type ObjectType() const
Definition: hps.h:36798
HPS::Type ObjectType() const
Definition: hps.h:34985
GreekingMode
Definition: hps.h:1635
HPS::Type ObjectType() const
Definition: hps.h:20214
HPS::KeyboardCodeArray KeyboardCodes
Array of keyboard codes for this KeyboardEvent.
Definition: hps.h:41761
Operation
Definition: hps.h:448
HPS::Type ObjectType() const
Definition: hps.h:37379
Type
Definition: hps.h:1992
WorldPoint(Point const &in_point)
Definition: hps.h:5723
HPS::TouchArray Touches
Array of Touches for this TouchEvent.
Definition: hps.h:41355
HPS::Type ObjectType() const
Definition: hps.h:9842
static HPS_INLINE bool Equals(float const &a, float const &b, int tolerance=32)
Definition: hps.h:2472
HPS::Type ObjectType() const
Definition: hps.h:6662
TouchEvent(Event const &in_event)
Definition: hps.h:41263
void SetTouches(HPS::TouchArray const &in_touches)
Definition: hps.h:41349
friend bool operator!=(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6947
Relation
Definition: hps.h:371
Action
Definition: hps.h:41656
ChannelMapping
Definition: hps.h:1021
HPS::Type ObjectType() const
Definition: hps.h:22628
IOResult result
Enumeration indicating the category of the exception.
Definition: hps.h:5565
HPS::Type ObjectType() const
Definition: hps.h:38856
HPS::Type ObjectType() const
Definition: hps.h:39495
bool Alt() const
Definition: hps.h:41064
ToleranceUnits
Definition: hps.h:354
HPS::Type ObjectType() const
Definition: hps.h:12494
SizeUnits
Definition: hps.h:1797
Type
Definition: hps.h:2009
The vertex colors applied to faces.
RelationTest
Definition: hps.h:381
Type
Definition: hps.h:316
HPS::Type ObjectType() const
Definition: hps.h:14719
Behavior
Definition: hps.h:563
Ambient Occulsion Quality.
HPS::Type ObjectType() const
Definition: hps.h:6737
HPS::KeyboardEvent::Action CurrentAction
The action for the keyboard codes for this KeyboardEvent.
Definition: hps.h:41762
HPS::Type ObjectType() const
Definition: hps.h:18613
ImageFormat
Definition: hps.h:213
An InvalidLicenseException is thrown when trying to run Visualize with an invalid license...
Definition: hps.h:5539
float blue
Definition: hps.h:4282
A grid of lines will be drawn in place of characters below the greeking limit.
Type
Definition: hps.h:421
HPS::Type ObjectType() const
Definition: hps.h:21042
friend bool operator!=(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6965
PixelPoint(Point const &in_point)
Definition: hps.h:6069
HPS::Type ObjectType() const
Definition: hps.h:6191
HPS::Type ObjectType() const
Definition: hps.h:7054
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:41622
HPS::Type ObjectType() const
Definition: hps.h:21639
HPS::Type ObjectType() const
Definition: hps.h:21519
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:35224
HPS::Type ObjectType() const
Definition: hps.h:28743
HPS::Type ObjectType() const
Definition: hps.h:24104
HPS::Type ObjectType() const
Definition: hps.h:39135
HPS::Type ObjectType() const
Definition: hps.h:20904
HPS::MouseEvent::Action CurrentAction
The action for this MouseEvent.
Definition: hps.h:41642
Event * Clone() const
Definition: hps.h:41010
bool operator==(GlyphPoint const &in_that) const
Definition: hps.h:5063
HPS::Type ObjectType() const
Definition: hps.h:34536
HPS::Type ObjectType() const
Definition: hps.h:40485
Alignment and justification will be defined relative to a screen-facing box around the text...
HPS::Type ObjectType() const
Definition: hps.h:15750
Infinite line which extends infinitely in both directions along a vector.
intptr_t GetChannel() const
Definition: hps.h:6145
HPS::Type ObjectType() const
Definition: hps.h:9213
Algorithm
Definition: hps.h:1351
HPS::Type ObjectType() const
Definition: hps.h:31215
HPS::Type ObjectType() const
Definition: hps.h:37850
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3839
Driver
Definition: hps.h:42973
SizeUnits
Definition: hps.h:1665
StandAloneWindowEvent()
Definition: hps.h:40860
HPS::Type ObjectType() const
Definition: hps.h:36377
HPS::Type ObjectType() const
Definition: hps.h:34374
HPS::Type ObjectType() const
Definition: hps.h:12332
HPS::Type ObjectType() const
Definition: hps.h:11163
virtual bool Equals(WarningEvent const &in_that) const
Definition: hps.h:40747
MouseEvent(Action in_action, WindowPoint in_location, MouseButtons in_button=MouseButtons(), ModifierKeys in_modifier=ModifierKeys(), size_t in_click_count=0)
Definition: hps.h:41550
An InvalidObjectException is thrown when a user tries to interact with an object that either is unini...
Definition: hps.h:5511
HPS::Type ObjectType() const
Definition: hps.h:17410
Level
Definition: hps.h:1342
bool Equals(ModifierKeys const &in_that) const
Definition: hps.h:41029
void Control(bool in_state)
Definition: hps.h:41088
HPS::Type ObjectType() const
Definition: hps.h:42707
HPS::Type ObjectType() const
Definition: hps.h:18121
HPS_INLINE bool Contains(Point_3D< F > const &contained) const
Definition: hps.h:3986
UTF8 message
The warning message for this WarningEvent.
Definition: hps.h:40768
The base class of all HPS exceptions.
Definition: hps.h:5503
RegionAlignment
Definition: hps.h:1644
TouchEvent(Action in_action, size_t in_touch_count, Touch const in_touches[], ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41257
Event * Clone() const
Definition: hps.h:41587
HPS::Type ObjectType() const
Definition: hps.h:21191
void Invalidate()
Definition: hps.h:3784
Quaternion Spline(Quaternion const &in_previous, Quaternion const &in_next) const
Definition: hps.h:4778
IOException(char const *in_info, IOResult in_result)
Definition: hps.h:5562
UpdateCompletedEvent(Time in_update_time)
Definition: hps.h:40948
HPS::Type ObjectType() const
Definition: hps.h:33862
HPS::Type ObjectType() const
Definition: hps.h:39732
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:6138
char const * GetBytes() const
Definition: hps.h:6851
virtual intptr_t Freshen() const
Definition: hps.h:41634
HPS::Type ObjectType() const
Definition: hps.h:35333
float green
Definition: hps.h:4281
Action
Definition: hps.h:41531
The vertex colors applied to faces.
SizeUnits
Definition: hps.h:1689
HPS::Type ObjectType() const
Definition: hps.h:10247
HPS::Type ObjectType() const
Definition: hps.h:27132
HPS::Type ObjectType() const
Definition: hps.h:24622
HPS::Type ObjectType() const
Definition: hps.h:24378
static void * Allocate(size_t in_bytes, bool in_clear_memory=true)
HPS::Type ObjectType() const
Definition: hps.h:37902
HPS::Type ObjectType() const
Definition: hps.h:24745
InnerPixelPoint(Point const &in_point)
Definition: hps.h:5970
ImportStatusEvent(Event const &in_event)
Definition: hps.h:40995
NormalizedPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5820
Touch(TouchID in_id, WindowPoint const &in_location, size_t in_tap_count=1)
Definition: hps.h:6410
static const float NegativeInfinity
Definition: hps.h:2182
HighlightEvent(Event const &in_event)
Definition: hps.h:40603
friend bool operator==(wchar_t const *in_left, UTF8 const &in_right)
Definition: hps.h:6956
SizeUnits
Definition: hps.h:1470
HPS::Type ObjectType() const
Definition: hps.h:12770
HPS::Type ObjectType() const
Definition: hps.h:20600
HPS::MouseButtons CurrentButton
If the action involves a button, this is the button.
Definition: hps.h:41644
HPS::Type ObjectType() const
Definition: hps.h:10468
InnerWindowPoint(Point const &in_point)
Definition: hps.h:5921
GatheringLevel
Definition: hps.h:1745
HPS::Type ObjectType() const
Definition: hps.h:28953
Cuboid_3D(size_t count, Point_3D< F > const *points)
Definition: hps.h:3751
FrameOptions
Definition: hps.h:207
HPS::Type ObjectType() const
Definition: hps.h:35174
Space
Definition: hps.h:8566
void Alt(bool in_state)
Definition: hps.h:41092
KeyboardEvent(KeyboardEvent::Action in_action, ModifierKeys in_modifiers=ModifierKeys())
Definition: hps.h:41669
HPS::Type ObjectType() const
Definition: hps.h:37106
Type
Definition: hps.h:251
bool operator!=(Touch const &in_that) const
Definition: hps.h:6424
Type
Definition: hps.h:439
HPS::Type ObjectType() const
Definition: hps.h:42204
HPS::Type ObjectType() const
Definition: hps.h:43549
HPS::Type ObjectType() const
Definition: hps.h:38102
HPS::Type ObjectType() const
Definition: hps.h:43438
HPS::Type ObjectType() const
Definition: hps.h:33593
WorldPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5720
HPS::Type ObjectType() const
Definition: hps.h:9403
HPS::Type ObjectType() const
Definition: hps.h:43635
friend bool operator==(char const *in_left, UTF8 const &in_right)
Definition: hps.h:6938
void SetTouches(size_t in_touch_count, Touch const in_touches[])
Definition: hps.h:41342
Event * Clone() const
Definition: hps.h:41282
virtual bool Equals(ErrorEvent const &in_that) const
Definition: hps.h:40818
Event * Clone() const
Definition: hps.h:40886
size_t GetLength() const
Definition: hps.h:6836
HPS::Type ObjectType() const
Definition: hps.h:20991
HPS::Type ObjectType() const
Definition: hps.h:26690
Type
Definition: hps.h:1127
HPS::Type ObjectType() const
Definition: hps.h:9321
bool None() const
Definition: hps.h:41052
size_t ClickCount
The number of clicks received.
Definition: hps.h:41646
virtual intptr_t Freshen() const
Definition: hps.h:6142
void Reset()
Definition: hps.h:6831
HPS::Type ObjectType() const
Definition: hps.h:37636
HPS::Type ObjectType() const
Definition: hps.h:23759
HPS::Type ObjectType() const
Definition: hps.h:39836
SizeUnits
Definition: hps.h:1598
Event * Clone() const
Definition: hps.h:40809
MouseEvent(Event const &in_event)
Definition: hps.h:41565
virtual bool Empty() const
Definition: hps.h:5603
Join
Definition: hps.h:1820
HPS_INLINE void Merge(Sphere_3D< F > const &sphere)
Definition: hps.h:3908
Modifier
Definition: hps.h:1857
TouchEvent(Action in_action, ModifierKeys in_modifier=ModifierKeys())
Definition: hps.h:41240
HighlightEvent()
Definition: hps.h:40587
virtual HPS::Type ObjectType() const
Definition: hps.h:5599
HPS::Type ObjectType() const
Definition: hps.h:13782
HPS::TouchEvent::Action CurrentAction
The action for the touches of this TouchEvent.
Definition: hps.h:41354
Type
Definition: hps.h:574
virtual intptr_t Freshen() const
Definition: hps.h:40570
Background
Definition: hps.h:232
HPS_INLINE bool Intersecting(Cuboid_3D const &cuboid) const
Definition: hps.h:3828
static ModifierKeys KeyControl()
Definition: hps.h:41135
HPS::Type ObjectType() const
Definition: hps.h:18333
HPS::Type ObjectType() const
Definition: hps.h:35587
ScreenRangePoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5868
HPS::Type ObjectType() const
Definition: hps.h:39628
StandAloneWindowEvent(Action in_action)
Definition: hps.h:40865
Mode
Definition: hps.h:1710
Event * Clone() const
Definition: hps.h:40969
HPS_INLINE Cuboid_3D & Expand(F border)
Definition: hps.h:4045
HPS_INLINE bool Intersecting(int dimension, Cuboid_3D const &cuboid, F const allowance) const
Definition: hps.h:3863
Type
Definition: hps.h:877
HPS_INLINE Vector_3D< F > Diagonal() const
Definition: hps.h:3816
HPS::Type ObjectType() const
Definition: hps.h:12241
HPS::Type ObjectType() const
Definition: hps.h:32292
HPS::Type ObjectType() const
Definition: hps.h:37734
HPS::Type ObjectType() const
Definition: hps.h:42324
HPS::Type ObjectType() const
Definition: hps.h:42002
HPS_INLINE void Generate_Cuboid_Points(Point_3D< F > *points) const
Definition: hps.h:3802
HPS::Type ObjectType() const
Definition: hps.h:36889
HPS::Type ObjectType() const
Definition: hps.h:12390
HPS::Type ObjectType() const
Definition: hps.h:17876
Mode
Definition: hps.h:1763
Event * Clone() const
Definition: hps.h:41716
HPS_INLINE bool Intersecting(Point_3D< F > const &start, Vector_3D< F > const &direction) const
Definition: hps.h:3874
Tiling
Definition: hps.h:980
HPS_INLINE Cuboid_3D & Union(Cuboid_3D const &cuboid)
Definition: hps.h:4030
WindowPoint(Point const &in_point)
Definition: hps.h:6020
Transform
Definition: hps.h:1553
HPS::Type ObjectType() const
Definition: hps.h:37204
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:38561
ModifierKeys()
Definition: hps.h:41024
Preference
Definition: hps.h:1578
HPS::Type ObjectType() const
Definition: hps.h:25297
Capping
Definition: hps.h:519
HPS::Type ObjectType() const
Definition: hps.h:35405
TouchEvent()
Definition: hps.h:41234
Interpolation
Definition: hps.h:996
HPS::Type ObjectType() const
Definition: hps.h:19975
WarningEvent(char const *in_message)
Definition: hps.h:40711
HPS::Type ObjectType() const
Definition: hps.h:20768
Modifiers
Definition: hps.h:41149
Component
Definition: hps.h:511
HPS::Type ObjectType() const
Definition: hps.h:35895
HPS::Type ObjectType() const
Definition: hps.h:6527
HPS::Type ObjectType() const
Definition: hps.h:22541
HPS_INLINE Cuboid_3D & Intersect(Cuboid_3D const &cuboid)
Definition: hps.h:4015
HPS::Type ObjectType() const
Definition: hps.h:42859
HPS::Type ObjectType() const
Definition: hps.h:22331
Format
Definition: hps.h:37067
WarningEvent()
Definition: hps.h:40707
virtual bool Drop(Event const *in_that_event) const
Definition: hps.h:40564
Touch()
Definition: hps.h:6404
Component
Definition: hps.h:401
A unitless linear scaling factor. A value of 2.0 will cause lines to be rendered twice as thick...
float red
Definition: hps.h:4280
ClipSpace
Definition: hps.h:1306
Control & operator=(Control &&in_that)
Definition: hps.h:5656
WarningEvent(char const *in_message, HPS::Info::Code in_code)
Definition: hps.h:40716
HPS::Type ObjectType() const
Definition: hps.h:13887
SizeUnits
Definition: hps.h:42816
virtual void Reset()
Definition: hps.h:40508
HPS::Type ObjectType() const
Definition: hps.h:11278
bool Meta() const
Definition: hps.h:41068
HPS_INLINE Cuboid_3D & Contract(F border)
Definition: hps.h:4057
TimerTickEvent()
Definition: hps.h:40536
HPS::Type ObjectType() const
Definition: hps.h:21994
RenderingAlgorithm
Definition: hps.h:268
EmergencyHandler()
Definition: hps.h:40051
CameraPoint(float px=0.0f, float py=0.0f, float pz=0.0f)
Definition: hps.h:5770
TouchID ID
TouchID for this Touch.
Definition: hps.h:6429
HPS::Type ObjectType() const
Definition: hps.h:10844
HPS::Type ObjectType() const
Definition: hps.h:33254
HPS::Type ObjectType() const
Definition: hps.h:8429
HandednessOptimization
Definition: hps.h:362
Projection
Definition: hps.h:1388
Control(Control &&in_that)
Definition: hps.h:5651
bool Control() const
Definition: hps.h:41060
HPS::Type ObjectType() const
Definition: hps.h:34773
Overlay
Definition: hps.h:1278
HPS::Type ObjectType() const
Definition: hps.h:37970
Status
Definition: hps.h:6118
HPS::Type ObjectType() const
Definition: hps.h:34903
HPS::Type ObjectType() const
Definition: hps.h:6609
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:41645
HPS::Type ObjectType() const
Definition: hps.h:42112